Merge branch 'master' of https://git.php.net/push/php-src

* 'master' of https://git.php.net/push/php-src: (6215 commits)
  Extra comma
  Moved proxy object support in ASSIGN_ADD (and family) from VM to slow paths of corresponding operators
  Simplification
  zend_get_property_info_quick() cleanup and optimization
  initialize lineno before calling compile file file in phar
  Use ADDREF instead of DUP, it must be enough.
  Removed old irrelevant comment
  fixed compilation error
  Fix bug #68262: Broken reference across cloned objects
  export functions needed for phpdbg
  Fixed compilation
  Optimized property access handlers. Removed EG(std_property_info).
  Fixed bug #68199 (PDO::pgsqlGetNotify doesn't support NOTIFY payloads)
  Don't make difference between undefined and unaccessible properies when call __get() and family
  Don't make useless CSE
  array_pop/array_shift optimization
  check for zlib headers as well as lib for mysqlnd
  a realpath cache key can be int or float, catching this
  News entry for new curl constants
  News entry for new curl constants
  ...

1 files changed, 4588 insertions, 5435 deletions

diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
index 3bdacc750d..5d3ee24c84 100644
--- a/Zend/zend_compile.c
+++ b/Zend/zend_compile.c
@@ -2,7 +2,7 @@
    +----------------------------------------------------------------------+
    | Zend Engine                                                          |
    +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2013 Zend Technologies Ltd. (http://www.zend.com) |
+   | Copyright (c) 1998-2014 Zend Technologies Ltd. (http://www.zend.com) |
    +----------------------------------------------------------------------+
    | This source file is subject to version 2.00 of the Zend license,     |
    | that is bundled with this package in the file LICENSE, and is        |
@@ -14,6 +14,7 @@
    +----------------------------------------------------------------------+
    | Authors: Andi Gutmans <andi@zend.com>                                |
    |          Zeev Suraski <zeev@zend.com>                                |
+   |          Nikita Popov <nikic@php.net>                                |
    +----------------------------------------------------------------------+
 */
 
@@ -26,12 +27,13 @@
 #include "zend_llist.h"
 #include "zend_API.h"
 #include "zend_exceptions.h"
-#include "tsrm_virtual_cwd.h"
+#include "zend_virtual_cwd.h"
 #include "zend_multibyte.h"
 #include "zend_language_scanner.h"
+#include "zend_inheritance.h"
 
 #define CONSTANT_EX(op_array, op) \
-	(op_array)->literals[op].constant
+	(op_array)->literals[op]
 
 #define CONSTANT(op) \
 	CONSTANT_EX(CG(active_op_array), op)
@@ -51,48 +53,21 @@
 			(target)->u.constant = CONSTANT(src.constant); \
 		} else { \
 			(target)->u.op = src; \
-			(target)->EA = 0; \
 		} \
 	} while (0)
 
-#define COPY_NODE(target, src) do { \
-		target ## _type = src ## _type; \
-		target = src; \
-	} while (0)
-
-#define CALCULATE_LITERAL_HASH(num) do { \
-		zval *c = &CONSTANT(num); \
-		Z_HASH_P(c) = str_hash(Z_STRVAL_P(c), Z_STRLEN_P(c)); \
-	} while (0)
-
-#define GET_CACHE_SLOT(literal) do { \
-		CG(active_op_array)->literals[literal].cache_slot = CG(active_op_array)->last_cache_slot++; \
-		if ((CG(active_op_array)->fn_flags & ZEND_ACC_INTERACTIVE) && CG(active_op_array)->run_time_cache) { \
-			CG(active_op_array)->run_time_cache = erealloc(CG(active_op_array)->run_time_cache, CG(active_op_array)->last_cache_slot * sizeof(void*)); \
-			CG(active_op_array)->run_time_cache[CG(active_op_array)->last_cache_slot - 1] = NULL; \
-		} \
-	} while (0)
+static inline void zend_alloc_cache_slot(uint32_t literal TSRMLS_DC) {
+	zend_op_array *op_array = CG(active_op_array);
+	Z_CACHE_SLOT(op_array->literals[literal]) = op_array->last_cache_slot++;
+}
 
 #define POLYMORPHIC_CACHE_SLOT_SIZE 2
 
-#define GET_POLYMORPHIC_CACHE_SLOT(literal) do { \
-		CG(active_op_array)->literals[literal].cache_slot = CG(active_op_array)->last_cache_slot; \
-		CG(active_op_array)->last_cache_slot += POLYMORPHIC_CACHE_SLOT_SIZE; \
-		if ((CG(active_op_array)->fn_flags & ZEND_ACC_INTERACTIVE) && CG(active_op_array)->run_time_cache) { \
-			CG(active_op_array)->run_time_cache = erealloc(CG(active_op_array)->run_time_cache, CG(active_op_array)->last_cache_slot * sizeof(void*)); \
-			CG(active_op_array)->run_time_cache[CG(active_op_array)->last_cache_slot - 1] = NULL; \
-			CG(active_op_array)->run_time_cache[CG(active_op_array)->last_cache_slot - 2] = NULL; \
-		} \
-	} while (0)
-
-#define FREE_POLYMORPHIC_CACHE_SLOT(literal) do { \
-		if (CG(active_op_array)->literals[literal].cache_slot != -1 && \
-		    CG(active_op_array)->literals[literal].cache_slot == \
-		    CG(active_op_array)->last_cache_slot - POLYMORPHIC_CACHE_SLOT_SIZE) { \
-			CG(active_op_array)->literals[literal].cache_slot = -1; \
-			CG(active_op_array)->last_cache_slot -= POLYMORPHIC_CACHE_SLOT_SIZE; \
-		} \
-	} while (0)
+static inline void zend_alloc_polymorphic_cache_slot(uint32_t literal TSRMLS_DC) {
+	zend_op_array *op_array = CG(active_op_array);
+	Z_CACHE_SLOT(op_array->literals[literal]) = op_array->last_cache_slot;
+	op_array->last_cache_slot += POLYMORPHIC_CACHE_SLOT_SIZE;
+}
 
 ZEND_API zend_op_array *(*zend_compile_file)(zend_file_handle *file_handle, int type TSRMLS_DC);
 ZEND_API zend_op_array *(*zend_compile_string)(zval *source_string, char *filename TSRMLS_DC);
@@ -102,78 +77,87 @@ ZEND_API zend_compiler_globals compiler_globals;
 ZEND_API zend_executor_globals executor_globals;
 #endif
 
-static void zend_duplicate_property_info(zend_property_info *property_info) /* {{{ */
+static void zend_destroy_property_info(zval *zv) /* {{{ */
 {
-	property_info->name = str_estrndup(property_info->name, property_info->name_length);
+	zend_property_info *property_info = Z_PTR_P(zv);
+
+	zend_string_release(property_info->name);
 	if (property_info->doc_comment) {
-		property_info->doc_comment = estrndup(property_info->doc_comment, property_info->doc_comment_len);
+		zend_string_release(property_info->doc_comment);
 	}
 }
 /* }}} */
 
-static void zend_duplicate_property_info_internal(zend_property_info *property_info) /* {{{ */
+static void zend_destroy_property_info_internal(zval *zv) /* {{{ */
 {
-	property_info->name = str_strndup(property_info->name, property_info->name_length);
-}
-/* }}} */
+	zend_property_info *property_info = Z_PTR_P(zv);
 
-static void zend_destroy_property_info(zend_property_info *property_info) /* {{{ */
-{
-	str_efree(property_info->name);
-	if (property_info->doc_comment) {
-		efree((char*)property_info->doc_comment);
-	}
+	zend_string_release(property_info->name);
+	free(property_info);
 }
 /* }}} */
 
-static void zend_destroy_property_info_internal(zend_property_info *property_info) /* {{{ */
-{
-	str_free((char*)property_info->name);
+static zend_string *zend_new_interned_string_safe(zend_string *str TSRMLS_DC) /* {{{ */ {
+	zend_string *interned_str;
+
+	zend_string_addref(str);
+	interned_str = zend_new_interned_string(str TSRMLS_CC);
+	if (str != interned_str) {
+		return interned_str;
+	} else {
+		zend_string_release(str);
+		return str;
+	}
 }
 /* }}} */
 
-static void build_runtime_defined_function_key(zval *result, const char *name, int name_length TSRMLS_DC) /* {{{ */
+static zend_string *zend_build_runtime_definition_key(zend_string *name, unsigned char *lex_pos TSRMLS_DC) /* {{{ */
 {
+	zend_string *result;
 	char char_pos_buf[32];
-	uint char_pos_len;
-	const char *filename;
+	size_t filename_len, char_pos_len = zend_sprintf(char_pos_buf, "%p", lex_pos);
 
-	char_pos_len = zend_sprintf(char_pos_buf, "%p", LANG_SCNG(yy_text));
+	const char *filename;
 	if (CG(active_op_array)->filename) {
-		filename = CG(active_op_array)->filename;
+		filename = CG(active_op_array)->filename->val;
+		filename_len = CG(active_op_array)->filename->len;
 	} else {
 		filename = "-";
+		filename_len = sizeof("-") - 1;
 	}
-
 	/* NULL, name length, filename length, last accepting char position length */
-	Z_STRLEN_P(result) = 1+name_length+strlen(filename)+char_pos_len;
+	result = zend_string_alloc(1 + name->len + filename_len + char_pos_len, 0);
+ 	sprintf(result->val, "%c%s%s%s", '\0', name->val, filename, char_pos_buf);
+	return zend_new_interned_string(result TSRMLS_CC);
+}
+/* }}} */
 
- 	/* must be binary safe */
- 	Z_STRVAL_P(result) = (char *) safe_emalloc(Z_STRLEN_P(result), 1, 1);
- 	Z_STRVAL_P(result)[0] = '\0';
- 	sprintf(Z_STRVAL_P(result)+1, "%s%s%s", name, filename, char_pos_buf);
+static zend_bool zend_get_unqualified_name(const zend_string *name, const char **result, size_t *result_len) /* {{{ */
+{
+	const char *ns_separator = zend_memrchr(name->val, '\\', name->len);
+	if (ns_separator != NULL) {
+		*result = ns_separator + 1;
+		*result_len = name->val + name->len - *result;
+		return 1;
+	}
 
-	result->type = IS_STRING;
-	Z_SET_REFCOUNT_P(result, 1);
+	return 0;
 }
 /* }}} */
 
 static void init_compiler_declarables(TSRMLS_D) /* {{{ */
 {
-	Z_TYPE(CG(declarables).ticks) = IS_LONG;
-	Z_LVAL(CG(declarables).ticks) = 0;
+	ZVAL_LONG(&CG(declarables).ticks, 0);
 }
 /* }}} */
 
 void zend_init_compiler_context(TSRMLS_D) /* {{{ */
 {
-	CG(context).opcodes_size = (CG(active_op_array)->fn_flags & ZEND_ACC_INTERACTIVE) ? INITIAL_INTERACTIVE_OP_ARRAY_SIZE : INITIAL_OP_ARRAY_SIZE;
+	CG(context).opcodes_size = INITIAL_OP_ARRAY_SIZE;
 	CG(context).vars_size = 0;
 	CG(context).literals_size = 0;
 	CG(context).current_brk_cont = -1;
 	CG(context).backpatch_count = 0;
-	CG(context).nested_calls = 0;
-	CG(context).used_stack = 0;
 	CG(context).in_finally = 0;
 	CG(context).labels = NULL;
 }
@@ -181,24 +165,20 @@ void zend_init_compiler_context(TSRMLS_D) /* {{{ */
 
 void zend_init_compiler_data_structures(TSRMLS_D) /* {{{ */
 {
-	zend_stack_init(&CG(bp_stack));
-	zend_stack_init(&CG(function_call_stack));
-	zend_stack_init(&CG(switch_cond_stack));
-	zend_stack_init(&CG(foreach_copy_stack));
-	zend_stack_init(&CG(object_stack));
-	zend_stack_init(&CG(declare_stack));
+	zend_stack_init(&CG(loop_var_stack), sizeof(znode));
+	zend_stack_init(&CG(delayed_oplines_stack), sizeof(zend_op));
 	CG(active_class_entry) = NULL;
-	zend_llist_init(&CG(list_llist), sizeof(list_llist_element), NULL, 0);
-	zend_llist_init(&CG(dimension_llist), sizeof(int), NULL, 0);
-	zend_stack_init(&CG(list_stack));
 	CG(in_compilation) = 0;
 	CG(start_lineno) = 0;
 	CG(current_namespace) = NULL;
 	CG(in_namespace) = 0;
 	CG(has_bracketed_namespaces) = 0;
 	CG(current_import) = NULL;
+	CG(current_import_function) = NULL;
+	CG(current_import_const) = NULL;
+	zend_hash_init(&CG(const_filenames), 8, NULL, NULL, 0);
 	init_compiler_declarables(TSRMLS_C);
-	zend_stack_init(&CG(context_stack));
+	zend_stack_init(&CG(context_stack), sizeof(CG(context)));
 
 	CG(encoding_declared) = 0;
 }
@@ -214,11 +194,12 @@ ZEND_API void file_handle_dtor(zend_file_handle *fh) /* {{{ */
 
 void init_compiler(TSRMLS_D) /* {{{ */
 {
+	CG(arena) = zend_arena_create(64 * 1024);
 	CG(active_op_array) = NULL;
 	memset(&CG(context), 0, sizeof(CG(context)));
 	zend_init_compiler_data_structures(TSRMLS_C);
 	zend_init_rsrc_list(TSRMLS_C);
-	zend_hash_init(&CG(filenames_table), 5, NULL, (dtor_func_t) free_estring, 0);
+	zend_hash_init(&CG(filenames_table), 8, NULL, free_string_zval, 0);
 	zend_llist_init(&CG(open_files), sizeof(zend_file_handle), (void (*)(void *)) file_handle_dtor, 0);
 	CG(unclean_shutdown) = 0;
 }
@@ -226,42 +207,38 @@ void init_compiler(TSRMLS_D) /* {{{ */
 
 void shutdown_compiler(TSRMLS_D) /* {{{ */
 {
-	zend_stack_destroy(&CG(bp_stack));
-	zend_stack_destroy(&CG(function_call_stack));
-	zend_stack_destroy(&CG(switch_cond_stack));
-	zend_stack_destroy(&CG(foreach_copy_stack));
-	zend_stack_destroy(&CG(object_stack));
-	zend_stack_destroy(&CG(declare_stack));
-	zend_stack_destroy(&CG(list_stack));
+	zend_stack_destroy(&CG(loop_var_stack));
+	zend_stack_destroy(&CG(delayed_oplines_stack));
 	zend_hash_destroy(&CG(filenames_table));
-	zend_llist_destroy(&CG(open_files));
+	zend_hash_destroy(&CG(const_filenames));
 	zend_stack_destroy(&CG(context_stack));
+	zend_arena_destroy(CG(arena));
 }
 /* }}} */
 
-ZEND_API char *zend_set_compiled_filename(const char *new_compiled_filename TSRMLS_DC) /* {{{ */
+ZEND_API zend_string *zend_set_compiled_filename(zend_string *new_compiled_filename TSRMLS_DC) /* {{{ */
 {
-	char **pp, *p;
-	int length = strlen(new_compiled_filename);
+	zend_string *p;
 
-	if (zend_hash_find(&CG(filenames_table), new_compiled_filename, length+1, (void **) &pp) == SUCCESS) {
-		CG(compiled_filename) = *pp;
-		return *pp;
+	p = zend_hash_find_ptr(&CG(filenames_table), new_compiled_filename);
+	if (p != NULL) {
+		CG(compiled_filename) = p;
+		return p;
 	}
-	p = estrndup(new_compiled_filename, length);
-	zend_hash_update(&CG(filenames_table), new_compiled_filename, length+1, &p, sizeof(char *), (void **) &pp);
+	p = zend_string_copy(new_compiled_filename);
+	zend_hash_update_ptr(&CG(filenames_table), new_compiled_filename, p);
 	CG(compiled_filename) = p;
 	return p;
 }
 /* }}} */
 
-ZEND_API void zend_restore_compiled_filename(char *original_compiled_filename TSRMLS_DC) /* {{{ */
+ZEND_API void zend_restore_compiled_filename(zend_string *original_compiled_filename TSRMLS_DC) /* {{{ */
 {
 	CG(compiled_filename) = original_compiled_filename;
 }
 /* }}} */
 
-ZEND_API char *zend_get_compiled_filename(TSRMLS_D) /* {{{ */
+ZEND_API zend_string *zend_get_compiled_filename(TSRMLS_D) /* {{{ */
 {
 	return CG(compiled_filename);
 }
@@ -279,24 +256,23 @@ ZEND_API zend_bool zend_is_compiling(TSRMLS_D) /* {{{ */
 }
 /* }}} */
 
-static zend_uint get_temporary_variable(zend_op_array *op_array) /* {{{ */
+static uint32_t get_temporary_variable(zend_op_array *op_array) /* {{{ */
 {
-	return (zend_uint)(zend_uintptr_t)EX_TMP_VAR_NUM(0, (op_array->T)++);
+	return (uint32_t)op_array->T++;
 }
 /* }}} */
 
-static int lookup_cv(zend_op_array *op_array, char* name, int name_len, ulong hash TSRMLS_DC) /* {{{ */
-{
+static int lookup_cv(zend_op_array *op_array, zend_string* name TSRMLS_DC) /* {{{ */{
 	int i = 0;
-	ulong hash_value = hash ? hash : zend_inline_hash_func(name, name_len+1);
+	zend_ulong hash_value = zend_string_hash_val(name);
 
 	while (i < op_array->last_var) {
-		if (op_array->vars[i].name == name ||
-		    (op_array->vars[i].hash_value == hash_value &&
-		     op_array->vars[i].name_len == name_len &&
-		     memcmp(op_array->vars[i].name, name, name_len) == 0)) {
-			str_efree(name);
-			return i;
+		if (op_array->vars[i]->val == name->val ||
+		    (op_array->vars[i]->h == hash_value &&
+		     op_array->vars[i]->len == name->len &&
+		     memcmp(op_array->vars[i]->val, name->val, name->len) == 0)) {
+			zend_string_release(name);
+			return (int)(zend_intptr_t)EX_VAR_NUM_2(NULL, i);
 		}
 		i++;
 	}
@@ -304,12 +280,11 @@ static int lookup_cv(zend_op_array *op_array, char* name, int name_len, ulong ha
 	op_array->last_var++;
 	if (op_array->last_var > CG(context).vars_size) {
 		CG(context).vars_size += 16; /* FIXME */
-		op_array->vars = erealloc(op_array->vars, CG(context).vars_size * sizeof(zend_compiled_variable));
+		op_array->vars = erealloc(op_array->vars, CG(context).vars_size * sizeof(zend_string*));
 	}
-	op_array->vars[i].name = zend_new_interned_string(name, name_len + 1, 1 TSRMLS_CC);
-	op_array->vars[i].name_len = name_len;
-	op_array->vars[i].hash_value = hash_value;
-	return i;
+
+	op_array->vars[i] = zend_new_interned_string(name TSRMLS_CC);
+	return (int)(zend_intptr_t)EX_VAR_NUM_2(NULL, i);
 }
 /* }}} */
 
@@ -319,30 +294,30 @@ void zend_del_literal(zend_op_array *op_array, int n) /* {{{ */
 	if (n + 1 == op_array->last_literal) {
 		op_array->last_literal--;
 	} else {
-		Z_TYPE(CONSTANT_EX(op_array, n)) = IS_NULL;
+		ZVAL_UNDEF(&CONSTANT_EX(op_array, n));
 	}
 }
 /* }}} */
 
 /* Common part of zend_add_literal and zend_append_individual_literal */
-static inline void zend_insert_literal(zend_op_array *op_array, const zval *zv, int literal_position TSRMLS_DC) /* {{{ */
+static inline void zend_insert_literal(zend_op_array *op_array, zval *zv, int literal_position TSRMLS_DC) /* {{{ */
 {
 	if (Z_TYPE_P(zv) == IS_STRING || Z_TYPE_P(zv) == IS_CONSTANT) {
-		zval *z = (zval*)zv;
-		Z_STRVAL_P(z) = (char*)zend_new_interned_string(Z_STRVAL_P(zv), Z_STRLEN_P(zv) + 1, 1 TSRMLS_CC);
+		zend_string_hash_val(Z_STR_P(zv));
+		Z_STR_P(zv) = zend_new_interned_string(Z_STR_P(zv) TSRMLS_CC);
+		if (IS_INTERNED(Z_STR_P(zv))) {
+			Z_TYPE_FLAGS_P(zv) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE);
+		}
 	}
-	CONSTANT_EX(op_array, literal_position) = *zv;
-	Z_SET_REFCOUNT(CONSTANT_EX(op_array, literal_position), 2);
-	Z_SET_ISREF(CONSTANT_EX(op_array, literal_position));
-	op_array->literals[literal_position].hash_value = 0;
-	op_array->literals[literal_position].cache_slot = -1;
+	ZVAL_COPY_VALUE(&CONSTANT_EX(op_array, literal_position), zv);
+	Z_CACHE_SLOT(op_array->literals[literal_position]) = -1;
 }
 /* }}} */
 
 /* Is used while compiling a function, using the context to keep track
    of an approximate size to avoid to relocate to often.
    Literals are truncated to actual size in the second compiler pass (pass_two()). */
-int zend_add_literal(zend_op_array *op_array, const zval *zv TSRMLS_DC) /* {{{ */
+int zend_add_literal(zend_op_array *op_array, zval *zv TSRMLS_DC) /* {{{ */
 {
 	int i = op_array->last_literal;
 	op_array->last_literal++;
@@ -350,4781 +325,4279 @@ int zend_add_literal(zend_op_array *op_array, const zval *zv TSRMLS_DC) /* {{{ *
 		while (i >= CG(context).literals_size) {
 			CG(context).literals_size += 16; /* FIXME */
 		}
-		op_array->literals = (zend_literal*)erealloc(op_array->literals, CG(context).literals_size * sizeof(zend_literal));
+		op_array->literals = (zval*)erealloc(op_array->literals, CG(context).literals_size * sizeof(zval));
 	}
 	zend_insert_literal(op_array, zv, i TSRMLS_CC);
 	return i;
 }
 /* }}} */
 
-/* Is used after normal compilation to append an additional literal.
-   Allocation is done precisely here. */
-int zend_append_individual_literal(zend_op_array *op_array, const zval *zv TSRMLS_DC) /* {{{ */
+static inline int zend_add_literal_string(zend_op_array *op_array, zend_string **str TSRMLS_DC) /* {{{ */
 {
-	int i = op_array->last_literal;
-	op_array->last_literal++;
-	op_array->literals = (zend_literal*)erealloc(op_array->literals, (i + 1) * sizeof(zend_literal));
-	zend_insert_literal(op_array, zv, i TSRMLS_CC);
-	return i;
+	int ret;
+	zval zv;
+	ZVAL_STR(&zv, *str);
+	ret = zend_add_literal(op_array, &zv TSRMLS_CC);
+	*str = Z_STR(zv);
+	return ret;
 }
-/* }}} */
 
-int zend_add_func_name_literal(zend_op_array *op_array, const zval *zv TSRMLS_DC) /* {{{ */
+static int zend_add_func_name_literal(zend_op_array *op_array, zend_string *name TSRMLS_DC) /* {{{ */
 {
-	int ret;
-	char *lc_name;
-	zval c;
-	int lc_literal;
-
-	if (op_array->last_literal > 0 &&
-	    &op_array->literals[op_array->last_literal - 1].constant == zv &&
-	    op_array->literals[op_array->last_literal - 1].cache_slot == -1) {
-		/* we already have function name as last literal (do nothing) */
-		ret = op_array->last_literal - 1;
-	} else {
-		ret = zend_add_literal(op_array, zv TSRMLS_CC);
-	}
+	/* Original name */
+	int ret = zend_add_literal_string(op_array, &name TSRMLS_CC);
 
-	lc_name = zend_str_tolower_dup(Z_STRVAL_P(zv), Z_STRLEN_P(zv));
-	ZVAL_STRINGL(&c, lc_name, Z_STRLEN_P(zv), 0);
-	lc_literal = zend_add_literal(CG(active_op_array), &c TSRMLS_CC);
-	CALCULATE_LITERAL_HASH(lc_literal);
+	/* Lowercased name */
+	zend_string *lc_name = zend_string_alloc(name->len, 0);
+	zend_str_tolower_copy(lc_name->val, name->val, name->len);
+	zend_add_literal_string(op_array, &lc_name TSRMLS_CC);
 
 	return ret;
 }
 /* }}} */
 
-int zend_add_ns_func_name_literal(zend_op_array *op_array, const zval *zv TSRMLS_DC) /* {{{ */
+static int zend_add_ns_func_name_literal(zend_op_array *op_array, zend_string *name TSRMLS_DC) /* {{{ */
 {
-	int ret;
-	char *lc_name;
-	const char *ns_separator;
-	int lc_len;
-	zval c;
-	int lc_literal;
-
-	if (op_array->last_literal > 0 &&
-	    &op_array->literals[op_array->last_literal - 1].constant == zv &&
-	    op_array->literals[op_array->last_literal - 1].cache_slot == -1) {
-		/* we already have function name as last literal (do nothing) */
-		ret = op_array->last_literal - 1;
-	} else {
-		ret = zend_add_literal(op_array, zv TSRMLS_CC);
-	}
+	const char *unqualified_name;
+	size_t unqualified_name_len;
+
+	/* Original name */
+	int ret = zend_add_literal_string(op_array, &name TSRMLS_CC);
 
-	lc_name = zend_str_tolower_dup(Z_STRVAL_P(zv), Z_STRLEN_P(zv));
-	ZVAL_STRINGL(&c, lc_name, Z_STRLEN_P(zv), 0);
-	lc_literal = zend_add_literal(CG(active_op_array), &c TSRMLS_CC);
-	CALCULATE_LITERAL_HASH(lc_literal);
+	/* Lowercased name */
+	zend_string *lc_name = zend_string_alloc(name->len, 0);
+	zend_str_tolower_copy(lc_name->val, name->val, name->len);
+	zend_add_literal_string(op_array, &lc_name TSRMLS_CC);
 
-	ns_separator = (const char*)zend_memrchr(Z_STRVAL_P(zv), '\\', Z_STRLEN_P(zv)) + 1;
-	lc_len = Z_STRLEN_P(zv) - (ns_separator - Z_STRVAL_P(zv));
-	lc_name = zend_str_tolower_dup(ns_separator, lc_len);
-	ZVAL_STRINGL(&c, lc_name, lc_len, 0);
-	lc_literal = zend_add_literal(CG(active_op_array), &c TSRMLS_CC);
-	CALCULATE_LITERAL_HASH(lc_literal);
+	/* Lowercased unqualfied name */
+	if (zend_get_unqualified_name(name, &unqualified_name, &unqualified_name_len)) {
+		lc_name = zend_string_alloc(unqualified_name_len, 0);
+		zend_str_tolower_copy(lc_name->val, unqualified_name, unqualified_name_len);
+		zend_add_literal_string(op_array, &lc_name TSRMLS_CC);
+	}
 
 	return ret;
 }
 /* }}} */
 
-int zend_add_class_name_literal(zend_op_array *op_array, const zval *zv TSRMLS_DC) /* {{{ */
+static int zend_add_class_name_literal(zend_op_array *op_array, zend_string *name TSRMLS_DC) /* {{{ */
 {
-	int ret;
-	char *lc_name;
-	int lc_len;
-	zval c;
-	int lc_literal;
-
-	if (op_array->last_literal > 0 &&
-	    &op_array->literals[op_array->last_literal - 1].constant == zv &&
-	    op_array->literals[op_array->last_literal - 1].cache_slot == -1) {
-		/* we already have function name as last literal (do nothing) */
-		ret = op_array->last_literal - 1;
-	} else {
-		ret = zend_add_literal(op_array, zv TSRMLS_CC);
-	}
+	/* Original name */
+	int ret = zend_add_literal_string(op_array, &name TSRMLS_CC);
 
-	if (Z_STRVAL_P(zv)[0] == '\\') {
-		lc_len = Z_STRLEN_P(zv) - 1;
-		lc_name = zend_str_tolower_dup(Z_STRVAL_P(zv) + 1, lc_len);
-	} else {
-		lc_len = Z_STRLEN_P(zv);
-		lc_name = zend_str_tolower_dup(Z_STRVAL_P(zv), lc_len);
-	}
-	ZVAL_STRINGL(&c, lc_name, lc_len, 0);
-	lc_literal = zend_add_literal(CG(active_op_array), &c TSRMLS_CC);
-	CALCULATE_LITERAL_HASH(lc_literal);
+	/* Lowercased name */
+	zend_string *lc_name = zend_string_alloc(name->len, 0);
+	zend_str_tolower_copy(lc_name->val, name->val, name->len);
+	zend_add_literal_string(op_array, &lc_name TSRMLS_CC);
 
-	GET_CACHE_SLOT(ret);
+	zend_alloc_cache_slot(ret TSRMLS_CC);
 
 	return ret;
 }
 /* }}} */
 
-int zend_add_const_name_literal(zend_op_array *op_array, const zval *zv, int unqualified TSRMLS_DC) /* {{{ */
+static int zend_add_const_name_literal(zend_op_array *op_array, zend_string *name, zend_bool unqualified TSRMLS_DC) /* {{{ */
 {
-	int ret, tmp_literal;
-	char *name, *tmp_name;
-	const char *ns_separator;
-	int name_len, ns_len;
-	zval c;
+	zend_string *tmp_name;
 
-	if (op_array->last_literal > 0 &&
-	    &op_array->literals[op_array->last_literal - 1].constant == zv &&
-	    op_array->literals[op_array->last_literal - 1].cache_slot == -1) {
-		/* we already have function name as last literal (do nothing) */
-		ret = op_array->last_literal - 1;
-	} else {
-		ret = zend_add_literal(op_array, zv TSRMLS_CC);
-	}
+	int ret = zend_add_literal_string(op_array, &name TSRMLS_CC);
 
-	/* skip leading '\\' */
-	if (Z_STRVAL_P(zv)[0] == '\\') {
-		name_len = Z_STRLEN_P(zv) - 1;
-		name = Z_STRVAL_P(zv) + 1;
-	} else {
-		name_len = Z_STRLEN_P(zv);
-		name = Z_STRVAL_P(zv);
-	}
-	ns_separator = zend_memrchr(name, '\\', name_len);
-	if (ns_separator) {
-		ns_len = ns_separator - name;
-	} else {
-		ns_len = 0;
-	}
+	size_t ns_len = 0, after_ns_len = name->len;
+	const char *after_ns = zend_memrchr(name->val, '\\', name->len);
+	if (after_ns) {
+		after_ns += 1;
+		ns_len = after_ns - name->val - 1;
+		after_ns_len = name->len - ns_len - 1;
 
-	if (ns_len) {
 		/* lowercased namespace name & original constant name */
-		tmp_name = estrndup(name, name_len);
-		zend_str_tolower(tmp_name, ns_len);
-		ZVAL_STRINGL(&c, tmp_name, name_len, 0);
-		tmp_literal = zend_add_literal(CG(active_op_array), &c TSRMLS_CC);
-		CALCULATE_LITERAL_HASH(tmp_literal);
+		tmp_name = zend_string_init(name->val, name->len, 0);
+		zend_str_tolower(tmp_name->val, ns_len);
+		zend_add_literal_string(op_array, &tmp_name TSRMLS_CC);
 
 		/* lowercased namespace name & lowercased constant name */
-		tmp_name = zend_str_tolower_dup(name, name_len);
-		ZVAL_STRINGL(&c, tmp_name, name_len, 0);
-		tmp_literal = zend_add_literal(CG(active_op_array), &c TSRMLS_CC);
-		CALCULATE_LITERAL_HASH(tmp_literal);
-	}
+		tmp_name = zend_string_alloc(name->len, 0);
+		zend_str_tolower_copy(tmp_name->val, name->val, name->len);
+		zend_add_literal_string(op_array, &tmp_name TSRMLS_CC);
 
-	if (ns_len) {
 		if (!unqualified) {
 			return ret;
 		}
-		ns_len++;
-		name += ns_len;
-		name_len -= ns_len;
+	} else {
+		after_ns = name->val;
 	}
 
-	/* original constant name */
-	tmp_name = estrndup(name, name_len);
-	ZVAL_STRINGL(&c, tmp_name, name_len, 0);
-	tmp_literal = zend_add_literal(CG(active_op_array), &c TSRMLS_CC);
-	CALCULATE_LITERAL_HASH(tmp_literal);
+	/* original unqualified constant name */
+	tmp_name = zend_string_init(after_ns, after_ns_len, 0);
+	zend_add_literal_string(op_array, &tmp_name TSRMLS_CC);
 
-	/* lowercased constant name */
-	tmp_name = zend_str_tolower_dup(name, name_len);
-	ZVAL_STRINGL(&c, tmp_name, name_len, 0);
-	tmp_literal = zend_add_literal(CG(active_op_array), &c TSRMLS_CC);
-	CALCULATE_LITERAL_HASH(tmp_literal);
+	/* lowercased unqualified constant name */
+	tmp_name = zend_string_alloc(after_ns_len, 0);
+	zend_str_tolower_copy(tmp_name->val, after_ns, after_ns_len);
+	zend_add_literal_string(op_array, &tmp_name TSRMLS_CC);
 
 	return ret;
 }
 /* }}} */
 
-#define LITERAL_STRINGL(op, str, len, copy) do { \
+#define LITERAL_STR(op, str) do { \
 		zval _c; \
-		ZVAL_STRINGL(&_c, str, len, copy); \
+		ZVAL_STR(&_c, str); \
 		op.constant = zend_add_literal(CG(active_op_array), &_c TSRMLS_CC); \
 	} while (0)
 
-#define LITERAL_LONG(op, val) do { \
-		zval _c; \
-		ZVAL_LONG(&_c, val); \
-		op.constant = zend_add_literal(CG(active_op_array), &_c TSRMLS_CC); \
-	} while (0)
+#define MAKE_NOP(opline) do { \
+	opline->opcode = ZEND_NOP; \
+	memset(&opline->result, 0, sizeof(opline->result)); \
+	memset(&opline->op1, 0, sizeof(opline->op1)); \
+	memset(&opline->op2, 0, sizeof(opline->op2)); \
+	opline->result_type = opline->op1_type = opline->op2_type = IS_UNUSED; \
+} while (0)
 
-#define LITERAL_LONG_EX(op_array, op, val) do { \
-		zval _c; \
-		ZVAL_LONG(&_c, val); \
-		op.constant = zend_add_literal(op_array, &_c TSRMLS_CC); \
-	} while (0)
-
-#define LITERAL_NULL(op) do { \
-		zval _c; \
-		INIT_ZVAL(	_c); \
-		op.constant = zend_add_literal(CG(active_op_array), &_c TSRMLS_CC); \
-	} while (0)
+void zend_stop_lexing(TSRMLS_D) {
+	LANG_SCNG(yy_cursor) = LANG_SCNG(yy_limit);
+}
 
-static inline zend_bool zend_is_function_or_method_call(const znode *variable) /* {{{ */
+static inline void zend_begin_loop(TSRMLS_D) /* {{{ */
 {
-	zend_uint type = variable->EA;
+	zend_brk_cont_element *brk_cont_element;
+	int parent;
 
-	return  ((type & ZEND_PARSED_METHOD_CALL) || (type == ZEND_PARSED_FUNCTION_CALL));
+	parent = CG(context).current_brk_cont;
+	CG(context).current_brk_cont = CG(active_op_array)->last_brk_cont;
+	brk_cont_element = get_next_brk_cont_element(CG(active_op_array));
+	brk_cont_element->start = get_next_op_number(CG(active_op_array));
+	brk_cont_element->parent = parent;
 }
 /* }}} */
 
-void zend_do_binary_op(zend_uchar op, znode *result, const znode *op1, const znode *op2 TSRMLS_DC) /* {{{ */
+static inline void zend_end_loop(int cont_addr, int has_loop_var TSRMLS_DC) /* {{{ */
 {
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-
-	opline->opcode = op;
-	opline->result_type = IS_TMP_VAR;
-	opline->result.var = get_temporary_variable(CG(active_op_array));
-	SET_NODE(opline->op1, op1);
-	SET_NODE(opline->op2, op2);
-	GET_NODE(result, opline->result);
+	if (!has_loop_var) {
+		/* The start fileld is used to free temporary variables in case of exceptions.
+		 * We won't try to free something of we don't have loop variable.
+		 */
+		CG(active_op_array)->brk_cont_array[CG(context).current_brk_cont].start = -1;
+	}
+	CG(active_op_array)->brk_cont_array[CG(context).current_brk_cont].cont = cont_addr;
+	CG(active_op_array)->brk_cont_array[CG(context).current_brk_cont].brk = get_next_op_number(CG(active_op_array));
+	CG(context).current_brk_cont = CG(active_op_array)->brk_cont_array[CG(context).current_brk_cont].parent;
 }
 /* }}} */
 
-void zend_do_unary_op(zend_uchar op, znode *result, const znode *op1 TSRMLS_DC) /* {{{ */
+void zend_do_free(znode *op1 TSRMLS_DC) /* {{{ */
 {
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	if (op1->op_type==IS_TMP_VAR) {
+		zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
-	opline->opcode = op;
-	opline->result_type = IS_TMP_VAR;
-	opline->result.var = get_temporary_variable(CG(active_op_array));
-	SET_NODE(opline->op1, op1);
-	GET_NODE(result, opline->result);
-	SET_UNUSED(opline->op2);
+		opline->opcode = ZEND_FREE;
+		SET_NODE(opline->op1, op1);
+		SET_UNUSED(opline->op2);
+	} else if (op1->op_type==IS_VAR) {
+		zend_op *opline = &CG(active_op_array)->opcodes[CG(active_op_array)->last-1];
+
+		while (opline->opcode == ZEND_END_SILENCE || opline->opcode == ZEND_EXT_FCALL_END || opline->opcode == ZEND_OP_DATA) {
+			opline--;
+		}
+		if (opline->result_type == IS_VAR
+			&& opline->result.var == op1->u.op.var) {
+			if (opline->opcode == ZEND_FETCH_R ||
+			    opline->opcode == ZEND_FETCH_DIM_R ||
+			    opline->opcode == ZEND_FETCH_OBJ_R) {
+				/* It's very rare and useless case. It's better to use
+				   additional FREE opcode and simplify the FETCH handlers
+				   their selves */
+				opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+				opline->opcode = ZEND_FREE;
+				SET_NODE(opline->op1, op1);
+				SET_UNUSED(opline->op2);
+			} else {
+				opline->result_type |= EXT_TYPE_UNUSED;
+			}
+		} else {
+			while (opline>CG(active_op_array)->opcodes) {
+				if (opline->opcode == ZEND_FETCH_LIST &&
+				    opline->op1_type == IS_VAR &&
+				    opline->op1.var == op1->u.op.var) {
+					opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+
+					opline->opcode = ZEND_FREE;
+					SET_NODE(opline->op1, op1);
+					SET_UNUSED(opline->op2);
+					return;
+				}
+				if (opline->result_type==IS_VAR
+					&& opline->result.var == op1->u.op.var) {
+					if (opline->opcode == ZEND_NEW) {
+						opline->result_type |= EXT_TYPE_UNUSED;
+						opline = &CG(active_op_array)->opcodes[CG(active_op_array)->last-1];
+						while (opline->opcode != ZEND_DO_FCALL || opline->op1.num != ZEND_CALL_CTOR) {
+							opline--;
+						}
+						opline->op1.num |= ZEND_CALL_CTOR_RESULT_UNUSED;
+					}
+					break;
+				}
+				opline--;
+			}
+		}
+	} else if (op1->op_type == IS_CONST) {
+		/* Destroy value without using GC: When opcache moves arrays into SHM it will
+		 * free the zend_array structure, so references to it from outside the op array
+		 * become invalid. GC would cause such a reference in the root buffer. */
+		zval_ptr_dtor_nogc(&op1->u.constant);
+	}
 }
 /* }}} */
 
-#define MAKE_NOP(opline)	{ opline->opcode = ZEND_NOP;  memset(&opline->result,0,sizeof(opline->result)); memset(&opline->op1,0,sizeof(opline->op1)); memset(&opline->op2,0,sizeof(opline->op2)); opline->result_type=opline->op1_type=opline->op2_type=IS_UNUSED;  }
-
-static void zend_do_op_data(zend_op *data_op, const znode *value TSRMLS_DC) /* {{{ */
+uint32_t zend_add_member_modifier(uint32_t flags, uint32_t new_flag) /* {{{ */
 {
-	data_op->opcode = ZEND_OP_DATA;
-	SET_NODE(data_op->op1, value);
-	SET_UNUSED(data_op->op2);
+	uint32_t new_flags = flags | new_flag;
+	if ((flags & ZEND_ACC_PPP_MASK) && (new_flag & ZEND_ACC_PPP_MASK)) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Multiple access type modifiers are not allowed");
+	}
+	if ((flags & ZEND_ACC_ABSTRACT) && (new_flag & ZEND_ACC_ABSTRACT)) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Multiple abstract modifiers are not allowed");
+	}
+	if ((flags & ZEND_ACC_STATIC) && (new_flag & ZEND_ACC_STATIC)) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Multiple static modifiers are not allowed");
+	}
+	if ((flags & ZEND_ACC_FINAL) && (new_flag & ZEND_ACC_FINAL)) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Multiple final modifiers are not allowed");
+	}
+	if ((new_flags & ZEND_ACC_ABSTRACT) && (new_flags & ZEND_ACC_FINAL)) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Cannot use the final modifier on an abstract class member");
+	}
+	return new_flags;
 }
 /* }}} */
 
-void zend_do_binary_assign_op(zend_uchar op, znode *result, const znode *op1, const znode *op2 TSRMLS_DC) /* {{{ */
+zend_string *zend_concat3(char *str1, size_t str1_len, char *str2, size_t str2_len, char *str3, size_t str3_len) /* {{{ */
 {
-	int last_op_number = get_next_op_number(CG(active_op_array));
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	size_t len = str1_len + str2_len + str3_len;
+	zend_string *res = zend_string_alloc(len, 0);
 
-	if (last_op_number > 0) {
-		zend_op *last_op = &CG(active_op_array)->opcodes[last_op_number-1];
+	memcpy(res->val, str1, str1_len);
+	memcpy(res->val + str1_len, str2, str2_len);
+	memcpy(res->val + str1_len + str2_len, str3, str3_len);
+	res->val[len] = '\0';
 
-		switch (last_op->opcode) {
-			case ZEND_FETCH_OBJ_RW:
-				last_op->opcode = op;
-				last_op->extended_value = ZEND_ASSIGN_OBJ;
+	return res;
+}
 
-				zend_do_op_data(opline, op2 TSRMLS_CC);
-				SET_UNUSED(opline->result);
-				GET_NODE(result, last_op->result);
-				return;
-			case ZEND_FETCH_DIM_RW:
-				last_op->opcode = op;
-				last_op->extended_value = ZEND_ASSIGN_DIM;
-
-				zend_do_op_data(opline, op2 TSRMLS_CC);
-				opline->op2.var = get_temporary_variable(CG(active_op_array));
-				opline->op2_type = IS_VAR;
-				SET_UNUSED(opline->result);
-				GET_NODE(result,last_op->result);
-				return;
-			default:
-				break;
-		}
+zend_string *zend_concat_names(char *name1, size_t name1_len, char *name2, size_t name2_len) {
+	return zend_concat3(name1, name1_len, "\\", 1, name2, name2_len);
+}
+
+zend_string *zend_prefix_with_ns(zend_string *name TSRMLS_DC) {
+	if (CG(current_namespace)) {
+		zend_string *ns = CG(current_namespace);
+		return zend_concat_names(ns->val, ns->len, name->val, name->len);
+	} else {
+		return zend_string_copy(name);
 	}
+}
 
-	opline->opcode = op;
-	SET_NODE(opline->op1, op1);
-	SET_NODE(opline->op2, op2);
-	opline->result_type = IS_VAR;
-	opline->result.var = get_temporary_variable(CG(active_op_array));
-	GET_NODE(result, opline->result);
+void *zend_hash_find_ptr_lc(HashTable *ht, const char *str, size_t len) {
+	void *result;
+	zend_string *lcname;
+	ALLOCA_FLAG(use_heap);
+
+	STR_ALLOCA_ALLOC(lcname, len, use_heap);
+	zend_str_tolower_copy(lcname->val, str, len);
+	result = zend_hash_find_ptr(ht, lcname);
+	STR_ALLOCA_FREE(lcname, use_heap);
+
+	return result;
 }
-/* }}} */
 
-void fetch_simple_variable_ex(znode *result, znode *varname, int bp, zend_uchar op TSRMLS_DC) /* {{{ */
-{
-	zend_op opline;
-	zend_op *opline_ptr;
-	zend_llist *fetch_list_ptr;
+zend_string *zend_resolve_non_class_name(
+	zend_string *name, uint32_t type, zend_bool *is_fully_qualified,
+	zend_bool case_sensitive, HashTable *current_import_sub TSRMLS_DC
+) {
+	char *compound;
+	*is_fully_qualified = 0;
 
-	if (varname->op_type == IS_CONST) {
-		ulong hash;
+	if (name->val[0] == '\\') {
+		/* Remove \ prefix (only relevant if this is a string rather than a label) */
+		return zend_string_init(name->val + 1, name->len - 1, 0);
+	}
 
-		if (Z_TYPE(varname->u.constant) != IS_STRING) {
-			convert_to_string(&varname->u.constant);
+	if (type == ZEND_NAME_FQ) {
+		*is_fully_qualified = 1;
+		return zend_string_copy(name);
+	}
+
+	if (type == ZEND_NAME_RELATIVE) {
+		*is_fully_qualified = 1;
+		return zend_prefix_with_ns(name TSRMLS_CC);
+	}
+
+	if (current_import_sub) {
+		/* If an unqualified name is a function/const alias, replace it. */
+		zend_string *import_name;
+		if (case_sensitive) {
+			import_name = zend_hash_find_ptr(current_import_sub, name);
+		} else {
+			import_name = zend_hash_find_ptr_lc(current_import_sub, name->val, name->len);
 		}
 
-		hash = str_hash(Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant));
-		if (!zend_is_auto_global_quick(Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant), hash TSRMLS_CC) &&
-		    !(Z_STRLEN(varname->u.constant) == (sizeof("this")-1) &&
-		      !memcmp(Z_STRVAL(varname->u.constant), "this", sizeof("this"))) &&
-		    (CG(active_op_array)->last == 0 ||
-		     CG(active_op_array)->opcodes[CG(active_op_array)->last-1].opcode != ZEND_BEGIN_SILENCE)) {
-			result->op_type = IS_CV;
-			result->u.op.var = lookup_cv(CG(active_op_array), Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant), hash TSRMLS_CC);
-			Z_STRVAL(varname->u.constant) = (char*)CG(active_op_array)->vars[result->u.op.var].name;
-			result->EA = 0;
-			return;
+		if (import_name) {
+			*is_fully_qualified = 1;
+			return zend_string_copy(import_name);
 		}
 	}
 
-	if (bp) {
-		opline_ptr = &opline;
-		init_op(opline_ptr TSRMLS_CC);
-	} else {
-		opline_ptr = get_next_op(CG(active_op_array) TSRMLS_CC);
+	compound = memchr(name->val, '\\', name->len);
+	if (compound) {
+		*is_fully_qualified = 1;
 	}
 
-	opline_ptr->opcode = op;
-	opline_ptr->result_type = IS_VAR;
-	opline_ptr->result.var = get_temporary_variable(CG(active_op_array));
-	SET_NODE(opline_ptr->op1, varname);
-	GET_NODE(result, opline_ptr->result);
-	SET_UNUSED(opline_ptr->op2);
-	opline_ptr->extended_value = ZEND_FETCH_LOCAL;
+	if (compound && CG(current_import)) {
+		/* If the first part of a qualified name is an alias, substitute it. */
+		size_t len = compound - name->val;
+		zend_string *import_name = zend_hash_find_ptr_lc(CG(current_import), name->val, len);
 
-	if (varname->op_type == IS_CONST) {
-		CALCULATE_LITERAL_HASH(opline_ptr->op1.constant);
-		if (zend_is_auto_global_quick(Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant), Z_HASH_P(&CONSTANT(opline_ptr->op1.constant)) TSRMLS_CC)) {
-			opline_ptr->extended_value = ZEND_FETCH_GLOBAL;
+		if (import_name) {
+			return zend_concat_names(
+				import_name->val, import_name->len, name->val + len + 1, name->len - len - 1);
 		}
 	}
 
-	if (bp) {
-		zend_stack_top(&CG(bp_stack), (void **) &fetch_list_ptr);
-		zend_llist_add_element(fetch_list_ptr, opline_ptr);
-	}
+	return zend_prefix_with_ns(name TSRMLS_CC);
 }
 /* }}} */
 
-void fetch_simple_variable(znode *result, znode *varname, int bp TSRMLS_DC) /* {{{ */
+zend_string *zend_resolve_function_name(zend_string *name, uint32_t type, zend_bool *is_fully_qualified TSRMLS_DC) /* {{{ */
 {
-	/* the default mode must be Write, since fetch_simple_variable() is used to define function arguments */
-	fetch_simple_variable_ex(result, varname, bp, ZEND_FETCH_W TSRMLS_CC);
+	return zend_resolve_non_class_name(
+		name, type, is_fully_qualified, 0, CG(current_import_function) TSRMLS_CC);
 }
 /* }}} */
 
-void zend_do_fetch_static_member(znode *result, znode *class_name TSRMLS_DC) /* {{{ */
+zend_string *zend_resolve_const_name(zend_string *name, uint32_t type, zend_bool *is_fully_qualified TSRMLS_DC) /* {{{ */ {
+	return zend_resolve_non_class_name(
+		name, type, is_fully_qualified, 1, CG(current_import_const) TSRMLS_CC);
+}
+/* }}} */
+
+zend_string *zend_resolve_class_name(zend_string *name, uint32_t type TSRMLS_DC) /* {{{ */
 {
-	znode class_node;
-	zend_llist *fetch_list_ptr;
-	zend_llist_element *le;
-	zend_op *opline_ptr;
-	zend_op opline;
+	char *compound;
 
-	if (class_name->op_type == IS_CONST &&
-	    ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant))) {
-		zend_resolve_class_name(class_name TSRMLS_CC);
-		class_node = *class_name;
-	} else {
-		zend_do_fetch_class(&class_node, class_name TSRMLS_CC);
-	}
-	zend_stack_top(&CG(bp_stack), (void **) &fetch_list_ptr);
-	if (result->op_type == IS_CV) {
-		init_op(&opline TSRMLS_CC);
-
-		opline.opcode = ZEND_FETCH_W;
-		opline.result_type = IS_VAR;
-		opline.result.var = get_temporary_variable(CG(active_op_array));
-		opline.op1_type = IS_CONST;
-		LITERAL_STRINGL(opline.op1, estrdup(CG(active_op_array)->vars[result->u.op.var].name), CG(active_op_array)->vars[result->u.op.var].name_len, 0);
-		CALCULATE_LITERAL_HASH(opline.op1.constant);
-		GET_POLYMORPHIC_CACHE_SLOT(opline.op1.constant);
-		if (class_node.op_type == IS_CONST) {
-			opline.op2_type = IS_CONST;
-			opline.op2.constant =
-				zend_add_class_name_literal(CG(active_op_array), &class_node.u.constant TSRMLS_CC);
+	if (type == ZEND_NAME_RELATIVE) {
+		return zend_prefix_with_ns(name TSRMLS_CC);
+	}
+
+	if (type == ZEND_NAME_FQ || name->val[0] == '\\') {
+		/* Remove \ prefix (only relevant if this is a string rather than a label) */
+		if (name->val[0] == '\\') {
+			name = zend_string_init(name->val + 1, name->len - 1, 0);
 		} else {
-			SET_NODE(opline.op2, &class_node);
+			zend_string_addref(name);
+		}
+		/* Ensure that \self, \parent and \static are not used */
+		if (ZEND_FETCH_CLASS_DEFAULT != zend_get_class_fetch_type(name)) {
+			zend_error_noreturn(E_COMPILE_ERROR, "'\\%s' is an invalid class name", name->val);
 		}
-		GET_NODE(result,opline.result);
-		opline.extended_value |= ZEND_FETCH_STATIC_MEMBER;
-		opline_ptr = &opline;
+		return name;
+	}
 
-		zend_llist_add_element(fetch_list_ptr, &opline);
-	} else {
-		le = fetch_list_ptr->head;
-
-		opline_ptr = (zend_op *)le->data;
-		if (opline_ptr->opcode != ZEND_FETCH_W && opline_ptr->op1_type == IS_CV) {
-			init_op(&opline TSRMLS_CC);
-			opline.opcode = ZEND_FETCH_W;
-			opline.result_type = IS_VAR;
-			opline.result.var = get_temporary_variable(CG(active_op_array));
-			opline.op1_type = IS_CONST;
-			LITERAL_STRINGL(opline.op1, estrdup(CG(active_op_array)->vars[opline_ptr->op1.var].name), CG(active_op_array)->vars[opline_ptr->op1.var].name_len, 0);
-			CALCULATE_LITERAL_HASH(opline.op1.constant);
-			GET_POLYMORPHIC_CACHE_SLOT(opline.op1.constant);
-			if (class_node.op_type == IS_CONST) {
-				opline.op2_type = IS_CONST;
-				opline.op2.constant =
-					zend_add_class_name_literal(CG(active_op_array), &class_node.u.constant TSRMLS_CC);
-			} else {
-				SET_NODE(opline.op2, &class_node);
+	if (CG(current_import)) {
+		compound = memchr(name->val, '\\', name->len);
+		if (compound) {
+			/* If the first part of a qualified name is an alias, substitute it. */
+			size_t len = compound - name->val;
+			zend_string *import_name = zend_hash_find_ptr_lc(CG(current_import), name->val, len);
+
+			if (import_name) {
+				return zend_concat_names(
+					import_name->val, import_name->len, name->val + len + 1, name->len - len - 1);
 			}
-			opline.extended_value |= ZEND_FETCH_STATIC_MEMBER;
-			COPY_NODE(opline_ptr->op1, opline.result);
-
-			zend_llist_prepend_element(fetch_list_ptr, &opline);
 		} else {
-			if (opline_ptr->op1_type == IS_CONST) {
-				GET_POLYMORPHIC_CACHE_SLOT(opline_ptr->op1.constant);
-			}
-			if (class_node.op_type == IS_CONST) {
-				opline_ptr->op2_type = IS_CONST;
-				opline_ptr->op2.constant =
-					zend_add_class_name_literal(CG(active_op_array), &class_node.u.constant TSRMLS_CC);
-			} else {
-				SET_NODE(opline_ptr->op2, &class_node);
+			/* If an unqualified name is an alias, replace it. */
+			zend_string *import_name
+				= zend_hash_find_ptr_lc(CG(current_import), name->val, name->len);
+
+			if (import_name) {
+				return zend_string_copy(import_name);
 			}
-			opline_ptr->extended_value |= ZEND_FETCH_STATIC_MEMBER;
 		}
 	}
+
+	/* If not fully qualified and not an alias, prepend the current namespace */
+	return zend_prefix_with_ns(name TSRMLS_CC);
+}
+/* }}} */
+
+zend_string *zend_resolve_class_name_ast(zend_ast *ast TSRMLS_DC) /* {{{ */
+{
+	zend_string *name = zend_ast_get_str(ast);
+	return zend_resolve_class_name(name, ast->attr TSRMLS_CC);
 }
 /* }}} */
 
-void fetch_array_begin(znode *result, znode *varname, znode *first_dim TSRMLS_DC) /* {{{ */
+static void ptr_dtor(zval *zv) /* {{{ */
 {
-	fetch_simple_variable(result, varname, 1 TSRMLS_CC);
+	efree(Z_PTR_P(zv));
+}
+/* }}} */
 
-	fetch_array_dim(result, result, first_dim TSRMLS_CC);
+static void str_dtor(zval *zv)  /* {{{ */ {
+	zend_string_release(Z_STR_P(zv));
 }
 /* }}} */
 
-void fetch_array_dim(znode *result, const znode *parent, const znode *dim TSRMLS_DC) /* {{{ */
+void zend_resolve_goto_label(zend_op_array *op_array, zend_op *opline, int pass2 TSRMLS_DC) /* {{{ */
 {
-	zend_op opline;
-	zend_llist *fetch_list_ptr;
+	zend_label *dest;
+	zend_long current, distance;
+	zval *label;
 
-	zend_stack_top(&CG(bp_stack), (void **) &fetch_list_ptr);
+	if (pass2) {
+		label = opline->op2.zv;
+	} else {
+		label = &CONSTANT_EX(op_array, opline->op2.constant);
+	}
+	if (CG(context).labels == NULL ||
+	    (dest = zend_hash_find_ptr(CG(context).labels, Z_STR_P(label))) == NULL) {
 
-	if (zend_is_function_or_method_call(parent)) {
-		init_op(&opline TSRMLS_CC);
-		opline.opcode = ZEND_SEPARATE;
-		SET_NODE(opline.op1, parent);
-		SET_UNUSED(opline.op2);
-		opline.result_type = IS_VAR;
-		opline.result.var = opline.op1.var;
-		zend_llist_add_element(fetch_list_ptr, &opline);
+		if (pass2) {
+			CG(in_compilation) = 1;
+			CG(active_op_array) = op_array;
+			CG(zend_lineno) = opline->lineno;
+			zend_error_noreturn(E_COMPILE_ERROR, "'goto' to undefined label '%s'", Z_STRVAL_P(label));
+		} else {
+			/* Label is not defined. Delay to pass 2. */
+			return;
+		}
 	}
 
-	init_op(&opline TSRMLS_CC);
-	opline.opcode = ZEND_FETCH_DIM_W;	/* the backpatching routine assumes W */
-	opline.result_type = IS_VAR;
-	opline.result.var = get_temporary_variable(CG(active_op_array));
-	SET_NODE(opline.op1, parent);
-	SET_NODE(opline.op2, dim);
-	if (opline.op2_type == IS_CONST && Z_TYPE(CONSTANT(opline.op2.constant)) == IS_STRING) {
-		ulong index;
-		int numeric = 0;
+	opline->op1.opline_num = dest->opline_num;
+	zval_dtor(label);
+	ZVAL_NULL(label);
 
-		ZEND_HANDLE_NUMERIC_EX(Z_STRVAL(CONSTANT(opline.op2.constant)), Z_STRLEN(CONSTANT(opline.op2.constant))+1, index, numeric = 1);
-		if (numeric) {
-			zval_dtor(&CONSTANT(opline.op2.constant));
-			ZVAL_LONG(&CONSTANT(opline.op2.constant), index);
-		} else {
-			CALCULATE_LITERAL_HASH(opline.op2.constant);
+	/* Check that we are not moving into loop or switch */
+	current = opline->extended_value;
+	for (distance = 0; current != dest->brk_cont; distance++) {
+		if (current == -1) {
+			if (pass2) {
+				CG(in_compilation) = 1;
+				CG(active_op_array) = op_array;
+				CG(zend_lineno) = opline->lineno;
+			}
+			zend_error_noreturn(E_COMPILE_ERROR, "'goto' into loop or switch statement is disallowed");
 		}
+		current = op_array->brk_cont_array[current].parent;
 	}
 
-	GET_NODE(result, opline.result);
+	if (distance == 0) {
+		/* Nothing to break out of, optimize to ZEND_JMP */
+		opline->opcode = ZEND_JMP;
+		opline->extended_value = 0;
+		SET_UNUSED(opline->op2);
+	} else {
+		/* Set real break distance */
+		ZVAL_LONG(label, distance);
+	}
+}
+/* }}} */
 
-	zend_llist_add_element(fetch_list_ptr, &opline);
+void zend_release_labels(int temporary TSRMLS_DC) /* {{{ */
+{
+	if (CG(context).labels) {
+		zend_hash_destroy(CG(context).labels);
+		FREE_HASHTABLE(CG(context).labels);
+		CG(context).labels = NULL;
+	}
+	if (!temporary && !zend_stack_is_empty(&CG(context_stack))) {
+		zend_compiler_context *ctx = zend_stack_top(&CG(context_stack));
+		CG(context) = *ctx;
+		zend_stack_del_top(&CG(context_stack));
+	}
 }
 /* }}} */
 
-void fetch_string_offset(znode *result, const znode *parent, const znode *offset TSRMLS_DC) /* {{{ */
+static zend_bool zend_is_call(zend_ast *ast);
+
+static int generate_free_loop_var(znode *var TSRMLS_DC) /* {{{ */
 {
-	fetch_array_dim(result, parent, offset TSRMLS_CC);
+	switch (var->op_type) {
+		case IS_UNUSED:
+			/* Stack separator on function boundary, stop applying */
+			return 1;
+		case IS_VAR:
+		case IS_TMP_VAR:
+		{
+			zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+
+			opline->opcode = ZEND_FREE;
+			SET_NODE(opline->op1, var);
+			SET_UNUSED(opline->op2);
+		}
+	}
+
+	return 0;
 }
 /* }}} */
 
-void zend_do_print(znode *result, const znode *arg TSRMLS_DC) /* {{{ */
+static uint32_t zend_add_try_element(uint32_t try_op TSRMLS_DC) /* {{{ */
 {
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	zend_op_array *op_array = CG(active_op_array);
+	uint32_t try_catch_offset = op_array->last_try_catch++;
+	zend_try_catch_element *elem;
 
-	opline->result_type = IS_TMP_VAR;
-	opline->result.var = get_temporary_variable(CG(active_op_array));
-	opline->opcode = ZEND_PRINT;
-	SET_NODE(opline->op1, arg);
-	SET_UNUSED(opline->op2);
-	GET_NODE(result, opline->result);
+	op_array->try_catch_array = safe_erealloc(
+		op_array->try_catch_array, sizeof(zend_try_catch_element), op_array->last_try_catch, 0);
+
+	elem = &op_array->try_catch_array[try_catch_offset];
+	elem->try_op = try_op;
+	elem->catch_op = 0;
+	elem->finally_op = 0;
+	elem->finally_end = 0;
+
+	return try_catch_offset;
 }
 /* }}} */
 
-void zend_do_echo(const znode *arg TSRMLS_DC) /* {{{ */
+ZEND_API void function_add_ref(zend_function *function) /* {{{ */
 {
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	if (function->type == ZEND_USER_FUNCTION) {
+		zend_op_array *op_array = &function->op_array;
 
-	opline->opcode = ZEND_ECHO;
-	SET_NODE(opline->op1, arg);
-	SET_UNUSED(opline->op2);
+		(*op_array->refcount)++;
+		if (op_array->static_variables) {
+			HashTable *static_variables = op_array->static_variables;
+
+			ALLOC_HASHTABLE(op_array->static_variables);
+			zend_array_dup(op_array->static_variables, static_variables);
+		}
+		op_array->run_time_cache = NULL;
+	} else if (function->type == ZEND_INTERNAL_FUNCTION) {
+		if (function->common.function_name) {
+			zend_string_addref(function->common.function_name);
+		}
+	}
 }
 /* }}} */
 
-void zend_do_abstract_method(const znode *function_name, znode *modifiers, const znode *body TSRMLS_DC) /* {{{ */
+ZEND_API int do_bind_function(const zend_op_array *op_array, const zend_op *opline, HashTable *function_table, zend_bool compile_time TSRMLS_DC) /* {{{ */
 {
-	char *method_type;
+	zend_function *function, *new_function;
+	zval *op1, *op2;
 
-	if (CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE) {
-		Z_LVAL(modifiers->u.constant) |= ZEND_ACC_ABSTRACT;
-		method_type = "Interface";
+	if (compile_time) {
+		op1 = &CONSTANT_EX(op_array, opline->op1.constant);
+		op2 = &CONSTANT_EX(op_array, opline->op2.constant);
 	} else {
-		method_type = "Abstract";
+		op1 = opline->op1.zv;
+		op2 = opline->op2.zv;
 	}
 
-	if (Z_LVAL(modifiers->u.constant) & ZEND_ACC_ABSTRACT) {
-		if(Z_LVAL(modifiers->u.constant) & ZEND_ACC_PRIVATE) {
-			zend_error(E_COMPILE_ERROR, "%s function %s::%s() cannot be declared private", method_type, CG(active_class_entry)->name, Z_STRVAL(function_name->u.constant));
-		}
-		if (Z_LVAL(body->u.constant) == ZEND_ACC_ABSTRACT) {
-			zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	function = zend_hash_find_ptr(function_table, Z_STR_P(op1));
+	new_function = zend_arena_alloc(&CG(arena), sizeof(zend_op_array));
+	memcpy(new_function, function, sizeof(zend_op_array));
+	if (zend_hash_add_ptr(function_table, Z_STR_P(op2), new_function) == NULL) {
+		int error_level = compile_time ? E_COMPILE_ERROR : E_ERROR;
+		zend_function *old_function;
 
-			opline->opcode = ZEND_RAISE_ABSTRACT_ERROR;
-			SET_UNUSED(opline->op1);
-			SET_UNUSED(opline->op2);
+		efree_size(new_function, sizeof(zend_op_array));
+		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);
 		} else {
-			/* we had code in the function body */
-			zend_error(E_COMPILE_ERROR, "%s function %s::%s() cannot contain body", method_type, CG(active_class_entry)->name, Z_STRVAL(function_name->u.constant));
+			zend_error(error_level, "Cannot redeclare %s()", function->common.function_name->val);
 		}
+		return FAILURE;
 	} else {
-		if (Z_LVAL(body->u.constant) == ZEND_ACC_ABSTRACT) {
-			zend_error(E_COMPILE_ERROR, "Non-abstract method %s::%s() must contain body", CG(active_class_entry)->name, Z_STRVAL(function_name->u.constant));
-		}
+		(*function->op_array.refcount)++;
+		function->op_array.static_variables = NULL; /* NULL out the unbound function */
+		return SUCCESS;
 	}
 }
 /* }}} */
 
-static zend_bool opline_is_fetch_this(const zend_op *opline TSRMLS_DC) /* {{{ */
+ZEND_API zend_class_entry *do_bind_class(const zend_op_array* op_array, const zend_op *opline, HashTable *class_table, zend_bool compile_time TSRMLS_DC) /* {{{ */
 {
-	if ((opline->opcode == ZEND_FETCH_W) && (opline->op1_type == IS_CONST)
-		&& (Z_TYPE(CONSTANT(opline->op1.constant)) == IS_STRING)
-		&& (Z_HASH_P(&CONSTANT(opline->op1.constant)) == THIS_HASHVAL)
-		&& (Z_STRLEN(CONSTANT(opline->op1.constant)) == (sizeof("this")-1))
-		&& !memcmp(Z_STRVAL(CONSTANT(opline->op1.constant)), "this", sizeof("this"))) {
-		return 1;
+	zend_class_entry *ce;
+	zval *op1, *op2;
+
+	if (compile_time) {
+		op1 = &CONSTANT_EX(op_array, opline->op1.constant);
+		op2 = &CONSTANT_EX(op_array, opline->op2.constant);
 	} else {
-		return 0;
+		op1 = opline->op1.zv;
+		op2 = opline->op2.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;
+	}
+	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;
 	}
 }
 /* }}} */
 
-void zend_do_assign(znode *result, znode *variable, znode *value TSRMLS_DC) /* {{{ */
+ZEND_API zend_class_entry *do_bind_inherited_class(const zend_op_array *op_array, const zend_op *opline, HashTable *class_table, zend_class_entry *parent_ce, zend_bool compile_time TSRMLS_DC) /* {{{ */
 {
-	int last_op_number;
-	zend_op *opline;
-
-	if (value->op_type == IS_CV) {
-		zend_llist *fetch_list_ptr;
+	zend_class_entry *ce;
+	zval *op1, *op2;
 
-		zend_stack_top(&CG(bp_stack), (void **) &fetch_list_ptr);
-		if (fetch_list_ptr && fetch_list_ptr->head) {
-			opline = (zend_op *)fetch_list_ptr->head->data;
+	if (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;
+	}
 
-			if (opline->opcode == ZEND_FETCH_DIM_W &&
-			    opline->op1_type == IS_CV &&
-			    opline->op1.var == value->u.op.var) {
+	ce = zend_hash_find_ptr(class_table, Z_STR_P(op1));
 
-				opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-				opline->opcode = ZEND_FETCH_R;
-				opline->result_type = IS_VAR;
-				opline->result.var = get_temporary_variable(CG(active_op_array));
-				opline->op1_type = IS_CONST;
-				LITERAL_STRINGL(opline->op1,
-					CG(active_op_array)->vars[value->u.op.var].name,
-					CG(active_op_array)->vars[value->u.op.var].name_len, 1);
-				CALCULATE_LITERAL_HASH(opline->op1.constant);
-				SET_UNUSED(opline->op2);
-				opline->extended_value = ZEND_FETCH_LOCAL;
-				GET_NODE(value, opline->result);
-			}
+	if (!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;
 	}
 
-	zend_do_end_variable_parse(variable, BP_VAR_W, 0 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);
+	}
 
-	last_op_number = get_next_op_number(CG(active_op_array));
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	zend_do_inheritance(ce, parent_ce TSRMLS_CC);
+
+	ce->refcount++;
+
+	/* 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;
+}
+/* }}} */
+
+void zend_do_early_binding(TSRMLS_D) /* {{{ */
+{
+	zend_op *opline = &CG(active_op_array)->opcodes[CG(active_op_array)->last-1];
+	HashTable *table;
+
+	while (opline->opcode == ZEND_TICKS && opline > CG(active_op_array)->opcodes) {
+		opline--;
+	}
+
+	switch (opline->opcode) {
+		case ZEND_DECLARE_FUNCTION:
+			if (do_bind_function(CG(active_op_array), opline, CG(function_table), 1 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;
 
-	if (variable->op_type == IS_CV) {
-		if (variable->u.op.var == CG(active_op_array)->this_var) {
-			zend_error(E_COMPILE_ERROR, "Cannot re-assign $this");
-		}
-	} else if (variable->op_type == IS_VAR) {
-		int n = 0;
-
-		while (last_op_number - n > 0) {
-			zend_op *last_op;
-
-			last_op = &CG(active_op_array)->opcodes[last_op_number-n-1];
-
-			if (last_op->result_type == IS_VAR &&
-			    last_op->result.var == variable->u.op.var) {
-				if (last_op->opcode == ZEND_FETCH_OBJ_W) {
-					if (n > 0) {
-						int opline_no = (opline-CG(active_op_array)->opcodes)/sizeof(*opline);
-						*opline = *last_op;
-						MAKE_NOP(last_op);
-						/* last_op = opline; */
-						opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-						/* get_next_op can realloc, we need to move last_op */
-						last_op = &CG(active_op_array)->opcodes[opline_no];
+				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;
+
+						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;
 					}
-					last_op->opcode = ZEND_ASSIGN_OBJ;
-					zend_do_op_data(opline, value TSRMLS_CC);
-					SET_UNUSED(opline->result);
-					GET_NODE(result, last_op->result);
 					return;
-				} else if (last_op->opcode == ZEND_FETCH_DIM_W) {
-					if (n > 0) {
-						int opline_no = (opline-CG(active_op_array)->opcodes)/sizeof(*opline);
-						*opline = *last_op;
-						MAKE_NOP(last_op);
-						/* last_op = opline; */
-						/* TBFixed: this can realloc opcodes, leaving last_op pointing wrong */
-						opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-						/* get_next_op can realloc, we need to move last_op */
-						last_op = &CG(active_op_array)->opcodes[opline_no];
-					}
-					last_op->opcode = ZEND_ASSIGN_DIM;
-					zend_do_op_data(opline, value TSRMLS_CC);
-					opline->op2.var = get_temporary_variable(CG(active_op_array));
-					opline->op2_type = IS_VAR;
-					SET_UNUSED(opline->result);
-					GET_NODE(result, last_op->result);
+				}
+				if (do_bind_inherited_class(CG(active_op_array), opline, CG(class_table), ce, 1 TSRMLS_CC) == NULL) {
 					return;
-				} else if (opline_is_fetch_this(last_op TSRMLS_CC)) {
-					zend_error(E_COMPILE_ERROR, "Cannot re-assign $this");
-				} else {
-					break;
 				}
+				/* clear unnecessary ZEND_FETCH_CLASS opcode */
+				zend_del_literal(CG(active_op_array), fetch_class_opline->op2.constant);
+				MAKE_NOP(fetch_class_opline);
+
+				table = CG(class_table);
+				break;
 			}
-			n++;
-		}
+		case ZEND_VERIFY_ABSTRACT_CLASS:
+		case ZEND_ADD_INTERFACE:
+		case ZEND_ADD_TRAIT:
+		case ZEND_BIND_TRAITS:
+			/* We currently don't early-bind classes that implement interfaces */
+			/* Classes with traits are handled exactly the same, no early-bind here */
+			return;
+		default:
+			zend_error_noreturn(E_COMPILE_ERROR, "Invalid binding type");
+			return;
 	}
 
-	opline->opcode = ZEND_ASSIGN;
-	SET_NODE(opline->op1, variable);
-	SET_NODE(opline->op2, value);
-	opline->result_type = IS_VAR;
-	opline->result.var = get_temporary_variable(CG(active_op_array));
-	GET_NODE(result, opline->result);
+	zend_hash_del(table, Z_STR(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);
 }
 /* }}} */
 
-void zend_do_assign_ref(znode *result, const znode *lvar, const znode *rvar TSRMLS_DC) /* {{{ */
+ZEND_API void zend_do_delayed_early_binding(const zend_op_array *op_array TSRMLS_DC) /* {{{ */
 {
-	zend_op *opline;
-
-	if (lvar->op_type == IS_CV) {
-		if (lvar->u.op.var == CG(active_op_array)->this_var) {
- 			zend_error(E_COMPILE_ERROR, "Cannot re-assign $this");
-		}
-	} else if (lvar->op_type == IS_VAR) {
-		int last_op_number = get_next_op_number(CG(active_op_array));
+	if (op_array->early_binding != -1) {
+		zend_bool orig_in_compilation = CG(in_compilation);
+		uint32_t opline_num = op_array->early_binding;
+		zend_class_entry *ce;
 
-		if (last_op_number > 0) {
-			opline = &CG(active_op_array)->opcodes[last_op_number-1];
-			if (opline_is_fetch_this(opline TSRMLS_CC)) {
-	 			zend_error(E_COMPILE_ERROR, "Cannot re-assign $this");
+		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 = get_next_op(CG(active_op_array) TSRMLS_CC);
-	opline->opcode = ZEND_ASSIGN_REF;
-	if (zend_is_function_or_method_call(rvar)) {
-		opline->extended_value = ZEND_RETURNS_FUNCTION;
-	} else if (rvar->EA & ZEND_PARSED_NEW) {
-		opline->extended_value = ZEND_RETURNS_NEW;
-	} else {
-		opline->extended_value = 0;
-	}
-	if (result) {
-		opline->result_type = IS_VAR;
-		opline->result.var = get_temporary_variable(CG(active_op_array));
-		GET_NODE(result, opline->result);
-	} else {
-		opline->result_type = IS_UNUSED | EXT_TYPE_UNUSED;
+			opline_num = op_array->opcodes[opline_num].result.opline_num;
+		}
+		CG(in_compilation) = orig_in_compilation;
 	}
-	SET_NODE(opline->op1, lvar);
-	SET_NODE(opline->op2, rvar);
 }
 /* }}} */
 
-static inline void do_begin_loop(TSRMLS_D) /* {{{ */
+ZEND_API zend_string *zend_mangle_property_name(const char *src1, size_t src1_length, const char *src2, size_t src2_length, int internal) /* {{{ */
 {
-	zend_brk_cont_element *brk_cont_element;
-	int parent;
+	size_t prop_name_length = 1 + src1_length + 1 + src2_length;
+	zend_string *prop_name = zend_string_alloc(prop_name_length, internal);
 
-	parent = CG(context).current_brk_cont;
-	CG(context).current_brk_cont = CG(active_op_array)->last_brk_cont;
-	brk_cont_element = get_next_brk_cont_element(CG(active_op_array));
-	brk_cont_element->start = get_next_op_number(CG(active_op_array));
-	brk_cont_element->parent = parent;
+	prop_name->val[0] = '\0';
+	memcpy(prop_name->val + 1, src1, src1_length+1);
+	memcpy(prop_name->val + 1 + src1_length + 1, src2, src2_length+1);
+	return prop_name;
 }
 /* }}} */
 
-static inline void do_end_loop(int cont_addr, int has_loop_var TSRMLS_DC) /* {{{ */
+static int zend_strnlen(const char* s, size_t maxlen) /* {{{ */
 {
-	if (!has_loop_var) {
-		/* The start fileld is used to free temporary variables in case of exceptions.
-		 * We won't try to free something of we don't have loop variable.
-		 */
-		CG(active_op_array)->brk_cont_array[CG(context).current_brk_cont].start = -1;
-	}
-	CG(active_op_array)->brk_cont_array[CG(context).current_brk_cont].cont = cont_addr;
-	CG(active_op_array)->brk_cont_array[CG(context).current_brk_cont].brk = get_next_op_number(CG(active_op_array));
-	CG(context).current_brk_cont = CG(active_op_array)->brk_cont_array[CG(context).current_brk_cont].parent;
+	size_t len = 0;
+	while (*s++ && maxlen--) len++;
+	return len;
 }
 /* }}} */
 
-void zend_do_while_cond(const znode *expr, znode *close_bracket_token TSRMLS_DC) /* {{{ */
+ZEND_API int zend_unmangle_property_name_ex(const zend_string *name, const char **class_name, const char **prop_name, size_t *prop_len) /* {{{ */
 {
-	int while_cond_op_number = get_next_op_number(CG(active_op_array));
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	size_t class_name_len;
 
-	opline->opcode = ZEND_JMPZ;
-	SET_NODE(opline->op1, expr);
-	close_bracket_token->u.op.opline_num = while_cond_op_number;
-	SET_UNUSED(opline->op2);
+	*class_name = NULL;
 
-	do_begin_loop(TSRMLS_C);
-	INC_BPC(CG(active_op_array));
+	if (name->val[0] != '\0') {
+		*prop_name = name->val;
+		if (prop_len) {
+			*prop_len = name->len;
+		}
+		return SUCCESS;
+	}
+	if (name->len < 3 || name->val[1] == '\0') {
+		zend_error(E_NOTICE, "Illegal member variable name");
+		*prop_name = name->val;
+		if (prop_len) {
+			*prop_len = name->len;
+		}
+		return FAILURE;
+	}
+
+	class_name_len = zend_strnlen(name->val + 1, name->len - 2);
+	if (class_name_len >= name->len - 2 || name->val[class_name_len + 1] != '\0') {
+		zend_error(E_NOTICE, "Corrupt member variable name");
+		*prop_name = name->val;
+		if (prop_len) {
+			*prop_len = name->len;
+		}
+		return FAILURE;
+	}
+
+	*class_name = name->val + 1;
+	*prop_name = name->val + class_name_len + 2;
+	if (prop_len) {
+		*prop_len = name->len - class_name_len - 2;
+	}
+	return SUCCESS;
 }
 /* }}} */
 
-void zend_do_while_end(const znode *while_token, const znode *close_bracket_token TSRMLS_DC) /* {{{ */
+static zend_constant *zend_lookup_reserved_const(const char *name, size_t len TSRMLS_DC) /* {{{ */
 {
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	zend_constant *c = zend_hash_find_ptr_lc(EG(zend_constants), name, len);
+	if (c && !(c->flags & CONST_CS) && (c->flags & CONST_CT_SUBST)) {
+		return c;
+	}
+	return NULL;
+}
+/* }}} */
 
-	/* add unconditional jump */
-	opline->opcode = ZEND_JMP;
-	opline->op1.opline_num = while_token->u.op.opline_num;
-	SET_UNUSED(opline->op1);
-	SET_UNUSED(opline->op2);
+static zend_bool zend_try_ct_eval_const(zval *zv, zend_string *name, zend_bool is_fully_qualified TSRMLS_DC) /* {{{ */
+{
+	zend_constant *c;
 
-	/* update while's conditional jmp */
-	CG(active_op_array)->opcodes[close_bracket_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array));
+	if (!(CG(compiler_options) & ZEND_COMPILE_NO_CONSTANT_SUBSTITUTION)) {
+		/* Substitute case-sensitive (or lowercase) persistent constants */
+		c = zend_hash_find_ptr(EG(zend_constants), name);
+		if (c && (c->flags & CONST_PERSISTENT)) {
+			ZVAL_DUP(zv, &c->value);
+			return 1;
+		}
+	}
 
-	do_end_loop(while_token->u.op.opline_num, 0 TSRMLS_CC);
+	{
+		/* Substitute true, false and null (including unqualified usage in namespaces) */
+		const char *lookup_name = name->val;
+		size_t lookup_len = name->len;
+
+		if (!is_fully_qualified) {
+			zend_get_unqualified_name(name, &lookup_name, &lookup_len);
+		}
 
-	DEC_BPC(CG(active_op_array));
+		c = zend_lookup_reserved_const(lookup_name, lookup_len TSRMLS_CC);
+		if (c) {
+			ZVAL_DUP(zv, &c->value);
+			return 1;
+		}
+	}
+
+	return 0;
 }
 /* }}} */
 
-void zend_do_for_cond(const znode *expr, znode *second_semicolon_token TSRMLS_DC) /* {{{ */
+void zend_init_list(void *result, void *item TSRMLS_DC) /* {{{ */
 {
-	int for_cond_op_number = get_next_op_number(CG(active_op_array));
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	void** list = emalloc(sizeof(void*) * 2);
 
-	opline->opcode = ZEND_JMPZNZ;
-	SET_NODE(opline->op1, expr);  /* the conditional expression */
-	second_semicolon_token->u.op.opline_num = for_cond_op_number;
-	SET_UNUSED(opline->op2);
+	list[0] = item;
+	list[1] = NULL;
+
+	*(void**)result = list;
 }
 /* }}} */
 
-void zend_do_for_before_statement(const znode *cond_start, const znode *second_semicolon_token TSRMLS_DC) /* {{{ */
+void zend_add_to_list(void *result, void *item TSRMLS_DC) /* {{{ */
 {
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	void** list = *(void**)result;
+	size_t n = 0;
 
-	opline->opcode = ZEND_JMP;
-	opline->op1.opline_num = cond_start->u.op.opline_num;
-	CG(active_op_array)->opcodes[second_semicolon_token->u.op.opline_num].extended_value = get_next_op_number(CG(active_op_array));
-	SET_UNUSED(opline->op1);
-	SET_UNUSED(opline->op2);
+	if (list) {
+		while (list[n]) {
+			n++;
+		}
+	}
+
+	list = erealloc(list, sizeof(void*) * (n+2));
 
-	do_begin_loop(TSRMLS_C);
+	list[n]   = item;
+	list[n+1] = NULL;
 
-	INC_BPC(CG(active_op_array));
+	*(void**)result = list;
 }
 /* }}} */
 
-void zend_do_for_end(const znode *second_semicolon_token TSRMLS_DC) /* {{{ */
+void zend_do_extended_info(TSRMLS_D) /* {{{ */
 {
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	zend_op *opline;
 
-	opline->opcode = ZEND_JMP;
-	opline->op1.opline_num = second_semicolon_token->u.op.opline_num+1;
-	CG(active_op_array)->opcodes[second_semicolon_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array));
-	SET_UNUSED(opline->op1);
-	SET_UNUSED(opline->op2);
+	if (!(CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO)) {
+		return;
+	}
 
-	do_end_loop(second_semicolon_token->u.op.opline_num+1, 0 TSRMLS_CC);
+	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
-	DEC_BPC(CG(active_op_array));
+	opline->opcode = ZEND_EXT_STMT;
+	SET_UNUSED(opline->op1);
+	SET_UNUSED(opline->op2);
 }
 /* }}} */
 
-void zend_do_pre_incdec(znode *result, const znode *op1, zend_uchar op TSRMLS_DC) /* {{{ */
+void zend_do_extended_fcall_begin(TSRMLS_D) /* {{{ */
 {
-	int last_op_number = get_next_op_number(CG(active_op_array));
 	zend_op *opline;
 
-	if (last_op_number > 0) {
-		zend_op *last_op = &CG(active_op_array)->opcodes[last_op_number-1];
-
-		if (last_op->opcode == ZEND_FETCH_OBJ_RW) {
-			last_op->opcode = (op==ZEND_PRE_INC)?ZEND_PRE_INC_OBJ:ZEND_PRE_DEC_OBJ;
-			last_op->result_type = IS_VAR;
-			last_op->result.var = get_temporary_variable(CG(active_op_array));
-			GET_NODE(result, last_op->result);
-			return;
-		}
+	if (!(CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO)) {
+		return;
 	}
 
 	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	opline->opcode = op;
-	SET_NODE(opline->op1, op1);
+
+	opline->opcode = ZEND_EXT_FCALL_BEGIN;
+	SET_UNUSED(opline->op1);
 	SET_UNUSED(opline->op2);
-	opline->result_type = IS_VAR;
-	opline->result.var = get_temporary_variable(CG(active_op_array));
-	GET_NODE(result, opline->result);
 }
 /* }}} */
 
-void zend_do_post_incdec(znode *result, const znode *op1, zend_uchar op TSRMLS_DC) /* {{{ */
+void zend_do_extended_fcall_end(TSRMLS_D) /* {{{ */
 {
-	int last_op_number = get_next_op_number(CG(active_op_array));
 	zend_op *opline;
 
-	if (last_op_number > 0) {
-		zend_op *last_op = &CG(active_op_array)->opcodes[last_op_number-1];
-
-		if (last_op->opcode == ZEND_FETCH_OBJ_RW) {
-			last_op->opcode = (op==ZEND_POST_INC)?ZEND_POST_INC_OBJ:ZEND_POST_DEC_OBJ;
-			last_op->result_type = IS_TMP_VAR;
-			last_op->result.var = get_temporary_variable(CG(active_op_array));
-			GET_NODE(result, last_op->result);
-			return;
-		}
+	if (!(CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO)) {
+		return;
 	}
 
 	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	opline->opcode = op;
-	SET_NODE(opline->op1, op1);
+
+	opline->opcode = ZEND_EXT_FCALL_END;
+	SET_UNUSED(opline->op1);
 	SET_UNUSED(opline->op2);
-	opline->result_type = IS_TMP_VAR;
-	opline->result.var = get_temporary_variable(CG(active_op_array));
-	GET_NODE(result, opline->result);
 }
 /* }}} */
 
-void zend_do_if_cond(const znode *cond, znode *closing_bracket_token TSRMLS_DC) /* {{{ */
+zend_bool zend_is_auto_global(zend_string *name TSRMLS_DC) /* {{{ */
 {
-	int if_cond_op_number = get_next_op_number(CG(active_op_array));
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	zend_auto_global *auto_global;
 
-	opline->opcode = ZEND_JMPZ;
-	SET_NODE(opline->op1, cond);
-	closing_bracket_token->u.op.opline_num = if_cond_op_number;
-	SET_UNUSED(opline->op2);
-	INC_BPC(CG(active_op_array));
+	if ((auto_global = zend_hash_find_ptr(CG(auto_globals), name)) != NULL) {
+		if (auto_global->armed) {
+			auto_global->armed = auto_global->auto_global_callback(auto_global->name TSRMLS_CC);
+		}
+		return 1;
+	}
+	return 0;
 }
 /* }}} */
 
-void zend_do_if_after_statement(const znode *closing_bracket_token, unsigned char initialize TSRMLS_DC) /* {{{ */
+int zend_register_auto_global(zend_string *name, zend_bool jit, zend_auto_global_callback auto_global_callback TSRMLS_DC) /* {{{ */
 {
-	int if_end_op_number = get_next_op_number(CG(active_op_array));
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	zend_llist *jmp_list_ptr;
+	zend_auto_global auto_global;
+	int retval;
 
-	opline->opcode = ZEND_JMP;
-	/* save for backpatching */
-	if (initialize) {
-		zend_llist jmp_list;
+	auto_global.name = zend_new_interned_string(name TSRMLS_CC);
+	auto_global.auto_global_callback = auto_global_callback;
+	auto_global.jit = jit;
 
-		zend_llist_init(&jmp_list, sizeof(int), NULL, 0);
-		zend_stack_push(&CG(bp_stack), (void *) &jmp_list, sizeof(zend_llist));
-	}
-	zend_stack_top(&CG(bp_stack), (void **) &jmp_list_ptr);
-	zend_llist_add_element(jmp_list_ptr, &if_end_op_number);
+	retval = zend_hash_add_mem(CG(auto_globals), name, &auto_global, sizeof(zend_auto_global)) != NULL ? SUCCESS : FAILURE;
 
-	CG(active_op_array)->opcodes[closing_bracket_token->u.op.opline_num].op2.opline_num = if_end_op_number+1;
-	SET_UNUSED(opline->op1);
-	SET_UNUSED(opline->op2);
+	zend_string_release(auto_global.name);
+	return retval;
 }
 /* }}} */
 
-void zend_do_if_end(TSRMLS_D) /* {{{ */
+ZEND_API void zend_activate_auto_globals(TSRMLS_D) /* {{{ */
 {
-	int next_op_number = get_next_op_number(CG(active_op_array));
-	zend_llist *jmp_list_ptr;
-	zend_llist_element *le;
+	zend_auto_global *auto_global;
 
-	zend_stack_top(&CG(bp_stack), (void **) &jmp_list_ptr);
-	for (le=jmp_list_ptr->head; le; le = le->next) {
-		CG(active_op_array)->opcodes[*((int *) le->data)].op1.opline_num = next_op_number;
-	}
-	zend_llist_destroy(jmp_list_ptr);
-	zend_stack_del_top(&CG(bp_stack));
-	DEC_BPC(CG(active_op_array));
+	ZEND_HASH_FOREACH_PTR(CG(auto_globals), auto_global) {
+		if (auto_global->jit) {
+			auto_global->armed = 1;
+		} else if (auto_global->auto_global_callback) {
+			auto_global->armed = auto_global->auto_global_callback(auto_global->name TSRMLS_CC);
+		} else {
+			auto_global->armed = 0;
+		}
+	} ZEND_HASH_FOREACH_END();
 }
 /* }}} */
 
-void zend_check_writable_variable(const znode *variable) /* {{{ */
+int zendlex(zend_parser_stack_elem *elem TSRMLS_DC) /* {{{ */
 {
-	zend_uint type = variable->EA;
+	zval zv;
+	int retval;
 
-	if (type & ZEND_PARSED_METHOD_CALL) {
-		zend_error(E_COMPILE_ERROR, "Can't use method return value in write context");
-	}
-	if (type == ZEND_PARSED_FUNCTION_CALL) {
-		zend_error(E_COMPILE_ERROR, "Can't use function return value in write context");
+	if (CG(increment_lineno)) {
+		CG(zend_lineno)++;
+		CG(increment_lineno) = 0;
 	}
-}
-/* }}} */
 
-void zend_do_begin_variable_parse(TSRMLS_D) /* {{{ */
-{
-	zend_llist fetch_list;
+again:
+	ZVAL_UNDEF(&zv);
+	retval = lex_scan(&zv TSRMLS_CC);
+	switch (retval) {
+		case T_COMMENT:
+		case T_DOC_COMMENT:
+		case T_OPEN_TAG:
+		case T_WHITESPACE:
+			goto again;
+
+		case T_CLOSE_TAG:
+			if (LANG_SCNG(yy_text)[LANG_SCNG(yy_leng)-1] != '>') {
+				CG(increment_lineno) = 1;
+			}
+			retval = ';'; /* implicit ; */
+			break;
+		case T_OPEN_TAG_WITH_ECHO:
+			retval = T_ECHO;
+			break;
+	}
+	if (Z_TYPE(zv) != IS_UNDEF) {
+		elem->ast = zend_ast_create_zval(&zv);
+	}
 
-	zend_llist_init(&fetch_list, sizeof(zend_op), NULL, 0);
-	zend_stack_push(&CG(bp_stack), (void *) &fetch_list, sizeof(zend_llist));
+	return retval;
 }
 /* }}} */
 
-void zend_do_end_variable_parse(znode *variable, int type, int arg_offset TSRMLS_DC) /* {{{ */
+ZEND_API void zend_initialize_class_data(zend_class_entry *ce, zend_bool nullify_handlers TSRMLS_DC) /* {{{ */
 {
-	zend_llist *fetch_list_ptr;
-	zend_llist_element *le;
-	zend_op *opline = NULL;
-	zend_op *opline_ptr;
-	zend_uint this_var = -1;
-
-	zend_stack_top(&CG(bp_stack), (void **) &fetch_list_ptr);
+	zend_bool persistent_hashes = (ce->type == ZEND_INTERNAL_CLASS) ? 1 : 0;
+	dtor_func_t zval_ptr_dtor_func = ((persistent_hashes) ? ZVAL_INTERNAL_PTR_DTOR : ZVAL_PTR_DTOR);
 
-	le = fetch_list_ptr->head;
+	ce->refcount = 1;
+	ce->ce_flags = ZEND_ACC_CONSTANTS_UPDATED;
 
-	/* TODO: $foo->x->y->z = 1 should fetch "x" and "y" for R or RW, not just W */
+	ce->default_properties_table = NULL;
+	ce->default_static_members_table = NULL;
+	zend_hash_init_ex(&ce->properties_info, 8, NULL, (persistent_hashes ? zend_destroy_property_info_internal : zend_destroy_property_info), persistent_hashes, 0);
+	zend_hash_init_ex(&ce->constants_table, 8, NULL, zval_ptr_dtor_func, persistent_hashes, 0);
+	zend_hash_init_ex(&ce->function_table, 8, NULL, ZEND_FUNCTION_DTOR, persistent_hashes, 0);
 
-	if (le) {
-		opline_ptr = (zend_op *)le->data;
-		if (opline_is_fetch_this(opline_ptr TSRMLS_CC)) {
-			/* convert to FETCH_?(this) into IS_CV */
-			if (CG(active_op_array)->last == 0 ||
-			    CG(active_op_array)->opcodes[CG(active_op_array)->last-1].opcode != ZEND_BEGIN_SILENCE) {
+	if (ce->type == ZEND_INTERNAL_CLASS) {
+#ifdef ZTS
+		int n = zend_hash_num_elements(CG(class_table));
 
-				this_var = opline_ptr->result.var;
-				if (CG(active_op_array)->this_var == -1) {
-					CG(active_op_array)->this_var = lookup_cv(CG(active_op_array), Z_STRVAL(CONSTANT(opline_ptr->op1.constant)), Z_STRLEN(CONSTANT(opline_ptr->op1.constant)), Z_HASH_P(&CONSTANT(opline_ptr->op1.constant)) TSRMLS_CC);
-					Z_TYPE(CONSTANT(opline_ptr->op1.constant)) = IS_NULL;
-				} else {
-					zend_del_literal(CG(active_op_array), opline_ptr->op1.constant);
-				}
-				le = le->next;
-				if (variable->op_type == IS_VAR &&
-				    variable->u.op.var == this_var) {
-					variable->op_type = IS_CV;
-					variable->u.op.var = CG(active_op_array)->this_var;
-				}
-			} else if (CG(active_op_array)->this_var == -1) {
-				CG(active_op_array)->this_var = lookup_cv(CG(active_op_array), estrndup("this", sizeof("this")-1), sizeof("this")-1, THIS_HASHVAL TSRMLS_CC);
-			}
+		if (CG(static_members_table) && n >= CG(last_static_member)) {
+			/* Support for run-time declaration: dl() */
+			CG(last_static_member) = n+1;
+			CG(static_members_table) = realloc(CG(static_members_table), (n+1)*sizeof(zval*));
+			CG(static_members_table)[n] = NULL;
 		}
+		ce->static_members_table = (zval*)(zend_intptr_t)n;
+#else
+		ce->static_members_table = NULL;
+#endif
+	} else {
+		ce->static_members_table = ce->default_static_members_table;
+		ce->info.user.doc_comment = NULL;
+	}
 
-		while (le) {
-			opline_ptr = (zend_op *)le->data;
-			if (opline_ptr->opcode == ZEND_SEPARATE) {
-				if (type != BP_VAR_R && type != BP_VAR_IS) {
-					opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-					memcpy(opline, opline_ptr, sizeof(zend_op));
-				}
-				le = le->next;
-				continue;
-			}
-			opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-			memcpy(opline, opline_ptr, sizeof(zend_op));
-			if (opline->op1_type == IS_VAR &&
-			    opline->op1.var == this_var) {
-				opline->op1_type = IS_CV;
-				opline->op1.var = CG(active_op_array)->this_var;
-			}
-			switch (type) {
-				case BP_VAR_R:
-					if (opline->opcode == ZEND_FETCH_DIM_W && opline->op2_type == IS_UNUSED) {
-						zend_error(E_COMPILE_ERROR, "Cannot use [] for reading");
-					}
-					opline->opcode -= 3;
-					break;
-				case BP_VAR_W:
-					break;
-				case BP_VAR_RW:
-					opline->opcode += 3;
-					break;
-				case BP_VAR_IS:
-					if (opline->opcode == ZEND_FETCH_DIM_W && opline->op2_type == IS_UNUSED) {
-						zend_error(E_COMPILE_ERROR, "Cannot use [] for reading");
-					}
-					opline->opcode += 6; /* 3+3 */
-					break;
-				case BP_VAR_FUNC_ARG:
-					opline->opcode += 9; /* 3+3+3 */
-					opline->extended_value |= arg_offset;
-					break;
-				case BP_VAR_UNSET:
-					if (opline->opcode == ZEND_FETCH_DIM_W && opline->op2_type == IS_UNUSED) {
-						zend_error(E_COMPILE_ERROR, "Cannot use [] for unsetting");
-					}
-					opline->opcode += 12; /* 3+3+3+3 */
-					break;
-			}
-			le = le->next;
-		}
-		if (opline && type == BP_VAR_W && arg_offset) {
-			opline->extended_value |= ZEND_FETCH_MAKE_REF;
+	ce->default_properties_count = 0;
+	ce->default_static_members_count = 0;
+
+	if (nullify_handlers) {
+		ce->constructor = NULL;
+		ce->destructor = NULL;
+		ce->clone = NULL;
+		ce->__get = NULL;
+		ce->__set = NULL;
+		ce->__unset = NULL;
+		ce->__isset = NULL;
+		ce->__call = NULL;
+		ce->__callstatic = NULL;
+		ce->__tostring = NULL;
+		ce->create_object = NULL;
+		ce->get_iterator = NULL;
+		ce->iterator_funcs.funcs = NULL;
+		ce->interface_gets_implemented = NULL;
+		ce->get_static_method = NULL;
+		ce->parent = NULL;
+		ce->num_interfaces = 0;
+		ce->interfaces = NULL;
+		ce->num_traits = 0;
+		ce->traits = NULL;
+		ce->trait_aliases = NULL;
+		ce->trait_precedences = NULL;
+		ce->serialize = NULL;
+		ce->unserialize = NULL;
+		ce->serialize_func = NULL;
+		ce->unserialize_func = NULL;
+		ce->__debugInfo = NULL;
+		if (ce->type == ZEND_INTERNAL_CLASS) {
+			ce->info.internal.module = NULL;
+			ce->info.internal.builtin_functions = NULL;
 		}
 	}
-	zend_llist_destroy(fetch_list_ptr);
-	zend_stack_del_top(&CG(bp_stack));
 }
 /* }}} */
 
-void zend_do_add_string(znode *result, const znode *op1, znode *op2 TSRMLS_DC) /* {{{ */
+uint32_t zend_get_class_fetch_type(zend_string *name) /* {{{ */ 
 {
-	zend_op *opline;
-
-	if (Z_STRLEN(op2->u.constant) > 1) {
-		opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-		opline->opcode = ZEND_ADD_STRING;
-	} else if (Z_STRLEN(op2->u.constant) == 1) {
-		int ch = *Z_STRVAL(op2->u.constant);
-
-		/* Free memory and use ZEND_ADD_CHAR in case of 1 character strings */
-		efree(Z_STRVAL(op2->u.constant));
-		ZVAL_LONG(&op2->u.constant, ch);
-		opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-		opline->opcode = ZEND_ADD_CHAR;
-	} else { /* String can be empty after a variable at the end of a heredoc */
-		efree(Z_STRVAL(op2->u.constant));
-		return;
-	}
-
-	if (op1) {
-		SET_NODE(opline->op1, op1);
-		SET_NODE(opline->result, op1);
+	if (zend_string_equals_literal_ci(name, "self")) {
+		return ZEND_FETCH_CLASS_SELF;
+	} else if (zend_string_equals_literal_ci(name, "parent")) {
+		return ZEND_FETCH_CLASS_PARENT;
+	} else if (zend_string_equals_literal_ci(name, "static")) {
+		return ZEND_FETCH_CLASS_STATIC;
 	} else {
-		SET_UNUSED(opline->op1);
-		opline->result_type = IS_TMP_VAR;
-		opline->result.var = get_temporary_variable(CG(active_op_array));
+		return ZEND_FETCH_CLASS_DEFAULT;
 	}
-	SET_NODE(opline->op2, op2);
-	GET_NODE(result, opline->result);
 }
 /* }}} */
 
-void zend_do_add_variable(znode *result, const znode *op1, const znode *op2 TSRMLS_DC) /* {{{ */
+ZEND_API zend_string *zend_get_compiled_variable_name(const zend_op_array *op_array, uint32_t var) /* {{{ */
 {
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-
-	opline->opcode = ZEND_ADD_VAR;
-
-	if (op1) {
-		SET_NODE(opline->op1, op1);
-		SET_NODE(opline->result, op1);
-	} else {
-		SET_UNUSED(opline->op1);
-		opline->result_type = IS_TMP_VAR;
-		opline->result.var = get_temporary_variable(CG(active_op_array));
-	}
-	SET_NODE(opline->op2, op2);
-	GET_NODE(result, opline->result);
+	return op_array->vars[EX_VAR_TO_NUM(var)];
 }
 /* }}} */
 
-void zend_do_free(znode *op1 TSRMLS_DC) /* {{{ */
+zend_ast *zend_ast_append_str(zend_ast *left_ast, zend_ast *right_ast) /* {{{ */
 {
-	if (op1->op_type==IS_TMP_VAR) {
-		zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	zval *left_zv = zend_ast_get_zval(left_ast);
+	zend_string *left = Z_STR_P(left_zv);
+	zend_string *right = zend_ast_get_str(right_ast);
 
-		opline->opcode = ZEND_FREE;
-		SET_NODE(opline->op1, op1);
-		SET_UNUSED(opline->op2);
-	} else if (op1->op_type==IS_VAR) {
-		zend_op *opline = &CG(active_op_array)->opcodes[CG(active_op_array)->last-1];
+	zend_string *result;
+	size_t left_len = left->len;
+	size_t len = left_len + right->len + 1; /* left\right */
 
-		while (opline->opcode == ZEND_END_SILENCE || opline->opcode == ZEND_EXT_FCALL_END || opline->opcode == ZEND_OP_DATA) {
-			opline--;
-		}
-		if (opline->result_type == IS_VAR
-			&& opline->result.var == op1->u.op.var) {
-			if (opline->opcode == ZEND_FETCH_R ||
-			    opline->opcode == ZEND_FETCH_DIM_R ||
-			    opline->opcode == ZEND_FETCH_OBJ_R ||
-			    opline->opcode == ZEND_QM_ASSIGN_VAR) {
-				/* It's very rare and useless case. It's better to use
-				   additional FREE opcode and simplify the FETCH handlers
-				   their selves */
-				opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-				opline->opcode = ZEND_FREE;
-				SET_NODE(opline->op1, op1);
-				SET_UNUSED(opline->op2);
-			} else {
-				opline->result_type |= EXT_TYPE_UNUSED;
-			}
-		} else {
-			while (opline>CG(active_op_array)->opcodes) {
-				if (opline->opcode == ZEND_FETCH_DIM_R
-				    && opline->op1_type == IS_VAR
-				    && opline->op1.var == op1->u.op.var) {
-					/* This should the end of a list() construct
-					 * Mark its result as unused
-					 */
-					opline->extended_value = ZEND_FETCH_STANDARD;
-					break;
-				} else if (opline->result_type==IS_VAR
-					&& opline->result.var == op1->u.op.var) {
-					if (opline->opcode == ZEND_NEW) {
-						opline->result_type |= EXT_TYPE_UNUSED;
-					}
-					break;
-				}
-				opline--;
-			}
-		}
-	} else if (op1->op_type == IS_CONST) {
-		zval_dtor(&op1->u.constant);
-	}
+	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;
 }
 /* }}} */
 
-int zend_do_verify_access_types(const znode *current_access_type, const znode *new_modifier) /* {{{ */
+/* A hacky way that is used to store the doc comment for properties */
+zend_ast *zend_ast_append_doc_comment(zend_ast *list TSRMLS_DC) /* {{{ */
 {
-	if ((Z_LVAL(current_access_type->u.constant) & ZEND_ACC_PPP_MASK)
-		&& (Z_LVAL(new_modifier->u.constant) & ZEND_ACC_PPP_MASK)) {
-		zend_error(E_COMPILE_ERROR, "Multiple access type modifiers are not allowed");
-	}
-	if ((Z_LVAL(current_access_type->u.constant) & ZEND_ACC_ABSTRACT)
-		&& (Z_LVAL(new_modifier->u.constant) & ZEND_ACC_ABSTRACT)) {
-		zend_error(E_COMPILE_ERROR, "Multiple abstract modifiers are not allowed");
-	}
-	if ((Z_LVAL(current_access_type->u.constant) & ZEND_ACC_STATIC)
-		&& (Z_LVAL(new_modifier->u.constant) & ZEND_ACC_STATIC)) {
-		zend_error(E_COMPILE_ERROR, "Multiple static modifiers are not allowed");
-	}
-	if ((Z_LVAL(current_access_type->u.constant) & ZEND_ACC_FINAL)
-		&& (Z_LVAL(new_modifier->u.constant) & ZEND_ACC_FINAL)) {
-		zend_error(E_COMPILE_ERROR, "Multiple final modifiers are not allowed");
-	}
-	if (((Z_LVAL(current_access_type->u.constant) | Z_LVAL(new_modifier->u.constant)) & (ZEND_ACC_ABSTRACT | ZEND_ACC_FINAL)) == (ZEND_ACC_ABSTRACT | ZEND_ACC_FINAL)) {
-		zend_error(E_COMPILE_ERROR, "Cannot use the final modifier on an abstract class member");
+	if (CG(doc_comment)) {
+		list = zend_ast_list_add(list, zend_ast_create_zval_from_str(CG(doc_comment)));
+		CG(doc_comment) = NULL;
 	}
-	return (Z_LVAL(current_access_type->u.constant) | Z_LVAL(new_modifier->u.constant));
+
+	return list;
 }
 /* }}} */
 
-void zend_do_begin_function_declaration(znode *function_token, znode *function_name, int is_method, int return_reference, znode *fn_flags_znode TSRMLS_DC) /* {{{ */
+void zend_verify_namespace(TSRMLS_D) /* {{{ */
 {
-	zend_op_array op_array;
-	char *name = Z_STRVAL(function_name->u.constant);
-	int name_len = Z_STRLEN(function_name->u.constant);
-	int function_begin_line = function_token->u.op.opline_num;
-	zend_uint fn_flags;
-	const char *lcname;
-	zend_bool orig_interactive;
-	ALLOCA_FLAG(use_heap)
-
-	if (is_method) {
-		if (CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE) {
-			if ((Z_LVAL(fn_flags_znode->u.constant) & ~(ZEND_ACC_STATIC|ZEND_ACC_PUBLIC))) {
-				zend_error(E_COMPILE_ERROR, "Access type for interface method %s::%s() must be omitted", CG(active_class_entry)->name, Z_STRVAL(function_name->u.constant));
-			}
-			Z_LVAL(fn_flags_znode->u.constant) |= ZEND_ACC_ABSTRACT; /* propagates to the rest of the parser */
-		}
-		fn_flags = Z_LVAL(fn_flags_znode->u.constant); /* must be done *after* the above check */
-	} else {
-		fn_flags = 0;
-	}
-	if ((fn_flags & ZEND_ACC_STATIC) && (fn_flags & ZEND_ACC_ABSTRACT) && !(CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE)) {
-		zend_error(E_STRICT, "Static function %s%s%s() should not be abstract", is_method ? CG(active_class_entry)->name : "", is_method ? "::" : "", Z_STRVAL(function_name->u.constant));
+	if (CG(has_bracketed_namespaces) && !CG(in_namespace)) {
+		zend_error_noreturn(E_COMPILE_ERROR, "No code may exist outside of namespace {}");
 	}
+}
+/* }}} */
 
-	function_token->u.op_array = CG(active_op_array);
-
-	orig_interactive = CG(interactive);
-	CG(interactive) = 0;
-	init_op_array(&op_array, ZEND_USER_FUNCTION, INITIAL_OP_ARRAY_SIZE TSRMLS_CC);
-	CG(interactive) = orig_interactive;
-
-	op_array.function_name = name;
-	if (return_reference) {
-		op_array.fn_flags |= ZEND_ACC_RETURN_REFERENCE;
+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;
 	}
-	op_array.fn_flags |= fn_flags;
 
-	op_array.scope = is_method?CG(active_class_entry):NULL;
-	op_array.prototype = NULL;
+	if (CG(current_import_function)) {
+		zend_hash_destroy(CG(current_import_function));
+		efree(CG(current_import_function));
+		CG(current_import_function) = NULL;
+	}
 
-	op_array.line_start = zend_get_compiled_lineno(TSRMLS_C);
+	if (CG(current_import_const)) {
+		zend_hash_destroy(CG(current_import_const));
+		efree(CG(current_import_const));
+		CG(current_import_const) = NULL;
+	}
+}
+/* }}} */
 
-	if (is_method) {
-		zend_ulong hash;
+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;
+	}
+}
+/* }}} */
 
-		lcname = zend_new_interned_string(zend_str_tolower_dup(name, name_len), name_len + 1, 1 TSRMLS_CC);
-		hash = str_hash(lcname, name_len);
-		if (zend_hash_quick_add(&CG(active_class_entry)->function_table, lcname, name_len+1, hash, &op_array, sizeof(zend_op_array), (void **) &CG(active_op_array)) == FAILURE) {
-			zend_error(E_COMPILE_ERROR, "Cannot redeclare %s::%s()", CG(active_class_entry)->name, name);
-		}
+void zend_do_end_compilation(TSRMLS_D) /* {{{ */
+{
+	CG(has_bracketed_namespaces) = 0;
+	zend_end_namespace(TSRMLS_C);
+}
+/* }}} */
 
-		zend_stack_push(&CG(context_stack), (void *) &CG(context), sizeof(CG(context)));
-		zend_init_compiler_context(TSRMLS_C);
+/* {{{ zend_dirname
+   Returns directory name component of path */
+ZEND_API size_t zend_dirname(char *path, size_t len)
+{
+	register char *end = path + len - 1;
+	unsigned int len_adjust = 0;
 
-		if (fn_flags & ZEND_ACC_ABSTRACT) {
-			CG(active_class_entry)->ce_flags |= ZEND_ACC_IMPLICIT_ABSTRACT_CLASS;
+#ifdef PHP_WIN32
+	/* Note that on Win32 CWD is per drive (heritage from CP/M).
+	 * This means dirname("c:foo") maps to "c:." or "c:" - which means CWD on C: drive.
+	 */
+	if ((2 <= len) && isalpha((int)((unsigned char *)path)[0]) && (':' == path[1])) {
+		/* Skip over the drive spec (if any) so as not to change */
+		path += 2;
+		len_adjust += 2;
+		if (2 == len) {
+			/* Return "c:" on Win32 for dirname("c:").
+			 * It would be more consistent to return "c:."
+			 * but that would require making the string *longer*.
+			 */
+			return len;
 		}
-
-		if (!(fn_flags & ZEND_ACC_PPP_MASK)) {
-			fn_flags |= ZEND_ACC_PUBLIC;
+	}
+#elif defined(NETWARE)
+	/*
+	 * Find the first occurrence of : from the left
+	 * move the path pointer to the position just after :
+	 * increment the len_adjust to the length of path till colon character(inclusive)
+	 * If there is no character beyond : simple return len
+	 */
+	char *colonpos = NULL;
+	colonpos = strchr(path, ':');
+	if (colonpos != NULL) {
+		len_adjust = ((colonpos - path) + 1);
+		path += len_adjust;
+		if (len_adjust == len) {
+			return len;
 		}
+	}
+#endif
 
-		if (CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE) {
-			if ((name_len == sizeof(ZEND_CALL_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_CALL_FUNC_NAME, sizeof(ZEND_CALL_FUNC_NAME)-1))) {
-				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
-					zend_error(E_WARNING, "The magic method __call() must have public visibility and cannot be static");
-				}
-			} else if ((name_len == sizeof(ZEND_CALLSTATIC_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_CALLSTATIC_FUNC_NAME, sizeof(ZEND_CALLSTATIC_FUNC_NAME)-1))) {
-				if ((fn_flags & (ZEND_ACC_PPP_MASK ^ ZEND_ACC_PUBLIC)) || (fn_flags & ZEND_ACC_STATIC) == 0) {
-					zend_error(E_WARNING, "The magic method __callStatic() must have public visibility and be static");
-				}
-			} else if ((name_len == sizeof(ZEND_GET_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_GET_FUNC_NAME, sizeof(ZEND_GET_FUNC_NAME)-1))) {
-				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
-					zend_error(E_WARNING, "The magic method __get() must have public visibility and cannot be static");
-				}
-			} else if ((name_len == sizeof(ZEND_SET_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_SET_FUNC_NAME, sizeof(ZEND_SET_FUNC_NAME)-1))) {
-				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
-					zend_error(E_WARNING, "The magic method __set() must have public visibility and cannot be static");
-				}
-			} else if ((name_len == sizeof(ZEND_UNSET_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_UNSET_FUNC_NAME, sizeof(ZEND_UNSET_FUNC_NAME)-1))) {
-				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
-					zend_error(E_WARNING, "The magic method __unset() must have public visibility and cannot be static");
-				}
-			} else if ((name_len == sizeof(ZEND_ISSET_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_ISSET_FUNC_NAME, sizeof(ZEND_ISSET_FUNC_NAME)-1))) {
-				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
-					zend_error(E_WARNING, "The magic method __isset() must have public visibility and cannot be static");
-				}
-			} else if ((name_len == sizeof(ZEND_TOSTRING_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_TOSTRING_FUNC_NAME, sizeof(ZEND_TOSTRING_FUNC_NAME)-1))) {
-				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
-					zend_error(E_WARNING, "The magic method __toString() must have public visibility and cannot be static");
-				}
-			} else if ((name_len == sizeof(ZEND_INVOKE_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1))) {
-				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
-					zend_error(E_WARNING, "The magic method __invoke() must have public visibility and cannot be static");
-				}
-			}
-		} else {
-			char *class_lcname;
-
-			class_lcname = do_alloca(CG(active_class_entry)->name_length + 1, use_heap);
-			zend_str_tolower_copy(class_lcname, CG(active_class_entry)->name, CG(active_class_entry)->name_length);
-			/* Improve after RC: cache the lowercase class name */
-
-			if ((CG(active_class_entry)->name_length == name_len) && ((CG(active_class_entry)->ce_flags & ZEND_ACC_TRAIT) != ZEND_ACC_TRAIT) && (!memcmp(class_lcname, lcname, name_len))) {
-				if (!CG(active_class_entry)->constructor) {
-					CG(active_class_entry)->constructor = (zend_function *) CG(active_op_array);
-				}
-			} else if ((name_len == sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_CONSTRUCTOR_FUNC_NAME, sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)))) {
-				if (CG(active_class_entry)->constructor) {
-					zend_error(E_STRICT, "Redefining already defined constructor for class %s", CG(active_class_entry)->name);
-				}
-				CG(active_class_entry)->constructor = (zend_function *) CG(active_op_array);
-			} else if ((name_len == sizeof(ZEND_DESTRUCTOR_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_DESTRUCTOR_FUNC_NAME, sizeof(ZEND_DESTRUCTOR_FUNC_NAME)-1))) {
-				CG(active_class_entry)->destructor = (zend_function *) CG(active_op_array);
-			} else if ((name_len == sizeof(ZEND_CLONE_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_CLONE_FUNC_NAME, sizeof(ZEND_CLONE_FUNC_NAME)-1))) {
-				CG(active_class_entry)->clone = (zend_function *) CG(active_op_array);
-			} else if ((name_len == sizeof(ZEND_CALL_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_CALL_FUNC_NAME, sizeof(ZEND_CALL_FUNC_NAME)-1))) {
-				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
-					zend_error(E_WARNING, "The magic method __call() must have public visibility and cannot be static");
-				}
-				CG(active_class_entry)->__call = (zend_function *) CG(active_op_array);
-			} else if ((name_len == sizeof(ZEND_CALLSTATIC_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_CALLSTATIC_FUNC_NAME, sizeof(ZEND_CALLSTATIC_FUNC_NAME)-1))) {
-				if ((fn_flags & (ZEND_ACC_PPP_MASK ^ ZEND_ACC_PUBLIC)) || (fn_flags & ZEND_ACC_STATIC) == 0) {
-					zend_error(E_WARNING, "The magic method __callStatic() must have public visibility and be static");
-				}
-				CG(active_class_entry)->__callstatic = (zend_function *) CG(active_op_array);
-			} else if ((name_len == sizeof(ZEND_GET_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_GET_FUNC_NAME, sizeof(ZEND_GET_FUNC_NAME)-1))) {
-				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
-					zend_error(E_WARNING, "The magic method __get() must have public visibility and cannot be static");
-				}
-				CG(active_class_entry)->__get = (zend_function *) CG(active_op_array);
-			} else if ((name_len == sizeof(ZEND_SET_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_SET_FUNC_NAME, sizeof(ZEND_SET_FUNC_NAME)-1))) {
-				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
-					zend_error(E_WARNING, "The magic method __set() must have public visibility and cannot be static");
-				}
-				CG(active_class_entry)->__set = (zend_function *) CG(active_op_array);
-			} else if ((name_len == sizeof(ZEND_UNSET_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_UNSET_FUNC_NAME, sizeof(ZEND_UNSET_FUNC_NAME)-1))) {
-				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
-					zend_error(E_WARNING, "The magic method __unset() must have public visibility and cannot be static");
-				}
-				CG(active_class_entry)->__unset = (zend_function *) CG(active_op_array);
-			} else if ((name_len == sizeof(ZEND_ISSET_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_ISSET_FUNC_NAME, sizeof(ZEND_ISSET_FUNC_NAME)-1))) {
-				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
-					zend_error(E_WARNING, "The magic method __isset() must have public visibility and cannot be static");
-				}
-				CG(active_class_entry)->__isset = (zend_function *) CG(active_op_array);
-			} else if ((name_len == sizeof(ZEND_TOSTRING_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_TOSTRING_FUNC_NAME, sizeof(ZEND_TOSTRING_FUNC_NAME)-1))) {
-				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
-					zend_error(E_WARNING, "The magic method __toString() must have public visibility and cannot be static");
-				}
-				CG(active_class_entry)->__tostring = (zend_function *) CG(active_op_array);
-			} else if ((name_len == sizeof(ZEND_INVOKE_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1))) {
-				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
-					zend_error(E_WARNING, "The magic method __invoke() must have public visibility and cannot be static");
-				}
-			} else if (!(fn_flags & ZEND_ACC_STATIC)) {
-				CG(active_op_array)->fn_flags |= ZEND_ACC_ALLOW_STATIC;
-			}
-			free_alloca(class_lcname, use_heap);
-		}
+	if (len == 0) {
+		/* Illegal use of this function */
+		return 0;
+	}
 
-		str_efree(lcname);
-	} else {
-		zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-		zval key;
+	/* 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;
+	}
 
-		if (CG(current_namespace)) {
-			/* Prefix function name with current namespace name */
-			znode tmp;
-
-			tmp.u.constant = *CG(current_namespace);
-			zval_copy_ctor(&tmp.u.constant);
-			zend_do_build_namespace_name(&tmp, &tmp, function_name TSRMLS_CC);
-			op_array.function_name = Z_STRVAL(tmp.u.constant);
-			name_len = Z_STRLEN(tmp.u.constant);
-			lcname = zend_str_tolower_dup(Z_STRVAL(tmp.u.constant), name_len);
+	/* Strip filename */
+	while (end >= path && !IS_SLASH_P(end)) {
+		end--;
+	}
+	if (end < path) {
+		/* No slash found, therefore return '.' */
+#ifdef NETWARE
+		if (len_adjust == 0) {
+			path[0] = '.';
+			path[1] = '\0';
+			return 1; /* only one character */
 		} else {
-			lcname = zend_str_tolower_dup(name, name_len);
+			path[0] = '\0';
+			return len_adjust;
 		}
-
-		opline->opcode = ZEND_DECLARE_FUNCTION;
-		opline->op1_type = IS_CONST;
-		build_runtime_defined_function_key(&key, lcname, name_len TSRMLS_CC);
-		opline->op1.constant = zend_add_literal(CG(active_op_array), &key TSRMLS_CC);
-		Z_HASH_P(&CONSTANT(opline->op1.constant)) = zend_hash_func(Z_STRVAL(CONSTANT(opline->op1.constant)), Z_STRLEN(CONSTANT(opline->op1.constant)));
-		opline->op2_type = IS_CONST;
-		LITERAL_STRINGL(opline->op2, lcname, name_len, 0);
-		CALCULATE_LITERAL_HASH(opline->op2.constant);
-		opline->extended_value = ZEND_DECLARE_FUNCTION;
-		zend_hash_quick_update(CG(function_table), Z_STRVAL(key), Z_STRLEN(key), Z_HASH_P(&CONSTANT(opline->op1.constant)), &op_array, sizeof(zend_op_array), (void **) &CG(active_op_array));
-		zend_stack_push(&CG(context_stack), (void *) &CG(context), sizeof(CG(context)));
-		zend_init_compiler_context(TSRMLS_C);
-	}
-
-	if (CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO) {
-		zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-
-		opline->opcode = ZEND_EXT_NOP;
-		opline->lineno = function_begin_line;
-		SET_UNUSED(opline->op1);
-		SET_UNUSED(opline->op2);
+#else
+		path[0] = '.';
+		path[1] = '\0';
+		return 1 + len_adjust;
+#endif
 	}
 
-	{
-		/* Push a separator to the switch stack */
-		zend_switch_entry switch_entry;
-
-		switch_entry.cond.op_type = IS_UNUSED;
-		switch_entry.default_case = 0;
-		switch_entry.control_var = 0;
-
-		zend_stack_push(&CG(switch_cond_stack), (void *) &switch_entry, sizeof(switch_entry));
+	/* Strip slashes which came before the file name */
+	while (end >= path && IS_SLASH_P(end)) {
+		end--;
 	}
-
-	{
-		/* Push a separator to the foreach stack */
-		zend_op dummy_opline;
-
-		dummy_opline.result_type = IS_UNUSED;
-
-		zend_stack_push(&CG(foreach_copy_stack), (void *) &dummy_opline, sizeof(zend_op));
+	if (end < path) {
+		path[0] = DEFAULT_SLASH;
+		path[1] = '\0';
+		return 1 + len_adjust;
 	}
+	*(end+1) = '\0';
 
-	if (CG(doc_comment)) {
-		CG(active_op_array)->doc_comment = CG(doc_comment);
-		CG(active_op_array)->doc_comment_len = CG(doc_comment_len);
-		CG(doc_comment) = NULL;
-		CG(doc_comment_len) = 0;
-	}
+	return (size_t)(end + 1 - path) + len_adjust;
 }
 /* }}} */
 
-void zend_do_begin_lambda_function_declaration(znode *result, znode *function_token, int return_reference, int is_static TSRMLS_DC) /* {{{ */
+static inline zend_bool zend_string_equals_str_ci(zend_string *str1, zend_string *str2) /* {{{ */
 {
-	znode          function_name;
-	zend_op_array *current_op_array = CG(active_op_array);
-	int            current_op_number = get_next_op_number(CG(active_op_array));
-	zend_op       *current_op;
-
-	function_name.op_type = IS_CONST;
-	ZVAL_STRINGL(&function_name.u.constant, "{closure}", sizeof("{closure}")-1, 1);
-
-	zend_do_begin_function_declaration(function_token, &function_name, 0, return_reference, NULL TSRMLS_CC);
-
-	result->op_type = IS_TMP_VAR;
-	result->u.op.var = get_temporary_variable(current_op_array);
+	return str1->len == str2->len
+		&& !zend_binary_strcasecmp(str1->val, str1->len, str2->val, str2->len);
+}
+/* }}} */
 
-	current_op = &current_op_array->opcodes[current_op_number];
-	current_op->opcode = ZEND_DECLARE_LAMBDA_FUNCTION;
-	zend_del_literal(current_op_array, current_op->op2.constant);
-	SET_UNUSED(current_op->op2);
-	SET_NODE(current_op->result, result);
-	if (is_static) {
-		CG(active_op_array)->fn_flags |= ZEND_ACC_STATIC;
+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()
 	}
-	CG(active_op_array)->fn_flags |= ZEND_ACC_CLOSURE;
 }
 /* }}} */
 
-void zend_do_handle_exception(TSRMLS_D) /* {{{ */
+static inline void zend_make_var_result(znode *result, zend_op *opline TSRMLS_DC) /* {{{ */ 
 {
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-
-	opline->opcode = ZEND_HANDLE_EXCEPTION;
-	SET_UNUSED(opline->op1);
-	SET_UNUSED(opline->op2);
+	opline->result_type = IS_VAR;
+	opline->result.var = get_temporary_variable(CG(active_op_array));
+	GET_NODE(result, opline->result);
 }
 /* }}} */
 
-void zend_do_end_function_declaration(const znode *function_token TSRMLS_DC) /* {{{ */
+static inline void zend_make_tmp_result(znode *result, zend_op *opline TSRMLS_DC) /* {{{ */
 {
-	char lcname[16];
-	int name_len;
-
-	zend_do_extended_info(TSRMLS_C);
-	zend_do_return(NULL, 0 TSRMLS_CC);
+	opline->result_type = IS_TMP_VAR;
+	opline->result.var = get_temporary_variable(CG(active_op_array));
+	GET_NODE(result, opline->result);
+}
+/* }}} */
 
-	pass_two(CG(active_op_array) TSRMLS_CC);
-	zend_release_labels(0 TSRMLS_CC);
+static zend_op *zend_emit_op(znode *result, zend_uchar opcode, znode *op1, znode *op2 TSRMLS_DC) /* {{{ */ 
+{
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	opline->opcode = opcode;
 
-	if (CG(active_class_entry)) {
-		zend_check_magic_method_implementation(CG(active_class_entry), (zend_function*)CG(active_op_array), E_COMPILE_ERROR TSRMLS_CC);
+	if (op1 == NULL) {
+		SET_UNUSED(opline->op1);
 	} else {
-		/* we don't care if the function name is longer, in fact lowercasing only
-		 * the beginning of the name speeds up the check process */
-		name_len = strlen(CG(active_op_array)->function_name);
-		zend_str_tolower_copy(lcname, CG(active_op_array)->function_name, MIN(name_len, sizeof(lcname)-1));
-		lcname[sizeof(lcname)-1] = '\0'; /* zend_str_tolower_copy won't necessarily set the zero byte */
-		if (name_len == sizeof(ZEND_AUTOLOAD_FUNC_NAME) - 1 && !memcmp(lcname, ZEND_AUTOLOAD_FUNC_NAME, sizeof(ZEND_AUTOLOAD_FUNC_NAME)) && CG(active_op_array)->num_args != 1) {
-			zend_error(E_COMPILE_ERROR, "%s() must take exactly 1 argument", ZEND_AUTOLOAD_FUNC_NAME);
-		}
+		SET_NODE(opline->op1, op1);
 	}
 
-	CG(active_op_array)->line_end = zend_get_compiled_lineno(TSRMLS_C);
-	CG(active_op_array) = function_token->u.op_array;
-
+	if (op2 == NULL) {
+		SET_UNUSED(opline->op2);
+	} else {
+		SET_NODE(opline->op2, op2);
+	}
 
-	/* Pop the switch and foreach separators */
-	zend_stack_del_top(&CG(switch_cond_stack));
-	zend_stack_del_top(&CG(foreach_copy_stack));
+	if (result) {
+		zend_make_var_result(result, opline TSRMLS_CC);
+	}
+	return opline;
 }
 /* }}} */
 
-void zend_do_receive_param(zend_uchar op, znode *varname, const znode *initialization, znode *class_type, zend_uchar pass_by_reference, zend_bool is_variadic TSRMLS_DC) /* {{{ */
+static zend_op *zend_emit_op_tmp(znode *result, zend_uchar opcode, znode *op1, znode *op2 TSRMLS_DC) /* {{{ */
 {
-	zend_op *opline;
-	zend_arg_info *cur_arg_info;
-	znode var;
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	opline->opcode = opcode;
 
-	if (zend_is_auto_global(Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant) TSRMLS_CC)) {
-		zend_error(E_COMPILE_ERROR, "Cannot re-assign auto-global variable %s", Z_STRVAL(varname->u.constant));
+	if (op1 == NULL) {
+		SET_UNUSED(opline->op1);
 	} else {
-		var.op_type = IS_CV;
-		var.u.op.var = lookup_cv(CG(active_op_array), Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant), 0 TSRMLS_CC);
-		Z_STRVAL(varname->u.constant) = (char*)CG(active_op_array)->vars[var.u.op.var].name;
-		var.EA = 0;
-		if (CG(active_op_array)->vars[var.u.op.var].hash_value == THIS_HASHVAL &&
-			Z_STRLEN(varname->u.constant) == sizeof("this")-1 &&
-		    !memcmp(Z_STRVAL(varname->u.constant), "this", sizeof("this")-1)) {
-			if (CG(active_op_array)->scope &&
-			    (CG(active_op_array)->fn_flags & ZEND_ACC_STATIC) == 0) {
-				zend_error(E_COMPILE_ERROR, "Cannot re-assign $this");
-			}
-			CG(active_op_array)->this_var = var.u.op.var;
-		}
+		SET_NODE(opline->op1, op1);
 	}
 
-	if (CG(active_op_array)->fn_flags & ZEND_ACC_VARIADIC) {
-		zend_error(E_COMPILE_ERROR, "Only the last parameter can be variadic");
+	if (op2 == NULL) {
+		SET_UNUSED(opline->op2);
+	} else {
+		SET_NODE(opline->op2, op2);
 	}
 
-	if (is_variadic) {
-		if (op == ZEND_RECV_INIT) {
-			zend_error(E_COMPILE_ERROR, "Variadic parameter cannot have a default value");
-		}
-
-		op = ZEND_RECV_VARIADIC;
-		CG(active_op_array)->fn_flags |= ZEND_ACC_VARIADIC;
+	if (result) {
+		zend_make_tmp_result(result, opline TSRMLS_CC);
 	}
 
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	CG(active_op_array)->num_args++;
-	opline->opcode = op;
-	SET_NODE(opline->result, &var);
-	opline->op1_type = IS_UNUSED;
-	opline->op1.num = CG(active_op_array)->num_args;
-	if (op == ZEND_RECV_INIT) {
-		SET_NODE(opline->op2, initialization);
-	} else {
-		SET_UNUSED(opline->op2);
-		if (!is_variadic) {
-			CG(active_op_array)->required_num_args = CG(active_op_array)->num_args;
-		}
-	}
-	CG(active_op_array)->arg_info = erealloc(CG(active_op_array)->arg_info, sizeof(zend_arg_info)*(CG(active_op_array)->num_args));
-	cur_arg_info = &CG(active_op_array)->arg_info[CG(active_op_array)->num_args-1];
-	cur_arg_info->name = zend_new_interned_string(estrndup(Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant)), Z_STRLEN(varname->u.constant) + 1, 1 TSRMLS_CC);
-	cur_arg_info->name_len = Z_STRLEN(varname->u.constant);
-	cur_arg_info->type_hint = 0;
-	cur_arg_info->pass_by_reference = pass_by_reference;
-	cur_arg_info->allow_null = 1;
-	cur_arg_info->is_variadic = is_variadic;
-	cur_arg_info->class_name = NULL;
-	cur_arg_info->class_name_len = 0;
-
-	if (class_type->op_type != IS_UNUSED) {
-		cur_arg_info->allow_null = 0;
-
-		if (class_type->u.constant.type != IS_NULL) {
-			if (class_type->u.constant.type == IS_ARRAY) {
-				cur_arg_info->type_hint = IS_ARRAY;
-				if (op == ZEND_RECV_INIT) {
-					if (Z_TYPE(initialization->u.constant) == IS_NULL || (Z_TYPE(initialization->u.constant) == IS_CONSTANT && !strcasecmp(Z_STRVAL(initialization->u.constant), "NULL"))) {
-						cur_arg_info->allow_null = 1;
-					} else if (Z_TYPE(initialization->u.constant) != IS_ARRAY && Z_TYPE(initialization->u.constant) != IS_CONSTANT_ARRAY) {
-						zend_error(E_COMPILE_ERROR, "Default value for parameters with array type hint can only be an array or NULL");
-					}
-				}
-			} else if (class_type->u.constant.type == IS_CALLABLE) {
-				cur_arg_info->type_hint = IS_CALLABLE;
-				if (op == ZEND_RECV_INIT) {
-					if (Z_TYPE(initialization->u.constant) == IS_NULL || (Z_TYPE(initialization->u.constant) == IS_CONSTANT && !strcasecmp(Z_STRVAL(initialization->u.constant), "NULL"))) {
-						cur_arg_info->allow_null = 1;
-					} else {
-						zend_error(E_COMPILE_ERROR, "Default value for parameters with callable type hint can only be NULL");
-					}
-				}
-			} else {
-				cur_arg_info->type_hint = IS_OBJECT;
-				if (ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(class_type->u.constant), Z_STRLEN(class_type->u.constant))) {
-					zend_resolve_class_name(class_type TSRMLS_CC);
-				}
-				Z_STRVAL(class_type->u.constant) = (char*)zend_new_interned_string(Z_STRVAL(class_type->u.constant), Z_STRLEN(class_type->u.constant) + 1, 1 TSRMLS_CC);
-				cur_arg_info->class_name = Z_STRVAL(class_type->u.constant);
-				cur_arg_info->class_name_len = Z_STRLEN(class_type->u.constant);
-				if (op == ZEND_RECV_INIT) {
-					if (Z_TYPE(initialization->u.constant) == IS_NULL || (Z_TYPE(initialization->u.constant) == IS_CONSTANT && !strcasecmp(Z_STRVAL(initialization->u.constant), "NULL"))) {
-						cur_arg_info->allow_null = 1;
-					} else {
-						zend_error(E_COMPILE_ERROR, "Default value for parameters with a class type hint can only be NULL");
-					}
-				}
-			}
-		}
-	}
+	return opline;
 }
 /* }}} */
 
-int zend_do_begin_function_call(znode *function_name, zend_bool check_namespace TSRMLS_DC) /* {{{ */
+static void zend_emit_tick(TSRMLS_D) /* {{{ */
 {
-	zend_function *function;
-	char *lcname;
-	char *is_compound = memchr(Z_STRVAL(function_name->u.constant), '\\', Z_STRLEN(function_name->u.constant));
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
-	zend_resolve_non_class_name(function_name, check_namespace TSRMLS_CC);
+	opline->opcode = ZEND_TICKS;
+	SET_UNUSED(opline->op1);
+	SET_UNUSED(opline->op2);
+	opline->extended_value = Z_LVAL(CG(declarables).ticks);
+}
+/* }}} */
 
-	if (check_namespace && CG(current_namespace) && !is_compound) {
-			/* We assume we call function from the current namespace
-			if it is not prefixed. */
+static inline zend_op *zend_emit_op_data(znode *value TSRMLS_DC) /* {{{ */
+{
+	return zend_emit_op(NULL, ZEND_OP_DATA, value, NULL TSRMLS_CC);
+}
+/* }}} */
 
-			/* In run-time PHP will check for function with full name and
-			internal function with short name */
-			zend_do_begin_dynamic_function_call(function_name, 1 TSRMLS_CC);
-			return 1;
-	}
+static inline uint32_t zend_emit_jump(uint32_t opnum_target 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;
+}
+/* }}} */
 
-	lcname = zend_str_tolower_dup(Z_STRVAL(function_name->u.constant), Z_STRLEN(function_name->u.constant));
-	if ((zend_hash_find(CG(function_table), lcname, Z_STRLEN(function_name->u.constant)+1, (void **) &function)==FAILURE) ||
-	 	((CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_FUNCTIONS) &&
- 		(function->type == ZEND_INTERNAL_FUNCTION))) {
- 			zend_do_begin_dynamic_function_call(function_name, 0 TSRMLS_CC);
- 			efree(lcname);
- 			return 1; /* Dynamic */
- 	}
-	efree(Z_STRVAL(function_name->u.constant));
-	Z_STRVAL(function_name->u.constant) = lcname;
+static inline uint32_t zend_emit_cond_jump(zend_uchar opcode, znode *cond, uint32_t opnum_target 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;
+}
+/* }}} */
 
-	zend_stack_push(&CG(function_call_stack), (void *) &function, sizeof(zend_function *));
-	if (CG(context).nested_calls + 1 > CG(active_op_array)->nested_calls) {
-		CG(active_op_array)->nested_calls = CG(context).nested_calls + 1;
+static inline void zend_update_jump_target(uint32_t opnum_jump, uint32_t opnum_target 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()
 	}
-	zend_do_extended_fcall_begin(TSRMLS_C);
-	return 0;
 }
 /* }}} */
 
-void zend_do_begin_method_call(znode *left_bracket TSRMLS_DC) /* {{{ */
+static inline void zend_update_jump_target_to_next(uint32_t opnum_jump TSRMLS_DC) /* {{{ */ 
 {
-	zend_op *last_op;
-	int last_op_number;
-	unsigned char *ptr = NULL;
-
-	zend_do_end_variable_parse(left_bracket, BP_VAR_R, 0 TSRMLS_CC);
-	zend_do_begin_variable_parse(TSRMLS_C);
-
-	last_op_number = get_next_op_number(CG(active_op_array))-1;
-	last_op = &CG(active_op_array)->opcodes[last_op_number];
+	zend_update_jump_target(opnum_jump, get_next_op_number(CG(active_op_array)) TSRMLS_CC);
+}
+/* }}} */
 
-	if ((last_op->op2_type == IS_CONST) && (Z_TYPE(CONSTANT(last_op->op2.constant)) == IS_STRING) && (Z_STRLEN(CONSTANT(last_op->op2.constant)) == sizeof(ZEND_CLONE_FUNC_NAME)-1)
-		&& !zend_binary_strcasecmp(Z_STRVAL(CONSTANT(last_op->op2.constant)), Z_STRLEN(CONSTANT(last_op->op2.constant)), ZEND_CLONE_FUNC_NAME, sizeof(ZEND_CLONE_FUNC_NAME)-1)) {
-		zend_error(E_COMPILE_ERROR, "Cannot call __clone() method on objects - use 'clone $obj' instead");
+static inline zend_op *zend_delayed_emit_op(znode *result, zend_uchar opcode, znode *op1, znode *op2 TSRMLS_DC) /* {{{ */
+{
+	zend_op tmp_opline;
+	init_op(&tmp_opline TSRMLS_CC);
+	tmp_opline.opcode = opcode;
+	SET_NODE(tmp_opline.op1, op1);
+	SET_NODE(tmp_opline.op2, op2);
+	if (result) {
+		zend_make_var_result(result, &tmp_opline TSRMLS_CC);
 	}
 
-	if (last_op->opcode == ZEND_FETCH_OBJ_R) {
-		if (last_op->op2_type == IS_CONST) {
-			zval name;
-			name = CONSTANT(last_op->op2.constant);
-			if (Z_TYPE(name) != IS_STRING) {
-				zend_error(E_COMPILE_ERROR, "Method name must be a string");
-			}
-			Z_STRVAL(name) = str_estrndup(Z_STRVAL(name), Z_STRLEN(name));
-			FREE_POLYMORPHIC_CACHE_SLOT(last_op->op2.constant);
-			last_op->op2.constant =
-				zend_add_func_name_literal(CG(active_op_array), &name TSRMLS_CC);
-			GET_POLYMORPHIC_CACHE_SLOT(last_op->op2.constant);
-		}
-		last_op->opcode = ZEND_INIT_METHOD_CALL;
-		last_op->result_type = IS_UNUSED;
-		last_op->result.num = CG(context).nested_calls;
-		Z_LVAL(left_bracket->u.constant) = ZEND_INIT_FCALL_BY_NAME;
-	} else {
-		zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-		opline->opcode = ZEND_INIT_FCALL_BY_NAME;
-		opline->result.num = CG(context).nested_calls;
-		SET_UNUSED(opline->op1);
-		if (left_bracket->op_type == IS_CONST) {
-			opline->op2_type = IS_CONST;
-			opline->op2.constant = zend_add_func_name_literal(CG(active_op_array), &left_bracket->u.constant TSRMLS_CC);
-			GET_CACHE_SLOT(opline->op2.constant);
-		} else {
-			SET_NODE(opline->op2, left_bracket);
-		}
-	}
+	zend_stack_push(&CG(delayed_oplines_stack), &tmp_opline);
+	return zend_stack_top(&CG(delayed_oplines_stack));
+}
+/* }}} */
 
-	zend_stack_push(&CG(function_call_stack), (void *) &ptr, sizeof(zend_function *));
-	if (++CG(context).nested_calls > CG(active_op_array)->nested_calls) {
-		CG(active_op_array)->nested_calls = CG(context).nested_calls;
-	}
-	zend_do_extended_fcall_begin(TSRMLS_C);
+static inline uint32_t zend_delayed_compile_begin(TSRMLS_D) /* {{{ */
+{
+	return zend_stack_count(&CG(delayed_oplines_stack));
 }
 /* }}} */
 
-void zend_do_clone(znode *result, const znode *expr TSRMLS_DC) /* {{{ */
+static zend_op *zend_delayed_compile_end(uint32_t offset TSRMLS_DC) /* {{{ */
 {
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	zend_op *opline, *oplines = zend_stack_base(&CG(delayed_oplines_stack));
+	uint32_t i, count = zend_stack_count(&CG(delayed_oplines_stack));
 
-	opline->opcode = ZEND_CLONE;
-	SET_NODE(opline->op1, expr);
-	SET_UNUSED(opline->op2);
-	opline->result_type = IS_VAR;
-	opline->result.var = get_temporary_variable(CG(active_op_array));
-	GET_NODE(result, opline->result);
+	ZEND_ASSERT(count > offset);
+	for (i = offset; i < count; ++i) {
+		opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+		memcpy(opline, &oplines[i], sizeof(zend_op));
+	}
+	CG(delayed_oplines_stack).top = offset;
+	return opline;
 }
 /* }}} */
 
-void zend_do_begin_dynamic_function_call(znode *function_name, int ns_call TSRMLS_DC) /* {{{ */
+void zend_emit_final_return(zval *zv TSRMLS_DC) /* {{{ */
 {
-	unsigned char *ptr = NULL;
-	zend_op *opline;
+	znode zn;
+	zend_bool returns_reference = (CG(active_op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0;
 
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	if (ns_call) {
-		/* In run-time PHP will check for function with full name and
-		   internal function with short name */
-		opline->opcode = ZEND_INIT_NS_FCALL_BY_NAME;
-		opline->result.num = CG(context).nested_calls;
-		SET_UNUSED(opline->op1);
-		opline->op2_type = IS_CONST;
-		opline->op2.constant = zend_add_ns_func_name_literal(CG(active_op_array), &function_name->u.constant TSRMLS_CC);
-		GET_CACHE_SLOT(opline->op2.constant);
+	zn.op_type = IS_CONST;
+	if (zv) {
+		ZVAL_COPY_VALUE(&zn.u.constant, zv);
 	} else {
-		opline->opcode = ZEND_INIT_FCALL_BY_NAME;
-		opline->result.num = CG(context).nested_calls;
-		SET_UNUSED(opline->op1);
-		if (function_name->op_type == IS_CONST) {
-			opline->op2_type = IS_CONST;
-			opline->op2.constant = zend_add_func_name_literal(CG(active_op_array), &function_name->u.constant TSRMLS_CC);
-			GET_CACHE_SLOT(opline->op2.constant);
-		} else {
-			SET_NODE(opline->op2, function_name);
-		}
+		ZVAL_NULL(&zn.u.constant);
 	}
 
-	zend_stack_push(&CG(function_call_stack), (void *) &ptr, sizeof(zend_function *));
-	if (++CG(context).nested_calls > CG(active_op_array)->nested_calls) {
-		CG(active_op_array)->nested_calls = CG(context).nested_calls;
-	}
-	zend_do_extended_fcall_begin(TSRMLS_C);
+	zend_emit_op(NULL, returns_reference ? ZEND_RETURN_BY_REF : ZEND_RETURN, &zn, NULL TSRMLS_CC);
 }
 /* }}} */
 
-void zend_resolve_non_class_name(znode *element_name, zend_bool check_namespace TSRMLS_DC) /* {{{ */
+static inline zend_bool zend_is_variable(zend_ast *ast) /* {{{ */
 {
-	znode tmp;
-	int len;
-	zval **ns;
-	char *lcname, *compound = memchr(Z_STRVAL(element_name->u.constant), '\\', Z_STRLEN(element_name->u.constant));
+	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;
+}
+/* }}} */
 
-	if (Z_STRVAL(element_name->u.constant)[0] == '\\') {
-		/* name starts with \ so it is known and unambiguos, nothing to do here but shorten it */
-		memmove(Z_STRVAL(element_name->u.constant), Z_STRVAL(element_name->u.constant)+1, Z_STRLEN(element_name->u.constant));
-		--Z_STRLEN(element_name->u.constant);
-		return;
-	}
+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;
+}
+/* }}} */
 
-	if(!check_namespace) {
-		return;
-	}
+static inline zend_bool zend_is_unticked_stmt(zend_ast *ast) /* {{{ */
+{
+	return ast->kind == ZEND_AST_STMT_LIST || ast->kind == ZEND_AST_LABEL;
+}
+/* }}} */
 
-	if (compound && CG(current_import)) {
-		len = compound - Z_STRVAL(element_name->u.constant);
-		lcname = zend_str_tolower_dup(Z_STRVAL(element_name->u.constant), len);
-		/* Check if first part of compound name is an import name */
-		if (zend_hash_find(CG(current_import), lcname, len+1, (void**)&ns) == SUCCESS) {
-			/* Substitute import name */
-			tmp.op_type = IS_CONST;
-			tmp.u.constant = **ns;
-			zval_copy_ctor(&tmp.u.constant);
-			len += 1;
-			Z_STRLEN(element_name->u.constant) -= len;
-			memmove(Z_STRVAL(element_name->u.constant), Z_STRVAL(element_name->u.constant)+len, Z_STRLEN(element_name->u.constant)+1);
-			zend_do_build_namespace_name(&tmp, &tmp, element_name TSRMLS_CC);
-			*element_name = tmp;
-			efree(lcname);
-			return;
-		}
-		efree(lcname);
+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 (CG(current_namespace)) {
-		tmp = *element_name;
-		Z_STRLEN(tmp.u.constant) = sizeof("\\")-1 + Z_STRLEN(element_name->u.constant) + Z_STRLEN_P(CG(current_namespace));
-		Z_STRVAL(tmp.u.constant) = (char *) emalloc(Z_STRLEN(tmp.u.constant)+1);
-		memcpy(Z_STRVAL(tmp.u.constant), Z_STRVAL_P(CG(current_namespace)), Z_STRLEN_P(CG(current_namespace)));
-		memcpy(&(Z_STRVAL(tmp.u.constant)[Z_STRLEN_P(CG(current_namespace))]), "\\", sizeof("\\")-1);
-		memcpy(&(Z_STRVAL(tmp.u.constant)[Z_STRLEN_P(CG(current_namespace)) + sizeof("\\")-1]), Z_STRVAL(element_name->u.constant), Z_STRLEN(element_name->u.constant)+1);
-		str_efree(Z_STRVAL(element_name->u.constant));
-		*element_name = tmp;
-	}
+	return zend_is_variable(ast);
 }
 /* }}} */
 
-void zend_do_resolve_class_name(znode *result, znode *class_name, int is_static TSRMLS_DC) /* {{{ */
+static inline zend_bool zend_is_const_default_class_ref(zend_ast *name_ast) /* {{{ */
 {
-	char *lcname;
-	int lctype;
-	znode constant_name;
+	zend_string *name;
 
-	lcname = zend_str_tolower_dup(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant));
-	lctype = zend_get_class_fetch_type(lcname, strlen(lcname));
-	switch (lctype) {
-		case ZEND_FETCH_CLASS_SELF:
-			if (!CG(active_class_entry)) {
-				zend_error(E_COMPILE_ERROR, "Cannot access self::class when no class scope is active");
-			}
-			zval_dtor(&class_name->u.constant);
-			class_name->op_type = IS_CONST;
-			ZVAL_STRINGL(&class_name->u.constant, CG(active_class_entry)->name, CG(active_class_entry)->name_length, 1);
-			*result = *class_name;
-			break;
-        case ZEND_FETCH_CLASS_STATIC:
-        case ZEND_FETCH_CLASS_PARENT:
-			if (is_static) {
-				zend_error(E_COMPILE_ERROR,
-					"%s::class cannot be used for compile-time class name resolution",
-					lctype == ZEND_FETCH_CLASS_STATIC ? "static" : "parent"
-					);
-			}
-			if (!CG(active_class_entry)) {
-				zend_error(E_COMPILE_ERROR,
-					"Cannot access %s::class when no class scope is active",
-					lctype == ZEND_FETCH_CLASS_STATIC ? "static" : "parent"
-					);
-			}
-			constant_name.op_type = IS_CONST;
-			ZVAL_STRINGL(&constant_name.u.constant, "class", sizeof("class")-1, 1);
-			zend_do_fetch_constant(result, class_name, &constant_name, ZEND_RT, 1 TSRMLS_CC);
-			break;
-		case ZEND_FETCH_CLASS_DEFAULT:
-			zend_resolve_class_name(class_name TSRMLS_CC);
-			*result = *class_name;
-			break;
+	if (name_ast->kind != ZEND_AST_ZVAL) {
+		return 0;
 	}
 
-	efree(lcname);
+	/* 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);
 }
 /* }}} */
 
-void zend_resolve_class_name(znode *class_name TSRMLS_DC) /* {{{ */
+static inline void zend_handle_numeric_op(znode *node TSRMLS_DC) /* {{{ */
 {
-	char *compound;
-	char *lcname;
-	zval **ns;
-	znode tmp;
-	int len;
+	if (node->op_type == IS_CONST && Z_TYPE(node->u.constant) == IS_STRING) {
+		zend_ulong index;
 
-	compound = memchr(Z_STRVAL(class_name->u.constant), '\\', Z_STRLEN(class_name->u.constant));
-	if (compound) {
-		/* This is a compound class name that contains namespace prefix */
-		if (Z_STRVAL(class_name->u.constant)[0] == '\\') {
-			/* The STRING name has "\" prefix */
-			Z_STRLEN(class_name->u.constant) -= 1;
-			memmove(Z_STRVAL(class_name->u.constant), Z_STRVAL(class_name->u.constant)+1, Z_STRLEN(class_name->u.constant)+1);
-			Z_STRVAL(class_name->u.constant) = erealloc(
-			Z_STRVAL(class_name->u.constant),
-			Z_STRLEN(class_name->u.constant) + 1);
-
-			if (ZEND_FETCH_CLASS_DEFAULT != zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant))) {
-				zend_error(E_COMPILE_ERROR, "'\\%s' is an invalid class name", Z_STRVAL(class_name->u.constant));
-			}
-		} else {
-			if (CG(current_import)) {
-				len = compound - Z_STRVAL(class_name->u.constant);
-				lcname = zend_str_tolower_dup(Z_STRVAL(class_name->u.constant), len);
-				/* Check if first part of compound name is an import name */
-				if (zend_hash_find(CG(current_import), lcname, len+1, (void**)&ns) == SUCCESS) {
-					/* Substitute import name */
-					tmp.op_type = IS_CONST;
-					tmp.u.constant = **ns;
-					zval_copy_ctor(&tmp.u.constant);
-					len += 1;
-					Z_STRLEN(class_name->u.constant) -= len;
-					memmove(Z_STRVAL(class_name->u.constant), Z_STRVAL(class_name->u.constant)+len, Z_STRLEN(class_name->u.constant)+1);
-					zend_do_build_namespace_name(&tmp, &tmp, class_name TSRMLS_CC);
-					*class_name = tmp;
-					efree(lcname);
-					return;
-				}
-				efree(lcname);
-			}
-			/* Here name is not prefixed with \ and not imported */
-			if (CG(current_namespace)) {
-				tmp.op_type = IS_CONST;
-				tmp.u.constant = *CG(current_namespace);
-				zval_copy_ctor(&tmp.u.constant);
-				zend_do_build_namespace_name(&tmp, &tmp, class_name TSRMLS_CC);
-				*class_name = tmp;
-			}
+		if (ZEND_HANDLE_NUMERIC(Z_STR(node->u.constant), index)) {
+			zval_ptr_dtor(&node->u.constant);
+			ZVAL_LONG(&node->u.constant, index);
 		}
-	} else if (CG(current_import) || CG(current_namespace)) {
-		/* this is a plain name (without \) */
-		lcname = zend_str_tolower_dup(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant));
+	}
+}
+/* }}} */
 
-		if (CG(current_import) &&
-		    zend_hash_find(CG(current_import), lcname, Z_STRLEN(class_name->u.constant)+1, (void**)&ns) == SUCCESS) {
-		    /* The given name is an import name. Substitute it. */
-			zval_dtor(&class_name->u.constant);
-			class_name->u.constant = **ns;
-			zval_copy_ctor(&class_name->u.constant);
-		} else if (CG(current_namespace)) {
-			/* plain name, no import - prepend current namespace to it */
-			tmp.op_type = IS_CONST;
-			tmp.u.constant = *CG(current_namespace);
-			zval_copy_ctor(&tmp.u.constant);
-			zend_do_build_namespace_name(&tmp, &tmp, class_name TSRMLS_CC);
-			*class_name = tmp;
-		}
-		efree(lcname);
+static inline void zend_set_class_name_op1(zend_op *opline, znode *class_node 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);
 	}
 }
 /* }}} */
 
-void zend_do_fetch_class(znode *result, znode *class_name TSRMLS_DC) /* {{{ */
+static zend_op *zend_compile_class_ref(znode *result, zend_ast *name_ast TSRMLS_DC) /* {{{ */
 {
-	long fetch_class_op_number;
 	zend_op *opline;
+	znode name_node;
+	zend_compile_expr(&name_node, name_ast TSRMLS_CC);
 
-	fetch_class_op_number = get_next_op_number(CG(active_op_array));
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	if (name_node.op_type == IS_CONST) {
+		zend_string *name = Z_STR(name_node.u.constant);
+		uint32_t fetch_type = zend_get_class_fetch_type(name);
 
-	opline->opcode = ZEND_FETCH_CLASS;
-	SET_UNUSED(opline->op1);
-	opline->extended_value = ZEND_FETCH_CLASS_DEFAULT;
-	CG(catch_begin) = fetch_class_op_number;
-	if (class_name->op_type == IS_CONST) {
-		int fetch_type;
+		opline = zend_emit_op(result, ZEND_FETCH_CLASS, NULL, NULL TSRMLS_CC);
+		opline->extended_value = fetch_type;
 
-		fetch_type = zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant));
-		switch (fetch_type) {
-			case ZEND_FETCH_CLASS_SELF:
-			case ZEND_FETCH_CLASS_PARENT:
-			case ZEND_FETCH_CLASS_STATIC:
-				SET_UNUSED(opline->op2);
-				opline->extended_value = fetch_type;
-				zval_dtor(&class_name->u.constant);
-				break;
-			default:
-				zend_resolve_class_name(class_name TSRMLS_CC);
-				opline->op2_type = IS_CONST;
-				opline->op2.constant =
-					zend_add_class_name_literal(CG(active_op_array), &class_name->u.constant TSRMLS_CC);
-				break;
+		if (fetch_type == ZEND_FETCH_CLASS_DEFAULT) {
+			uint32_t type = name_ast->kind == ZEND_AST_ZVAL ? name_ast->attr : ZEND_NAME_FQ;
+			opline->op2_type = IS_CONST;
+			opline->op2.constant = zend_add_class_name_literal(CG(active_op_array),
+				zend_resolve_class_name(name, type TSRMLS_CC) TSRMLS_CC);
 		}
+
+		zend_string_release(name);
 	} else {
-		SET_NODE(opline->op2, class_name);
+		opline = zend_emit_op(result, ZEND_FETCH_CLASS, NULL, &name_node TSRMLS_CC);
+		opline->extended_value = ZEND_FETCH_CLASS_DEFAULT;
 	}
-	opline->result.var = get_temporary_variable(CG(active_op_array));
-	opline->result_type = IS_VAR; /* FIXME: Hack so that INIT_FCALL_BY_NAME still knows this is a class */
-	GET_NODE(result, opline->result);
-	result->EA = opline->extended_value;
+
+	return opline;
 }
 /* }}} */
 
-void zend_do_label(znode *label TSRMLS_DC) /* {{{ */
+static int zend_try_compile_cv(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */ 
 {
-	zend_label dest;
+	zend_ast *name_ast = ast->child[0];
+	if (name_ast->kind == ZEND_AST_ZVAL) {
+		zend_string *name = zval_get_string(zend_ast_get_zval(name_ast));
 
-	if (!CG(context).labels) {
-		ALLOC_HASHTABLE(CG(context).labels);
-		zend_hash_init(CG(context).labels, 4, NULL, NULL, 0);
-	}
+		if (zend_is_auto_global(name TSRMLS_CC)) {
+			zend_string_release(name);
+			return FAILURE;
+		}
 
-	dest.brk_cont = CG(context).current_brk_cont;
-	dest.opline_num = get_next_op_number(CG(active_op_array));
+		result->op_type = IS_CV;
+		result->u.op.var = lookup_cv(CG(active_op_array), name TSRMLS_CC);
 
-	if (zend_hash_add(CG(context).labels, Z_STRVAL(label->u.constant), Z_STRLEN(label->u.constant) + 1, (void**)&dest, sizeof(zend_label), NULL) == FAILURE) {
-		zend_error(E_COMPILE_ERROR, "Label '%s' already defined", Z_STRVAL(label->u.constant));
+		if (zend_string_equals_literal(name, "this")) {
+			CG(active_op_array)->this_var = result->u.op.var;
+		}
+		return SUCCESS;
 	}
 
-	/* Done with label now */
-	zval_dtor(&label->u.constant);
+	return FAILURE;
 }
 /* }}} */
 
-void zend_resolve_goto_label(zend_op_array *op_array, zend_op *opline, int pass2 TSRMLS_DC) /* {{{ */
+static zend_op *zend_compile_simple_var_no_cv(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC) /* {{{ */
 {
-	zend_label *dest;
-	long current, distance;
-	zval *label;
+	zend_ast *name_ast = ast->child[0];
+	znode name_node;
+	zend_op *opline;
 
-	if (pass2) {
-		label = opline->op2.zv;
-	} else {
-		label = &CONSTANT_EX(op_array, opline->op2.constant);
+	/* there is a chance someone is accessing $this */
+	if (ast->kind != ZEND_AST_ZVAL
+		&& CG(active_op_array)->scope && CG(active_op_array)->this_var == -1
+	) {
+		zend_string *key = zend_string_init("this", sizeof("this") - 1, 0);
+		CG(active_op_array)->this_var = lookup_cv(CG(active_op_array), key TSRMLS_CC);
 	}
-	if (CG(context).labels == NULL ||
-	    zend_hash_find(CG(context).labels, Z_STRVAL_P(label), Z_STRLEN_P(label)+1, (void**)&dest) == FAILURE) {
 
-		if (pass2) {
-			CG(in_compilation) = 1;
-			CG(active_op_array) = op_array;
-			CG(zend_lineno) = opline->lineno;
-			zend_error(E_COMPILE_ERROR, "'goto' to undefined label '%s'", Z_STRVAL_P(label));
-		} else {
-			/* Label is not defined. Delay to pass 2. */
-			INC_BPC(op_array);
-			return;
+	zend_compile_expr(&name_node, name_ast 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;
 		}
 	}
 
-	opline->op1.opline_num = dest->opline_num;
-	zval_dtor(label);
-	Z_TYPE_P(label) = IS_NULL;
+	return opline;
+}
+/* }}} */
 
-	/* Check that we are not moving into loop or switch */
-	current = opline->extended_value;
-	for (distance = 0; current != dest->brk_cont; distance++) {
-		if (current == -1) {
-			if (pass2) {
-				CG(in_compilation) = 1;
-				CG(active_op_array) = op_array;
-				CG(zend_lineno) = opline->lineno;
-			}
-			zend_error(E_COMPILE_ERROR, "'goto' into loop or switch statement is disallowed");
+static void zend_compile_simple_var(znode *result, zend_ast *ast, uint32_t type 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);
+	}
+}
+/* }}} */
+
+static void zend_separate_if_call_and_write(znode *node, zend_ast *ast, uint32_t type TSRMLS_DC) /* {{{ */
+{
+	if (type != BP_VAR_R && type != BP_VAR_IS && zend_is_call(ast)) {
+		if (node->op_type == IS_VAR) {
+			zend_op *opline = zend_emit_op(NULL, ZEND_SEPARATE, node, NULL TSRMLS_CC);
+			opline->result_type = IS_VAR;
+			opline->result.var = opline->op1.var;
+		} else {
+			zend_error_noreturn(E_COMPILE_ERROR, "Cannot use result of built-in function in write context");
 		}
-		current = op_array->brk_cont_array[current].parent;
 	}
+}
+/* }}} */
 
-	if (distance == 0) {
-		/* Nothing to break out of, optimize to ZEND_JMP */
-		opline->opcode = ZEND_JMP;
-		opline->extended_value = 0;
-		SET_UNUSED(opline->op2);
+void zend_delayed_compile_var(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC);
+void zend_compile_assign(znode *result, zend_ast *ast TSRMLS_DC);
+static void zend_compile_list_assign(znode *result, zend_ast *ast, znode *expr_node TSRMLS_DC);
+
+static inline void zend_emit_assign_znode(zend_ast *var_ast, znode *value_node TSRMLS_DC) /* {{{ */
+{
+	znode dummy_node;
+	if (var_ast->kind == ZEND_AST_LIST) {
+		zend_compile_list_assign(&dummy_node, var_ast, value_node TSRMLS_CC);
 	} else {
-		/* Set real break distance */
-		ZVAL_LONG(label, distance);
+		zend_ast *assign_ast = zend_ast_create(ZEND_AST_ASSIGN, var_ast,
+			zend_ast_create_znode(value_node));
+		zend_compile_assign(&dummy_node, assign_ast TSRMLS_CC);
 	}
+	zend_do_free(&dummy_node TSRMLS_CC);
+}
+/* }}} */
 
-	if (pass2) {
-		DEC_BPC(op_array);
+static zend_op *zend_delayed_compile_dim(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC) /* {{{ */
+{
+	zend_ast *var_ast = ast->child[0];
+	zend_ast *dim_ast = ast->child[1];
+
+	znode var_node, dim_node;
+
+	zend_delayed_compile_var(&var_node, var_ast, type TSRMLS_CC);
+	zend_separate_if_call_and_write(&var_node, var_ast, type TSRMLS_CC);
+
+	if (dim_ast == NULL) {
+		if (type == BP_VAR_R || type == BP_VAR_IS) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Cannot use [] for reading");
+		}
+		if (type == BP_VAR_UNSET) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Cannot use [] for unsetting");
+		}
+		dim_node.op_type = IS_UNUSED;
+	} else {
+		zend_compile_expr(&dim_node, dim_ast TSRMLS_CC);
+		zend_handle_numeric_op(&dim_node TSRMLS_CC);
 	}
+
+	return zend_delayed_emit_op(result, ZEND_FETCH_DIM_R, &var_node, &dim_node TSRMLS_CC);
 }
 /* }}} */
 
-void zend_do_goto(const znode *label TSRMLS_DC) /* {{{ */
+static inline zend_op *zend_compile_dim_common(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC) /* {{{ */
 {
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	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);
+}
+/* }}} */
 
-	opline->opcode = ZEND_GOTO;
-	opline->extended_value = CG(context).current_brk_cont;
-	SET_UNUSED(opline->op1);
-	SET_NODE(opline->op2, label);
-	zend_resolve_goto_label(CG(active_op_array), opline, 0 TSRMLS_CC);
+void zend_compile_dim(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC) /* {{{ */
+{
+	zend_op *opline = zend_compile_dim_common(result, ast, type TSRMLS_CC);
+	zend_adjust_for_fetch_type(opline, type);
 }
 /* }}} */
 
-void zend_release_labels(int temporary TSRMLS_DC) /* {{{ */
+static zend_bool is_this_fetch(zend_ast *ast) /* {{{ */
 {
-	if (CG(context).labels) {
-		zend_hash_destroy(CG(context).labels);
-		FREE_HASHTABLE(CG(context).labels);
-		CG(context).labels = NULL;
+	if (ast->kind == ZEND_AST_VAR && ast->child[0]->kind == ZEND_AST_ZVAL) {
+		zval *name = zend_ast_get_zval(ast->child[0]);
+		return Z_TYPE_P(name) == IS_STRING && zend_string_equals_literal(Z_STR_P(name), "this");
 	}
-	if (!temporary && !zend_stack_is_empty(&CG(context_stack))) {
-		zend_compiler_context *ctx;
 
-		zend_stack_top(&CG(context_stack), (void**)&ctx);
-		CG(context) = *ctx;
-		zend_stack_del_top(&CG(context_stack));
-	}
+	return 0;
 }
 /* }}} */
 
-void zend_do_build_full_name(znode *result, znode *prefix, znode *name, int is_class_member TSRMLS_DC) /* {{{ */
+static zend_op *zend_delayed_compile_prop(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC) /* {{{ */
 {
-	zend_uint length;
+	zend_ast *obj_ast = ast->child[0];
+	zend_ast *prop_ast = ast->child[1];
 
-	if (!result) {
-		result = prefix;
+	znode obj_node, prop_node;
+	zend_op *opline;
+
+	if (is_this_fetch(obj_ast)) {
+		obj_node.op_type = IS_UNUSED;
 	} else {
-		*result = *prefix;
+		zend_delayed_compile_var(&obj_node, obj_ast, type TSRMLS_CC);
+		zend_separate_if_call_and_write(&obj_node, obj_ast, type TSRMLS_CC);
 	}
+	zend_compile_expr(&prop_node, prop_ast TSRMLS_CC);
 
-	if (is_class_member) {
-		length = sizeof("::")-1 + Z_STRLEN(result->u.constant) + Z_STRLEN(name->u.constant);
-		Z_STRVAL(result->u.constant) = erealloc(Z_STRVAL(result->u.constant), length+1);
-		memcpy(&Z_STRVAL(result->u.constant)[Z_STRLEN(result->u.constant)], "::", sizeof("::")-1);
-		memcpy(&Z_STRVAL(result->u.constant)[Z_STRLEN(result->u.constant) + sizeof("::")-1], Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant)+1);
-		str_efree(Z_STRVAL(name->u.constant));
-		Z_STRLEN(result->u.constant) = length;
-	} else {
-		length = sizeof("\\")-1 + Z_STRLEN(result->u.constant) + Z_STRLEN(name->u.constant);
-		Z_STRVAL(result->u.constant) = erealloc(Z_STRVAL(result->u.constant), length+1);
-		memcpy(&Z_STRVAL(result->u.constant)[Z_STRLEN(result->u.constant)], "\\", sizeof("\\")-1);
-		memcpy(&Z_STRVAL(result->u.constant)[Z_STRLEN(result->u.constant) + sizeof("\\")-1], Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant)+1);
-		str_efree(Z_STRVAL(name->u.constant));
-		Z_STRLEN(result->u.constant) = length;
+	opline = zend_delayed_emit_op(result, ZEND_FETCH_OBJ_R, &obj_node, &prop_node 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);
 	}
+
+	return opline;
+}
+/* }}} */
+
+static zend_op *zend_compile_prop_common(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC) /* {{{ */
+{
+	uint32_t offset = zend_delayed_compile_begin(TSRMLS_C);
+	zend_delayed_compile_prop(result, ast, type TSRMLS_CC);
+	return zend_delayed_compile_end(offset TSRMLS_CC);
 }
 /* }}} */
 
-int zend_do_begin_class_member_function_call(znode *class_name, znode *method_name TSRMLS_DC) /* {{{ */
+void zend_compile_prop(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC) /* {{{ */
 {
-	znode class_node;
-	unsigned char *ptr = NULL;
+	zend_op *opline = zend_compile_prop_common(result, ast, type TSRMLS_CC);
+	zend_adjust_for_fetch_type(opline, type);
+}
+/* }}} */
+
+zend_op *zend_compile_static_prop_common(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC) /* {{{ */
+{
+	zend_ast *class_ast = ast->child[0];
+	zend_ast *prop_ast = ast->child[1];
+
+	znode class_node, prop_node;
 	zend_op *opline;
 
-	if (method_name->op_type == IS_CONST) {
-		char *lcname;
-		if (Z_TYPE(method_name->u.constant) != IS_STRING) {
-			zend_error(E_COMPILE_ERROR, "Method name must be a string");
-		}
-		lcname = zend_str_tolower_dup(Z_STRVAL(method_name->u.constant), Z_STRLEN(method_name->u.constant));
-		if ((sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)-1) == Z_STRLEN(method_name->u.constant) &&
-		    memcmp(lcname, ZEND_CONSTRUCTOR_FUNC_NAME, sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)-1) == 0) {
-			zval_dtor(&method_name->u.constant);
-			method_name->op_type = IS_UNUSED;
-		}
-		efree(lcname);
+	if (zend_is_const_default_class_ref(class_ast)) {
+		class_node.op_type = IS_CONST;
+		ZVAL_STR(&class_node.u.constant, zend_resolve_class_name_ast(class_ast TSRMLS_CC));
+	} else {
+		zend_compile_class_ref(&class_node, class_ast TSRMLS_CC);
 	}
 
-	if (class_name->op_type == IS_CONST &&
-	    ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant))) {
-		zend_resolve_class_name(class_name TSRMLS_CC);
-		class_node = *class_name;
-		opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	} else {
-		zend_do_fetch_class(&class_node, class_name TSRMLS_CC);
-		opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-		opline->extended_value = class_node.EA	;
+	zend_compile_expr(&prop_node, prop_ast TSRMLS_CC);
+
+	opline = zend_emit_op(result, ZEND_FETCH_R, &prop_node, NULL TSRMLS_CC);
+	if (opline->op1_type == IS_CONST) {
+		zend_alloc_polymorphic_cache_slot(opline->op1.constant TSRMLS_CC);
 	}
-	opline->opcode = ZEND_INIT_STATIC_METHOD_CALL;
-	opline->result.num = CG(context).nested_calls;
 	if (class_node.op_type == IS_CONST) {
-		opline->op1_type = IS_CONST;
-		opline->op1.constant =
-			zend_add_class_name_literal(CG(active_op_array), &class_node.u.constant TSRMLS_CC);
-	} else {
-		SET_NODE(opline->op1, &class_node);
-	}
-	if (method_name->op_type == IS_CONST) {
 		opline->op2_type = IS_CONST;
-		opline->op2.constant =
-			zend_add_func_name_literal(CG(active_op_array), &method_name->u.constant TSRMLS_CC);
-		if (opline->op1_type == IS_CONST) {
-			GET_CACHE_SLOT(opline->op2.constant);
-		} else {
-			GET_POLYMORPHIC_CACHE_SLOT(opline->op2.constant);
-		}
+		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, method_name);
+		SET_NODE(opline->op2, &class_node);
 	}
+	opline->extended_value |= ZEND_FETCH_STATIC_MEMBER;
 
-	zend_stack_push(&CG(function_call_stack), (void *) &ptr, sizeof(zend_function *));
-	if (++CG(context).nested_calls > CG(active_op_array)->nested_calls) {
-		CG(active_op_array)->nested_calls = CG(context).nested_calls;
-	}
-	zend_do_extended_fcall_begin(TSRMLS_C);
-	return 1; /* Dynamic */
+	return opline;
 }
 /* }}} */
 
-void zend_do_end_function_call(znode *function_name, znode *result, const znode *argument_list, int is_method, int is_dynamic_fcall TSRMLS_DC) /* {{{ */
+void zend_compile_static_prop(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC) /* {{{ */
 {
-	zend_op *opline;
+	zend_op *opline = zend_compile_static_prop_common(result, ast, type TSRMLS_CC);
+	zend_adjust_for_fetch_type(opline, type);
+}
+/* }}} */
 
-	if (is_method && function_name && function_name->op_type == IS_UNUSED) {
-		/* clone */
-		if (Z_LVAL(argument_list->u.constant) != 0) {
-			zend_error(E_WARNING, "Clone method does not require arguments");
-		}
-		opline = &CG(active_op_array)->opcodes[Z_LVAL(function_name->u.constant)];
-	} else {
-		opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-		if (!is_method && !is_dynamic_fcall && function_name->op_type==IS_CONST) {
-			opline->opcode = ZEND_DO_FCALL;
-			SET_NODE(opline->op1, function_name);
-			SET_UNUSED(opline->op2);
-			opline->op2.num = CG(context).nested_calls;
-			CALCULATE_LITERAL_HASH(opline->op1.constant);
-			GET_CACHE_SLOT(opline->op1.constant);
-		} else {
-			opline->opcode = ZEND_DO_FCALL_BY_NAME;
-			SET_UNUSED(opline->op1);
-			SET_UNUSED(opline->op2);
-			opline->op2.num = --CG(context).nested_calls;
-		}
+static void zend_compile_list_assign(znode *result, zend_ast *ast, znode *expr_node TSRMLS_DC) /* {{{ */
+{
+	zend_ast_list *list = zend_ast_get_list(ast);
+	uint32_t i;
+
+	if (list->children == 1 && !list->child[0]) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Cannot use empty list");
 	}
 
-	opline->result.var = get_temporary_variable(CG(active_op_array));
-	opline->result_type = IS_VAR;
-	GET_NODE(result, opline->result);
+	for (i = 0; i < list->children; ++i) {
+		zend_ast *var_ast = list->child[i];
+		znode fetch_result, dim_node;
+
+		if (var_ast == NULL) {
+			continue;
+		}
 
-	zend_stack_del_top(&CG(function_call_stack));
-	opline->extended_value = Z_LVAL(argument_list->u.constant);
+		dim_node.op_type = IS_CONST;
+		ZVAL_LONG(&dim_node.u.constant, i);
 
-	if (CG(context).used_stack + 1 > CG(active_op_array)->used_stack) {
-		CG(active_op_array)->used_stack = CG(context).used_stack + 1;
+		if (expr_node->op_type == IS_CONST) {
+			Z_TRY_ADDREF(expr_node->u.constant);
+		}
+
+		zend_emit_op(&fetch_result, ZEND_FETCH_LIST, expr_node, &dim_node TSRMLS_CC);
+		zend_emit_assign_znode(var_ast, &fetch_result TSRMLS_CC);
 	}
-	CG(context).used_stack -= Z_LVAL(argument_list->u.constant);
+	*result = *expr_node;
 }
 /* }}} */
 
-void zend_do_pass_param(znode *param, zend_uchar op, int offset TSRMLS_DC) /* {{{ */
+void zend_ensure_writable_variable(const zend_ast *ast) /* {{{ */
 {
-	zend_op *opline;
-	int original_op=op;
-	zend_function **function_ptr_ptr, *function_ptr;
-	int send_by_reference;
-	int send_function = 0;
-
-	zend_stack_top(&CG(function_call_stack), (void **) &function_ptr_ptr);
-	function_ptr = *function_ptr_ptr;
-
-	if (original_op == ZEND_SEND_REF) {
-		if (function_ptr &&
-		    function_ptr->common.function_name &&
-		    function_ptr->common.type == ZEND_USER_FUNCTION &&
-		    !ARG_SHOULD_BE_SENT_BY_REF(function_ptr, (zend_uint) offset)) {
-			zend_error(E_COMPILE_ERROR,
-						"Call-time pass-by-reference has been removed; "
-						"If you would like to pass argument by reference, modify the declaration of %s().",
-						function_ptr->common.function_name);
-		} else {
-			zend_error(E_COMPILE_ERROR, "Call-time pass-by-reference has been removed");
-		}
-		return;
+	if (ast->kind == ZEND_AST_CALL) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Can't use function return value in write context");
 	}
-
-	if (function_ptr) {
-		if (ARG_MAY_BE_SENT_BY_REF(function_ptr, (zend_uint) offset)) {
-			if (param->op_type & (IS_VAR|IS_CV) && original_op != ZEND_SEND_VAL) {
-				send_by_reference = 1;
-				if (op == ZEND_SEND_VAR && zend_is_function_or_method_call(param)) {
-					/* Method call */
-					op = ZEND_SEND_VAR_NO_REF;
-					send_function = ZEND_ARG_SEND_FUNCTION | ZEND_ARG_SEND_SILENT;
-				}
-			} else {
-				op = ZEND_SEND_VAL;
-				send_by_reference = 0;
-			}
-		} else {
-			send_by_reference = ARG_SHOULD_BE_SENT_BY_REF(function_ptr, (zend_uint) offset) ? ZEND_ARG_SEND_BY_REF : 0;
-		}
-	} else {
-		send_by_reference = 0;
-	}
-
-	if (op == ZEND_SEND_VAR && zend_is_function_or_method_call(param)) {
-		/* Method call */
-		op = ZEND_SEND_VAR_NO_REF;
-		send_function = ZEND_ARG_SEND_FUNCTION;
-	} else if (op == ZEND_SEND_VAL && (param->op_type & (IS_VAR|IS_CV))) {
-		op = ZEND_SEND_VAR_NO_REF;
+	if (ast->kind == ZEND_AST_METHOD_CALL || ast->kind == ZEND_AST_STATIC_CALL) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Can't use method return value in write context");
 	}
+}
+/* }}} */
 
-	if (op!=ZEND_SEND_VAR_NO_REF && send_by_reference==ZEND_ARG_SEND_BY_REF) {
-		/* change to passing by reference */
-		switch (param->op_type) {
-			case IS_VAR:
-			case IS_CV:
-				op = ZEND_SEND_REF;
-				break;
-			default:
-				zend_error(E_COMPILE_ERROR, "Only variables can be passed by reference");
-				break;
-		}
+/* 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 (original_op == ZEND_SEND_VAR) {
-		switch (op) {
-			case ZEND_SEND_VAR_NO_REF:
-				zend_do_end_variable_parse(param, BP_VAR_R, 0 TSRMLS_CC);
-				break;
-			case ZEND_SEND_VAR:
-				if (function_ptr) {
-					zend_do_end_variable_parse(param, BP_VAR_R, 0 TSRMLS_CC);
-				} else {
-					zend_do_end_variable_parse(param, BP_VAR_FUNC_ARG, offset TSRMLS_CC);
-				}
-				break;
-			case ZEND_SEND_REF:
-				zend_do_end_variable_parse(param, BP_VAR_W, 0 TSRMLS_CC);
-				break;
-		}
+	while (zend_is_variable(var_ast) && var_ast->kind != ZEND_AST_VAR) {
+		var_ast = var_ast->child[0];
 	}
 
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-
-	if (op == ZEND_SEND_VAR_NO_REF) {
-		if (function_ptr) {
-			opline->extended_value = ZEND_ARG_COMPILE_TIME_BOUND | send_by_reference | send_function;
-		} else {
-			opline->extended_value = send_function;
-		}
-	} else {
-		if (function_ptr) {
-			opline->extended_value = ZEND_DO_FCALL;
-		} else {
-			opline->extended_value = ZEND_DO_FCALL_BY_NAME;
-		}
+	if (var_ast->kind != ZEND_AST_VAR || var_ast->child[0]->kind != ZEND_AST_ZVAL) {
+		return 0;
 	}
-	opline->opcode = op;
-	SET_NODE(opline->op1, param);
-	opline->op2.opline_num = offset;
-	SET_UNUSED(opline->op2);
 
-	if (++CG(context).used_stack > CG(active_op_array)->used_stack) {
-		CG(active_op_array)->used_stack = CG(context).used_stack;
+	{
+		zend_string *name1 = zval_get_string(zend_ast_get_zval(var_ast->child[0]));
+		zend_string *name2 = zval_get_string(zend_ast_get_zval(expr_ast->child[0]));
+		zend_bool result = zend_string_equals(name1, name2);
+		zend_string_release(name1);
+		zend_string_release(name2);
+		return result;
 	}
 }
 /* }}} */
 
-static int generate_free_switch_expr(const zend_switch_entry *switch_entry TSRMLS_DC) /* {{{ */
+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];
+
+	znode var_node, expr_node;
 	zend_op *opline;
+	uint32_t offset;
 
-	if (switch_entry->cond.op_type != IS_VAR && switch_entry->cond.op_type != IS_TMP_VAR) {
-		return (switch_entry->cond.op_type == IS_UNUSED);
+	if (is_this_fetch(var_ast)) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this");
 	}
 
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	zend_ensure_writable_variable(var_ast);
 
-	opline->opcode = (switch_entry->cond.op_type == IS_TMP_VAR) ? ZEND_FREE : ZEND_SWITCH_FREE;
-	SET_NODE(opline->op1, &switch_entry->cond);
-	SET_UNUSED(opline->op2);
-
-	return 0;
-}
-/* }}} */
+	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);
 
-static int generate_free_foreach_copy(const zend_op *foreach_copy TSRMLS_DC) /* {{{ */
-{
-	zend_op *opline;
+			if (zend_is_assign_to_self(var_ast, expr_ast TSRMLS_CC)) {
+				/* $a[0] = $a should evaluate the right $a first */
+				zend_compile_simple_var_no_cv(&expr_node, expr_ast, BP_VAR_R TSRMLS_CC);
+			} else {
+				zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
+			}
 
-	/* If we reach the separator then stop applying the stack */
-	if (foreach_copy->result_type == IS_UNUSED) {
-		return 1;
-	}
+			opline = zend_delayed_compile_end(offset TSRMLS_CC);
+			opline->opcode = ZEND_ASSIGN_DIM;
 
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+			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->opcode = (foreach_copy->result_type == IS_TMP_VAR) ? ZEND_FREE : ZEND_SWITCH_FREE;
-	COPY_NODE(opline->op1, foreach_copy->result);
-	SET_UNUSED(opline->op2);
+			opline = zend_delayed_compile_end(offset TSRMLS_CC);
+			opline->opcode = ZEND_ASSIGN_OBJ;
 
-	return 0;
+			zend_emit_op_data(&expr_node TSRMLS_CC);
+			return;
+		case ZEND_AST_LIST:
+			zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
+			zend_compile_list_assign(result, var_ast, &expr_node TSRMLS_CC);
+			return;
+		EMPTY_SWITCH_DEFAULT_CASE();
+	}
 }
 /* }}} */
 
-void zend_do_return(znode *expr, int do_end_vparse TSRMLS_DC) /* {{{ */
+void zend_compile_assign_ref(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	zend_op *opline;
-	int start_op_number, end_op_number;
-	zend_bool returns_reference = (CG(active_op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0;
+	zend_ast *target_ast = ast->child[0];
+	zend_ast *source_ast = ast->child[1];
 
-	/* The error for use of return inside a generator is thrown in pass_two. */
+	znode target_node, source_node;
+	zend_op *opline;
 
-	if (do_end_vparse) {
-		if (returns_reference && !zend_is_function_or_method_call(expr)) {
-			zend_do_end_variable_parse(expr, BP_VAR_W, 0 TSRMLS_CC);
-		} else {
-			zend_do_end_variable_parse(expr, BP_VAR_R, 0 TSRMLS_CC);
-		}
+	if (is_this_fetch(target_ast)) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this");
 	}
+	zend_ensure_writable_variable(target_ast);
 
-	start_op_number = get_next_op_number(CG(active_op_array));
-
-#ifdef ZTS
-	zend_stack_apply_with_argument(&CG(switch_cond_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element, void *)) generate_free_switch_expr TSRMLS_CC);
-	zend_stack_apply_with_argument(&CG(foreach_copy_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element, void *)) generate_free_foreach_copy TSRMLS_CC);
-#else
-	zend_stack_apply(&CG(switch_cond_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element)) generate_free_switch_expr);
-	zend_stack_apply(&CG(foreach_copy_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element)) generate_free_foreach_copy);
-#endif
+	zend_compile_var(&target_node, target_ast, BP_VAR_W TSRMLS_CC);
+	zend_compile_var(&source_node, source_ast, BP_VAR_REF TSRMLS_CC);
 
-	end_op_number = get_next_op_number(CG(active_op_array));
-	while (start_op_number < end_op_number) {
-		CG(active_op_array)->opcodes[start_op_number].extended_value |= EXT_TYPE_FREE_ON_RETURN;
-		start_op_number++;
+	if (source_node.op_type != IS_VAR && zend_is_call(source_ast)) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Cannot use result of built-in function in write context");
 	}
 
-	if (CG(context).in_finally) {
-		opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-		opline->opcode = ZEND_DISCARD_EXCEPTION;
-		SET_UNUSED(opline->op1);
-		SET_UNUSED(opline->op2);
+	opline = zend_emit_op(result, ZEND_ASSIGN_REF, &target_node, &source_node TSRMLS_CC);
+	if (!result) {
+		opline->result_type |= EXT_TYPE_UNUSED;
 	}
 
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-
-	opline->opcode = returns_reference ? ZEND_RETURN_BY_REF : ZEND_RETURN;
-
-	if (expr) {
-		SET_NODE(opline->op1, expr);
-
-		if (do_end_vparse && zend_is_function_or_method_call(expr)) {
-			opline->extended_value = ZEND_RETURNS_FUNCTION;
-		}
-	} else {
-		opline->op1_type = IS_CONST;
-		LITERAL_NULL(opline->op1);
+	if (zend_is_call(source_ast)) {
+		opline->extended_value = ZEND_RETURNS_FUNCTION;
+	} else if (source_ast->kind == ZEND_AST_NEW) {
+		zend_error(E_DEPRECATED, "Assigning the return value of new by reference is deprecated");
+		opline->extended_value = ZEND_RETURNS_NEW;
 	}
+}
+/* }}} */
 
-	SET_UNUSED(opline->op2);
+static inline void zend_emit_assign_ref_znode(zend_ast *var_ast, znode *value_node TSRMLS_DC) /* {{{ */
+{
+	zend_ast *assign_ast = zend_ast_create(ZEND_AST_ASSIGN_REF, var_ast,
+		zend_ast_create_znode(value_node));
+	zend_compile_assign_ref(NULL, assign_ast TSRMLS_CC);
 }
 /* }}} */
 
-void zend_do_yield(znode *result, znode *value, const znode *key, zend_bool is_variable TSRMLS_DC) /* {{{ */
+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;
 
-	if (!CG(active_op_array)->function_name) {
-		zend_error(E_COMPILE_ERROR, "The \"yield\" expression can only be used inside a function");
-	}
+	zend_ensure_writable_variable(var_ast);
 
-	CG(active_op_array)->fn_flags |= ZEND_ACC_GENERATOR;
+	switch (var_ast->kind) {
+		case ZEND_AST_VAR:
+		case ZEND_AST_STATIC_PROP:
+			zend_compile_var(&var_node, var_ast, BP_VAR_RW TSRMLS_CC);
+			zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
+			zend_emit_op(result, opcode, &var_node, &expr_node TSRMLS_CC);
+			return;
+		case ZEND_AST_DIM:
+			offset = zend_delayed_compile_begin(TSRMLS_C);
+			zend_delayed_compile_dim(result, var_ast, BP_VAR_RW TSRMLS_CC);
+			zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
+
+			opline = zend_delayed_compile_end(offset TSRMLS_CC);
+			opline->opcode = opcode;
+			opline->extended_value = ZEND_ASSIGN_DIM;
+
+			opline = zend_emit_op_data(&expr_node TSRMLS_CC);
+			opline->op2.var = get_temporary_variable(CG(active_op_array));
+			opline->op2_type = IS_VAR;
+			return;
+		case ZEND_AST_PROP:
+			offset = zend_delayed_compile_begin(TSRMLS_C);
+			zend_delayed_compile_prop(result, var_ast, BP_VAR_RW TSRMLS_CC);
+			zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
 
-	if (is_variable) {
-		if ((CG(active_op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) && !zend_is_function_or_method_call(value)) {
-			zend_do_end_variable_parse(value, BP_VAR_W, 0 TSRMLS_CC);
-		} else {
-			zend_do_end_variable_parse(value, BP_VAR_R, 0 TSRMLS_CC);
-		}
-	}
+			opline = zend_delayed_compile_end(offset TSRMLS_CC);
+			opline->opcode = opcode;
+			opline->extended_value = ZEND_ASSIGN_OBJ;
 
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+			zend_emit_op_data(&expr_node TSRMLS_CC);
+			return;
+		EMPTY_SWITCH_DEFAULT_CASE()
+	}
+}
+/* }}} */
 
-	opline->opcode = ZEND_YIELD;
+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 */
 
-	if (value) {
-		SET_NODE(opline->op1, value);
+	for (i = 0; i < args->children; ++i) {
+		zend_ast *arg = args->child[i];
+		uint32_t arg_num = i + 1;
 
-		if (is_variable && zend_is_function_or_method_call(value)) {
-			opline->extended_value = ZEND_RETURNS_FUNCTION;
+		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);
+				if (arg_node.op_type & (IS_CONST|IS_TMP_VAR)) {
+					/* Function call was converted into builtin instruction */
+					opcode = ZEND_SEND_VAL;
+				} else {
+					opcode = ZEND_SEND_VAR_NO_REF;
+					flags |= ZEND_ARG_SEND_FUNCTION;
+					if (fbc && ARG_SHOULD_BE_SENT_BY_REF(fbc, arg_num)) {
+						flags |= ZEND_ARG_SEND_BY_REF;
+						if (ARG_MAY_BE_SENT_BY_REF(fbc, arg_num)) {
+							flags |= ZEND_ARG_SEND_SILENT;
+						}
+					}
+				}
+			} else if (fbc) {
+				if (ARG_SHOULD_BE_SENT_BY_REF(fbc, arg_num)) {
+					zend_compile_var(&arg_node, arg, BP_VAR_W 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;
+				}
+			}
 		}
-	} else {
-		SET_UNUSED(opline->op1);
-	}
 
-	if (key) {
-		SET_NODE(opline->op2, key);
-	} else {
+		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;
+		}
 	}
 
-	opline->result_type = IS_TMP_VAR;
-	opline->result.var = get_temporary_variable(CG(active_op_array));
-	GET_NODE(result, opline->result);
+	return arg_count;
 }
 /* }}} */
 
-static int zend_add_try_element(zend_uint try_op TSRMLS_DC) /* {{{ */
+void zend_compile_call_common(znode *result, zend_ast *args_ast, zend_function *fbc TSRMLS_DC) /* {{{ */
 {
-	int try_catch_offset = CG(active_op_array)->last_try_catch++;
+	zend_op *opline;
+	uint32_t opnum_init = get_next_op_number(CG(active_op_array)) - 1;
+	uint32_t arg_count;
+	uint32_t call_flags;
 
-	CG(active_op_array)->try_catch_array = erealloc(CG(active_op_array)->try_catch_array, sizeof(zend_try_catch_element)*CG(active_op_array)->last_try_catch);
-	CG(active_op_array)->try_catch_array[try_catch_offset].try_op = try_op;
-	CG(active_op_array)->try_catch_array[try_catch_offset].catch_op = 0;
-	CG(active_op_array)->try_catch_array[try_catch_offset].finally_op = 0;
-	CG(active_op_array)->try_catch_array[try_catch_offset].finally_end = 0;
-	return try_catch_offset;
-}
-/* }}} */
+	zend_do_extended_fcall_begin(TSRMLS_C);
 
-static void zend_add_catch_element(int offset, zend_uint catch_op TSRMLS_DC) /* {{{ */
-{
-	CG(active_op_array)->try_catch_array[offset].catch_op = catch_op;
+	arg_count = zend_compile_args(args_ast, fbc TSRMLS_CC);
+
+	opline = &CG(active_op_array)->opcodes[opnum_init];
+	opline->extended_value = arg_count;
+
+	call_flags = (opline->opcode == ZEND_NEW ? ZEND_CALL_CTOR : 0);
+	opline = zend_emit_op(result, ZEND_DO_FCALL, NULL, NULL TSRMLS_CC);
+	opline->op1.num = call_flags;
+
+	zend_do_extended_fcall_end(TSRMLS_C);
 }
 /* }}} */
 
-void zend_do_first_catch(znode *open_parentheses TSRMLS_DC) /* {{{ */
+zend_bool zend_compile_function_name(znode *name_node, zend_ast *name_ast TSRMLS_DC) /* {{{ */
 {
-	open_parentheses->u.op.opline_num = get_next_op_number(CG(active_op_array));
+	zend_string *orig_name = zend_ast_get_str(name_ast);
+	zend_bool is_fully_qualified;
+
+	name_node->op_type = IS_CONST;
+	ZVAL_STR(&name_node->u.constant, zend_resolve_function_name(
+		orig_name, name_ast->attr, &is_fully_qualified TSRMLS_CC));
+
+	return !is_fully_qualified && CG(current_namespace);
 }
 /* }}} */
 
-void zend_initialize_try_catch_element(znode *catch_token TSRMLS_DC) /* {{{ */
+void zend_compile_ns_call(znode *result, znode *name_node, zend_ast *args_ast TSRMLS_DC) /* {{{ */
 {
-	int jmp_op_number = get_next_op_number(CG(active_op_array));
 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	zend_llist jmp_list;
-	zend_llist *jmp_list_ptr;
-
-	opline->opcode = ZEND_JMP;
+	opline->opcode = ZEND_INIT_NS_FCALL_BY_NAME;
 	SET_UNUSED(opline->op1);
-	SET_UNUSED(opline->op2);
-	/* save for backpatching */
-
-	zend_llist_init(&jmp_list, sizeof(int), NULL, 0);
-	zend_stack_push(&CG(bp_stack), (void *) &jmp_list, sizeof(zend_llist));
-	zend_stack_top(&CG(bp_stack), (void **) &jmp_list_ptr);
-	zend_llist_add_element(jmp_list_ptr, &jmp_op_number);
+	opline->op2_type = IS_CONST;
+	opline->op2.constant = zend_add_ns_func_name_literal(
+		CG(active_op_array), Z_STR(name_node->u.constant) TSRMLS_CC);
+	zend_alloc_cache_slot(opline->op2.constant TSRMLS_CC);
 
-	catch_token->EA = get_next_op_number(CG(active_op_array));
+	zend_compile_call_common(result, args_ast, NULL TSRMLS_CC);
 }
 /* }}} */
 
-void zend_do_mark_last_catch(const znode *first_catch, const znode *last_additional_catch TSRMLS_DC) /* {{{ */
+void zend_compile_dynamic_call(znode *result, znode *name_node, zend_ast *args_ast TSRMLS_DC) /* {{{ */
 {
-	CG(active_op_array)->last--;
-	zend_do_if_end(TSRMLS_C);
-	if (last_additional_catch->u.op.opline_num == -1) {
-		CG(active_op_array)->opcodes[first_catch->u.op.opline_num].result.num = 1;
-		CG(active_op_array)->opcodes[first_catch->u.op.opline_num].extended_value = get_next_op_number(CG(active_op_array));
+	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),
+			Z_STR(name_node->u.constant) TSRMLS_CC);
+		zend_alloc_cache_slot(opline->op2.constant TSRMLS_CC);
 	} else {
-		CG(active_op_array)->opcodes[last_additional_catch->u.op.opline_num].result.num = 1;
-		CG(active_op_array)->opcodes[last_additional_catch->u.op.opline_num].extended_value = get_next_op_number(CG(active_op_array));
+		SET_NODE(opline->op2, name_node);
 	}
-	DEC_BPC(CG(active_op_array));
+
+	zend_compile_call_common(result, args_ast, NULL TSRMLS_CC);
 }
 /* }}} */
 
-void zend_do_try(znode *try_token TSRMLS_DC) /* {{{ */
+static zend_bool zend_args_contain_unpack(zend_ast_list *args) /* {{{ */
 {
-	try_token->u.op.opline_num = zend_add_try_element(get_next_op_number(CG(active_op_array)) TSRMLS_CC);
-	INC_BPC(CG(active_op_array));
+	uint32_t i;
+	for (i = 0; i < args->children; ++i) {
+		if (args->child[i]->kind == ZEND_AST_UNPACK) {
+			return 1;
+		}
+	}
+	return 0;
 }
 /* }}} */
 
-void zend_do_finally(znode *finally_token TSRMLS_DC) /* {{{ */
+int zend_compile_func_strlen(znode *result, zend_ast_list *args TSRMLS_DC) /* {{{ */
 {
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	znode arg_node;
 
-	finally_token->u.op.opline_num = get_next_op_number(CG(active_op_array));
-	/* call the the "finally" block */
-	opline->opcode = ZEND_FAST_CALL;
-	SET_UNUSED(opline->op1);
-	opline->op1.opline_num = finally_token->u.op.opline_num + 1;
-	SET_UNUSED(opline->op2);
-	/* jump to code after the "finally" block,
-	 * the actual jump address is going to be set in zend_do_end_finally()
-	 */
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	opline->opcode = ZEND_JMP;
-	SET_UNUSED(opline->op1);
-	SET_UNUSED(opline->op2);
+	if ((CG(compiler_options) & ZEND_COMPILE_NO_BUILTIN_STRLEN)
+		|| args->children != 1 || args->child[0]->kind == ZEND_AST_UNPACK
+	) {
+		return FAILURE;
+	}
 
-	CG(context).in_finally++;
+	zend_compile_expr(&arg_node, args->child[0] TSRMLS_CC);
+	zend_emit_op_tmp(result, ZEND_STRLEN, &arg_node, NULL TSRMLS_CC);
+	return SUCCESS;
 }
 /* }}} */
 
-void zend_do_begin_catch(znode *catch_token, znode *class_name, znode *catch_var, znode *first_catch TSRMLS_DC) /* {{{ */
+int zend_compile_func_typecheck(znode *result, zend_ast_list *args, uint32_t type TSRMLS_DC) /* {{{ */
 {
-	long catch_op_number;
+	znode arg_node;
 	zend_op *opline;
-	znode catch_class;
-
-	if (class_name->op_type == IS_CONST &&
-	    ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant))) {
-		zend_resolve_class_name(class_name TSRMLS_CC);
-		catch_class = *class_name;
-	} else {
-		zend_error(E_COMPILE_ERROR, "Bad class name in the catch statement");
-	}
 
-	catch_op_number = get_next_op_number(CG(active_op_array));
-	if (first_catch) {
-		first_catch->u.op.opline_num = catch_op_number;
+	if (args->children != 1 || args->child[0]->kind == ZEND_AST_UNPACK) {
+		return FAILURE;
 	}
-
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	opline->opcode = ZEND_CATCH;
-	opline->op1_type = IS_CONST;
-	opline->op1.constant = zend_add_class_name_literal(CG(active_op_array), &catch_class.u.constant TSRMLS_CC);
-	opline->op2_type = IS_CV;
-	opline->op2.var = lookup_cv(CG(active_op_array), Z_STRVAL(catch_var->u.constant), Z_STRLEN(catch_var->u.constant), 0 TSRMLS_CC);
-	Z_STRVAL(catch_var->u.constant) = (char*)CG(active_op_array)->vars[opline->op2.var].name;
-	opline->result.num = 0; /* 1 means it's the last catch in the block */
-
-	catch_token->u.op.opline_num = catch_op_number;
+	
+	zend_compile_expr(&arg_node, args->child[0] TSRMLS_CC);
+	opline = zend_emit_op_tmp(result, ZEND_TYPE_CHECK, &arg_node, NULL TSRMLS_CC);
+	opline->extended_value = type;
+	return SUCCESS;
 }
 /* }}} */
 
-void zend_do_end_catch(znode *catch_token TSRMLS_DC) /* {{{ */
+int zend_compile_func_defined(znode *result, zend_ast_list *args TSRMLS_DC) /* {{{ */
 {
-	int jmp_op_number = get_next_op_number(CG(active_op_array));
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	zend_llist *jmp_list_ptr;
+	zend_string *name;
+	zend_op *opline;
 
-	opline->opcode = ZEND_JMP;
-	SET_UNUSED(opline->op1);
-	SET_UNUSED(opline->op2);
-	/* save for backpatching */
+	if (args->children != 1 || args->child[0]->kind != ZEND_AST_ZVAL) {
+		return FAILURE;
+	}
 
-	zend_stack_top(&CG(bp_stack), (void **) &jmp_list_ptr);
-	zend_llist_add_element(jmp_list_ptr, &jmp_op_number);
+	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;
+	}
 
-	CG(active_op_array)->opcodes[catch_token->u.op.opline_num].extended_value = get_next_op_number(CG(active_op_array));
-}
-/* }}} */
+	opline = zend_emit_op_tmp(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);
 
-void zend_do_bind_catch(znode *try_token, znode *catch_token TSRMLS_DC) /* {{{ */ {
-	if (catch_token->op_type != IS_UNUSED) {
-		zend_add_catch_element(try_token->u.op.opline_num, catch_token->EA TSRMLS_CC);
+	/* 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;
 }
 /* }}} */
 
-void zend_do_end_finally(znode *try_token, znode* catch_token, znode *finally_token TSRMLS_DC) /* {{{ */
+static int zend_try_compile_ct_bound_init_user_func(zend_ast *name_ast, uint32_t num_args TSRMLS_DC) /* {{{ */
 {
-	if (catch_token->op_type == IS_UNUSED && finally_token->op_type == IS_UNUSED) {
-		zend_error(E_COMPILE_ERROR, "Cannot use try without catch or finally");
+	zend_string *name, *lcname;
+	zend_function *fbc;
+	zend_op *opline;
+
+	if (name_ast->kind != ZEND_AST_ZVAL || Z_TYPE_P(zend_ast_get_zval(name_ast)) != IS_STRING) {
+		return FAILURE;
 	}
-	if (finally_token->op_type != IS_UNUSED) {
-		zend_op *opline;
 
-		CG(active_op_array)->try_catch_array[try_token->u.op.opline_num].finally_op = finally_token->u.op.opline_num + 1;
-		CG(active_op_array)->try_catch_array[try_token->u.op.opline_num].finally_end = get_next_op_number(CG(active_op_array));
-		CG(active_op_array)->has_finally_block = 1;
+	name = zend_ast_get_str(name_ast);
+	lcname = zend_string_alloc(name->len, 0);
+	zend_str_tolower_copy(lcname->val, name->val, name->len);
 
-		opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-		opline->opcode = ZEND_FAST_RET;
-		SET_UNUSED(opline->op1);
-		SET_UNUSED(opline->op2);
+	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;
+	}
 
-		CG(active_op_array)->opcodes[finally_token->u.op.opline_num].op1.opline_num = get_next_op_number(CG(active_op_array));
+	opline = zend_emit_op(NULL, ZEND_INIT_FCALL, NULL, NULL TSRMLS_CC);
+	opline->extended_value = num_args;
 
-		CG(context).in_finally--;
-	}
+	opline->op2_type = IS_CONST;
+	LITERAL_STR(opline->op2, lcname);
+	zend_alloc_cache_slot(opline->op2.constant TSRMLS_CC);
+
+	return SUCCESS;
 }
 /* }}} */
 
-void zend_do_throw(const znode *expr TSRMLS_DC) /* {{{ */
+static void zend_compile_init_user_func(zend_ast *name_ast, uint32_t num_args, zend_string *orig_func_name TSRMLS_DC) /* {{{ */
 {
 	zend_op *opline;
+	znode name_node;
 
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	opline->opcode = ZEND_THROW;
-	SET_NODE(opline->op1, expr);
-	SET_UNUSED(opline->op2);
+	if (zend_try_compile_ct_bound_init_user_func(name_ast, num_args TSRMLS_CC) == SUCCESS) {
+		return;
+	}
+
+	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;
 }
 /* }}} */
 
-ZEND_API void function_add_ref(zend_function *function) /* {{{ */
+/* cufa = call_user_func_array */
+int zend_compile_func_cufa(znode *result, zend_ast_list *args, zend_string *lcname TSRMLS_DC) /* {{{ */
 {
-	if (function->type == ZEND_USER_FUNCTION) {
-		zend_op_array *op_array = &function->op_array;
+	znode arg_node;
 
-		(*op_array->refcount)++;
-		if (op_array->static_variables) {
-			HashTable *static_variables = op_array->static_variables;
-			zval *tmp_zval;
-
-			ALLOC_HASHTABLE(op_array->static_variables);
-			zend_hash_init(op_array->static_variables, zend_hash_num_elements(static_variables), NULL, ZVAL_PTR_DTOR, 0);
-			zend_hash_copy(op_array->static_variables, static_variables, (copy_ctor_func_t) zval_add_ref, (void *) &tmp_zval, sizeof(zval *));
-		}
-		op_array->run_time_cache = NULL;
+	if (args->children != 2 || zend_args_contain_unpack(args)) {
+		return FAILURE;
 	}
+
+	zend_compile_init_user_func(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 do_inherit_parent_constructor(zend_class_entry *ce) /* {{{ */
+/* cuf = call_user_func */
+int zend_compile_func_cuf(znode *result, zend_ast_list *args, zend_string *lcname TSRMLS_DC) /* {{{ */
 {
-	zend_function *function, *new_function;
+	uint32_t i;
 
-	if (!ce->parent) {
-		return;
+	if (args->children < 1 || zend_args_contain_unpack(args)) {
+		return FAILURE;
 	}
 
-	/* You cannot change create_object */
-	ce->create_object = ce->parent->create_object;
+	zend_compile_init_user_func(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;
 
-	/* Inherit special functions if needed */
-	if (!ce->get_iterator) {
-		ce->get_iterator = ce->parent->get_iterator;
-	}
-	if (!ce->iterator_funcs.funcs) {
-		ce->iterator_funcs.funcs = ce->parent->iterator_funcs.funcs;
-	}
-	if (!ce->__get) {
-		ce->__get   = ce->parent->__get;
-	}
-	if (!ce->__set) {
-		ce->__set = ce->parent->__set;
-	}
-	if (!ce->__unset) {
-		ce->__unset = ce->parent->__unset;
-	}
-	if (!ce->__isset) {
-		ce->__isset = ce->parent->__isset;
-	}
-	if (!ce->__call) {
-		ce->__call = ce->parent->__call;
-	}
-	if (!ce->__callstatic) {
-		ce->__callstatic = ce->parent->__callstatic;
-	}
-	if (!ce->__tostring) {
-		ce->__tostring = ce->parent->__tostring;
-	}
-	if (!ce->clone) {
-		ce->clone = ce->parent->clone;
-	}
-	if(!ce->serialize) {
-		ce->serialize = ce->parent->serialize;
-	}
-	if(!ce->unserialize) {
-		ce->unserialize = ce->parent->unserialize;
-	}
-	if (!ce->destructor) {
-		ce->destructor   = ce->parent->destructor;
-	}
-	if (ce->constructor) {
-		if (ce->parent->constructor && ce->parent->constructor->common.fn_flags & ZEND_ACC_FINAL) {
-			zend_error(E_ERROR, "Cannot override final %s::%s() with %s::%s()",
-				ce->parent->name, ce->parent->constructor->common.function_name,
-				ce->name, ce->constructor->common.function_name
-				);
+		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;
+			}
 		}
-		return;
-	}
 
-	if (zend_hash_find(&ce->parent->function_table, ZEND_CONSTRUCTOR_FUNC_NAME, sizeof(ZEND_CONSTRUCTOR_FUNC_NAME), (void **)&function)==SUCCESS) {
-		/* inherit parent's constructor */
-		zend_hash_update(&ce->function_table, ZEND_CONSTRUCTOR_FUNC_NAME, sizeof(ZEND_CONSTRUCTOR_FUNC_NAME), function, sizeof(zend_function), (void**)&new_function);
-		function_add_ref(new_function);
-	} else {
-		/* Don't inherit the old style constructor if we already have the new style constructor */
-		char *lc_class_name;
-		char *lc_parent_class_name;
-
-		lc_class_name = zend_str_tolower_dup(ce->name, ce->name_length);
-		if (!zend_hash_exists(&ce->function_table, lc_class_name, ce->name_length+1)) {
-			lc_parent_class_name = zend_str_tolower_dup(ce->parent->name, ce->parent->name_length);
-			if (!zend_hash_exists(&ce->function_table, lc_parent_class_name, ce->parent->name_length+1) &&
-					zend_hash_find(&ce->parent->function_table, lc_parent_class_name, ce->parent->name_length+1, (void **)&function)==SUCCESS) {
-				if (function->common.fn_flags & ZEND_ACC_CTOR) {
-					/* inherit parent's constructor */
-					zend_hash_update(&ce->function_table, lc_parent_class_name, ce->parent->name_length+1, function, sizeof(zend_function), (void**)&new_function);
-					function_add_ref(new_function);
-				}
-			}
-			efree(lc_parent_class_name);
+		if (send_user) {
+			opline = zend_emit_op(NULL, ZEND_SEND_USER, &arg_node, NULL TSRMLS_CC);
+		} else {
+			opline = zend_emit_op(NULL, ZEND_SEND_VAL, &arg_node, NULL TSRMLS_CC);
 		}
-		efree(lc_class_name);
-	}
-	ce->constructor = ce->parent->constructor;
-}
-/* }}} */
 
-char *zend_visibility_string(zend_uint fn_flags) /* {{{ */
-{
-	if (fn_flags & ZEND_ACC_PRIVATE) {
-		return "private";
+		opline->op2.opline_num = i;
 	}
-	if (fn_flags & ZEND_ACC_PROTECTED) {
-		return "protected";
-	}
-	if (fn_flags & ZEND_ACC_PUBLIC) {
-		return "public";
-	}
-	return "";
+	zend_emit_op(result, ZEND_DO_FCALL, NULL, NULL TSRMLS_CC);
+
+	return SUCCESS;
 }
 /* }}} */
 
-static void do_inherit_method(zend_function *function) /* {{{ */
-{
-	/* The class entry of the derived function intentionally remains the same
-	 * as that of the parent class.  That allows us to know in which context
-	 * we're running, and handle private method calls properly.
-	 */
-	function_add_ref(function);
+int zend_try_compile_special_func(znode *result, zend_string *lcname, zend_ast_list *args TSRMLS_DC) /* {{{ */
+{
+	if (zend_string_equals_literal(lcname, "strlen")) {
+		return zend_compile_func_strlen(result, args TSRMLS_CC);
+	} else if (zend_string_equals_literal(lcname, "is_null")) {
+		return zend_compile_func_typecheck(result, args, IS_NULL TSRMLS_CC);
+	} else if (zend_string_equals_literal(lcname, "is_bool")) {
+		return zend_compile_func_typecheck(result, args, _IS_BOOL TSRMLS_CC);
+	} else if (zend_string_equals_literal(lcname, "is_long")
+		|| zend_string_equals_literal(lcname, "is_int")
+		|| zend_string_equals_literal(lcname, "is_integer")
+	) {
+		return zend_compile_func_typecheck(result, args, IS_LONG TSRMLS_CC);
+	} else if (zend_string_equals_literal(lcname, "is_float")
+		|| zend_string_equals_literal(lcname, "is_double")
+		|| zend_string_equals_literal(lcname, "is_real")
+	) {
+		return zend_compile_func_typecheck(result, args, IS_DOUBLE TSRMLS_CC);
+	} else if (zend_string_equals_literal(lcname, "is_string")) {
+		return zend_compile_func_typecheck(result, args, IS_STRING TSRMLS_CC);
+	} else if (zend_string_equals_literal(lcname, "is_array")) {
+		return zend_compile_func_typecheck(result, args, IS_ARRAY TSRMLS_CC);
+	} else if (zend_string_equals_literal(lcname, "is_object")) {
+		return zend_compile_func_typecheck(result, args, IS_OBJECT TSRMLS_CC);
+	} else if (zend_string_equals_literal(lcname, "is_resource")) {
+		return zend_compile_func_typecheck(result, args, IS_RESOURCE TSRMLS_CC);
+	} else if (zend_string_equals_literal(lcname, "defined")) {
+		return zend_compile_func_defined(result, args TSRMLS_CC);
+	} else if (zend_string_equals_literal(lcname, "call_user_func_array")) {
+		return zend_compile_func_cufa(result, args, lcname TSRMLS_CC);
+	} else if (zend_string_equals_literal(lcname, "call_user_func")) {
+		return zend_compile_func_cuf(result, args, lcname TSRMLS_CC);
+	} else {
+		return FAILURE;
+	}
 }
 /* }}} */
 
-static zend_bool zend_do_perform_implementation_check(const zend_function *fe, const zend_function *proto TSRMLS_DC) /* {{{ */
+void zend_compile_call(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC) /* {{{ */
 {
-	zend_uint i, num_args;
-
-	/* If it's a user function then arg_info == NULL means we don't have any parameters but
-	 * we still need to do the arg number checks.  We are only willing to ignore this for internal
-	 * functions because extensions don't always define arg_info.
-	 */
-	if (!proto || (!proto->common.arg_info && proto->common.type != ZEND_USER_FUNCTION)) {
-		return 1;
-	}
-
-	/* Checks for constructors only if they are declared in an interface,
-	 * or explicitly marked as abstract
-	 */
-	if ((fe->common.fn_flags & ZEND_ACC_CTOR)
-		&& ((proto->common.scope->ce_flags & ZEND_ACC_INTERFACE) == 0
-			&& (proto->common.fn_flags & ZEND_ACC_ABSTRACT) == 0)) {
-		return 1;
-	}
-
-	/* If both methods are private do not enforce a signature */
-    if ((fe->common.fn_flags & ZEND_ACC_PRIVATE) && (proto->common.fn_flags & ZEND_ACC_PRIVATE)) {
-		return 1;
-	}
+	zend_ast *name_ast = ast->child[0];
+	zend_ast *args_ast = ast->child[1];
 
-	/* check number of arguments */
-	if (proto->common.required_num_args < fe->common.required_num_args
-		|| proto->common.num_args > fe->common.num_args) {
-		return 0;
-	}
+	znode name_node;
 
-	/* by-ref constraints on return values are covariant */
-	if ((proto->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)
-		&& !(fe->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
-		return 0;
+	if (name_ast->kind != ZEND_AST_ZVAL || Z_TYPE_P(zend_ast_get_zval(name_ast)) != IS_STRING) {
+		zend_compile_expr(&name_node, name_ast TSRMLS_CC);
+		zend_compile_dynamic_call(result, &name_node, args_ast TSRMLS_CC);
+		return;
 	}
 
-	if ((proto->common.fn_flags & ZEND_ACC_VARIADIC)
-		&& !(fe->common.fn_flags & ZEND_ACC_VARIADIC)) {
-		return 0;
+	{
+		zend_bool runtime_resolution = zend_compile_function_name(&name_node, name_ast TSRMLS_CC);
+		if (runtime_resolution) {
+			zend_compile_ns_call(result, &name_node, args_ast TSRMLS_CC);
+			return;
+		}
 	}
 
-	/* For variadic functions any additional (optional) arguments that were added must be
-	 * checked against the signature of the variadic argument, so in this case we have to
-	 * go through all the parameters of the function and not just those present in the
-	 * prototype. */
-	num_args = proto->common.num_args;
-	if ((fe->common.fn_flags & ZEND_ACC_VARIADIC)
-		&& fe->common.num_args > proto->common.num_args) {
-		num_args = fe->common.num_args;
-	}
+	{
+		zval *name = &name_node.u.constant;
+		zend_string *lcname = zend_string_alloc(Z_STRLEN_P(name), 0);
+		zend_function *fbc;
+		zend_op *opline;
 
-	for (i = 0; i < num_args; i++) {
-		zend_arg_info *fe_arg_info = &fe->common.arg_info[i];
+		zend_str_tolower_copy(lcname->val, Z_STRVAL_P(name), Z_STRLEN_P(name));
 
-		zend_arg_info *proto_arg_info;
-		if (i < proto->common.num_args) {
-			proto_arg_info = &proto->common.arg_info[i];
-		} else {
-			proto_arg_info = &proto->common.arg_info[proto->common.num_args-1];
+		fbc = zend_hash_find_ptr(CG(function_table), lcname);
+		if (!fbc || (fbc->type == ZEND_INTERNAL_FUNCTION &&
+			(CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_FUNCTIONS))
+		) {
+			zend_string_release(lcname);
+			zend_compile_dynamic_call(result, &name_node, args_ast TSRMLS_CC);
+			return;
 		}
 
-		if (ZEND_LOG_XOR(fe_arg_info->class_name, proto_arg_info->class_name)) {
-			/* Only one has a type hint and the other one doesn't */
-			return 0;
+		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 (fe_arg_info->class_name) {
-			const char *fe_class_name, *proto_class_name;
-			zend_uint fe_class_name_len, proto_class_name_len;
+		zval_ptr_dtor(&name_node.u.constant);
+		ZVAL_NEW_STR(&name_node.u.constant, lcname);
 
-			if (!strcasecmp(fe_arg_info->class_name, "parent") && proto->common.scope) {
-				fe_class_name = proto->common.scope->name;
-				fe_class_name_len = proto->common.scope->name_length;
-			} else if (!strcasecmp(fe_arg_info->class_name, "self") && fe->common.scope) {
-				fe_class_name = fe->common.scope->name;
-				fe_class_name_len = fe->common.scope->name_length;
-			} else {
-				fe_class_name = fe_arg_info->class_name;
-				fe_class_name_len = fe_arg_info->class_name_len;
-			}
+		opline = zend_emit_op(NULL, ZEND_INIT_FCALL, NULL, &name_node TSRMLS_CC);
+		zend_alloc_cache_slot(opline->op2.constant TSRMLS_CC);
 
-			if (!strcasecmp(proto_arg_info->class_name, "parent") && proto->common.scope && proto->common.scope->parent) {
-				proto_class_name = proto->common.scope->parent->name;
-				proto_class_name_len = proto->common.scope->parent->name_length;
-			} else if (!strcasecmp(proto_arg_info->class_name, "self") && proto->common.scope) {
-				proto_class_name = proto->common.scope->name;
-				proto_class_name_len = proto->common.scope->name_length;
-			} else {
-				proto_class_name = proto_arg_info->class_name;
-				proto_class_name_len = proto_arg_info->class_name_len;
-			}
+		zend_compile_call_common(result, args_ast, fbc TSRMLS_CC);
+	}
+}
+/* }}} */
 
-			if (strcasecmp(fe_class_name, proto_class_name)!=0) {
-				const char *colon;
+void zend_compile_method_call(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC) /* {{{ */
+{
+	zend_ast *obj_ast = ast->child[0];
+	zend_ast *method_ast = ast->child[1];
+	zend_ast *args_ast = ast->child[2];
 
-				if (fe->common.type != ZEND_USER_FUNCTION) {
-					return 0;
-			    } else if (strchr(proto_class_name, '\\') != NULL ||
-						(colon = zend_memrchr(fe_class_name, '\\', fe_class_name_len)) == NULL ||
-						strcasecmp(colon+1, proto_class_name) != 0) {
-					zend_class_entry **fe_ce, **proto_ce;
-					int found, found2;
-
-					found = zend_lookup_class(fe_class_name, fe_class_name_len, &fe_ce TSRMLS_CC);
-					found2 = zend_lookup_class(proto_class_name, proto_class_name_len, &proto_ce TSRMLS_CC);
-
-					/* Check for class alias */
-					if (found != SUCCESS || found2 != SUCCESS ||
-							(*fe_ce)->type == ZEND_INTERNAL_CLASS ||
-							(*proto_ce)->type == ZEND_INTERNAL_CLASS ||
-							*fe_ce != *proto_ce) {
-						return 0;
-					}
-				}
-			}
-		}
-		if (fe_arg_info->type_hint != proto_arg_info->type_hint) {
-			/* Incompatible type hint */
-			return 0;
-		}
+	znode obj_node, method_node;
+	zend_op *opline;
 
-		/* by-ref constraints on arguments are invariant */
-		if (fe_arg_info->pass_by_reference != proto_arg_info->pass_by_reference) {
-			return 0;
+	if (is_this_fetch(obj_ast)) {
+		obj_node.op_type = IS_UNUSED;
+	} else {
+		zend_compile_expr(&obj_node, obj_ast TSRMLS_CC);
+	}
+
+	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");
 		}
+
+		opline->op2_type = IS_CONST;
+		opline->op2.constant = zend_add_func_name_literal(CG(active_op_array),
+			Z_STR(method_node.u.constant) TSRMLS_CC);
+		zend_alloc_polymorphic_cache_slot(opline->op2.constant TSRMLS_CC);
+	} else {
+		SET_NODE(opline->op2, &method_node);
 	}
 
-	return 1;
+	zend_compile_call_common(result, args_ast, NULL TSRMLS_CC);
 }
 /* }}} */
 
-#define REALLOC_BUF_IF_EXCEED(buf, offset, length, size) \
-	if (UNEXPECTED(offset - buf + size >= length)) { 	\
-		length += size + 1; 				\
-		buf = erealloc(buf, length); 		\
-	}
+zend_bool zend_is_constructor(zend_string *name) /* {{{ */
+{
+	return zend_string_equals_literal_ci(name, ZEND_CONSTRUCTOR_FUNC_NAME);
+}
+/* }}} */
 
-static char * zend_get_function_declaration(zend_function *fptr TSRMLS_DC) /* {{{ */
+void zend_compile_static_call(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC) /* {{{ */
 {
-	char *offset, *buf;
-	zend_uint length = 1024;
+	zend_ast *class_ast = ast->child[0];
+	zend_ast *method_ast = ast->child[1];
+	zend_ast *args_ast = ast->child[2];
 
-	offset = buf = (char *)emalloc(length * sizeof(char));
-	if (fptr->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE) {
-		*(offset++) = '&';
-		*(offset++) = ' ';
-	}
+	znode class_node, method_node;
+	zend_op *opline;
+	zend_ulong extended_value = 0;
 
-	if (fptr->common.scope) {
-		memcpy(offset, fptr->common.scope->name, fptr->common.scope->name_length);
-		offset += fptr->common.scope->name_length;
-		*(offset++) = ':';
-		*(offset++) = ':';
+	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;
 	}
 
-	{
-		size_t name_len = strlen(fptr->common.function_name);
-		REALLOC_BUF_IF_EXCEED(buf, offset, length, name_len);
-		memcpy(offset, fptr->common.function_name, name_len);
-		offset += name_len;
-	}
-
-	*(offset++) = '(';
-	if (fptr->common.arg_info) {
-		zend_uint i, required;
-		zend_arg_info *arg_info = fptr->common.arg_info;
-
-		required = fptr->common.required_num_args;
-		for (i = 0; i < fptr->common.num_args;) {
-			if (arg_info->class_name) {
-				const char *class_name;
-				zend_uint class_name_len;
-				if (!strcasecmp(arg_info->class_name, "self") && fptr->common.scope ) {
-					class_name = fptr->common.scope->name;
-					class_name_len = fptr->common.scope->name_length;
-				} else if (!strcasecmp(arg_info->class_name, "parent") && fptr->common.scope->parent) {
-					class_name = fptr->common.scope->parent->name;
-					class_name_len = fptr->common.scope->parent->name_length;
-				} else {
-					class_name = arg_info->class_name;
-					class_name_len = arg_info->class_name_len;
-				}
-				REALLOC_BUF_IF_EXCEED(buf, offset, length, class_name_len);
-				memcpy(offset, class_name, class_name_len);
-				offset += class_name_len;
-				*(offset++) = ' ';
-			} else if (arg_info->type_hint) {
-				zend_uint type_name_len;
-				char *type_name = zend_get_type_by_const(arg_info->type_hint);
-				type_name_len = strlen(type_name);
-				REALLOC_BUF_IF_EXCEED(buf, offset, length, type_name_len);
-				memcpy(offset, type_name, type_name_len);
-				offset += type_name_len;
-				*(offset++) = ' ';
-			}
-
-			if (arg_info->pass_by_reference) {
-				*(offset++) = '&';
-			}
+	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;
+		}
+	}
 
-			if (arg_info->is_variadic) {
-				*(offset++) = '.';
-				*(offset++) = '.';
-				*(offset++) = '.';
-			}
+	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	opline->opcode = ZEND_INIT_STATIC_METHOD_CALL;
+	opline->extended_value = extended_value;
 
-			*(offset++) = '$';
+	zend_set_class_name_op1(opline, &class_node TSRMLS_CC);
 
-			if (arg_info->name) {
-				REALLOC_BUF_IF_EXCEED(buf, offset, length, arg_info->name_len);
-				memcpy(offset, arg_info->name, arg_info->name_len);
-				offset += arg_info->name_len;
-			} else {
-				zend_uint idx = i;
-				memcpy(offset, "param", 5);
-				offset += 5;
-				do {
-					*(offset++) = (char) (idx % 10) + '0';
-					idx /= 10;
-				} while (idx > 0);
-			}
-			if (i >= required && !arg_info->is_variadic) {
-				*(offset++) = ' ';
-				*(offset++) = '=';
-				*(offset++) = ' ';
-				if (fptr->type == ZEND_USER_FUNCTION) {
-					zend_op *precv = NULL;
-					{
-						zend_uint idx  = i;
-						zend_op *op = ((zend_op_array *)fptr)->opcodes;
-						zend_op *end = op + ((zend_op_array *)fptr)->last;
-
-						++idx;
-						while (op < end) {
-							if ((op->opcode == ZEND_RECV || op->opcode == ZEND_RECV_INIT)
-									&& op->op1.num == (long)idx)
-							{
-								precv = op;
-							}
-							++op;
-						}
-					}
-					if (precv && precv->opcode == ZEND_RECV_INIT && precv->op2_type != IS_UNUSED) {
-						zval *zv, zv_copy;
-						int use_copy;
-						ALLOC_ZVAL(zv);
-						*zv = *precv->op2.zv;
-						zval_copy_ctor(zv);
-						INIT_PZVAL(zv);
-						zval_update_constant_ex(&zv, (void*)1, fptr->common.scope TSRMLS_CC);
-						if (Z_TYPE_P(zv) == IS_BOOL) {
-							if (Z_LVAL_P(zv)) {
-								memcpy(offset, "true", 4);
-								offset += 4;
-							} else {
-								memcpy(offset, "false", 5);
-								offset += 5;
-							}
-						} else if (Z_TYPE_P(zv) == IS_NULL) {
-							memcpy(offset, "NULL", 4);
-							offset += 4;
-						} else if (Z_TYPE_P(zv) == IS_STRING) {
-							*(offset++) = '\'';
-							REALLOC_BUF_IF_EXCEED(buf, offset, length, MIN(Z_STRLEN_P(zv), 10));
-							memcpy(offset, Z_STRVAL_P(zv), MIN(Z_STRLEN_P(zv), 10));
-							offset += MIN(Z_STRLEN_P(zv), 10);
-							if (Z_STRLEN_P(zv) > 10) {
-								*(offset++) = '.';
-								*(offset++) = '.';
-								*(offset++) = '.';
-							}
-							*(offset++) = '\'';
-						} else if (Z_TYPE_P(zv) == IS_ARRAY) {
-							memcpy(offset, "Array", 5);
-							offset += 5;
-						} else {
-							zend_make_printable_zval(zv, &zv_copy, &use_copy);
-							REALLOC_BUF_IF_EXCEED(buf, offset, length, Z_STRLEN(zv_copy));
-							memcpy(offset, Z_STRVAL(zv_copy), Z_STRLEN(zv_copy));
-							offset += Z_STRLEN(zv_copy);
-							if (use_copy) {
-								zval_dtor(&zv_copy);
-							}
-						}
-						zval_ptr_dtor(&zv);
-					}
-				} else {
-					memcpy(offset, "NULL", 4);
-					offset += 4;
-				}
-			}
-
-			if (++i < fptr->common.num_args) {
-				*(offset++) = ',';
-				*(offset++) = ' ';
-			}
-			arg_info++;
-			REALLOC_BUF_IF_EXCEED(buf, offset, length, 32);
+	if (method_node.op_type == IS_CONST) {
+		opline->op2_type = IS_CONST;
+		opline->op2.constant = zend_add_func_name_literal(CG(active_op_array),
+			Z_STR(method_node.u.constant) TSRMLS_CC);
+		if (opline->op1_type == IS_CONST) {
+			zend_alloc_cache_slot(opline->op2.constant TSRMLS_CC);
+		} else {
+			zend_alloc_polymorphic_cache_slot(opline->op2.constant TSRMLS_CC);
 		}
+	} else {
+		SET_NODE(opline->op2, &method_node);
 	}
-	*(offset++) = ')';
-	*offset = '\0';
 
-	return buf;
+	zend_compile_call_common(result, args_ast, NULL TSRMLS_CC);
 }
 /* }}} */
 
-static void do_inheritance_check_on_method(zend_function *child, zend_function *parent TSRMLS_DC) /* {{{ */
+void zend_compile_new(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	zend_uint child_flags;
-	zend_uint parent_flags = parent->common.fn_flags;
+	zend_ast *class_ast = ast->child[0];
+	zend_ast *args_ast = ast->child[1];
 
-	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(E_COMPILE_ERROR, "Can't inherit abstract function %s::%s() (previously declared abstract in %s)",
-			parent->common.scope->name,
-			child->common.function_name,
-			child->common.prototype ? child->common.prototype->common.scope->name : child->common.scope->name);
-	}
+	znode class_node, ctor_result;
+	zend_op *opline;
+	uint32_t opnum;
 
-	if (parent_flags & ZEND_ACC_FINAL) {
-		zend_error(E_COMPILE_ERROR, "Cannot override final method %s::%s()", ZEND_FN_SCOPE_NAME(parent), child->common.function_name);
-	}
+	zend_compile_class_ref(&class_node, class_ast TSRMLS_CC);
 
-	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(E_COMPILE_ERROR, "Cannot make non static method %s::%s() static in class %s", ZEND_FN_SCOPE_NAME(parent), child->common.function_name, ZEND_FN_SCOPE_NAME(child));
-		} else {
-			zend_error(E_COMPILE_ERROR, "Cannot make static method %s::%s() non static in class %s", ZEND_FN_SCOPE_NAME(parent), child->common.function_name, ZEND_FN_SCOPE_NAME(child));
-		}
-	}
+	opnum = get_next_op_number(CG(active_op_array));
+	zend_emit_op(result, ZEND_NEW, &class_node, NULL TSRMLS_CC);
 
-	/* Disallow making an inherited method abstract. */
-	if ((child_flags & ZEND_ACC_ABSTRACT) && !(parent_flags & ZEND_ACC_ABSTRACT)) {
-		zend_error(E_COMPILE_ERROR, "Cannot make non abstract method %s::%s() abstract in class %s", ZEND_FN_SCOPE_NAME(parent), child->common.function_name, ZEND_FN_SCOPE_NAME(child));
-	}
+	zend_compile_call_common(&ctor_result, args_ast, NULL TSRMLS_CC);
+	zend_do_free(&ctor_result TSRMLS_CC);
 
-	if (parent_flags & ZEND_ACC_CHANGED) {
-		child->common.fn_flags |= ZEND_ACC_CHANGED;
-	} else {
-		/* Prevent derived classes from restricting access that was available in parent classes
-		 */
-		if ((child_flags & ZEND_ACC_PPP_MASK) > (parent_flags & ZEND_ACC_PPP_MASK)) {
-			zend_error(E_COMPILE_ERROR, "Access level to %s::%s() must be %s (as in class %s)%s", ZEND_FN_SCOPE_NAME(child), child->common.function_name, zend_visibility_string(parent_flags), ZEND_FN_SCOPE_NAME(parent), (parent_flags&ZEND_ACC_PUBLIC) ? "" : " or weaker");
-		} else if (((child_flags & ZEND_ACC_PPP_MASK) < (parent_flags & ZEND_ACC_PPP_MASK))
-			&& ((parent_flags & ZEND_ACC_PPP_MASK) & ZEND_ACC_PRIVATE)) {
-			child->common.fn_flags |= ZEND_ACC_CHANGED;
-		}
-	}
+	/* New jumps over ctor call if ctor does not exist */
+	opline = &CG(active_op_array)->opcodes[opnum];
+	opline->op2.opline_num = get_next_op_number(CG(active_op_array));
+}
+/* }}} */
 
-	if (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;
-	}
+void zend_compile_clone(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
+{
+	zend_ast *obj_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(E_COMPILE_ERROR, "Declaration of %s::%s() must be compatible with %s", ZEND_FN_SCOPE_NAME(child), child->common.function_name, zend_get_function_declaration(child->common.prototype TSRMLS_CC));
-		}
-	} else if (EG(error_reporting) & E_STRICT || EG(user_error_handler)) { /* Check E_STRICT (or custom error handler) before the check so that we save some time */
-		if (!zend_do_perform_implementation_check(child, parent TSRMLS_CC)) {
-			char *method_prototype = zend_get_function_declaration(parent TSRMLS_CC);
-			zend_error(E_STRICT, "Declaration of %s::%s() should be compatible with %s", ZEND_FN_SCOPE_NAME(child), child->common.function_name, method_prototype);
-			efree(method_prototype);
-		}
-	}
+	znode obj_node;
+	zend_compile_expr(&obj_node, obj_ast TSRMLS_CC);
+
+	zend_emit_op(result, ZEND_CLONE, &obj_node, NULL TSRMLS_CC);
 }
 /* }}} */
 
-static zend_bool do_inherit_method_check(HashTable *child_function_table, zend_function *parent, const zend_hash_key *hash_key, zend_class_entry *child_ce) /* {{{ */
+void zend_compile_global_var(zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	zend_uint parent_flags = parent->common.fn_flags;
-	zend_function *child;
-	TSRMLS_FETCH();
+	zend_ast *var_ast = ast->child[0];
+	zend_ast *name_ast = var_ast->child[0];
+
+	znode name_node, result;
 
-	if (zend_hash_quick_find(child_function_table, hash_key->arKey, hash_key->nKeyLength, hash_key->h, (void **) &child)==FAILURE) {
-		if (parent_flags & (ZEND_ACC_ABSTRACT)) {
-			child_ce->ce_flags |= ZEND_ACC_IMPLICIT_ABSTRACT_CLASS;
+	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);
 		}
-		return 1; /* method doesn't exist in child, copy from parent */
 	}
 
-	do_inheritance_check_on_method(child, parent TSRMLS_CC);
+	if (zend_try_compile_cv(&result, var_ast TSRMLS_CC) == SUCCESS) {
+		zend_op *opline = zend_emit_op(NULL, ZEND_BIND_GLOBAL, &result, &name_node TSRMLS_CC);
+		zend_alloc_cache_slot(opline->op2.constant TSRMLS_CC);
+	} else {
+		zend_emit_op(&result, ZEND_FETCH_W, &name_node, NULL TSRMLS_CC);
 
-	return 0;
+		// TODO.AST Avoid double fetch
+		//opline->extended_value = ZEND_FETCH_GLOBAL_LOCK;
+
+		zend_emit_assign_ref_znode(var_ast, &result TSRMLS_CC);
+	}
 }
 /* }}} */
 
-static zend_bool do_inherit_property_access_check(HashTable *target_ht, zend_property_info *parent_info, const zend_hash_key *hash_key, zend_class_entry *ce) /* {{{ */
+static void zend_compile_static_var_common(zend_ast *var_ast, zval *value, zend_bool by_ref TSRMLS_DC) /* {{{ */
 {
-	zend_property_info *child_info;
-	zend_class_entry *parent_ce = ce->parent;
+	znode var_node, result;
+	zend_op *opline;
 
-	if (parent_info->flags & (ZEND_ACC_PRIVATE|ZEND_ACC_SHADOW)) {
-		if (zend_hash_quick_find(&ce->properties_info, hash_key->arKey, hash_key->nKeyLength, hash_key->h, (void **) &child_info)==SUCCESS) {
-			child_info->flags |= ZEND_ACC_CHANGED;
-		} else {
-			zend_hash_quick_update(&ce->properties_info, hash_key->arKey, hash_key->nKeyLength, hash_key->h, parent_info, sizeof(zend_property_info), (void **) &child_info);
-			if(ce->type & ZEND_INTERNAL_CLASS) {
-				zend_duplicate_property_info_internal(child_info);
-			} else {
-				zend_duplicate_property_info(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 */
+	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;
 		}
-		return 0; /* don't copy access information to child */
+		ALLOC_HASHTABLE(CG(active_op_array)->static_variables);
+		zend_hash_init(CG(active_op_array)->static_variables, 8, NULL, ZVAL_PTR_DTOR, 0);
 	}
 
-	if (zend_hash_quick_find(&ce->properties_info, hash_key->arKey, hash_key->nKeyLength, hash_key->h, (void **) &child_info)==SUCCESS) {
-		if ((parent_info->flags & ZEND_ACC_STATIC) != (child_info->flags & ZEND_ACC_STATIC)) {
-			zend_error(E_COMPILE_ERROR, "Cannot redeclare %s%s::$%s as %s%s::$%s",
-				(parent_info->flags & ZEND_ACC_STATIC) ? "static " : "non static ", parent_ce->name, hash_key->arKey,
-				(child_info->flags & ZEND_ACC_STATIC) ? "static " : "non static ", ce->name, hash_key->arKey);
+	zend_hash_update(CG(active_op_array)->static_variables, Z_STR(var_node.u.constant), value);
 
-		}
-
-		if(parent_info->flags & ZEND_ACC_CHANGED) {
-			child_info->flags |= ZEND_ACC_CHANGED;
-		}
+	opline = zend_emit_op(&result, by_ref ? ZEND_FETCH_W : ZEND_FETCH_R, &var_node, NULL TSRMLS_CC);
+	opline->extended_value = ZEND_FETCH_STATIC;
 
-		if ((child_info->flags & ZEND_ACC_PPP_MASK) > (parent_info->flags & ZEND_ACC_PPP_MASK)) {
-			zend_error(E_COMPILE_ERROR, "Access level to %s::$%s must be %s (as in class %s)%s", ce->name, hash_key->arKey, zend_visibility_string(parent_info->flags), parent_ce->name, (parent_info->flags&ZEND_ACC_PUBLIC) ? "" : " or weaker");
-		} else if ((child_info->flags & ZEND_ACC_STATIC) == 0) {
-			zval_ptr_dtor(&(ce->default_properties_table[parent_info->offset]));
-			ce->default_properties_table[parent_info->offset] = ce->default_properties_table[child_info->offset];
-			ce->default_properties_table[child_info->offset] = NULL;
-			child_info->offset = parent_info->offset;
-		}
-		return 0;	/* Don't copy from parent */
+	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 {
-		return 1;	/* Copy from parent */
+		zend_ast *fetch_ast = zend_ast_create(ZEND_AST_VAR, var_ast);
+		zend_emit_assign_znode(fetch_ast, &result TSRMLS_CC);
 	}
 }
 /* }}} */
 
-static inline void do_implement_interface(zend_class_entry *ce, zend_class_entry *iface TSRMLS_DC) /* {{{ */
+void zend_compile_static_var(zend_ast *ast 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, iface->name);
-	}
-	if (ce == iface) {
-		zend_error(E_ERROR, "Interface %s cannot implement itself", ce->name);
+	zend_ast *var_ast = ast->child[0];
+	zend_ast *value_ast = ast->child[1];
+	zval value_zv;
+
+	if (value_ast) {
+		zend_const_expr_to_zval(&value_zv, value_ast TSRMLS_CC);
+	} else {
+		ZVAL_NULL(&value_zv);
 	}
+
+	zend_compile_static_var_common(var_ast, &value_zv, 1 TSRMLS_CC);
 }
 /* }}} */
 
-ZEND_API void zend_do_inherit_interfaces(zend_class_entry *ce, const zend_class_entry *iface TSRMLS_DC) /* {{{ */
+void zend_compile_unset(zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	/* expects interface to be contained in ce's interface list already */
-	zend_uint i, ce_num, if_num = iface->num_interfaces;
-	zend_class_entry *entry;
+	zend_ast *var_ast = ast->child[0];
 
-	if (if_num==0) {
-		return;
-	}
-	ce_num = ce->num_interfaces;
-
-	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));
-	}
-
-	/* 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;
+	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;
 			}
-		}
-		if (i == ce_num) {
-			ce->interfaces[ce->num_interfaces++] = entry;
-		}
-	}
-
-	/* and now call the implementing handlers */
-	while (ce_num < ce->num_interfaces) {
-		do_implement_interface(ce, ce->interfaces[ce_num++] TSRMLS_CC);
+			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()
 	}
 }
 /* }}} */
 
-#ifdef ZTS
-static void zval_internal_ctor(zval **p) /* {{{ */
+static void zend_free_foreach_and_switch_variables(TSRMLS_D) /* {{{ */
 {
-	zval *orig_ptr = *p;
+	uint32_t opnum_start, opnum_end, i;
 
-	ALLOC_ZVAL(*p);
-	MAKE_COPY_ZVAL(&orig_ptr, *p);
-}
-/* }}} */
+	opnum_start = get_next_op_number(CG(active_op_array));
 
-# define zval_property_ctor(parent_ce, ce) \
-	((void (*)(void *)) (((parent_ce)->type != (ce)->type) ? zval_internal_ctor : zval_add_ref))
+#ifdef ZTS
+	zend_stack_apply_with_argument(&CG(loop_var_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element, void *)) generate_free_loop_var TSRMLS_CC);
 #else
-# define zval_property_ctor(parent_ce, ce) \
-	((void (*)(void *)) zval_add_ref)
+	zend_stack_apply(&CG(loop_var_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element)) generate_free_loop_var);
 #endif
 
-ZEND_API void zend_do_inheritance(zend_class_entry *ce, zend_class_entry *parent_ce TSRMLS_DC) /* {{{ */
-{
-	zend_property_info *property_info;
+	opnum_end = get_next_op_number(CG(active_op_array));
 
-	if ((ce->ce_flags & ZEND_ACC_INTERFACE)
-		&& !(parent_ce->ce_flags & ZEND_ACC_INTERFACE)) {
-		zend_error(E_COMPILE_ERROR, "Interface %s may not inherit from class (%s)", ce->name, parent_ce->name);
-	}
-	if (parent_ce->ce_flags & ZEND_ACC_FINAL_CLASS) {
-		zend_error(E_COMPILE_ERROR, "Class %s may not inherit from final class (%s)", ce->name, parent_ce->name);
+	for (i = opnum_start; i < opnum_end; ++i) {
+		CG(active_op_array)->opcodes[i].extended_value |= EXT_TYPE_FREE_ON_RETURN;
 	}
+}
+/* }}} */
 
-	ce->parent = parent_ce;
-	/* Copy serialize/unserialize callbacks */
-	if (!ce->serialize) {
-		ce->serialize   = parent_ce->serialize;
-	}
-	if (!ce->unserialize) {
-		ce->unserialize = parent_ce->unserialize;
-	}
+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;
 
-	/* Inherit interfaces */
-	zend_do_inherit_interfaces(ce, parent_ce TSRMLS_CC);
+	znode expr_node;
+	zend_op *opline;
 
-	/* Inherit properties */
-	if (parent_ce->default_properties_count) {
-		int i = ce->default_properties_count + parent_ce->default_properties_count;
+	if (!expr_ast) {
+		expr_node.op_type = IS_CONST;
+		ZVAL_NULL(&expr_node.u.constant);
+	} else if (by_ref && zend_is_variable(expr_ast) && !zend_is_call(expr_ast)) {
+		zend_compile_var(&expr_node, expr_ast, BP_VAR_REF TSRMLS_CC);
+	} else {
+		zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
+	}
 
-		ce->default_properties_table = perealloc(ce->default_properties_table, sizeof(void*) * i, ce->type == ZEND_INTERNAL_CLASS);
-		if (ce->default_properties_count) {
-			while (i-- > parent_ce->default_properties_count) {
-				ce->default_properties_table[i] = ce->default_properties_table[i - parent_ce->default_properties_count];
-			}
-		}
-		for (i = 0; i < parent_ce->default_properties_count; i++) {
-			ce->default_properties_table[i] = parent_ce->default_properties_table[i];
-			if (ce->default_properties_table[i]) {
-#ifdef ZTS
-				if (parent_ce->type != ce->type) {
-					zval *p;
+	zend_free_foreach_and_switch_variables(TSRMLS_C);
 
-					ALLOC_ZVAL(p);
-					MAKE_COPY_ZVAL(&ce->default_properties_table[i], p);
-					ce->default_properties_table[i] = p;
-				} else {
-					Z_ADDREF_P(ce->default_properties_table[i]);
-				}
-#else
-				Z_ADDREF_P(ce->default_properties_table[i]);
-#endif
-			}
-		}
-		ce->default_properties_count += parent_ce->default_properties_count;
+	if (CG(context).in_finally) {
+		zend_emit_op(NULL, ZEND_DISCARD_EXCEPTION, NULL, NULL TSRMLS_CC);
 	}
 
-	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;
-
-			ce->default_static_members_table = erealloc(ce->default_static_members_table, sizeof(void*) * i);
-			if (ce->default_static_members_count) {
-				while (i-- > parent_ce->default_static_members_count) {
-					ce->default_static_members_table[i] = ce->default_static_members_table[i - parent_ce->default_static_members_count];
-				}
-			}
-			for (i = 0; i < parent_ce->default_static_members_count; i++) {
-				SEPARATE_ZVAL_TO_MAKE_IS_REF(&CE_STATIC_MEMBERS(parent_ce)[i]);
-				ce->default_static_members_table[i] = CE_STATIC_MEMBERS(parent_ce)[i];
-				Z_ADDREF_P(ce->default_static_members_table[i]);
-			}
-			ce->default_static_members_count += parent_ce->default_static_members_count;
-			ce->static_members_table = ce->default_static_members_table;
-		}
-	} else {
-		if (parent_ce->default_static_members_count) {
-			int i = ce->default_static_members_count + parent_ce->default_static_members_count;
+	opline = zend_emit_op(NULL, by_ref ? ZEND_RETURN_BY_REF : ZEND_RETURN,
+		&expr_node, NULL TSRMLS_CC);
 
-			ce->default_static_members_table = perealloc(ce->default_static_members_table, sizeof(void*) * i, ce->type == ZEND_INTERNAL_CLASS);
-			if (ce->default_static_members_count) {
-				while (i-- > parent_ce->default_static_members_count) {
-					ce->default_static_members_table[i] = ce->default_static_members_table[i - parent_ce->default_static_members_count];
-				}
-			}
-			for (i = 0; i < parent_ce->default_static_members_count; i++) {
-				SEPARATE_ZVAL_TO_MAKE_IS_REF(&parent_ce->default_static_members_table[i]);
-				ce->default_static_members_table[i] = parent_ce->default_static_members_table[i];
-				Z_ADDREF_P(ce->default_static_members_table[i]);
-			}
-			ce->default_static_members_count += parent_ce->default_static_members_count;
-			if (ce->type == ZEND_USER_CLASS) {
-				ce->static_members_table = ce->default_static_members_table;
-			}
+	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;
 		}
 	}
+}
+/* }}} */
 
-	for (zend_hash_internal_pointer_reset(&ce->properties_info);
-	zend_hash_get_current_data(&ce->properties_info, (void *) &property_info) == SUCCESS;
-	zend_hash_move_forward(&ce->properties_info)) {
-		if (property_info->ce == ce) {
-			if (property_info->flags & ZEND_ACC_STATIC) {
-				property_info->offset += parent_ce->default_static_members_count;
-			} else {
-				property_info->offset += parent_ce->default_properties_count;
-			}
-		}
-	}
+void zend_compile_echo(zend_ast *ast TSRMLS_DC) /* {{{ */
+{
+	zend_ast *expr_ast = ast->child[0];
 
-	zend_hash_merge_ex(&ce->properties_info, &parent_ce->properties_info, (copy_ctor_func_t) (ce->type & ZEND_INTERNAL_CLASS ? zend_duplicate_property_info_internal : zend_duplicate_property_info), sizeof(zend_property_info), (merge_checker_func_t) do_inherit_property_access_check, ce);
+	znode expr_node;
+	zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
 
-	zend_hash_merge(&ce->constants_table, &parent_ce->constants_table, zval_property_ctor(parent_ce, ce), NULL, sizeof(zval *), 0);
-	zend_hash_merge_ex(&ce->function_table, &parent_ce->function_table, (copy_ctor_func_t) do_inherit_method, sizeof(zend_function), (merge_checker_func_t) do_inherit_method_check, ce);
-	do_inherit_parent_constructor(ce);
+	zend_emit_op(NULL, ZEND_ECHO, &expr_node, NULL TSRMLS_CC);
+}
+/* }}} */
 
-	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);
-	}
-	ce->ce_flags |= parent_ce->ce_flags & ZEND_HAS_STATIC_IN_METHODS;
+void zend_compile_throw(zend_ast *ast TSRMLS_DC) /* {{{ */
+{
+	zend_ast *expr_ast = ast->child[0];
+
+	znode expr_node;
+	zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
+
+	zend_emit_op(NULL, ZEND_THROW, &expr_node, NULL TSRMLS_CC);
 }
 /* }}} */
 
-static zend_bool do_inherit_constant_check(HashTable *child_constants_table, const zval **parent_constant, const zend_hash_key *hash_key, const zend_class_entry *iface) /* {{{ */
+void zend_compile_break_continue(zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	zval **old_constant;
+	zend_ast *depth_ast = ast->child[0];
+
+	znode depth_node;
+	zend_op *opline;
+
+	ZEND_ASSERT(ast->kind == ZEND_AST_BREAK || ast->kind == ZEND_AST_CONTINUE);
 
-	if (zend_hash_quick_find(child_constants_table, hash_key->arKey, hash_key->nKeyLength, hash_key->h, (void**)&old_constant) == SUCCESS) {
-		if (*old_constant != *parent_constant) {
-			zend_error(E_COMPILE_ERROR, "Cannot inherit previously-inherited or override constant %s from interface %s", hash_key->arKey, iface->name);
+	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");
 		}
-		return 0;
+
+		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);
 	}
-	return 1;
+
+	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;
 }
 /* }}} */
 
-static int do_interface_constant_check(zval **val TSRMLS_DC, int num_args, va_list args, const zend_hash_key *key) /* {{{ */
+void zend_compile_goto(zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	zend_class_entry **iface = va_arg(args, zend_class_entry**);
-
-	do_inherit_constant_check(&(*iface)->constants_table, (const zval **) val, key, *iface);
+	zend_ast *label_ast = ast->child[0];
+	znode label_node;
+	zend_op *opline;
 
-	return ZEND_HASH_APPLY_KEEP;
+	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);
 }
 /* }}} */
 
-ZEND_API void zend_do_implement_interface(zend_class_entry *ce, zend_class_entry *iface TSRMLS_DC) /* {{{ */
+void zend_compile_label(zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	zend_uint i, ignore = 0;
-	zend_uint current_iface_num = ce->num_interfaces;
-	zend_uint parent_iface_num  = ce->parent ? ce->parent->num_interfaces : 0;
+	zend_string *label = zend_ast_get_str(ast->child[0]);
+	zend_label dest;
 
-	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(E_COMPILE_ERROR, "Class %s cannot implement previously implemented interface %s", ce->name, iface->name);
-			}
-		}
+	if (!CG(context).labels) {
+		ALLOC_HASHTABLE(CG(context).labels);
+		zend_hash_init(CG(context).labels, 8, NULL, ptr_dtor, 0);
 	}
-	if (ignore) {
-		/* Check for attempt to redeclare interface constants */
-		zend_hash_apply_with_arguments(&ce->constants_table TSRMLS_CC, (apply_func_args_t) do_interface_constant_check, 1, &iface);
-	} else {
-		if (ce->num_interfaces >= current_iface_num) {
-			if (ce->type == ZEND_INTERNAL_CLASS) {
-				ce->interfaces = (zend_class_entry **) realloc(ce->interfaces, sizeof(zend_class_entry *) * (++current_iface_num));
-			} else {
-				ce->interfaces = (zend_class_entry **) erealloc(ce->interfaces, sizeof(zend_class_entry *) * (++current_iface_num));
-			}
-		}
-		ce->interfaces[ce->num_interfaces++] = iface;
 
-		zend_hash_merge_ex(&ce->constants_table, &iface->constants_table, (copy_ctor_func_t) zval_add_ref, sizeof(zval *), (merge_checker_func_t) do_inherit_constant_check, iface);
-		zend_hash_merge_ex(&ce->function_table, &iface->function_table, (copy_ctor_func_t) do_inherit_method, sizeof(zend_function), (merge_checker_func_t) do_inherit_method_check, ce);
+	dest.brk_cont = CG(context).current_brk_cont;
+	dest.opline_num = get_next_op_number(CG(active_op_array));
 
-		do_implement_interface(ce, iface TSRMLS_CC);
-		zend_do_inherit_interfaces(ce, iface TSRMLS_CC);
+	if (!zend_hash_add_mem(CG(context).labels, label, &dest, sizeof(zend_label))) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Label '%s' already defined", label->val);
 	}
 }
 /* }}} */
 
-ZEND_API void zend_do_implement_trait(zend_class_entry *ce, zend_class_entry *trait TSRMLS_DC) /* {{{ */
+void zend_compile_while(zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	zend_uint i, ignore = 0;
-	zend_uint current_trait_num = ce->num_traits;
-	zend_uint parent_trait_num  = ce->parent ? ce->parent->num_traits : 0;
+	zend_ast *cond_ast = ast->child[0];
+	zend_ast *stmt_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;
-			}
-		}
-	}
-	if (!ignore) {
-		if (ce->num_traits >= current_trait_num) {
-			if (ce->type == ZEND_INTERNAL_CLASS) {
-				ce->traits = (zend_class_entry **) realloc(ce->traits, sizeof(zend_class_entry *) * (++current_trait_num));
-			} else {
-				ce->traits = (zend_class_entry **) erealloc(ce->traits, sizeof(zend_class_entry *) * (++current_trait_num));
-			}
-		}
-		ce->traits[ce->num_traits++] = trait;
-	}
+	znode cond_node;
+	uint32_t opnum_start, opnum_jmpz;
+
+	opnum_start = get_next_op_number(CG(active_op_array));
+	zend_compile_expr(&cond_node, cond_ast TSRMLS_CC);
+
+	opnum_jmpz = zend_emit_cond_jump(ZEND_JMPZ, &cond_node, 0 TSRMLS_CC);
+	zend_begin_loop(TSRMLS_C);
+
+	zend_compile_stmt(stmt_ast TSRMLS_CC);
+
+	zend_emit_jump(opnum_start TSRMLS_CC);
+
+	zend_update_jump_target_to_next(opnum_jmpz TSRMLS_CC);
+
+	zend_end_loop(opnum_start, 0 TSRMLS_CC);
 }
 /* }}} */
 
-static zend_bool zend_traits_method_compatibility_check(zend_function *fn, zend_function *other_fn TSRMLS_DC) /* {{{ */
+void zend_compile_do_while(zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	zend_uint    fn_flags = fn->common.scope->ce_flags;
-	zend_uint other_flags = other_fn->common.scope->ce_flags;
+	zend_ast *stmt_ast = ast->child[0];
+	zend_ast *cond_ast = ast->child[1];
+
+	znode cond_node;
+	uint32_t opnum_start, opnum_cond;
+
+	zend_begin_loop(TSRMLS_C);
+
+	opnum_start = get_next_op_number(CG(active_op_array));
+	zend_compile_stmt(stmt_ast TSRMLS_CC);
 
-	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 */
+	opnum_cond = get_next_op_number(CG(active_op_array));
+	zend_compile_expr(&cond_node, cond_ast TSRMLS_CC);
+
+	zend_emit_cond_jump(ZEND_JMPNZ, &cond_node, opnum_start TSRMLS_CC);
+
+	zend_end_loop(opnum_cond, 0 TSRMLS_CC);
 }
 /* }}} */
 
-static void zend_add_magic_methods(zend_class_entry* ce, const char* mname, uint mname_len, zend_function* fe TSRMLS_DC) /* {{{ */
+void zend_compile_expr_list(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	if (!strncmp(mname, ZEND_CLONE_FUNC_NAME, mname_len)) {
-		ce->clone = fe; fe->common.fn_flags |= ZEND_ACC_CLONE;
-	} else if (!strncmp(mname, ZEND_CONSTRUCTOR_FUNC_NAME, mname_len)) {
-		if (ce->constructor) {
-			zend_error(E_COMPILE_ERROR, "%s has colliding constructor definitions coming from traits", ce->name);
-		}
-		ce->constructor = fe; fe->common.fn_flags |= ZEND_ACC_CTOR;
-	} else if (!strncmp(mname, ZEND_DESTRUCTOR_FUNC_NAME,  mname_len)) {
-		ce->destructor = fe; fe->common.fn_flags |= ZEND_ACC_DTOR;
-	} else if (!strncmp(mname, ZEND_GET_FUNC_NAME, mname_len)) {
-		ce->__get = fe;
-	} else if (!strncmp(mname, ZEND_SET_FUNC_NAME, mname_len)) {
-		ce->__set = fe;
-	} else if (!strncmp(mname, ZEND_CALL_FUNC_NAME, mname_len)) {
-		ce->__call = fe;
-	} else if (!strncmp(mname, ZEND_UNSET_FUNC_NAME, mname_len)) {
-		ce->__unset = fe;
-	} else if (!strncmp(mname, ZEND_ISSET_FUNC_NAME, mname_len)) {
-		ce->__isset = fe;
-	} else if (!strncmp(mname, ZEND_CALLSTATIC_FUNC_NAME, mname_len)) {
-		ce->__callstatic = fe;
-	} else if (!strncmp(mname, ZEND_TOSTRING_FUNC_NAME, mname_len)) {
-		ce->__tostring = fe;
-	} else if (ce->name_length + 1 == mname_len) {
-		char *lowercase_name = emalloc(ce->name_length + 1);
-		zend_str_tolower_copy(lowercase_name, ce->name, ce->name_length);
-		lowercase_name = (char*)zend_new_interned_string(lowercase_name, ce->name_length + 1, 1 TSRMLS_CC);
-		if (!memcmp(mname, lowercase_name, mname_len)) {
-			if (ce->constructor) {
-				zend_error(E_COMPILE_ERROR, "%s has colliding constructor definitions coming from traits", ce->name);
-			}
-			ce->constructor = fe;
-			fe->common.fn_flags |= ZEND_ACC_CTOR;
-		}
-		str_efree(lowercase_name);
+	zend_ast_list *list;
+	uint32_t i;
+
+	result->op_type = IS_CONST;
+	ZVAL_TRUE(&result->u.constant);
+
+	if (!ast) {
+		return;
+	}
+
+	list = zend_ast_get_list(ast);
+	for (i = 0; i < list->children; ++i) {
+		zend_ast *expr_ast = list->child[i];
+
+		zend_do_free(result TSRMLS_CC);
+		zend_compile_expr(result, expr_ast TSRMLS_CC);
 	}
 }
 /* }}} */
 
-static void zend_add_trait_method(zend_class_entry *ce, const char *name, const char *arKey, uint nKeyLength, zend_function *fn, HashTable **overriden TSRMLS_DC) /* {{{ */
+void zend_compile_for(zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	zend_function *existing_fn = NULL;
-	ulong h = zend_hash_func(arKey, nKeyLength);
+	zend_ast *init_ast = ast->child[0];
+	zend_ast *cond_ast = ast->child[1];
+	zend_ast *loop_ast = ast->child[2];
+	zend_ast *stmt_ast = ast->child[3];
 
-	if (zend_hash_quick_find(&ce->function_table, arKey, nKeyLength, h, (void**) &existing_fn) == SUCCESS) {
-		if (existing_fn->common.scope == ce) {
-			/* members from the current class override trait methods */
-			/* use temporary *overriden HashTable to detect hidden conflict */
-			if (*overriden) {
-				if (zend_hash_quick_find(*overriden, arKey, nKeyLength, h, (void**) &existing_fn) == SUCCESS) {
-					if (existing_fn->common.fn_flags & ZEND_ACC_ABSTRACT) {
-						/* Make sure the trait method is compatible with previosly declared abstract method */
-						if (!zend_traits_method_compatibility_check(fn, existing_fn TSRMLS_CC)) {
-							zend_error(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(E_COMPILE_ERROR, "Declaration of %s must be compatible with %s",
-								zend_get_function_declaration(fn TSRMLS_CC),
-								zend_get_function_declaration(existing_fn TSRMLS_CC));
-						}
-						return;
-					}
-				}
-			} else {
-				ALLOC_HASHTABLE(*overriden);
-				zend_hash_init_ex(*overriden, 2, NULL, NULL, 0, 0);
-			}
-			zend_hash_quick_update(*overriden, arKey, nKeyLength, h, fn, sizeof(zend_function), (void**)&fn);
-			return;
-		} else if (existing_fn->common.fn_flags & ZEND_ACC_ABSTRACT) {
-			/* 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(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(E_COMPILE_ERROR, "Declaration of %s must be compatible with %s",
-					zend_get_function_declaration(fn TSRMLS_CC),
-					zend_get_function_declaration(existing_fn TSRMLS_CC));
-			}
-			return;
-		} else if ((existing_fn->common.scope->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) {
-			/* two trais can't define the same non-abstract method */
-#if 1
-			zend_error(E_COMPILE_ERROR, "Trait method %s has not been applied, because there are collisions with other trait methods on %s",
-				name, ce->name);
-#else		/* TODO: better errot message */
-			zend_error(E_COMPILE_ERROR, "Trait method %s::%s has not been applied as %s::%s, because of collision with %s::%s",
-				fn->common.scope->name, fn->common.function_name,
-				ce->name, name,
-				existing_fn->common.scope->name, existing_fn->common.function_name);
-#endif
-		} else {
-			/* inherited members are overridden by members inserted by traits */
-			/* check whether the trait method fulfills the inheritance requirements */
-			do_inheritance_check_on_method(fn, existing_fn TSRMLS_CC);
-		}
-	}
+	znode result;
+	uint32_t opnum_cond, opnum_jmpz, opnum_loop;
+
+	zend_compile_expr_list(&result, init_ast TSRMLS_CC);
+	zend_do_free(&result TSRMLS_CC);
+
+	opnum_cond = get_next_op_number(CG(active_op_array));
+	zend_compile_expr_list(&result, cond_ast TSRMLS_CC);
+	zend_do_extended_info(TSRMLS_C);
+
+	opnum_jmpz = zend_emit_cond_jump(ZEND_JMPZ, &result, 0 TSRMLS_CC);
+	zend_begin_loop(TSRMLS_C);
+
+	zend_compile_stmt(stmt_ast TSRMLS_CC);
+
+	opnum_loop = get_next_op_number(CG(active_op_array));
+	zend_compile_expr_list(&result, loop_ast TSRMLS_CC);
+	zend_do_free(&result TSRMLS_CC);
+
+	zend_emit_jump(opnum_cond TSRMLS_CC);
 
-	function_add_ref(fn);
-	zend_hash_quick_update(&ce->function_table, arKey, nKeyLength, h, fn, sizeof(zend_function), (void**)&fn);
-	zend_add_magic_methods(ce, arKey, nKeyLength, fn TSRMLS_CC);
+	zend_update_jump_target_to_next(opnum_jmpz TSRMLS_CC);
+
+	zend_end_loop(opnum_loop, 0 TSRMLS_CC);
 }
 /* }}} */
 
-static int zend_fixup_trait_method(zend_function *fn, zend_class_entry *ce TSRMLS_DC) /* {{{ */
+void zend_compile_foreach(zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	if ((fn->common.scope->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) {
+	zend_ast *expr_ast = ast->child[0];
+	zend_ast *value_ast = ast->child[1];
+	zend_ast *key_ast = ast->child[2];
+	zend_ast *stmt_ast = ast->child[3];
+	zend_bool by_ref = value_ast->kind == ZEND_AST_REF;
+	zend_bool is_variable = zend_is_variable(expr_ast) && !zend_is_call(expr_ast)
+		&& zend_can_write_to_variable(expr_ast);
 
-		fn->common.scope = ce;
+	znode expr_node, reset_node, value_node, key_node;
+	zend_op *opline;
+	uint32_t opnum_reset, opnum_fetch;
 
-		if (fn->common.fn_flags & ZEND_ACC_ABSTRACT) {
-			ce->ce_flags |= ZEND_ACC_IMPLICIT_ABSTRACT_CLASS;
+	if (key_ast) {
+		if (key_ast->kind == ZEND_AST_REF) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Key element cannot be a reference");
 		}
-		if (fn->op_array.static_variables) {
-			ce->ce_flags |= ZEND_HAS_STATIC_IN_METHODS;
+		if (key_ast->kind == ZEND_AST_LIST) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Cannot use list as key element");
 		}
 	}
-	return ZEND_HASH_APPLY_KEEP;
-}
-/* }}} */
 
-static int zend_traits_copy_functions(zend_function *fn TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */
-{
-	zend_class_entry  *ce;
-	HashTable         **overriden;
-	zend_trait_alias  *alias, **alias_ptr;
-	HashTable         *exclude_table;
-	char              *lcname;
-	unsigned int       fnname_len;
-	zend_function      fn_copy;
-	void              *dummy;
+	if (by_ref) {
+		value_ast = value_ast->child[0];
+	}
 
-	ce            = va_arg(args, zend_class_entry*);
-	overriden     = va_arg(args, HashTable**);
-	exclude_table = va_arg(args, HashTable*);
+	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);
+	}
 
-	fnname_len = hash_key->nKeyLength - 1;
+	if (by_ref) {
+		zend_separate_if_call_and_write(&expr_node, expr_ast, BP_VAR_W TSRMLS_CC);
+	}
 
-	/* apply aliases which are qualified with a class name, there should not be any ambiguity */
-	if (ce->trait_aliases) {
-		alias_ptr = ce->trait_aliases;
-		alias = *alias_ptr;
-		while (alias) {
-			/* Scope unset or equal to the function we compare to, and the alias applies to fn */
-			if (alias->alias != NULL
-				&& (!alias->trait_method->ce || fn->common.scope == alias->trait_method->ce)
-				&& alias->trait_method->mname_len == fnname_len
-				&& (zend_binary_strcasecmp(alias->trait_method->method_name, alias->trait_method->mname_len, hash_key->arKey, fnname_len) == 0)) {
-				fn_copy = *fn;
+	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_FETCH_BYREF;
+	}
 
-				/* 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));
-				}
+	zend_stack_push(&CG(loop_var_stack), &reset_node);
 
-				lcname = zend_str_tolower_dup(alias->alias, alias->alias_len);
-				zend_add_trait_method(ce, alias->alias, lcname, alias->alias_len+1, &fn_copy, overriden TSRMLS_CC);
-				efree(lcname);
+	opnum_fetch = get_next_op_number(CG(active_op_array));
+	opline = zend_emit_op(&value_node, ZEND_FE_FETCH, &reset_node, NULL TSRMLS_CC);
+	if (by_ref) {
+		opline->extended_value |= ZEND_FE_FETCH_BYREF;
+	}
+	if (key_ast) {
+		opline->extended_value |= ZEND_FE_FETCH_WITH_KEY;
+	}
 
-				/* Record the trait from which this alias was resolved. */
-				if (!alias->trait_method->ce) {
-					alias->trait_method->ce = fn->common.scope;
-				}
-			}
-			alias_ptr++;
-			alias = *alias_ptr;
-		}
+	opline = zend_emit_op(NULL, ZEND_OP_DATA, NULL, NULL TSRMLS_CC);
+
+	/* 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));
 	}
 
-	lcname = (char *) hash_key->arKey;
+	if (key_ast) {
+		zend_make_tmp_result(&key_node, opline TSRMLS_CC);
+	}
 
-	if (exclude_table == NULL || zend_hash_find(exclude_table, lcname, fnname_len, &dummy) == FAILURE) {
-		/* is not in hashtable, thus, function is not to be excluded */
-		fn_copy = *fn;
+	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);
+	}
 
-		/* apply aliases which have not alias name, just setting visibility */
-		if (ce->trait_aliases) {
-			alias_ptr = ce->trait_aliases;
-			alias = *alias_ptr;
-			while (alias) {
-				/* Scope unset or equal to the function we compare to, and the alias applies to fn */
-				if (alias->alias == NULL && alias->modifiers != 0
-					&& (!alias->trait_method->ce || fn->common.scope == alias->trait_method->ce)
-					&& (alias->trait_method->mname_len == fnname_len)
-					&& (zend_binary_strcasecmp(alias->trait_method->method_name, alias->trait_method->mname_len, lcname, fnname_len) == 0)) {
+	if (key_ast) {
+		zend_emit_assign_znode(key_ast, &key_node TSRMLS_CC);
+	}
 
-					fn_copy.common.fn_flags = alias->modifiers | (fn->common.fn_flags ^ (fn->common.fn_flags & ZEND_ACC_PPP_MASK));
+	zend_begin_loop(TSRMLS_C);
 
-					/** 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;
-			}
-		}
+	zend_compile_stmt(stmt_ast TSRMLS_CC);
 
-		zend_add_trait_method(ce, fn->common.function_name, lcname, fnname_len+1, &fn_copy, overriden TSRMLS_CC);
-	}
+	zend_emit_jump(opnum_fetch TSRMLS_CC);
+
+	opline = &CG(active_op_array)->opcodes[opnum_reset];
+	opline->op2.opline_num = get_next_op_number(CG(active_op_array));
+
+	opline = &CG(active_op_array)->opcodes[opnum_fetch];
+	opline->op2.opline_num = get_next_op_number(CG(active_op_array));
+
+	zend_end_loop(opnum_fetch, 1 TSRMLS_CC);
 
-	return ZEND_HASH_APPLY_KEEP;
+	generate_free_loop_var(&reset_node TSRMLS_CC);
+	zend_stack_del_top(&CG(loop_var_stack));
 }
 /* }}} */
 
-static void zend_check_trait_usage(zend_class_entry *ce, zend_class_entry *trait TSRMLS_DC) /* {{{ */
+void zend_compile_if(zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	zend_uint i;
+	zend_ast_list *list = zend_ast_get_list(ast);
+	uint32_t i;
+	uint32_t *jmp_opnums;
+	
+	if (list->children > 1) {
+		jmp_opnums = safe_emalloc(sizeof(uint32_t), list->children - 1, 0);
+	}
+
+	for (i = 0; i < list->children; ++i) {
+		zend_ast *elem_ast = list->child[i];
+		zend_ast *cond_ast = elem_ast->child[0];
+		zend_ast *stmt_ast = elem_ast->child[1];
 
-	if ((trait->ce_flags & ZEND_ACC_TRAIT) != ZEND_ACC_TRAIT) {
-		zend_error(E_COMPILE_ERROR, "Class %s is not a trait, Only traits may be used in 'as' and 'insteadof' statements", trait->name);
+		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);
+		}
+
+		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);
+		}
 	}
 
-	for (i = 0; i < ce->num_traits; i++) {
-		if (ce->traits[i] == trait) {
-			return;
+	if (list->children > 1) {
+		for (i = 0; i < list->children - 1; ++i) {
+			zend_update_jump_target_to_next(jmp_opnums[i] TSRMLS_CC);
 		}
+		efree(jmp_opnums);
 	}
-	zend_error(E_COMPILE_ERROR, "Required Trait %s wasn't added to %s", trait->name, ce->name);
 }
 /* }}} */
 
-static void zend_traits_init_trait_structures(zend_class_entry *ce TSRMLS_DC) /* {{{ */
+void zend_compile_switch(zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	size_t i, j = 0;
-	zend_trait_precedence *cur_precedence;
-	zend_trait_method_reference *cur_method_ref;
-	char *lcname;
-	zend_bool method_exists;
+	zend_ast *expr_ast = ast->child[0];
+	zend_ast_list *cases = zend_ast_get_list(ast->child[1]);
 
-	/* resolve class references */
-	if (ce->trait_precedences) {
-		i = 0;
-		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, cur_method_ref->cname_len,
-								ZEND_FETCH_CLASS_TRAIT|ZEND_FETCH_CLASS_NO_AUTOLOAD TSRMLS_CC))) {
-					zend_error(E_COMPILE_ERROR, "Could not find trait %s", cur_method_ref->class_name);
-				}
-				zend_check_trait_usage(ce, cur_precedence->trait_method->ce TSRMLS_CC);
-
-				/** Ensure that the prefered method is actually available. */
-				lcname = zend_str_tolower_dup(cur_method_ref->method_name,
-											  cur_method_ref->mname_len);
-				method_exists = zend_hash_exists(&cur_method_ref->ce->function_table,
-												 lcname,
-												 cur_method_ref->mname_len + 1);
-				efree(lcname);
-				if (!method_exists) {
-					zend_error(E_COMPILE_ERROR,
-							   "A precedence rule was defined for %s::%s but this method does not exist",
-							   cur_method_ref->ce->name,
-							   cur_method_ref->method_name);
-				}
+	uint32_t i;
+	zend_bool has_default_case = 0;
 
-				/** With the other traits, we are more permissive.
-					We do not give errors for those. This allows to be more
-					defensive in such definitions.
-					However, we want to make sure that the insteadof declaration
-					is consistent in itself.
-				 */
-				j = 0;
-				while (cur_precedence->exclude_from_classes[j]) {
-					char* class_name = (char*)cur_precedence->exclude_from_classes[j];
-					zend_uint name_length = strlen(class_name);
-
-					if (!(cur_precedence->exclude_from_classes[j] = zend_fetch_class(class_name, name_length, ZEND_FETCH_CLASS_TRAIT |ZEND_FETCH_CLASS_NO_AUTOLOAD TSRMLS_CC))) {
-						zend_error(E_COMPILE_ERROR, "Could not find trait %s", class_name);
-					}
-					zend_check_trait_usage(ce, cur_precedence->exclude_from_classes[j] TSRMLS_CC);
-
-					/* make sure that the trait method is not from a class mentioned in
-					 exclude_from_classes, for consistency */
-					if (cur_precedence->trait_method->ce == cur_precedence->exclude_from_classes[i]) {
-						zend_error(E_COMPILE_ERROR,
-								   "Inconsistent insteadof definition. "
-								   "The method %s is to be used from %s, but %s is also on the exclude list",
-								   cur_method_ref->method_name,
-								   cur_precedence->trait_method->ce->name,
-								   cur_precedence->trait_method->ce->name);
-					}
+	znode expr_node, case_node;
+	zend_op *opline;
+	uint32_t *jmpnz_opnums = safe_emalloc(sizeof(uint32_t), cases->children, 0);
+	uint32_t opnum_default_jmp;
 
-					efree(class_name);
-					j++;
-				}
+	zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
+
+	zend_stack_push(&CG(loop_var_stack), &expr_node);
+
+	zend_begin_loop(TSRMLS_C);
+
+	case_node.op_type = IS_TMP_VAR;
+	case_node.u.op.var = get_temporary_variable(CG(active_op_array));
+
+	for (i = 0; i < cases->children; ++i) {
+		zend_ast *case_ast = cases->child[i];
+		zend_ast *cond_ast = case_ast->child[0];
+		znode cond_node;
+
+		if (!cond_ast) {
+			if (has_default_case) {
+				CG(zend_lineno) = case_ast->lineno;
+				zend_error_noreturn(E_COMPILE_ERROR,
+					"Switch statements may only contain one default clause");
 			}
-			i++;
+			has_default_case = 1;
+			continue;
+		}
+
+		zend_compile_expr(&cond_node, cond_ast TSRMLS_CC);
+
+		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));
 		}
+
+		jmpnz_opnums[i] = zend_emit_cond_jump(ZEND_JMPNZ, &case_node, 0 TSRMLS_CC);
 	}
 
-	if (ce->trait_aliases) {
-		i = 0;
-		while (ce->trait_aliases[i]) {
-			/** For all aliases with an explicit class name, resolve the class now. */
-			if (ce->trait_aliases[i]->trait_method->class_name) {
-				cur_method_ref = ce->trait_aliases[i]->trait_method;
-				if (!(cur_method_ref->ce = zend_fetch_class(cur_method_ref->class_name, cur_method_ref->cname_len, ZEND_FETCH_CLASS_TRAIT|ZEND_FETCH_CLASS_NO_AUTOLOAD TSRMLS_CC))) {
-					zend_error(E_COMPILE_ERROR, "Could not find trait %s", cur_method_ref->class_name);
-				}
-				zend_check_trait_usage(ce, cur_method_ref->ce TSRMLS_CC);
+	opnum_default_jmp = zend_emit_jump(0 TSRMLS_CC);
 
-				/** And, ensure that the referenced method is resolvable, too. */
-				lcname = zend_str_tolower_dup(cur_method_ref->method_name,
-						cur_method_ref->mname_len);
-				method_exists = zend_hash_exists(&cur_method_ref->ce->function_table,
-						lcname, cur_method_ref->mname_len + 1);
-				efree(lcname);
+	for (i = 0; i < cases->children; ++i) {
+		zend_ast *case_ast = cases->child[i];
+		zend_ast *cond_ast = case_ast->child[0];
+		zend_ast *stmt_ast = case_ast->child[1];
 
-				if (!method_exists) {
-					zend_error(E_COMPILE_ERROR, "An alias was defined for %s::%s but this method does not exist", cur_method_ref->ce->name, cur_method_ref->method_name);
-				}
-			}
-			i++;
+		if (cond_ast) {
+			zend_update_jump_target_to_next(jmpnz_opnums[i] TSRMLS_CC);
+		} else {
+			zend_update_jump_target_to_next(opnum_default_jmp TSRMLS_CC);
 		}
+
+		zend_compile_stmt(stmt_ast TSRMLS_CC);
+	}
+
+	if (!has_default_case) {
+		zend_update_jump_target_to_next(opnum_default_jmp TSRMLS_CC);
 	}
+
+	zend_end_loop(get_next_op_number(CG(active_op_array)), 1 TSRMLS_CC);
+
+	if (expr_node.op_type == IS_VAR || expr_node.op_type == IS_TMP_VAR) {
+		zend_emit_op(NULL, ZEND_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(loop_var_stack));
+	efree(jmpnz_opnums);
 }
 /* }}} */
 
-static void zend_traits_compile_exclude_table(HashTable* exclude_table, zend_trait_precedence **precedences, zend_class_entry *trait) /* {{{ */
+void zend_compile_try(zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	size_t i = 0, j;
+	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];
 
-	if (!precedences) {
-		return;
+	uint32_t i;
+	zend_op *opline;
+	uint32_t try_catch_offset = zend_add_try_element(
+		get_next_op_number(CG(active_op_array)) TSRMLS_CC);
+	uint32_t *jmp_opnums = safe_emalloc(sizeof(uint32_t), catches->children, 0);
+
+	if (catches->children == 0 && !finally_ast) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Cannot use try without catch or finally");
 	}
-	while (precedences[i]) {
-		if (precedences[i]->exclude_from_classes) {
-			j = 0;
-			while (precedences[i]->exclude_from_classes[j]) {
-				if (precedences[i]->exclude_from_classes[j] == trait) {
-					zend_uint lcname_len = precedences[i]->trait_method->mname_len;
-					char *lcname = zend_str_tolower_dup(precedences[i]->trait_method->method_name, lcname_len);
-
-					if (zend_hash_add(exclude_table, lcname, lcname_len, NULL, 0, NULL) == FAILURE) {
-						efree(lcname);
-						zend_error(E_COMPILE_ERROR, "Failed to evaluate a trait precedence (%s). Method of trait %s was defined to be excluded multiple times", precedences[i]->trait_method->method_name, trait->name);
-					}
-					efree(lcname);
-				}
-				++j;
-			}
-		}
-		++i;
+
+	zend_compile_stmt(try_ast TSRMLS_CC);
+
+	if (catches->children != 0) {
+		jmp_opnums[0] = zend_emit_jump(0 TSRMLS_CC);
 	}
-}
-/* }}} */
 
-static void zend_do_traits_method_binding(zend_class_entry *ce TSRMLS_DC) /* {{{ */
-{
-	zend_uint i;
-	HashTable *overriden = NULL;
+	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);
 
-	for (i = 0; i < ce->num_traits; i++) {
-		if (ce->trait_precedences) {
-			HashTable exclude_table;
+		uint32_t opnum_catch;
 
-			/* TODO: revisit this start size, may be its not optimal */
-			zend_hash_init_ex(&exclude_table, 2, NULL, NULL, 0, 0);
+		if (!zend_is_const_default_class_ref(class_ast)) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Bad class name in the catch statement");
+		}
 
-			zend_traits_compile_exclude_table(&exclude_table, ce->trait_precedences, ce->traits[i]);
+		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;
+		}
 
-			/* copies functions, applies defined aliasing, and excludes unused trait methods */
-			zend_hash_apply_with_arguments(&ce->traits[i]->function_table TSRMLS_CC, (apply_func_args_t)zend_traits_copy_functions, 3, ce, &overriden, &exclude_table);
+		CG(zend_lineno) = catch_ast->lineno;
 
-			zend_hash_destroy(&exclude_table);
-		} else {
-			zend_hash_apply_with_arguments(&ce->traits[i]->function_table TSRMLS_CC, (apply_func_args_t)zend_traits_copy_functions, 3, ce, &overriden, NULL);
+		opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+		opline->opcode = ZEND_CATCH;
+		opline->op1_type = IS_CONST;
+		opline->op1.constant = zend_add_class_name_literal(CG(active_op_array),
+			zend_resolve_class_name_ast(class_ast TSRMLS_CC) TSRMLS_CC);
+
+		opline->op2_type = IS_CV;
+		opline->op2.var = lookup_cv(CG(active_op_array), zend_string_copy(Z_STR_P(var_name)) TSRMLS_CC);
+		opline->result.num = is_last_catch;
+
+		zend_compile_stmt(stmt_ast TSRMLS_CC);
+
+		if (!is_last_catch) {
+			jmp_opnums[i + 1] = zend_emit_jump(0 TSRMLS_CC);
 		}
-	}
 
-    zend_hash_apply_with_argument(&ce->function_table, (apply_func_arg_t)zend_fixup_trait_method, ce TSRMLS_CC);
+		opline = &CG(active_op_array)->opcodes[opnum_catch];
+		opline->extended_value = get_next_op_number(CG(active_op_array));
+	}
 
-	if (overriden) {
-		zend_hash_destroy(overriden);
-		FREE_HASHTABLE(overriden);
+	for (i = 0; i < catches->children; ++i) {
+		zend_update_jump_target_to_next(jmp_opnums[i] TSRMLS_CC);
 	}
-}
-/* }}} */
 
-static zend_class_entry* find_first_definition(zend_class_entry *ce, size_t current_trait, const char* prop_name, int prop_name_length, ulong prop_hash, zend_class_entry *coliding_ce) /* {{{ */
-{
-	size_t i;
+	if (finally_ast) {
+		uint32_t opnum_jmp = get_next_op_number(CG(active_op_array)) + 1;
 
-	if (coliding_ce == ce) {
-		for (i = 0; i < current_trait; i++) {
-			if (zend_hash_quick_exists(&ce->traits[i]->properties_info, prop_name, prop_name_length+1, prop_hash)) {
-				return ce->traits[i];
-			}
-		}
+		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)->fn_flags |= ZEND_ACC_HAS_FINALLY_BLOCK;
+
+		zend_emit_op(NULL, ZEND_FAST_RET, NULL, NULL TSRMLS_CC);
+
+		zend_update_jump_target_to_next(opnum_jmp TSRMLS_CC);
 	}
 
-	return coliding_ce;
+	efree(jmp_opnums);
 }
 /* }}} */
 
-static void zend_do_traits_property_binding(zend_class_entry *ce TSRMLS_DC) /* {{{ */
+/* Encoding declarations must already be handled during parsing */
+void zend_handle_encoding_declaration(zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	size_t i;
-	zend_property_info *property_info;
-	zend_property_info *coliding_prop;
-	zval compare_result;
-	const char* prop_name;
-	int   prop_name_length;
-	ulong prop_hash;
-	const char* class_name_unused;
-	zend_bool not_compatible;
-	zval* prop_value;
-	char* doc_comment;
-	zend_uint flags;
+	zend_ast_list *declares = zend_ast_get_list(ast);
+	uint32_t i;
+	for (i = 0; i < declares->children; ++i) {
+		zend_ast *declare_ast = declares->child[i];
+		zend_ast *name_ast = declare_ast->child[0];
+		zend_ast *value_ast = declare_ast->child[1];
+		zend_string *name = zend_ast_get_str(name_ast);
 
-	/* In the following steps the properties are inserted into the property table
-	 * for that, a very strict approach is applied:
-	 * - check for compatibility, if not compatible with any property in class -> fatal
-	 * - if compatible, then strict notice
-	 */
-	for (i = 0; i < ce->num_traits; i++) {
-		for (zend_hash_internal_pointer_reset(&ce->traits[i]->properties_info);
-			 zend_hash_get_current_data(&ce->traits[i]->properties_info, (void *) &property_info) == SUCCESS;
-			 zend_hash_move_forward(&ce->traits[i]->properties_info)) {
-			/* first get the unmangeld name if necessary,
-			 * then check whether the property is already there
-			 */
-			flags = property_info->flags;
-			if ((flags & ZEND_ACC_PPP_MASK) == ZEND_ACC_PUBLIC) {
-				prop_hash = property_info->h;
-				prop_name = property_info->name;
-				prop_name_length = property_info->name_length;
-			} else {
-				/* for private and protected we need to unmangle the names */
-				zend_unmangle_property_name_ex(property_info->name, property_info->name_length,
-											&class_name_unused, &prop_name, &prop_name_length);
-				prop_hash = zend_get_hash_value(prop_name, prop_name_length + 1);
+		if (zend_string_equals_literal_ci(name, "encoding")) {
+			if (value_ast->kind != ZEND_AST_ZVAL) {
+				zend_error_noreturn(E_COMPILE_ERROR, "Encoding must be a literal");
 			}
 
-			/* next: check for conflicts with current class */
-			if (zend_hash_quick_find(&ce->properties_info, prop_name, prop_name_length+1, prop_hash, (void **) &coliding_prop) == SUCCESS) {
-				if (coliding_prop->flags & ZEND_ACC_SHADOW) {
-					zend_hash_quick_del(&ce->properties_info, prop_name, prop_name_length+1, prop_hash);
-					flags |= ZEND_ACC_CHANGED;
-				} else {
-					if ((coliding_prop->flags & (ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC))
-						== (flags & (ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC))) {
-						/* flags are identical, now the value needs to be checked */
-						if (flags & ZEND_ACC_STATIC) {
-							not_compatible = (FAILURE == compare_function(&compare_result,
-											  ce->default_static_members_table[coliding_prop->offset],
-											  ce->traits[i]->default_static_members_table[property_info->offset] TSRMLS_CC))
-								  || (Z_LVAL(compare_result) != 0);
-						} else {
-							not_compatible = (FAILURE == compare_function(&compare_result,
-											  ce->default_properties_table[coliding_prop->offset],
-											  ce->traits[i]->default_properties_table[property_info->offset] TSRMLS_CC))
-								  || (Z_LVAL(compare_result) != 0);
-						}
-					} else {
-						/* the flags are not identical, thus, we assume properties are not compatible */
-						not_compatible = 1;
-					}
+			if (CG(multibyte)) {
+				zend_string *encoding_name = zval_get_string(zend_ast_get_zval(value_ast));
 
-					if (not_compatible) {
-						zend_error(E_COMPILE_ERROR,
-							   "%s and %s define the same property ($%s) in the composition of %s. However, the definition differs and is considered incompatible. Class was composed",
-								find_first_definition(ce, i, prop_name, prop_name_length, prop_hash, coliding_prop->ce)->name,
-								property_info->ce->name,
-								prop_name,
-								ce->name);
-					} else {
-						zend_error(E_STRICT,
-							   "%s and %s define the same property ($%s) in the composition of %s. This might be incompatible, to improve maintainability consider using accessor methods in traits instead. Class was composed",
-								find_first_definition(ce, i, prop_name, prop_name_length, prop_hash, coliding_prop->ce)->name,
-								property_info->ce->name,
-								prop_name,
-								ce->name);
-						continue;
+				const zend_encoding *new_encoding, *old_encoding;
+				zend_encoding_filter old_input_filter;
+
+				CG(encoding_declared) = 1;
+
+				new_encoding = zend_multibyte_fetch_encoding(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);
 					}
 				}
-			}
 
-			/* property not found, so lets add it */
-			if (flags & ZEND_ACC_STATIC) {
-				prop_value = ce->traits[i]->default_static_members_table[property_info->offset];
+				zend_string_release(encoding_name);
 			} else {
-				prop_value = ce->traits[i]->default_properties_table[property_info->offset];
+				zend_error(E_COMPILE_WARNING, "declare(encoding=...) ignored because "
+					"Zend multibyte feature is turned off by settings");
 			}
-			Z_ADDREF_P(prop_value);
-
-			doc_comment = property_info->doc_comment ? estrndup(property_info->doc_comment, property_info->doc_comment_len) : NULL;
-			zend_declare_property_ex(ce, prop_name, prop_name_length,
-									 prop_value, flags,
-								     doc_comment, property_info->doc_comment_len TSRMLS_CC);
 		}
 	}
 }
 /* }}} */
 
-static void zend_do_check_for_inconsistent_traits_aliasing(zend_class_entry *ce TSRMLS_DC) /* {{{ */
+void zend_compile_declare(zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	int i = 0;
-	zend_trait_alias* cur_alias;
-	char* lc_method_name;
-
-	if (ce->trait_aliases) {
-		while (ce->trait_aliases[i]) {
-			cur_alias = ce->trait_aliases[i];
-			/** The trait for this alias has not been resolved, this means, this
-				alias was not applied. Abort with an error. */
-			if (!cur_alias->trait_method->ce) {
-				if (cur_alias->alias) {
-					/** Plain old inconsistency/typo/bug */
-					zend_error(E_COMPILE_ERROR,
-							   "An alias (%s) was defined for method %s(), but this method does not exist",
-							   cur_alias->alias,
-							   cur_alias->trait_method->method_name);
-				} else {
-					/** Here are two possible cases:
-						1) this is an attempt to modifiy the visibility
-						   of a method introduce as part of another alias.
-						   Since that seems to violate the DRY principle,
-						   we check against it and abort.
-						2) it is just a plain old inconsitency/typo/bug
-						   as in the case where alias is set. */
-
-					lc_method_name = zend_str_tolower_dup(cur_alias->trait_method->method_name,
-														  cur_alias->trait_method->mname_len);
-					if (zend_hash_exists(&ce->function_table,
-										 lc_method_name,
-										 cur_alias->trait_method->mname_len+1)) {
-						efree(lc_method_name);
-						zend_error(E_COMPILE_ERROR,
-								   "The modifiers for the trait alias %s() need to be changed in the same statment in which the alias is defined. Error",
-								   cur_alias->trait_method->method_name);
-					} else {
-						efree(lc_method_name);
-						zend_error(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);
+	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_string_equals_literal_ci(name, "ticks")) {
+			zval value_zv;
+			zend_const_expr_to_zval(&value_zv, value_ast TSRMLS_CC);
+			convert_to_long(&value_zv);
+			ZVAL_COPY_VALUE(&CG(declarables).ticks, &value_zv);
+			zval_dtor(&value_zv);
+		} else if (zend_string_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;
 			}
-			i++;
+
+			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);
 		}
 	}
+
+	if (stmt_ast) {
+		zend_compile_stmt(stmt_ast TSRMLS_CC);
+
+		CG(declarables) = orig_declarables;
+	}
 }
 /* }}} */
 
-ZEND_API void zend_do_bind_traits(zend_class_entry *ce TSRMLS_DC) /* {{{ */
+void zend_compile_stmt_list(zend_ast *ast TSRMLS_DC) /* {{{ */
 {
+	zend_ast_list *list = zend_ast_get_list(ast);
+	uint32_t i;
+	for (i = 0; i < list->children; ++i) {
+		zend_compile_stmt(list->child[i] TSRMLS_CC);
+	}
+}
+/* }}} */
+
+void zend_compile_params(zend_ast *ast TSRMLS_DC) /* {{{ */
+{
+	zend_ast_list *list = zend_ast_get_list(ast);
+	uint32_t i;
+	zend_op_array *op_array = CG(active_op_array);
+	zend_arg_info *arg_infos;
 
-	if (ce->num_traits <= 0) {
+	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;
 
-	/* complete initialization of trait strutures in ce */
-	zend_traits_init_trait_structures(ce TSRMLS_CC);
+		if (zend_is_auto_global(name TSRMLS_CC)) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign auto-global variable %s",
+				name->val);
+		}
 
-	/* first care about all methods to be flattened into the class */
-	zend_do_traits_method_binding(ce TSRMLS_CC);
+		var_node.op_type = IS_CV;
+		var_node.u.op.var = lookup_cv(CG(active_op_array), zend_string_copy(name) TSRMLS_CC);
 
-	/* Aliases which have not been applied indicate typos/bugs. */
-	zend_do_check_for_inconsistent_traits_aliasing(ce TSRMLS_CC);
+		if (EX_VAR_TO_NUM(var_node.u.op.var) != i) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Redefinition of parameter $%s",
+				name->val);
+		} else if (zend_string_equals_literal(name, "this")) {
+			if (op_array->scope && (op_array->fn_flags & ZEND_ACC_STATIC) == 0) {
+				zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this");
+			}
+			op_array->this_var = var_node.u.op.var;
+		}
 
-	/* then flatten the properties into it, to, mostly to notfiy developer about problems */
-	zend_do_traits_property_binding(ce TSRMLS_CC);
+		if (op_array->fn_flags & ZEND_ACC_VARIADIC) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Only the last parameter can be variadic");
+		}
 
-	/* verify that all abstract methods from traits have been implemented */
-	zend_verify_abstract_class(ce TSRMLS_CC);
+		if (is_variadic) {
+			opcode = ZEND_RECV_VARIADIC;
+			default_node.op_type = IS_UNUSED;
+			op_array->fn_flags |= ZEND_ACC_VARIADIC;
 
-	/* 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 (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") == 0)
+					|| 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 (!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 do_bind_function(const zend_op_array *op_array, zend_op *opline, HashTable *function_table, zend_bool compile_time) /* {{{ */
-{
-	zend_function *function;
-	zval *op1, *op2;
+				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);
+				}
 
-	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;
-	}
+				arg_info->type_hint = IS_OBJECT;
+				arg_info->class_name = estrndup(class_name->val, class_name->len);
+				arg_info->class_name_len = class_name->len;
 
-	zend_hash_quick_find(function_table, Z_STRVAL_P(op1), Z_STRLEN_P(op1), Z_HASH_P(op1), (void *) &function);
-	if (zend_hash_quick_add(function_table, Z_STRVAL_P(op2), Z_STRLEN_P(op2)+1, Z_HASH_P(op2), function, sizeof(zend_function), NULL)==FAILURE) {
-		int error_level = compile_time ? E_COMPILE_ERROR : E_ERROR;
-		zend_function *old_function;
+				zend_string_release(class_name);
 
-		if (zend_hash_quick_find(function_table, Z_STRVAL_P(op2), Z_STRLEN_P(op2)+1, Z_HASH_P(op2), (void *) &old_function)==SUCCESS
-			&& old_function->type == ZEND_USER_FUNCTION
-			&& old_function->op_array.last > 0) {
-			zend_error(error_level, "Cannot redeclare %s() (previously declared in %s:%d)",
-						function->common.function_name,
-						old_function->op_array.filename,
-						old_function->op_array.opcodes[0].lineno);
-		} else {
-			zend_error(error_level, "Cannot redeclare %s()", function->common.function_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;
-	} else {
-		(*function->op_array.refcount)++;
-		function->op_array.static_variables = NULL; /* NULL out the unbound function */
-		return SUCCESS;
 	}
+
+	/* 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_prepare_reference(znode *result, znode *class_name, znode *method_name TSRMLS_DC) /* {{{ */
+void zend_compile_closure_uses(zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	zend_trait_method_reference *method_ref = emalloc(sizeof(zend_trait_method_reference));
-	method_ref->ce = NULL;
+	zend_ast_list *list = zend_ast_get_list(ast);
+	uint32_t i;
 
-	/* REM: There should not be a need for copying,
-	   zend_do_begin_class_declaration is also just using that string */
-	if (class_name) {
-		zend_resolve_class_name(class_name TSRMLS_CC);
-		method_ref->class_name = Z_STRVAL(class_name->u.constant);
-		method_ref->cname_len  = Z_STRLEN(class_name->u.constant);
-	} else {
-		method_ref->class_name = NULL;
-		method_ref->cname_len  = 0;
-	}
+	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;
 
-	method_ref->method_name = Z_STRVAL(method_name->u.constant);
-	method_ref->mname_len   = Z_STRLEN(method_name->u.constant);
+		if (zend_string_equals_literal(name, "this")) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Cannot use $this as lexical variable");
+		}
 
-	result->u.op.ptr = method_ref;
-	result->op_type = IS_TMP_VAR;
+		ZVAL_NULL(&zv);
+		Z_CONST_FLAGS(zv) = by_ref ? IS_LEXICAL_REF : IS_LEXICAL_VAR;
+
+		zend_compile_static_var_common(var_ast, &zv, by_ref TSRMLS_CC);
+	}
 }
 /* }}} */
 
-void zend_add_trait_alias(znode *method_reference, znode *modifiers, znode *alias TSRMLS_DC) /* {{{ */
+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_trait_alias *trait_alias;
+	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 (Z_LVAL(modifiers->u.constant) == ZEND_ACC_STATIC) {
-		zend_error(E_COMPILE_ERROR, "Cannot use 'static' as method modifier");
-		return;
-	} else if (Z_LVAL(modifiers->u.constant) == ZEND_ACC_ABSTRACT) {
-		zend_error(E_COMPILE_ERROR, "Cannot use 'abstract' as method modifier");
-		return;
-	} else if (Z_LVAL(modifiers->u.constant) == ZEND_ACC_FINAL) {
-		zend_error(E_COMPILE_ERROR, "Cannot use 'final' as method modifier");
-		return;
-	}
+	zend_string *lcname;
 
-	trait_alias = emalloc(sizeof(zend_trait_alias));
-	trait_alias->trait_method = (zend_trait_method_reference*)method_reference->u.op.ptr;
-	trait_alias->modifiers = Z_LVAL(modifiers->u.constant);
-	if (alias) {
-		trait_alias->alias = Z_STRVAL(alias->u.constant);
-		trait_alias->alias_len = Z_STRLEN(alias->u.constant);
-	} else {
-		trait_alias->alias = NULL;
+	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);
 	}
-	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));
+	if (op_array->fn_flags & ZEND_ACC_ABSTRACT) {
+		if (op_array->fn_flags & ZEND_ACC_PRIVATE) {
+			zend_error_noreturn(E_COMPILE_ERROR, "%s function %s::%s() cannot be declared private",
+				in_interface ? "Interface" : "Abstract", ce->name->val, name->val);
+		}
 
-	trait_precedence->trait_method = (zend_trait_method_reference*)method_reference->u.op.ptr;
-	trait_precedence->exclude_from_classes = (zend_class_entry**) trait_list->u.op.ptr;
+		if (has_body) {
+			zend_error_noreturn(E_COMPILE_ERROR, "%s function %s::%s() cannot contain body",
+				in_interface ? "Interface" : "Abstract", ce->name->val, name->val);
+		}
 
-	zend_add_to_list(&ce->trait_precedences, trait_precedence TSRMLS_CC);
-}
-/* }}} */
+		ce->ce_flags |= ZEND_ACC_IMPLICIT_ABSTRACT_CLASS;
+	} else if (!has_body) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Non-abstract method %s::%s() must contain body",
+			ce->name->val, name->val);
+	}
 
-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, **pce;
-	zval *op1, *op2;
+	op_array->scope = ce;
+	op_array->function_name = zend_string_copy(name);
 
-	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;
-	}
-	if (zend_hash_quick_find(class_table, Z_STRVAL_P(op1), Z_STRLEN_P(op1), Z_HASH_P(op1), (void **) &pce)==FAILURE) {
-		zend_error(E_COMPILE_ERROR, "Internal Zend error - Missing class information for %s", Z_STRVAL_P(op1));
-		return NULL;
-	} else {
-		ce = *pce;
+	lcname = zend_string_alloc(name->len, 0);
+	zend_str_tolower_copy(lcname->val, name->val, name->len);
+	lcname = zend_new_interned_string(lcname TSRMLS_CC);
+
+	if (zend_hash_add_ptr(&ce->function_table, lcname, op_array) == NULL) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare %s::%s()",
+			ce->name->val, name->val);
 	}
-	ce->refcount++;
-	if (zend_hash_quick_add(class_table, Z_STRVAL_P(op2), Z_STRLEN_P(op2)+1, Z_HASH_P(op2), &ce, sizeof(zend_class_entry *), NULL)==FAILURE) {
-		ce->refcount--;
-		if (!compile_time) {
-			/* If we're in compile time, in practice, it's quite possible
-			 * that we'll never reach this class declaration at runtime,
-			 * so we shut up about it.  This allows the if (!defined('FOO')) { return; }
-			 * approach to work.
-			 */
-			zend_error(E_COMPILE_ERROR, "Cannot redeclare class %s", ce->name);
+
+	if (in_interface) {
+		if (zend_string_equals_literal(lcname, ZEND_CALL_FUNC_NAME)) {
+			if (!is_public || is_static) {
+				zend_error(E_WARNING, "The magic method __call() must have "
+					"public visibility and cannot be static");
+			}
+		} else if (zend_string_equals_literal(lcname, ZEND_CALLSTATIC_FUNC_NAME)) {
+			if (!is_public || !is_static) {
+				zend_error(E_WARNING, "The magic method __callStatic() must have "
+					"public visibility and be static");
+			}
+		} else if (zend_string_equals_literal(lcname, ZEND_GET_FUNC_NAME)) {
+			if (!is_public || is_static) {
+				zend_error(E_WARNING, "The magic method __get() must have "
+					"public visibility and cannot be static");
+			}
+		} else if (zend_string_equals_literal(lcname, ZEND_SET_FUNC_NAME)) {
+			if (!is_public || is_static) {
+				zend_error(E_WARNING, "The magic method __set() must have "
+					"public visibility and cannot be static");
+			}
+		} else if (zend_string_equals_literal(lcname, ZEND_UNSET_FUNC_NAME)) {
+			if (!is_public || is_static) {
+				zend_error(E_WARNING, "The magic method __unset() must have "
+					"public visibility and cannot be static");
+			}
+		} else if (zend_string_equals_literal(lcname, ZEND_ISSET_FUNC_NAME)) {
+			if (!is_public || is_static) {
+				zend_error(E_WARNING, "The magic method __isset() must have "
+					"public visibility and cannot be static");
+			}
+		} else if (zend_string_equals_literal(lcname, ZEND_TOSTRING_FUNC_NAME)) {
+			if (!is_public || is_static) {
+				zend_error(E_WARNING, "The magic method __toString() must have "
+					"public visibility and cannot be static");
+			}
+		} else if (zend_string_equals_literal(lcname, ZEND_INVOKE_FUNC_NAME)) {
+			if (!is_public || is_static) {
+				zend_error(E_WARNING, "The magic method __invoke() must have "
+					"public visibility and cannot be static");
+			}
+		} else if (zend_string_equals_literal(lcname, ZEND_DEBUGINFO_FUNC_NAME)) {
+			if (!is_public || is_static) {
+				zend_error(E_WARNING, "The magic method __debugInfo() must have "
+					"public visibility and cannot be static");
+			}
 		}
-		return NULL;
 	} else {
-		if (!(ce->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_IMPLEMENT_INTERFACES|ZEND_ACC_IMPLEMENT_TRAITS))) {
-			zend_verify_abstract_class(ce TSRMLS_CC);
+		if (!in_trait && zend_string_equals_str_ci(lcname, ce->name)) {
+			if (!ce->constructor) {
+				ce->constructor = (zend_function *) op_array;
+			}
+		} else if (zend_string_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_string_equals_literal(lcname, ZEND_DESTRUCTOR_FUNC_NAME)) {
+			ce->destructor = (zend_function *) op_array;
+		} else if (zend_string_equals_literal(lcname, ZEND_CLONE_FUNC_NAME)) {
+			ce->clone = (zend_function *) op_array;
+		} else if (zend_string_equals_literal(lcname, ZEND_CALL_FUNC_NAME)) {
+			if (!is_public || is_static) {
+				zend_error(E_WARNING, "The magic method __call() must have "
+					"public visibility and cannot be static");
+			}
+			ce->__call = (zend_function *) op_array;
+		} else if (zend_string_equals_literal(lcname, ZEND_CALLSTATIC_FUNC_NAME)) {
+			if (!is_public || !is_static) {
+				zend_error(E_WARNING, "The magic method __callStatic() must have "
+					"public visibility and be static");
+			}
+			ce->__callstatic = (zend_function *) op_array;
+		} else if (zend_string_equals_literal(lcname, ZEND_GET_FUNC_NAME)) {
+			if (!is_public || is_static) {
+				zend_error(E_WARNING, "The magic method __get() must have "
+					"public visibility and cannot be static");
+			}
+			ce->__get = (zend_function *) op_array;
+		} else if (zend_string_equals_literal(lcname, ZEND_SET_FUNC_NAME)) {
+			if (!is_public || is_static) {
+				zend_error(E_WARNING, "The magic method __set() must have "
+					"public visibility and cannot be static");
+			}
+			ce->__set = (zend_function *) op_array;
+		} else if (zend_string_equals_literal(lcname, ZEND_UNSET_FUNC_NAME)) {
+			if (!is_public || is_static) {
+				zend_error(E_WARNING, "The magic method __unset() must have "
+					"public visibility and cannot be static");
+			}
+			ce->__unset = (zend_function *) op_array;
+		} else if (zend_string_equals_literal(lcname, ZEND_ISSET_FUNC_NAME)) {
+			if (!is_public || is_static) {
+				zend_error(E_WARNING, "The magic method __isset() must have "
+					"public visibility and cannot be static");
+			}
+			ce->__isset = (zend_function *) op_array;
+		} else if (zend_string_equals_literal(lcname, ZEND_TOSTRING_FUNC_NAME)) {
+			if (!is_public || is_static) {
+				zend_error(E_WARNING, "The magic method __toString() must have "
+					"public visibility and cannot be static");
+			}
+			ce->__tostring = (zend_function *) op_array;
+		} else if (zend_string_equals_literal(lcname, ZEND_INVOKE_FUNC_NAME)) {
+			if (!is_public || is_static) {
+				zend_error(E_WARNING, "The magic method __invoke() must have "
+					"public visibility and cannot be static");
+			}
+		} else if (zend_string_equals_literal(lcname, ZEND_DEBUGINFO_FUNC_NAME)) {
+			if (!is_public || is_static) {
+				zend_error(E_WARNING, "The magic method __debugInfo() must have "
+					"public visibility and cannot be static");
+			}
+			ce->__debugInfo = (zend_function *) op_array;
+		} else if (!is_static) {
+			op_array->fn_flags |= ZEND_ACC_ALLOW_STATIC;
 		}
-		return ce;
 	}
+
+	zend_string_release(lcname);
 }
 /* }}} */
 
-ZEND_API zend_class_entry *do_bind_inherited_class(const zend_op_array *op_array, const zend_op *opline, HashTable *class_table, zend_class_entry *parent_ce, zend_bool compile_time TSRMLS_DC) /* {{{ */
+static void zend_begin_func_decl(znode *result, zend_op_array *op_array, zend_ast_decl *decl TSRMLS_DC) /* {{{ */
 {
-	zend_class_entry *ce, **pce;
-	int found_ce;
-	zval *op1, *op2;
+	zend_ast *params_ast = decl->child[0];
+	zend_string *name = decl->name, *lcname;
+	zend_op *opline;
 
-	if (compile_time) {
-		op1 = &CONSTANT_EX(op_array, opline->op1.constant);
-		op2 = &CONSTANT_EX(op_array, opline->op2.constant);
-	} else {
-		op1 = opline->op1.zv;
-		op2 = opline->op2.zv;
-	}
+	op_array->function_name = name = zend_prefix_with_ns(name TSRMLS_CC);
 
-	found_ce = zend_hash_quick_find(class_table, Z_STRVAL_P(op1), Z_STRLEN_P(op1), Z_HASH_P(op1), (void **) &pce);
+	lcname = zend_string_alloc(name->len, 0);
+	zend_str_tolower_copy(lcname->val, name->val, name->len);
 
-	if (found_ce == FAILURE) {
-		if (!compile_time) {
-			/* If we're in compile time, in practice, it's quite possible
-			 * that we'll never reach this class declaration at runtime,
-			 * so we shut up about it.  This allows the if (!defined('FOO')) { return; }
-			 * approach to work.
-			 */
-			zend_error(E_COMPILE_ERROR, "Cannot redeclare class %s", Z_STRVAL_P(op2));
+	if (CG(current_import_function)) {
+		zend_string *import_name = zend_hash_find_ptr(CG(current_import_function), lcname);
+		if (import_name && !zend_string_equals_str_ci(lcname, import_name)) {
+			zend_error(E_COMPILE_ERROR, "Cannot declare function %s "
+				"because the name is already in use", name->val);
 		}
-		return NULL;
-	} else {
-		ce = *pce;
 	}
 
-	if (parent_ce->ce_flags & ZEND_ACC_INTERFACE) {
-		zend_error(E_COMPILE_ERROR, "Class %s cannot extend from interface %s", ce->name, parent_ce->name);
-	} else if ((parent_ce->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) {
-		zend_error(E_COMPILE_ERROR, "Class %s cannot extend from trait %s", ce->name, parent_ce->name);
+	if (zend_string_equals_literal(lcname, ZEND_AUTOLOAD_FUNC_NAME)
+		&& zend_ast_get_list(params_ast)->children != 1
+	) {
+		zend_error_noreturn(E_COMPILE_ERROR, "%s() must take exactly 1 argument",
+			ZEND_AUTOLOAD_FUNC_NAME);
 	}
 
-	zend_do_inheritance(ce, parent_ce TSRMLS_CC);
+	if (op_array->fn_flags & ZEND_ACC_CLOSURE) {
+		opline = zend_emit_op_tmp(result, ZEND_DECLARE_LAMBDA_FUNCTION, NULL, NULL TSRMLS_CC);
+	} else {
+		opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+		opline->opcode = ZEND_DECLARE_FUNCTION;
+		opline->op2_type = IS_CONST;
+		LITERAL_STR(opline->op2, zend_string_copy(lcname));
+	}
 
-	ce->refcount++;
+	{
+		zend_string *key = zend_build_runtime_definition_key(lcname, decl->lex_pos TSRMLS_CC);
 
-	/* Register the derived class */
-	if (zend_hash_quick_add(class_table, Z_STRVAL_P(op2), Z_STRLEN_P(op2)+1, Z_HASH_P(op2), pce, sizeof(zend_class_entry *), NULL)==FAILURE) {
-		zend_error(E_COMPILE_ERROR, "Cannot redeclare class %s", ce->name);
+		opline->op1_type = IS_CONST;
+		LITERAL_STR(opline->op1, key);
+
+		zend_hash_update_ptr(CG(function_table), key, op_array);
 	}
-	return ce;
+
+	zend_string_release(lcname);
 }
 /* }}} */
 
-void zend_do_early_binding(TSRMLS_D) /* {{{ */
+void zend_compile_func_decl(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	zend_op *opline = &CG(active_op_array)->opcodes[CG(active_op_array)->last-1];
-	HashTable *table;
+	zend_ast_decl *decl = (zend_ast_decl *) ast;
+	zend_ast *params_ast = decl->child[0];
+	zend_ast *uses_ast = decl->child[1];
+	zend_ast *stmt_ast = decl->child[2];
+	zend_bool is_method = decl->kind == ZEND_AST_METHOD;
 
-	while (opline->opcode == ZEND_TICKS && opline > CG(active_op_array)->opcodes) {
-		opline--;
-	}
+	zend_op_array *orig_op_array = CG(active_op_array);
+	zend_op_array *op_array = zend_arena_alloc(&CG(arena), sizeof(zend_op_array));
 
-	switch (opline->opcode) {
-		case ZEND_DECLARE_FUNCTION:
-			if (do_bind_function(CG(active_op_array), opline, CG(function_table), 1) == FAILURE) {
-				return;
-			}
-			table = CG(function_table);
-			break;
-		case ZEND_DECLARE_CLASS:
-			if (do_bind_class(CG(active_op_array), opline, CG(class_table), 1 TSRMLS_CC) == NULL) {
-				return;
-			}
-			table = CG(class_table);
-			break;
-		case ZEND_DECLARE_INHERITED_CLASS:
-			{
-				zend_op *fetch_class_opline = opline-1;
-				zval *parent_name;
-				zend_class_entry **pce;
-
-				parent_name = &CONSTANT(fetch_class_opline->op2.constant);
-				if ((zend_lookup_class(Z_STRVAL_P(parent_name), Z_STRLEN_P(parent_name), &pce TSRMLS_CC) == FAILURE) ||
-				    ((CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_CLASSES) &&
-				     ((*pce)->type == ZEND_INTERNAL_CLASS))) {
-				    if (CG(compiler_options) & ZEND_COMPILE_DELAYED_BINDING) {
-						zend_uint *opline_num = &CG(active_op_array)->early_binding;
-
-						while (*opline_num != -1) {
-							opline_num = &CG(active_op_array)->opcodes[*opline_num].result.opline_num;
-						}
-						*opline_num = opline - CG(active_op_array)->opcodes;
-						opline->opcode = ZEND_DECLARE_INHERITED_CLASS_DELAYED;
-						opline->result_type = IS_UNUSED;
-						opline->result.opline_num = -1;
-					}
-					return;
-				}
-				if (do_bind_inherited_class(CG(active_op_array), opline, CG(class_table), *pce, 1 TSRMLS_CC) == NULL) {
-					return;
-				}
-				/* clear unnecessary ZEND_FETCH_CLASS opcode */
-				zend_del_literal(CG(active_op_array), fetch_class_opline->op2.constant);
-				MAKE_NOP(fetch_class_opline);
+	// TODO.AST interactive (not just here - also bpc etc!)
+	
+	init_op_array(op_array, ZEND_USER_FUNCTION, INITIAL_OP_ARRAY_SIZE TSRMLS_CC);
 
-				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(E_COMPILE_ERROR, "Invalid binding type");
-			return;
+	op_array->fn_flags |= decl->flags;
+	op_array->line_start = decl->start_lineno;
+	op_array->line_end = decl->end_lineno;
+	if (decl->doc_comment) {
+		op_array->doc_comment = zend_string_copy(decl->doc_comment);
+	}
+	if (decl->kind == ZEND_AST_CLOSURE) {
+		op_array->fn_flags |= ZEND_ACC_CLOSURE;
 	}
 
-	zend_hash_quick_del(table, Z_STRVAL(CONSTANT(opline->op1.constant)), Z_STRLEN(CONSTANT(opline->op1.constant)), Z_HASH_P(&CONSTANT(opline->op1.constant)));
-	zend_del_literal(CG(active_op_array), opline->op1.constant);
-	zend_del_literal(CG(active_op_array), opline->op2.constant);
-	MAKE_NOP(opline);
-}
-/* }}} */
+	if (is_method) {
+		zend_bool has_body = stmt_ast != NULL;
+		zend_begin_method_decl(op_array, decl->name, has_body TSRMLS_CC);
+	} else {
+		zend_begin_func_decl(result, op_array, decl TSRMLS_CC);
+	}
 
-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);
-		zend_uint opline_num = op_array->early_binding;
-		zend_class_entry **pce;
+	CG(active_op_array) = op_array;
+	zend_stack_push(&CG(context_stack), (void *) &CG(context));
+	zend_init_compiler_context(TSRMLS_C);
 
-		CG(in_compilation) = 1;
-		while (opline_num != -1) {
-			if (zend_lookup_class(Z_STRVAL_P(op_array->opcodes[opline_num-1].op2.zv), Z_STRLEN_P(op_array->opcodes[opline_num-1].op2.zv), &pce TSRMLS_CC) == SUCCESS) {
-				do_bind_inherited_class(op_array, &op_array->opcodes[opline_num], EG(class_table), *pce, 0 TSRMLS_CC);
-			}
-			opline_num = op_array->opcodes[opline_num].result.opline_num;
-		}
-		CG(in_compilation) = orig_in_compilation;
+	if (CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO) {
+		zend_op *opline_ext = zend_emit_op(NULL, ZEND_EXT_NOP, NULL, NULL TSRMLS_CC);
+		opline_ext->lineno = decl->start_lineno;
 	}
-}
-/* }}} */
 
-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);
+	{
+		/* Push a separator to the loop variable stack */
+		znode dummy_var;
+		dummy_var.op_type = IS_UNUSED;
 
-	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;
+		zend_stack_push(&CG(loop_var_stack), (void *) &dummy_var);
 	}
-	SET_NODE(opline->op1, expr1);
-	SET_UNUSED(opline->op2);
 
-	op_token->u.op.opline_num = next_op_number;
+	zend_compile_params(params_ast TSRMLS_CC);
+	if (uses_ast) {
+		zend_compile_closure_uses(uses_ast TSRMLS_CC);
+	}
+	zend_compile_stmt(stmt_ast TSRMLS_CC);
 
-	GET_NODE(expr1, opline->result);
-}
-/* }}} */
+	if (is_method) {
+		zend_check_magic_method_implementation(
+			CG(active_class_entry), (zend_function *) op_array, E_COMPILE_ERROR TSRMLS_CC);
+	}
 
-void zend_do_boolean_or_end(znode *result, const znode *expr1, const znode *expr2, znode *op_token TSRMLS_DC) /* {{{ */
-{
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	zend_do_extended_info(TSRMLS_C);
+	zend_emit_final_return(NULL 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);
+	pass_two(CG(active_op_array) TSRMLS_CC);
+	zend_release_labels(0 TSRMLS_CC);
+
+	/* Pop the loop variable stack separator */
+	zend_stack_del_top(&CG(loop_var_stack));
 
-	CG(active_op_array)->opcodes[op_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array));
+	CG(active_op_array) = orig_op_array;
 }
 /* }}} */
 
-void zend_do_boolean_and_begin(znode *expr1, znode *op_token TSRMLS_DC) /* {{{ */
+void zend_compile_prop_decl(zend_ast *ast 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_ast_list *list = zend_ast_get_list(ast);
+	uint32_t flags = list->attr;
+	zend_class_entry *ce = CG(active_class_entry);
+	uint32_t i, children = list->children;
+	zend_string *doc_comment = NULL;
 
-	opline->opcode = ZEND_JMPZ_EX;
-	if (expr1->op_type == IS_TMP_VAR) {
-		SET_NODE(opline->result, expr1);
-	} else {
-		opline->result.var = get_temporary_variable(CG(active_op_array));
-		opline->result_type = IS_TMP_VAR;
+	if (ce->ce_flags & ZEND_ACC_INTERFACE) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Interfaces may not include member variables");
 	}
-	SET_NODE(opline->op1, expr1);
-	SET_UNUSED(opline->op2);
 
-	op_token->u.op.opline_num = next_op_number;
+	if (flags & ZEND_ACC_ABSTRACT) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Properties cannot be declared abstract");
+	}
 
-	GET_NODE(expr1, opline->result);
-}
-/* }}} */
+	/* Doc comment has been appended as last element in property list */
+	if (list->child[children - 1]->kind == ZEND_AST_ZVAL) {
+		doc_comment = zend_string_copy(zend_ast_get_str(list->child[children - 1]));
+		children -= 1;
+	}
 
-void zend_do_boolean_and_end(znode *result, const znode *expr1, const znode *expr2, const znode *op_token TSRMLS_DC) /* {{{ */
-{
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	for (i = 0; i < children; ++i) {
+		zend_ast *prop_ast = list->child[i];
+		zend_ast *name_ast = prop_ast->child[0];
+		zend_ast *value_ast = prop_ast->child[1];
+		zend_string *name = zend_ast_get_str(name_ast);
+		zval value_zv;
 
-	*result = *expr1; /* we saved the original result in expr1 */
-	opline->opcode = ZEND_BOOL;
-	SET_NODE(opline->result, result);
-	SET_NODE(opline->op1, expr2);
-	SET_UNUSED(opline->op2);
+		if (flags & ZEND_ACC_FINAL) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Cannot declare property %s::$%s final, "
+				"the final modifier is allowed only for methods and classes",
+				ce->name->val, name->val);
+		}
 
-	CG(active_op_array)->opcodes[op_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array));
-}
-/* }}} */
+		if (zend_hash_exists(&ce->properties_info, name)) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare %s::$%s",
+				ce->name->val, name->val);
+		}
 
-void zend_do_do_while_begin(TSRMLS_D) /* {{{ */
-{
-	do_begin_loop(TSRMLS_C);
-	INC_BPC(CG(active_op_array));
+		if (value_ast) {
+			zend_const_expr_to_zval(&value_zv, value_ast TSRMLS_CC);
+		} else {
+			ZVAL_NULL(&value_zv);
+		}
+
+		name = zend_new_interned_string_safe(name TSRMLS_CC);
+		zend_declare_property_ex(ce, name, &value_zv, flags, doc_comment TSRMLS_CC);
+
+		/* Doc comment is only assigned to first property */
+		doc_comment = NULL;
+	}
 }
 /* }}} */
 
-void zend_do_do_while_end(const znode *do_token, const znode *expr_open_bracket, const znode *expr TSRMLS_DC) /* {{{ */
+void zend_compile_class_const_decl(zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	zend_ast_list *list = zend_ast_get_list(ast);
+	zend_class_entry *ce = CG(active_class_entry);
+	uint32_t i;
 
-	opline->opcode = ZEND_JMPNZ;
-	SET_NODE(opline->op1, expr);
-	opline->op2.opline_num = do_token->u.op.opline_num;
-	SET_UNUSED(opline->op2);
+	for (i = 0; i < list->children; ++i) {
+		zend_ast *const_ast = list->child[i];
+		zend_ast *name_ast = const_ast->child[0];
+		zend_ast *value_ast = const_ast->child[1];
+		zend_string *name = zend_ast_get_str(name_ast);
+		zval value_zv;
+
+		if (ZEND_CE_IS_TRAIT(ce)) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Traits cannot have constants");
+			return;
+		}
+
+		zend_const_expr_to_zval(&value_zv, value_ast TSRMLS_CC);
 
-	do_end_loop(expr_open_bracket->u.op.opline_num, 0 TSRMLS_CC);
+		name = zend_new_interned_string_safe(name TSRMLS_CC);
+		if (zend_hash_add(&ce->constants_table, name, &value_zv) == NULL) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Cannot redefine class constant %s::%s",
+				ce->name->val, name->val);
+		}
 
-	DEC_BPC(CG(active_op_array));
+		if (Z_CONSTANT(value_zv)) {
+			ce->ce_flags &= ~ZEND_ACC_CONSTANTS_UPDATED;
+		}
+	}
 }
 /* }}} */
 
-void zend_do_brk_cont(zend_uchar op, const znode *expr TSRMLS_DC) /* {{{ */
+static zend_trait_method_reference *zend_compile_method_ref(zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	zend_ast *class_ast = ast->child[0];
+	zend_ast *method_ast = ast->child[1];
 
-	opline->opcode = op;
-	opline->op1.opline_num = CG(context).current_brk_cont;
-	SET_UNUSED(opline->op1);
-	if (expr) {
-		if (expr->op_type != IS_CONST) {
-			zend_error(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(E_COMPILE_ERROR, "'%s' operator accepts only positive numbers", op == ZEND_BRK ? "break" : "continue");
-		}
-		SET_NODE(opline->op2, expr);
+	zend_trait_method_reference *method_ref = emalloc(sizeof(zend_trait_method_reference));
+	method_ref->ce = NULL;
+	method_ref->method_name = zend_string_copy(zend_ast_get_str(method_ast));
+
+	if (class_ast) {
+		method_ref->class_name = zend_resolve_class_name_ast(class_ast TSRMLS_CC);
 	} else {
-		LITERAL_LONG(opline->op2, 1);
-		opline->op2_type = IS_CONST;
+		method_ref->class_name = NULL;
 	}
+
+	return method_ref;
 }
 /* }}} */
 
-void zend_do_switch_cond(const znode *cond TSRMLS_DC) /* {{{ */
+static zend_string **zend_compile_name_list(zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	zend_switch_entry switch_entry;
+	zend_ast_list *list = zend_ast_get_list(ast);
+	zend_string **names = safe_emalloc(sizeof(zend_string *), list->children + 1, 0);
+	uint32_t i;
 
-	switch_entry.cond = *cond;
-	switch_entry.default_case = -1;
-	switch_entry.control_var = -1;
-	zend_stack_push(&CG(switch_cond_stack), (void *) &switch_entry, sizeof(switch_entry));
+	for (i = 0; i < list->children; ++i) {
+		zend_ast *name_ast = list->child[i];
+		names[i] = zend_resolve_class_name_ast(name_ast TSRMLS_CC);
+	}
 
-	do_begin_loop(TSRMLS_C);
+	names[list->children] = NULL;
 
-	INC_BPC(CG(active_op_array));
+	return names;
 }
 /* }}} */
 
-void zend_do_switch_end(const znode *case_list TSRMLS_DC) /* {{{ */
+static void zend_compile_trait_precedence(zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	zend_op *opline;
-	zend_switch_entry *switch_entry_ptr;
+	zend_ast *method_ref_ast = ast->child[0];
+	zend_ast *insteadof_ast = ast->child[1];
+	
+	zend_trait_precedence *precedence = emalloc(sizeof(zend_trait_precedence));
+	precedence->trait_method = zend_compile_method_ref(method_ref_ast TSRMLS_CC);
+	precedence->exclude_from_classes
+		= (void *) zend_compile_name_list(insteadof_ast TSRMLS_CC);
 
-	zend_stack_top(&CG(switch_cond_stack), (void **) &switch_entry_ptr);
+	zend_add_to_list(&CG(active_class_entry)->trait_precedences, precedence TSRMLS_CC);
+}
+/* }}} */
 
-	/* 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;
-	}
+static void zend_compile_trait_alias(zend_ast *ast TSRMLS_DC) /* {{{ */
+{
+	zend_ast *method_ref_ast = ast->child[0];
+	zend_ast *alias_ast = ast->child[1];
+	uint32_t modifiers = ast->attr;
 
-	if (case_list->op_type != IS_UNUSED) { /* non-empty switch */
-		int next_op_number = get_next_op_number(CG(active_op_array));
+	zend_trait_alias *alias;
 
-		CG(active_op_array)->opcodes[case_list->u.op.opline_num].op1.opline_num = next_op_number;
+	if (modifiers == ZEND_ACC_STATIC) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Cannot use 'static' as method modifier");
+	} else if (modifiers == ZEND_ACC_ABSTRACT) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Cannot use 'abstract' as method modifier");
+	} else if (modifiers == ZEND_ACC_FINAL) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Cannot use 'final' as method modifier");
 	}
 
-	/* remember break/continue loop information */
-	CG(active_op_array)->brk_cont_array[CG(context).current_brk_cont].cont = CG(active_op_array)->brk_cont_array[CG(context).current_brk_cont].brk = get_next_op_number(CG(active_op_array));
-	CG(context).current_brk_cont = CG(active_op_array)->brk_cont_array[CG(context).current_brk_cont].parent;
+	alias = emalloc(sizeof(zend_trait_alias));
+	alias->trait_method = zend_compile_method_ref(method_ref_ast TSRMLS_CC);
+	alias->modifiers = modifiers;
 
-	if (switch_entry_ptr->cond.op_type==IS_VAR || switch_entry_ptr->cond.op_type==IS_TMP_VAR) {
-		/* emit free for the switch condition*/
-		opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-		opline->opcode = (switch_entry_ptr->cond.op_type == IS_TMP_VAR) ? ZEND_FREE : ZEND_SWITCH_FREE;
-		SET_NODE(opline->op1, &switch_entry_ptr->cond);
-		SET_UNUSED(opline->op2);
-	}
-	if (switch_entry_ptr->cond.op_type == IS_CONST) {
-		zval_dtor(&switch_entry_ptr->cond.u.constant);
+	if (alias_ast) {
+		alias->alias = zend_string_copy(zend_ast_get_str(alias_ast));
+	} else {
+		alias->alias = NULL;
 	}
 
-	zend_stack_del_top(&CG(switch_cond_stack));
-
-	DEC_BPC(CG(active_op_array));
+	zend_add_to_list(&CG(active_class_entry)->trait_aliases, alias TSRMLS_CC);
 }
 /* }}} */
 
-void zend_do_case_before_statement(const znode *case_list, znode *case_token, const znode *case_expr TSRMLS_DC) /* {{{ */
+void zend_compile_use_trait(zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	int next_op_number;
-	zend_switch_entry *switch_entry_ptr;
-	znode result;
+	zend_ast_list *traits = zend_ast_get_list(ast->child[0]);
+	zend_ast_list *adaptations = ast->child[1] ? zend_ast_get_list(ast->child[1]) : NULL;
+	zend_class_entry *ce = CG(active_class_entry);
+	zend_op *opline;
+	uint32_t i;
 
-	zend_stack_top(&CG(switch_cond_stack), (void **) &switch_entry_ptr);
+	for (i = 0; i < traits->children; ++i) {
+		zend_ast *trait_ast = traits->child[i];
+		zend_string *name = zend_ast_get_str(trait_ast);
 
-	if (switch_entry_ptr->control_var == -1) {
-		switch_entry_ptr->control_var = get_temporary_variable(CG(active_op_array));
-	}
-	opline->opcode = ZEND_CASE;
-	opline->result.var = switch_entry_ptr->control_var;
-	opline->result_type = IS_TMP_VAR;
-	SET_NODE(opline->op1, &switch_entry_ptr->cond);
-	SET_NODE(opline->op2, case_expr);
-	if (opline->op1_type == IS_CONST) {
-		zval_copy_ctor(&CONSTANT(opline->op1.constant));
-	}
-	GET_NODE(&result, opline->result);
+		if (ce->ce_flags & ZEND_ACC_INTERFACE) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Cannot use traits inside of interfaces. "
+				"%s is used in %s", name->val, ce->name->val);
+		}
 
-	next_op_number = get_next_op_number(CG(active_op_array));
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	opline->opcode = ZEND_JMPZ;
-	SET_NODE(opline->op1, &result);
-	SET_UNUSED(opline->op2);
-	case_token->u.op.opline_num = next_op_number;
+		switch (zend_get_class_fetch_type(name)) {
+			case ZEND_FETCH_CLASS_SELF:
+			case ZEND_FETCH_CLASS_PARENT:
+			case ZEND_FETCH_CLASS_STATIC:
+				zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as trait name "
+					"as it is reserved", name->val);
+				break;
+		}
 
-	if (case_list->op_type==IS_UNUSED) {
-		return;
-	}
-	next_op_number = get_next_op_number(CG(active_op_array));
-	CG(active_op_array)->opcodes[case_list->u.op.opline_num].op1.opline_num = next_op_number;
-}
-/* }}} */
+		opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+		opline->opcode = ZEND_ADD_TRAIT;
+		SET_NODE(opline->op1, &CG(implementing_class));
+		opline->extended_value = ZEND_FETCH_CLASS_TRAIT;
+		opline->op2_type = IS_CONST;
+		opline->op2.constant = zend_add_class_name_literal(CG(active_op_array),
+			zend_resolve_class_name_ast(trait_ast TSRMLS_CC) TSRMLS_CC);
 
-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);
+		ce->num_traits++;
+	}
 
-	opline->opcode = ZEND_JMP;
-	SET_UNUSED(opline->op1);
-	SET_UNUSED(opline->op2);
-	result->u.op.opline_num = next_op_number;
+	if (!adaptations) {
+		return;
+	}
 
-	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;
+	for (i = 0; i < adaptations->children; ++i) {
+		zend_ast *adaptation_ast = adaptations->child[i];
+		switch (adaptation_ast->kind) {
+			case ZEND_AST_TRAIT_PRECEDENCE:
+				zend_compile_trait_precedence(adaptation_ast TSRMLS_CC);
+				break;
+			case ZEND_AST_TRAIT_ALIAS:
+				zend_compile_trait_alias(adaptation_ast TSRMLS_CC);
+				break;
+			EMPTY_SWITCH_DEFAULT_CASE()
+		}
 	}
 }
 /* }}} */
 
-void zend_do_default_before_statement(const znode *case_list, znode *default_token TSRMLS_DC) /* {{{ */
+void zend_compile_implements(znode *class_node, zend_ast *ast 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_ast_list *list = zend_ast_get_list(ast);
+	uint32_t i;
+	for (i = 0; i < list->children; ++i) {
+		zend_ast *class_ast = list->child[i];
+		zend_string *name = zend_ast_get_str(class_ast);
 
-	zend_stack_top(&CG(switch_cond_stack), (void **) &switch_entry_ptr);
+		zend_op *opline;
 
-	opline->opcode = ZEND_JMP;
-	SET_UNUSED(opline->op1);
-	SET_UNUSED(opline->op2);
-	default_token->u.op.opline_num = next_op_number;
+		/* Traits can not implement interfaces */
+		if (ZEND_CE_IS_TRAIT(CG(active_class_entry))) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as interface on '%s' "
+				"since it is a Trait", name->val, CG(active_class_entry)->name->val);
+		}
 
-	next_op_number = get_next_op_number(CG(active_op_array));
-	switch_entry_ptr->default_case = next_op_number;
+		if (!zend_is_const_default_class_ref(class_ast)) {
+			zend_error_noreturn(E_COMPILE_ERROR,
+				"Cannot use '%s' as interface name as it is reserved", name->val);
+		}
 
-	if (case_list->op_type==IS_UNUSED) {
-		return;
+		opline = zend_emit_op(NULL, ZEND_ADD_INTERFACE, class_node, NULL TSRMLS_CC);
+		opline->extended_value = ZEND_FETCH_CLASS_INTERFACE;
+		opline->op2_type = IS_CONST;
+		opline->op2.constant = zend_add_class_name_literal(CG(active_op_array),
+			zend_resolve_class_name_ast(class_ast TSRMLS_CC) TSRMLS_CC);
+
+		CG(active_class_entry)->num_interfaces++;
 	}
-	CG(active_op_array)->opcodes[case_list->u.op.opline_num].op1.opline_num = next_op_number;
 }
 /* }}} */
 
-void zend_do_begin_class_declaration(const znode *class_token, znode *class_name, const znode *parent_class_name TSRMLS_DC) /* {{{ */
+void zend_compile_class_decl(zend_ast *ast TSRMLS_DC) /* {{{ */
 {
+	zend_ast_decl *decl = (zend_ast_decl *) ast;
+	zend_ast *extends_ast = decl->child[0];
+	zend_ast *implements_ast = decl->child[1];
+	zend_ast *stmt_ast = decl->child[2];
+
+	zend_string *name = decl->name, *lcname, *import_name = NULL;
+	zend_class_entry *ce = zend_arena_alloc(&CG(arena), sizeof(zend_class_entry));
 	zend_op *opline;
-	int doing_inheritance = 0;
-	zend_class_entry *new_class_entry;
-	char *lcname;
-	int error = 0;
-	zval **ns_name, key;
+	znode declare_node, extends_node;
 
 	if (CG(active_class_entry)) {
-		zend_error(E_COMPILE_ERROR, "Class declarations may not be nested");
+		zend_error_noreturn(E_COMPILE_ERROR, "Class declarations may not be nested");
 		return;
 	}
 
-	lcname = zend_str_tolower_dup(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant));
-
-	if (!(strcmp(lcname, "self") && strcmp(lcname, "parent"))) {
-		efree(lcname);
-		zend_error(E_COMPILE_ERROR, "Cannot use '%s' as class name as it is reserved", Z_STRVAL(class_name->u.constant));
+	if (ZEND_FETCH_CLASS_DEFAULT != zend_get_class_fetch_type(name)) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as class name as it is reserved",
+			name->val);
 	}
 
-	/* Class name must not conflict with import names */
-	if (CG(current_import) &&
-	    zend_hash_find(CG(current_import), lcname, Z_STRLEN(class_name->u.constant)+1, (void**)&ns_name) == SUCCESS) {
-		error = 1;
+	lcname = zend_string_alloc(name->len, 0);
+	zend_str_tolower_copy(lcname->val, name->val, name->len);
+
+	if (CG(current_import)) {
+		import_name = zend_hash_find_ptr(CG(current_import), lcname);
 	}
 
 	if (CG(current_namespace)) {
-		/* Prefix class name with name of current namespace */
-		znode tmp;
+		name = zend_prefix_with_ns(name TSRMLS_CC);
+
+		zend_string_release(lcname);
+		lcname = zend_string_alloc(name->len, 0);
+		zend_str_tolower_copy(lcname->val, name->val, name->len);
+	} else {
+		zend_string_addref(name);
+	}
 
-		tmp.op_type = IS_CONST;
-		tmp.u.constant = *CG(current_namespace);
-		zval_copy_ctor(&tmp.u.constant);
-		zend_do_build_namespace_name(&tmp, &tmp, class_name TSRMLS_CC);
-		*class_name = tmp;
-		efree(lcname);
-		lcname = zend_str_tolower_dup(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant));
+	if (import_name && !zend_string_equals_str_ci(lcname, import_name)) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Cannot declare class %s "
+			"because the name is already in use", name->val);
 	}
 
-	if (error) {
-		char *tmp = zend_str_tolower_dup(Z_STRVAL_PP(ns_name), Z_STRLEN_PP(ns_name));
+	name = zend_new_interned_string(name TSRMLS_CC);
+	lcname = zend_new_interned_string(lcname TSRMLS_CC);
 
-		if (Z_STRLEN_PP(ns_name) != Z_STRLEN(class_name->u.constant) ||
-			memcmp(tmp, lcname, Z_STRLEN(class_name->u.constant))) {
-			zend_error(E_COMPILE_ERROR, "Cannot declare class %s because the name is already in use", Z_STRVAL(class_name->u.constant));
-		}
-		efree(tmp);
-	}
+	ce->type = ZEND_USER_CLASS;
+	ce->name = name;
+	zend_initialize_class_data(ce, 1 TSRMLS_CC);
 
-	new_class_entry = emalloc(sizeof(zend_class_entry));
-	new_class_entry->type = ZEND_USER_CLASS;
-	new_class_entry->name = zend_new_interned_string(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant) + 1, 1 TSRMLS_CC);
-	new_class_entry->name_length = Z_STRLEN(class_name->u.constant);
+	ce->ce_flags |= decl->flags;
+	ce->info.user.filename = zend_get_compiled_filename(TSRMLS_C);
+	ce->info.user.line_start = decl->start_lineno;
+	ce->info.user.line_end = decl->end_lineno;
+	if (decl->doc_comment) {
+		ce->info.user.doc_comment = zend_string_copy(decl->doc_comment);
+	}
 
-	zend_initialize_class_data(new_class_entry, 1 TSRMLS_CC);
-	new_class_entry->info.user.filename = zend_get_compiled_filename(TSRMLS_C);
-	new_class_entry->info.user.line_start = class_token->u.op.opline_num;
-	new_class_entry->ce_flags |= class_token->EA;
+	if (extends_ast) {
+		if (ZEND_CE_IS_TRAIT(ce)) {
+			zend_error_noreturn(E_COMPILE_ERROR, "A trait (%s) cannot extend a class. "
+				"Traits can only be composed from other traits with the 'use' keyword. Error",
+				name->val);
+		}
 
-	if (parent_class_name && parent_class_name->op_type != IS_UNUSED) {
-		switch (parent_class_name->EA) {
-			case ZEND_FETCH_CLASS_SELF:
-				zend_error(E_COMPILE_ERROR, "Cannot use 'self' as class name as it is reserved");
-				break;
-			case ZEND_FETCH_CLASS_PARENT:
-				zend_error(E_COMPILE_ERROR, "Cannot use 'parent' as class name as it is reserved");
-				break;
-			case ZEND_FETCH_CLASS_STATIC:
-				zend_error(E_COMPILE_ERROR, "Cannot use 'static' as class name as it is reserved");
-				break;
-			default:
-				break;
+		if (!zend_is_const_default_class_ref(extends_ast)) {
+			zend_string *extends_name = zend_ast_get_str(extends_ast);
+			zend_error_noreturn(E_COMPILE_ERROR,
+				"Cannot use '%s' as class name as it is reserved", extends_name->val);
 		}
-		doing_inheritance = 1;
+
+		zend_compile_class_ref(&extends_node, extends_ast TSRMLS_CC);
 	}
 
 	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	opline->op1_type = IS_CONST;
-	build_runtime_defined_function_key(&key, lcname, new_class_entry->name_length TSRMLS_CC);
-	opline->op1.constant = zend_add_literal(CG(active_op_array), &key TSRMLS_CC);
-	Z_HASH_P(&CONSTANT(opline->op1.constant)) = zend_hash_func(Z_STRVAL(CONSTANT(opline->op1.constant)), Z_STRLEN(CONSTANT(opline->op1.constant)));
+	zend_make_var_result(&declare_node, opline TSRMLS_CC);
 
-	opline->op2_type = IS_CONST;
+	// TODO.AST drop this
+	GET_NODE(&CG(implementing_class), opline->result);
 
-	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(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);
-		}
+	opline->op2_type = IS_CONST;
+	LITERAL_STR(opline->op2, lcname);
 
-		opline->extended_value = parent_class_name->u.op.var;
+	if (extends_ast) {
 		opline->opcode = ZEND_DECLARE_INHERITED_CLASS;
+		opline->extended_value = extends_node.u.op.var;
 	} else {
 		opline->opcode = ZEND_DECLARE_CLASS;
 	}
 
-	LITERAL_STRINGL(opline->op2, lcname, new_class_entry->name_length, 0);
-	CALCULATE_LITERAL_HASH(opline->op2.constant);
-
-	zend_hash_quick_update(CG(class_table), Z_STRVAL(key), Z_STRLEN(key), Z_HASH_P(&CONSTANT(opline->op1.constant)), &new_class_entry, sizeof(zend_class_entry *), NULL);
-	CG(active_class_entry) = new_class_entry;
+	{
+		zend_string *key = zend_build_runtime_definition_key(lcname, decl->lex_pos TSRMLS_CC);
 
-	opline->result.var = get_temporary_variable(CG(active_op_array));
-	opline->result_type = IS_VAR;
-	GET_NODE(&CG(implementing_class), opline->result);
+		opline->op1_type = IS_CONST;
+		LITERAL_STR(opline->op1, key);
 
-	if (CG(doc_comment)) {
-		CG(active_class_entry)->info.user.doc_comment = CG(doc_comment);
-		CG(active_class_entry)->info.user.doc_comment_len = CG(doc_comment_len);
-		CG(doc_comment) = NULL;
-		CG(doc_comment_len) = 0;
+		zend_hash_update_ptr(CG(class_table), key, ce);
 	}
-}
-/* }}} */
 
-static void do_verify_abstract_class(TSRMLS_D) /* {{{ */
-{
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	CG(active_class_entry) = ce;
 
-	opline->opcode = ZEND_VERIFY_ABSTRACT_CLASS;
-	SET_NODE(opline->op1, &CG(implementing_class));
-	SET_UNUSED(opline->op2);
-}
-/* }}} */
+	if (implements_ast) {
+		zend_compile_implements(&declare_node, implements_ast TSRMLS_CC);
+	}
 
-void zend_do_end_class_declaration(const znode *class_token, const znode *parent_token TSRMLS_DC) /* {{{ */
-{
-	zend_class_entry *ce = CG(active_class_entry);
+	zend_compile_stmt(stmt_ast TSRMLS_CC);
 
 	if (ce->constructor) {
 		ce->constructor->common.fn_flags |= ZEND_ACC_CTOR;
 		if (ce->constructor->common.fn_flags & ZEND_ACC_STATIC) {
-			zend_error(E_COMPILE_ERROR, "Constructor %s::%s() cannot be static", ce->name, ce->constructor->common.function_name);
+			zend_error_noreturn(E_COMPILE_ERROR, "Constructor %s::%s() cannot be static",
+				ce->name->val, ce->constructor->common.function_name->val);
 		}
 	}
 	if (ce->destructor) {
 		ce->destructor->common.fn_flags |= ZEND_ACC_DTOR;
 		if (ce->destructor->common.fn_flags & ZEND_ACC_STATIC) {
-			zend_error(E_COMPILE_ERROR, "Destructor %s::%s() cannot be static", ce->name, ce->destructor->common.function_name);
+			zend_error_noreturn(E_COMPILE_ERROR, "Destructor %s::%s() cannot be static",
+				ce->name->val, ce->destructor->common.function_name->val);
 		}
 	}
 	if (ce->clone) {
 		ce->clone->common.fn_flags |= ZEND_ACC_CLONE;
 		if (ce->clone->common.fn_flags & ZEND_ACC_STATIC) {
-			zend_error(E_COMPILE_ERROR, "Clone method %s::%s() cannot be static", ce->name, ce->clone->common.function_name);
+			zend_error_noreturn(E_COMPILE_ERROR, "Clone method %s::%s() cannot be static",
+				ce->name->val, ce->clone->common.function_name->val);
 		}
 	}
 
-	ce->info.user.line_end = zend_get_compiled_lineno(TSRMLS_C);
-
 	/* Check for traits and proceed like with interfaces.
 	 * The only difference will be a combined handling of them in the end.
 	 * Thus, we need another opcode here. */
 	if (ce->num_traits > 0) {
-		zend_op *opline;
-
 		ce->traits = NULL;
 		ce->num_traits = 0;
 		ce->ce_flags |= ZEND_ACC_IMPLEMENT_TRAITS;
 
-		/* opcode generation: */
-		opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-		opline->opcode = ZEND_BIND_TRAITS;
-		SET_NODE(opline->op1, &CG(implementing_class));
+		zend_emit_op(NULL, ZEND_BIND_TRAITS, &declare_node, NULL TSRMLS_CC);
 	}
 
 	if (!(ce->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS))
-		&& (parent_token || (ce->num_interfaces > 0))) {
+		&& (extends_ast || 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);
+			zend_emit_op(NULL, ZEND_VERIFY_ABSTRACT_CLASS, &declare_node, NULL TSRMLS_CC);
 		}
 	}
+
 	/* 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
@@ -5139,2077 +4612,1757 @@ void zend_do_end_class_declaration(const znode *class_token, const znode *parent
 }
 /* }}} */
 
-void zend_do_implements_interface(znode *interface_name TSRMLS_DC) /* {{{ */
+static HashTable *zend_get_import_ht(uint32_t type TSRMLS_DC) /* {{{ */
 {
-	zend_op *opline;
-
-	/* Traits can not implement interfaces */
-	if ((CG(active_class_entry)->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) {
-		zend_error(E_COMPILE_ERROR, "Cannot use '%s' as interface on '%s' since it is a Trait",
-							 Z_STRVAL(interface_name->u.constant),
-							 CG(active_class_entry)->name);
-	}
-
-	switch (zend_get_class_fetch_type(Z_STRVAL(interface_name->u.constant), Z_STRLEN(interface_name->u.constant))) {
-		case ZEND_FETCH_CLASS_SELF:
-		case ZEND_FETCH_CLASS_PARENT:
-		case ZEND_FETCH_CLASS_STATIC:
-			zend_error(E_COMPILE_ERROR, "Cannot use '%s' as interface name as it is reserved", Z_STRVAL(interface_name->u.constant));
-			break;
-		default:
-			break;
+	switch (type) {
+		case T_CLASS:
+			if (!CG(current_import)) {
+				CG(current_import) = emalloc(sizeof(HashTable));
+				zend_hash_init(CG(current_import), 8, NULL, str_dtor, 0);
+			}
+			return CG(current_import);
+		case T_FUNCTION:
+			if (!CG(current_import_function)) {
+				CG(current_import_function) = emalloc(sizeof(HashTable));
+				zend_hash_init(CG(current_import_function), 8, NULL, str_dtor, 0);
+			}
+			return CG(current_import_function);
+		case T_CONST:
+			if (!CG(current_import_const)) {
+				CG(current_import_const) = emalloc(sizeof(HashTable));
+				zend_hash_init(CG(current_import_const), 8, NULL, str_dtor, 0);
+			}
+			return CG(current_import_const);
+		EMPTY_SWITCH_DEFAULT_CASE()
 	}
-
-	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_do_use_trait(znode *trait_name TSRMLS_DC) /* {{{ */
+static char *zend_get_use_type_str(uint32_t type) /* {{{ */
 {
-	zend_op *opline;
-
-	if ((CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE)) {
-		zend_error(E_COMPILE_ERROR,
-				"Cannot use traits inside of interfaces. %s is used in %s",
-				Z_STRVAL(trait_name->u.constant), CG(active_class_entry)->name);
-	}
-
-
-	switch (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(E_COMPILE_ERROR, "Cannot use '%s' as trait name as it is reserved", Z_STRVAL(trait_name->u.constant));
-			break;
-		default:
-			break;
+	switch (type) {
+		case T_CLASS:
+			return "";
+		case T_FUNCTION:
+			return " function";
+		case T_CONST:
+			return " const";
+		EMPTY_SWITCH_DEFAULT_CASE()
 	}
-
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	opline->opcode = ZEND_ADD_TRAIT;
-	SET_NODE(opline->op1, &CG(implementing_class));
-	zend_resolve_class_name(trait_name TSRMLS_CC);
-	opline->extended_value = ZEND_FETCH_CLASS_TRAIT;
-	opline->op2_type = IS_CONST;
-	opline->op2.constant = zend_add_class_name_literal(CG(active_op_array), &trait_name->u.constant TSRMLS_CC);
-	CG(active_class_entry)->num_traits++;
 }
 /* }}} */
 
-ZEND_API void zend_mangle_property_name(char **dest, int *dest_length, const char *src1, int src1_length, const char *src2, int src2_length, int internal) /* {{{ */
+static void zend_check_already_in_use(uint32_t type, zend_string *old_name, zend_string *new_name, zend_string *check_name) /* {{{ */
 {
-	char *prop_name;
-	int prop_name_length;
-
-	prop_name_length = 1 + src1_length + 1 + src2_length;
-	prop_name = pemalloc(prop_name_length + 1, internal);
-	prop_name[0] = '\0';
-	memcpy(prop_name + 1, src1, src1_length+1);
-	memcpy(prop_name + 1 + src1_length + 1, src2, src2_length+1);
+	if (zend_string_equals_str_ci(old_name, check_name)) {
+		return;
+	}
 
-	*dest = prop_name;
-	*dest_length = prop_name_length;
+	zend_error_noreturn(E_COMPILE_ERROR, "Cannot use%s %s as %s because the name "
+		"is already in use", zend_get_use_type_str(type), old_name->val, new_name->val);
 }
 /* }}} */
 
-static int zend_strnlen(const char* s, int maxlen) /* {{{ */
+void zend_compile_use(zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	int len = 0;
-	while (*s++ && maxlen--) len++;
-	return len;
-}
-/* }}} */
+	zend_ast_list *list = zend_ast_get_list(ast);
+	uint32_t i;
+	zend_string *current_ns = CG(current_namespace);
+	uint32_t type = ast->attr;
+	HashTable *current_import = zend_get_import_ht(type TSRMLS_CC);
+	zend_bool case_sensitive = type == T_CONST;
 
-ZEND_API int zend_unmangle_property_name_ex(const char *mangled_property, int len, const char **class_name, const char **prop_name, int *prop_len) /* {{{ */
-{
-	int class_name_len;
+	for (i = 0; i < list->children; ++i) {
+		zend_ast *use_ast = list->child[i];
+		zend_ast *old_name_ast = use_ast->child[0];
+		zend_ast *new_name_ast = use_ast->child[1];
+		zend_string *old_name = zend_ast_get_str(old_name_ast);
+		zend_string *new_name, *lookup_name;
 
-	*class_name = NULL;
+		if (new_name_ast) {
+			new_name = zend_string_copy(zend_ast_get_str(new_name_ast));
+		} else {
+			const char *unqualified_name;
+			size_t unqualified_name_len;
+			if (zend_get_unqualified_name(old_name, &unqualified_name, &unqualified_name_len)) {
+				/* The form "use A\B" is eqivalent to "use A\B as B" */
+				new_name = zend_string_init(unqualified_name, unqualified_name_len, 0);
+			} else {
+				new_name = zend_string_copy(old_name);
 
-	if (mangled_property[0]!=0) {
-		*prop_name = mangled_property;
-		if (prop_len) {
-			*prop_len = len;
-		}
-		return SUCCESS;
-	}
-	if (len < 3 || mangled_property[1]==0) {
-		zend_error(E_NOTICE, "Illegal member variable name");
-		*prop_name = mangled_property;
-		if (prop_len) {
-			*prop_len = len;
-		}
-		return FAILURE;
-	}
+				if (!current_ns) {
+					if (type == T_CLASS && zend_string_equals_literal(new_name, "strict")) {
+						zend_error_noreturn(E_COMPILE_ERROR,
+							"You seem to be trying to use a different language...");
+					}
 
-	class_name_len = zend_strnlen(mangled_property + 1, --len - 1) + 1;
-	if (class_name_len >= len || mangled_property[class_name_len]!=0) {
-		zend_error(E_NOTICE, "Corrupt member variable name");
-		*prop_name = mangled_property;
-		if (prop_len) {
-			*prop_len = len + 1;
+					zend_error(E_WARNING, "The use statement with non-compound name '%s' "
+						"has no effect", new_name->val);
+				}
+			}
 		}
-		return FAILURE;
-	}
-	*class_name = mangled_property + 1;
-	*prop_name = (*class_name) + class_name_len;
-	if (prop_len) {
-		*prop_len = len - class_name_len;
-	}
-	return SUCCESS;
-}
-/* }}} */
 
-void zend_do_declare_property(const znode *var_name, const znode *value, zend_uint access_type TSRMLS_DC) /* {{{ */
-{
-	zval *property;
-	zend_property_info *existing_property_info;
-	char *comment = NULL;
-	int comment_len = 0;
+		if (case_sensitive) {
+			lookup_name = zend_string_copy(new_name);
+		} else {
+			lookup_name = zend_string_alloc(new_name->len, 0);
+			zend_str_tolower_copy(lookup_name->val, new_name->val, new_name->len);
+		}
 
-	if (CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE) {
-		zend_error(E_COMPILE_ERROR, "Interfaces may not include member variables");
-	}
+		if (type == T_CLASS && (zend_string_equals_literal(lookup_name, "self")
+			|| zend_string_equals_literal(lookup_name, "parent"))
+		) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Cannot use %s as %s because '%s' "
+				"is a special class name", old_name->val, new_name->val, new_name->val);
+		}
 
-	if (access_type & ZEND_ACC_ABSTRACT) {
-		zend_error(E_COMPILE_ERROR, "Properties cannot be declared abstract");
-	}
+		if (current_ns) {
+			zend_string *ns_name = zend_string_alloc(current_ns->len + 1 + new_name->len, 0);
+			zend_str_tolower_copy(ns_name->val, current_ns->val, current_ns->len);
+			ns_name->val[current_ns->len] = '\\';
+			memcpy(ns_name->val + current_ns->len + 1, lookup_name->val, lookup_name->len);
 
-	if (access_type & ZEND_ACC_FINAL) {
-		zend_error(E_COMPILE_ERROR, "Cannot declare property %s::$%s final, the final modifier is allowed only for methods and classes",
-				   CG(active_class_entry)->name, Z_STRVAL(var_name->u.constant));
-	}
+			if (zend_hash_exists(CG(class_table), ns_name)) {
+				zend_check_already_in_use(type, old_name, new_name, ns_name);
+			}
 
-	if (zend_hash_find(&CG(active_class_entry)->properties_info, Z_STRVAL(var_name->u.constant), Z_STRLEN(var_name->u.constant)+1, (void **) &existing_property_info)==SUCCESS) {
-		zend_error(E_COMPILE_ERROR, "Cannot redeclare %s::$%s", CG(active_class_entry)->name, Z_STRVAL(var_name->u.constant));
-	}
-	ALLOC_ZVAL(property);
+			zend_string_free(ns_name);
+		} else {
+			switch (type) {
+				case T_CLASS:
+				{
+					zend_class_entry *ce = zend_hash_find_ptr(CG(class_table), lookup_name);
+					if (ce && ce->type == ZEND_USER_CLASS
+						&& ce->info.user.filename == CG(compiled_filename)
+					) {
+						zend_check_already_in_use(type, old_name, new_name, lookup_name);
+					}
+					break;
+				}
+				case T_FUNCTION:
+				{
+					zend_function *fn = zend_hash_find_ptr(CG(function_table), lookup_name);
+					if (fn && fn->type == ZEND_USER_FUNCTION
+						&& fn->op_array.filename == CG(compiled_filename)
+					) {
+						zend_check_already_in_use(type, old_name, new_name, lookup_name);
+					}
+					break;
+				}
+				case T_CONST:
+				{
+					zend_string *filename = zend_hash_find_ptr(&CG(const_filenames), lookup_name);
+					if (filename && filename == CG(compiled_filename)) {
+						zend_check_already_in_use(type, old_name, new_name, lookup_name);
+					}
+					break;
+				}
+				EMPTY_SWITCH_DEFAULT_CASE()
+			}
+		}
 
-	if (value) {
-		*property = value->u.constant;
-	} else {
-		INIT_PZVAL(property);
-		Z_TYPE_P(property) = IS_NULL;
-	}
+		zend_string_addref(old_name);
+		if (!zend_hash_add_ptr(current_import, lookup_name, old_name)) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Cannot use%s %s as %s because the name "
+				"is already in use", zend_get_use_type_str(type), old_name->val, new_name->val);
+		}
 
-	if (CG(doc_comment)) {
-		comment = CG(doc_comment);
-		comment_len = CG(doc_comment_len);
-		CG(doc_comment) = NULL;
-		CG(doc_comment_len) = 0;
+		zend_string_release(lookup_name);
+		zend_string_release(new_name);
 	}
-
-	zend_declare_property_ex(CG(active_class_entry), zend_new_interned_string(Z_STRVAL(var_name->u.constant), Z_STRLEN(var_name->u.constant) + 1, 0 TSRMLS_CC), Z_STRLEN(var_name->u.constant), property, access_type, comment, comment_len TSRMLS_CC);
-	efree(Z_STRVAL(var_name->u.constant));
 }
 /* }}} */
 
-void zend_do_declare_class_constant(znode *var_name, const znode *value TSRMLS_DC) /* {{{ */
+void zend_compile_const_decl(zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	zval *property;
-	const char *cname = NULL;
-	zend_ulong hash;
+	zend_ast_list *list = zend_ast_get_list(ast);
+	uint32_t i;
+	for (i = 0; i < list->children; ++i) {
+		zend_ast *const_ast = list->child[i];
+		zend_ast *name_ast = const_ast->child[0];
+		zend_ast *value_ast = const_ast->child[1];
+		zend_string *name = zend_ast_get_str(name_ast);
 
-	if(Z_TYPE(value->u.constant) == IS_CONSTANT_ARRAY) {
-		zend_error(E_COMPILE_ERROR, "Arrays are not allowed in class constants");
-		return;
-	}
-	if ((CG(active_class_entry)->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) {
-		zend_error(E_COMPILE_ERROR, "Traits cannot have constants");
-		return;
-	}
+		zend_string *import_name;
+		znode name_node, value_node;
+		zval *value_zv = &value_node.u.constant;
 
-	ALLOC_ZVAL(property);
-	*property = value->u.constant;
+		value_node.op_type = IS_CONST;
+		zend_const_expr_to_zval(value_zv, value_ast TSRMLS_CC);
 
-	cname = zend_new_interned_string(Z_STRVAL(var_name->u.constant), Z_STRLEN(var_name->u.constant)+1, 0 TSRMLS_CC);
-	hash = str_hash(cname, Z_STRLEN(var_name->u.constant));
-	if (zend_hash_quick_add(&CG(active_class_entry)->constants_table, cname, Z_STRLEN(var_name->u.constant)+1, hash, &property, sizeof(zval *), NULL) == FAILURE) {
-		FREE_ZVAL(property);
-		zend_error(E_COMPILE_ERROR, "Cannot redefine class constant %s::%s", CG(active_class_entry)->name, Z_STRVAL(var_name->u.constant));
-	}
-	FREE_PNODE(var_name);
+		if (zend_lookup_reserved_const(name->val, name->len TSRMLS_CC)) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare constant '%s'", name->val);
+		}
 
-	if (CG(doc_comment)) {
-		efree(CG(doc_comment));
-		CG(doc_comment) = NULL;
-		CG(doc_comment_len) = 0;
+		name = zend_prefix_with_ns(name TSRMLS_CC);
+		name = zend_new_interned_string(name TSRMLS_CC);
+
+		if (CG(current_import_const)
+			&& (import_name = zend_hash_find_ptr(CG(current_import_const), name))
+		) {
+			if (!zend_string_equals(import_name, name)) {
+				zend_error(E_COMPILE_ERROR, "Cannot declare const %s because "
+					"the name is already in use", name->val);
+			}
+		}
+
+		name_node.op_type = IS_CONST;
+		ZVAL_STR(&name_node.u.constant, name);
+
+		zend_emit_op(NULL, ZEND_DECLARE_CONST, &name_node, &value_node TSRMLS_CC);
+
+		zend_hash_add_ptr(&CG(const_filenames), name, CG(compiled_filename));
 	}
 }
-/* }}} */
+/* }}}*/
 
-void zend_do_fetch_property(znode *result, znode *object, const znode *property TSRMLS_DC) /* {{{ */
+void zend_compile_namespace(zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	zend_op opline;
-	zend_llist *fetch_list_ptr;
-
-	zend_stack_top(&CG(bp_stack), (void **) &fetch_list_ptr);
-
-	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;
+	zend_ast *name_ast = ast->child[0];
+	zend_ast *stmt_ast = ast->child[1];
+	zend_string *name;
+	zend_bool with_bracket = stmt_ast != NULL;
 
-		if (opline_is_fetch_this(opline_ptr TSRMLS_CC)) {
-			zend_del_literal(CG(active_op_array), opline_ptr->op1.constant);
-			SET_UNUSED(opline_ptr->op1); /* this means $this for objects */
-			SET_NODE(opline_ptr->op2, property);
-			/* if it was usual fetch, we change it to object fetch */
-			switch (opline_ptr->opcode) {
-				case ZEND_FETCH_W:
-					opline_ptr->opcode = ZEND_FETCH_OBJ_W;
-					break;
-				case ZEND_FETCH_R:
-					opline_ptr->opcode = ZEND_FETCH_OBJ_R;
-					break;
-				case ZEND_FETCH_RW:
-					opline_ptr->opcode = ZEND_FETCH_OBJ_RW;
-					break;
-				case ZEND_FETCH_IS:
-					opline_ptr->opcode = ZEND_FETCH_OBJ_IS;
-					break;
-				case ZEND_FETCH_UNSET:
-					opline_ptr->opcode = ZEND_FETCH_OBJ_UNSET;
-					break;
-				case ZEND_FETCH_FUNC_ARG:
-					opline_ptr->opcode = ZEND_FETCH_OBJ_FUNC_ARG;
-					break;
-			}
-			if (opline_ptr->op2_type == IS_CONST && Z_TYPE(CONSTANT(opline_ptr->op2.constant)) == IS_STRING) {
-				CALCULATE_LITERAL_HASH(opline_ptr->op2.constant);
-				GET_POLYMORPHIC_CACHE_SLOT(opline_ptr->op2.constant);
+	/* handle mixed syntax declaration or nested namespaces */
+	if (!CG(has_bracketed_namespaces)) {
+		if (CG(current_namespace)) {
+			/* previous namespace declarations were unbracketed */
+			if (with_bracket) {
+				zend_error_noreturn(E_COMPILE_ERROR, "Cannot mix bracketed namespace declarations "
+					"with unbracketed namespace declarations");
 			}
-			GET_NODE(result, opline_ptr->result);
-			return;
+		}
+	} else {
+		/* previous namespace declarations were bracketed */
+		if (!with_bracket) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Cannot mix bracketed namespace declarations "
+				"with unbracketed namespace declarations");
+		} else if (CG(current_namespace) || CG(in_namespace)) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Namespace declarations cannot be nested");
 		}
 	}
 
-	if (zend_is_function_or_method_call(object)) {
-		init_op(&opline TSRMLS_CC);
-		opline.opcode = ZEND_SEPARATE;
-		SET_NODE(opline.op1, object);
-		SET_UNUSED(opline.op2);
-		opline.result_type = IS_VAR;
-		opline.result.var = opline.op1.var;
-		zend_llist_add_element(fetch_list_ptr, &opline);
+	if (((!with_bracket && !CG(current_namespace))
+		 || (with_bracket && !CG(has_bracketed_namespaces))) && CG(active_op_array)->last > 0
+	) {
+		/* ignore ZEND_EXT_STMT and ZEND_TICKS */
+		uint32_t num = CG(active_op_array)->last;
+		while (num > 0 &&
+		       (CG(active_op_array)->opcodes[num-1].opcode == ZEND_EXT_STMT ||
+		        CG(active_op_array)->opcodes[num-1].opcode == ZEND_TICKS)) {
+			--num;
+		}
+		if (num > 0) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Namespace declaration statement has to be "
+				"the very first statement in the script");
+		}
 	}
 
-	init_op(&opline TSRMLS_CC);
-	opline.opcode = ZEND_FETCH_OBJ_W;	/* the backpatching routine assumes W */
-	opline.result_type = IS_VAR;
-	opline.result.var = get_temporary_variable(CG(active_op_array));
-	SET_NODE(opline.op1, object);
-	SET_NODE(opline.op2, property);
-	if (opline.op2_type == IS_CONST && Z_TYPE(CONSTANT(opline.op2.constant)) == IS_STRING) {
-		CALCULATE_LITERAL_HASH(opline.op2.constant);
-		GET_POLYMORPHIC_CACHE_SLOT(opline.op2.constant);
+	if (CG(current_namespace)) {
+		zend_string_release(CG(current_namespace));
 	}
-	GET_NODE(result, opline.result);
 
-	zend_llist_add_element(fetch_list_ptr, &opline);
-}
-/* }}} */
+	if (name_ast) {
+		name = zend_ast_get_str(name_ast);
 
-void zend_do_halt_compiler_register(TSRMLS_D) /* {{{ */
-{
-	char *name, *cfilename;
-	char haltoff[] = "__COMPILER_HALT_OFFSET__";
-	int len, clen;
+		if (ZEND_FETCH_CLASS_DEFAULT != zend_get_class_fetch_type(name)) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as namespace name", name->val);
+		}
 
-	if (CG(has_bracketed_namespaces) && CG(in_namespace)) {
-		zend_error(E_COMPILE_ERROR, "__HALT_COMPILER() can only be used from the outermost scope");
+		CG(current_namespace) = zend_string_copy(name);
+	} else {
+		CG(current_namespace) = NULL;
 	}
 
-	cfilename = zend_get_compiled_filename(TSRMLS_C);
-	clen = strlen(cfilename);
-	zend_mangle_property_name(&name, &len, haltoff, sizeof(haltoff) - 1, cfilename, clen, 0);
-	zend_register_long_constant(name, len+1, zend_get_scanned_file_offset(TSRMLS_C), CONST_CS, 0 TSRMLS_CC);
-	pefree(name, 0);
+	zend_reset_import_tables(TSRMLS_C);
 
-	if (CG(in_namespace)) {
-		zend_do_end_namespace(TSRMLS_C);
+	CG(in_namespace) = 1;
+	if (with_bracket) {
+		CG(has_bracketed_namespaces) = 1;
 	}
-}
-/* }}} */
 
-void zend_do_push_object(const znode *object TSRMLS_DC) /* {{{ */
-{
-	zend_stack_push(&CG(object_stack), object, sizeof(znode));
-}
-/* }}} */
-
-void zend_do_pop_object(znode *object TSRMLS_DC) /* {{{ */
-{
-	if (object) {
-		znode *tmp;
-
-		zend_stack_top(&CG(object_stack), (void **) &tmp);
-		*object = *tmp;
+	if (stmt_ast) {
+		zend_compile_top_stmt(stmt_ast TSRMLS_CC);
+		zend_end_namespace(TSRMLS_C);
 	}
-	zend_stack_del_top(&CG(object_stack));
 }
 /* }}} */
 
-void zend_do_begin_new_object(znode *new_token, znode *class_type TSRMLS_DC) /* {{{ */
+void zend_compile_halt_compiler(zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	zend_op *opline;
-	unsigned char *ptr = NULL;
+	zend_ast *offset_ast = ast->child[0];
+	zend_long offset = Z_LVAL_P(zend_ast_get_zval(offset_ast));
 
-	new_token->u.op.opline_num = get_next_op_number(CG(active_op_array));
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	opline->opcode = ZEND_NEW;
-	opline->extended_value = CG(context).nested_calls;
-	opline->result_type = IS_VAR;
-	opline->result.var = get_temporary_variable(CG(active_op_array));
-	SET_NODE(opline->op1, class_type);
-	SET_UNUSED(opline->op2);
+	zend_string *filename, *name;
+	const char const_name[] = "__COMPILER_HALT_OFFSET__";
 
-	zend_stack_push(&CG(function_call_stack), (void *) &ptr, sizeof(unsigned char *));
-	if (++CG(context).nested_calls > CG(active_op_array)->nested_calls) {
-		CG(active_op_array)->nested_calls = CG(context).nested_calls;
+	if (CG(has_bracketed_namespaces) && CG(in_namespace)) {
+		zend_error_noreturn(E_COMPILE_ERROR,
+			"__HALT_COMPILER() can only be used from the outermost scope");
 	}
-}
-/* }}} */
-
-void zend_do_end_new_object(znode *result, const znode *new_token, const znode *argument_list TSRMLS_DC) /* {{{ */
-{
-	znode ctor_result;
 
-	zend_do_end_function_call(NULL, &ctor_result, argument_list, 1, 0 TSRMLS_CC);
-	zend_do_free(&ctor_result TSRMLS_CC);
+	filename = zend_get_compiled_filename(TSRMLS_C);
+	name = zend_mangle_property_name(const_name, sizeof(const_name) - 1,
+		filename->val, filename->len, 0);
 
-	CG(active_op_array)->opcodes[new_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array));
-	GET_NODE(result, CG(active_op_array)->opcodes[new_token->u.op.opline_num].result);
+	zend_register_long_constant(name->val, name->len, offset, CONST_CS, 0 TSRMLS_CC);
+	zend_string_release(name);
 }
 /* }}} */
 
-static zend_constant* zend_get_ct_const(const zval *const_name, int all_internal_constants_substitution TSRMLS_DC) /* {{{ */
+static zend_bool zend_try_ct_eval_magic_const(zval *zv, zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	zend_constant *c = NULL;
-
-	if (Z_STRVAL_P(const_name)[0] == '\\') {
-		if (zend_hash_find(EG(zend_constants), Z_STRVAL_P(const_name)+1, Z_STRLEN_P(const_name), (void **) &c) == FAILURE) {
-			char *lookup_name = zend_str_tolower_dup(Z_STRVAL_P(const_name)+1, Z_STRLEN_P(const_name)-1);
+	zend_op_array *op_array = CG(active_op_array);
+	zend_class_entry *ce = CG(active_class_entry);
 
-			if (zend_hash_find(EG(zend_constants), lookup_name, Z_STRLEN_P(const_name), (void **) &c)==SUCCESS) {
-				if ((c->flags & CONST_CT_SUBST) && !(c->flags & CONST_CS)) {
-					efree(lookup_name);
-					return c;
-				}
+	switch (ast->attr) {
+		case T_LINE:
+			ZVAL_LONG(zv, ast->lineno);
+			break;
+		case T_FILE:
+			ZVAL_STR_COPY(zv, CG(compiled_filename));
+			break;
+		case T_DIR:
+		{
+			zend_string *filename = CG(compiled_filename);
+			zend_string *dirname = zend_string_init(filename->val, filename->len, 0);
+			zend_dirname(dirname->val, dirname->len);
+
+			if (strcmp(dirname->val, ".") == 0) {
+				dirname = zend_string_realloc(dirname, MAXPATHLEN, 0);
+#if HAVE_GETCWD
+				VCWD_GETCWD(dirname->val, MAXPATHLEN);
+#elif HAVE_GETWD
+				VCWD_GETWD(dirname->val);
+#endif
 			}
-			efree(lookup_name);
-			return NULL;
-		}
-	} else if (zend_hash_find(EG(zend_constants), Z_STRVAL_P(const_name), Z_STRLEN_P(const_name)+1, (void **) &c) == FAILURE) {
-		char *lookup_name = zend_str_tolower_dup(Z_STRVAL_P(const_name), Z_STRLEN_P(const_name));
 
-		if (zend_hash_find(EG(zend_constants), lookup_name, Z_STRLEN_P(const_name)+1, (void **) &c)==SUCCESS) {
-			if ((c->flags & CONST_CT_SUBST) && !(c->flags & CONST_CS)) {
-				efree(lookup_name);
-				return c;
-			}
+			dirname->len = strlen(dirname->val);
+			ZVAL_STR(zv, dirname);
+			break;
 		}
-		efree(lookup_name);
-		return NULL;
-	}
-	if (c->flags & CONST_CT_SUBST) {
-		return c;
-	}
-	if (all_internal_constants_substitution &&
-	    (c->flags & CONST_PERSISTENT) &&
-	    !(CG(compiler_options) & ZEND_COMPILE_NO_CONSTANT_SUBSTITUTION) &&
-	    Z_TYPE(c->value) != IS_CONSTANT &&
-	    Z_TYPE(c->value) != IS_CONSTANT_ARRAY) {
-		return c;
-	}
-	return NULL;
-}
-/* }}} */
-
-static int zend_constant_ct_subst(znode *result, zval *const_name, int all_internal_constants_substitution TSRMLS_DC) /* {{{ */
-{
-	zend_constant *c = zend_get_ct_const(const_name, all_internal_constants_substitution TSRMLS_CC);
-
-	if (c) {
-		zval_dtor(const_name);
-		result->op_type = IS_CONST;
-		result->u.constant = c->value;
-		zval_copy_ctor(&result->u.constant);
-		INIT_PZVAL(&result->u.constant);
-		return 1;
-	}
-	return 0;
-}
-/* }}} */
-
-void zend_do_fetch_constant(znode *result, znode *constant_container, znode *constant_name, int mode, zend_bool check_namespace TSRMLS_DC) /* {{{ */
-{
-	znode tmp;
-	zend_op *opline;
-	int type;
-	char *compound;
-	ulong fetch_type = 0;
-
-	if (constant_container) {
-		switch (mode) {
-			case ZEND_CT:
-				/* this is a class constant */
-				type = zend_get_class_fetch_type(Z_STRVAL(constant_container->u.constant), Z_STRLEN(constant_container->u.constant));
-
-				if (ZEND_FETCH_CLASS_STATIC == type) {
-					zend_error(E_ERROR, "\"static::\" is not allowed in compile-time constants");
-				} else if (ZEND_FETCH_CLASS_DEFAULT == type) {
-					zend_resolve_class_name(constant_container TSRMLS_CC);
-				}
-				zend_do_build_full_name(NULL, constant_container, constant_name, 1 TSRMLS_CC);
-				*result = *constant_container;
-				result->u.constant.type = IS_CONSTANT | fetch_type;
-				break;
-			case ZEND_RT:
-				if (constant_container->op_type == IS_CONST &&
-				ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(constant_container->u.constant), Z_STRLEN(constant_container->u.constant))) {
-					zend_resolve_class_name(constant_container TSRMLS_CC);
-				} else {
-					zend_do_fetch_class(&tmp, constant_container TSRMLS_CC);
-					constant_container = &tmp;
-				}
-				opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-				opline->opcode = ZEND_FETCH_CONSTANT;
-				opline->result_type = IS_TMP_VAR;
-				opline->result.var = get_temporary_variable(CG(active_op_array));
-				if (constant_container->op_type == IS_CONST) {
-					opline->op1_type = IS_CONST;
-					opline->op1.constant = zend_add_class_name_literal(CG(active_op_array), &constant_container->u.constant TSRMLS_CC);
+		case T_FUNC_C:
+			if (op_array && op_array->function_name) {
+				ZVAL_STR_COPY(zv, op_array->function_name);
+			} else {
+				ZVAL_EMPTY_STRING(zv);
+			}
+			break;
+		case T_METHOD_C:
+			if (ce) {
+				if (op_array && op_array->function_name) {
+					ZVAL_NEW_STR(zv, zend_concat3(ce->name->val, ce->name->len, "::", 2,
+						op_array->function_name->val, op_array->function_name->len));
 				} else {
-					SET_NODE(opline->op1, constant_container);
+					ZVAL_STR_COPY(zv, ce->name);
 				}
-				SET_NODE(opline->op2, constant_name);
-				CALCULATE_LITERAL_HASH(opline->op2.constant);
-				if (opline->op1_type == IS_CONST) {
-					GET_CACHE_SLOT(opline->op2.constant);
+			} else if (op_array && op_array->function_name) {
+				ZVAL_STR_COPY(zv, op_array->function_name);
+			} else {
+				ZVAL_EMPTY_STRING(zv);
+			}
+			break;
+		case T_CLASS_C:
+			if (ce) {
+				if (ZEND_CE_IS_TRAIT(ce)) {
+					return 0;
 				} else {
-					GET_POLYMORPHIC_CACHE_SLOT(opline->op2.constant);
+					ZVAL_STR_COPY(zv, ce->name);
 				}
-				GET_NODE(result, opline->result);
-				break;
-		}
-		return;
-	}
-	/* namespace constant */
-	/* only one that did not contain \ from the start can be converted to string if unknown */
-	switch (mode) {
-		case ZEND_CT:
-			compound = memchr(Z_STRVAL(constant_name->u.constant), '\\', Z_STRLEN(constant_name->u.constant));
-			/* this is a namespace constant, or an unprefixed constant */
-
-			if (zend_constant_ct_subst(result, &constant_name->u.constant, 0 TSRMLS_CC)) {
-				break;
-			}
-
-			zend_resolve_non_class_name(constant_name, check_namespace TSRMLS_CC);
-
-			if(!compound) {
-				fetch_type |= IS_CONSTANT_UNQUALIFIED;
+			} else {
+				ZVAL_EMPTY_STRING(zv);
 			}
-
-			*result = *constant_name;
-			result->u.constant.type = IS_CONSTANT | fetch_type;
 			break;
-		case ZEND_RT:
-			compound = memchr(Z_STRVAL(constant_name->u.constant), '\\', Z_STRLEN(constant_name->u.constant));
-
-			zend_resolve_non_class_name(constant_name, check_namespace TSRMLS_CC);
-
-			if(zend_constant_ct_subst(result, &constant_name->u.constant, 1 TSRMLS_CC)) {
-				break;
+		case T_TRAIT_C:
+			if (ce && ZEND_CE_IS_TRAIT(ce)) {
+				ZVAL_STR_COPY(zv, ce->name);
+			} else {
+				ZVAL_EMPTY_STRING(zv);
 			}
-
-			opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-			opline->opcode = ZEND_FETCH_CONSTANT;
-			opline->result_type = IS_TMP_VAR;
-			opline->result.var = get_temporary_variable(CG(active_op_array));
-			GET_NODE(result, opline->result);
-			SET_UNUSED(opline->op1);
-			opline->op2_type = IS_CONST;
-			if (compound) {
-				/* the name is unambiguous */
-				opline->extended_value = 0;
-				opline->op2.constant = zend_add_const_name_literal(CG(active_op_array), &constant_name->u.constant, 0 TSRMLS_CC);
+			break;
+		case T_NS_C:
+			if (CG(current_namespace)) {
+				ZVAL_STR_COPY(zv, CG(current_namespace));
 			} else {
-				opline->extended_value = IS_CONSTANT_UNQUALIFIED;
-				if (CG(current_namespace)) {
-					opline->extended_value |= IS_CONSTANT_IN_NAMESPACE;
-					opline->op2.constant = zend_add_const_name_literal(CG(active_op_array), &constant_name->u.constant, 1 TSRMLS_CC);
-				} else {
-					opline->op2.constant = zend_add_const_name_literal(CG(active_op_array), &constant_name->u.constant, 0 TSRMLS_CC);
-				}
+				ZVAL_EMPTY_STRING(zv);
 			}
-			GET_CACHE_SLOT(opline->op2.constant);
 			break;
+		EMPTY_SWITCH_DEFAULT_CASE()
 	}
+
+	return 1;
 }
 /* }}} */
 
-void zend_do_shell_exec(znode *result, const znode *cmd TSRMLS_DC) /* {{{ */
+static inline void zend_ct_eval_binary_op(zval *result, uint32_t opcode, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */
 {
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-
-	switch (cmd->op_type) {
-		case IS_CONST:
-		case IS_TMP_VAR:
-			opline->opcode = ZEND_SEND_VAL;
-			break;
-		default:
-			opline->opcode = ZEND_SEND_VAR;
-			break;
-	}
-	SET_NODE(opline->op1, cmd);
-	opline->op2.opline_num = 1;
-	opline->extended_value = ZEND_DO_FCALL;
-	SET_UNUSED(opline->op2);
-
-	/* FIXME: exception support not added to this op2 */
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	opline->opcode = ZEND_DO_FCALL;
-	opline->result.var = get_temporary_variable(CG(active_op_array));
-	opline->result_type = IS_VAR;
-	LITERAL_STRINGL(opline->op1, estrndup("shell_exec", sizeof("shell_exec")-1), sizeof("shell_exec")-1, 0);
-	CALCULATE_LITERAL_HASH(opline->op1.constant);
-	opline->op1_type = IS_CONST;
-	GET_CACHE_SLOT(opline->op1.constant);
-	opline->extended_value = 1;
-	SET_UNUSED(opline->op2);
-	opline->op2.num = CG(context).nested_calls;
-	GET_NODE(result, opline->result);
-
-	if (CG(context).nested_calls + 1 > CG(active_op_array)->nested_calls) {
-		CG(active_op_array)->nested_calls = CG(context).nested_calls + 1;
-	}
-	if (CG(context).used_stack + 2 > CG(active_op_array)->used_stack) {
-		CG(active_op_array)->used_stack = CG(context).used_stack + 2;
-	}
+	binary_op_type fn = get_binary_op(opcode);
+	fn(result, op1, op2 TSRMLS_CC);
 }
 /* }}} */
 
-void zend_do_init_array(znode *result, const znode *expr, const znode *offset, zend_bool is_ref TSRMLS_DC) /* {{{ */
+static inline void zend_ct_eval_unary_pm(zval *result, zend_ast_kind kind, zval *op TSRMLS_DC) /* {{{ */
 {
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	binary_op_type fn = kind == ZEND_AST_UNARY_PLUS
+		? add_function : sub_function;
 
-	opline->opcode = ZEND_INIT_ARRAY;
-	opline->result.var = get_temporary_variable(CG(active_op_array));
-	opline->result_type = IS_TMP_VAR;
-	GET_NODE(result, opline->result);
-	if (expr) {
-		SET_NODE(opline->op1, expr);
-		if (offset) {
-			SET_NODE(opline->op2, offset);
-			if (opline->op2_type == IS_CONST && Z_TYPE(CONSTANT(opline->op2.constant)) == IS_STRING) {
-				ulong index;
-				int numeric = 0;
-
-				ZEND_HANDLE_NUMERIC_EX(Z_STRVAL(CONSTANT(opline->op2.constant)), Z_STRLEN(CONSTANT(opline->op2.constant))+1, index, numeric = 1);
-				if (numeric) {
-					zval_dtor(&CONSTANT(opline->op2.constant));
-					ZVAL_LONG(&CONSTANT(opline->op2.constant), index);
-				} else {
-					CALCULATE_LITERAL_HASH(opline->op2.constant);
-				}
-			}
-		} else {
-			SET_UNUSED(opline->op2);
-		}
-	} else {
-		SET_UNUSED(opline->op1);
-		SET_UNUSED(opline->op2);
-	}
-	opline->extended_value = is_ref;
+	zval left;
+	ZVAL_LONG(&left, 0);
+	fn(result, &left, op TSRMLS_CC);
 }
 /* }}} */
 
-void zend_do_add_array_element(znode *result, const znode *expr, const znode *offset, zend_bool is_ref TSRMLS_DC) /* {{{ */
+static inline void zend_ct_eval_greater(zval *result, zend_ast_kind kind, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */
 {
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-
-	opline->opcode = ZEND_ADD_ARRAY_ELEMENT;
-	SET_NODE(opline->result, result);
-	SET_NODE(opline->op1, expr);
-	if (offset) {
-		SET_NODE(opline->op2, offset);
-		if (opline->op2_type == IS_CONST && Z_TYPE(CONSTANT(opline->op2.constant)) == IS_STRING) {
-			ulong index;
-			int numeric = 0;
-
-			ZEND_HANDLE_NUMERIC_EX(Z_STRVAL(CONSTANT(opline->op2.constant)), Z_STRLEN(CONSTANT(opline->op2.constant))+1, index, numeric = 1);
-			if (numeric) {
-				zval_dtor(&CONSTANT(opline->op2.constant));
-				ZVAL_LONG(&CONSTANT(opline->op2.constant), index);
-			} else {
-				CALCULATE_LITERAL_HASH(opline->op2.constant);
-			}
-		}
-	} else {
-		SET_UNUSED(opline->op2);
-	}
-	opline->extended_value = is_ref;
+	binary_op_type fn = kind == ZEND_AST_GREATER
+		? is_smaller_function : is_smaller_or_equal_function;
+	fn(result, op2, op1 TSRMLS_CC);
 }
 /* }}} */
 
-void zend_do_add_static_array_element(znode *result, znode *offset, const znode *expr) /* {{{ */
+static zend_bool zend_try_ct_eval_array(zval *result, zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	zval *element;
+	zend_ast_list *list = zend_ast_get_list(ast);
+	uint32_t i;
 
-	ALLOC_ZVAL(element);
-	*element = expr->u.constant;
-	if (offset) {
-		switch (offset->u.constant.type & IS_CONSTANT_TYPE_MASK) {
-			case IS_CONSTANT:
-				/* Ugly hack to denote that this value has a constant index */
-				Z_TYPE_P(element) |= IS_CONSTANT_INDEX;
-				Z_STRVAL(offset->u.constant) = erealloc(Z_STRVAL(offset->u.constant), Z_STRLEN(offset->u.constant)+3);
-				Z_STRVAL(offset->u.constant)[Z_STRLEN(offset->u.constant)+1] = Z_TYPE(offset->u.constant);
-				Z_STRVAL(offset->u.constant)[Z_STRLEN(offset->u.constant)+2] = 0;
-				zend_symtable_update(Z_ARRVAL(result->u.constant), Z_STRVAL(offset->u.constant), Z_STRLEN(offset->u.constant)+3, &element, sizeof(zval *), NULL);
-				zval_dtor(&offset->u.constant);
-				break;
-			case IS_STRING:
-				zend_symtable_update(Z_ARRVAL(result->u.constant), Z_STRVAL(offset->u.constant), Z_STRLEN(offset->u.constant)+1, &element, sizeof(zval *), NULL);
-				zval_dtor(&offset->u.constant);
-				break;
-			case IS_NULL:
-				zend_symtable_update(Z_ARRVAL(result->u.constant), "", 1, &element, sizeof(zval *), NULL);
-				break;
-			case IS_LONG:
-			case IS_BOOL:
-				zend_hash_index_update(Z_ARRVAL(result->u.constant), Z_LVAL(offset->u.constant), &element, sizeof(zval *), NULL);
-				break;
-			case IS_DOUBLE:
-				zend_hash_index_update(Z_ARRVAL(result->u.constant), zend_dval_to_lval(Z_DVAL(offset->u.constant)), &element, sizeof(zval *), NULL);
-				break;
-			case IS_CONSTANT_ARRAY:
-				zend_error(E_ERROR, "Illegal offset type");
-				break;
+	/* First ensure that *all* child nodes are constant and by-val */
+	for (i = 0; i < list->children; ++i) {
+		zend_ast *elem_ast = list->child[i];
+		zend_bool by_ref = elem_ast->attr;
+		zend_eval_const_expr(&elem_ast->child[0] TSRMLS_CC);
+		zend_eval_const_expr(&elem_ast->child[1] TSRMLS_CC);
+
+		if (by_ref || elem_ast->child[0]->kind != ZEND_AST_ZVAL
+			|| (elem_ast->child[1] && elem_ast->child[1]->kind != ZEND_AST_ZVAL)
+		) {
+			return 0;
 		}
-	} else {
-		zend_hash_next_index_insert(Z_ARRVAL(result->u.constant), &element, sizeof(zval *), NULL);
 	}
-}
-/* }}} */
 
-void zend_do_add_list_element(const znode *element TSRMLS_DC) /* {{{ */
-{
-	list_llist_element lle;
+	array_init_size(result, list->children);
+	for (i = 0; i < list->children; ++i) {
+		zend_ast *elem_ast = list->child[i];
+		zend_ast *value_ast = elem_ast->child[0];
+		zend_ast *key_ast = elem_ast->child[1];
 
-	if (element) {
-		zend_check_writable_variable(element);
+		zval *value = zend_ast_get_zval(value_ast);
+		if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
 
-		lle.var = *element;
-		zend_llist_copy(&lle.dimensions, &CG(dimension_llist));
-		zend_llist_prepend_element(&CG(list_llist), &lle);
+		if (key_ast) {
+			zval *key = zend_ast_get_zval(key_ast);
+			switch (Z_TYPE_P(key)) {
+				case IS_LONG:
+					zend_hash_index_update(Z_ARRVAL_P(result), Z_LVAL_P(key), value);
+					break;
+				case IS_STRING:
+					zend_symtable_update(Z_ARRVAL_P(result), Z_STR_P(key), value);
+					break;
+				case IS_DOUBLE:
+					zend_hash_index_update(Z_ARRVAL_P(result),
+						zend_dval_to_lval(Z_DVAL_P(key)), value);
+					break;
+				case IS_FALSE:
+					zend_hash_index_update(Z_ARRVAL_P(result), 0, value);
+					break;
+				case IS_TRUE:
+					zend_hash_index_update(Z_ARRVAL_P(result), 1, value);
+					break;
+				case IS_NULL:
+					zend_hash_update(Z_ARRVAL_P(result), STR_EMPTY_ALLOC(), value);
+					break;
+				default:
+					zend_error(E_COMPILE_ERROR, "Illegal offset type");
+					break;
+			}
+		} else {
+			zend_hash_next_index_insert(Z_ARRVAL_P(result), value);
+		}
 	}
-	(*((int *)CG(dimension_llist).tail->data))++;
-}
-/* }}} */
 
-void zend_do_new_list_begin(TSRMLS_D) /* {{{ */
-{
-	int current_dimension = 0;
-	zend_llist_add_element(&CG(dimension_llist), &current_dimension);
+	return 1;
 }
 /* }}} */
 
-void zend_do_new_list_end(TSRMLS_D) /* {{{ */
+void zend_compile_binary_op(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	zend_llist_remove_tail(&CG(dimension_llist));
-	(*((int *)CG(dimension_llist).tail->data))++;
-}
-/* }}} */
+	zend_ast *left_ast = ast->child[0];
+	zend_ast *right_ast = ast->child[1];
+	uint32_t opcode = ast->attr;
 
-void zend_do_list_init(TSRMLS_D) /* {{{ */
-{
-	zend_stack_push(&CG(list_stack), &CG(list_llist), sizeof(zend_llist));
-	zend_stack_push(&CG(list_stack), &CG(dimension_llist), sizeof(zend_llist));
-	zend_llist_init(&CG(list_llist), sizeof(list_llist_element), NULL, 0);
-	zend_llist_init(&CG(dimension_llist), sizeof(int), NULL, 0);
-	zend_do_new_list_begin(TSRMLS_C);
-}
-/* }}} */
+	znode left_node, right_node;
+	zend_compile_expr(&left_node, left_ast TSRMLS_CC);
+	zend_compile_expr(&right_node, right_ast TSRMLS_CC);
 
-void zend_do_list_end(znode *result, znode *expr TSRMLS_DC) /* {{{ */
-{
-	zend_llist_element *le;
-	zend_llist_element *dimension;
-	zend_op *opline;
-	znode last_container;
-
-	le = CG(list_llist).head;
-	while (le) {
-		zend_llist *tmp_dimension_llist = &((list_llist_element *)le->data)->dimensions;
-		dimension = tmp_dimension_llist->head;
-		while (dimension) {
-			opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-			if (dimension == tmp_dimension_llist->head) { /* first */
-				last_container = *expr;
-				switch (expr->op_type) {
-					case IS_VAR:
-					case IS_CV:
-						opline->opcode = ZEND_FETCH_DIM_R;
-						break;
-					case IS_TMP_VAR:
-						opline->opcode = ZEND_FETCH_DIM_TMP_VAR;
-						break;
-					case IS_CONST: /* fetch_dim_tmp_var will handle this bogus fetch */
-						zval_copy_ctor(&expr->u.constant);
-						opline->opcode = ZEND_FETCH_DIM_TMP_VAR;
-						break;
-				}
-				opline->extended_value |= ZEND_FETCH_ADD_LOCK;
-			} else {
-				opline->opcode = ZEND_FETCH_DIM_R;
-			}
-			opline->result_type = IS_VAR;
-			opline->result.var = get_temporary_variable(CG(active_op_array));
-			SET_NODE(opline->op1, &last_container);
-			opline->op2_type = IS_CONST;
-			LITERAL_LONG(opline->op2, *((int *) dimension->data));
-			GET_NODE(&last_container, opline->result);
-			dimension = dimension->next;
-		}
-		((list_llist_element *) le->data)->value = last_container;
-		zend_llist_destroy(&((list_llist_element *) le->data)->dimensions);
-		zend_do_assign(result, &((list_llist_element *) le->data)->var, &((list_llist_element *) le->data)->value TSRMLS_CC);
-		zend_do_free(result TSRMLS_CC);
-		le = le->next;
+	if (left_node.op_type == IS_CONST && right_node.op_type == IS_CONST) {
+		result->op_type = IS_CONST;
+		zend_ct_eval_binary_op(&result->u.constant, opcode,
+			&left_node.u.constant, &right_node.u.constant TSRMLS_CC);
+		zval_ptr_dtor(&left_node.u.constant);
+		zval_ptr_dtor(&right_node.u.constant);
+		return;
 	}
-	zend_llist_destroy(&CG(dimension_llist));
-	zend_llist_destroy(&CG(list_llist));
-	*result = *expr;
-	{
-		zend_llist *p;
 
-		/* restore previous lists */
-		zend_stack_top(&CG(list_stack), (void **) &p);
-		CG(dimension_llist) = *p;
-		zend_stack_del_top(&CG(list_stack));
-		zend_stack_top(&CG(list_stack), (void **) &p);
-		CG(list_llist) = *p;
-		zend_stack_del_top(&CG(list_stack));
-	}
+	zend_emit_op_tmp(result, opcode, &left_node, &right_node TSRMLS_CC);
 }
 /* }}} */
 
-void zend_init_list(void *result, void *item TSRMLS_DC) /* {{{ */
+/* We do not use zend_compile_binary_op for this because we want to retain the left-to-right
+ * evaluation order. */
+void zend_compile_greater(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	void** list = emalloc(sizeof(void*) * 2);
+	zend_ast *left_ast = ast->child[0];
+	zend_ast *right_ast = ast->child[1];
+	znode left_node, right_node;
 
-	list[0] = item;
-	list[1] = NULL;
+	ZEND_ASSERT(ast->kind == ZEND_AST_GREATER || ast->kind == ZEND_AST_GREATER_EQUAL);
 
-	*(void**)result = list;
+	zend_compile_expr(&left_node, left_ast TSRMLS_CC);
+	zend_compile_expr(&right_node, right_ast TSRMLS_CC);
+
+	if (left_node.op_type == IS_CONST && right_node.op_type == IS_CONST) {
+		result->op_type = IS_CONST;
+		zend_ct_eval_greater(&result->u.constant, ast->kind,
+			&left_node.u.constant, &right_node.u.constant TSRMLS_CC);
+		zval_ptr_dtor(&left_node.u.constant);
+		zval_ptr_dtor(&right_node.u.constant);
+		return;
+	}
+
+	zend_emit_op_tmp(result,
+		ast->kind == ZEND_AST_GREATER ? ZEND_IS_SMALLER : ZEND_IS_SMALLER_OR_EQUAL,
+		&right_node, &left_node TSRMLS_CC);
 }
 /* }}} */
 
-void zend_add_to_list(void *result, void *item TSRMLS_DC) /* {{{ */
+void zend_compile_unary_op(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	void** list = *(void**)result;
-	size_t n = 0;
-
-	if (list) {
-		while (list[n]) {
-			n++;
-		}
-	}
+	zend_ast *expr_ast = ast->child[0];
+	uint32_t opcode = ast->attr;
 
-	list = erealloc(list, sizeof(void*) * (n+2));
+	znode expr_node;
+	zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
 
-	list[n]   = item;
-	list[n+1] = NULL;
-
-	*(void**)result = list;
+	zend_emit_op_tmp(result, opcode, &expr_node, NULL TSRMLS_CC);
 }
 /* }}} */
 
-void zend_do_fetch_static_variable(znode *varname, const znode *static_assignment, int fetch_type TSRMLS_DC) /* {{{ */
+void zend_compile_unary_pm(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	zval *tmp;
-	zend_op *opline;
-	znode lval;
-	znode result;
+	zend_ast *expr_ast = ast->child[0];
+	znode zero_node, expr_node;
 
-	ALLOC_ZVAL(tmp);
+	ZEND_ASSERT(ast->kind == ZEND_AST_UNARY_PLUS || ast->kind == ZEND_AST_UNARY_MINUS);
 
-	if (static_assignment) {
-		*tmp = static_assignment->u.constant;
-	} else {
-		INIT_ZVAL(*tmp);
-	}
-	if (!CG(active_op_array)->static_variables) {
-		if (CG(active_op_array)->scope) {
-			CG(active_op_array)->scope->ce_flags |= ZEND_HAS_STATIC_IN_METHODS;
-		}
-		ALLOC_HASHTABLE(CG(active_op_array)->static_variables);
-		zend_hash_init(CG(active_op_array)->static_variables, 2, NULL, ZVAL_PTR_DTOR, 0);
-	}
-	zend_hash_update(CG(active_op_array)->static_variables, Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant)+1, &tmp, sizeof(zval *), NULL);
-
-	if (varname->op_type == IS_CONST) {
-		if (Z_TYPE(varname->u.constant) != IS_STRING) {
-			convert_to_string(&varname->u.constant);
-		}
-	}
+	zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
 
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	opline->opcode = (fetch_type == ZEND_FETCH_LEXICAL) ? ZEND_FETCH_R : ZEND_FETCH_W;		/* the default mode must be Write, since fetch_simple_variable() is used to define function arguments */
-	opline->result_type = IS_VAR;
-	opline->result.var = get_temporary_variable(CG(active_op_array));
-	SET_NODE(opline->op1, varname);
-	if (opline->op1_type == IS_CONST) {
-		CALCULATE_LITERAL_HASH(opline->op1.constant);
-	}
-	SET_UNUSED(opline->op2);
-	opline->extended_value = ZEND_FETCH_STATIC;
-	GET_NODE(&result, opline->result);
-
-	if (varname->op_type == IS_CONST) {
-		zval_copy_ctor(&varname->u.constant);
+	if (expr_node.op_type == IS_CONST) {
+		result->op_type = IS_CONST;
+		zend_ct_eval_unary_pm(&result->u.constant, ast->kind, &expr_node.u.constant TSRMLS_CC);
+		zval_ptr_dtor(&expr_node.u.constant);
+		return;
 	}
-	fetch_simple_variable(&lval, varname, 0 TSRMLS_CC); /* Relies on the fact that the default fetch is BP_VAR_W */
 
-	if (fetch_type == ZEND_FETCH_LEXICAL) {
-		znode dummy;
+	zero_node.op_type = IS_CONST;
+	ZVAL_LONG(&zero_node.u.constant, 0);
 
-		zend_do_begin_variable_parse(TSRMLS_C);
-		zend_do_assign(&dummy, &lval, &result TSRMLS_CC);
-		zend_do_free(&dummy TSRMLS_CC);
-	} else {
-		zend_do_assign_ref(NULL, &lval, &result TSRMLS_CC);
-	}
-	CG(active_op_array)->opcodes[CG(active_op_array)->last-1].result_type |= EXT_TYPE_UNUSED;
+	zend_emit_op_tmp(result, ast->kind == ZEND_AST_UNARY_PLUS ? ZEND_ADD : ZEND_SUB,
+		&zero_node, &expr_node TSRMLS_CC);
 }
 /* }}} */
 
-void zend_do_fetch_lexical_variable(znode *varname, zend_bool is_ref TSRMLS_DC) /* {{{ */
+void zend_compile_short_circuiting(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	znode value;
+	zend_ast *left_ast = ast->child[0];
+	zend_ast *right_ast = ast->child[1];
 
-	if (Z_STRLEN(varname->u.constant) == sizeof("this") - 1 &&
-	    memcmp(Z_STRVAL(varname->u.constant), "this", sizeof("this") - 1) == 0) {
-		zend_error(E_COMPILE_ERROR, "Cannot use $this as lexical variable");
-		return;
-	}
+	znode left_node, right_node;
+	zend_op *opline_jmpz, *opline_bool;
+	uint32_t opnum_jmpz;
 
-	value.op_type = IS_CONST;
-	ZVAL_NULL(&value.u.constant);
-	Z_TYPE(value.u.constant) |= is_ref ? IS_LEXICAL_REF : IS_LEXICAL_VAR;
-	Z_SET_REFCOUNT_P(&value.u.constant, 1);
-	Z_UNSET_ISREF_P(&value.u.constant);
+	ZEND_ASSERT(ast->kind == ZEND_AST_AND || ast->kind == ZEND_AST_OR);
 
-	zend_do_fetch_static_variable(varname, &value, is_ref ? ZEND_FETCH_STATIC : ZEND_FETCH_LEXICAL TSRMLS_CC);
-}
-/* }}} */
+	zend_compile_expr(&left_node, left_ast TSRMLS_CC);
 
-void zend_do_fetch_global_variable(znode *varname, const znode *static_assignment, int fetch_type TSRMLS_DC) /* {{{ */
-{
-	zend_op *opline;
-	znode lval;
-	znode result;
+	opnum_jmpz = get_next_op_number(CG(active_op_array));
+	opline_jmpz = zend_emit_op(NULL, ast->kind == ZEND_AST_AND ? ZEND_JMPZ_EX : ZEND_JMPNZ_EX,
+		&left_node, NULL TSRMLS_CC);
 
-	if (varname->op_type == IS_CONST) {
-		if (Z_TYPE(varname->u.constant) != IS_STRING) {
-			convert_to_string(&varname->u.constant);
-		}
+	if (left_node.op_type == IS_TMP_VAR) {
+		SET_NODE(opline_jmpz->result, &left_node);
+	} else {
+		opline_jmpz->result.var = get_temporary_variable(CG(active_op_array));
+		opline_jmpz->result_type = IS_TMP_VAR;
 	}
+	GET_NODE(result, opline_jmpz->result);
 
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	opline->opcode = ZEND_FETCH_W;		/* the default mode must be Write, since fetch_simple_variable() is used to define function arguments */
-	opline->result_type = IS_VAR;
-	opline->result.var = get_temporary_variable(CG(active_op_array));
-	SET_NODE(opline->op1, varname);
-	if (opline->op1_type == IS_CONST) {
-		CALCULATE_LITERAL_HASH(opline->op1.constant);
-	}
-	SET_UNUSED(opline->op2);
-	opline->extended_value = fetch_type;
-	GET_NODE(&result, opline->result);
+	zend_compile_expr(&right_node, right_ast TSRMLS_CC);
 
-	if (varname->op_type == IS_CONST) {
-		zval_copy_ctor(&varname->u.constant);
-	}
-	fetch_simple_variable(&lval, varname, 0 TSRMLS_CC); /* Relies on the fact that the default fetch is BP_VAR_W */
+	opline_bool = zend_emit_op(NULL, ZEND_BOOL, &right_node, NULL TSRMLS_CC);
+	SET_NODE(opline_bool->result, result);
 
-	zend_do_assign_ref(NULL, &lval, &result TSRMLS_CC);
-	CG(active_op_array)->opcodes[CG(active_op_array)->last-1].result_type |= EXT_TYPE_UNUSED;
+	zend_update_jump_target_to_next(opnum_jmpz TSRMLS_CC);
 }
 /* }}} */
 
-void zend_do_cast(znode *result, const znode *expr, int type TSRMLS_DC) /* {{{ */
+void zend_compile_post_incdec(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	zend_ast *var_ast = ast->child[0];
+	ZEND_ASSERT(ast->kind == ZEND_AST_POST_INC || ast->kind == ZEND_AST_POST_DEC);
 
-	opline->opcode = ZEND_CAST;
-	opline->result_type = IS_TMP_VAR;
-	opline->result.var = get_temporary_variable(CG(active_op_array));
-	SET_NODE(opline->op1, expr);
-	SET_UNUSED(opline->op2);
-	opline->extended_value = type;
-	GET_NODE(result, opline->result);
+	if (var_ast->kind == ZEND_AST_PROP) {
+		zend_op *opline = zend_compile_prop_common(NULL, var_ast, BP_VAR_RW TSRMLS_CC);
+		opline->opcode = ast->kind == ZEND_AST_POST_INC ? ZEND_POST_INC_OBJ : ZEND_POST_DEC_OBJ;
+		zend_make_tmp_result(result, opline TSRMLS_CC);
+	} else {
+		znode var_node;
+		zend_compile_var(&var_node, var_ast, BP_VAR_RW TSRMLS_CC);
+		zend_emit_op_tmp(result, ast->kind == ZEND_AST_POST_INC ? ZEND_POST_INC : ZEND_POST_DEC,
+			&var_node, NULL TSRMLS_CC);
+	}
 }
 /* }}} */
 
-void zend_do_include_or_eval(int type, znode *result, const znode *op1 TSRMLS_DC) /* {{{ */
+void zend_compile_pre_incdec(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	zend_do_extended_fcall_begin(TSRMLS_C);
-	{
-		zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	zend_ast *var_ast = ast->child[0];
+	ZEND_ASSERT(ast->kind == ZEND_AST_PRE_INC || ast->kind == ZEND_AST_PRE_DEC);
 
-		opline->opcode = ZEND_INCLUDE_OR_EVAL;
-		opline->result_type = IS_VAR;
-		opline->result.var = get_temporary_variable(CG(active_op_array));
-		SET_NODE(opline->op1, op1);
-		SET_UNUSED(opline->op2);
-		opline->extended_value = type;
-		GET_NODE(result, opline->result);
+	if (var_ast->kind == ZEND_AST_PROP) {
+		zend_op *opline = zend_compile_prop_common(result, var_ast, BP_VAR_RW TSRMLS_CC);
+		opline->opcode = ast->kind == ZEND_AST_PRE_INC ? ZEND_PRE_INC_OBJ : ZEND_PRE_DEC_OBJ;
+	} else {
+		znode var_node;
+		zend_compile_var(&var_node, var_ast, BP_VAR_RW TSRMLS_CC);
+		zend_emit_op(result, ast->kind == ZEND_AST_PRE_INC ? ZEND_PRE_INC : ZEND_PRE_DEC,
+			&var_node, NULL TSRMLS_CC);
 	}
-	zend_do_extended_fcall_end(TSRMLS_C);
 }
 /* }}} */
 
-void zend_do_indirect_references(znode *result, const znode *num_references, znode *variable TSRMLS_DC) /* {{{ */
+void zend_compile_cast(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	int i;
+	zend_ast *expr_ast = ast->child[0];
+	znode expr_node;
+	zend_op *opline;
 
-	zend_do_end_variable_parse(variable, BP_VAR_R, 0 TSRMLS_CC);
-	for (i=1; i<Z_LVAL(num_references->u.constant); i++) {
-		fetch_simple_variable_ex(result, variable, 0, ZEND_FETCH_R TSRMLS_CC);
-		*variable = *result;
-	}
-	zend_do_begin_variable_parse(TSRMLS_C);
-	fetch_simple_variable(result, variable, 1 TSRMLS_CC);
-	/* there is a chance someone is accessing $this */
-	if (CG(active_op_array)->scope && CG(active_op_array)->this_var == -1) {
-		CG(active_op_array)->this_var = lookup_cv(CG(active_op_array), estrndup("this", sizeof("this")-1), sizeof("this")-1, THIS_HASHVAL TSRMLS_CC);
-	}
+	zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
+
+	opline = zend_emit_op_tmp(result, ZEND_CAST, &expr_node, NULL TSRMLS_CC);
+	opline->extended_value = ast->attr;
 }
 /* }}} */
 
-void zend_do_unset(const znode *variable TSRMLS_DC) /* {{{ */
+static void zend_compile_shorthand_conditional(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	zend_op *last_op;
+	zend_ast *cond_ast = ast->child[0];
+	zend_ast *false_ast = ast->child[2];
 
-	zend_check_writable_variable(variable);
+	znode cond_node, false_node;
+	zend_op *opline_jmp_set, *opline_qm_assign;
+	uint32_t opnum_jmp_set;
 
-	if (variable->op_type == IS_CV) {
-		zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-		opline->opcode = ZEND_UNSET_VAR;
-		SET_NODE(opline->op1, variable);
-		SET_UNUSED(opline->op2);
-		SET_UNUSED(opline->result);
-		opline->extended_value = ZEND_FETCH_LOCAL | ZEND_QUICK_SET;
-	} else {
-		last_op = &CG(active_op_array)->opcodes[get_next_op_number(CG(active_op_array))-1];
+	ZEND_ASSERT(ast->child[1] == NULL);
 
-		switch (last_op->opcode) {
-			case ZEND_FETCH_UNSET:
-				last_op->opcode = ZEND_UNSET_VAR;
-				SET_UNUSED(last_op->result);
-				break;
-			case ZEND_FETCH_DIM_UNSET:
-				last_op->opcode = ZEND_UNSET_DIM;
-				SET_UNUSED(last_op->result);
-				break;
-			case ZEND_FETCH_OBJ_UNSET:
-				last_op->opcode = ZEND_UNSET_OBJ;
-				SET_UNUSED(last_op->result);
-				break;
+	zend_compile_expr(&cond_node, cond_ast TSRMLS_CC);
 
-		}
-	}
+	opnum_jmp_set = get_next_op_number(CG(active_op_array));
+	zend_emit_op_tmp(result, ZEND_JMP_SET, &cond_node, NULL TSRMLS_CC);
+
+	zend_compile_expr(&false_node, false_ast TSRMLS_CC);
+
+	opline_jmp_set = &CG(active_op_array)->opcodes[opnum_jmp_set];
+	opline_jmp_set->op2.opline_num = get_next_op_number(CG(active_op_array)) + 1;
+	opline_qm_assign = zend_emit_op_tmp(NULL, ZEND_QM_ASSIGN, &false_node, NULL TSRMLS_CC);
+	SET_NODE(opline_qm_assign->result, result);
 }
 /* }}} */
 
-void zend_do_isset_or_isempty(int type, znode *result, znode *variable TSRMLS_DC) /* {{{ */
+void zend_compile_conditional(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	zend_op *last_op;
+	zend_ast *cond_ast = ast->child[0];
+	zend_ast *true_ast = ast->child[1];
+	zend_ast *false_ast = ast->child[2];
 
-	zend_do_end_variable_parse(variable, BP_VAR_IS, 0 TSRMLS_CC);
-
-	if (zend_is_function_or_method_call(variable)) {
-		if (type == ZEND_ISEMPTY) {
-			/* empty(func()) can be transformed to !func() */
-			zend_do_unary_op(ZEND_BOOL_NOT, result, variable TSRMLS_CC);
-		} else {
-			zend_error(E_COMPILE_ERROR, "Cannot use isset() on the result of a function call (you can use \"null !== func()\" instead)");
-		}
+	znode cond_node, true_node, false_node;
+	zend_op *opline_qm_assign1, *opline_qm_assign2;
+	uint32_t opnum_jmpz, opnum_jmp, opnum_qm_assign1;
 
+	if (!true_ast) {
+		zend_compile_shorthand_conditional(result, ast TSRMLS_CC);
 		return;
 	}
+	
+	zend_compile_expr(&cond_node, cond_ast TSRMLS_CC);
 
-	if (variable->op_type == IS_CV) {
-		last_op = get_next_op(CG(active_op_array) TSRMLS_CC);
-		last_op->opcode = ZEND_ISSET_ISEMPTY_VAR;
-		SET_NODE(last_op->op1, variable);
-		SET_UNUSED(last_op->op2);
-		last_op->result.var = get_temporary_variable(CG(active_op_array));
-		last_op->extended_value = ZEND_FETCH_LOCAL | ZEND_QUICK_SET;
-	} else {
-		last_op = &CG(active_op_array)->opcodes[get_next_op_number(CG(active_op_array))-1];
-
-		switch (last_op->opcode) {
-			case ZEND_FETCH_IS:
-				last_op->opcode = ZEND_ISSET_ISEMPTY_VAR;
-				break;
-			case ZEND_FETCH_DIM_IS:
-				last_op->opcode = ZEND_ISSET_ISEMPTY_DIM_OBJ;
-				break;
-			case ZEND_FETCH_OBJ_IS:
-				last_op->opcode = ZEND_ISSET_ISEMPTY_PROP_OBJ;
-				break;
-		}
-	}
-	last_op->result_type = IS_TMP_VAR;
-	last_op->extended_value |= type;
+	opnum_jmpz = zend_emit_cond_jump(ZEND_JMPZ, &cond_node, 0 TSRMLS_CC);
 
-	GET_NODE(result, last_op->result);
-}
-/* }}} */
+	zend_compile_expr(&true_node, true_ast TSRMLS_CC);
 
-void zend_do_instanceof(znode *result, const znode *expr, const znode *class_znode, int type TSRMLS_DC) /* {{{ */
-{
-	int last_op_number = get_next_op_number(CG(active_op_array));
-	zend_op *opline;
+	opnum_qm_assign1 = get_next_op_number(CG(active_op_array));
+	zend_emit_op_tmp(result, ZEND_QM_ASSIGN, &true_node, NULL TSRMLS_CC);
 
-	if (last_op_number > 0) {
-		opline = &CG(active_op_array)->opcodes[last_op_number-1];
-		if (opline->opcode == ZEND_FETCH_CLASS) {
-			opline->extended_value |= ZEND_FETCH_CLASS_NO_AUTOLOAD;
-		}
-	}
+	opnum_jmp = zend_emit_jump(0 TSRMLS_CC);
 
-	if (expr->op_type == IS_CONST) {
-		zend_error(E_COMPILE_ERROR, "instanceof expects an object instance, constant given");
-	}
+	zend_update_jump_target_to_next(opnum_jmpz TSRMLS_CC);
 
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	opline->opcode = ZEND_INSTANCEOF;
-	opline->result_type = IS_TMP_VAR;
-	opline->result.var = get_temporary_variable(CG(active_op_array));
-	SET_NODE(opline->op1, expr);
+	zend_compile_expr(&false_node, false_ast TSRMLS_CC);
 
-	SET_NODE(opline->op2, class_znode);
+	opline_qm_assign1 = &CG(active_op_array)->opcodes[opnum_qm_assign1];
+	opline_qm_assign2 = zend_emit_op(NULL, opline_qm_assign1->opcode, &false_node, NULL TSRMLS_CC);
+	SET_NODE(opline_qm_assign2->result, result);
 
-	GET_NODE(result, opline->result);
+	zend_update_jump_target_to_next(opnum_jmp TSRMLS_CC);
 }
 /* }}} */
 
-void zend_do_foreach_begin(znode *foreach_token, znode *open_brackets_token, znode *array, znode *as_token, int variable TSRMLS_DC) /* {{{ */
+void zend_compile_coalesce(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
 {
+	zend_ast *expr_ast = ast->child[0];
+	zend_ast *default_ast = ast->child[1];
+
+	znode expr_node, default_node;
 	zend_op *opline;
-	zend_bool is_variable;
-	zend_op dummy_opline;
+	uint32_t opnum;
 
-	if (variable) {
-		if (zend_is_function_or_method_call(array)) {
-			is_variable = 0;
-		} else {
-			is_variable = 1;
-		}
-		/* save the location of FETCH_W instruction(s) */
-		open_brackets_token->u.op.opline_num = get_next_op_number(CG(active_op_array));
-		zend_do_end_variable_parse(array, BP_VAR_W, 0 TSRMLS_CC);
-	} else {
-		is_variable = 0;
-		open_brackets_token->u.op.opline_num = get_next_op_number(CG(active_op_array));
-	}
+	zend_compile_var(&expr_node, expr_ast, BP_VAR_IS TSRMLS_CC);
 
-	/* save the location of FE_RESET */
-	foreach_token->u.op.opline_num = get_next_op_number(CG(active_op_array));
+	opnum = get_next_op_number(CG(active_op_array));
+	zend_emit_op_tmp(result, ZEND_COALESCE, &expr_node, NULL TSRMLS_CC);
 
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	zend_compile_expr(&default_node, default_ast TSRMLS_CC);
 
-	/* Preform array reset */
-	opline->opcode = ZEND_FE_RESET;
-	opline->result_type = IS_VAR;
-	opline->result.var = get_temporary_variable(CG(active_op_array));
-	SET_NODE(opline->op1, array);
-	SET_UNUSED(opline->op2);
-	opline->extended_value = is_variable ? ZEND_FE_RESET_VARIABLE : 0;
+	opline = zend_emit_op_tmp(NULL, ZEND_QM_ASSIGN, &default_node, NULL TSRMLS_CC);
+	SET_NODE(opline->result, result);
 
-	COPY_NODE(dummy_opline.result, opline->result);
-	zend_stack_push(&CG(foreach_copy_stack), (void *) &dummy_opline, sizeof(zend_op));
+	opline = &CG(active_op_array)->opcodes[opnum];
+	opline->op2.opline_num = get_next_op_number(CG(active_op_array));
+}
+/* }}} */
 
-	/* save the location of FE_FETCH */
-	as_token->u.op.opline_num = get_next_op_number(CG(active_op_array));
+void zend_compile_print(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
+{
+	zend_ast *expr_ast = ast->child[0];
 
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	opline->opcode = ZEND_FE_FETCH;
-	opline->result_type = IS_VAR;
-	opline->result.var = get_temporary_variable(CG(active_op_array));
-	COPY_NODE(opline->op1, dummy_opline.result);
-	opline->extended_value = 0;
-	SET_UNUSED(opline->op2);
+	znode expr_node;
+	zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
 
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	opline->opcode = ZEND_OP_DATA;
-	SET_UNUSED(opline->op1);
-	SET_UNUSED(opline->op2);
-	SET_UNUSED(opline->result);
+	zend_emit_op_tmp(result, ZEND_PRINT, &expr_node, NULL TSRMLS_CC);
 }
 /* }}} */
 
-void zend_do_foreach_cont(znode *foreach_token, const znode *open_brackets_token, const znode *as_token, znode *value, znode *key TSRMLS_DC) /* {{{ */
+void zend_compile_exit(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	zend_op *opline;
-	znode dummy, value_node;
-	zend_bool assign_by_ref=0;
+	zend_ast *expr_ast = ast->child[0];
 
-	opline = &CG(active_op_array)->opcodes[as_token->u.op.opline_num];
-	if (key->op_type != IS_UNUSED) {
-		znode *tmp;
+	if (expr_ast) {
+		znode expr_node;
+		zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
+		zend_emit_op(NULL, ZEND_EXIT, &expr_node, NULL TSRMLS_CC);
+	} else {
+		zend_emit_op(NULL, ZEND_EXIT, NULL, NULL TSRMLS_CC);
+	}
 
-		/* switch between the key and value... */
-		tmp = key;
-		key = value;
-		value = tmp;
+	result->op_type = IS_CONST;
+	ZVAL_BOOL(&result->u.constant, 1);
+}
+/* }}} */
 
-		/* Mark extended_value in case both key and value are being used */
-		opline->extended_value |= ZEND_FE_FETCH_WITH_KEY;
-	}
+void zend_compile_yield(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
+{
+	zend_ast *value_ast = ast->child[0];
+	zend_ast *key_ast = ast->child[1];
 
-	if ((key->op_type != IS_UNUSED)) {
-		if (key->EA & ZEND_PARSED_REFERENCE_VARIABLE) {
-			zend_error(E_COMPILE_ERROR, "Key element cannot be a reference");
-		}
-		if (key->EA & ZEND_PARSED_LIST_EXPR) {
-			zend_error(E_COMPILE_ERROR, "Cannot use list as key element");
-		}
+	znode value_node, key_node;
+	znode *value_node_ptr = NULL, *key_node_ptr = NULL;
+	zend_op *opline;
+	zend_bool returns_by_ref = (CG(active_op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0;
+
+	if (!CG(active_op_array)->function_name) {
+		zend_error_noreturn(E_COMPILE_ERROR,
+			"The \"yield\" expression can only be used inside a function");
 	}
 
-	if (value->EA & ZEND_PARSED_REFERENCE_VARIABLE) {
-		assign_by_ref = 1;
+	CG(active_op_array)->fn_flags |= ZEND_ACC_GENERATOR;
 
-		/* Mark extended_value for assign-by-reference */
-		opline->extended_value |= ZEND_FE_FETCH_BYREF;
-		CG(active_op_array)->opcodes[foreach_token->u.op.opline_num].extended_value |= ZEND_FE_RESET_REFERENCE;
-	} else {
-		zend_op *fetch = &CG(active_op_array)->opcodes[foreach_token->u.op.opline_num];
-		zend_op	*end = &CG(active_op_array)->opcodes[open_brackets_token->u.op.opline_num];
-
-		/* Change "write context" into "read context" */
-		fetch->extended_value = 0;  /* reset ZEND_FE_RESET_VARIABLE */
-		while (fetch != end) {
-			--fetch;
-			if (fetch->opcode == ZEND_FETCH_DIM_W && fetch->op2_type == IS_UNUSED) {
-				zend_error(E_COMPILE_ERROR, "Cannot use [] for reading");
-			}
-			if (fetch->opcode == ZEND_SEPARATE) {
-				MAKE_NOP(fetch);
-			} else {
-				fetch->opcode -= 3; /* FETCH_W -> FETCH_R */
-			}
-		}
+	if (key_ast) {
+		zend_compile_expr(&key_node, key_ast TSRMLS_CC);
+		key_node_ptr = &key_node;
 	}
 
-	GET_NODE(&value_node, opline->result);
-
-	if (value->EA & ZEND_PARSED_LIST_EXPR) {
-		if (!CG(list_llist).head) {
-			zend_error(E_COMPILE_ERROR, "Cannot use empty list");
-		}
-		zend_do_list_end(&dummy, &value_node TSRMLS_CC);
-		zend_do_free(&dummy TSRMLS_CC);
-	} else {
-		if (assign_by_ref) {
-			zend_do_end_variable_parse(value, BP_VAR_W, 0 TSRMLS_CC);
-			/* Mark FE_FETCH as IS_VAR as it holds the data directly as a value */
-			zend_do_assign_ref(NULL, value, &value_node TSRMLS_CC);
+	if (value_ast) {
+		if (returns_by_ref && zend_is_variable(value_ast) && !zend_is_call(value_ast)) {
+			zend_compile_var(&value_node, value_ast, BP_VAR_REF TSRMLS_CC);
 		} else {
-			zend_do_assign(&dummy, value, &value_node TSRMLS_CC);
-			zend_do_free(&dummy TSRMLS_CC);
+			zend_compile_expr(&value_node, value_ast TSRMLS_CC);
 		}
+		value_node_ptr = &value_node;
 	}
 
-	if (key->op_type != IS_UNUSED) {
-		znode key_node;
-
-		opline = &CG(active_op_array)->opcodes[as_token->u.op.opline_num+1];
-		opline->result_type = IS_TMP_VAR;
-		opline->result.opline_num = get_temporary_variable(CG(active_op_array));
-		GET_NODE(&key_node, opline->result);
+	opline = zend_emit_op(result, ZEND_YIELD, value_node_ptr, key_node_ptr TSRMLS_CC);
 
-		zend_do_assign(&dummy, key, &key_node TSRMLS_CC);
-		zend_do_free(&dummy TSRMLS_CC);
+	if (value_ast && returns_by_ref && zend_is_call(value_ast)) {
+		opline->extended_value = ZEND_RETURNS_FUNCTION;
 	}
-
-	do_begin_loop(TSRMLS_C);
-	INC_BPC(CG(active_op_array));
 }
 /* }}} */
 
-void zend_do_foreach_end(const znode *foreach_token, const znode *as_token TSRMLS_DC) /* {{{ */
+void zend_compile_instanceof(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	zend_op *container_ptr;
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	zend_ast *obj_ast = ast->child[0];
+	zend_ast *class_ast = ast->child[1];
 
-	opline->opcode = ZEND_JMP;
-	opline->op1.opline_num = as_token->u.op.opline_num;
-	SET_UNUSED(opline->op1);
-	SET_UNUSED(opline->op2);
-
-	CG(active_op_array)->opcodes[foreach_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array)); /* FE_RESET */
-	CG(active_op_array)->opcodes[as_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array)); /* FE_FETCH */
+	znode obj_node, class_node;
+	zend_op *opline;
 
-	do_end_loop(as_token->u.op.opline_num, 1 TSRMLS_CC);
+	zend_compile_expr(&obj_node, obj_ast TSRMLS_CC);
+	if (obj_node.op_type == IS_CONST) {
+		zend_error_noreturn(E_COMPILE_ERROR,
+			"instanceof expects an object instance, constant given");
+	}
 
-	zend_stack_top(&CG(foreach_copy_stack), (void **) &container_ptr);
-	generate_free_foreach_copy(container_ptr TSRMLS_CC);
-	zend_stack_del_top(&CG(foreach_copy_stack));
+	opline = zend_compile_class_ref(&class_node, class_ast TSRMLS_CC);
+	opline->extended_value |= ZEND_FETCH_CLASS_NO_AUTOLOAD;
 
-	DEC_BPC(CG(active_op_array));
+	zend_emit_op_tmp(result, ZEND_INSTANCEOF, &obj_node, &class_node TSRMLS_CC);
 }
 /* }}} */
 
-void zend_do_declare_begin(TSRMLS_D) /* {{{ */
+void zend_compile_include_or_eval(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	zend_stack_push(&CG(declare_stack), &CG(declarables), sizeof(zend_declarables));
+	zend_ast *expr_ast = ast->child[0];
+	znode expr_node;
+	zend_op *opline;
+
+	zend_do_extended_fcall_begin(TSRMLS_C);
+	zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
+
+	opline = zend_emit_op(result, ZEND_INCLUDE_OR_EVAL, &expr_node, NULL TSRMLS_CC);
+	opline->extended_value = ast->attr;
+
+	zend_do_extended_fcall_end(TSRMLS_C);
 }
 /* }}} */
 
-void zend_do_declare_stmt(znode *var, znode *val TSRMLS_DC) /* {{{ */
+void zend_compile_isset_or_empty(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	if (!zend_binary_strcasecmp(Z_STRVAL(var->u.constant), Z_STRLEN(var->u.constant), "ticks", sizeof("ticks")-1)) {
-		convert_to_long(&val->u.constant);
-		CG(declarables).ticks = val->u.constant;
-	} else if (!zend_binary_strcasecmp(Z_STRVAL(var->u.constant), Z_STRLEN(var->u.constant), "encoding", sizeof("encoding")-1)) {
-		if ((Z_TYPE(val->u.constant) & IS_CONSTANT_TYPE_MASK) == IS_CONSTANT) {
-			zend_error(E_COMPILE_ERROR, "Cannot use constants as encoding");
-		}
-
-		/*
-		 * Check that the pragma comes before any opcodes. If the compilation
-		 * got as far as this, the previous portion of the script must have been
-		 * parseable according to the .ini script_encoding setting. We still
-		 * want to tell them to put declare() at the top.
-		 */
-		{
-			int num = CG(active_op_array)->last;
-			/* ignore ZEND_EXT_STMT and ZEND_TICKS */
-			while (num > 0 &&
-			       (CG(active_op_array)->opcodes[num-1].opcode == ZEND_EXT_STMT ||
-			        CG(active_op_array)->opcodes[num-1].opcode == ZEND_TICKS)) {
-				--num;
-			}
+	zend_ast *var_ast = ast->child[0];
 
-			if (num > 0) {
-				zend_error(E_COMPILE_ERROR, "Encoding declaration pragma must be the very first statement in the script");
-			}
-		}
-
-		if (CG(multibyte)) {
-			const zend_encoding *new_encoding, *old_encoding;
-			zend_encoding_filter old_input_filter;
+	znode var_node;
+	zend_op *opline;
 
-			CG(encoding_declared) = 1;
+	ZEND_ASSERT(ast->kind == ZEND_AST_ISSET || ast->kind == ZEND_AST_EMPTY);
 
-			convert_to_string(&val->u.constant);
-			new_encoding = zend_multibyte_fetch_encoding(Z_STRVAL(val->u.constant) TSRMLS_CC);
-			if (!new_encoding) {
-				zend_error(E_COMPILE_WARNING, "Unsupported encoding [%s]", Z_STRVAL(val->u.constant));
-			} else {
-				old_input_filter = LANG_SCNG(input_filter);
-				old_encoding = LANG_SCNG(script_encoding);
-				zend_multibyte_set_filter(new_encoding TSRMLS_CC);
-
-				/* need to re-scan if input filter changed */
-				if (old_input_filter != LANG_SCNG(input_filter) ||
-					 (old_input_filter && new_encoding != old_encoding)) {
-					zend_multibyte_yyinput_again(old_input_filter, old_encoding TSRMLS_CC);
-				}
-			}
+	if (!zend_is_variable(var_ast) || zend_is_call(var_ast)) {
+		if (ast->kind == ZEND_AST_EMPTY) {
+			/* empty(expr) can be transformed to !expr */
+			zend_ast *not_ast = zend_ast_create_ex(ZEND_AST_UNARY_OP, ZEND_BOOL_NOT, var_ast);
+			zend_compile_expr(result, not_ast TSRMLS_CC);
+			return;
 		} else {
-			zend_error(E_COMPILE_WARNING, "declare(encoding=...) ignored because Zend multibyte feature is turned off by settings");
+			zend_error_noreturn(E_COMPILE_ERROR,
+				"Cannot use isset() on the result of an expression "
+				"(you can use \"null !== expression\" instead)");
 		}
-		zval_dtor(&val->u.constant);
-	} else {
-		zend_error(E_COMPILE_WARNING, "Unsupported declare '%s'", Z_STRVAL(var->u.constant));
-		zval_dtor(&val->u.constant);
 	}
-	zval_dtor(&var->u.constant);
-}
-/* }}} */
 
-void zend_do_declare_end(const znode *declare_token TSRMLS_DC) /* {{{ */
-{
-	zend_declarables *declarables;
-
-	zend_stack_top(&CG(declare_stack), (void **) &declarables);
-	/* We should restore if there was more than (current - start) - (ticks?1:0) opcodes */
-	if ((get_next_op_number(CG(active_op_array)) - declare_token->u.op.opline_num) - ((Z_LVAL(CG(declarables).ticks))?1:0)) {
-		CG(declarables) = *declarables;
+	switch (var_ast->kind) {
+		case ZEND_AST_VAR:
+			if (zend_try_compile_cv(&var_node, var_ast TSRMLS_CC) == SUCCESS) {
+				opline = zend_emit_op(result, ZEND_ISSET_ISEMPTY_VAR, &var_node, NULL TSRMLS_CC);
+				opline->extended_value = ZEND_FETCH_LOCAL | ZEND_QUICK_SET;
+			} else {
+				opline = zend_compile_simple_var_no_cv(result, var_ast, BP_VAR_IS TSRMLS_CC);
+				opline->opcode = ZEND_ISSET_ISEMPTY_VAR;
+			}
+			break;
+		case ZEND_AST_DIM:
+			opline = zend_compile_dim_common(result, var_ast, BP_VAR_IS TSRMLS_CC);
+			opline->opcode = ZEND_ISSET_ISEMPTY_DIM_OBJ;
+			break;
+		case ZEND_AST_PROP:
+			opline = zend_compile_prop_common(result, var_ast, BP_VAR_IS TSRMLS_CC);
+			opline->opcode = ZEND_ISSET_ISEMPTY_PROP_OBJ;
+			break;
+		case ZEND_AST_STATIC_PROP:
+			opline = zend_compile_static_prop_common(result, var_ast, BP_VAR_IS TSRMLS_CC);
+			opline->opcode = ZEND_ISSET_ISEMPTY_VAR;
+			break;
+		EMPTY_SWITCH_DEFAULT_CASE()
 	}
+
+	result->op_type = opline->result_type = IS_TMP_VAR;
+	opline->extended_value |= ast->kind == ZEND_AST_ISSET ? ZEND_ISSET : ZEND_ISEMPTY;
 }
 /* }}} */
 
-void zend_do_exit(znode *result, const znode *message TSRMLS_DC) /* {{{ */
+void zend_compile_silence(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	zend_ast *expr_ast = ast->child[0];
+	znode silence_node;
+	uint32_t opline_num;
+	zend_op *begin_silence, *end_silence;
 
-	opline->opcode = ZEND_EXIT;
-	SET_NODE(opline->op1, message);
-	SET_UNUSED(opline->op2);
+	opline_num = get_next_op_number(CG(active_op_array));
+	begin_silence = zend_emit_op_tmp(&silence_node, ZEND_BEGIN_SILENCE, NULL, NULL TSRMLS_CC);
+	/* pair BEGIN_SILENCE and END_SILENCE opcodes */
+	begin_silence->op2.num = opline_num;
 
-	result->op_type = IS_CONST;
-	Z_TYPE(result->u.constant) = IS_BOOL;
-	Z_LVAL(result->u.constant) = 1;
+	if (expr_ast->kind == ZEND_AST_VAR) {
+		/* For @$var we need to force a FETCH instruction, otherwise the CV access will
+		 * happen outside the silenced section. */
+		zend_compile_simple_var_no_cv(result, expr_ast, BP_VAR_R TSRMLS_CC);
+	} else {
+		zend_compile_expr(result, expr_ast TSRMLS_CC);
+	}
+
+	end_silence = zend_emit_op(NULL, ZEND_END_SILENCE, &silence_node, NULL TSRMLS_CC);
+	/* pair BEGIN_SILENCE and END_SILENCE opcodes */
+	end_silence->op2.num = opline_num;
 }
 /* }}} */
 
-void zend_do_begin_silence(znode *strudel_token TSRMLS_DC) /* {{{ */
+void zend_compile_shell_exec(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	zend_ast *expr_ast = ast->child[0];
 
-	opline->opcode = ZEND_BEGIN_SILENCE;
-	opline->result_type = IS_TMP_VAR;
-	opline->result.var = get_temporary_variable(CG(active_op_array));
-	SET_UNUSED(opline->op1);
-	SET_UNUSED(opline->op2);
-	GET_NODE(strudel_token, opline->result);
-}
-/* }}} */
+	zval fn_name;
+	zend_ast *name_ast, *args_ast, *call_ast;
 
-void zend_do_end_silence(const znode *strudel_token TSRMLS_DC) /* {{{ */
-{
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	ZVAL_STRING(&fn_name, "shell_exec");
+	name_ast = zend_ast_create_zval(&fn_name);
+	args_ast = zend_ast_create_list(1, ZEND_AST_ARG_LIST, expr_ast);
+	call_ast = zend_ast_create(ZEND_AST_CALL, name_ast, args_ast);
 
-	opline->opcode = ZEND_END_SILENCE;
-	SET_NODE(opline->op1, strudel_token);
-	SET_UNUSED(opline->op2);
+	zend_compile_expr(result, call_ast TSRMLS_CC);
+
+	zval_ptr_dtor(&fn_name);
 }
 /* }}} */
 
-void zend_do_jmp_set(const znode *value, znode *jmp_token, znode *colon_token TSRMLS_DC) /* {{{ */
+void zend_compile_array(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	int op_number = get_next_op_number(CG(active_op_array));
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	zend_ast_list *list = zend_ast_get_list(ast);
+	zend_op *opline;
+	uint32_t i, opnum_init = -1;
+	zend_bool packed = 1;
 
-	if (value->op_type == IS_VAR || value->op_type == IS_CV) {
-		opline->opcode = ZEND_JMP_SET_VAR;
-		opline->result_type = IS_VAR;
-	} else {
-		opline->opcode = ZEND_JMP_SET;
-		opline->result_type = IS_TMP_VAR;
+	if (zend_try_ct_eval_array(&result->u.constant, ast TSRMLS_CC)) {
+		result->op_type = IS_CONST;
+		return;
 	}
-	opline->result.var = get_temporary_variable(CG(active_op_array));
-	SET_NODE(opline->op1, value);
-	SET_UNUSED(opline->op2);
 
-	GET_NODE(colon_token, opline->result);
+	for (i = 0; i < list->children; ++i) {
+		zend_ast *elem_ast = list->child[i];
+		zend_ast *value_ast = elem_ast->child[0];
+		zend_ast *key_ast = elem_ast->child[1];
+		zend_bool by_ref = elem_ast->attr;
 
-	jmp_token->u.op.opline_num = op_number;
+		znode value_node, key_node, *key_node_ptr = NULL;
 
-	INC_BPC(CG(active_op_array));
-}
-/* }}} */
+		if (key_ast) {
+			zend_compile_expr(&key_node, key_ast TSRMLS_CC);
+			zend_handle_numeric_op(&key_node TSRMLS_CC);
+			key_node_ptr = &key_node;
+		}
 
-void zend_do_jmp_set_else(znode *result, const znode *false_value, const znode *jmp_token, const znode *colon_token TSRMLS_DC) /* {{{ */
-{
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+		if (by_ref) {
+			zend_ensure_writable_variable(value_ast);
+			zend_compile_var(&value_node, value_ast, BP_VAR_W TSRMLS_CC);
+		} else {
+			zend_compile_expr(&value_node, value_ast TSRMLS_CC);
+		}
 
-	SET_NODE(opline->result, colon_token);
-	if (colon_token->op_type == IS_TMP_VAR) {
-		if (false_value->op_type == IS_VAR || false_value->op_type == IS_CV) {
-			CG(active_op_array)->opcodes[jmp_token->u.op.opline_num].opcode = ZEND_JMP_SET_VAR;
-			CG(active_op_array)->opcodes[jmp_token->u.op.opline_num].result_type = IS_VAR;
-			opline->opcode = ZEND_QM_ASSIGN_VAR;
-			opline->result_type = IS_VAR;
+		if (i == 0) {
+			opnum_init = get_next_op_number(CG(active_op_array));
+			opline = zend_emit_op_tmp(result, ZEND_INIT_ARRAY, &value_node, key_node_ptr TSRMLS_CC);
+			opline->extended_value = list->children << ZEND_ARRAY_SIZE_SHIFT;
 		} else {
-			opline->opcode = ZEND_QM_ASSIGN;
+			opline = zend_emit_op(NULL, ZEND_ADD_ARRAY_ELEMENT,
+				&value_node, key_node_ptr TSRMLS_CC);
+			SET_NODE(opline->result, result);
 		}
-	} else {
-		opline->opcode = ZEND_QM_ASSIGN_VAR;
-	}
-	opline->extended_value = 0;
-	SET_NODE(opline->op1, false_value);
-	SET_UNUSED(opline->op2);
+		opline->extended_value |= by_ref;
 
-	GET_NODE(result, opline->result);
+		if (key_ast && key_node.op_type == IS_CONST && Z_TYPE(key_node.u.constant) == IS_STRING) {
+			packed = 0;
+		}
+	}
 
-	CG(active_op_array)->opcodes[jmp_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array));
+	/* Handle empty array */
+	if (!list->children) {
+		zend_emit_op_tmp(result, ZEND_INIT_ARRAY, NULL, NULL TSRMLS_CC);
+	}
 
-	DEC_BPC(CG(active_op_array));
+	/* Add a flag to INIT_ARRAY if we know this array cannot be packed */
+	if (!packed) {
+		ZEND_ASSERT(opnum_init != -1);
+		opline = &CG(active_op_array)->opcodes[opnum_init];
+		opline->extended_value |= ZEND_ARRAY_NOT_PACKED;
+	}
 }
 /* }}} */
 
-void zend_do_begin_qm_op(const znode *cond, znode *qm_token TSRMLS_DC) /* {{{ */
+void zend_compile_const(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	int jmpz_op_number = get_next_op_number(CG(active_op_array));
+	zend_ast *name_ast = ast->child[0];
+
 	zend_op *opline;
 
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	zend_bool is_fully_qualified;
+	zend_string *orig_name = zend_ast_get_str(name_ast);
+	zend_string *resolved_name = zend_resolve_const_name(
+		orig_name, name_ast->attr, &is_fully_qualified TSRMLS_CC);
 
-	opline->opcode = ZEND_JMPZ;
-	SET_NODE(opline->op1, cond);
-	SET_UNUSED(opline->op2);
-	opline->op2.opline_num = jmpz_op_number;
-	GET_NODE(qm_token, opline->op2);
+	if (zend_try_ct_eval_const(&result->u.constant, resolved_name, is_fully_qualified TSRMLS_CC)) {
+		result->op_type = IS_CONST;
+		zend_string_release(resolved_name);
+		return;
+	}
 
-	INC_BPC(CG(active_op_array));
+	opline = zend_emit_op_tmp(result, ZEND_FETCH_CONSTANT, NULL, NULL TSRMLS_CC);
+	opline->op2_type = IS_CONST;
+
+	if (is_fully_qualified) {
+		opline->op2.constant = zend_add_const_name_literal(
+			CG(active_op_array), resolved_name, 0 TSRMLS_CC);
+	} else {
+		opline->extended_value = IS_CONSTANT_UNQUALIFIED;
+		if (CG(current_namespace)) {
+			opline->extended_value |= IS_CONSTANT_IN_NAMESPACE;
+			opline->op2.constant = zend_add_const_name_literal(
+				CG(active_op_array), resolved_name, 1 TSRMLS_CC);
+		} else {
+			opline->op2.constant = zend_add_const_name_literal(
+				CG(active_op_array), resolved_name, 0 TSRMLS_CC);
+		}
+	}
+	zend_alloc_cache_slot(opline->op2.constant TSRMLS_CC);
 }
 /* }}} */
 
-void zend_do_qm_true(const znode *true_value, znode *qm_token, znode *colon_token TSRMLS_DC) /* {{{ */
+void zend_compile_class_const(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	zend_ast *class_ast = ast->child[0];
+	zend_ast *const_ast = ast->child[1];
 
-	CG(active_op_array)->opcodes[qm_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array))+1; /* jmp over the ZEND_JMP */
+	znode class_node, const_node;
+	zend_op *opline;
 
-	if (true_value->op_type == IS_VAR || true_value->op_type == IS_CV) {
-		opline->opcode = ZEND_QM_ASSIGN_VAR;
-		opline->result_type = IS_VAR;
+	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->opcode = ZEND_QM_ASSIGN;
-		opline->result_type = IS_TMP_VAR;
+		zend_compile_class_ref(&class_node, class_ast TSRMLS_CC);
 	}
-	opline->result.var = get_temporary_variable(CG(active_op_array));
-	SET_NODE(opline->op1, true_value);
-	SET_UNUSED(opline->op2);
 
-	GET_NODE(qm_token, opline->result);
-	colon_token->u.op.opline_num = get_next_op_number(CG(active_op_array));
+	zend_compile_expr(&const_node, const_ast TSRMLS_CC);
 
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	opline->opcode = ZEND_JMP;
-	SET_UNUSED(opline->op1);
-	SET_UNUSED(opline->op2);
+	opline = zend_emit_op_tmp(result, ZEND_FETCH_CONSTANT, NULL, &const_node TSRMLS_CC);
+
+	zend_set_class_name_op1(opline, &class_node TSRMLS_CC);
+
+	if (opline->op1_type == IS_CONST) {
+		zend_alloc_cache_slot(opline->op2.constant TSRMLS_CC);
+	} else {
+		zend_alloc_polymorphic_cache_slot(opline->op2.constant TSRMLS_CC);
+	}
 }
 /* }}} */
 
-void zend_do_qm_false(znode *result, const znode *false_value, const znode *qm_token, const znode *colon_token TSRMLS_DC) /* {{{ */
+void zend_compile_resolve_class_name(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	zend_ast *name_ast = ast->child[0];
+	uint32_t fetch_type = zend_get_class_fetch_type(zend_ast_get_str(name_ast));
 
-	SET_NODE(opline->result, qm_token);
-	if (qm_token->op_type == IS_TMP_VAR) {
-		if (false_value->op_type == IS_VAR || false_value->op_type == IS_CV) {
-			CG(active_op_array)->opcodes[colon_token->u.op.opline_num - 1].opcode = ZEND_QM_ASSIGN_VAR;
-			CG(active_op_array)->opcodes[colon_token->u.op.opline_num - 1].result_type = IS_VAR;
-			opline->opcode = ZEND_QM_ASSIGN_VAR;
-			opline->result_type = IS_VAR;
-		} else {
-			opline->opcode = ZEND_QM_ASSIGN;
-		}
-	} else {
-		opline->opcode = ZEND_QM_ASSIGN_VAR;
-	}
-	SET_NODE(opline->op1, false_value);
-	SET_UNUSED(opline->op2);
+	switch (fetch_type) {
+		case ZEND_FETCH_CLASS_SELF:
+			if (!CG(active_class_entry)) {
+				zend_error_noreturn(E_COMPILE_ERROR,
+					"Cannot access self::class when no class scope is active");
+			}
+			result->op_type = IS_CONST;
+			ZVAL_STR_COPY(&result->u.constant, CG(active_class_entry)->name);
+			break;
+        case ZEND_FETCH_CLASS_STATIC:
+        case ZEND_FETCH_CLASS_PARENT:
+			if (!CG(active_class_entry)) {
+				zend_error_noreturn(E_COMPILE_ERROR,
+					"Cannot access %s::class when no class scope is active",
+					fetch_type == ZEND_FETCH_CLASS_STATIC ? "static" : "parent");
+			} else {
+				zval class_str_zv;
+				zend_ast *class_str_ast, *class_const_ast;
 
-	CG(active_op_array)->opcodes[colon_token->u.op.opline_num].op1.opline_num = get_next_op_number(CG(active_op_array));
+				ZVAL_STRING(&class_str_zv, "class");
+				class_str_ast = zend_ast_create_zval(&class_str_zv);
+				class_const_ast = zend_ast_create(
+					ZEND_AST_CLASS_CONST, name_ast, class_str_ast);
 
-	GET_NODE(result, opline->result);
+				zend_compile_expr(result, class_const_ast TSRMLS_CC);
 
-	DEC_BPC(CG(active_op_array));
+				zval_ptr_dtor(&class_str_zv);
+			}
+			break;
+		case ZEND_FETCH_CLASS_DEFAULT:
+			result->op_type = IS_CONST;
+			ZVAL_STR(&result->u.constant, zend_resolve_class_name_ast(name_ast TSRMLS_CC));
+			break;
+		EMPTY_SWITCH_DEFAULT_CASE()
+	}
 }
 /* }}} */
 
-void zend_do_extended_info(TSRMLS_D) /* {{{ */
+void zend_compile_encaps_list(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	zend_op *opline;
+	zend_ast_list *list = zend_ast_get_list(ast);
+	uint32_t i;
 
-	if (!(CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO)) {
-		return;
-	}
+	ZEND_ASSERT(list->children > 0);
 
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	result->op_type = IS_TMP_VAR;
+	result->u.op.var = get_temporary_variable(CG(active_op_array));
 
-	opline->opcode = ZEND_EXT_STMT;
-	SET_UNUSED(opline->op1);
-	SET_UNUSED(opline->op2);
-}
-/* }}} */
+	for (i = 0; i < list->children; ++i) {
+		zend_ast *elem_ast = list->child[i];
+		znode elem_node;
+		zend_op *opline;
 
-void zend_do_extended_fcall_begin(TSRMLS_D) /* {{{ */
-{
-	zend_op *opline;
+		zend_compile_expr(&elem_node, elem_ast TSRMLS_CC);
 
-	if (!(CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO)) {
-		return;
-	}
+		if (elem_ast->kind == ZEND_AST_ZVAL) {
+			zval *zv = &elem_node.u.constant;
+			ZEND_ASSERT(Z_TYPE_P(zv) == IS_STRING);
 
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+			if (Z_STRLEN_P(zv) > 1) {
+				opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+				opline->opcode = ZEND_ADD_STRING;
+			} else if (Z_STRLEN_P(zv) == 1) {
+				char ch = *Z_STRVAL_P(zv);
+				zend_string_release(Z_STR_P(zv));
+				ZVAL_LONG(zv, ch);
 
-	opline->opcode = ZEND_EXT_FCALL_BEGIN;
-	SET_UNUSED(opline->op1);
-	SET_UNUSED(opline->op2);
+				opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+				opline->opcode = ZEND_ADD_CHAR;
+			} else {
+				/* String can be empty after a variable at the end of a heredoc */
+				zend_string_release(Z_STR_P(zv));
+				continue;
+			}
+		} else {
+			opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+			opline->opcode = ZEND_ADD_VAR;
+			ZEND_ASSERT(elem_node.op_type != IS_CONST);
+		}
+
+		if (i == 0) {
+			SET_UNUSED(opline->op1);
+		} else {
+			SET_NODE(opline->op1, result);
+		}
+		SET_NODE(opline->op2, &elem_node);
+		SET_NODE(opline->result, result);
+	}
 }
 /* }}} */
 
-void zend_do_extended_fcall_end(TSRMLS_D) /* {{{ */
+void zend_compile_magic_const(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	zend_op *opline;
+	zend_class_entry *ce = CG(active_class_entry);
 
-	if (!(CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO)) {
+	if (zend_try_ct_eval_magic_const(&result->u.constant, ast TSRMLS_CC)) {
+		result->op_type = IS_CONST;
 		return;
 	}
 
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	ZEND_ASSERT(ast->attr == T_CLASS_C && ce && ZEND_CE_IS_TRAIT(ce));
 
-	opline->opcode = ZEND_EXT_FCALL_END;
-	SET_UNUSED(opline->op1);
-	SET_UNUSED(opline->op2);
+	{
+		zend_ast *const_ast = zend_ast_create(ZEND_AST_CONST,
+			zend_ast_create_zval_from_str(zend_string_init("__CLASS__", sizeof("__CLASS__") - 1, 0)));
+		zend_compile_const(result, const_ast TSRMLS_CC);
+		zend_ast_destroy(const_ast);
+	}
 }
 /* }}} */
 
-void zend_do_ticks(TSRMLS_D) /* {{{ */
+zend_bool zend_is_allowed_in_const_expr(zend_ast_kind kind) /* {{{ */
 {
-	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);
+	return kind == ZEND_AST_ZVAL || kind == ZEND_AST_BINARY_OP
+		|| kind == ZEND_AST_GREATER || kind == ZEND_AST_GREATER_EQUAL
+		|| kind == ZEND_AST_AND || kind == ZEND_AST_OR
+		|| kind == ZEND_AST_UNARY_OP
+		|| kind == ZEND_AST_UNARY_PLUS || kind == ZEND_AST_UNARY_MINUS
+		|| kind == ZEND_AST_CONDITIONAL || kind == ZEND_AST_DIM
+		|| kind == ZEND_AST_ARRAY || kind == ZEND_AST_ARRAY_ELEM
+		|| kind == ZEND_AST_CONST || kind == ZEND_AST_CLASS_CONST
+		|| kind == ZEND_AST_RESOLVE_CLASS_NAME || kind == ZEND_AST_MAGIC_CONST;
 }
 /* }}} */
 
-zend_bool zend_is_auto_global_quick(const char *name, uint name_len, ulong hash TSRMLS_DC) /* {{{ */
+void zend_compile_const_expr_class_const(zend_ast **ast_ptr TSRMLS_DC) /* {{{ */
 {
-	zend_auto_global *auto_global;
+	zend_ast *ast = *ast_ptr;
+	zend_ast *class_ast = ast->child[0];
+	zend_ast *const_ast = ast->child[1];
+	zend_string *class_name;
+	zend_string *const_name = zend_ast_get_str(const_ast);
+	zval result;
+	int fetch_type;
 
-	if (zend_hash_quick_find(CG(auto_globals), name, name_len+1, hash, (void **) &auto_global)==SUCCESS) {
-		if (auto_global->armed) {
-			auto_global->armed = auto_global->auto_global_callback(auto_global->name, auto_global->name_len TSRMLS_CC);
-		}
-		return 1;
+	if (class_ast->kind != ZEND_AST_ZVAL) {
+		zend_error_noreturn(E_COMPILE_ERROR,
+			"Dynamic class names are not allowed in compile-time class constant references");
 	}
-	return 0;
-}
-/* }}} */
 
-zend_bool zend_is_auto_global(const char *name, uint name_len TSRMLS_DC) /* {{{ */
-{
-	return zend_is_auto_global_quick(name, name_len, zend_hash_func(name, name_len+1) TSRMLS_CC);
-}
-/* }}} */
+	class_name = zend_ast_get_str(class_ast);
+	fetch_type = zend_get_class_fetch_type(class_name);
 
-int zend_register_auto_global(const char *name, uint name_len, zend_bool jit, zend_auto_global_callback auto_global_callback TSRMLS_DC) /* {{{ */
-{
-	zend_auto_global auto_global;
+	if (ZEND_FETCH_CLASS_STATIC == fetch_type) {
+		zend_error_noreturn(E_COMPILE_ERROR,
+			"\"static::\" is not allowed in compile-time constants");
+	}
+	
+	if (ZEND_FETCH_CLASS_DEFAULT == fetch_type) {
+		class_name = zend_resolve_class_name_ast(class_ast TSRMLS_CC);
+	} else {
+		zend_string_addref(class_name);
+	}
 
-	auto_global.name = zend_new_interned_string((char*)name, name_len + 1, 0 TSRMLS_CC);
-	auto_global.name_len = name_len;
-	auto_global.auto_global_callback = auto_global_callback;
-	auto_global.jit = jit;
+	Z_STR(result) = zend_concat3(
+		class_name->val, class_name->len, "::", 2, const_name->val, const_name->len);
 
-	return zend_hash_add(CG(auto_globals), name, name_len+1, &auto_global, sizeof(zend_auto_global), NULL);
+	Z_TYPE_INFO(result) = IS_CONSTANT_EX;
+	Z_CONST_FLAGS(result) = fetch_type;
+
+	zend_ast_destroy(ast);
+	zend_string_release(class_name);
+
+	*ast_ptr = zend_ast_create_zval(&result);
 }
 /* }}} */
 
-static int zend_auto_global_init(zend_auto_global *auto_global TSRMLS_DC) /* {{{ */
+void zend_compile_const_expr_const(zend_ast **ast_ptr TSRMLS_DC) /* {{{ */
 {
-	if (auto_global->jit) {
-		auto_global->armed = 1;
-	} else if (auto_global->auto_global_callback) {
-		auto_global->armed = auto_global->auto_global_callback(auto_global->name, auto_global->name_len TSRMLS_CC);
-	} else {
-		auto_global->armed = 0;
+	zend_ast *ast = *ast_ptr;
+	zend_ast *name_ast = ast->child[0];
+	zend_string *orig_name = zend_ast_get_str(name_ast);
+	zend_bool is_fully_qualified;
+
+	zval result, resolved_name;
+	ZVAL_STR(&resolved_name, zend_resolve_const_name(
+		orig_name, name_ast->attr, &is_fully_qualified TSRMLS_CC));
+
+	if (zend_try_ct_eval_const(&result, Z_STR(resolved_name), is_fully_qualified TSRMLS_CC)) {
+		zend_string_release(Z_STR(resolved_name));
+		zend_ast_destroy(ast);
+		*ast_ptr = zend_ast_create_zval(&result);
+		return;
 	}
-	return 0;
-}
-/* }}} */
 
-ZEND_API void zend_activate_auto_globals(TSRMLS_D) /* {{{ */
-{
-	zend_hash_apply(CG(auto_globals), (apply_func_t) zend_auto_global_init TSRMLS_CC);
+	Z_TYPE_INFO(resolved_name) = IS_CONSTANT_EX;
+	if (!is_fully_qualified) {
+		Z_CONST_FLAGS(resolved_name) = IS_CONSTANT_UNQUALIFIED;
+	}
+
+	zend_ast_destroy(ast);
+	*ast_ptr = zend_ast_create_zval(&resolved_name);
 }
 /* }}} */
 
-int zendlex(znode *zendlval TSRMLS_DC) /* {{{ */
+void zend_compile_const_expr_resolve_class_name(zend_ast **ast_ptr TSRMLS_DC) /* {{{ */
 {
-	int retval;
-
-	if (CG(increment_lineno)) {
-		CG(zend_lineno)++;
-		CG(increment_lineno) = 0;
-	}
-
-again:
-	Z_TYPE(zendlval->u.constant) = IS_LONG;
-	retval = lex_scan(&zendlval->u.constant TSRMLS_CC);
-	switch (retval) {
-		case T_COMMENT:
-		case T_DOC_COMMENT:
-		case T_OPEN_TAG:
-		case T_WHITESPACE:
-			goto again;
+	zend_ast *ast = *ast_ptr;
+	zend_ast *name_ast = ast->child[0];
+	uint32_t fetch_type = zend_get_class_fetch_type(zend_ast_get_str(name_ast));
+	zval result;
 
-		case T_CLOSE_TAG:
-			if (LANG_SCNG(yy_text)[LANG_SCNG(yy_leng)-1] != '>') {
-				CG(increment_lineno) = 1;
-			}
-			if (CG(has_bracketed_namespaces) && !CG(in_namespace)) {
-				goto again;
+	switch (fetch_type) {
+		case ZEND_FETCH_CLASS_SELF:
+			if (!CG(active_class_entry)) {
+				zend_error_noreturn(E_COMPILE_ERROR,
+					"Cannot access self::class when no class scope is active");
 			}
-			retval = ';'; /* implicit ; */
+			ZVAL_STR_COPY(&result, CG(active_class_entry)->name);
 			break;
-		case T_OPEN_TAG_WITH_ECHO:
-			retval = T_ECHO;
+        case ZEND_FETCH_CLASS_STATIC:
+        case ZEND_FETCH_CLASS_PARENT:
+			zend_error_noreturn(E_COMPILE_ERROR,
+				"%s::class cannot be used for compile-time class name resolution",
+				fetch_type == ZEND_FETCH_CLASS_STATIC ? "static" : "parent"
+			);
+			break;
+		case ZEND_FETCH_CLASS_DEFAULT:
+			ZVAL_STR(&result, zend_resolve_class_name_ast(name_ast TSRMLS_CC));
 			break;
+		EMPTY_SWITCH_DEFAULT_CASE()
 	}
 
-	INIT_PZVAL(&zendlval->u.constant);
-	zendlval->op_type = IS_CONST;
-	return retval;
+	zend_ast_destroy(ast);
+	*ast_ptr = zend_ast_create_zval(&result);
 }
 /* }}} */
 
-ZEND_API void zend_initialize_class_data(zend_class_entry *ce, zend_bool nullify_handlers TSRMLS_DC) /* {{{ */
+void zend_compile_const_expr_magic_const(zend_ast **ast_ptr TSRMLS_DC) /* {{{ */
 {
-	zend_bool persistent_hashes = (ce->type == ZEND_INTERNAL_CLASS) ? 1 : 0;
-	dtor_func_t zval_ptr_dtor_func = ((persistent_hashes) ? ZVAL_INTERNAL_PTR_DTOR : ZVAL_PTR_DTOR);
-
-	ce->refcount = 1;
-	ce->ce_flags = 0;
-
-	ce->default_properties_table = NULL;
-	ce->default_static_members_table = NULL;
-	zend_hash_init_ex(&ce->properties_info, 0, NULL, (dtor_func_t) (persistent_hashes ? zend_destroy_property_info_internal : zend_destroy_property_info), persistent_hashes, 0);
-	zend_hash_init_ex(&ce->constants_table, 0, NULL, zval_ptr_dtor_func, persistent_hashes, 0);
-	zend_hash_init_ex(&ce->function_table, 0, NULL, ZEND_FUNCTION_DTOR, persistent_hashes, 0);
-
-	if (ce->type == ZEND_INTERNAL_CLASS) {
-#ifdef ZTS
-		int n = zend_hash_num_elements(CG(class_table));
+	zend_ast *ast = *ast_ptr;
+	zend_class_entry *ce = CG(active_class_entry);
 
-		if (CG(static_members_table) && n >= CG(last_static_member)) {
-			/* Support for run-time declaration: dl() */
-			CG(last_static_member) = n+1;
-			CG(static_members_table) = realloc(CG(static_members_table), (n+1)*sizeof(zval**));
-			CG(static_members_table)[n] = NULL;
-		}
-		ce->static_members_table = (zval**)(zend_intptr_t)n;
-#else
-		ce->static_members_table = NULL;
-#endif
-	} else {
-		ce->static_members_table = ce->default_static_members_table;
-		ce->info.user.doc_comment = NULL;
-		ce->info.user.doc_comment_len = 0;
-	}
+	/* Other cases already resolved by constant folding */
+	ZEND_ASSERT(ast->attr == T_CLASS_C && ce && ZEND_CE_IS_TRAIT(ce));
 
-	ce->default_properties_count = 0;
-	ce->default_static_members_count = 0;
+	{
+		zval const_zv;
+		ZVAL_STRING(&const_zv, "__CLASS__");
+		Z_TYPE_INFO(const_zv) = IS_CONSTANT_EX;
 
-	if (nullify_handlers) {
-		ce->constructor = NULL;
-		ce->destructor = NULL;
-		ce->clone = NULL;
-		ce->__get = NULL;
-		ce->__set = NULL;
-		ce->__unset = NULL;
-		ce->__isset = NULL;
-		ce->__call = NULL;
-		ce->__callstatic = NULL;
-		ce->__tostring = NULL;
-		ce->create_object = NULL;
-		ce->get_iterator = NULL;
-		ce->iterator_funcs.funcs = NULL;
-		ce->interface_gets_implemented = NULL;
-		ce->get_static_method = NULL;
-		ce->parent = NULL;
-		ce->num_interfaces = 0;
-		ce->interfaces = NULL;
-		ce->num_traits = 0;
-		ce->traits = NULL;
-		ce->trait_aliases = NULL;
-		ce->trait_precedences = NULL;
-		ce->serialize = NULL;
-		ce->unserialize = NULL;
-		ce->serialize_func = NULL;
-		ce->unserialize_func = NULL;
-		if (ce->type == ZEND_INTERNAL_CLASS) {
-			ce->info.internal.module = NULL;
-			ce->info.internal.builtin_functions = NULL;
-		}
+		zend_ast_destroy(ast);
+		*ast_ptr = zend_ast_create_zval(&const_zv);
 	}
 }
 /* }}} */
 
-int zend_get_class_fetch_type(const char *class_name, uint class_name_len) /* {{{ */
+void zend_compile_const_expr(zend_ast **ast_ptr TSRMLS_DC) /* {{{ */
 {
-	if ((class_name_len == sizeof("self")-1) &&
-		!strncasecmp(class_name, "self", sizeof("self")-1)) {
-		return ZEND_FETCH_CLASS_SELF;
-	} else if ((class_name_len == sizeof("parent")-1) &&
-		!strncasecmp(class_name, "parent", sizeof("parent")-1)) {
-		return ZEND_FETCH_CLASS_PARENT;
-	} else if ((class_name_len == sizeof("static")-1) &&
-		!strncasecmp(class_name, "static", sizeof("static")-1)) {
-		return ZEND_FETCH_CLASS_STATIC;
-	} else {
-		return ZEND_FETCH_CLASS_DEFAULT;
+	zend_ast *ast = *ast_ptr;
+	if (ast == NULL || ast->kind == ZEND_AST_ZVAL) {
+		return;
 	}
-}
-/* }}} */
 
-ZEND_API const char* zend_get_compiled_variable_name(const zend_op_array *op_array, zend_uint var, int* name_len) /* {{{ */
-{
-	if (name_len) {
-		*name_len = op_array->vars[var].name_len;
+	if (!zend_is_allowed_in_const_expr(ast->kind)) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Constant expression contains invalid operations");
+	}
+
+	switch (ast->kind) {
+		case ZEND_AST_CLASS_CONST:
+			zend_compile_const_expr_class_const(ast_ptr TSRMLS_CC);
+			break;
+		case ZEND_AST_CONST:
+			zend_compile_const_expr_const(ast_ptr TSRMLS_CC);
+			break;
+		case ZEND_AST_RESOLVE_CLASS_NAME:
+			zend_compile_const_expr_resolve_class_name(ast_ptr TSRMLS_CC);
+			break;
+		case ZEND_AST_MAGIC_CONST:
+			zend_compile_const_expr_magic_const(ast_ptr TSRMLS_CC);
+			break;
+		default:
+			zend_ast_apply(ast, zend_compile_const_expr TSRMLS_CC);
+			break;
 	}
-	return op_array->vars[var].name;
 }
 /* }}} */
 
-void zend_do_build_namespace_name(znode *result, znode *prefix, znode *name TSRMLS_DC) /* {{{ */
+void zend_const_expr_to_zval(zval *result, zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	if (prefix) {
-		*result = *prefix;
-		if (Z_TYPE(result->u.constant) == IS_STRING &&
-		    Z_STRLEN(result->u.constant) == 0) {
-			/* namespace\ */
-			if (CG(current_namespace)) {
-				znode tmp;
+	zend_ast *orig_ast = ast;
+	zend_eval_const_expr(&ast TSRMLS_CC);
+	zend_compile_const_expr(&ast TSRMLS_CC);
+	if (ast->kind == ZEND_AST_ZVAL) {
+		ZVAL_COPY_VALUE(result, zend_ast_get_zval(ast));
 
-				zval_dtor(&result->u.constant);
-				tmp.op_type = IS_CONST;
-				tmp.u.constant = *CG(current_namespace);
-				zval_copy_ctor(&tmp.u.constant);
-				zend_do_build_namespace_name(result, NULL, &tmp TSRMLS_CC);
-			}
-		}
+		/* Kill this branch of the original AST, as it was already destroyed.
+		 * It would be nice to find a better solution to this problem in the
+		 * future. */
+		orig_ast->kind = 0;
 	} else {
-		result->op_type = IS_CONST;
-		Z_TYPE(result->u.constant) = IS_STRING;
-		Z_STRVAL(result->u.constant) = NULL;
-		Z_STRLEN(result->u.constant) = 0;
+		ZVAL_NEW_AST(result, zend_ast_copy(ast));
 	}
-	/* prefix = result */
-	zend_do_build_full_name(NULL, result, name, 0 TSRMLS_CC);
 }
 /* }}} */
 
-void zend_do_begin_namespace(const znode *name, zend_bool with_bracket TSRMLS_DC) /* {{{ */
+/* Same as compile_stmt, but with early binding */
+void zend_compile_top_stmt(zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	char *lcname;
-
-	/* handle mixed syntax declaration or nested namespaces */
-	if (!CG(has_bracketed_namespaces)) {
-		if (CG(current_namespace)) {
-			/* previous namespace declarations were unbracketed */
-			if (with_bracket) {
-				zend_error(E_COMPILE_ERROR, "Cannot mix bracketed namespace declarations with unbracketed namespace declarations");
-			}
-		}
-	} else {
-		/* previous namespace declarations were bracketed */
-		if (!with_bracket) {
-			zend_error(E_COMPILE_ERROR, "Cannot mix bracketed namespace declarations with unbracketed namespace declarations");
-		} else if (CG(current_namespace) || CG(in_namespace)) {
-			zend_error(E_COMPILE_ERROR, "Namespace declarations cannot be nested");
-		}
+	if (!ast) {
+		return;
 	}
 
-	if (((!with_bracket && !CG(current_namespace)) || (with_bracket && !CG(has_bracketed_namespaces))) && CG(active_op_array)->last > 0) {
-		/* ignore ZEND_EXT_STMT and ZEND_TICKS */
-		int num = CG(active_op_array)->last;
-		while (num > 0 &&
-		       (CG(active_op_array)->opcodes[num-1].opcode == ZEND_EXT_STMT ||
-		        CG(active_op_array)->opcodes[num-1].opcode == ZEND_TICKS)) {
-			--num;
-		}
-		if (num > 0) {
-			zend_error(E_COMPILE_ERROR, "Namespace declaration statement has to be the very first statement in the script");
+	if (ast->kind == ZEND_AST_STMT_LIST) {
+		zend_ast_list *list = zend_ast_get_list(ast);
+		uint32_t i;
+		for (i = 0; i < list->children; ++i) {
+			zend_compile_top_stmt(list->child[i] TSRMLS_CC);
 		}
+		return;
 	}
 
-	CG(in_namespace) = 1;
-	if (with_bracket) {
-		CG(has_bracketed_namespaces) = 1;
-	}
-
-	if (name) {
-		lcname = zend_str_tolower_dup(Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant));
-		if (((Z_STRLEN(name->u.constant) == sizeof("self")-1) &&
-		      !memcmp(lcname, "self", sizeof("self")-1)) ||
-		    ((Z_STRLEN(name->u.constant) == sizeof("parent")-1) &&
-	          !memcmp(lcname, "parent", sizeof("parent")-1))) {
-			zend_error(E_COMPILE_ERROR, "Cannot use '%s' as namespace name", Z_STRVAL(name->u.constant));
-		}
-		efree(lcname);
+	zend_compile_stmt(ast TSRMLS_CC);
 
-		if (CG(current_namespace)) {
-			zval_dtor(CG(current_namespace));
-		} else {
-			ALLOC_ZVAL(CG(current_namespace));
-		}
-		*CG(current_namespace) = name->u.constant;
-	} else {
-		if (CG(current_namespace)) {
-			zval_dtor(CG(current_namespace));
-			FREE_ZVAL(CG(current_namespace));
-			CG(current_namespace) = NULL;
-		}
+	if (ast->kind != ZEND_AST_NAMESPACE && ast->kind != ZEND_AST_HALT_COMPILER) {
+		zend_verify_namespace(TSRMLS_C);
 	}
-
-	if (CG(current_import)) {
-		zend_hash_destroy(CG(current_import));
-		efree(CG(current_import));
-		CG(current_import) = NULL;
-	}
-
-	if (CG(doc_comment)) {
-		efree(CG(doc_comment));
-		CG(doc_comment) = NULL;
-		CG(doc_comment_len) = 0;
+	if (ast->kind == ZEND_AST_FUNC_DECL || ast->kind == ZEND_AST_CLASS) {
+		CG(zend_lineno) = ((zend_ast_decl *) ast)->end_lineno;
+		zend_do_early_binding(TSRMLS_C);
 	}
 }
 /* }}} */
 
-void zend_do_use(znode *ns_name, znode *new_name, int is_global TSRMLS_DC) /* {{{ */
+void zend_compile_stmt(zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	char *lcname;
-	zval *name, *ns, tmp;
-	zend_bool warn = 0;
-	zend_class_entry **pce;
-
-	if (!CG(current_import)) {
-		CG(current_import) = emalloc(sizeof(HashTable));
-		zend_hash_init(CG(current_import), 0, NULL, ZVAL_PTR_DTOR, 0);
-	}
-
-	ALLOC_ZVAL(ns);
-	*ns = ns_name->u.constant;
-	if (new_name) {
-		name = &new_name->u.constant;
-	} else {
-		const char *p;
-
-		/* The form "use A\B" is eqivalent to "use A\B as B".
-		   So we extract the last part of compound name to use as a new_name */
-		name = &tmp;
-		p = zend_memrchr(Z_STRVAL_P(ns), '\\', Z_STRLEN_P(ns));
-		if (p) {
-			ZVAL_STRING(name, p+1, 1);
-		} else {
-			*name = *ns;
-			zval_copy_ctor(name);
-			warn = !is_global && !CG(current_namespace);
-		}
+	if (!ast) {
+		return;
 	}
 
-	lcname = zend_str_tolower_dup(Z_STRVAL_P(name), Z_STRLEN_P(name));
+	CG(zend_lineno) = ast->lineno;
 
-	if (((Z_STRLEN_P(name) == sizeof("self")-1) &&
-				!memcmp(lcname, "self", sizeof("self")-1)) ||
-			((Z_STRLEN_P(name) == sizeof("parent")-1) &&
-	   !memcmp(lcname, "parent", sizeof("parent")-1))) {
-		zend_error(E_COMPILE_ERROR, "Cannot use %s as %s because '%s' is a special class name", Z_STRVAL_P(ns), Z_STRVAL_P(name), Z_STRVAL_P(name));
-	}
-
-	if (CG(current_namespace)) {
-		/* Prefix import name with current namespace name to avoid conflicts with classes */
-		char *c_ns_name = emalloc(Z_STRLEN_P(CG(current_namespace)) + 1 + Z_STRLEN_P(name) + 1);
-
-		zend_str_tolower_copy(c_ns_name, Z_STRVAL_P(CG(current_namespace)), Z_STRLEN_P(CG(current_namespace)));
-		c_ns_name[Z_STRLEN_P(CG(current_namespace))] = '\\';
-		memcpy(c_ns_name+Z_STRLEN_P(CG(current_namespace))+1, lcname, Z_STRLEN_P(name)+1);
-		if (zend_hash_exists(CG(class_table), c_ns_name, Z_STRLEN_P(CG(current_namespace)) + 1 + Z_STRLEN_P(name)+1)) {
-			char *tmp2 = zend_str_tolower_dup(Z_STRVAL_P(ns), Z_STRLEN_P(ns));
-
-			if (Z_STRLEN_P(ns) != Z_STRLEN_P(CG(current_namespace)) + 1 + Z_STRLEN_P(name) ||
-				memcmp(tmp2, c_ns_name, Z_STRLEN_P(ns))) {
-				zend_error(E_COMPILE_ERROR, "Cannot use %s as %s because the name is already in use", Z_STRVAL_P(ns), Z_STRVAL_P(name));
-			}
-			efree(tmp2);
-		}
-		efree(c_ns_name);
-	} else if (zend_hash_find(CG(class_table), lcname, Z_STRLEN_P(name)+1, (void**)&pce) == SUCCESS &&
-	           (*pce)->type == ZEND_USER_CLASS &&
-	           (*pce)->info.user.filename == CG(compiled_filename)) {
-		char *c_tmp = zend_str_tolower_dup(Z_STRVAL_P(ns), Z_STRLEN_P(ns));
-
-		if (Z_STRLEN_P(ns) != Z_STRLEN_P(name) ||
-			memcmp(c_tmp, lcname, Z_STRLEN_P(ns))) {
-			zend_error(E_COMPILE_ERROR, "Cannot use %s as %s because the name is already in use", Z_STRVAL_P(ns), Z_STRVAL_P(name));
+	switch (ast->kind) {
+		case ZEND_AST_STMT_LIST:
+			zend_compile_stmt_list(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_GLOBAL:
+			zend_compile_global_var(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_STATIC:
+			zend_compile_static_var(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_UNSET:
+			zend_compile_unset(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_RETURN:
+			zend_compile_return(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_ECHO:
+			zend_compile_echo(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_THROW:
+			zend_compile_throw(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_BREAK:
+		case ZEND_AST_CONTINUE:
+			zend_compile_break_continue(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_GOTO:
+			zend_compile_goto(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_LABEL:
+			zend_compile_label(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_WHILE:
+			zend_compile_while(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_DO_WHILE:
+			zend_compile_do_while(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_FOR:
+			zend_compile_for(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_FOREACH:
+			zend_compile_foreach(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_IF:
+			zend_compile_if(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_SWITCH:
+			zend_compile_switch(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_TRY:
+			zend_compile_try(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_DECLARE:
+			zend_compile_declare(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_FUNC_DECL:
+		case ZEND_AST_METHOD:
+			zend_compile_func_decl(NULL, ast TSRMLS_CC);
+			break;
+		case ZEND_AST_PROP_DECL:
+			zend_compile_prop_decl(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_CLASS_CONST_DECL:
+			zend_compile_class_const_decl(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_USE_TRAIT:
+			zend_compile_use_trait(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_CLASS:
+			zend_compile_class_decl(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_USE:
+			zend_compile_use(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_CONST_DECL:
+			zend_compile_const_decl(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_NAMESPACE:
+			zend_compile_namespace(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_HALT_COMPILER:
+			zend_compile_halt_compiler(ast TSRMLS_CC);
+			break;
+		default:
+		{
+			znode result;
+			zend_compile_expr(&result, ast TSRMLS_CC);
+			zend_do_free(&result TSRMLS_CC);
 		}
-		efree(c_tmp);
 	}
 
-	if (zend_hash_add(CG(current_import), lcname, Z_STRLEN_P(name)+1, &ns, sizeof(zval*), NULL) != SUCCESS) {
-		zend_error(E_COMPILE_ERROR, "Cannot use %s as %s because the name is already in use", Z_STRVAL_P(ns), Z_STRVAL_P(name));
-	}
-	if (warn) {
-		if (!strcmp(Z_STRVAL_P(name), "strict")) {
-			zend_error(E_COMPILE_ERROR, "You seem to be trying to use a different language...");
-		}
-		zend_error(E_WARNING, "The use statement with non-compound name '%s' has no effect", Z_STRVAL_P(name));
+	if (Z_LVAL(CG(declarables).ticks) && !zend_is_unticked_stmt(ast)) {
+		zend_emit_tick(TSRMLS_C);
 	}
-	efree(lcname);
-	zval_dtor(name);
 }
 /* }}} */
 
-void zend_do_declare_constant(znode *name, znode *value TSRMLS_DC) /* {{{ */
+void zend_compile_expr(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
 {
-	zend_op *opline;
-
-	if(Z_TYPE(value->u.constant) == IS_CONSTANT_ARRAY) {
-		zend_error(E_COMPILE_ERROR, "Arrays are not allowed as constants");
-	}
-
-	if (zend_get_ct_const(&name->u.constant, 0 TSRMLS_CC)) {
-		zend_error(E_COMPILE_ERROR, "Cannot redeclare constant '%s'", Z_STRVAL(name->u.constant));
-	}
-
-	if (CG(current_namespace)) {
-		/* Prefix constant name with name of current namespace, lowercased */
-		znode tmp;
+	/* CG(zend_lineno) = ast->lineno; */
+	CG(zend_lineno) = zend_ast_get_lineno(ast);
 
-		tmp.op_type = IS_CONST;
-		tmp.u.constant = *CG(current_namespace);
-		Z_STRVAL(tmp.u.constant) = zend_str_tolower_dup(Z_STRVAL(tmp.u.constant), Z_STRLEN(tmp.u.constant));
-		zend_do_build_namespace_name(&tmp, &tmp, name TSRMLS_CC);
-		*name = tmp;
+	switch (ast->kind) {
+		case ZEND_AST_ZVAL:
+			ZVAL_COPY(&result->u.constant, zend_ast_get_zval(ast));
+			result->op_type = IS_CONST;
+			return;
+		case ZEND_AST_ZNODE:
+			*result = *zend_ast_get_znode(ast);
+			return;
+		case ZEND_AST_VAR:
+		case ZEND_AST_DIM:
+		case ZEND_AST_PROP:
+		case ZEND_AST_STATIC_PROP:
+		case ZEND_AST_CALL:
+		case ZEND_AST_METHOD_CALL:
+		case ZEND_AST_STATIC_CALL:
+			zend_compile_var(result, ast, BP_VAR_R TSRMLS_CC);
+			return;
+		case ZEND_AST_ASSIGN:
+			zend_compile_assign(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_ASSIGN_REF:
+			zend_compile_assign_ref(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_NEW:
+			zend_compile_new(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_CLONE:
+			zend_compile_clone(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_ASSIGN_OP:
+			zend_compile_compound_assign(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_BINARY_OP:
+			zend_compile_binary_op(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_GREATER:
+		case ZEND_AST_GREATER_EQUAL:
+			zend_compile_greater(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_UNARY_OP:
+			zend_compile_unary_op(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_UNARY_PLUS:
+		case ZEND_AST_UNARY_MINUS:
+			zend_compile_unary_pm(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_AND:
+		case ZEND_AST_OR:
+			zend_compile_short_circuiting(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_POST_INC:
+		case ZEND_AST_POST_DEC:
+			zend_compile_post_incdec(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_PRE_INC:
+		case ZEND_AST_PRE_DEC:
+			zend_compile_pre_incdec(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_CAST:
+			zend_compile_cast(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_CONDITIONAL:
+			zend_compile_conditional(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_COALESCE:
+			zend_compile_coalesce(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_PRINT:
+			zend_compile_print(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_EXIT:
+			zend_compile_exit(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_YIELD:
+			zend_compile_yield(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_INSTANCEOF:
+			zend_compile_instanceof(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_INCLUDE_OR_EVAL:
+			zend_compile_include_or_eval(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_ISSET:
+		case ZEND_AST_EMPTY:
+			zend_compile_isset_or_empty(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_SILENCE:
+			zend_compile_silence(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_SHELL_EXEC:
+			zend_compile_shell_exec(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_ARRAY:
+			zend_compile_array(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_CONST:
+			zend_compile_const(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_CLASS_CONST:
+			zend_compile_class_const(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_RESOLVE_CLASS_NAME:
+			zend_compile_resolve_class_name(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_ENCAPS_LIST:
+			zend_compile_encaps_list(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_MAGIC_CONST:
+			zend_compile_magic_const(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_CLOSURE:
+			zend_compile_func_decl(result, ast TSRMLS_CC);
+			return;
+		default:
+			ZEND_ASSERT(0 /* not supported */);
 	}
-
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	opline->opcode = ZEND_DECLARE_CONST;
-	SET_UNUSED(opline->result);
-	SET_NODE(opline->op1, name);
-	SET_NODE(opline->op2, value);
 }
 /* }}} */
 
-void zend_verify_namespace(TSRMLS_D) /* {{{ */
+void zend_compile_var(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC) /* {{{ */
 {
-	if (CG(has_bracketed_namespaces) && !CG(in_namespace)) {
-		zend_error(E_COMPILE_ERROR, "No code may exist outside of namespace {}");
+	switch (ast->kind) {
+		case ZEND_AST_VAR:
+			zend_compile_simple_var(result, ast, type TSRMLS_CC);
+			return;
+		case ZEND_AST_DIM:
+			zend_compile_dim(result, ast, type TSRMLS_CC);
+			return;
+		case ZEND_AST_PROP:
+			zend_compile_prop(result, ast, type TSRMLS_CC);
+			return;
+		case ZEND_AST_STATIC_PROP:
+			zend_compile_static_prop(result, ast, type TSRMLS_CC);
+			return;
+		case ZEND_AST_CALL:
+			zend_compile_call(result, ast, type TSRMLS_CC);
+			return;
+		case ZEND_AST_METHOD_CALL:
+			zend_compile_method_call(result, ast, type TSRMLS_CC);
+			return;
+		case ZEND_AST_STATIC_CALL:
+			zend_compile_static_call(result, ast, type TSRMLS_CC);
+			return;
+		case ZEND_AST_ZNODE:
+			*result = *zend_ast_get_znode(ast);
+			return;
+		default:
+			if (type == BP_VAR_W || type == BP_VAR_REF
+				|| type == BP_VAR_RW || type == BP_VAR_UNSET
+			) {
+				/* For BC reasons =& new Foo is allowed */
+				if (type != BP_VAR_REF || ast->kind != ZEND_AST_NEW) {
+					zend_error_noreturn(E_COMPILE_ERROR,
+						"Cannot use temporary expression in write context");
+				}
+			}
+
+			zend_compile_expr(result, ast TSRMLS_CC);
+			return;
 	}
 }
 /* }}} */
 
-void zend_do_end_namespace(TSRMLS_D) /* {{{ */
+void zend_delayed_compile_var(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC) /* {{{ */
 {
-	CG(in_namespace) = 0;
-	if (CG(current_namespace)) {
-		zval_dtor(CG(current_namespace));
-		FREE_ZVAL(CG(current_namespace));
-		CG(current_namespace) = NULL;
-	}
-	if (CG(current_import)) {
-		zend_hash_destroy(CG(current_import));
-		efree(CG(current_import));
-		CG(current_import) = NULL;
+	zend_op *opline;
+	switch (ast->kind) {
+		case ZEND_AST_DIM:
+			opline = zend_delayed_compile_dim(result, ast, type TSRMLS_CC);
+			zend_adjust_for_fetch_type(opline, type);
+			return;
+		case ZEND_AST_PROP:
+			opline = zend_delayed_compile_prop(result, ast, type TSRMLS_CC);
+			zend_adjust_for_fetch_type(opline, type);
+			return;
+		default:
+			zend_compile_var(result, ast, type TSRMLS_CC);
+			return;
 	}
 }
 /* }}} */
 
-void zend_do_end_compilation(TSRMLS_D) /* {{{ */
+void zend_eval_const_expr(zend_ast **ast_ptr TSRMLS_DC) /* {{{ */
 {
-	CG(has_bracketed_namespaces) = 0;
-	zend_do_end_namespace(TSRMLS_C);
-}
-/* }}} */
+	zend_ast *ast = *ast_ptr;
+	zval result;
 
-/* {{{ 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;
-
-#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;
-		}
+	if (!ast) {
+		return;
 	}
-#endif
 
-	if (len == 0) {
-		/* Illegal use of this function */
-		return 0;
-	}
+	switch (ast->kind) {
+		case ZEND_AST_BINARY_OP:
+			zend_eval_const_expr(&ast->child[0] TSRMLS_CC);
+			zend_eval_const_expr(&ast->child[1] TSRMLS_CC);
+			if (ast->child[0]->kind != ZEND_AST_ZVAL || ast->child[1]->kind != ZEND_AST_ZVAL) {
+				return;
+			}
 
-	/* Strip trailing slashes */
-	while (end >= path && IS_SLASH_P(end)) {
-		end--;
-	}
-	if (end < path) {
-		/* The path only contained slashes */
-		path[0] = DEFAULT_SLASH;
-		path[1] = '\0';
-		return 1 + len_adjust;
-	}
+			zend_ct_eval_binary_op(&result, ast->attr,
+				zend_ast_get_zval(ast->child[0]), zend_ast_get_zval(ast->child[1]) TSRMLS_CC);
+			break;
+		case ZEND_AST_GREATER:
+		case ZEND_AST_GREATER_EQUAL:
+			zend_eval_const_expr(&ast->child[0] TSRMLS_CC);
+			zend_eval_const_expr(&ast->child[1] TSRMLS_CC);
+			if (ast->child[0]->kind != ZEND_AST_ZVAL || ast->child[1]->kind != ZEND_AST_ZVAL) {
+				return;
+			}
 
-	/* 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
-	}
+			zend_ct_eval_greater(&result, ast->kind,
+				zend_ast_get_zval(ast->child[0]), zend_ast_get_zval(ast->child[1]) TSRMLS_CC);
+			break;
+		case ZEND_AST_UNARY_PLUS:
+		case ZEND_AST_UNARY_MINUS:
+			zend_eval_const_expr(&ast->child[0] TSRMLS_CC);
+			if (ast->child[0]->kind != ZEND_AST_ZVAL) {
+				return;
+			}
 
-	/* 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;
+			zend_ct_eval_unary_pm(&result, ast->kind,
+				zend_ast_get_zval(ast->child[0]) TSRMLS_CC);
+			break;
+		case ZEND_AST_ARRAY:
+			if (!zend_try_ct_eval_array(&result, ast TSRMLS_CC)) {
+				return;
+			}
+			break;
+		case ZEND_AST_MAGIC_CONST:
+			if (!zend_try_ct_eval_magic_const(&result, ast TSRMLS_CC)) {
+				return;
+			}
+			break;
+		case ZEND_AST_CONST:
+		{
+			zend_ast *name_ast = ast->child[0];
+			zend_bool is_fully_qualified;
+			zend_string *resolved_name = zend_resolve_const_name(
+				zend_ast_get_str(name_ast), name_ast->attr, &is_fully_qualified TSRMLS_CC);
+
+			if (!zend_try_ct_eval_const(&result, resolved_name, is_fully_qualified TSRMLS_CC)) {
+				zend_string_release(resolved_name);
+				return;
+			}
+
+			zend_string_release(resolved_name);
+			break;
+		}
+		default:
+			return;
 	}
-	*(end+1) = '\0';
 
-	return (size_t)(end + 1 - path) + len_adjust;
+	zend_ast_destroy(ast);
+	*ast_ptr = zend_ast_create_zval(&result);
 }
 /* }}} */