diff options
Diffstat (limited to 'Zend/zend_compile.c')
| -rw-r--r-- | Zend/zend_compile.c | 9270 |
1 files changed, 4500 insertions, 4770 deletions
diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index a37ca45265..4a4afa2de6 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> | +----------------------------------------------------------------------+ */ @@ -51,7 +52,6 @@ (target)->u.constant = CONSTANT(src.constant); \ } else { \ (target)->u.op = src; \ - (target)->EA = 0; \ } \ } while (0) @@ -60,34 +60,29 @@ target = src; \ } while (0) -#define GET_CACHE_SLOT(literal) do { \ - Z_CACHE_SLOT(CG(active_op_array)->literals[literal]) = 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 TSRMLS_DC) { + zend_op_array *op_array = CG(active_op_array); + Z_CACHE_SLOT(op_array->literals[literal]) = op_array->last_cache_slot++; + if ((op_array->fn_flags & ZEND_ACC_INTERACTIVE) && op_array->run_time_cache) { + op_array->run_time_cache = erealloc(op_array->run_time_cache, + op_array->last_cache_slot * sizeof(void*)); + op_array->run_time_cache[CG(active_op_array)->last_cache_slot - 1] = NULL; + } +} #define POLYMORPHIC_CACHE_SLOT_SIZE 2 -#define GET_POLYMORPHIC_CACHE_SLOT(literal) do { \ - Z_CACHE_SLOT(CG(active_op_array)->literals[literal]) = 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 (Z_CACHE_SLOT(CG(active_op_array)->literals[literal]) != -1 && \ - Z_CACHE_SLOT(CG(active_op_array)->literals[literal]) == \ - CG(active_op_array)->last_cache_slot - POLYMORPHIC_CACHE_SLOT_SIZE) { \ - Z_CACHE_SLOT(CG(active_op_array)->literals[literal]) = -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 TSRMLS_DC) { + zend_op_array *op_array = CG(active_op_array); + Z_CACHE_SLOT(op_array->literals[literal]) = op_array->last_cache_slot; + op_array->last_cache_slot += POLYMORPHIC_CACHE_SLOT_SIZE; + if ((op_array->fn_flags & ZEND_ACC_INTERACTIVE) && op_array->run_time_cache) { + op_array->run_time_cache = erealloc( + op_array->run_time_cache, op_array->last_cache_slot * sizeof(void *)); + op_array->run_time_cache[op_array->last_cache_slot - 1] = NULL; + op_array->run_time_cache[op_array->last_cache_slot - 2] = NULL; + } +} 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); @@ -97,13 +92,6 @@ 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, uint32_t opline_num TSRMLS_DC) /* {{{ */ -{ - zend_function_call_entry fcall = { fbc, opline_num }; - zend_stack_push(&CG(function_call_stack), &fcall); -} -/* }}} */ - static zend_property_info *zend_duplicate_property_info(zend_property_info *property_info TSRMLS_DC) /* {{{ */ { zend_property_info* new_property_info; @@ -147,13 +135,27 @@ static void zend_destroy_property_info_internal(zval *zv) /* {{{ */ } /* }}} */ -static void build_runtime_defined_function_key(zval *result, const char *name, int name_length TSRMLS_DC) /* {{{ */ -{ +static zend_string *zend_new_interned_string_safe(zend_string *str TSRMLS_DC) { + zend_string *interned_str; + + zend_string_addref(str); + interned_str = zend_new_interned_string(str TSRMLS_CC); + if (str != interned_str) { + return interned_str; + } else { + zend_string_release(str); + return str; + } +} + +static zend_string *zend_build_runtime_definition_key( + zend_string *name, unsigned char *lex_pos TSRMLS_DC +) { + zend_string *result; char char_pos_buf[32]; - uint char_pos_len; - const char *filename; + size_t char_pos_len = zend_sprintf(char_pos_buf, "%p", lex_pos); - char_pos_len = zend_sprintf(char_pos_buf, "%p", LANG_SCNG(yy_text)); + const char *filename; if (CG(active_op_array)->filename) { filename = CG(active_op_array)->filename->val; } else { @@ -161,13 +163,12 @@ static void build_runtime_defined_function_key(zval *result, const char *name, i } /* NULL, name length, filename length, last accepting char position length */ - ZVAL_NEW_STR(result, zend_string_alloc(1+name_length+strlen(filename)+char_pos_len, 0)); + result = zend_string_alloc(1 + name->len + strlen(filename) + char_pos_len, 0); - /* must be binary safe */ - Z_STRVAL_P(result)[0] = '\0'; - sprintf(Z_STRVAL_P(result)+1, "%s%s%s", name, filename, char_pos_buf); + result->val[0] = '\0'; + sprintf(result->val + 1, "%s%s%s", name->val, filename, char_pos_buf); + return result; } -/* }}} */ static void init_compiler_declarables(TSRMLS_D) /* {{{ */ { @@ -189,19 +190,13 @@ void zend_init_compiler_context(TSRMLS_D) /* {{{ */ void zend_init_compiler_data_structures(TSRMLS_D) /* {{{ */ { - zend_stack_init(&CG(bp_stack), sizeof(zend_llist)); - zend_stack_init(&CG(function_call_stack), sizeof(zend_function_call_entry)); zend_stack_init(&CG(switch_cond_stack), sizeof(zend_switch_entry)); zend_stack_init(&CG(foreach_copy_stack), sizeof(zend_op)); - zend_stack_init(&CG(object_stack), sizeof(znode)); - zend_stack_init(&CG(declare_stack), sizeof(zend_declarables)); + 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), sizeof(zend_llist)); CG(in_compilation) = 0; CG(start_lineno) = 0; - ZVAL_UNDEF(&CG(current_namespace)); + CG(current_namespace) = NULL; CG(in_namespace) = 0; CG(has_bracketed_namespaces) = 0; CG(current_import) = NULL; @@ -238,13 +233,9 @@ void init_compiler(TSRMLS_D) /* {{{ */ void shutdown_compiler(TSRMLS_D) /* {{{ */ { - 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(delayed_oplines_stack)); zend_hash_destroy(&CG(filenames_table)); zend_hash_destroy(&CG(const_filenames)); zend_stack_destroy(&CG(context_stack)); @@ -429,32 +420,23 @@ static int zend_add_ns_func_name_literal(zend_op_array *op_array, zval *zv TSRML } /* }}} */ -static int zend_add_class_name_literal(zend_op_array *op_array, zval *zv TSRMLS_DC) /* {{{ */ -{ +static int zend_add_class_name_literal(zend_op_array *op_array, zend_string *name TSRMLS_DC) { int ret; zend_string *lc_name; - zval c; - if (op_array->last_literal > 0 && - &op_array->literals[op_array->last_literal - 1] == zv && - Z_CACHE_SLOT(op_array->literals[op_array->last_literal - 1]) == -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); - } + zval zv; + ZVAL_STR(&zv, name); - if (Z_STRVAL_P(zv)[0] == '\\') { - lc_name = zend_string_alloc(Z_STRLEN_P(zv) - 1, 0); - zend_str_tolower_copy(lc_name->val, Z_STRVAL_P(zv) + 1, Z_STRLEN_P(zv) - 1); - } else { - lc_name = zend_string_alloc(Z_STRLEN_P(zv), 0); - zend_str_tolower_copy(lc_name->val, Z_STRVAL_P(zv), Z_STRLEN_P(zv)); - } - ZVAL_NEW_STR(&c, lc_name); - zend_add_literal(CG(active_op_array), &c TSRMLS_CC); + ret = zend_add_literal(op_array, &zv TSRMLS_CC); + name = Z_STR(zv); /* Load new name string in case it was interned */ + + lc_name = zend_string_alloc(name->len, 0); + zend_str_tolower_copy(lc_name->val, name->val, name->len); - GET_CACHE_SLOT(ret); + ZVAL_NEW_STR(&zv, lc_name); + zend_add_literal(CG(active_op_array), &zv TSRMLS_CC); + + zend_alloc_cache_slot(ret TSRMLS_CC); return ret; } @@ -537,511 +519,19 @@ static int zend_add_const_name_literal(zend_op_array *op_array, zval *zv, int un op.constant = zend_add_literal(CG(active_op_array), &_c TSRMLS_CC); \ } while (0) -#define LITERAL_STRINGL(op, str, len) do { \ - zval _c; \ - ZVAL_STRINGL(&_c, str, len); \ - op.constant = zend_add_literal(CG(active_op_array), &_c TSRMLS_CC); \ - } 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) - -#define LITERAL_NULL(op) do { \ - zval _c; \ - ZVAL_NULL(&_c); \ - op.constant = zend_add_literal(CG(active_op_array), &_c TSRMLS_CC); \ - } while (0) - -static inline zend_bool zend_is_function_or_method_call(const znode *variable) /* {{{ */ -{ - uint32_t type = variable->EA; - - return ((type & ZEND_PARSED_METHOD_CALL) || (type == ZEND_PARSED_FUNCTION_CALL)); -} -/* }}} */ - -void zend_do_binary_op(zend_uchar op, znode *result, znode *op1, znode *op2 TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - 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); -} -/* }}} */ - -void zend_do_unary_op(zend_uchar op, znode *result, znode *op1 TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - 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); -} -/* }}} */ - -#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; } - -static void zend_do_op_data(zend_op *data_op, znode *value TSRMLS_DC) /* {{{ */ -{ - data_op->opcode = ZEND_OP_DATA; - SET_NODE(data_op->op1, value); - SET_UNUSED(data_op->op2); -} -/* }}} */ - -void zend_do_binary_assign_op(zend_uchar op, znode *result, znode *op1, znode *op2 TSRMLS_DC) /* {{{ */ -{ - int last_op_number = get_next_op_number(CG(active_op_array)); - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - if (last_op_number > 0) { - zend_op *last_op = &CG(active_op_array)->opcodes[last_op_number-1]; - - switch (last_op->opcode) { - case ZEND_FETCH_OBJ_RW: - last_op->opcode = op; - last_op->extended_value = ZEND_ASSIGN_OBJ; - - 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; - } - } - - 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 fetch_simple_variable_ex(znode *result, znode *varname, int bp, zend_uchar op TSRMLS_DC) /* {{{ */ -{ - zend_op opline; - zend_op *opline_ptr; - - if (varname->op_type == IS_CONST) { - if (Z_TYPE(varname->u.constant) != IS_STRING) { - convert_to_string(&varname->u.constant); - } - - if (!zend_is_auto_global(Z_STR(varname->u.constant) 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_STR(varname->u.constant) TSRMLS_CC); - Z_STR(varname->u.constant) = CG(active_op_array)->vars[EX_VAR_TO_NUM(result->u.op.var)]; - result->EA = 0; - return; - } - } - - if (bp) { - opline_ptr = &opline; - init_op(opline_ptr TSRMLS_CC); - } else { - opline_ptr = get_next_op(CG(active_op_array) TSRMLS_CC); - } - - 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 (varname->op_type == IS_CONST) { - if (zend_is_auto_global(Z_STR(varname->u.constant) TSRMLS_CC)) { - opline_ptr->extended_value = ZEND_FETCH_GLOBAL; - } - } +#define MAKE_NOP(opline) do { \ + 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; \ +} while (0) - if (bp) { - zend_llist *fetch_list_ptr = zend_stack_top(&CG(bp_stack)); - zend_llist_add_element(fetch_list_ptr, opline_ptr); - } -} -/* }}} */ - -void fetch_simple_variable(znode *result, znode *varname, int bp TSRMLS_DC) /* {{{ */ -{ - /* 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); -} -/* }}} */ - -void zend_do_fetch_static_member(znode *result, znode *class_name TSRMLS_DC) /* {{{ */ -{ - znode class_node; - zend_llist *fetch_list_ptr; - zend_llist_element *le; - zend_op *opline_ptr; - zend_op opline; - - 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); - } - fetch_list_ptr = zend_stack_top(&CG(bp_stack)); - 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_STR(opline.op1, zend_string_copy(CG(active_op_array)->vars[EX_VAR_TO_NUM(result->u.op.var)])); - 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); - } - GET_NODE(result,opline.result); - opline.extended_value |= ZEND_FETCH_STATIC_MEMBER; - opline_ptr = &opline; - - 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_STR(opline.op1, zend_string_copy(CG(active_op_array)->vars[EX_VAR_TO_NUM(opline_ptr->op1.var)])); - 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); - - 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 (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); - } - opline_ptr->extended_value |= ZEND_FETCH_STATIC_MEMBER; - } - } -} -/* }}} */ - -void fetch_array_begin(znode *result, znode *varname, znode *first_dim TSRMLS_DC) /* {{{ */ -{ - fetch_simple_variable(result, varname, 1 TSRMLS_CC); - - fetch_array_dim(result, result, first_dim TSRMLS_CC); -} -/* }}} */ - -void fetch_array_dim(znode *result, znode *parent, znode *dim TSRMLS_DC) /* {{{ */ -{ - zend_op opline; - zend_llist *fetch_list_ptr = zend_stack_top(&CG(bp_stack)); - - 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); - } - - 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) { - zend_ulong index; - - if (ZEND_HANDLE_NUMERIC(Z_STR(CONSTANT(opline.op2.constant)), index)) { - zval_dtor(&CONSTANT(opline.op2.constant)); - ZVAL_LONG(&CONSTANT(opline.op2.constant), index); - } - } - - GET_NODE(result, opline.result); - - zend_llist_add_element(fetch_list_ptr, &opline); -} -/* }}} */ - -void fetch_string_offset(znode *result, znode *parent, znode *offset TSRMLS_DC) /* {{{ */ -{ - fetch_array_dim(result, parent, offset TSRMLS_CC); -} -/* }}} */ - -void zend_do_print(znode *result, znode *arg TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - 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); -} -/* }}} */ - -void zend_do_echo(znode *arg TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - opline->opcode = ZEND_ECHO; - SET_NODE(opline->op1, arg); - SET_UNUSED(opline->op2); -} -/* }}} */ - -void zend_do_abstract_method(const znode *function_name, znode *modifiers, const znode *body TSRMLS_DC) /* {{{ */ -{ - char *method_type; - - if (CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE) { - Z_LVAL(modifiers->u.constant) |= ZEND_ACC_ABSTRACT; - method_type = "Interface"; - } else { - method_type = "Abstract"; - } - - 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->val, 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); - - opline->opcode = ZEND_RAISE_ABSTRACT_ERROR; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); - } 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->val, Z_STRVAL(function_name->u.constant)); - } - } 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->val, Z_STRVAL(function_name->u.constant)); - } - } -} -/* }}} */ - -static zend_bool opline_is_fetch_this(const zend_op *opline TSRMLS_DC) /* {{{ */ -{ - 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_STRHASH(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; - } else { - return 0; - } -} -/* }}} */ - -void zend_do_assign(znode *result, znode *variable, znode *value TSRMLS_DC) /* {{{ */ -{ - int last_op_number; - zend_op *opline; - - if (value->op_type == IS_CV) { - zend_llist *fetch_list_ptr = zend_stack_top(&CG(bp_stack)); - 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_STR(opline->op1, - zend_string_copy(CG(active_op_array)->vars[EX_VAR_TO_NUM(value->u.op.var)])); - SET_UNUSED(opline->op2); - opline->extended_value = ZEND_FETCH_LOCAL; - GET_NODE(value, opline->result); - } - } - } - - zend_do_end_variable_parse(variable, BP_VAR_W, 0 TSRMLS_CC); - - last_op_number = get_next_op_number(CG(active_op_array)); - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - 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; - - while (last_op_number - n > 0) { - zend_op *last_op; - - last_op = &CG(active_op_array)->opcodes[last_op_number-n-1]; - - 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]; - } - 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); - return; - } else if (opline_is_fetch_this(last_op TSRMLS_CC)) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this"); - } else { - break; - } - } - n++; - } - } - - 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); -} -/* }}} */ - -void zend_do_assign_ref(znode *result, znode *lvar, znode *rvar TSRMLS_DC) /* {{{ */ -{ - 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 (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"); - } - } - } - - 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; - } - SET_NODE(opline->op1, lvar); - SET_NODE(opline->op2, rvar); +void zend_stop_lexing(TSRMLS_D) { + LANG_SCNG(yy_cursor) = LANG_SCNG(yy_limit); } -/* }}} */ -static inline void do_begin_loop(TSRMLS_D) /* {{{ */ +static inline void zend_begin_loop(TSRMLS_D) /* {{{ */ { zend_brk_cont_element *brk_cont_element; int parent; @@ -1054,7 +544,7 @@ static inline void do_begin_loop(TSRMLS_D) /* {{{ */ } /* }}} */ -static inline void do_end_loop(int cont_addr, int has_loop_var TSRMLS_DC) /* {{{ */ +static inline void zend_end_loop(int cont_addr, int has_loop_var TSRMLS_DC) /* {{{ */ { if (!has_loop_var) { /* The start fileld is used to free temporary variables in case of exceptions. @@ -1068,355 +558,6 @@ static inline void do_end_loop(int cont_addr, int has_loop_var TSRMLS_DC) /* {{{ } /* }}} */ -void zend_do_while_cond(znode *expr, znode *close_bracket_token TSRMLS_DC) /* {{{ */ -{ - 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); - - opline->opcode = ZEND_JMPZ; - SET_NODE(opline->op1, expr); - close_bracket_token->u.op.opline_num = while_cond_op_number; - SET_UNUSED(opline->op2); - - do_begin_loop(TSRMLS_C); - INC_BPC(CG(active_op_array)); -} -/* }}} */ - -void zend_do_while_end(const znode *while_token, const znode *close_bracket_token TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - /* 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); - - /* 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)); - - do_end_loop(while_token->u.op.opline_num, 0 TSRMLS_CC); - - DEC_BPC(CG(active_op_array)); -} -/* }}} */ - -void zend_do_for_cond(znode *expr, znode *second_semicolon_token TSRMLS_DC) /* {{{ */ -{ - 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); - - 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); -} -/* }}} */ - -void zend_do_for_before_statement(const znode *cond_start, const znode *second_semicolon_token TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - 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); - - do_begin_loop(TSRMLS_C); - - INC_BPC(CG(active_op_array)); -} -/* }}} */ - -void zend_do_for_end(const znode *second_semicolon_token TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - 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); - - do_end_loop(second_semicolon_token->u.op.opline_num+1, 0 TSRMLS_CC); - - DEC_BPC(CG(active_op_array)); -} -/* }}} */ - -void zend_do_pre_incdec(znode *result, znode *op1, zend_uchar op TSRMLS_DC) /* {{{ */ -{ - 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]; - - 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; - } - } - - 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); -} -/* }}} */ - -void zend_do_post_incdec(znode *result, znode *op1, zend_uchar op TSRMLS_DC) /* {{{ */ -{ - 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]; - - 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; - } - } - - 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); -} -/* }}} */ - -void zend_do_if_cond(znode *cond, znode *closing_bracket_token TSRMLS_DC) /* {{{ */ -{ - 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); - - opline->opcode = ZEND_JMPZ; - SET_NODE(opline->op1, cond); - closing_bracket_token->u.op.opline_num = if_cond_op_number; - 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) /* {{{ */ -{ - 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_llist_init(&jmp_list, sizeof(int), NULL, 0); - zend_stack_push(&CG(bp_stack), (void *) &jmp_list); - } - jmp_list_ptr = zend_stack_top(&CG(bp_stack)); - 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; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); -} -/* }}} */ - -void zend_do_if_end(TSRMLS_D) /* {{{ */ -{ - int next_op_number = get_next_op_number(CG(active_op_array)); - zend_llist *jmp_list_ptr = zend_stack_top(&CG(bp_stack)); - zend_llist_element *le; - - for (le=jmp_list_ptr->head; le; le = le->next) { - CG(active_op_array)->opcodes[*((int *) le->data)].op1.opline_num = next_op_number; - } - zend_llist_destroy(jmp_list_ptr); - zend_stack_del_top(&CG(bp_stack)); - DEC_BPC(CG(active_op_array)); -} -/* }}} */ - -void zend_check_writable_variable(const znode *variable) /* {{{ */ -{ - uint32_t type = variable->EA; - - 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"); - } -} -/* }}} */ - -void zend_do_begin_variable_parse(TSRMLS_D) /* {{{ */ -{ - zend_llist fetch_list; - - zend_llist_init(&fetch_list, sizeof(zend_op), NULL, 0); - zend_stack_push(&CG(bp_stack), (void *) &fetch_list); -} -/* }}} */ - -void zend_do_end_variable_parse(znode *variable, int type, int arg_offset TSRMLS_DC) /* {{{ */ -{ - zend_llist *fetch_list_ptr = zend_stack_top(&CG(bp_stack)); - zend_llist_element *le = fetch_list_ptr->head; - zend_op *opline = NULL; - zend_op *opline_ptr; - uint32_t this_var = -1; - - /* TODO: $foo->x->y->z = 1 should fetch "x" and "y" for R or RW, not just W */ - - 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) { - - 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_STR(CONSTANT(opline_ptr->op1.constant)) TSRMLS_CC); - ZVAL_UNDEF(&CONSTANT(opline_ptr->op1.constant)); - } 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), zend_string_init("this", sizeof("this")-1, 0) TSRMLS_CC); - } - } - - 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_llist_destroy(fetch_list_ptr); - zend_stack_del_top(&CG(bp_stack)); -} -/* }}} */ - -void zend_do_add_string(znode *result, znode *op1, znode *op2 TSRMLS_DC) /* {{{ */ -{ - zend_op *opline; - - 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 */ - zend_string_free(Z_STR(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 */ - zend_string_free(Z_STR(op2->u.constant)); - return; - } - - 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)); - } - SET_NODE(opline->op2, op2); - GET_NODE(result, opline->result); -} -/* }}} */ - -void zend_do_add_variable(znode *result, znode *op1, znode *op2 TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - opline->opcode = ZEND_ADD_VAR; - - 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)); - } - 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) { @@ -1473,869 +614,197 @@ void zend_do_free(znode *op1 TSRMLS_DC) /* {{{ */ } } } else if (op1->op_type == IS_CONST) { - zval_dtor(&op1->u.constant); + /* 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 *zv = &op1->u.constant; + if (Z_REFCOUNTED_P(zv) && !Z_DELREF_P(zv)) { + _zval_dtor_func_for_ptr(Z_COUNTED_P(zv) ZEND_FILE_LINE_CC); + } } } /* }}} */ -int zend_do_verify_access_types(const znode *current_access_type, const znode *new_modifier) /* {{{ */ -{ - if ((Z_LVAL(current_access_type->u.constant) & ZEND_ACC_PPP_MASK) - && (Z_LVAL(new_modifier->u.constant) & ZEND_ACC_PPP_MASK)) { +uint32_t zend_add_member_modifier(uint32_t flags, uint32_t new_flag) { + 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 ((Z_LVAL(current_access_type->u.constant) & ZEND_ACC_ABSTRACT) - && (Z_LVAL(new_modifier->u.constant) & ZEND_ACC_ABSTRACT)) { + if ((flags & ZEND_ACC_ABSTRACT) && (new_flag & 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)) { + if ((flags & ZEND_ACC_STATIC) && (new_flag & 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)) { + if ((flags & ZEND_ACC_FINAL) && (new_flag & 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)) { + 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 (Z_LVAL(current_access_type->u.constant) | Z_LVAL(new_modifier->u.constant)); + return new_flags; } -/* }}} */ - -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_op_array op_array; - zend_string *name = Z_STR(function_name->u.constant); - int function_begin_line = function_token->u.op.opline_num; - uint32_t fn_flags; - zend_string *lcname; - zend_bool orig_interactive; - ALLOCA_FLAG(use_heap) - - 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->val, 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->val : "", is_method ? "::" : "", Z_STRVAL(function_name->u.constant)); - } - - function_token->u.op_array = CG(active_op_array); - - 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; - - op_array.function_name = name; - if (return_reference) { - op_array.fn_flags |= ZEND_ACC_RETURN_REFERENCE; - } - 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); +zend_string *zend_concat3( + char *str1, size_t str1_len, char *str2, size_t str2_len, char *str3, size_t str3_len +) { + size_t len = str1_len + str2_len + str3_len; + zend_string *res = zend_string_alloc(len, 0); - if (is_method) { - lcname = zend_string_alloc(name->len, 0); - zend_str_tolower_copy(lcname->val, name->val, name->len); - lcname = zend_new_interned_string(lcname TSRMLS_CC); - CG(active_op_array) = zend_arena_alloc(&CG(arena), sizeof(zend_op_array)); - memcpy(CG(active_op_array), &op_array, sizeof(zend_op_array)); - if (zend_hash_add_ptr(&CG(active_class_entry)->function_table, lcname, CG(active_op_array)) == NULL) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare %s::%s()", CG(active_class_entry)->name->val, name->val); - } - - zend_stack_push(&CG(context_stack), (void *) &CG(context)); - zend_init_compiler_context(TSRMLS_C); - - if (fn_flags & ZEND_ACC_ABSTRACT) { - CG(active_class_entry)->ce_flags |= ZEND_ACC_IMPLICIT_ABSTRACT_CLASS; - } + memcpy(res->val, str1, str1_len); + memcpy(res->val + str1_len, str2, str2_len); + memcpy(res->val + str1_len + str2_len, str3, str3_len); + res->val[len] = '\0'; - if (!(fn_flags & ZEND_ACC_PPP_MASK)) { - fn_flags |= ZEND_ACC_PUBLIC; - } - - if (CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE) { - if ((name->len == sizeof(ZEND_CALL_FUNC_NAME)-1) && (!memcmp(lcname->val, 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->val, 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->val, 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->val, 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->val, 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->val, 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->val, 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->val, 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->val, 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->len + 1, use_heap); - zend_str_tolower_copy(class_lcname, CG(active_class_entry)->name->val, CG(active_class_entry)->name->len); - /* Improve after RC: cache the lowercase class name */ - - if ((CG(active_class_entry)->name->len == name->len) && ((CG(active_class_entry)->ce_flags & ZEND_ACC_TRAIT) != ZEND_ACC_TRAIT) && (!memcmp(class_lcname, lcname->val, 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->val, ZEND_CONSTRUCTOR_FUNC_NAME, sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)-1))) { - if (CG(active_class_entry)->constructor) { - zend_error(E_STRICT, "Redefining already defined constructor for class %s", CG(active_class_entry)->name->val); - } - CG(active_class_entry)->constructor = (zend_function *) CG(active_op_array); - } else if ((name->len == sizeof(ZEND_DESTRUCTOR_FUNC_NAME)-1) && (!memcmp(lcname->val, 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->val, 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->val, 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->val, 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->val, 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->val, 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->val, 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->val, 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->val, 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->val, 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->val, 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); - } - - zend_string_release(lcname); - } else { - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - zval key; - zval *ns_name; - - if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) { - /* Prefix function name with current namespace name */ - znode tmp; - - ZVAL_DUP(&tmp.u.constant, &CG(current_namespace)); - zend_do_build_namespace_name(&tmp, &tmp, function_name TSRMLS_CC); - op_array.function_name = Z_STR(tmp.u.constant); - lcname = zend_string_alloc(Z_STRLEN(tmp.u.constant), 0); - zend_str_tolower_copy(lcname->val, Z_STRVAL(tmp.u.constant), Z_STRLEN(tmp.u.constant)); - } else { - lcname = zend_string_alloc(name->len, 0); - zend_str_tolower_copy(lcname->val, name->val, name->len); - } - - /* Function name must not conflict with import names */ - if (CG(current_import_function) && - (ns_name = zend_hash_find(CG(current_import_function), lcname)) != NULL) { - - char *tmp = zend_str_tolower_dup(Z_STRVAL_P(ns_name), Z_STRLEN_P(ns_name)); - - if (Z_STRLEN_P(ns_name) != Z_STRLEN(function_name->u.constant) || - memcmp(tmp, lcname->val, 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); - } - - opline->opcode = ZEND_DECLARE_FUNCTION; - opline->op1_type = IS_CONST; - build_runtime_defined_function_key(&key, lcname->val, lcname->len TSRMLS_CC); - opline->op1.constant = zend_add_literal(CG(active_op_array), &key TSRMLS_CC); - opline->op2_type = IS_CONST; - LITERAL_STR(opline->op2, zend_string_copy(lcname)); - opline->extended_value = ZEND_DECLARE_FUNCTION; - CG(active_op_array) = zend_arena_alloc(&CG(arena), sizeof(zend_op_array)); - memcpy(CG(active_op_array), &op_array, sizeof(zend_op_array)); - zend_hash_update_ptr(CG(function_table), Z_STR(key), CG(active_op_array)); - zend_stack_push(&CG(context_stack), (void *) &CG(context)); - zend_init_compiler_context(TSRMLS_C); - zend_string_release(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); - } - - { - /* 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); - } - - { - /* 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); - } - - if (CG(doc_comment)) { - CG(active_op_array)->doc_comment = CG(doc_comment); - CG(doc_comment) = NULL; - } + return res; } -/* }}} */ - -void zend_do_begin_lambda_function_declaration(znode *result, znode *function_token, int return_reference, int is_static TSRMLS_DC) /* {{{ */ -{ - 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); - - 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; - } - CG(active_op_array)->fn_flags |= ZEND_ACC_CLOSURE; -} -/* }}} */ -void zend_do_handle_exception(TSRMLS_D) /* {{{ */ -{ - 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); +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); } -/* }}} */ - -void zend_do_end_function_declaration(const znode *function_token TSRMLS_DC) /* {{{ */ -{ - char lcname[16]; - int name_len; - zend_do_extended_info(TSRMLS_C); - zend_do_return(NULL, 0 TSRMLS_CC); - - pass_two(CG(active_op_array) TSRMLS_CC); - zend_release_labels(0 TSRMLS_CC); - - 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); +zend_string *zend_prefix_with_ns(zend_string *name TSRMLS_DC) { + if (CG(current_namespace)) { + zend_string *ns = CG(current_namespace); + return zend_concat_names(ns->val, ns->len, name->val, name->len); } 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 = CG(active_op_array)->function_name->len; - zend_str_tolower_copy(lcname, CG(active_op_array)->function_name->val, 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); - } + return zend_string_copy(name); } +} - CG(active_op_array)->line_end = zend_get_compiled_lineno(TSRMLS_C); - CG(active_op_array) = function_token->u.op_array; - - - /* Pop the switch and foreach separators */ - zend_stack_del_top(&CG(switch_cond_stack)); - zend_stack_del_top(&CG(foreach_copy_stack)); +void *zend_hash_find_ptr_lc(HashTable *ht, char *str, size_t len) { + void *result; + zend_string *lcname = zend_string_alloc(len, 0); + zend_str_tolower_copy(lcname->val, str, len); + result = zend_hash_find_ptr(ht, lcname); + zend_string_free(lcname); + return result; } -/* }}} */ -void zend_do_receive_param(zend_uchar op, znode *varname, znode *initialization, znode *class_type, zend_uchar pass_by_reference, zend_bool is_variadic TSRMLS_DC) /* {{{ */ -{ - zend_op *opline; - zend_arg_info *cur_arg_info; - znode var; +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 TSRMLS_DC +) { + char *compound; + *is_fully_qualified = 0; - if (zend_is_auto_global(Z_STR(varname->u.constant) TSRMLS_CC)) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign auto-global variable %s", Z_STRVAL(varname->u.constant)); - } else { - var.op_type = IS_CV; - var.u.op.var = lookup_cv(CG(active_op_array), Z_STR(varname->u.constant) TSRMLS_CC); - Z_STR(varname->u.constant) = CG(active_op_array)->vars[EX_VAR_TO_NUM(var.u.op.var)]; - var.EA = 0; - if (EX_VAR_TO_NUM(var.u.op.var) != CG(active_op_array)->num_args) { - zend_error_noreturn(E_COMPILE_ERROR, "Redefinition of parameter $%s", Z_STRVAL(varname->u.constant)); - } else if (Z_STRHASH(varname->u.constant) == 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; - } + if (name->val[0] == '\\') { + /* Remove \ prefix (only relevant if this is a string rather than a label) */ + return zend_string_init(name->val + 1, name->len - 1, 0); } - if (CG(active_op_array)->fn_flags & ZEND_ACC_VARIADIC) { - zend_error_noreturn(E_COMPILE_ERROR, "Only the last parameter can be variadic"); + if (type == ZEND_NAME_FQ) { + *is_fully_qualified = 1; + return zend_string_copy(name); } - 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 (type == ZEND_NAME_RELATIVE) { + *is_fully_qualified = 1; + return zend_prefix_with_ns(name TSRMLS_CC); } - 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 = estrndup(Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant)); - 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 (Z_TYPE(class_type->u.constant) != IS_NULL) { - if (Z_TYPE(class_type->u.constant) == 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")) || Z_TYPE(initialization->u.constant) == IS_CONSTANT_AST) { - cur_arg_info->allow_null = 1; - } 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 (Z_TYPE(class_type->u.constant) == 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")) || Z_TYPE(initialization->u.constant) == IS_CONSTANT_AST) { - cur_arg_info->allow_null = 1; - } 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_STR(class_type->u.constant) = zend_new_interned_string(Z_STR(class_type->u.constant) TSRMLS_CC); - if (IS_INTERNED(Z_STR(class_type->u.constant))) { - Z_TYPE_FLAGS(class_type->u.constant) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE); - } -// TODO: for now we have to copy it ??? -#if 1 - cur_arg_info->class_name = estrndup(Z_STRVAL(class_type->u.constant), Z_STRLEN(class_type->u.constant)); - cur_arg_info->class_name_len = Z_STRLEN(class_type->u.constant); - zend_string_release(Z_STR(class_type->u.constant)); -#else - cur_arg_info->class_name = Z_STRVAL(class_type->u.constant); - cur_arg_info->class_name_len = Z_STRLEN(class_type->u.constant); -#endif - 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")) || Z_TYPE(initialization->u.constant) == IS_CONSTANT_AST) { - cur_arg_info->allow_null = 1; - } else { - zend_error_noreturn(E_COMPILE_ERROR, "Default value for parameters with a class type hint can only be NULL"); - } - } - } + 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, name->val, name->len); } - } - if (cur_arg_info->class_name || cur_arg_info->type_hint) { - CG(active_op_array)->fn_flags |= ZEND_ACC_HAS_TYPE_HINTS; + if (import_name) { + *is_fully_qualified = 1; + return zend_string_copy(import_name); + } } -} -/* }}} */ - -int zend_do_begin_function_call(znode *function_name, zend_bool check_namespace TSRMLS_DC) /* {{{ */ -{ - zend_op *opline; - uint32_t op_number; - zend_function *function; - zend_string *lcname; - char *is_compound = memchr(Z_STRVAL(function_name->u.constant), '\\', Z_STRLEN(function_name->u.constant)); - zend_resolve_function_name(function_name, &check_namespace TSRMLS_CC); - - if (check_namespace && Z_TYPE(CG(current_namespace)) != IS_UNDEF && !is_compound) { - /* We assume we call function from the current namespace - if it is not prefixed. */ - - /* 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; + compound = memchr(name->val, '\\', name->len); + if (compound) { + *is_fully_qualified = 1; } - lcname = zend_string_alloc(Z_STRLEN(function_name->u.constant), 0); - zend_str_tolower_copy(lcname->val, Z_STRVAL(function_name->u.constant), Z_STRLEN(function_name->u.constant)); - if (((function = zend_hash_find_ptr(CG(function_table), lcname)) == NULL) || - ((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 */ - } - zend_string_release(Z_STR(function_name->u.constant)); - Z_STR(function_name->u.constant) = lcname; - - op_number = get_next_op_number(CG(active_op_array)); - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_INIT_FCALL; - SET_UNUSED(opline->op1); - SET_NODE(opline->op2, function_name); - GET_CACHE_SLOT(opline->op2.constant); - - zend_push_function_call_entry(function, op_number TSRMLS_CC); - zend_do_extended_fcall_begin(TSRMLS_C); - return 0; -} -/* }}} */ - -void zend_do_begin_method_call(znode *left_bracket TSRMLS_DC) /* {{{ */ -{ - 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]; - - 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"); - } + if (compound && CG(current_import)) { + /* If the first part of a qualified name is an alias, substitute it. */ + size_t len = compound - name->val; + zend_string *import_name = zend_hash_find_ptr_lc(CG(current_import), name->val, len); - 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_STR(name) = zend_string_copy(Z_STR(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; - Z_LVAL(left_bracket->u.constant) = ZEND_INIT_FCALL_BY_NAME; - } else { - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_INIT_FCALL_BY_NAME; - 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); + if (import_name) { + return zend_concat_names( + import_name->val, import_name->len, name->val + len + 1, name->len - len - 1); } } - zend_push_function_call_entry(NULL, last_op_number TSRMLS_CC); - zend_do_extended_fcall_begin(TSRMLS_C); + return zend_prefix_with_ns(name TSRMLS_CC); } /* }}} */ -void zend_do_clone(znode *result, znode *expr TSRMLS_DC) /* {{{ */ -{ - 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); +zend_string *zend_resolve_function_name( + zend_string *name, uint32_t type, zend_bool *is_fully_qualified TSRMLS_DC +) { + return zend_resolve_non_class_name( + name, type, is_fully_qualified, 0, CG(current_import_function) TSRMLS_CC); } -/* }}} */ - -void zend_do_begin_dynamic_function_call(znode *function_name, int ns_call TSRMLS_DC) /* {{{ */ -{ - uint32_t op_number; - zend_op *opline; - - op_number = get_next_op_number(CG(active_op_array)); - 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; - 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; - 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_push_function_call_entry(NULL, op_number TSRMLS_CC); - zend_do_extended_fcall_begin(TSRMLS_C); +zend_string *zend_resolve_const_name( + zend_string *name, uint32_t type, zend_bool *is_fully_qualified TSRMLS_DC +) { + return zend_resolve_non_class_name( + name, type, is_fully_qualified, 1, CG(current_import_const) TSRMLS_CC); } -/* }}} */ -void zend_resolve_non_class_name(znode *element_name, zend_bool *check_namespace, zend_bool case_sensitive, HashTable *current_import_sub TSRMLS_DC) /* {{{ */ -{ - znode tmp; - int len; - zval *ns; - zend_string *lookup_name; - char *compound = memchr(Z_STRVAL(element_name->u.constant), '\\', Z_STRLEN(element_name->u.constant)); - - 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; - } +zend_string *zend_resolve_class_name( + zend_string *name, uint32_t type TSRMLS_DC +) { + char *compound; - if(!*check_namespace) { - return; + if (type == ZEND_NAME_RELATIVE) { + return zend_prefix_with_ns(name TSRMLS_CC); } - if (current_import_sub) { - len = Z_STRLEN(element_name->u.constant); - if (case_sensitive) { - lookup_name = zend_string_init(Z_STRVAL(element_name->u.constant), len, 0); + if (type == ZEND_NAME_FQ || name->val[0] == '\\') { + /* Remove \ prefix (only relevant if this is a string rather than a label) */ + if (name->val[0] == '\\') { + name = zend_string_init(name->val + 1, name->len - 1, 0); } else { - lookup_name = zend_string_alloc(len, 0); - zend_str_tolower_copy(lookup_name->val, Z_STRVAL(element_name->u.constant), len); - } - /* Check if function/const matches imported name */ - if ((ns = zend_hash_find(current_import_sub, lookup_name)) != NULL) { - zval_dtor(&element_name->u.constant); - ZVAL_DUP(&element_name->u.constant, ns); - zend_string_free(lookup_name); - *check_namespace = 0; - return; + zend_string_addref(name); } - zend_string_free(lookup_name); - } - - if (compound && CG(current_import)) { - len = compound - Z_STRVAL(element_name->u.constant); - /* namespace is always lowercase */ - lookup_name = zend_string_alloc(len, 0); - zend_str_tolower_copy(lookup_name->val, Z_STRVAL(element_name->u.constant), len); - /* Check if first part of compound name is an import name */ - if ((ns = zend_hash_find(CG(current_import), lookup_name)) != NULL) { - /* Substitute import name */ - tmp.op_type = IS_CONST; - ZVAL_DUP(&tmp.u.constant, ns); - 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; - zend_string_free(lookup_name); - *check_namespace = 0; - return; + /* 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", name->val); } - zend_string_free(lookup_name); - } - - if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) { - tmp = *element_name; - Z_STR(tmp.u.constant) = zend_string_alloc(sizeof("\\")-1 + Z_STRLEN(element_name->u.constant) + Z_STRLEN(CG(current_namespace)), 0); - Z_TYPE_FLAGS(tmp.u.constant) = IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE; - memcpy(Z_STRVAL(tmp.u.constant), Z_STRVAL(CG(current_namespace)), Z_STRLEN(CG(current_namespace))); - memcpy(&(Z_STRVAL(tmp.u.constant)[Z_STRLEN(CG(current_namespace))]), "\\", sizeof("\\")-1); - memcpy(&(Z_STRVAL(tmp.u.constant)[Z_STRLEN(CG(current_namespace)) + sizeof("\\")-1]), Z_STRVAL(element_name->u.constant), Z_STRLEN(element_name->u.constant)+1); - zend_string_release(Z_STR(element_name->u.constant)); - *element_name = tmp; + return name; } -} -/* }}} */ - -void zend_resolve_function_name(znode *element_name, zend_bool *check_namespace TSRMLS_DC) /* {{{ */ -{ - zend_resolve_non_class_name(element_name, check_namespace, 0, CG(current_import_function) TSRMLS_CC); -} -/* }}} */ - -void zend_resolve_const_name(znode *element_name, zend_bool *check_namespace TSRMLS_DC) /* {{{ */ -{ - zend_resolve_non_class_name(element_name, check_namespace, 1, CG(current_import_const) TSRMLS_CC); -} -/* }}} */ - -void zend_do_resolve_class_name(znode *result, znode *class_name, int is_static TSRMLS_DC) /* {{{ */ -{ - char *lcname; - int lctype; - znode constant_name; - 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"); - } - zval_dtor(&class_name->u.constant); - class_name->op_type = IS_CONST; - ZVAL_STR(&class_name->u.constant, zend_string_copy(CG(active_class_entry)->name)); - *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); - 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; - } - - efree(lcname); - -} -/* }}} */ - -void zend_resolve_class_name(znode *class_name TSRMLS_DC) /* {{{ */ -{ - char *compound; - zend_string *lcname; - zval *ns; - znode tmp; - int len; - - 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 */ - memmove(Z_STRVAL(class_name->u.constant), Z_STRVAL(class_name->u.constant)+1, Z_STRLEN(class_name->u.constant)); - Z_STR(class_name->u.constant) = zend_string_realloc( - Z_STR(class_name->u.constant), - Z_STRLEN(class_name->u.constant) - 1, 0); - Z_TYPE_FLAGS(class_name->u.constant) = IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE; - - 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)); + if (CG(current_import)) { + compound = memchr(name->val, '\\', name->len); + if (compound) { + /* If the first part of a qualified name is an alias, substitute it. */ + size_t len = compound - name->val; + zend_string *import_name = zend_hash_find_ptr_lc(CG(current_import), name->val, len); + + if (import_name) { + return zend_concat_names( + import_name->val, import_name->len, name->val + len + 1, name->len - len - 1); } } else { - if (CG(current_import)) { - len = compound - Z_STRVAL(class_name->u.constant); - lcname = zend_string_alloc(len, 0); - zend_str_tolower_copy(lcname->val, Z_STRVAL(class_name->u.constant), len); - /* Check if first part of compound name is an import name */ - if ((ns = zend_hash_find(CG(current_import), lcname)) != NULL) { - /* Substitute import name */ - tmp.op_type = IS_CONST; - ZVAL_DUP(&tmp.u.constant, ns); - 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; - zend_string_free(lcname); - return; - } - zend_string_free(lcname); - } - /* Here name is not prefixed with \ and not imported */ - if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) { - tmp.op_type = IS_CONST; - ZVAL_DUP(&tmp.u.constant, &CG(current_namespace)); - zend_do_build_namespace_name(&tmp, &tmp, class_name TSRMLS_CC); - *class_name = tmp; + /* If an unqualified name is an alias, replace it. */ + zend_string *import_name + = zend_hash_find_ptr_lc(CG(current_import), name->val, name->len); + + if (import_name) { + return zend_string_copy(import_name); } } - } else if (CG(current_import) || Z_TYPE(CG(current_namespace)) != IS_UNDEF) { - /* this is a plain name (without \) */ - lcname = zend_string_alloc(Z_STRLEN(class_name->u.constant), 0); - zend_str_tolower_copy(lcname->val, Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant)); - - if (CG(current_import) && - (ns = zend_hash_find(CG(current_import), lcname)) != NULL) { - /* The given name is an import name. Substitute it. */ - zval_dtor(&class_name->u.constant); - ZVAL_DUP(&class_name->u.constant, ns); - } else if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) { - /* plain name, no import - prepend current namespace to it */ - tmp.op_type = IS_CONST; - ZVAL_DUP(&tmp.u.constant, &CG(current_namespace)); - zend_do_build_namespace_name(&tmp, &tmp, class_name TSRMLS_CC); - *class_name = tmp; - } - zend_string_free(lcname); } -} -/* }}} */ - -void zend_do_fetch_class(znode *result, znode *class_name TSRMLS_DC) /* {{{ */ -{ - zend_long fetch_class_op_number; - zend_op *opline; - - fetch_class_op_number = get_next_op_number(CG(active_op_array)); - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - 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; + /* If not fully qualified and not an alias, prepend the current namespace */ + return zend_prefix_with_ns(name TSRMLS_CC); +} - 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; - } - } else { - SET_NODE(opline->op2, class_name); - } - 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; +zend_string *zend_resolve_class_name_ast(zend_ast *ast TSRMLS_DC) { + zend_string *name = zend_ast_get_str(ast); + return zend_resolve_class_name(name, ast->attr TSRMLS_CC); } -/* }}} */ static void ptr_dtor(zval *zv) /* {{{ */ { @@ -2343,26 +812,9 @@ static void ptr_dtor(zval *zv) /* {{{ */ } /* }}} */ -void zend_do_label(znode *label TSRMLS_DC) /* {{{ */ -{ - 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, Z_STR(label->u.constant), &dest, sizeof(zend_label)) == NULL) { - zend_error_noreturn(E_COMPILE_ERROR, "Label '%s' already defined", Z_STRVAL(label->u.constant)); - } - - /* Done with label now */ - zval_dtor(&label->u.constant); +static void str_dtor(zval *zv) { + zend_string_release(Z_STR_P(zv)); } -/* }}} */ void zend_resolve_goto_label(zend_op_array *op_array, zend_op *opline, int pass2 TSRMLS_DC) /* {{{ */ { @@ -2424,18 +876,6 @@ void zend_resolve_goto_label(zend_op_array *op_array, zend_op *opline, int pass2 } /* }}} */ -void zend_do_goto(znode *label TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - 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_release_labels(int temporary TSRMLS_DC) /* {{{ */ { if (CG(context).labels) { @@ -2451,658 +891,7 @@ void zend_release_labels(int temporary TSRMLS_DC) /* {{{ */ } /* }}} */ -void zend_do_build_full_name(znode *result, znode *prefix, znode *name, int is_class_member TSRMLS_DC) /* {{{ */ -{ - uint32_t length; - - if (!result) { - result = prefix; - } else { - *result = *prefix; - } - - if (is_class_member) { - int old_len = Z_STRLEN(result->u.constant); - length = sizeof("::")-1 + old_len + Z_STRLEN(name->u.constant); - Z_STR(result->u.constant) = zend_string_realloc(Z_STR(result->u.constant), length, 0); - Z_TYPE_FLAGS(result->u.constant) = IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE; - memcpy(&Z_STRVAL(result->u.constant)[old_len], "::", sizeof("::")-1); - memcpy(&Z_STRVAL(result->u.constant)[old_len + sizeof("::")-1], Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant)+1); - zend_string_release(Z_STR(name->u.constant)); - } else { - int old_len = Z_STRLEN(result->u.constant); - length = sizeof("\\")-1 + old_len + Z_STRLEN(name->u.constant); - Z_STR(result->u.constant) = zend_string_realloc(Z_STR(result->u.constant), length, 0); - Z_TYPE_FLAGS(result->u.constant) = IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE; - memcpy(&Z_STRVAL(result->u.constant)[old_len], "\\", sizeof("\\")-1); - memcpy(&Z_STRVAL(result->u.constant)[old_len + sizeof("\\")-1], Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant)+1); - zend_string_release(Z_STR(name->u.constant)); - } -} -/* }}} */ - -int zend_do_begin_class_member_function_call(znode *class_name, znode *method_name TSRMLS_DC) /* {{{ */ -{ - znode class_node; - uint32_t op_number; - 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 (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; - op_number = get_next_op_number(CG(active_op_array)); - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - } else { - zend_do_fetch_class(&class_node, class_name TSRMLS_CC); - op_number = get_next_op_number(CG(active_op_array)); - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - } - opline->opcode = ZEND_INIT_STATIC_METHOD_CALL; - 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 (method_name->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); - } - } else { - SET_NODE(opline->op2, method_name); - } - - zend_push_function_call_entry(NULL, op_number TSRMLS_CC); - zend_do_extended_fcall_begin(TSRMLS_C); - return 1; /* Dynamic */ -} -/* }}} */ - -static int zend_do_convert_call(zend_op *init_opline, zend_op *opline, zend_long num_args, zend_function **func_ptr TSRMLS_DC) /* {{{ */ -{ - zval *function_name; - zend_string *lcname; - zend_function *function; - - *func_ptr = NULL; - if (opline->op1_type == IS_CONST && Z_TYPE(CONSTANT(opline->op1.constant)) == IS_STRING) { - function_name = &CONSTANT(opline->op1.constant); - lcname = zend_string_alloc(Z_STRLEN_P(function_name), 0); - zend_str_tolower_copy(lcname->val, Z_STRVAL_P(function_name), Z_STRLEN_P(function_name)); - if (((function = zend_hash_find_ptr(CG(function_table), lcname)) == NULL) || - ((CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_FUNCTIONS) && - (function->type == ZEND_INTERNAL_FUNCTION))) { - function = NULL; - zend_string_release(lcname); - opline->opcode = ZEND_INIT_USER_CALL; - opline->extended_value = num_args; - opline->op2_type = opline->op1_type; - opline->op2 = opline->op1; - opline->op1_type = IS_CONST; - opline->op1 = init_opline->op2; - SET_UNUSED(opline->result); - MAKE_NOP(init_opline); - return 1; - } else { - zend_string_release(Z_STR_P(function_name)); - Z_STR_P(function_name) = zend_new_interned_string(lcname TSRMLS_CC); - opline->opcode = ZEND_INIT_FCALL; - opline->extended_value = num_args; - opline->op2_type = IS_CONST; - opline->op2.constant = opline->op1.constant; - GET_CACHE_SLOT(opline->op2.constant); - SET_UNUSED(opline->op1); - SET_UNUSED(opline->result); - MAKE_NOP(init_opline); - *func_ptr = function; - return 1; - } - } else { - opline->opcode = ZEND_INIT_USER_CALL; - opline->extended_value = num_args; - opline->op2_type = opline->op1_type; - opline->op2 = opline->op1; - opline->op1_type = IS_CONST; - opline->op1 = init_opline->op2; - SET_UNUSED(opline->result); - MAKE_NOP(init_opline); - return 1; - } - return 0; -} -/* }}} */ - -static int zend_do_convert_call_user_func(zend_op *init_opline, uint32_t num_args TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = init_opline + 1; - int level = 0; - int converted = 0; - uint32_t arg_num = 0; - zend_function *func = NULL; - - while (1) { - switch (opline->opcode) { - case ZEND_SEND_VAL: - case ZEND_SEND_VAL_EX: - case ZEND_SEND_VAR: - case ZEND_SEND_VAR_EX: - case ZEND_SEND_VAR_NO_REF: - case ZEND_SEND_REF: - case ZEND_SEND_UNPACK: - if (level == 0) { - if (!converted) { - if (opline->opcode == ZEND_SEND_UNPACK) { - return 0; - } - if (!zend_do_convert_call(init_opline, opline, init_opline->extended_value - 1, &func TSRMLS_CC)) { - return 0; - } - converted = 1; - } else { - /* Use ZEND_SEND_USER instruction for parameters that may pass by reference */ - if (opline->opcode != ZEND_SEND_VAL && - (func == NULL || - ARG_SHOULD_BE_SENT_BY_REF(func, opline->op2.num-1))) { - opline->opcode = ZEND_SEND_USER; - } - opline->op2.num--; - } - if (++arg_num == num_args) { - return 1; - } - } - break; - case ZEND_INIT_FCALL_BY_NAME: - case ZEND_INIT_NS_FCALL_BY_NAME: - case ZEND_NEW: - case ZEND_INIT_METHOD_CALL: - case ZEND_INIT_STATIC_METHOD_CALL: - case ZEND_INIT_FCALL: - level++; - break; - case ZEND_DO_FCALL: - level--; - break; - } - opline++; - } -} -/* }}} */ - -static int zend_do_convert_call_user_func_array(zend_op *init_opline TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = init_opline + 1; - zend_op *send1 = NULL, *send2 = NULL; - int level = 0; - zend_function *func; - - do { - switch (opline->opcode) { - case ZEND_SEND_VAL: - case ZEND_SEND_VAL_EX: - case ZEND_SEND_VAR: - case ZEND_SEND_VAR_EX: - case ZEND_SEND_VAR_NO_REF: - case ZEND_SEND_REF: - case ZEND_SEND_UNPACK: - if (level == 0) { - if (opline->opcode == ZEND_SEND_UNPACK) { - return 0; - } - if (send1 == NULL) { - send1 = opline; - } else { - send2 = opline; - } - } - break; - case ZEND_INIT_FCALL_BY_NAME: - case ZEND_INIT_NS_FCALL_BY_NAME: - case ZEND_NEW: - case ZEND_INIT_METHOD_CALL: - case ZEND_INIT_STATIC_METHOD_CALL: - case ZEND_INIT_FCALL: - level++; - break; - case ZEND_DO_FCALL: - level--; - break; - } - opline++; - } while (send2 == NULL); - - if (!zend_do_convert_call(init_opline, send1, 0, &func TSRMLS_CC)) { - return 0; - } - - send2->opcode = ZEND_SEND_ARRAY; - send2->extended_value = 0; - send2->op2.num--; - return 1; -} -/* }}} */ - -static int zend_do_convert_strlen(zend_op *init_opline, znode *result TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = init_opline + 1; - zend_op *send = NULL; - int level = 0; - - do { - switch (opline->opcode) { - case ZEND_SEND_VAL: - case ZEND_SEND_VAL_EX: - case ZEND_SEND_VAR: - case ZEND_SEND_VAR_EX: - case ZEND_SEND_VAR_NO_REF: - case ZEND_SEND_REF: - case ZEND_SEND_UNPACK: - if (level == 0) { - if (opline->opcode == ZEND_SEND_UNPACK) { - return 0; - } - send = opline; - } - break; - case ZEND_INIT_FCALL_BY_NAME: - case ZEND_INIT_NS_FCALL_BY_NAME: - case ZEND_NEW: - case ZEND_INIT_METHOD_CALL: - case ZEND_INIT_STATIC_METHOD_CALL: - case ZEND_INIT_FCALL: - level++; - break; - case ZEND_DO_FCALL: - level--; - break; - } - opline++; - } while (send == NULL); - - MAKE_NOP(init_opline); - send->opcode = ZEND_STRLEN; - send->extended_value = 0; - SET_UNUSED(send->op2); - send->result.var = get_temporary_variable(CG(active_op_array)); - send->result_type = IS_TMP_VAR; - GET_NODE(result, send->result); - return 1; -} -/* }}} */ - -static int zend_do_convert_type_check(zend_op *init_opline, znode *result, uint32_t type TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = init_opline + 1; - zend_op *send = NULL; - int level = 0; - - do { - switch (opline->opcode) { - case ZEND_SEND_VAL: - case ZEND_SEND_VAL_EX: - case ZEND_SEND_VAR: - case ZEND_SEND_VAR_EX: - case ZEND_SEND_VAR_NO_REF: - case ZEND_SEND_REF: - case ZEND_SEND_UNPACK: - if (level == 0) { - if (opline->opcode == ZEND_SEND_UNPACK) { - return 0; - } - send = opline; - } - break; - case ZEND_INIT_FCALL_BY_NAME: - case ZEND_INIT_NS_FCALL_BY_NAME: - case ZEND_NEW: - case ZEND_INIT_METHOD_CALL: - case ZEND_INIT_STATIC_METHOD_CALL: - case ZEND_INIT_FCALL: - level++; - break; - case ZEND_DO_FCALL: - level--; - break; - } - opline++; - } while (send == NULL); - - MAKE_NOP(init_opline); - send->opcode = ZEND_TYPE_CHECK; - send->extended_value = type; - SET_UNUSED(send->op2); - send->result.var = get_temporary_variable(CG(active_op_array)); - send->result_type = IS_TMP_VAR; - GET_NODE(result, send->result); - return 1; -} -/* }}} */ - -static int zend_do_convert_defined(zend_op *init_opline, znode *result TSRMLS_DC) /* {{{ */ -{ - zval c; - zend_string *lc_name; - zend_op *opline = init_opline + 1; - - if (opline->opcode != ZEND_SEND_VAL || - opline->op1_type != IS_CONST || - Z_TYPE(CONSTANT(opline->op1.constant)) != IS_STRING - || zend_memrchr(Z_STRVAL(CONSTANT(opline->op1.constant)), '\\', Z_STRLEN(CONSTANT(opline->op1.constant))) != NULL - || zend_memrchr(Z_STRVAL(CONSTANT(opline->op1.constant)), ':', Z_STRLEN(CONSTANT(opline->op1.constant))) != NULL) { - return 0; - } - - MAKE_NOP(init_opline); - opline->opcode = ZEND_DEFINED; - opline->extended_value = 0; - GET_CACHE_SLOT(opline->op1.constant); - /* lowcase constant name */ - lc_name = zend_string_alloc(Z_STRLEN(CONSTANT(opline->op1.constant)), 0); - zend_str_tolower_copy(lc_name->val, Z_STRVAL(CONSTANT(opline->op1.constant)), Z_STRLEN(CONSTANT(opline->op1.constant))); - ZVAL_NEW_STR(&c, lc_name); - zend_add_literal(CG(active_op_array), &c TSRMLS_CC); - opline->result.var = get_temporary_variable(CG(active_op_array)); - opline->result_type = IS_TMP_VAR; - GET_NODE(result, opline->result); - return 1; -} -/* }}} */ - -void zend_do_end_function_call(znode *function_name, znode *result, int is_method, int is_dynamic_fcall TSRMLS_DC) /* {{{ */ -{ - zend_op *opline; - zend_function_call_entry *fcall = zend_stack_top(&CG(function_call_stack)); - - 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"); - } - opline = &CG(active_op_array)->opcodes[Z_LVAL(function_name->u.constant)]; - } else { - uint32_t call_flags = 0; - - opline = &CG(active_op_array)->opcodes[fcall->op_number]; - opline->extended_value = fcall->arg_num; - - if (opline->opcode == ZEND_NEW) { - call_flags = ZEND_CALL_CTOR; - } else { - zend_function *func = fcall->fbc; - if (func && func->type == ZEND_INTERNAL_FUNCTION) { - /* Convert calls to some internal functions into built-ins */ - if (func->common.function_name->len == sizeof("call_user_func")-1 && - memcmp(func->common.function_name->val, "call_user_func", sizeof("call_user_func")-1) == 0) { - if (fcall->arg_num > 0) { - if (zend_do_convert_call_user_func(opline, fcall->arg_num TSRMLS_CC)) { - fcall->arg_num--; - } - } - } else if (func->common.function_name->len == sizeof("call_user_func_array")-1 && - memcmp(func->common.function_name->val, "call_user_func_array", sizeof("call_user_func_array")-1) == 0) { - if (fcall->arg_num == 2) { - if (zend_do_convert_call_user_func_array(opline TSRMLS_CC)) { - fcall->arg_num = 0; - } - } - } else if (func->common.function_name->len == sizeof("defined")-1 && - memcmp(func->common.function_name->val, "defined", sizeof("defined")-1) == 0) { - if (fcall->arg_num == 1) { - if (zend_do_convert_defined(opline, result TSRMLS_CC)) { - zend_stack_del_top(&CG(function_call_stack)); - return; - } - } - } else if ((CG(compiler_options) & ZEND_COMPILE_NO_BUILTIN_STRLEN) == 0 && - func->common.function_name->len == sizeof("strlen")-1 && - memcmp(func->common.function_name->val, "strlen", sizeof("strlen")-1) == 0) { - if (fcall->arg_num == 1) { - if (zend_do_convert_strlen(opline, result TSRMLS_CC)) { - zend_stack_del_top(&CG(function_call_stack)); - return; - } - } - } else if (func->common.function_name->len == sizeof("is_null")-1 && - memcmp(func->common.function_name->val, "is_null", sizeof("is_null")-1) == 0) { - if (fcall->arg_num == 1) { - if (zend_do_convert_type_check(opline, result, IS_NULL TSRMLS_CC)) { - zend_stack_del_top(&CG(function_call_stack)); - return; - } - } - } else if (func->common.function_name->len == sizeof("is_bool")-1 && - memcmp(func->common.function_name->val, "is_bool", sizeof("is_bool")-1) == 0) { - if (fcall->arg_num == 1) { - if (zend_do_convert_type_check(opline, result, _IS_BOOL TSRMLS_CC)) { - zend_stack_del_top(&CG(function_call_stack)); - return; - } - } - } else if (func->common.function_name->len == sizeof("is_long")-1 && - memcmp(func->common.function_name->val, "is_long", sizeof("is_long")-1) == 0) { - if (fcall->arg_num == 1) { - if (zend_do_convert_type_check(opline, result, IS_LONG TSRMLS_CC)) { - zend_stack_del_top(&CG(function_call_stack)); - return; - } - } - } else if (func->common.function_name->len == sizeof("is_float")-1 && - memcmp(func->common.function_name->val, "is_float", sizeof("is_float")-1) == 0) { - if (fcall->arg_num == 1) { - if (zend_do_convert_type_check(opline, result, IS_DOUBLE TSRMLS_CC)) { - zend_stack_del_top(&CG(function_call_stack)); - return; - } - } - } else if (func->common.function_name->len == sizeof("is_string")-1 && - memcmp(func->common.function_name->val, "is_string", sizeof("is_string")-1) == 0) { - if (fcall->arg_num == 1) { - if (zend_do_convert_type_check(opline, result, IS_STRING TSRMLS_CC)) { - zend_stack_del_top(&CG(function_call_stack)); - return; - } - } - } else if (func->common.function_name->len == sizeof("is_array")-1 && - memcmp(func->common.function_name->val, "is_array", sizeof("is_array")-1) == 0) { - if (fcall->arg_num == 1) { - if (zend_do_convert_type_check(opline, result, IS_ARRAY TSRMLS_CC)) { - zend_stack_del_top(&CG(function_call_stack)); - return; - } - } - } else if (func->common.function_name->len == sizeof("is_object")-1 && - memcmp(func->common.function_name->val, "is_object", sizeof("is_object")-1) == 0) { - if (fcall->arg_num == 1) { - if (zend_do_convert_type_check(opline, result, IS_OBJECT TSRMLS_CC)) { - zend_stack_del_top(&CG(function_call_stack)); - return; - } - } - } else if (func->common.function_name->len == sizeof("is_resouce")-1 && - memcmp(func->common.function_name->val, "is_resource", sizeof("is_resource")-1) == 0) { - if (fcall->arg_num == 1) { - if (zend_do_convert_type_check(opline, result, IS_RESOURCE TSRMLS_CC)) { - zend_stack_del_top(&CG(function_call_stack)); - return; - } - } - } - } - } - - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_DO_FCALL; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); - opline->op1.num = call_flags; - } - - 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_stack_del_top(&CG(function_call_stack)); -} -/* }}} */ - -void zend_do_pass_param(znode *param, zend_uchar op TSRMLS_DC) /* {{{ */ -{ - zend_op *opline; - int original_op = op; - zend_function_call_entry *fcall = zend_stack_top(&CG(function_call_stack)); - zend_function *function_ptr = fcall->fbc; - int send_by_reference = 0; - int send_function = 0; - - fcall->arg_num++; - - if (fcall->uses_argument_unpacking) { - zend_error_noreturn(E_COMPILE_ERROR, - "Cannot use positional argument after argument unpacking"); - } - - if (op == ZEND_SEND_VAR && (param->op_type & (IS_CONST|IS_TMP_VAR))) { - /* Function call was converted into builtin instruction */ - zend_llist *fetch_list_ptr = zend_stack_top(&CG(bp_stack)); - zend_llist_destroy(fetch_list_ptr); - zend_stack_del_top(&CG(bp_stack)); - original_op = op = ZEND_SEND_VAL; - } - - 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->val); - } else { - zend_error_noreturn(E_COMPILE_ERROR, "Call-time pass-by-reference has been removed"); - } - return; - } - - 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; - } - } - - 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; - } - - 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 (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; - } - } - - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - 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; - } - } else { - if (!function_ptr) { - switch (op) { - case ZEND_SEND_VAL: - op = ZEND_SEND_VAL_EX; - break; - case ZEND_SEND_VAR: - op = ZEND_SEND_VAR_EX; - break; - } - } - } - opline->opcode = op; - SET_NODE(opline->op1, param); - opline->op2.opline_num = fcall->arg_num; - SET_UNUSED(opline->op2); -} -/* }}} */ - -void zend_do_unpack_params(znode *params TSRMLS_DC) /* {{{ */ -{ - zend_op *opline; - zend_function_call_entry *fcall = zend_stack_top(&CG(function_call_stack)); - - fcall->uses_argument_unpacking = 1; - - 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; -} -/* }}} */ +static zend_bool zend_is_call(zend_ast *ast); static int generate_free_switch_expr(zend_switch_entry *switch_entry TSRMLS_DC) /* {{{ */ { @@ -3141,292 +930,25 @@ static int generate_free_foreach_copy(const zend_op *foreach_copy TSRMLS_DC) /* } /* }}} */ -void zend_do_return(znode *expr, int do_end_vparse TSRMLS_DC) /* {{{ */ -{ - 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, 1 TSRMLS_CC); - } else { - zend_do_end_variable_parse(expr, BP_VAR_R, 0 TSRMLS_CC); - } - } - - start_op_number = get_next_op_number(CG(active_op_array)); - -#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 - - 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 (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); - } - - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - opline->opcode = returns_reference ? ZEND_RETURN_BY_REF : ZEND_RETURN; - - if (expr) { - SET_NODE(opline->op1, expr); - - 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; - } - } else { - opline->op1_type = IS_CONST; - LITERAL_NULL(opline->op1); - } - - SET_UNUSED(opline->op2); -} -/* }}} */ - -void zend_do_yield(znode *result, znode *value, znode *key, zend_bool is_variable TSRMLS_DC) /* {{{ */ +static uint32_t zend_add_try_element(uint32_t try_op TSRMLS_DC) /* {{{ */ { - 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, 1 TSRMLS_CC); - } else { - zend_do_end_variable_parse(value, BP_VAR_R, 0 TSRMLS_CC); - } - } - - opline = get_next_op(CG(active_op_array) 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; - opline->opcode = ZEND_YIELD; + op_array->try_catch_array = safe_erealloc( + op_array->try_catch_array, sizeof(zend_try_catch_element), op_array->last_try_catch, 0); - if (value) { - SET_NODE(opline->op1, value); + 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; - if (is_variable && zend_is_function_or_method_call(value)) { - opline->extended_value = ZEND_RETURNS_FUNCTION; - } - } else { - SET_UNUSED(opline->op1); - } - - if (key) { - SET_NODE(opline->op2, key); - } else { - SET_UNUSED(opline->op2); - } - - opline->result_type = IS_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - GET_NODE(result, opline->result); -} -/* }}} */ - -static int zend_add_try_element(uint32_t try_op TSRMLS_DC) /* {{{ */ -{ - int try_catch_offset = CG(active_op_array)->last_try_catch++; - - 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; } /* }}} */ -static void zend_add_catch_element(int offset, uint32_t catch_op TSRMLS_DC) /* {{{ */ -{ - CG(active_op_array)->try_catch_array[offset].catch_op = catch_op; -} -/* }}} */ - -void zend_do_first_catch(znode *open_parentheses TSRMLS_DC) /* {{{ */ -{ - open_parentheses->u.op.opline_num = get_next_op_number(CG(active_op_array)); -} -/* }}} */ - -void zend_initialize_try_catch_element(znode *catch_token TSRMLS_DC) /* {{{ */ -{ - 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); - jmp_list_ptr = zend_stack_top(&CG(bp_stack)); - zend_llist_add_element(jmp_list_ptr, &jmp_op_number); - - catch_token->EA = get_next_op_number(CG(active_op_array)); -} -/* }}} */ - -void zend_do_mark_last_catch(const znode *first_catch, const znode *last_additional_catch TSRMLS_DC) /* {{{ */ -{ - 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)); - } - DEC_BPC(CG(active_op_array)); -} -/* }}} */ - -void zend_do_try(znode *try_token TSRMLS_DC) /* {{{ */ -{ - 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)); -} -/* }}} */ - -void zend_do_finally(znode *finally_token TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - 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); - - CG(context).in_finally++; -} -/* }}} */ - -void zend_do_begin_catch(znode *catch_token, znode *class_name, znode *catch_var, znode *first_catch TSRMLS_DC) /* {{{ */ -{ - zend_long catch_op_number; - 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"); - } - - catch_op_number = get_next_op_number(CG(active_op_array)); - if (first_catch) { - first_catch->u.op.opline_num = catch_op_number; - } - - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_CATCH; - 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_STR(catch_var->u.constant) TSRMLS_CC); - Z_STR(catch_var->u.constant) = CG(active_op_array)->vars[EX_VAR_TO_NUM(opline->op2.var)]; - opline->result.num = 0; /* 1 means it's the last catch in the block */ - - catch_token->u.op.opline_num = catch_op_number; -} -/* }}} */ - -void zend_do_end_catch(znode *catch_token TSRMLS_DC) /* {{{ */ -{ - 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 */ - - jmp_list_ptr = zend_stack_top(&CG(bp_stack)); - zend_llist_add_element(jmp_list_ptr, &jmp_op_number); - - CG(active_op_array)->opcodes[catch_token->u.op.opline_num].extended_value = get_next_op_number(CG(active_op_array)); -} -/* }}} */ - -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); - } -} -/* }}} */ - -void zend_do_end_finally(znode *try_token, znode* catch_token, znode *finally_token TSRMLS_DC) /* {{{ */ -{ - 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; - - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_FAST_RET; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); - - CG(active_op_array)->opcodes[finally_token->u.op.opline_num].op1.opline_num = get_next_op_number(CG(active_op_array)); - - CG(context).in_finally--; - } -} -/* }}} */ - -void zend_do_throw(znode *expr TSRMLS_DC) /* {{{ */ -{ - zend_op *opline; - - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_THROW; - SET_NODE(opline->op1, expr); - SET_UNUSED(opline->op2); -} -/* }}} */ - ZEND_API void function_add_ref(zend_function *function) /* {{{ */ { if (function->type == ZEND_USER_FUNCTION) { @@ -3727,7 +1249,7 @@ static zend_bool zend_do_perform_implementation_check(const zend_function *fe, c buf = erealloc(buf, length); \ } -static char * zend_get_function_declaration(zend_function *fptr TSRMLS_DC) /* {{{ */ +static char *zend_get_function_declaration(zend_function *fptr TSRMLS_DC) /* {{{ */ { char *offset, *buf; uint32_t length = 1024; @@ -3825,7 +1347,7 @@ static char * zend_get_function_declaration(zend_function *fptr TSRMLS_DC) /* {{ ++idx; while (op < end) { if ((op->opcode == ZEND_RECV || op->opcode == ZEND_RECV_INIT) - && op->op1.num == (zend_long)idx) + && op->op1.num == (long)idx) { precv = op; } @@ -5009,67 +2531,6 @@ ZEND_API int do_bind_function(const zend_op_array *op_array, zend_op *opline, Ha } /* }}} */ -void zend_prepare_reference(znode *result, znode *class_name, znode *method_name TSRMLS_DC) /* {{{ */ -{ - zend_trait_method_reference *method_ref = emalloc(sizeof(zend_trait_method_reference)); - method_ref->ce = 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_STR(class_name->u.constant); - } else { - method_ref->class_name = NULL; - } - - method_ref->method_name = Z_STR(method_name->u.constant); - - result->u.op.ptr = method_ref; - result->op_type = IS_TMP_VAR; -} -/* }}} */ - -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 (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; - } - - 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_STR(alias->u.constant); - } else { - trait_alias->alias = NULL; - } - zend_add_to_list(&ce->trait_aliases, trait_alias TSRMLS_CC); -} -/* }}} */ - -void zend_add_trait_precedence(znode *method_reference, znode *trait_list TSRMLS_DC) /* {{{ */ -{ - zend_class_entry *ce = CG(active_class_entry); - zend_trait_precedence *trait_precedence = emalloc(sizeof(zend_trait_precedence)); - - trait_precedence->trait_method = (zend_trait_method_reference*)method_reference->u.op.ptr; - trait_precedence->exclude_from_classes = trait_list->u.op.ptr; - - zend_add_to_list(&ce->trait_precedences, trait_precedence TSRMLS_CC); -} -/* }}} */ - 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) /* {{{ */ { zend_class_entry *ce; @@ -5245,1315 +2706,1817 @@ ZEND_API void zend_do_delayed_early_binding(const zend_op_array *op_array TSRMLS } /* }}} */ -void zend_do_boolean_or_begin(znode *expr1, znode *op_token TSRMLS_DC) /* {{{ */ +ZEND_API zend_string *zend_mangle_property_name(const char *src1, int src1_length, const char *src2, int src2_length, int internal) /* {{{ */ { - int next_op_number = get_next_op_number(CG(active_op_array)); - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - 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; - } - SET_NODE(opline->op1, expr1); - SET_UNUSED(opline->op2); - - op_token->u.op.opline_num = next_op_number; + zend_string *prop_name; + int prop_name_length; - GET_NODE(expr1, opline->result); + prop_name_length = 1 + src1_length + 1 + src2_length; + prop_name = zend_string_alloc(prop_name_length, internal); + prop_name->val[0] = '\0'; + memcpy(prop_name->val + 1, src1, src1_length+1); + memcpy(prop_name->val + 1 + src1_length + 1, src2, src2_length+1); + return prop_name; } /* }}} */ -void zend_do_boolean_or_end(znode *result, znode *expr1, znode *expr2, const znode *op_token TSRMLS_DC) /* {{{ */ +static int zend_strnlen(const char* s, int maxlen) /* {{{ */ { - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - *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); - - CG(active_op_array)->opcodes[op_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array)); + int len = 0; + while (*s++ && maxlen--) len++; + return len; } /* }}} */ -void zend_do_boolean_and_begin(znode *expr1, znode *op_token TSRMLS_DC) /* {{{ */ +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 next_op_number = get_next_op_number(CG(active_op_array)); - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + int class_name_len; - 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; - } - SET_NODE(opline->op1, expr1); - SET_UNUSED(opline->op2); + *class_name = NULL; - op_token->u.op.opline_num = next_op_number; + 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; + } - GET_NODE(expr1, opline->result); + 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; + } + 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_boolean_and_end(znode *result, znode *expr1, znode *expr2, const znode *op_token TSRMLS_DC) /* {{{ */ +static zend_constant *zend_get_ct_const(zend_string *name, int all_internal_constants_substitution TSRMLS_DC) /* {{{ */ { - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + zend_constant *c = NULL; + char *lookup_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 (name->val[0] == '\\') { + c = zend_hash_str_find_ptr(EG(zend_constants), name->val + 1, name->len - 1); + if (!c) { + lookup_name = zend_str_tolower_dup(name->val + 1, name->len - 1); + c = zend_hash_str_find_ptr(EG(zend_constants), lookup_name, name->len - 1); + efree(lookup_name); - CG(active_op_array)->opcodes[op_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array)); + if (c && (c->flags & CONST_CT_SUBST) && !(c->flags & CONST_CS)) { + return c; + } + return NULL; + } + } else if ((c = zend_hash_find_ptr(EG(zend_constants), name)) == NULL) { + lookup_name = zend_str_tolower_dup(name->val, name->len); + c = zend_hash_str_find_ptr(EG(zend_constants), lookup_name, name->len); + efree(lookup_name); + + if (c && (c->flags & CONST_CT_SUBST) && !(c->flags & CONST_CS)) { + return c; + } + 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) && + !Z_CONSTANT(c->value)) { + return c; + } + return NULL; } /* }}} */ -void zend_do_do_while_begin(TSRMLS_D) /* {{{ */ +static int zend_constant_ct_subst(znode *result, zval *const_name, int all_internal_constants_substitution TSRMLS_DC) /* {{{ */ { - do_begin_loop(TSRMLS_C); - INC_BPC(CG(active_op_array)); + zend_constant *c = zend_get_ct_const(Z_STR_P(const_name), + all_internal_constants_substitution TSRMLS_CC); + + if (c) { + result->op_type = IS_CONST; + result->u.constant = c->value; + zval_copy_ctor(&result->u.constant); + return 1; + } + return 0; } /* }}} */ -void zend_do_do_while_end(const znode *do_token, const znode *expr_open_bracket, znode *expr TSRMLS_DC) /* {{{ */ +void zend_init_list(void *result, void *item TSRMLS_DC) /* {{{ */ { - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - opline->opcode = ZEND_JMPNZ; - SET_NODE(opline->op1, expr); - opline->op2.opline_num = do_token->u.op.opline_num; - SET_UNUSED(opline->op2); + void** list = emalloc(sizeof(void*) * 2); - do_end_loop(expr_open_bracket->u.op.opline_num, 0 TSRMLS_CC); + list[0] = item; + list[1] = NULL; - DEC_BPC(CG(active_op_array)); + *(void**)result = list; } /* }}} */ -void zend_do_brk_cont(zend_uchar op, znode *expr TSRMLS_DC) /* {{{ */ +void zend_add_to_list(void *result, void *item TSRMLS_DC) /* {{{ */ { - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + void** list = *(void**)result; + size_t n = 0; - 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"); + if (list) { + while (list[n]) { + n++; } - SET_NODE(opline->op2, expr); - } else { - LITERAL_LONG(opline->op2, 1); - opline->op2_type = IS_CONST; } -} -/* }}} */ - -void zend_do_switch_cond(const znode *cond TSRMLS_DC) /* {{{ */ -{ - zend_switch_entry switch_entry; - switch_entry.cond = *cond; - switch_entry.default_case = -1; - switch_entry.control_var = -1; - zend_stack_push(&CG(switch_cond_stack), (void *) &switch_entry); + list = erealloc(list, sizeof(void*) * (n+2)); - do_begin_loop(TSRMLS_C); + list[n] = item; + list[n+1] = NULL; - INC_BPC(CG(active_op_array)); + *(void**)result = list; } /* }}} */ -void zend_do_switch_end(const znode *case_list TSRMLS_DC) /* {{{ */ +void zend_do_extended_info(TSRMLS_D) /* {{{ */ { zend_op *opline; - zend_switch_entry *switch_entry_ptr = zend_stack_top(&CG(switch_cond_stack)); - /* 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; + if (!(CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO)) { + return; } - if (case_list->op_type != IS_UNUSED) { /* non-empty switch */ - int next_op_number = get_next_op_number(CG(active_op_array)); + opline = get_next_op(CG(active_op_array) TSRMLS_CC); - CG(active_op_array)->opcodes[case_list->u.op.opline_num].op1.opline_num = next_op_number; - } + opline->opcode = ZEND_EXT_STMT; + SET_UNUSED(opline->op1); + SET_UNUSED(opline->op2); +} +/* }}} */ - /* 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; +void zend_do_extended_fcall_begin(TSRMLS_D) /* {{{ */ +{ + zend_op *opline; - 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 (!(CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO)) { + return; } - zend_stack_del_top(&CG(switch_cond_stack)); + opline = get_next_op(CG(active_op_array) TSRMLS_CC); - DEC_BPC(CG(active_op_array)); + opline->opcode = ZEND_EXT_FCALL_BEGIN; + SET_UNUSED(opline->op1); + SET_UNUSED(opline->op2); } /* }}} */ -void zend_do_case_before_statement(const znode *case_list, znode *case_token, znode *case_expr TSRMLS_DC) /* {{{ */ +void zend_do_extended_fcall_end(TSRMLS_D) /* {{{ */ { - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - int next_op_number; - zend_switch_entry *switch_entry_ptr = zend_stack_top(&CG(switch_cond_stack)); - znode result; + zend_op *opline; - 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)); + if (!(CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO)) { + return; } - GET_NODE(&result, opline->result); - 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; - if (case_list->op_type==IS_UNUSED) { - 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; + opline->opcode = ZEND_EXT_FCALL_END; + SET_UNUSED(opline->op1); + SET_UNUSED(opline->op2); } /* }}} */ -void zend_do_case_after_statement(znode *result, const znode *case_token TSRMLS_DC) /* {{{ */ +zend_bool zend_is_auto_global(zend_string *name 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); - - opline->opcode = ZEND_JMP; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); - result->u.op.opline_num = next_op_number; + zend_auto_global *auto_global; - 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 ((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 TSRMLS_CC); + } + return 1; } + return 0; } /* }}} */ -void zend_do_default_before_statement(const znode *case_list, znode *default_token TSRMLS_DC) /* {{{ */ +int zend_register_auto_global(zend_string *name, zend_bool jit, zend_auto_global_callback auto_global_callback 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); - zend_switch_entry *switch_entry_ptr = zend_stack_top(&CG(switch_cond_stack)); + zend_auto_global auto_global; + int retval; - opline->opcode = ZEND_JMP; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); - default_token->u.op.opline_num = next_op_number; + auto_global.name = zend_new_interned_string(name TSRMLS_CC); + auto_global.auto_global_callback = auto_global_callback; + auto_global.jit = jit; - next_op_number = get_next_op_number(CG(active_op_array)); - switch_entry_ptr->default_case = next_op_number; + retval = zend_hash_add_mem(CG(auto_globals), name, &auto_global, sizeof(zend_auto_global)) != NULL ? SUCCESS : FAILURE; - 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; + zend_string_release(auto_global.name); + return retval; } /* }}} */ -void zend_do_begin_class_declaration(const znode *class_token, znode *class_name, const znode *parent_class_name TSRMLS_DC) /* {{{ */ +ZEND_API void zend_activate_auto_globals(TSRMLS_D) /* {{{ */ { - zend_op *opline; - int doing_inheritance = 0; - zend_class_entry *new_class_entry; - zend_string *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; - } + zend_auto_global *auto_global; - lcname = zend_string_alloc(Z_STRLEN(class_name->u.constant), 0); - zend_str_tolower_copy(lcname->val, Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant)); + 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 TSRMLS_CC); + } else { + auto_global->armed = 0; + } + } ZEND_HASH_FOREACH_END(); +} +/* }}} */ - if (!(strcmp(lcname->val, "self") && strcmp(lcname->val, "parent"))) { - zend_string_free(lcname); - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as class name as it is reserved", Z_STRVAL(class_name->u.constant)); - } +int zendlex(zend_parser_stack_elem *elem TSRMLS_DC) /* {{{ */ +{ + zval zv; + int retval; - /* Class name must not conflict with import names */ - if (CG(current_import) && - (ns_name = zend_hash_find(CG(current_import), lcname)) != NULL) { - error = 1; + if (CG(increment_lineno)) { + CG(zend_lineno)++; + CG(increment_lineno) = 0; } - if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) { - /* Prefix class name with name of current namespace */ - znode tmp; +again: + ZVAL_UNDEF(&zv); + retval = lex_scan(&zv TSRMLS_CC); + switch (retval) { + case T_COMMENT: + case T_DOC_COMMENT: + case T_OPEN_TAG: + case T_WHITESPACE: + goto again; - tmp.op_type = IS_CONST; - ZVAL_DUP(&tmp.u.constant, &CG(current_namespace)); - zend_do_build_namespace_name(&tmp, &tmp, class_name TSRMLS_CC); - *class_name = tmp; - zend_string_free(lcname); - lcname = zend_string_alloc(Z_STRLEN(class_name->u.constant), 0); - zend_str_tolower_copy(lcname->val, Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant)); + 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 (Z_TYPE(zv) != IS_UNDEF) { + elem->ast = zend_ast_create_zval(&zv); } - if (error) { - char *tmp = zend_str_tolower_dup(Z_STRVAL_P(ns_name), Z_STRLEN_P(ns_name)); + return retval; +} +/* }}} */ - if (Z_STRLEN_P(ns_name) != Z_STRLEN(class_name->u.constant) || - memcmp(tmp, lcname->val, 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); - } +ZEND_API void zend_initialize_class_data(zend_class_entry *ce, zend_bool nullify_handlers TSRMLS_DC) /* {{{ */ +{ + 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); - new_class_entry = zend_arena_alloc(&CG(arena), sizeof(zend_class_entry)); - new_class_entry->type = ZEND_USER_CLASS; - new_class_entry->name = zend_new_interned_string(Z_STR(class_name->u.constant) TSRMLS_CC); + ce->refcount = 1; + ce->ce_flags = ZEND_ACC_CONSTANTS_UPDATED; - 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; + 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 : zend_destroy_property_info), 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 (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 (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; } - doing_inheritance = 1; + 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; } - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->op1_type = IS_CONST; - build_runtime_defined_function_key(&key, lcname->val, lcname->len TSRMLS_CC); - opline->op1.constant = zend_add_literal(CG(active_op_array), &key TSRMLS_CC); - - opline->op2_type = IS_CONST; + ce->default_properties_count = 0; + ce->default_static_members_count = 0; - 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->val); + 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; } + } +} +/* }}} */ - opline->extended_value = parent_class_name->u.op.var; - opline->opcode = ZEND_DECLARE_INHERITED_CLASS; +uint32_t zend_get_class_fetch_type(zend_string *name) { + if (name->len == sizeof("self") - 1 && + !strncasecmp(name->val, "self", sizeof("self") - 1)) { + return ZEND_FETCH_CLASS_SELF; + } else if (name->len == sizeof("parent") - 1 && + !strncasecmp(name->val, "parent", sizeof("parent") - 1)) { + return ZEND_FETCH_CLASS_PARENT; + } else if (name->len == sizeof("static") - 1 && + !strncasecmp(name->val, "static", sizeof("static") - 1)) { + return ZEND_FETCH_CLASS_STATIC; } else { - opline->opcode = ZEND_DECLARE_CLASS; + return ZEND_FETCH_CLASS_DEFAULT; } +} - LITERAL_STR(opline->op2, lcname); +ZEND_API zend_string *zend_get_compiled_variable_name(const zend_op_array *op_array, uint32_t var) /* {{{ */ +{ + return op_array->vars[EX_VAR_TO_NUM(var)]; +} +/* }}} */ - zend_hash_update_ptr(CG(class_table), Z_STR(key), new_class_entry); - CG(active_class_entry) = new_class_entry; +zend_ast *zend_ast_append_str(zend_ast *left_ast, zend_ast *right_ast) { + 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); - opline->result.var = get_temporary_variable(CG(active_op_array)); - opline->result_type = IS_VAR; - GET_NODE(&CG(implementing_class), opline->result); + zend_string *result; + size_t left_len = left->len; + size_t len = left_len + right->len + 1; /* left\right */ + + result = zend_string_realloc(left, len, 0); + result->val[left_len] = '\\'; + memcpy(&result->val[left_len + 1], right->val, right->len); + result->val[len] = '\0'; + zend_string_release(right); + ZVAL_STR(left_zv, result); + return left_ast; +} + +/* A hacky way that is used to store the doc comment for properties */ +zend_ast_list *zend_ast_append_doc_comment(zend_ast_list *list TSRMLS_DC) { if (CG(doc_comment)) { - CG(active_class_entry)->info.user.doc_comment = CG(doc_comment); + list = zend_ast_list_add(list, zend_ast_create_zval_from_str(CG(doc_comment))); CG(doc_comment) = NULL; } + + return list; +} + +void zend_verify_namespace(TSRMLS_D) /* {{{ */ +{ + if (CG(has_bracketed_namespaces) && !CG(in_namespace)) { + zend_error_noreturn(E_COMPILE_ERROR, "No code may exist outside of namespace {}"); + } } /* }}} */ -static void do_verify_abstract_class(TSRMLS_D) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); +static void zend_reset_import_tables(TSRMLS_D) { + if (CG(current_import)) { + zend_hash_destroy(CG(current_import)); + efree(CG(current_import)); + CG(current_import) = NULL; + } - opline->opcode = ZEND_VERIFY_ABSTRACT_CLASS; - SET_NODE(opline->op1, &CG(implementing_class)); - SET_UNUSED(opline->op2); + 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; + } +} + +static void zend_end_namespace(TSRMLS_D) { + CG(in_namespace) = 0; + zend_reset_import_tables(TSRMLS_C); + if (CG(current_namespace)) { + zend_string_release(CG(current_namespace)); + CG(current_namespace) = NULL; + } +} + +void zend_do_end_compilation(TSRMLS_D) /* {{{ */ +{ + CG(has_bracketed_namespaces) = 0; + zend_end_namespace(TSRMLS_C); } /* }}} */ -void zend_do_end_class_declaration(const znode *class_token, const znode *parent_token TSRMLS_DC) /* {{{ */ +/* {{{ zend_dirname + Returns directory name component of path */ +ZEND_API size_t zend_dirname(char *path, size_t len) { - zend_class_entry *ce = CG(active_class_entry); + register char *end = path + len - 1; + unsigned int len_adjust = 0; - 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->val, ce->constructor->common.function_name->val); +#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 (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->val, ce->destructor->common.function_name->val); +#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; } } - 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->val, ce->clone->common.function_name->val); +#endif + + if (len == 0) { + /* Illegal use of this function */ + return 0; + } + + /* 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; + } + + /* 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; } +#else + path[0] = '.'; + path[1] = '\0'; + return 1 + len_adjust; +#endif } - ce->info.user.line_end = zend_get_compiled_lineno(TSRMLS_C); + /* 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; + } + *(end+1) = '\0'; - /* 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; + return (size_t)(end + 1 - path) + len_adjust; +} +/* }}} */ - ce->traits = NULL; - ce->num_traits = 0; - ce->ce_flags |= ZEND_ACC_IMPLEMENT_TRAITS; +static inline zend_bool zend_str_equals_str(zend_string *str1, zend_string *str2) { + return str1->len == str2->len && !memcmp(str1->val, str2->val, str2->len); +} +static inline zend_bool zend_str_equals_str_ci(zend_string *str1, zend_string *str2) { + return str1->len == str2->len + && !zend_binary_strcasecmp(str1->val, str1->len, str2->val, str2->len); +} - /* opcode generation: */ - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_BIND_TRAITS; - SET_NODE(opline->op1, &CG(implementing_class)); +#define zend_str_equals_literal(str, c) \ + ((str)->len == sizeof(c) - 1 && !memcmp((str)->val, (c), sizeof(c) - 1)) +#define zend_str_equals_literal_ci(str, c) \ + ((str)->len == sizeof(c) - 1 \ + && !zend_binary_strcasecmp((str)->val, (str)->len, (c), sizeof(c) - 1)) + +static void zend_adjust_for_fetch_type(zend_op *opline, uint32_t type) { + switch (type & BP_VAR_MASK) { + case BP_VAR_R: + return; + case BP_VAR_W: + opline->opcode += 3; + return; + case BP_VAR_REF: + opline->opcode += 3; + opline->extended_value |= ZEND_FETCH_MAKE_REF; + 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() } +} - 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); - if (ce->num_interfaces && !(ce->ce_flags & ZEND_ACC_IMPLEMENT_TRAITS)) { - do_verify_abstract_class(TSRMLS_C); - } +static inline void zend_make_var_result(znode *result, zend_op *opline TSRMLS_DC) { + opline->result_type = IS_VAR; + opline->result.var = get_temporary_variable(CG(active_op_array)); + GET_NODE(result, opline->result); +} + +static inline void zend_make_tmp_result(znode *result, zend_op *opline TSRMLS_DC) { + opline->result_type = IS_TMP_VAR; + opline->result.var = get_temporary_variable(CG(active_op_array)); + GET_NODE(result, opline->result); +} + +static zend_op *zend_emit_op(znode *result, zend_uchar opcode, znode *op1, znode *op2 TSRMLS_DC) { + zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + opline->opcode = opcode; + + if (op1 == NULL) { + SET_UNUSED(opline->op1); + } else { + SET_NODE(opline->op1, op1); } - /* 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 - * zend_verify_abstract_class() */ - if (ce->num_interfaces > 0) { - ce->interfaces = NULL; - ce->num_interfaces = 0; - ce->ce_flags |= ZEND_ACC_IMPLEMENT_INTERFACES; + + if (op2 == NULL) { + SET_UNUSED(opline->op2); + } else { + SET_NODE(opline->op2, op2); } - CG(active_class_entry) = NULL; + if (result) { + zend_make_var_result(result, opline TSRMLS_CC); + } + return opline; } -/* }}} */ -void zend_do_implements_interface(znode *interface_name TSRMLS_DC) /* {{{ */ -{ - zend_op *opline; +static zend_op *zend_emit_op_tmp( + znode *result, zend_uchar opcode, znode *op1, znode *op2 TSRMLS_DC +) { + zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + opline->opcode = opcode; - /* 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->val); + if (op1 == NULL) { + SET_UNUSED(opline->op1); + } else { + SET_NODE(opline->op1, op1); } - 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)); + if (op2 == NULL) { + SET_UNUSED(opline->op2); + } else { + SET_NODE(opline->op2, op2); + } + + zend_make_tmp_result(result, opline TSRMLS_CC); + + return opline; +} + +static void zend_emit_tick(TSRMLS_D) { + zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + + opline->opcode = ZEND_TICKS; + SET_UNUSED(opline->op1); + SET_UNUSED(opline->op2); + opline->extended_value = Z_LVAL(CG(declarables).ticks); +} + +static inline zend_op *zend_emit_op_data(znode *value TSRMLS_DC) { + return zend_emit_op(NULL, ZEND_OP_DATA, value, NULL TSRMLS_CC); +} + +static inline uint32_t zend_emit_jump(uint32_t opnum_target TSRMLS_DC) { + uint32_t opnum = get_next_op_number(CG(active_op_array)); + zend_op *opline = zend_emit_op(NULL, ZEND_JMP, NULL, NULL TSRMLS_CC); + opline->op1.opline_num = opnum_target; + return opnum; +} + +static inline uint32_t zend_emit_cond_jump( + zend_uchar opcode, znode *cond, uint32_t opnum_target TSRMLS_DC +) { + uint32_t opnum = get_next_op_number(CG(active_op_array)); + zend_op *opline = zend_emit_op(NULL, opcode, cond, NULL TSRMLS_CC); + opline->op2.opline_num = opnum_target; + return opnum; +} + +static inline void zend_update_jump_target(uint32_t opnum_jump, uint32_t opnum_target TSRMLS_DC) { + zend_op *opline = &CG(active_op_array)->opcodes[opnum_jump]; + switch (opline->opcode) { + case ZEND_JMP: + opline->op1.opline_num = opnum_target; break; - default: + case ZEND_JMPZ: + case ZEND_JMPNZ: + case ZEND_JMPZ_EX: + case ZEND_JMPNZ_EX: + opline->op2.opline_num = opnum_target; break; + 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++; +static inline void zend_update_jump_target_to_next(uint32_t opnum_jump TSRMLS_DC) { + zend_update_jump_target(opnum_jump, get_next_op_number(CG(active_op_array)) TSRMLS_CC); } -/* }}} */ -void zend_do_use_trait(znode *trait_name TSRMLS_DC) /* {{{ */ -{ - zend_op *opline; +static inline zend_op *zend_delayed_emit_op( + znode *result, zend_uchar opcode, znode *op1, znode *op2 TSRMLS_DC +) { + zend_op tmp_opline; + init_op(&tmp_opline TSRMLS_CC); + tmp_opline.opcode = opcode; + SET_NODE(tmp_opline.op1, op1); + SET_NODE(tmp_opline.op2, op2); + if (result) { + zend_make_var_result(result, &tmp_opline TSRMLS_CC); + } - 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->val); + zend_stack_push(&CG(delayed_oplines_stack), &tmp_opline); + return zend_stack_top(&CG(delayed_oplines_stack)); +} + +static inline uint32_t zend_delayed_compile_begin(TSRMLS_D) { + return zend_stack_count(&CG(delayed_oplines_stack)); +} + +static zend_op *zend_delayed_compile_end(uint32_t offset TSRMLS_DC) { + zend_op *opline, *oplines = zend_stack_base(&CG(delayed_oplines_stack)); + uint32_t i, count = zend_stack_count(&CG(delayed_oplines_stack)); + + ZEND_ASSERT(count > offset); + for (i = offset; i < count; ++i) { + opline = get_next_op(CG(active_op_array) TSRMLS_CC); + memcpy(opline, &oplines[i], sizeof(zend_op)); } + CG(delayed_oplines_stack).top = offset; + return opline; +} +void zend_emit_final_return(zval *zv TSRMLS_DC) { + znode zn; + zend_bool returns_reference = (CG(active_op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0; - 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; + zn.op_type = IS_CONST; + if (zv) { + ZVAL_COPY_VALUE(&zn.u.constant, zv); + } else { + ZVAL_NULL(&zn.u.constant); } - 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++; + zend_emit_op(NULL, returns_reference ? ZEND_RETURN_BY_REF : ZEND_RETURN, &zn, NULL TSRMLS_CC); } -/* }}} */ -ZEND_API zend_string *zend_mangle_property_name(const char *src1, int src1_length, const char *src2, int src2_length, int internal) /* {{{ */ -{ - zend_string *prop_name; - int prop_name_length; - prop_name_length = 1 + src1_length + 1 + src2_length; - prop_name = zend_string_alloc(prop_name_length, internal); - prop_name->val[0] = '\0'; - memcpy(prop_name->val + 1, src1, src1_length+1); - memcpy(prop_name->val + 1 + src1_length + 1, src2, src2_length+1); - return prop_name; +static inline zend_bool zend_is_variable(zend_ast *ast) { + 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; } -/* }}} */ -static int zend_strnlen(const char* s, int maxlen) /* {{{ */ -{ - int len = 0; - while (*s++ && maxlen--) len++; - return len; +static inline zend_bool zend_is_call(zend_ast *ast) { + return ast->kind == ZEND_AST_CALL + || ast->kind == ZEND_AST_METHOD_CALL + || ast->kind == ZEND_AST_STATIC_CALL; } -/* }}} */ -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; +static inline zend_bool zend_is_unticked_stmt(zend_ast *ast) { + return ast->kind == ZEND_AST_STMT_LIST || ast->kind == ZEND_AST_LABEL; +} - *class_name = NULL; +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]; + } - if (mangled_property[0]!=0) { - *prop_name = mangled_property; - if (prop_len) { - *prop_len = len; - } - return SUCCESS; + return zend_is_variable(ast); +} + +static inline zend_bool zend_is_const_default_class_ref(zend_ast *name_ast) { + zend_string *name; + + if (name_ast->kind != ZEND_AST_ZVAL) { + return 0; } - 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; + + /* Fully qualified names are always default refs */ + if (!name_ast->attr) { + return 1; + } + + name = zend_ast_get_str(name_ast); + return ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(name); +} + +static inline void zend_handle_numeric_op(znode *node TSRMLS_DC) { + if (node->op_type == IS_CONST && Z_TYPE(node->u.constant) == IS_STRING) { + zend_ulong index; + + if (ZEND_HANDLE_NUMERIC(Z_STR(node->u.constant), index)) { + zval_ptr_dtor(&node->u.constant); + ZVAL_LONG(&node->u.constant, index); } - return FAILURE; } +} - 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; +static inline void zend_set_class_name_op1(zend_op *opline, znode *class_node TSRMLS_DC) { + 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) TSRMLS_CC); + } else { + SET_NODE(opline->op1, class_node); + } +} + +static zend_op *zend_compile_class_ref(znode *result, zend_ast *name_ast TSRMLS_DC) { + zend_op *opline; + znode name_node; + zend_compile_expr(&name_node, name_ast 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 = zend_emit_op(result, ZEND_FETCH_CLASS, NULL, NULL TSRMLS_CC); + opline->extended_value = fetch_type; + + 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 TSRMLS_CC) TSRMLS_CC); } - return FAILURE; + + zend_string_release(name); + } else { + opline = zend_emit_op(result, ZEND_FETCH_CLASS, NULL, &name_node TSRMLS_CC); + opline->extended_value = ZEND_FETCH_CLASS_DEFAULT; } - *class_name = mangled_property + 1; - *prop_name = (*class_name) + class_name_len; - if (prop_len) { - *prop_len = len - class_name_len; + + return opline; +} + +static int zend_try_compile_cv(znode *result, zend_ast *ast TSRMLS_DC) { + 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 (zend_is_auto_global(name TSRMLS_CC)) { + zend_string_release(name); + return FAILURE; + } + + result->op_type = IS_CV; + result->u.op.var = lookup_cv(CG(active_op_array), name TSRMLS_CC); + + if (zend_str_equals_literal(name, "this")) { + CG(active_op_array)->this_var = result->u.op.var; + } + return SUCCESS; } - return SUCCESS; + + return FAILURE; } -/* }}} */ -void zend_do_declare_property(znode *var_name, znode *value, uint32_t access_type TSRMLS_DC) /* {{{ */ -{ - zval property; - zend_property_info *existing_property_info; - zend_string *comment = NULL; +static zend_op *zend_compile_simple_var_no_cv(znode *result, zend_ast *ast, int type TSRMLS_DC) { + zend_ast *name_ast = ast->child[0]; + znode name_node; + zend_op *opline; - if (CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE) { - zend_error_noreturn(E_COMPILE_ERROR, "Interfaces may not include member variables"); + /* 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 == -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 TSRMLS_CC); } - if (access_type & ZEND_ACC_ABSTRACT) { - zend_error_noreturn(E_COMPILE_ERROR, "Properties cannot be declared abstract"); + zend_compile_expr(&name_node, name_ast TSRMLS_CC); + + opline = get_next_op(CG(active_op_array) TSRMLS_CC); + opline = zend_emit_op(result, ZEND_FETCH_R, &name_node, NULL TSRMLS_CC); + + opline->extended_value = ZEND_FETCH_LOCAL; + if (name_node.op_type == IS_CONST) { + if (zend_is_auto_global(Z_STR(name_node.u.constant) TSRMLS_CC)) { + opline->extended_value = ZEND_FETCH_GLOBAL; + } } - 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->val, Z_STRVAL(var_name->u.constant)); + return opline; +} + +static void zend_compile_simple_var(znode *result, zend_ast *ast, int type TSRMLS_DC) { + if (zend_try_compile_cv(result, ast TSRMLS_CC) == FAILURE) { + zend_op *opline = zend_compile_simple_var_no_cv(result, ast, type TSRMLS_CC); + zend_adjust_for_fetch_type(opline, type); } +} - if ((existing_property_info = zend_hash_find_ptr(&CG(active_class_entry)->properties_info, Z_STR(var_name->u.constant))) != NULL) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare %s::$%s", CG(active_class_entry)->name->val, Z_STRVAL(var_name->u.constant)); +static void zend_separate_if_call_and_write(znode *node, zend_ast *ast, int type TSRMLS_DC) { + if (type != BP_VAR_R && type != BP_VAR_IS && zend_is_call(ast)) { + zend_op *opline = zend_emit_op(NULL, ZEND_SEPARATE, node, NULL TSRMLS_CC); + opline->result_type = IS_VAR; + opline->result.var = opline->op1.var; } +} + +void zend_delayed_compile_var(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC); - if (value) { - ZVAL_COPY_VALUE(&property, &value->u.constant); +static zend_op *zend_delayed_compile_dim(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC) { + 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 TSRMLS_CC); + zend_separate_if_call_and_write(&var_node, var_ast, type TSRMLS_CC); + + 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 { - ZVAL_NULL(&property); + zend_compile_expr(&dim_node, dim_ast TSRMLS_CC); + zend_handle_numeric_op(&dim_node TSRMLS_CC); } - if (CG(doc_comment)) { - comment = CG(doc_comment); - CG(doc_comment) = NULL; - } + return zend_delayed_emit_op(result, ZEND_FETCH_DIM_R, &var_node, &dim_node TSRMLS_CC); +} + +static inline zend_op *zend_compile_dim_common( + znode *result, zend_ast *ast, uint32_t type TSRMLS_DC +) { + uint32_t offset = zend_delayed_compile_begin(TSRMLS_C); + zend_delayed_compile_dim(result, ast, type TSRMLS_CC); + return zend_delayed_compile_end(offset TSRMLS_CC); +} - Z_STR(var_name->u.constant) = zend_new_interned_string(Z_STR(var_name->u.constant) TSRMLS_CC); - if (IS_INTERNED(Z_STR(var_name->u.constant))) { - Z_TYPE_FLAGS(var_name->u.constant) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE); +void zend_compile_dim(znode *result, zend_ast *ast, int type TSRMLS_DC) { + zend_op *opline = zend_compile_dim_common(result, ast, type TSRMLS_CC); + zend_adjust_for_fetch_type(opline, type); +} + +static zend_bool is_this_fetch(zend_ast *ast) { + 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_str_equals_literal(Z_STR_P(name), "this"); } - zend_declare_property_ex(CG(active_class_entry), Z_STR(var_name->u.constant), &property, access_type, comment TSRMLS_CC); - zend_string_release(Z_STR(var_name->u.constant)); + + return 0; } -/* }}} */ -void zend_do_declare_class_constant(znode *var_name, znode *value TSRMLS_DC) /* {{{ */ -{ - if ((CG(active_class_entry)->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) { - zend_error_noreturn(E_COMPILE_ERROR, "Traits cannot have constants"); - return; +static zend_op *zend_delayed_compile_prop( + znode *result, zend_ast *ast, uint32_t type TSRMLS_DC +) { + zend_ast *obj_ast = ast->child[0]; + zend_ast *prop_ast = ast->child[1]; + + znode obj_node, prop_node; + zend_op *opline; + + if (is_this_fetch(obj_ast)) { + obj_node.op_type = IS_UNUSED; + } else { + zend_delayed_compile_var(&obj_node, obj_ast, type TSRMLS_CC); + zend_separate_if_call_and_write(&obj_node, obj_ast, type TSRMLS_CC); } + zend_compile_expr(&prop_node, prop_ast TSRMLS_CC); - Z_STR(var_name->u.constant) = zend_new_interned_string(Z_STR(var_name->u.constant) TSRMLS_CC); - if (IS_INTERNED(Z_STR(var_name->u.constant))) { - Z_TYPE_FLAGS(var_name->u.constant) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE); + opline = zend_delayed_emit_op(result, ZEND_FETCH_OBJ_R, &obj_node, &prop_node TSRMLS_CC); + if (opline->op2_type == IS_CONST && Z_TYPE(CONSTANT(opline->op2.constant)) == IS_STRING) { + zend_alloc_polymorphic_cache_slot(opline->op2.constant TSRMLS_CC); } - if (Z_CONSTANT(value->u.constant)) { - CG(active_class_entry)->ce_flags &= ~ZEND_ACC_CONSTANTS_UPDATED; + + return opline; +} + +static zend_op *zend_compile_prop_common(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC) { + uint32_t offset = zend_delayed_compile_begin(TSRMLS_C); + zend_delayed_compile_prop(result, ast, type TSRMLS_CC); + return zend_delayed_compile_end(offset TSRMLS_CC); +} + +void zend_compile_prop(znode *result, zend_ast *ast, int type TSRMLS_DC) { + zend_op *opline = zend_compile_prop_common(result, ast, type TSRMLS_CC); + zend_adjust_for_fetch_type(opline, type); +} + +zend_op *zend_compile_static_prop_common(znode *result, zend_ast *ast, int type TSRMLS_DC) { + zend_ast *class_ast = ast->child[0]; + zend_ast *prop_ast = ast->child[1]; + + znode class_node, prop_node; + zend_op *opline; + + 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 TSRMLS_CC)); + } else { + zend_compile_class_ref(&class_node, class_ast TSRMLS_CC); } - if (zend_hash_add(&CG(active_class_entry)->constants_table, Z_STR(var_name->u.constant), &value->u.constant) == NULL) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot redefine class constant %s::%s", CG(active_class_entry)->name->val, Z_STRVAL(var_name->u.constant)); + + zend_compile_expr(&prop_node, prop_ast TSRMLS_CC); + + opline = zend_emit_op(result, ZEND_FETCH_R, &prop_node, NULL TSRMLS_CC); + if (opline->op1_type == IS_CONST) { + zend_alloc_polymorphic_cache_slot(opline->op1.constant TSRMLS_CC); } - FREE_PNODE(var_name); + 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) TSRMLS_CC); + } else { + SET_NODE(opline->op2, &class_node); + } + opline->extended_value |= ZEND_FETCH_STATIC_MEMBER; - if (CG(doc_comment)) { - zend_string_release(CG(doc_comment)); - CG(doc_comment) = NULL; + return opline; +} + +void zend_compile_static_prop(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC) { + zend_op *opline = zend_compile_static_prop_common(result, ast, type TSRMLS_CC); + zend_adjust_for_fetch_type(opline, type); +} + +static inline zend_uchar get_list_fetch_opcode(zend_uchar op_type) { + switch (op_type) { + case IS_VAR: + case IS_CV: + return ZEND_FETCH_DIM_R; + case IS_TMP_VAR: + case IS_CONST: + return ZEND_FETCH_DIM_TMP_VAR; + EMPTY_SWITCH_DEFAULT_CASE() } } -/* }}} */ -void zend_do_fetch_property(znode *result, znode *object, znode *property TSRMLS_DC) /* {{{ */ -{ - zend_op opline; - zend_llist *fetch_list_ptr = zend_stack_top(&CG(bp_stack)); - - 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 */ - } - } 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) { - GET_POLYMORPHIC_CACHE_SLOT(opline_ptr->op2.constant); +static void zend_compile_list_assign(znode *result, zend_ast *ast, znode *expr_node TSRMLS_DC) { + zend_ast_list *list = zend_ast_get_list(ast); + uint32_t i; + + if (list->children == 1 && !list->child[0]) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use empty list"); + } + + for (i = 0; i < list->children; ++i) { + zend_ast *var_ast = list->child[i]; + znode fetch_result, dim_node, var_node, assign_result; + zend_op *opline; + + if (var_ast == NULL) { + continue; + } + + 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 = zend_emit_op(&fetch_result, + get_list_fetch_opcode(expr_node->op_type), expr_node, &dim_node TSRMLS_CC); + opline->extended_value |= ZEND_FETCH_ADD_LOCK; + + if (var_ast->kind != ZEND_AST_LIST) { + if (is_this_fetch(var_ast)) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this"); } - GET_NODE(result, opline_ptr->result); - return; + zend_compile_var(&var_node, var_ast, BP_VAR_W TSRMLS_CC); + zend_emit_op(&assign_result, ZEND_ASSIGN, &var_node, &fetch_result TSRMLS_CC); + zend_do_free(&assign_result TSRMLS_CC); + } else { + zend_compile_list_assign(&assign_result, var_ast, &fetch_result TSRMLS_CC); + zend_do_free(&assign_result TSRMLS_CC); } } + *result = *expr_node; +} + +void zend_ensure_writable_variable(const zend_ast *ast) { + if (ast->kind == ZEND_AST_CALL) { + zend_error_noreturn(E_COMPILE_ERROR, "Can't use function return value in write context"); + } + 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 (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); +/* Detects $a... = $a pattern */ +zend_bool zend_is_assign_to_self(zend_ast *var_ast, zend_ast *expr_ast TSRMLS_DC) { + if (expr_ast->kind != ZEND_AST_VAR || expr_ast->child[0]->kind != ZEND_AST_ZVAL) { + return 0; } - 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) { - GET_POLYMORPHIC_CACHE_SLOT(opline.op2.constant); + while (zend_is_variable(var_ast) && var_ast->kind != ZEND_AST_VAR) { + var_ast = var_ast->child[0]; } - GET_NODE(result, opline.result); - zend_llist_add_element(fetch_list_ptr, &opline); + if (var_ast->kind != ZEND_AST_VAR || var_ast->child[0]->kind != ZEND_AST_ZVAL) { + return 0; + } + + { + 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_str_equals_str(name1, name2); + zend_string_release(name1); + zend_string_release(name2); + return result; + } } -/* }}} */ -void zend_do_halt_compiler_register(TSRMLS_D) /* {{{ */ -{ - zend_string *name; - zend_string *cfilename; - char haltoff[] = "__COMPILER_HALT_OFFSET__"; +void zend_compile_assign(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *var_ast = ast->child[0]; + zend_ast *expr_ast = ast->child[1]; - if (CG(has_bracketed_namespaces) && CG(in_namespace)) { - zend_error_noreturn(E_COMPILE_ERROR, "__HALT_COMPILER() can only be used from the outermost scope"); + znode var_node, expr_node; + zend_op *opline; + uint32_t offset; + + if (is_this_fetch(var_ast)) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this"); } - cfilename = zend_get_compiled_filename(TSRMLS_C); - name = zend_mangle_property_name(haltoff, sizeof(haltoff) - 1, cfilename->val, cfilename->len, 0); - zend_register_long_constant(name->val, name->len, zend_get_scanned_file_offset(TSRMLS_C), CONST_CS, 0 TSRMLS_CC); - zend_string_free(name); + 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_W TSRMLS_CC); + zend_compile_expr(&expr_node, expr_ast TSRMLS_CC); + zend_emit_op(result, ZEND_ASSIGN, &var_node, &expr_node TSRMLS_CC); + return; + case ZEND_AST_DIM: + offset = zend_delayed_compile_begin(TSRMLS_C); + zend_delayed_compile_dim(result, var_ast, BP_VAR_W TSRMLS_CC); + + if (zend_is_assign_to_self(var_ast, expr_ast TSRMLS_CC)) { + /* $a[0] = $a should evaluate the right $a first */ + zend_compile_simple_var_no_cv(&expr_node, expr_ast, BP_VAR_R TSRMLS_CC); + } else { + zend_compile_expr(&expr_node, expr_ast TSRMLS_CC); + } + + opline = zend_delayed_compile_end(offset TSRMLS_CC); + opline->opcode = ZEND_ASSIGN_DIM; - if (CG(in_namespace)) { - zend_do_end_namespace(TSRMLS_C); + opline = zend_emit_op_data(&expr_node TSRMLS_CC); + opline->op2.var = get_temporary_variable(CG(active_op_array)); + opline->op2_type = IS_VAR; + return; + case ZEND_AST_PROP: + offset = zend_delayed_compile_begin(TSRMLS_C); + zend_delayed_compile_prop(result, var_ast, BP_VAR_W TSRMLS_CC); + zend_compile_expr(&expr_node, expr_ast TSRMLS_CC); + + opline = zend_delayed_compile_end(offset TSRMLS_CC); + opline->opcode = ZEND_ASSIGN_OBJ; + + zend_emit_op_data(&expr_node TSRMLS_CC); + return; + case ZEND_AST_LIST: + zend_compile_expr(&expr_node, expr_ast TSRMLS_CC); + zend_compile_list_assign(result, var_ast, &expr_node TSRMLS_CC); + return; + EMPTY_SWITCH_DEFAULT_CASE(); } } -/* }}} */ -void zend_do_push_object(const znode *object TSRMLS_DC) /* {{{ */ -{ - zend_stack_push(&CG(object_stack), object); +static inline void zend_emit_assign_znode(zend_ast *var_ast, znode *value_node TSRMLS_DC) { + znode dummy_node; + 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 TSRMLS_CC); + zend_do_free(&dummy_node TSRMLS_CC); } -/* }}} */ -void zend_do_pop_object(znode *object TSRMLS_DC) /* {{{ */ -{ - if (object) { - znode *tmp = zend_stack_top(&CG(object_stack)); - *object = *tmp; +void zend_compile_assign_ref(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *target_ast = ast->child[0]; + zend_ast *source_ast = ast->child[1]; + + znode target_node, source_node; + zend_op *opline; + + if (is_this_fetch(target_ast)) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this"); + } + zend_ensure_writable_variable(target_ast); + + zend_compile_var(&target_node, target_ast, BP_VAR_W TSRMLS_CC); + zend_compile_var(&source_node, source_ast, BP_VAR_REF TSRMLS_CC); + + opline = zend_emit_op(result, ZEND_ASSIGN_REF, &target_node, &source_node TSRMLS_CC); + if (!result) { + opline->result_type |= EXT_TYPE_UNUSED; + } + + if (zend_is_call(source_ast)) { + opline->extended_value = ZEND_RETURNS_FUNCTION; + } else if (source_ast->kind == ZEND_AST_NEW) { + opline->extended_value = ZEND_RETURNS_NEW; } - zend_stack_del_top(&CG(object_stack)); } -/* }}} */ -void zend_do_begin_new_object(znode *new_token, znode *class_type TSRMLS_DC) /* {{{ */ -{ +static inline void zend_emit_assign_ref_znode(zend_ast *var_ast, znode *value_node TSRMLS_DC) { + 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 TSRMLS_CC); +} + +void zend_compile_compound_assign(znode *result, zend_ast *ast TSRMLS_DC) { + 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; - 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->result_type = IS_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - SET_NODE(opline->op1, class_type); - SET_UNUSED(opline->op2); + zend_ensure_writable_variable(var_ast); - zend_push_function_call_entry(NULL, new_token->u.op.opline_num TSRMLS_CC); + switch (var_ast->kind) { + case ZEND_AST_VAR: + case ZEND_AST_STATIC_PROP: + zend_compile_var(&var_node, var_ast, BP_VAR_RW TSRMLS_CC); + zend_compile_expr(&expr_node, expr_ast TSRMLS_CC); + zend_emit_op(result, opcode, &var_node, &expr_node TSRMLS_CC); + return; + case ZEND_AST_DIM: + offset = zend_delayed_compile_begin(TSRMLS_C); + zend_delayed_compile_dim(result, var_ast, BP_VAR_RW TSRMLS_CC); + zend_compile_expr(&expr_node, expr_ast TSRMLS_CC); + + opline = zend_delayed_compile_end(offset TSRMLS_CC); + opline->opcode = opcode; + opline->extended_value = ZEND_ASSIGN_DIM; + + opline = zend_emit_op_data(&expr_node TSRMLS_CC); + opline->op2.var = get_temporary_variable(CG(active_op_array)); + opline->op2_type = IS_VAR; + return; + case ZEND_AST_PROP: + offset = zend_delayed_compile_begin(TSRMLS_C); + zend_delayed_compile_prop(result, var_ast, BP_VAR_RW TSRMLS_CC); + zend_compile_expr(&expr_node, expr_ast TSRMLS_CC); + + opline = zend_delayed_compile_end(offset TSRMLS_CC); + opline->opcode = opcode; + opline->extended_value = ZEND_ASSIGN_OBJ; + + zend_emit_op_data(&expr_node TSRMLS_CC); + return; + EMPTY_SWITCH_DEFAULT_CASE() + } } -/* }}} */ -void zend_do_end_new_object(znode *result, const znode *new_token TSRMLS_DC) /* {{{ */ -{ - znode ctor_result; +uint32_t zend_compile_args(zend_ast *ast, zend_function *fbc TSRMLS_DC) { + // 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 */ - zend_do_end_function_call(NULL, &ctor_result, 1, 0 TSRMLS_CC); - zend_do_free(&ctor_result TSRMLS_CC); + for (i = 0; i < args->children; ++i) { + zend_ast *arg = args->child[i]; + uint32_t arg_num = i + 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); -} -/* }}} */ + znode arg_node; + zend_op *opline; + zend_uchar opcode; + zend_ulong flags = 0; -static zend_constant* zend_get_ct_const(const zval *const_name, int all_internal_constants_substitution TSRMLS_DC) /* {{{ */ -{ - zend_constant *c = NULL; - char *lookup_name; + if (arg->kind == ZEND_AST_UNPACK) { + uses_arg_unpack = 1; + fbc = NULL; + + zend_compile_expr(&arg_node, arg->child[0] TSRMLS_CC); + opline = zend_emit_op(NULL, ZEND_SEND_UNPACK, &arg_node, NULL TSRMLS_CC); + opline->op2.num = arg_count; + continue; + } - if (Z_STRVAL_P(const_name)[0] == '\\') { - if ((c = zend_hash_str_find_ptr(EG(zend_constants), Z_STRVAL_P(const_name)+1, Z_STRLEN_P(const_name)-1)) == NULL) { - lookup_name = zend_str_tolower_dup(Z_STRVAL_P(const_name)+1, Z_STRLEN_P(const_name)-1); - if ((c = zend_hash_str_find_ptr(EG(zend_constants), lookup_name, Z_STRLEN_P(const_name)-1)) != NULL) { - if ((c->flags & CONST_CT_SUBST) && !(c->flags & CONST_CS)) { - efree(lookup_name); - return c; + if (uses_arg_unpack) { + zend_error_noreturn(E_COMPILE_ERROR, + "Cannot use positional argument after argument unpacking"); + } + + arg_count++; + if (zend_is_variable(arg)) { + if (zend_is_call(arg)) { + zend_compile_var(&arg_node, arg, BP_VAR_R TSRMLS_CC); + 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 TSRMLS_CC); + opcode = ZEND_SEND_REF; + } else { + zend_compile_var(&arg_node, arg, BP_VAR_R TSRMLS_CC); + opcode = ZEND_SEND_VAR; + } + } else { + zend_compile_var(&arg_node, arg, + BP_VAR_FUNC_ARG | (arg_num << BP_VAR_SHIFT) TSRMLS_CC); + opcode = ZEND_SEND_VAR_EX; + } + } else { + zend_compile_expr(&arg_node, arg TSRMLS_CC); + 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; } } - efree(lookup_name); - return NULL; } - } else if ((c = zend_hash_find_ptr(EG(zend_constants), Z_STR_P(const_name))) == NULL) { - lookup_name = zend_str_tolower_dup(Z_STRVAL_P(const_name), Z_STRLEN_P(const_name)); - if ((c = zend_hash_str_find_ptr(EG(zend_constants), lookup_name, Z_STRLEN_P(const_name))) != NULL) { - if ((c->flags & CONST_CT_SUBST) && !(c->flags & CONST_CS)) { - efree(lookup_name); - return c; + + opline = get_next_op(CG(active_op_array) TSRMLS_CC); + opline->opcode = opcode; + SET_NODE(opline->op1, &arg_node); + SET_UNUSED(opline->op2); + opline->op2.opline_num = arg_num; + + if (opcode == ZEND_SEND_VAR_NO_REF) { + if (fbc) { + flags |= ZEND_ARG_COMPILE_TIME_BOUND; } + opline->extended_value = flags; + } else if (fbc) { + opline->extended_value = ZEND_ARG_COMPILE_TIME_BOUND; } - efree(lookup_name); - return NULL; } - if (c->flags & CONST_CT_SUBST) { - return c; + + return arg_count; +} + +void zend_compile_call_common(znode *result, zend_ast *args_ast, zend_function *fbc TSRMLS_DC) { + zend_op *opline; + uint32_t opnum_init = get_next_op_number(CG(active_op_array)) - 1; + uint32_t arg_count; + uint32_t call_flags; + + zend_do_extended_fcall_begin(TSRMLS_C); + + arg_count = zend_compile_args(args_ast, fbc TSRMLS_CC); + + opline = &CG(active_op_array)->opcodes[opnum_init]; + opline->extended_value = arg_count; + + call_flags = (opline->opcode == ZEND_NEW ? ZEND_CALL_CTOR : 0); + opline = zend_emit_op(result, ZEND_DO_FCALL, NULL, NULL TSRMLS_CC); + opline->op1.num = call_flags; + + zend_do_extended_fcall_end(TSRMLS_C); +} + +zend_bool zend_compile_function_name(znode *name_node, zend_ast *name_ast TSRMLS_DC) { + zend_string *orig_name = zend_ast_get_str(name_ast); + zend_bool is_fully_qualified; + + name_node->op_type = IS_CONST; + ZVAL_STR(&name_node->u.constant, zend_resolve_function_name( + orig_name, name_ast->attr, &is_fully_qualified TSRMLS_CC)); + + return !is_fully_qualified && CG(current_namespace); +} + +void zend_compile_ns_call(znode *result, znode *name_node, zend_ast *args_ast TSRMLS_DC) { + zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + 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), &name_node->u.constant TSRMLS_CC); + zend_alloc_cache_slot(opline->op2.constant TSRMLS_CC); + + zend_compile_call_common(result, args_ast, NULL TSRMLS_CC); +} + +void zend_compile_dynamic_call(znode *result, znode *name_node, zend_ast *args_ast TSRMLS_DC) { + zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + opline->opcode = ZEND_INIT_FCALL_BY_NAME; + SET_UNUSED(opline->op1); + if (name_node->op_type == IS_CONST && Z_TYPE(name_node->u.constant) == IS_STRING) { + opline->op2_type = IS_CONST; + opline->op2.constant + = zend_add_func_name_literal(CG(active_op_array), &name_node->u.constant TSRMLS_CC); + zend_alloc_cache_slot(opline->op2.constant TSRMLS_CC); + } else { + SET_NODE(opline->op2, name_node); } - if (all_internal_constants_substitution && - (c->flags & CONST_PERSISTENT) && - !(CG(compiler_options) & ZEND_COMPILE_NO_CONSTANT_SUBSTITUTION) && - !Z_CONSTANT(c->value)) { - return c; + + zend_compile_call_common(result, args_ast, NULL TSRMLS_CC); +} + +static zend_bool zend_args_contain_unpack(zend_ast_list *args) { + uint32_t i; + for (i = 0; i < args->children; ++i) { + if (args->child[i]->kind == ZEND_AST_UNPACK) { + return 1; + } } - return NULL; + return 0; } -/* }}} */ -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); +int zend_compile_func_strlen(znode *result, zend_ast_list *args TSRMLS_DC) { + znode arg_node; - if (c) { - zval_dtor(const_name); - result->op_type = IS_CONST; - result->u.constant = c->value; - zval_copy_ctor(&result->u.constant); - return 1; + if ((CG(compiler_options) & ZEND_COMPILE_NO_BUILTIN_STRLEN) + || args->children != 1 || args->child[0]->kind == ZEND_AST_UNPACK + ) { + return FAILURE; } - return 0; + + zend_compile_expr(&arg_node, args->child[0] TSRMLS_CC); + zend_emit_op(result, ZEND_STRLEN, &arg_node, NULL TSRMLS_CC); + return SUCCESS; } -/* }}} */ -void zend_do_fetch_constant(znode *result, znode *constant_container, znode *constant_name, int mode, zend_bool check_namespace TSRMLS_DC) /* {{{ */ -{ - znode tmp; +int zend_compile_func_typecheck(znode *result, zend_ast_list *args, uint32_t type TSRMLS_DC) { + znode arg_node; zend_op *opline; - int type; - char *compound; - zend_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; - Z_TYPE_INFO(result->u.constant) = IS_CONSTANT_EX; - if (IS_INTERNED(Z_STR(result->u.constant))) { - Z_TYPE_FLAGS(result->u.constant) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE); - } - Z_CONST_FLAGS(result->u.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); - 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; + + if (args->children != 1 || args->child[0]->kind == ZEND_AST_UNPACK) { + return FAILURE; } - /* 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 */ + + zend_compile_expr(&arg_node, args->child[0] TSRMLS_CC); + opline = zend_emit_op(result, ZEND_TYPE_CHECK, &arg_node, NULL TSRMLS_CC); + opline->extended_value = type; + return SUCCESS; +} - if (zend_constant_ct_subst(result, &constant_name->u.constant, 0 TSRMLS_CC)) { - break; - } +int zend_compile_func_defined(znode *result, zend_ast_list *args TSRMLS_DC) { + zend_string *name; + zend_op *opline; - zend_resolve_const_name(constant_name, &check_namespace TSRMLS_CC); + if (args->children != 1 || args->child[0]->kind != ZEND_AST_ZVAL) { + return FAILURE; + } - if(!compound) { - fetch_type |= IS_CONSTANT_UNQUALIFIED; - } + name = zval_get_string(zend_ast_get_zval(args->child[0])); + if (zend_memrchr(name->val, '\\', name->len) || zend_memrchr(name->val, ':', name->len)) { + zend_string_release(name); + return FAILURE; + } - *result = *constant_name; - Z_TYPE_INFO(result->u.constant) = IS_CONSTANT_EX; - if (IS_INTERNED(Z_STR(result->u.constant))) { - Z_TYPE_FLAGS(result->u.constant) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE); - } - Z_CONST_FLAGS(result->u.constant) = fetch_type; - break; - case ZEND_RT: - compound = memchr(Z_STRVAL(constant_name->u.constant), '\\', Z_STRLEN(constant_name->u.constant)); + opline = zend_emit_op(result, ZEND_DEFINED, NULL, NULL TSRMLS_CC); + opline->op1_type = IS_CONST; + LITERAL_STR(opline->op1, name); + zend_alloc_cache_slot(opline->op1.constant TSRMLS_CC); - zend_resolve_const_name(constant_name, &check_namespace TSRMLS_CC); + /* Lowercase constant name in a separate literal */ + { + zval c; + zend_string *lcname = zend_string_alloc(name->len, 0); + zend_str_tolower_copy(lcname->val, name->val, name->len); + ZVAL_NEW_STR(&c, lcname); + zend_add_literal(CG(active_op_array), &c TSRMLS_CC); + } + return SUCCESS; +} - if(zend_constant_ct_subst(result, &constant_name->u.constant, 1 TSRMLS_CC)) { - break; - } +static int zend_try_compile_ct_bound_init_user_func( + znode *result, zend_ast *name_ast, uint32_t num_args TSRMLS_DC +) { + zend_string *name, *lcname; + zend_function *fbc; + zend_op *opline; - 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); - } else { - opline->extended_value = IS_CONSTANT_UNQUALIFIED; - if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) { - 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); - } else { - opline->op2.constant = zend_add_const_name_literal(CG(active_op_array), &constant_name->u.constant, 0 TSRMLS_CC); - } - } - GET_CACHE_SLOT(opline->op2.constant); - break; + if (name_ast->kind != ZEND_AST_CONST || Z_TYPE_P(zend_ast_get_zval(name_ast)) != IS_STRING) { + return FAILURE; } -} -/* }}} */ -void zend_do_shell_exec(znode *result, znode *cmd TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + name = zend_ast_get_str(name_ast); + lcname = zend_string_alloc(name->len, 0); + zend_str_tolower_copy(lcname->val, name->val, name->len); - opline->opcode = ZEND_INIT_FCALL; - opline->extended_value = 1; - SET_UNUSED(opline->op1); + 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_free(lcname); + return FAILURE; + } + + opline = zend_emit_op(NULL, ZEND_INIT_FCALL, NULL, NULL TSRMLS_CC); opline->op2_type = IS_CONST; - LITERAL_STR(opline->op2, zend_string_init("shell_exec", sizeof("shell_exec")-1, 0)); - GET_CACHE_SLOT(opline->op2.constant); + LITERAL_STR(opline->op2, lcname); + opline->extended_value = num_args; - 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; - break; - default: - opline->opcode = ZEND_SEND_VAR; - break; + return SUCCESS; +} + +static void zend_compile_init_user_func( + znode *result, zend_ast *name_ast, uint32_t num_args, zend_string *orig_func_name TSRMLS_DC +) { + zend_op *opline; + znode name_node; + + if (zend_try_compile_ct_bound_init_user_func(result, name_ast, num_args TSRMLS_CC) == SUCCESS) { + return; } - SET_NODE(opline->op1, cmd); - opline->op2.opline_num = 1; - 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->extended_value = 1; - opline->result.var = get_temporary_variable(CG(active_op_array)); - opline->result_type = IS_VAR; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); - GET_NODE(result, opline->result); + zend_compile_expr(&name_node, name_ast TSRMLS_CC); + + opline = zend_emit_op(NULL, ZEND_INIT_USER_CALL, NULL, &name_node TSRMLS_CC); + opline->op1_type = IS_CONST; + LITERAL_STR(opline->op1, zend_string_copy(orig_func_name)); + opline->extended_value = num_args; } -/* }}} */ -void zend_do_init_array(znode *result, znode *expr, znode *offset, zend_bool is_ref TSRMLS_DC) /* {{{ */ -{ - int op_num = get_next_op_number(CG(active_op_array)); - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); +/* cufa = call_user_func_array */ +int zend_compile_func_cufa(znode *result, zend_ast_list *args, zend_string *lcname TSRMLS_DC) { + znode arg_node; - result->u.op.opline_num = op_num; + if (args->children != 2 || zend_args_contain_unpack(args)) { + return FAILURE; + } - opline->opcode = ZEND_INIT_ARRAY; - opline->result.var = get_temporary_variable(CG(active_op_array)); - opline->result_type = IS_TMP_VAR; - opline->extended_value = is_ref; /* extval = size << 2 | not_packed << 1 | is_ref */ - - if (expr) { - opline->extended_value += 1 << ZEND_ARRAY_SIZE_SHIFT; /* increment size */ - 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) { - zend_ulong index; - - opline->extended_value |= ZEND_ARRAY_NOT_PACKED; - if (ZEND_HANDLE_NUMERIC(Z_STR(CONSTANT(opline->op2.constant)), index)) { - zval_dtor(&CONSTANT(opline->op2.constant)); - ZVAL_LONG(&CONSTANT(opline->op2.constant), index); - } + zend_compile_init_user_func(NULL, args->child[0], 1, lcname TSRMLS_CC); + zend_compile_expr(&arg_node, args->child[1] TSRMLS_CC); + zend_emit_op(NULL, ZEND_SEND_ARRAY, &arg_node, NULL TSRMLS_CC); + zend_emit_op(result, ZEND_DO_FCALL, NULL, NULL TSRMLS_CC); + + return SUCCESS; +} + +/* cuf = call_user_func */ +int zend_compile_func_cuf(znode *result, zend_ast_list *args, zend_string *lcname TSRMLS_DC) { + uint32_t i; + + if (args->children < 1 || zend_args_contain_unpack(args)) { + return FAILURE; + } + + zend_compile_init_user_func(NULL, args->child[0], args->children - 1, lcname TSRMLS_CC); + 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; + + 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) TSRMLS_CC); + send_user = 1; + } else { + zend_compile_expr(&arg_node, arg_ast TSRMLS_CC); + if (arg_node.op_type & (IS_VAR|IS_CV)) { + send_user = 1; } + } + + if (send_user) { + opline = zend_emit_op(NULL, ZEND_SEND_USER, &arg_node, NULL TSRMLS_CC); } else { - SET_UNUSED(opline->op2); + opline = zend_emit_op(NULL, ZEND_SEND_VAL, &arg_node, NULL TSRMLS_CC); } - } else { - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); + + opline->op2.opline_num = i; } + zend_emit_op(result, ZEND_DO_FCALL, NULL, NULL TSRMLS_CC); + + return SUCCESS; } -/* }}} */ -void zend_do_add_array_element(znode *result, znode *expr, znode *offset, zend_bool is_ref TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - zend_op *init_opline = &CG(active_op_array)->opcodes[result->u.op.opline_num]; - init_opline->extended_value += 1 << ZEND_ARRAY_SIZE_SHIFT; /* increment size */ - - opline->opcode = ZEND_ADD_ARRAY_ELEMENT; - COPY_NODE(opline->result, init_opline->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) { - zend_ulong index; - - init_opline->extended_value |= ZEND_ARRAY_NOT_PACKED; - if (ZEND_HANDLE_NUMERIC(Z_STR(CONSTANT(opline->op2.constant)), index)) { - zval_dtor(&CONSTANT(opline->op2.constant)); - ZVAL_LONG(&CONSTANT(opline->op2.constant), index); - } - } +int zend_try_compile_special_func( + znode *result, zend_string *lcname, zend_ast_list *args TSRMLS_DC +) { + if (zend_str_equals_literal(lcname, "strlen")) { + return zend_compile_func_strlen(result, args TSRMLS_CC); + } else if (zend_str_equals_literal(lcname, "is_null")) { + return zend_compile_func_typecheck(result, args, IS_NULL TSRMLS_CC); + } else if (zend_str_equals_literal(lcname, "is_bool")) { + return zend_compile_func_typecheck(result, args, _IS_BOOL TSRMLS_CC); + } else if (zend_str_equals_literal(lcname, "is_long")) { + return zend_compile_func_typecheck(result, args, IS_LONG TSRMLS_CC); + } else if (zend_str_equals_literal(lcname, "is_float")) { + return zend_compile_func_typecheck(result, args, IS_DOUBLE TSRMLS_CC); + } else if (zend_str_equals_literal(lcname, "is_string")) { + return zend_compile_func_typecheck(result, args, IS_STRING TSRMLS_CC); + } else if (zend_str_equals_literal(lcname, "is_array")) { + return zend_compile_func_typecheck(result, args, IS_ARRAY TSRMLS_CC); + } else if (zend_str_equals_literal(lcname, "is_object")) { + return zend_compile_func_typecheck(result, args, IS_OBJECT TSRMLS_CC); + } else if (zend_str_equals_literal(lcname, "is_resource")) { + return zend_compile_func_typecheck(result, args, IS_RESOURCE TSRMLS_CC); + } else if (zend_str_equals_literal(lcname, "defined")) { + return zend_compile_func_defined(result, args TSRMLS_CC); + } else if (zend_str_equals_literal(lcname, "call_user_func_array")) { + return zend_compile_func_cufa(result, args, lcname TSRMLS_CC); + } else if (zend_str_equals_literal(lcname, "call_user_func")) { + return zend_compile_func_cuf(result, args, lcname TSRMLS_CC); } else { - SET_UNUSED(opline->op2); + return FAILURE; } - opline->extended_value = is_ref; } -/* }}} */ -void zend_do_end_array(znode *result, const znode *array_node TSRMLS_DC) /* {{{ */ -{ - int next_op_num = get_next_op_number(CG(active_op_array)); - zend_op *init_opline = &CG(active_op_array)->opcodes[array_node->u.op.opline_num]; - zend_op *opline; - int i; - int constant_array = 0; - zval array; - - /* check if constructed array consists only from constants */ - if ((init_opline->op1_type & (IS_UNUSED | IS_CONST)) && - (init_opline->op2_type & (IS_UNUSED | IS_CONST))) { - if (next_op_num == array_node->u.op.opline_num + 1) { - constant_array = 1; - } else if ((init_opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT) == next_op_num - array_node->u.op.opline_num) { - opline = init_opline + 1; - i = next_op_num - array_node->u.op.opline_num - 1; - while (i > 0) { - if (opline->opcode != ZEND_ADD_ARRAY_ELEMENT || - opline->op1_type != IS_CONST || - !(opline->op2_type & (IS_UNUSED | IS_CONST))) { - break; - } - opline++; - i--; - } - if (i == 0) { - constant_array = 1; - } - } +void zend_compile_call(znode *result, zend_ast *ast, int type TSRMLS_DC) { + zend_ast *name_ast = ast->child[0]; + zend_ast *args_ast = ast->child[1]; + + znode name_node; + + 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 TSRMLS_CC); + zend_compile_dynamic_call(result, &name_node, args_ast TSRMLS_CC); + return; } - - if (constant_array) { - /* try to construct constant array */ - uint32_t size; - zend_long num; - zend_string *str; - - if (init_opline->op1_type != IS_UNUSED) { - size = init_opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; - } else { - size = 0; + + { + zend_bool runtime_resolution = zend_compile_function_name(&name_node, name_ast TSRMLS_CC); + if (runtime_resolution) { + zend_compile_ns_call(result, &name_node, args_ast TSRMLS_CC); + return; } - ZVAL_NEW_ARR(&array); - zend_hash_init(Z_ARRVAL(array), size, NULL, ZVAL_PTR_DTOR, 0); + } - if (init_opline->op1_type != IS_UNUSED) { - /* Explicitly initialize array as not-packed if flag is set */ - if (init_opline->extended_value & ZEND_ARRAY_NOT_PACKED) { - zend_hash_real_init(Z_ARRVAL(array), 0); - } + { + zval *name = &name_node.u.constant; + zend_string *lcname = zend_string_alloc(Z_STRLEN_P(name), 0); + zend_function *fbc; + zend_op *opline; - opline = init_opline; - i = next_op_num - array_node->u.op.opline_num; - while (i > 0 && constant_array) { - if (opline->op2_type == IS_CONST) { - switch (Z_TYPE(CONSTANT(opline->op2.constant))) { - case IS_LONG: - num = Z_LVAL(CONSTANT(opline->op2.constant)); -num_index: - zend_hash_index_update(Z_ARRVAL(array), num, &CONSTANT(opline->op1.constant)); - if (Z_REFCOUNTED(CONSTANT(opline->op1.constant))) Z_ADDREF(CONSTANT(opline->op1.constant)); - break; - case IS_STRING: - str = Z_STR(CONSTANT(opline->op2.constant)); -str_index: - zend_hash_update(Z_ARRVAL(array), str, &CONSTANT(opline->op1.constant)); - if (Z_REFCOUNTED(CONSTANT(opline->op1.constant))) Z_ADDREF(CONSTANT(opline->op1.constant)); - break; - case IS_DOUBLE: - num = zend_dval_to_lval(Z_DVAL(CONSTANT(opline->op2.constant))); - goto num_index; - case IS_FALSE: - num = 0; - goto num_index; - case IS_TRUE: - num = 1; - goto num_index; - case IS_NULL: - str = STR_EMPTY_ALLOC(); - goto str_index; - default: - constant_array = 0; - break; - } - } else { - zend_hash_next_index_insert(Z_ARRVAL(array), &CONSTANT(opline->op1.constant)); - if (Z_REFCOUNTED(CONSTANT(opline->op1.constant))) Z_ADDREF(CONSTANT(opline->op1.constant)); - } - opline++; - i--; - } - if (!constant_array) { - zval_dtor(&array); - } + zend_str_tolower_copy(lcname->val, Z_STRVAL_P(name), Z_STRLEN_P(name)); + + 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 TSRMLS_CC); + return; } - } - if (constant_array) { - /* remove run-time array construction and use constant array instead */ - opline = &CG(active_op_array)->opcodes[next_op_num-1]; - while (1) { - if (opline->op2_type == IS_CONST) { - zend_del_literal(CG(active_op_array), opline->op2.constant); - } - if (opline->op1_type == IS_CONST) { - if (Z_TYPE(CONSTANT(opline->op1.constant)) == IS_ARRAY && - Z_REFCOUNTED(CONSTANT(opline->op1.constant)) && - Z_REFCOUNT(CONSTANT(opline->op1.constant)) == 2) { - /* don't delete nested arrays */ - Z_DELREF(CONSTANT(opline->op1.constant)); - ZVAL_UNDEF(&CONSTANT(opline->op1.constant)); - } - zend_del_literal(CG(active_op_array), opline->op1.constant); - } - if (opline == init_opline) { - break; - } - opline--; + if (zend_try_compile_special_func(result, lcname, + zend_ast_get_list(args_ast) TSRMLS_CC) == SUCCESS + ) { + zend_string_release(lcname); + zval_ptr_dtor(&name_node.u.constant); + return; } - CG(active_op_array)->last = array_node->u.op.opline_num; - result->op_type = IS_CONST; - ZVAL_COPY_VALUE(&result->u.constant, &array); - } else { - GET_NODE(result, init_opline->result); + 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 TSRMLS_CC); + zend_alloc_cache_slot(opline->op2.constant TSRMLS_CC); + + zend_compile_call_common(result, args_ast, fbc TSRMLS_CC); } - result->EA = 0; } -/* }}} */ -void zend_do_add_list_element(const znode *element TSRMLS_DC) /* {{{ */ -{ - list_llist_element lle; +void zend_compile_method_call(znode *result, zend_ast *ast, int type TSRMLS_DC) { + zend_ast *obj_ast = ast->child[0]; + zend_ast *method_ast = ast->child[1]; + zend_ast *args_ast = ast->child[2]; - if (element) { - zend_check_writable_variable(element); + znode obj_node, method_node; + zend_op *opline; - lle.var = *element; - zend_llist_copy(&lle.dimensions, &CG(dimension_llist)); - zend_llist_prepend_element(&CG(list_llist), &lle); + if (is_this_fetch(obj_ast)) { + obj_node.op_type = IS_UNUSED; + } else { + zend_compile_var(&obj_node, obj_ast, type TSRMLS_CC); } - (*((int *)CG(dimension_llist).tail->data))++; -} -/* }}} */ -void zend_do_new_list_begin(TSRMLS_D) /* {{{ */ -{ - int current_dimension = 0; - zend_llist_add_element(&CG(dimension_llist), ¤t_dimension); -} -/* }}} */ + zend_compile_expr(&method_node, method_ast TSRMLS_CC); + opline = zend_emit_op(NULL, ZEND_INIT_METHOD_CALL, &obj_node, NULL TSRMLS_CC); + + 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"); + } -void zend_do_new_list_end(TSRMLS_D) /* {{{ */ -{ - zend_llist_remove_tail(&CG(dimension_llist)); - (*((int *)CG(dimension_llist).tail->data))++; + opline->op2_type = IS_CONST; + opline->op2.constant = + zend_add_func_name_literal(CG(active_op_array), &method_node.u.constant TSRMLS_CC); + zend_alloc_polymorphic_cache_slot(opline->op2.constant TSRMLS_CC); + } else { + SET_NODE(opline->op2, &method_node); + } + + zend_compile_call_common(result, args_ast, NULL TSRMLS_CC); } -/* }}} */ -void zend_do_list_init(TSRMLS_D) /* {{{ */ -{ - zend_stack_push(&CG(list_stack), &CG(list_llist)); - zend_stack_push(&CG(list_stack), &CG(dimension_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_bool zend_is_constructor(zend_string *name) { + return zend_str_equals_literal_ci(name, ZEND_CONSTRUCTOR_FUNC_NAME); } -/* }}} */ -void zend_do_list_end(znode *result, znode *expr TSRMLS_DC) /* {{{ */ -{ - zend_llist_element *le; - zend_llist_element *dimension; +void zend_compile_static_call(znode *result, zend_ast *ast, int type TSRMLS_DC) { + zend_ast *class_ast = ast->child[0]; + zend_ast *method_ast = ast->child[1]; + zend_ast *args_ast = ast->child[2]; + + znode class_node, method_node; zend_op *opline; - znode last_container; + zend_ulong extended_value = 0; - 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; + 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 TSRMLS_CC)); + } else { + opline = zend_compile_class_ref(&class_node, class_ast TSRMLS_CC); + extended_value = opline->extended_value; + } + + zend_compile_expr(&method_node, method_ast TSRMLS_CC); + 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 (zend_is_constructor(Z_STR_P(name))) { + zval_ptr_dtor(name); + method_node.op_type = IS_UNUSED; } - ((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; - /* restore previous lists */ - p = zend_stack_top(&CG(list_stack)); - CG(dimension_llist) = *p; - zend_stack_del_top(&CG(list_stack)); - p = zend_stack_top(&CG(list_stack)); - CG(list_llist) = *p; - zend_stack_del_top(&CG(list_stack)); + opline = get_next_op(CG(active_op_array) TSRMLS_CC); + opline->opcode = ZEND_INIT_STATIC_METHOD_CALL; + opline->extended_value = extended_value; + + zend_set_class_name_op1(opline, &class_node TSRMLS_CC); + + if (method_node.op_type == IS_CONST) { + opline->op2_type = IS_CONST; + opline->op2.constant = + zend_add_func_name_literal(CG(active_op_array), &method_node.u.constant TSRMLS_CC); + if (opline->op1_type == IS_CONST) { + zend_alloc_cache_slot(opline->op2.constant TSRMLS_CC); + } else { + zend_alloc_polymorphic_cache_slot(opline->op2.constant TSRMLS_CC); + } + } else { + SET_NODE(opline->op2, &method_node); } + + zend_compile_call_common(result, args_ast, NULL TSRMLS_CC); } -/* }}} */ -void zend_init_list(void *result, void *item TSRMLS_DC) /* {{{ */ -{ - void** list = emalloc(sizeof(void*) * 2); +void zend_compile_new(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *class_ast = ast->child[0]; + zend_ast *args_ast = ast->child[1]; - list[0] = item; - list[1] = NULL; + znode class_node, ctor_result; + zend_op *opline; + uint32_t opnum; - *(void**)result = list; + zend_compile_class_ref(&class_node, class_ast TSRMLS_CC); + + opnum = get_next_op_number(CG(active_op_array)); + opline = zend_emit_op(result, ZEND_NEW, &class_node, NULL TSRMLS_CC); + + zend_compile_call_common(&ctor_result, args_ast, NULL TSRMLS_CC); + zend_do_free(&ctor_result TSRMLS_CC); + + /* 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)); } -/* }}} */ -void zend_add_to_list(void *result, void *item TSRMLS_DC) /* {{{ */ -{ - void** list = *(void**)result; - size_t n = 0; +void zend_compile_clone(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *obj_ast = ast->child[0]; - if (list) { - while (list[n]) { - n++; + znode obj_node; + zend_compile_expr(&obj_node, obj_ast TSRMLS_CC); + + zend_emit_op(result, ZEND_CLONE, &obj_node, NULL TSRMLS_CC); +} + +void zend_compile_global_var(zend_ast *ast TSRMLS_DC) { + zend_ast *var_ast = ast->child[0]; + zend_ast *name_ast = var_ast->child[0]; + + znode name_node, result; + + zend_compile_expr(&name_node, name_ast TSRMLS_CC); + if (name_node.op_type == IS_CONST) { + if (Z_TYPE(name_node.u.constant) != IS_STRING) { + convert_to_string(&name_node.u.constant); } } - list = erealloc(list, sizeof(void*) * (n+2)); + if (zend_try_compile_cv(&result, var_ast TSRMLS_CC) == SUCCESS) { + zend_emit_op(NULL, ZEND_BIND_GLOBAL, &result, &name_node TSRMLS_CC); + } else { + zend_emit_op(&result, ZEND_FETCH_W, &name_node, NULL TSRMLS_CC); - list[n] = item; - list[n+1] = NULL; + // TODO.AST Avoid double fetch + //opline->extended_value = ZEND_FETCH_GLOBAL_LOCK; - *(void**)result = list; + zend_emit_assign_ref_znode(var_ast, &result TSRMLS_CC); + } } -/* }}} */ -void zend_do_fetch_static_variable(znode *varname, znode *static_assignment, int fetch_type TSRMLS_DC) /* {{{ */ -{ - zval tmp; +static void zend_compile_static_var_common( + zend_ast *var_ast, zval *value, zend_bool by_ref TSRMLS_DC +) { + znode var_node, result; zend_op *opline; - znode lval; - znode result; - if (static_assignment) { - ZVAL_COPY_VALUE(&tmp, &static_assignment->u.constant); - } else { - ZVAL_NULL(&tmp); - Z_CONST_FLAGS(tmp) = 0; - } + zend_compile_expr(&var_node, var_ast TSRMLS_CC); + 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; @@ -6561,1402 +4524,3169 @@ void zend_do_fetch_static_variable(znode *varname, znode *static_assignment, int ALLOC_HASHTABLE(CG(active_op_array)->static_variables); zend_hash_init(CG(active_op_array)->static_variables, 8, NULL, ZVAL_PTR_DTOR, 0); } - zend_hash_update(CG(active_op_array)->static_variables, Z_STR(varname->u.constant), &tmp); - if (varname->op_type == IS_CONST) { - if (Z_TYPE(varname->u.constant) != IS_STRING) { - convert_to_string(&varname->u.constant); - } - } + zend_hash_update(CG(active_op_array)->static_variables, Z_STR(var_node.u.constant), value); - 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); - SET_UNUSED(opline->op2); + opline = zend_emit_op(&result, by_ref ? ZEND_FETCH_W : ZEND_FETCH_R, &var_node, NULL TSRMLS_CC); opline->extended_value = ZEND_FETCH_STATIC; - GET_NODE(&result, opline->result); - if (varname->op_type == IS_CONST) { - zval_copy_ctor(&varname->u.constant); + if (by_ref) { + zend_ast *fetch_ast = zend_ast_create(ZEND_AST_VAR, var_ast); + zend_emit_assign_ref_znode(fetch_ast, &result TSRMLS_CC); + } else { + zend_ast *fetch_ast = zend_ast_create(ZEND_AST_VAR, var_ast); + zend_emit_assign_znode(fetch_ast, &result TSRMLS_CC); } - 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; +void zend_compile_static_var(zend_ast *ast TSRMLS_DC) { + zend_ast *var_ast = ast->child[0]; + zend_ast *value_ast = ast->child[1]; + zval value_zv; - zend_do_begin_variable_parse(TSRMLS_C); - zend_do_assign(&dummy, &lval, &result TSRMLS_CC); - zend_do_free(&dummy TSRMLS_CC); + if (value_ast) { + zend_const_expr_to_zval(&value_zv, value_ast TSRMLS_CC); } else { - zend_do_assign_ref(NULL, &lval, &result TSRMLS_CC); + ZVAL_NULL(&value_zv); } - CG(active_op_array)->opcodes[CG(active_op_array)->last-1].result_type |= EXT_TYPE_UNUSED; + + zend_compile_static_var_common(var_ast, &value_zv, 1 TSRMLS_CC); } -/* }}} */ -void zend_do_fetch_lexical_variable(znode *varname, zend_bool is_ref TSRMLS_DC) /* {{{ */ -{ - znode value; +void zend_compile_unset(zend_ast *ast TSRMLS_DC) { + zend_ast *var_ast = ast->child[0]; - 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"); - return; + znode var_node; + zend_op *opline; + switch (var_ast->kind) { + case ZEND_AST_VAR: + if (zend_try_compile_cv(&var_node, var_ast TSRMLS_CC) == SUCCESS) { + opline = zend_emit_op(NULL, ZEND_UNSET_VAR, &var_node, NULL TSRMLS_CC); + opline->extended_value = ZEND_FETCH_LOCAL | ZEND_QUICK_SET; + } else { + opline = zend_compile_simple_var_no_cv(NULL, var_ast, BP_VAR_UNSET TSRMLS_CC); + opline->opcode = ZEND_UNSET_VAR; + } + return; + case ZEND_AST_DIM: + opline = zend_compile_dim_common(NULL, var_ast, BP_VAR_UNSET TSRMLS_CC); + opline->opcode = ZEND_UNSET_DIM; + return; + case ZEND_AST_PROP: + opline = zend_compile_prop_common(NULL, var_ast, BP_VAR_UNSET TSRMLS_CC); + opline->opcode = ZEND_UNSET_OBJ; + return; + case ZEND_AST_STATIC_PROP: + opline = zend_compile_static_prop_common(NULL, var_ast, BP_VAR_UNSET TSRMLS_CC); + opline->opcode = ZEND_UNSET_VAR; + return; + EMPTY_SWITCH_DEFAULT_CASE() } +} + +static void zend_free_foreach_and_switch_variables(TSRMLS_D) { + uint32_t opnum_start, opnum_end, i; + + opnum_start = get_next_op_number(CG(active_op_array)); - value.op_type = IS_CONST; - ZVAL_NULL(&value.u.constant); - Z_CONST_FLAGS(value.u.constant) = is_ref ? IS_LEXICAL_REF : IS_LEXICAL_VAR; - zend_do_fetch_static_variable(varname, &value, is_ref ? ZEND_FETCH_STATIC : ZEND_FETCH_LEXICAL TSRMLS_CC); +#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 + + opnum_end = get_next_op_number(CG(active_op_array)); + + for (i = opnum_start; i < opnum_end; ++i) { + CG(active_op_array)->opcodes[i].extended_value |= EXT_TYPE_FREE_ON_RETURN; + } } -/* }}} */ -void zend_do_fetch_global_variable(znode *varname, const znode *static_assignment, int fetch_type TSRMLS_DC) /* {{{ */ -{ +void zend_compile_return(zend_ast *ast TSRMLS_DC) { + zend_ast *expr_ast = ast->child[0]; + zend_bool by_ref = (CG(active_op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0; + + znode expr_node; zend_op *opline; - znode lval; - znode result; - if (varname->op_type == IS_CONST) { - if (Z_TYPE(varname->u.constant) != IS_STRING) { - convert_to_string(&varname->u.constant); - } + 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 TSRMLS_CC); + } else { + zend_compile_expr(&expr_node, expr_ast TSRMLS_CC); } - opline = get_next_op(CG(active_op_array) TSRMLS_CC); + zend_free_foreach_and_switch_variables(TSRMLS_C); - if (varname->op_type == IS_CONST && - !zend_is_auto_global(Z_STR(varname->u.constant) TSRMLS_CC) && - !(Z_STRLEN(varname->u.constant) == (sizeof("this")-1) && - !memcmp(Z_STRVAL(varname->u.constant), "this", sizeof("this") - 1))) { - opline->opcode = ZEND_BIND_GLOBAL; - SET_NODE(opline->op2, varname); - opline->op1_type = IS_CV; - zval_copy_ctor(&varname->u.constant); - opline->op1.var = lookup_cv(CG(active_op_array), Z_STR(varname->u.constant) TSRMLS_CC); - } else { - 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); - SET_UNUSED(opline->op2); - opline->extended_value = fetch_type; - GET_NODE(&result, opline->result); + if (CG(context).in_finally) { + zend_emit_op(NULL, ZEND_DISCARD_EXCEPTION, NULL, NULL TSRMLS_CC); + } - 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 */ + opline = zend_emit_op(NULL, by_ref ? ZEND_RETURN_BY_REF : ZEND_RETURN, + &expr_node, NULL TSRMLS_CC); - 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 (expr_ast) { + if (zend_is_call(expr_ast)) { + opline->extended_value = ZEND_RETURNS_FUNCTION; + } else if (!zend_is_variable(expr_ast)) { + opline->extended_value = ZEND_RETURNS_VALUE; + } } } -/* }}} */ -void zend_do_cast(znode *result, znode *expr, int type TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); +void zend_compile_echo(zend_ast *ast TSRMLS_DC) { + zend_ast *expr_ast = ast->child[0]; - opline->opcode = ZEND_CAST; - opline->result_type = IS_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); + znode expr_node; + zend_compile_expr(&expr_node, expr_ast TSRMLS_CC); + + zend_emit_op(NULL, ZEND_ECHO, &expr_node, NULL TSRMLS_CC); } -/* }}} */ -void zend_do_include_or_eval(int type, znode *result, znode *op1 TSRMLS_DC) /* {{{ */ -{ - zend_do_extended_fcall_begin(TSRMLS_C); - { - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); +void zend_compile_throw(zend_ast *ast TSRMLS_DC) { + zend_ast *expr_ast = ast->child[0]; - 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); + znode expr_node; + zend_compile_expr(&expr_node, expr_ast TSRMLS_CC); + + zend_emit_op(NULL, ZEND_THROW, &expr_node, NULL TSRMLS_CC); +} + +void zend_compile_break_continue(zend_ast *ast TSRMLS_DC) { + zend_ast *depth_ast = ast->child[0]; + + znode depth_node; + zend_op *opline; + + ZEND_ASSERT(ast->kind == ZEND_AST_BREAK || ast->kind == ZEND_AST_CONTINUE); + + if (depth_ast) { + 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"); + } + + zend_compile_expr(&depth_node, depth_ast TSRMLS_CC); + + if (Z_TYPE(depth_node.u.constant) != IS_LONG || Z_LVAL(depth_node.u.constant) < 1) { + zend_error_noreturn(E_COMPILE_ERROR, "'%s' operator accepts only positive numbers", + ast->kind == ZEND_AST_BREAK ? "break" : "continue"); + } + } else { + depth_node.op_type = IS_CONST; + ZVAL_LONG(&depth_node.u.constant, 1); } - zend_do_extended_fcall_end(TSRMLS_C); + + opline = zend_emit_op(NULL, ast->kind == ZEND_AST_BREAK ? ZEND_BRK : ZEND_CONT, + NULL, &depth_node TSRMLS_CC); + opline->op1.opline_num = CG(context).current_brk_cont; } -/* }}} */ -void zend_do_indirect_references(znode *result, const znode *num_references, znode *variable TSRMLS_DC) /* {{{ */ -{ - int i; +void zend_compile_goto(zend_ast *ast TSRMLS_DC) { + zend_ast *label_ast = ast->child[0]; + znode label_node; + zend_op *opline; - 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_compile_expr(&label_node, label_ast TSRMLS_CC); + opline = zend_emit_op(NULL, ZEND_GOTO, NULL, &label_node TSRMLS_CC); + opline->extended_value = CG(context).current_brk_cont; + zend_resolve_goto_label(CG(active_op_array), opline, 0 TSRMLS_CC); +} + +void zend_compile_label(zend_ast *ast TSRMLS_DC) { + zval *label = zend_ast_get_zval(ast->child[0]); + zend_label dest; + + ZEND_ASSERT(Z_TYPE_P(label) == IS_STRING); + + if (!CG(context).labels) { + ALLOC_HASHTABLE(CG(context).labels); + zend_hash_init(CG(context).labels, 8, NULL, ptr_dtor, 0); } - 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) { - zend_string *key = zend_string_init("this", sizeof("this")-1, 0); - CG(active_op_array)->this_var = lookup_cv(CG(active_op_array), key TSRMLS_CC); + + 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, Z_STR_P(label), &dest, sizeof(zend_label))) { + zend_error_noreturn(E_COMPILE_ERROR, "Label '%s' already defined", Z_STRVAL_P(label)); } } -/* }}} */ -void zend_do_unset(znode *variable TSRMLS_DC) /* {{{ */ -{ - zend_op *last_op; +void zend_compile_while(zend_ast *ast TSRMLS_DC) { + zend_ast *cond_ast = ast->child[0]; + zend_ast *stmt_ast = ast->child[1]; - zend_check_writable_variable(variable); + znode cond_node; + uint32_t opnum_start, 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]; + opnum_start = get_next_op_number(CG(active_op_array)); + zend_compile_expr(&cond_node, cond_ast TSRMLS_CC); - 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; + opnum_jmpz = zend_emit_cond_jump(ZEND_JMPZ, &cond_node, 0 TSRMLS_CC); + zend_begin_loop(TSRMLS_C); - } - } + zend_compile_stmt(stmt_ast TSRMLS_CC); + + zend_emit_jump(opnum_start TSRMLS_CC); + + zend_update_jump_target_to_next(opnum_jmpz TSRMLS_CC); + + zend_end_loop(opnum_start, 0 TSRMLS_CC); } -/* }}} */ -void zend_do_isset_or_isempty(int type, znode *result, znode *variable TSRMLS_DC) /* {{{ */ -{ - zend_op *last_op; +void zend_compile_do_while(zend_ast *ast TSRMLS_DC) { + zend_ast *stmt_ast = ast->child[0]; + zend_ast *cond_ast = ast->child[1]; - zend_do_end_variable_parse(variable, BP_VAR_IS, 0 TSRMLS_CC); + znode cond_node; + uint32_t opnum_start, opnum_cond; - 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)"); - } + zend_begin_loop(TSRMLS_C); - return; - } + opnum_start = get_next_op_number(CG(active_op_array)); + zend_compile_stmt(stmt_ast TSRMLS_CC); - 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_cond = get_next_op_number(CG(active_op_array)); + zend_compile_expr(&cond_node, cond_ast TSRMLS_CC); - 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; - } - } - last_op->result_type = IS_TMP_VAR; - last_op->extended_value |= type; + zend_emit_cond_jump(ZEND_JMPNZ, &cond_node, opnum_start TSRMLS_CC); - GET_NODE(result, last_op->result); + zend_end_loop(opnum_cond, 0 TSRMLS_CC); } -/* }}} */ -void zend_do_instanceof(znode *result, znode *expr, znode *class_znode, int type TSRMLS_DC) /* {{{ */ -{ - int last_op_number = get_next_op_number(CG(active_op_array)); - zend_op *opline; +void zend_compile_expr_list(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast_list *list; + uint32_t i; - 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; - } + result->op_type = IS_CONST; + ZVAL_TRUE(&result->u.constant); + + if (!ast) { + return; } - if (expr->op_type == IS_CONST) { - zend_error_noreturn(E_COMPILE_ERROR, "instanceof expects an object instance, constant given"); + list = zend_ast_get_list(ast); + for (i = 0; i < list->children; ++i) { + zend_ast *expr_ast = list->child[i]; + + zend_do_free(result TSRMLS_CC); + zend_compile_expr(result, expr_ast TSRMLS_CC); } +} - 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_for(zend_ast *ast TSRMLS_DC) { + 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]; - SET_NODE(opline->op2, class_znode); + znode result; + uint32_t opnum_cond, opnum_jmpz, opnum_loop; - GET_NODE(result, opline->result); + zend_compile_expr_list(&result, init_ast TSRMLS_CC); + zend_do_free(&result TSRMLS_CC); + + opnum_cond = get_next_op_number(CG(active_op_array)); + zend_compile_expr_list(&result, cond_ast TSRMLS_CC); + zend_do_extended_info(TSRMLS_C); + + opnum_jmpz = zend_emit_cond_jump(ZEND_JMPZ, &result, 0 TSRMLS_CC); + zend_begin_loop(TSRMLS_C); + + zend_compile_stmt(stmt_ast TSRMLS_CC); + + opnum_loop = get_next_op_number(CG(active_op_array)); + zend_compile_expr_list(&result, loop_ast TSRMLS_CC); + zend_do_free(&result TSRMLS_CC); + + zend_emit_jump(opnum_cond TSRMLS_CC); + + zend_update_jump_target_to_next(opnum_jmpz TSRMLS_CC); + + zend_end_loop(opnum_loop, 0 TSRMLS_CC); } -/* }}} */ -void zend_do_foreach_begin(znode *foreach_token, znode *open_brackets_token, znode *array, znode *as_token, int variable TSRMLS_DC) /* {{{ */ -{ +void zend_compile_foreach(zend_ast *ast TSRMLS_DC) { + 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); + + znode expr_node, reset_node, value_node, key_node, dummy_node; zend_op *opline; - zend_bool is_variable; - zend_op dummy_opline; + uint32_t opnum_reset, opnum_fetch; + zend_op foreach_stack_opline; - if (variable) { - if (zend_is_function_or_method_call(array)) { - is_variable = 0; - } else { - is_variable = 1; + if (key_ast) { + if (key_ast->kind == ZEND_AST_REF) { + zend_error_noreturn(E_COMPILE_ERROR, "Key element cannot be a reference"); + } + if (key_ast->kind == ZEND_AST_LIST) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use list as key element"); } - /* 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); - } else { - is_variable = 0; - open_brackets_token->u.op.opline_num = get_next_op_number(CG(active_op_array)); } - /* save the location of FE_RESET */ - foreach_token->u.op.opline_num = get_next_op_number(CG(active_op_array)); + if (by_ref) { + value_ast = value_ast->child[0]; + } - opline = get_next_op(CG(active_op_array) TSRMLS_CC); + if (by_ref && is_variable) { + zend_compile_var(&expr_node, expr_ast, BP_VAR_W TSRMLS_CC); + } else { + zend_compile_expr(&expr_node, expr_ast TSRMLS_CC); + } - /* 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; + opnum_reset = get_next_op_number(CG(active_op_array)); + opline = zend_emit_op(&reset_node, ZEND_FE_RESET, &expr_node, NULL TSRMLS_CC); + if (by_ref && is_variable) { + opline->extended_value = ZEND_FE_RESET_VARIABLE | ZEND_FE_RESET_REFERENCE; // ??? + } - COPY_NODE(dummy_opline.result, opline->result); - zend_stack_push(&CG(foreach_copy_stack), (void *) &dummy_opline); + SET_NODE(foreach_stack_opline.result, &reset_node); + zend_stack_push(&CG(foreach_copy_stack), &foreach_stack_opline); - /* save the location of FE_FETCH */ - as_token->u.op.opline_num = get_next_op_number(CG(active_op_array)); + opnum_fetch = get_next_op_number(CG(active_op_array)); + opline = zend_emit_op(&value_node, ZEND_FE_FETCH, &reset_node, NULL TSRMLS_CC); + if (by_ref) { + opline->extended_value |= ZEND_FE_FETCH_BYREF; + } + if (key_ast) { + opline->extended_value |= ZEND_FE_FETCH_WITH_KEY; + } - 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); + opline = zend_emit_op(NULL, ZEND_OP_DATA, NULL, NULL TSRMLS_CC); - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_OP_DATA; /* Allocate enough space to keep HashPointer on VM stack */ opline->op1_type = IS_TMP_VAR; opline->op1.var = get_temporary_variable(CG(active_op_array)); if (sizeof(HashPointer) > sizeof(zval)) { - /* Make shure 1 zval is enough for HashPointer (2 must be enough) */ + /* Make sure 1 zval is enough for HashPointer (2 must be enough) */ get_temporary_variable(CG(active_op_array)); } - SET_UNUSED(opline->op2); - SET_UNUSED(opline->result); -} -/* }}} */ -void zend_do_foreach_cont(znode *foreach_token, const znode *open_brackets_token, const znode *as_token, znode *value, znode *key TSRMLS_DC) /* {{{ */ -{ - zend_op *opline; - znode dummy, value_node; - zend_bool assign_by_ref=0; + if (key_ast) { + zend_make_tmp_result(&key_node, opline TSRMLS_CC); + } + + if (value_ast->attr == ZEND_AST_LIST) { + zend_compile_list_assign(&dummy_node, value_ast, &value_node TSRMLS_CC); + zend_do_free(&dummy_node TSRMLS_CC); + } else if (by_ref) { + zend_emit_assign_ref_znode(value_ast, &value_node TSRMLS_CC); + } else { + zend_emit_assign_znode(value_ast, &value_node TSRMLS_CC); + } + + if (key_ast) { + zend_emit_assign_znode(key_ast, &key_node TSRMLS_CC); + } - opline = &CG(active_op_array)->opcodes[as_token->u.op.opline_num]; - if (key->op_type != IS_UNUSED) { - znode *tmp; + zend_begin_loop(TSRMLS_C); - /* switch between the key and value... */ - tmp = key; - key = value; - value = tmp; + zend_compile_stmt(stmt_ast TSRMLS_CC); - /* Mark extended_value in case both key and value are being used */ - opline->extended_value |= ZEND_FE_FETCH_WITH_KEY; + zend_emit_jump(opnum_fetch TSRMLS_CC); + + opline = &CG(active_op_array)->opcodes[opnum_reset]; + opline->op2.opline_num = get_next_op_number(CG(active_op_array)); + + opline = &CG(active_op_array)->opcodes[opnum_fetch]; + opline->op2.opline_num = get_next_op_number(CG(active_op_array)); + + zend_end_loop(opnum_fetch, 1 TSRMLS_CC); + + { + zend_op *container_ptr = zend_stack_top(&CG(foreach_copy_stack)); + generate_free_foreach_copy(container_ptr TSRMLS_CC); + zend_stack_del_top(&CG(foreach_copy_stack)); } +} - 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"); +void zend_compile_if(zend_ast *ast TSRMLS_DC) { + zend_ast_list *list = zend_ast_get_list(ast); + uint32_t i; + uint32_t *jmp_opnums = safe_emalloc(sizeof(uint32_t), list->children - 1, 0); + + 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 TSRMLS_CC); + opnum_jmpz = zend_emit_cond_jump(ZEND_JMPZ, &cond_node, 0 TSRMLS_CC); } - if (key->EA & ZEND_PARSED_LIST_EXPR) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use list as key element"); + + zend_compile_stmt(stmt_ast TSRMLS_CC); + + if (i != list->children - 1) { + jmp_opnums[i] = zend_emit_jump(0 TSRMLS_CC); + } + + if (cond_ast) { + zend_update_jump_target_to_next(opnum_jmpz TSRMLS_CC); } } - if (value->EA & ZEND_PARSED_REFERENCE_VARIABLE) { - assign_by_ref = 1; + for (i = 0; i < list->children - 1; ++i) { + zend_update_jump_target_to_next(jmp_opnums[i] TSRMLS_CC); + } - /* 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 */ - } + efree(jmp_opnums); +} + +void zend_compile_switch(zend_ast *ast TSRMLS_DC) { + zend_ast *expr_ast = ast->child[0]; + zend_ast_list *cases = zend_ast_get_list(ast->child[1]); + + uint32_t i; + zend_bool has_default_case = 0; + zend_switch_entry switch_entry; + + 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; + + zend_compile_expr(&expr_node, expr_ast TSRMLS_CC); + + switch_entry.cond = expr_node; + switch_entry.default_case = -1; + switch_entry.control_var = -1; + zend_stack_push(&CG(switch_cond_stack), (void *) &switch_entry); + + zend_begin_loop(TSRMLS_C); + + 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) { + has_default_case = 1; + continue; } - } - GET_NODE(&value_node, opline->result); + zend_compile_expr(&cond_node, cond_ast TSRMLS_CC); - if (value->EA & ZEND_PARSED_LIST_EXPR) { - if (!CG(list_llist).head) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use empty list"); + opline = zend_emit_op(NULL, ZEND_CASE, &expr_node, &cond_node TSRMLS_CC); + SET_NODE(opline->result, &case_node); + if (opline->op1_type == IS_CONST) { + zval_copy_ctor(&CONSTANT(opline->op1.constant)); } - 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); + + jmpnz_opnums[i] = zend_emit_cond_jump(ZEND_JMPNZ, &case_node, 0 TSRMLS_CC); + } + + opnum_default_jmp = zend_emit_jump(0 TSRMLS_CC); + + 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 (cond_ast) { + zend_update_jump_target_to_next(jmpnz_opnums[i] TSRMLS_CC); } else { - zend_do_assign(&dummy, value, &value_node TSRMLS_CC); - zend_do_free(&dummy TSRMLS_CC); + zend_update_jump_target_to_next(opnum_default_jmp TSRMLS_CC); } + + zend_compile_stmt(stmt_ast TSRMLS_CC); } - if (key->op_type != IS_UNUSED) { - znode key_node; + if (!has_default_case) { + zend_update_jump_target_to_next(opnum_default_jmp TSRMLS_CC); + } - 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_end_loop(get_next_op_number(CG(active_op_array)), 1 TSRMLS_CC); - zend_do_assign(&dummy, key, &key_node TSRMLS_CC); - zend_do_free(&dummy TSRMLS_CC); + if (expr_node.op_type == IS_VAR || expr_node.op_type == IS_TMP_VAR) { + zend_emit_op(NULL, expr_node.op_type == IS_TMP_VAR ? ZEND_FREE : ZEND_SWITCH_FREE, + &expr_node, NULL TSRMLS_CC); + } else if (expr_node.op_type == IS_CONST) { + zval_dtor(&expr_node.u.constant); } - do_begin_loop(TSRMLS_C); - INC_BPC(CG(active_op_array)); + zend_stack_del_top(&CG(switch_cond_stack)); + efree(jmpnz_opnums); } -/* }}} */ -void zend_do_foreach_end(const znode *foreach_token, const znode *as_token TSRMLS_DC) /* {{{ */ -{ - zend_op *container_ptr; - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); +void zend_compile_try(zend_ast *ast TSRMLS_DC) { + 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]; - opline->opcode = ZEND_JMP; - opline->op1.opline_num = as_token->u.op.opline_num; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); + uint32_t i; + zend_op *opline; + uint32_t try_catch_offset = zend_add_try_element( + get_next_op_number(CG(active_op_array)) TSRMLS_CC); + uint32_t *jmp_opnums = safe_emalloc(sizeof(uint32_t), catches->children, 0); + + if (catches->children == 0 && !finally_ast) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use try without catch or finally"); + } - 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_stmt(try_ast TSRMLS_CC); - do_end_loop(as_token->u.op.opline_num, 1 TSRMLS_CC); + if (catches->children != 0) { + jmp_opnums[0] = zend_emit_jump(0 TSRMLS_CC); + } - container_ptr = zend_stack_top(&CG(foreach_copy_stack)); - generate_free_foreach_copy(container_ptr TSRMLS_CC); - zend_stack_del_top(&CG(foreach_copy_stack)); + 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); + + 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"); + } + + 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; + } + + CG(zend_lineno) = catch_ast->lineno; + + opline = get_next_op(CG(active_op_array) TSRMLS_CC); + 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 TSRMLS_CC) TSRMLS_CC); + + opline->op2_type = IS_CV; + opline->op2.var = lookup_cv(CG(active_op_array), zend_string_copy(Z_STR_P(var_name)) TSRMLS_CC); + opline->result.num = is_last_catch; + + zend_compile_stmt(stmt_ast TSRMLS_CC); - DEC_BPC(CG(active_op_array)); + if (!is_last_catch) { + jmp_opnums[i + 1] = zend_emit_jump(0 TSRMLS_CC); + } + + opline = &CG(active_op_array)->opcodes[opnum_catch]; + opline->extended_value = get_next_op_number(CG(active_op_array)); + } + + for (i = 0; i < catches->children; ++i) { + zend_update_jump_target_to_next(jmp_opnums[i] TSRMLS_CC); + } + + if (finally_ast) { + uint32_t opnum_jmp = get_next_op_number(CG(active_op_array)) + 1; + + opline = zend_emit_op(NULL, ZEND_FAST_CALL, NULL, NULL TSRMLS_CC); + opline->op1.opline_num = opnum_jmp + 1; + + zend_emit_op(NULL, ZEND_JMP, NULL, NULL TSRMLS_CC); + + CG(context).in_finally++; + zend_compile_stmt(finally_ast TSRMLS_CC); + 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)); + CG(active_op_array)->has_finally_block = 1; + + zend_emit_op(NULL, ZEND_FAST_RET, NULL, NULL TSRMLS_CC); + + zend_update_jump_target_to_next(opnum_jmp TSRMLS_CC); + } + + efree(jmp_opnums); } -/* }}} */ -void zend_do_declare_begin(TSRMLS_D) /* {{{ */ -{ - zend_stack_push(&CG(declare_stack), &CG(declarables)); +/* Encoding declarations must already be handled during parsing */ +void zend_handle_encoding_declaration(zend_ast_list *declares TSRMLS_DC) { + 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); + + if (zend_str_equals_literal_ci(name, "encoding")) { + if (value_ast->kind != ZEND_AST_ZVAL) { + zend_error_noreturn(E_COMPILE_ERROR, "Encoding must be a literal"); + } + + if (CG(multibyte)) { + zend_string *encoding_name = zval_get_string(zend_ast_get_zval(value_ast)); + + const zend_encoding *new_encoding, *old_encoding; + zend_encoding_filter old_input_filter; + + CG(encoding_declared) = 1; + + new_encoding = zend_multibyte_fetch_encoding(encoding_name->val TSRMLS_CC); + if (!new_encoding) { + zend_error(E_COMPILE_WARNING, "Unsupported encoding [%s]", encoding_name->val); + } 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); + } + } + + zend_string_release(encoding_name); + } else { + zend_error(E_COMPILE_WARNING, "declare(encoding=...) ignored because " + "Zend multibyte feature is turned off by settings"); + } + } + } } -/* }}} */ -void zend_do_declare_stmt(znode *var, znode *val TSRMLS_DC) /* {{{ */ -{ - 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) { - 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 */ +void zend_compile_declare(zend_ast *ast TSRMLS_DC) { + zend_ast_list *declares = zend_ast_get_list(ast->child[0]); + zend_ast *stmt_ast = ast->child[1]; + zend_declarables orig_declarables = CG(declarables); + 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); + if (zend_str_equals_literal_ci(name, "ticks")) { + zval value_zv; + zend_const_expr_to_zval(&value_zv, value_ast TSRMLS_CC); + convert_to_long(&value_zv); + ZVAL_COPY_VALUE(&CG(declarables).ticks, &value_zv); + zval_dtor(&value_zv); + } else if (zend_str_equals_literal_ci(name, "encoding")) { + /* Encoding declaration was already handled during parsing. Here we + * only check that it is the first statement in the file. */ + 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)) { + (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, "Encoding declaration pragma must be the very first statement in the script"); + zend_error_noreturn(E_COMPILE_ERROR, "Encoding declaration pragma must be " + "the very first statement in the script"); + } + } else { + zend_error(E_COMPILE_WARNING, "Unsupported declare '%s'", name->val); + } + } + + if (stmt_ast) { + zend_compile_stmt(stmt_ast TSRMLS_CC); + + CG(declarables) = orig_declarables; + } +} + +void zend_compile_stmt_list(zend_ast *ast TSRMLS_DC) { + 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] TSRMLS_CC); + } +} + +void zend_compile_params(zend_ast *ast TSRMLS_DC) { + 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 (list->children == 0) { + return; + } + + arg_infos = safe_emalloc(sizeof(zend_arg_info), list->children, 0); + 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; + + znode var_node, default_node; + zend_uchar opcode; + zend_op *opline; + zend_arg_info *arg_info; + + if (zend_is_auto_global(name TSRMLS_CC)) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign auto-global variable %s", + name->val); + } + + var_node.op_type = IS_CV; + var_node.u.op.var = lookup_cv(CG(active_op_array), zend_string_copy(name) TSRMLS_CC); + + if (EX_VAR_TO_NUM(var_node.u.op.var) != i) { + zend_error_noreturn(E_COMPILE_ERROR, "Redefinition of parameter $%s", + name->val); + } else if (zend_str_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 (CG(multibyte)) { - const zend_encoding *new_encoding, *old_encoding; - zend_encoding_filter old_input_filter; + if (op_array->fn_flags & ZEND_ACC_VARIADIC) { + zend_error_noreturn(E_COMPILE_ERROR, "Only the last parameter can be variadic"); + } - CG(encoding_declared) = 1; + if (is_variadic) { + opcode = ZEND_RECV_VARIADIC; + default_node.op_type = IS_UNUSED; + op_array->fn_flags |= ZEND_ACC_VARIADIC; - 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)); + if (default_ast) { + zend_error_noreturn(E_COMPILE_ERROR, + "Variadic parameter cannot have a default value"); + } + } else if (default_ast) { + opcode = ZEND_RECV_INIT; + default_node.op_type = IS_CONST; + zend_const_expr_to_zval(&default_node.u.constant, default_ast TSRMLS_CC); + } 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 TSRMLS_CC); + SET_NODE(opline->result, &var_node); + opline->op1.num = i + 1; + + arg_info = &arg_infos[i]; + arg_info->name = estrndup(name->val, name->len); + arg_info->name_len = name->len; + 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; + arg_info->class_name_len = 0; + + 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")) + || Z_TYPE(default_node.u.constant) == IS_CONSTANT_AST); // ??? + + op_array->fn_flags |= ZEND_ACC_HAS_TYPE_HINTS; + arg_info->allow_null = has_null_default; + + if (type_ast->kind == ZEND_AST_TYPE) { + arg_info->type_hint = type_ast->attr; + if (arg_info->type_hint == IS_ARRAY) { + if (default_ast && !has_null_default + && Z_TYPE(default_node.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 (arg_info->type_hint == IS_CALLABLE && default_ast) { + if (default_ast && !has_null_default) { + zend_error_noreturn(E_COMPILE_ERROR, "Default value for parameters " + "with callable type hint can only be NULL"); + } + } } 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); + zend_string *class_name = zend_ast_get_str(type_ast); + + if (zend_is_const_default_class_ref(type_ast)) { + class_name = zend_resolve_class_name_ast(type_ast TSRMLS_CC); + } else { + zend_string_addref(class_name); + } + + arg_info->type_hint = IS_OBJECT; + arg_info->class_name = estrndup(class_name->val, class_name->len); + arg_info->class_name_len = class_name->len; + + zend_string_release(class_name); + + if (default_ast && !has_null_default) { + zend_error_noreturn(E_COMPILE_ERROR, "Default value for parameters " + "with a class type hint can only be NULL"); } } - } 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); + + /* 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; } -/* }}} */ -void zend_do_declare_end(const znode *declare_token TSRMLS_DC) /* {{{ */ -{ - zend_declarables *declarables = zend_stack_top(&CG(declare_stack)); - /* 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; +void zend_compile_closure_uses(zend_ast *ast TSRMLS_DC) { + 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; + + if (zend_str_equals_literal(name, "this")) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use $this as lexical variable"); + } + + 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 TSRMLS_CC); } } -/* }}} */ -void zend_do_exit(znode *result, znode *message TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); +void zend_begin_method_decl( + zend_op_array *op_array, zend_string *name, zend_bool has_body TSRMLS_DC +) { + zend_class_entry *ce = CG(active_class_entry); + zend_bool in_interface = (ce->ce_flags & ZEND_ACC_INTERFACE) != 0; + zend_bool in_trait = ZEND_CE_IS_TRAIT(ce); + zend_bool is_public = (op_array->fn_flags & ZEND_ACC_PUBLIC) != 0; + zend_bool is_static = (op_array->fn_flags & ZEND_ACC_STATIC) != 0; - opline->opcode = ZEND_EXIT; - SET_NODE(opline->op1, message); - SET_UNUSED(opline->op2); + zend_string *lcname; - result->op_type = IS_CONST; - ZVAL_BOOL(&result->u.constant, 1); -} -/* }}} */ + 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", ce->name->val, name->val); + } + op_array->fn_flags |= ZEND_ACC_ABSTRACT; + } else if (is_static && (op_array->fn_flags & ZEND_ACC_ABSTRACT)) { + zend_error(E_STRICT, "Static function %s::%s() should not be abstract", + ce->name->val, name->val); + } -void zend_do_begin_silence(znode *strudel_token TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + if (op_array->fn_flags & ZEND_ACC_ABSTRACT) { + //zend_op *opline; - 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); -} -/* }}} */ + 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", ce->name->val, name->val); + } -void zend_do_end_silence(znode *strudel_token TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + if (has_body) { + zend_error_noreturn(E_COMPILE_ERROR, "%s function %s::%s() cannot contain body", + in_interface ? "Interface" : "Abstract", ce->name->val, name->val); + } - opline->opcode = ZEND_END_SILENCE; - SET_NODE(opline->op1, strudel_token); - SET_UNUSED(opline->op2); -} -/* }}} */ + ce->ce_flags |= ZEND_ACC_IMPLICIT_ABSTRACT_CLASS; -void zend_do_jmp_set(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); + /*opline = get_next_op(op_array TSRMLS_CC); + opline->opcode = ZEND_RAISE_ABSTRACT_ERROR; + SET_UNUSED(opline->op1); + SET_UNUSED(opline->op2);*/ + } else if (!has_body) { + zend_error_noreturn(E_COMPILE_ERROR, "Non-abstract method %s::%s() must contain body", + ce->name->val, name->val); + } - if (value->op_type == IS_VAR || value->op_type == IS_CV) { - opline->opcode = ZEND_JMP_SET_VAR; - opline->result_type = IS_VAR; + op_array->scope = ce; + op_array->function_name = zend_string_copy(name); + + lcname = zend_string_alloc(name->len, 0); + zend_str_tolower_copy(lcname->val, name->val, name->len); + lcname = zend_new_interned_string(lcname TSRMLS_CC); + + if (zend_hash_add_ptr(&ce->function_table, lcname, op_array) == NULL) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare %s::%s()", + ce->name->val, name->val); + } + + if (in_interface) { + if (zend_str_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_str_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_str_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_str_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_str_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_str_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_str_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_str_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_str_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"); + } + } } else { - opline->opcode = ZEND_JMP_SET; - opline->result_type = IS_TMP_VAR; + if (!in_trait && zend_str_equals_str_ci(lcname, ce->name)) { + if (!ce->constructor) { + ce->constructor = (zend_function *) op_array; + } + } else if (zend_str_equals_literal(lcname, ZEND_CONSTRUCTOR_FUNC_NAME)) { + if (CG(active_class_entry)->constructor) { + zend_error(E_STRICT, "Redefining already defined constructor for class %s", + ce->name->val); + } + ce->constructor = (zend_function *) op_array; + } else if (zend_str_equals_literal(lcname, ZEND_DESTRUCTOR_FUNC_NAME)) { + ce->destructor = (zend_function *) op_array; + } else if (zend_str_equals_literal(lcname, ZEND_CLONE_FUNC_NAME)) { + ce->clone = (zend_function *) op_array; + } else if (zend_str_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_str_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_str_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; + } else if (zend_str_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; + } else if (zend_str_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; + } else if (zend_str_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; + } else if (zend_str_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_str_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_str_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; + } } - 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); + zend_string_release(lcname); +} - jmp_token->u.op.opline_num = op_number; +static void zend_begin_func_decl( + znode *result, zend_op_array *op_array, zend_ast_decl *decl TSRMLS_DC +) { + zend_ast *params_ast = decl->child[0]; + zend_string *name = decl->name, *lcname; + zend_op *opline; - INC_BPC(CG(active_op_array)); -} -/* }}} */ + op_array->function_name = name = zend_prefix_with_ns(name TSRMLS_CC); -void zend_do_jmp_set_else(znode *result, znode *false_value, const znode *jmp_token, znode *colon_token TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + lcname = zend_string_alloc(name->len, 0); + zend_str_tolower_copy(lcname->val, name->val, name->len); - 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; + if (CG(current_import_function)) { + zend_string *import_name = zend_hash_find_ptr(CG(current_import_function), lcname); + if (import_name && !zend_str_equals_str_ci(lcname, import_name)) { + zend_error(E_COMPILE_ERROR, "Cannot declare function %s " + "because the name is already in use", name->val); } + } + + if (zend_str_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 TSRMLS_CC); } else { - opline->opcode = ZEND_QM_ASSIGN_VAR; + opline = get_next_op(CG(active_op_array) TSRMLS_CC); + opline->opcode = ZEND_DECLARE_FUNCTION; + opline->op2_type = IS_CONST; + LITERAL_STR(opline->op2, zend_string_copy(lcname)); } - opline->extended_value = 0; - SET_NODE(opline->op1, false_value); - SET_UNUSED(opline->op2); - GET_NODE(result, opline->result); + { + zend_string *key = zend_build_runtime_definition_key(lcname, decl->lex_pos TSRMLS_CC); + + opline->op1_type = IS_CONST; + LITERAL_STR(opline->op1, key); - CG(active_op_array)->opcodes[jmp_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array)); + zend_hash_update_ptr(CG(function_table), key, op_array); + } - DEC_BPC(CG(active_op_array)); + zend_string_release(lcname); } -/* }}} */ -void zend_do_begin_qm_op(znode *cond, znode *qm_token TSRMLS_DC) /* {{{ */ -{ - int jmpz_op_number = get_next_op_number(CG(active_op_array)); - zend_op *opline; +void zend_compile_func_decl(znode *result, zend_ast *ast TSRMLS_DC) { + 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_bool is_method = decl->kind == ZEND_AST_METHOD; - opline = get_next_op(CG(active_op_array) TSRMLS_CC); + zend_op_array *orig_op_array = CG(active_op_array); + zend_op_array *op_array = zend_arena_alloc(&CG(arena), sizeof(zend_op_array)); - 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); + // TODO.AST interactive (not just here - also bpc etc!) + + init_op_array(op_array, ZEND_USER_FUNCTION, INITIAL_OP_ARRAY_SIZE TSRMLS_CC); - INC_BPC(CG(active_op_array)); -} -/* }}} */ + 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; + } -void zend_do_qm_true(znode *true_value, znode *qm_token, znode *colon_token TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + if (is_method) { + zend_bool has_body = stmt_ast != NULL; + zend_begin_method_decl(op_array, decl->name, has_body TSRMLS_CC); + } else { + zend_begin_func_decl(result, op_array, decl TSRMLS_CC); + } - 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 */ + CG(active_op_array) = op_array; + zend_stack_push(&CG(context_stack), (void *) &CG(context)); + zend_init_compiler_context(TSRMLS_C); - 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; + if (CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO) { + zend_op *opline_ext = zend_emit_op(NULL, ZEND_EXT_NOP, NULL, NULL TSRMLS_CC); + opline_ext->lineno = decl->start_lineno; } - 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)); + { + /* 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; - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_JMP; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); + zend_stack_push(&CG(switch_cond_stack), (void *) &switch_entry); + } + + { + /* 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); + } + + zend_compile_params(params_ast TSRMLS_CC); + if (uses_ast) { + zend_compile_closure_uses(uses_ast TSRMLS_CC); + } + zend_compile_stmt(stmt_ast TSRMLS_CC); + + if (is_method) { + zend_check_magic_method_implementation( + CG(active_class_entry), (zend_function *) op_array, E_COMPILE_ERROR TSRMLS_CC); + } + + zend_do_extended_info(TSRMLS_C); + zend_emit_final_return(NULL TSRMLS_CC); + + pass_two(CG(active_op_array) TSRMLS_CC); + zend_release_labels(0 TSRMLS_CC); + + /* Pop the switch and foreach separators */ + zend_stack_del_top(&CG(switch_cond_stack)); + zend_stack_del_top(&CG(foreach_copy_stack)); + + CG(active_op_array) = orig_op_array; } -/* }}} */ -void zend_do_qm_false(znode *result, znode *false_value, znode *qm_token, const znode *colon_token TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); +void zend_compile_prop_decl(zend_ast *ast TSRMLS_DC) { + 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; + + if (ce->ce_flags & ZEND_ACC_INTERFACE) { + zend_error_noreturn(E_COMPILE_ERROR, "Interfaces may not include member variables"); + } + + if (flags & ZEND_ACC_ABSTRACT) { + zend_error_noreturn(E_COMPILE_ERROR, "Properties cannot be declared abstract"); + } + + /* 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->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; + 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; + + 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", + ce->name->val, name->val); + } + + if (zend_hash_exists(&ce->properties_info, name)) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare %s::$%s", + ce->name->val, name->val); + } + + if (value_ast) { + zend_const_expr_to_zval(&value_zv, value_ast TSRMLS_CC); } else { - opline->opcode = ZEND_QM_ASSIGN; + ZVAL_NULL(&value_zv); } + + name = zend_new_interned_string_safe(name TSRMLS_CC); + zend_declare_property_ex(ce, name, &value_zv, flags, doc_comment TSRMLS_CC); + + /* Doc comment is only assigned to first property */ + doc_comment = NULL; + } +} + +void zend_compile_class_const_decl(zend_ast *ast TSRMLS_DC) { + zend_ast_list *list = zend_ast_get_list(ast); + zend_class_entry *ce = CG(active_class_entry); + 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); + zval value_zv; + + if (ZEND_CE_IS_TRAIT(ce)) { + zend_error_noreturn(E_COMPILE_ERROR, "Traits cannot have constants"); + return; + } + + zend_const_expr_to_zval(&value_zv, value_ast TSRMLS_CC); + + name = zend_new_interned_string_safe(name TSRMLS_CC); + if (zend_hash_add(&ce->constants_table, name, &value_zv) == NULL) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot redefine class constant %s::%s", + ce->name->val, name->val); + } + + if (Z_CONSTANT(value_zv)) { + ce->ce_flags &= ~ZEND_ACC_CONSTANTS_UPDATED; + } + } +} + +static zend_trait_method_reference *zend_compile_method_ref(zend_ast *ast TSRMLS_DC) { + zend_ast *class_ast = ast->child[0]; + zend_ast *method_ast = ast->child[1]; + + 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)); + + if (class_ast) { + method_ref->class_name = zend_resolve_class_name_ast(class_ast TSRMLS_CC); } else { - opline->opcode = ZEND_QM_ASSIGN_VAR; + method_ref->class_name = NULL; } - 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)); + return method_ref; +} - GET_NODE(result, opline->result); +static zend_string **zend_compile_name_list(zend_ast *ast TSRMLS_DC) { + zend_ast_list *list = zend_ast_get_list(ast); + zend_string **names = safe_emalloc(sizeof(zend_string *), list->children + 1, 0); + uint32_t i; + + for (i = 0; i < list->children; ++i) { + zend_ast *name_ast = list->child[i]; + names[i] = zend_resolve_class_name_ast(name_ast TSRMLS_CC); + } + + names[list->children] = NULL; - DEC_BPC(CG(active_op_array)); + return names; } -/* }}} */ -void zend_do_extended_info(TSRMLS_D) /* {{{ */ -{ - zend_op *opline; +static void zend_compile_trait_precedence(zend_ast *ast TSRMLS_DC) { + zend_ast *method_ref_ast = ast->child[0]; + zend_ast *insteadof_ast = ast->child[1]; + + zend_trait_precedence *precedence = emalloc(sizeof(zend_trait_precedence)); + precedence->trait_method = zend_compile_method_ref(method_ref_ast TSRMLS_CC); + precedence->exclude_from_classes + = (void *) zend_compile_name_list(insteadof_ast TSRMLS_CC); - if (!(CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO)) { - return; + zend_add_to_list(&CG(active_class_entry)->trait_precedences, precedence TSRMLS_CC); +} + +static void zend_compile_trait_alias(zend_ast *ast TSRMLS_DC) { + zend_ast *method_ref_ast = ast->child[0]; + zend_ast *alias_ast = ast->child[1]; + uint32_t modifiers = ast->attr; + + zend_trait_alias *alias; + + 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"); } - opline = get_next_op(CG(active_op_array) TSRMLS_CC); + alias = emalloc(sizeof(zend_trait_alias)); + alias->trait_method = zend_compile_method_ref(method_ref_ast TSRMLS_CC); + alias->modifiers = modifiers; - opline->opcode = ZEND_EXT_STMT; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); + if (alias_ast) { + alias->alias = zend_string_copy(zend_ast_get_str(alias_ast)); + } else { + alias->alias = NULL; + } + + zend_add_to_list(&CG(active_class_entry)->trait_aliases, alias TSRMLS_CC); } -/* }}} */ -void zend_do_extended_fcall_begin(TSRMLS_D) /* {{{ */ -{ +void zend_compile_use_trait(zend_ast *ast TSRMLS_DC) { + 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; - if (!(CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO)) { + for (i = 0; i < traits->children; ++i) { + zend_ast *trait_ast = traits->child[i]; + zend_string *name = zend_ast_get_str(trait_ast); + + if (ce->ce_flags & ZEND_ACC_INTERFACE) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use traits inside of interfaces. " + "%s is used in %s", name->val, ce->name->val); + } + + 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", name->val); + break; + } + + opline = get_next_op(CG(active_op_array) TSRMLS_CC); + opline->opcode = ZEND_ADD_TRAIT; + SET_NODE(opline->op1, &CG(implementing_class)); + opline->extended_value = ZEND_FETCH_CLASS_TRAIT; + opline->op2_type = IS_CONST; + opline->op2.constant = zend_add_class_name_literal(CG(active_op_array), + zend_resolve_class_name_ast(trait_ast TSRMLS_CC) TSRMLS_CC); + + ce->num_traits++; + } + + if (!adaptations) { return; } - opline = get_next_op(CG(active_op_array) TSRMLS_CC); + 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 TSRMLS_CC); + break; + case ZEND_AST_TRAIT_ALIAS: + zend_compile_trait_alias(adaptation_ast TSRMLS_CC); + break; + EMPTY_SWITCH_DEFAULT_CASE() + } + } +} - opline->opcode = ZEND_EXT_FCALL_BEGIN; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); +void zend_compile_implements(znode *class_node, zend_ast *ast TSRMLS_DC) { + 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); + + zend_op *opline; + + /* Traits can not implement interfaces */ + if (ZEND_CE_IS_TRAIT(CG(active_class_entry))) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as interface on '%s' " + "since it is a Trait", name->val, CG(active_class_entry)->name->val); + } + + 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", name->val); + } + + opline = zend_emit_op(NULL, ZEND_ADD_INTERFACE, class_node, NULL TSRMLS_CC); + opline->extended_value = ZEND_FETCH_CLASS_INTERFACE; + opline->op2_type = IS_CONST; + opline->op2.constant = zend_add_class_name_literal(CG(active_op_array), + zend_resolve_class_name_ast(class_ast TSRMLS_CC) TSRMLS_CC); + + CG(active_class_entry)->num_interfaces++; + } } -/* }}} */ -void zend_do_extended_fcall_end(TSRMLS_D) /* {{{ */ -{ +void zend_compile_class_decl(zend_ast *ast TSRMLS_DC) { + 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 = decl->name, *lcname, *import_name = NULL; + zend_class_entry *ce = zend_arena_alloc(&CG(arena), sizeof(zend_class_entry)); zend_op *opline; + znode declare_node, extends_node; - if (!(CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO)) { + if (CG(active_class_entry)) { + zend_error_noreturn(E_COMPILE_ERROR, "Class declarations may not be nested"); return; } - opline = get_next_op(CG(active_op_array) TSRMLS_CC); + if (ZEND_FETCH_CLASS_DEFAULT != zend_get_class_fetch_type(name)) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as class name as it is reserved", + name->val); + } - opline->opcode = ZEND_EXT_FCALL_END; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); -} -/* }}} */ + lcname = zend_string_alloc(name->len, 0); + zend_str_tolower_copy(lcname->val, name->val, name->len); -void zend_do_ticks(TSRMLS_D) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + if (CG(current_import)) { + import_name = zend_hash_find_ptr(CG(current_import), lcname); + } - opline->opcode = ZEND_TICKS; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); - opline->extended_value = Z_LVAL(CG(declarables).ticks); -} -/* }}} */ + if (CG(current_namespace)) { + name = zend_prefix_with_ns(name TSRMLS_CC); -zend_bool zend_is_auto_global(zend_string *name TSRMLS_DC) /* {{{ */ -{ - zend_auto_global *auto_global; + zend_string_release(lcname); + lcname = zend_string_alloc(name->len, 0); + zend_str_tolower_copy(lcname->val, name->val, name->len); + } else { + zend_string_addref(name); + } - 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 TSRMLS_CC); + if (import_name && !zend_str_equals_str_ci(lcname, import_name)) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot declare class %s " + "because the name is already in use", name->val); + } + + name = zend_new_interned_string(name TSRMLS_CC); + lcname = zend_new_interned_string(lcname TSRMLS_CC); + + ce->type = ZEND_USER_CLASS; + ce->name = name; + zend_initialize_class_data(ce, 1 TSRMLS_CC); + + ce->ce_flags |= decl->flags; + ce->info.user.filename = zend_get_compiled_filename(TSRMLS_C); + ce->info.user.line_start = decl->start_lineno; + ce->info.user.line_end = decl->end_lineno; + if (decl->doc_comment) { + ce->info.user.doc_comment = zend_string_copy(decl->doc_comment); + } + + if (extends_ast) { + if (ZEND_CE_IS_TRAIT(ce)) { + 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", + name->val); } - return 1; + + 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", extends_name->val); + } + + zend_compile_class_ref(&extends_node, extends_ast TSRMLS_CC); } - return 0; -} -/* }}} */ -int zend_register_auto_global(zend_string *name, zend_bool jit, zend_auto_global_callback auto_global_callback TSRMLS_DC) /* {{{ */ -{ - zend_auto_global auto_global; - int retval; + opline = get_next_op(CG(active_op_array) TSRMLS_CC); + zend_make_var_result(&declare_node, opline TSRMLS_CC); - auto_global.name = zend_new_interned_string(name TSRMLS_CC); - auto_global.auto_global_callback = auto_global_callback; - auto_global.jit = jit; + // TODO.AST drop this + GET_NODE(&CG(implementing_class), opline->result); - retval = zend_hash_add_mem(CG(auto_globals), name, &auto_global, sizeof(zend_auto_global)) != NULL ? SUCCESS : FAILURE; + opline->op2_type = IS_CONST; + LITERAL_STR(opline->op2, lcname); - zend_string_release(auto_global.name); - return retval; -} -/* }}} */ + if (extends_ast) { + opline->opcode = ZEND_DECLARE_INHERITED_CLASS; + opline->extended_value = extends_node.u.op.var; + } else { + opline->opcode = ZEND_DECLARE_CLASS; + } -ZEND_API void zend_activate_auto_globals(TSRMLS_D) /* {{{ */ -{ - zend_auto_global *auto_global; + { + zend_string *key = zend_build_runtime_definition_key(lcname, decl->lex_pos TSRMLS_CC); - 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 TSRMLS_CC); - } else { - auto_global->armed = 0; + opline->op1_type = IS_CONST; + LITERAL_STR(opline->op1, key); + + zend_hash_update_ptr(CG(class_table), key, ce); + } + + CG(active_class_entry) = ce; + + if (implements_ast) { + zend_compile_implements(&declare_node, implements_ast TSRMLS_CC); + } + + zend_compile_stmt(stmt_ast TSRMLS_CC); + + 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->val, ce->constructor->common.function_name->val); } - } ZEND_HASH_FOREACH_END(); -} -/* }}} */ + } + 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->val, ce->destructor->common.function_name->val); + } + } + 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->val, ce->clone->common.function_name->val); + } + } -int zendlex(znode *zendlval TSRMLS_DC) /* {{{ */ -{ - int retval; + /* 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) { + ce->traits = NULL; + ce->num_traits = 0; + ce->ce_flags |= ZEND_ACC_IMPLEMENT_TRAITS; - if (CG(increment_lineno)) { - CG(zend_lineno)++; - CG(increment_lineno) = 0; + zend_emit_op(NULL, ZEND_BIND_TRAITS, &declare_node, NULL TSRMLS_CC); } -again: - Z_TYPE_INFO(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; + if (!(ce->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS)) + && (extends_ast || ce->num_interfaces > 0) + ) { + zend_verify_abstract_class(ce TSRMLS_CC); + if (ce->num_interfaces && !(ce->ce_flags & ZEND_ACC_IMPLEMENT_TRAITS)) { + zend_emit_op(NULL, ZEND_VERIFY_ABSTRACT_CLASS, &declare_node, NULL TSRMLS_CC); + } + } - case T_CLOSE_TAG: - if (LANG_SCNG(yy_text)[LANG_SCNG(yy_leng)-1] != '>') { - CG(increment_lineno) = 1; + /* 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 + * zend_verify_abstract_class() */ + if (ce->num_interfaces > 0) { + ce->interfaces = NULL; + ce->num_interfaces = 0; + ce->ce_flags |= ZEND_ACC_IMPLEMENT_INTERFACES; + } + + CG(active_class_entry) = NULL; +} + +static HashTable *zend_get_import_ht(uint32_t type TSRMLS_DC) { + switch (type) { + case T_CLASS: + if (!CG(current_import)) { + CG(current_import) = emalloc(sizeof(HashTable)); + zend_hash_init(CG(current_import), 8, NULL, str_dtor, 0); } - if (CG(has_bracketed_namespaces) && !CG(in_namespace)) { - goto again; + return CG(current_import); + case T_FUNCTION: + if (!CG(current_import_function)) { + CG(current_import_function) = emalloc(sizeof(HashTable)); + zend_hash_init(CG(current_import_function), 8, NULL, str_dtor, 0); } - retval = ';'; /* implicit ; */ - break; - case T_OPEN_TAG_WITH_ECHO: - retval = T_ECHO; - break; + return CG(current_import_function); + case T_CONST: + if (!CG(current_import_const)) { + CG(current_import_const) = emalloc(sizeof(HashTable)); + zend_hash_init(CG(current_import_const), 8, NULL, str_dtor, 0); + } + return CG(current_import_const); + EMPTY_SWITCH_DEFAULT_CASE() } +} - zendlval->op_type = IS_CONST; - return retval; +static char *zend_get_use_type_str(uint32_t type) { + switch (type) { + case T_CLASS: + return ""; + case T_FUNCTION: + return " function"; + case T_CONST: + return " const"; + EMPTY_SWITCH_DEFAULT_CASE() + } } -/* }}} */ -ZEND_API void zend_initialize_class_data(zend_class_entry *ce, zend_bool nullify_handlers TSRMLS_DC) /* {{{ */ -{ - 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); +static void zend_check_already_in_use( + uint32_t type, zend_string *old_name, zend_string *new_name, zend_string *check_name +) { + if (zend_str_equals_str_ci(old_name, check_name)) { + return; + } - ce->refcount = 1; - ce->ce_flags = ZEND_ACC_CONSTANTS_UPDATED; + 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), old_name->val, new_name->val); +} - 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 : zend_destroy_property_info), 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); +void zend_compile_use(zend_ast *ast TSRMLS_DC) { + zend_ast_list *list = zend_ast_get_list(ast); + uint32_t i; + zend_string *current_ns = CG(current_namespace); + uint32_t type = ast->attr; + HashTable *current_import = zend_get_import_ht(type TSRMLS_CC); + zend_bool case_sensitive = type == T_CONST; + + 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; + + if (new_name_ast) { + new_name = zend_string_copy(zend_ast_get_str(new_name_ast)); + } else { + /* The form "use A\B" is eqivalent to "use A\B as B" */ + const char *p = zend_memrchr(old_name->val, '\\', old_name->len); + if (p) { + new_name = zend_string_init(p + 1, old_name->len - (p - old_name->val + 1), 0); + } else { + new_name = zend_string_copy(old_name); - if (ce->type == ZEND_INTERNAL_CLASS) { -#ifdef ZTS - int n = zend_hash_num_elements(CG(class_table)); + if (!current_ns) { + if (type == T_CLASS && zend_str_equals_literal(new_name, "strict")) { + zend_error_noreturn(E_COMPILE_ERROR, + "You seem to be trying to use a different language..."); + } - 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; + zend_error(E_WARNING, "The use statement with non-compound name '%s' " + "has no effect", new_name->val); + } + } } - 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->default_properties_count = 0; - ce->default_static_members_count = 0; + if (case_sensitive) { + lookup_name = zend_string_copy(new_name); + } else { + lookup_name = zend_string_alloc(new_name->len, 0); + zend_str_tolower_copy(lookup_name->val, new_name->val, new_name->len); + } - 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 (type == T_CLASS && (zend_str_equals_literal(lookup_name, "self") + || zend_str_equals_literal(lookup_name, "parent")) + ) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use %s as %s because '%s' " + "is a special class name", old_name->val, new_name->val, new_name->val); } - } -} -/* }}} */ -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; - } else { - return ZEND_FETCH_CLASS_DEFAULT; + if (current_ns) { + zend_string *ns_name = zend_string_alloc(current_ns->len + 1 + new_name->len, 0); + zend_str_tolower_copy(ns_name->val, current_ns->val, current_ns->len); + ns_name->val[current_ns->len] = '\\'; + memcpy(ns_name->val + current_ns->len + 1, lookup_name->val, lookup_name->len); + + if (zend_hash_exists(CG(class_table), ns_name)) { + zend_check_already_in_use(type, old_name, new_name, ns_name); + } + + 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() + } + } + + 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), old_name->val, new_name->val); + } + + zend_string_release(lookup_name); + zend_string_release(new_name); } } -/* }}} */ -ZEND_API zend_string *zend_get_compiled_variable_name(const zend_op_array *op_array, uint32_t var) /* {{{ */ -{ - return op_array->vars[EX_VAR_TO_NUM(var)]; -} -/* }}} */ +void zend_compile_const_decl(zend_ast *ast TSRMLS_DC) { + 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); -void zend_do_build_namespace_name(znode *result, znode *prefix, znode *name TSRMLS_DC) /* {{{ */ -{ - if (prefix) { - *result = *prefix; - if (Z_TYPE(result->u.constant) == IS_STRING && - Z_STRLEN(result->u.constant) == 0) { - /* namespace\ */ - if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) { - znode tmp; - - zval_dtor(&result->u.constant); - tmp.op_type = IS_CONST; - ZVAL_DUP(&tmp.u.constant, &CG(current_namespace)); - zend_do_build_namespace_name(result, NULL, &tmp TSRMLS_CC); + zend_string *import_name; + znode name_node, value_node; + zval *value_zv = &value_node.u.constant; + + value_node.op_type = IS_CONST; + zend_const_expr_to_zval(value_zv, value_ast TSRMLS_CC); + + if (zend_get_ct_const(name, 0 TSRMLS_CC)) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare constant '%s'", name->val); + } + + name = zend_prefix_with_ns(name TSRMLS_CC); + + if (CG(current_import_const) + && (import_name = zend_hash_find_ptr(CG(current_import_const), name)) + ) { + if (!zend_str_equals_str(import_name, name)) { + zend_error(E_COMPILE_ERROR, "Cannot declare const %s because " + "the name is already in use", name->val); } } - } else { - result->op_type = IS_CONST; - ZVAL_EMPTY_STRING(&result->u.constant); + + name_node.op_type = IS_CONST; + ZVAL_STR(&name_node.u.constant, name); + + zend_emit_op(NULL, ZEND_DECLARE_CONST, &name_node, &value_node TSRMLS_CC); + + zend_hash_add_ptr(&CG(const_filenames), name, CG(compiled_filename)); } - /* prefix = result */ - zend_do_build_full_name(NULL, result, name, 0 TSRMLS_CC); } -/* }}} */ -void zend_do_begin_namespace(znode *name, zend_bool with_bracket TSRMLS_DC) /* {{{ */ -{ - char *lcname; +void zend_compile_namespace(zend_ast *ast TSRMLS_DC) { + zend_ast *name_ast = ast->child[0]; + zend_ast *stmt_ast = ast->child[1]; + zend_string *name; + zend_bool with_bracket = stmt_ast != NULL; /* handle mixed syntax declaration or nested namespaces */ if (!CG(has_bracketed_namespaces)) { - if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) { + 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_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 (Z_TYPE(CG(current_namespace)) != IS_UNDEF || CG(in_namespace)) { + 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"); } } - if (((!with_bracket && Z_TYPE(CG(current_namespace)) == IS_UNDEF) || (with_bracket && !CG(has_bracketed_namespaces))) && CG(active_op_array)->last > 0) { + 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; + 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"); + zend_error_noreturn(E_COMPILE_ERROR, "Namespace declaration statement has to be " + "the very first statement in the script"); + } + } + + if (CG(current_namespace)) { + zend_string_release(CG(current_namespace)); + } + + if (name_ast) { + name = zend_ast_get_str(name_ast); + + if (ZEND_FETCH_CLASS_DEFAULT != zend_get_class_fetch_type(name)) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as namespace name", name->val); } + + CG(current_namespace) = zend_string_copy(name); + } else { + CG(current_namespace) = NULL; } + zend_reset_import_tables(TSRMLS_C); + CG(in_namespace) = 1; if (with_bracket) { CG(has_bracketed_namespaces) = 1; } - 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); + if (stmt_ast) { + zend_compile_top_stmt(stmt_ast TSRMLS_CC); + zend_end_namespace(TSRMLS_C); + } +} + +void zend_compile_halt_compiler(zend_ast *ast TSRMLS_DC) { + zend_ast *offset_ast = ast->child[0]; + zend_long offset = Z_LVAL_P(zend_ast_get_zval(offset_ast)); + + zend_string *filename, *name; + const char const_name[] = "__COMPILER_HALT_OFFSET__"; + + if (CG(has_bracketed_namespaces) && CG(in_namespace)) { + zend_error_noreturn(E_COMPILE_ERROR, + "__HALT_COMPILER() can only be used from the outermost scope"); + } + + filename = zend_get_compiled_filename(TSRMLS_C); + name = zend_mangle_property_name(const_name, sizeof(const_name) - 1, + filename->val, filename->len, 0); + + zend_register_long_constant(name->val, name->len, offset, CONST_CS, 0 TSRMLS_CC); + zend_string_release(name); +} + +static zend_bool zend_try_ct_eval_magic_const(zval *zv, zend_ast *ast TSRMLS_DC) { + zend_op_array *op_array = CG(active_op_array); + zend_class_entry *ce = CG(active_class_entry); + + switch (ast->attr) { + case T_FUNC_C: + if (op_array && op_array->function_name) { + ZVAL_STR(zv, zend_string_copy(op_array->function_name)); + } else { + ZVAL_EMPTY_STRING(zv); + } + break; + case T_METHOD_C: + if (ce) { + if (op_array && op_array->function_name) { + ZVAL_STR(zv, zend_concat3(ce->name->val, ce->name->len, "::", 2, + op_array->function_name->val, op_array->function_name->len)); + } else { + ZVAL_STR(zv, zend_string_copy(ce->name)); + } + } else if (op_array && op_array->function_name) { + ZVAL_STR(zv, zend_string_copy(op_array->function_name)); + } else { + ZVAL_EMPTY_STRING(zv); + } + break; + case T_CLASS_C: + if (ce) { + if (ZEND_CE_IS_TRAIT(ce)) { + return 0; + } else { + ZVAL_STR(zv, zend_string_copy(ce->name)); + } + } else { + ZVAL_EMPTY_STRING(zv); + } + break; + case T_TRAIT_C: + if (ce && ZEND_CE_IS_TRAIT(ce)) { + ZVAL_STR(zv, zend_string_copy(ce->name)); + } else { + ZVAL_EMPTY_STRING(zv); + } + break; + case T_NS_C: + if (CG(current_namespace)) { + ZVAL_STR(zv, zend_string_copy(CG(current_namespace))); + } else { + ZVAL_EMPTY_STRING(zv); + } + break; + EMPTY_SWITCH_DEFAULT_CASE() + } + + return 1; +} + +static inline void zend_ct_eval_binary_op( + zval *result, uint32_t opcode, zval *op1, zval *op2 TSRMLS_DC +) { + binary_op_type fn = get_binary_op(opcode); + fn(result, op1, op2 TSRMLS_CC); +} + +static inline void zend_ct_eval_unary_pm(zval *result, zend_ast_kind kind, zval *op TSRMLS_DC) { + binary_op_type fn = kind == ZEND_AST_UNARY_PLUS + ? add_function : sub_function; + + zval left; + ZVAL_LONG(&left, 0); + fn(result, &left, op TSRMLS_CC); +} - if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) { - zval_dtor(&CG(current_namespace)); +static inline void zend_ct_eval_greater( + zval *result, zend_ast_kind kind, zval *op1, zval *op2 TSRMLS_DC +) { + binary_op_type fn = kind == ZEND_AST_GREATER + ? is_smaller_function : is_smaller_or_equal_function; + fn(result, op2, op1 TSRMLS_CC); +} + +static zend_bool zend_try_ct_eval_array(zval *result, zend_ast *ast TSRMLS_DC) { + zend_ast_list *list = zend_ast_get_list(ast); + uint32_t i; + + /* 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] TSRMLS_CC); + zend_eval_const_expr(&elem_ast->child[1] TSRMLS_CC); + + if (by_ref || elem_ast->child[0]->kind != ZEND_AST_ZVAL + || (elem_ast->child[1] && elem_ast->child[1]->kind != ZEND_AST_ZVAL) + ) { + return 0; } - ZVAL_COPY_VALUE(&CG(current_namespace), &name->u.constant); - } else { - if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) { - zval_dtor(&CG(current_namespace)); - ZVAL_UNDEF(&CG(current_namespace)); + } + + 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]; + + zval *value = zend_ast_get_zval(value_ast); + if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value); + + 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), STR_EMPTY_ALLOC(), value); + break; + default: + zend_error(E_COMPILE_ERROR, "Illegal offset type"); + break; + } + } else { + zend_hash_next_index_insert(Z_ARRVAL_P(result), value); } } - if (CG(current_import)) { - zend_hash_destroy(CG(current_import)); - efree(CG(current_import)); - CG(current_import) = NULL; + return 1; +} + +void zend_compile_binary_op(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *left_ast = ast->child[0]; + zend_ast *right_ast = ast->child[1]; + uint32_t opcode = ast->attr; + + znode left_node, right_node; + zend_compile_expr(&left_node, left_ast TSRMLS_CC); + zend_compile_expr(&right_node, right_ast TSRMLS_CC); + + if (left_node.op_type == IS_CONST && right_node.op_type == IS_CONST) { + result->op_type = IS_CONST; + zend_ct_eval_binary_op(&result->u.constant, opcode, + &left_node.u.constant, &right_node.u.constant TSRMLS_CC); + zval_ptr_dtor(&left_node.u.constant); + zval_ptr_dtor(&right_node.u.constant); + return; } - if (CG(current_import_function)) { - zend_hash_destroy(CG(current_import_function)); - efree(CG(current_import_function)); - CG(current_import_function) = NULL; + zend_emit_op_tmp(result, opcode, &left_node, &right_node TSRMLS_CC); +} + +/* 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 TSRMLS_DC) { + 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); + + zend_compile_expr(&left_node, left_ast TSRMLS_CC); + zend_compile_expr(&right_node, right_ast TSRMLS_CC); + + 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 TSRMLS_CC); + zval_ptr_dtor(&left_node.u.constant); + zval_ptr_dtor(&right_node.u.constant); + return; } - if (CG(current_import_const)) { - zend_hash_destroy(CG(current_import_const)); - efree(CG(current_import_const)); - CG(current_import_const) = NULL; + zend_emit_op_tmp(result, + ast->kind == ZEND_AST_GREATER ? ZEND_IS_SMALLER : ZEND_IS_SMALLER_OR_EQUAL, + &right_node, &left_node TSRMLS_CC); +} + +void zend_compile_unary_op(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *expr_ast = ast->child[0]; + uint32_t opcode = ast->attr; + + znode expr_node; + zend_compile_expr(&expr_node, expr_ast TSRMLS_CC); + + zend_emit_op_tmp(result, opcode, &expr_node, NULL TSRMLS_CC); +} + +void zend_compile_unary_pm(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *expr_ast = ast->child[0]; + znode zero_node, expr_node; + + ZEND_ASSERT(ast->kind == ZEND_AST_UNARY_PLUS || ast->kind == ZEND_AST_UNARY_MINUS); + + zend_compile_expr(&expr_node, expr_ast TSRMLS_CC); + + 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 TSRMLS_CC); + zval_ptr_dtor(&expr_node.u.constant); + return; } - if (CG(doc_comment)) { - zend_string_release(CG(doc_comment)); - CG(doc_comment) = NULL; + zero_node.op_type = IS_CONST; + ZVAL_LONG(&zero_node.u.constant, 0); + + zend_emit_op_tmp(result, ast->kind == ZEND_AST_UNARY_PLUS ? ZEND_ADD : ZEND_SUB, + &zero_node, &expr_node TSRMLS_CC); +} + +void zend_compile_short_circuiting(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *left_ast = ast->child[0]; + zend_ast *right_ast = ast->child[1]; + + znode left_node, right_node; + zend_op *opline_jmpz, *opline_bool; + uint32_t opnum_jmpz; + + ZEND_ASSERT(ast->kind == ZEND_AST_AND || ast->kind == ZEND_AST_OR); + + zend_compile_expr(&left_node, left_ast TSRMLS_CC); + + 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 TSRMLS_CC); + + 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; } + GET_NODE(result, opline_jmpz->result); + + zend_compile_expr(&right_node, right_ast TSRMLS_CC); + + opline_bool = zend_emit_op(NULL, ZEND_BOOL, &right_node, NULL TSRMLS_CC); + SET_NODE(opline_bool->result, result); + + zend_update_jump_target_to_next(opnum_jmpz TSRMLS_CC); } -/* }}} */ -void zend_do_use(znode *ns_name, znode *new_name, int is_global TSRMLS_DC) /* {{{ */ -{ - zend_string *lcname; - zval *name, ns, tmp; - zend_bool warn = 0; - zend_class_entry *ce; +void zend_compile_post_incdec(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *var_ast = ast->child[0]; + ZEND_ASSERT(ast->kind == ZEND_AST_POST_INC || ast->kind == ZEND_AST_POST_DEC); + + if (var_ast->kind == ZEND_AST_PROP) { + zend_op *opline = zend_compile_prop_common(NULL, var_ast, BP_VAR_RW TSRMLS_CC); + opline->opcode = ast->kind == ZEND_AST_POST_INC ? ZEND_POST_INC_OBJ : ZEND_POST_DEC_OBJ; + zend_make_tmp_result(result, opline TSRMLS_CC); + } else { + znode var_node; + zend_compile_var(&var_node, var_ast, BP_VAR_RW TSRMLS_CC); + zend_emit_op_tmp(result, ast->kind == ZEND_AST_POST_INC ? ZEND_POST_INC : ZEND_POST_DEC, + &var_node, NULL TSRMLS_CC); + } +} + +void zend_compile_pre_incdec(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *var_ast = ast->child[0]; + ZEND_ASSERT(ast->kind == ZEND_AST_PRE_INC || ast->kind == ZEND_AST_PRE_DEC); + + if (var_ast->kind == ZEND_AST_PROP) { + zend_op *opline = zend_compile_prop_common(result, var_ast, BP_VAR_RW TSRMLS_CC); + 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 TSRMLS_CC); + zend_emit_op(result, ast->kind == ZEND_AST_PRE_INC ? ZEND_PRE_INC : ZEND_PRE_DEC, + &var_node, NULL TSRMLS_CC); + } +} + +void zend_compile_cast(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *expr_ast = ast->child[0]; + znode expr_node; + zend_op *opline; + + zend_compile_expr(&expr_node, expr_ast TSRMLS_CC); + + opline = zend_emit_op(result, ZEND_CAST, &expr_node, NULL TSRMLS_CC); + opline->extended_value = ast->attr; +} + +static void zend_compile_shorthand_conditional(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *cond_ast = ast->child[0]; + zend_ast *false_ast = ast->child[2]; + + znode cond_node, false_node; + zend_op *opline_jmp_set, *opline_qm_assign; + uint32_t opnum_jmp_set; + + ZEND_ASSERT(ast->child[1] == NULL); + + zend_compile_expr(&cond_node, cond_ast TSRMLS_CC); + + opnum_jmp_set = get_next_op_number(CG(active_op_array)); + zend_emit_op_tmp(result, ZEND_JMP_SET, &cond_node, NULL TSRMLS_CC); + + zend_compile_expr(&false_node, false_ast TSRMLS_CC); + + opline_jmp_set = &CG(active_op_array)->opcodes[opnum_jmp_set]; + opline_jmp_set->op2.opline_num = get_next_op_number(CG(active_op_array)) + 1; + if (cond_node.op_type == IS_VAR || cond_node.op_type == IS_CV + || false_node.op_type == IS_VAR || false_node.op_type == IS_CV + ) { + opline_jmp_set->opcode = ZEND_JMP_SET_VAR; + opline_jmp_set->result_type = IS_VAR; + GET_NODE(result, opline_jmp_set->result); + + opline_qm_assign = zend_emit_op(NULL, ZEND_QM_ASSIGN_VAR, &false_node, NULL TSRMLS_CC); + } else { + opline_qm_assign = zend_emit_op(NULL, ZEND_QM_ASSIGN, &false_node, NULL TSRMLS_CC); + } + SET_NODE(opline_qm_assign->result, result); +} + +void zend_compile_conditional(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *cond_ast = ast->child[0]; + zend_ast *true_ast = ast->child[1]; + zend_ast *false_ast = ast->child[2]; + + znode cond_node, true_node, false_node; + zend_op *opline_qm_assign1, *opline_qm_assign2; + uint32_t opnum_jmpz, opnum_jmp, opnum_qm_assign1; + + if (!true_ast) { + zend_compile_shorthand_conditional(result, ast TSRMLS_CC); + return; + } + + zend_compile_expr(&cond_node, cond_ast TSRMLS_CC); + + opnum_jmpz = zend_emit_cond_jump(ZEND_JMPZ, &cond_node, 0 TSRMLS_CC); + + zend_compile_expr(&true_node, true_ast TSRMLS_CC); + + opnum_qm_assign1 = get_next_op_number(CG(active_op_array)); + zend_emit_op(result, ZEND_QM_ASSIGN, &true_node, NULL TSRMLS_CC); + + opnum_jmp = zend_emit_jump(0 TSRMLS_CC); + + zend_update_jump_target_to_next(opnum_jmpz TSRMLS_CC); + + zend_compile_expr(&false_node, false_ast TSRMLS_CC); - if (!CG(current_import)) { - CG(current_import) = emalloc(sizeof(HashTable)); - zend_hash_init(CG(current_import), 8, NULL, ZVAL_PTR_DTOR, 0); + opline_qm_assign1 = &CG(active_op_array)->opcodes[opnum_qm_assign1]; + if (true_node.op_type == IS_VAR || true_node.op_type == IS_CV + || false_node.op_type == IS_VAR || false_node.op_type == IS_CV + ) { + opline_qm_assign1->opcode = ZEND_QM_ASSIGN_VAR; + opline_qm_assign1->result_type = IS_VAR; + GET_NODE(result, opline_qm_assign1->result); } - ZVAL_ZVAL(&ns, &ns_name->u.constant, 0, 0); - if (new_name) { - name = &new_name->u.constant; + opline_qm_assign2 = zend_emit_op(NULL, opline_qm_assign1->opcode, &false_node, NULL TSRMLS_CC); + SET_NODE(opline_qm_assign2->result, result); + + zend_update_jump_target_to_next(opnum_jmp TSRMLS_CC); +} + +void zend_compile_print(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *expr_ast = ast->child[0]; + + znode expr_node; + zend_compile_expr(&expr_node, expr_ast TSRMLS_CC); + + zend_emit_op_tmp(result, ZEND_PRINT, &expr_node, NULL TSRMLS_CC); +} + +void zend_compile_exit(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *expr_ast = ast->child[0]; + + if (expr_ast) { + znode expr_node; + zend_compile_expr(&expr_node, expr_ast TSRMLS_CC); + zend_emit_op(NULL, ZEND_EXIT, &expr_node, NULL TSRMLS_CC); } 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(ns), '\\', Z_STRLEN(ns)); - if (p) { - ZVAL_STRING(name, p+1); + zend_emit_op(NULL, ZEND_EXIT, NULL, NULL TSRMLS_CC); + } + + result->op_type = IS_CONST; + ZVAL_BOOL(&result->u.constant, 1); +} + +void zend_compile_yield(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *value_ast = ast->child[0]; + zend_ast *key_ast = ast->child[1]; + + 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; + + 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 (key_ast) { + zend_compile_expr(&key_node, key_ast TSRMLS_CC); + key_node_ptr = &key_node; + } + + 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 TSRMLS_CC); } else { - ZVAL_ZVAL(name, &ns, 1, 0); - warn = !is_global && Z_TYPE(CG(current_namespace)) == IS_UNDEF; + zend_compile_expr(&value_node, value_ast TSRMLS_CC); } + value_node_ptr = &value_node; } - lcname = zend_string_alloc(Z_STRLEN_P(name), 0); - zend_str_tolower_copy(lcname->val, Z_STRVAL_P(name), Z_STRLEN_P(name)); + opline = zend_emit_op(result, ZEND_YIELD, value_node_ptr, key_node_ptr TSRMLS_CC); - if (((Z_STRLEN_P(name) == sizeof("self")-1) && - !memcmp(lcname->val, "self", sizeof("self")-1)) || - ((Z_STRLEN_P(name) == sizeof("parent")-1) && - !memcmp(lcname->val, "parent", sizeof("parent")-1))) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use %s as %s because '%s' is a special class name", Z_STRVAL(ns), Z_STRVAL_P(name), Z_STRVAL_P(name)); + if (value_ast && returns_by_ref && zend_is_call(value_ast)) { + opline->extended_value = ZEND_RETURNS_FUNCTION; } +} + +void zend_compile_instanceof(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *obj_ast = ast->child[0]; + zend_ast *class_ast = ast->child[1]; + + znode obj_node, class_node; + zend_op *opline; + + zend_compile_expr(&obj_node, obj_ast TSRMLS_CC); + if (obj_node.op_type == IS_CONST) { + zend_error_noreturn(E_COMPILE_ERROR, + "instanceof expects an object instance, constant given"); + } + + opline = zend_compile_class_ref(&class_node, class_ast TSRMLS_CC); + opline->extended_value |= ZEND_FETCH_CLASS_NO_AUTOLOAD; + + zend_emit_op_tmp(result, ZEND_INSTANCEOF, &obj_node, &class_node TSRMLS_CC); +} + +void zend_compile_include_or_eval(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *expr_ast = ast->child[0]; + znode expr_node; + zend_op *opline; + + zend_do_extended_fcall_begin(TSRMLS_C); + zend_compile_expr(&expr_node, expr_ast TSRMLS_CC); + + opline = zend_emit_op(result, ZEND_INCLUDE_OR_EVAL, &expr_node, NULL TSRMLS_CC); + opline->extended_value = ast->attr; - if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) { - /* Prefix import name with current namespace name to avoid conflicts with classes */ - zend_string *c_ns_name = zend_string_alloc(Z_STRLEN(CG(current_namespace)) + 1 + Z_STRLEN_P(name), 0); + zend_do_extended_fcall_end(TSRMLS_C); +} - zend_str_tolower_copy(c_ns_name->val, Z_STRVAL(CG(current_namespace)), Z_STRLEN(CG(current_namespace))); - c_ns_name->val[Z_STRLEN(CG(current_namespace))] = '\\'; - memcpy(c_ns_name->val+Z_STRLEN(CG(current_namespace))+1, lcname->val, Z_STRLEN_P(name)+1); - if (zend_hash_exists(CG(class_table), c_ns_name)) { - char *tmp2 = zend_str_tolower_dup(Z_STRVAL(ns), Z_STRLEN(ns)); +void zend_compile_isset_or_empty(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *var_ast = ast->child[0]; + + znode var_node; + zend_op *opline; + + 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 TSRMLS_CC); + return; + } else { + zend_error_noreturn(E_COMPILE_ERROR, + "Cannot use isset() on the result of an expression " + "(you can use \"null !== expression\" instead)"); + } + } - if (Z_STRLEN(ns) != Z_STRLEN(CG(current_namespace)) + 1 + Z_STRLEN_P(name) || - memcmp(tmp2, c_ns_name->val, Z_STRLEN(ns))) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use %s as %s because the name is already in use", Z_STRVAL(ns), Z_STRVAL_P(name)); + switch (var_ast->kind) { + case ZEND_AST_VAR: + if (zend_try_compile_cv(&var_node, var_ast TSRMLS_CC) == SUCCESS) { + opline = zend_emit_op(result, ZEND_ISSET_ISEMPTY_VAR, &var_node, NULL TSRMLS_CC); + opline->extended_value = ZEND_FETCH_LOCAL | ZEND_QUICK_SET; + } else { + opline = zend_compile_simple_var_no_cv(result, var_ast, BP_VAR_IS TSRMLS_CC); + opline->opcode = ZEND_ISSET_ISEMPTY_VAR; } - efree(tmp2); + break; + case ZEND_AST_DIM: + opline = zend_compile_dim_common(result, var_ast, BP_VAR_IS TSRMLS_CC); + opline->opcode = ZEND_ISSET_ISEMPTY_DIM_OBJ; + break; + case ZEND_AST_PROP: + opline = zend_compile_prop_common(result, var_ast, BP_VAR_IS TSRMLS_CC); + 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 TSRMLS_CC); + opline->opcode = ZEND_ISSET_ISEMPTY_VAR; + break; + EMPTY_SWITCH_DEFAULT_CASE() + } + + opline->result_type = IS_TMP_VAR; + opline->extended_value |= ast->kind == ZEND_AST_ISSET ? ZEND_ISSET : ZEND_ISEMPTY; +} + +void zend_compile_silence(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *expr_ast = ast->child[0]; + znode silence_node; + + zend_emit_op_tmp(&silence_node, ZEND_BEGIN_SILENCE, NULL, NULL 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 TSRMLS_CC); + } else { + zend_compile_expr(result, expr_ast TSRMLS_CC); + } + + zend_emit_op(NULL, ZEND_END_SILENCE, &silence_node, NULL TSRMLS_CC); +} + +void zend_compile_shell_exec(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *expr_ast = ast->child[0]; + + zval fn_name; + zend_ast *name_ast, *args_ast, *call_ast; + + ZVAL_STRING(&fn_name, "shell_exec"); + name_ast = zend_ast_create_zval(&fn_name); + args_ast = (zend_ast *) zend_ast_create_list(1, ZEND_AST_ARG_LIST, expr_ast); + call_ast = zend_ast_create(ZEND_AST_CALL, name_ast, args_ast); + + zend_compile_expr(result, call_ast TSRMLS_CC); + + zval_ptr_dtor(&fn_name); +} + +void zend_compile_array(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast_list *list = zend_ast_get_list(ast); + zend_op *opline; + uint32_t i, opnum_init; + zend_bool packed = 1; + + if (zend_try_ct_eval_array(&result->u.constant, ast TSRMLS_CC)) { + result->op_type = IS_CONST; + return; + } + + opnum_init = get_next_op_number(CG(active_op_array)); + + 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; + + znode value_node, key_node, *key_node_ptr = NULL; + + if (key_ast) { + zend_compile_expr(&key_node, key_ast TSRMLS_CC); + zend_handle_numeric_op(&key_node TSRMLS_CC); + key_node_ptr = &key_node; + } + + if (by_ref) { + zend_ensure_writable_variable(value_ast); + zend_compile_var(&value_node, value_ast, BP_VAR_W TSRMLS_CC); + } else { + zend_compile_expr(&value_node, value_ast TSRMLS_CC); + } + + if (i == 0) { + opline = zend_emit_op_tmp(result, ZEND_INIT_ARRAY, &value_node, key_node_ptr TSRMLS_CC); + opline->extended_value = list->children << ZEND_ARRAY_SIZE_SHIFT; + } else { + opline = zend_emit_op(NULL, ZEND_ADD_ARRAY_ELEMENT, + &value_node, key_node_ptr TSRMLS_CC); + SET_NODE(opline->result, result); } - zend_string_free(c_ns_name); - } else if ((ce = zend_hash_find_ptr(CG(class_table), lcname)) != NULL && - ce->type == ZEND_USER_CLASS && - ce->info.user.filename == CG(compiled_filename)) { - char *c_tmp = zend_str_tolower_dup(Z_STRVAL(ns), Z_STRLEN(ns)); + opline->extended_value |= by_ref; - if (Z_STRLEN(ns) != Z_STRLEN_P(name) || - memcmp(c_tmp, lcname->val, Z_STRLEN(ns))) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use %s as %s because the name is already in use", Z_STRVAL(ns), Z_STRVAL_P(name)); + if (key_ast && key_node.op_type == IS_CONST && Z_TYPE(key_node.u.constant) == IS_STRING) { + packed = 0; } - efree(c_tmp); } - if (zend_hash_add(CG(current_import), lcname, &ns) == NULL) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use %s as %s because the name is already in use", Z_STRVAL(ns), Z_STRVAL_P(name)); + /* Handle empty array */ + if (!list->children) { + zend_emit_op_tmp(result, ZEND_INIT_ARRAY, NULL, NULL TSRMLS_CC); } - 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)); + + /* Add a flag to INIT_ARRAY if we know this array cannot be packed */ + if (!packed) { + opline = &CG(active_op_array)->opcodes[opnum_init]; + opline->extended_value |= ZEND_ARRAY_NOT_PACKED; } - zend_string_release(lcname); - zval_dtor(name); } -/* }}} */ -void zend_do_use_non_class(znode *ns_name, znode *new_name, int is_global, int is_function, zend_bool case_sensitive, HashTable *current_import_sub, HashTable *lookup_table TSRMLS_DC) /* {{{ */ -{ - zend_string *lookup_name; - zval *name, ns, tmp; - zend_bool warn = 0; +void zend_compile_const(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *name_ast = ast->child[0]; + zend_string *orig_name = zend_ast_get_str(name_ast); + zend_bool is_fully_qualified; + + zval resolved_name; + zend_op *opline; - ZVAL_ZVAL(&ns, &ns_name->u.constant, 0, 0); - if (new_name) { - name = &new_name->u.constant; + ZVAL_STR(&resolved_name, zend_resolve_const_name( + orig_name, name_ast->attr, &is_fully_qualified TSRMLS_CC)); + + if (zend_constant_ct_subst(result, &resolved_name, 1 TSRMLS_CC)) { + zval_dtor(&resolved_name); + return; + } + + opline = zend_emit_op_tmp(result, ZEND_FETCH_CONSTANT, NULL, NULL TSRMLS_CC); + opline->op2_type = IS_CONST; + + if (is_fully_qualified) { + opline->op2.constant = zend_add_const_name_literal( + CG(active_op_array), &resolved_name, 0 TSRMLS_CC); } 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(ns), '\\', Z_STRLEN(ns)); - if (p) { - ZVAL_STRING(name, p+1); + 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), &resolved_name, 1 TSRMLS_CC); } else { - ZVAL_ZVAL(name, &ns, 1, 0); - warn = !is_global && Z_TYPE(CG(current_namespace)) == IS_UNDEF; + opline->op2.constant = zend_add_const_name_literal( + CG(active_op_array), &resolved_name, 0 TSRMLS_CC); } } + zend_alloc_cache_slot(opline->op2.constant TSRMLS_CC); +} + +void zend_compile_class_const(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *class_ast = ast->child[0]; + zend_ast *const_ast = ast->child[1]; - if (case_sensitive) { - lookup_name = zend_string_copy(Z_STR_P(name)); + znode class_node, const_node; + zend_op *opline; + + 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 TSRMLS_CC)); } else { - lookup_name = zend_string_alloc(Z_STRLEN_P(name), 0); - zend_str_tolower_copy(lookup_name->val, Z_STRVAL_P(name), Z_STRLEN_P(name)); + zend_compile_class_ref(&class_node, class_ast TSRMLS_CC); } - if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) { - /* Prefix import name with current namespace name to avoid conflicts with functions/consts */ - zend_string *c_ns_name = zend_string_alloc(Z_STRLEN(CG(current_namespace)) + 1 + Z_STRLEN_P(name), 0); + zend_compile_expr(&const_node, const_ast TSRMLS_CC); + + opline = zend_emit_op_tmp(result, ZEND_FETCH_CONSTANT, NULL, &const_node TSRMLS_CC); + + zend_set_class_name_op1(opline, &class_node TSRMLS_CC); + + if (opline->op1_type == IS_CONST) { + zend_alloc_cache_slot(opline->op2.constant TSRMLS_CC); + } else { + zend_alloc_polymorphic_cache_slot(opline->op2.constant TSRMLS_CC); + } +} - zend_str_tolower_copy(c_ns_name->val, Z_STRVAL(CG(current_namespace)), Z_STRLEN(CG(current_namespace))); - c_ns_name->val[Z_STRLEN(CG(current_namespace))] = '\\'; - memcpy(c_ns_name->val+Z_STRLEN(CG(current_namespace))+1, lookup_name, Z_STRLEN_P(name)+1); - if (zend_hash_exists(lookup_table, c_ns_name)) { - char *tmp2 = zend_str_tolower_dup(Z_STRVAL(ns), Z_STRLEN(ns)); +void zend_compile_resolve_class_name(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *name_ast = ast->child[0]; + uint32_t fetch_type = zend_get_class_fetch_type(zend_ast_get_str(name_ast)); - if (Z_STRLEN(ns) != Z_STRLEN(CG(current_namespace)) + 1 + Z_STRLEN_P(name) || - memcmp(tmp2, c_ns_name->val, Z_STRLEN(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(ns), Z_STRVAL_P(name)); + switch (fetch_type) { + 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"); } - efree(tmp2); - } - zend_string_free(c_ns_name); - } else if (is_function) { - zend_function *function; + result->op_type = IS_CONST; + ZVAL_STR(&result->u.constant, zend_string_copy(CG(active_class_entry)->name)); + break; + case ZEND_FETCH_CLASS_STATIC: + case ZEND_FETCH_CLASS_PARENT: + if (!CG(active_class_entry)) { + zend_error_noreturn(E_COMPILE_ERROR, + "Cannot access %s::class when no class scope is active", + fetch_type == ZEND_FETCH_CLASS_STATIC ? "static" : "parent"); + } else { + zval class_str_zv; + zend_ast *class_str_ast, *class_const_ast; + + ZVAL_STRING(&class_str_zv, "class"); + class_str_ast = zend_ast_create_zval(&class_str_zv); + class_const_ast = zend_ast_create( + ZEND_AST_CLASS_CONST, name_ast, class_str_ast); - if ((function = zend_hash_find_ptr(lookup_table, lookup_name)) != NULL && function->type == ZEND_USER_FUNCTION && strcmp(function->op_array.filename->val, CG(compiled_filename)->val) == 0) { - char *c_tmp = zend_str_tolower_dup(Z_STRVAL(ns), Z_STRLEN(ns)); + zend_compile_expr(result, class_const_ast TSRMLS_CC); - if (Z_STRLEN(ns) != Z_STRLEN_P(name) || - memcmp(c_tmp, lookup_name->val, Z_STRLEN(ns))) { - zend_error(E_COMPILE_ERROR, "Cannot use function %s as %s because the name is already in use", Z_STRVAL(ns), Z_STRVAL_P(name)); + zval_ptr_dtor(&class_str_zv); } - efree(c_tmp); - } - } else { - zend_string *filename; + break; + case ZEND_FETCH_CLASS_DEFAULT: + result->op_type = IS_CONST; + ZVAL_STR(&result->u.constant, zend_resolve_class_name_ast(name_ast TSRMLS_CC)); + break; + EMPTY_SWITCH_DEFAULT_CASE() + } +} + +void zend_compile_encaps_list(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast_list *list = zend_ast_get_list(ast); + uint32_t i; - if ((filename = zend_hash_find_ptr(lookup_table, lookup_name)) != NULL && strcmp(filename->val, CG(compiled_filename)->val) == 0) { - char *c_tmp = zend_str_tolower_dup(Z_STRVAL(ns), Z_STRLEN(ns)); + ZEND_ASSERT(list->children > 0); - if (Z_STRLEN(ns) != Z_STRLEN_P(name) || - memcmp(c_tmp, lookup_name->val, Z_STRLEN(ns))) { - zend_error(E_COMPILE_ERROR, "Cannot use const %s as %s because the name is already in use", Z_STRVAL(ns), Z_STRVAL_P(name)); + result->op_type = IS_TMP_VAR; + result->u.op.var = get_temporary_variable(CG(active_op_array)); + + for (i = 0; i < list->children; ++i) { + zend_ast *elem_ast = list->child[i]; + znode elem_node; + zend_op *opline; + + zend_compile_expr(&elem_node, elem_ast TSRMLS_CC); + + if (elem_ast->kind == ZEND_AST_ZVAL) { + zval *zv = &elem_node.u.constant; + ZEND_ASSERT(Z_TYPE_P(zv) == IS_STRING); + + if (Z_STRLEN_P(zv) > 1) { + opline = get_next_op(CG(active_op_array) TSRMLS_CC); + opline->opcode = ZEND_ADD_STRING; + } else if (Z_STRLEN_P(zv) == 1) { + char ch = *Z_STRVAL_P(zv); + zend_string_release(Z_STR_P(zv)); + ZVAL_LONG(zv, 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 */ + zend_string_release(Z_STR_P(zv)); + continue; } - efree(c_tmp); + } else { + opline = get_next_op(CG(active_op_array) TSRMLS_CC); + opline->opcode = ZEND_ADD_VAR; + ZEND_ASSERT(elem_node.op_type != IS_CONST); } + + if (i == 0) { + SET_UNUSED(opline->op1); + } else { + SET_NODE(opline->op1, result); + } + SET_NODE(opline->op2, &elem_node); + SET_NODE(opline->result, result); } +} - if (zend_hash_add(current_import_sub, lookup_name, &ns) == NULL) { - zend_error(E_COMPILE_ERROR, "Cannot use %s %s as %s because the name is already in use", is_function ? "function" : "const", Z_STRVAL(ns), Z_STRVAL_P(name)); +void zend_compile_magic_const(znode *result, zend_ast *ast TSRMLS_DC) { + zend_class_entry *ce = CG(active_class_entry); + + if (zend_try_ct_eval_magic_const(&result->u.constant, ast TSRMLS_CC)) { + result->op_type = IS_CONST; + return; } - 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_ASSERT(ast->attr == T_CLASS_C && ce && ZEND_CE_IS_TRAIT(ce)); + + { + zend_ast *const_ast = zend_ast_create(ZEND_AST_CONST, + zend_ast_create_zval_from_str(zend_string_init("__CLASS__", sizeof("__CLASS__") - 1, 0))); + zend_compile_const(result, const_ast TSRMLS_CC); + zend_ast_destroy(const_ast); + } +} + +zend_bool zend_is_allowed_in_const_expr(zend_ast_kind kind) { + 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_RESOLVE_CLASS_NAME || kind == ZEND_AST_MAGIC_CONST; +} + +void zend_compile_const_expr_class_const(zend_ast **ast_ptr TSRMLS_DC) { + zend_ast *ast = *ast_ptr; + zend_ast *class_ast = ast->child[0]; + zend_ast *const_ast = ast->child[1]; + zend_string *class_name = zend_ast_get_str(class_ast); + 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"); } - zend_string_release(lookup_name); - zval_dtor(name); -} -/* }}} */ -void zend_do_use_function(znode *ns_name, znode *new_name, int is_global TSRMLS_DC) /* {{{ */ -{ - if (!CG(current_import_function)) { - CG(current_import_function) = emalloc(sizeof(HashTable)); - zend_hash_init(CG(current_import_function), 8, NULL, ZVAL_PTR_DTOR, 0); + fetch_type = zend_get_class_fetch_type(class_name); + + if (ZEND_FETCH_CLASS_STATIC == fetch_type) { + zend_error_noreturn(E_COMPILE_ERROR, + "\"static::\" is not allowed in compile-time constants"); + } + + if (ZEND_FETCH_CLASS_DEFAULT == fetch_type) { + class_name = zend_resolve_class_name_ast(class_ast TSRMLS_CC); + } else { + zend_string_addref(class_name); } - zend_do_use_non_class(ns_name, new_name, is_global, 1, 0, CG(current_import_function), CG(function_table) TSRMLS_CC); -} -/* }}} */ + Z_STR(result) = zend_concat3( + class_name->val, class_name->len, "::", 2, const_name->val, const_name->len); -void zend_do_use_const(znode *ns_name, znode *new_name, int is_global TSRMLS_DC) /* {{{ */ -{ - if (!CG(current_import_const)) { - CG(current_import_const) = emalloc(sizeof(HashTable)); - zend_hash_init(CG(current_import_const), 8, NULL, ZVAL_PTR_DTOR, 0); + Z_TYPE_INFO(result) = IS_CONSTANT_EX; + if (IS_INTERNED(Z_STR(result))) { + Z_TYPE_FLAGS(result) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE); } + Z_CONST_FLAGS(result) = fetch_type; - zend_do_use_non_class(ns_name, new_name, is_global, 0, 1, CG(current_import_const), &CG(const_filenames) TSRMLS_CC); + zend_ast_destroy(ast); + zend_string_release(class_name); + + *ast_ptr = zend_ast_create_zval(&result); } -/* }}} */ -void zend_do_declare_constant(znode *name, znode *value TSRMLS_DC) /* {{{ */ -{ - zend_op *opline; - zval *ns_name; +void zend_compile_const_expr_const(zend_ast **ast_ptr TSRMLS_DC) { + zend_ast *ast = *ast_ptr; + zend_ast *name_ast = ast->child[0]; + zval *orig_name = zend_ast_get_zval(name_ast); + zend_bool is_fully_qualified; - 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)); + znode result; + zval resolved_name; + + if (zend_constant_ct_subst(&result, orig_name, 0 TSRMLS_CC)) { + zend_ast_destroy(ast); + *ast_ptr = zend_ast_create_zval(&result.u.constant); + return; } - if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) { - /* Prefix constant name with name of current namespace, lowercased */ - znode tmp; + ZVAL_STR(&resolved_name, zend_resolve_const_name( + Z_STR_P(orig_name), name_ast->attr, &is_fully_qualified TSRMLS_CC)); - tmp.op_type = IS_CONST; - ZVAL_NEW_STR(&tmp.u.constant, zend_string_alloc(Z_STRLEN(CG(current_namespace)), 0)); - zend_str_tolower_copy(Z_STRVAL(tmp.u.constant), Z_STRVAL(CG(current_namespace)), Z_STRLEN(CG(current_namespace))); - zend_do_build_namespace_name(&tmp, &tmp, name TSRMLS_CC); - *name = tmp; + Z_TYPE_INFO(resolved_name) = IS_CONSTANT_EX; + if (!is_fully_qualified) { + Z_CONST_FLAGS(resolved_name) = IS_CONSTANT_UNQUALIFIED; } - /* Constant name must not conflict with import names */ - if (CG(current_import_const) && - (ns_name = zend_hash_find(CG(current_import_const), Z_STR(name->u.constant))) != NULL) { + zend_ast_destroy(ast); + *ast_ptr = zend_ast_create_zval(&resolved_name); +} - char *tmp = estrndup(Z_STRVAL_P(ns_name), Z_STRLEN_P(ns_name)); +void zend_compile_const_expr_resolve_class_name(zend_ast **ast_ptr TSRMLS_DC) { + zend_ast *ast = *ast_ptr; + zend_ast *name_ast = ast->child[0]; + uint32_t fetch_type = zend_get_class_fetch_type(zend_ast_get_str(name_ast)); + zval result; - if (Z_STRLEN_P(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)); - } - efree(tmp); + switch (fetch_type) { + 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"); + } + ZVAL_STR(&result, zend_string_copy(CG(active_class_entry)->name)); + break; + case ZEND_FETCH_CLASS_STATIC: + case ZEND_FETCH_CLASS_PARENT: + 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" + ); + break; + case ZEND_FETCH_CLASS_DEFAULT: + ZVAL_STR(&result, zend_resolve_class_name_ast(name_ast TSRMLS_CC)); + break; + EMPTY_SWITCH_DEFAULT_CASE() } - 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_ptr(&CG(const_filenames), Z_STR(name->u.constant), CG(compiled_filename)); + zend_ast_destroy(ast); + *ast_ptr = zend_ast_create_zval(&result); } -/* }}} */ -void zend_verify_namespace(TSRMLS_D) /* {{{ */ -{ - if (CG(has_bracketed_namespaces) && !CG(in_namespace)) { - zend_error_noreturn(E_COMPILE_ERROR, "No code may exist outside of namespace {}"); +void zend_compile_const_expr_magic_const(zend_ast **ast_ptr TSRMLS_DC) { + zend_ast *ast = *ast_ptr; + zend_class_entry *ce = CG(active_class_entry); + + /* Other cases already resolved by constant folding */ + ZEND_ASSERT(ast->attr == T_CLASS_C && ce && ZEND_CE_IS_TRAIT(ce)); + + { + zval const_zv; + ZVAL_STRING(&const_zv, "__CLASS__"); + Z_TYPE_INFO(const_zv) = IS_CONSTANT_EX; + + zend_ast_destroy(ast); + *ast_ptr = zend_ast_create_zval(&const_zv); } } -/* }}} */ -void zend_do_end_namespace(TSRMLS_D) /* {{{ */ -{ - CG(in_namespace) = 0; - if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) { - zval_dtor(&CG(current_namespace)); - ZVAL_UNDEF(&CG(current_namespace)); - } - if (CG(current_import)) { - zend_hash_destroy(CG(current_import)); - efree(CG(current_import)); - CG(current_import) = NULL; +void zend_compile_const_expr(zend_ast **ast_ptr TSRMLS_DC) { + zend_ast *ast = *ast_ptr; + if (ast == NULL || ast->kind == ZEND_AST_ZVAL) { + return; } - if (CG(current_import_function)) { - zend_hash_destroy(CG(current_import_function)); - efree(CG(current_import_function)); - CG(current_import_function) = NULL; + + if (!zend_is_allowed_in_const_expr(ast->kind)) { + zend_error_noreturn(E_COMPILE_ERROR, "Constant expression contains invalid operations"); } - 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_CLASS_CONST: + zend_compile_const_expr_class_const(ast_ptr TSRMLS_CC); + break; + case ZEND_AST_CONST: + zend_compile_const_expr_const(ast_ptr TSRMLS_CC); + break; + case ZEND_AST_RESOLVE_CLASS_NAME: + zend_compile_const_expr_resolve_class_name(ast_ptr TSRMLS_CC); + break; + case ZEND_AST_MAGIC_CONST: + zend_compile_const_expr_magic_const(ast_ptr TSRMLS_CC); + break; + default: + zend_ast_apply(ast, zend_compile_const_expr TSRMLS_CC); + break; } } -/* }}} */ -void zend_do_end_compilation(TSRMLS_D) /* {{{ */ -{ - CG(has_bracketed_namespaces) = 0; - zend_do_end_namespace(TSRMLS_C); -} -/* }}} */ +void zend_const_expr_to_zval(zval *result, zend_ast *ast TSRMLS_DC) { + zend_ast *orig_ast = ast; + zend_eval_const_expr(&ast TSRMLS_CC); + zend_compile_const_expr(&ast TSRMLS_CC); + if (ast->kind == ZEND_AST_ZVAL) { + ZVAL_COPY_VALUE(result, zend_ast_get_zval(ast)); -void zend_do_constant_expression(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */ -{ - if (ast->kind == ZEND_CONST) { - ZVAL_COPY_VALUE(&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); + /* 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->u.constant, ast); + ZVAL_NEW_AST(result, zend_ast_copy(ast)); } } -/* }}} */ -/* {{{ 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; +/* Same as compile_stmt, but with early binding */ +void zend_compile_top_stmt(zend_ast *ast TSRMLS_DC) { + if (!ast) { + 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 (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] TSRMLS_CC); } + return; } -#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; - } + + zend_compile_stmt(ast TSRMLS_CC); + + if (ast->kind != ZEND_AST_NAMESPACE && ast->kind != ZEND_AST_HALT_COMPILER) { + zend_verify_namespace(TSRMLS_C); } -#endif + 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(TSRMLS_C); + } +} - if (len == 0) { - /* Illegal use of this function */ - return 0; +void zend_compile_stmt(zend_ast *ast TSRMLS_DC) { + if (!ast) { + return; } - /* Strip trailing slashes */ - while (end >= path && IS_SLASH_P(end)) { - end--; + CG(zend_lineno) = ast->lineno; + + switch (ast->kind) { + case ZEND_AST_STMT_LIST: + zend_compile_stmt_list(ast TSRMLS_CC); + break; + case ZEND_AST_GLOBAL: + zend_compile_global_var(ast TSRMLS_CC); + break; + case ZEND_AST_STATIC: + zend_compile_static_var(ast TSRMLS_CC); + break; + case ZEND_AST_UNSET: + zend_compile_unset(ast TSRMLS_CC); + break; + case ZEND_AST_RETURN: + zend_compile_return(ast TSRMLS_CC); + break; + case ZEND_AST_ECHO: + zend_compile_echo(ast TSRMLS_CC); + break; + case ZEND_AST_THROW: + zend_compile_throw(ast TSRMLS_CC); + break; + case ZEND_AST_BREAK: + case ZEND_AST_CONTINUE: + zend_compile_break_continue(ast TSRMLS_CC); + break; + case ZEND_AST_GOTO: + zend_compile_goto(ast TSRMLS_CC); + break; + case ZEND_AST_LABEL: + zend_compile_label(ast TSRMLS_CC); + break; + case ZEND_AST_WHILE: + zend_compile_while(ast TSRMLS_CC); + break; + case ZEND_AST_DO_WHILE: + zend_compile_do_while(ast TSRMLS_CC); + break; + case ZEND_AST_FOR: + zend_compile_for(ast TSRMLS_CC); + break; + case ZEND_AST_FOREACH: + zend_compile_foreach(ast TSRMLS_CC); + break; + case ZEND_AST_IF: + zend_compile_if(ast TSRMLS_CC); + break; + case ZEND_AST_SWITCH: + zend_compile_switch(ast TSRMLS_CC); + break; + case ZEND_AST_TRY: + zend_compile_try(ast TSRMLS_CC); + break; + case ZEND_AST_DECLARE: + zend_compile_declare(ast TSRMLS_CC); + break; + case ZEND_AST_FUNC_DECL: + case ZEND_AST_METHOD: + zend_compile_func_decl(NULL, ast TSRMLS_CC); + break; + case ZEND_AST_PROP_DECL: + zend_compile_prop_decl(ast TSRMLS_CC); + break; + case ZEND_AST_CLASS_CONST_DECL: + zend_compile_class_const_decl(ast TSRMLS_CC); + break; + case ZEND_AST_USE_TRAIT: + zend_compile_use_trait(ast TSRMLS_CC); + break; + case ZEND_AST_CLASS: + zend_compile_class_decl(ast TSRMLS_CC); + break; + case ZEND_AST_USE: + zend_compile_use(ast TSRMLS_CC); + break; + case ZEND_AST_CONST_DECL: + zend_compile_const_decl(ast TSRMLS_CC); + break; + case ZEND_AST_NAMESPACE: + zend_compile_namespace(ast TSRMLS_CC); + break; + case ZEND_AST_HALT_COMPILER: + zend_compile_halt_compiler(ast TSRMLS_CC); + break; + default: + { + znode result; + zend_compile_expr(&result, ast TSRMLS_CC); + zend_do_free(&result TSRMLS_CC); + } } - if (end < path) { - /* The path only contained slashes */ - path[0] = DEFAULT_SLASH; - path[1] = '\0'; - return 1 + len_adjust; + + if (Z_LVAL(CG(declarables).ticks) && !zend_is_unticked_stmt(ast)) { + zend_emit_tick(TSRMLS_C); } +} - /* Strip filename */ - while (end >= path && !IS_SLASH_P(end)) { - end--; +void zend_compile_expr(znode *result, zend_ast *ast TSRMLS_DC) { + //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 TSRMLS_CC); + return; + case ZEND_AST_ASSIGN: + zend_compile_assign(result, ast TSRMLS_CC); + return; + case ZEND_AST_ASSIGN_REF: + zend_compile_assign_ref(result, ast TSRMLS_CC); + return; + case ZEND_AST_NEW: + zend_compile_new(result, ast TSRMLS_CC); + return; + case ZEND_AST_CLONE: + zend_compile_clone(result, ast TSRMLS_CC); + return; + case ZEND_AST_ASSIGN_OP: + zend_compile_compound_assign(result, ast TSRMLS_CC); + return; + case ZEND_AST_BINARY_OP: + zend_compile_binary_op(result, ast TSRMLS_CC); + return; + case ZEND_AST_GREATER: + case ZEND_AST_GREATER_EQUAL: + zend_compile_greater(result, ast TSRMLS_CC); + return; + case ZEND_AST_UNARY_OP: + zend_compile_unary_op(result, ast TSRMLS_CC); + return; + case ZEND_AST_UNARY_PLUS: + case ZEND_AST_UNARY_MINUS: + zend_compile_unary_pm(result, ast TSRMLS_CC); + return; + case ZEND_AST_AND: + case ZEND_AST_OR: + zend_compile_short_circuiting(result, ast TSRMLS_CC); + return; + case ZEND_AST_POST_INC: + case ZEND_AST_POST_DEC: + zend_compile_post_incdec(result, ast TSRMLS_CC); + return; + case ZEND_AST_PRE_INC: + case ZEND_AST_PRE_DEC: + zend_compile_pre_incdec(result, ast TSRMLS_CC); + return; + case ZEND_AST_CAST: + zend_compile_cast(result, ast TSRMLS_CC); + return; + case ZEND_AST_CONDITIONAL: + zend_compile_conditional(result, ast TSRMLS_CC); + return; + case ZEND_AST_PRINT: + zend_compile_print(result, ast TSRMLS_CC); + return; + case ZEND_AST_EXIT: + zend_compile_exit(result, ast TSRMLS_CC); + return; + case ZEND_AST_YIELD: + zend_compile_yield(result, ast TSRMLS_CC); + return; + case ZEND_AST_INSTANCEOF: + zend_compile_instanceof(result, ast TSRMLS_CC); + return; + case ZEND_AST_INCLUDE_OR_EVAL: + zend_compile_include_or_eval(result, ast TSRMLS_CC); + return; + case ZEND_AST_ISSET: + case ZEND_AST_EMPTY: + zend_compile_isset_or_empty(result, ast TSRMLS_CC); + return; + case ZEND_AST_SILENCE: + zend_compile_silence(result, ast TSRMLS_CC); + return; + case ZEND_AST_SHELL_EXEC: + zend_compile_shell_exec(result, ast TSRMLS_CC); + return; + case ZEND_AST_ARRAY: + zend_compile_array(result, ast TSRMLS_CC); + return; + case ZEND_AST_CONST: + zend_compile_const(result, ast TSRMLS_CC); + return; + case ZEND_AST_CLASS_CONST: + zend_compile_class_const(result, ast TSRMLS_CC); + return; + case ZEND_AST_RESOLVE_CLASS_NAME: + zend_compile_resolve_class_name(result, ast TSRMLS_CC); + return; + case ZEND_AST_ENCAPS_LIST: + zend_compile_encaps_list(result, ast TSRMLS_CC); + return; + case ZEND_AST_MAGIC_CONST: + zend_compile_magic_const(result, ast TSRMLS_CC); + return; + case ZEND_AST_CLOSURE: + zend_compile_func_decl(result, ast TSRMLS_CC); + return; + default: + ZEND_ASSERT(0 /* not supported */); } - 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; - } -#else - path[0] = '.'; - path[1] = '\0'; - return 1 + len_adjust; -#endif +} + +void zend_compile_var(znode *result, zend_ast *ast, int type TSRMLS_DC) { + switch (ast->kind) { + case ZEND_AST_VAR: + zend_compile_simple_var(result, ast, type TSRMLS_CC); + return; + case ZEND_AST_DIM: + zend_compile_dim(result, ast, type TSRMLS_CC); + return; + case ZEND_AST_PROP: + zend_compile_prop(result, ast, type TSRMLS_CC); + return; + case ZEND_AST_STATIC_PROP: + zend_compile_static_prop(result, ast, type TSRMLS_CC); + return; + case ZEND_AST_CALL: + zend_compile_call(result, ast, type TSRMLS_CC); + return; + case ZEND_AST_METHOD_CALL: + zend_compile_method_call(result, ast, type TSRMLS_CC); + return; + case ZEND_AST_STATIC_CALL: + zend_compile_static_call(result, ast, type TSRMLS_CC); + 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 + ) { + /* For BC reasons =& new Foo is allowed */ + if (type != BP_VAR_REF || ast->kind != ZEND_AST_NEW) { + zend_error_noreturn(E_COMPILE_ERROR, + "Cannot use temporary expression in write context"); + } + } + + zend_compile_expr(result, ast TSRMLS_CC); + return; } +} - /* Strip slashes which came before the file name */ - while (end >= path && IS_SLASH_P(end)) { - end--; +void zend_delayed_compile_var(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC) { + zend_op *opline; + switch (ast->kind) { + case ZEND_AST_DIM: + opline = zend_delayed_compile_dim(result, ast, type TSRMLS_CC); + zend_adjust_for_fetch_type(opline, type); + return; + case ZEND_AST_PROP: + opline = zend_delayed_compile_prop(result, ast, type TSRMLS_CC); + zend_adjust_for_fetch_type(opline, type); + return; + default: + zend_compile_var(result, ast, type TSRMLS_CC); + return; } - if (end < path) { - path[0] = DEFAULT_SLASH; - path[1] = '\0'; - return 1 + len_adjust; +} + +void zend_eval_const_expr(zend_ast **ast_ptr TSRMLS_DC) { + zend_ast *ast = *ast_ptr; + zval result; + + if (!ast) { + return; } - *(end+1) = '\0'; - return (size_t)(end + 1 - path) + len_adjust; + switch (ast->kind) { + case ZEND_AST_BINARY_OP: + zend_eval_const_expr(&ast->child[0] TSRMLS_CC); + zend_eval_const_expr(&ast->child[1] TSRMLS_CC); + if (ast->child[0]->kind != ZEND_AST_ZVAL || ast->child[1]->kind != ZEND_AST_ZVAL) { + return; + } + + zend_ct_eval_binary_op(&result, ast->attr, + zend_ast_get_zval(ast->child[0]), zend_ast_get_zval(ast->child[1]) TSRMLS_CC); + break; + case ZEND_AST_GREATER: + case ZEND_AST_GREATER_EQUAL: + zend_eval_const_expr(&ast->child[0] TSRMLS_CC); + zend_eval_const_expr(&ast->child[1] TSRMLS_CC); + 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]) TSRMLS_CC); + break; + case ZEND_AST_UNARY_PLUS: + case ZEND_AST_UNARY_MINUS: + zend_eval_const_expr(&ast->child[0] TSRMLS_CC); + if (ast->child[0]->kind != ZEND_AST_ZVAL) { + return; + } + + zend_ct_eval_unary_pm(&result, ast->kind, + zend_ast_get_zval(ast->child[0]) TSRMLS_CC); + break; + case ZEND_AST_ARRAY: + if (!zend_try_ct_eval_array(&result, ast TSRMLS_CC)) { + return; + } + break; + case ZEND_AST_MAGIC_CONST: + if (!zend_try_ct_eval_magic_const(&result, ast TSRMLS_CC)) { + return; + } + break; + default: + return; + } + + zend_ast_destroy(ast); + *ast_ptr = zend_ast_create_zval(&result); } -/* }}} */ /* * Local variables: |