}
/* }}} */
- #define REALLOC_BUF_IF_EXCEED(buf, offset, length, size) \
- if (UNEXPECTED(offset - buf + size >= length)) { \
- length += size + 1; \
- buf = erealloc(buf, length); \
+ 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 {
+ return ZEND_FETCH_CLASS_DEFAULT;
}
+ }
- static char * zend_get_function_declaration(zend_function *fptr TSRMLS_DC) /* {{{ */
+ ZEND_API zend_string *zend_get_compiled_variable_name(const zend_op_array *op_array, uint32_t var) /* {{{ */
{
- char *offset, *buf;
- uint32_t length = 1024;
+ return op_array->vars[EX_VAR_TO_NUM(var)];
+ }
+ /* }}} */
- offset = buf = (char *)emalloc(length * sizeof(char));
- if (fptr->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE) {
- *(offset++) = '&';
- *(offset++) = ' ';
+ 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);
+
+ 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)) {
+ list = zend_ast_list_add(list, zend_ast_create_zval_from_str(CG(doc_comment)));
+ CG(doc_comment) = NULL;
}
- if (fptr->common.scope) {
- memcpy(offset, fptr->common.scope->name->val, fptr->common.scope->name->len);
- offset += fptr->common.scope->name->len;
- *(offset++) = ':';
- *(offset++) = ':';
+ 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 {}");
}
+ }
+ /* }}} */
- {
- size_t name_len = fptr->common.function_name->len;
- REALLOC_BUF_IF_EXCEED(buf, offset, length, name_len);
- memcpy(offset, fptr->common.function_name->val, name_len);
- offset += name_len;
+ 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;
}
- *(offset++) = '(';
- if (fptr->common.arg_info) {
- uint32_t i, required;
- zend_arg_info *arg_info = fptr->common.arg_info;
+ if (CG(current_import_function)) {
+ zend_hash_destroy(CG(current_import_function));
+ efree(CG(current_import_function));
+ CG(current_import_function) = NULL;
+ }
- required = fptr->common.required_num_args;
- for (i = 0; i < fptr->common.num_args;) {
- if (arg_info->class_name) {
- const char *class_name;
- uint32_t class_name_len;
- if (!strcasecmp(arg_info->class_name, "self") && fptr->common.scope ) {
- class_name = fptr->common.scope->name->val;
- class_name_len = fptr->common.scope->name->len;
- } else if (!strcasecmp(arg_info->class_name, "parent") && fptr->common.scope->parent) {
- class_name = fptr->common.scope->parent->name->val;
- class_name_len = fptr->common.scope->parent->name->len;
- } else {
- class_name = arg_info->class_name;
- class_name_len = arg_info->class_name_len;
- }
- REALLOC_BUF_IF_EXCEED(buf, offset, length, class_name_len);
- memcpy(offset, class_name, class_name_len);
- offset += class_name_len;
- *(offset++) = ' ';
- } else if (arg_info->type_hint) {
- uint32_t type_name_len;
- char *type_name = zend_get_type_by_const(arg_info->type_hint);
- type_name_len = strlen(type_name);
- REALLOC_BUF_IF_EXCEED(buf, offset, length, type_name_len);
- memcpy(offset, type_name, type_name_len);
- offset += type_name_len;
- *(offset++) = ' ';
- }
+ if (CG(current_import_const)) {
+ zend_hash_destroy(CG(current_import_const));
+ efree(CG(current_import_const));
+ CG(current_import_const) = NULL;
+ }
+ }
- if (arg_info->pass_by_reference) {
- *(offset++) = '&';
- }
+ 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;
+ }
+ }
- if (arg_info->is_variadic) {
- *(offset++) = '.';
- *(offset++) = '.';
- *(offset++) = '.';
- }
+ void zend_do_end_compilation(TSRMLS_D) /* {{{ */
+ {
+ CG(has_bracketed_namespaces) = 0;
+ zend_end_namespace(TSRMLS_C);
+ }
+ /* }}} */
- *(offset++) = '$';
+ /* {{{ zend_dirname
+ Returns directory name component of path */
+ ZEND_API size_t zend_dirname(char *path, size_t len)
+ {
+ register char *end = path + len - 1;
+ unsigned int len_adjust = 0;
- if (arg_info->name) {
- REALLOC_BUF_IF_EXCEED(buf, offset, length, arg_info->name_len);
- memcpy(offset, arg_info->name, arg_info->name_len);
- offset += arg_info->name_len;
- } else {
- uint32_t idx = i;
- memcpy(offset, "param", 5);
- offset += 5;
- do {
- *(offset++) = (char) (idx % 10) + '0';
- idx /= 10;
- } while (idx > 0);
- }
- if (i >= required && !arg_info->is_variadic) {
- *(offset++) = ' ';
- *(offset++) = '=';
- *(offset++) = ' ';
- if (fptr->type == ZEND_USER_FUNCTION) {
- zend_op *precv = NULL;
- {
- uint32_t idx = i;
- zend_op *op = ((zend_op_array *)fptr)->opcodes;
- zend_op *end = op + ((zend_op_array *)fptr)->last;
+ #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;
+ }
+ }
+ #elif defined(NETWARE)
+ /*
+ * Find the first occurrence of : from the left
+ * move the path pointer to the position just after :
+ * increment the len_adjust to the length of path till colon character(inclusive)
+ * If there is no character beyond : simple return len
+ */
+ char *colonpos = NULL;
+ colonpos = strchr(path, ':');
+ if (colonpos != NULL) {
+ len_adjust = ((colonpos - path) + 1);
+ path += len_adjust;
+ if (len_adjust == len) {
+ return len;
+ }
+ }
+ #endif
+
+ if (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
+ }
+
+ /* 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';
+
+ return (size_t)(end + 1 - path) + len_adjust;
+ }
+ /* }}} */
+
+ 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);
+ }
+
+ #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()
+ }
+ }
+
+ 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);
+ }
- ++idx;
- while (op < end) {
- if ((op->opcode == ZEND_RECV || op->opcode == ZEND_RECV_INIT)
- && op->op1.num == (zend_long)idx)
- {
- precv = op;
- }
- ++op;
- }
- }
- if (precv && precv->opcode == ZEND_RECV_INIT && precv->op2_type != IS_UNUSED) {
- zval *zv = precv->op2.zv;
+ 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 (Z_TYPE_P(zv) == IS_CONSTANT) {
- REALLOC_BUF_IF_EXCEED(buf, offset, length, Z_STRLEN_P(zv));
- memcpy(offset, Z_STRVAL_P(zv), Z_STRLEN_P(zv));
- offset += Z_STRLEN_P(zv);
- } else if (Z_TYPE_P(zv) == IS_FALSE) {
- memcpy(offset, "false", 5);
- offset += 5;
- } else if (Z_TYPE_P(zv) == IS_TRUE) {
- memcpy(offset, "true", 4);
- offset += 4;
- } else if (Z_TYPE_P(zv) == IS_NULL) {
- memcpy(offset, "NULL", 4);
- offset += 4;
- } else if (Z_TYPE_P(zv) == IS_STRING) {
- *(offset++) = '\'';
- REALLOC_BUF_IF_EXCEED(buf, offset, length, MIN(Z_STRLEN_P(zv), 10));
- memcpy(offset, Z_STRVAL_P(zv), MIN(Z_STRLEN_P(zv), 10));
- offset += MIN(Z_STRLEN_P(zv), 10);
- if (Z_STRLEN_P(zv) > 10) {
- *(offset++) = '.';
- *(offset++) = '.';
- *(offset++) = '.';
- }
- *(offset++) = '\'';
- } else if (Z_TYPE_P(zv) == IS_ARRAY) {
- memcpy(offset, "Array", 5);
- offset += 5;
- } else if (Z_TYPE_P(zv) == IS_CONSTANT_AST) {
- memcpy(offset, "<expression>", 12);
- offset += 12;
- } else {
- zend_string *str = zval_get_string(zv);
- REALLOC_BUF_IF_EXCEED(buf, offset, length, str->len);
- memcpy(offset, str->val, str->len);
- offset += str->len;
- zend_string_release(str);
- }
- }
- } else {
- memcpy(offset, "NULL", 4);
- offset += 4;
- }
- }
+ if (op1 == NULL) {
+ SET_UNUSED(opline->op1);
+ } else {
+ SET_NODE(opline->op1, op1);
+ }
- if (++i < fptr->common.num_args) {
- *(offset++) = ',';
- *(offset++) = ' ';
- }
- arg_info++;
- REALLOC_BUF_IF_EXCEED(buf, offset, length, 32);
- }
+ if (op2 == NULL) {
+ SET_UNUSED(opline->op2);
+ } else {
+ SET_NODE(opline->op2, op2);
}
- *(offset++) = ')';
- *offset = '\0';
- return buf;
+ if (result) {
+ zend_make_var_result(result, opline TSRMLS_CC);
+ }
+ return opline;
}
- /* }}} */
- static void do_inheritance_check_on_method(zend_function *child, zend_function *parent TSRMLS_DC) /* {{{ */
- {
- uint32_t child_flags;
- uint32_t parent_flags = parent->common.fn_flags;
+ 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;
- if ((parent->common.scope->ce_flags & ZEND_ACC_INTERFACE) == 0
- && parent->common.fn_flags & ZEND_ACC_ABSTRACT
- && parent->common.scope != (child->common.prototype ? child->common.prototype->common.scope : child->common.scope)
- && child->common.fn_flags & (ZEND_ACC_ABSTRACT|ZEND_ACC_IMPLEMENTED_ABSTRACT)) {
- zend_error_noreturn(E_COMPILE_ERROR, "Can't inherit abstract function %s::%s() (previously declared abstract in %s)",
- parent->common.scope->name->val,
- child->common.function_name->val,
- child->common.prototype ? child->common.prototype->common.scope->name->val : child->common.scope->name->val);
+ if (op1 == NULL) {
+ SET_UNUSED(opline->op1);
+ } else {
+ SET_NODE(opline->op1, op1);
}
- if (parent_flags & ZEND_ACC_FINAL) {
- zend_error_noreturn(E_COMPILE_ERROR, "Cannot override final method %s::%s()", ZEND_FN_SCOPE_NAME(parent), child->common.function_name->val);
+ if (op2 == NULL) {
+ SET_UNUSED(opline->op2);
+ } else {
+ SET_NODE(opline->op2, op2);
}
- child_flags = child->common.fn_flags;
- /* You cannot change from static to non static and vice versa.
- */
- if ((child_flags & ZEND_ACC_STATIC) != (parent_flags & ZEND_ACC_STATIC)) {
- if (child->common.fn_flags & ZEND_ACC_STATIC) {
- zend_error_noreturn(E_COMPILE_ERROR, "Cannot make non static method %s::%s() static in class %s", ZEND_FN_SCOPE_NAME(parent), child->common.function_name->val, ZEND_FN_SCOPE_NAME(child));
- } else {
- zend_error_noreturn(E_COMPILE_ERROR, "Cannot make static method %s::%s() non static in class %s", ZEND_FN_SCOPE_NAME(parent), child->common.function_name->val, ZEND_FN_SCOPE_NAME(child));
- }
+ 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;
+ 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()
+ }
+ }
+
+ 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);
+ }
+
+ 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);
}
- /* Disallow making an inherited method abstract. */
- if ((child_flags & ZEND_ACC_ABSTRACT) && !(parent_flags & ZEND_ACC_ABSTRACT)) {
- zend_error_noreturn(E_COMPILE_ERROR, "Cannot make non abstract method %s::%s() abstract in class %s", ZEND_FN_SCOPE_NAME(parent), child->common.function_name->val, ZEND_FN_SCOPE_NAME(child));
+ 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;
+ }
- if (parent_flags & ZEND_ACC_CHANGED) {
- child->common.fn_flags |= ZEND_ACC_CHANGED;
+ 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;
+
+ zn.op_type = IS_CONST;
+ if (zv) {
+ ZVAL_COPY_VALUE(&zn.u.constant, zv);
} else {
- /* Prevent derived classes from restricting access that was available in parent classes
- */
- if ((child_flags & ZEND_ACC_PPP_MASK) > (parent_flags & ZEND_ACC_PPP_MASK)) {
- zend_error_noreturn(E_COMPILE_ERROR, "Access level to %s::%s() must be %s (as in class %s)%s", ZEND_FN_SCOPE_NAME(child), child->common.function_name->val, zend_visibility_string(parent_flags), ZEND_FN_SCOPE_NAME(parent), (parent_flags&ZEND_ACC_PUBLIC) ? "" : " or weaker");
- } else if (((child_flags & ZEND_ACC_PPP_MASK) < (parent_flags & ZEND_ACC_PPP_MASK))
- && ((parent_flags & ZEND_ACC_PPP_MASK) & ZEND_ACC_PRIVATE)) {
- child->common.fn_flags |= ZEND_ACC_CHANGED;
- }
+ ZVAL_NULL(&zn.u.constant);
}
- if (parent_flags & ZEND_ACC_PRIVATE) {
- child->common.prototype = NULL;
- } else if (parent_flags & ZEND_ACC_ABSTRACT) {
- child->common.fn_flags |= ZEND_ACC_IMPLEMENTED_ABSTRACT;
- child->common.prototype = parent;
- } else if (!(parent->common.fn_flags & ZEND_ACC_CTOR) || (parent->common.prototype && (parent->common.prototype->common.scope->ce_flags & ZEND_ACC_INTERFACE))) {
- /* ctors only have a prototype if it comes from an interface */
- child->common.prototype = parent->common.prototype ? parent->common.prototype : parent;
+ zend_emit_op(NULL, returns_reference ? ZEND_RETURN_BY_REF : ZEND_RETURN, &zn, NULL TSRMLS_CC);
+ }
+
+
+ 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 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;
+ }
+
+ static inline zend_bool zend_is_unticked_stmt(zend_ast *ast) {
+ return ast->kind == ZEND_AST_STMT_LIST || ast->kind == ZEND_AST_LABEL;
+ }
+
+ 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 (child->common.prototype && (child->common.prototype->common.fn_flags & ZEND_ACC_ABSTRACT)) {
- if (!zend_do_perform_implementation_check(child, child->common.prototype TSRMLS_CC)) {
- zend_error_noreturn(E_COMPILE_ERROR, "Declaration of %s::%s() must be compatible with %s", ZEND_FN_SCOPE_NAME(child), child->common.function_name->val, zend_get_function_declaration(child->common.prototype TSRMLS_CC));
- }
- } else if (EG(error_reporting) & E_STRICT || Z_TYPE(EG(user_error_handler)) != IS_UNDEF) { /* Check E_STRICT (or custom error handler) before the check so that we save some time */
- if (!zend_do_perform_implementation_check(child, parent TSRMLS_CC)) {
- char *method_prototype = zend_get_function_declaration(parent TSRMLS_CC);
- zend_error(E_STRICT, "Declaration of %s::%s() should be compatible with %s", ZEND_FN_SCOPE_NAME(child), child->common.function_name->val, method_prototype);
- efree(method_prototype);
- }
+ 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;
+ }
+
+ /* 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 zend_bool do_inherit_method_check(HashTable *child_function_table, zend_function *parent, zend_string *key, zend_class_entry *child_ce) /* {{{ */
- {
- uint32_t parent_flags = parent->common.fn_flags;
- zend_function *child;
- TSRMLS_FETCH();
+ 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 ((child = zend_hash_find_ptr(child_function_table, key)) == NULL) {
- if (parent_flags & (ZEND_ACC_ABSTRACT)) {
- child_ce->ce_flags |= ZEND_ACC_IMPLICIT_ABSTRACT_CLASS;
+ if (ZEND_HANDLE_NUMERIC(Z_STR(node->u.constant), index)) {
+ zval_ptr_dtor(&node->u.constant);
+ ZVAL_LONG(&node->u.constant, index);
}
- return 1; /* method doesn't exist in child, copy from parent */
}
+ }
- do_inheritance_check_on_method(child, parent TSRMLS_CC);
-
- return 0;
+ 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_bool do_inherit_property_access_check(HashTable *target_ht, zend_property_info *parent_info, zend_string *key, zend_class_entry *ce TSRMLS_DC) /* {{{ */
- {
- zend_property_info *child_info;
- zend_class_entry *parent_ce = ce->parent;
+ 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 (parent_info->flags & (ZEND_ACC_PRIVATE|ZEND_ACC_SHADOW)) {
- if ((child_info = zend_hash_find_ptr(&ce->properties_info, key)) != NULL) {
- child_info->flags |= ZEND_ACC_CHANGED;
- } else {
- if(ce->type & ZEND_INTERNAL_CLASS) {
- child_info = zend_duplicate_property_info_internal(parent_info);
- } else {
- child_info = zend_duplicate_property_info(parent_info TSRMLS_CC);
- }
- zend_hash_update_ptr(&ce->properties_info, key, child_info);
- child_info->flags &= ~ZEND_ACC_PRIVATE; /* it's not private anymore */
- child_info->flags |= ZEND_ACC_SHADOW; /* but it's a shadow of private */
+ 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 0; /* don't copy access information to child */
+
+ 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;
}
- if ((child_info = zend_hash_find_ptr(&ce->properties_info, key)) != NULL) {
- if ((parent_info->flags & ZEND_ACC_STATIC) != (child_info->flags & ZEND_ACC_STATIC)) {
- zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare %s%s::$%s as %s%s::$%s",
- (parent_info->flags & ZEND_ACC_STATIC) ? "static " : "non static ", parent_ce->name->val, key->val,
- (child_info->flags & ZEND_ACC_STATIC) ? "static " : "non static ", ce->name->val, key->val);
+ 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;
}
- if(parent_info->flags & ZEND_ACC_CHANGED) {
- child_info->flags |= ZEND_ACC_CHANGED;
+ 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 FAILURE;
+ }
+
+ 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;
+
+ /* 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);
+ }
+
+ zend_compile_expr(&name_node, name_ast TSRMLS_CC);
- if ((child_info->flags & ZEND_ACC_PPP_MASK) > (parent_info->flags & ZEND_ACC_PPP_MASK)) {
- zend_error_noreturn(E_COMPILE_ERROR, "Access level to %s::$%s must be %s (as in class %s)%s", ce->name->val, key->val, zend_visibility_string(parent_info->flags), parent_ce->name->val, (parent_info->flags&ZEND_ACC_PUBLIC) ? "" : " or weaker");
- } else if ((child_info->flags & ZEND_ACC_STATIC) == 0) {
- zval_ptr_dtor(&(ce->default_properties_table[parent_info->offset]));
- ce->default_properties_table[parent_info->offset] = ce->default_properties_table[child_info->offset];
- ZVAL_UNDEF(&ce->default_properties_table[child_info->offset]);
- child_info->offset = parent_info->offset;
+ 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;
}
- return 0; /* Don't copy from parent */
- } else {
- return 1; /* Copy from parent */
}
+
+ return opline;
}
- /* }}} */
- static inline void do_implement_interface(zend_class_entry *ce, zend_class_entry *iface TSRMLS_DC) /* {{{ */
- {
- if (!(ce->ce_flags & ZEND_ACC_INTERFACE) && iface->interface_gets_implemented && iface->interface_gets_implemented(iface, ce TSRMLS_CC) == FAILURE) {
- zend_error(E_CORE_ERROR, "Class %s could not implement interface %s", ce->name->val, iface->name->val);
+ 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 (ce == iface) {
- zend_error(E_ERROR, "Interface %s cannot implement itself", ce->name->val);
+ }
+
+ 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;
}
}
- /* }}} */
- ZEND_API void zend_do_inherit_interfaces(zend_class_entry *ce, const zend_class_entry *iface TSRMLS_DC) /* {{{ */
- {
- /* expects interface to be contained in ce's interface list already */
- uint32_t i, ce_num, if_num = iface->num_interfaces;
- zend_class_entry *entry;
+ void zend_delayed_compile_var(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC);
- if (if_num==0) {
- return;
- }
- ce_num = ce->num_interfaces;
+ 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];
- if (ce->type == ZEND_INTERNAL_CLASS) {
- ce->interfaces = (zend_class_entry **) realloc(ce->interfaces, sizeof(zend_class_entry *) * (ce_num + if_num));
- } else {
- ce->interfaces = (zend_class_entry **) erealloc(ce->interfaces, sizeof(zend_class_entry *) * (ce_num + if_num));
- }
+ znode var_node, dim_node;
- /* Inherit the interfaces, only if they're not already inherited by the class */
- while (if_num--) {
- entry = iface->interfaces[if_num];
- for (i = 0; i < ce_num; i++) {
- if (ce->interfaces[i] == entry) {
- break;
- }
+ 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 (i == ce_num) {
- ce->interfaces[ce->num_interfaces++] = entry;
+ if (type == BP_VAR_UNSET) {
+ zend_error_noreturn(E_COMPILE_ERROR, "Cannot use [] for unsetting");
}
+ dim_node.op_type = IS_UNUSED;
+ } else {
+ zend_compile_expr(&dim_node, dim_ast TSRMLS_CC);
+ zend_handle_numeric_op(&dim_node TSRMLS_CC);
}
- /* and now call the implementing handlers */
- while (ce_num < ce->num_interfaces) {
- do_implement_interface(ce, ce->interfaces[ce_num++] TSRMLS_CC);
- }
+ return zend_delayed_emit_op(result, ZEND_FETCH_DIM_R, &var_node, &dim_node TSRMLS_CC);
}
- /* }}} */
- #ifdef ZTS
- # define zval_property_ctor(parent_ce, ce) \
- (((parent_ce)->type != (ce)->type) ? ZVAL_COPY_CTOR : zval_add_ref)
- #else
- # define zval_property_ctor(parent_ce, ce) \
- zval_add_ref
- #endif
+ 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);
+ }
- static void do_inherit_class_constant(zend_string *name, zval *zv, zend_class_entry *ce, zend_class_entry *parent_ce TSRMLS_DC) /* {{{ */
- {
- if (!Z_ISREF_P(zv)) {
- if (parent_ce->type == ZEND_INTERNAL_CLASS) {
- ZVAL_NEW_PERSISTENT_REF(zv, zv);
- } else {
- ZVAL_NEW_REF(zv, zv);
- }
- }
- if (Z_CONSTANT_P(Z_REFVAL_P(zv))) {
- ce->ce_flags &= ~ZEND_ACC_CONSTANTS_UPDATED;
- }
- if (zend_hash_add(&ce->constants_table, name, zv)) {
- Z_ADDREF_P(zv);
+ 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");
}
+
+ return 0;
}
- /* }}} */
- ZEND_API void zend_do_inheritance(zend_class_entry *ce, zend_class_entry *parent_ce TSRMLS_DC) /* {{{ */
- {
- zend_property_info *property_info;
- zend_function *func;
- zend_string *key;
- zval *zv;
+ 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];
- if ((ce->ce_flags & ZEND_ACC_INTERFACE)
- && !(parent_ce->ce_flags & ZEND_ACC_INTERFACE)) {
- zend_error_noreturn(E_COMPILE_ERROR, "Interface %s may not inherit from class (%s)", ce->name->val, parent_ce->name->val);
- }
- if (parent_ce->ce_flags & ZEND_ACC_FINAL_CLASS) {
- zend_error_noreturn(E_COMPILE_ERROR, "Class %s may not inherit from final class (%s)", ce->name->val, parent_ce->name->val);
- }
+ znode obj_node, prop_node;
+ zend_op *opline;
- ce->parent = parent_ce;
- /* Copy serialize/unserialize callbacks */
- if (!ce->serialize) {
- ce->serialize = parent_ce->serialize;
+ 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);
}
- if (!ce->unserialize) {
- ce->unserialize = parent_ce->unserialize;
+ zend_compile_expr(&prop_node, prop_ast TSRMLS_CC);
+
+ 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);
}
- /* Inherit interfaces */
- zend_do_inherit_interfaces(ce, parent_ce TSRMLS_CC);
+ return opline;
+ }
- /* Inherit properties */
- if (parent_ce->default_properties_count) {
- int i = ce->default_properties_count + parent_ce->default_properties_count;
+ 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);
+ }
- ce->default_properties_table = perealloc(ce->default_properties_table, sizeof(zval) * i, ce->type == ZEND_INTERNAL_CLASS);
- if (ce->default_properties_count) {
- while (i-- > parent_ce->default_properties_count) {
- ce->default_properties_table[i] = ce->default_properties_table[i - parent_ce->default_properties_count];
- }
- }
- for (i = 0; i < parent_ce->default_properties_count; i++) {
- #ifdef ZTS
- if (parent_ce->type != ce->type) {
- ZVAL_DUP(&ce->default_properties_table[i], &parent_ce->default_properties_table[i]);
- if (Z_OPT_CONSTANT(ce->default_properties_table[i])) {
- ce->ce_flags &= ~ZEND_ACC_CONSTANTS_UPDATED;
- }
- continue;
- }
- #endif
+ 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);
+ }
- ZVAL_COPY(&ce->default_properties_table[i], &parent_ce->default_properties_table[i]);
- if (Z_OPT_CONSTANT(ce->default_properties_table[i])) {
- ce->ce_flags &= ~ZEND_ACC_CONSTANTS_UPDATED;
- }
- }
- ce->default_properties_count += parent_ce->default_properties_count;
- }
+ 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];
- if (parent_ce->type != ce->type) {
- /* User class extends internal class */
- zend_update_class_constants(parent_ce TSRMLS_CC);
- if (parent_ce->default_static_members_count) {
- int i = ce->default_static_members_count + parent_ce->default_static_members_count;
+ znode class_node, prop_node;
+ zend_op *opline;
- ce->default_static_members_table = erealloc(ce->default_static_members_table, sizeof(zval) * i);
- if (ce->default_static_members_count) {
- while (i-- > parent_ce->default_static_members_count) {
- ce->default_static_members_table[i] = ce->default_static_members_table[i - parent_ce->default_static_members_count];
- }
- }
- for (i = 0; i < parent_ce->default_static_members_count; i++) {
- ZVAL_MAKE_REF(&CE_STATIC_MEMBERS(parent_ce)[i]);
- ce->default_static_members_table[i] = CE_STATIC_MEMBERS(parent_ce)[i];
- Z_ADDREF(ce->default_static_members_table[i]);
- if (Z_CONSTANT_P(Z_REFVAL(ce->default_static_members_table[i]))) {
- ce->ce_flags &= ~ZEND_ACC_CONSTANTS_UPDATED;
- }
- }
- ce->default_static_members_count += parent_ce->default_static_members_count;
- ce->static_members_table = ce->default_static_members_table;
- }
+ 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 {
- if (parent_ce->default_static_members_count) {
- int i = ce->default_static_members_count + parent_ce->default_static_members_count;
-
- ce->default_static_members_table = perealloc(ce->default_static_members_table, sizeof(zval) * i, ce->type == ZEND_INTERNAL_CLASS);
- if (ce->default_static_members_count) {
- while (i-- > parent_ce->default_static_members_count) {
- ce->default_static_members_table[i] = ce->default_static_members_table[i - parent_ce->default_static_members_count];
- }
- }
- for (i = 0; i < parent_ce->default_static_members_count; i++) {
- ZVAL_MAKE_REF(&parent_ce->default_static_members_table[i]);
- ce->default_static_members_table[i] = parent_ce->default_static_members_table[i];
- Z_ADDREF(ce->default_static_members_table[i]);
- if (Z_CONSTANT_P(Z_REFVAL(ce->default_static_members_table[i]))) {
- ce->ce_flags &= ~ZEND_ACC_CONSTANTS_UPDATED;
- }
- }
- ce->default_static_members_count += parent_ce->default_static_members_count;
- if (ce->type == ZEND_USER_CLASS) {
- ce->static_members_table = ce->default_static_members_table;
- }
- }
+ zend_compile_class_ref(&class_node, class_ast TSRMLS_CC);
}
- ZEND_HASH_FOREACH_PTR(&ce->properties_info, property_info) {
- if (property_info->ce == ce) {
- if (property_info->flags & ZEND_ACC_STATIC) {
- property_info->offset += parent_ce->default_static_members_count;
- } else {
- property_info->offset += parent_ce->default_properties_count;
- }
- }
- } ZEND_HASH_FOREACH_END();
-
- ZEND_HASH_FOREACH_STR_KEY_PTR(&parent_ce->properties_info, key, property_info) {
- if (do_inherit_property_access_check(&ce->properties_info, property_info, key, ce TSRMLS_CC)) {
- if (ce->type & ZEND_INTERNAL_CLASS) {
- property_info = zend_duplicate_property_info_internal(property_info);
- } else {
- property_info = zend_duplicate_property_info(property_info TSRMLS_CC);
- }
- zend_hash_add_new_ptr(&ce->properties_info, key, property_info);
- }
- } ZEND_HASH_FOREACH_END();
+ zend_compile_expr(&prop_node, prop_ast TSRMLS_CC);
- ZEND_HASH_FOREACH_STR_KEY_VAL(&parent_ce->constants_table, key, zv) {
- do_inherit_class_constant(key, zv, ce, parent_ce TSRMLS_CC);
- } ZEND_HASH_FOREACH_END();
+ 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);
+ }
+ 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;
- ZEND_HASH_FOREACH_STR_KEY_PTR(&parent_ce->function_table, key, func) {
- if (do_inherit_method_check(&ce->function_table, func, key, ce)) {
- zend_function *new_func = do_inherit_method(func TSRMLS_CC);
- zend_hash_add_new_ptr(&ce->function_table, key, new_func);
- }
- } ZEND_HASH_FOREACH_END();
+ return opline;
+ }
- do_inherit_parent_constructor(ce TSRMLS_CC);
+ 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);
+ }
- if (ce->ce_flags & ZEND_ACC_IMPLICIT_ABSTRACT_CLASS && ce->type == ZEND_INTERNAL_CLASS) {
- ce->ce_flags |= ZEND_ACC_EXPLICIT_ABSTRACT_CLASS;
- } else if (!(ce->ce_flags & (ZEND_ACC_IMPLEMENT_INTERFACES|ZEND_ACC_IMPLEMENT_TRAITS))) {
- /* The verification will be done in runtime by ZEND_VERIFY_ABSTRACT_CLASS */
- zend_verify_abstract_class(ce TSRMLS_CC);
+ 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()
}
- ce->ce_flags |= parent_ce->ce_flags & ZEND_HAS_STATIC_IN_METHODS;
}
- /* }}} */
- static zend_bool do_inherit_constant_check(HashTable *child_constants_table, zval *parent_constant, zend_string *name, const zend_class_entry *iface) /* {{{ */
- {
- zval *old_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 ((old_constant = zend_hash_find(child_constants_table, name)) != NULL) {
- if (!Z_ISREF_P(old_constant) ||
- !Z_ISREF_P(parent_constant) ||
- Z_REFVAL_P(old_constant) != Z_REFVAL_P(parent_constant)) {
- zend_error_noreturn(E_COMPILE_ERROR, "Cannot inherit previously-inherited or override constant %s from interface %s", name->val, iface->name->val);
- }
- return 0;
+ if (list->children == 1 && !list->child[0]) {
+ zend_error_noreturn(E_COMPILE_ERROR, "Cannot use empty list");
}
- return 1;
- }
- /* }}} */
- static void do_inherit_iface_constant(zend_string *name, zval *zv, zend_class_entry *ce, zend_class_entry *iface TSRMLS_DC) /* {{{ */
- {
- if (do_inherit_constant_check(&ce->constants_table, zv, name, iface)) {
- ZVAL_MAKE_REF(zv);
- Z_ADDREF_P(zv);
- if (Z_CONSTANT_P(Z_REFVAL_P(zv))) {
- ce->ce_flags &= ~ZEND_ACC_CONSTANTS_UPDATED;
+ 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");
+ }
+ 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);
}
- zend_hash_update(&ce->constants_table, name, zv);
}
+ *result = *expr_node;
}
- /* }}} */
- ZEND_API void zend_do_implement_interface(zend_class_entry *ce, zend_class_entry *iface TSRMLS_DC) /* {{{ */
- {
- uint32_t i, ignore = 0;
- uint32_t current_iface_num = ce->num_interfaces;
- uint32_t parent_iface_num = ce->parent ? ce->parent->num_interfaces : 0;
- zend_function *func;
- zend_string *key;
- zval *zv;
+ 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");
+ }
+ }
- for (i = 0; i < ce->num_interfaces; i++) {
- if (ce->interfaces[i] == NULL) {
- memmove(ce->interfaces + i, ce->interfaces + i + 1, sizeof(zend_class_entry*) * (--ce->num_interfaces - i));
- i--;
- } else if (ce->interfaces[i] == iface) {
- if (i < parent_iface_num) {
- ignore = 1;
- } else {
- zend_error_noreturn(E_COMPILE_ERROR, "Class %s cannot implement previously implemented interface %s", ce->name->val, iface->name->val);
- }
- }
+ /* 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;
}
- if (ignore) {
- /* Check for attempt to redeclare interface constants */
- ZEND_HASH_FOREACH_STR_KEY_VAL(&ce->constants_table, key, zv) {
- do_inherit_constant_check(&iface->constants_table, zv, key, iface);
- } ZEND_HASH_FOREACH_END();
- } else {
- if (ce->num_interfaces >= current_iface_num) {
- if (ce->type == ZEND_INTERNAL_CLASS) {
- ce->interfaces = (zend_class_entry **) realloc(ce->interfaces, sizeof(zend_class_entry *) * (++current_iface_num));
- } else {
- ce->interfaces = (zend_class_entry **) erealloc(ce->interfaces, sizeof(zend_class_entry *) * (++current_iface_num));
- }
- }
- ce->interfaces[ce->num_interfaces++] = iface;
- ZEND_HASH_FOREACH_STR_KEY_VAL(&iface->constants_table, key, zv) {
- do_inherit_iface_constant(key, zv, ce, iface TSRMLS_CC);
- } ZEND_HASH_FOREACH_END();
+ while (zend_is_variable(var_ast) && var_ast->kind != ZEND_AST_VAR) {
+ var_ast = var_ast->child[0];
+ }
- ZEND_HASH_FOREACH_STR_KEY_PTR(&iface->function_table, key, func) {
- if (do_inherit_method_check(&ce->function_table, func, key, ce)) {
- zend_function *new_func = do_inherit_method(func TSRMLS_CC);
- zend_hash_add_new_ptr(&ce->function_table, key, new_func);
- }
- } ZEND_HASH_FOREACH_END();
+ if (var_ast->kind != ZEND_AST_VAR || var_ast->child[0]->kind != ZEND_AST_ZVAL) {
+ return 0;
+ }
- do_implement_interface(ce, iface TSRMLS_CC);
- zend_do_inherit_interfaces(ce, iface TSRMLS_CC);
+ {
+ 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;
}
}
- /* }}} */
- ZEND_API void zend_do_implement_trait(zend_class_entry *ce, zend_class_entry *trait TSRMLS_DC) /* {{{ */
- {
- uint32_t i, ignore = 0;
- uint32_t current_trait_num = ce->num_traits;
- uint32_t parent_trait_num = ce->parent ? ce->parent->num_traits : 0;
+ 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];
- for (i = 0; i < ce->num_traits; i++) {
- if (ce->traits[i] == NULL) {
- memmove(ce->traits + i, ce->traits + i + 1, sizeof(zend_class_entry*) * (--ce->num_traits - i));
- i--;
- } else if (ce->traits[i] == trait) {
- if (i < parent_trait_num) {
- ignore = 1;
- }
- }
+ 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");
}
- if (!ignore) {
- if (ce->num_traits >= current_trait_num) {
- if (ce->type == ZEND_INTERNAL_CLASS) {
- ce->traits = (zend_class_entry **) realloc(ce->traits, sizeof(zend_class_entry *) * (++current_trait_num));
+
+ 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 {
- ce->traits = (zend_class_entry **) erealloc(ce->traits, sizeof(zend_class_entry *) * (++current_trait_num));
+ zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
}
- }
- ce->traits[ce->num_traits++] = trait;
+
+ opline = zend_delayed_compile_end(offset TSRMLS_CC);
+ opline->opcode = 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_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();
}
}
- /* }}} */
-
- static zend_bool zend_traits_method_compatibility_check(zend_function *fn, zend_function *other_fn TSRMLS_DC) /* {{{ */
- {
- uint32_t fn_flags = fn->common.scope->ce_flags;
- uint32_t other_flags = other_fn->common.scope->ce_flags;
- return zend_do_perform_implementation_check(fn, other_fn TSRMLS_CC)
- && ((other_fn->common.scope->ce_flags & ZEND_ACC_INTERFACE) || zend_do_perform_implementation_check(other_fn, fn TSRMLS_CC))
- && ((fn_flags & (ZEND_ACC_FINAL|ZEND_ACC_STATIC)) ==
- (other_flags & (ZEND_ACC_FINAL|ZEND_ACC_STATIC))); /* equal final and static qualifier */
+ static 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);
}
- /* }}} */
- static void zend_add_magic_methods(zend_class_entry* ce, zend_string* mname, zend_function* fe TSRMLS_DC) /* {{{ */
- {
- if (!strncmp(mname->val, ZEND_CLONE_FUNC_NAME, mname->len)) {
- ce->clone = fe; fe->common.fn_flags |= ZEND_ACC_CLONE;
- } else if (!strncmp(mname->val, ZEND_CONSTRUCTOR_FUNC_NAME, mname->len)) {
- if (ce->constructor) {
- zend_error_noreturn(E_COMPILE_ERROR, "%s has colliding constructor definitions coming from traits", ce->name->val);
- }
- ce->constructor = fe; fe->common.fn_flags |= ZEND_ACC_CTOR;
- } else if (!strncmp(mname->val, ZEND_DESTRUCTOR_FUNC_NAME, mname->len)) {
- ce->destructor = fe; fe->common.fn_flags |= ZEND_ACC_DTOR;
- } else if (!strncmp(mname->val, ZEND_GET_FUNC_NAME, mname->len)) {
- ce->__get = fe;
- } else if (!strncmp(mname->val, ZEND_SET_FUNC_NAME, mname->len)) {
- ce->__set = fe;
- } else if (!strncmp(mname->val, ZEND_CALL_FUNC_NAME, mname->len)) {
- ce->__call = fe;
- } else if (!strncmp(mname->val, ZEND_UNSET_FUNC_NAME, mname->len)) {
- ce->__unset = fe;
- } else if (!strncmp(mname->val, ZEND_ISSET_FUNC_NAME, mname->len)) {
- ce->__isset = fe;
- } else if (!strncmp(mname->val, ZEND_CALLSTATIC_FUNC_NAME, mname->len)) {
- ce->__callstatic = fe;
- } else if (!strncmp(mname->val, ZEND_TOSTRING_FUNC_NAME, mname->len)) {
- ce->__tostring = fe;
- } else if (!strncmp(mname->val, ZEND_DEBUGINFO_FUNC_NAME, mname->len)) {
- ce->__debugInfo = fe;
- } else if (ce->name->len == mname->len) {
- zend_string *lowercase_name = zend_string_alloc(ce->name->len, 0);
- zend_str_tolower_copy(lowercase_name->val, ce->name->val, ce->name->len);
- lowercase_name = zend_new_interned_string(lowercase_name TSRMLS_CC);
- if (!memcmp(mname->val, lowercase_name->val, mname->len)) {
- if (ce->constructor) {
- zend_error_noreturn(E_COMPILE_ERROR, "%s has colliding constructor definitions coming from traits", ce->name->val);
- }
- ce->constructor = fe;
- fe->common.fn_flags |= ZEND_ACC_CTOR;
- }
- zend_string_release(lowercase_name);
+ 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;
}
}
- /* }}} */
- static void zend_add_trait_method(zend_class_entry *ce, const char *name, zend_string *key, zend_function *fn, HashTable **overriden TSRMLS_DC) /* {{{ */
- {
- zend_function *existing_fn = NULL;
- zend_function *new_fn;
+ 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);
+ }
- if ((existing_fn = zend_hash_find_ptr(&ce->function_table, key)) != NULL) {
- if (existing_fn->common.scope == ce) {
- /* members from the current class override trait methods */
- /* use temporary *overriden HashTable to detect hidden conflict */
- if (*overriden) {
- if ((existing_fn = zend_hash_find_ptr(*overriden, key)) != NULL) {
- if (existing_fn->common.fn_flags & ZEND_ACC_ABSTRACT) {
- /* Make sure the trait method is compatible with previosly declared abstract method */
- if (!zend_traits_method_compatibility_check(fn, existing_fn TSRMLS_CC)) {
- zend_error_noreturn(E_COMPILE_ERROR, "Declaration of %s must be compatible with %s",
- zend_get_function_declaration(fn TSRMLS_CC),
- zend_get_function_declaration(existing_fn TSRMLS_CC));
- }
- } else if (fn->common.fn_flags & ZEND_ACC_ABSTRACT) {
- /* Make sure the abstract declaration is compatible with previous declaration */
- if (!zend_traits_method_compatibility_check(existing_fn, fn TSRMLS_CC)) {
- zend_error_noreturn(E_COMPILE_ERROR, "Declaration of %s must be compatible with %s",
- zend_get_function_declaration(fn TSRMLS_CC),
- zend_get_function_declaration(existing_fn TSRMLS_CC));
- }
- return;
- }
- }
- } else {
- ALLOC_HASHTABLE(*overriden);
- zend_hash_init_ex(*overriden, 8, NULL, ptr_dtor, 0, 0);
- }
- fn = zend_hash_update_mem(*overriden, key, fn, sizeof(zend_function));
+ 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;
+
+ zend_ensure_writable_variable(var_ast);
+
+ switch (var_ast->kind) {
+ case ZEND_AST_VAR:
+ case ZEND_AST_STATIC_PROP:
+ zend_compile_var(&var_node, var_ast, BP_VAR_RW TSRMLS_CC);
+ zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
+ zend_emit_op(result, opcode, &var_node, &expr_node TSRMLS_CC);
return;
- } else if (existing_fn->common.fn_flags & ZEND_ACC_ABSTRACT) {
- /* Make sure the trait method is compatible with previosly declared abstract method */
- if (!zend_traits_method_compatibility_check(fn, existing_fn TSRMLS_CC)) {
- zend_error_noreturn(E_COMPILE_ERROR, "Declaration of %s must be compatible with %s",
- zend_get_function_declaration(fn TSRMLS_CC),
- zend_get_function_declaration(existing_fn TSRMLS_CC));
- }
- } else if (fn->common.fn_flags & ZEND_ACC_ABSTRACT) {
- /* Make sure the abstract declaration is compatible with previous declaration */
- if (!zend_traits_method_compatibility_check(existing_fn, fn TSRMLS_CC)) {
- zend_error_noreturn(E_COMPILE_ERROR, "Declaration of %s must be compatible with %s",
- zend_get_function_declaration(fn TSRMLS_CC),
- zend_get_function_declaration(existing_fn TSRMLS_CC));
- }
+ 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;
- } else if ((existing_fn->common.scope->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) {
- /* two traits can't define the same non-abstract method */
- #if 1
- zend_error_noreturn(E_COMPILE_ERROR, "Trait method %s has not been applied, because there are collisions with other trait methods on %s",
- name, ce->name->val);
- #else /* TODO: better error message */
- zend_error_noreturn(E_COMPILE_ERROR, "Trait method %s::%s has not been applied as %s::%s, because of collision with %s::%s",
- fn->common.scope->name->val, fn->common.function_name->val,
- ce->name->val, name,
- existing_fn->common.scope->name->val, existing_fn->common.function_name->val);
- #endif
- } else {
- /* inherited members are overridden by members inserted by traits */
- /* check whether the trait method fulfills the inheritance requirements */
- do_inheritance_check_on_method(fn, existing_fn TSRMLS_CC);
- }
- }
+ 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);
- function_add_ref(fn);
- new_fn = zend_arena_alloc(&CG(arena), sizeof(zend_op_array));
- memcpy(new_fn, fn, sizeof(zend_op_array));
- fn = zend_hash_update_ptr(&ce->function_table, key, new_fn);
- zend_add_magic_methods(ce, key, fn 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()
+ }
}
- /* }}} */
- static void zend_fixup_trait_method(zend_function *fn, zend_class_entry *ce) /* {{{ */
- {
- if ((fn->common.scope->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) {
+ 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 */
- fn->common.scope = ce;
+ for (i = 0; i < args->children; ++i) {
+ zend_ast *arg = args->child[i];
+ uint32_t arg_num = i + 1;
- if (fn->common.fn_flags & ZEND_ACC_ABSTRACT) {
- ce->ce_flags |= ZEND_ACC_IMPLICIT_ABSTRACT_CLASS;
+ znode arg_node;
+ zend_op *opline;
+ zend_uchar opcode;
+ zend_ulong flags = 0;
+
+ 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 (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;
+ }
+ }
}
- if (fn->op_array.static_variables) {
- ce->ce_flags |= ZEND_HAS_STATIC_IN_METHODS;
+
+ 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;
}
}
+
+ return arg_count;
}
- /* }}} */
- static int zend_traits_copy_functions(zend_string *fnname, zend_function *fn, zend_class_entry *ce, HashTable **overriden, HashTable *exclude_table TSRMLS_DC) /* {{{ */
- {
- zend_trait_alias *alias, **alias_ptr;
- zend_string *lcname;
- zend_function fn_copy;
+ 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;
- /* apply aliases which are qualified with a class name, there should not be any ambiguity */
- if (ce->trait_aliases) {
- alias_ptr = ce->trait_aliases;
- alias = *alias_ptr;
- while (alias) {
- /* Scope unset or equal to the function we compare to, and the alias applies to fn */
- if (alias->alias != NULL
- && (!alias->trait_method->ce || fn->common.scope == alias->trait_method->ce)
- && alias->trait_method->method_name->len == fnname->len
- && (zend_binary_strcasecmp(alias->trait_method->method_name->val, alias->trait_method->method_name->len, fnname->val, fnname->len) == 0)) {
- fn_copy = *fn;
+ zend_do_extended_fcall_begin(TSRMLS_C);
- /* if it is 0, no modifieres has been changed */
- if (alias->modifiers) {
- fn_copy.common.fn_flags = alias->modifiers | (fn->common.fn_flags ^ (fn->common.fn_flags & ZEND_ACC_PPP_MASK));
- }
+ arg_count = zend_compile_args(args_ast, fbc TSRMLS_CC);
- lcname = zend_string_alloc(alias->alias->len, 0);
- zend_str_tolower_copy(lcname->val, alias->alias->val, alias->alias->len);
- zend_add_trait_method(ce, alias->alias->val, lcname, &fn_copy, overriden TSRMLS_CC);
- zend_string_release(lcname);
+ opline = &CG(active_op_array)->opcodes[opnum_init];
+ opline->extended_value = arg_count;
- /* Record the trait from which this alias was resolved. */
- if (!alias->trait_method->ce) {
- alias->trait_method->ce = fn->common.scope;
- }
- }
- alias_ptr++;
- alias = *alias_ptr;
- }
- }
+ 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;
- if (exclude_table == NULL || zend_hash_find(exclude_table, fnname) == NULL) {
- /* is not in hashtable, thus, function is not to be excluded */
- fn_copy = *fn;
+ zend_do_extended_fcall_end(TSRMLS_C);
+ }
- /* apply aliases which have not alias name, just setting visibility */
- if (ce->trait_aliases) {
- alias_ptr = ce->trait_aliases;
- alias = *alias_ptr;
- while (alias) {
- /* Scope unset or equal to the function we compare to, and the alias applies to fn */
- if (alias->alias == NULL && alias->modifiers != 0
- && (!alias->trait_method->ce || fn->common.scope == alias->trait_method->ce)
- && (alias->trait_method->method_name->len == fnname->len)
- && (zend_binary_strcasecmp(alias->trait_method->method_name->val, alias->trait_method->method_name->len, fnname->val, fnname->len) == 0)) {
+ 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;
- fn_copy.common.fn_flags = alias->modifiers | (fn->common.fn_flags ^ (fn->common.fn_flags & ZEND_ACC_PPP_MASK));
+ 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));
- /** Record the trait from which this alias was resolved. */
- if (!alias->trait_method->ce) {
- alias->trait_method->ce = fn->common.scope;
- }
- }
- alias_ptr++;
- alias = *alias_ptr;
- }
- }
+ return !is_fully_qualified && CG(current_namespace);
+ }
- zend_add_trait_method(ce, fn->common.function_name->val, fnname, &fn_copy, overriden TSRMLS_CC);
+ 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);
}
- return ZEND_HASH_APPLY_KEEP;
+ zend_compile_call_common(result, args_ast, NULL TSRMLS_CC);
}
- /* }}} */
- static void zend_check_trait_usage(zend_class_entry *ce, zend_class_entry *trait TSRMLS_DC) /* {{{ */
- {
+ static zend_bool zend_args_contain_unpack(zend_ast_list *args) {
uint32_t i;
-
- if ((trait->ce_flags & ZEND_ACC_TRAIT) != ZEND_ACC_TRAIT) {
- zend_error_noreturn(E_COMPILE_ERROR, "Class %s is not a trait, Only traits may be used in 'as' and 'insteadof' statements", trait->name->val);
+ for (i = 0; i < args->children; ++i) {
+ if (args->child[i]->kind == ZEND_AST_UNPACK) {
+ return 1;
+ }
}
+ return 0;
+ }
- for (i = 0; i < ce->num_traits; i++) {
- if (ce->traits[i] == trait) {
- return;
- }
+ int zend_compile_func_strlen(znode *result, zend_ast_list *args TSRMLS_DC) {
+ znode arg_node;
+
+ if ((CG(compiler_options) & ZEND_COMPILE_NO_BUILTIN_STRLEN)
+ || args->children != 1 || args->child[0]->kind == ZEND_AST_UNPACK
+ ) {
+ return FAILURE;
}
- zend_error_noreturn(E_COMPILE_ERROR, "Required Trait %s wasn't added to %s", trait->name->val, ce->name->val);
+
+ zend_compile_expr(&arg_node, args->child[0] TSRMLS_CC);
+ zend_emit_op(result, ZEND_STRLEN, &arg_node, NULL TSRMLS_CC);
+ return SUCCESS;
}
- /* }}} */
- static void zend_traits_init_trait_structures(zend_class_entry *ce TSRMLS_DC) /* {{{ */
- {
- size_t i, j = 0;
- zend_trait_precedence *cur_precedence;
- zend_trait_method_reference *cur_method_ref;
- zend_string *lcname;
- zend_bool method_exists;
+ int zend_compile_func_typecheck(znode *result, zend_ast_list *args, uint32_t type TSRMLS_DC) {
+ znode arg_node;
+ zend_op *opline;
- /* resolve class references */
- if (ce->trait_precedences) {
- i = 0;
- while ((cur_precedence = ce->trait_precedences[i])) {
- /** Resolve classes for all precedence operations. */
- if (cur_precedence->exclude_from_classes) {
- cur_method_ref = cur_precedence->trait_method;
- if (!(cur_precedence->trait_method->ce = zend_fetch_class(cur_method_ref->class_name,
- ZEND_FETCH_CLASS_TRAIT|ZEND_FETCH_CLASS_NO_AUTOLOAD TSRMLS_CC))) {
- zend_error_noreturn(E_COMPILE_ERROR, "Could not find trait %s", cur_method_ref->class_name->val);
- }
- zend_check_trait_usage(ce, cur_precedence->trait_method->ce TSRMLS_CC);
+ if (args->children != 1 || args->child[0]->kind == ZEND_AST_UNPACK) {
+ return FAILURE;
+ }
+
+ 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;
+ }
- /** Ensure that the prefered method is actually available. */
- lcname = zend_string_alloc(cur_method_ref->method_name->len, 0);
- zend_str_tolower_copy(lcname->val,
- cur_method_ref->method_name->val,
- cur_method_ref->method_name->len);
- method_exists = zend_hash_exists(&cur_method_ref->ce->function_table,
- lcname);
- zend_string_free(lcname);
- if (!method_exists) {
- zend_error_noreturn(E_COMPILE_ERROR,
- "A precedence rule was defined for %s::%s but this method does not exist",
- cur_method_ref->ce->name->val,
- cur_method_ref->method_name->val);
- }
+ int zend_compile_func_defined(znode *result, zend_ast_list *args TSRMLS_DC) {
+ zend_string *name;
+ zend_op *opline;
- /** With the other traits, we are more permissive.
- We do not give errors for those. This allows to be more
- defensive in such definitions.
- However, we want to make sure that the insteadof declaration
- is consistent in itself.
- */
- j = 0;
- while (cur_precedence->exclude_from_classes[j].class_name) {
- zend_string* class_name = cur_precedence->exclude_from_classes[j].class_name;
+ if (args->children != 1 || args->child[0]->kind != ZEND_AST_ZVAL) {
+ return FAILURE;
+ }
- if (!(cur_precedence->exclude_from_classes[j].ce = zend_fetch_class(class_name, ZEND_FETCH_CLASS_TRAIT |ZEND_FETCH_CLASS_NO_AUTOLOAD TSRMLS_CC))) {
- zend_error_noreturn(E_COMPILE_ERROR, "Could not find trait %s", class_name->val);
- }
- zend_check_trait_usage(ce, cur_precedence->exclude_from_classes[j].ce TSRMLS_CC);
+ 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;
+ }
- /* make sure that the trait method is not from a class mentioned in
- exclude_from_classes, for consistency */
- if (cur_precedence->trait_method->ce == cur_precedence->exclude_from_classes[i].ce) {
- zend_error_noreturn(E_COMPILE_ERROR,
- "Inconsistent insteadof definition. "
- "The method %s is to be used from %s, but %s is also on the exclude list",
- cur_method_ref->method_name->val,
- cur_precedence->trait_method->ce->name->val,
- cur_precedence->trait_method->ce->name->val);
- }
+ 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_string_release(class_name);
- j++;
- }
- }
- i++;
- }
+ /* 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 (ce->trait_aliases) {
- i = 0;
- while (ce->trait_aliases[i]) {
- /** For all aliases with an explicit class name, resolve the class now. */
- if (ce->trait_aliases[i]->trait_method->class_name) {
- cur_method_ref = ce->trait_aliases[i]->trait_method;
- if (!(cur_method_ref->ce = zend_fetch_class(cur_method_ref->class_name, ZEND_FETCH_CLASS_TRAIT|ZEND_FETCH_CLASS_NO_AUTOLOAD TSRMLS_CC))) {
- zend_error_noreturn(E_COMPILE_ERROR, "Could not find trait %s", cur_method_ref->class_name->val);
- }
- zend_check_trait_usage(ce, cur_method_ref->ce TSRMLS_CC);
+ 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;
- /** And, ensure that the referenced method is resolvable, too. */
- lcname = zend_string_alloc(cur_method_ref->method_name->len, 0);
- zend_str_tolower_copy(lcname->val,
- cur_method_ref->method_name->val,
- cur_method_ref->method_name->len);
- method_exists = zend_hash_exists(&cur_method_ref->ce->function_table,
- lcname);
- zend_string_free(lcname);
+ if (name_ast->kind != ZEND_AST_CONST || Z_TYPE_P(zend_ast_get_zval(name_ast)) != IS_STRING) {
+ return FAILURE;
+ }
- if (!method_exists) {
- zend_error_noreturn(E_COMPILE_ERROR, "An alias was defined for %s::%s but this method does not exist", cur_method_ref->ce->name->val, cur_method_ref->method_name->val);
- }
- }
- i++;
- }
+ name = zend_ast_get_str(name_ast);
+ lcname = zend_string_alloc(name->len, 0);
+ zend_str_tolower_copy(lcname->val, name->val, name->len);
+
+ 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, lcname);
+ opline->extended_value = num_args;
+
+ return SUCCESS;
}
- /* }}} */
- static void zend_traits_compile_exclude_table(HashTable* exclude_table, zend_trait_precedence **precedences, zend_class_entry *trait) /* {{{ */
- {
- size_t i = 0, j;
+ 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 (!precedences) {
+ if (zend_try_compile_ct_bound_init_user_func(result, name_ast, num_args TSRMLS_CC) == SUCCESS) {
return;
}
- while (precedences[i]) {
- if (precedences[i]->exclude_from_classes) {
- j = 0;
- while (precedences[i]->exclude_from_classes[j].ce) {
- if (precedences[i]->exclude_from_classes[j].ce == trait) {
- zend_string *lcname = zend_string_alloc(precedences[i]->trait_method->method_name->len, 0);
-
- zend_str_tolower_copy(lcname->val,
- precedences[i]->trait_method->method_name->val,
- precedences[i]->trait_method->method_name->len);
- if (zend_hash_add_empty_element(exclude_table, lcname) == NULL) {
- zend_string_release(lcname);
- zend_error_noreturn(E_COMPILE_ERROR, "Failed to evaluate a trait precedence (%s). Method of trait %s was defined to be excluded multiple times", precedences[i]->trait_method->method_name->val, trait->name->val);
- }
- zend_string_release(lcname);
- }
- ++j;
- }
- }
- ++i;
+
+ 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;
+ }
+
+ /* cufa = call_user_func_array */
+ int zend_compile_func_cufa(znode *result, zend_ast_list *args, zend_string *lcname TSRMLS_DC) {
+ znode arg_node;
+
+ if (args->children != 2 || zend_args_contain_unpack(args)) {
+ return FAILURE;
}
+
+ 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;
}
- /* }}} */
- static void zend_do_traits_method_binding(zend_class_entry *ce TSRMLS_DC) /* {{{ */
- {
+ /* cuf = call_user_func */
+ int zend_compile_func_cuf(znode *result, zend_ast_list *args, zend_string *lcname TSRMLS_DC) {
uint32_t i;
- HashTable *overriden = NULL;
- zend_string *key;
- zend_function *fn;
-
- for (i = 0; i < ce->num_traits; i++) {
- if (ce->trait_precedences) {
- HashTable exclude_table;
- /* TODO: revisit this start size, may be its not optimal */
- zend_hash_init_ex(&exclude_table, 8, NULL, NULL, 0, 0);
+ if (args->children < 1 || zend_args_contain_unpack(args)) {
+ return FAILURE;
+ }
- zend_traits_compile_exclude_table(&exclude_table, ce->trait_precedences, ce->traits[i]);
+ 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;
- /* copies functions, applies defined aliasing, and excludes unused trait methods */
- ZEND_HASH_FOREACH_STR_KEY_PTR(&ce->traits[i]->function_table, key, fn) {
- zend_traits_copy_functions(key, fn, ce, &overriden, &exclude_table TSRMLS_CC);
- } ZEND_HASH_FOREACH_END();
+ 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;
+ }
+ }
- zend_hash_destroy(&exclude_table);
+ if (send_user) {
+ opline = zend_emit_op(NULL, ZEND_SEND_USER, &arg_node, NULL TSRMLS_CC);
} else {
- ZEND_HASH_FOREACH_STR_KEY_PTR(&ce->traits[i]->function_table, key, fn) {
- zend_traits_copy_functions(key, fn, ce, &overriden, NULL TSRMLS_CC);
- } ZEND_HASH_FOREACH_END();
+ opline = zend_emit_op(NULL, ZEND_SEND_VAL, &arg_node, NULL TSRMLS_CC);
}
+
+ opline->op2.opline_num = i;
}
+ zend_emit_op(result, ZEND_DO_FCALL, NULL, NULL TSRMLS_CC);
- ZEND_HASH_FOREACH_PTR(&ce->function_table, fn) {
- zend_fixup_trait_method(fn, ce);
- } ZEND_HASH_FOREACH_END();
+ return SUCCESS;
+ }
- if (overriden) {
- zend_hash_destroy(overriden);
- FREE_HASHTABLE(overriden);
+ 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 {
+ return FAILURE;
}
}
- /* }}} */
- static zend_class_entry* find_first_definition(zend_class_entry *ce, size_t current_trait, zend_string *prop_name, zend_class_entry *coliding_ce) /* {{{ */
- {
- size_t i;
+ 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];
- if (coliding_ce == ce) {
- for (i = 0; i < current_trait; i++) {
- if (zend_hash_exists(&ce->traits[i]->properties_info, prop_name)) {
- return ce->traits[i];
- }
- }
+ 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;
}
- return coliding_ce;
- }
- /* }}} */
+ {
+ 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;
+ }
+ }
- static void zend_do_traits_property_binding(zend_class_entry *ce TSRMLS_DC) /* {{{ */
- {
- size_t i;
- zend_property_info *property_info;
- zend_property_info *coliding_prop;
- zval compare_result;
- zend_string* prop_name;
- const char* class_name_unused;
- zend_bool not_compatible;
- zval* prop_value;
- uint32_t flags;
- zend_string *doc_comment;
+ {
+ zval *name = &name_node.u.constant;
+ zend_string *lcname = zend_string_alloc(Z_STRLEN_P(name), 0);
+ zend_function *fbc;
+ zend_op *opline;
- /* In the following steps the properties are inserted into the property table
- * for that, a very strict approach is applied:
- * - check for compatibility, if not compatible with any property in class -> fatal
- * - if compatible, then strict notice
- */
- for (i = 0; i < ce->num_traits; i++) {
- ZEND_HASH_FOREACH_PTR(&ce->traits[i]->properties_info, property_info) {
- /* first get the unmangeld name if necessary,
- * then check whether the property is already there
- */
- flags = property_info->flags;
- if ((flags & ZEND_ACC_PPP_MASK) == ZEND_ACC_PUBLIC) {
- prop_name = zend_string_copy(property_info->name);
- } else {
- const char *pname;
- int pname_len;
+ zend_str_tolower_copy(lcname->val, Z_STRVAL_P(name), Z_STRLEN_P(name));
- /* for private and protected we need to unmangle the names */
- zend_unmangle_property_name_ex(property_info->name->val, property_info->name->len,
- &class_name_unused, &pname, &pname_len);
- prop_name = zend_string_init(pname, pname_len, 0);
- }
+ fbc = zend_hash_find_ptr(CG(function_table), lcname);
+ if (!fbc || (fbc->type == ZEND_INTERNAL_FUNCTION &&
+ (CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_FUNCTIONS))
+ ) {
+ zend_string_release(lcname);
+ zend_compile_dynamic_call(result, &name_node, args_ast TSRMLS_CC);
+ return;
+ }
- /* next: check for conflicts with current class */
- if ((coliding_prop = zend_hash_find_ptr(&ce->properties_info, prop_name)) != NULL) {
- if (coliding_prop->flags & ZEND_ACC_SHADOW) {
- zend_hash_del(&ce->properties_info, prop_name);
- flags |= ZEND_ACC_CHANGED;
- } else {
- if ((coliding_prop->flags & (ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC))
- == (flags & (ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC))) {
- /* flags are identical, now the value needs to be checked */
- if (flags & ZEND_ACC_STATIC) {
- not_compatible = (FAILURE == compare_function(&compare_result,
- &ce->default_static_members_table[coliding_prop->offset],
- &ce->traits[i]->default_static_members_table[property_info->offset] TSRMLS_CC))
- || (Z_LVAL(compare_result) != 0);
- } else {
- not_compatible = (FAILURE == compare_function(&compare_result,
- &ce->default_properties_table[coliding_prop->offset],
- &ce->traits[i]->default_properties_table[property_info->offset] TSRMLS_CC))
- || (Z_LVAL(compare_result) != 0);
- }
- } else {
- /* the flags are not identical, thus, we assume properties are not compatible */
- not_compatible = 1;
- }
+ if (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;
+ }
- if (not_compatible) {
- zend_error_noreturn(E_COMPILE_ERROR,
- "%s and %s define the same property ($%s) in the composition of %s. However, the definition differs and is considered incompatible. Class was composed",
- find_first_definition(ce, i, prop_name, coliding_prop->ce)->name->val,
- property_info->ce->name->val,
- prop_name->val,
- ce->name->val);
- } else {
- zend_error(E_STRICT,
- "%s and %s define the same property ($%s) in the composition of %s. This might be incompatible, to improve maintainability consider using accessor methods in traits instead. Class was composed",
- find_first_definition(ce, i, prop_name, coliding_prop->ce)->name->val,
- property_info->ce->name->val,
- prop_name->val,
- ce->name->val);
- zend_string_release(prop_name);
- continue;
- }
- }
- }
+ zval_ptr_dtor(&name_node.u.constant);
+ ZVAL_NEW_STR(&name_node.u.constant, lcname);
- /* property not found, so lets add it */
- if (flags & ZEND_ACC_STATIC) {
- prop_value = &ce->traits[i]->default_static_members_table[property_info->offset];
- } else {
- prop_value = &ce->traits[i]->default_properties_table[property_info->offset];
- }
- if (Z_REFCOUNTED_P(prop_value)) Z_ADDREF_P(prop_value);
+ opline = zend_emit_op(NULL, ZEND_INIT_FCALL, NULL, &name_node TSRMLS_CC);
+ zend_alloc_cache_slot(opline->op2.constant TSRMLS_CC);
- doc_comment = property_info->doc_comment ? zend_string_copy(property_info->doc_comment) : NULL;
- zend_declare_property_ex(ce, prop_name,
- prop_value, flags,
- doc_comment TSRMLS_CC);
- zend_string_release(prop_name);
- } ZEND_HASH_FOREACH_END();
+ zend_compile_call_common(result, args_ast, fbc TSRMLS_CC);
}
}
- /* }}} */
-
- static void zend_do_check_for_inconsistent_traits_aliasing(zend_class_entry *ce TSRMLS_DC) /* {{{ */
- {
- int i = 0;
- zend_trait_alias* cur_alias;
- zend_string* lc_method_name;
- if (ce->trait_aliases) {
- while (ce->trait_aliases[i]) {
- cur_alias = ce->trait_aliases[i];
- /** The trait for this alias has not been resolved, this means, this
- alias was not applied. Abort with an error. */
- if (!cur_alias->trait_method->ce) {
- if (cur_alias->alias) {
- /** Plain old inconsistency/typo/bug */
- zend_error_noreturn(E_COMPILE_ERROR,
- "An alias (%s) was defined for method %s(), but this method does not exist",
- cur_alias->alias->val,
- cur_alias->trait_method->method_name->val);
- } else {
- /** Here are two possible cases:
- 1) this is an attempt to modifiy the visibility
- of a method introduce as part of another alias.
- Since that seems to violate the DRY principle,
- we check against it and abort.
- 2) it is just a plain old inconsitency/typo/bug
- as in the case where alias is set. */
+ 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];
- lc_method_name = zend_string_alloc(cur_alias->trait_method->method_name->len, 0);
- zend_str_tolower_copy(
- lc_method_name->val,
- cur_alias->trait_method->method_name->val,
- cur_alias->trait_method->method_name->len);
- if (zend_hash_exists(&ce->function_table,
- lc_method_name)) {
- zend_string_free(lc_method_name);
- zend_error_noreturn(E_COMPILE_ERROR,
- "The modifiers for the trait alias %s() need to be changed in the same statment in which the alias is defined. Error",
- cur_alias->trait_method->method_name->val);
- } else {
- zend_string_free(lc_method_name);
- zend_error_noreturn(E_COMPILE_ERROR,
- "The modifiers of the trait method %s() are changed, but this method does not exist. Error",
- cur_alias->trait_method->method_name->val);
+ znode obj_node, method_node;
+ zend_op *opline;
- }
- }
- }
- i++;
- }
+ if (is_this_fetch(obj_ast)) {
+ obj_node.op_type = IS_UNUSED;
+ } else {
+ zend_compile_var(&obj_node, obj_ast, type TSRMLS_CC);
}
- }
- /* }}} */
- ZEND_API void zend_do_bind_traits(zend_class_entry *ce TSRMLS_DC) /* {{{ */
- {
+ 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");
+ }
- if (ce->num_traits <= 0) {
- return;
+ 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);
}
- /* complete initialization of trait strutures in ce */
- zend_traits_init_trait_structures(ce TSRMLS_CC);
-
- /* first care about all methods to be flattened into the class */
- zend_do_traits_method_binding(ce TSRMLS_CC);
+ zend_compile_call_common(result, args_ast, NULL TSRMLS_CC);
+ }
- /* Aliases which have not been applied indicate typos/bugs. */
- zend_do_check_for_inconsistent_traits_aliasing(ce TSRMLS_CC);
+ zend_bool zend_is_constructor(zend_string *name) {
+ return zend_str_equals_literal_ci(name, ZEND_CONSTRUCTOR_FUNC_NAME);
+ }
- /* then flatten the properties into it, to, mostly to notfiy developer about problems */
- zend_do_traits_property_binding(ce TSRMLS_CC);
+ 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];
- /* verify that all abstract methods from traits have been implemented */
- zend_verify_abstract_class(ce TSRMLS_CC);
+ znode class_node, method_node;
+ zend_op *opline;
+ zend_ulong extended_value = 0;
- /* now everything should be fine and an added ZEND_ACC_IMPLICIT_ABSTRACT_CLASS should be removed */
- if (ce->ce_flags & ZEND_ACC_IMPLICIT_ABSTRACT_CLASS) {
- ce->ce_flags -= ZEND_ACC_IMPLICIT_ABSTRACT_CLASS;
+ 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_API int do_bind_function(const zend_op_array *op_array, zend_op *opline, HashTable *function_table, zend_bool compile_time TSRMLS_DC) /* {{{ */
- {
- zend_function *function, *new_function;
- zval *op1, *op2;
- if (compile_time) {
- op1 = &CONSTANT_EX(op_array, opline->op1.constant);
- op2 = &CONSTANT_EX(op_array, opline->op2.constant);
- } else {
- op1 = opline->op1.zv;
- op2 = opline->op2.zv;
+ zend_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;
+ }
}
- function = zend_hash_find_ptr(function_table, Z_STR_P(op1));
- new_function = zend_arena_alloc(&CG(arena), sizeof(zend_op_array));
- memcpy(new_function, function, sizeof(zend_op_array));
- if (zend_hash_add_ptr(function_table, Z_STR_P(op2), new_function) == NULL) {
- int error_level = compile_time ? E_COMPILE_ERROR : E_ERROR;
- zend_function *old_function;
+ opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+ opline->opcode = ZEND_INIT_STATIC_METHOD_CALL;
+ opline->extended_value = extended_value;
- efree(new_function);
- if ((old_function = zend_hash_find_ptr(function_table, Z_STR_P(op2))) != NULL
- && old_function->type == ZEND_USER_FUNCTION
- && old_function->op_array.last > 0) {
- zend_error(error_level, "Cannot redeclare %s() (previously declared in %s:%d)",
- function->common.function_name->val,
- old_function->op_array.filename->val,
- old_function->op_array.opcodes[0].lineno);
+ 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_error(error_level, "Cannot redeclare %s()", function->common.function_name->val);
+ zend_alloc_polymorphic_cache_slot(opline->op2.constant TSRMLS_CC);
}
- return FAILURE;
} else {
- (*function->op_array.refcount)++;
- function->op_array.static_variables = NULL; /* NULL out the unbound function */
- return SUCCESS;
+ SET_NODE(opline->op2, &method_node);
}
+
+ zend_compile_call_common(result, args_ast, NULL TSRMLS_CC);
}
- /* }}} */
- 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;
+ 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];
- /* 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;
- }
+ znode class_node, ctor_result;
+ zend_op *opline;
+ uint32_t opnum;
- method_ref->method_name = Z_STR(method_name->u.constant);
+ zend_compile_class_ref(&class_node, class_ast TSRMLS_CC);
- result->u.op.ptr = method_ref;
- result->op_type = IS_TMP_VAR;
+ 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_trait_alias(znode *method_reference, znode *modifiers, znode *alias TSRMLS_DC) /* {{{ */
- {
- zend_class_entry *ce = CG(active_class_entry);
- zend_trait_alias *trait_alias;
+ void zend_compile_clone(znode *result, zend_ast *ast TSRMLS_DC) {
+ zend_ast *obj_ast = ast->child[0];
- 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;
+ 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);
+ }
}
- 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);
+ if (zend_try_compile_cv(&result, var_ast TSRMLS_CC) == SUCCESS) {
+ zend_emit_op(NULL, ZEND_BIND_GLOBAL, &result, &name_node TSRMLS_CC);
} else {
- trait_alias->alias = NULL;
+ zend_emit_op(&result, ZEND_FETCH_W, &name_node, NULL TSRMLS_CC);
+
+ // TODO.AST Avoid double fetch
+ //opline->extended_value = ZEND_FETCH_GLOBAL_LOCK;
+
+ zend_emit_assign_ref_znode(var_ast, &result TSRMLS_CC);
}
- 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));
+ 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;
+
+ 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;
+ }
+ 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(var_node.u.constant), value);
- trait_precedence->trait_method = (zend_trait_method_reference*)method_reference->u.op.ptr;
- trait_precedence->exclude_from_classes = trait_list->u.op.ptr;
+ opline = zend_emit_op(&result, by_ref ? ZEND_FETCH_W : ZEND_FETCH_R, &var_node, NULL TSRMLS_CC);
+ opline->extended_value = ZEND_FETCH_STATIC;
- zend_add_to_list(&ce->trait_precedences, trait_precedence TSRMLS_CC);
+ 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);
+ }
}
- /* }}} */
- 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;
- zval *op1, *op2;
+ 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;
- if (compile_time) {
- op1 = &CONSTANT_EX(op_array, opline->op1.constant);
- op2 = &CONSTANT_EX(op_array, opline->op2.constant);
+ if (value_ast) {
+ zend_const_expr_to_zval(&value_zv, value_ast TSRMLS_CC);
} else {
- op1 = opline->op1.zv;
- op2 = opline->op2.zv;
+ ZVAL_NULL(&value_zv);
}
- if ((ce = zend_hash_find_ptr(class_table, Z_STR_P(op1))) == NULL) {
- zend_error_noreturn(E_COMPILE_ERROR, "Internal Zend error - Missing class information for %s", Z_STRVAL_P(op1));
- return NULL;
+
+ zend_compile_static_var_common(var_ast, &value_zv, 1 TSRMLS_CC);
+ }
+
+ void zend_compile_unset(zend_ast *ast TSRMLS_DC) {
+ zend_ast *var_ast = ast->child[0];
+
+ 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()
}
- ce->refcount++;
- if (zend_hash_add_ptr(class_table, Z_STR_P(op2), ce) == NULL) {
- ce->refcount--;
- if (!compile_time) {
- /* If we're in compile time, in practice, it's quite possible
- * that we'll never reach this class declaration at runtime,
- * so we shut up about it. This allows the if (!defined('FOO')) { return; }
- * approach to work.
- */
- zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare class %s", ce->name->val);
- }
- return NULL;
- } else {
- if (!(ce->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_IMPLEMENT_INTERFACES|ZEND_ACC_IMPLEMENT_TRAITS))) {
- zend_verify_abstract_class(ce TSRMLS_CC);
- }
- return ce;
+ }
+
+ 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));
+
+ #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;
}
}
- /* }}} */
- ZEND_API zend_class_entry *do_bind_inherited_class(const zend_op_array *op_array, const zend_op *opline, HashTable *class_table, zend_class_entry *parent_ce, zend_bool compile_time TSRMLS_DC) /* {{{ */
- {
- zend_class_entry *ce;
- zval *op1, *op2;
+ 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;
- if (compile_time) {
- op1 = &CONSTANT_EX(op_array, opline->op1.constant);
- op2 = &CONSTANT_EX(op_array, opline->op2.constant);
+ znode expr_node;
+ zend_op *opline;
+
+ 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 {
- op1 = opline->op1.zv;
- op2 = opline->op2.zv;
+ zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
}
- ce = zend_hash_find_ptr(class_table, Z_STR_P(op1));
+ zend_free_foreach_and_switch_variables(TSRMLS_C);
- if (!ce) {
- if (!compile_time) {
- /* If we're in compile time, in practice, it's quite possible
- * that we'll never reach this class declaration at runtime,
- * so we shut up about it. This allows the if (!defined('FOO')) { return; }
- * approach to work.
- */
- zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare class %s", Z_STRVAL_P(op2));
- }
- return NULL;
+ if (CG(context).in_finally) {
+ zend_emit_op(NULL, ZEND_DISCARD_EXCEPTION, NULL, NULL TSRMLS_CC);
}
- if (parent_ce->ce_flags & ZEND_ACC_INTERFACE) {
- zend_error_noreturn(E_COMPILE_ERROR, "Class %s cannot extend from interface %s", ce->name->val, parent_ce->name->val);
- } else if ((parent_ce->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) {
- zend_error_noreturn(E_COMPILE_ERROR, "Class %s cannot extend from trait %s", ce->name->val, parent_ce->name->val);
+ opline = zend_emit_op(NULL, by_ref ? ZEND_RETURN_BY_REF : ZEND_RETURN,
+ &expr_node, NULL TSRMLS_CC);
+
+ 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;
+ }
}
+ }
- zend_do_inheritance(ce, parent_ce TSRMLS_CC);
+ void zend_compile_echo(zend_ast *ast TSRMLS_DC) {
+ zend_ast *expr_ast = ast->child[0];
- ce->refcount++;
+ znode expr_node;
+ zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
- /* Register the derived class */
- if (zend_hash_add_ptr(class_table, Z_STR_P(op2), ce) == NULL) {
- zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare class %s", ce->name->val);
- }
- return ce;
+ zend_emit_op(NULL, ZEND_ECHO, &expr_node, NULL TSRMLS_CC);
}
- /* }}} */
- void zend_do_early_binding(TSRMLS_D) /* {{{ */
- {
- zend_op *opline = &CG(active_op_array)->opcodes[CG(active_op_array)->last-1];
- HashTable *table;
+ void zend_compile_throw(zend_ast *ast TSRMLS_DC) {
+ zend_ast *expr_ast = ast->child[0];
- while (opline->opcode == ZEND_TICKS && opline > CG(active_op_array)->opcodes) {
- opline--;
- }
+ znode expr_node;
+ zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
- switch (opline->opcode) {
- case ZEND_DECLARE_FUNCTION:
- if (do_bind_function(CG(active_op_array), opline, CG(function_table), 1 TSRMLS_CC) == FAILURE) {
- return;
- }
- table = CG(function_table);
- break;
- case ZEND_DECLARE_CLASS:
- if (do_bind_class(CG(active_op_array), opline, CG(class_table), 1 TSRMLS_CC) == NULL) {
- return;
- }
- table = CG(class_table);
- break;
- case ZEND_DECLARE_INHERITED_CLASS:
- {
- zend_op *fetch_class_opline = opline-1;
- zval *parent_name;
- zend_class_entry *ce;
+ zend_emit_op(NULL, ZEND_THROW, &expr_node, NULL TSRMLS_CC);
+ }
- parent_name = &CONSTANT(fetch_class_opline->op2.constant);
- if (((ce = zend_lookup_class(Z_STR_P(parent_name) TSRMLS_CC)) == NULL) ||
- ((CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_CLASSES) &&
- (ce->type == ZEND_INTERNAL_CLASS))) {
- if (CG(compiler_options) & ZEND_COMPILE_DELAYED_BINDING) {
- uint32_t *opline_num = &CG(active_op_array)->early_binding;
+ void zend_compile_break_continue(zend_ast *ast TSRMLS_DC) {
+ zend_ast *depth_ast = ast->child[0];
- while (*opline_num != -1) {
- opline_num = &CG(active_op_array)->opcodes[*opline_num].result.opline_num;
- }
- *opline_num = opline - CG(active_op_array)->opcodes;
- opline->opcode = ZEND_DECLARE_INHERITED_CLASS_DELAYED;
- opline->result_type = IS_UNUSED;
- opline->result.opline_num = -1;
- }
- return;
- }
- if (do_bind_inherited_class(CG(active_op_array), opline, CG(class_table), ce, 1 TSRMLS_CC) == NULL) {
- return;
- }
- /* clear unnecessary ZEND_FETCH_CLASS opcode */
- zend_del_literal(CG(active_op_array), fetch_class_opline->op2.constant);
- MAKE_NOP(fetch_class_opline);
+ znode depth_node;
+ zend_op *opline;
- table = CG(class_table);
- break;
- }
- case ZEND_VERIFY_ABSTRACT_CLASS:
- case ZEND_ADD_INTERFACE:
- case ZEND_ADD_TRAIT:
- case ZEND_BIND_TRAITS:
- /* We currently don't early-bind classes that implement interfaces */
- /* Classes with traits are handled exactly the same, no early-bind here */
- return;
- default:
- zend_error_noreturn(E_COMPILE_ERROR, "Invalid binding type");
- return;
+ 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_hash_del(table, Z_STR(CONSTANT(opline->op1.constant)));
- zend_del_literal(CG(active_op_array), opline->op1.constant);
- zend_del_literal(CG(active_op_array), opline->op2.constant);
- MAKE_NOP(opline);
+ 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;
}
- /* }}} */
- ZEND_API void zend_do_delayed_early_binding(const zend_op_array *op_array TSRMLS_DC) /* {{{ */
- {
- if (op_array->early_binding != -1) {
- zend_bool orig_in_compilation = CG(in_compilation);
- uint32_t opline_num = op_array->early_binding;
- zend_class_entry *ce;
+ void zend_compile_goto(zend_ast *ast TSRMLS_DC) {
+ zend_ast *label_ast = ast->child[0];
+ znode label_node;
+ zend_op *opline;
+
+ 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);
+ }
+
+ dest.brk_cont = CG(context).current_brk_cont;
+ dest.opline_num = get_next_op_number(CG(active_op_array));
- CG(in_compilation) = 1;
- while (opline_num != -1) {
- if ((ce = zend_lookup_class(Z_STR_P(op_array->opcodes[opline_num-1].op2.zv) TSRMLS_CC)) != NULL) {
- do_bind_inherited_class(op_array, &op_array->opcodes[opline_num], EG(class_table), ce, 0 TSRMLS_CC);
- }
- opline_num = op_array->opcodes[opline_num].result.opline_num;
- }
- CG(in_compilation) = orig_in_compilation;
+ 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_boolean_or_begin(znode *expr1, znode *op_token TSRMLS_DC) /* {{{ */
- {
- int next_op_number = get_next_op_number(CG(active_op_array));
- zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+ void zend_compile_while(zend_ast *ast TSRMLS_DC) {
+ zend_ast *cond_ast = ast->child[0];
+ zend_ast *stmt_ast = ast->child[1];
- 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);
+ znode cond_node;
+ uint32_t opnum_start, opnum_jmpz;
- op_token->u.op.opline_num = next_op_number;
+ opnum_start = get_next_op_number(CG(active_op_array));
+ zend_compile_expr(&cond_node, cond_ast TSRMLS_CC);
- GET_NODE(expr1, opline->result);
- }
- /* }}} */
+ opnum_jmpz = zend_emit_cond_jump(ZEND_JMPZ, &cond_node, 0 TSRMLS_CC);
+ zend_begin_loop(TSRMLS_C);
- void zend_do_boolean_or_end(znode *result, znode *expr1, znode *expr2, const znode *op_token TSRMLS_DC) /* {{{ */
- {
- zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+ zend_compile_stmt(stmt_ast 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);
+ zend_emit_jump(opnum_start TSRMLS_CC);
+
+ zend_update_jump_target_to_next(opnum_jmpz TSRMLS_CC);
- CG(active_op_array)->opcodes[op_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array));
+ zend_end_loop(opnum_start, 0 TSRMLS_CC);
}
- /* }}} */
- void zend_do_boolean_and_begin(znode *expr1, znode *op_token TSRMLS_DC) /* {{{ */
- {
- int next_op_number = get_next_op_number(CG(active_op_array));
- zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+ void zend_compile_do_while(zend_ast *ast TSRMLS_DC) {
+ zend_ast *stmt_ast = ast->child[0];
+ zend_ast *cond_ast = ast->child[1];
- 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);
+ znode cond_node;
+ uint32_t opnum_start, opnum_cond;
- op_token->u.op.opline_num = next_op_number;
+ zend_begin_loop(TSRMLS_C);
- GET_NODE(expr1, opline->result);
- }
- /* }}} */
+ opnum_start = get_next_op_number(CG(active_op_array));
+ zend_compile_stmt(stmt_ast TSRMLS_CC);
- void zend_do_boolean_and_end(znode *result, znode *expr1, znode *expr2, const znode *op_token TSRMLS_DC) /* {{{ */
- {
- zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+ opnum_cond = get_next_op_number(CG(active_op_array));
+ zend_compile_expr(&cond_node, cond_ast 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);
+ zend_emit_cond_jump(ZEND_JMPNZ, &cond_node, opnum_start TSRMLS_CC);
- CG(active_op_array)->opcodes[op_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array));
+ zend_end_loop(opnum_cond, 0 TSRMLS_CC);
}
- /* }}} */
- void zend_do_do_while_begin(TSRMLS_D) /* {{{ */
- {
- do_begin_loop(TSRMLS_C);
- INC_BPC(CG(active_op_array));
- }
- /* }}} */
+ void zend_compile_expr_list(znode *result, zend_ast *ast TSRMLS_DC) {
+ zend_ast_list *list;
+ uint32_t i;
- void zend_do_do_while_end(const znode *do_token, const znode *expr_open_bracket, znode *expr TSRMLS_DC) /* {{{ */
- {
- zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+ result->op_type = IS_CONST;
+ ZVAL_TRUE(&result->u.constant);
- opline->opcode = ZEND_JMPNZ;
- SET_NODE(opline->op1, expr);
- opline->op2.opline_num = do_token->u.op.opline_num;
- SET_UNUSED(opline->op2);
+ if (!ast) {
+ return;
+ }
- do_end_loop(expr_open_bracket->u.op.opline_num, 0 TSRMLS_CC);
+ list = zend_ast_get_list(ast);
+ for (i = 0; i < list->children; ++i) {
+ zend_ast *expr_ast = list->child[i];
- DEC_BPC(CG(active_op_array));
+ zend_do_free(result TSRMLS_CC);
+ zend_compile_expr(result, expr_ast TSRMLS_CC);
+ }
}
- /* }}} */
- void zend_do_brk_cont(zend_uchar op, znode *expr TSRMLS_DC) /* {{{ */
- {
- zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+ 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];
- opline->opcode = op;
- opline->op1.opline_num = CG(context).current_brk_cont;
- SET_UNUSED(opline->op1);
- if (expr) {
- if (expr->op_type != IS_CONST) {
- zend_error_noreturn(E_COMPILE_ERROR, "'%s' operator with non-constant operand is no longer supported", op == ZEND_BRK ? "break" : "continue");
- } else if (Z_TYPE(expr->u.constant) != IS_LONG || Z_LVAL(expr->u.constant) < 1) {
- zend_error_noreturn(E_COMPILE_ERROR, "'%s' operator accepts only positive numbers", op == ZEND_BRK ? "break" : "continue");
- }
- SET_NODE(opline->op2, expr);
- } else {
- LITERAL_LONG(opline->op2, 1);
- opline->op2_type = IS_CONST;
- }
- }
- /* }}} */
+ znode result;
+ uint32_t opnum_cond, opnum_jmpz, opnum_loop;
- void zend_do_switch_cond(const znode *cond TSRMLS_DC) /* {{{ */
- {
- zend_switch_entry switch_entry;
+ zend_compile_expr_list(&result, init_ast TSRMLS_CC);
+ zend_do_free(&result TSRMLS_CC);
- switch_entry.cond = *cond;
- switch_entry.default_case = -1;
- switch_entry.control_var = -1;
- zend_stack_push(&CG(switch_cond_stack), (void *) &switch_entry);
+ 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);
- do_begin_loop(TSRMLS_C);
+ 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);
- INC_BPC(CG(active_op_array));
+ 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_switch_end(const znode *case_list 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_switch_entry *switch_entry_ptr = zend_stack_top(&CG(switch_cond_stack));
+ uint32_t opnum_reset, opnum_fetch;
+ zend_op foreach_stack_opline;
- /* 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 (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");
+ }
}
- if (case_list->op_type != IS_UNUSED) { /* non-empty switch */
- int next_op_number = get_next_op_number(CG(active_op_array));
+ if (by_ref) {
+ value_ast = value_ast->child[0];
+ }
- CG(active_op_array)->opcodes[case_list->u.op.opline_num].op1.opline_num = next_op_number;
+ 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);
}
- /* 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;
+ 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; // ???
+ }
- 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);
+ SET_NODE(foreach_stack_opline.result, &reset_node);
+ zend_stack_push(&CG(foreach_copy_stack), &foreach_stack_opline);
+
+ 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 (switch_entry_ptr->cond.op_type == IS_CONST) {
- zval_dtor(&switch_entry_ptr->cond.u.constant);
+ if (key_ast) {
+ opline->extended_value |= ZEND_FE_FETCH_WITH_KEY;
}
- zend_stack_del_top(&CG(switch_cond_stack));
+ opline = zend_emit_op(NULL, ZEND_OP_DATA, NULL, NULL TSRMLS_CC);
- DEC_BPC(CG(active_op_array));
- }
- /* }}} */
+ /* 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 sure 1 zval is enough for HashPointer (2 must be enough) */
+ get_temporary_variable(CG(active_op_array));
+ }
- void zend_do_case_before_statement(const znode *case_list, znode *case_token, znode *case_expr TSRMLS_DC) /* {{{ */
- {
- 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;
+ if (key_ast) {
+ zend_make_tmp_result(&key_node, opline TSRMLS_CC);
+ }
- if (switch_entry_ptr->control_var == -1) {
- switch_entry_ptr->control_var = get_temporary_variable(CG(active_op_array));
+ 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);
}
- 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 (key_ast) {
+ zend_emit_assign_znode(key_ast, &key_node TSRMLS_CC);
}
- 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;
+ zend_begin_loop(TSRMLS_C);
- 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;
- }
- /* }}} */
+ zend_compile_stmt(stmt_ast TSRMLS_CC);
- void zend_do_case_after_statement(znode *result, const znode *case_token TSRMLS_DC) /* {{{ */
- {
- int next_op_number = get_next_op_number(CG(active_op_array));
- zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+ zend_emit_jump(opnum_fetch TSRMLS_CC);
- opline->opcode = ZEND_JMP;
- SET_UNUSED(opline->op1);
- SET_UNUSED(opline->op2);
- result->u.op.opline_num = next_op_number;
+ opline = &CG(active_op_array)->opcodes[opnum_reset];
+ opline->op2.opline_num = get_next_op_number(CG(active_op_array));
- 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;
+ 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));
}
}
- /* }}} */
- void zend_do_default_before_statement(const znode *case_list, znode *default_token TSRMLS_DC) /* {{{ */
- {
- int next_op_number = get_next_op_number(CG(active_op_array));
- zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
- zend_switch_entry *switch_entry_ptr = zend_stack_top(&CG(switch_cond_stack));
+ 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);
- opline->opcode = ZEND_JMP;
- SET_UNUSED(opline->op1);
- SET_UNUSED(opline->op2);
- default_token->u.op.opline_num = next_op_number;
+ 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];
- next_op_number = get_next_op_number(CG(active_op_array));
- switch_entry_ptr->default_case = next_op_number;
+ 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 (case_list->op_type==IS_UNUSED) {
- return;
+ 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);
+ }
}
- CG(active_op_array)->opcodes[case_list->u.op.opline_num].op1.opline_num = next_op_number;
+
+ for (i = 0; i < list->children - 1; ++i) {
+ zend_update_jump_target_to_next(jmp_opnums[i] TSRMLS_CC);
+ }
+
+ efree(jmp_opnums);
}
- /* }}} */
- void zend_do_begin_class_declaration(const znode *class_token, znode *class_name, const znode *parent_class_name TSRMLS_DC) /* {{{ */
- {
- zend_op *opline;
- int doing_inheritance = 0;
- zend_class_entry *new_class_entry;
- zend_string *lcname;
- int error = 0;
- zval *ns_name, key;
+ 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]);
- if (CG(active_class_entry)) {
- zend_error_noreturn(E_COMPILE_ERROR, "Class declarations may not be nested");
- return;
- }
+ uint32_t i;
+ zend_bool has_default_case = 0;
+ zend_switch_entry switch_entry;
- 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));
+ 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;
- 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));
- }
+ zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
- /* Class name must not conflict with import names */
- if (CG(current_import) &&
- (ns_name = zend_hash_find(CG(current_import), lcname)) != NULL) {
- error = 1;
- }
+ 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);
- if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
- /* Prefix class name with name of current namespace */
- znode tmp;
+ zend_begin_loop(TSRMLS_C);
- 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_node.op_type = IS_TMP_VAR;
+ case_node.u.op.var = get_temporary_variable(CG(active_op_array));
- if (error) {
- char *tmp = zend_str_tolower_dup(Z_STRVAL_P(ns_name), Z_STRLEN_P(ns_name));
+ 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 (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));
+ if (!cond_ast) {
+ has_default_case = 1;
+ continue;
}
- efree(tmp);
- }
-
- 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);
- 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;
+ zend_compile_expr(&cond_node, cond_ast TSRMLS_CC);
- 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;
+ 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));
}
- doing_inheritance = 1;
+
+ jmpnz_opnums[i] = zend_emit_cond_jump(ZEND_JMPNZ, &case_node, 0 TSRMLS_CC);
}
- 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);
+ opnum_default_jmp = zend_emit_jump(0 TSRMLS_CC);
- opline->op2_type = IS_CONST;
+ 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 (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 (cond_ast) {
+ zend_update_jump_target_to_next(jmpnz_opnums[i] TSRMLS_CC);
+ } else {
+ zend_update_jump_target_to_next(opnum_default_jmp TSRMLS_CC);
}
- opline->extended_value = parent_class_name->u.op.var;
- opline->opcode = ZEND_DECLARE_INHERITED_CLASS;
- } else {
- opline->opcode = ZEND_DECLARE_CLASS;
+ zend_compile_stmt(stmt_ast TSRMLS_CC);
}
- LITERAL_STR(opline->op2, lcname);
-
- zend_hash_update_ptr(CG(class_table), Z_STR(key), new_class_entry);
- CG(active_class_entry) = new_class_entry;
+ if (!has_default_case) {
+ zend_update_jump_target_to_next(opnum_default_jmp TSRMLS_CC);
+ }
- opline->result.var = get_temporary_variable(CG(active_op_array));
- opline->result_type = IS_VAR;
- GET_NODE(&CG(implementing_class), opline->result);
+ zend_end_loop(get_next_op_number(CG(active_op_array)), 1 TSRMLS_CC);
- if (CG(doc_comment)) {
- CG(active_class_entry)->info.user.doc_comment = CG(doc_comment);
- CG(doc_comment) = NULL;
+ 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);
}
+
+ zend_stack_del_top(&CG(switch_cond_stack));
+ efree(jmpnz_opnums);
}
- /* }}} */
- static void do_verify_abstract_class(TSRMLS_D) /* {{{ */
- {
- 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_VERIFY_ABSTRACT_CLASS;
- SET_NODE(opline->op1, &CG(implementing_class));
- 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);
- void zend_do_end_class_declaration(const znode *class_token, const znode *parent_token TSRMLS_DC) /* {{{ */
- {
- zend_class_entry *ce = CG(active_class_entry);
+ if (catches->children == 0 && !finally_ast) {
+ zend_error_noreturn(E_COMPILE_ERROR, "Cannot use try without catch or finally");
+ }
- 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_compile_stmt(try_ast TSRMLS_CC);
+
+ if (catches->children != 0) {
+ jmp_opnums[0] = zend_emit_jump(0 TSRMLS_CC);
}
- 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);
+
+ 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");
}
- }
- 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);
+
+ 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;
}
- }
- ce->info.user.line_end = zend_get_compiled_lineno(TSRMLS_C);
+ CG(zend_lineno) = catch_ast->lineno;
- /* 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;
+ 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);
- ce->traits = NULL;
- ce->num_traits = 0;
- ce->ce_flags |= ZEND_ACC_IMPLEMENT_TRAITS;
+ 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;
- /* opcode generation: */
- opline = get_next_op(CG(active_op_array) TSRMLS_CC);
- opline->opcode = ZEND_BIND_TRAITS;
- SET_NODE(opline->op1, &CG(implementing_class));
- }
+ zend_compile_stmt(stmt_ast TSRMLS_CC);
- 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);
+ 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));
}
- /* 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;
+
+ 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);
}
- CG(active_class_entry) = NULL;
+ efree(jmp_opnums);
+ }
+
+ /* 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_implements_interface(znode *interface_name TSRMLS_DC) /* {{{ */
- {
- zend_op *opline;
+ 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_int(&value_zv);
++ 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)) {
+ --num;
+ }
- /* 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 (num > 0) {
+ 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);
+ }
}
- switch (zend_get_class_fetch_type(Z_STRVAL(interface_name->u.constant), Z_STRLEN(interface_name->u.constant))) {
- case ZEND_FETCH_CLASS_SELF:
- case ZEND_FETCH_CLASS_PARENT:
- case ZEND_FETCH_CLASS_STATIC:
- zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as interface name as it is reserved", Z_STRVAL(interface_name->u.constant));
- break;
- default:
- break;
+ if (stmt_ast) {
+ zend_compile_stmt(stmt_ast TSRMLS_CC);
+
+ CG(declarables) = orig_declarables;
}
+ }
- 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++;
+ 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_do_use_trait(znode *trait_name TSRMLS_DC) /* {{{ */
- {
- zend_op *opline;
+ 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 ((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);
+ 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);
+ }
- 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;
- }
+ var_node.op_type = IS_CV;
+ var_node.u.op.var = lookup_cv(CG(active_op_array), zend_string_copy(name) TSRMLS_CC);
- 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++;
- }
- /* }}} */
+ 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;
+ }
- 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;
+ if (op_array->fn_flags & ZEND_ACC_VARIADIC) {
+ zend_error_noreturn(E_COMPILE_ERROR, "Only the last parameter can be variadic");
+ }
- 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;
- }
- /* }}} */
+ if (is_variadic) {
+ opcode = ZEND_RECV_VARIADIC;
+ default_node.op_type = IS_UNUSED;
+ op_array->fn_flags |= ZEND_ACC_VARIADIC;
- static int zend_strnlen(const char* s, int maxlen) /* {{{ */
- {
- int len = 0;
- while (*s++ && maxlen--) len++;
- return len;
- }
- /* }}} */
+ 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 {
+ zend_string *class_name = zend_ast_get_str(type_ast);
- 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;
+ 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);
+ }
- *class_name = NULL;
+ 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;
- 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;
+ 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");
+ }
+ }
}
- 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;
+ /* 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_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");
}
- return FAILURE;
- }
- *class_name = mangled_property + 1;
- *prop_name = (*class_name) + class_name_len;
- if (prop_len) {
- *prop_len = len - class_name_len;
+
+ 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);
}
- return SUCCESS;
}
- /* }}} */
- 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;
+ 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;
- if (CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE) {
- zend_error_noreturn(E_COMPILE_ERROR, "Interfaces may not include member variables");
- }
+ zend_string *lcname;
- if (access_type & ZEND_ACC_ABSTRACT) {
- zend_error_noreturn(E_COMPILE_ERROR, "Properties cannot be declared abstract");
+ 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);
}
- 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));
- }
+ if (op_array->fn_flags & ZEND_ACC_ABSTRACT) {
+ //zend_op *opline;
- 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));
- }
+ 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);
+ }
- if (value) {
- ZVAL_COPY_VALUE(&property, &value->u.constant);
- } else {
- ZVAL_NULL(&property);
- }
+ 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);
+ }
- if (CG(doc_comment)) {
- comment = CG(doc_comment);
- CG(doc_comment) = NULL;
- }
+ ce->ce_flags |= ZEND_ACC_IMPLICIT_ABSTRACT_CLASS;
- 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 = 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);
}
- 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));
- }
- /* }}} */
- 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;
- }
+ op_array->scope = ce;
+ op_array->function_name = zend_string_copy(name);
- 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);
- }
- if (Z_CONSTANT(value->u.constant)) {
- CG(active_class_entry)->ce_flags &= ~ZEND_ACC_CONSTANTS_UPDATED;
- }
- 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));
- }
- FREE_PNODE(var_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 (CG(doc_comment)) {
- zend_string_release(CG(doc_comment));
- CG(doc_comment) = NULL;
+ 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);
}
- }
- /* }}} */
- 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 (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");
}
- if (opline_ptr->op2_type == IS_CONST && Z_TYPE(CONSTANT(opline_ptr->op2.constant)) == IS_STRING) {
- GET_POLYMORPHIC_CACHE_SLOT(opline_ptr->op2.constant);
+ } 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");
}
- GET_NODE(result, opline_ptr->result);
- return;
+ }
+ } else {
+ 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;
}
}
projects / php / commitdiff