diff options
Diffstat (limited to 'Zend/zend_compile.c')
| -rw-r--r-- | Zend/zend_compile.c | 11279 |
1 files changed, 5594 insertions, 5685 deletions
diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index 278ac4e02e..3ae9567a94 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -14,6 +14,7 @@ +----------------------------------------------------------------------+ | Authors: Andi Gutmans <andi@zend.com> | | Zeev Suraski <zeev@zend.com> | + | Nikita Popov <nikic@php.net> | +----------------------------------------------------------------------+ */ @@ -26,20 +27,17 @@ #include "zend_llist.h" #include "zend_API.h" #include "zend_exceptions.h" +#include "zend_interfaces.h" #include "zend_virtual_cwd.h" #include "zend_multibyte.h" #include "zend_language_scanner.h" - -#define CONSTANT_EX(op_array, op) \ - (op_array)->literals[op].constant - -#define CONSTANT(op) \ - CONSTANT_EX(CG(active_op_array), op) +#include "zend_inheritance.h" +#include "zend_vm.h" #define SET_NODE(target, src) do { \ target ## _type = (src)->op_type; \ if ((src)->op_type == IS_CONST) { \ - target.constant = zend_add_literal(CG(active_op_array), &(src)->u.constant TSRMLS_CC); \ + target.constant = zend_add_literal(CG(active_op_array), &(src)->u.constant); \ } else { \ target = (src)->u.op; \ } \ @@ -48,167 +46,255 @@ #define GET_NODE(target, src) do { \ (target)->op_type = src ## _type; \ if ((target)->op_type == IS_CONST) { \ - (target)->u.constant = CONSTANT(src.constant); \ + ZVAL_COPY_VALUE(&(target)->u.constant, CT_CONSTANT(src)); \ } else { \ (target)->u.op = src; \ - (target)->EA = 0; \ } \ } while (0) -#define COPY_NODE(target, src) do { \ - target ## _type = src ## _type; \ - target = src; \ - } while (0) +#define FC(member) (CG(file_context).member) -#define CALCULATE_LITERAL_HASH(num) do { \ - zval *c = &CONSTANT(num); \ - Z_HASH_P(c) = str_hash(Z_STRVAL_P(c), Z_STRLEN_P(c)); \ - } while (0) - -#define GET_CACHE_SLOT(literal) do { \ - CG(active_op_array)->literals[literal].cache_slot = CG(active_op_array)->last_cache_slot++; \ - if ((CG(active_op_array)->fn_flags & ZEND_ACC_INTERACTIVE) && CG(active_op_array)->run_time_cache) { \ - CG(active_op_array)->run_time_cache = erealloc(CG(active_op_array)->run_time_cache, CG(active_op_array)->last_cache_slot * sizeof(void*)); \ - CG(active_op_array)->run_time_cache[CG(active_op_array)->last_cache_slot - 1] = NULL; \ - } \ - } while (0) +static inline void zend_alloc_cache_slot(uint32_t literal) { + zend_op_array *op_array = CG(active_op_array); + Z_CACHE_SLOT(op_array->literals[literal]) = op_array->cache_size; + op_array->cache_size += sizeof(void*); +} #define POLYMORPHIC_CACHE_SLOT_SIZE 2 -#define GET_POLYMORPHIC_CACHE_SLOT(literal) do { \ - CG(active_op_array)->literals[literal].cache_slot = CG(active_op_array)->last_cache_slot; \ - CG(active_op_array)->last_cache_slot += POLYMORPHIC_CACHE_SLOT_SIZE; \ - if ((CG(active_op_array)->fn_flags & ZEND_ACC_INTERACTIVE) && CG(active_op_array)->run_time_cache) { \ - CG(active_op_array)->run_time_cache = erealloc(CG(active_op_array)->run_time_cache, CG(active_op_array)->last_cache_slot * sizeof(void*)); \ - CG(active_op_array)->run_time_cache[CG(active_op_array)->last_cache_slot - 1] = NULL; \ - CG(active_op_array)->run_time_cache[CG(active_op_array)->last_cache_slot - 2] = NULL; \ - } \ - } while (0) - -#define FREE_POLYMORPHIC_CACHE_SLOT(literal) do { \ - if (CG(active_op_array)->literals[literal].cache_slot != -1 && \ - CG(active_op_array)->literals[literal].cache_slot == \ - CG(active_op_array)->last_cache_slot - POLYMORPHIC_CACHE_SLOT_SIZE) { \ - CG(active_op_array)->literals[literal].cache_slot = -1; \ - CG(active_op_array)->last_cache_slot -= POLYMORPHIC_CACHE_SLOT_SIZE; \ - } \ - } while (0) +static inline void zend_alloc_polymorphic_cache_slot(uint32_t literal) { + zend_op_array *op_array = CG(active_op_array); + Z_CACHE_SLOT(op_array->literals[literal]) = op_array->cache_size; + op_array->cache_size += POLYMORPHIC_CACHE_SLOT_SIZE * sizeof(void*); +} -ZEND_API zend_op_array *(*zend_compile_file)(zend_file_handle *file_handle, int type TSRMLS_DC); -ZEND_API zend_op_array *(*zend_compile_string)(zval *source_string, char *filename TSRMLS_DC); +ZEND_API zend_op_array *(*zend_compile_file)(zend_file_handle *file_handle, int type); +ZEND_API zend_op_array *(*zend_compile_string)(zval *source_string, char *filename); #ifndef ZTS ZEND_API zend_compiler_globals compiler_globals; ZEND_API zend_executor_globals executor_globals; #endif -static void zend_push_function_call_entry(zend_function *fbc TSRMLS_DC) /* {{{ */ +static void zend_destroy_property_info_internal(zval *zv) /* {{{ */ { - zend_function_call_entry fcall = { fbc }; - zend_stack_push(&CG(function_call_stack), &fcall, sizeof(zend_function_call_entry)); + zend_property_info *property_info = Z_PTR_P(zv); + + zend_string_release(property_info->name); + free(property_info); } /* }}} */ -static void zend_duplicate_property_info(zend_property_info *property_info) /* {{{ */ -{ - property_info->name = str_estrndup(property_info->name, property_info->name_length); - if (property_info->doc_comment) { - property_info->doc_comment = estrndup(property_info->doc_comment, property_info->doc_comment_len); +static zend_string *zend_new_interned_string_safe(zend_string *str) /* {{{ */ { + zend_string *interned_str; + + zend_string_addref(str); + interned_str = zend_new_interned_string(str); + if (str != interned_str) { + return interned_str; + } else { + zend_string_release(str); + return str; } } /* }}} */ -static void zend_duplicate_property_info_internal(zend_property_info *property_info) /* {{{ */ +static zend_string *zend_build_runtime_definition_key(zend_string *name, unsigned char *lex_pos) /* {{{ */ { - property_info->name = str_strndup(property_info->name, property_info->name_length); + zend_string *result; + char char_pos_buf[32]; + size_t char_pos_len = zend_sprintf(char_pos_buf, "%p", lex_pos); + zend_string *filename = CG(active_op_array)->filename; + + /* NULL, name length, filename length, last accepting char position length */ + result = zend_string_alloc(1 + ZSTR_LEN(name) + ZSTR_LEN(filename) + char_pos_len, 0); + sprintf(ZSTR_VAL(result), "%c%s%s%s", '\0', ZSTR_VAL(name), ZSTR_VAL(filename), char_pos_buf); + return zend_new_interned_string(result); } /* }}} */ -static void zend_destroy_property_info(zend_property_info *property_info) /* {{{ */ +static zend_bool zend_get_unqualified_name(const zend_string *name, const char **result, size_t *result_len) /* {{{ */ { - str_efree(property_info->name); - if (property_info->doc_comment) { - efree((char*)property_info->doc_comment); + const char *ns_separator = zend_memrchr(ZSTR_VAL(name), '\\', ZSTR_LEN(name)); + if (ns_separator != NULL) { + *result = ns_separator + 1; + *result_len = ZSTR_VAL(name) + ZSTR_LEN(name) - *result; + return 1; } + + return 0; } /* }}} */ -static void zend_destroy_property_info_internal(zend_property_info *property_info) /* {{{ */ -{ - str_free((char*)property_info->name); +struct reserved_class_name { + const char *name; + size_t len; +}; +static const struct reserved_class_name reserved_class_names[] = { + {ZEND_STRL("bool")}, + {ZEND_STRL("false")}, + {ZEND_STRL("float")}, + {ZEND_STRL("int")}, + {ZEND_STRL("null")}, + {ZEND_STRL("parent")}, + {ZEND_STRL("self")}, + {ZEND_STRL("static")}, + {ZEND_STRL("string")}, + {ZEND_STRL("true")}, + {NULL, 0} +}; + +static zend_bool zend_is_reserved_class_name(const zend_string *name) /* {{{ */ +{ + const struct reserved_class_name *reserved = reserved_class_names; + + const char *uqname = ZSTR_VAL(name); + size_t uqname_len = ZSTR_LEN(name); + zend_get_unqualified_name(name, &uqname, &uqname_len); + + for (; reserved->name; ++reserved) { + if (uqname_len == reserved->len + && zend_binary_strcasecmp(uqname, uqname_len, reserved->name, reserved->len) == 0 + ) { + return 1; + } + } + + return 0; } /* }}} */ -static void build_runtime_defined_function_key(zval *result, const char *name, int name_length TSRMLS_DC) /* {{{ */ +ZEND_API void zend_assert_valid_class_name(const zend_string *name) /* {{{ */ { - char char_pos_buf[32]; - uint char_pos_len; - const char *filename; - - char_pos_len = zend_sprintf(char_pos_buf, "%p", LANG_SCNG(yy_text)); - if (CG(active_op_array)->filename) { - filename = CG(active_op_array)->filename; - } else { - filename = "-"; + if (zend_is_reserved_class_name(name)) { + zend_error_noreturn(E_COMPILE_ERROR, + "Cannot use '%s' as class name as it is reserved", ZSTR_VAL(name)); } +} +/* }}} */ - /* NULL, name length, filename length, last accepting char position length */ - Z_STRLEN_P(result) = 1+name_length+strlen(filename)+char_pos_len; +typedef struct _builtin_type_info { + const char* name; + const size_t name_len; + const zend_uchar type; +} builtin_type_info; - /* must be binary safe */ - Z_STRVAL_P(result) = (char *) safe_emalloc(Z_STRLEN_P(result), 1, 1); - Z_STRVAL_P(result)[0] = '\0'; - sprintf(Z_STRVAL_P(result)+1, "%s%s%s", name, filename, char_pos_buf); +static const builtin_type_info builtin_types[] = { + {"int", sizeof("int") - 1, IS_LONG}, + {"float", sizeof("float") - 1, IS_DOUBLE}, + {"string", sizeof("string") - 1, IS_STRING}, + {"bool", sizeof("bool") - 1, _IS_BOOL}, + {NULL, 0, IS_UNDEF} +}; - result->type = IS_STRING; - Z_SET_REFCOUNT_P(result, 1); -} -/* }}} */ -static void init_compiler_declarables(TSRMLS_D) /* {{{ */ +static zend_always_inline zend_uchar zend_lookup_builtin_type_by_name(const zend_string *name) /* {{{ */ { - Z_TYPE(CG(declarables).ticks) = IS_LONG; - Z_LVAL(CG(declarables).ticks) = 0; + const builtin_type_info *info = &builtin_types[0]; + + for (; info->name; ++info) { + if (ZSTR_LEN(name) == info->name_len + && zend_binary_strcasecmp(ZSTR_VAL(name), ZSTR_LEN(name), info->name, info->name_len) == 0 + ) { + return info->type; + } + } + + return 0; } /* }}} */ -void zend_init_compiler_context(TSRMLS_D) /* {{{ */ + +void zend_oparray_context_begin(zend_oparray_context *prev_context) /* {{{ */ { - CG(context).opcodes_size = (CG(active_op_array)->fn_flags & ZEND_ACC_INTERACTIVE) ? INITIAL_INTERACTIVE_OP_ARRAY_SIZE : INITIAL_OP_ARRAY_SIZE; + *prev_context = CG(context); + CG(context).opcodes_size = INITIAL_OP_ARRAY_SIZE; CG(context).vars_size = 0; CG(context).literals_size = 0; - CG(context).current_brk_cont = -1; CG(context).backpatch_count = 0; - CG(context).nested_calls = 0; - CG(context).used_stack = 0; CG(context).in_finally = 0; + CG(context).fast_call_var = -1; + CG(context).current_brk_cont = -1; + CG(context).last_brk_cont = 0; + CG(context).brk_cont_array = NULL; CG(context).labels = NULL; } /* }}} */ -void zend_init_compiler_data_structures(TSRMLS_D) /* {{{ */ +void zend_oparray_context_end(zend_oparray_context *prev_context) /* {{{ */ +{ + if (CG(context).brk_cont_array) { + efree(CG(context).brk_cont_array); + } + if (CG(context).labels) { + zend_hash_destroy(CG(context).labels); + FREE_HASHTABLE(CG(context).labels); + CG(context).labels = NULL; + } + CG(context) = *prev_context; +} +/* }}} */ + +static void zend_reset_import_tables(void) /* {{{ */ +{ + if (FC(imports)) { + zend_hash_destroy(FC(imports)); + efree(FC(imports)); + FC(imports) = NULL; + } + + if (FC(imports_function)) { + zend_hash_destroy(FC(imports_function)); + efree(FC(imports_function)); + FC(imports_function) = NULL; + } + + if (FC(imports_const)) { + zend_hash_destroy(FC(imports_const)); + efree(FC(imports_const)); + FC(imports_const) = NULL; + } +} +/* }}} */ + +static void zend_end_namespace(void) /* {{{ */ { + FC(in_namespace) = 0; + zend_reset_import_tables(); + if (FC(current_namespace)) { + zend_string_release(FC(current_namespace)); + FC(current_namespace) = NULL; + } +} +/* }}} */ + +void zend_file_context_begin(zend_file_context *prev_context) /* {{{ */ +{ + *prev_context = CG(file_context); + FC(imports) = NULL; + FC(imports_function) = NULL; + FC(imports_const) = NULL; + FC(current_namespace) = NULL; + FC(in_namespace) = 0; + FC(has_bracketed_namespaces) = 0; + FC(declarables).ticks = 0; +} +/* }}} */ + +void zend_file_context_end(zend_file_context *prev_context) /* {{{ */ +{ + zend_end_namespace(); + CG(file_context) = *prev_context; +} +/* }}} */ + +void zend_init_compiler_data_structures(void) /* {{{ */ { - zend_stack_init(&CG(bp_stack)); - zend_stack_init(&CG(function_call_stack)); - zend_stack_init(&CG(switch_cond_stack)); - zend_stack_init(&CG(foreach_copy_stack)); - zend_stack_init(&CG(object_stack)); - zend_stack_init(&CG(declare_stack)); + zend_stack_init(&CG(loop_var_stack), sizeof(znode)); + zend_stack_init(&CG(delayed_oplines_stack), sizeof(zend_op)); CG(active_class_entry) = NULL; - zend_llist_init(&CG(list_llist), sizeof(list_llist_element), NULL, 0); - zend_llist_init(&CG(dimension_llist), sizeof(int), NULL, 0); - zend_stack_init(&CG(list_stack)); CG(in_compilation) = 0; CG(start_lineno) = 0; - CG(current_namespace) = NULL; - CG(in_namespace) = 0; - CG(has_bracketed_namespaces) = 0; - CG(current_import) = NULL; - CG(current_import_function) = NULL; - CG(current_import_const) = NULL; - zend_hash_init(&CG(const_filenames), 0, NULL, NULL, 0); - init_compiler_declarables(TSRMLS_C); - zend_stack_init(&CG(context_stack)); + zend_hash_init(&CG(const_filenames), 8, NULL, NULL, 0); CG(encoding_declared) = 0; } @@ -216,98 +302,91 @@ void zend_init_compiler_data_structures(TSRMLS_D) /* {{{ */ ZEND_API void file_handle_dtor(zend_file_handle *fh) /* {{{ */ { - TSRMLS_FETCH(); - zend_file_handle_dtor(fh TSRMLS_CC); + zend_file_handle_dtor(fh); } /* }}} */ -void init_compiler(TSRMLS_D) /* {{{ */ +void init_compiler(void) /* {{{ */ { + CG(arena) = zend_arena_create(64 * 1024); CG(active_op_array) = NULL; memset(&CG(context), 0, sizeof(CG(context))); - zend_init_compiler_data_structures(TSRMLS_C); - zend_init_rsrc_list(TSRMLS_C); - zend_hash_init(&CG(filenames_table), 5, NULL, (dtor_func_t) free_estring, 0); + zend_init_compiler_data_structures(); + zend_init_rsrc_list(); + zend_hash_init(&CG(filenames_table), 8, NULL, free_string_zval, 0); zend_llist_init(&CG(open_files), sizeof(zend_file_handle), (void (*)(void *)) file_handle_dtor, 0); CG(unclean_shutdown) = 0; } /* }}} */ -void shutdown_compiler(TSRMLS_D) /* {{{ */ +void shutdown_compiler(void) /* {{{ */ { - zend_stack_destroy(&CG(bp_stack)); - zend_stack_destroy(&CG(function_call_stack)); - zend_stack_destroy(&CG(switch_cond_stack)); - zend_stack_destroy(&CG(foreach_copy_stack)); - zend_stack_destroy(&CG(object_stack)); - zend_stack_destroy(&CG(declare_stack)); - zend_stack_destroy(&CG(list_stack)); + zend_stack_destroy(&CG(loop_var_stack)); + zend_stack_destroy(&CG(delayed_oplines_stack)); zend_hash_destroy(&CG(filenames_table)); - zend_llist_destroy(&CG(open_files)); zend_hash_destroy(&CG(const_filenames)); - zend_stack_destroy(&CG(context_stack)); + zend_arena_destroy(CG(arena)); } /* }}} */ -ZEND_API char *zend_set_compiled_filename(const char *new_compiled_filename TSRMLS_DC) /* {{{ */ +ZEND_API zend_string *zend_set_compiled_filename(zend_string *new_compiled_filename) /* {{{ */ { - char **pp, *p; - int length = strlen(new_compiled_filename); + zend_string *p; - if (zend_hash_find(&CG(filenames_table), new_compiled_filename, length+1, (void **) &pp) == SUCCESS) { - CG(compiled_filename) = *pp; - return *pp; + p = zend_hash_find_ptr(&CG(filenames_table), new_compiled_filename); + if (p != NULL) { + CG(compiled_filename) = p; + return p; } - p = estrndup(new_compiled_filename, length); - zend_hash_update(&CG(filenames_table), new_compiled_filename, length+1, &p, sizeof(char *), (void **) &pp); + p = zend_string_copy(new_compiled_filename); + zend_hash_update_ptr(&CG(filenames_table), new_compiled_filename, p); CG(compiled_filename) = p; return p; } /* }}} */ -ZEND_API void zend_restore_compiled_filename(char *original_compiled_filename TSRMLS_DC) /* {{{ */ +ZEND_API void zend_restore_compiled_filename(zend_string *original_compiled_filename) /* {{{ */ { CG(compiled_filename) = original_compiled_filename; } /* }}} */ -ZEND_API char *zend_get_compiled_filename(TSRMLS_D) /* {{{ */ +ZEND_API zend_string *zend_get_compiled_filename(void) /* {{{ */ { return CG(compiled_filename); } /* }}} */ -ZEND_API int zend_get_compiled_lineno(TSRMLS_D) /* {{{ */ +ZEND_API int zend_get_compiled_lineno(void) /* {{{ */ { return CG(zend_lineno); } /* }}} */ -ZEND_API zend_bool zend_is_compiling(TSRMLS_D) /* {{{ */ +ZEND_API zend_bool zend_is_compiling(void) /* {{{ */ { return CG(in_compilation); } /* }}} */ -static zend_uint get_temporary_variable(zend_op_array *op_array) /* {{{ */ +static uint32_t get_temporary_variable(zend_op_array *op_array) /* {{{ */ { - return (zend_uint)(zend_uintptr_t)EX_TMP_VAR_NUM(0, (op_array->T)++); + return (uint32_t)op_array->T++; } /* }}} */ -static int lookup_cv(zend_op_array *op_array, char* name, int name_len, ulong hash TSRMLS_DC) /* {{{ */ -{ +static int lookup_cv(zend_op_array *op_array, zend_string* name) /* {{{ */{ int i = 0; - ulong hash_value = hash ? hash : zend_inline_hash_func(name, name_len+1); + zend_ulong hash_value = zend_string_hash_val(name); while (i < op_array->last_var) { - if (op_array->vars[i].name == name || - (op_array->vars[i].hash_value == hash_value && - op_array->vars[i].name_len == name_len && - memcmp(op_array->vars[i].name, name, name_len) == 0)) { - str_efree(name); - return i; + if (ZSTR_VAL(op_array->vars[i]) == ZSTR_VAL(name) || + (ZSTR_H(op_array->vars[i]) == hash_value && + ZSTR_LEN(op_array->vars[i]) == ZSTR_LEN(name) && + memcmp(ZSTR_VAL(op_array->vars[i]), ZSTR_VAL(name), ZSTR_LEN(name)) == 0)) { + zend_string_release(name); + return (int)(zend_intptr_t)ZEND_CALL_VAR_NUM(NULL, i); } i++; } @@ -315,45 +394,44 @@ static int lookup_cv(zend_op_array *op_array, char* name, int name_len, ulong ha op_array->last_var++; if (op_array->last_var > CG(context).vars_size) { CG(context).vars_size += 16; /* FIXME */ - op_array->vars = erealloc(op_array->vars, CG(context).vars_size * sizeof(zend_compiled_variable)); + op_array->vars = erealloc(op_array->vars, CG(context).vars_size * sizeof(zend_string*)); } - op_array->vars[i].name = zend_new_interned_string(name, name_len + 1, 1 TSRMLS_CC); - op_array->vars[i].name_len = name_len; - op_array->vars[i].hash_value = hash_value; - return i; + + op_array->vars[i] = zend_new_interned_string(name); + return (int)(zend_intptr_t)ZEND_CALL_VAR_NUM(NULL, i); } /* }}} */ void zend_del_literal(zend_op_array *op_array, int n) /* {{{ */ { - zval_dtor(&CONSTANT_EX(op_array, n)); + zval_dtor(CT_CONSTANT_EX(op_array, n)); if (n + 1 == op_array->last_literal) { op_array->last_literal--; } else { - Z_TYPE(CONSTANT_EX(op_array, n)) = IS_NULL; + ZVAL_UNDEF(CT_CONSTANT_EX(op_array, n)); } } /* }}} */ /* Common part of zend_add_literal and zend_append_individual_literal */ -static inline void zend_insert_literal(zend_op_array *op_array, const zval *zv, int literal_position TSRMLS_DC) /* {{{ */ +static inline void zend_insert_literal(zend_op_array *op_array, zval *zv, int literal_position) /* {{{ */ { if (Z_TYPE_P(zv) == IS_STRING || Z_TYPE_P(zv) == IS_CONSTANT) { - zval *z = (zval*)zv; - Z_STRVAL_P(z) = (char*)zend_new_interned_string(Z_STRVAL_P(zv), Z_STRLEN_P(zv) + 1, 1 TSRMLS_CC); + zend_string_hash_val(Z_STR_P(zv)); + Z_STR_P(zv) = zend_new_interned_string(Z_STR_P(zv)); + if (ZSTR_IS_INTERNED(Z_STR_P(zv))) { + Z_TYPE_FLAGS_P(zv) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE); + } } - CONSTANT_EX(op_array, literal_position) = *zv; - Z_SET_REFCOUNT(CONSTANT_EX(op_array, literal_position), 2); - Z_SET_ISREF(CONSTANT_EX(op_array, literal_position)); - op_array->literals[literal_position].hash_value = 0; - op_array->literals[literal_position].cache_slot = -1; + ZVAL_COPY_VALUE(CT_CONSTANT_EX(op_array, literal_position), zv); + Z_CACHE_SLOT(op_array->literals[literal_position]) = -1; } /* }}} */ /* Is used while compiling a function, using the context to keep track of an approximate size to avoid to relocate to often. Literals are truncated to actual size in the second compiler pass (pass_two()). */ -int zend_add_literal(zend_op_array *op_array, const zval *zv TSRMLS_DC) /* {{{ */ +int zend_add_literal(zend_op_array *op_array, zval *zv) /* {{{ */ { int i = op_array->last_literal; op_array->last_literal++; @@ -361,4937 +439,4846 @@ int zend_add_literal(zend_op_array *op_array, const zval *zv TSRMLS_DC) /* {{{ * while (i >= CG(context).literals_size) { CG(context).literals_size += 16; /* FIXME */ } - op_array->literals = (zend_literal*)erealloc(op_array->literals, CG(context).literals_size * sizeof(zend_literal)); + op_array->literals = (zval*)erealloc(op_array->literals, CG(context).literals_size * sizeof(zval)); } - zend_insert_literal(op_array, zv, i TSRMLS_CC); + zend_insert_literal(op_array, zv, i); return i; } /* }}} */ -/* Is used after normal compilation to append an additional literal. - Allocation is done precisely here. */ -int zend_append_individual_literal(zend_op_array *op_array, const zval *zv TSRMLS_DC) /* {{{ */ +static inline int zend_add_literal_string(zend_op_array *op_array, zend_string **str) /* {{{ */ { - int i = op_array->last_literal; - op_array->last_literal++; - op_array->literals = (zend_literal*)erealloc(op_array->literals, (i + 1) * sizeof(zend_literal)); - zend_insert_literal(op_array, zv, i TSRMLS_CC); - return i; + int ret; + zval zv; + ZVAL_STR(&zv, *str); + ret = zend_add_literal(op_array, &zv); + *str = Z_STR(zv); + return ret; } /* }}} */ -int zend_add_func_name_literal(zend_op_array *op_array, const zval *zv TSRMLS_DC) /* {{{ */ +static int zend_add_func_name_literal(zend_op_array *op_array, zend_string *name) /* {{{ */ { - int ret; - char *lc_name; - zval c; - int lc_literal; - - if (op_array->last_literal > 0 && - &op_array->literals[op_array->last_literal - 1].constant == zv && - op_array->literals[op_array->last_literal - 1].cache_slot == -1) { - /* we already have function name as last literal (do nothing) */ - ret = op_array->last_literal - 1; - } else { - ret = zend_add_literal(op_array, zv TSRMLS_CC); - } + /* Original name */ + int ret = zend_add_literal_string(op_array, &name); - lc_name = zend_str_tolower_dup(Z_STRVAL_P(zv), Z_STRLEN_P(zv)); - ZVAL_STRINGL(&c, lc_name, Z_STRLEN_P(zv), 0); - lc_literal = zend_add_literal(CG(active_op_array), &c TSRMLS_CC); - CALCULATE_LITERAL_HASH(lc_literal); + /* Lowercased name */ + zend_string *lc_name = zend_string_tolower(name); + zend_add_literal_string(op_array, &lc_name); return ret; } /* }}} */ -int zend_add_ns_func_name_literal(zend_op_array *op_array, const zval *zv TSRMLS_DC) /* {{{ */ +static int zend_add_ns_func_name_literal(zend_op_array *op_array, zend_string *name) /* {{{ */ { - int ret; - char *lc_name; - const char *ns_separator; - int lc_len; - zval c; - int lc_literal; - - if (op_array->last_literal > 0 && - &op_array->literals[op_array->last_literal - 1].constant == zv && - op_array->literals[op_array->last_literal - 1].cache_slot == -1) { - /* we already have function name as last literal (do nothing) */ - ret = op_array->last_literal - 1; - } else { - ret = zend_add_literal(op_array, zv TSRMLS_CC); - } + const char *unqualified_name; + size_t unqualified_name_len; - lc_name = zend_str_tolower_dup(Z_STRVAL_P(zv), Z_STRLEN_P(zv)); - ZVAL_STRINGL(&c, lc_name, Z_STRLEN_P(zv), 0); - lc_literal = zend_add_literal(CG(active_op_array), &c TSRMLS_CC); - CALCULATE_LITERAL_HASH(lc_literal); + /* Original name */ + int ret = zend_add_literal_string(op_array, &name); - ns_separator = (const char*)zend_memrchr(Z_STRVAL_P(zv), '\\', Z_STRLEN_P(zv)); + /* Lowercased name */ + zend_string *lc_name = zend_string_tolower(name); + zend_add_literal_string(op_array, &lc_name); - if (ns_separator != NULL) { - ns_separator += 1; - lc_len = Z_STRLEN_P(zv) - (ns_separator - Z_STRVAL_P(zv)); - lc_name = zend_str_tolower_dup(ns_separator, lc_len); - ZVAL_STRINGL(&c, lc_name, lc_len, 0); - lc_literal = zend_add_literal(CG(active_op_array), &c TSRMLS_CC); - CALCULATE_LITERAL_HASH(lc_literal); + /* Lowercased unqualfied name */ + if (zend_get_unqualified_name(name, &unqualified_name, &unqualified_name_len)) { + lc_name = zend_string_alloc(unqualified_name_len, 0); + zend_str_tolower_copy(ZSTR_VAL(lc_name), unqualified_name, unqualified_name_len); + zend_add_literal_string(op_array, &lc_name); } return ret; } /* }}} */ -int zend_add_class_name_literal(zend_op_array *op_array, const zval *zv TSRMLS_DC) /* {{{ */ +static int zend_add_class_name_literal(zend_op_array *op_array, zend_string *name) /* {{{ */ { - int ret; - char *lc_name; - int lc_len; - zval c; - int lc_literal; - - if (op_array->last_literal > 0 && - &op_array->literals[op_array->last_literal - 1].constant == zv && - op_array->literals[op_array->last_literal - 1].cache_slot == -1) { - /* we already have function name as last literal (do nothing) */ - ret = op_array->last_literal - 1; - } else { - ret = zend_add_literal(op_array, zv TSRMLS_CC); - } + /* Original name */ + int ret = zend_add_literal_string(op_array, &name); - if (Z_STRVAL_P(zv)[0] == '\\') { - lc_len = Z_STRLEN_P(zv) - 1; - lc_name = zend_str_tolower_dup(Z_STRVAL_P(zv) + 1, lc_len); - } else { - lc_len = Z_STRLEN_P(zv); - lc_name = zend_str_tolower_dup(Z_STRVAL_P(zv), lc_len); - } - ZVAL_STRINGL(&c, lc_name, lc_len, 0); - lc_literal = zend_add_literal(CG(active_op_array), &c TSRMLS_CC); - CALCULATE_LITERAL_HASH(lc_literal); + /* Lowercased name */ + zend_string *lc_name = zend_string_tolower(name); + zend_add_literal_string(op_array, &lc_name); - GET_CACHE_SLOT(ret); + zend_alloc_cache_slot(ret); return ret; } /* }}} */ -int zend_add_const_name_literal(zend_op_array *op_array, const zval *zv, int unqualified TSRMLS_DC) /* {{{ */ +static int zend_add_const_name_literal(zend_op_array *op_array, zend_string *name, zend_bool unqualified) /* {{{ */ { - int ret, tmp_literal; - char *name, *tmp_name; - const char *ns_separator; - int name_len, ns_len; - zval c; + zend_string *tmp_name; - if (op_array->last_literal > 0 && - &op_array->literals[op_array->last_literal - 1].constant == zv && - op_array->literals[op_array->last_literal - 1].cache_slot == -1) { - /* we already have function name as last literal (do nothing) */ - ret = op_array->last_literal - 1; - } else { - ret = zend_add_literal(op_array, zv TSRMLS_CC); - } + int ret = zend_add_literal_string(op_array, &name); - /* skip leading '\\' */ - if (Z_STRVAL_P(zv)[0] == '\\') { - name_len = Z_STRLEN_P(zv) - 1; - name = Z_STRVAL_P(zv) + 1; - } else { - name_len = Z_STRLEN_P(zv); - name = Z_STRVAL_P(zv); - } - ns_separator = zend_memrchr(name, '\\', name_len); - if (ns_separator) { - ns_len = ns_separator - name; - } else { - ns_len = 0; - } + size_t ns_len = 0, after_ns_len = ZSTR_LEN(name); + const char *after_ns = zend_memrchr(ZSTR_VAL(name), '\\', ZSTR_LEN(name)); + if (after_ns) { + after_ns += 1; + ns_len = after_ns - ZSTR_VAL(name) - 1; + after_ns_len = ZSTR_LEN(name) - ns_len - 1; - if (ns_len) { /* lowercased namespace name & original constant name */ - tmp_name = estrndup(name, name_len); - zend_str_tolower(tmp_name, ns_len); - ZVAL_STRINGL(&c, tmp_name, name_len, 0); - tmp_literal = zend_add_literal(CG(active_op_array), &c TSRMLS_CC); - CALCULATE_LITERAL_HASH(tmp_literal); + tmp_name = zend_string_init(ZSTR_VAL(name), ZSTR_LEN(name), 0); + zend_str_tolower(ZSTR_VAL(tmp_name), ns_len); + zend_add_literal_string(op_array, &tmp_name); /* lowercased namespace name & lowercased constant name */ - tmp_name = zend_str_tolower_dup(name, name_len); - ZVAL_STRINGL(&c, tmp_name, name_len, 0); - tmp_literal = zend_add_literal(CG(active_op_array), &c TSRMLS_CC); - CALCULATE_LITERAL_HASH(tmp_literal); - } + tmp_name = zend_string_tolower(name); + zend_add_literal_string(op_array, &tmp_name); - if (ns_len) { if (!unqualified) { return ret; } - ns_len++; - name += ns_len; - name_len -= ns_len; + } else { + after_ns = ZSTR_VAL(name); } - /* original constant name */ - tmp_name = estrndup(name, name_len); - ZVAL_STRINGL(&c, tmp_name, name_len, 0); - tmp_literal = zend_add_literal(CG(active_op_array), &c TSRMLS_CC); - CALCULATE_LITERAL_HASH(tmp_literal); + /* original unqualified constant name */ + tmp_name = zend_string_init(after_ns, after_ns_len, 0); + zend_add_literal_string(op_array, &tmp_name); - /* lowercased constant name */ - tmp_name = zend_str_tolower_dup(name, name_len); - ZVAL_STRINGL(&c, tmp_name, name_len, 0); - tmp_literal = zend_add_literal(CG(active_op_array), &c TSRMLS_CC); - CALCULATE_LITERAL_HASH(tmp_literal); + /* lowercased unqualified constant name */ + tmp_name = zend_string_alloc(after_ns_len, 0); + zend_str_tolower_copy(ZSTR_VAL(tmp_name), after_ns, after_ns_len); + zend_add_literal_string(op_array, &tmp_name); return ret; } /* }}} */ -#define LITERAL_STRINGL(op, str, len, copy) do { \ +#define LITERAL_STR(op, str) do { \ zval _c; \ - ZVAL_STRINGL(&_c, str, len, copy); \ - op.constant = zend_add_literal(CG(active_op_array), &_c TSRMLS_CC); \ + ZVAL_STR(&_c, str); \ + op.constant = zend_add_literal(CG(active_op_array), &_c); \ } while (0) -#define LITERAL_LONG(op, val) do { \ - zval _c; \ - ZVAL_LONG(&_c, val); \ - op.constant = zend_add_literal(CG(active_op_array), &_c TSRMLS_CC); \ - } while (0) - -#define LITERAL_LONG_EX(op_array, op, val) do { \ - zval _c; \ - ZVAL_LONG(&_c, val); \ - op.constant = zend_add_literal(op_array, &_c TSRMLS_CC); \ - } while (0) +void zend_stop_lexing(void) +{ + if(LANG_SCNG(on_event)) LANG_SCNG(on_event)(ON_STOP, END, 0); -#define LITERAL_NULL(op) do { \ - zval _c; \ - INIT_ZVAL( _c); \ - op.constant = zend_add_literal(CG(active_op_array), &_c TSRMLS_CC); \ - } while (0) + LANG_SCNG(yy_cursor) = LANG_SCNG(yy_limit); +} -static inline zend_bool zend_is_function_or_method_call(const znode *variable) /* {{{ */ +static inline void zend_begin_loop(const znode *loop_var) /* {{{ */ { - zend_uint type = variable->EA; + zend_brk_cont_element *brk_cont_element; + int parent = CG(context).current_brk_cont; + + CG(context).current_brk_cont = CG(context).last_brk_cont; + brk_cont_element = get_next_brk_cont_element(CG(active_op_array)); + brk_cont_element->parent = parent; - return ((type & ZEND_PARSED_METHOD_CALL) || (type == ZEND_PARSED_FUNCTION_CALL)); + if (loop_var) { + zend_stack_push(&CG(loop_var_stack), loop_var); + brk_cont_element->start = get_next_op_number(CG(active_op_array)); + } else { + /* The start field is used to free temporary variables in case of exceptions. + * We won't try to free something of we don't have loop variable. */ + brk_cont_element->start = -1; + } } /* }}} */ -void zend_do_binary_op(zend_uchar op, znode *result, const znode *op1, const znode *op2 TSRMLS_DC) /* {{{ */ +static inline void zend_end_loop(int cont_addr) /* {{{ */ { - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + zend_brk_cont_element *brk_cont_element + = &CG(context).brk_cont_array[CG(context).current_brk_cont]; + brk_cont_element->cont = cont_addr; + brk_cont_element->brk = get_next_op_number(CG(active_op_array)); + CG(context).current_brk_cont = brk_cont_element->parent; - opline->opcode = op; - opline->result_type = IS_TMP_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - SET_NODE(opline->op1, op1); - SET_NODE(opline->op2, op2); - GET_NODE(result, opline->result); + if (brk_cont_element->start >= 0) { + zend_stack_del_top(&CG(loop_var_stack)); + } } /* }}} */ -void zend_do_unary_op(zend_uchar op, znode *result, const znode *op1 TSRMLS_DC) /* {{{ */ +void zend_do_free(znode *op1) /* {{{ */ { - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + if (op1->op_type==IS_TMP_VAR) { + zend_op *opline = get_next_op(CG(active_op_array)); - opline->opcode = op; - opline->result_type = IS_TMP_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - SET_NODE(opline->op1, op1); - GET_NODE(result, opline->result); - SET_UNUSED(opline->op2); + opline->opcode = ZEND_FREE; + SET_NODE(opline->op1, op1); + SET_UNUSED(opline->op2); + } else if (op1->op_type==IS_VAR) { + zend_op *opline = &CG(active_op_array)->opcodes[CG(active_op_array)->last-1]; + + while (opline->opcode == ZEND_END_SILENCE || opline->opcode == ZEND_EXT_FCALL_END || opline->opcode == ZEND_OP_DATA) { + opline--; + } + if (opline->result_type == IS_VAR + && opline->result.var == op1->u.op.var) { + if (opline->opcode == ZEND_FETCH_R || + opline->opcode == ZEND_FETCH_DIM_R || + opline->opcode == ZEND_FETCH_OBJ_R) { + /* It's very rare and useless case. It's better to use + additional FREE opcode and simplify the FETCH handlers + their selves */ + opline = get_next_op(CG(active_op_array)); + opline->opcode = ZEND_FREE; + SET_NODE(opline->op1, op1); + SET_UNUSED(opline->op2); + } else { + opline->result_type |= EXT_TYPE_UNUSED; + } + } else { + while (opline >= CG(active_op_array)->opcodes) { + if (opline->opcode == ZEND_FETCH_LIST && + opline->op1_type == IS_VAR && + opline->op1.var == op1->u.op.var) { + opline = get_next_op(CG(active_op_array)); + + opline->opcode = ZEND_FREE; + SET_NODE(opline->op1, op1); + SET_UNUSED(opline->op2); + return; + } + if (opline->result_type==IS_VAR + && opline->result.var == op1->u.op.var) { + if (opline->opcode == ZEND_NEW) { + opline->result_type |= EXT_TYPE_UNUSED; + opline = &CG(active_op_array)->opcodes[CG(active_op_array)->last-1]; + while (opline->opcode != ZEND_DO_FCALL || opline->op1.num != ZEND_CALL_CTOR) { + opline--; + } + opline->op1.num |= ZEND_CALL_CTOR_RESULT_UNUSED; + } + break; + } + opline--; + } + } + } else if (op1->op_type == IS_CONST) { + /* Destroy value without using GC: When opcache moves arrays into SHM it will + * free the zend_array structure, so references to it from outside the op array + * become invalid. GC would cause such a reference in the root buffer. */ + zval_ptr_dtor_nogc(&op1->u.constant); + } } /* }}} */ -#define MAKE_NOP(opline) { opline->opcode = ZEND_NOP; memset(&opline->result,0,sizeof(opline->result)); memset(&opline->op1,0,sizeof(opline->op1)); memset(&opline->op2,0,sizeof(opline->op2)); opline->result_type=opline->op1_type=opline->op2_type=IS_UNUSED; } +uint32_t zend_add_class_modifier(uint32_t flags, uint32_t new_flag) /* {{{ */ +{ + uint32_t new_flags = flags | new_flag; + if ((flags & ZEND_ACC_EXPLICIT_ABSTRACT_CLASS) && (new_flag & ZEND_ACC_EXPLICIT_ABSTRACT_CLASS)) { + zend_error_noreturn(E_COMPILE_ERROR, "Multiple abstract modifiers are not allowed"); + } + if ((flags & ZEND_ACC_FINAL) && (new_flag & ZEND_ACC_FINAL)) { + zend_error_noreturn(E_COMPILE_ERROR, "Multiple final modifiers are not allowed"); + } + if ((new_flags & ZEND_ACC_EXPLICIT_ABSTRACT_CLASS) && (new_flags & ZEND_ACC_FINAL)) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use the final modifier on an abstract class"); + } + return new_flags; +} +/* }}} */ -static void zend_do_op_data(zend_op *data_op, const znode *value TSRMLS_DC) /* {{{ */ +uint32_t zend_add_member_modifier(uint32_t flags, uint32_t new_flag) /* {{{ */ { - data_op->opcode = ZEND_OP_DATA; - SET_NODE(data_op->op1, value); - SET_UNUSED(data_op->op2); + uint32_t new_flags = flags | new_flag; + if ((flags & ZEND_ACC_PPP_MASK) && (new_flag & ZEND_ACC_PPP_MASK)) { + zend_error_noreturn(E_COMPILE_ERROR, "Multiple access type modifiers are not allowed"); + } + if ((flags & ZEND_ACC_ABSTRACT) && (new_flag & ZEND_ACC_ABSTRACT)) { + zend_error_noreturn(E_COMPILE_ERROR, "Multiple abstract modifiers are not allowed"); + } + if ((flags & ZEND_ACC_STATIC) && (new_flag & ZEND_ACC_STATIC)) { + zend_error_noreturn(E_COMPILE_ERROR, "Multiple static modifiers are not allowed"); + } + if ((flags & ZEND_ACC_FINAL) && (new_flag & ZEND_ACC_FINAL)) { + zend_error_noreturn(E_COMPILE_ERROR, "Multiple final modifiers are not allowed"); + } + if ((new_flags & ZEND_ACC_ABSTRACT) && (new_flags & ZEND_ACC_FINAL)) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use the final modifier on an abstract class member"); + } + return new_flags; } /* }}} */ -void zend_do_binary_assign_op(zend_uchar op, znode *result, const znode *op1, const znode *op2 TSRMLS_DC) /* {{{ */ +zend_string *zend_concat3(char *str1, size_t str1_len, char *str2, size_t str2_len, char *str3, size_t str3_len) /* {{{ */ { - int last_op_number = get_next_op_number(CG(active_op_array)); - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + size_t len = str1_len + str2_len + str3_len; + zend_string *res = zend_string_alloc(len, 0); - if (last_op_number > 0) { - zend_op *last_op = &CG(active_op_array)->opcodes[last_op_number-1]; + memcpy(ZSTR_VAL(res), str1, str1_len); + memcpy(ZSTR_VAL(res) + str1_len, str2, str2_len); + memcpy(ZSTR_VAL(res) + str1_len + str2_len, str3, str3_len); + ZSTR_VAL(res)[len] = '\0'; - switch (last_op->opcode) { - case ZEND_FETCH_OBJ_RW: - last_op->opcode = op; - last_op->extended_value = ZEND_ASSIGN_OBJ; + return res; +} - zend_do_op_data(opline, op2 TSRMLS_CC); - SET_UNUSED(opline->result); - GET_NODE(result, last_op->result); - return; - case ZEND_FETCH_DIM_RW: - last_op->opcode = op; - last_op->extended_value = ZEND_ASSIGN_DIM; - - zend_do_op_data(opline, op2 TSRMLS_CC); - opline->op2.var = get_temporary_variable(CG(active_op_array)); - opline->op2_type = IS_VAR; - SET_UNUSED(opline->result); - GET_NODE(result,last_op->result); - return; - default: - break; - } +zend_string *zend_concat_names(char *name1, size_t name1_len, char *name2, size_t name2_len) { + return zend_concat3(name1, name1_len, "\\", 1, name2, name2_len); +} + +zend_string *zend_prefix_with_ns(zend_string *name) { + if (FC(current_namespace)) { + zend_string *ns = FC(current_namespace); + return zend_concat_names(ZSTR_VAL(ns), ZSTR_LEN(ns), ZSTR_VAL(name), ZSTR_LEN(name)); + } else { + return zend_string_copy(name); } +} - opline->opcode = op; - SET_NODE(opline->op1, op1); - SET_NODE(opline->op2, op2); - opline->result_type = IS_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - GET_NODE(result, opline->result); +void *zend_hash_find_ptr_lc(HashTable *ht, const char *str, size_t len) { + void *result; + zend_string *lcname; + ALLOCA_FLAG(use_heap); + + ZSTR_ALLOCA_ALLOC(lcname, len, use_heap); + zend_str_tolower_copy(ZSTR_VAL(lcname), str, len); + result = zend_hash_find_ptr(ht, lcname); + ZSTR_ALLOCA_FREE(lcname, use_heap); + + return result; } -/* }}} */ -void fetch_simple_variable_ex(znode *result, znode *varname, int bp, zend_uchar op TSRMLS_DC) /* {{{ */ -{ - zend_op opline; - zend_op *opline_ptr; - zend_llist *fetch_list_ptr; +zend_string *zend_resolve_non_class_name( + zend_string *name, uint32_t type, zend_bool *is_fully_qualified, + zend_bool case_sensitive, HashTable *current_import_sub +) { + char *compound; + *is_fully_qualified = 0; - if (varname->op_type == IS_CONST) { - ulong hash; + if (ZSTR_VAL(name)[0] == '\\') { + /* Remove \ prefix (only relevant if this is a string rather than a label) */ + return zend_string_init(ZSTR_VAL(name) + 1, ZSTR_LEN(name) - 1, 0); + } - if (Z_TYPE(varname->u.constant) != IS_STRING) { - convert_to_string(&varname->u.constant); + if (type == ZEND_NAME_FQ) { + *is_fully_qualified = 1; + return zend_string_copy(name); + } + + if (type == ZEND_NAME_RELATIVE) { + *is_fully_qualified = 1; + return zend_prefix_with_ns(name); + } + + if (current_import_sub) { + /* If an unqualified name is a function/const alias, replace it. */ + zend_string *import_name; + if (case_sensitive) { + import_name = zend_hash_find_ptr(current_import_sub, name); + } else { + import_name = zend_hash_find_ptr_lc(current_import_sub, ZSTR_VAL(name), ZSTR_LEN(name)); } - hash = str_hash(Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant)); - if (!zend_is_auto_global_quick(Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant), hash TSRMLS_CC) && - !(Z_STRLEN(varname->u.constant) == (sizeof("this")-1) && - !memcmp(Z_STRVAL(varname->u.constant), "this", sizeof("this") - 1)) && - (CG(active_op_array)->last == 0 || - CG(active_op_array)->opcodes[CG(active_op_array)->last-1].opcode != ZEND_BEGIN_SILENCE)) { - result->op_type = IS_CV; - result->u.op.var = lookup_cv(CG(active_op_array), Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant), hash TSRMLS_CC); - Z_STRVAL(varname->u.constant) = (char*)CG(active_op_array)->vars[result->u.op.var].name; - result->EA = 0; - return; + if (import_name) { + *is_fully_qualified = 1; + return zend_string_copy(import_name); } } - if (bp) { - opline_ptr = &opline; - init_op(opline_ptr TSRMLS_CC); - } else { - opline_ptr = get_next_op(CG(active_op_array) TSRMLS_CC); + compound = memchr(ZSTR_VAL(name), '\\', ZSTR_LEN(name)); + if (compound) { + *is_fully_qualified = 1; } - opline_ptr->opcode = op; - opline_ptr->result_type = IS_VAR; - opline_ptr->result.var = get_temporary_variable(CG(active_op_array)); - SET_NODE(opline_ptr->op1, varname); - GET_NODE(result, opline_ptr->result); - SET_UNUSED(opline_ptr->op2); - opline_ptr->extended_value = ZEND_FETCH_LOCAL; + if (compound && FC(imports)) { + /* If the first part of a qualified name is an alias, substitute it. */ + size_t len = compound - ZSTR_VAL(name); + zend_string *import_name = zend_hash_find_ptr_lc(FC(imports), ZSTR_VAL(name), len); - if (varname->op_type == IS_CONST) { - CALCULATE_LITERAL_HASH(opline_ptr->op1.constant); - if (zend_is_auto_global_quick(Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant), Z_HASH_P(&CONSTANT(opline_ptr->op1.constant)) TSRMLS_CC)) { - opline_ptr->extended_value = ZEND_FETCH_GLOBAL; + if (import_name) { + return zend_concat_names( + ZSTR_VAL(import_name), ZSTR_LEN(import_name), ZSTR_VAL(name) + len + 1, ZSTR_LEN(name) - len - 1); } } - if (bp) { - zend_stack_top(&CG(bp_stack), (void **) &fetch_list_ptr); - zend_llist_add_element(fetch_list_ptr, opline_ptr); - } + return zend_prefix_with_ns(name); } /* }}} */ -void fetch_simple_variable(znode *result, znode *varname, int bp TSRMLS_DC) /* {{{ */ +zend_string *zend_resolve_function_name(zend_string *name, uint32_t type, zend_bool *is_fully_qualified) /* {{{ */ { - /* the default mode must be Write, since fetch_simple_variable() is used to define function arguments */ - fetch_simple_variable_ex(result, varname, bp, ZEND_FETCH_W TSRMLS_CC); + return zend_resolve_non_class_name( + name, type, is_fully_qualified, 0, FC(imports_function)); +} +/* }}} */ + +zend_string *zend_resolve_const_name(zend_string *name, uint32_t type, zend_bool *is_fully_qualified) /* {{{ */ { + return zend_resolve_non_class_name( + name, type, is_fully_qualified, 1, FC(imports_const)); } /* }}} */ -void zend_do_fetch_static_member(znode *result, znode *class_name TSRMLS_DC) /* {{{ */ +zend_string *zend_resolve_class_name(zend_string *name, uint32_t type) /* {{{ */ { - znode class_node; - zend_llist *fetch_list_ptr; - zend_llist_element *le; - zend_op *opline_ptr; - zend_op opline; + char *compound; - if (class_name->op_type == IS_CONST && - ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant))) { - zend_resolve_class_name(class_name TSRMLS_CC); - class_node = *class_name; - } else { - zend_do_fetch_class(&class_node, class_name TSRMLS_CC); - } - zend_stack_top(&CG(bp_stack), (void **) &fetch_list_ptr); - if (result->op_type == IS_CV) { - init_op(&opline TSRMLS_CC); - - opline.opcode = ZEND_FETCH_W; - opline.result_type = IS_VAR; - opline.result.var = get_temporary_variable(CG(active_op_array)); - opline.op1_type = IS_CONST; - LITERAL_STRINGL(opline.op1, estrdup(CG(active_op_array)->vars[result->u.op.var].name), CG(active_op_array)->vars[result->u.op.var].name_len, 0); - CALCULATE_LITERAL_HASH(opline.op1.constant); - GET_POLYMORPHIC_CACHE_SLOT(opline.op1.constant); - if (class_node.op_type == IS_CONST) { - opline.op2_type = IS_CONST; - opline.op2.constant = - zend_add_class_name_literal(CG(active_op_array), &class_node.u.constant TSRMLS_CC); + if (type == ZEND_NAME_RELATIVE) { + return zend_prefix_with_ns(name); + } + + if (type == ZEND_NAME_FQ || ZSTR_VAL(name)[0] == '\\') { + /* Remove \ prefix (only relevant if this is a string rather than a label) */ + if (ZSTR_VAL(name)[0] == '\\') { + name = zend_string_init(ZSTR_VAL(name) + 1, ZSTR_LEN(name) - 1, 0); } else { - SET_NODE(opline.op2, &class_node); + zend_string_addref(name); } - GET_NODE(result,opline.result); - opline.extended_value |= ZEND_FETCH_STATIC_MEMBER; - opline_ptr = &opline; + /* Ensure that \self, \parent and \static are not used */ + if (ZEND_FETCH_CLASS_DEFAULT != zend_get_class_fetch_type(name)) { + zend_error_noreturn(E_COMPILE_ERROR, "'\\%s' is an invalid class name", ZSTR_VAL(name)); + } + return name; + } - zend_llist_add_element(fetch_list_ptr, &opline); - } else { - le = fetch_list_ptr->head; - - opline_ptr = (zend_op *)le->data; - if (opline_ptr->opcode != ZEND_FETCH_W && opline_ptr->op1_type == IS_CV) { - init_op(&opline TSRMLS_CC); - opline.opcode = ZEND_FETCH_W; - opline.result_type = IS_VAR; - opline.result.var = get_temporary_variable(CG(active_op_array)); - opline.op1_type = IS_CONST; - LITERAL_STRINGL(opline.op1, estrdup(CG(active_op_array)->vars[opline_ptr->op1.var].name), CG(active_op_array)->vars[opline_ptr->op1.var].name_len, 0); - CALCULATE_LITERAL_HASH(opline.op1.constant); - GET_POLYMORPHIC_CACHE_SLOT(opline.op1.constant); - if (class_node.op_type == IS_CONST) { - opline.op2_type = IS_CONST; - opline.op2.constant = - zend_add_class_name_literal(CG(active_op_array), &class_node.u.constant TSRMLS_CC); - } else { - SET_NODE(opline.op2, &class_node); - } - opline.extended_value |= ZEND_FETCH_STATIC_MEMBER; - COPY_NODE(opline_ptr->op1, opline.result); + if (FC(imports)) { + compound = memchr(ZSTR_VAL(name), '\\', ZSTR_LEN(name)); + if (compound) { + /* If the first part of a qualified name is an alias, substitute it. */ + size_t len = compound - ZSTR_VAL(name); + zend_string *import_name = + zend_hash_find_ptr_lc(FC(imports), ZSTR_VAL(name), len); - zend_llist_prepend_element(fetch_list_ptr, &opline); - } else { - if (opline_ptr->op1_type == IS_CONST) { - GET_POLYMORPHIC_CACHE_SLOT(opline_ptr->op1.constant); + if (import_name) { + return zend_concat_names( + ZSTR_VAL(import_name), ZSTR_LEN(import_name), ZSTR_VAL(name) + len + 1, ZSTR_LEN(name) - len - 1); } - if (class_node.op_type == IS_CONST) { - opline_ptr->op2_type = IS_CONST; - opline_ptr->op2.constant = - zend_add_class_name_literal(CG(active_op_array), &class_node.u.constant TSRMLS_CC); - } else { - SET_NODE(opline_ptr->op2, &class_node); + } else { + /* If an unqualified name is an alias, replace it. */ + zend_string *import_name + = zend_hash_find_ptr_lc(FC(imports), ZSTR_VAL(name), ZSTR_LEN(name)); + + if (import_name) { + return zend_string_copy(import_name); } - opline_ptr->extended_value |= ZEND_FETCH_STATIC_MEMBER; } } + + /* If not fully qualified and not an alias, prepend the current namespace */ + return zend_prefix_with_ns(name); } /* }}} */ -void fetch_array_begin(znode *result, znode *varname, znode *first_dim TSRMLS_DC) /* {{{ */ +zend_string *zend_resolve_class_name_ast(zend_ast *ast) /* {{{ */ { - fetch_simple_variable(result, varname, 1 TSRMLS_CC); - - fetch_array_dim(result, result, first_dim TSRMLS_CC); + zval *class_name = zend_ast_get_zval(ast); + if (Z_TYPE_P(class_name) != IS_STRING) { + zend_error_noreturn(E_COMPILE_ERROR, "Illegal class name"); + } + return zend_resolve_class_name(Z_STR_P(class_name), ast->attr); } /* }}} */ -void fetch_array_dim(znode *result, const znode *parent, const znode *dim TSRMLS_DC) /* {{{ */ +static void ptr_dtor(zval *zv) /* {{{ */ { - zend_op opline; - zend_llist *fetch_list_ptr; + efree(Z_PTR_P(zv)); +} +/* }}} */ - zend_stack_top(&CG(bp_stack), (void **) &fetch_list_ptr); +static void str_dtor(zval *zv) /* {{{ */ { + zend_string_release(Z_STR_P(zv)); +} +/* }}} */ - if (zend_is_function_or_method_call(parent)) { - init_op(&opline TSRMLS_CC); - opline.opcode = ZEND_SEPARATE; - SET_NODE(opline.op1, parent); - SET_UNUSED(opline.op2); - opline.result_type = IS_VAR; - opline.result.var = opline.op1.var; - zend_llist_add_element(fetch_list_ptr, &opline); - } +static zend_bool zend_is_call(zend_ast *ast); - init_op(&opline TSRMLS_CC); - opline.opcode = ZEND_FETCH_DIM_W; /* the backpatching routine assumes W */ - opline.result_type = IS_VAR; - opline.result.var = get_temporary_variable(CG(active_op_array)); - SET_NODE(opline.op1, parent); - SET_NODE(opline.op2, dim); - if (opline.op2_type == IS_CONST && Z_TYPE(CONSTANT(opline.op2.constant)) == IS_STRING) { - ulong index; - int numeric = 0; +static int generate_free_loop_var(znode *var) /* {{{ */ +{ + switch (var->op_type) { + case IS_UNUSED: + /* Stack separator on function boundary, stop applying */ + return 1; + case IS_VAR: + case IS_TMP_VAR: + { + zend_op *opline = get_next_op(CG(active_op_array)); - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL(CONSTANT(opline.op2.constant)), Z_STRLEN(CONSTANT(opline.op2.constant))+1, index, numeric = 1); - if (numeric) { - zval_dtor(&CONSTANT(opline.op2.constant)); - ZVAL_LONG(&CONSTANT(opline.op2.constant), index); - } else { - CALCULATE_LITERAL_HASH(opline.op2.constant); + opline->opcode = var->flag ? ZEND_FE_FREE : ZEND_FREE; + SET_NODE(opline->op1, var); + SET_UNUSED(opline->op2); } } - GET_NODE(result, opline.result); - - zend_llist_add_element(fetch_list_ptr, &opline); + return 0; } /* }}} */ -void fetch_string_offset(znode *result, const znode *parent, const znode *offset TSRMLS_DC) /* {{{ */ +static uint32_t zend_add_try_element(uint32_t try_op) /* {{{ */ { - fetch_array_dim(result, parent, offset TSRMLS_CC); -} -/* }}} */ + zend_op_array *op_array = CG(active_op_array); + uint32_t try_catch_offset = op_array->last_try_catch++; + zend_try_catch_element *elem; -void zend_do_print(znode *result, const znode *arg TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + op_array->try_catch_array = safe_erealloc( + op_array->try_catch_array, sizeof(zend_try_catch_element), op_array->last_try_catch, 0); - opline->result_type = IS_TMP_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - opline->opcode = ZEND_PRINT; - SET_NODE(opline->op1, arg); - SET_UNUSED(opline->op2); - GET_NODE(result, opline->result); + elem = &op_array->try_catch_array[try_catch_offset]; + elem->try_op = try_op; + elem->catch_op = 0; + elem->finally_op = 0; + elem->finally_end = 0; + + return try_catch_offset; } /* }}} */ -void zend_do_echo(const znode *arg TSRMLS_DC) /* {{{ */ +ZEND_API void function_add_ref(zend_function *function) /* {{{ */ { - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + if (function->type == ZEND_USER_FUNCTION) { + zend_op_array *op_array = &function->op_array; - opline->opcode = ZEND_ECHO; - SET_NODE(opline->op1, arg); - SET_UNUSED(opline->op2); + if (op_array->refcount) { + (*op_array->refcount)++; + } + if (op_array->static_variables) { + if (!(GC_FLAGS(op_array->static_variables) & IS_ARRAY_IMMUTABLE)) { + GC_REFCOUNT(op_array->static_variables)++; + } + } + op_array->run_time_cache = NULL; + } else if (function->type == ZEND_INTERNAL_FUNCTION) { + if (function->common.function_name) { + zend_string_addref(function->common.function_name); + } + } } /* }}} */ -void zend_do_abstract_method(const znode *function_name, znode *modifiers, const znode *body TSRMLS_DC) /* {{{ */ +ZEND_API int do_bind_function(const zend_op_array *op_array, const zend_op *opline, HashTable *function_table, zend_bool compile_time) /* {{{ */ { - char *method_type; + zend_function *function, *new_function; + zval *op1, *op2; - if (CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE) { - Z_LVAL(modifiers->u.constant) |= ZEND_ACC_ABSTRACT; - method_type = "Interface"; + if (compile_time) { + op1 = CT_CONSTANT_EX(op_array, opline->op1.constant); + op2 = CT_CONSTANT_EX(op_array, opline->op2.constant); } else { - method_type = "Abstract"; + op1 = RT_CONSTANT(op_array, opline->op1); + op2 = RT_CONSTANT(op_array, opline->op2); } - if (Z_LVAL(modifiers->u.constant) & ZEND_ACC_ABSTRACT) { - if(Z_LVAL(modifiers->u.constant) & ZEND_ACC_PRIVATE) { - zend_error_noreturn(E_COMPILE_ERROR, "%s function %s::%s() cannot be declared private", method_type, CG(active_class_entry)->name, Z_STRVAL(function_name->u.constant)); - } - if (Z_LVAL(body->u.constant) == ZEND_ACC_ABSTRACT) { - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + function = zend_hash_find_ptr(function_table, Z_STR_P(op1)); + new_function = zend_arena_alloc(&CG(arena), sizeof(zend_op_array)); + memcpy(new_function, function, sizeof(zend_op_array)); + if (zend_hash_add_ptr(function_table, Z_STR_P(op2), new_function) == NULL) { + int error_level = compile_time ? E_COMPILE_ERROR : E_ERROR; + zend_function *old_function; - opline->opcode = ZEND_RAISE_ABSTRACT_ERROR; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); + if ((old_function = zend_hash_find_ptr(function_table, Z_STR_P(op2))) != NULL + && old_function->type == ZEND_USER_FUNCTION + && old_function->op_array.last > 0) { + zend_error_noreturn(error_level, "Cannot redeclare %s() (previously declared in %s:%d)", + ZSTR_VAL(function->common.function_name), + ZSTR_VAL(old_function->op_array.filename), + old_function->op_array.opcodes[0].lineno); } else { - /* we had code in the function body */ - zend_error_noreturn(E_COMPILE_ERROR, "%s function %s::%s() cannot contain body", method_type, CG(active_class_entry)->name, Z_STRVAL(function_name->u.constant)); + zend_error_noreturn(error_level, "Cannot redeclare %s()", ZSTR_VAL(function->common.function_name)); } + return FAILURE; } else { - if (Z_LVAL(body->u.constant) == ZEND_ACC_ABSTRACT) { - zend_error_noreturn(E_COMPILE_ERROR, "Non-abstract method %s::%s() must contain body", CG(active_class_entry)->name, Z_STRVAL(function_name->u.constant)); + if (function->op_array.refcount) { + (*function->op_array.refcount)++; } + function->op_array.static_variables = NULL; /* NULL out the unbound function */ + return SUCCESS; } } /* }}} */ -static zend_bool opline_is_fetch_this(const zend_op *opline TSRMLS_DC) /* {{{ */ +ZEND_API zend_class_entry *do_bind_class(const zend_op_array* op_array, const zend_op *opline, HashTable *class_table, zend_bool compile_time) /* {{{ */ { - if ((opline->opcode == ZEND_FETCH_W) && (opline->op1_type == IS_CONST) - && (Z_TYPE(CONSTANT(opline->op1.constant)) == IS_STRING) - && ((opline->extended_value & ZEND_FETCH_STATIC_MEMBER) != ZEND_FETCH_STATIC_MEMBER) - && (Z_HASH_P(&CONSTANT(opline->op1.constant)) == THIS_HASHVAL) - && (Z_STRLEN(CONSTANT(opline->op1.constant)) == (sizeof("this")-1)) - && !memcmp(Z_STRVAL(CONSTANT(opline->op1.constant)), "this", sizeof("this") - 1)) { - return 1; + zend_class_entry *ce; + zval *op1, *op2; + + if (compile_time) { + op1 = CT_CONSTANT_EX(op_array, opline->op1.constant); + op2 = CT_CONSTANT_EX(op_array, opline->op2.constant); } else { - return 0; + op1 = RT_CONSTANT(op_array, opline->op1); + op2 = RT_CONSTANT(op_array, opline->op2); + } + if ((ce = zend_hash_find_ptr(class_table, Z_STR_P(op1))) == NULL) { + zend_error_noreturn(E_COMPILE_ERROR, "Internal Zend error - Missing class information for %s", Z_STRVAL_P(op1)); + return NULL; + } + ce->refcount++; + if (zend_hash_add_ptr(class_table, Z_STR_P(op2), ce) == NULL) { + ce->refcount--; + if (!compile_time) { + /* If we're in compile time, in practice, it's quite possible + * that we'll never reach this class declaration at runtime, + * so we shut up about it. This allows the if (!defined('FOO')) { return; } + * approach to work. + */ + zend_error_noreturn(E_COMPILE_ERROR, "Cannot declare %s %s, because the name is already in use", zend_get_object_type(ce), ZSTR_VAL(ce->name)); + } + return NULL; + } else { + if (!(ce->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_IMPLEMENT_INTERFACES|ZEND_ACC_IMPLEMENT_TRAITS))) { + zend_verify_abstract_class(ce); + } + return ce; } } /* }}} */ -void zend_do_assign(znode *result, znode *variable, znode *value TSRMLS_DC) /* {{{ */ +ZEND_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) /* {{{ */ { - int last_op_number; - zend_op *opline; + zend_class_entry *ce; + zval *op1, *op2; - if (value->op_type == IS_CV) { - zend_llist *fetch_list_ptr; - - zend_stack_top(&CG(bp_stack), (void **) &fetch_list_ptr); - if (fetch_list_ptr && fetch_list_ptr->head) { - opline = (zend_op *)fetch_list_ptr->head->data; - - if (opline->opcode == ZEND_FETCH_DIM_W && - opline->op1_type == IS_CV && - opline->op1.var == value->u.op.var) { - - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_FETCH_R; - opline->result_type = IS_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - opline->op1_type = IS_CONST; - LITERAL_STRINGL(opline->op1, - CG(active_op_array)->vars[value->u.op.var].name, - CG(active_op_array)->vars[value->u.op.var].name_len, 1); - CALCULATE_LITERAL_HASH(opline->op1.constant); - SET_UNUSED(opline->op2); - opline->extended_value = ZEND_FETCH_LOCAL; - GET_NODE(value, opline->result); - } + if (compile_time) { + op1 = CT_CONSTANT_EX(op_array, opline->op1.constant); + op2 = CT_CONSTANT_EX(op_array, opline->op2.constant); + } else { + op1 = RT_CONSTANT(op_array, opline->op1); + op2 = RT_CONSTANT(op_array, opline->op2); + } + + ce = zend_hash_find_ptr(class_table, Z_STR_P(op1)); + + if (!ce) { + if (!compile_time) { + /* If we're in compile time, in practice, it's quite possible + * that we'll never reach this class declaration at runtime, + * so we shut up about it. This allows the if (!defined('FOO')) { return; } + * approach to work. + */ + zend_error_noreturn(E_COMPILE_ERROR, "Cannot declare %s %s, because the name is already in use", zend_get_object_type(Z_OBJCE_P(op2)), Z_STRVAL_P(op2)); } + return NULL; } - zend_do_end_variable_parse(variable, BP_VAR_W, 0 TSRMLS_CC); + if (zend_hash_exists(class_table, Z_STR_P(op2))) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot declare %s %s, because the name is already in use", zend_get_object_type(ce), ZSTR_VAL(ce->name)); + } - last_op_number = get_next_op_number(CG(active_op_array)); - opline = get_next_op(CG(active_op_array) TSRMLS_CC); + zend_do_inheritance(ce, parent_ce); - if (variable->op_type == IS_CV) { - if (variable->u.op.var == CG(active_op_array)->this_var) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this"); - } - } else if (variable->op_type == IS_VAR) { - int n = 0; + ce->refcount++; - while (last_op_number - n > 0) { - zend_op *last_op; + /* Register the derived class */ + if (zend_hash_add_ptr(class_table, Z_STR_P(op2), ce) == NULL) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot declare %s %s, because the name is already in use", zend_get_object_type(ce), ZSTR_VAL(ce->name)); + } + return ce; +} +/* }}} */ - last_op = &CG(active_op_array)->opcodes[last_op_number-n-1]; +void zend_do_early_binding(void) /* {{{ */ +{ + zend_op *opline = &CG(active_op_array)->opcodes[CG(active_op_array)->last-1]; + HashTable *table; + + while (opline->opcode == ZEND_TICKS && opline > CG(active_op_array)->opcodes) { + opline--; + } + + switch (opline->opcode) { + case ZEND_DECLARE_FUNCTION: + if (do_bind_function(CG(active_op_array), opline, CG(function_table), 1) == FAILURE) { + return; + } + table = CG(function_table); + break; + case ZEND_DECLARE_CLASS: + if (do_bind_class(CG(active_op_array), opline, CG(class_table), 1) == NULL) { + return; + } + table = CG(class_table); + break; + case ZEND_DECLARE_INHERITED_CLASS: + { + zend_op *fetch_class_opline = opline-1; + zval *parent_name; + zend_class_entry *ce; - if (last_op->result_type == IS_VAR && - last_op->result.var == variable->u.op.var) { - if (last_op->opcode == ZEND_FETCH_OBJ_W) { - if (n > 0) { - int opline_no = (opline-CG(active_op_array)->opcodes)/sizeof(*opline); - *opline = *last_op; - MAKE_NOP(last_op); - /* last_op = opline; */ - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - /* get_next_op can realloc, we need to move last_op */ - last_op = &CG(active_op_array)->opcodes[opline_no]; + parent_name = CT_CONSTANT(fetch_class_opline->op2); + if (((ce = zend_lookup_class_ex(Z_STR_P(parent_name), parent_name + 1, 0)) == NULL) || + ((CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_CLASSES) && + (ce->type == ZEND_INTERNAL_CLASS))) { + if (CG(compiler_options) & ZEND_COMPILE_DELAYED_BINDING) { + uint32_t *opline_num = &CG(active_op_array)->early_binding; + + while (*opline_num != (uint32_t)-1) { + opline_num = &CG(active_op_array)->opcodes[*opline_num].result.opline_num; + } + *opline_num = opline - CG(active_op_array)->opcodes; + opline->opcode = ZEND_DECLARE_INHERITED_CLASS_DELAYED; + opline->result_type = IS_UNUSED; + opline->result.opline_num = -1; } - last_op->opcode = ZEND_ASSIGN_OBJ; - zend_do_op_data(opline, value TSRMLS_CC); - SET_UNUSED(opline->result); - GET_NODE(result, last_op->result); return; - } else if (last_op->opcode == ZEND_FETCH_DIM_W) { - if (n > 0) { - int opline_no = (opline-CG(active_op_array)->opcodes)/sizeof(*opline); - *opline = *last_op; - MAKE_NOP(last_op); - /* last_op = opline; */ - /* TBFixed: this can realloc opcodes, leaving last_op pointing wrong */ - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - /* get_next_op can realloc, we need to move last_op */ - last_op = &CG(active_op_array)->opcodes[opline_no]; - } - last_op->opcode = ZEND_ASSIGN_DIM; - zend_do_op_data(opline, value TSRMLS_CC); - opline->op2.var = get_temporary_variable(CG(active_op_array)); - opline->op2_type = IS_VAR; - SET_UNUSED(opline->result); - GET_NODE(result, last_op->result); + } + if (do_bind_inherited_class(CG(active_op_array), opline, CG(class_table), ce, 1) == NULL) { return; - } else if (opline_is_fetch_this(last_op TSRMLS_CC)) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this"); - } else { - break; } + /* clear unnecessary ZEND_FETCH_CLASS opcode */ + zend_del_literal(CG(active_op_array), fetch_class_opline->op2.constant); + MAKE_NOP(fetch_class_opline); + + table = CG(class_table); + break; } - n++; - } + case ZEND_VERIFY_ABSTRACT_CLASS: + case ZEND_ADD_INTERFACE: + case ZEND_ADD_TRAIT: + case ZEND_BIND_TRAITS: + /* We currently don't early-bind classes that implement interfaces */ + /* Classes with traits are handled exactly the same, no early-bind here */ + return; + default: + zend_error_noreturn(E_COMPILE_ERROR, "Invalid binding type"); + return; } - opline->opcode = ZEND_ASSIGN; - SET_NODE(opline->op1, variable); - SET_NODE(opline->op2, value); - opline->result_type = IS_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - GET_NODE(result, opline->result); + zend_hash_del(table, Z_STR_P(CT_CONSTANT(opline->op1))); + zend_del_literal(CG(active_op_array), opline->op1.constant); + zend_del_literal(CG(active_op_array), opline->op2.constant); + MAKE_NOP(opline); } /* }}} */ -void zend_do_assign_ref(znode *result, const znode *lvar, const znode *rvar TSRMLS_DC) /* {{{ */ +ZEND_API void zend_do_delayed_early_binding(const zend_op_array *op_array) /* {{{ */ { - zend_op *opline; - - if (lvar->op_type == IS_CV) { - if (lvar->u.op.var == CG(active_op_array)->this_var) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this"); - } - } else if (lvar->op_type == IS_VAR) { - int last_op_number = get_next_op_number(CG(active_op_array)); + if (op_array->early_binding != (uint32_t)-1) { + zend_bool orig_in_compilation = CG(in_compilation); + uint32_t opline_num = op_array->early_binding; + zend_class_entry *ce; - if (last_op_number > 0) { - opline = &CG(active_op_array)->opcodes[last_op_number-1]; - if (opline_is_fetch_this(opline TSRMLS_CC)) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this"); + CG(in_compilation) = 1; + while (opline_num != (uint32_t)-1) { + zval *parent_name = RT_CONSTANT(op_array, op_array->opcodes[opline_num-1].op2); + if ((ce = zend_lookup_class_ex(Z_STR_P(parent_name), parent_name + 1, 0)) != NULL) { + do_bind_inherited_class(op_array, &op_array->opcodes[opline_num], EG(class_table), ce, 0); } - } - } - - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_ASSIGN_REF; - if (zend_is_function_or_method_call(rvar)) { - opline->extended_value = ZEND_RETURNS_FUNCTION; - } else if (rvar->EA & ZEND_PARSED_NEW) { - opline->extended_value = ZEND_RETURNS_NEW; - } else { - opline->extended_value = 0; - } - if (result) { - opline->result_type = IS_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - GET_NODE(result, opline->result); - } else { - opline->result_type = IS_UNUSED | EXT_TYPE_UNUSED; + opline_num = op_array->opcodes[opline_num].result.opline_num; + } + CG(in_compilation) = orig_in_compilation; } - SET_NODE(opline->op1, lvar); - SET_NODE(opline->op2, rvar); } /* }}} */ -static inline void do_begin_loop(TSRMLS_D) /* {{{ */ +ZEND_API zend_string *zend_mangle_property_name(const char *src1, size_t src1_length, const char *src2, size_t src2_length, int internal) /* {{{ */ { - zend_brk_cont_element *brk_cont_element; - int parent; + size_t prop_name_length = 1 + src1_length + 1 + src2_length; + zend_string *prop_name = zend_string_alloc(prop_name_length, internal); - parent = CG(context).current_brk_cont; - CG(context).current_brk_cont = CG(active_op_array)->last_brk_cont; - brk_cont_element = get_next_brk_cont_element(CG(active_op_array)); - brk_cont_element->start = get_next_op_number(CG(active_op_array)); - brk_cont_element->parent = parent; + ZSTR_VAL(prop_name)[0] = '\0'; + memcpy(ZSTR_VAL(prop_name) + 1, src1, src1_length+1); + memcpy(ZSTR_VAL(prop_name) + 1 + src1_length + 1, src2, src2_length+1); + return prop_name; } /* }}} */ -static inline void do_end_loop(int cont_addr, int has_loop_var TSRMLS_DC) /* {{{ */ +static zend_always_inline size_t zend_strnlen(const char* s, size_t maxlen) /* {{{ */ { - if (!has_loop_var) { - /* The start fileld is used to free temporary variables in case of exceptions. - * We won't try to free something of we don't have loop variable. - */ - CG(active_op_array)->brk_cont_array[CG(context).current_brk_cont].start = -1; - } - CG(active_op_array)->brk_cont_array[CG(context).current_brk_cont].cont = cont_addr; - CG(active_op_array)->brk_cont_array[CG(context).current_brk_cont].brk = get_next_op_number(CG(active_op_array)); - CG(context).current_brk_cont = CG(active_op_array)->brk_cont_array[CG(context).current_brk_cont].parent; + size_t len = 0; + while (*s++ && maxlen--) len++; + return len; } /* }}} */ -void zend_do_while_cond(const znode *expr, znode *close_bracket_token TSRMLS_DC) /* {{{ */ +ZEND_API int zend_unmangle_property_name_ex(const zend_string *name, const char **class_name, const char **prop_name, size_t *prop_len) /* {{{ */ { - int while_cond_op_number = get_next_op_number(CG(active_op_array)); - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + size_t class_name_len; - opline->opcode = ZEND_JMPZ; - SET_NODE(opline->op1, expr); - close_bracket_token->u.op.opline_num = while_cond_op_number; - SET_UNUSED(opline->op2); + *class_name = NULL; + + if (ZSTR_VAL(name)[0] != '\0') { + *prop_name = ZSTR_VAL(name); + if (prop_len) { + *prop_len = ZSTR_LEN(name); + } + return SUCCESS; + } + if (ZSTR_LEN(name) < 3 || ZSTR_VAL(name)[1] == '\0') { + zend_error(E_NOTICE, "Illegal member variable name"); + *prop_name = ZSTR_VAL(name); + if (prop_len) { + *prop_len = ZSTR_LEN(name); + } + return FAILURE; + } - do_begin_loop(TSRMLS_C); - INC_BPC(CG(active_op_array)); + class_name_len = zend_strnlen(ZSTR_VAL(name) + 1, ZSTR_LEN(name) - 2); + if (class_name_len >= ZSTR_LEN(name) - 2 || ZSTR_VAL(name)[class_name_len + 1] != '\0') { + zend_error(E_NOTICE, "Corrupt member variable name"); + *prop_name = ZSTR_VAL(name); + if (prop_len) { + *prop_len = ZSTR_LEN(name); + } + return FAILURE; + } + + *class_name = ZSTR_VAL(name) + 1; + *prop_name = ZSTR_VAL(name) + class_name_len + 2; + if (prop_len) { + *prop_len = ZSTR_LEN(name) - class_name_len - 2; + } + return SUCCESS; } /* }}} */ -void zend_do_while_end(const znode *while_token, const znode *close_bracket_token TSRMLS_DC) /* {{{ */ +static zend_constant *zend_lookup_reserved_const(const char *name, size_t len) /* {{{ */ { - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + zend_constant *c = zend_hash_find_ptr_lc(EG(zend_constants), name, len); + if (c && !(c->flags & CONST_CS) && (c->flags & CONST_CT_SUBST)) { + return c; + } + return NULL; +} +/* }}} */ - /* add unconditional jump */ - opline->opcode = ZEND_JMP; - opline->op1.opline_num = while_token->u.op.opline_num; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); +static zend_bool zend_try_ct_eval_const(zval *zv, zend_string *name, zend_bool is_fully_qualified) /* {{{ */ +{ + zend_constant *c; + + /* Substitute case-sensitive (or lowercase) constants */ + c = zend_hash_find_ptr(EG(zend_constants), name); + if (c && ( + ((c->flags & CONST_PERSISTENT) && !(CG(compiler_options) & ZEND_COMPILE_NO_PERSISTENT_CONSTANT_SUBSTITUTION)) + || (Z_TYPE(c->value) < IS_OBJECT && !(CG(compiler_options) & ZEND_COMPILE_NO_CONSTANT_SUBSTITUTION)) + )) { + ZVAL_DUP(zv, &c->value); + return 1; + } + + { + /* Substitute true, false and null (including unqualified usage in namespaces) */ + const char *lookup_name = ZSTR_VAL(name); + size_t lookup_len = ZSTR_LEN(name); - /* update while's conditional jmp */ - CG(active_op_array)->opcodes[close_bracket_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array)); + if (!is_fully_qualified) { + zend_get_unqualified_name(name, &lookup_name, &lookup_len); + } - do_end_loop(while_token->u.op.opline_num, 0 TSRMLS_CC); + c = zend_lookup_reserved_const(lookup_name, lookup_len); + if (c) { + ZVAL_DUP(zv, &c->value); + return 1; + } + } - DEC_BPC(CG(active_op_array)); + return 0; } /* }}} */ -void zend_do_for_cond(const znode *expr, znode *second_semicolon_token TSRMLS_DC) /* {{{ */ +static inline zend_bool zend_is_scope_known() /* {{{ */ { - int for_cond_op_number = get_next_op_number(CG(active_op_array)); - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + if (CG(active_op_array)->fn_flags & ZEND_ACC_CLOSURE) { + /* Closures can be rebound to a different scope */ + return 0; + } - opline->opcode = ZEND_JMPZNZ; - SET_NODE(opline->op1, expr); /* the conditional expression */ - second_semicolon_token->u.op.opline_num = for_cond_op_number; - SET_UNUSED(opline->op2); + if (!CG(active_class_entry)) { + /* The scope is known if we're in a free function (no scope), but not if we're in + * a file/eval (which inherits including/eval'ing scope). */ + return CG(active_op_array)->function_name != NULL; + } + + /* For traits self etc refers to the using class, not the trait itself */ + return (CG(active_class_entry)->ce_flags & ZEND_ACC_TRAIT) == 0; } /* }}} */ -void zend_do_for_before_statement(const znode *cond_start, const znode *second_semicolon_token TSRMLS_DC) /* {{{ */ +static inline zend_bool class_name_refers_to_active_ce(zend_string *class_name, uint32_t fetch_type) /* {{{ */ { - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + if (!CG(active_class_entry)) { + return 0; + } + if (fetch_type == ZEND_FETCH_CLASS_SELF && zend_is_scope_known()) { + return 1; + } + return fetch_type == ZEND_FETCH_CLASS_DEFAULT + && zend_string_equals_ci(class_name, CG(active_class_entry)->name); +} +/* }}} */ - opline->opcode = ZEND_JMP; - opline->op1.opline_num = cond_start->u.op.opline_num; - CG(active_op_array)->opcodes[second_semicolon_token->u.op.opline_num].extended_value = get_next_op_number(CG(active_op_array)); - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); +uint32_t zend_get_class_fetch_type(zend_string *name) /* {{{ */ +{ + if (zend_string_equals_literal_ci(name, "self")) { + return ZEND_FETCH_CLASS_SELF; + } else if (zend_string_equals_literal_ci(name, "parent")) { + return ZEND_FETCH_CLASS_PARENT; + } else if (zend_string_equals_literal_ci(name, "static")) { + return ZEND_FETCH_CLASS_STATIC; + } else { + return ZEND_FETCH_CLASS_DEFAULT; + } +} +/* }}} */ - do_begin_loop(TSRMLS_C); +static uint32_t zend_get_class_fetch_type_ast(zend_ast *name_ast) /* {{{ */ +{ + /* Fully qualified names are always default refs */ + if (name_ast->attr == ZEND_NAME_FQ) { + return ZEND_FETCH_CLASS_DEFAULT; + } - INC_BPC(CG(active_op_array)); + return zend_get_class_fetch_type(zend_ast_get_str(name_ast)); } /* }}} */ -void zend_do_for_end(const znode *second_semicolon_token TSRMLS_DC) /* {{{ */ +static void zend_ensure_valid_class_fetch_type(uint32_t fetch_type) /* {{{ */ { - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + if (fetch_type != ZEND_FETCH_CLASS_DEFAULT && !CG(active_class_entry) && zend_is_scope_known()) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use \"%s\" when no class scope is active", + fetch_type == ZEND_FETCH_CLASS_SELF ? "self" : + fetch_type == ZEND_FETCH_CLASS_PARENT ? "parent" : "static"); + } +} +/* }}} */ - opline->opcode = ZEND_JMP; - opline->op1.opline_num = second_semicolon_token->u.op.opline_num+1; - CG(active_op_array)->opcodes[second_semicolon_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array)); - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); +static zend_bool zend_try_compile_const_expr_resolve_class_name(zval *zv, zend_ast *class_ast, zend_ast *name_ast, zend_bool constant) /* {{{ */ +{ + uint32_t fetch_type; - do_end_loop(second_semicolon_token->u.op.opline_num+1, 0 TSRMLS_CC); + if (name_ast->kind != ZEND_AST_ZVAL) { + return 0; + } + + if (!zend_string_equals_literal_ci(zend_ast_get_str(name_ast), "class")) { + return 0; + } - DEC_BPC(CG(active_op_array)); + if (class_ast->kind != ZEND_AST_ZVAL) { + zend_error_noreturn(E_COMPILE_ERROR, + "Dynamic class names are not allowed in compile-time ::class fetch"); + } + + fetch_type = zend_get_class_fetch_type(zend_ast_get_str(class_ast)); + zend_ensure_valid_class_fetch_type(fetch_type); + + switch (fetch_type) { + case ZEND_FETCH_CLASS_SELF: + if (constant || (CG(active_class_entry) && zend_is_scope_known())) { + ZVAL_STR_COPY(zv, CG(active_class_entry)->name); + } else { + ZVAL_NULL(zv); + } + return 1; + case ZEND_FETCH_CLASS_STATIC: + case ZEND_FETCH_CLASS_PARENT: + if (constant) { + zend_error_noreturn(E_COMPILE_ERROR, + "%s::class cannot be used for compile-time class name resolution", + fetch_type == ZEND_FETCH_CLASS_STATIC ? "static" : "parent" + ); + } else { + ZVAL_NULL(zv); + } + return 1; + case ZEND_FETCH_CLASS_DEFAULT: + ZVAL_STR(zv, zend_resolve_class_name_ast(class_ast)); + return 1; + EMPTY_SWITCH_DEFAULT_CASE() + } } /* }}} */ -void zend_do_pre_incdec(znode *result, const znode *op1, zend_uchar op TSRMLS_DC) /* {{{ */ +static zend_bool zend_try_ct_eval_class_const(zval *zv, zend_string *class_name, zend_string *name) /* {{{ */ { - int last_op_number = get_next_op_number(CG(active_op_array)); - zend_op *opline; + uint32_t fetch_type = zend_get_class_fetch_type(class_name); + zval *c; - if (last_op_number > 0) { - zend_op *last_op = &CG(active_op_array)->opcodes[last_op_number-1]; - - if (last_op->opcode == ZEND_FETCH_OBJ_RW) { - last_op->opcode = (op==ZEND_PRE_INC)?ZEND_PRE_INC_OBJ:ZEND_PRE_DEC_OBJ; - last_op->result_type = IS_VAR; - last_op->result.var = get_temporary_variable(CG(active_op_array)); - GET_NODE(result, last_op->result); - return; + if (class_name_refers_to_active_ce(class_name, fetch_type)) { + c = zend_hash_find(&CG(active_class_entry)->constants_table, name); + } else if (fetch_type == ZEND_FETCH_CLASS_DEFAULT && !(CG(compiler_options) & ZEND_COMPILE_NO_CONSTANT_SUBSTITUTION)) { + zend_class_entry *ce = zend_hash_find_ptr_lc(CG(class_table), ZSTR_VAL(class_name), ZSTR_LEN(class_name)); + if (ce) { + c = zend_hash_find(&ce->constants_table, name); + } else { + return 0; } + } else { + return 0; } - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = op; - SET_NODE(opline->op1, op1); - SET_UNUSED(opline->op2); - opline->result_type = IS_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - GET_NODE(result, opline->result); + if (CG(compiler_options) & ZEND_COMPILE_NO_PERSISTENT_CONSTANT_SUBSTITUTION) { + return 0; + } + + /* Substitute case-sensitive (or lowercase) persistent class constants */ + if (c && Z_TYPE_P(c) < IS_OBJECT) { + ZVAL_DUP(zv, c); + return 1; + } + + return 0; } /* }}} */ -void zend_do_post_incdec(znode *result, const znode *op1, zend_uchar op TSRMLS_DC) /* {{{ */ +static void zend_add_to_list(void *result, void *item) /* {{{ */ { - int last_op_number = get_next_op_number(CG(active_op_array)); - zend_op *opline; - - if (last_op_number > 0) { - zend_op *last_op = &CG(active_op_array)->opcodes[last_op_number-1]; + void** list = *(void**)result; + size_t n = 0; - if (last_op->opcode == ZEND_FETCH_OBJ_RW) { - last_op->opcode = (op==ZEND_POST_INC)?ZEND_POST_INC_OBJ:ZEND_POST_DEC_OBJ; - last_op->result_type = IS_TMP_VAR; - last_op->result.var = get_temporary_variable(CG(active_op_array)); - GET_NODE(result, last_op->result); - return; + if (list) { + while (list[n]) { + n++; } } - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = op; - SET_NODE(opline->op1, op1); - SET_UNUSED(opline->op2); - opline->result_type = IS_TMP_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - GET_NODE(result, opline->result); + list = erealloc(list, sizeof(void*) * (n+2)); + + list[n] = item; + list[n+1] = NULL; + + *(void**)result = list; } /* }}} */ -void zend_do_if_cond(const znode *cond, znode *closing_bracket_token TSRMLS_DC) /* {{{ */ +void zend_do_extended_info(void) /* {{{ */ { - int if_cond_op_number = get_next_op_number(CG(active_op_array)); - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + zend_op *opline; + + if (!(CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO)) { + return; + } + + opline = get_next_op(CG(active_op_array)); - opline->opcode = ZEND_JMPZ; - SET_NODE(opline->op1, cond); - closing_bracket_token->u.op.opline_num = if_cond_op_number; + opline->opcode = ZEND_EXT_STMT; + SET_UNUSED(opline->op1); SET_UNUSED(opline->op2); - INC_BPC(CG(active_op_array)); } /* }}} */ -void zend_do_if_after_statement(const znode *closing_bracket_token, unsigned char initialize TSRMLS_DC) /* {{{ */ +void zend_do_extended_fcall_begin(void) /* {{{ */ { - int if_end_op_number = get_next_op_number(CG(active_op_array)); - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - zend_llist *jmp_list_ptr; - - opline->opcode = ZEND_JMP; - /* save for backpatching */ - if (initialize) { - zend_llist jmp_list; + zend_op *opline; - zend_llist_init(&jmp_list, sizeof(int), NULL, 0); - zend_stack_push(&CG(bp_stack), (void *) &jmp_list, sizeof(zend_llist)); + if (!(CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO)) { + return; } - zend_stack_top(&CG(bp_stack), (void **) &jmp_list_ptr); - zend_llist_add_element(jmp_list_ptr, &if_end_op_number); - CG(active_op_array)->opcodes[closing_bracket_token->u.op.opline_num].op2.opline_num = if_end_op_number+1; + opline = get_next_op(CG(active_op_array)); + + opline->opcode = ZEND_EXT_FCALL_BEGIN; SET_UNUSED(opline->op1); SET_UNUSED(opline->op2); } /* }}} */ -void zend_do_if_end(TSRMLS_D) /* {{{ */ +void zend_do_extended_fcall_end(void) /* {{{ */ { - int next_op_number = get_next_op_number(CG(active_op_array)); - zend_llist *jmp_list_ptr; - zend_llist_element *le; + zend_op *opline; - zend_stack_top(&CG(bp_stack), (void **) &jmp_list_ptr); - for (le=jmp_list_ptr->head; le; le = le->next) { - CG(active_op_array)->opcodes[*((int *) le->data)].op1.opline_num = next_op_number; + if (!(CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO)) { + return; } - zend_llist_destroy(jmp_list_ptr); - zend_stack_del_top(&CG(bp_stack)); - DEC_BPC(CG(active_op_array)); + + opline = get_next_op(CG(active_op_array)); + + opline->opcode = ZEND_EXT_FCALL_END; + SET_UNUSED(opline->op1); + SET_UNUSED(opline->op2); } /* }}} */ -void zend_check_writable_variable(const znode *variable) /* {{{ */ -{ - zend_uint type = variable->EA; +zend_bool zend_is_auto_global_str(char *name, size_t len) /* {{{ */ { + zend_auto_global *auto_global; - if (type & ZEND_PARSED_METHOD_CALL) { - zend_error_noreturn(E_COMPILE_ERROR, "Can't use method return value in write context"); - } - if (type == ZEND_PARSED_FUNCTION_CALL) { - zend_error_noreturn(E_COMPILE_ERROR, "Can't use function return value in write context"); + if ((auto_global = zend_hash_str_find_ptr(CG(auto_globals), name, len)) != NULL) { + if (auto_global->armed) { + auto_global->armed = auto_global->auto_global_callback(auto_global->name); + } + return 1; } + return 0; } /* }}} */ -void zend_do_begin_variable_parse(TSRMLS_D) /* {{{ */ +zend_bool zend_is_auto_global(zend_string *name) /* {{{ */ { - zend_llist fetch_list; + zend_auto_global *auto_global; - zend_llist_init(&fetch_list, sizeof(zend_op), NULL, 0); - zend_stack_push(&CG(bp_stack), (void *) &fetch_list, sizeof(zend_llist)); + if ((auto_global = zend_hash_find_ptr(CG(auto_globals), name)) != NULL) { + if (auto_global->armed) { + auto_global->armed = auto_global->auto_global_callback(auto_global->name); + } + return 1; + } + return 0; } /* }}} */ -void zend_do_end_variable_parse(znode *variable, int type, int arg_offset TSRMLS_DC) /* {{{ */ +int zend_register_auto_global(zend_string *name, zend_bool jit, zend_auto_global_callback auto_global_callback) /* {{{ */ { - zend_llist *fetch_list_ptr; - zend_llist_element *le; - zend_op *opline = NULL; - zend_op *opline_ptr; - zend_uint this_var = -1; - - zend_stack_top(&CG(bp_stack), (void **) &fetch_list_ptr); + zend_auto_global auto_global; + int retval; - le = fetch_list_ptr->head; + auto_global.name = zend_new_interned_string(name); + auto_global.auto_global_callback = auto_global_callback; + auto_global.jit = jit; - /* TODO: $foo->x->y->z = 1 should fetch "x" and "y" for R or RW, not just W */ + retval = zend_hash_add_mem(CG(auto_globals), auto_global.name, &auto_global, sizeof(zend_auto_global)) != NULL ? SUCCESS : FAILURE; - if (le) { - opline_ptr = (zend_op *)le->data; - if (opline_is_fetch_this(opline_ptr TSRMLS_CC)) { - /* convert to FETCH_?(this) into IS_CV */ - if (CG(active_op_array)->last == 0 || - CG(active_op_array)->opcodes[CG(active_op_array)->last-1].opcode != ZEND_BEGIN_SILENCE) { + zend_string_release(name); + return retval; +} +/* }}} */ - this_var = opline_ptr->result.var; - if (CG(active_op_array)->this_var == -1) { - CG(active_op_array)->this_var = lookup_cv(CG(active_op_array), Z_STRVAL(CONSTANT(opline_ptr->op1.constant)), Z_STRLEN(CONSTANT(opline_ptr->op1.constant)), Z_HASH_P(&CONSTANT(opline_ptr->op1.constant)) TSRMLS_CC); - Z_TYPE(CONSTANT(opline_ptr->op1.constant)) = IS_NULL; - } else { - zend_del_literal(CG(active_op_array), opline_ptr->op1.constant); - } - le = le->next; - if (variable->op_type == IS_VAR && - variable->u.op.var == this_var) { - variable->op_type = IS_CV; - variable->u.op.var = CG(active_op_array)->this_var; - } - } else if (CG(active_op_array)->this_var == -1) { - CG(active_op_array)->this_var = lookup_cv(CG(active_op_array), estrndup("this", sizeof("this")-1), sizeof("this")-1, THIS_HASHVAL TSRMLS_CC); - } - } +ZEND_API void zend_activate_auto_globals(void) /* {{{ */ +{ + zend_auto_global *auto_global; - while (le) { - opline_ptr = (zend_op *)le->data; - if (opline_ptr->opcode == ZEND_SEPARATE) { - if (type != BP_VAR_R && type != BP_VAR_IS) { - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - memcpy(opline, opline_ptr, sizeof(zend_op)); - } - le = le->next; - continue; - } - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - memcpy(opline, opline_ptr, sizeof(zend_op)); - if (opline->op1_type == IS_VAR && - opline->op1.var == this_var) { - opline->op1_type = IS_CV; - opline->op1.var = CG(active_op_array)->this_var; - } - switch (type) { - case BP_VAR_R: - if (opline->opcode == ZEND_FETCH_DIM_W && opline->op2_type == IS_UNUSED) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use [] for reading"); - } - opline->opcode -= 3; - break; - case BP_VAR_W: - break; - case BP_VAR_RW: - opline->opcode += 3; - break; - case BP_VAR_IS: - if (opline->opcode == ZEND_FETCH_DIM_W && opline->op2_type == IS_UNUSED) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use [] for reading"); - } - opline->opcode += 6; /* 3+3 */ - break; - case BP_VAR_FUNC_ARG: - opline->opcode += 9; /* 3+3+3 */ - opline->extended_value |= arg_offset; - break; - case BP_VAR_UNSET: - if (opline->opcode == ZEND_FETCH_DIM_W && opline->op2_type == IS_UNUSED) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use [] for unsetting"); - } - opline->opcode += 12; /* 3+3+3+3 */ - break; - } - le = le->next; - } - if (opline && type == BP_VAR_W && arg_offset) { - opline->extended_value |= ZEND_FETCH_MAKE_REF; + ZEND_HASH_FOREACH_PTR(CG(auto_globals), auto_global) { + if (auto_global->jit) { + auto_global->armed = 1; + } else if (auto_global->auto_global_callback) { + auto_global->armed = auto_global->auto_global_callback(auto_global->name); + } else { + auto_global->armed = 0; } - } - zend_llist_destroy(fetch_list_ptr); - zend_stack_del_top(&CG(bp_stack)); + } ZEND_HASH_FOREACH_END(); } /* }}} */ -void zend_do_add_string(znode *result, const znode *op1, znode *op2 TSRMLS_DC) /* {{{ */ +int zendlex(zend_parser_stack_elem *elem) /* {{{ */ { - zend_op *opline; + zval zv; + int retval; - if (Z_STRLEN(op2->u.constant) > 1) { - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_ADD_STRING; - } else if (Z_STRLEN(op2->u.constant) == 1) { - int ch = *Z_STRVAL(op2->u.constant); - - /* Free memory and use ZEND_ADD_CHAR in case of 1 character strings */ - efree(Z_STRVAL(op2->u.constant)); - ZVAL_LONG(&op2->u.constant, ch); - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_ADD_CHAR; - } else { /* String can be empty after a variable at the end of a heredoc */ - efree(Z_STRVAL(op2->u.constant)); - return; + if (CG(increment_lineno)) { + CG(zend_lineno)++; + CG(increment_lineno) = 0; } - if (op1) { - SET_NODE(opline->op1, op1); - SET_NODE(opline->result, op1); - } else { - SET_UNUSED(opline->op1); - opline->result_type = IS_TMP_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); +again: + ZVAL_UNDEF(&zv); + retval = lex_scan(&zv); + switch (retval) { + case T_COMMENT: + case T_DOC_COMMENT: + case T_OPEN_TAG: + case T_WHITESPACE: + goto again; + + case T_CLOSE_TAG: + if (LANG_SCNG(yy_text)[LANG_SCNG(yy_leng)-1] != '>') { + CG(increment_lineno) = 1; + } + retval = ';'; /* implicit ; */ + break; + case T_OPEN_TAG_WITH_ECHO: + retval = T_ECHO; + break; } - SET_NODE(opline->op2, op2); - GET_NODE(result, opline->result); + if (Z_TYPE(zv) != IS_UNDEF) { + elem->ast = zend_ast_create_zval(&zv); + } + + return retval; } /* }}} */ -void zend_do_add_variable(znode *result, const znode *op1, const znode *op2 TSRMLS_DC) /* {{{ */ +ZEND_API void zend_initialize_class_data(zend_class_entry *ce, zend_bool nullify_handlers) /* {{{ */ { - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + zend_bool persistent_hashes = (ce->type == ZEND_INTERNAL_CLASS) ? 1 : 0; + dtor_func_t zval_ptr_dtor_func = ((persistent_hashes) ? ZVAL_INTERNAL_PTR_DTOR : ZVAL_PTR_DTOR); - opline->opcode = ZEND_ADD_VAR; + ce->refcount = 1; + ce->ce_flags = ZEND_ACC_CONSTANTS_UPDATED; - if (op1) { - SET_NODE(opline->op1, op1); - SET_NODE(opline->result, op1); + ce->default_properties_table = NULL; + ce->default_static_members_table = NULL; + zend_hash_init_ex(&ce->properties_info, 8, NULL, (persistent_hashes ? zend_destroy_property_info_internal : NULL), persistent_hashes, 0); + zend_hash_init_ex(&ce->constants_table, 8, NULL, zval_ptr_dtor_func, persistent_hashes, 0); + zend_hash_init_ex(&ce->function_table, 8, NULL, ZEND_FUNCTION_DTOR, persistent_hashes, 0); + + if (ce->type == ZEND_INTERNAL_CLASS) { +#ifdef ZTS + int n = zend_hash_num_elements(CG(class_table)); + + if (CG(static_members_table) && n >= CG(last_static_member)) { + /* Support for run-time declaration: dl() */ + CG(last_static_member) = n+1; + CG(static_members_table) = realloc(CG(static_members_table), (n+1)*sizeof(zval*)); + CG(static_members_table)[n] = NULL; + } + ce->static_members_table = (zval*)(zend_intptr_t)n; +#else + ce->static_members_table = NULL; +#endif } else { - SET_UNUSED(opline->op1); - opline->result_type = IS_TMP_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); + ce->static_members_table = ce->default_static_members_table; + ce->info.user.doc_comment = NULL; } - SET_NODE(opline->op2, op2); - GET_NODE(result, opline->result); -} -/* }}} */ -void zend_do_free(znode *op1 TSRMLS_DC) /* {{{ */ -{ - if (op1->op_type==IS_TMP_VAR) { - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - opline->opcode = ZEND_FREE; - SET_NODE(opline->op1, op1); - SET_UNUSED(opline->op2); - } else if (op1->op_type==IS_VAR) { - zend_op *opline = &CG(active_op_array)->opcodes[CG(active_op_array)->last-1]; + ce->default_properties_count = 0; + ce->default_static_members_count = 0; - while (opline->opcode == ZEND_END_SILENCE || opline->opcode == ZEND_EXT_FCALL_END || opline->opcode == ZEND_OP_DATA) { - opline--; - } - if (opline->result_type == IS_VAR - && opline->result.var == op1->u.op.var) { - if (opline->opcode == ZEND_FETCH_R || - opline->opcode == ZEND_FETCH_DIM_R || - opline->opcode == ZEND_FETCH_OBJ_R || - opline->opcode == ZEND_QM_ASSIGN_VAR) { - /* It's very rare and useless case. It's better to use - additional FREE opcode and simplify the FETCH handlers - their selves */ - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_FREE; - SET_NODE(opline->op1, op1); - SET_UNUSED(opline->op2); - } else { - opline->result_type |= EXT_TYPE_UNUSED; - } - } else { - while (opline>CG(active_op_array)->opcodes) { - if (opline->opcode == ZEND_FETCH_DIM_R - && opline->op1_type == IS_VAR - && opline->op1.var == op1->u.op.var) { - /* This should the end of a list() construct - * Mark its result as unused - */ - opline->extended_value = ZEND_FETCH_STANDARD; - break; - } else if (opline->result_type==IS_VAR - && opline->result.var == op1->u.op.var) { - if (opline->opcode == ZEND_NEW) { - opline->result_type |= EXT_TYPE_UNUSED; - } - break; - } - opline--; - } + if (nullify_handlers) { + ce->constructor = NULL; + ce->destructor = NULL; + ce->clone = NULL; + ce->__get = NULL; + ce->__set = NULL; + ce->__unset = NULL; + ce->__isset = NULL; + ce->__call = NULL; + ce->__callstatic = NULL; + ce->__tostring = NULL; + ce->create_object = NULL; + ce->get_iterator = NULL; + ce->iterator_funcs.funcs = NULL; + ce->interface_gets_implemented = NULL; + ce->get_static_method = NULL; + ce->parent = NULL; + ce->num_interfaces = 0; + ce->interfaces = NULL; + ce->num_traits = 0; + ce->traits = NULL; + ce->trait_aliases = NULL; + ce->trait_precedences = NULL; + ce->serialize = NULL; + ce->unserialize = NULL; + ce->serialize_func = NULL; + ce->unserialize_func = NULL; + ce->__debugInfo = NULL; + if (ce->type == ZEND_INTERNAL_CLASS) { + ce->info.internal.module = NULL; + ce->info.internal.builtin_functions = NULL; } - } else if (op1->op_type == IS_CONST) { - zval_dtor(&op1->u.constant); } } /* }}} */ -int zend_do_verify_access_types(const znode *current_access_type, const znode *new_modifier) /* {{{ */ +ZEND_API zend_string *zend_get_compiled_variable_name(const zend_op_array *op_array, uint32_t var) /* {{{ */ { - if ((Z_LVAL(current_access_type->u.constant) & ZEND_ACC_PPP_MASK) - && (Z_LVAL(new_modifier->u.constant) & ZEND_ACC_PPP_MASK)) { - zend_error_noreturn(E_COMPILE_ERROR, "Multiple access type modifiers are not allowed"); - } - if ((Z_LVAL(current_access_type->u.constant) & ZEND_ACC_ABSTRACT) - && (Z_LVAL(new_modifier->u.constant) & ZEND_ACC_ABSTRACT)) { - zend_error_noreturn(E_COMPILE_ERROR, "Multiple abstract modifiers are not allowed"); - } - if ((Z_LVAL(current_access_type->u.constant) & ZEND_ACC_STATIC) - && (Z_LVAL(new_modifier->u.constant) & ZEND_ACC_STATIC)) { - zend_error_noreturn(E_COMPILE_ERROR, "Multiple static modifiers are not allowed"); - } - if ((Z_LVAL(current_access_type->u.constant) & ZEND_ACC_FINAL) - && (Z_LVAL(new_modifier->u.constant) & ZEND_ACC_FINAL)) { - zend_error_noreturn(E_COMPILE_ERROR, "Multiple final modifiers are not allowed"); - } - if (((Z_LVAL(current_access_type->u.constant) | Z_LVAL(new_modifier->u.constant)) & (ZEND_ACC_ABSTRACT | ZEND_ACC_FINAL)) == (ZEND_ACC_ABSTRACT | ZEND_ACC_FINAL)) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use the final modifier on an abstract class member"); - } - return (Z_LVAL(current_access_type->u.constant) | Z_LVAL(new_modifier->u.constant)); + return op_array->vars[EX_VAR_TO_NUM(var)]; } /* }}} */ -void zend_do_begin_function_declaration(znode *function_token, znode *function_name, int is_method, int return_reference, znode *fn_flags_znode TSRMLS_DC) /* {{{ */ +zend_ast *zend_ast_append_str(zend_ast *left_ast, zend_ast *right_ast) /* {{{ */ { - zend_op_array op_array; - char *name = Z_STRVAL(function_name->u.constant); - int name_len = Z_STRLEN(function_name->u.constant); - int function_begin_line = function_token->u.op.opline_num; - zend_uint fn_flags; - const char *lcname; - zend_bool orig_interactive; - ALLOCA_FLAG(use_heap) + zval *left_zv = zend_ast_get_zval(left_ast); + zend_string *left = Z_STR_P(left_zv); + zend_string *right = zend_ast_get_str(right_ast); - if (is_method) { - if (CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE) { - if ((Z_LVAL(fn_flags_znode->u.constant) & ~(ZEND_ACC_STATIC|ZEND_ACC_PUBLIC))) { - zend_error_noreturn(E_COMPILE_ERROR, "Access type for interface method %s::%s() must be omitted", CG(active_class_entry)->name, Z_STRVAL(function_name->u.constant)); - } - Z_LVAL(fn_flags_znode->u.constant) |= ZEND_ACC_ABSTRACT; /* propagates to the rest of the parser */ - } - fn_flags = Z_LVAL(fn_flags_znode->u.constant); /* must be done *after* the above check */ - } else { - fn_flags = 0; - } - if ((fn_flags & ZEND_ACC_STATIC) && (fn_flags & ZEND_ACC_ABSTRACT) && !(CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE)) { - zend_error(E_STRICT, "Static function %s%s%s() should not be abstract", is_method ? CG(active_class_entry)->name : "", is_method ? "::" : "", Z_STRVAL(function_name->u.constant)); - } + zend_string *result; + size_t left_len = ZSTR_LEN(left); + size_t len = left_len + ZSTR_LEN(right) + 1; /* left\right */ - function_token->u.op_array = CG(active_op_array); + result = zend_string_extend(left, len, 0); + ZSTR_VAL(result)[left_len] = '\\'; + memcpy(&ZSTR_VAL(result)[left_len + 1], ZSTR_VAL(right), ZSTR_LEN(right)); + ZSTR_VAL(result)[len] = '\0'; + zend_string_release(right); - orig_interactive = CG(interactive); - CG(interactive) = 0; - init_op_array(&op_array, ZEND_USER_FUNCTION, INITIAL_OP_ARRAY_SIZE TSRMLS_CC); - CG(interactive) = orig_interactive; + ZVAL_STR(left_zv, result); + return left_ast; +} +/* }}} */ - op_array.function_name = name; - if (return_reference) { - op_array.fn_flags |= ZEND_ACC_RETURN_REFERENCE; +/* A hacky way that is used to store the doc comment for properties */ +zend_ast *zend_ast_append_doc_comment(zend_ast *list) /* {{{ */ +{ + if (CG(doc_comment)) { + list = zend_ast_list_add(list, zend_ast_create_zval_from_str(CG(doc_comment))); + CG(doc_comment) = NULL; } - op_array.fn_flags |= fn_flags; - op_array.scope = is_method?CG(active_class_entry):NULL; - op_array.prototype = NULL; - - op_array.line_start = zend_get_compiled_lineno(TSRMLS_C); - - if (is_method) { - zend_ulong hash; + return list; +} +/* }}} */ - lcname = zend_new_interned_string(zend_str_tolower_dup(name, name_len), name_len + 1, 1 TSRMLS_CC); - hash = str_hash(lcname, name_len); - if (zend_hash_quick_add(&CG(active_class_entry)->function_table, lcname, name_len+1, hash, &op_array, sizeof(zend_op_array), (void **) &CG(active_op_array)) == FAILURE) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare %s::%s()", CG(active_class_entry)->name, name); - } +void zend_verify_namespace(void) /* {{{ */ +{ + if (FC(has_bracketed_namespaces) && !FC(in_namespace)) { + zend_error_noreturn(E_COMPILE_ERROR, "No code may exist outside of namespace {}"); + } +} +/* }}} */ - zend_stack_push(&CG(context_stack), (void *) &CG(context), sizeof(CG(context))); - zend_init_compiler_context(TSRMLS_C); +/* {{{ zend_dirname + Returns directory name component of path */ +ZEND_API size_t zend_dirname(char *path, size_t len) +{ + register char *end = path + len - 1; + unsigned int len_adjust = 0; - if (fn_flags & ZEND_ACC_ABSTRACT) { - CG(active_class_entry)->ce_flags |= ZEND_ACC_IMPLICIT_ABSTRACT_CLASS; +#ifdef ZEND_WIN32 + /* Note that on Win32 CWD is per drive (heritage from CP/M). + * This means dirname("c:foo") maps to "c:." or "c:" - which means CWD on C: drive. + */ + if ((2 <= len) && isalpha((int)((unsigned char *)path)[0]) && (':' == path[1])) { + /* Skip over the drive spec (if any) so as not to change */ + path += 2; + len_adjust += 2; + if (2 == len) { + /* Return "c:" on Win32 for dirname("c:"). + * It would be more consistent to return "c:." + * but that would require making the string *longer*. + */ + return len; } - - if (!(fn_flags & ZEND_ACC_PPP_MASK)) { - fn_flags |= ZEND_ACC_PUBLIC; + } +#elif defined(NETWARE) + /* + * Find the first occurrence of : from the left + * move the path pointer to the position just after : + * increment the len_adjust to the length of path till colon character(inclusive) + * If there is no character beyond : simple return len + */ + char *colonpos = NULL; + colonpos = strchr(path, ':'); + if (colonpos != NULL) { + len_adjust = ((colonpos - path) + 1); + path += len_adjust; + if (len_adjust == len) { + return len; } + } +#endif - if (CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE) { - if ((name_len == sizeof(ZEND_CALL_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_CALL_FUNC_NAME, sizeof(ZEND_CALL_FUNC_NAME)-1))) { - if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) { - zend_error(E_WARNING, "The magic method __call() must have public visibility and cannot be static"); - } - } else if ((name_len == sizeof(ZEND_CALLSTATIC_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_CALLSTATIC_FUNC_NAME, sizeof(ZEND_CALLSTATIC_FUNC_NAME)-1))) { - if ((fn_flags & (ZEND_ACC_PPP_MASK ^ ZEND_ACC_PUBLIC)) || (fn_flags & ZEND_ACC_STATIC) == 0) { - zend_error(E_WARNING, "The magic method __callStatic() must have public visibility and be static"); - } - } else if ((name_len == sizeof(ZEND_GET_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_GET_FUNC_NAME, sizeof(ZEND_GET_FUNC_NAME)-1))) { - if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) { - zend_error(E_WARNING, "The magic method __get() must have public visibility and cannot be static"); - } - } else if ((name_len == sizeof(ZEND_SET_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_SET_FUNC_NAME, sizeof(ZEND_SET_FUNC_NAME)-1))) { - if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) { - zend_error(E_WARNING, "The magic method __set() must have public visibility and cannot be static"); - } - } else if ((name_len == sizeof(ZEND_UNSET_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_UNSET_FUNC_NAME, sizeof(ZEND_UNSET_FUNC_NAME)-1))) { - if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) { - zend_error(E_WARNING, "The magic method __unset() must have public visibility and cannot be static"); - } - } else if ((name_len == sizeof(ZEND_ISSET_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_ISSET_FUNC_NAME, sizeof(ZEND_ISSET_FUNC_NAME)-1))) { - if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) { - zend_error(E_WARNING, "The magic method __isset() must have public visibility and cannot be static"); - } - } else if ((name_len == sizeof(ZEND_TOSTRING_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_TOSTRING_FUNC_NAME, sizeof(ZEND_TOSTRING_FUNC_NAME)-1))) { - if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) { - zend_error(E_WARNING, "The magic method __toString() must have public visibility and cannot be static"); - } - } else if ((name_len == sizeof(ZEND_INVOKE_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1))) { - if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) { - zend_error(E_WARNING, "The magic method __invoke() must have public visibility and cannot be static"); - } - - } else if ((name_len == sizeof(ZEND_DEBUGINFO_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_DEBUGINFO_FUNC_NAME, sizeof(ZEND_DEBUGINFO_FUNC_NAME)-1))) { - if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) { - zend_error(E_WARNING, "The magic method __debugInfo() must have public visibility and cannot be static"); - } - } - } else { - char *class_lcname; - - class_lcname = do_alloca(CG(active_class_entry)->name_length + 1, use_heap); - zend_str_tolower_copy(class_lcname, CG(active_class_entry)->name, CG(active_class_entry)->name_length); - /* Improve after RC: cache the lowercase class name */ + if (len == 0) { + /* Illegal use of this function */ + return 0; + } - if ((CG(active_class_entry)->name_length == name_len) && ((CG(active_class_entry)->ce_flags & ZEND_ACC_TRAIT) != ZEND_ACC_TRAIT) && (!memcmp(class_lcname, lcname, name_len))) { - if (!CG(active_class_entry)->constructor) { - CG(active_class_entry)->constructor = (zend_function *) CG(active_op_array); - } - } else if ((name_len == sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_CONSTRUCTOR_FUNC_NAME, sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)))) { - if (CG(active_class_entry)->constructor) { - zend_error(E_STRICT, "Redefining already defined constructor for class %s", CG(active_class_entry)->name); - } - CG(active_class_entry)->constructor = (zend_function *) CG(active_op_array); - } else if ((name_len == sizeof(ZEND_DESTRUCTOR_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_DESTRUCTOR_FUNC_NAME, sizeof(ZEND_DESTRUCTOR_FUNC_NAME)-1))) { - CG(active_class_entry)->destructor = (zend_function *) CG(active_op_array); - } else if ((name_len == sizeof(ZEND_CLONE_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_CLONE_FUNC_NAME, sizeof(ZEND_CLONE_FUNC_NAME)-1))) { - CG(active_class_entry)->clone = (zend_function *) CG(active_op_array); - } else if ((name_len == sizeof(ZEND_CALL_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_CALL_FUNC_NAME, sizeof(ZEND_CALL_FUNC_NAME)-1))) { - if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) { - zend_error(E_WARNING, "The magic method __call() must have public visibility and cannot be static"); - } - CG(active_class_entry)->__call = (zend_function *) CG(active_op_array); - } else if ((name_len == sizeof(ZEND_CALLSTATIC_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_CALLSTATIC_FUNC_NAME, sizeof(ZEND_CALLSTATIC_FUNC_NAME)-1))) { - if ((fn_flags & (ZEND_ACC_PPP_MASK ^ ZEND_ACC_PUBLIC)) || (fn_flags & ZEND_ACC_STATIC) == 0) { - zend_error(E_WARNING, "The magic method __callStatic() must have public visibility and be static"); - } - CG(active_class_entry)->__callstatic = (zend_function *) CG(active_op_array); - } else if ((name_len == sizeof(ZEND_GET_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_GET_FUNC_NAME, sizeof(ZEND_GET_FUNC_NAME)-1))) { - if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) { - zend_error(E_WARNING, "The magic method __get() must have public visibility and cannot be static"); - } - CG(active_class_entry)->__get = (zend_function *) CG(active_op_array); - } else if ((name_len == sizeof(ZEND_SET_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_SET_FUNC_NAME, sizeof(ZEND_SET_FUNC_NAME)-1))) { - if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) { - zend_error(E_WARNING, "The magic method __set() must have public visibility and cannot be static"); - } - CG(active_class_entry)->__set = (zend_function *) CG(active_op_array); - } else if ((name_len == sizeof(ZEND_UNSET_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_UNSET_FUNC_NAME, sizeof(ZEND_UNSET_FUNC_NAME)-1))) { - if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) { - zend_error(E_WARNING, "The magic method __unset() must have public visibility and cannot be static"); - } - CG(active_class_entry)->__unset = (zend_function *) CG(active_op_array); - } else if ((name_len == sizeof(ZEND_ISSET_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_ISSET_FUNC_NAME, sizeof(ZEND_ISSET_FUNC_NAME)-1))) { - if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) { - zend_error(E_WARNING, "The magic method __isset() must have public visibility and cannot be static"); - } - CG(active_class_entry)->__isset = (zend_function *) CG(active_op_array); - } else if ((name_len == sizeof(ZEND_TOSTRING_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_TOSTRING_FUNC_NAME, sizeof(ZEND_TOSTRING_FUNC_NAME)-1))) { - if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) { - zend_error(E_WARNING, "The magic method __toString() must have public visibility and cannot be static"); - } - CG(active_class_entry)->__tostring = (zend_function *) CG(active_op_array); - } else if ((name_len == sizeof(ZEND_INVOKE_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1))) { - if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) { - zend_error(E_WARNING, "The magic method __invoke() must have public visibility and cannot be static"); - } - } else if ((name_len == sizeof(ZEND_DEBUGINFO_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_DEBUGINFO_FUNC_NAME, sizeof(ZEND_DEBUGINFO_FUNC_NAME)-1))) { - if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) { - zend_error(E_WARNING, "The magic method __debugInfo() must have public visibility and cannot be static"); - } - CG(active_class_entry)->__debugInfo = (zend_function *) CG(active_op_array); - } else if (!(fn_flags & ZEND_ACC_STATIC)) { - CG(active_op_array)->fn_flags |= ZEND_ACC_ALLOW_STATIC; - } - free_alloca(class_lcname, use_heap); - } + /* Strip trailing slashes */ + while (end >= path && IS_SLASH_P(end)) { + end--; + } + if (end < path) { + /* The path only contained slashes */ + path[0] = DEFAULT_SLASH; + path[1] = '\0'; + return 1 + len_adjust; + } - str_efree(lcname); - } else { - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - zval key; - zval **ns_name; - - if (CG(current_namespace)) { - /* Prefix function name with current namespace name */ - znode tmp; - - tmp.u.constant = *CG(current_namespace); - zval_copy_ctor(&tmp.u.constant); - zend_do_build_namespace_name(&tmp, &tmp, function_name TSRMLS_CC); - op_array.function_name = Z_STRVAL(tmp.u.constant); - name_len = Z_STRLEN(tmp.u.constant); - lcname = zend_str_tolower_dup(Z_STRVAL(tmp.u.constant), name_len); + /* Strip filename */ + while (end >= path && !IS_SLASH_P(end)) { + end--; + } + if (end < path) { + /* No slash found, therefore return '.' */ +#ifdef NETWARE + if (len_adjust == 0) { + path[0] = '.'; + path[1] = '\0'; + return 1; /* only one character */ } else { - lcname = zend_str_tolower_dup(name, name_len); - } - - /* Function name must not conflict with import names */ - if (CG(current_import_function) && - zend_hash_find(CG(current_import_function), lcname, Z_STRLEN(function_name->u.constant)+1, (void**)&ns_name) == SUCCESS) { - - char *tmp = zend_str_tolower_dup(Z_STRVAL_PP(ns_name), Z_STRLEN_PP(ns_name)); - - if (Z_STRLEN_PP(ns_name) != Z_STRLEN(function_name->u.constant) || - memcmp(tmp, lcname, Z_STRLEN(function_name->u.constant))) { - zend_error(E_COMPILE_ERROR, "Cannot declare function %s because the name is already in use", Z_STRVAL(function_name->u.constant)); - } - efree(tmp); + path[0] = '\0'; + return len_adjust; } - - opline->opcode = ZEND_DECLARE_FUNCTION; - opline->op1_type = IS_CONST; - build_runtime_defined_function_key(&key, lcname, name_len TSRMLS_CC); - opline->op1.constant = zend_add_literal(CG(active_op_array), &key TSRMLS_CC); - Z_HASH_P(&CONSTANT(opline->op1.constant)) = zend_hash_func(Z_STRVAL(CONSTANT(opline->op1.constant)), Z_STRLEN(CONSTANT(opline->op1.constant))); - opline->op2_type = IS_CONST; - LITERAL_STRINGL(opline->op2, lcname, name_len, 1); - CALCULATE_LITERAL_HASH(opline->op2.constant); - opline->extended_value = ZEND_DECLARE_FUNCTION; - zend_hash_quick_update(CG(function_table), Z_STRVAL(key), Z_STRLEN(key), Z_HASH_P(&CONSTANT(opline->op1.constant)), &op_array, sizeof(zend_op_array), (void **) &CG(active_op_array)); - zend_stack_push(&CG(context_stack), (void *) &CG(context), sizeof(CG(context))); - zend_init_compiler_context(TSRMLS_C); - str_efree(lcname); - } - - if (CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO) { - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - opline->opcode = ZEND_EXT_NOP; - opline->lineno = function_begin_line; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); +#else + path[0] = '.'; + path[1] = '\0'; + return 1 + len_adjust; +#endif } - { - /* Push a separator to the switch stack */ - zend_switch_entry switch_entry; - - switch_entry.cond.op_type = IS_UNUSED; - switch_entry.default_case = 0; - switch_entry.control_var = 0; - - zend_stack_push(&CG(switch_cond_stack), (void *) &switch_entry, sizeof(switch_entry)); + /* Strip slashes which came before the file name */ + while (end >= path && IS_SLASH_P(end)) { + end--; } - - { - /* Push a separator to the foreach stack */ - zend_op dummy_opline; - - dummy_opline.result_type = IS_UNUSED; - - zend_stack_push(&CG(foreach_copy_stack), (void *) &dummy_opline, sizeof(zend_op)); + if (end < path) { + path[0] = DEFAULT_SLASH; + path[1] = '\0'; + return 1 + len_adjust; } + *(end+1) = '\0'; - if (CG(doc_comment)) { - CG(active_op_array)->doc_comment = CG(doc_comment); - CG(active_op_array)->doc_comment_len = CG(doc_comment_len); - CG(doc_comment) = NULL; - CG(doc_comment_len) = 0; - } + return (size_t)(end + 1 - path) + len_adjust; } /* }}} */ -void zend_do_begin_lambda_function_declaration(znode *result, znode *function_token, int return_reference, int is_static TSRMLS_DC) /* {{{ */ +static void zend_adjust_for_fetch_type(zend_op *opline, uint32_t type) /* {{{ */ { - znode function_name; - zend_op_array *current_op_array = CG(active_op_array); - int current_op_number = get_next_op_number(CG(active_op_array)); - zend_op *current_op; - - function_name.op_type = IS_CONST; - ZVAL_STRINGL(&function_name.u.constant, "{closure}", sizeof("{closure}")-1, 1); - - zend_do_begin_function_declaration(function_token, &function_name, 0, return_reference, NULL TSRMLS_CC); - - result->op_type = IS_TMP_VAR; - result->u.op.var = get_temporary_variable(current_op_array); - - current_op = ¤t_op_array->opcodes[current_op_number]; - current_op->opcode = ZEND_DECLARE_LAMBDA_FUNCTION; - zend_del_literal(current_op_array, current_op->op2.constant); - SET_UNUSED(current_op->op2); - SET_NODE(current_op->result, result); - if (is_static) { - CG(active_op_array)->fn_flags |= ZEND_ACC_STATIC; + switch (type & BP_VAR_MASK) { + case BP_VAR_R: + return; + case BP_VAR_W: + case BP_VAR_REF: + opline->opcode += 3; + return; + case BP_VAR_RW: + opline->opcode += 6; + return; + case BP_VAR_IS: + opline->opcode += 9; + return; + case BP_VAR_FUNC_ARG: + opline->opcode += 12; + opline->extended_value |= type >> BP_VAR_SHIFT; + return; + case BP_VAR_UNSET: + opline->opcode += 15; + return; + EMPTY_SWITCH_DEFAULT_CASE() } - CG(active_op_array)->fn_flags |= ZEND_ACC_CLOSURE; } /* }}} */ -void zend_do_handle_exception(TSRMLS_D) /* {{{ */ +static inline void zend_make_var_result(znode *result, zend_op *opline) /* {{{ */ { - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - opline->opcode = ZEND_HANDLE_EXCEPTION; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); + opline->result_type = IS_VAR; + opline->result.var = get_temporary_variable(CG(active_op_array)); + GET_NODE(result, opline->result); } /* }}} */ -void zend_do_end_function_declaration(const znode *function_token TSRMLS_DC) /* {{{ */ +static inline void zend_make_tmp_result(znode *result, zend_op *opline) /* {{{ */ { - char lcname[16]; - int name_len; - - zend_do_extended_info(TSRMLS_C); - zend_do_return(NULL, 0 TSRMLS_CC); + opline->result_type = IS_TMP_VAR; + opline->result.var = get_temporary_variable(CG(active_op_array)); + GET_NODE(result, opline->result); +} +/* }}} */ - pass_two(CG(active_op_array) TSRMLS_CC); - zend_release_labels(0 TSRMLS_CC); +static zend_op *zend_emit_op(znode *result, zend_uchar opcode, znode *op1, znode *op2) /* {{{ */ +{ + zend_op *opline = get_next_op(CG(active_op_array)); + opline->opcode = opcode; - if (CG(active_class_entry)) { - zend_check_magic_method_implementation(CG(active_class_entry), (zend_function*)CG(active_op_array), E_COMPILE_ERROR TSRMLS_CC); + if (op1 == NULL) { + SET_UNUSED(opline->op1); } else { - /* we don't care if the function name is longer, in fact lowercasing only - * the beginning of the name speeds up the check process */ - name_len = strlen(CG(active_op_array)->function_name); - zend_str_tolower_copy(lcname, CG(active_op_array)->function_name, MIN(name_len, sizeof(lcname)-1)); - lcname[sizeof(lcname)-1] = '\0'; /* zend_str_tolower_copy won't necessarily set the zero byte */ - if (name_len == sizeof(ZEND_AUTOLOAD_FUNC_NAME) - 1 && !memcmp(lcname, ZEND_AUTOLOAD_FUNC_NAME, sizeof(ZEND_AUTOLOAD_FUNC_NAME)) && CG(active_op_array)->num_args != 1) { - zend_error_noreturn(E_COMPILE_ERROR, "%s() must take exactly 1 argument", ZEND_AUTOLOAD_FUNC_NAME); - } + SET_NODE(opline->op1, op1); } - CG(active_op_array)->line_end = zend_get_compiled_lineno(TSRMLS_C); - CG(active_op_array) = function_token->u.op_array; - + if (op2 == NULL) { + SET_UNUSED(opline->op2); + } else { + SET_NODE(opline->op2, op2); + } - /* Pop the switch and foreach separators */ - zend_stack_del_top(&CG(switch_cond_stack)); - zend_stack_del_top(&CG(foreach_copy_stack)); + if (result) { + zend_make_var_result(result, opline); + } + return opline; } /* }}} */ -void zend_do_receive_param(zend_uchar op, znode *varname, const znode *initialization, znode *class_type, zend_uchar pass_by_reference, zend_bool is_variadic TSRMLS_DC) /* {{{ */ +static zend_op *zend_emit_op_tmp(znode *result, zend_uchar opcode, znode *op1, znode *op2) /* {{{ */ { - zend_op *opline; - zend_arg_info *cur_arg_info; - znode var; + zend_op *opline = get_next_op(CG(active_op_array)); + opline->opcode = opcode; - if (zend_is_auto_global(Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant) TSRMLS_CC)) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign auto-global variable %s", Z_STRVAL(varname->u.constant)); + if (op1 == NULL) { + SET_UNUSED(opline->op1); } else { - var.op_type = IS_CV; - var.u.op.var = lookup_cv(CG(active_op_array), Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant), 0 TSRMLS_CC); - Z_STRVAL(varname->u.constant) = (char*)CG(active_op_array)->vars[var.u.op.var].name; - var.EA = 0; - if (CG(active_op_array)->vars[var.u.op.var].hash_value == THIS_HASHVAL && - Z_STRLEN(varname->u.constant) == sizeof("this")-1 && - !memcmp(Z_STRVAL(varname->u.constant), "this", sizeof("this")-1)) { - if (CG(active_op_array)->scope && - (CG(active_op_array)->fn_flags & ZEND_ACC_STATIC) == 0) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this"); - } - CG(active_op_array)->this_var = var.u.op.var; - } + SET_NODE(opline->op1, op1); } - if (CG(active_op_array)->fn_flags & ZEND_ACC_VARIADIC) { - zend_error_noreturn(E_COMPILE_ERROR, "Only the last parameter can be variadic"); + if (op2 == NULL) { + SET_UNUSED(opline->op2); + } else { + SET_NODE(opline->op2, op2); } - if (is_variadic) { - if (op == ZEND_RECV_INIT) { - zend_error_noreturn(E_COMPILE_ERROR, "Variadic parameter cannot have a default value"); - } - - op = ZEND_RECV_VARIADIC; - CG(active_op_array)->fn_flags |= ZEND_ACC_VARIADIC; + if (result) { + zend_make_tmp_result(result, opline); } - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - CG(active_op_array)->num_args++; - opline->opcode = op; - SET_NODE(opline->result, &var); - opline->op1_type = IS_UNUSED; - opline->op1.num = CG(active_op_array)->num_args; - if (op == ZEND_RECV_INIT) { - SET_NODE(opline->op2, initialization); - } else { - SET_UNUSED(opline->op2); - if (!is_variadic) { - CG(active_op_array)->required_num_args = CG(active_op_array)->num_args; - } - } - CG(active_op_array)->arg_info = erealloc(CG(active_op_array)->arg_info, sizeof(zend_arg_info)*(CG(active_op_array)->num_args)); - cur_arg_info = &CG(active_op_array)->arg_info[CG(active_op_array)->num_args-1]; - cur_arg_info->name = zend_new_interned_string(estrndup(Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant)), Z_STRLEN(varname->u.constant) + 1, 1 TSRMLS_CC); - cur_arg_info->name_len = Z_STRLEN(varname->u.constant); - cur_arg_info->type_hint = 0; - cur_arg_info->pass_by_reference = pass_by_reference; - cur_arg_info->allow_null = 1; - cur_arg_info->is_variadic = is_variadic; - cur_arg_info->class_name = NULL; - cur_arg_info->class_name_len = 0; - - if (class_type->op_type != IS_UNUSED) { - cur_arg_info->allow_null = 0; - - if (class_type->u.constant.type != IS_NULL) { - if (class_type->u.constant.type == IS_ARRAY) { - cur_arg_info->type_hint = IS_ARRAY; - if (op == ZEND_RECV_INIT) { - if (Z_TYPE(initialization->u.constant) == IS_NULL || (Z_TYPE(initialization->u.constant) == IS_CONSTANT && !strcasecmp(Z_STRVAL(initialization->u.constant), "NULL"))) { - cur_arg_info->allow_null = 1; - } else if (IS_CONSTANT_TYPE(Z_TYPE(initialization->u.constant))) { - /* delay constant resolution and check to run-time */ - cur_arg_info->allow_null = 0; - } else if (Z_TYPE(initialization->u.constant) != IS_ARRAY) { - zend_error_noreturn(E_COMPILE_ERROR, "Default value for parameters with array type hint can only be an array or NULL"); - } - } - } else if (class_type->u.constant.type == IS_CALLABLE) { - cur_arg_info->type_hint = IS_CALLABLE; - if (op == ZEND_RECV_INIT) { - if (Z_TYPE(initialization->u.constant) == IS_NULL || (Z_TYPE(initialization->u.constant) == IS_CONSTANT && !strcasecmp(Z_STRVAL(initialization->u.constant), "NULL"))) { - cur_arg_info->allow_null = 1; - } else if (IS_CONSTANT_TYPE(Z_TYPE(initialization->u.constant))) { - /* delay constant resolution and check to run-time */ - cur_arg_info->allow_null = 0; - } else { - zend_error_noreturn(E_COMPILE_ERROR, "Default value for parameters with callable type hint can only be NULL"); - } - } - } else { - cur_arg_info->type_hint = IS_OBJECT; - if (ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(class_type->u.constant), Z_STRLEN(class_type->u.constant))) { - zend_resolve_class_name(class_type TSRMLS_CC); - } - Z_STRVAL(class_type->u.constant) = (char*)zend_new_interned_string(Z_STRVAL(class_type->u.constant), Z_STRLEN(class_type->u.constant) + 1, 1 TSRMLS_CC); - cur_arg_info->class_name = Z_STRVAL(class_type->u.constant); - cur_arg_info->class_name_len = Z_STRLEN(class_type->u.constant); - if (op == ZEND_RECV_INIT) { - if (Z_TYPE(initialization->u.constant) == IS_NULL || (Z_TYPE(initialization->u.constant) == IS_CONSTANT && !strcasecmp(Z_STRVAL(initialization->u.constant), "NULL"))) { - cur_arg_info->allow_null = 1; - } else if (IS_CONSTANT_TYPE(Z_TYPE(initialization->u.constant))) { - /* delay constant resolution and check to run-time */ - cur_arg_info->allow_null = 0; - } else { - zend_error_noreturn(E_COMPILE_ERROR, "Default value for parameters with a class type hint can only be NULL"); - } - } - } - } - } + return opline; } /* }}} */ -int zend_do_begin_function_call(znode *function_name, zend_bool check_namespace TSRMLS_DC) /* {{{ */ +static void zend_emit_tick(void) /* {{{ */ { - zend_function *function; - char *lcname; - char *is_compound = memchr(Z_STRVAL(function_name->u.constant), '\\', Z_STRLEN(function_name->u.constant)); + /* This prevents a double TICK generated by the parser statement of "declare()" */ + if (CG(active_op_array)->last && CG(active_op_array)->opcodes[CG(active_op_array)->last - 1].opcode == ZEND_TICKS) { + return; + } + + zend_op *opline = get_next_op(CG(active_op_array)); - zend_resolve_function_name(function_name, &check_namespace TSRMLS_CC); + opline->opcode = ZEND_TICKS; + SET_UNUSED(opline->op1); + SET_UNUSED(opline->op2); + opline->extended_value = FC(declarables).ticks; +} +/* }}} */ - if (check_namespace && CG(current_namespace) && !is_compound) { - /* We assume we call function from the current namespace - if it is not prefixed. */ +static inline zend_op *zend_emit_op_data(znode *value) /* {{{ */ +{ + return zend_emit_op(NULL, ZEND_OP_DATA, value, NULL); +} +/* }}} */ - /* In run-time PHP will check for function with full name and - internal function with short name */ - zend_do_begin_dynamic_function_call(function_name, 1 TSRMLS_CC); - return 1; - } +static inline uint32_t zend_emit_jump(uint32_t opnum_target) /* {{{ */ +{ + uint32_t opnum = get_next_op_number(CG(active_op_array)); + zend_op *opline = zend_emit_op(NULL, ZEND_JMP, NULL, NULL); + opline->op1.opline_num = opnum_target; + return opnum; +} +/* }}} */ - lcname = zend_str_tolower_dup(Z_STRVAL(function_name->u.constant), Z_STRLEN(function_name->u.constant)); - if ((zend_hash_find(CG(function_table), lcname, Z_STRLEN(function_name->u.constant)+1, (void **) &function)==FAILURE) || - ((CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_FUNCTIONS) && - (function->type == ZEND_INTERNAL_FUNCTION))) { - zend_do_begin_dynamic_function_call(function_name, 0 TSRMLS_CC); - efree(lcname); - return 1; /* Dynamic */ - } - efree(Z_STRVAL(function_name->u.constant)); - Z_STRVAL(function_name->u.constant) = lcname; +static inline uint32_t zend_emit_cond_jump(zend_uchar opcode, znode *cond, uint32_t opnum_target) /* {{{ */ +{ + uint32_t opnum = get_next_op_number(CG(active_op_array)); + zend_op *opline = zend_emit_op(NULL, opcode, cond, NULL); + opline->op2.opline_num = opnum_target; + return opnum; +} +/* }}} */ - zend_push_function_call_entry(function TSRMLS_CC); - if (CG(context).nested_calls + 1 > CG(active_op_array)->nested_calls) { - CG(active_op_array)->nested_calls = CG(context).nested_calls + 1; +static inline void zend_update_jump_target(uint32_t opnum_jump, uint32_t opnum_target) /* {{{ */ +{ + zend_op *opline = &CG(active_op_array)->opcodes[opnum_jump]; + switch (opline->opcode) { + case ZEND_JMP: + opline->op1.opline_num = opnum_target; + break; + case ZEND_JMPZ: + case ZEND_JMPNZ: + case ZEND_JMPZ_EX: + case ZEND_JMPNZ_EX: + case ZEND_JMP_SET: + opline->op2.opline_num = opnum_target; + break; + EMPTY_SWITCH_DEFAULT_CASE() } - zend_do_extended_fcall_begin(TSRMLS_C); - return 0; } /* }}} */ -void zend_do_begin_method_call(znode *left_bracket TSRMLS_DC) /* {{{ */ +static inline void zend_update_jump_target_to_next(uint32_t opnum_jump) /* {{{ */ { - zend_op *last_op; - int last_op_number; - - zend_do_end_variable_parse(left_bracket, BP_VAR_R, 0 TSRMLS_CC); - zend_do_begin_variable_parse(TSRMLS_C); - - last_op_number = get_next_op_number(CG(active_op_array))-1; - last_op = &CG(active_op_array)->opcodes[last_op_number]; + zend_update_jump_target(opnum_jump, get_next_op_number(CG(active_op_array))); +} +/* }}} */ - if ((last_op->op2_type == IS_CONST) && (Z_TYPE(CONSTANT(last_op->op2.constant)) == IS_STRING) && (Z_STRLEN(CONSTANT(last_op->op2.constant)) == sizeof(ZEND_CLONE_FUNC_NAME)-1) - && !zend_binary_strcasecmp(Z_STRVAL(CONSTANT(last_op->op2.constant)), Z_STRLEN(CONSTANT(last_op->op2.constant)), ZEND_CLONE_FUNC_NAME, sizeof(ZEND_CLONE_FUNC_NAME)-1)) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot call __clone() method on objects - use 'clone $obj' instead"); +static inline zend_op *zend_delayed_emit_op(znode *result, zend_uchar opcode, znode *op1, znode *op2) /* {{{ */ +{ + zend_op tmp_opline; + init_op(&tmp_opline); + tmp_opline.opcode = opcode; + if (op1 == NULL) { + SET_UNUSED(tmp_opline.op1); + } else { + SET_NODE(tmp_opline.op1, op1); } - - if (last_op->opcode == ZEND_FETCH_OBJ_R) { - if (last_op->op2_type == IS_CONST) { - zval name; - name = CONSTANT(last_op->op2.constant); - if (Z_TYPE(name) != IS_STRING) { - zend_error_noreturn(E_COMPILE_ERROR, "Method name must be a string"); - } - Z_STRVAL(name) = str_estrndup(Z_STRVAL(name), Z_STRLEN(name)); - FREE_POLYMORPHIC_CACHE_SLOT(last_op->op2.constant); - last_op->op2.constant = - zend_add_func_name_literal(CG(active_op_array), &name TSRMLS_CC); - GET_POLYMORPHIC_CACHE_SLOT(last_op->op2.constant); - } - last_op->opcode = ZEND_INIT_METHOD_CALL; - last_op->result_type = IS_UNUSED; - last_op->result.num = CG(context).nested_calls; - Z_LVAL(left_bracket->u.constant) = ZEND_INIT_FCALL_BY_NAME; + if (op2 == NULL) { + SET_UNUSED(tmp_opline.op2); } else { - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_INIT_FCALL_BY_NAME; - opline->result.num = CG(context).nested_calls; - SET_UNUSED(opline->op1); - if (left_bracket->op_type == IS_CONST) { - opline->op2_type = IS_CONST; - opline->op2.constant = zend_add_func_name_literal(CG(active_op_array), &left_bracket->u.constant TSRMLS_CC); - GET_CACHE_SLOT(opline->op2.constant); - } else { - SET_NODE(opline->op2, left_bracket); - } + SET_NODE(tmp_opline.op2, op2); } - - zend_push_function_call_entry(NULL TSRMLS_CC); - if (++CG(context).nested_calls > CG(active_op_array)->nested_calls) { - CG(active_op_array)->nested_calls = CG(context).nested_calls; + if (result) { + zend_make_var_result(result, &tmp_opline); } - zend_do_extended_fcall_begin(TSRMLS_C); + + zend_stack_push(&CG(delayed_oplines_stack), &tmp_opline); + return zend_stack_top(&CG(delayed_oplines_stack)); } /* }}} */ -void zend_do_clone(znode *result, const znode *expr TSRMLS_DC) /* {{{ */ +static inline uint32_t zend_delayed_compile_begin(void) /* {{{ */ { - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - opline->opcode = ZEND_CLONE; - SET_NODE(opline->op1, expr); - SET_UNUSED(opline->op2); - opline->result_type = IS_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - GET_NODE(result, opline->result); + return zend_stack_count(&CG(delayed_oplines_stack)); } /* }}} */ -void zend_do_begin_dynamic_function_call(znode *function_name, int ns_call TSRMLS_DC) /* {{{ */ +static zend_op *zend_delayed_compile_end(uint32_t offset) /* {{{ */ { - zend_op *opline; + zend_op *opline = NULL, *oplines = zend_stack_base(&CG(delayed_oplines_stack)); + uint32_t i, count = zend_stack_count(&CG(delayed_oplines_stack)); - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - if (ns_call) { - /* In run-time PHP will check for function with full name and - internal function with short name */ - opline->opcode = ZEND_INIT_NS_FCALL_BY_NAME; - opline->result.num = CG(context).nested_calls; - SET_UNUSED(opline->op1); - opline->op2_type = IS_CONST; - opline->op2.constant = zend_add_ns_func_name_literal(CG(active_op_array), &function_name->u.constant TSRMLS_CC); - GET_CACHE_SLOT(opline->op2.constant); - } else { - opline->opcode = ZEND_INIT_FCALL_BY_NAME; - opline->result.num = CG(context).nested_calls; - SET_UNUSED(opline->op1); - if (function_name->op_type == IS_CONST) { - opline->op2_type = IS_CONST; - opline->op2.constant = zend_add_func_name_literal(CG(active_op_array), &function_name->u.constant TSRMLS_CC); - GET_CACHE_SLOT(opline->op2.constant); - } else { - SET_NODE(opline->op2, function_name); - } + ZEND_ASSERT(count > offset); + for (i = offset; i < count; ++i) { + opline = get_next_op(CG(active_op_array)); + memcpy(opline, &oplines[i], sizeof(zend_op)); } + CG(delayed_oplines_stack).top = offset; + return opline; +} +/* }}} */ - zend_push_function_call_entry(NULL TSRMLS_CC); - if (++CG(context).nested_calls > CG(active_op_array)->nested_calls) { - CG(active_op_array)->nested_calls = CG(context).nested_calls; +static void zend_emit_return_type_check(znode *expr, zend_arg_info *return_info) /* {{{ */ +{ + if (return_info->type_hint != IS_UNDEF) { + zend_op *opline = zend_emit_op(NULL, ZEND_VERIFY_RETURN_TYPE, expr, NULL); + if (expr && expr->op_type == IS_CONST) { + opline->result_type = expr->op_type = IS_TMP_VAR; + opline->result.var = expr->u.op.var = get_temporary_variable(CG(active_op_array)); + } + if (return_info->class_name) { + opline->op2.num = CG(active_op_array)->cache_size; + CG(active_op_array)->cache_size += sizeof(void*); + } else { + opline->op2.num = -1; + } } - zend_do_extended_fcall_begin(TSRMLS_C); } /* }}} */ -void zend_resolve_non_class_name(znode *element_name, zend_bool *check_namespace, zend_bool case_sensitive, HashTable *current_import_sub TSRMLS_DC) /* {{{ */ +void zend_emit_final_return(zval *zv) /* {{{ */ { - znode tmp; - int len; - zval **ns; - char *lookup_name, *compound = memchr(Z_STRVAL(element_name->u.constant), '\\', Z_STRLEN(element_name->u.constant)); + znode zn; + zend_bool returns_reference = (CG(active_op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0; - if (Z_STRVAL(element_name->u.constant)[0] == '\\') { - /* name starts with \ so it is known and unambiguos, nothing to do here but shorten it */ - memmove(Z_STRVAL(element_name->u.constant), Z_STRVAL(element_name->u.constant)+1, Z_STRLEN(element_name->u.constant)); - --Z_STRLEN(element_name->u.constant); - return; + if (CG(active_op_array)->fn_flags & ZEND_ACC_HAS_RETURN_TYPE) { + zend_emit_return_type_check(NULL, CG(active_op_array)->arg_info - 1); } - if(!*check_namespace) { - return; - } - - if (current_import_sub) { - len = Z_STRLEN(element_name->u.constant)+1; - if (case_sensitive) { - lookup_name = estrndup(Z_STRVAL(element_name->u.constant), len); - } else { - lookup_name = zend_str_tolower_dup(Z_STRVAL(element_name->u.constant), len); - } - /* Check if function/const matches imported name */ - if (zend_hash_find(current_import_sub, lookup_name, len, (void**)&ns) == SUCCESS) { - zval_dtor(&element_name->u.constant); - element_name->u.constant = **ns; - zval_copy_ctor(&element_name->u.constant); - efree(lookup_name); - *check_namespace = 0; - return; - } - efree(lookup_name); - } - - if (compound && CG(current_import)) { - len = compound - Z_STRVAL(element_name->u.constant); - /* namespace is always lowercase */ - lookup_name = zend_str_tolower_dup(Z_STRVAL(element_name->u.constant), len); - /* Check if first part of compound name is an import name */ - if (zend_hash_find(CG(current_import), lookup_name, len+1, (void**)&ns) == SUCCESS) { - /* Substitute import name */ - tmp.op_type = IS_CONST; - tmp.u.constant = **ns; - zval_copy_ctor(&tmp.u.constant); - len += 1; - Z_STRLEN(element_name->u.constant) -= len; - memmove(Z_STRVAL(element_name->u.constant), Z_STRVAL(element_name->u.constant)+len, Z_STRLEN(element_name->u.constant)+1); - zend_do_build_namespace_name(&tmp, &tmp, element_name TSRMLS_CC); - *element_name = tmp; - efree(lookup_name); - *check_namespace = 0; - return; - } - efree(lookup_name); + zn.op_type = IS_CONST; + if (zv) { + ZVAL_COPY_VALUE(&zn.u.constant, zv); + } else { + ZVAL_NULL(&zn.u.constant); } - if (CG(current_namespace)) { - tmp = *element_name; - Z_STRLEN(tmp.u.constant) = sizeof("\\")-1 + Z_STRLEN(element_name->u.constant) + Z_STRLEN_P(CG(current_namespace)); - Z_STRVAL(tmp.u.constant) = (char *) emalloc(Z_STRLEN(tmp.u.constant)+1); - memcpy(Z_STRVAL(tmp.u.constant), Z_STRVAL_P(CG(current_namespace)), Z_STRLEN_P(CG(current_namespace))); - memcpy(&(Z_STRVAL(tmp.u.constant)[Z_STRLEN_P(CG(current_namespace))]), "\\", sizeof("\\")-1); - memcpy(&(Z_STRVAL(tmp.u.constant)[Z_STRLEN_P(CG(current_namespace)) + sizeof("\\")-1]), Z_STRVAL(element_name->u.constant), Z_STRLEN(element_name->u.constant)+1); - str_efree(Z_STRVAL(element_name->u.constant)); - *element_name = tmp; - } + zend_emit_op(NULL, returns_reference ? ZEND_RETURN_BY_REF : ZEND_RETURN, &zn, NULL); } /* }}} */ -void zend_resolve_function_name(znode *element_name, zend_bool *check_namespace TSRMLS_DC) /* {{{ */ +static inline zend_bool zend_is_variable(zend_ast *ast) /* {{{ */ { - zend_resolve_non_class_name(element_name, check_namespace, 0, CG(current_import_function) TSRMLS_CC); + return ast->kind == ZEND_AST_VAR || ast->kind == ZEND_AST_DIM + || ast->kind == ZEND_AST_PROP || ast->kind == ZEND_AST_STATIC_PROP + || ast->kind == ZEND_AST_CALL || ast->kind == ZEND_AST_METHOD_CALL + || ast->kind == ZEND_AST_STATIC_CALL; } /* }}} */ -void zend_resolve_const_name(znode *element_name, zend_bool *check_namespace TSRMLS_DC) /* {{{ */ +static inline zend_bool zend_is_call(zend_ast *ast) /* {{{ */ { - zend_resolve_non_class_name(element_name, check_namespace, 1, CG(current_import_const) TSRMLS_CC); + return ast->kind == ZEND_AST_CALL + || ast->kind == ZEND_AST_METHOD_CALL + || ast->kind == ZEND_AST_STATIC_CALL; } /* }}} */ -void zend_do_resolve_class_name(znode *result, znode *class_name, int is_static TSRMLS_DC) /* {{{ */ +static inline zend_bool zend_is_unticked_stmt(zend_ast *ast) /* {{{ */ { - char *lcname; - int lctype; - znode constant_name; + return ast->kind == ZEND_AST_STMT_LIST || ast->kind == ZEND_AST_LABEL; +} +/* }}} */ - lcname = zend_str_tolower_dup(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant)); - lctype = zend_get_class_fetch_type(lcname, strlen(lcname)); - switch (lctype) { - case ZEND_FETCH_CLASS_SELF: - if (!CG(active_class_entry)) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot access self::class when no class scope is active"); - } - if (CG(active_class_entry)->ce_flags & ZEND_ACC_TRAIT) { - constant_name.op_type = IS_CONST; - ZVAL_STRINGL(&constant_name.u.constant, "class", sizeof("class")-1, 1); - zend_do_fetch_constant(result, class_name, &constant_name, ZEND_RT, 1 TSRMLS_CC); - break; - } - zval_dtor(&class_name->u.constant); - class_name->op_type = IS_CONST; - ZVAL_STRINGL(&class_name->u.constant, CG(active_class_entry)->name, CG(active_class_entry)->name_length, 1); - *result = *class_name; - break; - case ZEND_FETCH_CLASS_STATIC: - case ZEND_FETCH_CLASS_PARENT: - if (is_static) { - zend_error_noreturn(E_COMPILE_ERROR, - "%s::class cannot be used for compile-time class name resolution", - lctype == ZEND_FETCH_CLASS_STATIC ? "static" : "parent" - ); - } - if (!CG(active_class_entry)) { - zend_error_noreturn(E_COMPILE_ERROR, - "Cannot access %s::class when no class scope is active", - lctype == ZEND_FETCH_CLASS_STATIC ? "static" : "parent" - ); - } - constant_name.op_type = IS_CONST; - ZVAL_STRINGL(&constant_name.u.constant, "class", sizeof("class")-1, 1); - zend_do_fetch_constant(result, class_name, &constant_name, ZEND_RT, 1 TSRMLS_CC); - break; - case ZEND_FETCH_CLASS_DEFAULT: - zend_resolve_class_name(class_name TSRMLS_CC); - *result = *class_name; - break; +static inline zend_bool zend_can_write_to_variable(zend_ast *ast) /* {{{ */ +{ + while (ast->kind == ZEND_AST_DIM || ast->kind == ZEND_AST_PROP) { + ast = ast->child[0]; } - efree(lcname); + return zend_is_variable(ast); +} +/* }}} */ +static inline zend_bool zend_is_const_default_class_ref(zend_ast *name_ast) /* {{{ */ +{ + if (name_ast->kind != ZEND_AST_ZVAL) { + return 0; + } + + return ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type_ast(name_ast); } /* }}} */ -void zend_resolve_class_name(znode *class_name TSRMLS_DC) /* {{{ */ +static inline void zend_handle_numeric_op(znode *node) /* {{{ */ { - char *compound; - char *lcname; - zval **ns; - znode tmp; - int len; + if (node->op_type == IS_CONST && Z_TYPE(node->u.constant) == IS_STRING) { + zend_ulong index; - compound = memchr(Z_STRVAL(class_name->u.constant), '\\', Z_STRLEN(class_name->u.constant)); - if (compound) { - /* This is a compound class name that contains namespace prefix */ - if (Z_STRVAL(class_name->u.constant)[0] == '\\') { - /* The STRING name has "\" prefix */ - Z_STRLEN(class_name->u.constant) -= 1; - memmove(Z_STRVAL(class_name->u.constant), Z_STRVAL(class_name->u.constant)+1, Z_STRLEN(class_name->u.constant)+1); - Z_STRVAL(class_name->u.constant) = erealloc( - Z_STRVAL(class_name->u.constant), - Z_STRLEN(class_name->u.constant) + 1); - - if (ZEND_FETCH_CLASS_DEFAULT != zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant))) { - zend_error_noreturn(E_COMPILE_ERROR, "'\\%s' is an invalid class name", Z_STRVAL(class_name->u.constant)); - } - } else { - if (CG(current_import)) { - len = compound - Z_STRVAL(class_name->u.constant); - lcname = zend_str_tolower_dup(Z_STRVAL(class_name->u.constant), len); - /* Check if first part of compound name is an import name */ - if (zend_hash_find(CG(current_import), lcname, len+1, (void**)&ns) == SUCCESS) { - /* Substitute import name */ - tmp.op_type = IS_CONST; - tmp.u.constant = **ns; - zval_copy_ctor(&tmp.u.constant); - len += 1; - Z_STRLEN(class_name->u.constant) -= len; - memmove(Z_STRVAL(class_name->u.constant), Z_STRVAL(class_name->u.constant)+len, Z_STRLEN(class_name->u.constant)+1); - zend_do_build_namespace_name(&tmp, &tmp, class_name TSRMLS_CC); - *class_name = tmp; - efree(lcname); - return; - } - efree(lcname); - } - /* Here name is not prefixed with \ and not imported */ - if (CG(current_namespace)) { - tmp.op_type = IS_CONST; - tmp.u.constant = *CG(current_namespace); - zval_copy_ctor(&tmp.u.constant); - zend_do_build_namespace_name(&tmp, &tmp, class_name TSRMLS_CC); - *class_name = tmp; - } + if (ZEND_HANDLE_NUMERIC(Z_STR(node->u.constant), index)) { + zval_ptr_dtor(&node->u.constant); + ZVAL_LONG(&node->u.constant, index); } - } else if (CG(current_import) || CG(current_namespace)) { - /* this is a plain name (without \) */ - lcname = zend_str_tolower_dup(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant)); + } +} +/* }}} */ - if (CG(current_import) && - zend_hash_find(CG(current_import), lcname, Z_STRLEN(class_name->u.constant)+1, (void**)&ns) == SUCCESS) { - /* The given name is an import name. Substitute it. */ - zval_dtor(&class_name->u.constant); - class_name->u.constant = **ns; - zval_copy_ctor(&class_name->u.constant); - } else if (CG(current_namespace)) { - /* plain name, no import - prepend current namespace to it */ - tmp.op_type = IS_CONST; - tmp.u.constant = *CG(current_namespace); - zval_copy_ctor(&tmp.u.constant); - zend_do_build_namespace_name(&tmp, &tmp, class_name TSRMLS_CC); - *class_name = tmp; - } - efree(lcname); +static inline void zend_set_class_name_op1(zend_op *opline, znode *class_node) /* {{{ */ +{ + if (class_node->op_type == IS_CONST) { + opline->op1_type = IS_CONST; + opline->op1.constant = zend_add_class_name_literal( + CG(active_op_array), Z_STR(class_node->u.constant)); + } else { + SET_NODE(opline->op1, class_node); } } /* }}} */ -void zend_do_fetch_class(znode *result, znode *class_name TSRMLS_DC) /* {{{ */ +static zend_op *zend_compile_class_ref(znode *result, zend_ast *name_ast, int throw_exception) /* {{{ */ { - long fetch_class_op_number; zend_op *opline; + znode name_node; + zend_compile_expr(&name_node, name_ast); - fetch_class_op_number = get_next_op_number(CG(active_op_array)); - opline = get_next_op(CG(active_op_array) TSRMLS_CC); + if (name_node.op_type == IS_CONST) { + zend_string *name = Z_STR(name_node.u.constant); + uint32_t fetch_type = zend_get_class_fetch_type(name); - opline->opcode = ZEND_FETCH_CLASS; - SET_UNUSED(opline->op1); - opline->extended_value = ZEND_FETCH_CLASS_DEFAULT; - CG(catch_begin) = fetch_class_op_number; - if (class_name->op_type == IS_CONST) { - int fetch_type; + opline = zend_emit_op(result, ZEND_FETCH_CLASS, NULL, NULL); + opline->extended_value = fetch_type | (throw_exception ? ZEND_FETCH_CLASS_EXCEPTION : 0); - fetch_type = zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant)); - switch (fetch_type) { - case ZEND_FETCH_CLASS_SELF: - case ZEND_FETCH_CLASS_PARENT: - case ZEND_FETCH_CLASS_STATIC: - SET_UNUSED(opline->op2); - opline->extended_value = fetch_type; - zval_dtor(&class_name->u.constant); - break; - default: - zend_resolve_class_name(class_name TSRMLS_CC); - opline->op2_type = IS_CONST; - opline->op2.constant = - zend_add_class_name_literal(CG(active_op_array), &class_name->u.constant TSRMLS_CC); - break; + if (fetch_type == ZEND_FETCH_CLASS_DEFAULT) { + uint32_t type = name_ast->kind == ZEND_AST_ZVAL ? name_ast->attr : ZEND_NAME_FQ; + opline->op2_type = IS_CONST; + opline->op2.constant = zend_add_class_name_literal(CG(active_op_array), + zend_resolve_class_name(name, type)); + } else { + zend_ensure_valid_class_fetch_type(fetch_type); } + + zend_string_release(name); } else { - SET_NODE(opline->op2, class_name); + opline = zend_emit_op(result, ZEND_FETCH_CLASS, NULL, &name_node); + opline->extended_value = ZEND_FETCH_CLASS_DEFAULT | (throw_exception ? ZEND_FETCH_CLASS_EXCEPTION : 0); } - opline->result.var = get_temporary_variable(CG(active_op_array)); - opline->result_type = IS_VAR; /* FIXME: Hack so that INIT_FCALL_BY_NAME still knows this is a class */ - GET_NODE(result, opline->result); - result->EA = opline->extended_value; + + return opline; } /* }}} */ -void zend_do_label(znode *label TSRMLS_DC) /* {{{ */ +static int zend_try_compile_cv(znode *result, zend_ast *ast) /* {{{ */ { - zend_label dest; + zend_ast *name_ast = ast->child[0]; + if (name_ast->kind == ZEND_AST_ZVAL) { + zend_string *name = zval_get_string(zend_ast_get_zval(name_ast)); - if (!CG(context).labels) { - ALLOC_HASHTABLE(CG(context).labels); - zend_hash_init(CG(context).labels, 4, NULL, NULL, 0); - } + if (zend_is_auto_global(name)) { + zend_string_release(name); + return FAILURE; + } - dest.brk_cont = CG(context).current_brk_cont; - dest.opline_num = get_next_op_number(CG(active_op_array)); + result->op_type = IS_CV; + result->u.op.var = lookup_cv(CG(active_op_array), name); + + /* lookup_cv may be using another zend_string instance */ + name = CG(active_op_array)->vars[EX_VAR_TO_NUM(result->u.op.var)]; - if (zend_hash_add(CG(context).labels, Z_STRVAL(label->u.constant), Z_STRLEN(label->u.constant) + 1, (void**)&dest, sizeof(zend_label), NULL) == FAILURE) { - zend_error_noreturn(E_COMPILE_ERROR, "Label '%s' already defined", Z_STRVAL(label->u.constant)); + if (zend_string_equals_literal(name, "this")) { + CG(active_op_array)->this_var = result->u.op.var; + } + return SUCCESS; } - /* Done with label now */ - zval_dtor(&label->u.constant); + return FAILURE; } /* }}} */ -void zend_resolve_goto_label(zend_op_array *op_array, zend_op *opline, int pass2 TSRMLS_DC) /* {{{ */ +static zend_op *zend_compile_simple_var_no_cv(znode *result, zend_ast *ast, uint32_t type, int delayed) /* {{{ */ { - zend_label *dest; - long current, distance; - zval *label; + zend_ast *name_ast = ast->child[0]; + znode name_node; + zend_op *opline; - if (pass2) { - label = opline->op2.zv; + zend_compile_expr(&name_node, name_ast); + if (name_node.op_type == IS_CONST) { + convert_to_string(&name_node.u.constant); + } + + if (delayed) { + opline = zend_delayed_emit_op(result, ZEND_FETCH_R, &name_node, NULL); } else { - label = &CONSTANT_EX(op_array, opline->op2.constant); + opline = zend_emit_op(result, ZEND_FETCH_R, &name_node, NULL); } - if (CG(context).labels == NULL || - zend_hash_find(CG(context).labels, Z_STRVAL_P(label), Z_STRLEN_P(label)+1, (void**)&dest) == FAILURE) { - if (pass2) { - CG(in_compilation) = 1; - CG(active_op_array) = op_array; - CG(zend_lineno) = opline->lineno; - zend_error_noreturn(E_COMPILE_ERROR, "'goto' to undefined label '%s'", Z_STRVAL_P(label)); - } else { - /* Label is not defined. Delay to pass 2. */ - INC_BPC(op_array); - return; + if (name_node.op_type == IS_CONST && + zend_is_auto_global(Z_STR(name_node.u.constant))) { + + opline->extended_value = ZEND_FETCH_GLOBAL; + } else { + opline->extended_value = ZEND_FETCH_LOCAL; + /* there is a chance someone is accessing $this */ + if (ast->kind != ZEND_AST_ZVAL + && CG(active_op_array)->scope && CG(active_op_array)->this_var == (uint32_t)-1 + ) { + zend_string *key = zend_string_init("this", sizeof("this") - 1, 0); + CG(active_op_array)->this_var = lookup_cv(CG(active_op_array), key); } } - opline->op1.opline_num = dest->opline_num; - zval_dtor(label); - Z_TYPE_P(label) = IS_NULL; + return opline; +} +/* }}} */ - /* Check that we are not moving into loop or switch */ - current = opline->extended_value; - for (distance = 0; current != dest->brk_cont; distance++) { - if (current == -1) { - if (pass2) { - CG(in_compilation) = 1; - CG(active_op_array) = op_array; - CG(zend_lineno) = opline->lineno; - } - zend_error_noreturn(E_COMPILE_ERROR, "'goto' into loop or switch statement is disallowed"); +static void zend_compile_simple_var(znode *result, zend_ast *ast, uint32_t type, int delayed) /* {{{ */ +{ + if (zend_try_compile_cv(result, ast) == FAILURE) { + zend_op *opline = zend_compile_simple_var_no_cv(result, ast, type, delayed); + zend_adjust_for_fetch_type(opline, type); + } +} +/* }}} */ + +static void zend_separate_if_call_and_write(znode *node, zend_ast *ast, uint32_t type) /* {{{ */ +{ + if (type != BP_VAR_R && type != BP_VAR_IS && zend_is_call(ast)) { + if (node->op_type == IS_VAR) { + zend_op *opline = zend_emit_op(NULL, ZEND_SEPARATE, node, NULL); + opline->result_type = IS_VAR; + opline->result.var = opline->op1.var; + } else { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use result of built-in function in write context"); } - current = op_array->brk_cont_array[current].parent; } +} +/* }}} */ - if (distance == 0) { - /* Nothing to break out of, optimize to ZEND_JMP */ - opline->opcode = ZEND_JMP; - opline->extended_value = 0; - SET_UNUSED(opline->op2); +void zend_delayed_compile_var(znode *result, zend_ast *ast, uint32_t type); +void zend_compile_assign(znode *result, zend_ast *ast); +static void zend_compile_list_assign(znode *result, zend_ast *ast, znode *expr_node); + +static inline void zend_emit_assign_znode(zend_ast *var_ast, znode *value_node) /* {{{ */ +{ + znode dummy_node; + if (var_ast->kind == ZEND_AST_LIST) { + zend_compile_list_assign(&dummy_node, var_ast, value_node); } else { - /* Set real break distance */ - ZVAL_LONG(label, distance); + zend_ast *assign_ast = zend_ast_create(ZEND_AST_ASSIGN, var_ast, + zend_ast_create_znode(value_node)); + zend_compile_assign(&dummy_node, assign_ast); } + zend_do_free(&dummy_node); +} +/* }}} */ - if (pass2) { - DEC_BPC(op_array); +static zend_op *zend_delayed_compile_dim(znode *result, zend_ast *ast, uint32_t type) /* {{{ */ +{ + zend_ast *var_ast = ast->child[0]; + zend_ast *dim_ast = ast->child[1]; + + znode var_node, dim_node; + + zend_delayed_compile_var(&var_node, var_ast, type); + zend_separate_if_call_and_write(&var_node, var_ast, type); + + if (dim_ast == NULL) { + if (type == BP_VAR_R || type == BP_VAR_IS) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use [] for reading"); + } + if (type == BP_VAR_UNSET) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use [] for unsetting"); + } + dim_node.op_type = IS_UNUSED; + } else { + zend_compile_expr(&dim_node, dim_ast); + zend_handle_numeric_op(&dim_node); } + + return zend_delayed_emit_op(result, ZEND_FETCH_DIM_R, &var_node, &dim_node); } /* }}} */ -void zend_do_goto(const znode *label TSRMLS_DC) /* {{{ */ +static inline zend_op *zend_compile_dim_common(znode *result, zend_ast *ast, uint32_t type) /* {{{ */ { - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + uint32_t offset = zend_delayed_compile_begin(); + zend_delayed_compile_dim(result, ast, type); + return zend_delayed_compile_end(offset); +} +/* }}} */ - opline->opcode = ZEND_GOTO; - opline->extended_value = CG(context).current_brk_cont; - SET_UNUSED(opline->op1); - SET_NODE(opline->op2, label); - zend_resolve_goto_label(CG(active_op_array), opline, 0 TSRMLS_CC); +void zend_compile_dim(znode *result, zend_ast *ast, uint32_t type) /* {{{ */ +{ + zend_op *opline = zend_compile_dim_common(result, ast, type); + zend_adjust_for_fetch_type(opline, type); } /* }}} */ -void zend_release_labels(int temporary TSRMLS_DC) /* {{{ */ +static zend_bool is_this_fetch(zend_ast *ast) /* {{{ */ { - if (CG(context).labels) { - zend_hash_destroy(CG(context).labels); - FREE_HASHTABLE(CG(context).labels); - CG(context).labels = NULL; + if (ast->kind == ZEND_AST_VAR && ast->child[0]->kind == ZEND_AST_ZVAL) { + zval *name = zend_ast_get_zval(ast->child[0]); + return Z_TYPE_P(name) == IS_STRING && zend_string_equals_literal(Z_STR_P(name), "this"); } - if (!temporary && !zend_stack_is_empty(&CG(context_stack))) { - zend_compiler_context *ctx; - zend_stack_top(&CG(context_stack), (void**)&ctx); - CG(context) = *ctx; - zend_stack_del_top(&CG(context_stack)); - } + return 0; } /* }}} */ -void zend_do_build_full_name(znode *result, znode *prefix, znode *name, int is_class_member TSRMLS_DC) /* {{{ */ +static zend_op *zend_delayed_compile_prop(znode *result, zend_ast *ast, uint32_t type) /* {{{ */ { - zend_uint length; + zend_ast *obj_ast = ast->child[0]; + zend_ast *prop_ast = ast->child[1]; - if (!result) { - result = prefix; + znode obj_node, prop_node; + zend_op *opline; + + if (is_this_fetch(obj_ast)) { + obj_node.op_type = IS_UNUSED; } else { - *result = *prefix; + zend_delayed_compile_var(&obj_node, obj_ast, type); + zend_separate_if_call_and_write(&obj_node, obj_ast, type); } + zend_compile_expr(&prop_node, prop_ast); - if (is_class_member) { - length = sizeof("::")-1 + Z_STRLEN(result->u.constant) + Z_STRLEN(name->u.constant); - Z_STRVAL(result->u.constant) = str_erealloc(Z_STRVAL(result->u.constant), length+1); - memcpy(&Z_STRVAL(result->u.constant)[Z_STRLEN(result->u.constant)], "::", sizeof("::")-1); - memcpy(&Z_STRVAL(result->u.constant)[Z_STRLEN(result->u.constant) + sizeof("::")-1], Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant)+1); - str_efree(Z_STRVAL(name->u.constant)); - Z_STRLEN(result->u.constant) = length; - } else { - length = sizeof("\\")-1 + Z_STRLEN(result->u.constant) + Z_STRLEN(name->u.constant); - Z_STRVAL(result->u.constant) = str_erealloc(Z_STRVAL(result->u.constant), length+1); - memcpy(&Z_STRVAL(result->u.constant)[Z_STRLEN(result->u.constant)], "\\", sizeof("\\")-1); - memcpy(&Z_STRVAL(result->u.constant)[Z_STRLEN(result->u.constant) + sizeof("\\")-1], Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant)+1); - str_efree(Z_STRVAL(name->u.constant)); - Z_STRLEN(result->u.constant) = length; + opline = zend_delayed_emit_op(result, ZEND_FETCH_OBJ_R, &obj_node, &prop_node); + if (opline->op2_type == IS_CONST) { + convert_to_string(CT_CONSTANT(opline->op2)); + zend_alloc_polymorphic_cache_slot(opline->op2.constant); } + + return opline; } /* }}} */ -int zend_do_begin_class_member_function_call(znode *class_name, znode *method_name TSRMLS_DC) /* {{{ */ +static zend_op *zend_compile_prop_common(znode *result, zend_ast *ast, uint32_t type) /* {{{ */ { - znode class_node; + uint32_t offset = zend_delayed_compile_begin(); + zend_delayed_compile_prop(result, ast, type); + return zend_delayed_compile_end(offset); +} +/* }}} */ + +void zend_compile_prop(znode *result, zend_ast *ast, uint32_t type) /* {{{ */ +{ + zend_op *opline = zend_compile_prop_common(result, ast, type); + zend_adjust_for_fetch_type(opline, type); +} +/* }}} */ + +zend_op *zend_compile_static_prop_common(znode *result, zend_ast *ast, uint32_t type, int delayed) /* {{{ */ +{ + zend_ast *class_ast = ast->child[0]; + zend_ast *prop_ast = ast->child[1]; + + znode class_node, prop_node; zend_op *opline; - if (method_name->op_type == IS_CONST) { - char *lcname; - if (Z_TYPE(method_name->u.constant) != IS_STRING) { - zend_error_noreturn(E_COMPILE_ERROR, "Method name must be a string"); - } - lcname = zend_str_tolower_dup(Z_STRVAL(method_name->u.constant), Z_STRLEN(method_name->u.constant)); - if ((sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)-1) == Z_STRLEN(method_name->u.constant) && - memcmp(lcname, ZEND_CONSTRUCTOR_FUNC_NAME, sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)-1) == 0) { - zval_dtor(&method_name->u.constant); - method_name->op_type = IS_UNUSED; - } - efree(lcname); + if (zend_is_const_default_class_ref(class_ast)) { + class_node.op_type = IS_CONST; + ZVAL_STR(&class_node.u.constant, zend_resolve_class_name_ast(class_ast)); + } else { + zend_compile_class_ref(&class_node, class_ast, 1); } - if (class_name->op_type == IS_CONST && - ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant))) { - zend_resolve_class_name(class_name TSRMLS_CC); - class_node = *class_name; - opline = get_next_op(CG(active_op_array) TSRMLS_CC); + zend_compile_expr(&prop_node, prop_ast); + + if (delayed) { + opline = zend_delayed_emit_op(result, ZEND_FETCH_R, &prop_node, NULL); } else { - zend_do_fetch_class(&class_node, class_name TSRMLS_CC); - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->extended_value = class_node.EA ; + opline = zend_emit_op(result, ZEND_FETCH_R, &prop_node, NULL); } - opline->opcode = ZEND_INIT_STATIC_METHOD_CALL; - opline->result.num = CG(context).nested_calls; - if (class_node.op_type == IS_CONST) { - opline->op1_type = IS_CONST; - opline->op1.constant = - zend_add_class_name_literal(CG(active_op_array), &class_node.u.constant TSRMLS_CC); - } else { - SET_NODE(opline->op1, &class_node); + if (opline->op1_type == IS_CONST) { + zend_alloc_polymorphic_cache_slot(opline->op1.constant); } - if (method_name->op_type == IS_CONST) { + if (class_node.op_type == IS_CONST) { opline->op2_type = IS_CONST; - opline->op2.constant = - zend_add_func_name_literal(CG(active_op_array), &method_name->u.constant TSRMLS_CC); - if (opline->op1_type == IS_CONST) { - GET_CACHE_SLOT(opline->op2.constant); - } else { - GET_POLYMORPHIC_CACHE_SLOT(opline->op2.constant); - } + opline->op2.constant = zend_add_class_name_literal( + CG(active_op_array), Z_STR(class_node.u.constant)); } else { - SET_NODE(opline->op2, method_name); + SET_NODE(opline->op2, &class_node); } + opline->extended_value |= ZEND_FETCH_STATIC_MEMBER; - zend_push_function_call_entry(NULL TSRMLS_CC); - if (++CG(context).nested_calls > CG(active_op_array)->nested_calls) { - CG(active_op_array)->nested_calls = CG(context).nested_calls; - } - zend_do_extended_fcall_begin(TSRMLS_C); - return 1; /* Dynamic */ + return opline; } /* }}} */ -void zend_do_end_function_call(znode *function_name, znode *result, int is_method, int is_dynamic_fcall TSRMLS_DC) /* {{{ */ +void zend_compile_static_prop(znode *result, zend_ast *ast, uint32_t type, int delayed) /* {{{ */ { - zend_op *opline; - zend_function_call_entry *fcall; - zend_stack_top(&CG(function_call_stack), (void **) &fcall); + zend_op *opline = zend_compile_static_prop_common(result, ast, type, delayed); + zend_adjust_for_fetch_type(opline, type); +} +/* }}} */ - if (is_method && function_name && function_name->op_type == IS_UNUSED) { - /* clone */ - if (fcall->arg_num != 0) { - zend_error(E_WARNING, "Clone method does not require arguments"); +static void zend_compile_list_assign(znode *result, zend_ast *ast, znode *expr_node) /* {{{ */ +{ + zend_ast_list *list = zend_ast_get_list(ast); + uint32_t i; + zend_bool has_elems = 0; + + for (i = 0; i < list->children; ++i) { + zend_ast *var_ast = list->child[i]; + znode fetch_result, dim_node; + + if (var_ast == NULL) { + continue; } - opline = &CG(active_op_array)->opcodes[Z_LVAL(function_name->u.constant)]; - } else { - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - if (fcall->fbc) { - opline->opcode = ZEND_DO_FCALL; - SET_NODE(opline->op1, function_name); - SET_UNUSED(opline->op2); - opline->op2.num = CG(context).nested_calls; - CALCULATE_LITERAL_HASH(opline->op1.constant); - GET_CACHE_SLOT(opline->op1.constant); - } else { - opline->opcode = ZEND_DO_FCALL_BY_NAME; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); - opline->op2.num = --CG(context).nested_calls; + has_elems = 1; - /* This would normally be a ZEND_DO_FCALL, but was forced to use - * ZEND_DO_FCALL_BY_NAME due to a ... argument. In this case we need to - * free the function_name */ - if (!is_method && !is_dynamic_fcall && function_name->op_type==IS_CONST) { - zval_dtor(&function_name->u.constant); - } + dim_node.op_type = IS_CONST; + ZVAL_LONG(&dim_node.u.constant, i); + + if (expr_node->op_type == IS_CONST) { + Z_TRY_ADDREF(expr_node->u.constant); } - } - opline->result.var = get_temporary_variable(CG(active_op_array)); - opline->result_type = IS_VAR; - GET_NODE(result, opline->result); - opline->extended_value = fcall->arg_num; + zend_emit_op(&fetch_result, ZEND_FETCH_LIST, expr_node, &dim_node); + zend_emit_assign_znode(var_ast, &fetch_result); + } - if (CG(context).used_stack + 1 > CG(active_op_array)->used_stack) { - CG(active_op_array)->used_stack = CG(context).used_stack + 1; + if (!has_elems) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use empty list"); } - CG(context).used_stack -= fcall->arg_num; - zend_stack_del_top(&CG(function_call_stack)); + + *result = *expr_node; } /* }}} */ -void zend_do_pass_param(znode *param, zend_uchar op TSRMLS_DC) /* {{{ */ +static void zend_ensure_writable_variable(const zend_ast *ast) /* {{{ */ { - zend_op *opline; - int original_op = op; - zend_function_call_entry *fcall; - zend_function *function_ptr; - int send_by_reference = 0; - int send_function = 0; - - zend_stack_top(&CG(function_call_stack), (void **) &fcall); - function_ptr = fcall->fbc; - fcall->arg_num++; - - if (fcall->uses_argument_unpacking) { - zend_error_noreturn(E_COMPILE_ERROR, - "Cannot use positional argument after argument unpacking"); + if (ast->kind == ZEND_AST_CALL) { + zend_error_noreturn(E_COMPILE_ERROR, "Can't use function return value in write context"); } - - if (original_op == ZEND_SEND_REF) { - if (function_ptr && - function_ptr->common.function_name && - function_ptr->common.type == ZEND_USER_FUNCTION && - !ARG_SHOULD_BE_SENT_BY_REF(function_ptr, fcall->arg_num)) { - zend_error_noreturn(E_COMPILE_ERROR, - "Call-time pass-by-reference has been removed; " - "If you would like to pass argument by reference, modify the declaration of %s().", - function_ptr->common.function_name); - } else { - zend_error_noreturn(E_COMPILE_ERROR, "Call-time pass-by-reference has been removed"); - } - return; + if (ast->kind == ZEND_AST_METHOD_CALL || ast->kind == ZEND_AST_STATIC_CALL) { + zend_error_noreturn(E_COMPILE_ERROR, "Can't use method return value in write context"); } +} +/* }}} */ - if (function_ptr) { - if (ARG_MAY_BE_SENT_BY_REF(function_ptr, fcall->arg_num)) { - if (op == ZEND_SEND_VAR && param->op_type & (IS_VAR|IS_CV)) { - send_by_reference = ZEND_ARG_SEND_BY_REF; - if (zend_is_function_or_method_call(param)) { - /* Method call */ - op = ZEND_SEND_VAR_NO_REF; - send_function = ZEND_ARG_SEND_FUNCTION | ZEND_ARG_SEND_SILENT; - } - } else { - op = ZEND_SEND_VAL; - } - } else if (ARG_SHOULD_BE_SENT_BY_REF(function_ptr, fcall->arg_num)) { - send_by_reference = ZEND_ARG_SEND_BY_REF; - } +/* Detects $a... = $a pattern */ +zend_bool zend_is_assign_to_self(zend_ast *var_ast, zend_ast *expr_ast) /* {{{ */ +{ + if (expr_ast->kind != ZEND_AST_VAR || expr_ast->child[0]->kind != ZEND_AST_ZVAL) { + return 0; } - if (op == ZEND_SEND_VAR && zend_is_function_or_method_call(param)) { - /* Method call */ - op = ZEND_SEND_VAR_NO_REF; - send_function = ZEND_ARG_SEND_FUNCTION; - } else if (op == ZEND_SEND_VAL && (param->op_type & (IS_VAR|IS_CV))) { - op = ZEND_SEND_VAR_NO_REF; + while (zend_is_variable(var_ast) && var_ast->kind != ZEND_AST_VAR) { + var_ast = var_ast->child[0]; } - if (op!=ZEND_SEND_VAR_NO_REF && send_by_reference==ZEND_ARG_SEND_BY_REF) { - /* change to passing by reference */ - switch (param->op_type) { - case IS_VAR: - case IS_CV: - op = ZEND_SEND_REF; - break; - default: - zend_error_noreturn(E_COMPILE_ERROR, "Only variables can be passed by reference"); - break; - } + if (var_ast->kind != ZEND_AST_VAR || var_ast->child[0]->kind != ZEND_AST_ZVAL) { + return 0; } - if (original_op == ZEND_SEND_VAR) { - switch (op) { - case ZEND_SEND_VAR_NO_REF: - zend_do_end_variable_parse(param, BP_VAR_R, 0 TSRMLS_CC); - break; - case ZEND_SEND_VAR: - if (function_ptr) { - zend_do_end_variable_parse(param, BP_VAR_R, 0 TSRMLS_CC); - } else { - zend_do_end_variable_parse(param, BP_VAR_FUNC_ARG, fcall->arg_num TSRMLS_CC); - } - break; - case ZEND_SEND_REF: - zend_do_end_variable_parse(param, BP_VAR_W, 0 TSRMLS_CC); - break; - } + { + zend_string *name1 = zval_get_string(zend_ast_get_zval(var_ast->child[0])); + zend_string *name2 = zval_get_string(zend_ast_get_zval(expr_ast->child[0])); + zend_bool result = zend_string_equals(name1, name2); + zend_string_release(name1); + zend_string_release(name2); + return result; } +} +/* }}} */ - opline = get_next_op(CG(active_op_array) TSRMLS_CC); +/* Detects if list($a, $b, $c) contains variable with given name */ +zend_bool zend_list_has_assign_to(zend_ast *list_ast, zend_string *name) /* {{{ */ +{ + zend_ast_list *list = zend_ast_get_list(list_ast); + uint32_t i; + for (i = 0; i < list->children; i++) { + zend_ast *var_ast = list->child[i]; + if (!var_ast) { + continue; + } - if (op == ZEND_SEND_VAR_NO_REF) { - if (function_ptr) { - opline->extended_value = ZEND_ARG_COMPILE_TIME_BOUND | send_by_reference | send_function; - } else { - opline->extended_value = send_function; + /* Recursively check nested list()s */ + if (var_ast->kind == ZEND_AST_LIST && zend_list_has_assign_to(var_ast, name)) { + return 1; } - } else { - if (function_ptr) { - opline->extended_value = ZEND_DO_FCALL; - } else { - opline->extended_value = ZEND_DO_FCALL_BY_NAME; + + if (var_ast->kind == ZEND_AST_VAR && var_ast->child[0]->kind == ZEND_AST_ZVAL) { + zend_string *var_name = zval_get_string(zend_ast_get_zval(var_ast->child[0])); + zend_bool result = zend_string_equals(var_name, name); + zend_string_release(var_name); + if (result) { + return 1; + } } } - opline->opcode = op; - SET_NODE(opline->op1, param); - opline->op2.opline_num = fcall->arg_num; - SET_UNUSED(opline->op2); - if (++CG(context).used_stack > CG(active_op_array)->used_stack) { - CG(active_op_array)->used_stack = CG(context).used_stack; + return 0; +} +/* }}} */ + +/* Detects patterns like list($a, $b, $c) = $a */ +zend_bool zend_list_has_assign_to_self(zend_ast *list_ast, zend_ast *expr_ast) /* {{{ */ +{ + /* Only check simple variables on the RHS, as only CVs cause issues with this. */ + if (expr_ast->kind == ZEND_AST_VAR && expr_ast->child[0]->kind == ZEND_AST_ZVAL) { + zend_string *name = zval_get_string(zend_ast_get_zval(expr_ast->child[0])); + zend_bool result = zend_list_has_assign_to(list_ast, name); + zend_string_release(name); + return result; } + return 0; } /* }}} */ -void zend_do_unpack_params(znode *params TSRMLS_DC) /* {{{ */ +void zend_compile_assign(znode *result, zend_ast *ast) /* {{{ */ { + zend_ast *var_ast = ast->child[0]; + zend_ast *expr_ast = ast->child[1]; + + znode var_node, expr_node; zend_op *opline; - zend_function_call_entry *fcall; + uint32_t offset; - zend_stack_top(&CG(function_call_stack), (void **) &fcall); - fcall->uses_argument_unpacking = 1; + if (is_this_fetch(var_ast)) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this"); + } - if (fcall->fbc) { - /* If argument unpacking is used argument numbers and sending modes can no longer be - * computed at compile time, thus we need access to EX(call). In order to have it we - * retroactively emit a ZEND_INIT_FCALL_BY_NAME opcode. */ - zval func_name; - ZVAL_STRING(&func_name, fcall->fbc->common.function_name, 1); + zend_ensure_writable_variable(var_ast); - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_INIT_FCALL_BY_NAME; - opline->result.num = CG(context).nested_calls; - SET_UNUSED(opline->op1); - opline->op2_type = IS_CONST; - opline->op2.constant = zend_add_func_name_literal(CG(active_op_array), &func_name TSRMLS_CC); - GET_CACHE_SLOT(opline->op2.constant); + switch (var_ast->kind) { + case ZEND_AST_VAR: + case ZEND_AST_STATIC_PROP: + zend_compile_var(&var_node, var_ast, BP_VAR_W); + zend_compile_expr(&expr_node, expr_ast); + zend_emit_op(result, ZEND_ASSIGN, &var_node, &expr_node); + return; + case ZEND_AST_DIM: + offset = zend_delayed_compile_begin(); + zend_delayed_compile_dim(result, var_ast, BP_VAR_W); - ++CG(context).nested_calls; - fcall->fbc = NULL; - } + if (zend_is_assign_to_self(var_ast, expr_ast)) { + /* $a[0] = $a should evaluate the right $a first */ + zend_compile_simple_var_no_cv(&expr_node, expr_ast, BP_VAR_R, 0); + } else { + zend_compile_expr(&expr_node, expr_ast); + } - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_SEND_UNPACK; - SET_NODE(opline->op1, params); - SET_UNUSED(opline->op2); - opline->op2.num = fcall->arg_num; + opline = zend_delayed_compile_end(offset); + opline->opcode = ZEND_ASSIGN_DIM; + + opline = zend_emit_op_data(&expr_node); + return; + case ZEND_AST_PROP: + offset = zend_delayed_compile_begin(); + zend_delayed_compile_prop(result, var_ast, BP_VAR_W); + zend_compile_expr(&expr_node, expr_ast); + + opline = zend_delayed_compile_end(offset); + opline->opcode = ZEND_ASSIGN_OBJ; + + zend_emit_op_data(&expr_node); + return; + case ZEND_AST_LIST: + if (zend_list_has_assign_to_self(var_ast, expr_ast)) { + /* list($a, $b) = $a should evaluate the right $a first */ + zend_compile_simple_var_no_cv(&expr_node, expr_ast, BP_VAR_R, 0); + } else { + zend_compile_expr(&expr_node, expr_ast); + } + + zend_compile_list_assign(result, var_ast, &expr_node); + return; + EMPTY_SWITCH_DEFAULT_CASE(); + } } /* }}} */ -static int generate_free_switch_expr(const zend_switch_entry *switch_entry TSRMLS_DC) /* {{{ */ +void zend_compile_assign_ref(znode *result, zend_ast *ast) /* {{{ */ { + zend_ast *target_ast = ast->child[0]; + zend_ast *source_ast = ast->child[1]; + + znode target_node, source_node; zend_op *opline; - if (switch_entry->cond.op_type != IS_VAR && switch_entry->cond.op_type != IS_TMP_VAR) { - return (switch_entry->cond.op_type == IS_UNUSED); + if (is_this_fetch(target_ast)) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this"); } + zend_ensure_writable_variable(target_ast); - opline = get_next_op(CG(active_op_array) TSRMLS_CC); + zend_compile_var(&target_node, target_ast, BP_VAR_W); + zend_compile_var(&source_node, source_ast, BP_VAR_REF); - opline->opcode = (switch_entry->cond.op_type == IS_TMP_VAR) ? ZEND_FREE : ZEND_SWITCH_FREE; - SET_NODE(opline->op1, &switch_entry->cond); - SET_UNUSED(opline->op2); + if (source_node.op_type != IS_VAR && zend_is_call(source_ast)) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use result of built-in function in write context"); + } - return 0; + opline = zend_emit_op(result, ZEND_ASSIGN_REF, &target_node, &source_node); + if (!result) { + opline->result_type |= EXT_TYPE_UNUSED; + } + + if (zend_is_call(source_ast)) { + opline->extended_value = ZEND_RETURNS_FUNCTION; + } } /* }}} */ -static int generate_free_foreach_copy(const zend_op *foreach_copy TSRMLS_DC) /* {{{ */ +static inline void zend_emit_assign_ref_znode(zend_ast *var_ast, znode *value_node) /* {{{ */ { + zend_ast *assign_ast = zend_ast_create(ZEND_AST_ASSIGN_REF, var_ast, + zend_ast_create_znode(value_node)); + zend_compile_assign_ref(NULL, assign_ast); +} +/* }}} */ + +void zend_compile_compound_assign(znode *result, zend_ast *ast) /* {{{ */ +{ + zend_ast *var_ast = ast->child[0]; + zend_ast *expr_ast = ast->child[1]; + uint32_t opcode = ast->attr; + + znode var_node, expr_node; zend_op *opline; + uint32_t offset; - /* If we reach the separator then stop applying the stack */ - if (foreach_copy->result_type == IS_UNUSED) { - return 1; - } + zend_ensure_writable_variable(var_ast); + + switch (var_ast->kind) { + case ZEND_AST_VAR: + case ZEND_AST_STATIC_PROP: + zend_compile_var(&var_node, var_ast, BP_VAR_RW); + zend_compile_expr(&expr_node, expr_ast); + zend_emit_op(result, opcode, &var_node, &expr_node); + return; + case ZEND_AST_DIM: + offset = zend_delayed_compile_begin(); + zend_delayed_compile_dim(result, var_ast, BP_VAR_RW); + zend_compile_expr(&expr_node, expr_ast); - opline = get_next_op(CG(active_op_array) TSRMLS_CC); + opline = zend_delayed_compile_end(offset); + opline->opcode = opcode; + opline->extended_value = ZEND_ASSIGN_DIM; - opline->opcode = (foreach_copy->result_type == IS_TMP_VAR) ? ZEND_FREE : ZEND_SWITCH_FREE; - COPY_NODE(opline->op1, foreach_copy->result); - SET_UNUSED(opline->op2); + opline = zend_emit_op_data(&expr_node); + return; + case ZEND_AST_PROP: + offset = zend_delayed_compile_begin(); + zend_delayed_compile_prop(result, var_ast, BP_VAR_RW); + zend_compile_expr(&expr_node, expr_ast); - return 0; + opline = zend_delayed_compile_end(offset); + opline->opcode = opcode; + opline->extended_value = ZEND_ASSIGN_OBJ; + + zend_emit_op_data(&expr_node); + return; + EMPTY_SWITCH_DEFAULT_CASE() + } } /* }}} */ -void zend_do_return(znode *expr, int do_end_vparse TSRMLS_DC) /* {{{ */ +uint32_t zend_compile_args(zend_ast *ast, zend_function *fbc) /* {{{ */ { - zend_op *opline; - int start_op_number, end_op_number; - zend_bool returns_reference = (CG(active_op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0; - - /* The error for use of return inside a generator is thrown in pass_two. */ - - if (do_end_vparse) { - if (returns_reference && !zend_is_function_or_method_call(expr)) { - zend_do_end_variable_parse(expr, BP_VAR_W, 0 TSRMLS_CC); - } else { - zend_do_end_variable_parse(expr, BP_VAR_R, 0 TSRMLS_CC); - } - } + /* TODO.AST &var error */ + zend_ast_list *args = zend_ast_get_list(ast); + uint32_t i; + zend_bool uses_arg_unpack = 0; + uint32_t arg_count = 0; /* number of arguments not including unpacks */ - start_op_number = get_next_op_number(CG(active_op_array)); + for (i = 0; i < args->children; ++i) { + zend_ast *arg = args->child[i]; + uint32_t arg_num = i + 1; -#ifdef ZTS - zend_stack_apply_with_argument(&CG(switch_cond_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element, void *)) generate_free_switch_expr TSRMLS_CC); - zend_stack_apply_with_argument(&CG(foreach_copy_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element, void *)) generate_free_foreach_copy TSRMLS_CC); -#else - zend_stack_apply(&CG(switch_cond_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element)) generate_free_switch_expr); - zend_stack_apply(&CG(foreach_copy_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element)) generate_free_foreach_copy); -#endif + znode arg_node; + zend_op *opline; + zend_uchar opcode; + zend_ulong flags = 0; - end_op_number = get_next_op_number(CG(active_op_array)); - while (start_op_number < end_op_number) { - CG(active_op_array)->opcodes[start_op_number].extended_value |= EXT_TYPE_FREE_ON_RETURN; - start_op_number++; - } + if (arg->kind == ZEND_AST_UNPACK) { + uses_arg_unpack = 1; + fbc = NULL; - if (CG(context).in_finally) { - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_DISCARD_EXCEPTION; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); - } + zend_compile_expr(&arg_node, arg->child[0]); + opline = zend_emit_op(NULL, ZEND_SEND_UNPACK, &arg_node, NULL); + opline->op2.num = arg_count; + opline->result.var = (uint32_t)(zend_intptr_t)ZEND_CALL_ARG(NULL, arg_count); + continue; + } - opline = get_next_op(CG(active_op_array) TSRMLS_CC); + if (uses_arg_unpack) { + zend_error_noreturn(E_COMPILE_ERROR, + "Cannot use positional argument after argument unpacking"); + } - opline->opcode = returns_reference ? ZEND_RETURN_BY_REF : ZEND_RETURN; + arg_count++; + if (zend_is_variable(arg)) { + if (zend_is_call(arg)) { + zend_compile_var(&arg_node, arg, BP_VAR_R); + if (arg_node.op_type & (IS_CONST|IS_TMP_VAR)) { + /* Function call was converted into builtin instruction */ + opcode = ZEND_SEND_VAL; + } else { + opcode = ZEND_SEND_VAR_NO_REF; + flags |= ZEND_ARG_SEND_FUNCTION; + if (fbc && ARG_SHOULD_BE_SENT_BY_REF(fbc, arg_num)) { + flags |= ZEND_ARG_SEND_BY_REF; + if (ARG_MAY_BE_SENT_BY_REF(fbc, arg_num)) { + flags |= ZEND_ARG_SEND_SILENT; + } + } + } + } else if (fbc) { + if (ARG_SHOULD_BE_SENT_BY_REF(fbc, arg_num)) { + zend_compile_var(&arg_node, arg, BP_VAR_W); + opcode = ZEND_SEND_REF; + } else { + zend_compile_var(&arg_node, arg, BP_VAR_R); + opcode = ZEND_SEND_VAR; + } + } else { + zend_compile_var(&arg_node, arg, + BP_VAR_FUNC_ARG | (arg_num << BP_VAR_SHIFT)); + opcode = ZEND_SEND_VAR_EX; + } + } else { + zend_compile_expr(&arg_node, arg); + if (arg_node.op_type & (IS_VAR|IS_CV)) { + opcode = ZEND_SEND_VAR_NO_REF; + if (fbc && ARG_MUST_BE_SENT_BY_REF(fbc, arg_num)) { + flags |= ZEND_ARG_SEND_BY_REF; + } + } else { + if (fbc) { + opcode = ZEND_SEND_VAL; + if (ARG_MUST_BE_SENT_BY_REF(fbc, arg_num)) { + zend_error_noreturn(E_COMPILE_ERROR, "Only variables can be passed by reference"); + } + } else { + opcode = ZEND_SEND_VAL_EX; + } + } + } - if (expr) { - SET_NODE(opline->op1, expr); + opline = get_next_op(CG(active_op_array)); + opline->opcode = opcode; + SET_NODE(opline->op1, &arg_node); + SET_UNUSED(opline->op2); + opline->op2.opline_num = arg_num; + opline->result.var = (uint32_t)(zend_intptr_t)ZEND_CALL_ARG(NULL, arg_num); - if (!do_end_vparse) { - opline->extended_value = ZEND_RETURNS_VALUE; - } else if (zend_is_function_or_method_call(expr)) { - opline->extended_value = ZEND_RETURNS_FUNCTION; + if (opcode == ZEND_SEND_VAR_NO_REF) { + if (fbc) { + flags |= ZEND_ARG_COMPILE_TIME_BOUND; + } + if ((flags & ZEND_ARG_COMPILE_TIME_BOUND) && !(flags & ZEND_ARG_SEND_BY_REF)) { + opline->opcode = ZEND_SEND_VAR; + opline->extended_value = ZEND_ARG_COMPILE_TIME_BOUND; + } else { + opline->extended_value = flags; + } + } else if (fbc) { + opline->extended_value = ZEND_ARG_COMPILE_TIME_BOUND; } - } else { - opline->op1_type = IS_CONST; - LITERAL_NULL(opline->op1); } - SET_UNUSED(opline->op2); + return arg_count; } /* }}} */ -void zend_do_yield(znode *result, znode *value, const znode *key, zend_bool is_variable TSRMLS_DC) /* {{{ */ +ZEND_API zend_uchar zend_get_call_op(zend_uchar init_op, zend_function *fbc) /* {{{ */ { - zend_op *opline; - - if (!CG(active_op_array)->function_name) { - zend_error_noreturn(E_COMPILE_ERROR, "The \"yield\" expression can only be used inside a function"); - } - - CG(active_op_array)->fn_flags |= ZEND_ACC_GENERATOR; - - if (is_variable) { - if ((CG(active_op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) && !zend_is_function_or_method_call(value)) { - zend_do_end_variable_parse(value, BP_VAR_W, 0 TSRMLS_CC); + if (fbc) { + if (fbc->type == ZEND_INTERNAL_FUNCTION) { + if (!zend_execute_internal && + !fbc->common.scope && + !(fbc->common.fn_flags & (ZEND_ACC_ABSTRACT|ZEND_ACC_DEPRECATED|ZEND_ACC_HAS_TYPE_HINTS|ZEND_ACC_RETURN_REFERENCE))) { + return ZEND_DO_ICALL; + } } else { - zend_do_end_variable_parse(value, BP_VAR_R, 0 TSRMLS_CC); + if (zend_execute_ex == execute_ex && + !(fbc->common.fn_flags & ZEND_ACC_GENERATOR)) { + return ZEND_DO_UCALL; + } } + } else if (zend_execute_ex == execute_ex && + !zend_execute_internal && + (init_op == ZEND_INIT_FCALL_BY_NAME || + init_op == ZEND_INIT_NS_FCALL_BY_NAME)) { + return ZEND_DO_FCALL_BY_NAME; } + return ZEND_DO_FCALL; +} +/* }}} */ - opline = get_next_op(CG(active_op_array) TSRMLS_CC); +void zend_compile_call_common(znode *result, zend_ast *args_ast, zend_function *fbc) /* {{{ */ +{ + zend_op *opline; + uint32_t opnum_init = get_next_op_number(CG(active_op_array)) - 1; + uint32_t arg_count; + uint32_t call_flags; - opline->opcode = ZEND_YIELD; + zend_do_extended_fcall_begin(); - if (value) { - SET_NODE(opline->op1, value); + arg_count = zend_compile_args(args_ast, fbc); - if (is_variable && zend_is_function_or_method_call(value)) { - opline->extended_value = ZEND_RETURNS_FUNCTION; - } - } else { - SET_UNUSED(opline->op1); - } + opline = &CG(active_op_array)->opcodes[opnum_init]; + opline->extended_value = arg_count; - if (key) { - SET_NODE(opline->op2, key); - } else { - SET_UNUSED(opline->op2); + if (opline->opcode == ZEND_INIT_FCALL) { + opline->op1.num = zend_vm_calc_used_stack(arg_count, fbc); } - opline->result_type = IS_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - GET_NODE(result, opline->result); + call_flags = (opline->opcode == ZEND_NEW ? ZEND_CALL_CTOR : 0); + opline = zend_emit_op(result, zend_get_call_op(opline->opcode, fbc), NULL, NULL); + opline->op1.num = call_flags; + + zend_do_extended_fcall_end(); } /* }}} */ -static int zend_add_try_element(zend_uint try_op TSRMLS_DC) /* {{{ */ +zend_bool zend_compile_function_name(znode *name_node, zend_ast *name_ast) /* {{{ */ { - int try_catch_offset = CG(active_op_array)->last_try_catch++; + zend_string *orig_name = zend_ast_get_str(name_ast); + zend_bool is_fully_qualified; - CG(active_op_array)->try_catch_array = erealloc(CG(active_op_array)->try_catch_array, sizeof(zend_try_catch_element)*CG(active_op_array)->last_try_catch); - CG(active_op_array)->try_catch_array[try_catch_offset].try_op = try_op; - CG(active_op_array)->try_catch_array[try_catch_offset].catch_op = 0; - CG(active_op_array)->try_catch_array[try_catch_offset].finally_op = 0; - CG(active_op_array)->try_catch_array[try_catch_offset].finally_end = 0; - return try_catch_offset; -} -/* }}} */ + name_node->op_type = IS_CONST; + ZVAL_STR(&name_node->u.constant, zend_resolve_function_name( + orig_name, name_ast->attr, &is_fully_qualified)); -static void zend_add_catch_element(int offset, zend_uint catch_op TSRMLS_DC) /* {{{ */ -{ - CG(active_op_array)->try_catch_array[offset].catch_op = catch_op; + return !is_fully_qualified && FC(current_namespace); } /* }}} */ -void zend_do_first_catch(znode *open_parentheses TSRMLS_DC) /* {{{ */ +void zend_compile_ns_call(znode *result, znode *name_node, zend_ast *args_ast) /* {{{ */ { - open_parentheses->u.op.opline_num = get_next_op_number(CG(active_op_array)); + zend_op *opline = get_next_op(CG(active_op_array)); + opline->opcode = ZEND_INIT_NS_FCALL_BY_NAME; + SET_UNUSED(opline->op1); + opline->op2_type = IS_CONST; + opline->op2.constant = zend_add_ns_func_name_literal( + CG(active_op_array), Z_STR(name_node->u.constant)); + zend_alloc_cache_slot(opline->op2.constant); + + zend_compile_call_common(result, args_ast, NULL); } /* }}} */ -void zend_initialize_try_catch_element(znode *catch_token TSRMLS_DC) /* {{{ */ +void zend_compile_dynamic_call(znode *result, znode *name_node, zend_ast *args_ast) /* {{{ */ { - int jmp_op_number = get_next_op_number(CG(active_op_array)); - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - zend_llist jmp_list; - zend_llist *jmp_list_ptr; - - opline->opcode = ZEND_JMP; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); - /* save for backpatching */ - - zend_llist_init(&jmp_list, sizeof(int), NULL, 0); - zend_stack_push(&CG(bp_stack), (void *) &jmp_list, sizeof(zend_llist)); - zend_stack_top(&CG(bp_stack), (void **) &jmp_list_ptr); - zend_llist_add_element(jmp_list_ptr, &jmp_op_number); + zend_op *opline = get_next_op(CG(active_op_array)); + if (name_node->op_type == IS_CONST && Z_TYPE(name_node->u.constant) == IS_STRING) { + const char *colon; + zend_string *str = Z_STR(name_node->u.constant); + if ((colon = zend_memrchr(ZSTR_VAL(str), ':', ZSTR_LEN(str))) != NULL && colon > ZSTR_VAL(str) && *(colon - 1) == ':') { + zend_string *class = zend_string_init(ZSTR_VAL(str), colon - ZSTR_VAL(str) - 1, 0); + zend_string *method = zend_string_init(colon + 1, ZSTR_LEN(str) - (colon - ZSTR_VAL(str)) - 1, 0); + opline->opcode = ZEND_INIT_STATIC_METHOD_CALL; + opline->op1_type = IS_CONST; + opline->op1.constant = zend_add_class_name_literal(CG(active_op_array), class); + opline->op2_type = IS_CONST; + opline->op2.constant = zend_add_func_name_literal(CG(active_op_array), method); + zend_alloc_cache_slot(opline->op2.constant); + zval_ptr_dtor(&name_node->u.constant); + } else { + opline->opcode = ZEND_INIT_FCALL_BY_NAME; + SET_UNUSED(opline->op1); + opline->op2_type = IS_CONST; + opline->op2.constant = zend_add_func_name_literal(CG(active_op_array), str); + zend_alloc_cache_slot(opline->op2.constant); + } + } else { + opline->opcode = ZEND_INIT_DYNAMIC_CALL; + SET_UNUSED(opline->op1); + SET_NODE(opline->op2, name_node); + } - catch_token->EA = get_next_op_number(CG(active_op_array)); + zend_compile_call_common(result, args_ast, NULL); } /* }}} */ -void zend_do_mark_last_catch(const znode *first_catch, const znode *last_additional_catch TSRMLS_DC) /* {{{ */ +static zend_bool zend_args_contain_unpack(zend_ast_list *args) /* {{{ */ { - CG(active_op_array)->last--; - zend_do_if_end(TSRMLS_C); - if (last_additional_catch->u.op.opline_num == -1) { - CG(active_op_array)->opcodes[first_catch->u.op.opline_num].result.num = 1; - CG(active_op_array)->opcodes[first_catch->u.op.opline_num].extended_value = get_next_op_number(CG(active_op_array)); - } else { - CG(active_op_array)->opcodes[last_additional_catch->u.op.opline_num].result.num = 1; - CG(active_op_array)->opcodes[last_additional_catch->u.op.opline_num].extended_value = get_next_op_number(CG(active_op_array)); + uint32_t i; + for (i = 0; i < args->children; ++i) { + if (args->child[i]->kind == ZEND_AST_UNPACK) { + return 1; + } } - DEC_BPC(CG(active_op_array)); + return 0; } /* }}} */ -void zend_do_try(znode *try_token TSRMLS_DC) /* {{{ */ +int zend_compile_func_strlen(znode *result, zend_ast_list *args) /* {{{ */ { - try_token->u.op.opline_num = zend_add_try_element(get_next_op_number(CG(active_op_array)) TSRMLS_CC); - INC_BPC(CG(active_op_array)); + znode arg_node; + + if ((CG(compiler_options) & ZEND_COMPILE_NO_BUILTIN_STRLEN) + || args->children != 1 || args->child[0]->kind == ZEND_AST_UNPACK + ) { + return FAILURE; + } + + zend_compile_expr(&arg_node, args->child[0]); + if (arg_node.op_type == IS_CONST && Z_TYPE(arg_node.u.constant) == IS_STRING) { + result->op_type = IS_CONST; + ZVAL_LONG(&result->u.constant, Z_STRLEN(arg_node.u.constant)); + zval_dtor(&arg_node.u.constant); + } else { + zend_emit_op_tmp(result, ZEND_STRLEN, &arg_node, NULL); + } + return SUCCESS; } /* }}} */ -void zend_do_finally(znode *finally_token TSRMLS_DC) /* {{{ */ +int zend_compile_func_typecheck(znode *result, zend_ast_list *args, uint32_t type) /* {{{ */ { - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + znode arg_node; + zend_op *opline; - finally_token->u.op.opline_num = get_next_op_number(CG(active_op_array)); - /* call the the "finally" block */ - opline->opcode = ZEND_FAST_CALL; - SET_UNUSED(opline->op1); - opline->op1.opline_num = finally_token->u.op.opline_num + 1; - SET_UNUSED(opline->op2); - /* jump to code after the "finally" block, - * the actual jump address is going to be set in zend_do_end_finally() - */ - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_JMP; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); + if (args->children != 1 || args->child[0]->kind == ZEND_AST_UNPACK) { + return FAILURE; + } - CG(context).in_finally++; + zend_compile_expr(&arg_node, args->child[0]); + opline = zend_emit_op_tmp(result, ZEND_TYPE_CHECK, &arg_node, NULL); + opline->extended_value = type; + return SUCCESS; } /* }}} */ -void zend_do_begin_catch(znode *catch_token, znode *class_name, znode *catch_var, znode *first_catch TSRMLS_DC) /* {{{ */ +int zend_compile_func_defined(znode *result, zend_ast_list *args) /* {{{ */ { - long catch_op_number; + zend_string *name; zend_op *opline; - znode catch_class; - if (class_name->op_type == IS_CONST && - ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant))) { - zend_resolve_class_name(class_name TSRMLS_CC); - catch_class = *class_name; - } else { - zend_error_noreturn(E_COMPILE_ERROR, "Bad class name in the catch statement"); + if (args->children != 1 || args->child[0]->kind != ZEND_AST_ZVAL) { + return FAILURE; } - catch_op_number = get_next_op_number(CG(active_op_array)); - if (first_catch) { - first_catch->u.op.opline_num = catch_op_number; + name = zval_get_string(zend_ast_get_zval(args->child[0])); + if (zend_memrchr(ZSTR_VAL(name), '\\', ZSTR_LEN(name)) || zend_memrchr(ZSTR_VAL(name), ':', ZSTR_LEN(name))) { + zend_string_release(name); + return FAILURE; } - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_CATCH; + opline = zend_emit_op_tmp(result, ZEND_DEFINED, NULL, NULL); opline->op1_type = IS_CONST; - opline->op1.constant = zend_add_class_name_literal(CG(active_op_array), &catch_class.u.constant TSRMLS_CC); - opline->op2_type = IS_CV; - opline->op2.var = lookup_cv(CG(active_op_array), Z_STRVAL(catch_var->u.constant), Z_STRLEN(catch_var->u.constant), 0 TSRMLS_CC); - Z_STRVAL(catch_var->u.constant) = (char*)CG(active_op_array)->vars[opline->op2.var].name; - opline->result.num = 0; /* 1 means it's the last catch in the block */ + LITERAL_STR(opline->op1, name); + zend_alloc_cache_slot(opline->op1.constant); - catch_token->u.op.opline_num = catch_op_number; + /* Lowercase constant name in a separate literal */ + { + zval c; + zend_string *lcname = zend_string_tolower(name); + ZVAL_NEW_STR(&c, lcname); + zend_add_literal(CG(active_op_array), &c); + } + return SUCCESS; } /* }}} */ -void zend_do_end_catch(znode *catch_token TSRMLS_DC) /* {{{ */ +static int zend_try_compile_ct_bound_init_user_func(zend_ast *name_ast, uint32_t num_args) /* {{{ */ { - int jmp_op_number = get_next_op_number(CG(active_op_array)); - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - zend_llist *jmp_list_ptr; - - opline->opcode = ZEND_JMP; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); - /* save for backpatching */ + zend_string *name, *lcname; + zend_function *fbc; + zend_op *opline; - zend_stack_top(&CG(bp_stack), (void **) &jmp_list_ptr); - zend_llist_add_element(jmp_list_ptr, &jmp_op_number); + if (name_ast->kind != ZEND_AST_ZVAL || Z_TYPE_P(zend_ast_get_zval(name_ast)) != IS_STRING) { + return FAILURE; + } - CG(active_op_array)->opcodes[catch_token->u.op.opline_num].extended_value = get_next_op_number(CG(active_op_array)); -} -/* }}} */ + name = zend_ast_get_str(name_ast); + lcname = zend_string_tolower(name); -void zend_do_bind_catch(znode *try_token, znode *catch_token TSRMLS_DC) /* {{{ */ { - if (catch_token->op_type != IS_UNUSED) { - zend_add_catch_element(try_token->u.op.opline_num, catch_token->EA TSRMLS_CC); + fbc = zend_hash_find_ptr(CG(function_table), lcname); + if (!fbc || (fbc->type == ZEND_INTERNAL_FUNCTION && + (CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_FUNCTIONS)) + ) { + zend_string_release(lcname); + return FAILURE; } + + opline = zend_emit_op(NULL, ZEND_INIT_FCALL, NULL, NULL); + opline->extended_value = num_args; + opline->op1.num = zend_vm_calc_used_stack(num_args, fbc); + opline->op2_type = IS_CONST; + LITERAL_STR(opline->op2, lcname); + zend_alloc_cache_slot(opline->op2.constant); + + return SUCCESS; } /* }}} */ -void zend_do_end_finally(znode *try_token, znode* catch_token, znode *finally_token TSRMLS_DC) /* {{{ */ +static void zend_compile_init_user_func(zend_ast *name_ast, uint32_t num_args, zend_string *orig_func_name) /* {{{ */ { - if (catch_token->op_type == IS_UNUSED && finally_token->op_type == IS_UNUSED) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use try without catch or finally"); - } - if (finally_token->op_type != IS_UNUSED) { - zend_op *opline; - - CG(active_op_array)->try_catch_array[try_token->u.op.opline_num].finally_op = finally_token->u.op.opline_num + 1; - CG(active_op_array)->try_catch_array[try_token->u.op.opline_num].finally_end = get_next_op_number(CG(active_op_array)); - CG(active_op_array)->has_finally_block = 1; + zend_op *opline; + znode name_node; - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_FAST_RET; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); + if (zend_try_compile_ct_bound_init_user_func(name_ast, num_args) == SUCCESS) { + return; + } - CG(active_op_array)->opcodes[finally_token->u.op.opline_num].op1.opline_num = get_next_op_number(CG(active_op_array)); + zend_compile_expr(&name_node, name_ast); - CG(context).in_finally--; - } + opline = zend_emit_op(NULL, ZEND_INIT_USER_CALL, NULL, &name_node); + opline->op1_type = IS_CONST; + LITERAL_STR(opline->op1, zend_string_copy(orig_func_name)); + opline->extended_value = num_args; } /* }}} */ -void zend_do_throw(const znode *expr TSRMLS_DC) /* {{{ */ +/* cufa = call_user_func_array */ +int zend_compile_func_cufa(znode *result, zend_ast_list *args, zend_string *lcname) /* {{{ */ { - zend_op *opline; + znode arg_node; - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_THROW; - SET_NODE(opline->op1, expr); - SET_UNUSED(opline->op2); + if (args->children != 2 || zend_args_contain_unpack(args)) { + return FAILURE; + } + + zend_compile_init_user_func(args->child[0], 0, lcname); + zend_compile_expr(&arg_node, args->child[1]); + zend_emit_op(NULL, ZEND_SEND_ARRAY, &arg_node, NULL); + zend_emit_op(result, ZEND_DO_FCALL, NULL, NULL); + + return SUCCESS; } /* }}} */ -ZEND_API void function_add_ref(zend_function *function) /* {{{ */ +/* cuf = call_user_func */ +int zend_compile_func_cuf(znode *result, zend_ast_list *args, zend_string *lcname) /* {{{ */ { - if (function->type == ZEND_USER_FUNCTION) { - zend_op_array *op_array = &function->op_array; + uint32_t i; - (*op_array->refcount)++; - if (op_array->static_variables) { - HashTable *static_variables = op_array->static_variables; - zval *tmp_zval; + if (args->children < 1 || zend_args_contain_unpack(args)) { + return FAILURE; + } + + zend_compile_init_user_func(args->child[0], args->children - 1, lcname); + for (i = 1; i < args->children; ++i) { + zend_ast *arg_ast = args->child[i]; + znode arg_node; + zend_op *opline; + zend_bool send_user = 0; - ALLOC_HASHTABLE(op_array->static_variables); - zend_hash_init(op_array->static_variables, zend_hash_num_elements(static_variables), NULL, ZVAL_PTR_DTOR, 0); - zend_hash_copy(op_array->static_variables, static_variables, (copy_ctor_func_t) zval_add_ref, (void *) &tmp_zval, sizeof(zval *)); + if (zend_is_variable(arg_ast) && !zend_is_call(arg_ast)) { + zend_compile_var(&arg_node, arg_ast, BP_VAR_FUNC_ARG | (i << BP_VAR_SHIFT)); + send_user = 1; + } else { + zend_compile_expr(&arg_node, arg_ast); + if (arg_node.op_type & (IS_VAR|IS_CV)) { + send_user = 1; + } } - op_array->run_time_cache = NULL; + + if (send_user) { + opline = zend_emit_op(NULL, ZEND_SEND_USER, &arg_node, NULL); + } else { + opline = zend_emit_op(NULL, ZEND_SEND_VAL, &arg_node, NULL); + } + + opline->op2.num = i; + opline->result.var = (uint32_t)(zend_intptr_t)ZEND_CALL_ARG(NULL, i); } + zend_emit_op(result, ZEND_DO_FCALL, NULL, NULL); + + return SUCCESS; } /* }}} */ -static void do_inherit_parent_constructor(zend_class_entry *ce) /* {{{ */ +static int zend_compile_assert(znode *result, zend_ast_list *args, zend_string *name, zend_function *fbc) /* {{{ */ { - zend_function *function, *new_function; + if (EG(assertions) >= 0) { + znode name_node; + zend_op *opline; + uint32_t check_op_number = get_next_op_number(CG(active_op_array)); - if (!ce->parent) { - return; - } + zend_emit_op(NULL, ZEND_ASSERT_CHECK, NULL, NULL); - /* You cannot change create_object */ - ce->create_object = ce->parent->create_object; + if (fbc) { + name_node.op_type = IS_CONST; + ZVAL_STR_COPY(&name_node.u.constant, name); - /* Inherit special functions if needed */ - if (!ce->get_iterator) { - ce->get_iterator = ce->parent->get_iterator; - } - if (!ce->iterator_funcs.funcs) { - ce->iterator_funcs.funcs = ce->parent->iterator_funcs.funcs; - } - if (!ce->__get) { - ce->__get = ce->parent->__get; - } - if (!ce->__set) { - ce->__set = ce->parent->__set; - } - if (!ce->__unset) { - ce->__unset = ce->parent->__unset; - } - if (!ce->__isset) { - ce->__isset = ce->parent->__isset; - } - if (!ce->__call) { - ce->__call = ce->parent->__call; - } - if (!ce->__callstatic) { - ce->__callstatic = ce->parent->__callstatic; - } - if (!ce->__tostring) { - ce->__tostring = ce->parent->__tostring; - } - if (!ce->clone) { - ce->clone = ce->parent->clone; - } - if(!ce->serialize) { - ce->serialize = ce->parent->serialize; - } - if(!ce->unserialize) { - ce->unserialize = ce->parent->unserialize; - } - if (!ce->destructor) { - ce->destructor = ce->parent->destructor; - } - if (!ce->__debugInfo) { - ce->__debugInfo = ce->parent->__debugInfo; - } - if (ce->constructor) { - if (ce->parent->constructor && ce->parent->constructor->common.fn_flags & ZEND_ACC_FINAL) { - zend_error(E_ERROR, "Cannot override final %s::%s() with %s::%s()", - ce->parent->name, ce->parent->constructor->common.function_name, - ce->name, ce->constructor->common.function_name - ); + opline = zend_emit_op(NULL, ZEND_INIT_FCALL, NULL, &name_node); + } else { + opline = zend_emit_op(NULL, ZEND_INIT_NS_FCALL_BY_NAME, NULL, NULL); + opline->op2_type = IS_CONST; + opline->op2.constant = zend_add_ns_func_name_literal( + CG(active_op_array), name); } - return; - } + zend_alloc_cache_slot(opline->op2.constant); - if (zend_hash_find(&ce->parent->function_table, ZEND_CONSTRUCTOR_FUNC_NAME, sizeof(ZEND_CONSTRUCTOR_FUNC_NAME), (void **)&function)==SUCCESS) { - /* inherit parent's constructor */ - zend_hash_update(&ce->function_table, ZEND_CONSTRUCTOR_FUNC_NAME, sizeof(ZEND_CONSTRUCTOR_FUNC_NAME), function, sizeof(zend_function), (void**)&new_function); - function_add_ref(new_function); + if (args->children == 1 && + (args->child[0]->kind != ZEND_AST_ZVAL || + Z_TYPE_P(zend_ast_get_zval(args->child[0])) != IS_STRING)) { + /* add "assert(condition) as assertion message */ + zend_ast_list_add((zend_ast*)args, + zend_ast_create_zval_from_str( + zend_ast_export("assert(", args->child[0], ")"))); + } + + zend_compile_call_common(result, (zend_ast*)args, fbc); + + CG(active_op_array)->opcodes[check_op_number].op2.opline_num = get_next_op_number(CG(active_op_array)); } else { - /* Don't inherit the old style constructor if we already have the new style constructor */ - char *lc_class_name; - char *lc_parent_class_name; - - lc_class_name = zend_str_tolower_dup(ce->name, ce->name_length); - if (!zend_hash_exists(&ce->function_table, lc_class_name, ce->name_length+1)) { - lc_parent_class_name = zend_str_tolower_dup(ce->parent->name, ce->parent->name_length); - if (!zend_hash_exists(&ce->function_table, lc_parent_class_name, ce->parent->name_length+1) && - zend_hash_find(&ce->parent->function_table, lc_parent_class_name, ce->parent->name_length+1, (void **)&function)==SUCCESS) { - if (function->common.fn_flags & ZEND_ACC_CTOR) { - /* inherit parent's constructor */ - zend_hash_update(&ce->function_table, lc_parent_class_name, ce->parent->name_length+1, function, sizeof(zend_function), (void**)&new_function); - function_add_ref(new_function); - } - } - efree(lc_parent_class_name); + if (!fbc) { + zend_string_release(name); } - efree(lc_class_name); + result->op_type = IS_CONST; + ZVAL_TRUE(&result->u.constant); } - ce->constructor = ce->parent->constructor; + + return SUCCESS; } /* }}} */ -char *zend_visibility_string(zend_uint fn_flags) /* {{{ */ +int zend_try_compile_special_func(znode *result, zend_string *lcname, zend_ast_list *args, zend_function *fbc) /* {{{ */ { - if (fn_flags & ZEND_ACC_PRIVATE) { - return "private"; - } - if (fn_flags & ZEND_ACC_PROTECTED) { - return "protected"; + if (fbc->internal_function.handler == ZEND_FN(display_disabled_function)) { + return FAILURE; } - if (fn_flags & ZEND_ACC_PUBLIC) { - return "public"; + + if (zend_string_equals_literal(lcname, "strlen")) { + return zend_compile_func_strlen(result, args); + } else if (zend_string_equals_literal(lcname, "is_null")) { + return zend_compile_func_typecheck(result, args, IS_NULL); + } else if (zend_string_equals_literal(lcname, "is_bool")) { + return zend_compile_func_typecheck(result, args, _IS_BOOL); + } else if (zend_string_equals_literal(lcname, "is_long") + || zend_string_equals_literal(lcname, "is_int") + || zend_string_equals_literal(lcname, "is_integer") + ) { + return zend_compile_func_typecheck(result, args, IS_LONG); + } else if (zend_string_equals_literal(lcname, "is_float") + || zend_string_equals_literal(lcname, "is_double") + || zend_string_equals_literal(lcname, "is_real") + ) { + return zend_compile_func_typecheck(result, args, IS_DOUBLE); + } else if (zend_string_equals_literal(lcname, "is_string")) { + return zend_compile_func_typecheck(result, args, IS_STRING); + } else if (zend_string_equals_literal(lcname, "is_array")) { + return zend_compile_func_typecheck(result, args, IS_ARRAY); + } else if (zend_string_equals_literal(lcname, "is_object")) { + return zend_compile_func_typecheck(result, args, IS_OBJECT); + } else if (zend_string_equals_literal(lcname, "is_resource")) { + return zend_compile_func_typecheck(result, args, IS_RESOURCE); + } else if (zend_string_equals_literal(lcname, "defined")) { + return zend_compile_func_defined(result, args); + } else if (zend_string_equals_literal(lcname, "call_user_func_array")) { + return zend_compile_func_cufa(result, args, lcname); + } else if (zend_string_equals_literal(lcname, "call_user_func")) { + return zend_compile_func_cuf(result, args, lcname); + } else if (zend_string_equals_literal(lcname, "assert")) { + return zend_compile_assert(result, args, lcname, fbc); + } else { + return FAILURE; } - return ""; } /* }}} */ -static void do_inherit_method(zend_function *function) /* {{{ */ +void zend_compile_call(znode *result, zend_ast *ast, uint32_t type) /* {{{ */ { - /* The class entry of the derived function intentionally remains the same - * as that of the parent class. That allows us to know in which context - * we're running, and handle private method calls properly. - */ - function_add_ref(function); -} -/* }}} */ + zend_ast *name_ast = ast->child[0]; + zend_ast *args_ast = ast->child[1]; -static zend_bool zend_do_perform_implementation_check(const zend_function *fe, const zend_function *proto TSRMLS_DC) /* {{{ */ -{ - zend_uint i, num_args; + znode name_node; - /* If it's a user function then arg_info == NULL means we don't have any parameters but - * we still need to do the arg number checks. We are only willing to ignore this for internal - * functions because extensions don't always define arg_info. - */ - if (!proto || (!proto->common.arg_info && proto->common.type != ZEND_USER_FUNCTION)) { - return 1; + if (name_ast->kind != ZEND_AST_ZVAL || Z_TYPE_P(zend_ast_get_zval(name_ast)) != IS_STRING) { + zend_compile_expr(&name_node, name_ast); + zend_compile_dynamic_call(result, &name_node, args_ast); + return; } - /* Checks for constructors only if they are declared in an interface, - * or explicitly marked as abstract - */ - if ((fe->common.fn_flags & ZEND_ACC_CTOR) - && ((proto->common.scope->ce_flags & ZEND_ACC_INTERFACE) == 0 - && (proto->common.fn_flags & ZEND_ACC_ABSTRACT) == 0)) { - return 1; + { + zend_bool runtime_resolution = zend_compile_function_name(&name_node, name_ast); + if (runtime_resolution) { + if (zend_string_equals_literal_ci(zend_ast_get_str(name_ast), "assert")) { + zend_compile_assert(result, zend_ast_get_list(args_ast), Z_STR(name_node.u.constant), NULL); + } else { + zend_compile_ns_call(result, &name_node, args_ast); + } + return; + } } - /* If both methods are private do not enforce a signature */ - if ((fe->common.fn_flags & ZEND_ACC_PRIVATE) && (proto->common.fn_flags & ZEND_ACC_PRIVATE)) { - return 1; - } + { + zval *name = &name_node.u.constant; + zend_string *lcname; + zend_function *fbc; + zend_op *opline; - /* check number of arguments */ - if (proto->common.required_num_args < fe->common.required_num_args - || proto->common.num_args > fe->common.num_args) { - return 0; - } + lcname = zend_string_tolower(Z_STR_P(name)); - /* by-ref constraints on return values are covariant */ - if ((proto->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) - && !(fe->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)) { - return 0; - } + fbc = zend_hash_find_ptr(CG(function_table), lcname); + if (!fbc || (fbc->type == ZEND_INTERNAL_FUNCTION && + (CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_FUNCTIONS)) + ) { + zend_string_release(lcname); + zend_compile_dynamic_call(result, &name_node, args_ast); + return; + } - if ((proto->common.fn_flags & ZEND_ACC_VARIADIC) - && !(fe->common.fn_flags & ZEND_ACC_VARIADIC)) { - return 0; + if (zend_try_compile_special_func(result, lcname, + zend_ast_get_list(args_ast), fbc) == SUCCESS + ) { + zend_string_release(lcname); + zval_ptr_dtor(&name_node.u.constant); + return; + } + + zval_ptr_dtor(&name_node.u.constant); + ZVAL_NEW_STR(&name_node.u.constant, lcname); + + opline = zend_emit_op(NULL, ZEND_INIT_FCALL, NULL, &name_node); + zend_alloc_cache_slot(opline->op2.constant); + + zend_compile_call_common(result, args_ast, fbc); } +} +/* }}} */ - /* For variadic functions any additional (optional) arguments that were added must be - * checked against the signature of the variadic argument, so in this case we have to - * go through all the parameters of the function and not just those present in the - * prototype. */ - num_args = proto->common.num_args; - if ((proto->common.fn_flags & ZEND_ACC_VARIADIC) - && fe->common.num_args > proto->common.num_args) { - num_args = fe->common.num_args; +void zend_compile_method_call(znode *result, zend_ast *ast, uint32_t type) /* {{{ */ +{ + zend_ast *obj_ast = ast->child[0]; + zend_ast *method_ast = ast->child[1]; + zend_ast *args_ast = ast->child[2]; + + znode obj_node, method_node; + zend_op *opline; + + if (is_this_fetch(obj_ast)) { + obj_node.op_type = IS_UNUSED; + } else { + zend_compile_expr(&obj_node, obj_ast); } - for (i = 0; i < num_args; i++) { - zend_arg_info *fe_arg_info = &fe->common.arg_info[i]; + zend_compile_expr(&method_node, method_ast); + opline = zend_emit_op(NULL, ZEND_INIT_METHOD_CALL, &obj_node, NULL); - zend_arg_info *proto_arg_info; - if (i < proto->common.num_args) { - proto_arg_info = &proto->common.arg_info[i]; - } else { - proto_arg_info = &proto->common.arg_info[proto->common.num_args-1]; + if (method_node.op_type == IS_CONST) { + if (Z_TYPE(method_node.u.constant) != IS_STRING) { + zend_error_noreturn(E_COMPILE_ERROR, "Method name must be a string"); } - if (ZEND_LOG_XOR(fe_arg_info->class_name, proto_arg_info->class_name)) { - /* Only one has a type hint and the other one doesn't */ - return 0; - } + opline->op2_type = IS_CONST; + opline->op2.constant = zend_add_func_name_literal(CG(active_op_array), + Z_STR(method_node.u.constant)); + zend_alloc_polymorphic_cache_slot(opline->op2.constant); + } else { + SET_NODE(opline->op2, &method_node); + } - if (fe_arg_info->class_name) { - const char *fe_class_name, *proto_class_name; - zend_uint fe_class_name_len, proto_class_name_len; + zend_compile_call_common(result, args_ast, NULL); +} +/* }}} */ - if (!strcasecmp(fe_arg_info->class_name, "parent") && proto->common.scope) { - fe_class_name = proto->common.scope->name; - fe_class_name_len = proto->common.scope->name_length; - } else if (!strcasecmp(fe_arg_info->class_name, "self") && fe->common.scope) { - fe_class_name = fe->common.scope->name; - fe_class_name_len = fe->common.scope->name_length; - } else { - fe_class_name = fe_arg_info->class_name; - fe_class_name_len = fe_arg_info->class_name_len; - } +static zend_bool zend_is_constructor(zend_string *name) /* {{{ */ +{ + return zend_string_equals_literal_ci(name, ZEND_CONSTRUCTOR_FUNC_NAME); +} +/* }}} */ - if (!strcasecmp(proto_arg_info->class_name, "parent") && proto->common.scope && proto->common.scope->parent) { - proto_class_name = proto->common.scope->parent->name; - proto_class_name_len = proto->common.scope->parent->name_length; - } else if (!strcasecmp(proto_arg_info->class_name, "self") && proto->common.scope) { - proto_class_name = proto->common.scope->name; - proto_class_name_len = proto->common.scope->name_length; - } else { - proto_class_name = proto_arg_info->class_name; - proto_class_name_len = proto_arg_info->class_name_len; - } +void zend_compile_static_call(znode *result, zend_ast *ast, uint32_t type) /* {{{ */ +{ + zend_ast *class_ast = ast->child[0]; + zend_ast *method_ast = ast->child[1]; + zend_ast *args_ast = ast->child[2]; - if (strcasecmp(fe_class_name, proto_class_name)!=0) { - const char *colon; + znode class_node, method_node; + zend_op *opline; + zend_ulong extended_value = 0; - if (fe->common.type != ZEND_USER_FUNCTION) { - return 0; - } else if (strchr(proto_class_name, '\\') != NULL || - (colon = zend_memrchr(fe_class_name, '\\', fe_class_name_len)) == NULL || - strcasecmp(colon+1, proto_class_name) != 0) { - zend_class_entry **fe_ce, **proto_ce; - int found, found2; - - found = zend_lookup_class(fe_class_name, fe_class_name_len, &fe_ce TSRMLS_CC); - found2 = zend_lookup_class(proto_class_name, proto_class_name_len, &proto_ce TSRMLS_CC); - - /* Check for class alias */ - if (found != SUCCESS || found2 != SUCCESS || - (*fe_ce)->type == ZEND_INTERNAL_CLASS || - (*proto_ce)->type == ZEND_INTERNAL_CLASS || - *fe_ce != *proto_ce) { - return 0; - } - } - } + if (zend_is_const_default_class_ref(class_ast)) { + class_node.op_type = IS_CONST; + ZVAL_STR(&class_node.u.constant, zend_resolve_class_name_ast(class_ast)); + } else { + opline = zend_compile_class_ref(&class_node, class_ast, 1); + extended_value = opline->extended_value; + } + + zend_compile_expr(&method_node, method_ast); + if (method_node.op_type == IS_CONST) { + zval *name = &method_node.u.constant; + if (Z_TYPE_P(name) != IS_STRING) { + zend_error_noreturn(E_COMPILE_ERROR, "Method name must be a string"); } - if (fe_arg_info->type_hint != proto_arg_info->type_hint) { - /* Incompatible type hint */ - return 0; + if (zend_is_constructor(Z_STR_P(name))) { + zval_ptr_dtor(name); + method_node.op_type = IS_UNUSED; } + } - /* by-ref constraints on arguments are invariant */ - if (fe_arg_info->pass_by_reference != proto_arg_info->pass_by_reference) { - return 0; + opline = get_next_op(CG(active_op_array)); + opline->opcode = ZEND_INIT_STATIC_METHOD_CALL; + opline->extended_value = extended_value; + + zend_set_class_name_op1(opline, &class_node); + + if (method_node.op_type == IS_CONST) { + opline->op2_type = IS_CONST; + opline->op2.constant = zend_add_func_name_literal(CG(active_op_array), + Z_STR(method_node.u.constant)); + if (opline->op1_type == IS_CONST) { + zend_alloc_cache_slot(opline->op2.constant); + } else { + zend_alloc_polymorphic_cache_slot(opline->op2.constant); } + } else { + SET_NODE(opline->op2, &method_node); } - return 1; + zend_compile_call_common(result, args_ast, NULL); } /* }}} */ -#define REALLOC_BUF_IF_EXCEED(buf, offset, length, size) \ - if (UNEXPECTED(offset - buf + size >= length)) { \ - length += size + 1; \ - buf = erealloc(buf, length); \ - } +void zend_compile_class_decl(zend_ast *ast); -static char * zend_get_function_declaration(zend_function *fptr TSRMLS_DC) /* {{{ */ +void zend_compile_new(znode *result, zend_ast *ast) /* {{{ */ { - char *offset, *buf; - zend_uint length = 1024; - - offset = buf = (char *)emalloc(length * sizeof(char)); - if (fptr->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE) { - *(offset++) = '&'; - *(offset++) = ' '; - } + zend_ast *class_ast = ast->child[0]; + zend_ast *args_ast = ast->child[1]; - if (fptr->common.scope) { - memcpy(offset, fptr->common.scope->name, fptr->common.scope->name_length); - offset += fptr->common.scope->name_length; - *(offset++) = ':'; - *(offset++) = ':'; + znode class_node, ctor_result; + zend_op *opline; + uint32_t opnum; + + if (zend_is_const_default_class_ref(class_ast)) { + class_node.op_type = IS_CONST; + ZVAL_STR(&class_node.u.constant, zend_resolve_class_name_ast(class_ast)); + } else if (class_ast->kind == ZEND_AST_CLASS) { + uint32_t dcl_opnum = get_next_op_number(CG(active_op_array)); + zend_compile_class_decl(class_ast); + /* jump over anon class declaration */ + opline = &CG(active_op_array)->opcodes[dcl_opnum]; + if (opline->opcode == ZEND_FETCH_CLASS) { + opline++; + } + class_node.op_type = opline->result_type; + class_node.u.op.var = opline->result.var; + opline->op1.opline_num = get_next_op_number(CG(active_op_array)); + } else { + zend_compile_class_ref(&class_node, class_ast, 1); } - { - size_t name_len = strlen(fptr->common.function_name); - REALLOC_BUF_IF_EXCEED(buf, offset, length, name_len); - memcpy(offset, fptr->common.function_name, name_len); - offset += name_len; - } - - *(offset++) = '('; - if (fptr->common.arg_info) { - zend_uint i, required; - zend_arg_info *arg_info = fptr->common.arg_info; - - required = fptr->common.required_num_args; - for (i = 0; i < fptr->common.num_args;) { - if (arg_info->class_name) { - const char *class_name; - zend_uint class_name_len; - if (!strcasecmp(arg_info->class_name, "self") && fptr->common.scope ) { - class_name = fptr->common.scope->name; - class_name_len = fptr->common.scope->name_length; - } else if (!strcasecmp(arg_info->class_name, "parent") && fptr->common.scope->parent) { - class_name = fptr->common.scope->parent->name; - class_name_len = fptr->common.scope->parent->name_length; - } else { - class_name = arg_info->class_name; - class_name_len = arg_info->class_name_len; - } - REALLOC_BUF_IF_EXCEED(buf, offset, length, class_name_len); - memcpy(offset, class_name, class_name_len); - offset += class_name_len; - *(offset++) = ' '; - } else if (arg_info->type_hint) { - zend_uint type_name_len; - char *type_name = zend_get_type_by_const(arg_info->type_hint); - type_name_len = strlen(type_name); - REALLOC_BUF_IF_EXCEED(buf, offset, length, type_name_len); - memcpy(offset, type_name, type_name_len); - offset += type_name_len; - *(offset++) = ' '; - } + opnum = get_next_op_number(CG(active_op_array)); + opline = zend_emit_op(result, ZEND_NEW, NULL, NULL); - if (arg_info->pass_by_reference) { - *(offset++) = '&'; - } + if (class_node.op_type == IS_CONST) { + opline->op1_type = IS_CONST; + opline->op1.constant = zend_add_class_name_literal( + CG(active_op_array), Z_STR(class_node.u.constant)); + } else { + SET_NODE(opline->op1, &class_node); + } - if (arg_info->is_variadic) { - *(offset++) = '.'; - *(offset++) = '.'; - *(offset++) = '.'; - } + zend_compile_call_common(&ctor_result, args_ast, NULL); + zend_do_free(&ctor_result); - *(offset++) = '$'; + /* New jumps over ctor call if ctor does not exist */ + opline = &CG(active_op_array)->opcodes[opnum]; + opline->op2.opline_num = get_next_op_number(CG(active_op_array)); +} +/* }}} */ - if (arg_info->name) { - REALLOC_BUF_IF_EXCEED(buf, offset, length, arg_info->name_len); - memcpy(offset, arg_info->name, arg_info->name_len); - offset += arg_info->name_len; - } else { - zend_uint idx = i; - memcpy(offset, "param", 5); - offset += 5; - do { - *(offset++) = (char) (idx % 10) + '0'; - idx /= 10; - } while (idx > 0); - } - if (i >= required && !arg_info->is_variadic) { - *(offset++) = ' '; - *(offset++) = '='; - *(offset++) = ' '; - if (fptr->type == ZEND_USER_FUNCTION) { - zend_op *precv = NULL; - { - zend_uint idx = i; - zend_op *op = ((zend_op_array *)fptr)->opcodes; - zend_op *end = op + ((zend_op_array *)fptr)->last; - - ++idx; - while (op < end) { - if ((op->opcode == ZEND_RECV || op->opcode == ZEND_RECV_INIT) - && op->op1.num == (long)idx) - { - precv = op; - } - ++op; - } - } - if (precv && precv->opcode == ZEND_RECV_INIT && precv->op2_type != IS_UNUSED) { - zval *zv, zv_copy; - int use_copy; - ALLOC_ZVAL(zv); - *zv = *precv->op2.zv; - zval_copy_ctor(zv); - INIT_PZVAL(zv); - if ((Z_TYPE_P(zv) & IS_CONSTANT_TYPE_MASK) == IS_CONSTANT) { - REALLOC_BUF_IF_EXCEED(buf, offset, length, Z_STRLEN_P(zv)); - memcpy(offset, Z_STRVAL_P(zv), Z_STRLEN_P(zv)); - offset += Z_STRLEN_P(zv); - } else if (Z_TYPE_P(zv) == IS_BOOL) { - if (Z_LVAL_P(zv)) { - memcpy(offset, "true", 4); - offset += 4; - } else { - memcpy(offset, "false", 5); - offset += 5; - } - } else if (Z_TYPE_P(zv) == IS_NULL) { - memcpy(offset, "NULL", 4); - offset += 4; - } else if (Z_TYPE_P(zv) == IS_STRING) { - *(offset++) = '\''; - REALLOC_BUF_IF_EXCEED(buf, offset, length, MIN(Z_STRLEN_P(zv), 10)); - memcpy(offset, Z_STRVAL_P(zv), MIN(Z_STRLEN_P(zv), 10)); - offset += MIN(Z_STRLEN_P(zv), 10); - if (Z_STRLEN_P(zv) > 10) { - *(offset++) = '.'; - *(offset++) = '.'; - *(offset++) = '.'; - } - *(offset++) = '\''; - } else if (Z_TYPE_P(zv) == IS_ARRAY) { - memcpy(offset, "Array", 5); - offset += 5; - } else if ((Z_TYPE_P(zv) & IS_CONSTANT_TYPE_MASK) == IS_CONSTANT_AST) { - memcpy(offset, "<expression>", 12); - offset += 12; - } else { - zend_make_printable_zval(zv, &zv_copy, &use_copy); - REALLOC_BUF_IF_EXCEED(buf, offset, length, Z_STRLEN(zv_copy)); - memcpy(offset, Z_STRVAL(zv_copy), Z_STRLEN(zv_copy)); - offset += Z_STRLEN(zv_copy); - if (use_copy) { - zval_dtor(&zv_copy); - } - } - zval_ptr_dtor(&zv); - } - } else { - memcpy(offset, "NULL", 4); - offset += 4; - } - } +void zend_compile_clone(znode *result, zend_ast *ast) /* {{{ */ +{ + zend_ast *obj_ast = ast->child[0]; - if (++i < fptr->common.num_args) { - *(offset++) = ','; - *(offset++) = ' '; - } - arg_info++; - REALLOC_BUF_IF_EXCEED(buf, offset, length, 32); - } - } - *(offset++) = ')'; - *offset = '\0'; + znode obj_node; + zend_compile_expr(&obj_node, obj_ast); - return buf; + zend_emit_op(result, ZEND_CLONE, &obj_node, NULL); } /* }}} */ -static void do_inheritance_check_on_method(zend_function *child, zend_function *parent TSRMLS_DC) /* {{{ */ +void zend_compile_global_var(zend_ast *ast) /* {{{ */ { - zend_uint child_flags; - zend_uint parent_flags = parent->common.fn_flags; + zend_ast *var_ast = ast->child[0]; + zend_ast *name_ast = var_ast->child[0]; - if ((parent->common.scope->ce_flags & ZEND_ACC_INTERFACE) == 0 - && parent->common.fn_flags & ZEND_ACC_ABSTRACT - && parent->common.scope != (child->common.prototype ? child->common.prototype->common.scope : child->common.scope) - && child->common.fn_flags & (ZEND_ACC_ABSTRACT|ZEND_ACC_IMPLEMENTED_ABSTRACT)) { - zend_error_noreturn(E_COMPILE_ERROR, "Can't inherit abstract function %s::%s() (previously declared abstract in %s)", - parent->common.scope->name, - child->common.function_name, - child->common.prototype ? child->common.prototype->common.scope->name : child->common.scope->name); - } + znode name_node, result; - if (parent_flags & ZEND_ACC_FINAL) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot override final method %s::%s()", ZEND_FN_SCOPE_NAME(parent), child->common.function_name); + zend_compile_expr(&name_node, name_ast); + if (name_node.op_type == IS_CONST) { + convert_to_string(&name_node.u.constant); } - child_flags = child->common.fn_flags; - /* You cannot change from static to non static and vice versa. - */ - if ((child_flags & ZEND_ACC_STATIC) != (parent_flags & ZEND_ACC_STATIC)) { - if (child->common.fn_flags & ZEND_ACC_STATIC) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot make non static method %s::%s() static in class %s", ZEND_FN_SCOPE_NAME(parent), child->common.function_name, ZEND_FN_SCOPE_NAME(child)); - } else { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot make static method %s::%s() non static in class %s", ZEND_FN_SCOPE_NAME(parent), child->common.function_name, ZEND_FN_SCOPE_NAME(child)); - } - } + if (zend_try_compile_cv(&result, var_ast) == SUCCESS) { + zend_op *opline = zend_emit_op(NULL, ZEND_BIND_GLOBAL, &result, &name_node); + zend_alloc_cache_slot(opline->op2.constant); + } else { + zend_emit_op(&result, ZEND_FETCH_W, &name_node, NULL); + + // TODO.AST Avoid double fetch + //opline->extended_value = ZEND_FETCH_GLOBAL_LOCK; - /* Disallow making an inherited method abstract. */ - if ((child_flags & ZEND_ACC_ABSTRACT) && !(parent_flags & ZEND_ACC_ABSTRACT)) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot make non abstract method %s::%s() abstract in class %s", ZEND_FN_SCOPE_NAME(parent), child->common.function_name, ZEND_FN_SCOPE_NAME(child)); + zend_emit_assign_ref_znode(var_ast, &result); } +} +/* }}} */ - if (parent_flags & ZEND_ACC_CHANGED) { - child->common.fn_flags |= ZEND_ACC_CHANGED; - } else { - /* Prevent derived classes from restricting access that was available in parent classes - */ - if ((child_flags & ZEND_ACC_PPP_MASK) > (parent_flags & ZEND_ACC_PPP_MASK)) { - zend_error_noreturn(E_COMPILE_ERROR, "Access level to %s::%s() must be %s (as in class %s)%s", ZEND_FN_SCOPE_NAME(child), child->common.function_name, zend_visibility_string(parent_flags), ZEND_FN_SCOPE_NAME(parent), (parent_flags&ZEND_ACC_PUBLIC) ? "" : " or weaker"); - } else if (((child_flags & ZEND_ACC_PPP_MASK) < (parent_flags & ZEND_ACC_PPP_MASK)) - && ((parent_flags & ZEND_ACC_PPP_MASK) & ZEND_ACC_PRIVATE)) { - child->common.fn_flags |= ZEND_ACC_CHANGED; +static void zend_compile_static_var_common(zend_ast *var_ast, zval *value, zend_bool by_ref) /* {{{ */ +{ + znode var_node, result; + zend_op *opline; + + zend_compile_expr(&var_node, var_ast); + + if (!CG(active_op_array)->static_variables) { + if (CG(active_op_array)->scope) { + CG(active_op_array)->scope->ce_flags |= ZEND_HAS_STATIC_IN_METHODS; } + ALLOC_HASHTABLE(CG(active_op_array)->static_variables); + zend_hash_init(CG(active_op_array)->static_variables, 8, NULL, ZVAL_PTR_DTOR, 0); } - if (parent_flags & ZEND_ACC_PRIVATE) { - child->common.prototype = NULL; - } else if (parent_flags & ZEND_ACC_ABSTRACT) { - child->common.fn_flags |= ZEND_ACC_IMPLEMENTED_ABSTRACT; - child->common.prototype = parent; - } else if (!(parent->common.fn_flags & ZEND_ACC_CTOR) || (parent->common.prototype && (parent->common.prototype->common.scope->ce_flags & ZEND_ACC_INTERFACE))) { - /* ctors only have a prototype if it comes from an interface */ - child->common.prototype = parent->common.prototype ? parent->common.prototype : parent; + if (GC_REFCOUNT(CG(active_op_array)->static_variables) > 1) { + if (!(GC_FLAGS(CG(active_op_array)->static_variables) & IS_ARRAY_IMMUTABLE)) { + GC_REFCOUNT(CG(active_op_array)->static_variables)--; + } + CG(active_op_array)->static_variables = zend_array_dup(CG(active_op_array)->static_variables); } + zend_hash_update(CG(active_op_array)->static_variables, Z_STR(var_node.u.constant), value); - if (child->common.prototype && (child->common.prototype->common.fn_flags & ZEND_ACC_ABSTRACT)) { - if (!zend_do_perform_implementation_check(child, child->common.prototype TSRMLS_CC)) { - zend_error_noreturn(E_COMPILE_ERROR, "Declaration of %s::%s() must be compatible with %s", ZEND_FN_SCOPE_NAME(child), child->common.function_name, zend_get_function_declaration(child->common.prototype TSRMLS_CC)); - } - } else if (EG(error_reporting) & E_STRICT || EG(user_error_handler)) { /* Check E_STRICT (or custom error handler) before the check so that we save some time */ - if (!zend_do_perform_implementation_check(child, parent TSRMLS_CC)) { - char *method_prototype = zend_get_function_declaration(parent TSRMLS_CC); - zend_error(E_STRICT, "Declaration of %s::%s() should be compatible with %s", ZEND_FN_SCOPE_NAME(child), child->common.function_name, method_prototype); - efree(method_prototype); - } + opline = zend_emit_op(&result, by_ref ? ZEND_FETCH_W : ZEND_FETCH_R, &var_node, NULL); + opline->extended_value = ZEND_FETCH_STATIC; + + if (by_ref) { + zend_ast *fetch_ast = zend_ast_create(ZEND_AST_VAR, var_ast); + zend_emit_assign_ref_znode(fetch_ast, &result); + } else { + zend_ast *fetch_ast = zend_ast_create(ZEND_AST_VAR, var_ast); + zend_emit_assign_znode(fetch_ast, &result); } } /* }}} */ -static zend_bool do_inherit_method_check(HashTable *child_function_table, zend_function *parent, const zend_hash_key *hash_key, zend_class_entry *child_ce) /* {{{ */ +void zend_compile_static_var(zend_ast *ast) /* {{{ */ { - zend_uint parent_flags = parent->common.fn_flags; - zend_function *child; - TSRMLS_FETCH(); + zend_ast *var_ast = ast->child[0]; + zend_ast *value_ast = ast->child[1]; + zval value_zv; - if (zend_hash_quick_find(child_function_table, hash_key->arKey, hash_key->nKeyLength, hash_key->h, (void **) &child)==FAILURE) { - if (parent_flags & (ZEND_ACC_ABSTRACT)) { - child_ce->ce_flags |= ZEND_ACC_IMPLICIT_ABSTRACT_CLASS; - } - return 1; /* method doesn't exist in child, copy from parent */ + if (value_ast) { + zend_const_expr_to_zval(&value_zv, value_ast); + } else { + ZVAL_NULL(&value_zv); } - do_inheritance_check_on_method(child, parent TSRMLS_CC); - - return 0; + zend_compile_static_var_common(var_ast, &value_zv, 1); } /* }}} */ -static zend_bool do_inherit_property_access_check(HashTable *target_ht, zend_property_info *parent_info, const zend_hash_key *hash_key, zend_class_entry *ce) /* {{{ */ +void zend_compile_unset(zend_ast *ast) /* {{{ */ { - zend_property_info *child_info; - zend_class_entry *parent_ce = ce->parent; + zend_ast *var_ast = ast->child[0]; - if (parent_info->flags & (ZEND_ACC_PRIVATE|ZEND_ACC_SHADOW)) { - if (zend_hash_quick_find(&ce->properties_info, hash_key->arKey, hash_key->nKeyLength, hash_key->h, (void **) &child_info)==SUCCESS) { - child_info->flags |= ZEND_ACC_CHANGED; - } else { - zend_hash_quick_update(&ce->properties_info, hash_key->arKey, hash_key->nKeyLength, hash_key->h, parent_info, sizeof(zend_property_info), (void **) &child_info); - if(ce->type & ZEND_INTERNAL_CLASS) { - zend_duplicate_property_info_internal(child_info); + znode var_node; + zend_op *opline; + switch (var_ast->kind) { + case ZEND_AST_VAR: + if (zend_try_compile_cv(&var_node, var_ast) == SUCCESS) { + opline = zend_emit_op(NULL, ZEND_UNSET_VAR, &var_node, NULL); + opline->extended_value = ZEND_FETCH_LOCAL | ZEND_QUICK_SET; } else { - zend_duplicate_property_info(child_info); + opline = zend_compile_simple_var_no_cv(NULL, var_ast, BP_VAR_UNSET, 0); + opline->opcode = ZEND_UNSET_VAR; } - child_info->flags &= ~ZEND_ACC_PRIVATE; /* it's not private anymore */ - child_info->flags |= ZEND_ACC_SHADOW; /* but it's a shadow of private */ - } - return 0; /* don't copy access information to child */ - } - - if (zend_hash_quick_find(&ce->properties_info, hash_key->arKey, hash_key->nKeyLength, hash_key->h, (void **) &child_info)==SUCCESS) { - if ((parent_info->flags & ZEND_ACC_STATIC) != (child_info->flags & ZEND_ACC_STATIC)) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare %s%s::$%s as %s%s::$%s", - (parent_info->flags & ZEND_ACC_STATIC) ? "static " : "non static ", parent_ce->name, hash_key->arKey, - (child_info->flags & ZEND_ACC_STATIC) ? "static " : "non static ", ce->name, hash_key->arKey); - - } - - if(parent_info->flags & ZEND_ACC_CHANGED) { - child_info->flags |= ZEND_ACC_CHANGED; - } - - if ((child_info->flags & ZEND_ACC_PPP_MASK) > (parent_info->flags & ZEND_ACC_PPP_MASK)) { - zend_error_noreturn(E_COMPILE_ERROR, "Access level to %s::$%s must be %s (as in class %s)%s", ce->name, hash_key->arKey, zend_visibility_string(parent_info->flags), parent_ce->name, (parent_info->flags&ZEND_ACC_PUBLIC) ? "" : " or weaker"); - } else if ((child_info->flags & ZEND_ACC_STATIC) == 0) { - zval_ptr_dtor(&(ce->default_properties_table[parent_info->offset])); - ce->default_properties_table[parent_info->offset] = ce->default_properties_table[child_info->offset]; - ce->default_properties_table[child_info->offset] = NULL; - child_info->offset = parent_info->offset; - } - return 0; /* Don't copy from parent */ - } else { - return 1; /* Copy from parent */ + return; + case ZEND_AST_DIM: + opline = zend_compile_dim_common(NULL, var_ast, BP_VAR_UNSET); + opline->opcode = ZEND_UNSET_DIM; + return; + case ZEND_AST_PROP: + opline = zend_compile_prop_common(NULL, var_ast, BP_VAR_UNSET); + opline->opcode = ZEND_UNSET_OBJ; + return; + case ZEND_AST_STATIC_PROP: + opline = zend_compile_static_prop_common(NULL, var_ast, BP_VAR_UNSET, 0); + opline->opcode = ZEND_UNSET_VAR; + return; + EMPTY_SWITCH_DEFAULT_CASE() } } /* }}} */ -static inline void do_implement_interface(zend_class_entry *ce, zend_class_entry *iface TSRMLS_DC) /* {{{ */ +static void zend_free_foreach_and_switch_variables(void) /* {{{ */ { - if (!(ce->ce_flags & ZEND_ACC_INTERFACE) && iface->interface_gets_implemented && iface->interface_gets_implemented(iface, ce TSRMLS_CC) == FAILURE) { - zend_error(E_CORE_ERROR, "Class %s could not implement interface %s", ce->name, iface->name); - } - if (ce == iface) { - zend_error(E_ERROR, "Interface %s cannot implement itself", ce->name); - } + zend_stack_apply(&CG(loop_var_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element)) generate_free_loop_var); } /* }}} */ -ZEND_API void zend_do_inherit_interfaces(zend_class_entry *ce, const zend_class_entry *iface TSRMLS_DC) /* {{{ */ + +void zend_compile_return(zend_ast *ast) /* {{{ */ { - /* expects interface to be contained in ce's interface list already */ - zend_uint i, ce_num, if_num = iface->num_interfaces; - zend_class_entry *entry; + zend_ast *expr_ast = ast->child[0]; + zend_bool by_ref = (CG(active_op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0; - if (if_num==0) { - return; - } - ce_num = ce->num_interfaces; + znode expr_node; + zend_op *opline; - if (ce->type == ZEND_INTERNAL_CLASS) { - ce->interfaces = (zend_class_entry **) realloc(ce->interfaces, sizeof(zend_class_entry *) * (ce_num + if_num)); + if (!expr_ast) { + expr_node.op_type = IS_CONST; + ZVAL_NULL(&expr_node.u.constant); + } else if (by_ref && zend_is_variable(expr_ast) && !zend_is_call(expr_ast)) { + zend_compile_var(&expr_node, expr_ast, BP_VAR_REF); } else { - ce->interfaces = (zend_class_entry **) erealloc(ce->interfaces, sizeof(zend_class_entry *) * (ce_num + if_num)); + zend_compile_expr(&expr_node, expr_ast); } - /* Inherit the interfaces, only if they're not already inherited by the class */ - while (if_num--) { - entry = iface->interfaces[if_num]; - for (i = 0; i < ce_num; i++) { - if (ce->interfaces[i] == entry) { - break; - } - } - if (i == ce_num) { - ce->interfaces[ce->num_interfaces++] = entry; - } + zend_free_foreach_and_switch_variables(); + + if (CG(context).in_finally) { + opline = zend_emit_op(NULL, ZEND_DISCARD_EXCEPTION, NULL, NULL); + opline->op1_type = IS_TMP_VAR; + opline->op1.var = CG(context).fast_call_var; } - /* and now call the implementing handlers */ - while (ce_num < ce->num_interfaces) { - do_implement_interface(ce, ce->interfaces[ce_num++] TSRMLS_CC); + /* Generator return types are handled separately */ + if (!(CG(active_op_array)->fn_flags & ZEND_ACC_GENERATOR) && CG(active_op_array)->fn_flags & ZEND_ACC_HAS_RETURN_TYPE) { + zend_emit_return_type_check(expr_ast ? &expr_node : NULL, CG(active_op_array)->arg_info - 1); + } + opline = zend_emit_op(NULL, by_ref ? ZEND_RETURN_BY_REF : ZEND_RETURN, + &expr_node, NULL); + + if (expr_ast) { + if (zend_is_call(expr_ast)) { + opline->extended_value = ZEND_RETURNS_FUNCTION; + } else if (by_ref && !zend_is_variable(expr_ast)) { + opline->extended_value = ZEND_RETURNS_VALUE; + } } } /* }}} */ -#ifdef ZTS -static void zval_internal_ctor(zval **p) /* {{{ */ +void zend_compile_echo(zend_ast *ast) /* {{{ */ { - zval *orig_ptr = *p; + zend_ast *expr_ast = ast->child[0]; - ALLOC_ZVAL(*p); - MAKE_COPY_ZVAL(&orig_ptr, *p); + znode expr_node; + zend_compile_expr(&expr_node, expr_ast); + + zend_emit_op(NULL, ZEND_ECHO, &expr_node, NULL); } /* }}} */ -# define zval_property_ctor(parent_ce, ce) \ - ((void (*)(void *)) (((parent_ce)->type != (ce)->type) ? zval_internal_ctor : zval_add_ref)) -#else -# define zval_property_ctor(parent_ce, ce) \ - ((void (*)(void *)) zval_add_ref) -#endif - -ZEND_API void zend_do_inheritance(zend_class_entry *ce, zend_class_entry *parent_ce TSRMLS_DC) /* {{{ */ +void zend_compile_throw(zend_ast *ast) /* {{{ */ { - zend_property_info *property_info; + zend_ast *expr_ast = ast->child[0]; - if ((ce->ce_flags & ZEND_ACC_INTERFACE) - && !(parent_ce->ce_flags & ZEND_ACC_INTERFACE)) { - zend_error_noreturn(E_COMPILE_ERROR, "Interface %s may not inherit from class (%s)", ce->name, parent_ce->name); - } - if (parent_ce->ce_flags & ZEND_ACC_FINAL_CLASS) { - zend_error_noreturn(E_COMPILE_ERROR, "Class %s may not inherit from final class (%s)", ce->name, parent_ce->name); - } + znode expr_node; + zend_compile_expr(&expr_node, expr_ast); - ce->parent = parent_ce; - /* Copy serialize/unserialize callbacks */ - if (!ce->serialize) { - ce->serialize = parent_ce->serialize; - } - if (!ce->unserialize) { - ce->unserialize = parent_ce->unserialize; - } + zend_emit_op(NULL, ZEND_THROW, &expr_node, NULL); +} +/* }}} */ - /* Inherit interfaces */ - zend_do_inherit_interfaces(ce, parent_ce TSRMLS_CC); +void zend_compile_break_continue(zend_ast *ast) /* {{{ */ +{ + zend_ast *depth_ast = ast->child[0]; - /* Inherit properties */ - if (parent_ce->default_properties_count) { - int i = ce->default_properties_count + parent_ce->default_properties_count; + zend_op *opline; + int depth; - ce->default_properties_table = perealloc(ce->default_properties_table, sizeof(void*) * i, ce->type == ZEND_INTERNAL_CLASS); - if (ce->default_properties_count) { - while (i-- > parent_ce->default_properties_count) { - ce->default_properties_table[i] = ce->default_properties_table[i - parent_ce->default_properties_count]; - } + ZEND_ASSERT(ast->kind == ZEND_AST_BREAK || ast->kind == ZEND_AST_CONTINUE); + + if (depth_ast) { + zval *depth_zv; + if (depth_ast->kind != ZEND_AST_ZVAL) { + zend_error_noreturn(E_COMPILE_ERROR, "'%s' operator with non-constant operand " + "is no longer supported", ast->kind == ZEND_AST_BREAK ? "break" : "continue"); } - for (i = 0; i < parent_ce->default_properties_count; i++) { - ce->default_properties_table[i] = parent_ce->default_properties_table[i]; - if (ce->default_properties_table[i]) { -#ifdef ZTS - if (parent_ce->type != ce->type) { - zval *p; - ALLOC_ZVAL(p); - MAKE_COPY_ZVAL(&ce->default_properties_table[i], p); - ce->default_properties_table[i] = p; - } else { - Z_ADDREF_P(ce->default_properties_table[i]); - } -#else - Z_ADDREF_P(ce->default_properties_table[i]); -#endif - } + depth_zv = zend_ast_get_zval(depth_ast); + if (Z_TYPE_P(depth_zv) != IS_LONG || Z_LVAL_P(depth_zv) < 1) { + zend_error_noreturn(E_COMPILE_ERROR, "'%s' operator accepts only positive numbers", + ast->kind == ZEND_AST_BREAK ? "break" : "continue"); } - ce->default_properties_count += parent_ce->default_properties_count; - } - if (parent_ce->type != ce->type) { - /* User class extends internal class */ - zend_update_class_constants(parent_ce TSRMLS_CC); - if (parent_ce->default_static_members_count) { - int i = ce->default_static_members_count + parent_ce->default_static_members_count; + depth = Z_LVAL_P(depth_zv); + } else { + depth = 1; + } - ce->default_static_members_table = erealloc(ce->default_static_members_table, sizeof(void*) * i); - if (ce->default_static_members_count) { - while (i-- > parent_ce->default_static_members_count) { - ce->default_static_members_table[i] = ce->default_static_members_table[i - parent_ce->default_static_members_count]; - } + if (CG(context).current_brk_cont == -1) { + zend_error_noreturn(E_COMPILE_ERROR, "'%s' not in the 'loop' or 'switch' context", + ast->kind == ZEND_AST_BREAK ? "break" : "continue"); + } else { + int array_offset = CG(context).current_brk_cont; + zend_long nest_level = depth; + znode *loop_var = zend_stack_top(&CG(loop_var_stack)); + + do { + if (array_offset == -1) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot '%s' %d level%s", + ast->kind == ZEND_AST_BREAK ? "break" : "continue", + depth, depth == 1 ? "" : "s"); } - for (i = 0; i < parent_ce->default_static_members_count; i++) { - SEPARATE_ZVAL_TO_MAKE_IS_REF(&CE_STATIC_MEMBERS(parent_ce)[i]); - ce->default_static_members_table[i] = CE_STATIC_MEMBERS(parent_ce)[i]; - Z_ADDREF_P(ce->default_static_members_table[i]); + + if (nest_level > 1 && CG(context).brk_cont_array[array_offset].start >= 0) { + generate_free_loop_var(loop_var); + loop_var--; } - ce->default_static_members_count += parent_ce->default_static_members_count; - ce->static_members_table = ce->default_static_members_table; - } + + array_offset = CG(context).brk_cont_array[array_offset].parent; + } while (--nest_level > 0); + } + opline = zend_emit_op(NULL, ast->kind == ZEND_AST_BREAK ? ZEND_BRK : ZEND_CONT, NULL, NULL); + opline->op1.num = CG(context).current_brk_cont; + opline->op2.num = depth; +} +/* }}} */ + +void zend_resolve_goto_label(zend_op_array *op_array, znode *label_node, zend_op *pass2_opline) /* {{{ */ +{ + zend_label *dest; + int current, distance, free_vars; + zval *label; + znode *loop_var = NULL; + + if (pass2_opline) { + label = RT_CONSTANT(op_array, pass2_opline->op2); } else { - if (parent_ce->default_static_members_count) { - int i = ce->default_static_members_count + parent_ce->default_static_members_count; + label = &label_node->u.constant; + } + if (CG(context).labels == NULL || + (dest = zend_hash_find_ptr(CG(context).labels, Z_STR_P(label))) == NULL) { - ce->default_static_members_table = perealloc(ce->default_static_members_table, sizeof(void*) * i, ce->type == ZEND_INTERNAL_CLASS); - if (ce->default_static_members_count) { - while (i-- > parent_ce->default_static_members_count) { - ce->default_static_members_table[i] = ce->default_static_members_table[i - parent_ce->default_static_members_count]; + if (pass2_opline) { + CG(in_compilation) = 1; + CG(active_op_array) = op_array; + CG(zend_lineno) = pass2_opline->lineno; + zend_error_noreturn(E_COMPILE_ERROR, "'goto' to undefined label '%s'", Z_STRVAL_P(label)); + } else { + /* Label is not defined. Delay to pass 2. */ + zend_op *opline; + + current = CG(context).current_brk_cont; + while (current != -1) { + if (CG(context).brk_cont_array[current].start >= 0) { + zend_emit_op(NULL, ZEND_NOP, NULL, NULL); } + current = CG(context).brk_cont_array[current].parent; } - for (i = 0; i < parent_ce->default_static_members_count; i++) { - SEPARATE_ZVAL_TO_MAKE_IS_REF(&parent_ce->default_static_members_table[i]); - ce->default_static_members_table[i] = parent_ce->default_static_members_table[i]; - Z_ADDREF_P(ce->default_static_members_table[i]); - } - ce->default_static_members_count += parent_ce->default_static_members_count; - if (ce->type == ZEND_USER_CLASS) { - ce->static_members_table = ce->default_static_members_table; - } + opline = zend_emit_op(NULL, ZEND_GOTO, NULL, label_node); + opline->extended_value = CG(context).current_brk_cont; + return; } } - for (zend_hash_internal_pointer_reset(&ce->properties_info); - zend_hash_get_current_data(&ce->properties_info, (void *) &property_info) == SUCCESS; - zend_hash_move_forward(&ce->properties_info)) { - if (property_info->ce == ce) { - if (property_info->flags & ZEND_ACC_STATIC) { - property_info->offset += parent_ce->default_static_members_count; + zval_dtor(label); + ZVAL_NULL(label); + + /* Check that we are not moving into loop or switch */ + if (pass2_opline) { + current = pass2_opline->extended_value; + } else { + current = CG(context).current_brk_cont; + } + if (!pass2_opline) { + loop_var = zend_stack_top(&CG(loop_var_stack)); + } + for (distance = 0, free_vars = 0; current != dest->brk_cont; distance++) { + if (current == -1) { + if (pass2_opline) { + CG(in_compilation) = 1; + CG(active_op_array) = op_array; + CG(zend_lineno) = pass2_opline->lineno; + } + zend_error_noreturn(E_COMPILE_ERROR, "'goto' into loop or switch statement is disallowed"); + } + if (CG(context).brk_cont_array[current].start >= 0) { + if (pass2_opline) { + free_vars++; } else { - property_info->offset += parent_ce->default_properties_count; + generate_free_loop_var(loop_var); + loop_var--; } } + current = CG(context).brk_cont_array[current].parent; } - zend_hash_merge_ex(&ce->properties_info, &parent_ce->properties_info, (copy_ctor_func_t) (ce->type & ZEND_INTERNAL_CLASS ? zend_duplicate_property_info_internal : zend_duplicate_property_info), sizeof(zend_property_info), (merge_checker_func_t) do_inherit_property_access_check, ce); - - zend_hash_merge(&ce->constants_table, &parent_ce->constants_table, zval_property_ctor(parent_ce, ce), NULL, sizeof(zval *), 0); - zend_hash_merge_ex(&ce->function_table, &parent_ce->function_table, (copy_ctor_func_t) do_inherit_method, sizeof(zend_function), (merge_checker_func_t) do_inherit_method_check, ce); - do_inherit_parent_constructor(ce); + if (pass2_opline) { + if (free_vars) { + current = pass2_opline->extended_value; + while (current != dest->brk_cont) { + if (CG(context).brk_cont_array[current].start >= 0) { + zend_op *brk_opline = &op_array->opcodes[CG(context).brk_cont_array[current].brk]; - if (ce->ce_flags & ZEND_ACC_IMPLICIT_ABSTRACT_CLASS && ce->type == ZEND_INTERNAL_CLASS) { - ce->ce_flags |= ZEND_ACC_EXPLICIT_ABSTRACT_CLASS; - } else if (!(ce->ce_flags & (ZEND_ACC_IMPLEMENT_INTERFACES|ZEND_ACC_IMPLEMENT_TRAITS))) { - /* The verification will be done in runtime by ZEND_VERIFY_ABSTRACT_CLASS */ - zend_verify_abstract_class(ce TSRMLS_CC); + if (brk_opline->opcode == ZEND_FREE) { + (pass2_opline - free_vars)->opcode = ZEND_FREE; + (pass2_opline - free_vars)->op1_type = brk_opline->op1_type; + if (op_array->fn_flags & ZEND_ACC_HAS_FINALLY_BLOCK) { + (pass2_opline - free_vars)->op1.var = brk_opline->op1.var; + } else { + (pass2_opline - free_vars)->op1.var = (uint32_t)(zend_intptr_t)ZEND_CALL_VAR_NUM(NULL, op_array->last_var + brk_opline->op1.var); + ZEND_VM_SET_OPCODE_HANDLER(pass2_opline - free_vars); + } + free_vars--; + } else if (brk_opline->opcode == ZEND_FE_FREE) { + (pass2_opline - free_vars)->opcode = ZEND_FE_FREE; + (pass2_opline - free_vars)->op1_type = brk_opline->op1_type; + if (op_array->fn_flags & ZEND_ACC_HAS_FINALLY_BLOCK) { + (pass2_opline - free_vars)->op1.var = brk_opline->op1.var; + } else { + (pass2_opline - free_vars)->op1.var = (uint32_t)(zend_intptr_t)ZEND_CALL_VAR_NUM(NULL, op_array->last_var + brk_opline->op1.var); + ZEND_VM_SET_OPCODE_HANDLER(pass2_opline - free_vars); + } + free_vars--; + } + } + current = CG(context).brk_cont_array[current].parent; + } + } + pass2_opline->opcode = ZEND_JMP; + pass2_opline->op1.opline_num = dest->opline_num; + SET_UNUSED(pass2_opline->op2); + pass2_opline->extended_value = 0; + } else { + zend_op *opline = zend_emit_op(NULL, ZEND_JMP, NULL, NULL); + opline->op1.opline_num = dest->opline_num; } - ce->ce_flags |= parent_ce->ce_flags & ZEND_HAS_STATIC_IN_METHODS; } /* }}} */ -static zend_bool do_inherit_constant_check(HashTable *child_constants_table, const zval **parent_constant, const zend_hash_key *hash_key, const zend_class_entry *iface) /* {{{ */ +void zend_compile_goto(zend_ast *ast) /* {{{ */ { - zval **old_constant; + zend_ast *label_ast = ast->child[0]; + znode label_node; - if (zend_hash_quick_find(child_constants_table, hash_key->arKey, hash_key->nKeyLength, hash_key->h, (void**)&old_constant) == SUCCESS) { - if (*old_constant != *parent_constant) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot inherit previously-inherited or override constant %s from interface %s", hash_key->arKey, iface->name); - } - return 0; + zend_compile_expr(&label_node, label_ast); + zend_resolve_goto_label(CG(active_op_array), &label_node, NULL); +} +/* }}} */ + +void zend_compile_label(zend_ast *ast) /* {{{ */ +{ + zend_string *label = zend_ast_get_str(ast->child[0]); + zend_label dest; + + if (!CG(context).labels) { + ALLOC_HASHTABLE(CG(context).labels); + zend_hash_init(CG(context).labels, 8, NULL, ptr_dtor, 0); + } + + dest.brk_cont = CG(context).current_brk_cont; + dest.opline_num = get_next_op_number(CG(active_op_array)); + + if (!zend_hash_add_mem(CG(context).labels, label, &dest, sizeof(zend_label))) { + zend_error_noreturn(E_COMPILE_ERROR, "Label '%s' already defined", ZSTR_VAL(label)); } - return 1; } /* }}} */ -static int do_interface_constant_check(zval **val TSRMLS_DC, int num_args, va_list args, const zend_hash_key *key) /* {{{ */ +void zend_compile_while(zend_ast *ast) /* {{{ */ { - zend_class_entry **iface = va_arg(args, zend_class_entry**); + zend_ast *cond_ast = ast->child[0]; + zend_ast *stmt_ast = ast->child[1]; + znode cond_node; + uint32_t opnum_start, opnum_jmp, opnum_cond; + + opnum_jmp = zend_emit_jump(0); + + zend_begin_loop(NULL); + + opnum_start = get_next_op_number(CG(active_op_array)); + zend_compile_stmt(stmt_ast); - do_inherit_constant_check(&(*iface)->constants_table, (const zval **) val, key, *iface); + opnum_cond = get_next_op_number(CG(active_op_array)); + zend_update_jump_target(opnum_jmp, opnum_cond); + zend_compile_expr(&cond_node, cond_ast); - return ZEND_HASH_APPLY_KEEP; + zend_emit_cond_jump(ZEND_JMPNZ, &cond_node, opnum_start); + + zend_end_loop(opnum_cond); } /* }}} */ -ZEND_API void zend_do_implement_interface(zend_class_entry *ce, zend_class_entry *iface TSRMLS_DC) /* {{{ */ +void zend_compile_do_while(zend_ast *ast) /* {{{ */ { - zend_uint i, ignore = 0; - zend_uint current_iface_num = ce->num_interfaces; - zend_uint parent_iface_num = ce->parent ? ce->parent->num_interfaces : 0; + zend_ast *stmt_ast = ast->child[0]; + zend_ast *cond_ast = ast->child[1]; - for (i = 0; i < ce->num_interfaces; i++) { - if (ce->interfaces[i] == NULL) { - memmove(ce->interfaces + i, ce->interfaces + i + 1, sizeof(zend_class_entry*) * (--ce->num_interfaces - i)); - i--; - } else if (ce->interfaces[i] == iface) { - if (i < parent_iface_num) { - ignore = 1; - } else { - zend_error_noreturn(E_COMPILE_ERROR, "Class %s cannot implement previously implemented interface %s", ce->name, iface->name); - } - } - } - if (ignore) { - /* Check for attempt to redeclare interface constants */ - zend_hash_apply_with_arguments(&ce->constants_table TSRMLS_CC, (apply_func_args_t) do_interface_constant_check, 1, &iface); - } else { - if (ce->num_interfaces >= current_iface_num) { - if (ce->type == ZEND_INTERNAL_CLASS) { - ce->interfaces = (zend_class_entry **) realloc(ce->interfaces, sizeof(zend_class_entry *) * (++current_iface_num)); - } else { - ce->interfaces = (zend_class_entry **) erealloc(ce->interfaces, sizeof(zend_class_entry *) * (++current_iface_num)); - } - } - ce->interfaces[ce->num_interfaces++] = iface; + znode cond_node; + uint32_t opnum_start, opnum_cond; - zend_hash_merge_ex(&ce->constants_table, &iface->constants_table, (copy_ctor_func_t) zval_add_ref, sizeof(zval *), (merge_checker_func_t) do_inherit_constant_check, iface); - zend_hash_merge_ex(&ce->function_table, &iface->function_table, (copy_ctor_func_t) do_inherit_method, sizeof(zend_function), (merge_checker_func_t) do_inherit_method_check, ce); + zend_begin_loop(NULL); - do_implement_interface(ce, iface TSRMLS_CC); - zend_do_inherit_interfaces(ce, iface TSRMLS_CC); - } + opnum_start = get_next_op_number(CG(active_op_array)); + zend_compile_stmt(stmt_ast); + + opnum_cond = get_next_op_number(CG(active_op_array)); + zend_compile_expr(&cond_node, cond_ast); + + zend_emit_cond_jump(ZEND_JMPNZ, &cond_node, opnum_start); + + zend_end_loop(opnum_cond); } /* }}} */ -ZEND_API void zend_do_implement_trait(zend_class_entry *ce, zend_class_entry *trait TSRMLS_DC) /* {{{ */ +void zend_compile_expr_list(znode *result, zend_ast *ast) /* {{{ */ { - zend_uint i, ignore = 0; - zend_uint current_trait_num = ce->num_traits; - zend_uint parent_trait_num = ce->parent ? ce->parent->num_traits : 0; + zend_ast_list *list; + uint32_t i; - for (i = 0; i < ce->num_traits; i++) { - if (ce->traits[i] == NULL) { - memmove(ce->traits + i, ce->traits + i + 1, sizeof(zend_class_entry*) * (--ce->num_traits - i)); - i--; - } else if (ce->traits[i] == trait) { - if (i < parent_trait_num) { - ignore = 1; - } - } + result->op_type = IS_CONST; + ZVAL_TRUE(&result->u.constant); + + if (!ast) { + return; } - if (!ignore) { - if (ce->num_traits >= current_trait_num) { - if (ce->type == ZEND_INTERNAL_CLASS) { - ce->traits = (zend_class_entry **) realloc(ce->traits, sizeof(zend_class_entry *) * (++current_trait_num)); - } else { - ce->traits = (zend_class_entry **) erealloc(ce->traits, sizeof(zend_class_entry *) * (++current_trait_num)); - } - } - ce->traits[ce->num_traits++] = trait; - } -} -/* }}} */ - -static zend_bool zend_traits_method_compatibility_check(zend_function *fn, zend_function *other_fn TSRMLS_DC) /* {{{ */ -{ - zend_uint fn_flags = fn->common.scope->ce_flags; - zend_uint other_flags = other_fn->common.scope->ce_flags; - - return zend_do_perform_implementation_check(fn, other_fn TSRMLS_CC) - && ((other_fn->common.scope->ce_flags & ZEND_ACC_INTERFACE) || zend_do_perform_implementation_check(other_fn, fn TSRMLS_CC)) - && ((fn_flags & (ZEND_ACC_FINAL|ZEND_ACC_STATIC)) == - (other_flags & (ZEND_ACC_FINAL|ZEND_ACC_STATIC))); /* equal final and static qualifier */ -} -/* }}} */ - -static void zend_add_magic_methods(zend_class_entry* ce, const char* mname, uint mname_len, zend_function* fe TSRMLS_DC) /* {{{ */ -{ - if (!strncmp(mname, ZEND_CLONE_FUNC_NAME, mname_len)) { - ce->clone = fe; fe->common.fn_flags |= ZEND_ACC_CLONE; - } else if (!strncmp(mname, ZEND_CONSTRUCTOR_FUNC_NAME, mname_len)) { - if (ce->constructor && (!ce->parent || ce->constructor != ce->parent->constructor)) { - zend_error_noreturn(E_COMPILE_ERROR, "%s has colliding constructor definitions coming from traits", ce->name); - } - ce->constructor = fe; fe->common.fn_flags |= ZEND_ACC_CTOR; - } else if (!strncmp(mname, ZEND_DESTRUCTOR_FUNC_NAME, mname_len)) { - ce->destructor = fe; fe->common.fn_flags |= ZEND_ACC_DTOR; - } else if (!strncmp(mname, ZEND_GET_FUNC_NAME, mname_len)) { - ce->__get = fe; - } else if (!strncmp(mname, ZEND_SET_FUNC_NAME, mname_len)) { - ce->__set = fe; - } else if (!strncmp(mname, ZEND_CALL_FUNC_NAME, mname_len)) { - ce->__call = fe; - } else if (!strncmp(mname, ZEND_UNSET_FUNC_NAME, mname_len)) { - ce->__unset = fe; - } else if (!strncmp(mname, ZEND_ISSET_FUNC_NAME, mname_len)) { - ce->__isset = fe; - } else if (!strncmp(mname, ZEND_CALLSTATIC_FUNC_NAME, mname_len)) { - ce->__callstatic = fe; - } else if (!strncmp(mname, ZEND_TOSTRING_FUNC_NAME, mname_len)) { - ce->__tostring = fe; - } else if (!strncmp(mname, ZEND_DEBUGINFO_FUNC_NAME, mname_len)) { - ce->__debugInfo = fe; - } else if (ce->name_length + 1 == mname_len) { - char *lowercase_name = emalloc(ce->name_length + 1); - zend_str_tolower_copy(lowercase_name, ce->name, ce->name_length); - lowercase_name = (char*)zend_new_interned_string(lowercase_name, ce->name_length + 1, 1 TSRMLS_CC); - if (!memcmp(mname, lowercase_name, mname_len)) { - if (ce->constructor && (!ce->parent || ce->constructor != ce->parent->constructor)) { - zend_error_noreturn(E_COMPILE_ERROR, "%s has colliding constructor definitions coming from traits", ce->name); - } - ce->constructor = fe; - fe->common.fn_flags |= ZEND_ACC_CTOR; - } - str_efree(lowercase_name); + + list = zend_ast_get_list(ast); + for (i = 0; i < list->children; ++i) { + zend_ast *expr_ast = list->child[i]; + + zend_do_free(result); + zend_compile_expr(result, expr_ast); } } /* }}} */ -static void zend_add_trait_method(zend_class_entry *ce, const char *name, const char *arKey, uint nKeyLength, zend_function *fn, HashTable **overriden TSRMLS_DC) /* {{{ */ +void zend_compile_for(zend_ast *ast) /* {{{ */ { - zend_function *existing_fn = NULL; - ulong h = zend_hash_func(arKey, nKeyLength); + zend_ast *init_ast = ast->child[0]; + zend_ast *cond_ast = ast->child[1]; + zend_ast *loop_ast = ast->child[2]; + zend_ast *stmt_ast = ast->child[3]; - if (zend_hash_quick_find(&ce->function_table, arKey, nKeyLength, h, (void**) &existing_fn) == SUCCESS) { - if (existing_fn->common.scope == ce) { - /* members from the current class override trait methods */ - /* use temporary *overriden HashTable to detect hidden conflict */ - if (*overriden) { - if (zend_hash_quick_find(*overriden, arKey, nKeyLength, h, (void**) &existing_fn) == SUCCESS) { - if (existing_fn->common.fn_flags & ZEND_ACC_ABSTRACT) { - /* Make sure the trait method is compatible with previosly declared abstract method */ - if (!zend_traits_method_compatibility_check(fn, existing_fn TSRMLS_CC)) { - zend_error_noreturn(E_COMPILE_ERROR, "Declaration of %s must be compatible with %s", - zend_get_function_declaration(fn TSRMLS_CC), - zend_get_function_declaration(existing_fn TSRMLS_CC)); - } - } else if (fn->common.fn_flags & ZEND_ACC_ABSTRACT) { - /* Make sure the abstract declaration is compatible with previous declaration */ - if (!zend_traits_method_compatibility_check(existing_fn, fn TSRMLS_CC)) { - zend_error_noreturn(E_COMPILE_ERROR, "Declaration of %s must be compatible with %s", - zend_get_function_declaration(fn TSRMLS_CC), - zend_get_function_declaration(existing_fn TSRMLS_CC)); - } - return; - } - } - } else { - ALLOC_HASHTABLE(*overriden); - zend_hash_init_ex(*overriden, 2, NULL, NULL, 0, 0); - } - zend_hash_quick_update(*overriden, arKey, nKeyLength, h, fn, sizeof(zend_function), (void**)&fn); - return; - } else if (existing_fn->common.fn_flags & ZEND_ACC_ABSTRACT && - (existing_fn->common.scope->ce_flags & ZEND_ACC_INTERFACE) == 0) { - /* Make sure the trait method is compatible with previosly declared abstract method */ - if (!zend_traits_method_compatibility_check(fn, existing_fn TSRMLS_CC)) { - zend_error_noreturn(E_COMPILE_ERROR, "Declaration of %s must be compatible with %s", - zend_get_function_declaration(fn TSRMLS_CC), - zend_get_function_declaration(existing_fn TSRMLS_CC)); - } - } else if (fn->common.fn_flags & ZEND_ACC_ABSTRACT) { - /* Make sure the abstract declaration is compatible with previous declaration */ - if (!zend_traits_method_compatibility_check(existing_fn, fn TSRMLS_CC)) { - zend_error_noreturn(E_COMPILE_ERROR, "Declaration of %s must be compatible with %s", - zend_get_function_declaration(fn TSRMLS_CC), - zend_get_function_declaration(existing_fn TSRMLS_CC)); - } - return; - } else if ((existing_fn->common.scope->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) { - /* two traits can't define the same non-abstract method */ -#if 1 - zend_error_noreturn(E_COMPILE_ERROR, "Trait method %s has not been applied, because there are collisions with other trait methods on %s", - name, ce->name); -#else /* TODO: better error message */ - zend_error_noreturn(E_COMPILE_ERROR, "Trait method %s::%s has not been applied as %s::%s, because of collision with %s::%s", - fn->common.scope->name, fn->common.function_name, - ce->name, name, - existing_fn->common.scope->name, existing_fn->common.function_name); -#endif - } else { - /* inherited members are overridden by members inserted by traits */ - /* check whether the trait method fulfills the inheritance requirements */ - do_inheritance_check_on_method(fn, existing_fn TSRMLS_CC); - fn->common.prototype = NULL; - } - } + znode result; + uint32_t opnum_start, opnum_jmp, opnum_loop; + + zend_compile_expr_list(&result, init_ast); + zend_do_free(&result); + + opnum_jmp = zend_emit_jump(0); + + zend_begin_loop(NULL); + + opnum_start = get_next_op_number(CG(active_op_array)); + zend_compile_stmt(stmt_ast); + + opnum_loop = get_next_op_number(CG(active_op_array)); + zend_compile_expr_list(&result, loop_ast); + zend_do_free(&result); + + zend_update_jump_target_to_next(opnum_jmp); + zend_compile_expr_list(&result, cond_ast); + zend_do_extended_info(); + + zend_emit_cond_jump(ZEND_JMPNZ, &result, opnum_start); - function_add_ref(fn); - zend_hash_quick_update(&ce->function_table, arKey, nKeyLength, h, fn, sizeof(zend_function), (void**)&fn); - zend_add_magic_methods(ce, arKey, nKeyLength, fn TSRMLS_CC); + zend_end_loop(opnum_loop); } /* }}} */ -static int zend_fixup_trait_method(zend_function *fn, zend_class_entry *ce TSRMLS_DC) /* {{{ */ +void zend_compile_foreach(zend_ast *ast) /* {{{ */ { - if ((fn->common.scope->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) { + zend_ast *expr_ast = ast->child[0]; + zend_ast *value_ast = ast->child[1]; + zend_ast *key_ast = ast->child[2]; + zend_ast *stmt_ast = ast->child[3]; + zend_bool by_ref = value_ast->kind == ZEND_AST_REF; + zend_bool is_variable = zend_is_variable(expr_ast) && !zend_is_call(expr_ast) + && zend_can_write_to_variable(expr_ast); - fn->common.scope = ce; + znode expr_node, reset_node, value_node, key_node; + zend_op *opline; + uint32_t opnum_reset, opnum_fetch; - if (fn->common.fn_flags & ZEND_ACC_ABSTRACT) { - ce->ce_flags |= ZEND_ACC_IMPLICIT_ABSTRACT_CLASS; + if (key_ast) { + if (key_ast->kind == ZEND_AST_REF) { + zend_error_noreturn(E_COMPILE_ERROR, "Key element cannot be a reference"); } - if (fn->type == ZEND_USER_FUNCTION && fn->op_array.static_variables) { - ce->ce_flags |= ZEND_HAS_STATIC_IN_METHODS; + if (key_ast->kind == ZEND_AST_LIST) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use list as key element"); } } - return ZEND_HASH_APPLY_KEEP; -} -/* }}} */ - -static int zend_traits_copy_functions(zend_function *fn TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */ -{ - zend_class_entry *ce; - HashTable **overriden; - zend_trait_alias *alias, **alias_ptr; - HashTable *exclude_table; - char *lcname; - unsigned int fnname_len; - zend_function fn_copy; - void *dummy; - ce = va_arg(args, zend_class_entry*); - overriden = va_arg(args, HashTable**); - exclude_table = va_arg(args, HashTable*); + if (by_ref) { + value_ast = value_ast->child[0]; + } - fnname_len = hash_key->nKeyLength - 1; + if (by_ref && is_variable) { + zend_compile_var(&expr_node, expr_ast, BP_VAR_W); + } else { + zend_compile_expr(&expr_node, expr_ast); + } - /* apply aliases which are qualified with a class name, there should not be any ambiguity */ - if (ce->trait_aliases) { - alias_ptr = ce->trait_aliases; - alias = *alias_ptr; - while (alias) { - /* Scope unset or equal to the function we compare to, and the alias applies to fn */ - if (alias->alias != NULL - && (!alias->trait_method->ce || fn->common.scope == alias->trait_method->ce) - && alias->trait_method->mname_len == fnname_len - && (zend_binary_strcasecmp(alias->trait_method->method_name, alias->trait_method->mname_len, hash_key->arKey, fnname_len) == 0)) { - fn_copy = *fn; + if (by_ref) { + zend_separate_if_call_and_write(&expr_node, expr_ast, BP_VAR_W); + } - /* if it is 0, no modifieres has been changed */ - if (alias->modifiers) { - fn_copy.common.fn_flags = alias->modifiers | (fn->common.fn_flags ^ (fn->common.fn_flags & ZEND_ACC_PPP_MASK)); - } + opnum_reset = get_next_op_number(CG(active_op_array)); + opline = zend_emit_op(&reset_node, by_ref ? ZEND_FE_RESET_RW : ZEND_FE_RESET_R, &expr_node, NULL); - lcname = zend_str_tolower_dup(alias->alias, alias->alias_len); - zend_add_trait_method(ce, alias->alias, lcname, alias->alias_len+1, &fn_copy, overriden TSRMLS_CC); - efree(lcname); + opnum_fetch = get_next_op_number(CG(active_op_array)); + opline = zend_emit_op(NULL, by_ref ? ZEND_FE_FETCH_RW : ZEND_FE_FETCH_R, &reset_node, NULL); - /* Record the trait from which this alias was resolved. */ - if (!alias->trait_method->ce) { - alias->trait_method->ce = fn->common.scope; - } - } - alias_ptr++; - alias = *alias_ptr; + if (value_ast->kind == ZEND_AST_VAR && + zend_try_compile_cv(&value_node, value_ast) == SUCCESS) { + SET_NODE(opline->op2, &value_node); + } else { + opline->op2_type = IS_VAR; + opline->op2.var = get_temporary_variable(CG(active_op_array)); + GET_NODE(&value_node, opline->op2); + if (by_ref) { + zend_emit_assign_ref_znode(value_ast, &value_node); + } else { + zend_emit_assign_znode(value_ast, &value_node); } } - lcname = (char *) hash_key->arKey; + if (key_ast) { + opline = &CG(active_op_array)->opcodes[opnum_fetch]; + zend_make_tmp_result(&key_node, opline); + zend_emit_assign_znode(key_ast, &key_node); + } - if (exclude_table == NULL || zend_hash_find(exclude_table, lcname, fnname_len, &dummy) == FAILURE) { - /* is not in hashtable, thus, function is not to be excluded */ - fn_copy = *fn; + reset_node.flag = 1; /* generate FE_FREE */ + zend_begin_loop(&reset_node); - /* apply aliases which have not alias name, just setting visibility */ - if (ce->trait_aliases) { - alias_ptr = ce->trait_aliases; - alias = *alias_ptr; - while (alias) { - /* Scope unset or equal to the function we compare to, and the alias applies to fn */ - if (alias->alias == NULL && alias->modifiers != 0 - && (!alias->trait_method->ce || fn->common.scope == alias->trait_method->ce) - && (alias->trait_method->mname_len == fnname_len) - && (zend_binary_strcasecmp(alias->trait_method->method_name, alias->trait_method->mname_len, lcname, fnname_len) == 0)) { + zend_compile_stmt(stmt_ast); - fn_copy.common.fn_flags = alias->modifiers | (fn->common.fn_flags ^ (fn->common.fn_flags & ZEND_ACC_PPP_MASK)); + zend_emit_jump(opnum_fetch); - /** Record the trait from which this alias was resolved. */ - if (!alias->trait_method->ce) { - alias->trait_method->ce = fn->common.scope; - } - } - alias_ptr++; - alias = *alias_ptr; - } - } + opline = &CG(active_op_array)->opcodes[opnum_reset]; + opline->op2.opline_num = get_next_op_number(CG(active_op_array)); - zend_add_trait_method(ce, fn->common.function_name, lcname, fnname_len+1, &fn_copy, overriden TSRMLS_CC); - } + opline = &CG(active_op_array)->opcodes[opnum_fetch]; + opline->extended_value = get_next_op_number(CG(active_op_array)); + + zend_end_loop(opnum_fetch); - return ZEND_HASH_APPLY_KEEP; + generate_free_loop_var(&reset_node); } /* }}} */ -static void zend_check_trait_usage(zend_class_entry *ce, zend_class_entry *trait TSRMLS_DC) /* {{{ */ +void zend_compile_if(zend_ast *ast) /* {{{ */ { - zend_uint i; + zend_ast_list *list = zend_ast_get_list(ast); + uint32_t i; + uint32_t *jmp_opnums = NULL; - if ((trait->ce_flags & ZEND_ACC_TRAIT) != ZEND_ACC_TRAIT) { - zend_error_noreturn(E_COMPILE_ERROR, "Class %s is not a trait, Only traits may be used in 'as' and 'insteadof' statements", trait->name); + if (list->children > 1) { + jmp_opnums = safe_emalloc(sizeof(uint32_t), list->children - 1, 0); } - for (i = 0; i < ce->num_traits; i++) { - if (ce->traits[i] == trait) { - return; + for (i = 0; i < list->children; ++i) { + zend_ast *elem_ast = list->child[i]; + zend_ast *cond_ast = elem_ast->child[0]; + zend_ast *stmt_ast = elem_ast->child[1]; + + znode cond_node; + uint32_t opnum_jmpz; + if (cond_ast) { + zend_compile_expr(&cond_node, cond_ast); + opnum_jmpz = zend_emit_cond_jump(ZEND_JMPZ, &cond_node, 0); + } + + zend_compile_stmt(stmt_ast); + + if (i != list->children - 1) { + jmp_opnums[i] = zend_emit_jump(0); + } + + if (cond_ast) { + zend_update_jump_target_to_next(opnum_jmpz); } } - zend_error_noreturn(E_COMPILE_ERROR, "Required Trait %s wasn't added to %s", trait->name, ce->name); + + if (list->children > 1) { + for (i = 0; i < list->children - 1; ++i) { + zend_update_jump_target_to_next(jmp_opnums[i]); + } + efree(jmp_opnums); + } } /* }}} */ -static void zend_traits_init_trait_structures(zend_class_entry *ce TSRMLS_DC) /* {{{ */ +void zend_compile_switch(zend_ast *ast) /* {{{ */ { - size_t i, j = 0; - zend_trait_precedence **precedences; - zend_trait_precedence *cur_precedence; - zend_trait_method_reference *cur_method_ref; - char *lcname; - zend_bool method_exists; + zend_ast *expr_ast = ast->child[0]; + zend_ast_list *cases = zend_ast_get_list(ast->child[1]); - /* resolve class references */ - if (ce->trait_precedences) { - i = 0; - precedences = ce->trait_precedences; - ce->trait_precedences = NULL; - while ((cur_precedence = precedences[i])) { - /** Resolve classes for all precedence operations. */ - if (cur_precedence->exclude_from_classes) { - cur_method_ref = cur_precedence->trait_method; - if (!(cur_precedence->trait_method->ce = zend_fetch_class(cur_method_ref->class_name, cur_method_ref->cname_len, - ZEND_FETCH_CLASS_TRAIT|ZEND_FETCH_CLASS_NO_AUTOLOAD TSRMLS_CC))) { - zend_error_noreturn(E_COMPILE_ERROR, "Could not find trait %s", cur_method_ref->class_name); - } - zend_check_trait_usage(ce, cur_precedence->trait_method->ce TSRMLS_CC); - - /** Ensure that the prefered method is actually available. */ - lcname = zend_str_tolower_dup(cur_method_ref->method_name, - cur_method_ref->mname_len); - method_exists = zend_hash_exists(&cur_method_ref->ce->function_table, - lcname, - cur_method_ref->mname_len + 1); - efree(lcname); - if (!method_exists) { - zend_error_noreturn(E_COMPILE_ERROR, - "A precedence rule was defined for %s::%s but this method does not exist", - cur_method_ref->ce->name, - cur_method_ref->method_name); - } + uint32_t i; + zend_bool has_default_case = 0; - /** With the other traits, we are more permissive. - We do not give errors for those. This allows to be more - defensive in such definitions. - However, we want to make sure that the insteadof declaration - is consistent in itself. - */ - j = 0; - while (cur_precedence->exclude_from_classes[j]) { - char* class_name = (char*)cur_precedence->exclude_from_classes[j]; - zend_uint name_length = strlen(class_name); - - if (!(cur_precedence->exclude_from_classes[j] = zend_fetch_class(class_name, name_length, ZEND_FETCH_CLASS_TRAIT |ZEND_FETCH_CLASS_NO_AUTOLOAD TSRMLS_CC))) { - zend_error_noreturn(E_COMPILE_ERROR, "Could not find trait %s", class_name); - } - zend_check_trait_usage(ce, cur_precedence->exclude_from_classes[j] TSRMLS_CC); - - /* make sure that the trait method is not from a class mentioned in - exclude_from_classes, for consistency */ - if (cur_precedence->trait_method->ce == cur_precedence->exclude_from_classes[j]) { - zend_error(E_COMPILE_ERROR, - "Inconsistent insteadof definition. " - "The method %s is to be used from %s, but %s is also on the exclude list", - cur_method_ref->method_name, - cur_precedence->trait_method->ce->name, - cur_precedence->trait_method->ce->name); - } + znode expr_node, case_node; + zend_op *opline; + uint32_t *jmpnz_opnums = safe_emalloc(sizeof(uint32_t), cases->children, 0); + uint32_t opnum_default_jmp; - efree(class_name); - j++; - } + zend_compile_expr(&expr_node, expr_ast); + + expr_node.flag = 0; /* Generate normal FREE */ + zend_begin_loop(&expr_node); + + case_node.op_type = IS_TMP_VAR; + case_node.u.op.var = get_temporary_variable(CG(active_op_array)); + + for (i = 0; i < cases->children; ++i) { + zend_ast *case_ast = cases->child[i]; + zend_ast *cond_ast = case_ast->child[0]; + znode cond_node; + + if (!cond_ast) { + if (has_default_case) { + CG(zend_lineno) = case_ast->lineno; + zend_error_noreturn(E_COMPILE_ERROR, + "Switch statements may only contain one default clause"); } - i++; + has_default_case = 1; + continue; + } + + zend_compile_expr(&cond_node, cond_ast); + + if (expr_node.op_type == IS_CONST + && Z_TYPE(expr_node.u.constant) == IS_FALSE) { + jmpnz_opnums[i] = zend_emit_cond_jump(ZEND_JMPZ, &cond_node, 0); + } else if (expr_node.op_type == IS_CONST + && Z_TYPE(expr_node.u.constant) == IS_TRUE) { + jmpnz_opnums[i] = zend_emit_cond_jump(ZEND_JMPNZ, &cond_node, 0); + } else { + opline = zend_emit_op(NULL, ZEND_CASE, &expr_node, &cond_node); + SET_NODE(opline->result, &case_node); + if (opline->op1_type == IS_CONST) { + zval_copy_ctor(CT_CONSTANT(opline->op1)); + } + + jmpnz_opnums[i] = zend_emit_cond_jump(ZEND_JMPNZ, &case_node, 0); } - ce->trait_precedences = precedences; } - if (ce->trait_aliases) { - i = 0; - while (ce->trait_aliases[i]) { - /** For all aliases with an explicit class name, resolve the class now. */ - if (ce->trait_aliases[i]->trait_method->class_name) { - cur_method_ref = ce->trait_aliases[i]->trait_method; - if (!(cur_method_ref->ce = zend_fetch_class(cur_method_ref->class_name, cur_method_ref->cname_len, ZEND_FETCH_CLASS_TRAIT|ZEND_FETCH_CLASS_NO_AUTOLOAD TSRMLS_CC))) { - zend_error_noreturn(E_COMPILE_ERROR, "Could not find trait %s", cur_method_ref->class_name); - } - zend_check_trait_usage(ce, cur_method_ref->ce TSRMLS_CC); + opnum_default_jmp = zend_emit_jump(0); - /** And, ensure that the referenced method is resolvable, too. */ - lcname = zend_str_tolower_dup(cur_method_ref->method_name, - cur_method_ref->mname_len); - method_exists = zend_hash_exists(&cur_method_ref->ce->function_table, - lcname, cur_method_ref->mname_len + 1); - efree(lcname); + for (i = 0; i < cases->children; ++i) { + zend_ast *case_ast = cases->child[i]; + zend_ast *cond_ast = case_ast->child[0]; + zend_ast *stmt_ast = case_ast->child[1]; - if (!method_exists) { - zend_error_noreturn(E_COMPILE_ERROR, "An alias was defined for %s::%s but this method does not exist", cur_method_ref->ce->name, cur_method_ref->method_name); - } - } - i++; + if (cond_ast) { + zend_update_jump_target_to_next(jmpnz_opnums[i]); + } else { + zend_update_jump_target_to_next(opnum_default_jmp); } - } -} -/* }}} */ -static void zend_traits_compile_exclude_table(HashTable* exclude_table, zend_trait_precedence **precedences, zend_class_entry *trait) /* {{{ */ -{ - size_t i = 0, j; + zend_compile_stmt(stmt_ast); + } - if (!precedences) { - return; + if (!has_default_case) { + zend_update_jump_target_to_next(opnum_default_jmp); } - while (precedences[i]) { - if (precedences[i]->exclude_from_classes) { - j = 0; - while (precedences[i]->exclude_from_classes[j]) { - if (precedences[i]->exclude_from_classes[j] == trait) { - zend_uint lcname_len = precedences[i]->trait_method->mname_len; - char *lcname = zend_str_tolower_dup(precedences[i]->trait_method->method_name, lcname_len); - - if (zend_hash_add(exclude_table, lcname, lcname_len, NULL, 0, NULL) == FAILURE) { - efree(lcname); - zend_error_noreturn(E_COMPILE_ERROR, "Failed to evaluate a trait precedence (%s). Method of trait %s was defined to be excluded multiple times", precedences[i]->trait_method->method_name, trait->name); - } - efree(lcname); - } - ++j; - } - } - ++i; + + zend_end_loop(get_next_op_number(CG(active_op_array))); + + if (expr_node.op_type == IS_VAR || expr_node.op_type == IS_TMP_VAR) { + zend_emit_op(NULL, ZEND_FREE, &expr_node, NULL); + } else if (expr_node.op_type == IS_CONST) { + zval_dtor(&expr_node.u.constant); } + + efree(jmpnz_opnums); } /* }}} */ -static void zend_do_traits_method_binding(zend_class_entry *ce TSRMLS_DC) /* {{{ */ +void zend_compile_try(zend_ast *ast) /* {{{ */ { - zend_uint i; - HashTable *overriden = NULL; + zend_ast *try_ast = ast->child[0]; + zend_ast_list *catches = zend_ast_get_list(ast->child[1]); + zend_ast *finally_ast = ast->child[2]; + + uint32_t i; + zend_op *opline; + uint32_t try_catch_offset = zend_add_try_element( + get_next_op_number(CG(active_op_array))); + uint32_t *jmp_opnums = safe_emalloc(sizeof(uint32_t), catches->children, 0); - for (i = 0; i < ce->num_traits; i++) { - if (ce->trait_precedences) { - HashTable exclude_table; - zend_trait_precedence **precedences; + if (catches->children == 0 && !finally_ast) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use try without catch or finally"); + } - /* TODO: revisit this start size, may be its not optimal */ - zend_hash_init_ex(&exclude_table, 2, NULL, NULL, 0, 0); + zend_compile_stmt(try_ast); - precedences = ce->trait_precedences; - ce->trait_precedences = NULL; - zend_traits_compile_exclude_table(&exclude_table, precedences, ce->traits[i]); + if (catches->children != 0) { + jmp_opnums[0] = zend_emit_jump(0); + } - /* copies functions, applies defined aliasing, and excludes unused trait methods */ - zend_hash_apply_with_arguments(&ce->traits[i]->function_table TSRMLS_CC, (apply_func_args_t)zend_traits_copy_functions, 3, ce, &overriden, &exclude_table); + for (i = 0; i < catches->children; ++i) { + zend_ast *catch_ast = catches->child[i]; + zend_ast *class_ast = catch_ast->child[0]; + zend_ast *var_ast = catch_ast->child[1]; + zend_ast *stmt_ast = catch_ast->child[2]; + zval *var_name = zend_ast_get_zval(var_ast); + zend_bool is_last_catch = (i + 1 == catches->children); - zend_hash_destroy(&exclude_table); - ce->trait_precedences = precedences; - } else { - zend_hash_apply_with_arguments(&ce->traits[i]->function_table TSRMLS_CC, (apply_func_args_t)zend_traits_copy_functions, 3, ce, &overriden, NULL); + uint32_t opnum_catch; + + if (!zend_is_const_default_class_ref(class_ast)) { + zend_error_noreturn(E_COMPILE_ERROR, "Bad class name in the catch statement"); } - } - zend_hash_apply_with_argument(&ce->function_table, (apply_func_arg_t)zend_fixup_trait_method, ce TSRMLS_CC); + opnum_catch = get_next_op_number(CG(active_op_array)); + if (i == 0) { + CG(active_op_array)->try_catch_array[try_catch_offset].catch_op = opnum_catch; + } - if (ce->trait_precedences) { - i = 0; - while (ce->trait_precedences[i]) { - if (ce->trait_precedences[i]->exclude_from_classes) { - efree(ce->trait_precedences[i]->exclude_from_classes); - ce->trait_precedences[i]->exclude_from_classes = NULL; - } - i++; + CG(zend_lineno) = catch_ast->lineno; + + opline = get_next_op(CG(active_op_array)); + opline->opcode = ZEND_CATCH; + opline->op1_type = IS_CONST; + opline->op1.constant = zend_add_class_name_literal(CG(active_op_array), + zend_resolve_class_name_ast(class_ast)); + + opline->op2_type = IS_CV; + opline->op2.var = lookup_cv(CG(active_op_array), zend_string_copy(Z_STR_P(var_name))); + opline->result.num = is_last_catch; + + zend_compile_stmt(stmt_ast); + + if (!is_last_catch) { + jmp_opnums[i + 1] = zend_emit_jump(0); } + + opline = &CG(active_op_array)->opcodes[opnum_catch]; + opline->extended_value = get_next_op_number(CG(active_op_array)); } - if (overriden) { - zend_hash_destroy(overriden); - FREE_HASHTABLE(overriden); + for (i = 0; i < catches->children; ++i) { + zend_update_jump_target_to_next(jmp_opnums[i]); } -} -/* }}} */ -static zend_class_entry* find_first_definition(zend_class_entry *ce, size_t current_trait, const char* prop_name, int prop_name_length, ulong prop_hash, zend_class_entry *coliding_ce) /* {{{ */ -{ - size_t i; + if (finally_ast) { + uint32_t opnum_jmp = get_next_op_number(CG(active_op_array)) + 1; - if (coliding_ce == ce) { - for (i = 0; i < current_trait; i++) { - if (zend_hash_quick_exists(&ce->traits[i]->properties_info, prop_name, prop_name_length+1, prop_hash)) { - return ce->traits[i]; - } + if (!(CG(active_op_array)->fn_flags & ZEND_ACC_HAS_FINALLY_BLOCK)) { + CG(active_op_array)->fn_flags |= ZEND_ACC_HAS_FINALLY_BLOCK; + CG(context).fast_call_var = get_temporary_variable(CG(active_op_array)); } + + opline = zend_emit_op(NULL, ZEND_FAST_CALL, NULL, NULL); + opline->op1.opline_num = opnum_jmp + 1; + opline->result_type = IS_TMP_VAR; + opline->result.var = CG(context).fast_call_var; + + zend_emit_op(NULL, ZEND_JMP, NULL, NULL); + + CG(context).in_finally++; + zend_compile_stmt(finally_ast); + CG(context).in_finally--; + + CG(active_op_array)->try_catch_array[try_catch_offset].finally_op = opnum_jmp + 1; + CG(active_op_array)->try_catch_array[try_catch_offset].finally_end + = get_next_op_number(CG(active_op_array)); + + opline = zend_emit_op(NULL, ZEND_FAST_RET, NULL, NULL); + opline->op1_type = IS_TMP_VAR; + opline->op1.var = CG(context).fast_call_var; + + zend_update_jump_target_to_next(opnum_jmp); } - return coliding_ce; + efree(jmp_opnums); } /* }}} */ -static void zend_do_traits_property_binding(zend_class_entry *ce TSRMLS_DC) /* {{{ */ +/* Encoding declarations must already be handled during parsing */ +void zend_handle_encoding_declaration(zend_ast *ast) /* {{{ */ { - size_t i; - zend_property_info *property_info; - zend_property_info *coliding_prop; - zval compare_result; - const char* prop_name; - int prop_name_length; - ulong prop_hash; - const char* class_name_unused; - zend_bool not_compatible; - zval* prop_value; - char* doc_comment; - zend_uint flags; + zend_ast_list *declares = zend_ast_get_list(ast); + uint32_t i; + for (i = 0; i < declares->children; ++i) { + zend_ast *declare_ast = declares->child[i]; + zend_ast *name_ast = declare_ast->child[0]; + zend_ast *value_ast = declare_ast->child[1]; + zend_string *name = zend_ast_get_str(name_ast); - /* In the following steps the properties are inserted into the property table - * for that, a very strict approach is applied: - * - check for compatibility, if not compatible with any property in class -> fatal - * - if compatible, then strict notice - */ - for (i = 0; i < ce->num_traits; i++) { - for (zend_hash_internal_pointer_reset(&ce->traits[i]->properties_info); - zend_hash_get_current_data(&ce->traits[i]->properties_info, (void *) &property_info) == SUCCESS; - zend_hash_move_forward(&ce->traits[i]->properties_info)) { - /* first get the unmangeld name if necessary, - * then check whether the property is already there - */ - flags = property_info->flags; - if ((flags & ZEND_ACC_PPP_MASK) == ZEND_ACC_PUBLIC) { - prop_hash = property_info->h; - prop_name = property_info->name; - prop_name_length = property_info->name_length; - } else { - /* for private and protected we need to unmangle the names */ - zend_unmangle_property_name_ex(property_info->name, property_info->name_length, - &class_name_unused, &prop_name, &prop_name_length); - prop_hash = zend_get_hash_value(prop_name, prop_name_length + 1); + if (zend_string_equals_literal_ci(name, "encoding")) { + if (value_ast->kind != ZEND_AST_ZVAL) { + zend_error_noreturn(E_COMPILE_ERROR, "Encoding must be a literal"); } - /* next: check for conflicts with current class */ - if (zend_hash_quick_find(&ce->properties_info, prop_name, prop_name_length+1, prop_hash, (void **) &coliding_prop) == SUCCESS) { - if (coliding_prop->flags & ZEND_ACC_SHADOW) { - zend_hash_quick_del(&ce->properties_info, prop_name, prop_name_length+1, prop_hash); - flags |= ZEND_ACC_CHANGED; - } else { - if ((coliding_prop->flags & (ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC)) - == (flags & (ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC))) { - /* flags are identical, now the value needs to be checked */ - if (flags & ZEND_ACC_STATIC) { - not_compatible = (FAILURE == compare_function(&compare_result, - ce->default_static_members_table[coliding_prop->offset], - ce->traits[i]->default_static_members_table[property_info->offset] TSRMLS_CC)) - || (Z_LVAL(compare_result) != 0); - } else { - not_compatible = (FAILURE == compare_function(&compare_result, - ce->default_properties_table[coliding_prop->offset], - ce->traits[i]->default_properties_table[property_info->offset] TSRMLS_CC)) - || (Z_LVAL(compare_result) != 0); - } - } else { - /* the flags are not identical, thus, we assume properties are not compatible */ - not_compatible = 1; - } + if (CG(multibyte)) { + zend_string *encoding_name = zval_get_string(zend_ast_get_zval(value_ast)); - if (not_compatible) { - zend_error_noreturn(E_COMPILE_ERROR, - "%s and %s define the same property ($%s) in the composition of %s. However, the definition differs and is considered incompatible. Class was composed", - find_first_definition(ce, i, prop_name, prop_name_length, prop_hash, coliding_prop->ce)->name, - property_info->ce->name, - prop_name, - ce->name); - } else { - zend_error(E_STRICT, - "%s and %s define the same property ($%s) in the composition of %s. This might be incompatible, to improve maintainability consider using accessor methods in traits instead. Class was composed", - find_first_definition(ce, i, prop_name, prop_name_length, prop_hash, coliding_prop->ce)->name, - property_info->ce->name, - prop_name, - ce->name); - continue; + const zend_encoding *new_encoding, *old_encoding; + zend_encoding_filter old_input_filter; + + CG(encoding_declared) = 1; + + new_encoding = zend_multibyte_fetch_encoding(ZSTR_VAL(encoding_name)); + if (!new_encoding) { + zend_error(E_COMPILE_WARNING, "Unsupported encoding [%s]", ZSTR_VAL(encoding_name)); + } else { + old_input_filter = LANG_SCNG(input_filter); + old_encoding = LANG_SCNG(script_encoding); + zend_multibyte_set_filter(new_encoding); + + /* need to re-scan if input filter changed */ + if (old_input_filter != LANG_SCNG(input_filter) || + (old_input_filter && new_encoding != old_encoding)) { + zend_multibyte_yyinput_again(old_input_filter, old_encoding); } } - } - /* property not found, so lets add it */ - if (flags & ZEND_ACC_STATIC) { - prop_value = ce->traits[i]->default_static_members_table[property_info->offset]; + zend_string_release(encoding_name); } else { - prop_value = ce->traits[i]->default_properties_table[property_info->offset]; + zend_error(E_COMPILE_WARNING, "declare(encoding=...) ignored because " + "Zend multibyte feature is turned off by settings"); } - Z_ADDREF_P(prop_value); - - doc_comment = property_info->doc_comment ? estrndup(property_info->doc_comment, property_info->doc_comment_len) : NULL; - zend_declare_property_ex(ce, prop_name, prop_name_length, - prop_value, flags, - doc_comment, property_info->doc_comment_len TSRMLS_CC); } } } /* }}} */ -static void zend_do_check_for_inconsistent_traits_aliasing(zend_class_entry *ce TSRMLS_DC) /* {{{ */ +static int zend_declare_is_first_statement(zend_ast *ast) /* {{{ */ { - int i = 0; - zend_trait_alias* cur_alias; - char* lc_method_name; - - if (ce->trait_aliases) { - while (ce->trait_aliases[i]) { - cur_alias = ce->trait_aliases[i]; - /** The trait for this alias has not been resolved, this means, this - alias was not applied. Abort with an error. */ - if (!cur_alias->trait_method->ce) { - if (cur_alias->alias) { - /** Plain old inconsistency/typo/bug */ - zend_error_noreturn(E_COMPILE_ERROR, - "An alias (%s) was defined for method %s(), but this method does not exist", - cur_alias->alias, - cur_alias->trait_method->method_name); - } else { - /** Here are two possible cases: - 1) this is an attempt to modifiy the visibility - of a method introduce as part of another alias. - Since that seems to violate the DRY principle, - we check against it and abort. - 2) it is just a plain old inconsitency/typo/bug - as in the case where alias is set. */ - - lc_method_name = zend_str_tolower_dup(cur_alias->trait_method->method_name, - cur_alias->trait_method->mname_len); - if (zend_hash_exists(&ce->function_table, - lc_method_name, - cur_alias->trait_method->mname_len+1)) { - efree(lc_method_name); - zend_error_noreturn(E_COMPILE_ERROR, - "The modifiers for the trait alias %s() need to be changed in the same statment in which the alias is defined. Error", - cur_alias->trait_method->method_name); - } else { - efree(lc_method_name); - zend_error_noreturn(E_COMPILE_ERROR, - "The modifiers of the trait method %s() are changed, but this method does not exist. Error", - cur_alias->trait_method->method_name); + uint32_t i = 0; + zend_ast_list *file_ast = zend_ast_get_list(CG(ast)); - } - } - } - i++; + /* Check to see if this declare is preceeded only by declare statements */ + while (i < file_ast->children) { + if (file_ast->child[i] == ast) { + return SUCCESS; + } else if (file_ast->child[i] == NULL) { + /* Empty statements are not allowed prior to a declare */ + return FAILURE; + } else if (file_ast->child[i]->kind != ZEND_AST_DECLARE) { + /* declares can only be preceeded by other declares */ + return FAILURE; } + i++; } + return FAILURE; } /* }}} */ -ZEND_API void zend_do_bind_traits(zend_class_entry *ce TSRMLS_DC) /* {{{ */ +void zend_compile_declare(zend_ast *ast) /* {{{ */ { + zend_ast_list *declares = zend_ast_get_list(ast->child[0]); + zend_ast *stmt_ast = ast->child[1]; + zend_declarables orig_declarables = FC(declarables); + uint32_t i; - if (ce->num_traits <= 0) { - return; - } + for (i = 0; i < declares->children; ++i) { + zend_ast *declare_ast = declares->child[i]; + zend_ast *name_ast = declare_ast->child[0]; + zend_ast *value_ast = declare_ast->child[1]; + + zend_string *name = zend_ast_get_str(name_ast); + if (zend_string_equals_literal_ci(name, "ticks")) { + zval value_zv; + zend_const_expr_to_zval(&value_zv, value_ast); + FC(declarables).ticks = zval_get_long(&value_zv); + zval_dtor(&value_zv); + } else if (zend_string_equals_literal_ci(name, "encoding")) { + + if (FAILURE == zend_declare_is_first_statement(ast)) { + zend_error_noreturn(E_COMPILE_ERROR, "Encoding declaration pragma must be " + "the very first statement in the script"); + } + } else if (zend_string_equals_literal_ci(name, "strict_types")) { + zval value_zv; - /* complete initialization of trait strutures in ce */ - zend_traits_init_trait_structures(ce TSRMLS_CC); + if (FAILURE == zend_declare_is_first_statement(ast)) { + zend_error_noreturn(E_COMPILE_ERROR, "strict_types declaration must be " + "the very first statement in the script"); + } + + if (ast->child[1] != NULL) { + zend_error_noreturn(E_COMPILE_ERROR, "strict_types declaration must not " + "use block mode"); + } - /* first care about all methods to be flattened into the class */ - zend_do_traits_method_binding(ce TSRMLS_CC); + zend_const_expr_to_zval(&value_zv, value_ast); - /* Aliases which have not been applied indicate typos/bugs. */ - zend_do_check_for_inconsistent_traits_aliasing(ce TSRMLS_CC); + if (Z_TYPE(value_zv) != IS_LONG || (Z_LVAL(value_zv) != 0 && Z_LVAL(value_zv) != 1)) { + zend_error_noreturn(E_COMPILE_ERROR, "strict_types declaration must have 0 or 1 as its value"); + } + + if (Z_LVAL(value_zv) == 1) { + CG(active_op_array)->fn_flags |= ZEND_ACC_STRICT_TYPES; + } + + } else { + zend_error(E_COMPILE_WARNING, "Unsupported declare '%s'", ZSTR_VAL(name)); + } + } - /* then flatten the properties into it, to, mostly to notfiy developer about problems */ - zend_do_traits_property_binding(ce TSRMLS_CC); + if (stmt_ast) { + zend_compile_stmt(stmt_ast); - /* verify that all abstract methods from traits have been implemented */ - zend_verify_abstract_class(ce TSRMLS_CC); + FC(declarables) = orig_declarables; + } +} +/* }}} */ - /* now everything should be fine and an added ZEND_ACC_IMPLICIT_ABSTRACT_CLASS should be removed */ - if (ce->ce_flags & ZEND_ACC_IMPLICIT_ABSTRACT_CLASS) { - ce->ce_flags -= ZEND_ACC_IMPLICIT_ABSTRACT_CLASS; +void zend_compile_stmt_list(zend_ast *ast) /* {{{ */ +{ + zend_ast_list *list = zend_ast_get_list(ast); + uint32_t i; + for (i = 0; i < list->children; ++i) { + zend_compile_stmt(list->child[i]); } } /* }}} */ -ZEND_API int do_bind_function(const zend_op_array *op_array, zend_op *opline, HashTable *function_table, zend_bool compile_time) /* {{{ */ +ZEND_API void zend_set_function_arg_flags(zend_function *func) /* {{{ */ { - zend_function *function; - zval *op1, *op2; + uint32_t i, n; - if (compile_time) { - op1 = &CONSTANT_EX(op_array, opline->op1.constant); - op2 = &CONSTANT_EX(op_array, opline->op2.constant); - } else { - op1 = opline->op1.zv; - op2 = opline->op2.zv; + func->common.arg_flags[0] = 0; + func->common.arg_flags[1] = 0; + func->common.arg_flags[2] = 0; + if (func->common.arg_info) { + n = MIN(func->common.num_args, MAX_ARG_FLAG_NUM); + i = 0; + while (i < n) { + ZEND_SET_ARG_FLAG(func, i + 1, func->common.arg_info[i].pass_by_reference); + i++; + } + if (UNEXPECTED(func->common.fn_flags & ZEND_ACC_VARIADIC && func->common.arg_info[i].pass_by_reference)) { + uint32_t pass_by_reference = func->common.arg_info[i].pass_by_reference; + while (i < MAX_ARG_FLAG_NUM) { + ZEND_SET_ARG_FLAG(func, i + 1, pass_by_reference); + i++; + } + } } +} +/* }}} */ - zend_hash_quick_find(function_table, Z_STRVAL_P(op1), Z_STRLEN_P(op1), Z_HASH_P(op1), (void *) &function); - if (zend_hash_quick_add(function_table, Z_STRVAL_P(op2), Z_STRLEN_P(op2)+1, Z_HASH_P(op2), function, sizeof(zend_function), NULL)==FAILURE) { - int error_level = compile_time ? E_COMPILE_ERROR : E_ERROR; - zend_function *old_function; +static void zend_compile_typename(zend_ast *ast, zend_arg_info *arg_info) /* {{{ */ +{ + if (ast->kind == ZEND_AST_TYPE) { + arg_info->type_hint = ast->attr; + } else { + zend_string *class_name = zend_ast_get_str(ast); + zend_uchar type = zend_lookup_builtin_type_by_name(class_name); - if (zend_hash_quick_find(function_table, Z_STRVAL_P(op2), Z_STRLEN_P(op2)+1, Z_HASH_P(op2), (void *) &old_function)==SUCCESS - && old_function->type == ZEND_USER_FUNCTION - && old_function->op_array.last > 0) { - zend_error(error_level, "Cannot redeclare %s() (previously declared in %s:%d)", - function->common.function_name, - old_function->op_array.filename, - old_function->op_array.opcodes[0].lineno); + if (type != 0) { + arg_info->type_hint = type; } else { - zend_error(error_level, "Cannot redeclare %s()", function->common.function_name); + uint32_t fetch_type = zend_get_class_fetch_type_ast(ast); + if (fetch_type == ZEND_FETCH_CLASS_DEFAULT) { + class_name = zend_resolve_class_name_ast(ast); + zend_assert_valid_class_name(class_name); + } else { + zend_ensure_valid_class_fetch_type(fetch_type); + zend_string_addref(class_name); + } + + arg_info->type_hint = IS_OBJECT; + arg_info->class_name = class_name; } - return FAILURE; - } else { - (*function->op_array.refcount)++; - function->op_array.static_variables = NULL; /* NULL out the unbound function */ - return SUCCESS; } } /* }}} */ -void zend_prepare_reference(znode *result, znode *class_name, znode *method_name TSRMLS_DC) /* {{{ */ +void zend_compile_params(zend_ast *ast, zend_ast *return_type_ast) /* {{{ */ { - zend_trait_method_reference *method_ref = emalloc(sizeof(zend_trait_method_reference)); - method_ref->ce = NULL; + zend_ast_list *list = zend_ast_get_list(ast); + uint32_t i; + zend_op_array *op_array = CG(active_op_array); + zend_arg_info *arg_infos; + + if (return_type_ast) { + /* Use op_array->arg_info[-1] for return type hinting */ + arg_infos = safe_emalloc(sizeof(zend_arg_info), list->children + 1, 0); + arg_infos->name = NULL; + arg_infos->pass_by_reference = (op_array->fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0; + arg_infos->is_variadic = 0; + arg_infos->type_hint = 0; + arg_infos->allow_null = 0; + arg_infos->class_name = NULL; - /* REM: There should not be a need for copying, - zend_do_begin_class_declaration is also just using that string */ - if (class_name) { - zend_resolve_class_name(class_name TSRMLS_CC); - method_ref->class_name = Z_STRVAL(class_name->u.constant); - method_ref->cname_len = Z_STRLEN(class_name->u.constant); + zend_compile_typename(return_type_ast, arg_infos); + + arg_infos++; + op_array->fn_flags |= ZEND_ACC_HAS_RETURN_TYPE; } else { - method_ref->class_name = NULL; - method_ref->cname_len = 0; + if (list->children == 0) { + return; + } + arg_infos = safe_emalloc(sizeof(zend_arg_info), list->children, 0); } - method_ref->method_name = Z_STRVAL(method_name->u.constant); - method_ref->mname_len = Z_STRLEN(method_name->u.constant); + for (i = 0; i < list->children; ++i) { + zend_ast *param_ast = list->child[i]; + zend_ast *type_ast = param_ast->child[0]; + zend_ast *var_ast = param_ast->child[1]; + zend_ast *default_ast = param_ast->child[2]; + zend_string *name = zend_ast_get_str(var_ast); + zend_bool is_ref = (param_ast->attr & ZEND_PARAM_REF) != 0; + zend_bool is_variadic = (param_ast->attr & ZEND_PARAM_VARIADIC) != 0; - result->u.op.ptr = method_ref; - result->op_type = IS_TMP_VAR; -} -/* }}} */ + znode var_node, default_node; + zend_uchar opcode; + zend_op *opline; + zend_arg_info *arg_info; -void zend_add_trait_alias(znode *method_reference, znode *modifiers, znode *alias TSRMLS_DC) /* {{{ */ -{ - zend_class_entry *ce = CG(active_class_entry); - zend_trait_alias *trait_alias; + if (zend_is_auto_global(name)) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign auto-global variable %s", + ZSTR_VAL(name)); + } - if (Z_LVAL(modifiers->u.constant) == ZEND_ACC_STATIC) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use 'static' as method modifier"); - return; - } else if (Z_LVAL(modifiers->u.constant) == ZEND_ACC_ABSTRACT) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use 'abstract' as method modifier"); - return; - } else if (Z_LVAL(modifiers->u.constant) == ZEND_ACC_FINAL) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use 'final' as method modifier"); - return; + var_node.op_type = IS_CV; + var_node.u.op.var = lookup_cv(CG(active_op_array), zend_string_copy(name)); + + if (EX_VAR_TO_NUM(var_node.u.op.var) != i) { + zend_error_noreturn(E_COMPILE_ERROR, "Redefinition of parameter $%s", + ZSTR_VAL(name)); + } else if (zend_string_equals_literal(name, "this")) { + if (op_array->scope && (op_array->fn_flags & ZEND_ACC_STATIC) == 0) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this"); + } + op_array->this_var = var_node.u.op.var; + } + + if (op_array->fn_flags & ZEND_ACC_VARIADIC) { + zend_error_noreturn(E_COMPILE_ERROR, "Only the last parameter can be variadic"); + } + + if (is_variadic) { + opcode = ZEND_RECV_VARIADIC; + default_node.op_type = IS_UNUSED; + op_array->fn_flags |= ZEND_ACC_VARIADIC; + + if (default_ast) { + zend_error_noreturn(E_COMPILE_ERROR, + "Variadic parameter cannot have a default value"); + } + } else if (default_ast) { + /* we cannot substitute constants here or it will break ReflectionParameter::getDefaultValueConstantName() and ReflectionParameter::isDefaultValueConstant() */ + uint32_t cops = CG(compiler_options); + CG(compiler_options) |= ZEND_COMPILE_NO_CONSTANT_SUBSTITUTION | ZEND_COMPILE_NO_PERSISTENT_CONSTANT_SUBSTITUTION; + opcode = ZEND_RECV_INIT; + default_node.op_type = IS_CONST; + zend_const_expr_to_zval(&default_node.u.constant, default_ast); + CG(compiler_options) = cops; + } else { + opcode = ZEND_RECV; + default_node.op_type = IS_UNUSED; + op_array->required_num_args = i + 1; + } + + opline = zend_emit_op(NULL, opcode, NULL, &default_node); + SET_NODE(opline->result, &var_node); + opline->op1.num = i + 1; + + arg_info = &arg_infos[i]; + arg_info->name = zend_string_copy(name); + arg_info->pass_by_reference = is_ref; + arg_info->is_variadic = is_variadic; + arg_info->type_hint = 0; + arg_info->allow_null = 1; + arg_info->class_name = NULL; + + if (type_ast) { + zend_bool has_null_default = default_ast + && (Z_TYPE(default_node.u.constant) == IS_NULL + || (Z_TYPE(default_node.u.constant) == IS_CONSTANT + && strcasecmp(Z_STRVAL(default_node.u.constant), "NULL") == 0)); + + op_array->fn_flags |= ZEND_ACC_HAS_TYPE_HINTS; + arg_info->allow_null = has_null_default; + + zend_compile_typename(type_ast, arg_info); + + if (type_ast->kind == ZEND_AST_TYPE) { + if (arg_info->type_hint == IS_ARRAY) { + if (default_ast && !has_null_default + && Z_TYPE(default_node.u.constant) != IS_ARRAY + && !Z_CONSTANT(default_node.u.constant) + ) { + zend_error_noreturn(E_COMPILE_ERROR, "Default value for parameters " + "with array type hint can only be an array or NULL"); + } + } else if (arg_info->type_hint == IS_CALLABLE && default_ast) { + if (!has_null_default && !Z_CONSTANT(default_node.u.constant)) { + zend_error_noreturn(E_COMPILE_ERROR, "Default value for parameters " + "with callable type hint can only be NULL"); + } + } + } else { + if (default_ast && !has_null_default && !Z_CONSTANT(default_node.u.constant)) { + if (arg_info->class_name) { + zend_error_noreturn(E_COMPILE_ERROR, "Default value for parameters " + "with a class type hint can only be NULL"); + } else switch (arg_info->type_hint) { + case IS_DOUBLE: + if (Z_TYPE(default_node.u.constant) != IS_DOUBLE && Z_TYPE(default_node.u.constant) != IS_LONG) { + zend_error_noreturn(E_COMPILE_ERROR, "Default value for parameters " + "with a float type hint can only be float, integer, or NULL"); + } + break; + + default: + if (!ZEND_SAME_FAKE_TYPE(arg_info->type_hint, Z_TYPE(default_node.u.constant))) { + zend_error_noreturn(E_COMPILE_ERROR, "Default value for parameters " + "with a %s type hint can only be %s or NULL", + zend_get_type_by_const(arg_info->type_hint), zend_get_type_by_const(arg_info->type_hint)); + } + break; + } + } + } + + /* Allocate cache slot to speed-up run-time class resolution */ + if (opline->opcode == ZEND_RECV_INIT) { + if (arg_info->class_name) { + zend_alloc_cache_slot(opline->op2.constant); + } else { + Z_CACHE_SLOT(op_array->literals[opline->op2.constant]) = -1; + } + } else { + if (arg_info->class_name) { + opline->op2.num = op_array->cache_size; + op_array->cache_size += sizeof(void*); + } else { + opline->op2.num = -1; + } + } + } else { + if (opline->opcode == ZEND_RECV_INIT) { + Z_CACHE_SLOT(op_array->literals[opline->op2.constant]) = -1; + } else { + opline->op2.num = -1; + } + } } - trait_alias = emalloc(sizeof(zend_trait_alias)); - trait_alias->trait_method = (zend_trait_method_reference*)method_reference->u.op.ptr; - trait_alias->modifiers = Z_LVAL(modifiers->u.constant); - if (alias) { - trait_alias->alias = Z_STRVAL(alias->u.constant); - trait_alias->alias_len = Z_STRLEN(alias->u.constant); - } else { - trait_alias->alias = NULL; + /* These are assigned at the end to avoid unitialized memory in case of an error */ + op_array->num_args = list->children; + op_array->arg_info = arg_infos; + + /* Don't count the variadic argument */ + if (op_array->fn_flags & ZEND_ACC_VARIADIC) { + op_array->num_args--; } - zend_add_to_list(&ce->trait_aliases, trait_alias TSRMLS_CC); + zend_set_function_arg_flags((zend_function*)op_array); } /* }}} */ -void zend_add_trait_precedence(znode *method_reference, znode *trait_list TSRMLS_DC) /* {{{ */ +void zend_compile_closure_uses(zend_ast *ast) /* {{{ */ { - zend_class_entry *ce = CG(active_class_entry); - zend_trait_precedence *trait_precedence = emalloc(sizeof(zend_trait_precedence)); + zend_ast_list *list = zend_ast_get_list(ast); + uint32_t i; + + for (i = 0; i < list->children; ++i) { + zend_ast *var_ast = list->child[i]; + zend_string *name = zend_ast_get_str(var_ast); + zend_bool by_ref = var_ast->attr; + zval zv; - trait_precedence->trait_method = (zend_trait_method_reference*)method_reference->u.op.ptr; - trait_precedence->exclude_from_classes = (zend_class_entry**) trait_list->u.op.ptr; + if (zend_string_equals_literal(name, "this")) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use $this as lexical variable"); + } - zend_add_to_list(&ce->trait_precedences, trait_precedence TSRMLS_CC); + ZVAL_NULL(&zv); + Z_CONST_FLAGS(zv) = by_ref ? IS_LEXICAL_REF : IS_LEXICAL_VAR; + + zend_compile_static_var_common(var_ast, &zv, by_ref); + } } /* }}} */ -ZEND_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) /* {{{ */ +void zend_begin_method_decl(zend_op_array *op_array, zend_string *name, zend_bool has_body) /* {{{ */ { - zend_class_entry *ce, **pce; - zval *op1, *op2; + zend_class_entry *ce = CG(active_class_entry); + zend_bool in_interface = (ce->ce_flags & ZEND_ACC_INTERFACE) != 0; + zend_bool in_trait = (ce->ce_flags & ZEND_ACC_TRAIT) != 0; + zend_bool is_public = (op_array->fn_flags & ZEND_ACC_PUBLIC) != 0; + zend_bool is_static = (op_array->fn_flags & ZEND_ACC_STATIC) != 0; - if (compile_time) { - op1 = &CONSTANT_EX(op_array, opline->op1.constant); - op2 = &CONSTANT_EX(op_array, opline->op2.constant); - } else { - op1 = opline->op1.zv; - op2 = opline->op2.zv; + zend_string *lcname; + + if (in_interface) { + if ((op_array->fn_flags & ZEND_ACC_PPP_MASK) != ZEND_ACC_PUBLIC) { + zend_error_noreturn(E_COMPILE_ERROR, "Access type for interface method " + "%s::%s() must be omitted", ZSTR_VAL(ce->name), ZSTR_VAL(name)); + } + op_array->fn_flags |= ZEND_ACC_ABSTRACT; } - if (zend_hash_quick_find(class_table, Z_STRVAL_P(op1), Z_STRLEN_P(op1), Z_HASH_P(op1), (void **) &pce)==FAILURE) { - zend_error_noreturn(E_COMPILE_ERROR, "Internal Zend error - Missing class information for %s", Z_STRVAL_P(op1)); - return NULL; - } else { - ce = *pce; + + if (op_array->fn_flags & ZEND_ACC_ABSTRACT) { + if (op_array->fn_flags & ZEND_ACC_PRIVATE) { + zend_error_noreturn(E_COMPILE_ERROR, "%s function %s::%s() cannot be declared private", + in_interface ? "Interface" : "Abstract", ZSTR_VAL(ce->name), ZSTR_VAL(name)); + } + + if (has_body) { + zend_error_noreturn(E_COMPILE_ERROR, "%s function %s::%s() cannot contain body", + in_interface ? "Interface" : "Abstract", ZSTR_VAL(ce->name), ZSTR_VAL(name)); + } + + ce->ce_flags |= ZEND_ACC_IMPLICIT_ABSTRACT_CLASS; + } else if (!has_body) { + zend_error_noreturn(E_COMPILE_ERROR, "Non-abstract method %s::%s() must contain body", + ZSTR_VAL(ce->name), ZSTR_VAL(name)); } - ce->refcount++; - if (zend_hash_quick_add(class_table, Z_STRVAL_P(op2), Z_STRLEN_P(op2)+1, Z_HASH_P(op2), &ce, sizeof(zend_class_entry *), NULL)==FAILURE) { - ce->refcount--; - if (!compile_time) { - /* If we're in compile time, in practice, it's quite possible - * that we'll never reach this class declaration at runtime, - * so we shut up about it. This allows the if (!defined('FOO')) { return; } - * approach to work. - */ - zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare class %s", ce->name); + + op_array->scope = ce; + op_array->function_name = zend_string_copy(name); + + lcname = zend_string_tolower(name); + lcname = zend_new_interned_string(lcname); + + if (zend_hash_add_ptr(&ce->function_table, lcname, op_array) == NULL) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare %s::%s()", + ZSTR_VAL(ce->name), ZSTR_VAL(name)); + } + + if (in_interface) { + if (zend_string_equals_literal(lcname, ZEND_CALL_FUNC_NAME)) { + if (!is_public || is_static) { + zend_error(E_WARNING, "The magic method __call() must have " + "public visibility and cannot be static"); + } + } else if (zend_string_equals_literal(lcname, ZEND_CALLSTATIC_FUNC_NAME)) { + if (!is_public || !is_static) { + zend_error(E_WARNING, "The magic method __callStatic() must have " + "public visibility and be static"); + } + } else if (zend_string_equals_literal(lcname, ZEND_GET_FUNC_NAME)) { + if (!is_public || is_static) { + zend_error(E_WARNING, "The magic method __get() must have " + "public visibility and cannot be static"); + } + } else if (zend_string_equals_literal(lcname, ZEND_SET_FUNC_NAME)) { + if (!is_public || is_static) { + zend_error(E_WARNING, "The magic method __set() must have " + "public visibility and cannot be static"); + } + } else if (zend_string_equals_literal(lcname, ZEND_UNSET_FUNC_NAME)) { + if (!is_public || is_static) { + zend_error(E_WARNING, "The magic method __unset() must have " + "public visibility and cannot be static"); + } + } else if (zend_string_equals_literal(lcname, ZEND_ISSET_FUNC_NAME)) { + if (!is_public || is_static) { + zend_error(E_WARNING, "The magic method __isset() must have " + "public visibility and cannot be static"); + } + } else if (zend_string_equals_literal(lcname, ZEND_TOSTRING_FUNC_NAME)) { + if (!is_public || is_static) { + zend_error(E_WARNING, "The magic method __toString() must have " + "public visibility and cannot be static"); + } + } else if (zend_string_equals_literal(lcname, ZEND_INVOKE_FUNC_NAME)) { + if (!is_public || is_static) { + zend_error(E_WARNING, "The magic method __invoke() must have " + "public visibility and cannot be static"); + } + } else if (zend_string_equals_literal(lcname, ZEND_DEBUGINFO_FUNC_NAME)) { + if (!is_public || is_static) { + zend_error(E_WARNING, "The magic method __debugInfo() must have " + "public visibility and cannot be static"); + } } - return NULL; } else { - if (!(ce->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_IMPLEMENT_INTERFACES|ZEND_ACC_IMPLEMENT_TRAITS))) { - zend_verify_abstract_class(ce TSRMLS_CC); + if (!in_trait && zend_string_equals_ci(lcname, ce->name)) { + if (!ce->constructor) { + ce->constructor = (zend_function *) op_array; + } + } else if (zend_string_equals_literal(lcname, ZEND_CONSTRUCTOR_FUNC_NAME)) { + ce->constructor = (zend_function *) op_array; + } else if (zend_string_equals_literal(lcname, ZEND_DESTRUCTOR_FUNC_NAME)) { + ce->destructor = (zend_function *) op_array; + } else if (zend_string_equals_literal(lcname, ZEND_CLONE_FUNC_NAME)) { + ce->clone = (zend_function *) op_array; + } else if (zend_string_equals_literal(lcname, ZEND_CALL_FUNC_NAME)) { + if (!is_public || is_static) { + zend_error(E_WARNING, "The magic method __call() must have " + "public visibility and cannot be static"); + } + ce->__call = (zend_function *) op_array; + } else if (zend_string_equals_literal(lcname, ZEND_CALLSTATIC_FUNC_NAME)) { + if (!is_public || !is_static) { + zend_error(E_WARNING, "The magic method __callStatic() must have " + "public visibility and be static"); + } + ce->__callstatic = (zend_function *) op_array; + } else if (zend_string_equals_literal(lcname, ZEND_GET_FUNC_NAME)) { + if (!is_public || is_static) { + zend_error(E_WARNING, "The magic method __get() must have " + "public visibility and cannot be static"); + } + ce->__get = (zend_function *) op_array; + ce->ce_flags |= ZEND_ACC_USE_GUARDS; + } else if (zend_string_equals_literal(lcname, ZEND_SET_FUNC_NAME)) { + if (!is_public || is_static) { + zend_error(E_WARNING, "The magic method __set() must have " + "public visibility and cannot be static"); + } + ce->__set = (zend_function *) op_array; + ce->ce_flags |= ZEND_ACC_USE_GUARDS; + } else if (zend_string_equals_literal(lcname, ZEND_UNSET_FUNC_NAME)) { + if (!is_public || is_static) { + zend_error(E_WARNING, "The magic method __unset() must have " + "public visibility and cannot be static"); + } + ce->__unset = (zend_function *) op_array; + ce->ce_flags |= ZEND_ACC_USE_GUARDS; + } else if (zend_string_equals_literal(lcname, ZEND_ISSET_FUNC_NAME)) { + if (!is_public || is_static) { + zend_error(E_WARNING, "The magic method __isset() must have " + "public visibility and cannot be static"); + } + ce->__isset = (zend_function *) op_array; + ce->ce_flags |= ZEND_ACC_USE_GUARDS; + } else if (zend_string_equals_literal(lcname, ZEND_TOSTRING_FUNC_NAME)) { + if (!is_public || is_static) { + zend_error(E_WARNING, "The magic method __toString() must have " + "public visibility and cannot be static"); + } + ce->__tostring = (zend_function *) op_array; + } else if (zend_string_equals_literal(lcname, ZEND_INVOKE_FUNC_NAME)) { + if (!is_public || is_static) { + zend_error(E_WARNING, "The magic method __invoke() must have " + "public visibility and cannot be static"); + } + } else if (zend_string_equals_literal(lcname, ZEND_DEBUGINFO_FUNC_NAME)) { + if (!is_public || is_static) { + zend_error(E_WARNING, "The magic method __debugInfo() must have " + "public visibility and cannot be static"); + } + ce->__debugInfo = (zend_function *) op_array; + } else if (!is_static) { + op_array->fn_flags |= ZEND_ACC_ALLOW_STATIC; } - return ce; } + + zend_string_release(lcname); } /* }}} */ -ZEND_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) /* {{{ */ +static void zend_begin_func_decl(znode *result, zend_op_array *op_array, zend_ast_decl *decl) /* {{{ */ { - zend_class_entry *ce, **pce; - int found_ce; - zval *op1, *op2; + zend_ast *params_ast = decl->child[0]; + zend_string *name = decl->name, *lcname; + zend_op *opline; - if (compile_time) { - op1 = &CONSTANT_EX(op_array, opline->op1.constant); - op2 = &CONSTANT_EX(op_array, opline->op2.constant); - } else { - op1 = opline->op1.zv; - op2 = opline->op2.zv; - } + op_array->function_name = name = zend_prefix_with_ns(name); - found_ce = zend_hash_quick_find(class_table, Z_STRVAL_P(op1), Z_STRLEN_P(op1), Z_HASH_P(op1), (void **) &pce); + lcname = zend_string_tolower(name); - if (found_ce == FAILURE) { - if (!compile_time) { - /* If we're in compile time, in practice, it's quite possible - * that we'll never reach this class declaration at runtime, - * so we shut up about it. This allows the if (!defined('FOO')) { return; } - * approach to work. - */ - zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare class %s", Z_STRVAL_P(op2)); + if (FC(imports_function)) { + zend_string *import_name = zend_hash_find_ptr(FC(imports_function), lcname); + if (import_name && !zend_string_equals_ci(lcname, import_name)) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot declare function %s " + "because the name is already in use", ZSTR_VAL(name)); } - return NULL; - } else { - ce = *pce; } - if (parent_ce->ce_flags & ZEND_ACC_INTERFACE) { - zend_error_noreturn(E_COMPILE_ERROR, "Class %s cannot extend from interface %s", ce->name, parent_ce->name); - } else if ((parent_ce->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) { - zend_error_noreturn(E_COMPILE_ERROR, "Class %s cannot extend from trait %s", ce->name, parent_ce->name); + if (zend_string_equals_literal(lcname, ZEND_AUTOLOAD_FUNC_NAME) + && zend_ast_get_list(params_ast)->children != 1 + ) { + zend_error_noreturn(E_COMPILE_ERROR, "%s() must take exactly 1 argument", + ZEND_AUTOLOAD_FUNC_NAME); + } + + if (op_array->fn_flags & ZEND_ACC_CLOSURE) { + opline = zend_emit_op_tmp(result, ZEND_DECLARE_LAMBDA_FUNCTION, NULL, NULL); + } else { + opline = get_next_op(CG(active_op_array)); + opline->opcode = ZEND_DECLARE_FUNCTION; + opline->op2_type = IS_CONST; + LITERAL_STR(opline->op2, zend_string_copy(lcname)); } - zend_do_inheritance(ce, parent_ce TSRMLS_CC); + { + zend_string *key = zend_build_runtime_definition_key(lcname, decl->lex_pos); - ce->refcount++; + opline->op1_type = IS_CONST; + LITERAL_STR(opline->op1, key); - /* Register the derived class */ - if (zend_hash_quick_add(class_table, Z_STRVAL_P(op2), Z_STRLEN_P(op2)+1, Z_HASH_P(op2), pce, sizeof(zend_class_entry *), NULL)==FAILURE) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare class %s", ce->name); + zend_hash_update_ptr(CG(function_table), key, op_array); } - return ce; + + zend_string_release(lcname); } /* }}} */ -void zend_do_early_binding(TSRMLS_D) /* {{{ */ +void zend_compile_func_decl(znode *result, zend_ast *ast) /* {{{ */ { - zend_op *opline = &CG(active_op_array)->opcodes[CG(active_op_array)->last-1]; - HashTable *table; + zend_ast_decl *decl = (zend_ast_decl *) ast; + zend_ast *params_ast = decl->child[0]; + zend_ast *uses_ast = decl->child[1]; + zend_ast *stmt_ast = decl->child[2]; + zend_ast *return_type_ast = decl->child[3]; + zend_bool is_method = decl->kind == ZEND_AST_METHOD; - while (opline->opcode == ZEND_TICKS && opline > CG(active_op_array)->opcodes) { - opline--; + zend_op_array *orig_op_array = CG(active_op_array); + zend_op_array *op_array = zend_arena_alloc(&CG(arena), sizeof(zend_op_array)); + zend_oparray_context orig_oparray_context; + + init_op_array(op_array, ZEND_USER_FUNCTION, INITIAL_OP_ARRAY_SIZE); + + op_array->fn_flags |= (orig_op_array->fn_flags & ZEND_ACC_STRICT_TYPES); + op_array->fn_flags |= decl->flags; + op_array->line_start = decl->start_lineno; + op_array->line_end = decl->end_lineno; + if (decl->doc_comment) { + op_array->doc_comment = zend_string_copy(decl->doc_comment); + } + if (decl->kind == ZEND_AST_CLOSURE) { + op_array->fn_flags |= ZEND_ACC_CLOSURE; } - switch (opline->opcode) { - case ZEND_DECLARE_FUNCTION: - if (do_bind_function(CG(active_op_array), opline, CG(function_table), 1) == FAILURE) { - return; - } - table = CG(function_table); - break; - case ZEND_DECLARE_CLASS: - if (do_bind_class(CG(active_op_array), opline, CG(class_table), 1 TSRMLS_CC) == NULL) { - return; - } - table = CG(class_table); - break; - case ZEND_DECLARE_INHERITED_CLASS: - { - zend_op *fetch_class_opline = opline-1; - zval *parent_name; - zend_class_entry **pce; + if (is_method) { + zend_bool has_body = stmt_ast != NULL; + zend_begin_method_decl(op_array, decl->name, has_body); + } else { + zend_begin_func_decl(result, op_array, decl); + } - parent_name = &CONSTANT(fetch_class_opline->op2.constant); - if ((zend_lookup_class(Z_STRVAL_P(parent_name), Z_STRLEN_P(parent_name), &pce TSRMLS_CC) == FAILURE) || - ((CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_CLASSES) && - ((*pce)->type == ZEND_INTERNAL_CLASS))) { - if (CG(compiler_options) & ZEND_COMPILE_DELAYED_BINDING) { - zend_uint *opline_num = &CG(active_op_array)->early_binding; + CG(active_op_array) = op_array; + zend_oparray_context_begin(&orig_oparray_context); - while (*opline_num != -1) { - opline_num = &CG(active_op_array)->opcodes[*opline_num].result.opline_num; - } - *opline_num = opline - CG(active_op_array)->opcodes; - opline->opcode = ZEND_DECLARE_INHERITED_CLASS_DELAYED; - opline->result_type = IS_UNUSED; - opline->result.opline_num = -1; - } - return; - } - if (do_bind_inherited_class(CG(active_op_array), opline, CG(class_table), *pce, 1 TSRMLS_CC) == NULL) { - return; - } - /* clear unnecessary ZEND_FETCH_CLASS opcode */ - zend_del_literal(CG(active_op_array), fetch_class_opline->op2.constant); - MAKE_NOP(fetch_class_opline); + if (CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO) { + zend_op *opline_ext = zend_emit_op(NULL, ZEND_EXT_NOP, NULL, NULL); + opline_ext->lineno = decl->start_lineno; + } - table = CG(class_table); - break; - } - case ZEND_VERIFY_ABSTRACT_CLASS: - case ZEND_ADD_INTERFACE: - case ZEND_ADD_TRAIT: - case ZEND_BIND_TRAITS: - /* We currently don't early-bind classes that implement interfaces */ - /* Classes with traits are handled exactly the same, no early-bind here */ - return; - default: - zend_error_noreturn(E_COMPILE_ERROR, "Invalid binding type"); - return; + { + /* Push a separator to the loop variable stack */ + znode dummy_var; + dummy_var.op_type = IS_UNUSED; + + zend_stack_push(&CG(loop_var_stack), (void *) &dummy_var); } - zend_hash_quick_del(table, Z_STRVAL(CONSTANT(opline->op1.constant)), Z_STRLEN(CONSTANT(opline->op1.constant)), Z_HASH_P(&CONSTANT(opline->op1.constant))); - zend_del_literal(CG(active_op_array), opline->op1.constant); - zend_del_literal(CG(active_op_array), opline->op2.constant); - MAKE_NOP(opline); + zend_compile_params(params_ast, return_type_ast); + if (uses_ast) { + zend_compile_closure_uses(uses_ast); + } + zend_compile_stmt(stmt_ast); + + if (is_method) { + zend_check_magic_method_implementation( + CG(active_class_entry), (zend_function *) op_array, E_COMPILE_ERROR); + } + + zend_do_extended_info(); + zend_emit_final_return(NULL); + + pass_two(CG(active_op_array)); + zend_oparray_context_end(&orig_oparray_context); + + /* Pop the loop variable stack separator */ + zend_stack_del_top(&CG(loop_var_stack)); + + CG(active_op_array) = orig_op_array; } /* }}} */ -ZEND_API void zend_do_delayed_early_binding(const zend_op_array *op_array TSRMLS_DC) /* {{{ */ +void zend_compile_prop_decl(zend_ast *ast) /* {{{ */ { - if (op_array->early_binding != -1) { - zend_bool orig_in_compilation = CG(in_compilation); - zend_uint opline_num = op_array->early_binding; - zend_class_entry **pce; + zend_ast_list *list = zend_ast_get_list(ast); + uint32_t flags = list->attr; + zend_class_entry *ce = CG(active_class_entry); + uint32_t i, children = list->children; + zend_string *doc_comment = NULL; - CG(in_compilation) = 1; - while (opline_num != -1) { - if (zend_lookup_class(Z_STRVAL_P(op_array->opcodes[opline_num-1].op2.zv), Z_STRLEN_P(op_array->opcodes[opline_num-1].op2.zv), &pce TSRMLS_CC) == SUCCESS) { - do_bind_inherited_class(op_array, &op_array->opcodes[opline_num], EG(class_table), *pce, 0 TSRMLS_CC); - } - opline_num = op_array->opcodes[opline_num].result.opline_num; - } - CG(in_compilation) = orig_in_compilation; + if (ce->ce_flags & ZEND_ACC_INTERFACE) { + zend_error_noreturn(E_COMPILE_ERROR, "Interfaces may not include member variables"); } -} -/* }}} */ -void zend_do_boolean_or_begin(znode *expr1, znode *op_token TSRMLS_DC) /* {{{ */ -{ - int next_op_number = get_next_op_number(CG(active_op_array)); - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + if (flags & ZEND_ACC_ABSTRACT) { + zend_error_noreturn(E_COMPILE_ERROR, "Properties cannot be declared abstract"); + } - opline->opcode = ZEND_JMPNZ_EX; - if (expr1->op_type == IS_TMP_VAR) { - SET_NODE(opline->result, expr1); - } else { - opline->result.var = get_temporary_variable(CG(active_op_array)); - opline->result_type = IS_TMP_VAR; + /* Doc comment has been appended as last element in property list */ + if (list->child[children - 1]->kind == ZEND_AST_ZVAL) { + doc_comment = zend_string_copy(zend_ast_get_str(list->child[children - 1])); + children -= 1; } - SET_NODE(opline->op1, expr1); - SET_UNUSED(opline->op2); - op_token->u.op.opline_num = next_op_number; + for (i = 0; i < children; ++i) { + zend_ast *prop_ast = list->child[i]; + zend_ast *name_ast = prop_ast->child[0]; + zend_ast *value_ast = prop_ast->child[1]; + zend_string *name = zend_ast_get_str(name_ast); + zval value_zv; - GET_NODE(expr1, opline->result); -} -/* }}} */ + if (flags & ZEND_ACC_FINAL) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot declare property %s::$%s final, " + "the final modifier is allowed only for methods and classes", + ZSTR_VAL(ce->name), ZSTR_VAL(name)); + } -void zend_do_boolean_or_end(znode *result, const znode *expr1, const znode *expr2, znode *op_token TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + if (zend_hash_exists(&ce->properties_info, name)) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare %s::$%s", + ZSTR_VAL(ce->name), ZSTR_VAL(name)); + } - *result = *expr1; /* we saved the original result in expr1 */ - opline->opcode = ZEND_BOOL; - SET_NODE(opline->result, result); - SET_NODE(opline->op1, expr2); - SET_UNUSED(opline->op2); + if (value_ast) { + zend_const_expr_to_zval(&value_zv, value_ast); + } else { + ZVAL_NULL(&value_zv); + } + + name = zend_new_interned_string_safe(name); + zend_declare_property_ex(ce, name, &value_zv, flags, doc_comment); - CG(active_op_array)->opcodes[op_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array)); + /* Doc comment is only assigned to first property */ + doc_comment = NULL; + } } /* }}} */ -void zend_do_boolean_and_begin(znode *expr1, znode *op_token TSRMLS_DC) /* {{{ */ +void zend_compile_class_const_decl(zend_ast *ast) /* {{{ */ { - int next_op_number = get_next_op_number(CG(active_op_array)); - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + zend_ast_list *list = zend_ast_get_list(ast); + zend_class_entry *ce = CG(active_class_entry); + uint32_t i; - opline->opcode = ZEND_JMPZ_EX; - if (expr1->op_type == IS_TMP_VAR) { - SET_NODE(opline->result, expr1); - } else { - opline->result.var = get_temporary_variable(CG(active_op_array)); - opline->result_type = IS_TMP_VAR; + if ((ce->ce_flags & ZEND_ACC_TRAIT) != 0) { + zend_error_noreturn(E_COMPILE_ERROR, "Traits cannot have constants"); + return; } - SET_NODE(opline->op1, expr1); - SET_UNUSED(opline->op2); - op_token->u.op.opline_num = next_op_number; + for (i = 0; i < list->children; ++i) { + zend_ast *const_ast = list->child[i]; + zend_ast *name_ast = const_ast->child[0]; + zend_ast *value_ast = const_ast->child[1]; + zend_string *name = zend_ast_get_str(name_ast); + zval value_zv; - GET_NODE(expr1, opline->result); -} -/* }}} */ - -void zend_do_boolean_and_end(znode *result, const znode *expr1, const znode *expr2, const znode *op_token TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + if (zend_string_equals_literal_ci(name, "class")) { + zend_error(E_COMPILE_ERROR, + "A class constant must not be called 'class'; it is reserved for class name fetching"); + } - *result = *expr1; /* we saved the original result in expr1 */ - opline->opcode = ZEND_BOOL; - SET_NODE(opline->result, result); - SET_NODE(opline->op1, expr2); - SET_UNUSED(opline->op2); + zend_const_expr_to_zval(&value_zv, value_ast); - CG(active_op_array)->opcodes[op_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array)); -} -/* }}} */ + name = zend_new_interned_string_safe(name); + if (zend_hash_add(&ce->constants_table, name, &value_zv) == NULL) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot redefine class constant %s::%s", + ZSTR_VAL(ce->name), ZSTR_VAL(name)); + } -void zend_do_do_while_begin(TSRMLS_D) /* {{{ */ -{ - do_begin_loop(TSRMLS_C); - INC_BPC(CG(active_op_array)); + if (Z_CONSTANT(value_zv)) { + ce->ce_flags &= ~ZEND_ACC_CONSTANTS_UPDATED; + } + } } /* }}} */ -void zend_do_do_while_end(const znode *do_token, const znode *expr_open_bracket, const znode *expr TSRMLS_DC) /* {{{ */ +static zend_trait_method_reference *zend_compile_method_ref(zend_ast *ast) /* {{{ */ { - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + zend_ast *class_ast = ast->child[0]; + zend_ast *method_ast = ast->child[1]; - opline->opcode = ZEND_JMPNZ; - SET_NODE(opline->op1, expr); - opline->op2.opline_num = do_token->u.op.opline_num; - SET_UNUSED(opline->op2); + zend_trait_method_reference *method_ref = emalloc(sizeof(zend_trait_method_reference)); + method_ref->ce = NULL; + method_ref->method_name = zend_string_copy(zend_ast_get_str(method_ast)); - do_end_loop(expr_open_bracket->u.op.opline_num, 0 TSRMLS_CC); + if (class_ast) { + method_ref->class_name = zend_resolve_class_name_ast(class_ast); + } else { + method_ref->class_name = NULL; + } - DEC_BPC(CG(active_op_array)); + return method_ref; } /* }}} */ -void zend_do_brk_cont(zend_uchar op, const znode *expr TSRMLS_DC) /* {{{ */ +static zend_string **zend_compile_name_list(zend_ast *ast) /* {{{ */ { - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + zend_ast_list *list = zend_ast_get_list(ast); + zend_string **names = safe_emalloc(sizeof(zend_string *), list->children + 1, 0); + uint32_t i; - opline->opcode = op; - opline->op1.opline_num = CG(context).current_brk_cont; - SET_UNUSED(opline->op1); - if (expr) { - if (expr->op_type != IS_CONST) { - zend_error_noreturn(E_COMPILE_ERROR, "'%s' operator with non-constant operand is no longer supported", op == ZEND_BRK ? "break" : "continue"); - } else if (Z_TYPE(expr->u.constant) != IS_LONG || Z_LVAL(expr->u.constant) < 1) { - zend_error_noreturn(E_COMPILE_ERROR, "'%s' operator accepts only positive numbers", op == ZEND_BRK ? "break" : "continue"); - } - SET_NODE(opline->op2, expr); - } else { - LITERAL_LONG(opline->op2, 1); - opline->op2_type = IS_CONST; + for (i = 0; i < list->children; ++i) { + zend_ast *name_ast = list->child[i]; + names[i] = zend_resolve_class_name_ast(name_ast); } + + names[list->children] = NULL; + + return names; } /* }}} */ -void zend_do_switch_cond(const znode *cond TSRMLS_DC) /* {{{ */ +static void zend_compile_trait_precedence(zend_ast *ast) /* {{{ */ { - zend_switch_entry switch_entry; + zend_ast *method_ref_ast = ast->child[0]; + zend_ast *insteadof_ast = ast->child[1]; - switch_entry.cond = *cond; - switch_entry.default_case = -1; - switch_entry.control_var = -1; - zend_stack_push(&CG(switch_cond_stack), (void *) &switch_entry, sizeof(switch_entry)); + zend_trait_precedence *precedence = emalloc(sizeof(zend_trait_precedence)); + precedence->trait_method = zend_compile_method_ref(method_ref_ast); + precedence->exclude_from_classes + = (void *) zend_compile_name_list(insteadof_ast); - do_begin_loop(TSRMLS_C); - - INC_BPC(CG(active_op_array)); + zend_add_to_list(&CG(active_class_entry)->trait_precedences, precedence); } /* }}} */ -void zend_do_switch_end(const znode *case_list TSRMLS_DC) /* {{{ */ +static void zend_compile_trait_alias(zend_ast *ast) /* {{{ */ { - zend_op *opline; - zend_switch_entry *switch_entry_ptr; - - zend_stack_top(&CG(switch_cond_stack), (void **) &switch_entry_ptr); - - /* add code to jmp to default case */ - if (switch_entry_ptr->default_case != -1) { - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_JMP; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); - opline->op1.opline_num = switch_entry_ptr->default_case; - } + zend_ast *method_ref_ast = ast->child[0]; + zend_ast *alias_ast = ast->child[1]; + uint32_t modifiers = ast->attr; - if (case_list->op_type != IS_UNUSED) { /* non-empty switch */ - int next_op_number = get_next_op_number(CG(active_op_array)); + zend_trait_alias *alias; - CG(active_op_array)->opcodes[case_list->u.op.opline_num].op1.opline_num = next_op_number; + if (modifiers == ZEND_ACC_STATIC) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use 'static' as method modifier"); + } else if (modifiers == ZEND_ACC_ABSTRACT) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use 'abstract' as method modifier"); + } else if (modifiers == ZEND_ACC_FINAL) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use 'final' as method modifier"); } - /* remember break/continue loop information */ - CG(active_op_array)->brk_cont_array[CG(context).current_brk_cont].cont = CG(active_op_array)->brk_cont_array[CG(context).current_brk_cont].brk = get_next_op_number(CG(active_op_array)); - CG(context).current_brk_cont = CG(active_op_array)->brk_cont_array[CG(context).current_brk_cont].parent; + alias = emalloc(sizeof(zend_trait_alias)); + alias->trait_method = zend_compile_method_ref(method_ref_ast); + alias->modifiers = modifiers; - if (switch_entry_ptr->cond.op_type==IS_VAR || switch_entry_ptr->cond.op_type==IS_TMP_VAR) { - /* emit free for the switch condition*/ - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = (switch_entry_ptr->cond.op_type == IS_TMP_VAR) ? ZEND_FREE : ZEND_SWITCH_FREE; - SET_NODE(opline->op1, &switch_entry_ptr->cond); - SET_UNUSED(opline->op2); - } - if (switch_entry_ptr->cond.op_type == IS_CONST) { - zval_dtor(&switch_entry_ptr->cond.u.constant); + if (alias_ast) { + alias->alias = zend_string_copy(zend_ast_get_str(alias_ast)); + } else { + alias->alias = NULL; } - zend_stack_del_top(&CG(switch_cond_stack)); - - DEC_BPC(CG(active_op_array)); + zend_add_to_list(&CG(active_class_entry)->trait_aliases, alias); } /* }}} */ -void zend_do_case_before_statement(const znode *case_list, znode *case_token, const znode *case_expr TSRMLS_DC) /* {{{ */ +void zend_compile_use_trait(zend_ast *ast) /* {{{ */ { - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - int next_op_number; - zend_switch_entry *switch_entry_ptr; - znode result; + zend_ast_list *traits = zend_ast_get_list(ast->child[0]); + zend_ast_list *adaptations = ast->child[1] ? zend_ast_get_list(ast->child[1]) : NULL; + zend_class_entry *ce = CG(active_class_entry); + zend_op *opline; + uint32_t i; - zend_stack_top(&CG(switch_cond_stack), (void **) &switch_entry_ptr); + for (i = 0; i < traits->children; ++i) { + zend_ast *trait_ast = traits->child[i]; + zend_string *name = zend_ast_get_str(trait_ast); - if (switch_entry_ptr->control_var == -1) { - switch_entry_ptr->control_var = get_temporary_variable(CG(active_op_array)); - } - opline->opcode = ZEND_CASE; - opline->result.var = switch_entry_ptr->control_var; - opline->result_type = IS_TMP_VAR; - SET_NODE(opline->op1, &switch_entry_ptr->cond); - SET_NODE(opline->op2, case_expr); - if (opline->op1_type == IS_CONST) { - zval_copy_ctor(&CONSTANT(opline->op1.constant)); - } - GET_NODE(&result, opline->result); + if (ce->ce_flags & ZEND_ACC_INTERFACE) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use traits inside of interfaces. " + "%s is used in %s", ZSTR_VAL(name), ZSTR_VAL(ce->name)); + } - next_op_number = get_next_op_number(CG(active_op_array)); - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_JMPZ; - SET_NODE(opline->op1, &result); - SET_UNUSED(opline->op2); - case_token->u.op.opline_num = next_op_number; + switch (zend_get_class_fetch_type(name)) { + case ZEND_FETCH_CLASS_SELF: + case ZEND_FETCH_CLASS_PARENT: + case ZEND_FETCH_CLASS_STATIC: + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as trait name " + "as it is reserved", ZSTR_VAL(name)); + break; + } + + opline = get_next_op(CG(active_op_array)); + opline->opcode = ZEND_ADD_TRAIT; + SET_NODE(opline->op1, &FC(implementing_class)); + opline->op2_type = IS_CONST; + opline->op2.constant = zend_add_class_name_literal(CG(active_op_array), + zend_resolve_class_name_ast(trait_ast)); - if (case_list->op_type==IS_UNUSED) { + ce->num_traits++; + } + + if (!adaptations) { return; } - next_op_number = get_next_op_number(CG(active_op_array)); - CG(active_op_array)->opcodes[case_list->u.op.opline_num].op1.opline_num = next_op_number; + + for (i = 0; i < adaptations->children; ++i) { + zend_ast *adaptation_ast = adaptations->child[i]; + switch (adaptation_ast->kind) { + case ZEND_AST_TRAIT_PRECEDENCE: + zend_compile_trait_precedence(adaptation_ast); + break; + case ZEND_AST_TRAIT_ALIAS: + zend_compile_trait_alias(adaptation_ast); + break; + EMPTY_SWITCH_DEFAULT_CASE() + } + } } /* }}} */ -void zend_do_case_after_statement(znode *result, const znode *case_token TSRMLS_DC) /* {{{ */ +void zend_compile_implements(znode *class_node, zend_ast *ast) /* {{{ */ { - int next_op_number = get_next_op_number(CG(active_op_array)); - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + zend_ast_list *list = zend_ast_get_list(ast); + uint32_t i; + for (i = 0; i < list->children; ++i) { + zend_ast *class_ast = list->child[i]; + zend_string *name = zend_ast_get_str(class_ast); - opline->opcode = ZEND_JMP; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); - result->u.op.opline_num = next_op_number; + zend_op *opline; - switch (CG(active_op_array)->opcodes[case_token->u.op.opline_num].opcode) { - case ZEND_JMP: - CG(active_op_array)->opcodes[case_token->u.op.opline_num].op1.opline_num = get_next_op_number(CG(active_op_array)); - break; - case ZEND_JMPZ: - CG(active_op_array)->opcodes[case_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array)); - break; + if (!zend_is_const_default_class_ref(class_ast)) { + zend_error_noreturn(E_COMPILE_ERROR, + "Cannot use '%s' as interface name as it is reserved", ZSTR_VAL(name)); + } + + opline = zend_emit_op(NULL, ZEND_ADD_INTERFACE, class_node, NULL); + opline->op2_type = IS_CONST; + opline->op2.constant = zend_add_class_name_literal(CG(active_op_array), + zend_resolve_class_name_ast(class_ast)); + + CG(active_class_entry)->num_interfaces++; } } /* }}} */ -void zend_do_default_before_statement(const znode *case_list, znode *default_token TSRMLS_DC) /* {{{ */ +static zend_string *zend_generate_anon_class_name(unsigned char *lex_pos) /* {{{ */ { - int next_op_number = get_next_op_number(CG(active_op_array)); - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - zend_switch_entry *switch_entry_ptr; - - zend_stack_top(&CG(switch_cond_stack), (void **) &switch_entry_ptr); - - opline->opcode = ZEND_JMP; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); - default_token->u.op.opline_num = next_op_number; - - next_op_number = get_next_op_number(CG(active_op_array)); - switch_entry_ptr->default_case = next_op_number; + zend_string *result; + char char_pos_buf[32]; + size_t char_pos_len = zend_sprintf(char_pos_buf, "%p", lex_pos); + zend_string *filename = CG(active_op_array)->filename; - if (case_list->op_type==IS_UNUSED) { - return; - } - CG(active_op_array)->opcodes[case_list->u.op.opline_num].op1.opline_num = next_op_number; + /* NULL, name length, filename length, last accepting char position length */ + result = zend_string_alloc(sizeof("class@anonymous") + ZSTR_LEN(filename) + char_pos_len, 0); + sprintf(ZSTR_VAL(result), "class@anonymous%c%s%s", '\0', ZSTR_VAL(filename), char_pos_buf); + return zend_new_interned_string(result); } /* }}} */ -void zend_do_begin_class_declaration(const znode *class_token, znode *class_name, const znode *parent_class_name TSRMLS_DC) /* {{{ */ +void zend_compile_class_decl(zend_ast *ast) /* {{{ */ { + zend_ast_decl *decl = (zend_ast_decl *) ast; + zend_ast *extends_ast = decl->child[0]; + zend_ast *implements_ast = decl->child[1]; + zend_ast *stmt_ast = decl->child[2]; + zend_string *name, *lcname, *import_name = NULL; + zend_class_entry *ce = zend_arena_alloc(&CG(arena), sizeof(zend_class_entry)); zend_op *opline; - int doing_inheritance = 0; - zend_class_entry *new_class_entry; - char *lcname; - int error = 0; - zval **ns_name, key; - - if (CG(active_class_entry)) { - zend_error_noreturn(E_COMPILE_ERROR, "Class declarations may not be nested"); - return; - } + znode declare_node, extends_node; - lcname = zend_str_tolower_dup(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant)); + zend_class_entry *original_ce = CG(active_class_entry); + znode original_implementing_class = FC(implementing_class); - if (!(strcmp(lcname, "self") && strcmp(lcname, "parent"))) { - efree(lcname); - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as class name as it is reserved", Z_STRVAL(class_name->u.constant)); - } + if (EXPECTED((decl->flags & ZEND_ACC_ANON_CLASS) == 0)) { + if (CG(active_class_entry)) { + zend_error_noreturn(E_COMPILE_ERROR, "Class declarations may not be nested"); + } + name = decl->name; + zend_assert_valid_class_name(name); + lcname = zend_string_tolower(name); + if (FC(current_namespace)) { + name = zend_prefix_with_ns(name); - /* Class name must not conflict with import names */ - if (CG(current_import) && - zend_hash_find(CG(current_import), lcname, Z_STRLEN(class_name->u.constant)+1, (void**)&ns_name) == SUCCESS) { - error = 1; - } + zend_string_release(lcname); + lcname = zend_string_tolower(name); + } else { + zend_string_addref(name); + } - if (CG(current_namespace)) { - /* Prefix class name with name of current namespace */ - znode tmp; + if (FC(imports)) { + import_name = zend_hash_find_ptr(FC(imports), lcname); + } + + if (import_name && !zend_string_equals_ci(lcname, import_name)) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot declare class %s " + "because the name is already in use", ZSTR_VAL(name)); + } - tmp.op_type = IS_CONST; - tmp.u.constant = *CG(current_namespace); - zval_copy_ctor(&tmp.u.constant); - zend_do_build_namespace_name(&tmp, &tmp, class_name TSRMLS_CC); - *class_name = tmp; - efree(lcname); - lcname = zend_str_tolower_dup(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant)); + name = zend_new_interned_string(name); + lcname = zend_new_interned_string(lcname); + } else { + name = zend_generate_anon_class_name(decl->lex_pos); + lcname = zend_string_copy(name); /* this normally is an interned string, except with opcache. We need a proper copy here or opcache will fail with use after free. */ } - if (error) { - char *tmp = zend_str_tolower_dup(Z_STRVAL_PP(ns_name), Z_STRLEN_PP(ns_name)); + ce->type = ZEND_USER_CLASS; + ce->name = name; + zend_initialize_class_data(ce, 1); - if (Z_STRLEN_PP(ns_name) != Z_STRLEN(class_name->u.constant) || - memcmp(tmp, lcname, Z_STRLEN(class_name->u.constant))) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot declare class %s because the name is already in use", Z_STRVAL(class_name->u.constant)); - } - efree(tmp); - } + ce->ce_flags |= decl->flags; + ce->info.user.filename = zend_get_compiled_filename(); + ce->info.user.line_start = decl->start_lineno; + ce->info.user.line_end = decl->end_lineno; - new_class_entry = emalloc(sizeof(zend_class_entry)); - new_class_entry->type = ZEND_USER_CLASS; - new_class_entry->name = zend_new_interned_string(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant) + 1, 1 TSRMLS_CC); - new_class_entry->name_length = Z_STRLEN(class_name->u.constant); + if (decl->doc_comment) { + ce->info.user.doc_comment = zend_string_copy(decl->doc_comment); + } - zend_initialize_class_data(new_class_entry, 1 TSRMLS_CC); - new_class_entry->info.user.filename = zend_get_compiled_filename(TSRMLS_C); - new_class_entry->info.user.line_start = class_token->u.op.opline_num; - new_class_entry->ce_flags |= class_token->EA; + if (UNEXPECTED((decl->flags & ZEND_ACC_ANON_CLASS))) { + /* Serialization is not supported for anonymous classes */ + ce->serialize = zend_class_serialize_deny; + ce->unserialize = zend_class_unserialize_deny; + } - if (parent_class_name && parent_class_name->op_type != IS_UNUSED) { - switch (parent_class_name->EA) { - case ZEND_FETCH_CLASS_SELF: - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use 'self' as class name as it is reserved"); - break; - case ZEND_FETCH_CLASS_PARENT: - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use 'parent' as class name as it is reserved"); - break; - case ZEND_FETCH_CLASS_STATIC: - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use 'static' as class name as it is reserved"); - break; - default: - break; + if (extends_ast) { + if (!zend_is_const_default_class_ref(extends_ast)) { + zend_string *extends_name = zend_ast_get_str(extends_ast); + zend_error_noreturn(E_COMPILE_ERROR, + "Cannot use '%s' as class name as it is reserved", ZSTR_VAL(extends_name)); } - doing_inheritance = 1; + + zend_compile_class_ref(&extends_node, extends_ast, 0); } - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->op1_type = IS_CONST; - build_runtime_defined_function_key(&key, lcname, new_class_entry->name_length TSRMLS_CC); - opline->op1.constant = zend_add_literal(CG(active_op_array), &key TSRMLS_CC); - Z_HASH_P(&CONSTANT(opline->op1.constant)) = zend_hash_func(Z_STRVAL(CONSTANT(opline->op1.constant)), Z_STRLEN(CONSTANT(opline->op1.constant))); + opline = get_next_op(CG(active_op_array)); + zend_make_var_result(&declare_node, opline); + + // TODO.AST drop this + GET_NODE(&FC(implementing_class), opline->result); opline->op2_type = IS_CONST; + LITERAL_STR(opline->op2, lcname); - if (doing_inheritance) { - /* Make sure a trait does not try to extend a class */ - if ((new_class_entry->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) { - zend_error_noreturn(E_COMPILE_ERROR, "A trait (%s) cannot extend a class. Traits can only be composed from other traits with the 'use' keyword. Error", new_class_entry->name); + if (decl->flags & ZEND_ACC_ANON_CLASS) { + if (extends_ast) { + opline->opcode = ZEND_DECLARE_ANON_INHERITED_CLASS; + opline->extended_value = extends_node.u.op.var; + } else { + opline->opcode = ZEND_DECLARE_ANON_CLASS; } - opline->extended_value = parent_class_name->u.op.var; - opline->opcode = ZEND_DECLARE_INHERITED_CLASS; + opline->op1_type = IS_UNUSED; + + zend_hash_update_ptr(CG(class_table), lcname, ce); } else { - opline->opcode = ZEND_DECLARE_CLASS; - } + zend_string *key; - LITERAL_STRINGL(opline->op2, lcname, new_class_entry->name_length, 0); - CALCULATE_LITERAL_HASH(opline->op2.constant); + if (extends_ast) { + opline->opcode = ZEND_DECLARE_INHERITED_CLASS; + opline->extended_value = extends_node.u.op.var; + } else { + opline->opcode = ZEND_DECLARE_CLASS; + } - zend_hash_quick_update(CG(class_table), Z_STRVAL(key), Z_STRLEN(key), Z_HASH_P(&CONSTANT(opline->op1.constant)), &new_class_entry, sizeof(zend_class_entry *), NULL); - CG(active_class_entry) = new_class_entry; + key = zend_build_runtime_definition_key(lcname, decl->lex_pos); - opline->result.var = get_temporary_variable(CG(active_op_array)); - opline->result_type = IS_VAR; - GET_NODE(&CG(implementing_class), opline->result); + opline->op1_type = IS_CONST; + LITERAL_STR(opline->op1, key); - if (CG(doc_comment)) { - CG(active_class_entry)->info.user.doc_comment = CG(doc_comment); - CG(active_class_entry)->info.user.doc_comment_len = CG(doc_comment_len); - CG(doc_comment) = NULL; - CG(doc_comment_len) = 0; + zend_hash_update_ptr(CG(class_table), key, ce); } -} -/* }}} */ -static void do_verify_abstract_class(TSRMLS_D) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + CG(active_class_entry) = ce; - opline->opcode = ZEND_VERIFY_ABSTRACT_CLASS; - SET_NODE(opline->op1, &CG(implementing_class)); - SET_UNUSED(opline->op2); -} -/* }}} */ + if (implements_ast) { + zend_compile_implements(&declare_node, implements_ast); + } -void zend_do_end_class_declaration(const znode *class_token, const znode *parent_token TSRMLS_DC) /* {{{ */ -{ - zend_class_entry *ce = CG(active_class_entry); + zend_compile_stmt(stmt_ast); + + if (ce->num_traits == 0) { + /* For traits this check is delayed until after trait binding */ + zend_check_deprecated_constructor(ce); + } if (ce->constructor) { ce->constructor->common.fn_flags |= ZEND_ACC_CTOR; if (ce->constructor->common.fn_flags & ZEND_ACC_STATIC) { - zend_error_noreturn(E_COMPILE_ERROR, "Constructor %s::%s() cannot be static", ce->name, ce->constructor->common.function_name); + zend_error_noreturn(E_COMPILE_ERROR, "Constructor %s::%s() cannot be static", + ZSTR_VAL(ce->name), ZSTR_VAL(ce->constructor->common.function_name)); + } + if (ce->constructor->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) { + zend_error_noreturn(E_COMPILE_ERROR, + "Constructor %s::%s() cannot declare a return type", + ZSTR_VAL(ce->name), ZSTR_VAL(ce->constructor->common.function_name)); } } if (ce->destructor) { ce->destructor->common.fn_flags |= ZEND_ACC_DTOR; if (ce->destructor->common.fn_flags & ZEND_ACC_STATIC) { - zend_error_noreturn(E_COMPILE_ERROR, "Destructor %s::%s() cannot be static", ce->name, ce->destructor->common.function_name); + zend_error_noreturn(E_COMPILE_ERROR, "Destructor %s::%s() cannot be static", + ZSTR_VAL(ce->name), ZSTR_VAL(ce->destructor->common.function_name)); + } else if (ce->destructor->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) { + zend_error_noreturn(E_COMPILE_ERROR, + "Destructor %s::%s() cannot declare a return type", + ZSTR_VAL(ce->name), ZSTR_VAL(ce->destructor->common.function_name)); } } if (ce->clone) { ce->clone->common.fn_flags |= ZEND_ACC_CLONE; if (ce->clone->common.fn_flags & ZEND_ACC_STATIC) { - zend_error_noreturn(E_COMPILE_ERROR, "Clone method %s::%s() cannot be static", ce->name, ce->clone->common.function_name); + zend_error_noreturn(E_COMPILE_ERROR, "Clone method %s::%s() cannot be static", + ZSTR_VAL(ce->name), ZSTR_VAL(ce->clone->common.function_name)); + } else if (ce->clone->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) { + zend_error_noreturn(E_COMPILE_ERROR, + "%s::%s() cannot declare a return type", + ZSTR_VAL(ce->name), ZSTR_VAL(ce->clone->common.function_name)); } } - ce->info.user.line_end = zend_get_compiled_lineno(TSRMLS_C); - /* Check for traits and proceed like with interfaces. * The only difference will be a combined handling of them in the end. * Thus, we need another opcode here. */ if (ce->num_traits > 0) { - zend_op *opline; - ce->traits = NULL; ce->num_traits = 0; ce->ce_flags |= ZEND_ACC_IMPLEMENT_TRAITS; - /* opcode generation: */ - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_BIND_TRAITS; - SET_NODE(opline->op1, &CG(implementing_class)); + zend_emit_op(NULL, ZEND_BIND_TRAITS, &declare_node, NULL); } if (!(ce->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS)) - && (parent_token || (ce->num_interfaces > 0))) { - zend_verify_abstract_class(ce TSRMLS_CC); + && (extends_ast || ce->num_interfaces > 0) + ) { + zend_verify_abstract_class(ce); if (ce->num_interfaces && !(ce->ce_flags & ZEND_ACC_IMPLEMENT_TRAITS)) { - do_verify_abstract_class(TSRMLS_C); + zend_emit_op(NULL, ZEND_VERIFY_ABSTRACT_CLASS, &declare_node, NULL); } } + /* Inherit interfaces; reset number to zero, we need it for above check and * will restore it during actual implementation. * The ZEND_ACC_IMPLEMENT_INTERFACES flag disables double call to @@ -5302,2232 +5289,2154 @@ void zend_do_end_class_declaration(const znode *class_token, const znode *parent ce->ce_flags |= ZEND_ACC_IMPLEMENT_INTERFACES; } - CG(active_class_entry) = NULL; + FC(implementing_class) = original_implementing_class; + CG(active_class_entry) = original_ce; } /* }}} */ -void zend_do_implements_interface(znode *interface_name TSRMLS_DC) /* {{{ */ +static HashTable *zend_get_import_ht(uint32_t type) /* {{{ */ { - zend_op *opline; - - /* Traits can not implement interfaces */ - if ((CG(active_class_entry)->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as interface on '%s' since it is a Trait", - Z_STRVAL(interface_name->u.constant), - CG(active_class_entry)->name); - } - - switch (zend_get_class_fetch_type(Z_STRVAL(interface_name->u.constant), Z_STRLEN(interface_name->u.constant))) { - case ZEND_FETCH_CLASS_SELF: - case ZEND_FETCH_CLASS_PARENT: - case ZEND_FETCH_CLASS_STATIC: - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as interface name as it is reserved", Z_STRVAL(interface_name->u.constant)); - break; - default: - break; + switch (type) { + case T_CLASS: + if (!FC(imports)) { + FC(imports) = emalloc(sizeof(HashTable)); + zend_hash_init(FC(imports), 8, NULL, str_dtor, 0); + } + return FC(imports); + case T_FUNCTION: + if (!FC(imports_function)) { + FC(imports_function) = emalloc(sizeof(HashTable)); + zend_hash_init(FC(imports_function), 8, NULL, str_dtor, 0); + } + return FC(imports_function); + case T_CONST: + if (!FC(imports_const)) { + FC(imports_const) = emalloc(sizeof(HashTable)); + zend_hash_init(FC(imports_const), 8, NULL, str_dtor, 0); + } + return FC(imports_const); + EMPTY_SWITCH_DEFAULT_CASE() } - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_ADD_INTERFACE; - SET_NODE(opline->op1, &CG(implementing_class)); - zend_resolve_class_name(interface_name TSRMLS_CC); - opline->extended_value = (opline->extended_value & ~ZEND_FETCH_CLASS_MASK) | ZEND_FETCH_CLASS_INTERFACE; - opline->op2_type = IS_CONST; - opline->op2.constant = zend_add_class_name_literal(CG(active_op_array), &interface_name->u.constant TSRMLS_CC); - CG(active_class_entry)->num_interfaces++; + return NULL; } /* }}} */ -void zend_do_use_trait(znode *trait_name TSRMLS_DC) /* {{{ */ +static char *zend_get_use_type_str(uint32_t type) /* {{{ */ { - zend_op *opline; - - if ((CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE)) { - zend_error_noreturn(E_COMPILE_ERROR, - "Cannot use traits inside of interfaces. %s is used in %s", - Z_STRVAL(trait_name->u.constant), CG(active_class_entry)->name); + switch (type) { + case T_CLASS: + return ""; + case T_FUNCTION: + return " function"; + case T_CONST: + return " const"; + EMPTY_SWITCH_DEFAULT_CASE() } - - switch (zend_get_class_fetch_type(Z_STRVAL(trait_name->u.constant), Z_STRLEN(trait_name->u.constant))) { - case ZEND_FETCH_CLASS_SELF: - case ZEND_FETCH_CLASS_PARENT: - case ZEND_FETCH_CLASS_STATIC: - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as trait name as it is reserved", Z_STRVAL(trait_name->u.constant)); - break; - default: - break; - } - - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_ADD_TRAIT; - SET_NODE(opline->op1, &CG(implementing_class)); - zend_resolve_class_name(trait_name TSRMLS_CC); - opline->extended_value = ZEND_FETCH_CLASS_TRAIT; - opline->op2_type = IS_CONST; - opline->op2.constant = zend_add_class_name_literal(CG(active_op_array), &trait_name->u.constant TSRMLS_CC); - CG(active_class_entry)->num_traits++; + return " unknown"; } /* }}} */ -ZEND_API void zend_mangle_property_name(char **dest, int *dest_length, const char *src1, int src1_length, const char *src2, int src2_length, int internal) /* {{{ */ +static void zend_check_already_in_use(uint32_t type, zend_string *old_name, zend_string *new_name, zend_string *check_name) /* {{{ */ { - char *prop_name; - int prop_name_length; - - prop_name_length = 1 + src1_length + 1 + src2_length; - prop_name = pemalloc(prop_name_length + 1, internal); - prop_name[0] = '\0'; - memcpy(prop_name + 1, src1, src1_length+1); - memcpy(prop_name + 1 + src1_length + 1, src2, src2_length+1); + if (zend_string_equals_ci(old_name, check_name)) { + return; + } - *dest = prop_name; - *dest_length = prop_name_length; + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use%s %s as %s because the name " + "is already in use", zend_get_use_type_str(type), ZSTR_VAL(old_name), ZSTR_VAL(new_name)); } /* }}} */ -static int zend_strnlen(const char* s, int maxlen) /* {{{ */ +void zend_compile_use(zend_ast *ast) /* {{{ */ { - int len = 0; - while (*s++ && maxlen--) len++; - return len; -} -/* }}} */ + zend_ast_list *list = zend_ast_get_list(ast); + uint32_t i; + zend_string *current_ns = FC(current_namespace); + uint32_t type = ast->attr; + HashTable *current_import = zend_get_import_ht(type); + zend_bool case_sensitive = type == T_CONST; -ZEND_API int zend_unmangle_property_name_ex(const char *mangled_property, int len, const char **class_name, const char **prop_name, int *prop_len) /* {{{ */ -{ - int class_name_len; + for (i = 0; i < list->children; ++i) { + zend_ast *use_ast = list->child[i]; + zend_ast *old_name_ast = use_ast->child[0]; + zend_ast *new_name_ast = use_ast->child[1]; + zend_string *old_name = zend_ast_get_str(old_name_ast); + zend_string *new_name, *lookup_name; - *class_name = NULL; + if (new_name_ast) { + new_name = zend_string_copy(zend_ast_get_str(new_name_ast)); + } else { + const char *unqualified_name; + size_t unqualified_name_len; + if (zend_get_unqualified_name(old_name, &unqualified_name, &unqualified_name_len)) { + /* The form "use A\B" is equivalent to "use A\B as B" */ + new_name = zend_string_init(unqualified_name, unqualified_name_len, 0); + } else { + new_name = zend_string_copy(old_name); - if (mangled_property[0]!=0) { - *prop_name = mangled_property; - if (prop_len) { - *prop_len = len; - } - return SUCCESS; - } - if (len < 3 || mangled_property[1]==0) { - zend_error(E_NOTICE, "Illegal member variable name"); - *prop_name = mangled_property; - if (prop_len) { - *prop_len = len; - } - return FAILURE; - } + if (!current_ns) { + if (type == T_CLASS && zend_string_equals_literal(new_name, "strict")) { + zend_error_noreturn(E_COMPILE_ERROR, + "You seem to be trying to use a different language..."); + } - class_name_len = zend_strnlen(mangled_property + 1, --len - 1) + 1; - if (class_name_len >= len || mangled_property[class_name_len]!=0) { - zend_error(E_NOTICE, "Corrupt member variable name"); - *prop_name = mangled_property; - if (prop_len) { - *prop_len = len + 1; + zend_error(E_WARNING, "The use statement with non-compound name '%s' " + "has no effect", ZSTR_VAL(new_name)); + } + } } - return FAILURE; - } - *class_name = mangled_property + 1; - *prop_name = (*class_name) + class_name_len; - if (prop_len) { - *prop_len = len - class_name_len; - } - return SUCCESS; -} -/* }}} */ -void zend_do_declare_property(const znode *var_name, const znode *value, zend_uint access_type TSRMLS_DC) /* {{{ */ -{ - zval *property; - zend_property_info *existing_property_info; - char *comment = NULL; - int comment_len = 0; + if (case_sensitive) { + lookup_name = zend_string_copy(new_name); + } else { + lookup_name = zend_string_tolower(new_name); + } - if (CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE) { - zend_error_noreturn(E_COMPILE_ERROR, "Interfaces may not include member variables"); - } + if (type == T_CLASS && zend_is_reserved_class_name(new_name)) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use %s as %s because '%s' " + "is a special class name", ZSTR_VAL(old_name), ZSTR_VAL(new_name), ZSTR_VAL(new_name)); + } - if (access_type & ZEND_ACC_ABSTRACT) { - zend_error_noreturn(E_COMPILE_ERROR, "Properties cannot be declared abstract"); - } + if (current_ns) { + zend_string *ns_name = zend_string_alloc(ZSTR_LEN(current_ns) + 1 + ZSTR_LEN(new_name), 0); + zend_str_tolower_copy(ZSTR_VAL(ns_name), ZSTR_VAL(current_ns), ZSTR_LEN(current_ns)); + ZSTR_VAL(ns_name)[ZSTR_LEN(current_ns)] = '\\'; + memcpy(ZSTR_VAL(ns_name) + ZSTR_LEN(current_ns) + 1, ZSTR_VAL(lookup_name), ZSTR_LEN(lookup_name)); - if (access_type & ZEND_ACC_FINAL) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot declare property %s::$%s final, the final modifier is allowed only for methods and classes", - CG(active_class_entry)->name, Z_STRVAL(var_name->u.constant)); - } + if (zend_hash_exists(CG(class_table), ns_name)) { + zend_check_already_in_use(type, old_name, new_name, ns_name); + } - if (zend_hash_find(&CG(active_class_entry)->properties_info, Z_STRVAL(var_name->u.constant), Z_STRLEN(var_name->u.constant)+1, (void **) &existing_property_info)==SUCCESS) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare %s::$%s", CG(active_class_entry)->name, Z_STRVAL(var_name->u.constant)); - } - ALLOC_ZVAL(property); + zend_string_free(ns_name); + } else { + switch (type) { + case T_CLASS: + { + zend_class_entry *ce = zend_hash_find_ptr(CG(class_table), lookup_name); + if (ce && ce->type == ZEND_USER_CLASS + && ce->info.user.filename == CG(compiled_filename) + ) { + zend_check_already_in_use(type, old_name, new_name, lookup_name); + } + break; + } + case T_FUNCTION: + { + zend_function *fn = zend_hash_find_ptr(CG(function_table), lookup_name); + if (fn && fn->type == ZEND_USER_FUNCTION + && fn->op_array.filename == CG(compiled_filename) + ) { + zend_check_already_in_use(type, old_name, new_name, lookup_name); + } + break; + } + case T_CONST: + { + zend_string *filename = zend_hash_find_ptr(&CG(const_filenames), lookup_name); + if (filename && filename == CG(compiled_filename)) { + zend_check_already_in_use(type, old_name, new_name, lookup_name); + } + break; + } + EMPTY_SWITCH_DEFAULT_CASE() + } + } - if (value) { - *property = value->u.constant; - } else { - INIT_PZVAL(property); - Z_TYPE_P(property) = IS_NULL; - } + zend_string_addref(old_name); + if (!zend_hash_add_ptr(current_import, lookup_name, old_name)) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use%s %s as %s because the name " + "is already in use", zend_get_use_type_str(type), ZSTR_VAL(old_name), ZSTR_VAL(new_name)); + } - if (CG(doc_comment)) { - comment = CG(doc_comment); - comment_len = CG(doc_comment_len); - CG(doc_comment) = NULL; - CG(doc_comment_len) = 0; + zend_string_release(lookup_name); + zend_string_release(new_name); } - - zend_declare_property_ex(CG(active_class_entry), zend_new_interned_string(Z_STRVAL(var_name->u.constant), Z_STRLEN(var_name->u.constant) + 1, 0 TSRMLS_CC), Z_STRLEN(var_name->u.constant), property, access_type, comment, comment_len TSRMLS_CC); - efree(Z_STRVAL(var_name->u.constant)); } /* }}} */ -void zend_do_declare_class_constant(znode *var_name, const znode *value TSRMLS_DC) /* {{{ */ +void zend_compile_group_use(zend_ast *ast) /* {{{ */ { - zval *property; - const char *cname = NULL; - zend_ulong hash; - - if ((CG(active_class_entry)->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) { - zend_error_noreturn(E_COMPILE_ERROR, "Traits cannot have constants"); - return; - } - - ALLOC_ZVAL(property); - *property = value->u.constant; - - cname = zend_new_interned_string(Z_STRVAL(var_name->u.constant), Z_STRLEN(var_name->u.constant)+1, 0 TSRMLS_CC); - hash = str_hash(cname, Z_STRLEN(var_name->u.constant)); - if (zend_hash_quick_add(&CG(active_class_entry)->constants_table, cname, Z_STRLEN(var_name->u.constant)+1, hash, &property, sizeof(zval *), NULL) == FAILURE) { - FREE_ZVAL(property); - zend_error_noreturn(E_COMPILE_ERROR, "Cannot redefine class constant %s::%s", CG(active_class_entry)->name, Z_STRVAL(var_name->u.constant)); - } - FREE_PNODE(var_name); + uint32_t i; + zend_string *ns = zend_ast_get_str(ast->child[0]); + zend_ast_list *list = zend_ast_get_list(ast->child[1]); - if (CG(doc_comment)) { - efree(CG(doc_comment)); - CG(doc_comment) = NULL; - CG(doc_comment_len) = 0; + for (i = 0; i < list->children; i++) { + zend_ast *inline_use, *use = list->child[i]; + zval *name_zval = zend_ast_get_zval(use->child[0]); + zend_string *name = Z_STR_P(name_zval); + zend_string *compound_ns = zend_concat_names(ZSTR_VAL(ns), ZSTR_LEN(ns), ZSTR_VAL(name), ZSTR_LEN(name)); + zend_string_release(name); + ZVAL_STR(name_zval, compound_ns); + inline_use = zend_ast_create_list(1, ZEND_AST_USE, use); + inline_use->attr = ast->attr ? ast->attr : use->attr; + zend_compile_use(inline_use); } } /* }}} */ -void zend_do_fetch_property(znode *result, znode *object, const znode *property TSRMLS_DC) /* {{{ */ + +void zend_compile_const_decl(zend_ast *ast) /* {{{ */ { - zend_op opline; - zend_llist *fetch_list_ptr; + zend_ast_list *list = zend_ast_get_list(ast); + uint32_t i; + for (i = 0; i < list->children; ++i) { + zend_ast *const_ast = list->child[i]; + zend_ast *name_ast = const_ast->child[0]; + zend_ast *value_ast = const_ast->child[1]; + zend_string *name = zend_ast_get_str(name_ast); - zend_stack_top(&CG(bp_stack), (void **) &fetch_list_ptr); + zend_string *import_name; + znode name_node, value_node; + zval *value_zv = &value_node.u.constant; - if (object->op_type == IS_CV) { - if (object->u.op.var == CG(active_op_array)->this_var) { - object->op_type = IS_UNUSED; /* this means $this for objects */ + value_node.op_type = IS_CONST; + zend_const_expr_to_zval(value_zv, value_ast); + + if (zend_lookup_reserved_const(ZSTR_VAL(name), ZSTR_LEN(name))) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare constant '%s'", ZSTR_VAL(name)); } - } else if (fetch_list_ptr->count == 1) { - zend_llist_element *le = fetch_list_ptr->head; - zend_op *opline_ptr = (zend_op *) le->data; - if (opline_is_fetch_this(opline_ptr TSRMLS_CC)) { - zend_del_literal(CG(active_op_array), opline_ptr->op1.constant); - SET_UNUSED(opline_ptr->op1); /* this means $this for objects */ - SET_NODE(opline_ptr->op2, property); - /* if it was usual fetch, we change it to object fetch */ - switch (opline_ptr->opcode) { - case ZEND_FETCH_W: - opline_ptr->opcode = ZEND_FETCH_OBJ_W; - break; - case ZEND_FETCH_R: - opline_ptr->opcode = ZEND_FETCH_OBJ_R; - break; - case ZEND_FETCH_RW: - opline_ptr->opcode = ZEND_FETCH_OBJ_RW; - break; - case ZEND_FETCH_IS: - opline_ptr->opcode = ZEND_FETCH_OBJ_IS; - break; - case ZEND_FETCH_UNSET: - opline_ptr->opcode = ZEND_FETCH_OBJ_UNSET; - break; - case ZEND_FETCH_FUNC_ARG: - opline_ptr->opcode = ZEND_FETCH_OBJ_FUNC_ARG; - break; - } - if (opline_ptr->op2_type == IS_CONST && Z_TYPE(CONSTANT(opline_ptr->op2.constant)) == IS_STRING) { - CALCULATE_LITERAL_HASH(opline_ptr->op2.constant); - GET_POLYMORPHIC_CACHE_SLOT(opline_ptr->op2.constant); + name = zend_prefix_with_ns(name); + name = zend_new_interned_string(name); + + if (FC(imports_const) + && (import_name = zend_hash_find_ptr(FC(imports_const), name)) + ) { + if (!zend_string_equals(import_name, name)) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot declare const %s because " + "the name is already in use", ZSTR_VAL(name)); } - GET_NODE(result, opline_ptr->result); - return; } - } - if (zend_is_function_or_method_call(object)) { - init_op(&opline TSRMLS_CC); - opline.opcode = ZEND_SEPARATE; - SET_NODE(opline.op1, object); - SET_UNUSED(opline.op2); - opline.result_type = IS_VAR; - opline.result.var = opline.op1.var; - zend_llist_add_element(fetch_list_ptr, &opline); - } + name_node.op_type = IS_CONST; + ZVAL_STR(&name_node.u.constant, name); - init_op(&opline TSRMLS_CC); - opline.opcode = ZEND_FETCH_OBJ_W; /* the backpatching routine assumes W */ - opline.result_type = IS_VAR; - opline.result.var = get_temporary_variable(CG(active_op_array)); - SET_NODE(opline.op1, object); - SET_NODE(opline.op2, property); - if (opline.op2_type == IS_CONST && Z_TYPE(CONSTANT(opline.op2.constant)) == IS_STRING) { - CALCULATE_LITERAL_HASH(opline.op2.constant); - GET_POLYMORPHIC_CACHE_SLOT(opline.op2.constant); - } - GET_NODE(result, opline.result); + zend_emit_op(NULL, ZEND_DECLARE_CONST, &name_node, &value_node); - zend_llist_add_element(fetch_list_ptr, &opline); + zend_hash_add_ptr(&CG(const_filenames), name, CG(compiled_filename)); + } } -/* }}} */ +/* }}}*/ -void zend_do_halt_compiler_register(TSRMLS_D) /* {{{ */ +void zend_compile_namespace(zend_ast *ast) /* {{{ */ { - char *name, *cfilename; - char haltoff[] = "__COMPILER_HALT_OFFSET__"; - int len, clen; + zend_ast *name_ast = ast->child[0]; + zend_ast *stmt_ast = ast->child[1]; + zend_string *name; + zend_bool with_bracket = stmt_ast != NULL; - if (CG(has_bracketed_namespaces) && CG(in_namespace)) { - zend_error_noreturn(E_COMPILE_ERROR, "__HALT_COMPILER() can only be used from the outermost scope"); + /* handle mixed syntax declaration or nested namespaces */ + if (!FC(has_bracketed_namespaces)) { + if (FC(current_namespace)) { + /* previous namespace declarations were unbracketed */ + if (with_bracket) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot mix bracketed namespace declarations " + "with unbracketed namespace declarations"); + } + } + } else { + /* previous namespace declarations were bracketed */ + if (!with_bracket) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot mix bracketed namespace declarations " + "with unbracketed namespace declarations"); + } else if (FC(current_namespace) || FC(in_namespace)) { + zend_error_noreturn(E_COMPILE_ERROR, "Namespace declarations cannot be nested"); + } } - cfilename = zend_get_compiled_filename(TSRMLS_C); - clen = strlen(cfilename); - zend_mangle_property_name(&name, &len, haltoff, sizeof(haltoff) - 1, cfilename, clen, 0); - zend_register_long_constant(name, len+1, zend_get_scanned_file_offset(TSRMLS_C), CONST_CS, 0 TSRMLS_CC); - pefree(name, 0); - - if (CG(in_namespace)) { - zend_do_end_namespace(TSRMLS_C); + if (((!with_bracket && !FC(current_namespace)) + || (with_bracket && !FC(has_bracketed_namespaces))) && CG(active_op_array)->last > 0 + ) { + /* ignore ZEND_EXT_STMT and ZEND_TICKS */ + uint32_t num = CG(active_op_array)->last; + while (num > 0 && + (CG(active_op_array)->opcodes[num-1].opcode == ZEND_EXT_STMT || + CG(active_op_array)->opcodes[num-1].opcode == ZEND_TICKS)) { + --num; + } + if (num > 0) { + zend_error_noreturn(E_COMPILE_ERROR, "Namespace declaration statement has to be " + "the very first statement in the script"); + } } -} -/* }}} */ -void zend_do_push_object(const znode *object TSRMLS_DC) /* {{{ */ -{ - zend_stack_push(&CG(object_stack), object, sizeof(znode)); -} -/* }}} */ - -void zend_do_pop_object(znode *object TSRMLS_DC) /* {{{ */ -{ - if (object) { - znode *tmp; - - zend_stack_top(&CG(object_stack), (void **) &tmp); - *object = *tmp; + if (FC(current_namespace)) { + zend_string_release(FC(current_namespace)); } - zend_stack_del_top(&CG(object_stack)); -} -/* }}} */ -void zend_do_begin_new_object(znode *new_token, znode *class_type TSRMLS_DC) /* {{{ */ -{ - zend_op *opline; + if (name_ast) { + name = zend_ast_get_str(name_ast); - new_token->u.op.opline_num = get_next_op_number(CG(active_op_array)); - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_NEW; - opline->extended_value = CG(context).nested_calls; - opline->result_type = IS_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - SET_NODE(opline->op1, class_type); - SET_UNUSED(opline->op2); + if (ZEND_FETCH_CLASS_DEFAULT != zend_get_class_fetch_type(name)) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as namespace name", ZSTR_VAL(name)); + } - zend_push_function_call_entry(NULL TSRMLS_CC); - if (++CG(context).nested_calls > CG(active_op_array)->nested_calls) { - CG(active_op_array)->nested_calls = CG(context).nested_calls; + FC(current_namespace) = zend_string_copy(name); + } else { + FC(current_namespace) = NULL; } -} -/* }}} */ -void zend_do_end_new_object(znode *result, const znode *new_token TSRMLS_DC) /* {{{ */ -{ - znode ctor_result; + zend_reset_import_tables(); - zend_do_end_function_call(NULL, &ctor_result, 1, 0 TSRMLS_CC); - zend_do_free(&ctor_result TSRMLS_CC); + FC(in_namespace) = 1; + if (with_bracket) { + FC(has_bracketed_namespaces) = 1; + } - CG(active_op_array)->opcodes[new_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array)); - GET_NODE(result, CG(active_op_array)->opcodes[new_token->u.op.opline_num].result); + if (stmt_ast) { + zend_compile_top_stmt(stmt_ast); + zend_end_namespace(); + } } /* }}} */ -static zend_constant* zend_get_ct_const(const zval *const_name, int all_internal_constants_substitution TSRMLS_DC) /* {{{ */ +void zend_compile_halt_compiler(zend_ast *ast) /* {{{ */ { - zend_constant *c = NULL; + zend_ast *offset_ast = ast->child[0]; + zend_long offset = Z_LVAL_P(zend_ast_get_zval(offset_ast)); - if (Z_STRVAL_P(const_name)[0] == '\\') { - if (zend_hash_find(EG(zend_constants), Z_STRVAL_P(const_name)+1, Z_STRLEN_P(const_name), (void **) &c) == FAILURE) { - char *lookup_name = zend_str_tolower_dup(Z_STRVAL_P(const_name)+1, Z_STRLEN_P(const_name)-1); + zend_string *filename, *name; + const char const_name[] = "__COMPILER_HALT_OFFSET__"; - if (zend_hash_find(EG(zend_constants), lookup_name, Z_STRLEN_P(const_name), (void **) &c)==SUCCESS) { - if ((c->flags & CONST_CT_SUBST) && !(c->flags & CONST_CS)) { - efree(lookup_name); - return c; - } - } - efree(lookup_name); - return NULL; - } - } else if (zend_hash_find(EG(zend_constants), Z_STRVAL_P(const_name), Z_STRLEN_P(const_name)+1, (void **) &c) == FAILURE) { - char *lookup_name = zend_str_tolower_dup(Z_STRVAL_P(const_name), Z_STRLEN_P(const_name)); - - if (zend_hash_find(EG(zend_constants), lookup_name, Z_STRLEN_P(const_name)+1, (void **) &c)==SUCCESS) { - if ((c->flags & CONST_CT_SUBST) && !(c->flags & CONST_CS)) { - efree(lookup_name); - return c; - } - } - efree(lookup_name); - return NULL; - } - if (c->flags & CONST_CT_SUBST) { - return c; - } - if (all_internal_constants_substitution && - (c->flags & CONST_PERSISTENT) && - !(CG(compiler_options) & ZEND_COMPILE_NO_CONSTANT_SUBSTITUTION) && - !IS_CONSTANT_TYPE(Z_TYPE(c->value))) { - return c; + if (FC(has_bracketed_namespaces) && FC(in_namespace)) { + zend_error_noreturn(E_COMPILE_ERROR, + "__HALT_COMPILER() can only be used from the outermost scope"); } - return NULL; -} -/* }}} */ -static int zend_constant_ct_subst(znode *result, zval *const_name, int all_internal_constants_substitution TSRMLS_DC) /* {{{ */ -{ - zend_constant *c = zend_get_ct_const(const_name, all_internal_constants_substitution TSRMLS_CC); + filename = zend_get_compiled_filename(); + name = zend_mangle_property_name(const_name, sizeof(const_name) - 1, + ZSTR_VAL(filename), ZSTR_LEN(filename), 0); - if (c) { - zval_dtor(const_name); - result->op_type = IS_CONST; - result->u.constant = c->value; - zval_copy_ctor(&result->u.constant); - INIT_PZVAL(&result->u.constant); - return 1; - } - return 0; + zend_register_long_constant(ZSTR_VAL(name), ZSTR_LEN(name), offset, CONST_CS, 0); + zend_string_release(name); } /* }}} */ -void zend_do_fetch_constant(znode *result, znode *constant_container, znode *constant_name, int mode, zend_bool check_namespace TSRMLS_DC) /* {{{ */ +static zend_bool zend_try_ct_eval_magic_const(zval *zv, zend_ast *ast) /* {{{ */ { - znode tmp; - zend_op *opline; - int type; - char *compound; - ulong fetch_type = 0; - - if (constant_container) { - switch (mode) { - case ZEND_CT: - /* this is a class constant */ - type = zend_get_class_fetch_type(Z_STRVAL(constant_container->u.constant), Z_STRLEN(constant_container->u.constant)); - - if (ZEND_FETCH_CLASS_STATIC == type) { - zend_error(E_ERROR, "\"static::\" is not allowed in compile-time constants"); - } else if (ZEND_FETCH_CLASS_DEFAULT == type) { - zend_resolve_class_name(constant_container TSRMLS_CC); - } - zend_do_build_full_name(NULL, constant_container, constant_name, 1 TSRMLS_CC); - *result = *constant_container; - result->u.constant.type = IS_CONSTANT | fetch_type; - break; - case ZEND_RT: - if (constant_container->op_type == IS_CONST && - ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(constant_container->u.constant), Z_STRLEN(constant_container->u.constant))) { - zend_resolve_class_name(constant_container TSRMLS_CC); - } else { - zend_do_fetch_class(&tmp, constant_container TSRMLS_CC); - constant_container = &tmp; - } - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_FETCH_CONSTANT; - opline->result_type = IS_TMP_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - if (constant_container->op_type == IS_CONST) { - opline->op1_type = IS_CONST; - opline->op1.constant = zend_add_class_name_literal(CG(active_op_array), &constant_container->u.constant TSRMLS_CC); - } else { - SET_NODE(opline->op1, constant_container); - } - SET_NODE(opline->op2, constant_name); - CALCULATE_LITERAL_HASH(opline->op2.constant); - if (opline->op1_type == IS_CONST) { - GET_CACHE_SLOT(opline->op2.constant); - } else { - GET_POLYMORPHIC_CACHE_SLOT(opline->op2.constant); - } - GET_NODE(result, opline->result); - break; - } - return; - } - /* namespace constant */ - /* only one that did not contain \ from the start can be converted to string if unknown */ - switch (mode) { - case ZEND_CT: - compound = memchr(Z_STRVAL(constant_name->u.constant), '\\', Z_STRLEN(constant_name->u.constant)); - /* this is a namespace constant, or an unprefixed constant */ - - if (zend_constant_ct_subst(result, &constant_name->u.constant, 0 TSRMLS_CC)) { - break; - } - - zend_resolve_const_name(constant_name, &check_namespace TSRMLS_CC); + zend_op_array *op_array = CG(active_op_array); + zend_class_entry *ce = CG(active_class_entry); - if(!compound) { - fetch_type |= IS_CONSTANT_UNQUALIFIED; + switch (ast->attr) { + case T_LINE: + ZVAL_LONG(zv, ast->lineno); + break; + case T_FILE: + ZVAL_STR_COPY(zv, CG(compiled_filename)); + break; + case T_DIR: + { + zend_string *filename = CG(compiled_filename); + zend_string *dirname = zend_string_init(ZSTR_VAL(filename), ZSTR_LEN(filename), 0); + zend_dirname(ZSTR_VAL(dirname), ZSTR_LEN(dirname)); + + if (strcmp(ZSTR_VAL(dirname), ".") == 0) { + dirname = zend_string_extend(dirname, MAXPATHLEN, 0); +#if HAVE_GETCWD + VCWD_GETCWD(ZSTR_VAL(dirname), MAXPATHLEN); +#elif HAVE_GETWD + VCWD_GETWD(ZSTR_VAL(dirname)); +#endif } - *result = *constant_name; - result->u.constant.type = IS_CONSTANT | fetch_type; + ZSTR_LEN(dirname) = strlen(ZSTR_VAL(dirname)); + ZVAL_STR(zv, dirname); break; - case ZEND_RT: - compound = memchr(Z_STRVAL(constant_name->u.constant), '\\', Z_STRLEN(constant_name->u.constant)); - - zend_resolve_const_name(constant_name, &check_namespace TSRMLS_CC); - - if(zend_constant_ct_subst(result, &constant_name->u.constant, 1 TSRMLS_CC)) { - break; + } + case T_FUNC_C: + if (op_array && op_array->function_name) { + ZVAL_STR_COPY(zv, op_array->function_name); + } else { + ZVAL_EMPTY_STRING(zv); } - - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_FETCH_CONSTANT; - opline->result_type = IS_TMP_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - GET_NODE(result, opline->result); - SET_UNUSED(opline->op1); - opline->op2_type = IS_CONST; - if (compound) { - /* the name is unambiguous */ - opline->extended_value = 0; - opline->op2.constant = zend_add_const_name_literal(CG(active_op_array), &constant_name->u.constant, 0 TSRMLS_CC); + break; + case T_METHOD_C: + if (ce) { + if (op_array && op_array->function_name) { + ZVAL_NEW_STR(zv, zend_concat3(ZSTR_VAL(ce->name), ZSTR_LEN(ce->name), "::", 2, + ZSTR_VAL(op_array->function_name), ZSTR_LEN(op_array->function_name))); + } else { + ZVAL_STR_COPY(zv, ce->name); + } + } else if (op_array && op_array->function_name) { + ZVAL_STR_COPY(zv, op_array->function_name); } else { - opline->extended_value = IS_CONSTANT_UNQUALIFIED; - if (CG(current_namespace)) { - opline->extended_value |= IS_CONSTANT_IN_NAMESPACE; - opline->op2.constant = zend_add_const_name_literal(CG(active_op_array), &constant_name->u.constant, 1 TSRMLS_CC); + ZVAL_EMPTY_STRING(zv); + } + break; + case T_CLASS_C: + if (ce) { + if ((ce->ce_flags & ZEND_ACC_TRAIT) != 0) { + return 0; } else { - opline->op2.constant = zend_add_const_name_literal(CG(active_op_array), &constant_name->u.constant, 0 TSRMLS_CC); + ZVAL_STR_COPY(zv, ce->name); } + } else { + ZVAL_EMPTY_STRING(zv); } - GET_CACHE_SLOT(opline->op2.constant); break; - } -} -/* }}} */ - -void zend_do_shell_exec(znode *result, const znode *cmd TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - switch (cmd->op_type) { - case IS_CONST: - case IS_TMP_VAR: - opline->opcode = ZEND_SEND_VAL; + case T_TRAIT_C: + if (ce && (ce->ce_flags & ZEND_ACC_TRAIT) != 0) { + ZVAL_STR_COPY(zv, ce->name); + } else { + ZVAL_EMPTY_STRING(zv); + } break; - default: - opline->opcode = ZEND_SEND_VAR; + case T_NS_C: + if (FC(current_namespace)) { + ZVAL_STR_COPY(zv, FC(current_namespace)); + } else { + ZVAL_EMPTY_STRING(zv); + } break; + EMPTY_SWITCH_DEFAULT_CASE() } - SET_NODE(opline->op1, cmd); - opline->op2.opline_num = 1; - opline->extended_value = ZEND_DO_FCALL; - SET_UNUSED(opline->op2); - - /* FIXME: exception support not added to this op2 */ - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_DO_FCALL; - opline->result.var = get_temporary_variable(CG(active_op_array)); - opline->result_type = IS_VAR; - LITERAL_STRINGL(opline->op1, estrndup("shell_exec", sizeof("shell_exec")-1), sizeof("shell_exec")-1, 0); - CALCULATE_LITERAL_HASH(opline->op1.constant); - opline->op1_type = IS_CONST; - GET_CACHE_SLOT(opline->op1.constant); - opline->extended_value = 1; - SET_UNUSED(opline->op2); - opline->op2.num = CG(context).nested_calls; - GET_NODE(result, opline->result); - if (CG(context).nested_calls + 1 > CG(active_op_array)->nested_calls) { - CG(active_op_array)->nested_calls = CG(context).nested_calls + 1; - } - if (CG(context).used_stack + 2 > CG(active_op_array)->used_stack) { - CG(active_op_array)->used_stack = CG(context).used_stack + 2; - } + return 1; } /* }}} */ -void zend_do_init_array(znode *result, const znode *expr, const znode *offset, zend_bool is_ref TSRMLS_DC) /* {{{ */ +static inline zend_bool zend_try_ct_eval_binary_op(zval *result, uint32_t opcode, zval *op1, zval *op2) /* {{{ */ { - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + binary_op_type fn = get_binary_op(opcode); - opline->opcode = ZEND_INIT_ARRAY; - opline->result.var = get_temporary_variable(CG(active_op_array)); - opline->result_type = IS_TMP_VAR; - GET_NODE(result, opline->result); - if (expr) { - SET_NODE(opline->op1, expr); - if (offset) { - SET_NODE(opline->op2, offset); - if (opline->op2_type == IS_CONST && Z_TYPE(CONSTANT(opline->op2.constant)) == IS_STRING) { - ulong index; - int numeric = 0; - - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL(CONSTANT(opline->op2.constant)), Z_STRLEN(CONSTANT(opline->op2.constant))+1, index, numeric = 1); - if (numeric) { - zval_dtor(&CONSTANT(opline->op2.constant)); - ZVAL_LONG(&CONSTANT(opline->op2.constant), index); - } else { - CALCULATE_LITERAL_HASH(opline->op2.constant); - } - } - } else { - SET_UNUSED(opline->op2); - } - } else { - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); + /* don't evaluate division by zero at compile-time */ + if ((opcode == ZEND_DIV || opcode == ZEND_MOD) && + zval_get_long(op2) == 0) { + return 0; + } else if ((opcode == ZEND_SL || opcode == ZEND_SR) && + zval_get_long(op2) < 0) { + return 0; } - opline->extended_value = is_ref; -} -/* }}} */ -void zend_do_add_array_element(znode *result, const znode *expr, const znode *offset, zend_bool is_ref TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - opline->opcode = ZEND_ADD_ARRAY_ELEMENT; - SET_NODE(opline->result, result); - SET_NODE(opline->op1, expr); - if (offset) { - SET_NODE(opline->op2, offset); - if (opline->op2_type == IS_CONST && Z_TYPE(CONSTANT(opline->op2.constant)) == IS_STRING) { - ulong index; - int numeric = 0; - - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL(CONSTANT(opline->op2.constant)), Z_STRLEN(CONSTANT(opline->op2.constant))+1, index, numeric = 1); - if (numeric) { - zval_dtor(&CONSTANT(opline->op2.constant)); - ZVAL_LONG(&CONSTANT(opline->op2.constant), index); - } else { - CALCULATE_LITERAL_HASH(opline->op2.constant); - } - } - } else { - SET_UNUSED(opline->op2); - } - opline->extended_value = is_ref; + fn(result, op1, op2); + return 1; } /* }}} */ -void zend_do_add_static_array_element(zval *result, zval *offset, const zval *expr) /* {{{ */ +static inline void zend_ct_eval_unary_op(zval *result, uint32_t opcode, zval *op) /* {{{ */ { - if (offset) { - switch (Z_TYPE_P(offset)) { - case IS_STRING: - zend_symtable_update(Z_ARRVAL_P(result), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr, sizeof(zval *), NULL); - zval_dtor(offset); - break; - case IS_NULL: - zend_symtable_update(Z_ARRVAL_P(result), "", 1, &expr, sizeof(zval *), NULL); - break; - case IS_LONG: - case IS_BOOL: - zend_hash_index_update(Z_ARRVAL_P(result), Z_LVAL_P(offset), &expr, sizeof(zval *), NULL); - break; - case IS_DOUBLE: - zend_hash_index_update(Z_ARRVAL_P(result), zend_dval_to_lval(Z_DVAL_P(offset)), &expr, sizeof(zval *), NULL); - break; - case IS_ARRAY: - zend_error(E_ERROR, "Illegal offset type"); - break; - } - } else { - zend_hash_next_index_insert(Z_ARRVAL_P(result), &expr, sizeof(zval *), NULL); - } + unary_op_type fn = get_unary_op(opcode); + fn(result, op); } /* }}} */ -void zend_do_add_list_element(const znode *element TSRMLS_DC) /* {{{ */ +static inline void zend_ct_eval_unary_pm(zval *result, zend_ast_kind kind, zval *op) /* {{{ */ { - list_llist_element lle; - - if (element) { - zend_check_writable_variable(element); - - lle.var = *element; - zend_llist_copy(&lle.dimensions, &CG(dimension_llist)); - zend_llist_prepend_element(&CG(list_llist), &lle); - } - (*((int *)CG(dimension_llist).tail->data))++; -} -/* }}} */ + binary_op_type fn = kind == ZEND_AST_UNARY_PLUS + ? add_function : sub_function; -void zend_do_new_list_begin(TSRMLS_D) /* {{{ */ -{ - int current_dimension = 0; - zend_llist_add_element(&CG(dimension_llist), ¤t_dimension); + zval left; + ZVAL_LONG(&left, 0); + fn(result, &left, op); } /* }}} */ -void zend_do_new_list_end(TSRMLS_D) /* {{{ */ +static inline void zend_ct_eval_greater(zval *result, zend_ast_kind kind, zval *op1, zval *op2) /* {{{ */ { - zend_llist_remove_tail(&CG(dimension_llist)); - (*((int *)CG(dimension_llist).tail->data))++; + binary_op_type fn = kind == ZEND_AST_GREATER + ? is_smaller_function : is_smaller_or_equal_function; + fn(result, op2, op1); } /* }}} */ -void zend_do_list_init(TSRMLS_D) /* {{{ */ +static zend_bool zend_try_ct_eval_array(zval *result, zend_ast *ast) /* {{{ */ { - zend_stack_push(&CG(list_stack), &CG(list_llist), sizeof(zend_llist)); - zend_stack_push(&CG(list_stack), &CG(dimension_llist), sizeof(zend_llist)); - zend_llist_init(&CG(list_llist), sizeof(list_llist_element), NULL, 0); - zend_llist_init(&CG(dimension_llist), sizeof(int), NULL, 0); - zend_do_new_list_begin(TSRMLS_C); -} -/* }}} */ + zend_ast_list *list = zend_ast_get_list(ast); + uint32_t i; + zend_bool is_constant = 1; -void zend_do_list_end(znode *result, znode *expr TSRMLS_DC) /* {{{ */ -{ - zend_llist_element *le; - zend_llist_element *dimension; - zend_op *opline; - znode last_container; - - le = CG(list_llist).head; - while (le) { - zend_llist *tmp_dimension_llist = &((list_llist_element *)le->data)->dimensions; - dimension = tmp_dimension_llist->head; - while (dimension) { - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - if (dimension == tmp_dimension_llist->head) { /* first */ - last_container = *expr; - switch (expr->op_type) { - case IS_VAR: - case IS_CV: - opline->opcode = ZEND_FETCH_DIM_R; - break; - case IS_TMP_VAR: - opline->opcode = ZEND_FETCH_DIM_TMP_VAR; - break; - case IS_CONST: /* fetch_dim_tmp_var will handle this bogus fetch */ - zval_copy_ctor(&expr->u.constant); - opline->opcode = ZEND_FETCH_DIM_TMP_VAR; - break; - } - opline->extended_value |= ZEND_FETCH_ADD_LOCK; - } else { - opline->opcode = ZEND_FETCH_DIM_R; - } - opline->result_type = IS_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - SET_NODE(opline->op1, &last_container); - opline->op2_type = IS_CONST; - LITERAL_LONG(opline->op2, *((int *) dimension->data)); - GET_NODE(&last_container, opline->result); - dimension = dimension->next; - } - ((list_llist_element *) le->data)->value = last_container; - zend_llist_destroy(&((list_llist_element *) le->data)->dimensions); - zend_do_assign(result, &((list_llist_element *) le->data)->var, &((list_llist_element *) le->data)->value TSRMLS_CC); - zend_do_free(result TSRMLS_CC); - le = le->next; - } - zend_llist_destroy(&CG(dimension_llist)); - zend_llist_destroy(&CG(list_llist)); - *result = *expr; - { - zend_llist *p; + /* First ensure that *all* child nodes are constant and by-val */ + for (i = 0; i < list->children; ++i) { + zend_ast *elem_ast = list->child[i]; + zend_bool by_ref = elem_ast->attr; + zend_eval_const_expr(&elem_ast->child[0]); + zend_eval_const_expr(&elem_ast->child[1]); - /* restore previous lists */ - zend_stack_top(&CG(list_stack), (void **) &p); - CG(dimension_llist) = *p; - zend_stack_del_top(&CG(list_stack)); - zend_stack_top(&CG(list_stack), (void **) &p); - CG(list_llist) = *p; - zend_stack_del_top(&CG(list_stack)); + if (by_ref || elem_ast->child[0]->kind != ZEND_AST_ZVAL + || (elem_ast->child[1] && elem_ast->child[1]->kind != ZEND_AST_ZVAL) + ) { + is_constant = 0; + } } -} -/* }}} */ - -void zend_init_list(void *result, void *item TSRMLS_DC) /* {{{ */ -{ - void** list = emalloc(sizeof(void*) * 2); - list[0] = item; - list[1] = NULL; + if (!is_constant) { + return 0; + } - *(void**)result = list; -} -/* }}} */ + array_init_size(result, list->children); + for (i = 0; i < list->children; ++i) { + zend_ast *elem_ast = list->child[i]; + zend_ast *value_ast = elem_ast->child[0]; + zend_ast *key_ast = elem_ast->child[1]; -void zend_add_to_list(void *result, void *item TSRMLS_DC) /* {{{ */ -{ - void** list = *(void**)result; - size_t n = 0; + zval *value = zend_ast_get_zval(value_ast); + if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value); - if (list) { - while (list[n]) { - n++; + if (key_ast) { + zval *key = zend_ast_get_zval(key_ast); + switch (Z_TYPE_P(key)) { + case IS_LONG: + zend_hash_index_update(Z_ARRVAL_P(result), Z_LVAL_P(key), value); + break; + case IS_STRING: + zend_symtable_update(Z_ARRVAL_P(result), Z_STR_P(key), value); + break; + case IS_DOUBLE: + zend_hash_index_update(Z_ARRVAL_P(result), + zend_dval_to_lval(Z_DVAL_P(key)), value); + break; + case IS_FALSE: + zend_hash_index_update(Z_ARRVAL_P(result), 0, value); + break; + case IS_TRUE: + zend_hash_index_update(Z_ARRVAL_P(result), 1, value); + break; + case IS_NULL: + zend_hash_update(Z_ARRVAL_P(result), ZSTR_EMPTY_ALLOC(), value); + break; + default: + zend_error_noreturn(E_COMPILE_ERROR, "Illegal offset type"); + break; + } + } else { + zend_hash_next_index_insert(Z_ARRVAL_P(result), value); } } - list = erealloc(list, sizeof(void*) * (n+2)); - - list[n] = item; - list[n+1] = NULL; - - *(void**)result = list; + return 1; } /* }}} */ -void zend_do_fetch_static_variable(znode *varname, const znode *static_assignment, int fetch_type TSRMLS_DC) /* {{{ */ +void zend_compile_binary_op(znode *result, zend_ast *ast) /* {{{ */ { - zval *tmp; - zend_op *opline; - znode lval; - znode result; + zend_ast *left_ast = ast->child[0]; + zend_ast *right_ast = ast->child[1]; + uint32_t opcode = ast->attr; - ALLOC_ZVAL(tmp); + znode left_node, right_node; + zend_compile_expr(&left_node, left_ast); + zend_compile_expr(&right_node, right_ast); - if (static_assignment) { - *tmp = static_assignment->u.constant; - } else { - INIT_ZVAL(*tmp); - } - if (!CG(active_op_array)->static_variables) { - if (CG(active_op_array)->scope) { - CG(active_op_array)->scope->ce_flags |= ZEND_HAS_STATIC_IN_METHODS; + if (left_node.op_type == IS_CONST && right_node.op_type == IS_CONST) { + if (zend_try_ct_eval_binary_op(&result->u.constant, opcode, + &left_node.u.constant, &right_node.u.constant) + ) { + result->op_type = IS_CONST; + zval_ptr_dtor(&left_node.u.constant); + zval_ptr_dtor(&right_node.u.constant); + return; } - ALLOC_HASHTABLE(CG(active_op_array)->static_variables); - zend_hash_init(CG(active_op_array)->static_variables, 2, NULL, ZVAL_PTR_DTOR, 0); } - zend_hash_update(CG(active_op_array)->static_variables, Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant)+1, &tmp, sizeof(zval *), NULL); - if (varname->op_type == IS_CONST) { - if (Z_TYPE(varname->u.constant) != IS_STRING) { - convert_to_string(&varname->u.constant); + do { + if (opcode == ZEND_IS_EQUAL || opcode == ZEND_IS_NOT_EQUAL) { + if (left_node.op_type == IS_CONST) { + if (Z_TYPE(left_node.u.constant) == IS_FALSE) { + opcode = (opcode == ZEND_IS_NOT_EQUAL) ? ZEND_BOOL : ZEND_BOOL_NOT; + zend_emit_op_tmp(result, opcode, &right_node, NULL); + break; + } else if (Z_TYPE(left_node.u.constant) == IS_TRUE) { + opcode = (opcode == ZEND_IS_EQUAL) ? ZEND_BOOL : ZEND_BOOL_NOT; + zend_emit_op_tmp(result, opcode, &right_node, NULL); + break; + } + } else if (right_node.op_type == IS_CONST) { + if (Z_TYPE(right_node.u.constant) == IS_FALSE) { + opcode = (opcode == ZEND_IS_NOT_EQUAL) ? ZEND_BOOL : ZEND_BOOL_NOT; + zend_emit_op_tmp(result, opcode, &left_node, NULL); + break; + } else if (Z_TYPE(right_node.u.constant) == IS_TRUE) { + opcode = (opcode == ZEND_IS_EQUAL) ? ZEND_BOOL : ZEND_BOOL_NOT; + zend_emit_op_tmp(result, opcode, &left_node, NULL); + break; + } + } } - } - - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = (fetch_type == ZEND_FETCH_LEXICAL) ? ZEND_FETCH_R : ZEND_FETCH_W; /* the default mode must be Write, since fetch_simple_variable() is used to define function arguments */ - opline->result_type = IS_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - SET_NODE(opline->op1, varname); - if (opline->op1_type == IS_CONST) { - CALCULATE_LITERAL_HASH(opline->op1.constant); - } - SET_UNUSED(opline->op2); - opline->extended_value = ZEND_FETCH_STATIC; - GET_NODE(&result, opline->result); - - if (varname->op_type == IS_CONST) { - zval_copy_ctor(&varname->u.constant); - } - fetch_simple_variable(&lval, varname, 0 TSRMLS_CC); /* Relies on the fact that the default fetch is BP_VAR_W */ - - if (fetch_type == ZEND_FETCH_LEXICAL) { - znode dummy; - - zend_do_begin_variable_parse(TSRMLS_C); - zend_do_assign(&dummy, &lval, &result TSRMLS_CC); - zend_do_free(&dummy TSRMLS_CC); - } else { - zend_do_assign_ref(NULL, &lval, &result TSRMLS_CC); - } - CG(active_op_array)->opcodes[CG(active_op_array)->last-1].result_type |= EXT_TYPE_UNUSED; + if (opcode == ZEND_CONCAT) { + /* convert constant operands to strings at compile-time */ + if (left_node.op_type == IS_CONST) { + convert_to_string(&left_node.u.constant); + } + if (right_node.op_type == IS_CONST) { + convert_to_string(&right_node.u.constant); + } + } + zend_emit_op_tmp(result, opcode, &left_node, &right_node); + } while (0); } /* }}} */ -void zend_do_fetch_lexical_variable(znode *varname, zend_bool is_ref TSRMLS_DC) /* {{{ */ +/* We do not use zend_compile_binary_op for this because we want to retain the left-to-right + * evaluation order. */ +void zend_compile_greater(znode *result, zend_ast *ast) /* {{{ */ { - znode value; + zend_ast *left_ast = ast->child[0]; + zend_ast *right_ast = ast->child[1]; + znode left_node, right_node; + + ZEND_ASSERT(ast->kind == ZEND_AST_GREATER || ast->kind == ZEND_AST_GREATER_EQUAL); - if (Z_STRLEN(varname->u.constant) == sizeof("this") - 1 && - memcmp(Z_STRVAL(varname->u.constant), "this", sizeof("this") - 1) == 0) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use $this as lexical variable"); + zend_compile_expr(&left_node, left_ast); + zend_compile_expr(&right_node, right_ast); + + if (left_node.op_type == IS_CONST && right_node.op_type == IS_CONST) { + result->op_type = IS_CONST; + zend_ct_eval_greater(&result->u.constant, ast->kind, + &left_node.u.constant, &right_node.u.constant); + zval_ptr_dtor(&left_node.u.constant); + zval_ptr_dtor(&right_node.u.constant); return; } - value.op_type = IS_CONST; - ZVAL_NULL(&value.u.constant); - Z_TYPE(value.u.constant) |= is_ref ? IS_LEXICAL_REF : IS_LEXICAL_VAR; - Z_SET_REFCOUNT_P(&value.u.constant, 1); - Z_UNSET_ISREF_P(&value.u.constant); - - zend_do_fetch_static_variable(varname, &value, is_ref ? ZEND_FETCH_STATIC : ZEND_FETCH_LEXICAL TSRMLS_CC); + zend_emit_op_tmp(result, + ast->kind == ZEND_AST_GREATER ? ZEND_IS_SMALLER : ZEND_IS_SMALLER_OR_EQUAL, + &right_node, &left_node); } /* }}} */ -void zend_do_fetch_global_variable(znode *varname, const znode *static_assignment, int fetch_type TSRMLS_DC) /* {{{ */ +void zend_compile_unary_op(znode *result, zend_ast *ast) /* {{{ */ { - zend_op *opline; - znode lval; - znode result; + zend_ast *expr_ast = ast->child[0]; + uint32_t opcode = ast->attr; - if (varname->op_type == IS_CONST) { - if (Z_TYPE(varname->u.constant) != IS_STRING) { - convert_to_string(&varname->u.constant); - } - } - - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_FETCH_W; /* the default mode must be Write, since fetch_simple_variable() is used to define function arguments */ - opline->result_type = IS_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - SET_NODE(opline->op1, varname); - if (opline->op1_type == IS_CONST) { - CALCULATE_LITERAL_HASH(opline->op1.constant); - } - SET_UNUSED(opline->op2); - opline->extended_value = fetch_type; - GET_NODE(&result, opline->result); + znode expr_node; + zend_compile_expr(&expr_node, expr_ast); - if (varname->op_type == IS_CONST) { - zval_copy_ctor(&varname->u.constant); + if (expr_node.op_type == IS_CONST) { + result->op_type = IS_CONST; + zend_ct_eval_unary_op(&result->u.constant, opcode, + &expr_node.u.constant); + zval_ptr_dtor(&expr_node.u.constant); + return; } - fetch_simple_variable(&lval, varname, 0 TSRMLS_CC); /* Relies on the fact that the default fetch is BP_VAR_W */ - zend_do_assign_ref(NULL, &lval, &result TSRMLS_CC); - CG(active_op_array)->opcodes[CG(active_op_array)->last-1].result_type |= EXT_TYPE_UNUSED; + zend_emit_op_tmp(result, opcode, &expr_node, NULL); } /* }}} */ -void zend_do_cast(znode *result, const znode *expr, int type TSRMLS_DC) /* {{{ */ +void zend_compile_unary_pm(znode *result, zend_ast *ast) /* {{{ */ { - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + zend_ast *expr_ast = ast->child[0]; + znode zero_node, expr_node; - opline->opcode = ZEND_CAST; - opline->result_type = IS_TMP_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - SET_NODE(opline->op1, expr); - SET_UNUSED(opline->op2); - opline->extended_value = type; - GET_NODE(result, opline->result); -} -/* }}} */ + ZEND_ASSERT(ast->kind == ZEND_AST_UNARY_PLUS || ast->kind == ZEND_AST_UNARY_MINUS); -void zend_do_include_or_eval(int type, znode *result, const znode *op1 TSRMLS_DC) /* {{{ */ -{ - zend_do_extended_fcall_begin(TSRMLS_C); - { - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + zend_compile_expr(&expr_node, expr_ast); - opline->opcode = ZEND_INCLUDE_OR_EVAL; - opline->result_type = IS_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - SET_NODE(opline->op1, op1); - SET_UNUSED(opline->op2); - opline->extended_value = type; - GET_NODE(result, opline->result); + if (expr_node.op_type == IS_CONST) { + result->op_type = IS_CONST; + zend_ct_eval_unary_pm(&result->u.constant, ast->kind, &expr_node.u.constant); + zval_ptr_dtor(&expr_node.u.constant); + return; } - zend_do_extended_fcall_end(TSRMLS_C); -} -/* }}} */ -void zend_do_indirect_references(znode *result, const znode *num_references, znode *variable TSRMLS_DC) /* {{{ */ -{ - int i; + zero_node.op_type = IS_CONST; + ZVAL_LONG(&zero_node.u.constant, 0); - zend_do_end_variable_parse(variable, BP_VAR_R, 0 TSRMLS_CC); - for (i=1; i<Z_LVAL(num_references->u.constant); i++) { - fetch_simple_variable_ex(result, variable, 0, ZEND_FETCH_R TSRMLS_CC); - *variable = *result; - } - zend_do_begin_variable_parse(TSRMLS_C); - fetch_simple_variable(result, variable, 1 TSRMLS_CC); - /* there is a chance someone is accessing $this */ - if (CG(active_op_array)->scope && CG(active_op_array)->this_var == -1) { - CG(active_op_array)->this_var = lookup_cv(CG(active_op_array), estrndup("this", sizeof("this")-1), sizeof("this")-1, THIS_HASHVAL TSRMLS_CC); - } + zend_emit_op_tmp(result, ast->kind == ZEND_AST_UNARY_PLUS ? ZEND_ADD : ZEND_SUB, + &zero_node, &expr_node); } /* }}} */ -void zend_do_unset(const znode *variable TSRMLS_DC) /* {{{ */ +void zend_compile_short_circuiting(znode *result, zend_ast *ast) /* {{{ */ { - zend_op *last_op; + zend_ast *left_ast = ast->child[0]; + zend_ast *right_ast = ast->child[1]; - zend_check_writable_variable(variable); + znode left_node, right_node; + zend_op *opline_jmpz, *opline_bool; + uint32_t opnum_jmpz; - if (variable->op_type == IS_CV) { - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_UNSET_VAR; - SET_NODE(opline->op1, variable); - SET_UNUSED(opline->op2); - SET_UNUSED(opline->result); - opline->extended_value = ZEND_FETCH_LOCAL | ZEND_QUICK_SET; - } else { - last_op = &CG(active_op_array)->opcodes[get_next_op_number(CG(active_op_array))-1]; - - switch (last_op->opcode) { - case ZEND_FETCH_UNSET: - last_op->opcode = ZEND_UNSET_VAR; - SET_UNUSED(last_op->result); - break; - case ZEND_FETCH_DIM_UNSET: - last_op->opcode = ZEND_UNSET_DIM; - SET_UNUSED(last_op->result); - break; - case ZEND_FETCH_OBJ_UNSET: - last_op->opcode = ZEND_UNSET_OBJ; - SET_UNUSED(last_op->result); - break; + ZEND_ASSERT(ast->kind == ZEND_AST_AND || ast->kind == ZEND_AST_OR); - } - } -} -/* }}} */ + zend_compile_expr(&left_node, left_ast); -void zend_do_isset_or_isempty(int type, znode *result, znode *variable TSRMLS_DC) /* {{{ */ -{ - zend_op *last_op; + if (left_node.op_type == IS_CONST) { + if ((ast->kind == ZEND_AST_AND && !zend_is_true(&left_node.u.constant)) + || (ast->kind == ZEND_AST_OR && zend_is_true(&left_node.u.constant))) { + result->op_type = IS_CONST; + ZVAL_BOOL(&result->u.constant, zend_is_true(&left_node.u.constant)); + } else { + zend_compile_expr(&right_node, right_ast); - zend_do_end_variable_parse(variable, BP_VAR_IS, 0 TSRMLS_CC); + if (right_node.op_type == IS_CONST) { + result->op_type = IS_CONST; + ZVAL_BOOL(&result->u.constant, zend_is_true(&right_node.u.constant)); - if (zend_is_function_or_method_call(variable)) { - if (type == ZEND_ISEMPTY) { - /* empty(func()) can be transformed to !func() */ - zend_do_unary_op(ZEND_BOOL_NOT, result, variable TSRMLS_CC); - } else { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use isset() on the result of a function call (you can use \"null !== func()\" instead)"); + zval_ptr_dtor(&right_node.u.constant); + } else { + zend_emit_op(result, ZEND_BOOL, &right_node, NULL); + } } + zval_ptr_dtor(&left_node.u.constant); return; } - if (variable->op_type == IS_CV) { - last_op = get_next_op(CG(active_op_array) TSRMLS_CC); - last_op->opcode = ZEND_ISSET_ISEMPTY_VAR; - SET_NODE(last_op->op1, variable); - SET_UNUSED(last_op->op2); - last_op->result.var = get_temporary_variable(CG(active_op_array)); - last_op->extended_value = ZEND_FETCH_LOCAL | ZEND_QUICK_SET; - } else { - last_op = &CG(active_op_array)->opcodes[get_next_op_number(CG(active_op_array))-1]; + opnum_jmpz = get_next_op_number(CG(active_op_array)); + opline_jmpz = zend_emit_op(NULL, ast->kind == ZEND_AST_AND ? ZEND_JMPZ_EX : ZEND_JMPNZ_EX, + &left_node, NULL); - switch (last_op->opcode) { - case ZEND_FETCH_IS: - last_op->opcode = ZEND_ISSET_ISEMPTY_VAR; - break; - case ZEND_FETCH_DIM_IS: - last_op->opcode = ZEND_ISSET_ISEMPTY_DIM_OBJ; - break; - case ZEND_FETCH_OBJ_IS: - last_op->opcode = ZEND_ISSET_ISEMPTY_PROP_OBJ; - break; - } + if (left_node.op_type == IS_TMP_VAR) { + SET_NODE(opline_jmpz->result, &left_node); + } else { + opline_jmpz->result.var = get_temporary_variable(CG(active_op_array)); + opline_jmpz->result_type = IS_TMP_VAR; } - last_op->result_type = IS_TMP_VAR; - last_op->extended_value |= type; - GET_NODE(result, last_op->result); + GET_NODE(result, opline_jmpz->result); + zend_compile_expr(&right_node, right_ast); + + opline_bool = zend_emit_op(NULL, ZEND_BOOL, &right_node, NULL); + SET_NODE(opline_bool->result, result); + + zend_update_jump_target_to_next(opnum_jmpz); } /* }}} */ -void zend_do_instanceof(znode *result, const znode *expr, const znode *class_znode, int type TSRMLS_DC) /* {{{ */ +void zend_compile_post_incdec(znode *result, zend_ast *ast) /* {{{ */ { - int last_op_number = get_next_op_number(CG(active_op_array)); - zend_op *opline; + zend_ast *var_ast = ast->child[0]; + ZEND_ASSERT(ast->kind == ZEND_AST_POST_INC || ast->kind == ZEND_AST_POST_DEC); - if (last_op_number > 0) { - opline = &CG(active_op_array)->opcodes[last_op_number-1]; - if (opline->opcode == ZEND_FETCH_CLASS) { - opline->extended_value |= ZEND_FETCH_CLASS_NO_AUTOLOAD; - } - } + zend_ensure_writable_variable(var_ast); - if (expr->op_type == IS_CONST) { - zend_error_noreturn(E_COMPILE_ERROR, "instanceof expects an object instance, constant given"); + if (var_ast->kind == ZEND_AST_PROP) { + zend_op *opline = zend_compile_prop_common(NULL, var_ast, BP_VAR_RW); + opline->opcode = ast->kind == ZEND_AST_POST_INC ? ZEND_POST_INC_OBJ : ZEND_POST_DEC_OBJ; + zend_make_tmp_result(result, opline); + } else { + znode var_node; + zend_compile_var(&var_node, var_ast, BP_VAR_RW); + zend_emit_op_tmp(result, ast->kind == ZEND_AST_POST_INC ? ZEND_POST_INC : ZEND_POST_DEC, + &var_node, NULL); } +} +/* }}} */ - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_INSTANCEOF; - opline->result_type = IS_TMP_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - SET_NODE(opline->op1, expr); +void zend_compile_pre_incdec(znode *result, zend_ast *ast) /* {{{ */ +{ + zend_ast *var_ast = ast->child[0]; + ZEND_ASSERT(ast->kind == ZEND_AST_PRE_INC || ast->kind == ZEND_AST_PRE_DEC); - SET_NODE(opline->op2, class_znode); + zend_ensure_writable_variable(var_ast); - GET_NODE(result, opline->result); + if (var_ast->kind == ZEND_AST_PROP) { + zend_op *opline = zend_compile_prop_common(result, var_ast, BP_VAR_RW); + opline->opcode = ast->kind == ZEND_AST_PRE_INC ? ZEND_PRE_INC_OBJ : ZEND_PRE_DEC_OBJ; + } else { + znode var_node; + zend_compile_var(&var_node, var_ast, BP_VAR_RW); + zend_emit_op(result, ast->kind == ZEND_AST_PRE_INC ? ZEND_PRE_INC : ZEND_PRE_DEC, + &var_node, NULL); + } } /* }}} */ -void zend_do_foreach_begin(znode *foreach_token, znode *open_brackets_token, znode *array, znode *as_token, int variable TSRMLS_DC) /* {{{ */ +void zend_compile_cast(znode *result, zend_ast *ast) /* {{{ */ { + zend_ast *expr_ast = ast->child[0]; + znode expr_node; zend_op *opline; - zend_bool is_variable; - zend_op dummy_opline; - if (variable) { - if (zend_is_function_or_method_call(array)) { - is_variable = 0; - } else { - is_variable = 1; - } - /* save the location of FETCH_W instruction(s) */ - open_brackets_token->u.op.opline_num = get_next_op_number(CG(active_op_array)); - zend_do_end_variable_parse(array, BP_VAR_W, 0 TSRMLS_CC); + zend_compile_expr(&expr_node, expr_ast); - if (zend_is_function_or_method_call(array)) { - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_SEPARATE; - SET_NODE(opline->op1, array); - SET_UNUSED(opline->op2); - opline->result_type = IS_VAR; - opline->result.var = opline->op1.var; - } - } else { - is_variable = 0; - open_brackets_token->u.op.opline_num = get_next_op_number(CG(active_op_array)); - } + opline = zend_emit_op_tmp(result, ZEND_CAST, &expr_node, NULL); + opline->extended_value = ast->attr; +} +/* }}} */ - /* save the location of FE_RESET */ - foreach_token->u.op.opline_num = get_next_op_number(CG(active_op_array)); +static void zend_compile_shorthand_conditional(znode *result, zend_ast *ast) /* {{{ */ +{ + zend_ast *cond_ast = ast->child[0]; + zend_ast *false_ast = ast->child[2]; - opline = get_next_op(CG(active_op_array) TSRMLS_CC); + znode cond_node, false_node; + zend_op *opline_qm_assign; + uint32_t opnum_jmp_set; - /* Preform array reset */ - opline->opcode = ZEND_FE_RESET; - opline->result_type = IS_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - SET_NODE(opline->op1, array); - SET_UNUSED(opline->op2); - opline->extended_value = is_variable ? ZEND_FE_RESET_VARIABLE : 0; + ZEND_ASSERT(ast->child[1] == NULL); - COPY_NODE(dummy_opline.result, opline->result); - zend_stack_push(&CG(foreach_copy_stack), (void *) &dummy_opline, sizeof(zend_op)); + zend_compile_expr(&cond_node, cond_ast); - /* save the location of FE_FETCH */ - as_token->u.op.opline_num = get_next_op_number(CG(active_op_array)); + opnum_jmp_set = get_next_op_number(CG(active_op_array)); + zend_emit_op_tmp(result, ZEND_JMP_SET, &cond_node, NULL); - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_FE_FETCH; - opline->result_type = IS_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - COPY_NODE(opline->op1, dummy_opline.result); - opline->extended_value = 0; - SET_UNUSED(opline->op2); + zend_compile_expr(&false_node, false_ast); - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_OP_DATA; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); - SET_UNUSED(opline->result); + opline_qm_assign = zend_emit_op_tmp(NULL, ZEND_QM_ASSIGN, &false_node, NULL); + SET_NODE(opline_qm_assign->result, result); + + zend_update_jump_target_to_next(opnum_jmp_set); } /* }}} */ -void zend_do_foreach_cont(znode *foreach_token, const znode *open_brackets_token, const znode *as_token, znode *value, znode *key TSRMLS_DC) /* {{{ */ +void zend_compile_conditional(znode *result, zend_ast *ast) /* {{{ */ { - zend_op *opline; - znode dummy, value_node; - zend_bool assign_by_ref=0; - - opline = &CG(active_op_array)->opcodes[as_token->u.op.opline_num]; - if (key->op_type != IS_UNUSED) { - znode *tmp; + zend_ast *cond_ast = ast->child[0]; + zend_ast *true_ast = ast->child[1]; + zend_ast *false_ast = ast->child[2]; - /* switch between the key and value... */ - tmp = key; - key = value; - value = tmp; + znode cond_node, true_node, false_node; + zend_op *opline_qm_assign2; + uint32_t opnum_jmpz, opnum_jmp; - /* Mark extended_value in case both key and value are being used */ - opline->extended_value |= ZEND_FE_FETCH_WITH_KEY; + if (!true_ast) { + zend_compile_shorthand_conditional(result, ast); + return; } - if ((key->op_type != IS_UNUSED)) { - if (key->EA & ZEND_PARSED_REFERENCE_VARIABLE) { - zend_error_noreturn(E_COMPILE_ERROR, "Key element cannot be a reference"); - } - if (key->EA & ZEND_PARSED_LIST_EXPR) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use list as key element"); - } - } + zend_compile_expr(&cond_node, cond_ast); - if (value->EA & ZEND_PARSED_REFERENCE_VARIABLE) { - assign_by_ref = 1; + opnum_jmpz = zend_emit_cond_jump(ZEND_JMPZ, &cond_node, 0); - /* Mark extended_value for assign-by-reference */ - opline->extended_value |= ZEND_FE_FETCH_BYREF; - CG(active_op_array)->opcodes[foreach_token->u.op.opline_num].extended_value |= ZEND_FE_RESET_REFERENCE; - } else { - zend_op *fetch = &CG(active_op_array)->opcodes[foreach_token->u.op.opline_num]; - zend_op *end = &CG(active_op_array)->opcodes[open_brackets_token->u.op.opline_num]; - - /* Change "write context" into "read context" */ - fetch->extended_value = 0; /* reset ZEND_FE_RESET_VARIABLE */ - while (fetch != end) { - --fetch; - if (fetch->opcode == ZEND_FETCH_DIM_W && fetch->op2_type == IS_UNUSED) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use [] for reading"); - } - if (fetch->opcode == ZEND_SEPARATE) { - MAKE_NOP(fetch); - } else { - fetch->opcode -= 3; /* FETCH_W -> FETCH_R */ - } - } - } + zend_compile_expr(&true_node, true_ast); - GET_NODE(&value_node, opline->result); + zend_emit_op_tmp(result, ZEND_QM_ASSIGN, &true_node, NULL); - if (value->EA & ZEND_PARSED_LIST_EXPR) { - if (!CG(list_llist).head) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use empty list"); - } - zend_do_list_end(&dummy, &value_node TSRMLS_CC); - zend_do_free(&dummy TSRMLS_CC); - } else { - if (assign_by_ref) { - zend_do_end_variable_parse(value, BP_VAR_W, 0 TSRMLS_CC); - /* Mark FE_FETCH as IS_VAR as it holds the data directly as a value */ - zend_do_assign_ref(NULL, value, &value_node TSRMLS_CC); - } else { - zend_do_assign(&dummy, value, &value_node TSRMLS_CC); - zend_do_free(&dummy TSRMLS_CC); - } - } + opnum_jmp = zend_emit_jump(0); - if (key->op_type != IS_UNUSED) { - znode key_node; + zend_update_jump_target_to_next(opnum_jmpz); - opline = &CG(active_op_array)->opcodes[as_token->u.op.opline_num+1]; - opline->result_type = IS_TMP_VAR; - opline->result.opline_num = get_temporary_variable(CG(active_op_array)); - GET_NODE(&key_node, opline->result); + zend_compile_expr(&false_node, false_ast); - zend_do_assign(&dummy, key, &key_node TSRMLS_CC); - zend_do_free(&dummy TSRMLS_CC); - } + opline_qm_assign2 = zend_emit_op(NULL, ZEND_QM_ASSIGN, &false_node, NULL); + SET_NODE(opline_qm_assign2->result, result); - do_begin_loop(TSRMLS_C); - INC_BPC(CG(active_op_array)); + zend_update_jump_target_to_next(opnum_jmp); } /* }}} */ -void zend_do_foreach_end(const znode *foreach_token, const znode *as_token TSRMLS_DC) /* {{{ */ +void zend_compile_coalesce(znode *result, zend_ast *ast) /* {{{ */ { - zend_op *container_ptr; - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + zend_ast *expr_ast = ast->child[0]; + zend_ast *default_ast = ast->child[1]; - opline->opcode = ZEND_JMP; - opline->op1.opline_num = as_token->u.op.opline_num; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); + znode expr_node, default_node; + zend_op *opline; + uint32_t opnum; - CG(active_op_array)->opcodes[foreach_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array)); /* FE_RESET */ - CG(active_op_array)->opcodes[as_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array)); /* FE_FETCH */ + zend_compile_var(&expr_node, expr_ast, BP_VAR_IS); - do_end_loop(as_token->u.op.opline_num, 1 TSRMLS_CC); + opnum = get_next_op_number(CG(active_op_array)); + zend_emit_op_tmp(result, ZEND_COALESCE, &expr_node, NULL); - zend_stack_top(&CG(foreach_copy_stack), (void **) &container_ptr); - generate_free_foreach_copy(container_ptr TSRMLS_CC); - zend_stack_del_top(&CG(foreach_copy_stack)); + zend_compile_expr(&default_node, default_ast); - DEC_BPC(CG(active_op_array)); -} -/* }}} */ + opline = zend_emit_op_tmp(NULL, ZEND_QM_ASSIGN, &default_node, NULL); + SET_NODE(opline->result, result); -void zend_do_declare_begin(TSRMLS_D) /* {{{ */ -{ - zend_stack_push(&CG(declare_stack), &CG(declarables), sizeof(zend_declarables)); + opline = &CG(active_op_array)->opcodes[opnum]; + opline->op2.opline_num = get_next_op_number(CG(active_op_array)); } /* }}} */ -void zend_do_declare_stmt(znode *var, znode *val TSRMLS_DC) /* {{{ */ +void zend_compile_print(znode *result, zend_ast *ast) /* {{{ */ { - if (!zend_binary_strcasecmp(Z_STRVAL(var->u.constant), Z_STRLEN(var->u.constant), "ticks", sizeof("ticks")-1)) { - convert_to_long(&val->u.constant); - CG(declarables).ticks = val->u.constant; - } else if (!zend_binary_strcasecmp(Z_STRVAL(var->u.constant), Z_STRLEN(var->u.constant), "encoding", sizeof("encoding")-1)) { - if ((Z_TYPE(val->u.constant) & IS_CONSTANT_TYPE_MASK) == IS_CONSTANT) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use constants as encoding"); - } - - /* - * Check that the pragma comes before any opcodes. If the compilation - * got as far as this, the previous portion of the script must have been - * parseable according to the .ini script_encoding setting. We still - * want to tell them to put declare() at the top. - */ - { - int num = CG(active_op_array)->last; - /* ignore ZEND_EXT_STMT and ZEND_TICKS */ - while (num > 0 && - (CG(active_op_array)->opcodes[num-1].opcode == ZEND_EXT_STMT || - CG(active_op_array)->opcodes[num-1].opcode == ZEND_TICKS)) { - --num; - } + zend_ast *expr_ast = ast->child[0]; - if (num > 0) { - zend_error_noreturn(E_COMPILE_ERROR, "Encoding declaration pragma must be the very first statement in the script"); - } - } + znode expr_node; + zend_compile_expr(&expr_node, expr_ast); - if (CG(multibyte)) { - const zend_encoding *new_encoding, *old_encoding; - zend_encoding_filter old_input_filter; + zend_emit_op(NULL, ZEND_ECHO, &expr_node, NULL); - CG(encoding_declared) = 1; - - convert_to_string(&val->u.constant); - new_encoding = zend_multibyte_fetch_encoding(Z_STRVAL(val->u.constant) TSRMLS_CC); - if (!new_encoding) { - zend_error(E_COMPILE_WARNING, "Unsupported encoding [%s]", Z_STRVAL(val->u.constant)); - } else { - old_input_filter = LANG_SCNG(input_filter); - old_encoding = LANG_SCNG(script_encoding); - zend_multibyte_set_filter(new_encoding TSRMLS_CC); - - /* need to re-scan if input filter changed */ - if (old_input_filter != LANG_SCNG(input_filter) || - (old_input_filter && new_encoding != old_encoding)) { - zend_multibyte_yyinput_again(old_input_filter, old_encoding TSRMLS_CC); - } - } - } else { - zend_error(E_COMPILE_WARNING, "declare(encoding=...) ignored because Zend multibyte feature is turned off by settings"); - } - zval_dtor(&val->u.constant); - } else { - zend_error(E_COMPILE_WARNING, "Unsupported declare '%s'", Z_STRVAL(var->u.constant)); - zval_dtor(&val->u.constant); - } - zval_dtor(&var->u.constant); + result->op_type = IS_CONST; + ZVAL_LONG(&result->u.constant, 1); } /* }}} */ -void zend_do_declare_end(const znode *declare_token TSRMLS_DC) /* {{{ */ +void zend_compile_exit(znode *result, zend_ast *ast) /* {{{ */ { - zend_declarables *declarables; + zend_ast *expr_ast = ast->child[0]; - zend_stack_top(&CG(declare_stack), (void **) &declarables); - /* We should restore if there was more than (current - start) - (ticks?1:0) opcodes */ - if ((get_next_op_number(CG(active_op_array)) - declare_token->u.op.opline_num) - ((Z_LVAL(CG(declarables).ticks))?1:0)) { - CG(declarables) = *declarables; + if (expr_ast) { + znode expr_node; + zend_compile_expr(&expr_node, expr_ast); + zend_emit_op(NULL, ZEND_EXIT, &expr_node, NULL); + } else { + zend_emit_op(NULL, ZEND_EXIT, NULL, NULL); } -} -/* }}} */ - -void zend_do_exit(znode *result, const znode *message TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - opline->opcode = ZEND_EXIT; - SET_NODE(opline->op1, message); - SET_UNUSED(opline->op2); result->op_type = IS_CONST; - Z_TYPE(result->u.constant) = IS_BOOL; - Z_LVAL(result->u.constant) = 1; + ZVAL_BOOL(&result->u.constant, 1); } /* }}} */ -void zend_do_begin_silence(znode *strudel_token TSRMLS_DC) /* {{{ */ +static void zend_mark_function_as_generator() /* {{{ */ { - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + if (!CG(active_op_array)->function_name) { + zend_error_noreturn(E_COMPILE_ERROR, + "The \"yield\" expression can only be used inside a function"); + } + if (CG(active_op_array)->fn_flags & ZEND_ACC_HAS_RETURN_TYPE) { + const char *msg = "Generators may only declare a return type of Generator, Iterator or Traversable, %s is not permitted"; + if (!CG(active_op_array)->arg_info[-1].class_name) { + zend_error_noreturn(E_COMPILE_ERROR, msg, + zend_get_type_by_const(CG(active_op_array)->arg_info[-1].type_hint)); + } + if (!(ZSTR_LEN(CG(active_op_array)->arg_info[-1].class_name) == sizeof("Traversable")-1 + && zend_binary_strcasecmp(ZSTR_VAL(CG(active_op_array)->arg_info[-1].class_name), sizeof("Traversable")-1, "Traversable", sizeof("Traversable")-1) == 0) && + !(ZSTR_LEN(CG(active_op_array)->arg_info[-1].class_name) == sizeof("Iterator")-1 + && zend_binary_strcasecmp(ZSTR_VAL(CG(active_op_array)->arg_info[-1].class_name), sizeof("Iterator")-1, "Iterator", sizeof("Iterator")-1) == 0) && + !(ZSTR_LEN(CG(active_op_array)->arg_info[-1].class_name) == sizeof("Generator")-1 + && zend_binary_strcasecmp(ZSTR_VAL(CG(active_op_array)->arg_info[-1].class_name), sizeof("Generator")-1, "Generator", sizeof("Generator")-1) == 0)) { + zend_error_noreturn(E_COMPILE_ERROR, msg, ZSTR_VAL(CG(active_op_array)->arg_info[-1].class_name)); + } + } - opline->opcode = ZEND_BEGIN_SILENCE; - opline->result_type = IS_TMP_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); - GET_NODE(strudel_token, opline->result); + CG(active_op_array)->fn_flags |= ZEND_ACC_GENERATOR; } /* }}} */ -void zend_do_end_silence(const znode *strudel_token TSRMLS_DC) /* {{{ */ +void zend_compile_yield(znode *result, zend_ast *ast) /* {{{ */ { - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + zend_ast *value_ast = ast->child[0]; + zend_ast *key_ast = ast->child[1]; - opline->opcode = ZEND_END_SILENCE; - SET_NODE(opline->op1, strudel_token); - SET_UNUSED(opline->op2); -} -/* }}} */ + znode value_node, key_node; + znode *value_node_ptr = NULL, *key_node_ptr = NULL; + zend_op *opline; + zend_bool returns_by_ref = (CG(active_op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0; -void zend_do_jmp_set(const znode *value, znode *jmp_token, znode *colon_token TSRMLS_DC) /* {{{ */ -{ - int op_number = get_next_op_number(CG(active_op_array)); - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + zend_mark_function_as_generator(); - if (value->op_type == IS_VAR || value->op_type == IS_CV) { - opline->opcode = ZEND_JMP_SET_VAR; - opline->result_type = IS_VAR; - } else { - opline->opcode = ZEND_JMP_SET; - opline->result_type = IS_TMP_VAR; + if (key_ast) { + zend_compile_expr(&key_node, key_ast); + key_node_ptr = &key_node; } - opline->result.var = get_temporary_variable(CG(active_op_array)); - SET_NODE(opline->op1, value); - SET_UNUSED(opline->op2); - GET_NODE(colon_token, opline->result); + if (value_ast) { + if (returns_by_ref && zend_is_variable(value_ast) && !zend_is_call(value_ast)) { + zend_compile_var(&value_node, value_ast, BP_VAR_REF); + } else { + zend_compile_expr(&value_node, value_ast); + } + value_node_ptr = &value_node; + } - jmp_token->u.op.opline_num = op_number; + opline = zend_emit_op(result, ZEND_YIELD, value_node_ptr, key_node_ptr); - INC_BPC(CG(active_op_array)); + if (value_ast && returns_by_ref && zend_is_call(value_ast)) { + opline->extended_value = ZEND_RETURNS_FUNCTION; + } } /* }}} */ -void zend_do_jmp_set_else(znode *result, const znode *false_value, const znode *jmp_token, const znode *colon_token TSRMLS_DC) /* {{{ */ +void zend_compile_yield_from(znode *result, zend_ast *ast) /* {{{ */ { - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + zend_ast *expr_ast = ast->child[0]; + znode expr_node; - SET_NODE(opline->result, colon_token); - if (colon_token->op_type == IS_TMP_VAR) { - if (false_value->op_type == IS_VAR || false_value->op_type == IS_CV) { - CG(active_op_array)->opcodes[jmp_token->u.op.opline_num].opcode = ZEND_JMP_SET_VAR; - CG(active_op_array)->opcodes[jmp_token->u.op.opline_num].result_type = IS_VAR; - opline->opcode = ZEND_QM_ASSIGN_VAR; - opline->result_type = IS_VAR; - } else { - opline->opcode = ZEND_QM_ASSIGN; - } - } else { - opline->opcode = ZEND_QM_ASSIGN_VAR; - } - opline->extended_value = 0; - SET_NODE(opline->op1, false_value); - SET_UNUSED(opline->op2); + zend_mark_function_as_generator(); - GET_NODE(result, opline->result); - - CG(active_op_array)->opcodes[jmp_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array)); - - DEC_BPC(CG(active_op_array)); + zend_compile_expr(&expr_node, expr_ast); + zend_emit_op_tmp(result, ZEND_YIELD_FROM, &expr_node, NULL); } /* }}} */ -void zend_do_begin_qm_op(const znode *cond, znode *qm_token TSRMLS_DC) /* {{{ */ +void zend_compile_instanceof(znode *result, zend_ast *ast) /* {{{ */ { - int jmpz_op_number = get_next_op_number(CG(active_op_array)); + zend_ast *obj_ast = ast->child[0]; + zend_ast *class_ast = ast->child[1]; + + znode obj_node, class_node; zend_op *opline; - opline = get_next_op(CG(active_op_array) TSRMLS_CC); + zend_compile_expr(&obj_node, obj_ast); + if (obj_node.op_type == IS_CONST) { + zend_error_noreturn(E_COMPILE_ERROR, + "instanceof expects an object instance, constant given"); + } - opline->opcode = ZEND_JMPZ; - SET_NODE(opline->op1, cond); - SET_UNUSED(opline->op2); - opline->op2.opline_num = jmpz_op_number; - GET_NODE(qm_token, opline->op2); + if (zend_is_const_default_class_ref(class_ast)) { + class_node.op_type = IS_CONST; + ZVAL_STR(&class_node.u.constant, zend_resolve_class_name_ast(class_ast)); + } else { + opline = zend_compile_class_ref(&class_node, class_ast, 0); + opline->extended_value |= ZEND_FETCH_CLASS_NO_AUTOLOAD; + } + + opline = zend_emit_op_tmp(result, ZEND_INSTANCEOF, &obj_node, NULL); - INC_BPC(CG(active_op_array)); + if (class_node.op_type == IS_CONST) { + opline->op2_type = IS_CONST; + opline->op2.constant = zend_add_class_name_literal( + CG(active_op_array), Z_STR(class_node.u.constant)); + } else { + SET_NODE(opline->op2, &class_node); + } } /* }}} */ -void zend_do_qm_true(const znode *true_value, znode *qm_token, znode *colon_token TSRMLS_DC) /* {{{ */ +void zend_compile_include_or_eval(znode *result, zend_ast *ast) /* {{{ */ { - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + zend_ast *expr_ast = ast->child[0]; + znode expr_node; + zend_op *opline; - CG(active_op_array)->opcodes[qm_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array))+1; /* jmp over the ZEND_JMP */ + zend_do_extended_fcall_begin(); + zend_compile_expr(&expr_node, expr_ast); - if (true_value->op_type == IS_VAR || true_value->op_type == IS_CV) { - opline->opcode = ZEND_QM_ASSIGN_VAR; - opline->result_type = IS_VAR; - } else { - opline->opcode = ZEND_QM_ASSIGN; - opline->result_type = IS_TMP_VAR; - } - opline->result.var = get_temporary_variable(CG(active_op_array)); - SET_NODE(opline->op1, true_value); - SET_UNUSED(opline->op2); - - GET_NODE(qm_token, opline->result); - colon_token->u.op.opline_num = get_next_op_number(CG(active_op_array)); + opline = zend_emit_op(result, ZEND_INCLUDE_OR_EVAL, &expr_node, NULL); + opline->extended_value = ast->attr; - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_JMP; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); + zend_do_extended_fcall_end(); } /* }}} */ -void zend_do_qm_false(znode *result, const znode *false_value, const znode *qm_token, const znode *colon_token TSRMLS_DC) /* {{{ */ +void zend_compile_isset_or_empty(znode *result, zend_ast *ast) /* {{{ */ { - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + zend_ast *var_ast = ast->child[0]; - SET_NODE(opline->result, qm_token); - if (qm_token->op_type == IS_TMP_VAR) { - if (false_value->op_type == IS_VAR || false_value->op_type == IS_CV) { - CG(active_op_array)->opcodes[colon_token->u.op.opline_num - 1].opcode = ZEND_QM_ASSIGN_VAR; - CG(active_op_array)->opcodes[colon_token->u.op.opline_num - 1].result_type = IS_VAR; - opline->opcode = ZEND_QM_ASSIGN_VAR; - opline->result_type = IS_VAR; + znode var_node; + zend_op *opline = NULL; + + ZEND_ASSERT(ast->kind == ZEND_AST_ISSET || ast->kind == ZEND_AST_EMPTY); + + if (!zend_is_variable(var_ast) || zend_is_call(var_ast)) { + if (ast->kind == ZEND_AST_EMPTY) { + /* empty(expr) can be transformed to !expr */ + zend_ast *not_ast = zend_ast_create_ex(ZEND_AST_UNARY_OP, ZEND_BOOL_NOT, var_ast); + zend_compile_expr(result, not_ast); + return; } else { - opline->opcode = ZEND_QM_ASSIGN; + zend_error_noreturn(E_COMPILE_ERROR, + "Cannot use isset() on the result of an expression " + "(you can use \"null !== expression\" instead)"); } - } else { - opline->opcode = ZEND_QM_ASSIGN_VAR; } - SET_NODE(opline->op1, false_value); - SET_UNUSED(opline->op2); - CG(active_op_array)->opcodes[colon_token->u.op.opline_num].op1.opline_num = get_next_op_number(CG(active_op_array)); - - GET_NODE(result, opline->result); + switch (var_ast->kind) { + case ZEND_AST_VAR: + if (zend_try_compile_cv(&var_node, var_ast) == SUCCESS) { + opline = zend_emit_op(result, ZEND_ISSET_ISEMPTY_VAR, &var_node, NULL); + opline->extended_value = ZEND_FETCH_LOCAL | ZEND_QUICK_SET; + } else { + opline = zend_compile_simple_var_no_cv(result, var_ast, BP_VAR_IS, 0); + opline->opcode = ZEND_ISSET_ISEMPTY_VAR; + } + break; + case ZEND_AST_DIM: + opline = zend_compile_dim_common(result, var_ast, BP_VAR_IS); + opline->opcode = ZEND_ISSET_ISEMPTY_DIM_OBJ; + break; + case ZEND_AST_PROP: + opline = zend_compile_prop_common(result, var_ast, BP_VAR_IS); + opline->opcode = ZEND_ISSET_ISEMPTY_PROP_OBJ; + break; + case ZEND_AST_STATIC_PROP: + opline = zend_compile_static_prop_common(result, var_ast, BP_VAR_IS, 0); + opline->opcode = ZEND_ISSET_ISEMPTY_VAR; + break; + EMPTY_SWITCH_DEFAULT_CASE() + } - DEC_BPC(CG(active_op_array)); + result->op_type = opline->result_type = IS_TMP_VAR; + opline->extended_value |= ast->kind == ZEND_AST_ISSET ? ZEND_ISSET : ZEND_ISEMPTY; } /* }}} */ -void zend_do_extended_info(TSRMLS_D) /* {{{ */ +void zend_compile_silence(znode *result, zend_ast *ast) /* {{{ */ { - zend_op *opline; + zend_ast *expr_ast = ast->child[0]; + znode silence_node; - if (!(CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO)) { - return; - } + zend_emit_op_tmp(&silence_node, ZEND_BEGIN_SILENCE, NULL, NULL); - opline = get_next_op(CG(active_op_array) TSRMLS_CC); + if (expr_ast->kind == ZEND_AST_VAR) { + /* For @$var we need to force a FETCH instruction, otherwise the CV access will + * happen outside the silenced section. */ + zend_compile_simple_var_no_cv(result, expr_ast, BP_VAR_R, 0 ); + } else { + zend_compile_expr(result, expr_ast); + } - opline->opcode = ZEND_EXT_STMT; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); + zend_emit_op(NULL, ZEND_END_SILENCE, &silence_node, NULL); } /* }}} */ -void zend_do_extended_fcall_begin(TSRMLS_D) /* {{{ */ +void zend_compile_shell_exec(znode *result, zend_ast *ast) /* {{{ */ { - zend_op *opline; + zend_ast *expr_ast = ast->child[0]; - if (!(CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO)) { - return; - } + zval fn_name; + zend_ast *name_ast, *args_ast, *call_ast; - opline = get_next_op(CG(active_op_array) TSRMLS_CC); + ZVAL_STRING(&fn_name, "shell_exec"); + name_ast = zend_ast_create_zval(&fn_name); + args_ast = zend_ast_create_list(1, ZEND_AST_ARG_LIST, expr_ast); + call_ast = zend_ast_create(ZEND_AST_CALL, name_ast, args_ast); - opline->opcode = ZEND_EXT_FCALL_BEGIN; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); + zend_compile_expr(result, call_ast); + + zval_ptr_dtor(&fn_name); } /* }}} */ -void zend_do_extended_fcall_end(TSRMLS_D) /* {{{ */ +void zend_compile_array(znode *result, zend_ast *ast) /* {{{ */ { + zend_ast_list *list = zend_ast_get_list(ast); zend_op *opline; + uint32_t i, opnum_init = -1; + zend_bool packed = 1; - if (!(CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO)) { + if (zend_try_ct_eval_array(&result->u.constant, ast)) { + result->op_type = IS_CONST; return; } - opline = get_next_op(CG(active_op_array) TSRMLS_CC); + for (i = 0; i < list->children; ++i) { + zend_ast *elem_ast = list->child[i]; + zend_ast *value_ast = elem_ast->child[0]; + zend_ast *key_ast = elem_ast->child[1]; + zend_bool by_ref = elem_ast->attr; - opline->opcode = ZEND_EXT_FCALL_END; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); -} -/* }}} */ + znode value_node, key_node, *key_node_ptr = NULL; -void zend_do_ticks(TSRMLS_D) /* {{{ */ -{ - /* This prevents a double TICK generated by the parser statement of "declare()" */ - if (CG(active_op_array)->last && CG(active_op_array)->opcodes[CG(active_op_array)->last - 1].opcode == ZEND_TICKS) { - return; - } - - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + if (key_ast) { + zend_compile_expr(&key_node, key_ast); + zend_handle_numeric_op(&key_node); + key_node_ptr = &key_node; + } - opline->opcode = ZEND_TICKS; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); - opline->extended_value = Z_LVAL(CG(declarables).ticks); -} -/* }}} */ + if (by_ref) { + zend_ensure_writable_variable(value_ast); + zend_compile_var(&value_node, value_ast, BP_VAR_W); + } else { + zend_compile_expr(&value_node, value_ast); + } -zend_bool zend_is_auto_global_quick(const char *name, uint name_len, ulong hash TSRMLS_DC) /* {{{ */ -{ - zend_auto_global *auto_global; + if (i == 0) { + opnum_init = get_next_op_number(CG(active_op_array)); + opline = zend_emit_op_tmp(result, ZEND_INIT_ARRAY, &value_node, key_node_ptr); + opline->extended_value = list->children << ZEND_ARRAY_SIZE_SHIFT; + } else { + opline = zend_emit_op(NULL, ZEND_ADD_ARRAY_ELEMENT, + &value_node, key_node_ptr); + SET_NODE(opline->result, result); + } + opline->extended_value |= by_ref; - if (zend_hash_quick_find(CG(auto_globals), name, name_len+1, hash, (void **) &auto_global)==SUCCESS) { - if (auto_global->armed) { - auto_global->armed = auto_global->auto_global_callback(auto_global->name, auto_global->name_len TSRMLS_CC); + if (key_ast && key_node.op_type == IS_CONST && Z_TYPE(key_node.u.constant) == IS_STRING) { + packed = 0; } - return 1; } - return 0; -} -/* }}} */ -zend_bool zend_is_auto_global(const char *name, uint name_len TSRMLS_DC) /* {{{ */ -{ - return zend_is_auto_global_quick(name, name_len, zend_hash_func(name, name_len+1) TSRMLS_CC); + /* Handle empty array */ + if (!list->children) { + zend_emit_op_tmp(result, ZEND_INIT_ARRAY, NULL, NULL); + } + + /* Add a flag to INIT_ARRAY if we know this array cannot be packed */ + if (!packed) { + ZEND_ASSERT(opnum_init != -1); + opline = &CG(active_op_array)->opcodes[opnum_init]; + opline->extended_value |= ZEND_ARRAY_NOT_PACKED; + } } /* }}} */ -int zend_register_auto_global(const char *name, uint name_len, zend_bool jit, zend_auto_global_callback auto_global_callback TSRMLS_DC) /* {{{ */ +void zend_compile_const(znode *result, zend_ast *ast) /* {{{ */ { - zend_auto_global auto_global; + zend_ast *name_ast = ast->child[0]; - auto_global.name = zend_new_interned_string((char*)name, name_len + 1, 0 TSRMLS_CC); - auto_global.name_len = name_len; - auto_global.auto_global_callback = auto_global_callback; - auto_global.jit = jit; + zend_op *opline; - return zend_hash_add(CG(auto_globals), name, name_len+1, &auto_global, sizeof(zend_auto_global), NULL); -} -/* }}} */ + zend_bool is_fully_qualified; + zend_string *orig_name = zend_ast_get_str(name_ast); + zend_string *resolved_name = zend_resolve_const_name( + orig_name, name_ast->attr, &is_fully_qualified); -static int zend_auto_global_init(zend_auto_global *auto_global TSRMLS_DC) /* {{{ */ -{ - if (auto_global->jit) { - auto_global->armed = 1; - } else if (auto_global->auto_global_callback) { - auto_global->armed = auto_global->auto_global_callback(auto_global->name, auto_global->name_len TSRMLS_CC); - } else { - auto_global->armed = 0; + if (zend_try_ct_eval_const(&result->u.constant, resolved_name, is_fully_qualified)) { + result->op_type = IS_CONST; + zend_string_release(resolved_name); + return; } - return 0; -} -/* }}} */ -ZEND_API void zend_activate_auto_globals(TSRMLS_D) /* {{{ */ -{ - zend_hash_apply(CG(auto_globals), (apply_func_t) zend_auto_global_init TSRMLS_CC); -} -/* }}} */ - -int zendlex(znode *zendlval TSRMLS_DC) /* {{{ */ -{ - int retval; + if (zend_string_equals_literal(resolved_name, "__COMPILER_HALT_OFFSET__")) { + zend_ast *last = CG(ast); - if (CG(increment_lineno)) { - CG(zend_lineno)++; - CG(increment_lineno) = 0; + while (last->kind == ZEND_AST_STMT_LIST) { + zend_ast_list *list = zend_ast_get_list(last); + last = list->child[list->children-1]; + } + if (last->kind == ZEND_AST_HALT_COMPILER) { + result->op_type = IS_CONST; + ZVAL_LONG(&result->u.constant, + Z_LVAL_P(zend_ast_get_zval(last->child[0]))); + zend_string_release(resolved_name); + return; + } } -again: - Z_TYPE(zendlval->u.constant) = IS_LONG; - retval = lex_scan(&zendlval->u.constant TSRMLS_CC); - switch (retval) { - case T_COMMENT: - case T_DOC_COMMENT: - case T_OPEN_TAG: - case T_WHITESPACE: - goto again; + opline = zend_emit_op_tmp(result, ZEND_FETCH_CONSTANT, NULL, NULL); + opline->op2_type = IS_CONST; - case T_CLOSE_TAG: - if (LANG_SCNG(yy_text)[LANG_SCNG(yy_leng)-1] != '>') { - CG(increment_lineno) = 1; - } - if (CG(has_bracketed_namespaces) && !CG(in_namespace)) { - goto again; - } - retval = ';'; /* implicit ; */ - break; - case T_OPEN_TAG_WITH_ECHO: - retval = T_ECHO; - break; + if (is_fully_qualified) { + opline->op2.constant = zend_add_const_name_literal( + CG(active_op_array), resolved_name, 0); + } else { + opline->extended_value = IS_CONSTANT_UNQUALIFIED; + if (FC(current_namespace)) { + opline->extended_value |= IS_CONSTANT_IN_NAMESPACE; + opline->op2.constant = zend_add_const_name_literal( + CG(active_op_array), resolved_name, 1); + } else { + opline->op2.constant = zend_add_const_name_literal( + CG(active_op_array), resolved_name, 0); + } } - - INIT_PZVAL(&zendlval->u.constant); - zendlval->op_type = IS_CONST; - return retval; + zend_alloc_cache_slot(opline->op2.constant); } /* }}} */ -ZEND_API void zend_initialize_class_data(zend_class_entry *ce, zend_bool nullify_handlers TSRMLS_DC) /* {{{ */ +void zend_compile_class_const(znode *result, zend_ast *ast) /* {{{ */ { - zend_bool persistent_hashes = (ce->type == ZEND_INTERNAL_CLASS) ? 1 : 0; - dtor_func_t zval_ptr_dtor_func = ((persistent_hashes) ? ZVAL_INTERNAL_PTR_DTOR : ZVAL_PTR_DTOR); + zend_ast *class_ast = ast->child[0]; + zend_ast *const_ast = ast->child[1]; - ce->refcount = 1; - ce->ce_flags = 0; + znode class_node, const_node; + zend_op *opline; + zend_string *resolved_name; - ce->default_properties_table = NULL; - ce->default_static_members_table = NULL; - zend_hash_init_ex(&ce->properties_info, 0, NULL, (dtor_func_t) (persistent_hashes ? zend_destroy_property_info_internal : zend_destroy_property_info), persistent_hashes, 0); - zend_hash_init_ex(&ce->constants_table, 0, NULL, zval_ptr_dtor_func, persistent_hashes, 0); - zend_hash_init_ex(&ce->function_table, 0, NULL, ZEND_FUNCTION_DTOR, persistent_hashes, 0); + if (zend_try_compile_const_expr_resolve_class_name(&result->u.constant, class_ast, const_ast, 0)) { + if (Z_TYPE(result->u.constant) == IS_NULL) { + zend_op *opline = zend_emit_op_tmp(result, ZEND_FETCH_CLASS_NAME, NULL, NULL); + opline->extended_value = zend_get_class_fetch_type(zend_ast_get_str(class_ast)); + } else { + result->op_type = IS_CONST; + } + return; + } - if (ce->type == ZEND_INTERNAL_CLASS) { -#ifdef ZTS - int n = zend_hash_num_elements(CG(class_table)); + zend_eval_const_expr(&class_ast); + zend_eval_const_expr(&const_ast); - if (CG(static_members_table) && n >= CG(last_static_member)) { - /* Support for run-time declaration: dl() */ - CG(last_static_member) = n+1; - CG(static_members_table) = realloc(CG(static_members_table), (n+1)*sizeof(zval**)); - CG(static_members_table)[n] = NULL; + if (class_ast->kind == ZEND_AST_ZVAL) { + resolved_name = zend_resolve_class_name_ast(class_ast); + if (const_ast->kind == ZEND_AST_ZVAL && zend_try_ct_eval_class_const(&result->u.constant, resolved_name, zend_ast_get_str(const_ast))) { + result->op_type = IS_CONST; + zend_string_release(resolved_name); + return; } - ce->static_members_table = (zval**)(zend_intptr_t)n; -#else - ce->static_members_table = NULL; -#endif - } else { - ce->static_members_table = ce->default_static_members_table; - ce->info.user.doc_comment = NULL; - ce->info.user.doc_comment_len = 0; + } + if (const_ast->kind == ZEND_AST_ZVAL && zend_string_equals_literal_ci(zend_ast_get_str(const_ast), "class")) { + zend_error_noreturn(E_COMPILE_ERROR, + "Dynamic class names are not allowed in compile-time ::class fetch"); } - ce->default_properties_count = 0; - ce->default_static_members_count = 0; - - if (nullify_handlers) { - ce->constructor = NULL; - ce->destructor = NULL; - ce->clone = NULL; - ce->__get = NULL; - ce->__set = NULL; - ce->__unset = NULL; - ce->__isset = NULL; - ce->__call = NULL; - ce->__callstatic = NULL; - ce->__tostring = NULL; - ce->create_object = NULL; - ce->get_iterator = NULL; - ce->iterator_funcs.funcs = NULL; - ce->interface_gets_implemented = NULL; - ce->get_static_method = NULL; - ce->parent = NULL; - ce->num_interfaces = 0; - ce->interfaces = NULL; - ce->num_traits = 0; - ce->traits = NULL; - ce->trait_aliases = NULL; - ce->trait_precedences = NULL; - ce->serialize = NULL; - ce->unserialize = NULL; - ce->serialize_func = NULL; - ce->unserialize_func = NULL; - ce->__debugInfo = NULL; - if (ce->type == ZEND_INTERNAL_CLASS) { - ce->info.internal.module = NULL; - ce->info.internal.builtin_functions = NULL; + if (zend_is_const_default_class_ref(class_ast)) { + class_node.op_type = IS_CONST; + ZVAL_STR(&class_node.u.constant, resolved_name); + } else { + if (class_ast->kind == ZEND_AST_ZVAL) { + zend_string_release(resolved_name); } + zend_compile_class_ref(&class_node, class_ast, 1); } -} -/* }}} */ -int zend_get_class_fetch_type(const char *class_name, uint class_name_len) /* {{{ */ -{ - if ((class_name_len == sizeof("self")-1) && - !strncasecmp(class_name, "self", sizeof("self")-1)) { - return ZEND_FETCH_CLASS_SELF; - } else if ((class_name_len == sizeof("parent")-1) && - !strncasecmp(class_name, "parent", sizeof("parent")-1)) { - return ZEND_FETCH_CLASS_PARENT; - } else if ((class_name_len == sizeof("static")-1) && - !strncasecmp(class_name, "static", sizeof("static")-1)) { - return ZEND_FETCH_CLASS_STATIC; + zend_compile_expr(&const_node, const_ast); + + opline = zend_emit_op_tmp(result, ZEND_FETCH_CONSTANT, NULL, &const_node); + + zend_set_class_name_op1(opline, &class_node); + + if (opline->op1_type == IS_CONST) { + zend_alloc_cache_slot(opline->op2.constant); } else { - return ZEND_FETCH_CLASS_DEFAULT; + zend_alloc_polymorphic_cache_slot(opline->op2.constant); } } /* }}} */ -ZEND_API const char* zend_get_compiled_variable_name(const zend_op_array *op_array, zend_uint var, int* name_len) /* {{{ */ +void zend_compile_resolve_class_name(znode *result, zend_ast *ast) /* {{{ */ { - if (name_len) { - *name_len = op_array->vars[var].name_len; + zend_ast *name_ast = ast->child[0]; + uint32_t fetch_type = zend_get_class_fetch_type(zend_ast_get_str(name_ast)); + zend_ensure_valid_class_fetch_type(fetch_type); + + switch (fetch_type) { + case ZEND_FETCH_CLASS_SELF: + if (CG(active_class_entry) && zend_is_scope_known()) { + result->op_type = IS_CONST; + ZVAL_STR_COPY(&result->u.constant, CG(active_class_entry)->name); + } else { + zend_op *opline = zend_emit_op_tmp(result, ZEND_FETCH_CLASS_NAME, NULL, NULL); + opline->extended_value = fetch_type; + } + break; + case ZEND_FETCH_CLASS_STATIC: + case ZEND_FETCH_CLASS_PARENT: + { + zend_op *opline = zend_emit_op_tmp(result, ZEND_FETCH_CLASS_NAME, NULL, NULL); + opline->extended_value = fetch_type; + } + break; + case ZEND_FETCH_CLASS_DEFAULT: + result->op_type = IS_CONST; + ZVAL_STR(&result->u.constant, zend_resolve_class_name_ast(name_ast)); + break; + EMPTY_SWITCH_DEFAULT_CASE() } - return op_array->vars[var].name; } /* }}} */ -void zend_do_build_namespace_name(znode *result, znode *prefix, znode *name TSRMLS_DC) /* {{{ */ +static zend_op *zend_compile_rope_add(znode *result, uint32_t num, znode *elem_node) /* {{{ */ { - if (prefix) { - *result = *prefix; - if (Z_TYPE(result->u.constant) == IS_STRING && - Z_STRLEN(result->u.constant) == 0) { - /* namespace\ */ - if (CG(current_namespace)) { - znode tmp; + zend_op *opline = get_next_op(CG(active_op_array)); - zval_dtor(&result->u.constant); - tmp.op_type = IS_CONST; - tmp.u.constant = *CG(current_namespace); - zval_copy_ctor(&tmp.u.constant); - zend_do_build_namespace_name(result, NULL, &tmp TSRMLS_CC); - } - } + if (num == 0) { + result->op_type = IS_TMP_VAR; + result->u.op.var = -1; + opline->opcode = ZEND_ROPE_INIT; + SET_UNUSED(opline->op1); } else { - result->op_type = IS_CONST; - Z_TYPE(result->u.constant) = IS_STRING; - Z_STRVAL(result->u.constant) = NULL; - Z_STRLEN(result->u.constant) = 0; + opline->opcode = ZEND_ROPE_ADD; + SET_NODE(opline->op1, result); } - /* prefix = result */ - zend_do_build_full_name(NULL, result, name, 0 TSRMLS_CC); + SET_NODE(opline->op2, elem_node); + SET_NODE(opline->result, result); + opline->extended_value = num; + return opline; } /* }}} */ -void zend_do_begin_namespace(const znode *name, zend_bool with_bracket TSRMLS_DC) /* {{{ */ +static void zend_compile_encaps_list(znode *result, zend_ast *ast) /* {{{ */ { - char *lcname; + uint32_t i, j; + uint32_t rope_init_lineno = -1; + zend_op *opline = NULL, *init_opline; + znode elem_node, last_const_node; + zend_ast_list *list = zend_ast_get_list(ast); - /* handle mixed syntax declaration or nested namespaces */ - if (!CG(has_bracketed_namespaces)) { - if (CG(current_namespace)) { - /* previous namespace declarations were unbracketed */ - if (with_bracket) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot mix bracketed namespace declarations with unbracketed namespace declarations"); + ZEND_ASSERT(list->children > 0); + + j = 0; + last_const_node.op_type = IS_UNUSED; + for (i = 0; i < list->children; i++) { + zend_compile_expr(&elem_node, list->child[i]); + + if (elem_node.op_type == IS_CONST) { + convert_to_string(&elem_node.u.constant); + + if (Z_STRLEN(elem_node.u.constant) == 0) { + zval_ptr_dtor(&elem_node.u.constant); + } else if (last_const_node.op_type == IS_CONST) { + concat_function(&last_const_node.u.constant, &last_const_node.u.constant, &elem_node.u.constant); + zval_ptr_dtor(&elem_node.u.constant); + } else { + last_const_node.op_type = IS_CONST; + ZVAL_COPY_VALUE(&last_const_node.u.constant, &elem_node.u.constant); } - } - } else { - /* previous namespace declarations were bracketed */ - if (!with_bracket) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot mix bracketed namespace declarations with unbracketed namespace declarations"); - } else if (CG(current_namespace) || CG(in_namespace)) { - zend_error_noreturn(E_COMPILE_ERROR, "Namespace declarations cannot be nested"); + continue; + } else { + if (j == 0) { + rope_init_lineno = get_next_op_number(CG(active_op_array)); + } + if (last_const_node.op_type == IS_CONST) { + zend_compile_rope_add(result, j++, &last_const_node); + last_const_node.op_type = IS_UNUSED; + } + opline = zend_compile_rope_add(result, j++, &elem_node); } } - if (((!with_bracket && !CG(current_namespace)) || (with_bracket && !CG(has_bracketed_namespaces))) && CG(active_op_array)->last > 0) { - /* ignore ZEND_EXT_STMT and ZEND_TICKS */ - int num = CG(active_op_array)->last; - while (num > 0 && - (CG(active_op_array)->opcodes[num-1].opcode == ZEND_EXT_STMT || - CG(active_op_array)->opcodes[num-1].opcode == ZEND_TICKS)) { - --num; + if (j == 0) { + result->op_type = IS_CONST; + if (last_const_node.op_type == IS_CONST) { + ZVAL_COPY_VALUE(&result->u.constant, &last_const_node.u.constant); + } else { + ZVAL_EMPTY_STRING(&result->u.constant); + /* empty string */ } - if (num > 0) { - zend_error_noreturn(E_COMPILE_ERROR, "Namespace declaration statement has to be the very first statement in the script"); + return; + } else if (last_const_node.op_type == IS_CONST) { + opline = zend_compile_rope_add(result, j++, &last_const_node); + } + init_opline = CG(active_op_array)->opcodes + rope_init_lineno; + if (j == 1) { + if (opline->op2_type == IS_CONST) { + GET_NODE(result, opline->op2); + MAKE_NOP(opline); + } else { + opline->opcode = ZEND_CAST; + opline->extended_value = IS_STRING; + opline->op1_type = opline->op2_type; + opline->op1 = opline->op2; + opline->result_type = IS_TMP_VAR; + opline->result.var = get_temporary_variable(CG(active_op_array)); + SET_UNUSED(opline->op2); + GET_NODE(result, opline->result); } - } - - CG(in_namespace) = 1; - if (with_bracket) { - CG(has_bracketed_namespaces) = 1; - } + } else if (j == 2) { + opline->opcode = ZEND_FAST_CONCAT; + opline->extended_value = 0; + opline->op1_type = init_opline->op2_type; + opline->op1 = init_opline->op2; + opline->result_type = IS_TMP_VAR; + opline->result.var = get_temporary_variable(CG(active_op_array)); + MAKE_NOP(init_opline); + GET_NODE(result, opline->result); + } else { + uint32_t var; - if (name) { - lcname = zend_str_tolower_dup(Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant)); - if (((Z_STRLEN(name->u.constant) == sizeof("self")-1) && - !memcmp(lcname, "self", sizeof("self")-1)) || - ((Z_STRLEN(name->u.constant) == sizeof("parent")-1) && - !memcmp(lcname, "parent", sizeof("parent")-1))) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as namespace name", Z_STRVAL(name->u.constant)); - } - efree(lcname); + init_opline->extended_value = j; + opline->opcode = ZEND_ROPE_END; + opline->result.var = get_temporary_variable(CG(active_op_array)); + var = opline->op1.var = get_temporary_variable(CG(active_op_array)); + GET_NODE(result, opline->result); - if (CG(current_namespace)) { - zval_dtor(CG(current_namespace)); - } else { - ALLOC_ZVAL(CG(current_namespace)); + /* Allocates the necessary number of zval slots to keep the rope */ + i = ((j * sizeof(zend_string*)) + (sizeof(zval) - 1)) / sizeof(zval); + while (i > 1) { + get_temporary_variable(CG(active_op_array)); + i--; } - *CG(current_namespace) = name->u.constant; - } else { - if (CG(current_namespace)) { - zval_dtor(CG(current_namespace)); - FREE_ZVAL(CG(current_namespace)); - CG(current_namespace) = NULL; + /* Update all the previous opcodes to use the same variable */ + while (opline != init_opline) { + opline--; + if (opline->opcode == ZEND_ROPE_ADD && + opline->result.var == -1) { + opline->op1.var = var; + opline->result.var = var; + } else if (opline->opcode == ZEND_ROPE_INIT && + opline->result.var == -1) { + opline->result.var = var; + } } } +} +/* }}} */ - if (CG(current_import)) { - zend_hash_destroy(CG(current_import)); - efree(CG(current_import)); - CG(current_import) = NULL; - } +void zend_compile_magic_const(znode *result, zend_ast *ast) /* {{{ */ +{ + zend_op *opline; - if (CG(current_import_function)) { - zend_hash_destroy(CG(current_import_function)); - efree(CG(current_import_function)); - CG(current_import_function) = NULL; + if (zend_try_ct_eval_magic_const(&result->u.constant, ast)) { + result->op_type = IS_CONST; + return; } - if (CG(current_import_const)) { - zend_hash_destroy(CG(current_import_const)); - efree(CG(current_import_const)); - CG(current_import_const) = NULL; - } + ZEND_ASSERT(ast->attr == T_CLASS_C && + CG(active_class_entry) && + (CG(active_class_entry)->ce_flags & ZEND_ACC_TRAIT) != 0); - if (CG(doc_comment)) { - efree(CG(doc_comment)); - CG(doc_comment) = NULL; - CG(doc_comment_len) = 0; - } + opline = zend_emit_op_tmp(result, ZEND_FETCH_CLASS_NAME, NULL, NULL); + opline->extended_value = ZEND_FETCH_CLASS_SELF; } /* }}} */ -void zend_do_use(znode *ns_name, znode *new_name TSRMLS_DC) /* {{{ */ +zend_bool zend_is_allowed_in_const_expr(zend_ast_kind kind) /* {{{ */ { - char *lcname; - zval *name, *ns, tmp; - zend_bool warn = 0; - zend_class_entry **pce; + return kind == ZEND_AST_ZVAL || kind == ZEND_AST_BINARY_OP + || kind == ZEND_AST_GREATER || kind == ZEND_AST_GREATER_EQUAL + || kind == ZEND_AST_AND || kind == ZEND_AST_OR + || kind == ZEND_AST_UNARY_OP + || kind == ZEND_AST_UNARY_PLUS || kind == ZEND_AST_UNARY_MINUS + || kind == ZEND_AST_CONDITIONAL || kind == ZEND_AST_DIM + || kind == ZEND_AST_ARRAY || kind == ZEND_AST_ARRAY_ELEM + || kind == ZEND_AST_CONST || kind == ZEND_AST_CLASS_CONST + || kind == ZEND_AST_MAGIC_CONST; +} +/* }}} */ - if (!CG(current_import)) { - CG(current_import) = emalloc(sizeof(HashTable)); - zend_hash_init(CG(current_import), 0, NULL, ZVAL_PTR_DTOR, 0); +void zend_compile_const_expr_class_const(zend_ast **ast_ptr) /* {{{ */ +{ + zend_ast *ast = *ast_ptr; + zend_ast *class_ast = ast->child[0]; + zend_ast *const_ast = ast->child[1]; + zend_string *class_name; + zend_string *const_name = zend_ast_get_str(const_ast); + zval result; + int fetch_type; + + if (class_ast->kind != ZEND_AST_ZVAL) { + zend_error_noreturn(E_COMPILE_ERROR, + "Dynamic class names are not allowed in compile-time class constant references"); } - MAKE_STD_ZVAL(ns); - ZVAL_ZVAL(ns, &ns_name->u.constant, 0, 0); - if (new_name) { - name = &new_name->u.constant; - } else { - const char *p; - - /* The form "use A\B" is eqivalent to "use A\B as B". - So we extract the last part of compound name to use as a new_name */ - name = &tmp; - p = zend_memrchr(Z_STRVAL_P(ns), '\\', Z_STRLEN_P(ns)); - if (p) { - ZVAL_STRING(name, p+1, 1); - } else { - ZVAL_ZVAL(name, ns, 1, 0); - warn = !CG(current_namespace); - } + if (zend_try_compile_const_expr_resolve_class_name(&result, class_ast, const_ast, 1)) { + *ast_ptr = zend_ast_create_zval(&result); + return; } - lcname = zend_str_tolower_dup(Z_STRVAL_P(name), Z_STRLEN_P(name)); + class_name = zend_ast_get_str(class_ast); + fetch_type = zend_get_class_fetch_type(class_name); - if (((Z_STRLEN_P(name) == sizeof("self")-1) && - !memcmp(lcname, "self", sizeof("self")-1)) || - ((Z_STRLEN_P(name) == sizeof("parent")-1) && - !memcmp(lcname, "parent", sizeof("parent")-1))) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use %s as %s because '%s' is a special class name", Z_STRVAL_P(ns), Z_STRVAL_P(name), Z_STRVAL_P(name)); + if (ZEND_FETCH_CLASS_STATIC == fetch_type) { + zend_error_noreturn(E_COMPILE_ERROR, + "\"static::\" is not allowed in compile-time constants"); } - if (CG(current_namespace)) { - /* Prefix import name with current namespace name to avoid conflicts with classes */ - char *c_ns_name = emalloc(Z_STRLEN_P(CG(current_namespace)) + 1 + Z_STRLEN_P(name) + 1); + if (ZEND_FETCH_CLASS_DEFAULT == fetch_type) { + class_name = zend_resolve_class_name_ast(class_ast); + } else { + zend_string_addref(class_name); + } - zend_str_tolower_copy(c_ns_name, Z_STRVAL_P(CG(current_namespace)), Z_STRLEN_P(CG(current_namespace))); - c_ns_name[Z_STRLEN_P(CG(current_namespace))] = '\\'; - memcpy(c_ns_name+Z_STRLEN_P(CG(current_namespace))+1, lcname, Z_STRLEN_P(name)+1); - if (zend_hash_exists(CG(class_table), c_ns_name, Z_STRLEN_P(CG(current_namespace)) + 1 + Z_STRLEN_P(name)+1)) { - char *tmp2 = zend_str_tolower_dup(Z_STRVAL_P(ns), Z_STRLEN_P(ns)); + Z_STR(result) = zend_concat3( + ZSTR_VAL(class_name), ZSTR_LEN(class_name), "::", 2, ZSTR_VAL(const_name), ZSTR_LEN(const_name)); - if (Z_STRLEN_P(ns) != Z_STRLEN_P(CG(current_namespace)) + 1 + Z_STRLEN_P(name) || - memcmp(tmp2, c_ns_name, Z_STRLEN_P(ns))) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use %s as %s because the name is already in use", Z_STRVAL_P(ns), Z_STRVAL_P(name)); - } - efree(tmp2); - } - efree(c_ns_name); - } else if (zend_hash_find(CG(class_table), lcname, Z_STRLEN_P(name)+1, (void**)&pce) == SUCCESS && - (*pce)->type == ZEND_USER_CLASS && - (*pce)->info.user.filename == CG(compiled_filename)) { - char *c_tmp = zend_str_tolower_dup(Z_STRVAL_P(ns), Z_STRLEN_P(ns)); + Z_TYPE_INFO(result) = IS_CONSTANT_EX; + Z_CONST_FLAGS(result) = fetch_type; - if (Z_STRLEN_P(ns) != Z_STRLEN_P(name) || - memcmp(c_tmp, lcname, Z_STRLEN_P(ns))) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use %s as %s because the name is already in use", Z_STRVAL_P(ns), Z_STRVAL_P(name)); - } - efree(c_tmp); - } + zend_ast_destroy(ast); + zend_string_release(class_name); - if (zend_hash_add(CG(current_import), lcname, Z_STRLEN_P(name)+1, &ns, sizeof(zval*), NULL) != SUCCESS) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use %s as %s because the name is already in use", Z_STRVAL_P(ns), Z_STRVAL_P(name)); - } - if (warn) { - if (!strcmp(Z_STRVAL_P(name), "strict")) { - zend_error_noreturn(E_COMPILE_ERROR, "You seem to be trying to use a different language..."); - } - zend_error(E_WARNING, "The use statement with non-compound name '%s' has no effect", Z_STRVAL_P(name)); - } - efree(lcname); - zval_dtor(name); + *ast_ptr = zend_ast_create_zval(&result); } /* }}} */ -void zend_do_use_non_class(znode *ns_name, znode *new_name, int is_function, zend_bool case_sensitive, HashTable *current_import_sub, HashTable *lookup_table TSRMLS_DC) /* {{{ */ +void zend_compile_const_expr_const(zend_ast **ast_ptr) /* {{{ */ { - char *lookup_name; - zval *name, *ns, tmp; - zend_bool warn = 0; + zend_ast *ast = *ast_ptr; + zend_ast *name_ast = ast->child[0]; + zend_string *orig_name = zend_ast_get_str(name_ast); + zend_bool is_fully_qualified; - MAKE_STD_ZVAL(ns); - ZVAL_ZVAL(ns, &ns_name->u.constant, 0, 0); - if (new_name) { - name = &new_name->u.constant; - } else { - const char *p; - - /* The form "use A\B" is eqivalent to "use A\B as B". - So we extract the last part of compound name to use as a new_name */ - name = &tmp; - p = zend_memrchr(Z_STRVAL_P(ns), '\\', Z_STRLEN_P(ns)); - if (p) { - ZVAL_STRING(name, p+1, 1); - } else { - ZVAL_ZVAL(name, ns, 1, 0); - warn = !CG(current_namespace); - } - } + zval result, resolved_name; + ZVAL_STR(&resolved_name, zend_resolve_const_name( + orig_name, name_ast->attr, &is_fully_qualified)); - if (case_sensitive) { - lookup_name = estrndup(Z_STRVAL_P(name), Z_STRLEN_P(name)); - } else { - lookup_name = zend_str_tolower_dup(Z_STRVAL_P(name), Z_STRLEN_P(name)); + if (zend_try_ct_eval_const(&result, Z_STR(resolved_name), is_fully_qualified)) { + zend_string_release(Z_STR(resolved_name)); + zend_ast_destroy(ast); + *ast_ptr = zend_ast_create_zval(&result); + return; } - if (CG(current_namespace)) { - /* Prefix import name with current namespace name to avoid conflicts with functions/consts */ - char *c_ns_name = emalloc(Z_STRLEN_P(CG(current_namespace)) + 1 + Z_STRLEN_P(name) + 1); - - zend_str_tolower_copy(c_ns_name, Z_STRVAL_P(CG(current_namespace)), Z_STRLEN_P(CG(current_namespace))); - c_ns_name[Z_STRLEN_P(CG(current_namespace))] = '\\'; - memcpy(c_ns_name+Z_STRLEN_P(CG(current_namespace))+1, lookup_name, Z_STRLEN_P(name)+1); - if (zend_hash_exists(lookup_table, c_ns_name, Z_STRLEN_P(CG(current_namespace)) + 1 + Z_STRLEN_P(name)+1)) { - char *tmp2 = zend_str_tolower_dup(Z_STRVAL_P(ns), Z_STRLEN_P(ns)); - - if (Z_STRLEN_P(ns) != Z_STRLEN_P(CG(current_namespace)) + 1 + Z_STRLEN_P(name) || - memcmp(tmp2, c_ns_name, Z_STRLEN_P(ns))) { - zend_error(E_COMPILE_ERROR, "Cannot use %s %s as %s because the name is already in use", is_function ? "function" : "const", Z_STRVAL_P(ns), Z_STRVAL_P(name)); - } - efree(tmp2); - } - efree(c_ns_name); - } else if (is_function) { - zend_function *function; + Z_TYPE_INFO(resolved_name) = IS_CONSTANT_EX; + if (!is_fully_qualified) { + Z_CONST_FLAGS(resolved_name) = IS_CONSTANT_UNQUALIFIED; + } - if (zend_hash_find(lookup_table, lookup_name, Z_STRLEN_P(name)+1, (void **) &function) == SUCCESS && function->type == ZEND_USER_FUNCTION && strcmp(function->op_array.filename, CG(compiled_filename)) == 0) { - char *c_tmp = zend_str_tolower_dup(Z_STRVAL_P(ns), Z_STRLEN_P(ns)); + zend_ast_destroy(ast); + *ast_ptr = zend_ast_create_zval(&resolved_name); +} +/* }}} */ - if (Z_STRLEN_P(ns) != Z_STRLEN_P(name) || - memcmp(c_tmp, lookup_name, Z_STRLEN_P(ns))) { - zend_error(E_COMPILE_ERROR, "Cannot use function %s as %s because the name is already in use", Z_STRVAL_P(ns), Z_STRVAL_P(name)); - } - efree(c_tmp); - } - } else { - const char *filename; +void zend_compile_const_expr_magic_const(zend_ast **ast_ptr) /* {{{ */ +{ + zend_ast *ast = *ast_ptr; - if (zend_hash_find(lookup_table, lookup_name, Z_STRLEN_P(name)+1, (void **) &filename) == SUCCESS && strcmp(filename, CG(compiled_filename)) == 0) { - char *c_tmp = zend_str_tolower_dup(Z_STRVAL_P(ns), Z_STRLEN_P(ns)); + /* Other cases already resolved by constant folding */ + ZEND_ASSERT(ast->attr == T_CLASS_C && + CG(active_class_entry) && + (CG(active_class_entry)->ce_flags & ZEND_ACC_TRAIT) != 0); - if (Z_STRLEN_P(ns) != Z_STRLEN_P(name) || - memcmp(c_tmp, lookup_name, Z_STRLEN_P(ns))) { - zend_error(E_COMPILE_ERROR, "Cannot use const %s as %s because the name is already in use", Z_STRVAL_P(ns), Z_STRVAL_P(name)); - } - efree(c_tmp); - } - } + { + zval const_zv; + Z_STR(const_zv) = zend_string_init("__CLASS__", sizeof("__CLASS__")-1, 0); + Z_TYPE_INFO(const_zv) = IS_CONSTANT_EX | (IS_CONSTANT_CLASS << Z_CONST_FLAGS_SHIFT); - if (zend_hash_add(current_import_sub, lookup_name, Z_STRLEN_P(name)+1, &ns, sizeof(zval*), NULL) != SUCCESS) { - zend_error(E_COMPILE_ERROR, "Cannot use %s %s as %s because the name is already in use", is_function ? "function" : "const", Z_STRVAL_P(ns), Z_STRVAL_P(name)); - } - if (warn) { - zend_error(E_WARNING, "The use %s statement with non-compound name '%s' has no effect", is_function ? "function" : "const", Z_STRVAL_P(name)); + zend_ast_destroy(ast); + *ast_ptr = zend_ast_create_zval(&const_zv); } - efree(lookup_name); - zval_dtor(name); } /* }}} */ -void zend_do_use_function(znode *ns_name, znode *new_name TSRMLS_DC) /* {{{ */ +void zend_compile_const_expr(zend_ast **ast_ptr) /* {{{ */ { - if (!CG(current_import_function)) { - CG(current_import_function) = emalloc(sizeof(HashTable)); - zend_hash_init(CG(current_import_function), 0, NULL, ZVAL_PTR_DTOR, 0); + zend_ast *ast = *ast_ptr; + if (ast == NULL || ast->kind == ZEND_AST_ZVAL) { + return; + } + + if (!zend_is_allowed_in_const_expr(ast->kind)) { + zend_error_noreturn(E_COMPILE_ERROR, "Constant expression contains invalid operations"); } - zend_do_use_non_class(ns_name, new_name, 1, 0, CG(current_import_function), CG(function_table) TSRMLS_CC); + switch (ast->kind) { + case ZEND_AST_CLASS_CONST: + zend_compile_const_expr_class_const(ast_ptr); + break; + case ZEND_AST_CONST: + zend_compile_const_expr_const(ast_ptr); + break; + case ZEND_AST_MAGIC_CONST: + zend_compile_const_expr_magic_const(ast_ptr); + break; + default: + zend_ast_apply(ast, zend_compile_const_expr); + break; + } } /* }}} */ -void zend_do_use_const(znode *ns_name, znode *new_name TSRMLS_DC) /* {{{ */ +void zend_const_expr_to_zval(zval *result, zend_ast *ast) /* {{{ */ { - if (!CG(current_import_const)) { - CG(current_import_const) = emalloc(sizeof(HashTable)); - zend_hash_init(CG(current_import_const), 0, NULL, ZVAL_PTR_DTOR, 0); - } + zend_ast *orig_ast = ast; + zend_eval_const_expr(&ast); + zend_compile_const_expr(&ast); + if (ast->kind == ZEND_AST_ZVAL) { + ZVAL_COPY_VALUE(result, zend_ast_get_zval(ast)); - zend_do_use_non_class(ns_name, new_name, 0, 1, CG(current_import_const), &CG(const_filenames) TSRMLS_CC); + /* Kill this branch of the original AST, as it was already destroyed. + * It would be nice to find a better solution to this problem in the + * future. */ + orig_ast->kind = 0; + } else { + ZVAL_NEW_AST(result, zend_ast_copy(ast)); + } } /* }}} */ -void zend_do_declare_constant(znode *name, znode *value TSRMLS_DC) /* {{{ */ +/* Same as compile_stmt, but with early binding */ +void zend_compile_top_stmt(zend_ast *ast) /* {{{ */ { - zend_op *opline; - zval **ns_name; + if (!ast) { + return; + } - if (zend_get_ct_const(&name->u.constant, 0 TSRMLS_CC)) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare constant '%s'", Z_STRVAL(name->u.constant)); + if (ast->kind == ZEND_AST_STMT_LIST) { + zend_ast_list *list = zend_ast_get_list(ast); + uint32_t i; + for (i = 0; i < list->children; ++i) { + zend_compile_top_stmt(list->child[i]); + } + return; } - if (CG(current_namespace)) { - /* Prefix constant name with name of current namespace, lowercased */ - znode tmp; + zend_compile_stmt(ast); - tmp.op_type = IS_CONST; - tmp.u.constant = *CG(current_namespace); - Z_STRVAL(tmp.u.constant) = zend_str_tolower_dup(Z_STRVAL(tmp.u.constant), Z_STRLEN(tmp.u.constant)); - zend_do_build_namespace_name(&tmp, &tmp, name TSRMLS_CC); - *name = tmp; + if (ast->kind != ZEND_AST_NAMESPACE && ast->kind != ZEND_AST_HALT_COMPILER) { + zend_verify_namespace(); } + if (ast->kind == ZEND_AST_FUNC_DECL || ast->kind == ZEND_AST_CLASS) { + CG(zend_lineno) = ((zend_ast_decl *) ast)->end_lineno; + zend_do_early_binding(); + } +} +/* }}} */ - /* Constant name must not conflict with import names */ - if (CG(current_import_const) && - zend_hash_find(CG(current_import_const), Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant)+1, (void**)&ns_name) == SUCCESS) { +void zend_compile_stmt(zend_ast *ast) /* {{{ */ +{ + if (!ast) { + return; + } - char *tmp = estrndup(Z_STRVAL_PP(ns_name), Z_STRLEN_PP(ns_name)); + CG(zend_lineno) = ast->lineno; - if (Z_STRLEN_PP(ns_name) != Z_STRLEN(name->u.constant) || - memcmp(tmp, Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant))) { - zend_error(E_COMPILE_ERROR, "Cannot declare const %s because the name is already in use", Z_STRVAL(name->u.constant)); + switch (ast->kind) { + case ZEND_AST_STMT_LIST: + zend_compile_stmt_list(ast); + break; + case ZEND_AST_GLOBAL: + zend_compile_global_var(ast); + break; + case ZEND_AST_STATIC: + zend_compile_static_var(ast); + break; + case ZEND_AST_UNSET: + zend_compile_unset(ast); + break; + case ZEND_AST_RETURN: + zend_compile_return(ast); + break; + case ZEND_AST_ECHO: + zend_compile_echo(ast); + break; + case ZEND_AST_THROW: + zend_compile_throw(ast); + break; + case ZEND_AST_BREAK: + case ZEND_AST_CONTINUE: + zend_compile_break_continue(ast); + break; + case ZEND_AST_GOTO: + zend_compile_goto(ast); + break; + case ZEND_AST_LABEL: + zend_compile_label(ast); + break; + case ZEND_AST_WHILE: + zend_compile_while(ast); + break; + case ZEND_AST_DO_WHILE: + zend_compile_do_while(ast); + break; + case ZEND_AST_FOR: + zend_compile_for(ast); + break; + case ZEND_AST_FOREACH: + zend_compile_foreach(ast); + break; + case ZEND_AST_IF: + zend_compile_if(ast); + break; + case ZEND_AST_SWITCH: + zend_compile_switch(ast); + break; + case ZEND_AST_TRY: + zend_compile_try(ast); + break; + case ZEND_AST_DECLARE: + zend_compile_declare(ast); + break; + case ZEND_AST_FUNC_DECL: + case ZEND_AST_METHOD: + zend_compile_func_decl(NULL, ast); + break; + case ZEND_AST_PROP_DECL: + zend_compile_prop_decl(ast); + break; + case ZEND_AST_CLASS_CONST_DECL: + zend_compile_class_const_decl(ast); + break; + case ZEND_AST_USE_TRAIT: + zend_compile_use_trait(ast); + break; + case ZEND_AST_CLASS: + zend_compile_class_decl(ast); + break; + case ZEND_AST_GROUP_USE: + zend_compile_group_use(ast); + break; + case ZEND_AST_USE: + zend_compile_use(ast); + break; + case ZEND_AST_CONST_DECL: + zend_compile_const_decl(ast); + break; + case ZEND_AST_NAMESPACE: + zend_compile_namespace(ast); + break; + case ZEND_AST_HALT_COMPILER: + zend_compile_halt_compiler(ast); + break; + default: + { + znode result; + zend_compile_expr(&result, ast); + zend_do_free(&result); } - efree(tmp); } - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_DECLARE_CONST; - SET_UNUSED(opline->result); - SET_NODE(opline->op1, name); - SET_NODE(opline->op2, value); - - zend_hash_add(&CG(const_filenames), Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant)+1, CG(compiled_filename), strlen(CG(compiled_filename))+1, NULL); + if (FC(declarables).ticks && !zend_is_unticked_stmt(ast)) { + zend_emit_tick(); + } } /* }}} */ -void zend_verify_namespace(TSRMLS_D) /* {{{ */ +void zend_compile_expr(znode *result, zend_ast *ast) /* {{{ */ { - if (CG(has_bracketed_namespaces) && !CG(in_namespace)) { - zend_error_noreturn(E_COMPILE_ERROR, "No code may exist outside of namespace {}"); + /* CG(zend_lineno) = ast->lineno; */ + CG(zend_lineno) = zend_ast_get_lineno(ast); + + switch (ast->kind) { + case ZEND_AST_ZVAL: + ZVAL_COPY(&result->u.constant, zend_ast_get_zval(ast)); + result->op_type = IS_CONST; + return; + case ZEND_AST_ZNODE: + *result = *zend_ast_get_znode(ast); + return; + case ZEND_AST_VAR: + case ZEND_AST_DIM: + case ZEND_AST_PROP: + case ZEND_AST_STATIC_PROP: + case ZEND_AST_CALL: + case ZEND_AST_METHOD_CALL: + case ZEND_AST_STATIC_CALL: + zend_compile_var(result, ast, BP_VAR_R); + return; + case ZEND_AST_ASSIGN: + zend_compile_assign(result, ast); + return; + case ZEND_AST_ASSIGN_REF: + zend_compile_assign_ref(result, ast); + return; + case ZEND_AST_NEW: + zend_compile_new(result, ast); + return; + case ZEND_AST_CLONE: + zend_compile_clone(result, ast); + return; + case ZEND_AST_ASSIGN_OP: + zend_compile_compound_assign(result, ast); + return; + case ZEND_AST_BINARY_OP: + zend_compile_binary_op(result, ast); + return; + case ZEND_AST_GREATER: + case ZEND_AST_GREATER_EQUAL: + zend_compile_greater(result, ast); + return; + case ZEND_AST_UNARY_OP: + zend_compile_unary_op(result, ast); + return; + case ZEND_AST_UNARY_PLUS: + case ZEND_AST_UNARY_MINUS: + zend_compile_unary_pm(result, ast); + return; + case ZEND_AST_AND: + case ZEND_AST_OR: + zend_compile_short_circuiting(result, ast); + return; + case ZEND_AST_POST_INC: + case ZEND_AST_POST_DEC: + zend_compile_post_incdec(result, ast); + return; + case ZEND_AST_PRE_INC: + case ZEND_AST_PRE_DEC: + zend_compile_pre_incdec(result, ast); + return; + case ZEND_AST_CAST: + zend_compile_cast(result, ast); + return; + case ZEND_AST_CONDITIONAL: + zend_compile_conditional(result, ast); + return; + case ZEND_AST_COALESCE: + zend_compile_coalesce(result, ast); + return; + case ZEND_AST_PRINT: + zend_compile_print(result, ast); + return; + case ZEND_AST_EXIT: + zend_compile_exit(result, ast); + return; + case ZEND_AST_YIELD: + zend_compile_yield(result, ast); + return; + case ZEND_AST_YIELD_FROM: + zend_compile_yield_from(result, ast); + return; + case ZEND_AST_INSTANCEOF: + zend_compile_instanceof(result, ast); + return; + case ZEND_AST_INCLUDE_OR_EVAL: + zend_compile_include_or_eval(result, ast); + return; + case ZEND_AST_ISSET: + case ZEND_AST_EMPTY: + zend_compile_isset_or_empty(result, ast); + return; + case ZEND_AST_SILENCE: + zend_compile_silence(result, ast); + return; + case ZEND_AST_SHELL_EXEC: + zend_compile_shell_exec(result, ast); + return; + case ZEND_AST_ARRAY: + zend_compile_array(result, ast); + return; + case ZEND_AST_CONST: + zend_compile_const(result, ast); + return; + case ZEND_AST_CLASS_CONST: + zend_compile_class_const(result, ast); + return; + case ZEND_AST_ENCAPS_LIST: + zend_compile_encaps_list(result, ast); + return; + case ZEND_AST_MAGIC_CONST: + zend_compile_magic_const(result, ast); + return; + case ZEND_AST_CLOSURE: + zend_compile_func_decl(result, ast); + return; + default: + ZEND_ASSERT(0 /* not supported */); } } /* }}} */ -void zend_do_end_namespace(TSRMLS_D) /* {{{ */ +void zend_compile_var(znode *result, zend_ast *ast, uint32_t type) /* {{{ */ { - CG(in_namespace) = 0; - if (CG(current_namespace)) { - zval_dtor(CG(current_namespace)); - FREE_ZVAL(CG(current_namespace)); - CG(current_namespace) = NULL; - } - if (CG(current_import)) { - zend_hash_destroy(CG(current_import)); - efree(CG(current_import)); - CG(current_import) = NULL; - } - if (CG(current_import_function)) { - zend_hash_destroy(CG(current_import_function)); - efree(CG(current_import_function)); - CG(current_import_function) = NULL; - } - if (CG(current_import_const)) { - zend_hash_destroy(CG(current_import_const)); - efree(CG(current_import_const)); - CG(current_import_const) = NULL; + switch (ast->kind) { + case ZEND_AST_VAR: + zend_compile_simple_var(result, ast, type, 0); + return; + case ZEND_AST_DIM: + zend_compile_dim(result, ast, type); + return; + case ZEND_AST_PROP: + zend_compile_prop(result, ast, type); + return; + case ZEND_AST_STATIC_PROP: + zend_compile_static_prop(result, ast, type, 0); + return; + case ZEND_AST_CALL: + zend_compile_call(result, ast, type); + return; + case ZEND_AST_METHOD_CALL: + zend_compile_method_call(result, ast, type); + return; + case ZEND_AST_STATIC_CALL: + zend_compile_static_call(result, ast, type); + return; + case ZEND_AST_ZNODE: + *result = *zend_ast_get_znode(ast); + return; + default: + if (type == BP_VAR_W || type == BP_VAR_REF + || type == BP_VAR_RW || type == BP_VAR_UNSET + ) { + zend_error_noreturn(E_COMPILE_ERROR, + "Cannot use temporary expression in write context"); + } + + zend_compile_expr(result, ast); + return; } } /* }}} */ -void zend_do_end_compilation(TSRMLS_D) /* {{{ */ +void zend_delayed_compile_var(znode *result, zend_ast *ast, uint32_t type) /* {{{ */ { - CG(has_bracketed_namespaces) = 0; - zend_do_end_namespace(TSRMLS_C); + zend_op *opline; + switch (ast->kind) { + case ZEND_AST_VAR: + zend_compile_simple_var(result, ast, type, 1); + return; + case ZEND_AST_DIM: + opline = zend_delayed_compile_dim(result, ast, type); + zend_adjust_for_fetch_type(opline, type); + return; + case ZEND_AST_PROP: + opline = zend_delayed_compile_prop(result, ast, type); + zend_adjust_for_fetch_type(opline, type); + return; + case ZEND_AST_STATIC_PROP: + zend_compile_static_prop(result, ast, type, 1); + return; + default: + zend_compile_var(result, ast, type); + return; + } } /* }}} */ -void zend_do_constant_expression(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */ +void zend_eval_const_expr(zend_ast **ast_ptr) /* {{{ */ { - if (ast->kind == ZEND_CONST) { - result->u.constant = *ast->u.val; - efree(ast); - } else if (zend_ast_is_ct_constant(ast)) { - zend_ast_evaluate(&result->u.constant, ast, NULL TSRMLS_CC); - zend_ast_destroy(ast); - } else { - Z_TYPE(result->u.constant) = IS_CONSTANT_AST; - Z_AST(result->u.constant) = ast; + zend_ast *ast = *ast_ptr; + zval result; + + if (!ast) { + return; } -} -/* }}} */ -/* {{{ zend_dirname - Returns directory name component of path */ -ZEND_API size_t zend_dirname(char *path, size_t len) -{ - register char *end = path + len - 1; - unsigned int len_adjust = 0; + switch (ast->kind) { + case ZEND_AST_BINARY_OP: + zend_eval_const_expr(&ast->child[0]); + zend_eval_const_expr(&ast->child[1]); + if (ast->child[0]->kind != ZEND_AST_ZVAL || ast->child[1]->kind != ZEND_AST_ZVAL) { + return; + } -#ifdef PHP_WIN32 - /* Note that on Win32 CWD is per drive (heritage from CP/M). - * This means dirname("c:foo") maps to "c:." or "c:" - which means CWD on C: drive. - */ - if ((2 <= len) && isalpha((int)((unsigned char *)path)[0]) && (':' == path[1])) { - /* Skip over the drive spec (if any) so as not to change */ - path += 2; - len_adjust += 2; - if (2 == len) { - /* Return "c:" on Win32 for dirname("c:"). - * It would be more consistent to return "c:." - * but that would require making the string *longer*. - */ - return len; + if (!zend_try_ct_eval_binary_op(&result, ast->attr, + zend_ast_get_zval(ast->child[0]), zend_ast_get_zval(ast->child[1])) + ) { + return; + } + break; + case ZEND_AST_GREATER: + case ZEND_AST_GREATER_EQUAL: + zend_eval_const_expr(&ast->child[0]); + zend_eval_const_expr(&ast->child[1]); + if (ast->child[0]->kind != ZEND_AST_ZVAL || ast->child[1]->kind != ZEND_AST_ZVAL) { + return; + } + + zend_ct_eval_greater(&result, ast->kind, + zend_ast_get_zval(ast->child[0]), zend_ast_get_zval(ast->child[1])); + break; + case ZEND_AST_AND: + case ZEND_AST_OR: + { + int i; + for (i = 0; i <= 1; i++) { + zend_eval_const_expr(&ast->child[i]); + if (ast->child[i]->kind == ZEND_AST_ZVAL) { + if (zend_is_true(zend_ast_get_zval(ast->child[i])) == (ast->kind == ZEND_AST_OR)) { + ZVAL_BOOL(&result, ast->kind == ZEND_AST_OR); + return; + } + } + } + + if (ast->child[0]->kind != ZEND_AST_ZVAL || ast->child[1]->kind != ZEND_AST_ZVAL) { + return; + } + + if (ast->kind == ZEND_AST_OR) { + ZVAL_BOOL(&result, zend_is_true(zend_ast_get_zval(ast->child[0])) || zend_is_true(zend_ast_get_zval(ast->child[1]))); + } else { + ZVAL_BOOL(&result, zend_is_true(zend_ast_get_zval(ast->child[0])) && zend_is_true(zend_ast_get_zval(ast->child[1]))); + } + break; } - } -#elif defined(NETWARE) - /* - * Find the first occurrence of : from the left - * move the path pointer to the position just after : - * increment the len_adjust to the length of path till colon character(inclusive) - * If there is no character beyond : simple return len - */ - char *colonpos = NULL; - colonpos = strchr(path, ':'); - if (colonpos != NULL) { - len_adjust = ((colonpos - path) + 1); - path += len_adjust; - if (len_adjust == len) { - return len; + case ZEND_AST_UNARY_OP: + zend_eval_const_expr(&ast->child[0]); + if (ast->child[0]->kind != ZEND_AST_ZVAL) { + return; + } + + zend_ct_eval_unary_op(&result, ast->attr, zend_ast_get_zval(ast->child[0])); + break; + case ZEND_AST_UNARY_PLUS: + case ZEND_AST_UNARY_MINUS: + zend_eval_const_expr(&ast->child[0]); + if (ast->child[0]->kind != ZEND_AST_ZVAL) { + return; + } + + zend_ct_eval_unary_pm(&result, ast->kind, zend_ast_get_zval(ast->child[0])); + break; + case ZEND_AST_CONDITIONAL: + { + zend_ast **child, *child_ast; + zend_eval_const_expr(&ast->child[0]); + if (ast->child[0]->kind != ZEND_AST_ZVAL) { + /* ensure everything was compile-time evaluated at least once */ + if (ast->child[1]) { + zend_eval_const_expr(&ast->child[1]); + } + zend_eval_const_expr(&ast->child[2]); + return; + } + + child = &ast->child[2 - zend_is_true(zend_ast_get_zval(ast->child[0]))]; + if (*child == NULL) { + child--; + } + child_ast = *child; + *child = NULL; + zend_ast_destroy(ast); + *ast_ptr = child_ast; + zend_eval_const_expr(ast_ptr); + return; } - } -#endif + case ZEND_AST_DIM: + { + /* constant expression should be always read context ... */ - if (len == 0) { - /* Illegal use of this function */ - return 0; - } + zval *container, *dim; - /* Strip trailing slashes */ - while (end >= path && IS_SLASH_P(end)) { - end--; - } - if (end < path) { - /* The path only contained slashes */ - path[0] = DEFAULT_SLASH; - path[1] = '\0'; - return 1 + len_adjust; - } + zend_eval_const_expr(&ast->child[0]); + zend_eval_const_expr(&ast->child[1]); + if (ast->child[0]->kind != ZEND_AST_ZVAL || ast->child[1]->kind != ZEND_AST_ZVAL) { + return; + } - /* Strip filename */ - while (end >= path && !IS_SLASH_P(end)) { - end--; - } - if (end < path) { - /* No slash found, therefore return '.' */ -#ifdef NETWARE - if (len_adjust == 0) { - path[0] = '.'; - path[1] = '\0'; - return 1; /* only one character */ - } else { - path[0] = '\0'; - return len_adjust; + container = zend_ast_get_zval(ast->child[0]); + dim = zend_ast_get_zval(ast->child[1]); + + if (Z_TYPE_P(container) == IS_ARRAY) { + zval *el; + if (Z_TYPE_P(dim) == IS_LONG) { + el = zend_hash_index_find(Z_ARR_P(container), Z_LVAL_P(dim)); + if (el) { + ZVAL_COPY(&result, el); + } else { + return; + } + } else if (Z_TYPE_P(dim) == IS_STRING) { + el = zend_symtable_find(Z_ARR_P(container), Z_STR_P(dim)); + if (el) { + ZVAL_COPY(&result, el); + } else { + return; + } + } else { + return; /* warning... handle at runtime */ + } + } else if (Z_TYPE_P(container) == IS_STRING) { + zend_long offset; + zend_uchar c; + if (Z_TYPE_P(dim) == IS_LONG) { + offset = Z_LVAL_P(dim); + } else if (Z_TYPE_P(dim) != IS_STRING || is_numeric_string(Z_STRVAL_P(dim), Z_STRLEN_P(dim), &offset, NULL, 1) != IS_LONG) { + return; + } + if (offset < 0 || offset >= Z_STRLEN_P(container)) { + return; + } + c = (zend_uchar) Z_STRVAL_P(container)[offset]; + if (CG(one_char_string)[c]) { + ZVAL_INTERNED_STR(&result, CG(one_char_string)[c]); + } else { + ZVAL_NEW_STR(&result, zend_string_init((char *) &c, 1, 0)); + } + } else if (Z_TYPE_P(container) <= IS_FALSE) { + ZVAL_NULL(&result); + } else { + return; + } + break; } -#else - path[0] = '.'; - path[1] = '\0'; - return 1 + len_adjust; -#endif - } + case ZEND_AST_ARRAY: + if (!zend_try_ct_eval_array(&result, ast)) { + return; + } + break; + case ZEND_AST_MAGIC_CONST: + if (!zend_try_ct_eval_magic_const(&result, ast)) { + return; + } + break; + case ZEND_AST_CONST: + { + zend_ast *name_ast = ast->child[0]; + zend_bool is_fully_qualified; + zend_string *resolved_name = zend_resolve_const_name( + zend_ast_get_str(name_ast), name_ast->attr, &is_fully_qualified); - /* Strip slashes which came before the file name */ - while (end >= path && IS_SLASH_P(end)) { - end--; - } - if (end < path) { - path[0] = DEFAULT_SLASH; - path[1] = '\0'; - return 1 + len_adjust; + if (!zend_try_ct_eval_const(&result, resolved_name, is_fully_qualified)) { + zend_string_release(resolved_name); + return; + } + + zend_string_release(resolved_name); + break; + } + case ZEND_AST_CLASS_CONST: + { + zend_ast *class_ast = ast->child[0]; + zend_ast *name_ast = ast->child[1]; + zend_string *resolved_name; + + if (zend_try_compile_const_expr_resolve_class_name(&result, class_ast, name_ast, 0)) { + if (Z_TYPE(result) == IS_NULL) { + return; + } else { + break; + } + } + + zend_eval_const_expr(&class_ast); + zend_eval_const_expr(&name_ast); + + if (name_ast->kind == ZEND_AST_ZVAL && zend_string_equals_literal_ci(zend_ast_get_str(name_ast), "class")) { + zend_error_noreturn(E_COMPILE_ERROR, + "Dynamic class names are not allowed in compile-time ::class fetch"); + } + + if (class_ast->kind != ZEND_AST_ZVAL || name_ast->kind != ZEND_AST_ZVAL) { + return; + } + + resolved_name = zend_resolve_class_name_ast(class_ast); + + if (!zend_try_ct_eval_class_const(&result, resolved_name, zend_ast_get_str(name_ast))) { + zend_string_release(resolved_name); + return; + } + + zend_string_release(resolved_name); + break; + } + + default: + return; } - *(end+1) = '\0'; - return (size_t)(end + 1 - path) + len_adjust; + zend_ast_destroy(ast); + *ast_ptr = zend_ast_create_zval(&result); } /* }}} */ |