Merge branch 'ast'POST_AST_MERGE

Conflicts:
	Zend/zend_compile.c

62 files changed, 9060 insertions, 6801 deletions

diff --git a/Zend/tests/024.phpt b/Zend/tests/024.phpt
index ff35a5c895..f89c49e613 100644
--- a/Zend/tests/024.phpt
+++ b/Zend/tests/024.phpt
@@ -11,7 +11,7 @@ var_dump($a++);
 var_dump(++$b);
 var_dump($a->$b);
 var_dump($a->$b);
-var_dump($a->$b->$c[1]);
+var_dump($a->$b->{$c[1]});
 
 ?>
 --EXPECTF--
diff --git a/Zend/tests/bug27669.phpt b/Zend/tests/bug27669.phpt
index 4d513e91aa..43591a9386 100644
--- a/Zend/tests/bug27669.phpt
+++ b/Zend/tests/bug27669.phpt
@@ -10,7 +10,7 @@ Bug #27669 (PHP 5 didn't support all possibilities for calling static methods dy
 		}
 	}
 	$y[0] = 'hello';
-	A::$y[0]();
+	A::{$y[0]}();
 ?>
 ===DONE===
 --EXPECTF--
diff --git a/Zend/tests/bug30080.phpt b/Zend/tests/bug30080.phpt
index bd8401e1be..8cac75ab8d 100644
--- a/Zend/tests/bug30080.phpt
+++ b/Zend/tests/bug30080.phpt
@@ -10,9 +10,9 @@ class foo {
 
 new foo(array(new stdClass)); 
 ?>
---EXPECT--
+--EXPECTF--
 array(1) {
   [0]=>
-  object(stdClass)#2 (0) {
+  object(stdClass)#%d (0) {
   }
 }
diff --git a/Zend/tests/bug39304.phpt b/Zend/tests/bug39304.phpt
index 8303b82573..5540135fa4 100644
--- a/Zend/tests/bug39304.phpt
+++ b/Zend/tests/bug39304.phpt
@@ -9,8 +9,8 @@ echo "I am alive";
 --EXPECTF--
 Notice: Uninitialized string offset: 0 in %sbug39304.php on line %d
 
-Notice: Uninitialized string offset: 1 in %sbug39304.php on line %d
-
 Notice: Uninitialized string offset: 0 in %sbug39304.php on line %d
+
+Notice: Uninitialized string offset: 1 in %sbug39304.php on line %d
 I am alive
 
diff --git a/Zend/tests/bug39304_2_4.phpt b/Zend/tests/bug39304_2_4.phpt
index b0e6ddc72c..cc0709b424 100644
--- a/Zend/tests/bug39304_2_4.phpt
+++ b/Zend/tests/bug39304_2_4.phpt
@@ -11,8 +11,8 @@ Bug #39304 (Segmentation fault with list unpacking of string offset)
 --EXPECTF--
 Notice: Uninitialized string offset: 0 in %sbug39304_2_4.php on line %d
 
-Notice: Uninitialized string offset: 1 in %sbug39304_2_4.php on line %d
-
 Notice: Uninitialized string offset: 0 in %sbug39304_2_4.php on line %d
+
+Notice: Uninitialized string offset: 1 in %sbug39304_2_4.php on line %d
 string(0) ""
 string(0) ""
diff --git a/Zend/tests/bug43450.phpt b/Zend/tests/bug43450.phpt
index a94eba312e..f0cd4f75bc 100644
--- a/Zend/tests/bug43450.phpt
+++ b/Zend/tests/bug43450.phpt
@@ -18,15 +18,15 @@ class Foo
 
 $num_repeats = 100000;
 
-$start = (memory_get_usage() / 1024) + 16;
+$start = memory_get_usage() / 1024;
 for ($i=1;$i<$num_repeats;$i++) 
 {
 	$foo = new Foo();
 	md5($foo);
 }
-$end = memory_get_peak_usage() / 1024;
+$end = memory_get_usage() / 1024;
 
-if ($start < $end) {
+if ($start + 16 < $end) {
 	echo 'FAIL';
 } else {
 	echo 'PASS';
diff --git a/Zend/tests/bug44414.phpt b/Zend/tests/bug44414.phpt
index 1f3a2583d7..e9e6de7b45 100644
--- a/Zend/tests/bug44414.phpt
+++ b/Zend/tests/bug44414.phpt
@@ -12,4 +12,4 @@ class C extends A implements B {
 }
 ?>
 --EXPECTF--
-Fatal error: Class C contains 2 abstract methods and must therefore be declared abstract or implement the remaining methods (A::foo, B::bar) in %sbug44414.php on line 9
+Fatal error: Class C contains 2 abstract methods and must therefore be declared abstract or implement the remaining methods (A::foo, B::bar) in %sbug44414.php on line 8
diff --git a/Zend/tests/bug55007.phpt b/Zend/tests/bug55007.phpt
index 12fbf120a8..425ce8f296 100644
--- a/Zend/tests/bug55007.phpt
+++ b/Zend/tests/bug55007.phpt
@@ -4,7 +4,7 @@ Bug #55007 (compiler fail after previous fail)
 <?php
 
 function __autoload($classname) {
-  if ('CompileErrorClass'==$classname) eval('class CompileErrorClass { function foo() { $a[] } }');
+  if ('CompileErrorClass'==$classname) eval('class CompileErrorClass { function foo() { $a[]; } }');
   if ('MyErrorHandler'==$classname) eval('class MyErrorHandler { function __construct() { print "My error handler runs.\n"; } }');
 }
 
diff --git a/Zend/tests/bug60099.phpt b/Zend/tests/bug60099.phpt
index 13e2f54b09..8cca3440fb 100644
--- a/Zend/tests/bug60099.phpt
+++ b/Zend/tests/bug60099.phpt
@@ -7,4 +7,4 @@ namespace foo {
 
 ?>
 --EXPECTF--
-Fatal error: __HALT_COMPILER() can only be used from the outermost scope in %s on line %d
+Parse error: syntax error, unexpected end of file in %s on line %d
diff --git a/Zend/tests/declare_001.phpt b/Zend/tests/declare_001.phpt
index 21d797880e..4eff18045c 100644
--- a/Zend/tests/declare_001.phpt
+++ b/Zend/tests/declare_001.phpt
@@ -13,7 +13,6 @@ zend.multibyte=1
 
 declare(encoding = 1);
 declare(encoding = 112313123213131232100);
-declare(encoding = NULL);
 declare(encoding = 'utf-8');
 declare(encoding = M_PI);
 
@@ -25,6 +24,4 @@ Warning: Unsupported encoding [1] in %sdeclare_001.php on line %d
 
 Warning: Unsupported encoding [1.1231312321313E+20] in %sdeclare_001.php on line %d
 
-Warning: Unsupported encoding [] in %sdeclare_001.php on line %d
-
-Fatal error: Cannot use constants as encoding in %sdeclare_001.php on line %d
+Fatal error: Encoding must be a literal in %s on line %d
diff --git a/Zend/tests/declare_003.phpt b/Zend/tests/declare_003.phpt
index 2980f7589b..2f3e887380 100644
--- a/Zend/tests/declare_003.phpt
+++ b/Zend/tests/declare_003.phpt
@@ -8,7 +8,6 @@ zend.multibyte=1
 
 declare(encoding = 1);
 declare(encoding = 11111111111111);
-declare(encoding = NULL);
 declare(encoding = M_PI);
 
 print 'DONE';
@@ -19,6 +18,4 @@ Warning: Unsupported encoding [1] in %sdeclare_003.php on line %d
 
 Warning: Unsupported encoding [11111111111111] in %sdeclare_003.php on line %d
 
-Warning: Unsupported encoding [] in %sdeclare_003.php on line %d
-
-Fatal error: Cannot use constants as encoding in %sdeclare_003.php on line %d
+Fatal error: Encoding must be a literal in %s on line %d
diff --git a/Zend/tests/errmsg_014.phpt b/Zend/tests/errmsg_014.phpt
deleted file mode 100644
index 77e12b05e9..0000000000
--- a/Zend/tests/errmsg_014.phpt
+++ /dev/null
@@ -1,17 +0,0 @@
---TEST--
-errmsg: cannot call __clone() method on objects
---FILE--
-<?php
-
-class test {
-	function __clone() {
-	}
-}
-
-$t = new test;
-$t->__clone();
-
-echo "Done\n";
-?>
---EXPECTF--	
-Fatal error: Cannot call __clone() method on objects - use 'clone $obj' instead in %s on line %d
diff --git a/Zend/tests/foreach_list_002.phpt b/Zend/tests/foreach_list_002.phpt
index 251870ba09..bc17d94268 100644
--- a/Zend/tests/foreach_list_002.phpt
+++ b/Zend/tests/foreach_list_002.phpt
@@ -9,7 +9,7 @@ foreach (array(array(1,2), array(3,4)) as list($a, )) {
 
 $array = [['a', 'b'], 'c', 'd'];
 
-foreach($array as list(list(), $a)) {
+foreach($array as list(, $a)) {
    var_dump($a); 
 }
 
diff --git a/Zend/tests/isset_003.phpt b/Zend/tests/isset_003.phpt
index 4db42a933b..92225b5906 100644
--- a/Zend/tests/isset_003.phpt
+++ b/Zend/tests/isset_003.phpt
@@ -14,7 +14,7 @@ var_dump(isset($a[0]->a));
 
 var_dump(isset($c[0][1][2]->a->b->c->d));
 
-var_dump(isset(${$a}->{$b->$c[$d]}));
+var_dump(isset(${$a}->{$b->{$c[$d]}}));
 
 var_dump(isset($GLOBALS));
 
diff --git a/Zend/tests/isset_003_2_4.phpt b/Zend/tests/isset_003_2_4.phpt
index c05f3e26f4..42d8cc6a08 100644
--- a/Zend/tests/isset_003_2_4.phpt
+++ b/Zend/tests/isset_003_2_4.phpt
@@ -16,7 +16,7 @@ var_dump(isset($a[0]->a));
 
 var_dump(isset($c[0][1][2]->a->b->c->d));
 
-var_dump(isset(${$a}->{$b->$c[$d]}));
+var_dump(isset(${$a}->{$b->{$c[$d]}}));
 
 var_dump(isset($GLOBALS));
 
diff --git a/Zend/tests/isset_func_error.phpt b/Zend/tests/isset_func_error.phpt
index 7d1036def8..7d6616b96d 100644
--- a/Zend/tests/isset_func_error.phpt
+++ b/Zend/tests/isset_func_error.phpt
@@ -5,4 +5,4 @@ Error message for isset(func())
 isset(abc());
 ?>
 --EXPECTF--
-Fatal error: Cannot use isset() on the result of a function call (you can use "null !== func()" instead) in %s on line %d
+Fatal error: Cannot use isset() on the result of an expression (you can use "null !== expression" instead) in %s on line %d
diff --git a/Zend/tests/list_005.phpt b/Zend/tests/list_005.phpt
index 4afc353b2f..ec5640a60a 100644
--- a/Zend/tests/list_005.phpt
+++ b/Zend/tests/list_005.phpt
@@ -3,33 +3,33 @@ Testing list() with several variables
 --FILE--
 <?php
 
-$a = "foo";
+$str = "foo";
 
-list($a, $b, $c) = $a;
+list($a, $b, $c) = $str;
 
 var_dump($a, $b, $c);
 
 print "----\n";
 
-$a = 1;
+$int = 1;
 
-list($a, $b, $c) = $a;
+list($a, $b, $c) = $int;
 
 var_dump($a, $b, $c);
 
 print "----\n";
 
-$a = new stdClass;
+$obj = new stdClass;
 
-list($a, $b, $c) = $a;
+list($a, $b, $c) = $obj;
 
 var_dump($a, $b, $c);
 
 print "----\n";
 
-$a = array(1, 2, 3);
+$arr = array(1, 2, 3);
 
-list($a, $b, $c) = $a;
+list($a, $b, $c) = $arr;
 
 var_dump($a, $b, $c);
 
diff --git a/Zend/tests/list_006.phpt b/Zend/tests/list_006.phpt
index f5f5970be4..d380235d25 100644
--- a/Zend/tests/list_006.phpt
+++ b/Zend/tests/list_006.phpt
@@ -7,8 +7,6 @@ list($a, list($b, list(list($d)))) = array();
 
 ?>
 --EXPECTF--
-Notice: Undefined offset: 1 in %s on line %d
+Notice: Undefined offset: 0 in %s on line %d
 
 Notice: Undefined offset: 1 in %s on line %d
-
-Notice: Undefined offset: 0 in %s on line %d
diff --git a/Zend/tests/use_const/no_global_fallback.phpt b/Zend/tests/use_const/no_global_fallback.phpt
index a128f353ed..64e2a154ce 100644
--- a/Zend/tests/use_const/no_global_fallback.phpt
+++ b/Zend/tests/use_const/no_global_fallback.phpt
@@ -10,5 +10,4 @@ var_dump(baz);
 
 ?>
 --EXPECTF--
-Notice: Use of undefined constant baz - assumed 'baz' in %s on line %d
-string(3) "baz"
+Fatal error: Undefined constant 'foo\bar\baz' in %s on line %d
diff --git a/Zend/tests/varSyntax/globalNonSimpleVariableError.phpt b/Zend/tests/varSyntax/globalNonSimpleVariableError.phpt
new file mode 100644
index 0000000000..ed04921f89
--- /dev/null
+++ b/Zend/tests/varSyntax/globalNonSimpleVariableError.phpt
@@ -0,0 +1,10 @@
+--TEST--
+Global keyword only accepts simple variables
+--FILE--
+<?php
+
+global $$foo->bar;
+
+?>
+--EXPECTF--
+Parse error: syntax error, unexpected '->' (T_OBJECT_OPERATOR), expecting ',' or ';' in %s on line %d
diff --git a/Zend/tests/varSyntax/indirectFcall.phpt b/Zend/tests/varSyntax/indirectFcall.phpt
new file mode 100644
index 0000000000..4cc5c1171a
--- /dev/null
+++ b/Zend/tests/varSyntax/indirectFcall.phpt
@@ -0,0 +1,53 @@
+--TEST--
+Indirect function calls
+--FILE--
+<?php
+
+function id($x = 'id') { return $x; }
+
+var_dump(0);
+
+id('var_dump')(1);
+id('id')('var_dump')(2);
+id('id')('id')('var_dump')(3);
+id()()('var_dump')(4);
+
+id(['udef', 'id'])[1]()('var_dump')(5);
+(id((object) ['a' => 'id', 'b' => 'udef'])->a)()()()()('var_dump')(6);
+
+$id = function($x) { return $x; };
+
+$id($id)('var_dump')(7);
+
+(function($x) { return $x; })('id')('var_dump')(8);
+
+($f = function($x = null) use (&$f) {
+    return $x ?: $f;
+})()()()('var_dump')(9);
+
+class Test {
+    public static function id($x = [__CLASS__, 'id']) { return $x; }
+}
+
+$obj = new Test;
+[$obj, 'id']()('id')($id)('var_dump')(10);
+['Test', 'id']()()('var_dump')(11);
+'id'()('id')('var_dump')(12);
+('i' . 'd')()('var_dump')(13);
+
+?>
+--EXPECT--
+int(0)
+int(1)
+int(2)
+int(3)
+int(4)
+int(5)
+int(6)
+int(7)
+int(8)
+int(9)
+int(10)
+int(11)
+int(12)
+int(13)
diff --git a/Zend/tests/varSyntax/issetOnTemp.phpt b/Zend/tests/varSyntax/issetOnTemp.phpt
new file mode 100644
index 0000000000..cd7bc006cd
--- /dev/null
+++ b/Zend/tests/varSyntax/issetOnTemp.phpt
@@ -0,0 +1,26 @@
+--TEST--
+isset() can be used on dereferences of temporary expressions
+--FILE--
+<?php
+
+var_dump(isset([0, 1][0]));
+var_dump(isset(([0, 1] + [])[0]));
+var_dump(isset([[0, 1]][0][0]));
+var_dump(isset(([[0, 1]] + [])[0][0]));
+var_dump(isset(((object) ['a' => 'b'])->a));
+var_dump(isset(['a' => 'b']->a));
+var_dump(isset("str"->a));
+var_dump(isset((['a' => 'b'] + [])->a));
+var_dump(isset((['a' => 'b'] + [])->a->b));
+
+?>
+--EXPECT--
+bool(true)
+bool(true)
+bool(true)
+bool(true)
+bool(true)
+bool(false)
+bool(false)
+bool(false)
+bool(false)
diff --git a/Zend/tests/varSyntax/newVariable.phpt b/Zend/tests/varSyntax/newVariable.phpt
new file mode 100644
index 0000000000..360f99ac36
--- /dev/null
+++ b/Zend/tests/varSyntax/newVariable.phpt
@@ -0,0 +1,39 @@
+--TEST--
+Variable as class name for new expression
+--FILE--
+<?php
+
+$className = 'stdClass';
+$array = ['className' => 'stdClass'];
+$obj = (object) ['className' => 'stdClass'];
+
+class Test {
+    public static $className = 'stdClass';
+}
+$test = 'Test';
+$weird = [0 => (object) ['foo' => 'Test']];
+
+var_dump(new $className);
+var_dump(new $array['className']);
+var_dump(new $array{'className'});
+var_dump(new $obj->className);
+var_dump(new Test::$className);
+var_dump(new $test::$className);
+var_dump(new $weird[0]->foo::$className);
+
+?>
+--EXPECTF--
+object(stdClass)#%d (0) {
+}
+object(stdClass)#%d (0) {
+}
+object(stdClass)#%d (0) {
+}
+object(stdClass)#%d (0) {
+}
+object(stdClass)#%d (0) {
+}
+object(stdClass)#%d (0) {
+}
+object(stdClass)#%d (0) {
+}
diff --git a/Zend/tests/varSyntax/parenthesesDeref.phpt b/Zend/tests/varSyntax/parenthesesDeref.phpt
new file mode 100644
index 0000000000..0ebfe9c5d7
--- /dev/null
+++ b/Zend/tests/varSyntax/parenthesesDeref.phpt
@@ -0,0 +1,20 @@
+--TEST--
+Dereferencing expression parentheses
+--FILE--
+<?php
+
+$array = [&$array, 1];
+var_dump(($array)[1]);
+var_dump((($array[0][0])[0])[1]);
+
+var_dump(((object) ['a' => 0, 'b' => 1])->b);
+
+$obj = (object) ['a' => 0, 'b' => ['var_dump', 1]];
+(clone $obj)->b[0](1);
+
+?>
+--EXPECT--
+int(1)
+int(1)
+int(1)
+int(1)
diff --git a/Zend/tests/varSyntax/propertyOfStringError.phpt b/Zend/tests/varSyntax/propertyOfStringError.phpt
new file mode 100644
index 0000000000..85abc5849a
--- /dev/null
+++ b/Zend/tests/varSyntax/propertyOfStringError.phpt
@@ -0,0 +1,10 @@
+--TEST--
+Cannot take property of a string
+--FILE--
+<?php
+
+"foo"->bar;
+
+?>
+--EXPECTF--
+Notice: Trying to get property of non-object in %s on line %d
diff --git a/Zend/tests/varSyntax/staticMember.phpt b/Zend/tests/varSyntax/staticMember.phpt
new file mode 100644
index 0000000000..22a1fa2b13
--- /dev/null
+++ b/Zend/tests/varSyntax/staticMember.phpt
@@ -0,0 +1,37 @@
+--TEST--
+Static member access
+--FILE--
+<?php
+
+class A {
+    public static $b = 0;
+    public static $c = [0, 1];
+    public static $A_str = 'A';
+}
+
+$A_str = 'A';
+$A_obj = new A;
+$b_str = 'b';
+$c_str = 'c';
+
+var_dump(A::$b);
+var_dump($A_str::$b);
+var_dump($A_obj::$b);
+var_dump(('A' . '')::$b);
+var_dump('A'::$b);
+var_dump('A'[0]::$b);
+var_dump(A::$$b_str);
+var_dump(A::$$c_str[1]);
+var_dump(A::$A_str::$b);
+
+?>
+--EXPECT--
+int(0)
+int(0)
+int(0)
+int(0)
+int(0)
+int(0)
+int(0)
+int(1)
+int(0)
diff --git a/Zend/tests/varSyntax/tempDimFetchByRefError.phpt b/Zend/tests/varSyntax/tempDimFetchByRefError.phpt
new file mode 100644
index 0000000000..dbcac75ea9
--- /dev/null
+++ b/Zend/tests/varSyntax/tempDimFetchByRefError.phpt
@@ -0,0 +1,11 @@
+--TEST--
+Passing a dimention fetch on a temporary by reference is not allowed
+--FILE--
+<?php
+
+$fn = function(&$ref) {};
+$fn([0, 1][0]);
+
+?>
+--EXPECTF--
+Fatal error: Cannot use temporary expression in write context in %s on line %d
diff --git a/Zend/tests/varSyntax/tempPropFetchByRefError.phpt b/Zend/tests/varSyntax/tempPropFetchByRefError.phpt
new file mode 100644
index 0000000000..f8298a936d
--- /dev/null
+++ b/Zend/tests/varSyntax/tempPropFetchByRefError.phpt
@@ -0,0 +1,11 @@
+--TEST--
+Passing a property fetch on a temporary by reference is not allowed
+--FILE--
+<?php
+
+$fn = function(&$ref) {};
+$fn([0, 1]->prop);
+
+?>
+--EXPECTF--
+Fatal error: Cannot use temporary expression in write context in %s on line %d
diff --git a/Zend/tests/varSyntax/writeToTempExpr.phpt b/Zend/tests/varSyntax/writeToTempExpr.phpt
new file mode 100644
index 0000000000..daeaf24938
--- /dev/null
+++ b/Zend/tests/varSyntax/writeToTempExpr.phpt
@@ -0,0 +1,10 @@
+--TEST--
+Writing to a temporary expression is not allowed
+--FILE--
+<?php
+
+[0, 1][0] = 1;
+
+?>
+--EXPECTF--
+Fatal error: Cannot use temporary expression in write context in %s on line %d
diff --git a/Zend/zend.c b/Zend/zend.c
index 413c799a37..2d4232ee98 100644
--- a/Zend/zend.c
+++ b/Zend/zend.c
@@ -1021,13 +1021,9 @@ ZEND_API void zend_error(int type, const char *format, ...) /* {{{ */
 	zval orig_user_error_handler;
 	zend_bool in_compilation;
 	zend_class_entry *saved_class_entry;
-	zend_stack bp_stack;
-	zend_stack function_call_stack;
 	zend_stack switch_cond_stack;
 	zend_stack foreach_copy_stack;
-	zend_stack object_stack;
-	zend_stack declare_stack;
-	zend_stack list_stack;
+	zend_stack delayed_oplines_stack;
 	zend_stack context_stack;
 	zend_array *symbol_table;
 	TSRMLS_FETCH();
@@ -1190,13 +1186,9 @@ ZEND_API void zend_error(int type, const char *format, ...) /* {{{ */
 			if (in_compilation) {
 				saved_class_entry = CG(active_class_entry);
 				CG(active_class_entry) = NULL;
-				SAVE_STACK(bp_stack);
-				SAVE_STACK(function_call_stack);
 				SAVE_STACK(switch_cond_stack);
 				SAVE_STACK(foreach_copy_stack);
-				SAVE_STACK(object_stack);
-				SAVE_STACK(declare_stack);
-				SAVE_STACK(list_stack);
+				SAVE_STACK(delayed_oplines_stack);
 				SAVE_STACK(context_stack);
 				CG(in_compilation) = 0;
 			}
@@ -1216,13 +1208,9 @@ ZEND_API void zend_error(int type, const char *format, ...) /* {{{ */
 
 			if (in_compilation) {
 				CG(active_class_entry) = saved_class_entry;
-				RESTORE_STACK(bp_stack);
-				RESTORE_STACK(function_call_stack);
 				RESTORE_STACK(switch_cond_stack);
 				RESTORE_STACK(foreach_copy_stack);
-				RESTORE_STACK(object_stack);
-				RESTORE_STACK(declare_stack);
-				RESTORE_STACK(list_stack);
+				RESTORE_STACK(delayed_oplines_stack);
 				RESTORE_STACK(context_stack);
 				CG(in_compilation) = 1;
 			}
diff --git a/Zend/zend.h b/Zend/zend.h
index 0e8de14cb4..c667b6c45a 100644
--- a/Zend/zend.h
+++ b/Zend/zend.h
@@ -309,7 +309,6 @@ void zend_error_noreturn(int type, const char *format, ...) __attribute__ ((nore
 #endif
 
 #include "zend_object_handlers.h"
-#include "zend_ast.h"
 
 /* overloaded elements data types */
 #define OE_IS_ARRAY					(1<<0)
@@ -401,6 +400,7 @@ void zend_error_noreturn(int type, const char *format, ...) __attribute__ ((nore
 #endif
 
 #include "zend_string.h"
+#include "zend_ast.h"
 
 static zend_always_inline uint32_t zval_refcount_p(zval* pz) {
 	ZEND_ASSERT(Z_REFCOUNTED_P(pz) || Z_IMMUTABLE_P(pz));
diff --git a/Zend/zend_ast.c b/Zend/zend_ast.c
index 810b9b1fe8..2532018274 100644
--- a/Zend/zend_ast.c
+++ b/Zend/zend_ast.c
@@ -23,82 +23,146 @@
 #include "zend_API.h"
 #include "zend_operators.h"
 
-ZEND_API zend_ast *zend_ast_create_constant(zval *zv)
-{
-	zend_ast *ast = emalloc(sizeof(zend_ast) + sizeof(zval));
-	ast->kind = ZEND_CONST;
-	ast->children = 0;
-	ZVAL_COPY_VALUE(&ast->u.val, zv);
-	return ast;
+static inline void *zend_ast_alloc(size_t size TSRMLS_DC) {
+	return zend_arena_alloc(&CG(ast_arena), size);
 }
 
-ZEND_API zend_ast* zend_ast_create_unary(uint kind, zend_ast *op0)
-{
-	zend_ast *ast = emalloc(sizeof(zend_ast));
+static inline void *zend_ast_realloc(void *old, size_t old_size, size_t new_size TSRMLS_DC) {
+	void *new = zend_ast_alloc(new_size TSRMLS_CC);
+	memcpy(new, old, old_size);
+	return new;
+}
+
+static inline size_t zend_ast_size(uint32_t children) {
+	return sizeof(zend_ast) - sizeof(zend_ast *) + sizeof(zend_ast *) * children;
+}
+
+static inline size_t zend_ast_list_size(uint32_t children) {
+	return sizeof(zend_ast_list) - sizeof(zend_ast *) + sizeof(zend_ast *) * children;
+}
+
+ZEND_API zend_ast *zend_ast_create_znode(znode *node) {
+	TSRMLS_FETCH();
+	zend_ast_znode *ast = zend_ast_alloc(sizeof(zend_ast_znode) TSRMLS_CC);
+	ast->kind = ZEND_AST_ZNODE;
+	ast->attr = 0;
+	ast->lineno = CG(zend_lineno);
+	ast->node = *node;
+	return (zend_ast *) ast;
+}
+
+ZEND_API zend_ast *zend_ast_create_zval_ex(zval *zv, zend_ast_attr attr) {
+	TSRMLS_FETCH();
+	zend_ast_zval *ast = zend_ast_alloc(sizeof(zend_ast_zval) TSRMLS_CC);
+	ast->kind = ZEND_AST_ZVAL;
+	ast->attr = attr;
+	ZVAL_COPY_VALUE(&ast->val, zv);
+	ast->val.u2.lineno = CG(zend_lineno);
+	return (zend_ast *) ast;
+}
+
+ZEND_API zend_ast *zend_ast_create_decl(
+	zend_ast_kind kind, uint32_t flags, uint32_t start_lineno, zend_string *doc_comment,
+	zend_string *name, zend_ast *child0, zend_ast *child1, zend_ast *child2
+) {
+	TSRMLS_FETCH();
+	zend_ast_decl *ast = zend_ast_alloc(sizeof(zend_ast_decl) TSRMLS_CC);
+
 	ast->kind = kind;
-	ast->children = 1;
-	(&ast->u.child)[0] = op0;
-	return ast;
+	ast->attr = 0;
+	ast->start_lineno = start_lineno;
+	ast->end_lineno = CG(zend_lineno);
+	ast->flags = flags;
+	ast->lex_pos = LANG_SCNG(yy_text);
+	ast->doc_comment = doc_comment;
+	ast->name = name;
+	ast->child[0] = child0;
+	ast->child[1] = child1;
+	ast->child[2] = child2;
+
+	return (zend_ast *) ast;
 }
 
-ZEND_API zend_ast* zend_ast_create_binary(uint kind, zend_ast *op0, zend_ast *op1)
-{
-	zend_ast *ast = emalloc(sizeof(zend_ast) + sizeof(zend_ast*));
+static zend_ast *zend_ast_create_from_va_list(zend_ast_kind kind, zend_ast_attr attr, va_list va) {
+	TSRMLS_FETCH();
+	uint32_t i, children = kind >> ZEND_AST_NUM_CHILDREN_SHIFT;
+	zend_ast *ast = zend_ast_alloc(zend_ast_size(children) TSRMLS_CC);
 	ast->kind = kind;
-	ast->children = 2;
-	(&ast->u.child)[0] = op0;
-	(&ast->u.child)[1] = op1;
+	ast->attr = attr;
+	ast->lineno = (uint32_t) -1;
+
+	for (i = 0; i < children; ++i) {
+		ast->child[i] = va_arg(va, zend_ast *);
+		if (ast->child[i] != NULL) {
+			uint32_t lineno = zend_ast_get_lineno(ast->child[i]);
+			if (lineno < ast->lineno) {
+				ast->lineno = lineno;
+			}
+		}
+	}
+
+	if (ast->lineno == UINT_MAX) {
+		ast->lineno = CG(zend_lineno);
+	}
+
 	return ast;
 }
 
-ZEND_API zend_ast* zend_ast_create_ternary(uint kind, zend_ast *op0, zend_ast *op1, zend_ast *op2)
-{
-	zend_ast *ast = emalloc(sizeof(zend_ast) + sizeof(zend_ast*) * 2);
-	ast->kind = kind;
-	ast->children = 3;
-	(&ast->u.child)[0] = op0;
-	(&ast->u.child)[1] = op1;
-	(&ast->u.child)[2] = op2;
+ZEND_API zend_ast *zend_ast_create_ex(zend_ast_kind kind, zend_ast_attr attr, ...) {
+	va_list va;
+	zend_ast *ast;
+
+	va_start(va, attr);
+	ast = zend_ast_create_from_va_list(kind, attr, va);
+	va_end(va);
+
 	return ast;
 }
 
-ZEND_API zend_ast* zend_ast_create_dynamic(uint kind)
-{
-	zend_ast *ast = emalloc(sizeof(zend_ast) + sizeof(zend_ast*) * 3); /* use 4 children as deafult */
-	ast->kind = kind;
-	ast->children = 0;
+ZEND_API zend_ast *zend_ast_create(zend_ast_kind kind, ...) {
+	va_list va;
+	zend_ast *ast;
+
+	va_start(va, kind);
+	ast = zend_ast_create_from_va_list(kind, 0, va);
+	va_end(va);
+
 	return ast;
 }
 
-ZEND_API void zend_ast_dynamic_add(zend_ast **ast, zend_ast *op)
-{
-	if ((*ast)->children >= 4 && (*ast)->children == ((*ast)->children & -(*ast)->children)) {
-		*ast = erealloc(*ast, sizeof(zend_ast) + sizeof(zend_ast*) * ((*ast)->children * 2 + 1));
+ZEND_API zend_ast_list *zend_ast_create_list(uint32_t init_children, zend_ast_kind kind, ...) {
+	TSRMLS_FETCH();
+	zend_ast_list *list = zend_ast_alloc(zend_ast_list_size(4) TSRMLS_CC);
+	list->kind = kind;
+	list->attr = 0;
+	list->lineno = CG(zend_lineno);
+	list->children = 0;
+
+	{
+		va_list va;
+		uint32_t i;
+		va_start(va, kind);
+		for (i = 0; i < init_children; ++i) {
+			list = zend_ast_list_add(list, va_arg(va, zend_ast *));
+		}
+		va_end(va);
 	}
-	(&(*ast)->u.child)[(*ast)->children++] = op;
-}
 
-ZEND_API void zend_ast_dynamic_shrink(zend_ast **ast)
-{
-	*ast = erealloc(*ast, sizeof(zend_ast) + sizeof(zend_ast*) * ((*ast)->children - 1));
+	return list;
 }
 
-ZEND_API int zend_ast_is_ct_constant(zend_ast *ast)
-{
-	int i;
+static inline zend_bool is_power_of_two(uint32_t n) {
+	return n == (n & -n);
+}
 
-	if (ast->kind == ZEND_CONST) {
-		return !Z_CONSTANT(ast->u.val);
-	} else {
-		for (i = 0; i < ast->children; i++) {
-			if ((&ast->u.child)[i]) {
-				if (!zend_ast_is_ct_constant((&ast->u.child)[i])) {
-					return 0;
-				}
-			}
-		}
-		return 1;
+ZEND_API zend_ast_list *zend_ast_list_add(zend_ast_list *list, zend_ast *op) {
+	if (list->children >= 4 && is_power_of_two(list->children)) {
+		TSRMLS_FETCH();
+		list = zend_ast_realloc(list,
+			zend_ast_list_size(list->children), zend_ast_list_size(list->children * 2) TSRMLS_CC);
 	}
+	list->child[list->children++] = op;
+	return list;
 }
 
 static void zend_ast_add_array_element(zval *result, zval *offset, zval *expr TSRMLS_DC)
@@ -137,167 +201,58 @@ ZEND_API void zend_ast_evaluate(zval *result, zend_ast *ast, zend_class_entry *s
 	zval op1, op2;
 
 	switch (ast->kind) {
-		case ZEND_ADD:
-			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
-			zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
-			add_function(result, &op1, &op2 TSRMLS_CC);
-			zval_dtor(&op1);
-			zval_dtor(&op2);
-			break;
-		case ZEND_SUB:
-			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
-			zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
-			sub_function(result, &op1, &op2 TSRMLS_CC);
-			zval_dtor(&op1);
-			zval_dtor(&op2);
-			break;
-		case ZEND_MUL:
-			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
-			zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
-			mul_function(result, &op1, &op2 TSRMLS_CC);
-			zval_dtor(&op1);
-			zval_dtor(&op2);
-			break;
-		case ZEND_POW:
-			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
-			zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
-			pow_function(result, &op1, &op2 TSRMLS_CC);
-			zval_dtor(&op1);
-			zval_dtor(&op2);
-			break;
-		case ZEND_DIV:
-			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
-			zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
-			div_function(result, &op1, &op2 TSRMLS_CC);
-			zval_dtor(&op1);
-			zval_dtor(&op2);
-			break;
-		case ZEND_MOD:
-			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
-			zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
-			mod_function(result, &op1, &op2 TSRMLS_CC);
-			zval_dtor(&op1);
-			zval_dtor(&op2);
-			break;
-		case ZEND_SL:
-			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
-			zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
-			shift_left_function(result, &op1, &op2 TSRMLS_CC);
-			zval_dtor(&op1);
-			zval_dtor(&op2);
-			break;
-		case ZEND_SR:
-			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
-			zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
-			shift_right_function(result, &op1, &op2 TSRMLS_CC);
-			zval_dtor(&op1);
-			zval_dtor(&op2);
-			break;
-		case ZEND_CONCAT:
-			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
-			zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
-			concat_function(result, &op1, &op2 TSRMLS_CC);
-			zval_dtor(&op1);
-			zval_dtor(&op2);
-			break;
-		case ZEND_BW_OR:
-			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
-			zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
-			bitwise_or_function(result, &op1, &op2 TSRMLS_CC);
-			zval_dtor(&op1);
-			zval_dtor(&op2);
-			break;
-		case ZEND_BW_AND:
-			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
-			zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
-			bitwise_and_function(result, &op1, &op2 TSRMLS_CC);
-			zval_dtor(&op1);
-			zval_dtor(&op2);
-			break;
-		case ZEND_BW_XOR:
-			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
-			zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
-			bitwise_xor_function(result, &op1, &op2 TSRMLS_CC);
-			zval_dtor(&op1);
-			zval_dtor(&op2);
-			break;
-		case ZEND_BW_NOT:
-			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
-			bitwise_not_function(result, &op1 TSRMLS_CC);
-			zval_dtor(&op1);
-			break;
-		case ZEND_BOOL_NOT:
-			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
-			boolean_not_function(result, &op1 TSRMLS_CC);
-			zval_dtor(&op1);
-			break;
-		case ZEND_BOOL_XOR:
-			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
-			zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
-			boolean_xor_function(result, &op1, &op2 TSRMLS_CC);
-			zval_dtor(&op1);
-			zval_dtor(&op2);
-			break;
-		case ZEND_IS_IDENTICAL:
-			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
-			zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
-			is_identical_function(result, &op1, &op2 TSRMLS_CC);
-			zval_dtor(&op1);
-			zval_dtor(&op2);
-			break;
-		case ZEND_IS_NOT_IDENTICAL:
-			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
-			zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
-			is_not_identical_function(result, &op1, &op2 TSRMLS_CC);
-			zval_dtor(&op1);
-			zval_dtor(&op2);
-			break;
-		case ZEND_IS_EQUAL:
-			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
-			zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
-			is_equal_function(result, &op1, &op2 TSRMLS_CC);
-			zval_dtor(&op1);
-			zval_dtor(&op2);
-			break;
-		case ZEND_IS_NOT_EQUAL:
-			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
-			zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
-			is_not_equal_function(result, &op1, &op2 TSRMLS_CC);
+		case ZEND_AST_BINARY_OP:
+		{
+			binary_op_type op = get_binary_op(ast->attr);
+			zend_ast_evaluate(&op1, ast->child[0], scope TSRMLS_CC);
+			zend_ast_evaluate(&op2, ast->child[1], scope TSRMLS_CC);
+			op(result, &op1, &op2 TSRMLS_CC);
 			zval_dtor(&op1);
 			zval_dtor(&op2);
 			break;
-		case ZEND_IS_SMALLER:
-			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
-			zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
-			is_smaller_function(result, &op1, &op2 TSRMLS_CC);
+		}
+		case ZEND_AST_GREATER:
+		case ZEND_AST_GREATER_EQUAL:
+		{
+			/* op1 > op2 is the same as op2 < op1 */
+			binary_op_type op = ast->kind == ZEND_AST_GREATER
+				? is_smaller_function : is_smaller_or_equal_function;
+			zend_ast_evaluate(&op1, ast->child[0], scope TSRMLS_CC);
+			zend_ast_evaluate(&op2, ast->child[1], scope TSRMLS_CC);
+			op(result, &op2, &op1 TSRMLS_CC);
 			zval_dtor(&op1);
 			zval_dtor(&op2);
 			break;
-		case ZEND_IS_SMALLER_OR_EQUAL:
-			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
-			zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
-			is_smaller_or_equal_function(result, &op1, &op2 TSRMLS_CC);
+		}
+		case ZEND_AST_UNARY_OP:
+		{
+			unary_op_type op = get_unary_op(ast->attr);
+			zend_ast_evaluate(&op1, ast->child[0], scope TSRMLS_CC);
+			op(result, &op1 TSRMLS_CC);
 			zval_dtor(&op1);
-			zval_dtor(&op2);
 			break;
-		case ZEND_CONST:
-			/* class constants may be updated in-place */
+		}
+		case ZEND_AST_ZVAL:
+		{
+			zval *zv = zend_ast_get_zval(ast);
 			if (scope) {
-				if (Z_OPT_CONSTANT(ast->u.val)) {
-					zval_update_constant_ex(&ast->u.val, 1, scope TSRMLS_CC);
+				/* class constants may be updated in-place */
+				if (Z_OPT_CONSTANT_P(zv)) {
+					zval_update_constant_ex(zv, 1, scope TSRMLS_CC);
 				}
-				ZVAL_DUP(result, &ast->u.val);
+				ZVAL_DUP(result, zv);
 			} else {
-				ZVAL_DUP(result, &ast->u.val);
+				ZVAL_DUP(result, zv);
 				if (Z_OPT_CONSTANT_P(result)) {
 					zval_update_constant_ex(result, 1, scope TSRMLS_CC);
 				}
 			}
 			break;
-		case ZEND_BOOL_AND:
-			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
+		}
+		case ZEND_AST_AND:
+			zend_ast_evaluate(&op1, ast->child[0], scope TSRMLS_CC);
 			if (zend_is_true(&op1 TSRMLS_CC)) {
-				zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
+				zend_ast_evaluate(&op2, ast->child[1], scope TSRMLS_CC);
 				ZVAL_BOOL(result, zend_is_true(&op2 TSRMLS_CC));
 				zval_dtor(&op2);
 			} else {
@@ -305,61 +260,63 @@ ZEND_API void zend_ast_evaluate(zval *result, zend_ast *ast, zend_class_entry *s
 			}
 			zval_dtor(&op1);
 			break;
-		case ZEND_BOOL_OR:
-			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
+		case ZEND_AST_OR:
+			zend_ast_evaluate(&op1, ast->child[0], scope TSRMLS_CC);
 			if (zend_is_true(&op1 TSRMLS_CC)) {
 				ZVAL_BOOL(result, 1);
 			} else {
-				zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
+				zend_ast_evaluate(&op2, ast->child[1], scope TSRMLS_CC);
 				ZVAL_BOOL(result, zend_is_true(&op2 TSRMLS_CC));
 				zval_dtor(&op2);
 			}
 			zval_dtor(&op1);
 			break;
-		case ZEND_SELECT:
-			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
+		case ZEND_AST_CONDITIONAL:
+			zend_ast_evaluate(&op1, ast->child[0], scope TSRMLS_CC);
 			if (zend_is_true(&op1 TSRMLS_CC)) {
-				if (!(&ast->u.child)[1]) {
+				if (!ast->child[1]) {
 					*result = op1;
 				} else {
-					zend_ast_evaluate(result, (&ast->u.child)[1], scope TSRMLS_CC);
+					zend_ast_evaluate(result, ast->child[1], scope TSRMLS_CC);
 					zval_dtor(&op1);
 				}
 			} else {
-				zend_ast_evaluate(result, (&ast->u.child)[2], scope TSRMLS_CC);
+				zend_ast_evaluate(result, ast->child[2], scope TSRMLS_CC);
 				zval_dtor(&op1);
 			}
 			break;
-		case ZEND_UNARY_PLUS:
+		case ZEND_AST_UNARY_PLUS:
 			ZVAL_LONG(&op1, 0);
-			zend_ast_evaluate(&op2, (&ast->u.child)[0], scope TSRMLS_CC);
+			zend_ast_evaluate(&op2, ast->child[0], scope TSRMLS_CC);
 			add_function(result, &op1, &op2 TSRMLS_CC);
 			zval_dtor(&op2);
 			break;
-		case ZEND_UNARY_MINUS:
+		case ZEND_AST_UNARY_MINUS:
 			ZVAL_LONG(&op1, 0);
-			zend_ast_evaluate(&op2, (&ast->u.child)[0], scope TSRMLS_CC);
+			zend_ast_evaluate(&op2, ast->child[0], scope TSRMLS_CC);
 			sub_function(result, &op1, &op2 TSRMLS_CC);
 			zval_dtor(&op2);
 			break;
-		case ZEND_INIT_ARRAY:
+		case ZEND_AST_ARRAY:
 			array_init(result);
 			{
-				int i;
-				for (i = 0; i < ast->children; i+=2) {
-					if ((&ast->u.child)[i]) {
-						zend_ast_evaluate(&op1, (&ast->u.child)[i], scope TSRMLS_CC);
+				uint32_t i;
+				zend_ast_list *list = zend_ast_get_list(ast);
+				for (i = 0; i < list->children; i++) {
+					zend_ast *elem = list->child[i];
+					if (elem->child[1]) {
+						zend_ast_evaluate(&op1, elem->child[1], scope TSRMLS_CC);
 					} else {
 						ZVAL_UNDEF(&op1);
 					}
-					zend_ast_evaluate(&op2, (&ast->u.child)[i+1], scope TSRMLS_CC);
+					zend_ast_evaluate(&op2, elem->child[0], scope TSRMLS_CC);
 					zend_ast_add_array_element(result, &op1, &op2 TSRMLS_CC);
 				}
 			}
 			break;
-		case ZEND_FETCH_DIM_R:
-			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
-			zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
+		case ZEND_AST_DIM:
+			zend_ast_evaluate(&op1, ast->child[0], scope TSRMLS_CC);
+			zend_ast_evaluate(&op2, ast->child[1], scope TSRMLS_CC);
 			{
 				zval tmp;
 				zend_fetch_dimension_by_zval(&tmp, &op1, &op2 TSRMLS_CC);
@@ -377,35 +334,105 @@ ZEND_API zend_ast *zend_ast_copy(zend_ast *ast)
 {
 	if (ast == NULL) {
 		return NULL;
-	} else if (ast->kind == ZEND_CONST) {
-		zend_ast *copy = zend_ast_create_constant(&ast->u.val);
-		zval_copy_ctor(&copy->u.val);
-		return copy;
-	} else if (ast->children) {
-		zend_ast *new = emalloc(sizeof(zend_ast) + sizeof(zend_ast*) * (ast->children - 1));
-		int i;
+	} else if (ast->kind == ZEND_AST_ZVAL) {
+		zend_ast_zval *new = emalloc(sizeof(zend_ast_zval));
+		new->kind = ZEND_AST_ZVAL;
+		new->attr = ast->attr;
+		ZVAL_COPY(&new->val, zend_ast_get_zval(ast));
+		return (zend_ast *) new;
+	} else if (zend_ast_is_list(ast)) {
+		zend_ast_list *list = zend_ast_get_list(ast);
+		zend_ast_list *new = emalloc(zend_ast_list_size(list->children));
+		uint32_t i;
+		new->kind = list->kind;
+		new->attr = list->attr;
+		new->children = list->children;
+		for (i = 0; i < list->children; i++) {
+			new->child[i] = zend_ast_copy(list->child[i]);
+		}
+		return (zend_ast *) new;
+	} else {
+		uint32_t i, children = zend_ast_get_num_children(ast);
+		zend_ast *new = emalloc(zend_ast_size(children));
 		new->kind = ast->kind;
-		new->children = ast->children;
-		for (i = 0; i < ast->children; i++) {
-			(&new->u.child)[i] = zend_ast_copy((&ast->u.child)[i]);
+		new->attr = ast->attr;
+		for (i = 0; i < children; i++) {
+			new->child[i] = zend_ast_copy(ast->child[i]);
 		}
 		return new;
 	}
-	return zend_ast_create_dynamic(ast->kind);
 }
 
-ZEND_API void zend_ast_destroy(zend_ast *ast)
-{
-	int i;
+static void zend_ast_destroy_ex(zend_ast *ast, zend_bool free) {
+	if (!ast) {
+		return;
+	}
 
-	if (ast->kind == ZEND_CONST) {
-		zval_dtor(&ast->u.val);
-	} else {
-		for (i = 0; i < ast->children; i++) {
-			if ((&ast->u.child)[i]) {
-				zend_ast_destroy((&ast->u.child)[i]);
+	switch (ast->kind) {
+		case ZEND_AST_ZVAL:
+		{
+			/* Destroy value without using GC: When opcache moves arrays into SHM it will
+			 * free the zend_array structure, so references to it from outside the op array
+			 * become invalid. GC would cause such a reference in the root buffer. */
+			zval *zv = zend_ast_get_zval(ast);
+			if (Z_REFCOUNTED_P(zv) && !Z_DELREF_P(zv)) {
+				_zval_dtor_func_for_ptr(Z_COUNTED_P(zv) ZEND_FILE_LINE_CC);
+			}
+			break;
+		}
+		case ZEND_AST_FUNC_DECL:
+		case ZEND_AST_CLOSURE:
+		case ZEND_AST_METHOD:
+		case ZEND_AST_CLASS:
+		{
+			zend_ast_decl *decl = (zend_ast_decl *) ast;
+			zend_string_release(decl->name);
+			if (decl->doc_comment) {
+				zend_string_release(decl->doc_comment);
+			}
+			zend_ast_destroy_ex(decl->child[0], free);
+			zend_ast_destroy_ex(decl->child[1], free);
+			zend_ast_destroy_ex(decl->child[2], free);
+			break;
+		}
+		default:
+			if (zend_ast_is_list(ast)) {
+				zend_ast_list *list = zend_ast_get_list(ast);
+				uint32_t i;
+				for (i = 0; i < list->children; i++) {
+					zend_ast_destroy_ex(list->child[i], free);
+				}
+			} else {
+				uint32_t i, children = zend_ast_get_num_children(ast);
+				for (i = 0; i < children; i++) {
+					zend_ast_destroy_ex(ast->child[i], free);
+				}
 			}
+	}
+
+	if (free) {
+		efree(ast);
+	}
+}
+
+ZEND_API void zend_ast_destroy(zend_ast *ast) {
+	zend_ast_destroy_ex(ast, 0);
+}
+ZEND_API void zend_ast_destroy_and_free(zend_ast *ast) {
+	zend_ast_destroy_ex(ast, 1);
+}
+
+ZEND_API void zend_ast_apply(zend_ast *ast, zend_ast_apply_func fn TSRMLS_DC) {
+	if (zend_ast_is_list(ast)) {
+		zend_ast_list *list = zend_ast_get_list(ast);
+		uint32_t i;
+		for (i = 0; i < list->children; ++i) {
+			fn(&list->child[i] TSRMLS_CC);
+		}
+	} else {
+		uint32_t i, children = zend_ast_get_num_children(ast);
+		for (i = 0; i < children; ++i) {
+			fn(&ast->child[i] TSRMLS_CC);
 		}
 	}
-	efree(ast);
 }
diff --git a/Zend/zend_ast.h b/Zend/zend_ast.h
index 8678299f0f..24d2aa6308 100644
--- a/Zend/zend_ast.h
+++ b/Zend/zend_ast.h
@@ -14,6 +14,7 @@
    +----------------------------------------------------------------------+
    | Authors: Bob Weinand <bwoebi@php.net>                                |
    |          Dmitry Stogov <dmitry@zend.com>                             |
+   |          Nikita Popov <nikic@php.net>                                |
    +----------------------------------------------------------------------+
 */
 
@@ -24,39 +25,239 @@
 
 #include "zend.h"
 
-typedef enum _zend_ast_kind {
-	/* first 256 kinds are reserved for opcodes */
-	ZEND_CONST = 256,
-	ZEND_BOOL_AND,
-	ZEND_BOOL_OR,
-	ZEND_SELECT,
-	ZEND_UNARY_PLUS,
-	ZEND_UNARY_MINUS,
-} zend_ast_kind;
+#define ZEND_AST_SPECIAL_SHIFT      6
+#define ZEND_AST_IS_LIST_SHIFT      7
+#define ZEND_AST_NUM_CHILDREN_SHIFT 8
+
+enum _zend_ast_kind {
+	/* special nodes */
+	ZEND_AST_ZVAL = 1 << ZEND_AST_SPECIAL_SHIFT,
+	ZEND_AST_ZNODE,
+
+	/* declaration nodes */
+	ZEND_AST_FUNC_DECL,
+	ZEND_AST_CLOSURE,
+	ZEND_AST_METHOD,
+	ZEND_AST_CLASS,
+
+	/* list nodes */
+	ZEND_AST_ARG_LIST = 1 << ZEND_AST_IS_LIST_SHIFT,
+	ZEND_AST_LIST,
+	ZEND_AST_ARRAY,
+	ZEND_AST_ENCAPS_LIST,
+	ZEND_AST_EXPR_LIST,
+	ZEND_AST_STMT_LIST,
+	ZEND_AST_IF,
+	ZEND_AST_SWITCH_LIST,
+	ZEND_AST_CATCH_LIST,
+	ZEND_AST_PARAM_LIST,
+	ZEND_AST_CLOSURE_USES,
+	ZEND_AST_PROP_DECL,
+	ZEND_AST_CONST_DECL,
+	ZEND_AST_CLASS_CONST_DECL,
+	ZEND_AST_NAME_LIST,
+	ZEND_AST_TRAIT_ADAPTATIONS,
+	ZEND_AST_USE,
+
+	/* 0 child nodes */
+	ZEND_AST_MAGIC_CONST = 0 << ZEND_AST_NUM_CHILDREN_SHIFT,
+	ZEND_AST_TYPE,
+
+	/* 1 child node */
+	ZEND_AST_VAR = 1 << ZEND_AST_NUM_CHILDREN_SHIFT,
+	ZEND_AST_CONST,
+	ZEND_AST_RESOLVE_CLASS_NAME,
+	ZEND_AST_UNPACK,
+	ZEND_AST_UNARY_PLUS,
+	ZEND_AST_UNARY_MINUS,
+	ZEND_AST_CAST,
+	ZEND_AST_EMPTY,
+	ZEND_AST_ISSET,
+	ZEND_AST_SILENCE,
+	ZEND_AST_SHELL_EXEC,
+	ZEND_AST_CLONE,
+	ZEND_AST_EXIT,
+	ZEND_AST_PRINT,
+	ZEND_AST_INCLUDE_OR_EVAL,
+	ZEND_AST_UNARY_OP,
+	ZEND_AST_PRE_INC,
+	ZEND_AST_PRE_DEC,
+	ZEND_AST_POST_INC,
+	ZEND_AST_POST_DEC,
+
+	ZEND_AST_GLOBAL,
+	ZEND_AST_UNSET,
+	ZEND_AST_RETURN,
+	ZEND_AST_LABEL,
+	ZEND_AST_REF,
+	ZEND_AST_HALT_COMPILER,
+	ZEND_AST_ECHO,
+	ZEND_AST_THROW,
+	ZEND_AST_GOTO,
+	ZEND_AST_BREAK,
+	ZEND_AST_CONTINUE,
+
+	/* 2 child nodes */
+	ZEND_AST_DIM = 2 << ZEND_AST_NUM_CHILDREN_SHIFT,
+	ZEND_AST_PROP,
+	ZEND_AST_STATIC_PROP,
+	ZEND_AST_CALL,
+	ZEND_AST_CLASS_CONST,
+	ZEND_AST_ASSIGN,
+	ZEND_AST_ASSIGN_REF,
+	ZEND_AST_ASSIGN_OP,
+	ZEND_AST_BINARY_OP,
+	ZEND_AST_GREATER,
+	ZEND_AST_GREATER_EQUAL,
+	ZEND_AST_AND,
+	ZEND_AST_OR,
+	ZEND_AST_ARRAY_ELEM,
+	ZEND_AST_NEW,
+	ZEND_AST_INSTANCEOF,
+	ZEND_AST_YIELD,
+
+	ZEND_AST_STATIC,
+	ZEND_AST_WHILE,
+	ZEND_AST_DO_WHILE,
+	ZEND_AST_IF_ELEM,
+	ZEND_AST_SWITCH,
+	ZEND_AST_SWITCH_CASE,
+	ZEND_AST_DECLARE,
+	ZEND_AST_PROP_ELEM,
+	ZEND_AST_CONST_ELEM,
+	ZEND_AST_USE_TRAIT,
+	ZEND_AST_TRAIT_PRECEDENCE,
+	ZEND_AST_METHOD_REFERENCE,
+	ZEND_AST_NAMESPACE,
+	ZEND_AST_USE_ELEM,
+	ZEND_AST_TRAIT_ALIAS,
+
+	/* 3 child nodes */
+	ZEND_AST_METHOD_CALL = 3 << ZEND_AST_NUM_CHILDREN_SHIFT,
+	ZEND_AST_STATIC_CALL,
+	ZEND_AST_CONDITIONAL,
+
+	ZEND_AST_TRY,
+	ZEND_AST_CATCH,
+	ZEND_AST_PARAM,
+
+	/* 4 child nodes */
+	ZEND_AST_FOR = 4 << ZEND_AST_NUM_CHILDREN_SHIFT,
+	ZEND_AST_FOREACH,
+};
+
+typedef uint16_t zend_ast_kind;
+typedef uint16_t zend_ast_attr;
 
 struct _zend_ast {
-	unsigned short kind;
-	unsigned short children;
-	union {
-		zval      val;
-		zend_ast *child;
-	} u;
+	zend_ast_kind kind; /* Type of the node (ZEND_AST_* enum constant) */
+	zend_ast_attr attr; /* Additional attribute, use depending on node type */
+	uint32_t lineno;    /* Line number */
+	zend_ast *child[1]; /* Array of children (using struct hack) */
 };
 
-ZEND_API zend_ast *zend_ast_create_constant(zval *zv);
+/* Same as zend_ast, but with children count, which is updated dynamically */
+typedef struct _zend_ast_list {
+	zend_ast_kind kind;
+	zend_ast_attr attr;
+	uint32_t lineno;
+	uint32_t children;
+	zend_ast *child[1];
+} zend_ast_list;
+
+/* Lineno is stored in val.u2.lineno */
+typedef struct _zend_ast_zval {
+	zend_ast_kind kind;
+	zend_ast_attr attr;
+	zval val;
+} zend_ast_zval;
+
+/* Separate structure for function and class declaration, as they need extra information. */
+typedef struct _zend_ast_decl {
+	zend_ast_kind kind;
+	zend_ast_attr attr; /* Unused - for structure compatibility */
+	uint32_t start_lineno;
+	uint32_t end_lineno;
+	uint32_t flags;
+	unsigned char *lex_pos;
+	zend_string *doc_comment;
+	zend_string *name;
+	zend_ast *child[3];
+} zend_ast_decl;
 
-ZEND_API zend_ast *zend_ast_create_unary(uint kind, zend_ast *op0);
-ZEND_API zend_ast *zend_ast_create_binary(uint kind, zend_ast *op0, zend_ast *op1);
-ZEND_API zend_ast *zend_ast_create_ternary(uint kind, zend_ast *op0, zend_ast *op1, zend_ast *op2);
-ZEND_API zend_ast* zend_ast_create_dynamic(uint kind);
-ZEND_API void zend_ast_dynamic_add(zend_ast **ast, zend_ast *op);
-ZEND_API void zend_ast_dynamic_shrink(zend_ast **ast);
+ZEND_API zend_ast *zend_ast_create_zval_ex(zval *zv, zend_ast_attr attr);
 
-ZEND_API int zend_ast_is_ct_constant(zend_ast *ast);
+ZEND_API zend_ast *zend_ast_create_ex(zend_ast_kind kind, zend_ast_attr attr, ...);
+ZEND_API zend_ast *zend_ast_create(zend_ast_kind kind, ...);
+
+ZEND_API zend_ast *zend_ast_create_decl(
+	zend_ast_kind kind, uint32_t flags, uint32_t start_lineno, zend_string *doc_comment,
+	zend_string *name, zend_ast *child0, zend_ast *child1, zend_ast *child2
+);
+
+ZEND_API zend_ast_list *zend_ast_create_list(uint32_t init_children, zend_ast_kind kind, ...);
+ZEND_API zend_ast_list *zend_ast_list_add(zend_ast_list *list, zend_ast *op);
 
 ZEND_API void zend_ast_evaluate(zval *result, zend_ast *ast, zend_class_entry *scope TSRMLS_DC);
 
 ZEND_API zend_ast *zend_ast_copy(zend_ast *ast);
 ZEND_API void zend_ast_destroy(zend_ast *ast);
+ZEND_API void zend_ast_destroy_and_free(zend_ast *ast);
+
+typedef void (*zend_ast_apply_func)(zend_ast **ast_ptr TSRMLS_DC);
+ZEND_API void zend_ast_apply(zend_ast *ast, zend_ast_apply_func fn TSRMLS_DC);
+
+static inline zend_bool zend_ast_is_list(zend_ast *ast) {
+	return (ast->kind >> ZEND_AST_IS_LIST_SHIFT) & 1;
+}
+static inline zend_ast_list *zend_ast_get_list(zend_ast *ast) {
+	ZEND_ASSERT(zend_ast_is_list(ast));
+	return (zend_ast_list *) ast;
+}
+
+static inline zval *zend_ast_get_zval(zend_ast *ast) {
+	ZEND_ASSERT(ast->kind == ZEND_AST_ZVAL);
+	return &((zend_ast_zval *) ast)->val;
+}
+static inline zend_string *zend_ast_get_str(zend_ast *ast) {
+	return Z_STR_P(zend_ast_get_zval(ast));
+}
+
+static inline uint32_t zend_ast_get_num_children(zend_ast *ast) {
+	ZEND_ASSERT(!zend_ast_is_list(ast));
+	return ast->kind >> ZEND_AST_NUM_CHILDREN_SHIFT;
+}
+static inline uint32_t zend_ast_get_lineno(zend_ast *ast) {
+	if (ast->kind == ZEND_AST_ZVAL) {
+		zval *zv = zend_ast_get_zval(ast);
+		return zv->u2.lineno;
+	} else {
+		return ast->lineno;
+	}
+}
+
+static inline zend_ast *zend_ast_create_zval(zval *zv) {
+	return zend_ast_create_zval_ex(zv, 0);
+}
+static inline zend_ast *zend_ast_create_zval_from_str(zend_string *str) {
+	zval zv;
+	ZVAL_STR(&zv, str);
+	return zend_ast_create_zval(&zv);
+}
+static inline zend_ast *zend_ast_create_zval_from_long(zend_long lval) {
+	zval zv;
+	ZVAL_LONG(&zv, lval);
+	return zend_ast_create_zval(&zv);
+}
+
+static inline zend_ast *zend_ast_create_binary_op(uint32_t opcode, zend_ast *op0, zend_ast *op1) {
+	return zend_ast_create_ex(ZEND_AST_BINARY_OP, opcode, op0, op1);
+}
+static inline zend_ast *zend_ast_create_assign_op(uint32_t opcode, zend_ast *op0, zend_ast *op1) {
+	return zend_ast_create_ex(ZEND_AST_ASSIGN_OP, opcode, op0, op1);
+}
+static inline zend_ast *zend_ast_create_cast(uint32_t type, zend_ast *op0) {
+	return zend_ast_create_ex(ZEND_AST_CAST, type, op0);
+}
 
 #endif
diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
index a37ca45265..4a4afa2de6 100644
--- a/Zend/zend_compile.c
+++ b/Zend/zend_compile.c
@@ -14,6 +14,7 @@
    +----------------------------------------------------------------------+
    | Authors: Andi Gutmans <andi@zend.com>                                |
    |          Zeev Suraski <zeev@zend.com>                                |
+   |          Nikita Popov <nikic@php.net>                                |
    +----------------------------------------------------------------------+
 */
 
@@ -51,7 +52,6 @@
 			(target)->u.constant = CONSTANT(src.constant); \
 		} else { \
 			(target)->u.op = src; \
-			(target)->EA = 0; \
 		} \
 	} while (0)
 
@@ -60,34 +60,29 @@
 		target = src; \
 	} while (0)
 
-#define GET_CACHE_SLOT(literal) do { \
-		Z_CACHE_SLOT(CG(active_op_array)->literals[literal]) = CG(active_op_array)->last_cache_slot++; \
-		if ((CG(active_op_array)->fn_flags & ZEND_ACC_INTERACTIVE) && CG(active_op_array)->run_time_cache) { \
-			CG(active_op_array)->run_time_cache = erealloc(CG(active_op_array)->run_time_cache, CG(active_op_array)->last_cache_slot * sizeof(void*)); \
-			CG(active_op_array)->run_time_cache[CG(active_op_array)->last_cache_slot - 1] = NULL; \
-		} \
-	} while (0)
+static inline void zend_alloc_cache_slot(uint32_t literal TSRMLS_DC) {
+	zend_op_array *op_array = CG(active_op_array);
+	Z_CACHE_SLOT(op_array->literals[literal]) = op_array->last_cache_slot++;
+	if ((op_array->fn_flags & ZEND_ACC_INTERACTIVE) && op_array->run_time_cache) {
+		op_array->run_time_cache = erealloc(op_array->run_time_cache,
+			op_array->last_cache_slot * sizeof(void*));
+		op_array->run_time_cache[CG(active_op_array)->last_cache_slot - 1] = NULL;
+	}
+}
 
 #define POLYMORPHIC_CACHE_SLOT_SIZE 2
 
-#define GET_POLYMORPHIC_CACHE_SLOT(literal) do { \
-		Z_CACHE_SLOT(CG(active_op_array)->literals[literal]) = CG(active_op_array)->last_cache_slot; \
-		CG(active_op_array)->last_cache_slot += POLYMORPHIC_CACHE_SLOT_SIZE; \
-		if ((CG(active_op_array)->fn_flags & ZEND_ACC_INTERACTIVE) && CG(active_op_array)->run_time_cache) { \
-			CG(active_op_array)->run_time_cache = erealloc(CG(active_op_array)->run_time_cache, CG(active_op_array)->last_cache_slot * sizeof(void*)); \
-			CG(active_op_array)->run_time_cache[CG(active_op_array)->last_cache_slot - 1] = NULL; \
-			CG(active_op_array)->run_time_cache[CG(active_op_array)->last_cache_slot - 2] = NULL; \
-		} \
-	} while (0)
-
-#define FREE_POLYMORPHIC_CACHE_SLOT(literal) do { \
-		if (Z_CACHE_SLOT(CG(active_op_array)->literals[literal]) != -1 && \
-		    Z_CACHE_SLOT(CG(active_op_array)->literals[literal]) == \
-		    CG(active_op_array)->last_cache_slot - POLYMORPHIC_CACHE_SLOT_SIZE) { \
-			Z_CACHE_SLOT(CG(active_op_array)->literals[literal]) = -1; \
-			CG(active_op_array)->last_cache_slot -= POLYMORPHIC_CACHE_SLOT_SIZE; \
-		} \
-	} while (0)
+static inline void zend_alloc_polymorphic_cache_slot(uint32_t literal TSRMLS_DC) {
+	zend_op_array *op_array = CG(active_op_array);
+	Z_CACHE_SLOT(op_array->literals[literal]) = op_array->last_cache_slot;
+	op_array->last_cache_slot += POLYMORPHIC_CACHE_SLOT_SIZE;
+	if ((op_array->fn_flags & ZEND_ACC_INTERACTIVE) && op_array->run_time_cache) {
+		op_array->run_time_cache = erealloc(
+			op_array->run_time_cache, op_array->last_cache_slot * sizeof(void *));
+		op_array->run_time_cache[op_array->last_cache_slot - 1] = NULL;
+		op_array->run_time_cache[op_array->last_cache_slot - 2] = NULL;
+	}
+}
 
 ZEND_API zend_op_array *(*zend_compile_file)(zend_file_handle *file_handle, int type TSRMLS_DC);
 ZEND_API zend_op_array *(*zend_compile_string)(zval *source_string, char *filename TSRMLS_DC);
@@ -97,13 +92,6 @@ ZEND_API zend_compiler_globals compiler_globals;
 ZEND_API zend_executor_globals executor_globals;
 #endif
 
-static void zend_push_function_call_entry(zend_function *fbc, uint32_t opline_num TSRMLS_DC) /* {{{ */
-{
-	zend_function_call_entry fcall = { fbc, opline_num };
-	zend_stack_push(&CG(function_call_stack), &fcall);
-}
-/* }}} */
-
 static zend_property_info *zend_duplicate_property_info(zend_property_info *property_info TSRMLS_DC) /* {{{ */
 {
 	zend_property_info* new_property_info;
@@ -147,13 +135,27 @@ static void zend_destroy_property_info_internal(zval *zv) /* {{{ */
 }
 /* }}} */
 
-static void build_runtime_defined_function_key(zval *result, const char *name, int name_length TSRMLS_DC) /* {{{ */
-{
+static zend_string *zend_new_interned_string_safe(zend_string *str TSRMLS_DC) {
+	zend_string *interned_str;
+
+	zend_string_addref(str);
+	interned_str = zend_new_interned_string(str TSRMLS_CC);
+	if (str != interned_str) {
+		return interned_str;
+	} else {
+		zend_string_release(str);
+		return str;
+	}
+}
+
+static zend_string *zend_build_runtime_definition_key(
+	zend_string *name, unsigned char *lex_pos TSRMLS_DC
+) {
+	zend_string *result;
 	char char_pos_buf[32];
-	uint char_pos_len;
-	const char *filename;
+	size_t char_pos_len = zend_sprintf(char_pos_buf, "%p", lex_pos);
 
-	char_pos_len = zend_sprintf(char_pos_buf, "%p", LANG_SCNG(yy_text));
+	const char *filename;
 	if (CG(active_op_array)->filename) {
 		filename = CG(active_op_array)->filename->val;
 	} else {
@@ -161,13 +163,12 @@ static void build_runtime_defined_function_key(zval *result, const char *name, i
 	}
 
 	/* NULL, name length, filename length, last accepting char position length */
-	ZVAL_NEW_STR(result, zend_string_alloc(1+name_length+strlen(filename)+char_pos_len, 0));
+	result = zend_string_alloc(1 + name->len + strlen(filename) + char_pos_len, 0);
 
- 	/* must be binary safe */
- 	Z_STRVAL_P(result)[0] = '\0';
- 	sprintf(Z_STRVAL_P(result)+1, "%s%s%s", name, filename, char_pos_buf);
+ 	result->val[0] = '\0';
+ 	sprintf(result->val + 1, "%s%s%s", name->val, filename, char_pos_buf);
+	return result;
 }
-/* }}} */
 
 static void init_compiler_declarables(TSRMLS_D) /* {{{ */
 {
@@ -189,19 +190,13 @@ void zend_init_compiler_context(TSRMLS_D) /* {{{ */
 
 void zend_init_compiler_data_structures(TSRMLS_D) /* {{{ */
 {
-	zend_stack_init(&CG(bp_stack), sizeof(zend_llist));
-	zend_stack_init(&CG(function_call_stack), sizeof(zend_function_call_entry));
 	zend_stack_init(&CG(switch_cond_stack), sizeof(zend_switch_entry));
 	zend_stack_init(&CG(foreach_copy_stack), sizeof(zend_op));
-	zend_stack_init(&CG(object_stack), sizeof(znode));
-	zend_stack_init(&CG(declare_stack), sizeof(zend_declarables));
+	zend_stack_init(&CG(delayed_oplines_stack), sizeof(zend_op));
 	CG(active_class_entry) = NULL;
-	zend_llist_init(&CG(list_llist), sizeof(list_llist_element), NULL, 0);
-	zend_llist_init(&CG(dimension_llist), sizeof(int), NULL, 0);
-	zend_stack_init(&CG(list_stack), sizeof(zend_llist));
 	CG(in_compilation) = 0;
 	CG(start_lineno) = 0;
-	ZVAL_UNDEF(&CG(current_namespace));
+	CG(current_namespace) = NULL;
 	CG(in_namespace) = 0;
 	CG(has_bracketed_namespaces) = 0;
 	CG(current_import) = NULL;
@@ -238,13 +233,9 @@ void init_compiler(TSRMLS_D) /* {{{ */
 
 void shutdown_compiler(TSRMLS_D) /* {{{ */
 {
-	zend_stack_destroy(&CG(bp_stack));
-	zend_stack_destroy(&CG(function_call_stack));
 	zend_stack_destroy(&CG(switch_cond_stack));
 	zend_stack_destroy(&CG(foreach_copy_stack));
-	zend_stack_destroy(&CG(object_stack));
-	zend_stack_destroy(&CG(declare_stack));
-	zend_stack_destroy(&CG(list_stack));
+	zend_stack_destroy(&CG(delayed_oplines_stack));
 	zend_hash_destroy(&CG(filenames_table));
 	zend_hash_destroy(&CG(const_filenames));
 	zend_stack_destroy(&CG(context_stack));
@@ -429,32 +420,23 @@ static int zend_add_ns_func_name_literal(zend_op_array *op_array, zval *zv TSRML
 }
 /* }}} */
 
-static int zend_add_class_name_literal(zend_op_array *op_array, zval *zv TSRMLS_DC) /* {{{ */
-{
+static int zend_add_class_name_literal(zend_op_array *op_array, zend_string *name TSRMLS_DC) {
 	int ret;
 	zend_string *lc_name;
-	zval c;
 
-	if (op_array->last_literal > 0 &&
-	    &op_array->literals[op_array->last_literal - 1] == zv &&
-	    Z_CACHE_SLOT(op_array->literals[op_array->last_literal - 1]) == -1) {
-		/* we already have function name as last literal (do nothing) */
-		ret = op_array->last_literal - 1;
-	} else {
-		ret = zend_add_literal(op_array, zv TSRMLS_CC);
-	}
+	zval zv;
+	ZVAL_STR(&zv, name);
 
-	if (Z_STRVAL_P(zv)[0] == '\\') {
-		lc_name = zend_string_alloc(Z_STRLEN_P(zv) - 1, 0);
-		zend_str_tolower_copy(lc_name->val, Z_STRVAL_P(zv) + 1, Z_STRLEN_P(zv) - 1);
-	} else {
-		lc_name = zend_string_alloc(Z_STRLEN_P(zv), 0);
-		zend_str_tolower_copy(lc_name->val, Z_STRVAL_P(zv), Z_STRLEN_P(zv));
-	}
-	ZVAL_NEW_STR(&c, lc_name);
-	zend_add_literal(CG(active_op_array), &c TSRMLS_CC);
+	ret = zend_add_literal(op_array, &zv TSRMLS_CC);
+	name = Z_STR(zv); /* Load new name string in case it was interned */
+
+	lc_name = zend_string_alloc(name->len, 0);
+	zend_str_tolower_copy(lc_name->val, name->val, name->len);
 
-	GET_CACHE_SLOT(ret);
+	ZVAL_NEW_STR(&zv, lc_name);
+	zend_add_literal(CG(active_op_array), &zv TSRMLS_CC);
+
+	zend_alloc_cache_slot(ret TSRMLS_CC);
 
 	return ret;
 }
@@ -537,511 +519,19 @@ static int zend_add_const_name_literal(zend_op_array *op_array, zval *zv, int un
 		op.constant = zend_add_literal(CG(active_op_array), &_c TSRMLS_CC); \
 	} while (0)
 
-#define LITERAL_STRINGL(op, str, len) do { \
-		zval _c; \
-		ZVAL_STRINGL(&_c, str, len); \
-		op.constant = zend_add_literal(CG(active_op_array), &_c TSRMLS_CC); \
-	} while (0)
-
-#define LITERAL_LONG(op, val) do { \
-		zval _c; \
-		ZVAL_LONG(&_c, val); \
-		op.constant = zend_add_literal(CG(active_op_array), &_c TSRMLS_CC); \
-	} while (0)
-
-#define LITERAL_LONG_EX(op_array, op, val) do { \
-		zval _c; \
-		ZVAL_LONG(&_c, val); \
-		op.constant = zend_add_literal(op_array, &_c TSRMLS_CC); \
-	} while (0)
-
-#define LITERAL_NULL(op) do { \
-		zval _c; \
-		ZVAL_NULL(&_c); \
-		op.constant = zend_add_literal(CG(active_op_array), &_c TSRMLS_CC); \
-	} while (0)
-
-static inline zend_bool zend_is_function_or_method_call(const znode *variable) /* {{{ */
-{
-	uint32_t type = variable->EA;
-
-	return  ((type & ZEND_PARSED_METHOD_CALL) || (type == ZEND_PARSED_FUNCTION_CALL));
-}
-/* }}} */
-
-void zend_do_binary_op(zend_uchar op, znode *result, znode *op1, znode *op2 TSRMLS_DC) /* {{{ */
-{
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-
-	opline->opcode = op;
-	opline->result_type = IS_TMP_VAR;
-	opline->result.var = get_temporary_variable(CG(active_op_array));
-	SET_NODE(opline->op1, op1);
-	SET_NODE(opline->op2, op2);
-	GET_NODE(result, opline->result);
-}
-/* }}} */
-
-void zend_do_unary_op(zend_uchar op, znode *result, znode *op1 TSRMLS_DC) /* {{{ */
-{
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-
-	opline->opcode = op;
-	opline->result_type = IS_TMP_VAR;
-	opline->result.var = get_temporary_variable(CG(active_op_array));
-	SET_NODE(opline->op1, op1);
-	GET_NODE(result, opline->result);
-	SET_UNUSED(opline->op2);
-}
-/* }}} */
-
-#define MAKE_NOP(opline)	{ opline->opcode = ZEND_NOP;  memset(&opline->result,0,sizeof(opline->result)); memset(&opline->op1,0,sizeof(opline->op1)); memset(&opline->op2,0,sizeof(opline->op2)); opline->result_type=opline->op1_type=opline->op2_type=IS_UNUSED;  }
-
-static void zend_do_op_data(zend_op *data_op, znode *value TSRMLS_DC) /* {{{ */
-{
-	data_op->opcode = ZEND_OP_DATA;
-	SET_NODE(data_op->op1, value);
-	SET_UNUSED(data_op->op2);
-}
-/* }}} */
-
-void zend_do_binary_assign_op(zend_uchar op, znode *result, znode *op1, znode *op2 TSRMLS_DC) /* {{{ */
-{
-	int last_op_number = get_next_op_number(CG(active_op_array));
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-
-	if (last_op_number > 0) {
-		zend_op *last_op = &CG(active_op_array)->opcodes[last_op_number-1];
-
-		switch (last_op->opcode) {
-			case ZEND_FETCH_OBJ_RW:
-				last_op->opcode = op;
-				last_op->extended_value = ZEND_ASSIGN_OBJ;
-
-				zend_do_op_data(opline, op2 TSRMLS_CC);
-				SET_UNUSED(opline->result);
-				GET_NODE(result, last_op->result);
-				return;
-			case ZEND_FETCH_DIM_RW:
-				last_op->opcode = op;
-				last_op->extended_value = ZEND_ASSIGN_DIM;
-
-				zend_do_op_data(opline, op2 TSRMLS_CC);
-				opline->op2.var = get_temporary_variable(CG(active_op_array));
-				opline->op2_type = IS_VAR;
-				SET_UNUSED(opline->result);
-				GET_NODE(result,last_op->result);
-				return;
-			default:
-				break;
-		}
-	}
-
-	opline->opcode = op;
-	SET_NODE(opline->op1, op1);
-	SET_NODE(opline->op2, op2);
-	opline->result_type = IS_VAR;
-	opline->result.var = get_temporary_variable(CG(active_op_array));
-	GET_NODE(result, opline->result);
-}
-/* }}} */
-
-void fetch_simple_variable_ex(znode *result, znode *varname, int bp, zend_uchar op TSRMLS_DC) /* {{{ */
-{
-	zend_op opline;
-	zend_op *opline_ptr;
-
-	if (varname->op_type == IS_CONST) {
-		if (Z_TYPE(varname->u.constant) != IS_STRING) {
-			convert_to_string(&varname->u.constant);
-		}
-
-		if (!zend_is_auto_global(Z_STR(varname->u.constant) TSRMLS_CC) &&
-		    !(Z_STRLEN(varname->u.constant) == (sizeof("this")-1) &&
-		      !memcmp(Z_STRVAL(varname->u.constant), "this", sizeof("this") - 1)) &&
-		    (CG(active_op_array)->last == 0 ||
-		     CG(active_op_array)->opcodes[CG(active_op_array)->last-1].opcode != ZEND_BEGIN_SILENCE)) {
-			result->op_type = IS_CV;
-			result->u.op.var = lookup_cv(CG(active_op_array), Z_STR(varname->u.constant) TSRMLS_CC);
-			Z_STR(varname->u.constant) = CG(active_op_array)->vars[EX_VAR_TO_NUM(result->u.op.var)];
-			result->EA = 0;
-			return;
-		}
-	}
-
-	if (bp) {
-		opline_ptr = &opline;
-		init_op(opline_ptr TSRMLS_CC);
-	} else {
-		opline_ptr = get_next_op(CG(active_op_array) TSRMLS_CC);
-	}
-
-	opline_ptr->opcode = op;
-	opline_ptr->result_type = IS_VAR;
-	opline_ptr->result.var = get_temporary_variable(CG(active_op_array));
-	SET_NODE(opline_ptr->op1, varname);
-	GET_NODE(result, opline_ptr->result);
-	SET_UNUSED(opline_ptr->op2);
-	opline_ptr->extended_value = ZEND_FETCH_LOCAL;
-
-	if (varname->op_type == IS_CONST) {
-		if (zend_is_auto_global(Z_STR(varname->u.constant) TSRMLS_CC)) {
-			opline_ptr->extended_value = ZEND_FETCH_GLOBAL;
-		}
-	}
+#define MAKE_NOP(opline) do { \
+	opline->opcode = ZEND_NOP; \
+	memset(&opline->result, 0, sizeof(opline->result)); \
+	memset(&opline->op1, 0, sizeof(opline->op1)); \
+	memset(&opline->op2, 0, sizeof(opline->op2)); \
+	opline->result_type = opline->op1_type = opline->op2_type = IS_UNUSED; \
+} while (0)
 
-	if (bp) {
-		zend_llist *fetch_list_ptr = zend_stack_top(&CG(bp_stack));
-		zend_llist_add_element(fetch_list_ptr, opline_ptr);
-	}
-}
-/* }}} */
-
-void fetch_simple_variable(znode *result, znode *varname, int bp TSRMLS_DC) /* {{{ */
-{
-	/* the default mode must be Write, since fetch_simple_variable() is used to define function arguments */
-	fetch_simple_variable_ex(result, varname, bp, ZEND_FETCH_W TSRMLS_CC);
-}
-/* }}} */
-
-void zend_do_fetch_static_member(znode *result, znode *class_name TSRMLS_DC) /* {{{ */
-{
-	znode class_node;
-	zend_llist *fetch_list_ptr;
-	zend_llist_element *le;
-	zend_op *opline_ptr;
-	zend_op opline;
-
-	if (class_name->op_type == IS_CONST &&
-	    ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant))) {
-		zend_resolve_class_name(class_name TSRMLS_CC);
-		class_node = *class_name;
-	} else {
-		zend_do_fetch_class(&class_node, class_name TSRMLS_CC);
-	}
-	fetch_list_ptr = zend_stack_top(&CG(bp_stack));
-	if (result->op_type == IS_CV) {
-		init_op(&opline TSRMLS_CC);
-
-		opline.opcode = ZEND_FETCH_W;
-		opline.result_type = IS_VAR;
-		opline.result.var = get_temporary_variable(CG(active_op_array));
-		opline.op1_type = IS_CONST;
-		LITERAL_STR(opline.op1, zend_string_copy(CG(active_op_array)->vars[EX_VAR_TO_NUM(result->u.op.var)]));
-		GET_POLYMORPHIC_CACHE_SLOT(opline.op1.constant);
-		if (class_node.op_type == IS_CONST) {
-			opline.op2_type = IS_CONST;
-			opline.op2.constant =
-				zend_add_class_name_literal(CG(active_op_array), &class_node.u.constant TSRMLS_CC);
-		} else {
-			SET_NODE(opline.op2, &class_node);
-		}
-		GET_NODE(result,opline.result);
-		opline.extended_value |= ZEND_FETCH_STATIC_MEMBER;
-		opline_ptr = &opline;
-
-		zend_llist_add_element(fetch_list_ptr, &opline);
-	} else {
-		le = fetch_list_ptr->head;
-
-		opline_ptr = (zend_op *)le->data;
-		if (opline_ptr->opcode != ZEND_FETCH_W && opline_ptr->op1_type == IS_CV) {
-			init_op(&opline TSRMLS_CC);
-			opline.opcode = ZEND_FETCH_W;
-			opline.result_type = IS_VAR;
-			opline.result.var = get_temporary_variable(CG(active_op_array));
-			opline.op1_type = IS_CONST;
-			LITERAL_STR(opline.op1, zend_string_copy(CG(active_op_array)->vars[EX_VAR_TO_NUM(opline_ptr->op1.var)]));
-			GET_POLYMORPHIC_CACHE_SLOT(opline.op1.constant);
-			if (class_node.op_type == IS_CONST) {
-				opline.op2_type = IS_CONST;
-				opline.op2.constant =
-					zend_add_class_name_literal(CG(active_op_array), &class_node.u.constant TSRMLS_CC);
-			} else {
-				SET_NODE(opline.op2, &class_node);
-			}
-			opline.extended_value |= ZEND_FETCH_STATIC_MEMBER;
-			COPY_NODE(opline_ptr->op1, opline.result);
-
-			zend_llist_prepend_element(fetch_list_ptr, &opline);
-		} else {
-			if (opline_ptr->op1_type == IS_CONST) {
-				GET_POLYMORPHIC_CACHE_SLOT(opline_ptr->op1.constant);
-			}
-			if (class_node.op_type == IS_CONST) {
-				opline_ptr->op2_type = IS_CONST;
-				opline_ptr->op2.constant =
-					zend_add_class_name_literal(CG(active_op_array), &class_node.u.constant TSRMLS_CC);
-			} else {
-				SET_NODE(opline_ptr->op2, &class_node);
-			}
-			opline_ptr->extended_value |= ZEND_FETCH_STATIC_MEMBER;
-		}
-	}
-}
-/* }}} */
-
-void fetch_array_begin(znode *result, znode *varname, znode *first_dim TSRMLS_DC) /* {{{ */
-{
-	fetch_simple_variable(result, varname, 1 TSRMLS_CC);
-
-	fetch_array_dim(result, result, first_dim TSRMLS_CC);
-}
-/* }}} */
-
-void fetch_array_dim(znode *result, znode *parent, znode *dim TSRMLS_DC) /* {{{ */
-{
-	zend_op opline;
-	zend_llist *fetch_list_ptr = zend_stack_top(&CG(bp_stack));
-
-	if (zend_is_function_or_method_call(parent)) {
-		init_op(&opline TSRMLS_CC);
-		opline.opcode = ZEND_SEPARATE;
-		SET_NODE(opline.op1, parent);
-		SET_UNUSED(opline.op2);
-		opline.result_type = IS_VAR;
-		opline.result.var = opline.op1.var;
-		zend_llist_add_element(fetch_list_ptr, &opline);
-	}
-
-	init_op(&opline TSRMLS_CC);
-	opline.opcode = ZEND_FETCH_DIM_W;	/* the backpatching routine assumes W */
-	opline.result_type = IS_VAR;
-	opline.result.var = get_temporary_variable(CG(active_op_array));
-	SET_NODE(opline.op1, parent);
-	SET_NODE(opline.op2, dim);
-	if (opline.op2_type == IS_CONST && Z_TYPE(CONSTANT(opline.op2.constant)) == IS_STRING) {
-		zend_ulong index;
-
-		if (ZEND_HANDLE_NUMERIC(Z_STR(CONSTANT(opline.op2.constant)), index)) {
-			zval_dtor(&CONSTANT(opline.op2.constant));
-			ZVAL_LONG(&CONSTANT(opline.op2.constant), index);
-		}
-	}
-
-	GET_NODE(result, opline.result);
-
-	zend_llist_add_element(fetch_list_ptr, &opline);
-}
-/* }}} */
-
-void fetch_string_offset(znode *result, znode *parent, znode *offset TSRMLS_DC) /* {{{ */
-{
-	fetch_array_dim(result, parent, offset TSRMLS_CC);
-}
-/* }}} */
-
-void zend_do_print(znode *result, znode *arg TSRMLS_DC) /* {{{ */
-{
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-
-	opline->result_type = IS_TMP_VAR;
-	opline->result.var = get_temporary_variable(CG(active_op_array));
-	opline->opcode = ZEND_PRINT;
-	SET_NODE(opline->op1, arg);
-	SET_UNUSED(opline->op2);
-	GET_NODE(result, opline->result);
-}
-/* }}} */
-
-void zend_do_echo(znode *arg TSRMLS_DC) /* {{{ */
-{
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-
-	opline->opcode = ZEND_ECHO;
-	SET_NODE(opline->op1, arg);
-	SET_UNUSED(opline->op2);
-}
-/* }}} */
-
-void zend_do_abstract_method(const znode *function_name, znode *modifiers, const znode *body TSRMLS_DC) /* {{{ */
-{
-	char *method_type;
-
-	if (CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE) {
-		Z_LVAL(modifiers->u.constant) |= ZEND_ACC_ABSTRACT;
-		method_type = "Interface";
-	} else {
-		method_type = "Abstract";
-	}
-
-	if (Z_LVAL(modifiers->u.constant) & ZEND_ACC_ABSTRACT) {
-		if(Z_LVAL(modifiers->u.constant) & ZEND_ACC_PRIVATE) {
-			zend_error_noreturn(E_COMPILE_ERROR, "%s function %s::%s() cannot be declared private", method_type, CG(active_class_entry)->name->val, Z_STRVAL(function_name->u.constant));
-		}
-		if (Z_LVAL(body->u.constant) == ZEND_ACC_ABSTRACT) {
-			zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-
-			opline->opcode = ZEND_RAISE_ABSTRACT_ERROR;
-			SET_UNUSED(opline->op1);
-			SET_UNUSED(opline->op2);
-		} else {
-			/* we had code in the function body */
-			zend_error_noreturn(E_COMPILE_ERROR, "%s function %s::%s() cannot contain body", method_type, CG(active_class_entry)->name->val, Z_STRVAL(function_name->u.constant));
-		}
-	} else {
-		if (Z_LVAL(body->u.constant) == ZEND_ACC_ABSTRACT) {
-			zend_error_noreturn(E_COMPILE_ERROR, "Non-abstract method %s::%s() must contain body", CG(active_class_entry)->name->val, Z_STRVAL(function_name->u.constant));
-		}
-	}
-}
-/* }}} */
-
-static zend_bool opline_is_fetch_this(const zend_op *opline TSRMLS_DC) /* {{{ */
-{
-	if ((opline->opcode == ZEND_FETCH_W) && (opline->op1_type == IS_CONST)
-		&& (Z_TYPE(CONSTANT(opline->op1.constant)) == IS_STRING)
-		&& ((opline->extended_value & ZEND_FETCH_STATIC_MEMBER) != ZEND_FETCH_STATIC_MEMBER)
-		&& (Z_STRHASH(CONSTANT(opline->op1.constant)) == THIS_HASHVAL)
-		&& (Z_STRLEN(CONSTANT(opline->op1.constant)) == (sizeof("this")-1))
-		&& !memcmp(Z_STRVAL(CONSTANT(opline->op1.constant)), "this", sizeof("this") - 1)) {
-		return 1;
-	} else {
-		return 0;
-	}
-}
-/* }}} */
-
-void zend_do_assign(znode *result, znode *variable, znode *value TSRMLS_DC) /* {{{ */
-{
-	int last_op_number;
-	zend_op *opline;
-
-	if (value->op_type == IS_CV) {
-		zend_llist *fetch_list_ptr = zend_stack_top(&CG(bp_stack));
-		if (fetch_list_ptr && fetch_list_ptr->head) {
-			opline = (zend_op *)fetch_list_ptr->head->data;
-
-			if (opline->opcode == ZEND_FETCH_DIM_W &&
-			    opline->op1_type == IS_CV &&
-			    opline->op1.var == value->u.op.var) {
-
-				opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-				opline->opcode = ZEND_FETCH_R;
-				opline->result_type = IS_VAR;
-				opline->result.var = get_temporary_variable(CG(active_op_array));
-				opline->op1_type = IS_CONST;
-				LITERAL_STR(opline->op1,
-					zend_string_copy(CG(active_op_array)->vars[EX_VAR_TO_NUM(value->u.op.var)]));
-				SET_UNUSED(opline->op2);
-				opline->extended_value = ZEND_FETCH_LOCAL;
-				GET_NODE(value, opline->result);
-			}
-		}
-	}
-
-	zend_do_end_variable_parse(variable, BP_VAR_W, 0 TSRMLS_CC);
-
-	last_op_number = get_next_op_number(CG(active_op_array));
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-
-	if (variable->op_type == IS_CV) {
-		if (variable->u.op.var == CG(active_op_array)->this_var) {
-			zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this");
-		}
-	} else if (variable->op_type == IS_VAR) {
-		int n = 0;
-
-		while (last_op_number - n > 0) {
-			zend_op *last_op;
-
-			last_op = &CG(active_op_array)->opcodes[last_op_number-n-1];
-
-			if (last_op->result_type == IS_VAR &&
-			    last_op->result.var == variable->u.op.var) {
-				if (last_op->opcode == ZEND_FETCH_OBJ_W) {
-					if (n > 0) {
-						int opline_no = (opline-CG(active_op_array)->opcodes)/sizeof(*opline);
-						*opline = *last_op;
-						MAKE_NOP(last_op);
-						/* last_op = opline; */
-						opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-						/* get_next_op can realloc, we need to move last_op */
-						last_op = &CG(active_op_array)->opcodes[opline_no];
-					}
-					last_op->opcode = ZEND_ASSIGN_OBJ;
-					zend_do_op_data(opline, value TSRMLS_CC);
-					SET_UNUSED(opline->result);
-					GET_NODE(result, last_op->result);
-					return;
-				} else if (last_op->opcode == ZEND_FETCH_DIM_W) {
-					if (n > 0) {
-						int opline_no = (opline-CG(active_op_array)->opcodes)/sizeof(*opline);
-						*opline = *last_op;
-						MAKE_NOP(last_op);
-						/* last_op = opline; */
-						/* TBFixed: this can realloc opcodes, leaving last_op pointing wrong */
-						opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-						/* get_next_op can realloc, we need to move last_op */
-						last_op = &CG(active_op_array)->opcodes[opline_no];
-					}
-					last_op->opcode = ZEND_ASSIGN_DIM;
-					zend_do_op_data(opline, value TSRMLS_CC);
-					opline->op2.var = get_temporary_variable(CG(active_op_array));
-					opline->op2_type = IS_VAR;
-					SET_UNUSED(opline->result);
-					GET_NODE(result, last_op->result);
-					return;
-				} else if (opline_is_fetch_this(last_op TSRMLS_CC)) {
-					zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this");
-				} else {
-					break;
-				}
-			}
-			n++;
-		}
-	}
-
-	opline->opcode = ZEND_ASSIGN;
-	SET_NODE(opline->op1, variable);
-	SET_NODE(opline->op2, value);
-	opline->result_type = IS_VAR;
-	opline->result.var = get_temporary_variable(CG(active_op_array));
-	GET_NODE(result, opline->result);
-}
-/* }}} */
-
-void zend_do_assign_ref(znode *result, znode *lvar, znode *rvar TSRMLS_DC) /* {{{ */
-{
-	zend_op *opline;
-
-	if (lvar->op_type == IS_CV) {
-		if (lvar->u.op.var == CG(active_op_array)->this_var) {
- 			zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this");
-		}
-	} else if (lvar->op_type == IS_VAR) {
-		int last_op_number = get_next_op_number(CG(active_op_array));
-
-		if (last_op_number > 0) {
-			opline = &CG(active_op_array)->opcodes[last_op_number-1];
-			if (opline_is_fetch_this(opline TSRMLS_CC)) {
-	 			zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this");
-			}
- 		}
- 	}
-
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	opline->opcode = ZEND_ASSIGN_REF;
-	if (zend_is_function_or_method_call(rvar)) {
-		opline->extended_value = ZEND_RETURNS_FUNCTION;
-	} else if (rvar->EA & ZEND_PARSED_NEW) {
-		opline->extended_value = ZEND_RETURNS_NEW;
-	} else {
-		opline->extended_value = 0;
-	}
-	if (result) {
-		opline->result_type = IS_VAR;
-		opline->result.var = get_temporary_variable(CG(active_op_array));
-		GET_NODE(result, opline->result);
-	} else {
-		opline->result_type = IS_UNUSED | EXT_TYPE_UNUSED;
-	}
-	SET_NODE(opline->op1, lvar);
-	SET_NODE(opline->op2, rvar);
+void zend_stop_lexing(TSRMLS_D) {
+	LANG_SCNG(yy_cursor) = LANG_SCNG(yy_limit);
 }
-/* }}} */
 
-static inline void do_begin_loop(TSRMLS_D) /* {{{ */
+static inline void zend_begin_loop(TSRMLS_D) /* {{{ */
 {
 	zend_brk_cont_element *brk_cont_element;
 	int parent;
@@ -1054,7 +544,7 @@ static inline void do_begin_loop(TSRMLS_D) /* {{{ */
 }
 /* }}} */
 
-static inline void do_end_loop(int cont_addr, int has_loop_var TSRMLS_DC) /* {{{ */
+static inline void zend_end_loop(int cont_addr, int has_loop_var TSRMLS_DC) /* {{{ */
 {
 	if (!has_loop_var) {
 		/* The start fileld is used to free temporary variables in case of exceptions.
@@ -1068,355 +558,6 @@ static inline void do_end_loop(int cont_addr, int has_loop_var TSRMLS_DC) /* {{{
 }
 /* }}} */
 
-void zend_do_while_cond(znode *expr, znode *close_bracket_token TSRMLS_DC) /* {{{ */
-{
-	int while_cond_op_number = get_next_op_number(CG(active_op_array));
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-
-	opline->opcode = ZEND_JMPZ;
-	SET_NODE(opline->op1, expr);
-	close_bracket_token->u.op.opline_num = while_cond_op_number;
-	SET_UNUSED(opline->op2);
-
-	do_begin_loop(TSRMLS_C);
-	INC_BPC(CG(active_op_array));
-}
-/* }}} */
-
-void zend_do_while_end(const znode *while_token, const znode *close_bracket_token TSRMLS_DC) /* {{{ */
-{
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-
-	/* add unconditional jump */
-	opline->opcode = ZEND_JMP;
-	opline->op1.opline_num = while_token->u.op.opline_num;
-	SET_UNUSED(opline->op1);
-	SET_UNUSED(opline->op2);
-
-	/* update while's conditional jmp */
-	CG(active_op_array)->opcodes[close_bracket_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array));
-
-	do_end_loop(while_token->u.op.opline_num, 0 TSRMLS_CC);
-
-	DEC_BPC(CG(active_op_array));
-}
-/* }}} */
-
-void zend_do_for_cond(znode *expr, znode *second_semicolon_token TSRMLS_DC) /* {{{ */
-{
-	int for_cond_op_number = get_next_op_number(CG(active_op_array));
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-
-	opline->opcode = ZEND_JMPZNZ;
-	SET_NODE(opline->op1, expr);  /* the conditional expression */
-	second_semicolon_token->u.op.opline_num = for_cond_op_number;
-	SET_UNUSED(opline->op2);
-}
-/* }}} */
-
-void zend_do_for_before_statement(const znode *cond_start, const znode *second_semicolon_token TSRMLS_DC) /* {{{ */
-{
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-
-	opline->opcode = ZEND_JMP;
-	opline->op1.opline_num = cond_start->u.op.opline_num;
-	CG(active_op_array)->opcodes[second_semicolon_token->u.op.opline_num].extended_value = get_next_op_number(CG(active_op_array));
-	SET_UNUSED(opline->op1);
-	SET_UNUSED(opline->op2);
-
-	do_begin_loop(TSRMLS_C);
-
-	INC_BPC(CG(active_op_array));
-}
-/* }}} */
-
-void zend_do_for_end(const znode *second_semicolon_token TSRMLS_DC) /* {{{ */
-{
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-
-	opline->opcode = ZEND_JMP;
-	opline->op1.opline_num = second_semicolon_token->u.op.opline_num+1;
-	CG(active_op_array)->opcodes[second_semicolon_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array));
-	SET_UNUSED(opline->op1);
-	SET_UNUSED(opline->op2);
-
-	do_end_loop(second_semicolon_token->u.op.opline_num+1, 0 TSRMLS_CC);
-
-	DEC_BPC(CG(active_op_array));
-}
-/* }}} */
-
-void zend_do_pre_incdec(znode *result, znode *op1, zend_uchar op TSRMLS_DC) /* {{{ */
-{
-	int last_op_number = get_next_op_number(CG(active_op_array));
-	zend_op *opline;
-
-	if (last_op_number > 0) {
-		zend_op *last_op = &CG(active_op_array)->opcodes[last_op_number-1];
-
-		if (last_op->opcode == ZEND_FETCH_OBJ_RW) {
-			last_op->opcode = (op==ZEND_PRE_INC)?ZEND_PRE_INC_OBJ:ZEND_PRE_DEC_OBJ;
-			last_op->result_type = IS_VAR;
-			last_op->result.var = get_temporary_variable(CG(active_op_array));
-			GET_NODE(result, last_op->result);
-			return;
-		}
-	}
-
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	opline->opcode = op;
-	SET_NODE(opline->op1, op1);
-	SET_UNUSED(opline->op2);
-	opline->result_type = IS_VAR;
-	opline->result.var = get_temporary_variable(CG(active_op_array));
-	GET_NODE(result, opline->result);
-}
-/* }}} */
-
-void zend_do_post_incdec(znode *result, znode *op1, zend_uchar op TSRMLS_DC) /* {{{ */
-{
-	int last_op_number = get_next_op_number(CG(active_op_array));
-	zend_op *opline;
-
-	if (last_op_number > 0) {
-		zend_op *last_op = &CG(active_op_array)->opcodes[last_op_number-1];
-
-		if (last_op->opcode == ZEND_FETCH_OBJ_RW) {
-			last_op->opcode = (op==ZEND_POST_INC)?ZEND_POST_INC_OBJ:ZEND_POST_DEC_OBJ;
-			last_op->result_type = IS_TMP_VAR;
-			last_op->result.var = get_temporary_variable(CG(active_op_array));
-			GET_NODE(result, last_op->result);
-			return;
-		}
-	}
-
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	opline->opcode = op;
-	SET_NODE(opline->op1, op1);
-	SET_UNUSED(opline->op2);
-	opline->result_type = IS_TMP_VAR;
-	opline->result.var = get_temporary_variable(CG(active_op_array));
-	GET_NODE(result, opline->result);
-}
-/* }}} */
-
-void zend_do_if_cond(znode *cond, znode *closing_bracket_token TSRMLS_DC) /* {{{ */
-{
-	int if_cond_op_number = get_next_op_number(CG(active_op_array));
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-
-	opline->opcode = ZEND_JMPZ;
-	SET_NODE(opline->op1, cond);
-	closing_bracket_token->u.op.opline_num = if_cond_op_number;
-	SET_UNUSED(opline->op2);
-	INC_BPC(CG(active_op_array));
-}
-/* }}} */
-
-void zend_do_if_after_statement(const znode *closing_bracket_token, unsigned char initialize TSRMLS_DC) /* {{{ */
-{
-	int if_end_op_number = get_next_op_number(CG(active_op_array));
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	zend_llist *jmp_list_ptr;
-
-	opline->opcode = ZEND_JMP;
-	/* save for backpatching */
-	if (initialize) {
-		zend_llist jmp_list;
-
-		zend_llist_init(&jmp_list, sizeof(int), NULL, 0);
-		zend_stack_push(&CG(bp_stack), (void *) &jmp_list);
-	}
-	jmp_list_ptr = zend_stack_top(&CG(bp_stack));
-	zend_llist_add_element(jmp_list_ptr, &if_end_op_number);
-
-	CG(active_op_array)->opcodes[closing_bracket_token->u.op.opline_num].op2.opline_num = if_end_op_number+1;
-	SET_UNUSED(opline->op1);
-	SET_UNUSED(opline->op2);
-}
-/* }}} */
-
-void zend_do_if_end(TSRMLS_D) /* {{{ */
-{
-	int next_op_number = get_next_op_number(CG(active_op_array));
-	zend_llist *jmp_list_ptr = zend_stack_top(&CG(bp_stack));
-	zend_llist_element *le;
-
-	for (le=jmp_list_ptr->head; le; le = le->next) {
-		CG(active_op_array)->opcodes[*((int *) le->data)].op1.opline_num = next_op_number;
-	}
-	zend_llist_destroy(jmp_list_ptr);
-	zend_stack_del_top(&CG(bp_stack));
-	DEC_BPC(CG(active_op_array));
-}
-/* }}} */
-
-void zend_check_writable_variable(const znode *variable) /* {{{ */
-{
-	uint32_t type = variable->EA;
-
-	if (type & ZEND_PARSED_METHOD_CALL) {
-		zend_error_noreturn(E_COMPILE_ERROR, "Can't use method return value in write context");
-	}
-	if (type == ZEND_PARSED_FUNCTION_CALL) {
-		zend_error_noreturn(E_COMPILE_ERROR, "Can't use function return value in write context");
-	}
-}
-/* }}} */
-
-void zend_do_begin_variable_parse(TSRMLS_D) /* {{{ */
-{
-	zend_llist fetch_list;
-
-	zend_llist_init(&fetch_list, sizeof(zend_op), NULL, 0);
-	zend_stack_push(&CG(bp_stack), (void *) &fetch_list);
-}
-/* }}} */
-
-void zend_do_end_variable_parse(znode *variable, int type, int arg_offset TSRMLS_DC) /* {{{ */
-{
-	zend_llist *fetch_list_ptr = zend_stack_top(&CG(bp_stack));
-	zend_llist_element *le = fetch_list_ptr->head;
-	zend_op *opline = NULL;
-	zend_op *opline_ptr;
-	uint32_t this_var = -1;
-
-	/* TODO: $foo->x->y->z = 1 should fetch "x" and "y" for R or RW, not just W */
-
-	if (le) {
-		opline_ptr = (zend_op *)le->data;
-		if (opline_is_fetch_this(opline_ptr TSRMLS_CC)) {
-			/* convert to FETCH_?(this) into IS_CV */
-			if (CG(active_op_array)->last == 0 ||
-			    CG(active_op_array)->opcodes[CG(active_op_array)->last-1].opcode != ZEND_BEGIN_SILENCE) {
-
-				this_var = opline_ptr->result.var;
-				if (CG(active_op_array)->this_var == -1) {
-					CG(active_op_array)->this_var = lookup_cv(CG(active_op_array), Z_STR(CONSTANT(opline_ptr->op1.constant)) TSRMLS_CC);
-					ZVAL_UNDEF(&CONSTANT(opline_ptr->op1.constant));
-				} else {
-					zend_del_literal(CG(active_op_array), opline_ptr->op1.constant);
-				}
-				le = le->next;
-				if (variable->op_type == IS_VAR &&
-				    variable->u.op.var == this_var) {
-					variable->op_type = IS_CV;
-					variable->u.op.var = CG(active_op_array)->this_var;
-				}
-			} else if (CG(active_op_array)->this_var == -1) {
-				CG(active_op_array)->this_var = lookup_cv(CG(active_op_array), zend_string_init("this", sizeof("this")-1, 0) TSRMLS_CC);
-			}
-		}
-
-		while (le) {
-			opline_ptr = (zend_op *)le->data;
-			if (opline_ptr->opcode == ZEND_SEPARATE) {
-				if (type != BP_VAR_R && type != BP_VAR_IS) {
-					opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-					memcpy(opline, opline_ptr, sizeof(zend_op));
-				}
-				le = le->next;
-				continue;
-			}
-			opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-			memcpy(opline, opline_ptr, sizeof(zend_op));
-			if (opline->op1_type == IS_VAR &&
-			    opline->op1.var == this_var) {
-				opline->op1_type = IS_CV;
-				opline->op1.var = CG(active_op_array)->this_var;
-			}
-			switch (type) {
-				case BP_VAR_R:
-					if (opline->opcode == ZEND_FETCH_DIM_W && opline->op2_type == IS_UNUSED) {
-						zend_error_noreturn(E_COMPILE_ERROR, "Cannot use [] for reading");
-					}
-					opline->opcode -= 3;
-					break;
-				case BP_VAR_W:
-					break;
-				case BP_VAR_RW:
-					opline->opcode += 3;
-					break;
-				case BP_VAR_IS:
-					if (opline->opcode == ZEND_FETCH_DIM_W && opline->op2_type == IS_UNUSED) {
-						zend_error_noreturn(E_COMPILE_ERROR, "Cannot use [] for reading");
-					}
-					opline->opcode += 6; /* 3+3 */
-					break;
-				case BP_VAR_FUNC_ARG:
-					opline->opcode += 9; /* 3+3+3 */
-					opline->extended_value |= arg_offset;
-					break;
-				case BP_VAR_UNSET:
-					if (opline->opcode == ZEND_FETCH_DIM_W && opline->op2_type == IS_UNUSED) {
-						zend_error_noreturn(E_COMPILE_ERROR, "Cannot use [] for unsetting");
-					}
-					opline->opcode += 12; /* 3+3+3+3 */
-					break;
-			}
-			le = le->next;
-		}
-		if (opline && type == BP_VAR_W && arg_offset) {
-			opline->extended_value |= ZEND_FETCH_MAKE_REF;
-		}
-	}
-	zend_llist_destroy(fetch_list_ptr);
-	zend_stack_del_top(&CG(bp_stack));
-}
-/* }}} */
-
-void zend_do_add_string(znode *result, znode *op1, znode *op2 TSRMLS_DC) /* {{{ */
-{
-	zend_op *opline;
-
-	if (Z_STRLEN(op2->u.constant) > 1) {
-		opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-		opline->opcode = ZEND_ADD_STRING;
-	} else if (Z_STRLEN(op2->u.constant) == 1) {
-		int ch = *Z_STRVAL(op2->u.constant);
-
-		/* Free memory and use ZEND_ADD_CHAR in case of 1 character strings */
-		zend_string_free(Z_STR(op2->u.constant));
-		ZVAL_LONG(&op2->u.constant, ch);
-		opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-		opline->opcode = ZEND_ADD_CHAR;
-	} else { /* String can be empty after a variable at the end of a heredoc */
-		zend_string_free(Z_STR(op2->u.constant));
-		return;
-	}
-
-	if (op1) {
-		SET_NODE(opline->op1, op1);
-		SET_NODE(opline->result, op1);
-	} else {
-		SET_UNUSED(opline->op1);
-		opline->result_type = IS_TMP_VAR;
-		opline->result.var = get_temporary_variable(CG(active_op_array));
-	}
-	SET_NODE(opline->op2, op2);
-	GET_NODE(result, opline->result);
-}
-/* }}} */
-
-void zend_do_add_variable(znode *result, znode *op1, znode *op2 TSRMLS_DC) /* {{{ */
-{
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-
-	opline->opcode = ZEND_ADD_VAR;
-
-	if (op1) {
-		SET_NODE(opline->op1, op1);
-		SET_NODE(opline->result, op1);
-	} else {
-		SET_UNUSED(opline->op1);
-		opline->result_type = IS_TMP_VAR;
-		opline->result.var = get_temporary_variable(CG(active_op_array));
-	}
-	SET_NODE(opline->op2, op2);
-	GET_NODE(result, opline->result);
-}
-/* }}} */
-
 void zend_do_free(znode *op1 TSRMLS_DC) /* {{{ */
 {
 	if (op1->op_type==IS_TMP_VAR) {
@@ -1473,869 +614,197 @@ void zend_do_free(znode *op1 TSRMLS_DC) /* {{{ */
 			}
 		}
 	} else if (op1->op_type == IS_CONST) {
-		zval_dtor(&op1->u.constant);
+		/* Destroy value without using GC: When opcache moves arrays into SHM it will
+		 * free the zend_array structure, so references to it from outside the op array
+		 * become invalid. GC would cause such a reference in the root buffer. */
+		zval *zv = &op1->u.constant;
+		if (Z_REFCOUNTED_P(zv) && !Z_DELREF_P(zv)) {
+			_zval_dtor_func_for_ptr(Z_COUNTED_P(zv) ZEND_FILE_LINE_CC);
+		}
 	}
 }
 /* }}} */
 
-int zend_do_verify_access_types(const znode *current_access_type, const znode *new_modifier) /* {{{ */
-{
-	if ((Z_LVAL(current_access_type->u.constant) & ZEND_ACC_PPP_MASK)
-		&& (Z_LVAL(new_modifier->u.constant) & ZEND_ACC_PPP_MASK)) {
+uint32_t zend_add_member_modifier(uint32_t flags, uint32_t new_flag) {
+	uint32_t new_flags = flags | new_flag;
+	if ((flags & ZEND_ACC_PPP_MASK) && (new_flag & ZEND_ACC_PPP_MASK)) {
 		zend_error_noreturn(E_COMPILE_ERROR, "Multiple access type modifiers are not allowed");
 	}
-	if ((Z_LVAL(current_access_type->u.constant) & ZEND_ACC_ABSTRACT)
-		&& (Z_LVAL(new_modifier->u.constant) & ZEND_ACC_ABSTRACT)) {
+	if ((flags & ZEND_ACC_ABSTRACT) && (new_flag & ZEND_ACC_ABSTRACT)) {
 		zend_error_noreturn(E_COMPILE_ERROR, "Multiple abstract modifiers are not allowed");
 	}
-	if ((Z_LVAL(current_access_type->u.constant) & ZEND_ACC_STATIC)
-		&& (Z_LVAL(new_modifier->u.constant) & ZEND_ACC_STATIC)) {
+	if ((flags & ZEND_ACC_STATIC) && (new_flag & ZEND_ACC_STATIC)) {
 		zend_error_noreturn(E_COMPILE_ERROR, "Multiple static modifiers are not allowed");
 	}
-	if ((Z_LVAL(current_access_type->u.constant) & ZEND_ACC_FINAL)
-		&& (Z_LVAL(new_modifier->u.constant) & ZEND_ACC_FINAL)) {
+	if ((flags & ZEND_ACC_FINAL) && (new_flag & ZEND_ACC_FINAL)) {
 		zend_error_noreturn(E_COMPILE_ERROR, "Multiple final modifiers are not allowed");
 	}
-	if (((Z_LVAL(current_access_type->u.constant) | Z_LVAL(new_modifier->u.constant)) & (ZEND_ACC_ABSTRACT | ZEND_ACC_FINAL)) == (ZEND_ACC_ABSTRACT | ZEND_ACC_FINAL)) {
+	if ((new_flags & ZEND_ACC_ABSTRACT) && (new_flags & ZEND_ACC_FINAL)) {
 		zend_error_noreturn(E_COMPILE_ERROR, "Cannot use the final modifier on an abstract class member");
 	}
-	return (Z_LVAL(current_access_type->u.constant) | Z_LVAL(new_modifier->u.constant));
+	return new_flags;
 }
-/* }}} */
-
-void zend_do_begin_function_declaration(znode *function_token, znode *function_name, int is_method, int return_reference, znode *fn_flags_znode TSRMLS_DC) /* {{{ */
-{
-	zend_op_array op_array;
-	zend_string *name = Z_STR(function_name->u.constant);
-	int function_begin_line = function_token->u.op.opline_num;
-	uint32_t fn_flags;
-	zend_string *lcname;
-	zend_bool orig_interactive;
-	ALLOCA_FLAG(use_heap)
-
-	if (is_method) {
-		if (CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE) {
-			if ((Z_LVAL(fn_flags_znode->u.constant) & ~(ZEND_ACC_STATIC|ZEND_ACC_PUBLIC))) {
-				zend_error_noreturn(E_COMPILE_ERROR, "Access type for interface method %s::%s() must be omitted", CG(active_class_entry)->name->val, Z_STRVAL(function_name->u.constant));
-			}
-			Z_LVAL(fn_flags_znode->u.constant) |= ZEND_ACC_ABSTRACT; /* propagates to the rest of the parser */
-		}
-		fn_flags = Z_LVAL(fn_flags_znode->u.constant); /* must be done *after* the above check */
-	} else {
-		fn_flags = 0;
-	}
-	if ((fn_flags & ZEND_ACC_STATIC) && (fn_flags & ZEND_ACC_ABSTRACT) && !(CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE)) {
-		zend_error(E_STRICT, "Static function %s%s%s() should not be abstract", is_method ? CG(active_class_entry)->name->val : "", is_method ? "::" : "", Z_STRVAL(function_name->u.constant));
-	}
-
-	function_token->u.op_array = CG(active_op_array);
-
-	orig_interactive = CG(interactive);
-	CG(interactive) = 0;
-	init_op_array(&op_array, ZEND_USER_FUNCTION, INITIAL_OP_ARRAY_SIZE TSRMLS_CC);
-	CG(interactive) = orig_interactive;
-
-	op_array.function_name = name;
-	if (return_reference) {
-		op_array.fn_flags |= ZEND_ACC_RETURN_REFERENCE;
-	}
-	op_array.fn_flags |= fn_flags;
-
-	op_array.scope = is_method?CG(active_class_entry):NULL;
-	op_array.prototype = NULL;
 
-	op_array.line_start = zend_get_compiled_lineno(TSRMLS_C);
+zend_string *zend_concat3(
+	char *str1, size_t str1_len, char *str2, size_t str2_len, char *str3, size_t str3_len
+) {
+	size_t len = str1_len + str2_len + str3_len;
+	zend_string *res = zend_string_alloc(len, 0);
 
-	if (is_method) {
-		lcname = zend_string_alloc(name->len, 0);
-		zend_str_tolower_copy(lcname->val, name->val, name->len);
-		lcname = zend_new_interned_string(lcname TSRMLS_CC);
-		CG(active_op_array) = zend_arena_alloc(&CG(arena), sizeof(zend_op_array));
-		memcpy(CG(active_op_array), &op_array, sizeof(zend_op_array));
-		if (zend_hash_add_ptr(&CG(active_class_entry)->function_table, lcname, CG(active_op_array)) == NULL) {
-			zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare %s::%s()", CG(active_class_entry)->name->val, name->val);
-		}
-
-		zend_stack_push(&CG(context_stack), (void *) &CG(context));
-		zend_init_compiler_context(TSRMLS_C);
-
-		if (fn_flags & ZEND_ACC_ABSTRACT) {
-			CG(active_class_entry)->ce_flags |= ZEND_ACC_IMPLICIT_ABSTRACT_CLASS;
-		}
+	memcpy(res->val, str1, str1_len);
+	memcpy(res->val + str1_len, str2, str2_len);
+	memcpy(res->val + str1_len + str2_len, str3, str3_len);
+	res->val[len] = '\0';
 
-		if (!(fn_flags & ZEND_ACC_PPP_MASK)) {
-			fn_flags |= ZEND_ACC_PUBLIC;
-		}
-
-		if (CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE) {
-			if ((name->len == sizeof(ZEND_CALL_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_CALL_FUNC_NAME, sizeof(ZEND_CALL_FUNC_NAME)-1))) {
-				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
-					zend_error(E_WARNING, "The magic method __call() must have public visibility and cannot be static");
-				}
-			} else if ((name->len == sizeof(ZEND_CALLSTATIC_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_CALLSTATIC_FUNC_NAME, sizeof(ZEND_CALLSTATIC_FUNC_NAME)-1))) {
-				if ((fn_flags & (ZEND_ACC_PPP_MASK ^ ZEND_ACC_PUBLIC)) || (fn_flags & ZEND_ACC_STATIC) == 0) {
-					zend_error(E_WARNING, "The magic method __callStatic() must have public visibility and be static");
-				}
-			} else if ((name->len == sizeof(ZEND_GET_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_GET_FUNC_NAME, sizeof(ZEND_GET_FUNC_NAME)-1))) {
-				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
-					zend_error(E_WARNING, "The magic method __get() must have public visibility and cannot be static");
-				}
-			} else if ((name->len == sizeof(ZEND_SET_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_SET_FUNC_NAME, sizeof(ZEND_SET_FUNC_NAME)-1))) {
-				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
-					zend_error(E_WARNING, "The magic method __set() must have public visibility and cannot be static");
-				}
-			} else if ((name->len == sizeof(ZEND_UNSET_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_UNSET_FUNC_NAME, sizeof(ZEND_UNSET_FUNC_NAME)-1))) {
-				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
-					zend_error(E_WARNING, "The magic method __unset() must have public visibility and cannot be static");
-				}
-			} else if ((name->len == sizeof(ZEND_ISSET_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_ISSET_FUNC_NAME, sizeof(ZEND_ISSET_FUNC_NAME)-1))) {
-				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
-					zend_error(E_WARNING, "The magic method __isset() must have public visibility and cannot be static");
-				}
-			} else if ((name->len == sizeof(ZEND_TOSTRING_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_TOSTRING_FUNC_NAME, sizeof(ZEND_TOSTRING_FUNC_NAME)-1))) {
-				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
-					zend_error(E_WARNING, "The magic method __toString() must have public visibility and cannot be static");
-				}
-			} else if ((name->len == sizeof(ZEND_INVOKE_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1))) {
-				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
-					zend_error(E_WARNING, "The magic method __invoke() must have public visibility and cannot be static");
-				}
-
-			} else if ((name->len == sizeof(ZEND_DEBUGINFO_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_DEBUGINFO_FUNC_NAME, sizeof(ZEND_DEBUGINFO_FUNC_NAME)-1))) {
-				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
-					zend_error(E_WARNING, "The magic method __debugInfo() must have public visibility and cannot be static");
-				}
-			}
-		} else {
-			char *class_lcname;
-
-			class_lcname = do_alloca(CG(active_class_entry)->name->len + 1, use_heap);
-			zend_str_tolower_copy(class_lcname, CG(active_class_entry)->name->val, CG(active_class_entry)->name->len);
-			/* Improve after RC: cache the lowercase class name */
-
-			if ((CG(active_class_entry)->name->len == name->len) && ((CG(active_class_entry)->ce_flags & ZEND_ACC_TRAIT) != ZEND_ACC_TRAIT) && (!memcmp(class_lcname, lcname->val, name->len))) {
-				if (!CG(active_class_entry)->constructor) {
-					CG(active_class_entry)->constructor = (zend_function *) CG(active_op_array);
-				}
-			} else if ((name->len == sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_CONSTRUCTOR_FUNC_NAME, sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)-1))) {
-				if (CG(active_class_entry)->constructor) {
-					zend_error(E_STRICT, "Redefining already defined constructor for class %s", CG(active_class_entry)->name->val);
-				}
-				CG(active_class_entry)->constructor = (zend_function *) CG(active_op_array);
-			} else if ((name->len == sizeof(ZEND_DESTRUCTOR_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_DESTRUCTOR_FUNC_NAME, sizeof(ZEND_DESTRUCTOR_FUNC_NAME)-1))) {
-				CG(active_class_entry)->destructor = (zend_function *) CG(active_op_array);
-			} else if ((name->len == sizeof(ZEND_CLONE_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_CLONE_FUNC_NAME, sizeof(ZEND_CLONE_FUNC_NAME)-1))) {
-				CG(active_class_entry)->clone = (zend_function *) CG(active_op_array);
-			} else if ((name->len == sizeof(ZEND_CALL_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_CALL_FUNC_NAME, sizeof(ZEND_CALL_FUNC_NAME)-1))) {
-				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
-					zend_error(E_WARNING, "The magic method __call() must have public visibility and cannot be static");
-				}
-				CG(active_class_entry)->__call = (zend_function *) CG(active_op_array);
-			} else if ((name->len == sizeof(ZEND_CALLSTATIC_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_CALLSTATIC_FUNC_NAME, sizeof(ZEND_CALLSTATIC_FUNC_NAME)-1))) {
-				if ((fn_flags & (ZEND_ACC_PPP_MASK ^ ZEND_ACC_PUBLIC)) || (fn_flags & ZEND_ACC_STATIC) == 0) {
-					zend_error(E_WARNING, "The magic method __callStatic() must have public visibility and be static");
-				}
-				CG(active_class_entry)->__callstatic = (zend_function *) CG(active_op_array);
-			} else if ((name->len == sizeof(ZEND_GET_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_GET_FUNC_NAME, sizeof(ZEND_GET_FUNC_NAME)-1))) {
-				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
-					zend_error(E_WARNING, "The magic method __get() must have public visibility and cannot be static");
-				}
-				CG(active_class_entry)->__get = (zend_function *) CG(active_op_array);
-			} else if ((name->len == sizeof(ZEND_SET_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_SET_FUNC_NAME, sizeof(ZEND_SET_FUNC_NAME)-1))) {
-				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
-					zend_error(E_WARNING, "The magic method __set() must have public visibility and cannot be static");
-				}
-				CG(active_class_entry)->__set = (zend_function *) CG(active_op_array);
-			} else if ((name->len == sizeof(ZEND_UNSET_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_UNSET_FUNC_NAME, sizeof(ZEND_UNSET_FUNC_NAME)-1))) {
-				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
-					zend_error(E_WARNING, "The magic method __unset() must have public visibility and cannot be static");
-				}
-				CG(active_class_entry)->__unset = (zend_function *) CG(active_op_array);
-			} else if ((name->len == sizeof(ZEND_ISSET_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_ISSET_FUNC_NAME, sizeof(ZEND_ISSET_FUNC_NAME)-1))) {
-				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
-					zend_error(E_WARNING, "The magic method __isset() must have public visibility and cannot be static");
-				}
-				CG(active_class_entry)->__isset = (zend_function *) CG(active_op_array);
-			} else if ((name->len == sizeof(ZEND_TOSTRING_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_TOSTRING_FUNC_NAME, sizeof(ZEND_TOSTRING_FUNC_NAME)-1))) {
-				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
-					zend_error(E_WARNING, "The magic method __toString() must have public visibility and cannot be static");
-				}
-				CG(active_class_entry)->__tostring = (zend_function *) CG(active_op_array);
-			} else if ((name->len == sizeof(ZEND_INVOKE_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1))) {
-				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
-					zend_error(E_WARNING, "The magic method __invoke() must have public visibility and cannot be static");
-				}
-			} else if ((name->len == sizeof(ZEND_DEBUGINFO_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_DEBUGINFO_FUNC_NAME, sizeof(ZEND_DEBUGINFO_FUNC_NAME)-1))) {
-				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
-					zend_error(E_WARNING, "The magic method __debugInfo() must have public visibility and cannot be static");
-				}
-				CG(active_class_entry)->__debugInfo = (zend_function *) CG(active_op_array);
-			} else if (!(fn_flags & ZEND_ACC_STATIC)) {
-				CG(active_op_array)->fn_flags |= ZEND_ACC_ALLOW_STATIC;
-			}
-			free_alloca(class_lcname, use_heap);
-		}
-
-		zend_string_release(lcname);
-	} else {
-		zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-		zval key;
-		zval *ns_name;
-
-		if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
-			/* Prefix function name with current namespace name */
-			znode tmp;
-
-			ZVAL_DUP(&tmp.u.constant, &CG(current_namespace));
-			zend_do_build_namespace_name(&tmp, &tmp, function_name TSRMLS_CC);
-			op_array.function_name = Z_STR(tmp.u.constant);
-			lcname = zend_string_alloc(Z_STRLEN(tmp.u.constant), 0);
-			zend_str_tolower_copy(lcname->val, Z_STRVAL(tmp.u.constant), Z_STRLEN(tmp.u.constant));
-		} else {
-			lcname = zend_string_alloc(name->len, 0);
-			zend_str_tolower_copy(lcname->val, name->val, name->len);
-		}
-
-		/* Function name must not conflict with import names */
-		if (CG(current_import_function) &&
-		    (ns_name = zend_hash_find(CG(current_import_function), lcname)) != NULL) {
-
-			char *tmp = zend_str_tolower_dup(Z_STRVAL_P(ns_name), Z_STRLEN_P(ns_name));
-
-			if (Z_STRLEN_P(ns_name) != Z_STRLEN(function_name->u.constant) ||
-				memcmp(tmp, lcname->val, Z_STRLEN(function_name->u.constant))) {
-				zend_error(E_COMPILE_ERROR, "Cannot declare function %s because the name is already in use", Z_STRVAL(function_name->u.constant));
-			}
-			efree(tmp);
-		}
-
-		opline->opcode = ZEND_DECLARE_FUNCTION;
-		opline->op1_type = IS_CONST;
-		build_runtime_defined_function_key(&key, lcname->val, lcname->len TSRMLS_CC);
-		opline->op1.constant = zend_add_literal(CG(active_op_array), &key TSRMLS_CC);
-		opline->op2_type = IS_CONST;
-		LITERAL_STR(opline->op2, zend_string_copy(lcname));
-		opline->extended_value = ZEND_DECLARE_FUNCTION;
-		CG(active_op_array) = zend_arena_alloc(&CG(arena), sizeof(zend_op_array));
-		memcpy(CG(active_op_array), &op_array, sizeof(zend_op_array));
-		zend_hash_update_ptr(CG(function_table), Z_STR(key), CG(active_op_array));
-		zend_stack_push(&CG(context_stack), (void *) &CG(context));
-		zend_init_compiler_context(TSRMLS_C);
-		zend_string_release(lcname);
-	}
-
-	if (CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO) {
-		zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-
-		opline->opcode = ZEND_EXT_NOP;
-		opline->lineno = function_begin_line;
-		SET_UNUSED(opline->op1);
-		SET_UNUSED(opline->op2);
-	}
-
-	{
-		/* Push a separator to the switch stack */
-		zend_switch_entry switch_entry;
-
-		switch_entry.cond.op_type = IS_UNUSED;
-		switch_entry.default_case = 0;
-		switch_entry.control_var = 0;
-
-		zend_stack_push(&CG(switch_cond_stack), (void *) &switch_entry);
-	}
-
-	{
-		/* Push a separator to the foreach stack */
-		zend_op dummy_opline;
-
-		dummy_opline.result_type = IS_UNUSED;
-
-		zend_stack_push(&CG(foreach_copy_stack), (void *) &dummy_opline);
-	}
-
-	if (CG(doc_comment)) {
-		CG(active_op_array)->doc_comment = CG(doc_comment);
-		CG(doc_comment) = NULL;
-	}
+	return res;
 }
-/* }}} */
-
-void zend_do_begin_lambda_function_declaration(znode *result, znode *function_token, int return_reference, int is_static TSRMLS_DC) /* {{{ */
-{
-	znode          function_name;
-	zend_op_array *current_op_array = CG(active_op_array);
-	int            current_op_number = get_next_op_number(CG(active_op_array));
-	zend_op       *current_op;
-
-	function_name.op_type = IS_CONST;
-	ZVAL_STRINGL(&function_name.u.constant, "{closure}", sizeof("{closure}")-1);
-
-	zend_do_begin_function_declaration(function_token, &function_name, 0, return_reference, NULL TSRMLS_CC);
-
-	result->op_type = IS_TMP_VAR;
-	result->u.op.var = get_temporary_variable(current_op_array);
-
-	current_op = &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;
-	}
-	CG(active_op_array)->fn_flags |= ZEND_ACC_CLOSURE;
-}
-/* }}} */
 
-void zend_do_handle_exception(TSRMLS_D) /* {{{ */
-{
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-
-	opline->opcode = ZEND_HANDLE_EXCEPTION;
-	SET_UNUSED(opline->op1);
-	SET_UNUSED(opline->op2);
+zend_string *zend_concat_names(char *name1, size_t name1_len, char *name2, size_t name2_len) {
+	return zend_concat3(name1, name1_len, "\\", 1, name2, name2_len);
 }
-/* }}} */
-
-void zend_do_end_function_declaration(const znode *function_token TSRMLS_DC) /* {{{ */
-{
-	char lcname[16];
-	int name_len;
 
-	zend_do_extended_info(TSRMLS_C);
-	zend_do_return(NULL, 0 TSRMLS_CC);
-
-	pass_two(CG(active_op_array) TSRMLS_CC);
-	zend_release_labels(0 TSRMLS_CC);
-
-	if (CG(active_class_entry)) {
-		zend_check_magic_method_implementation(CG(active_class_entry), (zend_function*)CG(active_op_array), E_COMPILE_ERROR TSRMLS_CC);
+zend_string *zend_prefix_with_ns(zend_string *name TSRMLS_DC) {
+	if (CG(current_namespace)) {
+		zend_string *ns = CG(current_namespace);
+		return zend_concat_names(ns->val, ns->len, name->val, name->len);
 	} else {
-		/* we don't care if the function name is longer, in fact lowercasing only
-		 * the beginning of the name speeds up the check process */
-		name_len = CG(active_op_array)->function_name->len;
-		zend_str_tolower_copy(lcname, CG(active_op_array)->function_name->val, MIN(name_len, sizeof(lcname)-1));
-		lcname[sizeof(lcname)-1] = '\0'; /* zend_str_tolower_copy won't necessarily set the zero byte */
-		if (name_len == sizeof(ZEND_AUTOLOAD_FUNC_NAME) - 1 && !memcmp(lcname, ZEND_AUTOLOAD_FUNC_NAME, sizeof(ZEND_AUTOLOAD_FUNC_NAME)) && CG(active_op_array)->num_args != 1) {
-			zend_error_noreturn(E_COMPILE_ERROR, "%s() must take exactly 1 argument", ZEND_AUTOLOAD_FUNC_NAME);
-		}
+		return zend_string_copy(name);
 	}
+}
 
-	CG(active_op_array)->line_end = zend_get_compiled_lineno(TSRMLS_C);
-	CG(active_op_array) = function_token->u.op_array;
-
-
-	/* Pop the switch and foreach separators */
-	zend_stack_del_top(&CG(switch_cond_stack));
-	zend_stack_del_top(&CG(foreach_copy_stack));
+void *zend_hash_find_ptr_lc(HashTable *ht, char *str, size_t len) {
+	void *result;
+	zend_string *lcname = zend_string_alloc(len, 0);
+	zend_str_tolower_copy(lcname->val, str, len);
+	result = zend_hash_find_ptr(ht, lcname);
+	zend_string_free(lcname);
+	return result;
 }
-/* }}} */
 
-void zend_do_receive_param(zend_uchar op, znode *varname, znode *initialization, znode *class_type, zend_uchar pass_by_reference, zend_bool is_variadic TSRMLS_DC) /* {{{ */
-{
-	zend_op *opline;
-	zend_arg_info *cur_arg_info;
-	znode var;
+zend_string *zend_resolve_non_class_name(
+	zend_string *name, uint32_t type, zend_bool *is_fully_qualified,
+	zend_bool case_sensitive, HashTable *current_import_sub TSRMLS_DC
+) {
+	char *compound;
+	*is_fully_qualified = 0;
 
-	if (zend_is_auto_global(Z_STR(varname->u.constant) TSRMLS_CC)) {
-		zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign auto-global variable %s", Z_STRVAL(varname->u.constant));
-	} else {
-		var.op_type = IS_CV;
-		var.u.op.var = lookup_cv(CG(active_op_array), Z_STR(varname->u.constant) TSRMLS_CC);
-		Z_STR(varname->u.constant) = CG(active_op_array)->vars[EX_VAR_TO_NUM(var.u.op.var)];
-		var.EA = 0;
-		if (EX_VAR_TO_NUM(var.u.op.var) != CG(active_op_array)->num_args) {
-			zend_error_noreturn(E_COMPILE_ERROR, "Redefinition of parameter $%s", Z_STRVAL(varname->u.constant));
-		} else if (Z_STRHASH(varname->u.constant) == THIS_HASHVAL &&
-			Z_STRLEN(varname->u.constant) == sizeof("this")-1 &&
-		    !memcmp(Z_STRVAL(varname->u.constant), "this", sizeof("this")-1)) {
-			if (CG(active_op_array)->scope &&
-			    (CG(active_op_array)->fn_flags & ZEND_ACC_STATIC) == 0) {
-				zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this");
-			}
-			CG(active_op_array)->this_var = var.u.op.var;
-		}
+	if (name->val[0] == '\\') {
+		/* Remove \ prefix (only relevant if this is a string rather than a label) */
+		return zend_string_init(name->val + 1, name->len - 1, 0);
 	}
 
-	if (CG(active_op_array)->fn_flags & ZEND_ACC_VARIADIC) {
-		zend_error_noreturn(E_COMPILE_ERROR, "Only the last parameter can be variadic");
+	if (type == ZEND_NAME_FQ) {
+		*is_fully_qualified = 1;
+		return zend_string_copy(name);
 	}
 
-	if (is_variadic) {
-		if (op == ZEND_RECV_INIT) {
-			zend_error_noreturn(E_COMPILE_ERROR, "Variadic parameter cannot have a default value");
-		}
-
-		op = ZEND_RECV_VARIADIC;
-		CG(active_op_array)->fn_flags |= ZEND_ACC_VARIADIC;
+	if (type == ZEND_NAME_RELATIVE) {
+		*is_fully_qualified = 1;
+		return zend_prefix_with_ns(name TSRMLS_CC);
 	}
 
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	CG(active_op_array)->num_args++;
-	opline->opcode = op;
-	SET_NODE(opline->result, &var);
-	opline->op1_type = IS_UNUSED;
-	opline->op1.num = CG(active_op_array)->num_args;
-	if (op == ZEND_RECV_INIT) {
-		SET_NODE(opline->op2, initialization);
-	} else {
-		SET_UNUSED(opline->op2);
-		if (!is_variadic) {
-			CG(active_op_array)->required_num_args = CG(active_op_array)->num_args;
-		}
-	}
-	CG(active_op_array)->arg_info = erealloc(CG(active_op_array)->arg_info, sizeof(zend_arg_info)*(CG(active_op_array)->num_args));
-	cur_arg_info = &CG(active_op_array)->arg_info[CG(active_op_array)->num_args-1];
-	cur_arg_info->name = estrndup(Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant));
-	cur_arg_info->name_len = Z_STRLEN(varname->u.constant);
-	cur_arg_info->type_hint = 0;
-	cur_arg_info->pass_by_reference = pass_by_reference;
-	cur_arg_info->allow_null = 1;
-	cur_arg_info->is_variadic = is_variadic;
-	cur_arg_info->class_name = NULL;
-	cur_arg_info->class_name_len = 0;
-
-	if (class_type->op_type != IS_UNUSED) {
-		cur_arg_info->allow_null = 0;
-
-		if (Z_TYPE(class_type->u.constant) != IS_NULL) {
-			if (Z_TYPE(class_type->u.constant) == IS_ARRAY) {
-				cur_arg_info->type_hint = IS_ARRAY;
-				if (op == ZEND_RECV_INIT) {
-					if (Z_TYPE(initialization->u.constant) == IS_NULL || (Z_TYPE(initialization->u.constant) == IS_CONSTANT && !strcasecmp(Z_STRVAL(initialization->u.constant), "NULL")) || Z_TYPE(initialization->u.constant) == IS_CONSTANT_AST) {
-						cur_arg_info->allow_null = 1;
-					} else if (Z_TYPE(initialization->u.constant) != IS_ARRAY) {
-						zend_error_noreturn(E_COMPILE_ERROR, "Default value for parameters with array type hint can only be an array or NULL");
-					}
-				}
-			} else if (Z_TYPE(class_type->u.constant) == IS_CALLABLE) {
-				cur_arg_info->type_hint = IS_CALLABLE;
-				if (op == ZEND_RECV_INIT) {
-					if (Z_TYPE(initialization->u.constant) == IS_NULL || (Z_TYPE(initialization->u.constant) == IS_CONSTANT && !strcasecmp(Z_STRVAL(initialization->u.constant), "NULL")) || Z_TYPE(initialization->u.constant) == IS_CONSTANT_AST) {
-						cur_arg_info->allow_null = 1;
-					} else {
-						zend_error_noreturn(E_COMPILE_ERROR, "Default value for parameters with callable type hint can only be NULL");
-					}
-				}
-			} else {
-				cur_arg_info->type_hint = IS_OBJECT;
-				if (ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(class_type->u.constant), Z_STRLEN(class_type->u.constant))) {
-					zend_resolve_class_name(class_type TSRMLS_CC);
-				}
-				Z_STR(class_type->u.constant) = zend_new_interned_string(Z_STR(class_type->u.constant) TSRMLS_CC);
-				if (IS_INTERNED(Z_STR(class_type->u.constant))) {
-					Z_TYPE_FLAGS(class_type->u.constant) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE);
-				}
-// TODO: for now we have to copy it ???
-#if 1
-				cur_arg_info->class_name = estrndup(Z_STRVAL(class_type->u.constant), Z_STRLEN(class_type->u.constant));
-				cur_arg_info->class_name_len = Z_STRLEN(class_type->u.constant);
-				zend_string_release(Z_STR(class_type->u.constant));
-#else
-				cur_arg_info->class_name = Z_STRVAL(class_type->u.constant);
-				cur_arg_info->class_name_len = Z_STRLEN(class_type->u.constant);
-#endif
-				if (op == ZEND_RECV_INIT) {
-					if (Z_TYPE(initialization->u.constant) == IS_NULL || (Z_TYPE(initialization->u.constant) == IS_CONSTANT && !strcasecmp(Z_STRVAL(initialization->u.constant), "NULL")) || Z_TYPE(initialization->u.constant) == IS_CONSTANT_AST) {
-						cur_arg_info->allow_null = 1;
-					} else {
-						zend_error_noreturn(E_COMPILE_ERROR, "Default value for parameters with a class type hint can only be NULL");
-					}
-				}
-			}
+	if (current_import_sub) {
+		/* If an unqualified name is a function/const alias, replace it. */
+		zend_string *import_name;
+		if (case_sensitive) {
+			import_name = zend_hash_find_ptr(current_import_sub, name);
+		} else {
+			import_name = zend_hash_find_ptr_lc(current_import_sub, name->val, name->len);
 		}
-	}
 
-	if (cur_arg_info->class_name || cur_arg_info->type_hint) {
-		CG(active_op_array)->fn_flags |= ZEND_ACC_HAS_TYPE_HINTS;
+		if (import_name) {
+			*is_fully_qualified = 1;
+			return zend_string_copy(import_name);
+		}
 	}
-}
-/* }}} */
-
-int zend_do_begin_function_call(znode *function_name, zend_bool check_namespace TSRMLS_DC) /* {{{ */
-{
-	zend_op *opline;
-	uint32_t op_number;
-	zend_function *function;
-	zend_string *lcname;
-	char *is_compound = memchr(Z_STRVAL(function_name->u.constant), '\\', Z_STRLEN(function_name->u.constant));
 
-	zend_resolve_function_name(function_name, &check_namespace TSRMLS_CC);
-
-	if (check_namespace && Z_TYPE(CG(current_namespace)) != IS_UNDEF && !is_compound) {
-			/* We assume we call function from the current namespace
-			if it is not prefixed. */
-
-			/* In run-time PHP will check for function with full name and
-			internal function with short name */
-			zend_do_begin_dynamic_function_call(function_name, 1 TSRMLS_CC);
-			return 1;
+	compound = memchr(name->val, '\\', name->len);
+	if (compound) {
+		*is_fully_qualified = 1;
 	}
 
-	lcname = zend_string_alloc(Z_STRLEN(function_name->u.constant), 0);
-	zend_str_tolower_copy(lcname->val, Z_STRVAL(function_name->u.constant), Z_STRLEN(function_name->u.constant));
-	if (((function = zend_hash_find_ptr(CG(function_table), lcname)) == NULL) ||
-	 	((CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_FUNCTIONS) &&
- 		(function->type == ZEND_INTERNAL_FUNCTION))) {
- 			zend_do_begin_dynamic_function_call(function_name, 0 TSRMLS_CC);
- 			efree(lcname);
- 			return 1; /* Dynamic */
- 	}
-	zend_string_release(Z_STR(function_name->u.constant));
-	Z_STR(function_name->u.constant) = lcname;
-
-	op_number = get_next_op_number(CG(active_op_array));
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	opline->opcode = ZEND_INIT_FCALL;
-	SET_UNUSED(opline->op1);
-	SET_NODE(opline->op2, function_name);
-	GET_CACHE_SLOT(opline->op2.constant);
-
-	zend_push_function_call_entry(function, op_number TSRMLS_CC);
-	zend_do_extended_fcall_begin(TSRMLS_C);
-	return 0;
-}
-/* }}} */
-
-void zend_do_begin_method_call(znode *left_bracket TSRMLS_DC) /* {{{ */
-{
-	zend_op *last_op;
-	int last_op_number;
-
-	zend_do_end_variable_parse(left_bracket, BP_VAR_R, 0 TSRMLS_CC);
-	zend_do_begin_variable_parse(TSRMLS_C);
-
-	last_op_number = get_next_op_number(CG(active_op_array))-1;
-	last_op = &CG(active_op_array)->opcodes[last_op_number];
-
-	if ((last_op->op2_type == IS_CONST) && (Z_TYPE(CONSTANT(last_op->op2.constant)) == IS_STRING) && (Z_STRLEN(CONSTANT(last_op->op2.constant)) == sizeof(ZEND_CLONE_FUNC_NAME)-1)
-		&& !zend_binary_strcasecmp(Z_STRVAL(CONSTANT(last_op->op2.constant)), Z_STRLEN(CONSTANT(last_op->op2.constant)), ZEND_CLONE_FUNC_NAME, sizeof(ZEND_CLONE_FUNC_NAME)-1)) {
-		zend_error_noreturn(E_COMPILE_ERROR, "Cannot call __clone() method on objects - use 'clone $obj' instead");
-	}
+	if (compound && CG(current_import)) {
+		/* If the first part of a qualified name is an alias, substitute it. */
+		size_t len = compound - name->val;
+		zend_string *import_name = zend_hash_find_ptr_lc(CG(current_import), name->val, len);
 
-	if (last_op->opcode == ZEND_FETCH_OBJ_R) {
-		if (last_op->op2_type == IS_CONST) {
-			zval name;
-			name = CONSTANT(last_op->op2.constant);
-			if (Z_TYPE(name) != IS_STRING) {
-				zend_error_noreturn(E_COMPILE_ERROR, "Method name must be a string");
-			}
-			Z_STR(name) = zend_string_copy(Z_STR(name));
-			FREE_POLYMORPHIC_CACHE_SLOT(last_op->op2.constant);
-			last_op->op2.constant =
-				zend_add_func_name_literal(CG(active_op_array), &name TSRMLS_CC);
-			GET_POLYMORPHIC_CACHE_SLOT(last_op->op2.constant);
-		}
-		last_op->opcode = ZEND_INIT_METHOD_CALL;
-		last_op->result_type = IS_UNUSED;
-		Z_LVAL(left_bracket->u.constant) = ZEND_INIT_FCALL_BY_NAME;
-	} else {
-		zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-		opline->opcode = ZEND_INIT_FCALL_BY_NAME;
-		SET_UNUSED(opline->op1);
-		if (left_bracket->op_type == IS_CONST) {
-			opline->op2_type = IS_CONST;
-			opline->op2.constant = zend_add_func_name_literal(CG(active_op_array), &left_bracket->u.constant TSRMLS_CC);
-			GET_CACHE_SLOT(opline->op2.constant);
-		} else {
-			SET_NODE(opline->op2, left_bracket);
+		if (import_name) {
+			return zend_concat_names(
+				import_name->val, import_name->len, name->val + len + 1, name->len - len - 1);
 		}
 	}
 
-	zend_push_function_call_entry(NULL, last_op_number TSRMLS_CC);
-	zend_do_extended_fcall_begin(TSRMLS_C);
+	return zend_prefix_with_ns(name TSRMLS_CC);
 }
 /* }}} */
 
-void zend_do_clone(znode *result, znode *expr TSRMLS_DC) /* {{{ */
-{
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-
-	opline->opcode = ZEND_CLONE;
-	SET_NODE(opline->op1, expr);
-	SET_UNUSED(opline->op2);
-	opline->result_type = IS_VAR;
-	opline->result.var = get_temporary_variable(CG(active_op_array));
-	GET_NODE(result, opline->result);
+zend_string *zend_resolve_function_name(
+	zend_string *name, uint32_t type, zend_bool *is_fully_qualified TSRMLS_DC
+) {
+	return zend_resolve_non_class_name(
+		name, type, is_fully_qualified, 0, CG(current_import_function) TSRMLS_CC);
 }
-/* }}} */
-
-void zend_do_begin_dynamic_function_call(znode *function_name, int ns_call TSRMLS_DC) /* {{{ */
-{
-	uint32_t op_number;
-	zend_op *opline;
-
-	op_number = get_next_op_number(CG(active_op_array));
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	if (ns_call) {
-		/* In run-time PHP will check for function with full name and
-		   internal function with short name */
-		opline->opcode = ZEND_INIT_NS_FCALL_BY_NAME;
-		SET_UNUSED(opline->op1);
-		opline->op2_type = IS_CONST;
-		opline->op2.constant = zend_add_ns_func_name_literal(CG(active_op_array), &function_name->u.constant TSRMLS_CC);
-		GET_CACHE_SLOT(opline->op2.constant);
-	} else {
-		opline->opcode = ZEND_INIT_FCALL_BY_NAME;
-		SET_UNUSED(opline->op1);
-		if (function_name->op_type == IS_CONST) {
-			opline->op2_type = IS_CONST;
-			opline->op2.constant = zend_add_func_name_literal(CG(active_op_array), &function_name->u.constant TSRMLS_CC);
-			GET_CACHE_SLOT(opline->op2.constant);
-		} else {
-			SET_NODE(opline->op2, function_name);
-		}
-	}
 
-	zend_push_function_call_entry(NULL, op_number TSRMLS_CC);
-	zend_do_extended_fcall_begin(TSRMLS_C);
+zend_string *zend_resolve_const_name(
+	zend_string *name, uint32_t type, zend_bool *is_fully_qualified TSRMLS_DC
+) {
+	return zend_resolve_non_class_name(
+		name, type, is_fully_qualified, 1, CG(current_import_const) TSRMLS_CC);
 }
-/* }}} */
 
-void zend_resolve_non_class_name(znode *element_name, zend_bool *check_namespace, zend_bool case_sensitive, HashTable *current_import_sub TSRMLS_DC) /* {{{ */
-{
-	znode tmp;
-	int len;
-	zval *ns;
-	zend_string *lookup_name;
-	char *compound = memchr(Z_STRVAL(element_name->u.constant), '\\', Z_STRLEN(element_name->u.constant));
-
-	if (Z_STRVAL(element_name->u.constant)[0] == '\\') {
-		/* name starts with \ so it is known and unambiguos, nothing to do here but shorten it */
-		memmove(Z_STRVAL(element_name->u.constant), Z_STRVAL(element_name->u.constant)+1, Z_STRLEN(element_name->u.constant));
-		--Z_STRLEN(element_name->u.constant);
-		return;
-	}
+zend_string *zend_resolve_class_name(
+	zend_string *name, uint32_t type TSRMLS_DC
+) {
+	char *compound;
 
-	if(!*check_namespace) {
-		return;
+	if (type == ZEND_NAME_RELATIVE) {
+		return zend_prefix_with_ns(name TSRMLS_CC);
 	}
 
-	if (current_import_sub) {
-		len = Z_STRLEN(element_name->u.constant);
-		if (case_sensitive) {
-			lookup_name = zend_string_init(Z_STRVAL(element_name->u.constant), len, 0);
+	if (type == ZEND_NAME_FQ || name->val[0] == '\\') {
+		/* Remove \ prefix (only relevant if this is a string rather than a label) */
+		if (name->val[0] == '\\') {
+			name = zend_string_init(name->val + 1, name->len - 1, 0);
 		} else {
-			lookup_name = zend_string_alloc(len, 0);
-			zend_str_tolower_copy(lookup_name->val, Z_STRVAL(element_name->u.constant), len);
-		}
-		/* Check if function/const matches imported name */
-		if ((ns = zend_hash_find(current_import_sub, lookup_name)) != NULL) {
-			zval_dtor(&element_name->u.constant);
-			ZVAL_DUP(&element_name->u.constant, ns);
-			zend_string_free(lookup_name);
-			*check_namespace = 0;
-			return;
+			zend_string_addref(name);
 		}
-		zend_string_free(lookup_name);
-	}
-
-	if (compound && CG(current_import)) {
-		len = compound - Z_STRVAL(element_name->u.constant);
-		/* namespace is always lowercase */
-		lookup_name = zend_string_alloc(len, 0);
-		zend_str_tolower_copy(lookup_name->val, Z_STRVAL(element_name->u.constant), len);
-		/* Check if first part of compound name is an import name */
-		if ((ns = zend_hash_find(CG(current_import), lookup_name)) != NULL) {
-			/* Substitute import name */
-			tmp.op_type = IS_CONST;
-			ZVAL_DUP(&tmp.u.constant, ns);
-			len += 1;
-			Z_STRLEN(element_name->u.constant) -= len;
-			memmove(Z_STRVAL(element_name->u.constant), Z_STRVAL(element_name->u.constant)+len, Z_STRLEN(element_name->u.constant)+1);
-			zend_do_build_namespace_name(&tmp, &tmp, element_name TSRMLS_CC);
-			*element_name = tmp;
-			zend_string_free(lookup_name);
-			*check_namespace = 0;
-			return;
+		/* Ensure that \self, \parent and \static are not used */
+		if (ZEND_FETCH_CLASS_DEFAULT != zend_get_class_fetch_type(name)) {
+			zend_error_noreturn(E_COMPILE_ERROR, "'\\%s' is an invalid class name", name->val);
 		}
-		zend_string_free(lookup_name);
-	}
-
-	if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
-		tmp = *element_name;
-		Z_STR(tmp.u.constant) = zend_string_alloc(sizeof("\\")-1 + Z_STRLEN(element_name->u.constant) + Z_STRLEN(CG(current_namespace)), 0);
-		Z_TYPE_FLAGS(tmp.u.constant) = IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE;
-		memcpy(Z_STRVAL(tmp.u.constant), Z_STRVAL(CG(current_namespace)), Z_STRLEN(CG(current_namespace)));
-		memcpy(&(Z_STRVAL(tmp.u.constant)[Z_STRLEN(CG(current_namespace))]), "\\", sizeof("\\")-1);
-		memcpy(&(Z_STRVAL(tmp.u.constant)[Z_STRLEN(CG(current_namespace)) + sizeof("\\")-1]), Z_STRVAL(element_name->u.constant), Z_STRLEN(element_name->u.constant)+1);
-		zend_string_release(Z_STR(element_name->u.constant));
-		*element_name = tmp;
+		return name;
 	}
-}
-/* }}} */
-
-void zend_resolve_function_name(znode *element_name, zend_bool *check_namespace TSRMLS_DC) /* {{{ */
-{
-	zend_resolve_non_class_name(element_name, check_namespace, 0, CG(current_import_function) TSRMLS_CC);
-}
-/* }}} */
-
-void zend_resolve_const_name(znode *element_name, zend_bool *check_namespace TSRMLS_DC) /* {{{ */
-{
-	zend_resolve_non_class_name(element_name, check_namespace, 1, CG(current_import_const) TSRMLS_CC);
-}
-/* }}} */
-
-void zend_do_resolve_class_name(znode *result, znode *class_name, int is_static TSRMLS_DC) /* {{{ */
-{
-	char *lcname;
-	int lctype;
-	znode constant_name;
 
-	lcname = zend_str_tolower_dup(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant));
-	lctype = zend_get_class_fetch_type(lcname, strlen(lcname));
-	switch (lctype) {
-		case ZEND_FETCH_CLASS_SELF:
-			if (!CG(active_class_entry)) {
-				zend_error_noreturn(E_COMPILE_ERROR, "Cannot access self::class when no class scope is active");
-			}
-			zval_dtor(&class_name->u.constant);
-			class_name->op_type = IS_CONST;
-			ZVAL_STR(&class_name->u.constant, zend_string_copy(CG(active_class_entry)->name));
-			*result = *class_name;
-			break;
-        case ZEND_FETCH_CLASS_STATIC:
-        case ZEND_FETCH_CLASS_PARENT:
-			if (is_static) {
-				zend_error_noreturn(E_COMPILE_ERROR,
-					"%s::class cannot be used for compile-time class name resolution",
-					lctype == ZEND_FETCH_CLASS_STATIC ? "static" : "parent"
-					);
-			}
-			if (!CG(active_class_entry)) {
-				zend_error_noreturn(E_COMPILE_ERROR,
-					"Cannot access %s::class when no class scope is active",
-					lctype == ZEND_FETCH_CLASS_STATIC ? "static" : "parent"
-					);
-			}
-			constant_name.op_type = IS_CONST;
-			ZVAL_STRINGL(&constant_name.u.constant, "class", sizeof("class")-1);
-			zend_do_fetch_constant(result, class_name, &constant_name, ZEND_RT, 1 TSRMLS_CC);
-			break;
-		case ZEND_FETCH_CLASS_DEFAULT:
-			zend_resolve_class_name(class_name TSRMLS_CC);
-			*result = *class_name;
-			break;
-	}
-
-	efree(lcname);
-
-}
-/* }}} */
-
-void zend_resolve_class_name(znode *class_name TSRMLS_DC) /* {{{ */
-{
-	char *compound;
-	zend_string *lcname;
-	zval *ns;
-	znode tmp;
-	int len;
-
-	compound = memchr(Z_STRVAL(class_name->u.constant), '\\', Z_STRLEN(class_name->u.constant));
-	if (compound) {
-		/* This is a compound class name that contains namespace prefix */
-		if (Z_STRVAL(class_name->u.constant)[0] == '\\') {
-			/* The STRING name has "\" prefix */
-			memmove(Z_STRVAL(class_name->u.constant), Z_STRVAL(class_name->u.constant)+1, Z_STRLEN(class_name->u.constant));
-			Z_STR(class_name->u.constant) = zend_string_realloc(
-				Z_STR(class_name->u.constant),
-				Z_STRLEN(class_name->u.constant) - 1, 0);
-			Z_TYPE_FLAGS(class_name->u.constant) = IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE;
-
-			if (ZEND_FETCH_CLASS_DEFAULT != zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant))) {
-				zend_error_noreturn(E_COMPILE_ERROR, "'\\%s' is an invalid class name", Z_STRVAL(class_name->u.constant));
+	if (CG(current_import)) {
+		compound = memchr(name->val, '\\', name->len);
+		if (compound) {
+			/* If the first part of a qualified name is an alias, substitute it. */
+			size_t len = compound - name->val;
+			zend_string *import_name = zend_hash_find_ptr_lc(CG(current_import), name->val, len);
+
+			if (import_name) {
+				return zend_concat_names(
+					import_name->val, import_name->len, name->val + len + 1, name->len - len - 1);
 			}
 		} else {
-			if (CG(current_import)) {
-				len = compound - Z_STRVAL(class_name->u.constant);
-				lcname = zend_string_alloc(len, 0);
-				zend_str_tolower_copy(lcname->val, Z_STRVAL(class_name->u.constant), len);
-				/* Check if first part of compound name is an import name */
-				if ((ns = zend_hash_find(CG(current_import), lcname)) != NULL) {
-					/* Substitute import name */
-					tmp.op_type = IS_CONST;
-					ZVAL_DUP(&tmp.u.constant, ns);
-					len += 1;
-					Z_STRLEN(class_name->u.constant) -= len;
-					memmove(Z_STRVAL(class_name->u.constant), Z_STRVAL(class_name->u.constant)+len, Z_STRLEN(class_name->u.constant)+1);
-					zend_do_build_namespace_name(&tmp, &tmp, class_name TSRMLS_CC);
-					*class_name = tmp;
-					zend_string_free(lcname);
-					return;
-				}
-				zend_string_free(lcname);
-			}
-			/* Here name is not prefixed with \ and not imported */
-			if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
-				tmp.op_type = IS_CONST;
-				ZVAL_DUP(&tmp.u.constant, &CG(current_namespace));
-				zend_do_build_namespace_name(&tmp, &tmp, class_name TSRMLS_CC);
-				*class_name = tmp;
+			/* If an unqualified name is an alias, replace it. */
+			zend_string *import_name
+				= zend_hash_find_ptr_lc(CG(current_import), name->val, name->len);
+
+			if (import_name) {
+				return zend_string_copy(import_name);
 			}
 		}
-	} else if (CG(current_import) || Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
-		/* this is a plain name (without \) */
-		lcname = zend_string_alloc(Z_STRLEN(class_name->u.constant), 0);
-		zend_str_tolower_copy(lcname->val, Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant));
-
-		if (CG(current_import) &&
-		    (ns = zend_hash_find(CG(current_import), lcname)) != NULL) {
-		    /* The given name is an import name. Substitute it. */
-			zval_dtor(&class_name->u.constant);
-			ZVAL_DUP(&class_name->u.constant, ns);
-		} else if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
-			/* plain name, no import - prepend current namespace to it */
-			tmp.op_type = IS_CONST;
-			ZVAL_DUP(&tmp.u.constant, &CG(current_namespace));
-			zend_do_build_namespace_name(&tmp, &tmp, class_name TSRMLS_CC);
-			*class_name = tmp;
-		}
-		zend_string_free(lcname);
 	}
-}
-/* }}} */
-
-void zend_do_fetch_class(znode *result, znode *class_name TSRMLS_DC) /* {{{ */
-{
-	zend_long fetch_class_op_number;
-	zend_op *opline;
-
-	fetch_class_op_number = get_next_op_number(CG(active_op_array));
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
-	opline->opcode = ZEND_FETCH_CLASS;
-	SET_UNUSED(opline->op1);
-	opline->extended_value = ZEND_FETCH_CLASS_DEFAULT;
-	CG(catch_begin) = fetch_class_op_number;
-	if (class_name->op_type == IS_CONST) {
-		int fetch_type;
+	/* If not fully qualified and not an alias, prepend the current namespace */
+	return zend_prefix_with_ns(name TSRMLS_CC);
+}
 
-		fetch_type = zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant));
-		switch (fetch_type) {
-			case ZEND_FETCH_CLASS_SELF:
-			case ZEND_FETCH_CLASS_PARENT:
-			case ZEND_FETCH_CLASS_STATIC:
-				SET_UNUSED(opline->op2);
-				opline->extended_value = fetch_type;
-				zval_dtor(&class_name->u.constant);
-				break;
-			default:
-				zend_resolve_class_name(class_name TSRMLS_CC);
-				opline->op2_type = IS_CONST;
-				opline->op2.constant =
-					zend_add_class_name_literal(CG(active_op_array), &class_name->u.constant TSRMLS_CC);
-				break;
-		}
-	} else {
-		SET_NODE(opline->op2, class_name);
-	}
-	opline->result.var = get_temporary_variable(CG(active_op_array));
-	opline->result_type = IS_VAR; /* FIXME: Hack so that INIT_FCALL_BY_NAME still knows this is a class */
-	GET_NODE(result, opline->result);
-	result->EA = opline->extended_value;
+zend_string *zend_resolve_class_name_ast(zend_ast *ast TSRMLS_DC) {
+	zend_string *name = zend_ast_get_str(ast);
+	return zend_resolve_class_name(name, ast->attr TSRMLS_CC);
 }
-/* }}} */
 
 static void ptr_dtor(zval *zv) /* {{{ */
 {
@@ -2343,26 +812,9 @@ static void ptr_dtor(zval *zv) /* {{{ */
 }
 /* }}} */
 
-void zend_do_label(znode *label TSRMLS_DC) /* {{{ */
-{
-	zend_label dest;
-
-	if (!CG(context).labels) {
-		ALLOC_HASHTABLE(CG(context).labels);
-		zend_hash_init(CG(context).labels, 8, NULL, ptr_dtor, 0);
-	}
-
-	dest.brk_cont = CG(context).current_brk_cont;
-	dest.opline_num = get_next_op_number(CG(active_op_array));
-
-	if (zend_hash_add_mem(CG(context).labels, Z_STR(label->u.constant), &dest, sizeof(zend_label)) == NULL) {
-		zend_error_noreturn(E_COMPILE_ERROR, "Label '%s' already defined", Z_STRVAL(label->u.constant));
-	}
-
-	/* Done with label now */
-	zval_dtor(&label->u.constant);
+static void str_dtor(zval *zv) {
+	zend_string_release(Z_STR_P(zv));
 }
-/* }}} */
 
 void zend_resolve_goto_label(zend_op_array *op_array, zend_op *opline, int pass2 TSRMLS_DC) /* {{{ */
 {
@@ -2424,18 +876,6 @@ void zend_resolve_goto_label(zend_op_array *op_array, zend_op *opline, int pass2
 }
 /* }}} */
 
-void zend_do_goto(znode *label TSRMLS_DC) /* {{{ */
-{
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-
-	opline->opcode = ZEND_GOTO;
-	opline->extended_value = CG(context).current_brk_cont;
-	SET_UNUSED(opline->op1);
-	SET_NODE(opline->op2, label);
-	zend_resolve_goto_label(CG(active_op_array), opline, 0 TSRMLS_CC);
-}
-/* }}} */
-
 void zend_release_labels(int temporary TSRMLS_DC) /* {{{ */
 {
 	if (CG(context).labels) {
@@ -2451,658 +891,7 @@ void zend_release_labels(int temporary TSRMLS_DC) /* {{{ */
 }
 /* }}} */
 
-void zend_do_build_full_name(znode *result, znode *prefix, znode *name, int is_class_member TSRMLS_DC) /* {{{ */
-{
-	uint32_t length;
-
-	if (!result) {
-		result = prefix;
-	} else {
-		*result = *prefix;
-	}
-
-	if (is_class_member) {
-		int old_len = Z_STRLEN(result->u.constant);
-		length = sizeof("::")-1 + old_len + Z_STRLEN(name->u.constant);
-		Z_STR(result->u.constant) = zend_string_realloc(Z_STR(result->u.constant), length, 0);
-		Z_TYPE_FLAGS(result->u.constant) = IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE;
-		memcpy(&Z_STRVAL(result->u.constant)[old_len], "::", sizeof("::")-1);
-		memcpy(&Z_STRVAL(result->u.constant)[old_len + sizeof("::")-1], Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant)+1);
-		zend_string_release(Z_STR(name->u.constant));
-	} else {
-		int old_len = Z_STRLEN(result->u.constant);
-		length = sizeof("\\")-1 + old_len + Z_STRLEN(name->u.constant);
-		Z_STR(result->u.constant) = zend_string_realloc(Z_STR(result->u.constant), length, 0);
-		Z_TYPE_FLAGS(result->u.constant) = IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE;
-		memcpy(&Z_STRVAL(result->u.constant)[old_len], "\\", sizeof("\\")-1);
-		memcpy(&Z_STRVAL(result->u.constant)[old_len + sizeof("\\")-1], Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant)+1);
-		zend_string_release(Z_STR(name->u.constant));
-	}
-}
-/* }}} */
-
-int zend_do_begin_class_member_function_call(znode *class_name, znode *method_name TSRMLS_DC) /* {{{ */
-{
-	znode class_node;
-	uint32_t op_number;
-	zend_op *opline;
-
-	if (method_name->op_type == IS_CONST) {
-		char *lcname;
-		if (Z_TYPE(method_name->u.constant) != IS_STRING) {
-			zend_error_noreturn(E_COMPILE_ERROR, "Method name must be a string");
-		}
-		lcname = zend_str_tolower_dup(Z_STRVAL(method_name->u.constant), Z_STRLEN(method_name->u.constant));
-		if ((sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)-1) == Z_STRLEN(method_name->u.constant) &&
-		    memcmp(lcname, ZEND_CONSTRUCTOR_FUNC_NAME, sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)-1) == 0) {
-			zval_dtor(&method_name->u.constant);
-			method_name->op_type = IS_UNUSED;
-		}
-		efree(lcname);
-	}
-
-	if (class_name->op_type == IS_CONST &&
-	    ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant))) {
-		zend_resolve_class_name(class_name TSRMLS_CC);
-		class_node = *class_name;
-		op_number = get_next_op_number(CG(active_op_array));
-		opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	} else {
-		zend_do_fetch_class(&class_node, class_name TSRMLS_CC);
-		op_number = get_next_op_number(CG(active_op_array));
-		opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	}
-	opline->opcode = ZEND_INIT_STATIC_METHOD_CALL;
-	if (class_node.op_type == IS_CONST) {
-		opline->op1_type = IS_CONST;
-		opline->op1.constant =
-			zend_add_class_name_literal(CG(active_op_array), &class_node.u.constant TSRMLS_CC);
-	} else {
-		SET_NODE(opline->op1, &class_node);
-	}
-	if (method_name->op_type == IS_CONST) {
-		opline->op2_type = IS_CONST;
-		opline->op2.constant =
-			zend_add_func_name_literal(CG(active_op_array), &method_name->u.constant TSRMLS_CC);
-		if (opline->op1_type == IS_CONST) {
-			GET_CACHE_SLOT(opline->op2.constant);
-		} else {
-			GET_POLYMORPHIC_CACHE_SLOT(opline->op2.constant);
-		}
-	} else {
-		SET_NODE(opline->op2, method_name);
-	}
-
-	zend_push_function_call_entry(NULL, op_number TSRMLS_CC);
-	zend_do_extended_fcall_begin(TSRMLS_C);
-	return 1; /* Dynamic */
-}
-/* }}} */
-
-static int zend_do_convert_call(zend_op *init_opline, zend_op *opline, zend_long num_args, zend_function **func_ptr TSRMLS_DC)  /* {{{ */
-{
-	zval *function_name;
-	zend_string *lcname;
-	zend_function *function;
-
-	*func_ptr = NULL;
-	if (opline->op1_type == IS_CONST && Z_TYPE(CONSTANT(opline->op1.constant)) == IS_STRING) {
- 		function_name = &CONSTANT(opline->op1.constant);
-		lcname = zend_string_alloc(Z_STRLEN_P(function_name), 0);
-		zend_str_tolower_copy(lcname->val, Z_STRVAL_P(function_name), Z_STRLEN_P(function_name));
-		if (((function = zend_hash_find_ptr(CG(function_table), lcname)) == NULL) ||
-		 	((CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_FUNCTIONS) &&
-		 	(function->type == ZEND_INTERNAL_FUNCTION))) {
-			function = NULL;
-			zend_string_release(lcname);
-			opline->opcode = ZEND_INIT_USER_CALL;
-			opline->extended_value = num_args;
-			opline->op2_type = opline->op1_type;
-			opline->op2 = opline->op1;
-			opline->op1_type = IS_CONST;
-			opline->op1 = init_opline->op2;
-			SET_UNUSED(opline->result);
-			MAKE_NOP(init_opline);
-			return 1;
-		} else {
-			zend_string_release(Z_STR_P(function_name));
-			Z_STR_P(function_name) = zend_new_interned_string(lcname TSRMLS_CC);
-			opline->opcode = ZEND_INIT_FCALL;
-			opline->extended_value = num_args;
-			opline->op2_type = IS_CONST;
-			opline->op2.constant = opline->op1.constant;
-			GET_CACHE_SLOT(opline->op2.constant);
-			SET_UNUSED(opline->op1);
-			SET_UNUSED(opline->result);								
-			MAKE_NOP(init_opline);
-			*func_ptr = function;
-			return 1;
-		}
-	} else {
-		opline->opcode = ZEND_INIT_USER_CALL;
-		opline->extended_value = num_args;
-		opline->op2_type = opline->op1_type;
-		opline->op2 = opline->op1;
-		opline->op1_type = IS_CONST;
-		opline->op1 = init_opline->op2;
-		SET_UNUSED(opline->result);
-		MAKE_NOP(init_opline);
-		return 1;
-	}
-	return 0;
-}
-/* }}} */
-
-static int zend_do_convert_call_user_func(zend_op *init_opline, uint32_t num_args TSRMLS_DC) /* {{{ */
-{
-	zend_op *opline = init_opline + 1;
-	int level = 0;
-	int converted = 0;
-	uint32_t arg_num = 0;
-	zend_function *func = NULL;
-
-	while (1) {
-		switch (opline->opcode) {
-			case ZEND_SEND_VAL:
-			case ZEND_SEND_VAL_EX:
-			case ZEND_SEND_VAR:
-			case ZEND_SEND_VAR_EX:
-			case ZEND_SEND_VAR_NO_REF:
-			case ZEND_SEND_REF:
-			case ZEND_SEND_UNPACK:
-				if (level == 0) {
-					if (!converted) {
-						if (opline->opcode == ZEND_SEND_UNPACK) {
-							return 0;
-						}
-						if (!zend_do_convert_call(init_opline, opline, init_opline->extended_value - 1, &func TSRMLS_CC)) {
-							return 0;
-						}
-						converted = 1;
-					} else {
-						/* Use ZEND_SEND_USER instruction for parameters that may pass by reference */
-						if (opline->opcode != ZEND_SEND_VAL &&
-						    (func == NULL || 
-						     ARG_SHOULD_BE_SENT_BY_REF(func, opline->op2.num-1))) {
-							opline->opcode = ZEND_SEND_USER;
-						}
-						opline->op2.num--;
-					}
-					if (++arg_num == num_args) {
-						return 1;
-					}
-				}
-				break;
-			case ZEND_INIT_FCALL_BY_NAME:
-			case ZEND_INIT_NS_FCALL_BY_NAME:
-			case ZEND_NEW:
-			case ZEND_INIT_METHOD_CALL:
-			case ZEND_INIT_STATIC_METHOD_CALL:
-			case ZEND_INIT_FCALL:
-				level++;
-				break;
-			case ZEND_DO_FCALL:
-				level--;
-				break;
-		}
-		opline++;
-	}
-}
-/* }}} */
-
-static int zend_do_convert_call_user_func_array(zend_op *init_opline TSRMLS_DC) /* {{{ */
-{
-	zend_op *opline = init_opline + 1;
-	zend_op *send1 = NULL, *send2 = NULL;
-	int level = 0;
-	zend_function *func;
-
-	do {
-		switch (opline->opcode) {
-			case ZEND_SEND_VAL:
-			case ZEND_SEND_VAL_EX:
-			case ZEND_SEND_VAR:
-			case ZEND_SEND_VAR_EX:
-			case ZEND_SEND_VAR_NO_REF:
-			case ZEND_SEND_REF:
-			case ZEND_SEND_UNPACK:
-				if (level == 0) {
-					if (opline->opcode == ZEND_SEND_UNPACK) {
-						return 0;
-					}
-					if (send1 == NULL) {
-						send1 = opline;
-					} else {
-						send2 = opline;
-					}
-				}
-				break;
-			case ZEND_INIT_FCALL_BY_NAME:
-			case ZEND_INIT_NS_FCALL_BY_NAME:
-			case ZEND_NEW:
-			case ZEND_INIT_METHOD_CALL:
-			case ZEND_INIT_STATIC_METHOD_CALL:
-			case ZEND_INIT_FCALL:
-				level++;
-				break;
-			case ZEND_DO_FCALL:
-				level--;
-				break;
-		}
-		opline++;
-	} while (send2 == NULL);
-
-	if (!zend_do_convert_call(init_opline, send1, 0, &func TSRMLS_CC)) {
-		return 0;
-	}
-
-	send2->opcode = ZEND_SEND_ARRAY;
-	send2->extended_value = 0;
-	send2->op2.num--;
-	return 1;
-}
-/* }}} */
-
-static int zend_do_convert_strlen(zend_op *init_opline, znode *result TSRMLS_DC) /* {{{ */
-{
-	zend_op *opline = init_opline + 1;
-	zend_op *send = NULL;
-	int level = 0;
-
-	do {
-		switch (opline->opcode) {
-			case ZEND_SEND_VAL:
-			case ZEND_SEND_VAL_EX:
-			case ZEND_SEND_VAR:
-			case ZEND_SEND_VAR_EX:
-			case ZEND_SEND_VAR_NO_REF:
-			case ZEND_SEND_REF:
-			case ZEND_SEND_UNPACK:
-				if (level == 0) {
-					if (opline->opcode == ZEND_SEND_UNPACK) {
-						return 0;
-					}
-					send = opline;
-				}
-				break;
-			case ZEND_INIT_FCALL_BY_NAME:
-			case ZEND_INIT_NS_FCALL_BY_NAME:
-			case ZEND_NEW:
-			case ZEND_INIT_METHOD_CALL:
-			case ZEND_INIT_STATIC_METHOD_CALL:
-			case ZEND_INIT_FCALL:
-				level++;
-				break;
-			case ZEND_DO_FCALL:
-				level--;
-				break;
-		}
-		opline++;
-	} while (send == NULL);
-
-	MAKE_NOP(init_opline);
-	send->opcode = ZEND_STRLEN;
-	send->extended_value = 0;
-	SET_UNUSED(send->op2);
-	send->result.var = get_temporary_variable(CG(active_op_array));
-	send->result_type = IS_TMP_VAR;
-	GET_NODE(result, send->result);
-	return 1;
-}
-/* }}} */
-
-static int zend_do_convert_type_check(zend_op *init_opline, znode *result, uint32_t type TSRMLS_DC) /* {{{ */
-{
-	zend_op *opline = init_opline + 1;
-	zend_op *send = NULL;
-	int level = 0;
-
-	do {
-		switch (opline->opcode) {
-			case ZEND_SEND_VAL:
-			case ZEND_SEND_VAL_EX:
-			case ZEND_SEND_VAR:
-			case ZEND_SEND_VAR_EX:
-			case ZEND_SEND_VAR_NO_REF:
-			case ZEND_SEND_REF:
-			case ZEND_SEND_UNPACK:
-				if (level == 0) {
-					if (opline->opcode == ZEND_SEND_UNPACK) {
-						return 0;
-					}
-					send = opline;
-				}
-				break;
-			case ZEND_INIT_FCALL_BY_NAME:
-			case ZEND_INIT_NS_FCALL_BY_NAME:
-			case ZEND_NEW:
-			case ZEND_INIT_METHOD_CALL:
-			case ZEND_INIT_STATIC_METHOD_CALL:
-			case ZEND_INIT_FCALL:
-				level++;
-				break;
-			case ZEND_DO_FCALL:
-				level--;
-				break;
-		}
-		opline++;
-	} while (send == NULL);
-
-	MAKE_NOP(init_opline);
-	send->opcode = ZEND_TYPE_CHECK;
-	send->extended_value = type;
-	SET_UNUSED(send->op2);
-	send->result.var = get_temporary_variable(CG(active_op_array));
-	send->result_type = IS_TMP_VAR;
-	GET_NODE(result, send->result);
-	return 1;
-}
-/* }}} */
-
-static int zend_do_convert_defined(zend_op *init_opline, znode *result TSRMLS_DC) /* {{{ */
-{
-	zval c;
-	zend_string *lc_name;
-	zend_op *opline = init_opline + 1;
-
-	if (opline->opcode != ZEND_SEND_VAL ||
-		opline->op1_type != IS_CONST ||
-		Z_TYPE(CONSTANT(opline->op1.constant)) != IS_STRING
-		|| zend_memrchr(Z_STRVAL(CONSTANT(opline->op1.constant)), '\\', Z_STRLEN(CONSTANT(opline->op1.constant))) != NULL
-		|| zend_memrchr(Z_STRVAL(CONSTANT(opline->op1.constant)), ':', Z_STRLEN(CONSTANT(opline->op1.constant))) != NULL) {
-		return 0;
-	}
-
-	MAKE_NOP(init_opline);
-	opline->opcode = ZEND_DEFINED;
-	opline->extended_value = 0;
-	GET_CACHE_SLOT(opline->op1.constant);
-	/* lowcase constant name */
-	lc_name = zend_string_alloc(Z_STRLEN(CONSTANT(opline->op1.constant)), 0);
-	zend_str_tolower_copy(lc_name->val, Z_STRVAL(CONSTANT(opline->op1.constant)), Z_STRLEN(CONSTANT(opline->op1.constant)));
-	ZVAL_NEW_STR(&c, lc_name);
-	zend_add_literal(CG(active_op_array), &c TSRMLS_CC);
-	opline->result.var = get_temporary_variable(CG(active_op_array));
-	opline->result_type = IS_TMP_VAR;
-	GET_NODE(result, opline->result);
-	return 1;
-}
-/* }}} */
-
-void zend_do_end_function_call(znode *function_name, znode *result, int is_method, int is_dynamic_fcall TSRMLS_DC) /* {{{ */
-{
-	zend_op *opline;
-	zend_function_call_entry *fcall = zend_stack_top(&CG(function_call_stack));
-
-	if (is_method && function_name && function_name->op_type == IS_UNUSED) {
-		/* clone */
-		if (fcall->arg_num != 0) {
-			zend_error(E_WARNING, "Clone method does not require arguments");
-		}
-		opline = &CG(active_op_array)->opcodes[Z_LVAL(function_name->u.constant)];
-	} else {
-		uint32_t call_flags = 0;
-
-		opline = &CG(active_op_array)->opcodes[fcall->op_number];
-		opline->extended_value = fcall->arg_num;
-
-		if (opline->opcode == ZEND_NEW) {
-			call_flags = ZEND_CALL_CTOR;
-		} else {
-			zend_function *func = fcall->fbc;
-			if (func && func->type == ZEND_INTERNAL_FUNCTION) {
-				/* Convert calls to some internal functions into built-ins */
-				if (func->common.function_name->len == sizeof("call_user_func")-1 &&
-				    memcmp(func->common.function_name->val, "call_user_func", sizeof("call_user_func")-1) == 0) {
-					if (fcall->arg_num > 0) {
-						if (zend_do_convert_call_user_func(opline, fcall->arg_num TSRMLS_CC)) {
-							fcall->arg_num--;
-						}
-					}
-				} else if (func->common.function_name->len == sizeof("call_user_func_array")-1 &&
-				           memcmp(func->common.function_name->val, "call_user_func_array", sizeof("call_user_func_array")-1) == 0) {
-					if (fcall->arg_num == 2) {
-						if (zend_do_convert_call_user_func_array(opline TSRMLS_CC)) {
-							fcall->arg_num = 0;
-						}
-					}
-				} else if (func->common.function_name->len == sizeof("defined")-1 &&
-				           memcmp(func->common.function_name->val, "defined", sizeof("defined")-1) == 0) {
-					if (fcall->arg_num == 1) {
-						if (zend_do_convert_defined(opline, result TSRMLS_CC)) {
-							zend_stack_del_top(&CG(function_call_stack));
-							return;
-						}
-					}
-				} else if ((CG(compiler_options) & ZEND_COMPILE_NO_BUILTIN_STRLEN) == 0 &&
-				           func->common.function_name->len == sizeof("strlen")-1 &&
-				           memcmp(func->common.function_name->val, "strlen", sizeof("strlen")-1) == 0) {
-					if (fcall->arg_num == 1) {
-						if (zend_do_convert_strlen(opline, result TSRMLS_CC)) {
-							zend_stack_del_top(&CG(function_call_stack));
-							return;
-						}
-					}
-				} else if (func->common.function_name->len == sizeof("is_null")-1 &&
-						memcmp(func->common.function_name->val, "is_null", sizeof("is_null")-1) == 0) {
-					if (fcall->arg_num == 1) {
-						if (zend_do_convert_type_check(opline, result, IS_NULL TSRMLS_CC)) {
-							zend_stack_del_top(&CG(function_call_stack));
-							return;
-						}
-					}
-				} else if (func->common.function_name->len == sizeof("is_bool")-1 &&
-						memcmp(func->common.function_name->val, "is_bool", sizeof("is_bool")-1) == 0) {
-					if (fcall->arg_num == 1) {
-						if (zend_do_convert_type_check(opline, result, _IS_BOOL TSRMLS_CC)) {
-							zend_stack_del_top(&CG(function_call_stack));
-							return;
-						}
-					}
-				} else if (func->common.function_name->len == sizeof("is_long")-1 &&
-						memcmp(func->common.function_name->val, "is_long", sizeof("is_long")-1) == 0) {
-					if (fcall->arg_num == 1) {
-						if (zend_do_convert_type_check(opline, result, IS_LONG TSRMLS_CC)) {
-							zend_stack_del_top(&CG(function_call_stack));
-							return;
-						}
-					}
-				} else if (func->common.function_name->len == sizeof("is_float")-1 &&
-						memcmp(func->common.function_name->val, "is_float", sizeof("is_float")-1) == 0) {
-					if (fcall->arg_num == 1) {
-						if (zend_do_convert_type_check(opline, result, IS_DOUBLE TSRMLS_CC)) {
-							zend_stack_del_top(&CG(function_call_stack));
-							return;
-						}
-					}
-				} else if (func->common.function_name->len == sizeof("is_string")-1 &&
-						memcmp(func->common.function_name->val, "is_string", sizeof("is_string")-1) == 0) {
-					if (fcall->arg_num == 1) {
-						if (zend_do_convert_type_check(opline, result, IS_STRING TSRMLS_CC)) {
-							zend_stack_del_top(&CG(function_call_stack));
-							return;
-						}
-					}
-				} else if (func->common.function_name->len == sizeof("is_array")-1 &&
-						memcmp(func->common.function_name->val, "is_array", sizeof("is_array")-1) == 0) {
-					if (fcall->arg_num == 1) {
-						if (zend_do_convert_type_check(opline, result, IS_ARRAY TSRMLS_CC)) {
-							zend_stack_del_top(&CG(function_call_stack));
-							return;
-						}
-					}
-				} else if (func->common.function_name->len == sizeof("is_object")-1 &&
-						memcmp(func->common.function_name->val, "is_object", sizeof("is_object")-1) == 0) {
-					if (fcall->arg_num == 1) {
-						if (zend_do_convert_type_check(opline, result, IS_OBJECT TSRMLS_CC)) {
-							zend_stack_del_top(&CG(function_call_stack));
-							return;
-						}
-					}
-				} else if (func->common.function_name->len == sizeof("is_resouce")-1 &&
-						memcmp(func->common.function_name->val, "is_resource", sizeof("is_resource")-1) == 0) {
-					if (fcall->arg_num == 1) {
-						if (zend_do_convert_type_check(opline, result, IS_RESOURCE TSRMLS_CC)) {
-							zend_stack_del_top(&CG(function_call_stack));
-							return;
-						}
-					}
-				}
-			}
-		}
-
-		opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-		opline->opcode = ZEND_DO_FCALL;
-		SET_UNUSED(opline->op1);
-		SET_UNUSED(opline->op2);
-		opline->op1.num = call_flags;
-	}
-
-	opline->result.var = get_temporary_variable(CG(active_op_array));
-	opline->result_type = IS_VAR;
-	GET_NODE(result, opline->result);
-	opline->extended_value = fcall->arg_num;
-
-	zend_stack_del_top(&CG(function_call_stack));
-}
-/* }}} */
-
-void zend_do_pass_param(znode *param, zend_uchar op TSRMLS_DC) /* {{{ */
-{
-	zend_op *opline;
-	int original_op = op;
-	zend_function_call_entry *fcall = zend_stack_top(&CG(function_call_stack));
-	zend_function *function_ptr = fcall->fbc;
-	int send_by_reference = 0;
-	int send_function = 0;
-
-	fcall->arg_num++;
-
-	if (fcall->uses_argument_unpacking) {
-		zend_error_noreturn(E_COMPILE_ERROR,
-			"Cannot use positional argument after argument unpacking");
-	}
-
-	if (op == ZEND_SEND_VAR && (param->op_type & (IS_CONST|IS_TMP_VAR))) {
-		/* Function call was converted into builtin instruction */
-		zend_llist *fetch_list_ptr = zend_stack_top(&CG(bp_stack));
-		zend_llist_destroy(fetch_list_ptr);
-		zend_stack_del_top(&CG(bp_stack));
-		original_op = op = ZEND_SEND_VAL;
-	}
-
-	if (original_op == ZEND_SEND_REF) {
-		if (function_ptr &&
-		    function_ptr->common.function_name &&
-		    function_ptr->common.type == ZEND_USER_FUNCTION &&
-		    !ARG_SHOULD_BE_SENT_BY_REF(function_ptr, fcall->arg_num)) {
-			zend_error_noreturn(E_COMPILE_ERROR,
-						"Call-time pass-by-reference has been removed; "
-						"If you would like to pass argument by reference, modify the declaration of %s().",
-						function_ptr->common.function_name->val);
-		} else {
-			zend_error_noreturn(E_COMPILE_ERROR, "Call-time pass-by-reference has been removed");
-		}
-		return;
-	}
-
-	if (function_ptr) {
-		if (ARG_MAY_BE_SENT_BY_REF(function_ptr, fcall->arg_num)) {
-			if (op == ZEND_SEND_VAR && param->op_type & (IS_VAR|IS_CV)) {
-				send_by_reference = ZEND_ARG_SEND_BY_REF;
-				if (zend_is_function_or_method_call(param)) {
-					/* Method call */
-					op = ZEND_SEND_VAR_NO_REF;
-					send_function = ZEND_ARG_SEND_FUNCTION | ZEND_ARG_SEND_SILENT;
-				}
-			} else {
-				op = ZEND_SEND_VAL;
-			}
-		} else if (ARG_SHOULD_BE_SENT_BY_REF(function_ptr, fcall->arg_num)) {
-			send_by_reference = ZEND_ARG_SEND_BY_REF;
-		}
-	}
-
-	if (op == ZEND_SEND_VAR && zend_is_function_or_method_call(param)) {
-		/* Method call */
-		op = ZEND_SEND_VAR_NO_REF;
-		send_function = ZEND_ARG_SEND_FUNCTION;
-	} else if (op == ZEND_SEND_VAL && (param->op_type & (IS_VAR|IS_CV))) {
-		op = ZEND_SEND_VAR_NO_REF;
-	}
-
-	if (op!=ZEND_SEND_VAR_NO_REF && send_by_reference==ZEND_ARG_SEND_BY_REF) {
-		/* change to passing by reference */
-		switch (param->op_type) {
-			case IS_VAR:
-			case IS_CV:
-				op = ZEND_SEND_REF;
-				break;
-			default:
-				zend_error_noreturn(E_COMPILE_ERROR, "Only variables can be passed by reference");
-				break;
-		}
-	}
-
-	if (original_op == ZEND_SEND_VAR) {
-		switch (op) {
-			case ZEND_SEND_VAR_NO_REF:
-				zend_do_end_variable_parse(param, BP_VAR_R, 0 TSRMLS_CC);
-				break;
-			case ZEND_SEND_VAR:
-				if (function_ptr) {
-					zend_do_end_variable_parse(param, BP_VAR_R, 0 TSRMLS_CC);
-				} else {
-					zend_do_end_variable_parse(param, BP_VAR_FUNC_ARG, fcall->arg_num TSRMLS_CC);
-				}
-				break;
-			case ZEND_SEND_REF:
-				zend_do_end_variable_parse(param, BP_VAR_W, 0 TSRMLS_CC);
-				break;
-		}
-	}
-
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-
-	if (op == ZEND_SEND_VAR_NO_REF) {
-		if (function_ptr) {
-			opline->extended_value = ZEND_ARG_COMPILE_TIME_BOUND | send_by_reference | send_function;
-		} else {
-			opline->extended_value = send_function;
-		}
-	} else {
-		if (!function_ptr) {
-			switch (op) {
-				case ZEND_SEND_VAL:
-					op = ZEND_SEND_VAL_EX;
-					break;
-				case ZEND_SEND_VAR:
-					op = ZEND_SEND_VAR_EX;
-					break;
-			}
-		}
-	}
-	opline->opcode = op;
-	SET_NODE(opline->op1, param);
-	opline->op2.opline_num = fcall->arg_num;
-	SET_UNUSED(opline->op2);
-}
-/* }}} */
-
-void zend_do_unpack_params(znode *params TSRMLS_DC) /* {{{ */
-{
-	zend_op *opline;
-	zend_function_call_entry *fcall = zend_stack_top(&CG(function_call_stack));
-
-	fcall->uses_argument_unpacking = 1;
-
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	opline->opcode = ZEND_SEND_UNPACK;
-	SET_NODE(opline->op1, params);
-	SET_UNUSED(opline->op2);
-	opline->op2.num = fcall->arg_num;
-}
-/* }}} */
+static zend_bool zend_is_call(zend_ast *ast);
 
 static int generate_free_switch_expr(zend_switch_entry *switch_entry TSRMLS_DC) /* {{{ */
 {
@@ -3141,292 +930,25 @@ static int generate_free_foreach_copy(const zend_op *foreach_copy TSRMLS_DC) /*
 }
 /* }}} */
 
-void zend_do_return(znode *expr, int do_end_vparse TSRMLS_DC) /* {{{ */
-{
-	zend_op *opline;
-	int start_op_number, end_op_number;
-	zend_bool returns_reference = (CG(active_op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0;
-
-	/* The error for use of return inside a generator is thrown in pass_two. */
-
-	if (do_end_vparse) {
-		if (returns_reference && !zend_is_function_or_method_call(expr)) {
-			zend_do_end_variable_parse(expr, BP_VAR_W, 1 TSRMLS_CC);
-		} else {
-			zend_do_end_variable_parse(expr, BP_VAR_R, 0 TSRMLS_CC);
-		}
-	}
-
-	start_op_number = get_next_op_number(CG(active_op_array));
-
-#ifdef ZTS
-	zend_stack_apply_with_argument(&CG(switch_cond_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element, void *)) generate_free_switch_expr TSRMLS_CC);
-	zend_stack_apply_with_argument(&CG(foreach_copy_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element, void *)) generate_free_foreach_copy TSRMLS_CC);
-#else
-	zend_stack_apply(&CG(switch_cond_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element)) generate_free_switch_expr);
-	zend_stack_apply(&CG(foreach_copy_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element)) generate_free_foreach_copy);
-#endif
-
-	end_op_number = get_next_op_number(CG(active_op_array));
-	while (start_op_number < end_op_number) {
-		CG(active_op_array)->opcodes[start_op_number].extended_value |= EXT_TYPE_FREE_ON_RETURN;
-		start_op_number++;
-	}
-
-	if (CG(context).in_finally) {
-		opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-		opline->opcode = ZEND_DISCARD_EXCEPTION;
-		SET_UNUSED(opline->op1);
-		SET_UNUSED(opline->op2);
-	}
-
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-
-	opline->opcode = returns_reference ? ZEND_RETURN_BY_REF : ZEND_RETURN;
-
-	if (expr) {
-		SET_NODE(opline->op1, expr);
-
-		if (!do_end_vparse) {
-			opline->extended_value = ZEND_RETURNS_VALUE;
-		} else if (zend_is_function_or_method_call(expr)) {
-			opline->extended_value = ZEND_RETURNS_FUNCTION;
-		}
-	} else {
-		opline->op1_type = IS_CONST;
-		LITERAL_NULL(opline->op1);
-	}
-
-	SET_UNUSED(opline->op2);
-}
-/* }}} */
-
-void zend_do_yield(znode *result, znode *value, znode *key, zend_bool is_variable TSRMLS_DC) /* {{{ */
+static uint32_t zend_add_try_element(uint32_t try_op TSRMLS_DC) /* {{{ */
 {
-	zend_op *opline;
-
-	if (!CG(active_op_array)->function_name) {
-		zend_error_noreturn(E_COMPILE_ERROR, "The \"yield\" expression can only be used inside a function");
-	}
-
-	CG(active_op_array)->fn_flags |= ZEND_ACC_GENERATOR;
-
-	if (is_variable) {
-		if ((CG(active_op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) && !zend_is_function_or_method_call(value)) {
-			zend_do_end_variable_parse(value, BP_VAR_W, 1 TSRMLS_CC);
-		} else {
-			zend_do_end_variable_parse(value, BP_VAR_R, 0 TSRMLS_CC);
-		}
-	}
-
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	zend_op_array *op_array = CG(active_op_array);
+	uint32_t try_catch_offset = op_array->last_try_catch++;
+	zend_try_catch_element *elem;
 
-	opline->opcode = ZEND_YIELD;
+	op_array->try_catch_array = safe_erealloc(
+		op_array->try_catch_array, sizeof(zend_try_catch_element), op_array->last_try_catch, 0);
 
-	if (value) {
-		SET_NODE(opline->op1, value);
+	elem = &op_array->try_catch_array[try_catch_offset];
+	elem->try_op = try_op;
+	elem->catch_op = 0;
+	elem->finally_op = 0;
+	elem->finally_end = 0;
 
-		if (is_variable && zend_is_function_or_method_call(value)) {
-			opline->extended_value = ZEND_RETURNS_FUNCTION;
-		}
-	} else {
-		SET_UNUSED(opline->op1);
-	}
-
-	if (key) {
-		SET_NODE(opline->op2, key);
-	} else {
-		SET_UNUSED(opline->op2);
-	}
-
-	opline->result_type = IS_VAR;
-	opline->result.var = get_temporary_variable(CG(active_op_array));
-	GET_NODE(result, opline->result);
-}
-/* }}} */
-
-static int zend_add_try_element(uint32_t try_op TSRMLS_DC) /* {{{ */
-{
-	int try_catch_offset = CG(active_op_array)->last_try_catch++;
-
-	CG(active_op_array)->try_catch_array = erealloc(CG(active_op_array)->try_catch_array, sizeof(zend_try_catch_element)*CG(active_op_array)->last_try_catch);
-	CG(active_op_array)->try_catch_array[try_catch_offset].try_op = try_op;
-	CG(active_op_array)->try_catch_array[try_catch_offset].catch_op = 0;
-	CG(active_op_array)->try_catch_array[try_catch_offset].finally_op = 0;
-	CG(active_op_array)->try_catch_array[try_catch_offset].finally_end = 0;
 	return try_catch_offset;
 }
 /* }}} */
 
-static void zend_add_catch_element(int offset, uint32_t catch_op TSRMLS_DC) /* {{{ */
-{
-	CG(active_op_array)->try_catch_array[offset].catch_op = catch_op;
-}
-/* }}} */
-
-void zend_do_first_catch(znode *open_parentheses TSRMLS_DC) /* {{{ */
-{
-	open_parentheses->u.op.opline_num = get_next_op_number(CG(active_op_array));
-}
-/* }}} */
-
-void zend_initialize_try_catch_element(znode *catch_token TSRMLS_DC) /* {{{ */
-{
-	int jmp_op_number = get_next_op_number(CG(active_op_array));
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	zend_llist jmp_list;
-	zend_llist *jmp_list_ptr;
-
-	opline->opcode = ZEND_JMP;
-	SET_UNUSED(opline->op1);
-	SET_UNUSED(opline->op2);
-	/* save for backpatching */
-
-	zend_llist_init(&jmp_list, sizeof(int), NULL, 0);
-	zend_stack_push(&CG(bp_stack), (void *) &jmp_list);
-	jmp_list_ptr = zend_stack_top(&CG(bp_stack));
-	zend_llist_add_element(jmp_list_ptr, &jmp_op_number);
-
-	catch_token->EA = get_next_op_number(CG(active_op_array));
-}
-/* }}} */
-
-void zend_do_mark_last_catch(const znode *first_catch, const znode *last_additional_catch TSRMLS_DC) /* {{{ */
-{
-	CG(active_op_array)->last--;
-	zend_do_if_end(TSRMLS_C);
-	if (last_additional_catch->u.op.opline_num == -1) {
-		CG(active_op_array)->opcodes[first_catch->u.op.opline_num].result.num = 1;
-		CG(active_op_array)->opcodes[first_catch->u.op.opline_num].extended_value = get_next_op_number(CG(active_op_array));
-	} else {
-		CG(active_op_array)->opcodes[last_additional_catch->u.op.opline_num].result.num = 1;
-		CG(active_op_array)->opcodes[last_additional_catch->u.op.opline_num].extended_value = get_next_op_number(CG(active_op_array));
-	}
-	DEC_BPC(CG(active_op_array));
-}
-/* }}} */
-
-void zend_do_try(znode *try_token TSRMLS_DC) /* {{{ */
-{
-	try_token->u.op.opline_num = zend_add_try_element(get_next_op_number(CG(active_op_array)) TSRMLS_CC);
-	INC_BPC(CG(active_op_array));
-}
-/* }}} */
-
-void zend_do_finally(znode *finally_token TSRMLS_DC) /* {{{ */
-{
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-
-	finally_token->u.op.opline_num = get_next_op_number(CG(active_op_array));
-	/* call the the "finally" block */
-	opline->opcode = ZEND_FAST_CALL;
-	SET_UNUSED(opline->op1);
-	opline->op1.opline_num = finally_token->u.op.opline_num + 1;
-	SET_UNUSED(opline->op2);
-	/* jump to code after the "finally" block,
-	 * the actual jump address is going to be set in zend_do_end_finally()
-	 */
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	opline->opcode = ZEND_JMP;
-	SET_UNUSED(opline->op1);
-	SET_UNUSED(opline->op2);
-
-	CG(context).in_finally++;
-}
-/* }}} */
-
-void zend_do_begin_catch(znode *catch_token, znode *class_name, znode *catch_var, znode *first_catch TSRMLS_DC) /* {{{ */
-{
-	zend_long catch_op_number;
-	zend_op *opline;
-	znode catch_class;
-
-	if (class_name->op_type == IS_CONST &&
-	    ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant))) {
-		zend_resolve_class_name(class_name TSRMLS_CC);
-		catch_class = *class_name;
-	} else {
-		zend_error_noreturn(E_COMPILE_ERROR, "Bad class name in the catch statement");
-	}
-
-	catch_op_number = get_next_op_number(CG(active_op_array));
-	if (first_catch) {
-		first_catch->u.op.opline_num = catch_op_number;
-	}
-
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	opline->opcode = ZEND_CATCH;
-	opline->op1_type = IS_CONST;
-	opline->op1.constant = zend_add_class_name_literal(CG(active_op_array), &catch_class.u.constant TSRMLS_CC);
-	opline->op2_type = IS_CV;
-	opline->op2.var = lookup_cv(CG(active_op_array), Z_STR(catch_var->u.constant) TSRMLS_CC);
-	Z_STR(catch_var->u.constant) = CG(active_op_array)->vars[EX_VAR_TO_NUM(opline->op2.var)];
-	opline->result.num = 0; /* 1 means it's the last catch in the block */
-
-	catch_token->u.op.opline_num = catch_op_number;
-}
-/* }}} */
-
-void zend_do_end_catch(znode *catch_token TSRMLS_DC) /* {{{ */
-{
-	int jmp_op_number = get_next_op_number(CG(active_op_array));
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	zend_llist *jmp_list_ptr;
-
-	opline->opcode = ZEND_JMP;
-	SET_UNUSED(opline->op1);
-	SET_UNUSED(opline->op2);
-	/* save for backpatching */
-
-	jmp_list_ptr = zend_stack_top(&CG(bp_stack));
-	zend_llist_add_element(jmp_list_ptr, &jmp_op_number);
-
-	CG(active_op_array)->opcodes[catch_token->u.op.opline_num].extended_value = get_next_op_number(CG(active_op_array));
-}
-/* }}} */
-
-void zend_do_bind_catch(znode *try_token, znode *catch_token TSRMLS_DC) /* {{{ */ {
-	if (catch_token->op_type != IS_UNUSED) {
-		zend_add_catch_element(try_token->u.op.opline_num, catch_token->EA TSRMLS_CC);
-	}
-}
-/* }}} */
-
-void zend_do_end_finally(znode *try_token, znode* catch_token, znode *finally_token TSRMLS_DC) /* {{{ */
-{
-	if (catch_token->op_type == IS_UNUSED && finally_token->op_type == IS_UNUSED) {
-		zend_error_noreturn(E_COMPILE_ERROR, "Cannot use try without catch or finally");
-	}
-	if (finally_token->op_type != IS_UNUSED) {
-		zend_op *opline;
-
-		CG(active_op_array)->try_catch_array[try_token->u.op.opline_num].finally_op = finally_token->u.op.opline_num + 1;
-		CG(active_op_array)->try_catch_array[try_token->u.op.opline_num].finally_end = get_next_op_number(CG(active_op_array));
-		CG(active_op_array)->has_finally_block = 1;
-
-		opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-		opline->opcode = ZEND_FAST_RET;
-		SET_UNUSED(opline->op1);
-		SET_UNUSED(opline->op2);
-
-		CG(active_op_array)->opcodes[finally_token->u.op.opline_num].op1.opline_num = get_next_op_number(CG(active_op_array));
-
-		CG(context).in_finally--;
-	}
-}
-/* }}} */
-
-void zend_do_throw(znode *expr TSRMLS_DC) /* {{{ */
-{
-	zend_op *opline;
-
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	opline->opcode = ZEND_THROW;
-	SET_NODE(opline->op1, expr);
-	SET_UNUSED(opline->op2);
-}
-/* }}} */
-
 ZEND_API void function_add_ref(zend_function *function) /* {{{ */
 {
 	if (function->type == ZEND_USER_FUNCTION) {
@@ -3727,7 +1249,7 @@ static zend_bool zend_do_perform_implementation_check(const zend_function *fe, c
 		buf = erealloc(buf, length); 		\
 	}
 
-static char * zend_get_function_declaration(zend_function *fptr TSRMLS_DC) /* {{{ */
+static char *zend_get_function_declaration(zend_function *fptr TSRMLS_DC) /* {{{ */
 {
 	char *offset, *buf;
 	uint32_t length = 1024;
@@ -3825,7 +1347,7 @@ static char * zend_get_function_declaration(zend_function *fptr TSRMLS_DC) /* {{
 						++idx;
 						while (op < end) {
 							if ((op->opcode == ZEND_RECV || op->opcode == ZEND_RECV_INIT)
-									&& op->op1.num == (zend_long)idx)
+									&& op->op1.num == (long)idx)
 							{
 								precv = op;
 							}
@@ -5009,67 +2531,6 @@ ZEND_API int do_bind_function(const zend_op_array *op_array, zend_op *opline, Ha
 }
 /* }}} */
 
-void zend_prepare_reference(znode *result, znode *class_name, znode *method_name TSRMLS_DC) /* {{{ */
-{
-	zend_trait_method_reference *method_ref = emalloc(sizeof(zend_trait_method_reference));
-	method_ref->ce = NULL;
-
-	/* REM: There should not be a need for copying,
-	   zend_do_begin_class_declaration is also just using that string */
-	if (class_name) {
-		zend_resolve_class_name(class_name TSRMLS_CC);
-		method_ref->class_name = Z_STR(class_name->u.constant);
-	} else {
-		method_ref->class_name = NULL;
-	}
-
-	method_ref->method_name = Z_STR(method_name->u.constant);
-
-	result->u.op.ptr = method_ref;
-	result->op_type = IS_TMP_VAR;
-}
-/* }}} */
-
-void zend_add_trait_alias(znode *method_reference, znode *modifiers, znode *alias TSRMLS_DC) /* {{{ */
-{
-	zend_class_entry *ce = CG(active_class_entry);
-	zend_trait_alias *trait_alias;
-
-	if (Z_LVAL(modifiers->u.constant) == ZEND_ACC_STATIC) {
-		zend_error_noreturn(E_COMPILE_ERROR, "Cannot use 'static' as method modifier");
-		return;
-	} else if (Z_LVAL(modifiers->u.constant) == ZEND_ACC_ABSTRACT) {
-		zend_error_noreturn(E_COMPILE_ERROR, "Cannot use 'abstract' as method modifier");
-		return;
-	} else if (Z_LVAL(modifiers->u.constant) == ZEND_ACC_FINAL) {
-		zend_error_noreturn(E_COMPILE_ERROR, "Cannot use 'final' as method modifier");
-		return;
-	}
-
-	trait_alias = emalloc(sizeof(zend_trait_alias));
-	trait_alias->trait_method = (zend_trait_method_reference*)method_reference->u.op.ptr;
-	trait_alias->modifiers = Z_LVAL(modifiers->u.constant);
-	if (alias) {
-		trait_alias->alias = Z_STR(alias->u.constant);
-	} else {
-		trait_alias->alias = NULL;
-	}
-	zend_add_to_list(&ce->trait_aliases, trait_alias TSRMLS_CC);
-}
-/* }}} */
-
-void zend_add_trait_precedence(znode *method_reference, znode *trait_list TSRMLS_DC) /* {{{ */
-{
-	zend_class_entry *ce = CG(active_class_entry);
-	zend_trait_precedence *trait_precedence = emalloc(sizeof(zend_trait_precedence));
-
-	trait_precedence->trait_method = (zend_trait_method_reference*)method_reference->u.op.ptr;
-	trait_precedence->exclude_from_classes = trait_list->u.op.ptr;
-
-	zend_add_to_list(&ce->trait_precedences, trait_precedence TSRMLS_CC);
-}
-/* }}} */
-
 ZEND_API zend_class_entry *do_bind_class(const zend_op_array* op_array, const zend_op *opline, HashTable *class_table, zend_bool compile_time TSRMLS_DC) /* {{{ */
 {
 	zend_class_entry *ce;
@@ -5245,1315 +2706,1817 @@ ZEND_API void zend_do_delayed_early_binding(const zend_op_array *op_array TSRMLS
 }
 /* }}} */
 
-void zend_do_boolean_or_begin(znode *expr1, znode *op_token TSRMLS_DC) /* {{{ */
+ZEND_API zend_string *zend_mangle_property_name(const char *src1, int src1_length, const char *src2, int src2_length, int internal) /* {{{ */
 {
-	int next_op_number = get_next_op_number(CG(active_op_array));
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-
-	opline->opcode = ZEND_JMPNZ_EX;
-	if (expr1->op_type == IS_TMP_VAR) {
-		SET_NODE(opline->result, expr1);
-	} else {
-		opline->result.var = get_temporary_variable(CG(active_op_array));
-		opline->result_type = IS_TMP_VAR;
-	}
-	SET_NODE(opline->op1, expr1);
-	SET_UNUSED(opline->op2);
-
-	op_token->u.op.opline_num = next_op_number;
+	zend_string *prop_name;
+	int prop_name_length;
 
-	GET_NODE(expr1, opline->result);
+	prop_name_length = 1 + src1_length + 1 + src2_length;
+	prop_name = zend_string_alloc(prop_name_length, internal);
+	prop_name->val[0] = '\0';
+	memcpy(prop_name->val + 1, src1, src1_length+1);
+	memcpy(prop_name->val + 1 + src1_length + 1, src2, src2_length+1);
+	return prop_name;
 }
 /* }}} */
 
-void zend_do_boolean_or_end(znode *result, znode *expr1, znode *expr2, const znode *op_token TSRMLS_DC) /* {{{ */
+static int zend_strnlen(const char* s, int maxlen) /* {{{ */
 {
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-
-	*result = *expr1; /* we saved the original result in expr1 */
-	opline->opcode = ZEND_BOOL;
-	SET_NODE(opline->result, result);
-	SET_NODE(opline->op1, expr2);
-	SET_UNUSED(opline->op2);
-
-	CG(active_op_array)->opcodes[op_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array));
+	int len = 0;
+	while (*s++ && maxlen--) len++;
+	return len;
 }
 /* }}} */
 
-void zend_do_boolean_and_begin(znode *expr1, znode *op_token TSRMLS_DC) /* {{{ */
+ZEND_API int zend_unmangle_property_name_ex(const char *mangled_property, int len, const char **class_name, const char **prop_name, int *prop_len) /* {{{ */
 {
-	int next_op_number = get_next_op_number(CG(active_op_array));
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	int class_name_len;
 
-	opline->opcode = ZEND_JMPZ_EX;
-	if (expr1->op_type == IS_TMP_VAR) {
-		SET_NODE(opline->result, expr1);
-	} else {
-		opline->result.var = get_temporary_variable(CG(active_op_array));
-		opline->result_type = IS_TMP_VAR;
-	}
-	SET_NODE(opline->op1, expr1);
-	SET_UNUSED(opline->op2);
+	*class_name = NULL;
 
-	op_token->u.op.opline_num = next_op_number;
+	if (mangled_property[0]!=0) {
+		*prop_name = mangled_property;
+		if (prop_len) {
+			*prop_len = len;
+		}
+		return SUCCESS;
+	}
+	if (len < 3 || mangled_property[1]==0) {
+		zend_error(E_NOTICE, "Illegal member variable name");
+		*prop_name = mangled_property;
+		if (prop_len) {
+			*prop_len = len;
+		}
+		return FAILURE;
+	}
 
-	GET_NODE(expr1, opline->result);
+	class_name_len = zend_strnlen(mangled_property + 1, --len - 1) + 1;
+	if (class_name_len >= len || mangled_property[class_name_len]!=0) {
+		zend_error(E_NOTICE, "Corrupt member variable name");
+		*prop_name = mangled_property;
+		if (prop_len) {
+			*prop_len = len + 1;
+		}
+		return FAILURE;
+	}
+	*class_name = mangled_property + 1;
+	*prop_name = (*class_name) + class_name_len;
+	if (prop_len) {
+		*prop_len = len - class_name_len;
+	}
+	return SUCCESS;
 }
 /* }}} */
 
-void zend_do_boolean_and_end(znode *result, znode *expr1, znode *expr2, const znode *op_token TSRMLS_DC) /* {{{ */
+static zend_constant *zend_get_ct_const(zend_string *name, int all_internal_constants_substitution TSRMLS_DC) /* {{{ */
 {
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	zend_constant *c = NULL;
+	char *lookup_name;
 
-	*result = *expr1; /* we saved the original result in expr1 */
-	opline->opcode = ZEND_BOOL;
-	SET_NODE(opline->result, result);
-	SET_NODE(opline->op1, expr2);
-	SET_UNUSED(opline->op2);
+	if (name->val[0] == '\\') {
+		c = zend_hash_str_find_ptr(EG(zend_constants), name->val + 1, name->len - 1);
+		if (!c) {
+			lookup_name = zend_str_tolower_dup(name->val + 1, name->len - 1);
+			c = zend_hash_str_find_ptr(EG(zend_constants), lookup_name, name->len - 1);
+			efree(lookup_name);
 
-	CG(active_op_array)->opcodes[op_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array));
+			if (c && (c->flags & CONST_CT_SUBST) && !(c->flags & CONST_CS)) {
+				return c;
+			}
+			return NULL;
+		}
+	} else if ((c = zend_hash_find_ptr(EG(zend_constants), name)) == NULL) {
+		lookup_name = zend_str_tolower_dup(name->val, name->len);
+		c = zend_hash_str_find_ptr(EG(zend_constants), lookup_name, name->len);
+		efree(lookup_name);
+
+		if (c && (c->flags & CONST_CT_SUBST) && !(c->flags & CONST_CS)) {
+			return c;
+		}
+		return NULL;
+	}
+
+	if (c->flags & CONST_CT_SUBST) {
+		return c;
+	}
+	if (all_internal_constants_substitution &&
+	    (c->flags & CONST_PERSISTENT) &&
+	    !(CG(compiler_options) & ZEND_COMPILE_NO_CONSTANT_SUBSTITUTION) &&
+	    !Z_CONSTANT(c->value)) {
+		return c;
+	}
+	return NULL;
 }
 /* }}} */
 
-void zend_do_do_while_begin(TSRMLS_D) /* {{{ */
+static int zend_constant_ct_subst(znode *result, zval *const_name, int all_internal_constants_substitution TSRMLS_DC) /* {{{ */
 {
-	do_begin_loop(TSRMLS_C);
-	INC_BPC(CG(active_op_array));
+	zend_constant *c = zend_get_ct_const(Z_STR_P(const_name),
+		all_internal_constants_substitution TSRMLS_CC);
+
+	if (c) {
+		result->op_type = IS_CONST;
+		result->u.constant = c->value;
+		zval_copy_ctor(&result->u.constant);
+		return 1;
+	}
+	return 0;
 }
 /* }}} */
 
-void zend_do_do_while_end(const znode *do_token, const znode *expr_open_bracket, znode *expr TSRMLS_DC) /* {{{ */
+void zend_init_list(void *result, void *item TSRMLS_DC) /* {{{ */
 {
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-
-	opline->opcode = ZEND_JMPNZ;
-	SET_NODE(opline->op1, expr);
-	opline->op2.opline_num = do_token->u.op.opline_num;
-	SET_UNUSED(opline->op2);
+	void** list = emalloc(sizeof(void*) * 2);
 
-	do_end_loop(expr_open_bracket->u.op.opline_num, 0 TSRMLS_CC);
+	list[0] = item;
+	list[1] = NULL;
 
-	DEC_BPC(CG(active_op_array));
+	*(void**)result = list;
 }
 /* }}} */
 
-void zend_do_brk_cont(zend_uchar op, znode *expr TSRMLS_DC) /* {{{ */
+void zend_add_to_list(void *result, void *item TSRMLS_DC) /* {{{ */
 {
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	void** list = *(void**)result;
+	size_t n = 0;
 
-	opline->opcode = op;
-	opline->op1.opline_num = CG(context).current_brk_cont;
-	SET_UNUSED(opline->op1);
-	if (expr) {
-		if (expr->op_type != IS_CONST) {
-			zend_error_noreturn(E_COMPILE_ERROR, "'%s' operator with non-constant operand is no longer supported", op == ZEND_BRK ? "break" : "continue");
-		} else if (Z_TYPE(expr->u.constant) != IS_LONG || Z_LVAL(expr->u.constant) < 1) {
-			zend_error_noreturn(E_COMPILE_ERROR, "'%s' operator accepts only positive numbers", op == ZEND_BRK ? "break" : "continue");
+	if (list) {
+		while (list[n]) {
+			n++;
 		}
-		SET_NODE(opline->op2, expr);
-	} else {
-		LITERAL_LONG(opline->op2, 1);
-		opline->op2_type = IS_CONST;
 	}
-}
-/* }}} */
-
-void zend_do_switch_cond(const znode *cond TSRMLS_DC) /* {{{ */
-{
-	zend_switch_entry switch_entry;
 
-	switch_entry.cond = *cond;
-	switch_entry.default_case = -1;
-	switch_entry.control_var = -1;
-	zend_stack_push(&CG(switch_cond_stack), (void *) &switch_entry);
+	list = erealloc(list, sizeof(void*) * (n+2));
 
-	do_begin_loop(TSRMLS_C);
+	list[n]   = item;
+	list[n+1] = NULL;
 
-	INC_BPC(CG(active_op_array));
+	*(void**)result = list;
 }
 /* }}} */
 
-void zend_do_switch_end(const znode *case_list TSRMLS_DC) /* {{{ */
+void zend_do_extended_info(TSRMLS_D) /* {{{ */
 {
 	zend_op *opline;
-	zend_switch_entry *switch_entry_ptr = zend_stack_top(&CG(switch_cond_stack));
 
-	/* add code to jmp to default case */
-	if (switch_entry_ptr->default_case != -1) {
-		opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-		opline->opcode = ZEND_JMP;
-		SET_UNUSED(opline->op1);
-		SET_UNUSED(opline->op2);
-		opline->op1.opline_num = switch_entry_ptr->default_case;
+	if (!(CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO)) {
+		return;
 	}
 
-	if (case_list->op_type != IS_UNUSED) { /* non-empty switch */
-		int next_op_number = get_next_op_number(CG(active_op_array));
+	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
-		CG(active_op_array)->opcodes[case_list->u.op.opline_num].op1.opline_num = next_op_number;
-	}
+	opline->opcode = ZEND_EXT_STMT;
+	SET_UNUSED(opline->op1);
+	SET_UNUSED(opline->op2);
+}
+/* }}} */
 
-	/* remember break/continue loop information */
-	CG(active_op_array)->brk_cont_array[CG(context).current_brk_cont].cont = CG(active_op_array)->brk_cont_array[CG(context).current_brk_cont].brk = get_next_op_number(CG(active_op_array));
-	CG(context).current_brk_cont = CG(active_op_array)->brk_cont_array[CG(context).current_brk_cont].parent;
+void zend_do_extended_fcall_begin(TSRMLS_D) /* {{{ */
+{
+	zend_op *opline;
 
-	if (switch_entry_ptr->cond.op_type==IS_VAR || switch_entry_ptr->cond.op_type==IS_TMP_VAR) {
-		/* emit free for the switch condition*/
-		opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-		opline->opcode = (switch_entry_ptr->cond.op_type == IS_TMP_VAR) ? ZEND_FREE : ZEND_SWITCH_FREE;
-		SET_NODE(opline->op1, &switch_entry_ptr->cond);
-		SET_UNUSED(opline->op2);
-	}
-	if (switch_entry_ptr->cond.op_type == IS_CONST) {
-		zval_dtor(&switch_entry_ptr->cond.u.constant);
+	if (!(CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO)) {
+		return;
 	}
 
-	zend_stack_del_top(&CG(switch_cond_stack));
+	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
-	DEC_BPC(CG(active_op_array));
+	opline->opcode = ZEND_EXT_FCALL_BEGIN;
+	SET_UNUSED(opline->op1);
+	SET_UNUSED(opline->op2);
 }
 /* }}} */
 
-void zend_do_case_before_statement(const znode *case_list, znode *case_token, znode *case_expr TSRMLS_DC) /* {{{ */
+void zend_do_extended_fcall_end(TSRMLS_D) /* {{{ */
 {
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	int next_op_number;
-	zend_switch_entry *switch_entry_ptr = zend_stack_top(&CG(switch_cond_stack));
-	znode result;
+	zend_op *opline;
 
-	if (switch_entry_ptr->control_var == -1) {
-		switch_entry_ptr->control_var = get_temporary_variable(CG(active_op_array));
-	}
-	opline->opcode = ZEND_CASE;
-	opline->result.var = switch_entry_ptr->control_var;
-	opline->result_type = IS_TMP_VAR;
-	SET_NODE(opline->op1, &switch_entry_ptr->cond);
-	SET_NODE(opline->op2, case_expr);
-	if (opline->op1_type == IS_CONST) {
-		zval_copy_ctor(&CONSTANT(opline->op1.constant));
+	if (!(CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO)) {
+		return;
 	}
-	GET_NODE(&result, opline->result);
 
-	next_op_number = get_next_op_number(CG(active_op_array));
 	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	opline->opcode = ZEND_JMPZ;
-	SET_NODE(opline->op1, &result);
-	SET_UNUSED(opline->op2);
-	case_token->u.op.opline_num = next_op_number;
 
-	if (case_list->op_type==IS_UNUSED) {
-		return;
-	}
-	next_op_number = get_next_op_number(CG(active_op_array));
-	CG(active_op_array)->opcodes[case_list->u.op.opline_num].op1.opline_num = next_op_number;
+	opline->opcode = ZEND_EXT_FCALL_END;
+	SET_UNUSED(opline->op1);
+	SET_UNUSED(opline->op2);
 }
 /* }}} */
 
-void zend_do_case_after_statement(znode *result, const znode *case_token TSRMLS_DC) /* {{{ */
+zend_bool zend_is_auto_global(zend_string *name TSRMLS_DC) /* {{{ */
 {
-	int next_op_number = get_next_op_number(CG(active_op_array));
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-
-	opline->opcode = ZEND_JMP;
-	SET_UNUSED(opline->op1);
-	SET_UNUSED(opline->op2);
-	result->u.op.opline_num = next_op_number;
+	zend_auto_global *auto_global;
 
-	switch (CG(active_op_array)->opcodes[case_token->u.op.opline_num].opcode) {
-		case ZEND_JMP:
-			CG(active_op_array)->opcodes[case_token->u.op.opline_num].op1.opline_num = get_next_op_number(CG(active_op_array));
-			break;
-		case ZEND_JMPZ:
-			CG(active_op_array)->opcodes[case_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array));
-			break;
+	if ((auto_global = zend_hash_find_ptr(CG(auto_globals), name)) != NULL) {
+		if (auto_global->armed) {
+			auto_global->armed = auto_global->auto_global_callback(auto_global->name TSRMLS_CC);
+		}
+		return 1;
 	}
+	return 0;
 }
 /* }}} */
 
-void zend_do_default_before_statement(const znode *case_list, znode *default_token TSRMLS_DC) /* {{{ */
+int zend_register_auto_global(zend_string *name, zend_bool jit, zend_auto_global_callback auto_global_callback TSRMLS_DC) /* {{{ */
 {
-	int next_op_number = get_next_op_number(CG(active_op_array));
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	zend_switch_entry *switch_entry_ptr = zend_stack_top(&CG(switch_cond_stack));
+	zend_auto_global auto_global;
+	int retval;
 
-	opline->opcode = ZEND_JMP;
-	SET_UNUSED(opline->op1);
-	SET_UNUSED(opline->op2);
-	default_token->u.op.opline_num = next_op_number;
+	auto_global.name = zend_new_interned_string(name TSRMLS_CC);
+	auto_global.auto_global_callback = auto_global_callback;
+	auto_global.jit = jit;
 
-	next_op_number = get_next_op_number(CG(active_op_array));
-	switch_entry_ptr->default_case = next_op_number;
+	retval = zend_hash_add_mem(CG(auto_globals), name, &auto_global, sizeof(zend_auto_global)) != NULL ? SUCCESS : FAILURE;
 
-	if (case_list->op_type==IS_UNUSED) {
-		return;
-	}
-	CG(active_op_array)->opcodes[case_list->u.op.opline_num].op1.opline_num = next_op_number;
+	zend_string_release(auto_global.name);
+	return retval;
 }
 /* }}} */
 
-void zend_do_begin_class_declaration(const znode *class_token, znode *class_name, const znode *parent_class_name TSRMLS_DC) /* {{{ */
+ZEND_API void zend_activate_auto_globals(TSRMLS_D) /* {{{ */
 {
-	zend_op *opline;
-	int doing_inheritance = 0;
-	zend_class_entry *new_class_entry;
-	zend_string *lcname;
-	int error = 0;
-	zval *ns_name, key;
-
-	if (CG(active_class_entry)) {
-		zend_error_noreturn(E_COMPILE_ERROR, "Class declarations may not be nested");
-		return;
-	}
+	zend_auto_global *auto_global;
 
-	lcname = zend_string_alloc(Z_STRLEN(class_name->u.constant), 0);
-	zend_str_tolower_copy(lcname->val, Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant));
+	ZEND_HASH_FOREACH_PTR(CG(auto_globals), auto_global) {
+		if (auto_global->jit) {
+			auto_global->armed = 1;
+		} else if (auto_global->auto_global_callback) {
+			auto_global->armed = auto_global->auto_global_callback(auto_global->name TSRMLS_CC);
+		} else {
+			auto_global->armed = 0;
+		}
+	} ZEND_HASH_FOREACH_END();
+}
+/* }}} */
 
-	if (!(strcmp(lcname->val, "self") && strcmp(lcname->val, "parent"))) {
-		zend_string_free(lcname);
-		zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as class name as it is reserved", Z_STRVAL(class_name->u.constant));
-	}
+int zendlex(zend_parser_stack_elem *elem TSRMLS_DC) /* {{{ */
+{
+	zval zv;
+	int retval;
 
-	/* Class name must not conflict with import names */
-	if (CG(current_import) &&
-	    (ns_name = zend_hash_find(CG(current_import), lcname)) != NULL) {
-		error = 1;
+	if (CG(increment_lineno)) {
+		CG(zend_lineno)++;
+		CG(increment_lineno) = 0;
 	}
 
-	if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
-		/* Prefix class name with name of current namespace */
-		znode tmp;
+again:
+	ZVAL_UNDEF(&zv);
+	retval = lex_scan(&zv TSRMLS_CC);
+	switch (retval) {
+		case T_COMMENT:
+		case T_DOC_COMMENT:
+		case T_OPEN_TAG:
+		case T_WHITESPACE:
+			goto again;
 
-		tmp.op_type = IS_CONST;
-		ZVAL_DUP(&tmp.u.constant, &CG(current_namespace));
-		zend_do_build_namespace_name(&tmp, &tmp, class_name TSRMLS_CC);
-		*class_name = tmp;
-		zend_string_free(lcname);
-		lcname = zend_string_alloc(Z_STRLEN(class_name->u.constant), 0);
-		zend_str_tolower_copy(lcname->val, Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant));
+		case T_CLOSE_TAG:
+			if (LANG_SCNG(yy_text)[LANG_SCNG(yy_leng)-1] != '>') {
+				CG(increment_lineno) = 1;
+			}
+			if (CG(has_bracketed_namespaces) && !CG(in_namespace)) {
+				goto again;
+			}
+			retval = ';'; /* implicit ; */
+			break;
+		case T_OPEN_TAG_WITH_ECHO:
+			retval = T_ECHO;
+			break;
+	}
+	if (Z_TYPE(zv) != IS_UNDEF) {
+		elem->ast = zend_ast_create_zval(&zv);
 	}
 
-	if (error) {
-		char *tmp = zend_str_tolower_dup(Z_STRVAL_P(ns_name), Z_STRLEN_P(ns_name));
+	return retval;
+}
+/* }}} */
 
-		if (Z_STRLEN_P(ns_name) != Z_STRLEN(class_name->u.constant) ||
-			memcmp(tmp, lcname->val, Z_STRLEN(class_name->u.constant))) {
-			zend_error_noreturn(E_COMPILE_ERROR, "Cannot declare class %s because the name is already in use", Z_STRVAL(class_name->u.constant));
-		}
-		efree(tmp);
-	}
+ZEND_API void zend_initialize_class_data(zend_class_entry *ce, zend_bool nullify_handlers TSRMLS_DC) /* {{{ */
+{
+	zend_bool persistent_hashes = (ce->type == ZEND_INTERNAL_CLASS) ? 1 : 0;
+	dtor_func_t zval_ptr_dtor_func = ((persistent_hashes) ? ZVAL_INTERNAL_PTR_DTOR : ZVAL_PTR_DTOR);
 
-	new_class_entry = zend_arena_alloc(&CG(arena), sizeof(zend_class_entry));
-	new_class_entry->type = ZEND_USER_CLASS;
-	new_class_entry->name = zend_new_interned_string(Z_STR(class_name->u.constant) TSRMLS_CC);
+	ce->refcount = 1;
+	ce->ce_flags = ZEND_ACC_CONSTANTS_UPDATED;
 
-	zend_initialize_class_data(new_class_entry, 1 TSRMLS_CC);
-	new_class_entry->info.user.filename = zend_get_compiled_filename(TSRMLS_C);
-	new_class_entry->info.user.line_start = class_token->u.op.opline_num;
-	new_class_entry->ce_flags |= class_token->EA;
+	ce->default_properties_table = NULL;
+	ce->default_static_members_table = NULL;
+	zend_hash_init_ex(&ce->properties_info, 8, NULL, (persistent_hashes ? zend_destroy_property_info_internal : zend_destroy_property_info), persistent_hashes, 0);
+	zend_hash_init_ex(&ce->constants_table, 8, NULL, zval_ptr_dtor_func, persistent_hashes, 0);
+	zend_hash_init_ex(&ce->function_table, 8, NULL, ZEND_FUNCTION_DTOR, persistent_hashes, 0);
 
-	if (parent_class_name && parent_class_name->op_type != IS_UNUSED) {
-		switch (parent_class_name->EA) {
-			case ZEND_FETCH_CLASS_SELF:
-				zend_error_noreturn(E_COMPILE_ERROR, "Cannot use 'self' as class name as it is reserved");
-				break;
-			case ZEND_FETCH_CLASS_PARENT:
-				zend_error_noreturn(E_COMPILE_ERROR, "Cannot use 'parent' as class name as it is reserved");
-				break;
-			case ZEND_FETCH_CLASS_STATIC:
-				zend_error_noreturn(E_COMPILE_ERROR, "Cannot use 'static' as class name as it is reserved");
-				break;
-			default:
-				break;
+	if (ce->type == ZEND_INTERNAL_CLASS) {
+#ifdef ZTS
+		int n = zend_hash_num_elements(CG(class_table));
+
+		if (CG(static_members_table) && n >= CG(last_static_member)) {
+			/* Support for run-time declaration: dl() */
+			CG(last_static_member) = n+1;
+			CG(static_members_table) = realloc(CG(static_members_table), (n+1)*sizeof(zval*));
+			CG(static_members_table)[n] = NULL;
 		}
-		doing_inheritance = 1;
+		ce->static_members_table = (zval*)(zend_intptr_t)n;
+#else
+		ce->static_members_table = NULL;
+#endif
+	} else {
+		ce->static_members_table = ce->default_static_members_table;
+		ce->info.user.doc_comment = NULL;
 	}
 
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	opline->op1_type = IS_CONST;
-	build_runtime_defined_function_key(&key, lcname->val, lcname->len TSRMLS_CC);
-	opline->op1.constant = zend_add_literal(CG(active_op_array), &key TSRMLS_CC);
-
-	opline->op2_type = IS_CONST;
+	ce->default_properties_count = 0;
+	ce->default_static_members_count = 0;
 
-	if (doing_inheritance) {
-		/* Make sure a trait does not try to extend a class */
-		if ((new_class_entry->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) {
-			zend_error_noreturn(E_COMPILE_ERROR, "A trait (%s) cannot extend a class. Traits can only be composed from other traits with the 'use' keyword. Error", new_class_entry->name->val);
+	if (nullify_handlers) {
+		ce->constructor = NULL;
+		ce->destructor = NULL;
+		ce->clone = NULL;
+		ce->__get = NULL;
+		ce->__set = NULL;
+		ce->__unset = NULL;
+		ce->__isset = NULL;
+		ce->__call = NULL;
+		ce->__callstatic = NULL;
+		ce->__tostring = NULL;
+		ce->create_object = NULL;
+		ce->get_iterator = NULL;
+		ce->iterator_funcs.funcs = NULL;
+		ce->interface_gets_implemented = NULL;
+		ce->get_static_method = NULL;
+		ce->parent = NULL;
+		ce->num_interfaces = 0;
+		ce->interfaces = NULL;
+		ce->num_traits = 0;
+		ce->traits = NULL;
+		ce->trait_aliases = NULL;
+		ce->trait_precedences = NULL;
+		ce->serialize = NULL;
+		ce->unserialize = NULL;
+		ce->serialize_func = NULL;
+		ce->unserialize_func = NULL;
+		ce->__debugInfo = NULL;
+		if (ce->type == ZEND_INTERNAL_CLASS) {
+			ce->info.internal.module = NULL;
+			ce->info.internal.builtin_functions = NULL;
 		}
+	}
+}
+/* }}} */
 
-		opline->extended_value = parent_class_name->u.op.var;
-		opline->opcode = ZEND_DECLARE_INHERITED_CLASS;
+uint32_t zend_get_class_fetch_type(zend_string *name) {
+	if (name->len == sizeof("self") - 1 &&
+		!strncasecmp(name->val, "self", sizeof("self") - 1)) {
+		return ZEND_FETCH_CLASS_SELF;
+	} else if (name->len == sizeof("parent") - 1 &&
+		!strncasecmp(name->val, "parent", sizeof("parent") - 1)) {
+		return ZEND_FETCH_CLASS_PARENT;
+	} else if (name->len == sizeof("static") - 1 &&
+		!strncasecmp(name->val, "static", sizeof("static") - 1)) {
+		return ZEND_FETCH_CLASS_STATIC;
 	} else {
-		opline->opcode = ZEND_DECLARE_CLASS;
+		return ZEND_FETCH_CLASS_DEFAULT;
 	}
+}
 
-	LITERAL_STR(opline->op2, lcname);
+ZEND_API zend_string *zend_get_compiled_variable_name(const zend_op_array *op_array, uint32_t var) /* {{{ */
+{
+	return op_array->vars[EX_VAR_TO_NUM(var)];
+}
+/* }}} */
 
-	zend_hash_update_ptr(CG(class_table), Z_STR(key), new_class_entry);
-	CG(active_class_entry) = new_class_entry;
+zend_ast *zend_ast_append_str(zend_ast *left_ast, zend_ast *right_ast) {
+	zval *left_zv = zend_ast_get_zval(left_ast);
+	zend_string *left = Z_STR_P(left_zv);
+	zend_string *right = zend_ast_get_str(right_ast);
 
-	opline->result.var = get_temporary_variable(CG(active_op_array));
-	opline->result_type = IS_VAR;
-	GET_NODE(&CG(implementing_class), opline->result);
+	zend_string *result;
+	size_t left_len = left->len;
+	size_t len = left_len + right->len + 1; /* left\right */
+
+	result = zend_string_realloc(left, len, 0);
+	result->val[left_len] = '\\';
+	memcpy(&result->val[left_len + 1], right->val, right->len);
+	result->val[len] = '\0';
+	zend_string_release(right);
 
+	ZVAL_STR(left_zv, result);
+	return left_ast;
+}
+
+/* A hacky way that is used to store the doc comment for properties */
+zend_ast_list *zend_ast_append_doc_comment(zend_ast_list *list TSRMLS_DC) {
 	if (CG(doc_comment)) {
-		CG(active_class_entry)->info.user.doc_comment = CG(doc_comment);
+		list = zend_ast_list_add(list, zend_ast_create_zval_from_str(CG(doc_comment)));
 		CG(doc_comment) = NULL;
 	}
+
+	return list;
+}
+
+void zend_verify_namespace(TSRMLS_D) /* {{{ */
+{
+	if (CG(has_bracketed_namespaces) && !CG(in_namespace)) {
+		zend_error_noreturn(E_COMPILE_ERROR, "No code may exist outside of namespace {}");
+	}
 }
 /* }}} */
 
-static void do_verify_abstract_class(TSRMLS_D) /* {{{ */
-{
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+static void zend_reset_import_tables(TSRMLS_D) {
+	if (CG(current_import)) {
+		zend_hash_destroy(CG(current_import));
+		efree(CG(current_import));
+		CG(current_import) = NULL;
+	}
 
-	opline->opcode = ZEND_VERIFY_ABSTRACT_CLASS;
-	SET_NODE(opline->op1, &CG(implementing_class));
-	SET_UNUSED(opline->op2);
+	if (CG(current_import_function)) {
+		zend_hash_destroy(CG(current_import_function));
+		efree(CG(current_import_function));
+		CG(current_import_function) = NULL;
+	}
+
+	if (CG(current_import_const)) {
+		zend_hash_destroy(CG(current_import_const));
+		efree(CG(current_import_const));
+		CG(current_import_const) = NULL;
+	}
+}
+
+static void zend_end_namespace(TSRMLS_D) {
+	CG(in_namespace) = 0;
+	zend_reset_import_tables(TSRMLS_C);
+	if (CG(current_namespace)) {
+		zend_string_release(CG(current_namespace));
+		CG(current_namespace) = NULL;
+	}
+}
+
+void zend_do_end_compilation(TSRMLS_D) /* {{{ */
+{
+	CG(has_bracketed_namespaces) = 0;
+	zend_end_namespace(TSRMLS_C);
 }
 /* }}} */
 
-void zend_do_end_class_declaration(const znode *class_token, const znode *parent_token TSRMLS_DC) /* {{{ */
+/* {{{ zend_dirname
+   Returns directory name component of path */
+ZEND_API size_t zend_dirname(char *path, size_t len)
 {
-	zend_class_entry *ce = CG(active_class_entry);
+	register char *end = path + len - 1;
+	unsigned int len_adjust = 0;
 
-	if (ce->constructor) {
-		ce->constructor->common.fn_flags |= ZEND_ACC_CTOR;
-		if (ce->constructor->common.fn_flags & ZEND_ACC_STATIC) {
-			zend_error_noreturn(E_COMPILE_ERROR, "Constructor %s::%s() cannot be static", ce->name->val, ce->constructor->common.function_name->val);
+#ifdef PHP_WIN32
+	/* Note that on Win32 CWD is per drive (heritage from CP/M).
+	 * This means dirname("c:foo") maps to "c:." or "c:" - which means CWD on C: drive.
+	 */
+	if ((2 <= len) && isalpha((int)((unsigned char *)path)[0]) && (':' == path[1])) {
+		/* Skip over the drive spec (if any) so as not to change */
+		path += 2;
+		len_adjust += 2;
+		if (2 == len) {
+			/* Return "c:" on Win32 for dirname("c:").
+			 * It would be more consistent to return "c:."
+			 * but that would require making the string *longer*.
+			 */
+			return len;
 		}
 	}
-	if (ce->destructor) {
-		ce->destructor->common.fn_flags |= ZEND_ACC_DTOR;
-		if (ce->destructor->common.fn_flags & ZEND_ACC_STATIC) {
-			zend_error_noreturn(E_COMPILE_ERROR, "Destructor %s::%s() cannot be static", ce->name->val, ce->destructor->common.function_name->val);
+#elif defined(NETWARE)
+	/*
+	 * Find the first occurrence of : from the left
+	 * move the path pointer to the position just after :
+	 * increment the len_adjust to the length of path till colon character(inclusive)
+	 * If there is no character beyond : simple return len
+	 */
+	char *colonpos = NULL;
+	colonpos = strchr(path, ':');
+	if (colonpos != NULL) {
+		len_adjust = ((colonpos - path) + 1);
+		path += len_adjust;
+		if (len_adjust == len) {
+			return len;
 		}
 	}
-	if (ce->clone) {
-		ce->clone->common.fn_flags |= ZEND_ACC_CLONE;
-		if (ce->clone->common.fn_flags & ZEND_ACC_STATIC) {
-			zend_error_noreturn(E_COMPILE_ERROR, "Clone method %s::%s() cannot be static", ce->name->val, ce->clone->common.function_name->val);
+#endif
+
+	if (len == 0) {
+		/* Illegal use of this function */
+		return 0;
+	}
+
+	/* Strip trailing slashes */
+	while (end >= path && IS_SLASH_P(end)) {
+		end--;
+	}
+	if (end < path) {
+		/* The path only contained slashes */
+		path[0] = DEFAULT_SLASH;
+		path[1] = '\0';
+		return 1 + len_adjust;
+	}
+
+	/* Strip filename */
+	while (end >= path && !IS_SLASH_P(end)) {
+		end--;
+	}
+	if (end < path) {
+		/* No slash found, therefore return '.' */
+#ifdef NETWARE
+		if (len_adjust == 0) {
+			path[0] = '.';
+			path[1] = '\0';
+			return 1; /* only one character */
+		} else {
+			path[0] = '\0';
+			return len_adjust;
 		}
+#else
+		path[0] = '.';
+		path[1] = '\0';
+		return 1 + len_adjust;
+#endif
 	}
 
-	ce->info.user.line_end = zend_get_compiled_lineno(TSRMLS_C);
+	/* Strip slashes which came before the file name */
+	while (end >= path && IS_SLASH_P(end)) {
+		end--;
+	}
+	if (end < path) {
+		path[0] = DEFAULT_SLASH;
+		path[1] = '\0';
+		return 1 + len_adjust;
+	}
+	*(end+1) = '\0';
 
-	/* Check for traits and proceed like with interfaces.
-	 * The only difference will be a combined handling of them in the end.
-	 * Thus, we need another opcode here. */
-	if (ce->num_traits > 0) {
-		zend_op *opline;
+	return (size_t)(end + 1 - path) + len_adjust;
+}
+/* }}} */
 
-		ce->traits = NULL;
-		ce->num_traits = 0;
-		ce->ce_flags |= ZEND_ACC_IMPLEMENT_TRAITS;
+static inline zend_bool zend_str_equals_str(zend_string *str1, zend_string *str2) {
+	return str1->len == str2->len && !memcmp(str1->val, str2->val, str2->len);
+}
+static inline zend_bool zend_str_equals_str_ci(zend_string *str1, zend_string *str2) {
+	return str1->len == str2->len
+		&& !zend_binary_strcasecmp(str1->val, str1->len, str2->val, str2->len);
+}
 
-		/* opcode generation: */
-		opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-		opline->opcode = ZEND_BIND_TRAITS;
-		SET_NODE(opline->op1, &CG(implementing_class));
+#define zend_str_equals_literal(str, c) \
+	((str)->len == sizeof(c) - 1 && !memcmp((str)->val, (c), sizeof(c) - 1))
+#define zend_str_equals_literal_ci(str, c) \
+	((str)->len == sizeof(c) - 1 \
+	 && !zend_binary_strcasecmp((str)->val, (str)->len, (c), sizeof(c) - 1))
+
+static void zend_adjust_for_fetch_type(zend_op *opline, uint32_t type) {
+	switch (type & BP_VAR_MASK) {
+		case BP_VAR_R:
+			return;
+		case BP_VAR_W:
+			opline->opcode += 3;
+			return;
+		case BP_VAR_REF:
+			opline->opcode += 3;
+			opline->extended_value |= ZEND_FETCH_MAKE_REF;
+			return;
+		case BP_VAR_RW:
+			opline->opcode += 6;
+			return;
+		case BP_VAR_IS:
+			opline->opcode += 9;
+			return;
+		case BP_VAR_FUNC_ARG:
+			opline->opcode += 12;
+			opline->extended_value |= type >> BP_VAR_SHIFT;
+			return;
+		case BP_VAR_UNSET:
+			opline->opcode += 15;
+			return;
+		EMPTY_SWITCH_DEFAULT_CASE()
 	}
+}
 
-	if (!(ce->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS))
-		&& (parent_token || (ce->num_interfaces > 0))) {
-		zend_verify_abstract_class(ce TSRMLS_CC);
-		if (ce->num_interfaces && !(ce->ce_flags & ZEND_ACC_IMPLEMENT_TRAITS)) {
-			do_verify_abstract_class(TSRMLS_C);
-		}
+static inline void zend_make_var_result(znode *result, zend_op *opline TSRMLS_DC) {
+	opline->result_type = IS_VAR;
+	opline->result.var = get_temporary_variable(CG(active_op_array));
+	GET_NODE(result, opline->result);
+}
+
+static inline void zend_make_tmp_result(znode *result, zend_op *opline TSRMLS_DC) {
+	opline->result_type = IS_TMP_VAR;
+	opline->result.var = get_temporary_variable(CG(active_op_array));
+	GET_NODE(result, opline->result);
+}
+
+static zend_op *zend_emit_op(znode *result, zend_uchar opcode, znode *op1, znode *op2 TSRMLS_DC) {
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	opline->opcode = opcode;
+
+	if (op1 == NULL) {
+		SET_UNUSED(opline->op1);
+	} else {
+		SET_NODE(opline->op1, op1);
 	}
-	/* Inherit interfaces; reset number to zero, we need it for above check and
-	 * will restore it during actual implementation.
-	 * The ZEND_ACC_IMPLEMENT_INTERFACES flag disables double call to
-	 * zend_verify_abstract_class() */
-	if (ce->num_interfaces > 0) {
-		ce->interfaces = NULL;
-		ce->num_interfaces = 0;
-		ce->ce_flags |= ZEND_ACC_IMPLEMENT_INTERFACES;
+
+	if (op2 == NULL) {
+		SET_UNUSED(opline->op2);
+	} else {
+		SET_NODE(opline->op2, op2);
 	}
 
-	CG(active_class_entry) = NULL;
+	if (result) {
+		zend_make_var_result(result, opline TSRMLS_CC);
+	}
+	return opline;
 }
-/* }}} */
 
-void zend_do_implements_interface(znode *interface_name TSRMLS_DC) /* {{{ */
-{
-	zend_op *opline;
+static zend_op *zend_emit_op_tmp(
+	znode *result, zend_uchar opcode, znode *op1, znode *op2 TSRMLS_DC
+) {
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	opline->opcode = opcode;
 
-	/* Traits can not implement interfaces */
-	if ((CG(active_class_entry)->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) {
-		zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as interface on '%s' since it is a Trait",
-							 Z_STRVAL(interface_name->u.constant),
-							 CG(active_class_entry)->name->val);
+	if (op1 == NULL) {
+		SET_UNUSED(opline->op1);
+	} else {
+		SET_NODE(opline->op1, op1);
 	}
 
-	switch (zend_get_class_fetch_type(Z_STRVAL(interface_name->u.constant), Z_STRLEN(interface_name->u.constant))) {
-		case ZEND_FETCH_CLASS_SELF:
-		case ZEND_FETCH_CLASS_PARENT:
-		case ZEND_FETCH_CLASS_STATIC:
-			zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as interface name as it is reserved", Z_STRVAL(interface_name->u.constant));
+	if (op2 == NULL) {
+		SET_UNUSED(opline->op2);
+	} else {
+		SET_NODE(opline->op2, op2);
+	}
+
+	zend_make_tmp_result(result, opline TSRMLS_CC);
+
+	return opline;
+}
+
+static void zend_emit_tick(TSRMLS_D) {
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+
+	opline->opcode = ZEND_TICKS;
+	SET_UNUSED(opline->op1);
+	SET_UNUSED(opline->op2);
+	opline->extended_value = Z_LVAL(CG(declarables).ticks);
+}
+
+static inline zend_op *zend_emit_op_data(znode *value TSRMLS_DC) {
+	return zend_emit_op(NULL, ZEND_OP_DATA, value, NULL TSRMLS_CC);
+}
+
+static inline uint32_t zend_emit_jump(uint32_t opnum_target TSRMLS_DC) {
+	uint32_t opnum = get_next_op_number(CG(active_op_array));
+	zend_op *opline = zend_emit_op(NULL, ZEND_JMP, NULL, NULL TSRMLS_CC);
+	opline->op1.opline_num = opnum_target;
+	return opnum;
+}
+
+static inline uint32_t zend_emit_cond_jump(
+	zend_uchar opcode, znode *cond, uint32_t opnum_target TSRMLS_DC
+) {
+	uint32_t opnum = get_next_op_number(CG(active_op_array));
+	zend_op *opline = zend_emit_op(NULL, opcode, cond, NULL TSRMLS_CC);
+	opline->op2.opline_num = opnum_target;
+	return opnum;
+}
+
+static inline void zend_update_jump_target(uint32_t opnum_jump, uint32_t opnum_target TSRMLS_DC) {
+	zend_op *opline = &CG(active_op_array)->opcodes[opnum_jump];
+	switch (opline->opcode) {
+		case ZEND_JMP:
+			opline->op1.opline_num = opnum_target;
 			break;
-		default:
+		case ZEND_JMPZ:
+		case ZEND_JMPNZ:
+		case ZEND_JMPZ_EX:
+		case ZEND_JMPNZ_EX:
+			opline->op2.opline_num = opnum_target;
 			break;
+		EMPTY_SWITCH_DEFAULT_CASE()
 	}
+}
 
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	opline->opcode = ZEND_ADD_INTERFACE;
-	SET_NODE(opline->op1, &CG(implementing_class));
-	zend_resolve_class_name(interface_name TSRMLS_CC);
-	opline->extended_value = (opline->extended_value & ~ZEND_FETCH_CLASS_MASK) | ZEND_FETCH_CLASS_INTERFACE;
-	opline->op2_type = IS_CONST;
-	opline->op2.constant = zend_add_class_name_literal(CG(active_op_array), &interface_name->u.constant TSRMLS_CC);
-	CG(active_class_entry)->num_interfaces++;
+static inline void zend_update_jump_target_to_next(uint32_t opnum_jump TSRMLS_DC) {
+	zend_update_jump_target(opnum_jump, get_next_op_number(CG(active_op_array)) TSRMLS_CC);
 }
-/* }}} */
 
-void zend_do_use_trait(znode *trait_name TSRMLS_DC) /* {{{ */
-{
-	zend_op *opline;
+static inline zend_op *zend_delayed_emit_op(
+	znode *result, zend_uchar opcode, znode *op1, znode *op2 TSRMLS_DC
+) {
+	zend_op tmp_opline;
+	init_op(&tmp_opline TSRMLS_CC);
+	tmp_opline.opcode = opcode;
+	SET_NODE(tmp_opline.op1, op1);
+	SET_NODE(tmp_opline.op2, op2);
+	if (result) {
+		zend_make_var_result(result, &tmp_opline TSRMLS_CC);
+	}
 
-	if ((CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE)) {
-		zend_error_noreturn(E_COMPILE_ERROR,
-				"Cannot use traits inside of interfaces. %s is used in %s",
-				Z_STRVAL(trait_name->u.constant), CG(active_class_entry)->name->val);
+	zend_stack_push(&CG(delayed_oplines_stack), &tmp_opline);
+	return zend_stack_top(&CG(delayed_oplines_stack));
+}
+
+static inline uint32_t zend_delayed_compile_begin(TSRMLS_D) {
+	return zend_stack_count(&CG(delayed_oplines_stack));
+}
+
+static zend_op *zend_delayed_compile_end(uint32_t offset TSRMLS_DC) {
+	zend_op *opline, *oplines = zend_stack_base(&CG(delayed_oplines_stack));
+	uint32_t i, count = zend_stack_count(&CG(delayed_oplines_stack));
+
+	ZEND_ASSERT(count > offset);
+	for (i = offset; i < count; ++i) {
+		opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+		memcpy(opline, &oplines[i], sizeof(zend_op));
 	}
+	CG(delayed_oplines_stack).top = offset;
+	return opline;
+}
 
+void zend_emit_final_return(zval *zv TSRMLS_DC) {
+	znode zn;
+	zend_bool returns_reference = (CG(active_op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0;
 
-	switch (zend_get_class_fetch_type(Z_STRVAL(trait_name->u.constant), Z_STRLEN(trait_name->u.constant))) {
-		case ZEND_FETCH_CLASS_SELF:
-		case ZEND_FETCH_CLASS_PARENT:
-		case ZEND_FETCH_CLASS_STATIC:
-			zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as trait name as it is reserved", Z_STRVAL(trait_name->u.constant));
-			break;
-		default:
-			break;
+	zn.op_type = IS_CONST;
+	if (zv) {
+		ZVAL_COPY_VALUE(&zn.u.constant, zv);
+	} else {
+		ZVAL_NULL(&zn.u.constant);
 	}
 
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	opline->opcode = ZEND_ADD_TRAIT;
-	SET_NODE(opline->op1, &CG(implementing_class));
-	zend_resolve_class_name(trait_name TSRMLS_CC);
-	opline->extended_value = ZEND_FETCH_CLASS_TRAIT;
-	opline->op2_type = IS_CONST;
-	opline->op2.constant = zend_add_class_name_literal(CG(active_op_array), &trait_name->u.constant TSRMLS_CC);
-	CG(active_class_entry)->num_traits++;
+	zend_emit_op(NULL, returns_reference ? ZEND_RETURN_BY_REF : ZEND_RETURN, &zn, NULL TSRMLS_CC);
 }
-/* }}} */
 
-ZEND_API zend_string *zend_mangle_property_name(const char *src1, int src1_length, const char *src2, int src2_length, int internal) /* {{{ */
-{
-	zend_string *prop_name;
-	int prop_name_length;
 
-	prop_name_length = 1 + src1_length + 1 + src2_length;
-	prop_name = zend_string_alloc(prop_name_length, internal);
-	prop_name->val[0] = '\0';
-	memcpy(prop_name->val + 1, src1, src1_length+1);
-	memcpy(prop_name->val + 1 + src1_length + 1, src2, src2_length+1);
-	return prop_name;
+static inline zend_bool zend_is_variable(zend_ast *ast) {
+	return ast->kind == ZEND_AST_VAR || ast->kind == ZEND_AST_DIM
+		|| ast->kind == ZEND_AST_PROP || ast->kind == ZEND_AST_STATIC_PROP
+		|| ast->kind == ZEND_AST_CALL || ast->kind == ZEND_AST_METHOD_CALL
+		|| ast->kind == ZEND_AST_STATIC_CALL;
 }
-/* }}} */
 
-static int zend_strnlen(const char* s, int maxlen) /* {{{ */
-{
-	int len = 0;
-	while (*s++ && maxlen--) len++;
-	return len;
+static inline zend_bool zend_is_call(zend_ast *ast) {
+	return ast->kind == ZEND_AST_CALL
+		|| ast->kind == ZEND_AST_METHOD_CALL
+		|| ast->kind == ZEND_AST_STATIC_CALL;
 }
-/* }}} */
 
-ZEND_API int zend_unmangle_property_name_ex(const char *mangled_property, int len, const char **class_name, const char **prop_name, int *prop_len) /* {{{ */
-{
-	int class_name_len;
+static inline zend_bool zend_is_unticked_stmt(zend_ast *ast) {
+	return ast->kind == ZEND_AST_STMT_LIST || ast->kind == ZEND_AST_LABEL;
+}
 
-	*class_name = NULL;
+static inline zend_bool zend_can_write_to_variable(zend_ast *ast) {
+	while (ast->kind == ZEND_AST_DIM || ast->kind == ZEND_AST_PROP) {
+		ast = ast->child[0];
+	}
 
-	if (mangled_property[0]!=0) {
-		*prop_name = mangled_property;
-		if (prop_len) {
-			*prop_len = len;
-		}
-		return SUCCESS;
+	return zend_is_variable(ast);
+}
+
+static inline zend_bool zend_is_const_default_class_ref(zend_ast *name_ast) {
+	zend_string *name;
+
+	if (name_ast->kind != ZEND_AST_ZVAL) {
+		return 0;
 	}
-	if (len < 3 || mangled_property[1]==0) {
-		zend_error(E_NOTICE, "Illegal member variable name");
-		*prop_name = mangled_property;
-		if (prop_len) {
-			*prop_len = len;
+
+	/* Fully qualified names are always default refs */
+	if (!name_ast->attr) {
+		return 1;
+	}
+
+	name = zend_ast_get_str(name_ast);
+	return ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(name);
+}
+
+static inline void zend_handle_numeric_op(znode *node TSRMLS_DC) {
+	if (node->op_type == IS_CONST && Z_TYPE(node->u.constant) == IS_STRING) {
+		zend_ulong index;
+
+		if (ZEND_HANDLE_NUMERIC(Z_STR(node->u.constant), index)) {
+			zval_ptr_dtor(&node->u.constant);
+			ZVAL_LONG(&node->u.constant, index);
 		}
-		return FAILURE;
 	}
+}
 
-	class_name_len = zend_strnlen(mangled_property + 1, --len - 1) + 1;
-	if (class_name_len >= len || mangled_property[class_name_len]!=0) {
-		zend_error(E_NOTICE, "Corrupt member variable name");
-		*prop_name = mangled_property;
-		if (prop_len) {
-			*prop_len = len + 1;
+static inline void zend_set_class_name_op1(zend_op *opline, znode *class_node TSRMLS_DC) {
+	if (class_node->op_type == IS_CONST) {
+		opline->op1_type = IS_CONST;
+		opline->op1.constant = zend_add_class_name_literal(
+			CG(active_op_array), Z_STR(class_node->u.constant) TSRMLS_CC);
+	} else {
+		SET_NODE(opline->op1, class_node);
+	}
+}
+
+static zend_op *zend_compile_class_ref(znode *result, zend_ast *name_ast TSRMLS_DC) {
+	zend_op *opline;
+	znode name_node;
+	zend_compile_expr(&name_node, name_ast TSRMLS_CC);
+
+	if (name_node.op_type == IS_CONST) {
+		zend_string *name = Z_STR(name_node.u.constant);
+		uint32_t fetch_type = zend_get_class_fetch_type(name);
+
+		opline = zend_emit_op(result, ZEND_FETCH_CLASS, NULL, NULL TSRMLS_CC);
+		opline->extended_value = fetch_type;
+
+		if (fetch_type == ZEND_FETCH_CLASS_DEFAULT) {
+			uint32_t type = name_ast->kind == ZEND_AST_ZVAL ? name_ast->attr : ZEND_NAME_FQ;
+			opline->op2_type = IS_CONST;
+			opline->op2.constant = zend_add_class_name_literal(CG(active_op_array),
+				zend_resolve_class_name(name, type TSRMLS_CC) TSRMLS_CC);
 		}
-		return FAILURE;
+
+		zend_string_release(name);
+	} else {
+		opline = zend_emit_op(result, ZEND_FETCH_CLASS, NULL, &name_node TSRMLS_CC);
+		opline->extended_value = ZEND_FETCH_CLASS_DEFAULT;
 	}
-	*class_name = mangled_property + 1;
-	*prop_name = (*class_name) + class_name_len;
-	if (prop_len) {
-		*prop_len = len - class_name_len;
+
+	return opline;
+}
+
+static int zend_try_compile_cv(znode *result, zend_ast *ast TSRMLS_DC) {
+	zend_ast *name_ast = ast->child[0];
+	if (name_ast->kind == ZEND_AST_ZVAL) {
+		zend_string *name = zval_get_string(zend_ast_get_zval(name_ast));
+
+		if (zend_is_auto_global(name TSRMLS_CC)) {
+			zend_string_release(name);
+			return FAILURE;
+		}
+
+		result->op_type = IS_CV;
+		result->u.op.var = lookup_cv(CG(active_op_array), name TSRMLS_CC);
+
+		if (zend_str_equals_literal(name, "this")) {
+			CG(active_op_array)->this_var = result->u.op.var;
+		}
+		return SUCCESS;
 	}
-	return SUCCESS;
+
+	return FAILURE;
 }
-/* }}} */
 
-void zend_do_declare_property(znode *var_name, znode *value, uint32_t access_type TSRMLS_DC) /* {{{ */
-{
-	zval property;
-	zend_property_info *existing_property_info;
-	zend_string *comment = NULL;
+static zend_op *zend_compile_simple_var_no_cv(znode *result, zend_ast *ast, int type TSRMLS_DC) {
+	zend_ast *name_ast = ast->child[0];
+	znode name_node;
+	zend_op *opline;
 
-	if (CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE) {
-		zend_error_noreturn(E_COMPILE_ERROR, "Interfaces may not include member variables");
+	/* there is a chance someone is accessing $this */
+	if (ast->kind != ZEND_AST_ZVAL
+		&& CG(active_op_array)->scope && CG(active_op_array)->this_var == -1
+	) {
+		zend_string *key = zend_string_init("this", sizeof("this") - 1, 0);
+		CG(active_op_array)->this_var = lookup_cv(CG(active_op_array), key TSRMLS_CC);
 	}
 
-	if (access_type & ZEND_ACC_ABSTRACT) {
-		zend_error_noreturn(E_COMPILE_ERROR, "Properties cannot be declared abstract");
+	zend_compile_expr(&name_node, name_ast TSRMLS_CC);
+
+	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	opline = zend_emit_op(result, ZEND_FETCH_R, &name_node, NULL TSRMLS_CC);
+
+	opline->extended_value = ZEND_FETCH_LOCAL;
+	if (name_node.op_type == IS_CONST) {
+		if (zend_is_auto_global(Z_STR(name_node.u.constant) TSRMLS_CC)) {
+			opline->extended_value = ZEND_FETCH_GLOBAL;
+		}
 	}
 
-	if (access_type & ZEND_ACC_FINAL) {
-		zend_error_noreturn(E_COMPILE_ERROR, "Cannot declare property %s::$%s final, the final modifier is allowed only for methods and classes",
-				   CG(active_class_entry)->name->val, Z_STRVAL(var_name->u.constant));
+	return opline;
+}
+
+static void zend_compile_simple_var(znode *result, zend_ast *ast, int type TSRMLS_DC) {
+	if (zend_try_compile_cv(result, ast TSRMLS_CC) == FAILURE) {
+		zend_op *opline = zend_compile_simple_var_no_cv(result, ast, type TSRMLS_CC);
+		zend_adjust_for_fetch_type(opline, type);
 	}
+}
 
-	if ((existing_property_info = zend_hash_find_ptr(&CG(active_class_entry)->properties_info, Z_STR(var_name->u.constant))) != NULL) {
-		zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare %s::$%s", CG(active_class_entry)->name->val, Z_STRVAL(var_name->u.constant));
+static void zend_separate_if_call_and_write(znode *node, zend_ast *ast, int type TSRMLS_DC) {
+	if (type != BP_VAR_R && type != BP_VAR_IS && zend_is_call(ast)) {
+		zend_op *opline = zend_emit_op(NULL, ZEND_SEPARATE, node, NULL TSRMLS_CC);
+		opline->result_type = IS_VAR;
+		opline->result.var = opline->op1.var;
 	}
+}
+
+void zend_delayed_compile_var(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC);
 
-	if (value) {
-		ZVAL_COPY_VALUE(&property, &value->u.constant);
+static zend_op *zend_delayed_compile_dim(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC) {
+	zend_ast *var_ast = ast->child[0];
+	zend_ast *dim_ast = ast->child[1];
+
+	znode var_node, dim_node;
+
+	zend_delayed_compile_var(&var_node, var_ast, type TSRMLS_CC);
+	zend_separate_if_call_and_write(&var_node, var_ast, type TSRMLS_CC);
+
+	if (dim_ast == NULL) {
+		if (type == BP_VAR_R || type == BP_VAR_IS) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Cannot use [] for reading");
+		}
+		if (type == BP_VAR_UNSET) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Cannot use [] for unsetting");
+		}
+		dim_node.op_type = IS_UNUSED;
 	} else {
-		ZVAL_NULL(&property);
+		zend_compile_expr(&dim_node, dim_ast TSRMLS_CC);
+		zend_handle_numeric_op(&dim_node TSRMLS_CC);
 	}
 
-	if (CG(doc_comment)) {
-		comment = CG(doc_comment);
-		CG(doc_comment) = NULL;
-	}
+	return zend_delayed_emit_op(result, ZEND_FETCH_DIM_R, &var_node, &dim_node TSRMLS_CC);
+}
+
+static inline zend_op *zend_compile_dim_common(
+	znode *result, zend_ast *ast, uint32_t type TSRMLS_DC
+) {
+	uint32_t offset = zend_delayed_compile_begin(TSRMLS_C);
+	zend_delayed_compile_dim(result, ast, type TSRMLS_CC);
+	return zend_delayed_compile_end(offset TSRMLS_CC);
+}
 
-	Z_STR(var_name->u.constant) = zend_new_interned_string(Z_STR(var_name->u.constant) TSRMLS_CC);
-	if (IS_INTERNED(Z_STR(var_name->u.constant))) {
-		Z_TYPE_FLAGS(var_name->u.constant) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE);
+void zend_compile_dim(znode *result, zend_ast *ast, int type TSRMLS_DC) {
+	zend_op *opline = zend_compile_dim_common(result, ast, type TSRMLS_CC);
+	zend_adjust_for_fetch_type(opline, type);
+}
+
+static zend_bool is_this_fetch(zend_ast *ast) {
+	if (ast->kind == ZEND_AST_VAR && ast->child[0]->kind == ZEND_AST_ZVAL) {
+		zval *name = zend_ast_get_zval(ast->child[0]);
+		return Z_TYPE_P(name) == IS_STRING && zend_str_equals_literal(Z_STR_P(name), "this");
 	}
-	zend_declare_property_ex(CG(active_class_entry), Z_STR(var_name->u.constant), &property, access_type, comment TSRMLS_CC);
-	zend_string_release(Z_STR(var_name->u.constant));
+
+	return 0;
 }
-/* }}} */
 
-void zend_do_declare_class_constant(znode *var_name, znode *value TSRMLS_DC) /* {{{ */
-{
-	if ((CG(active_class_entry)->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) {
-		zend_error_noreturn(E_COMPILE_ERROR, "Traits cannot have constants");
-		return;
+static zend_op *zend_delayed_compile_prop(
+	znode *result, zend_ast *ast, uint32_t type TSRMLS_DC
+) {
+	zend_ast *obj_ast = ast->child[0];
+	zend_ast *prop_ast = ast->child[1];
+
+	znode obj_node, prop_node;
+	zend_op *opline;
+
+	if (is_this_fetch(obj_ast)) {
+		obj_node.op_type = IS_UNUSED;
+	} else {
+		zend_delayed_compile_var(&obj_node, obj_ast, type TSRMLS_CC);
+		zend_separate_if_call_and_write(&obj_node, obj_ast, type TSRMLS_CC);
 	}
+	zend_compile_expr(&prop_node, prop_ast TSRMLS_CC);
 
-	Z_STR(var_name->u.constant) = zend_new_interned_string(Z_STR(var_name->u.constant) TSRMLS_CC);
-	if (IS_INTERNED(Z_STR(var_name->u.constant))) {
-		Z_TYPE_FLAGS(var_name->u.constant) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE);
+	opline = zend_delayed_emit_op(result, ZEND_FETCH_OBJ_R, &obj_node, &prop_node TSRMLS_CC);
+	if (opline->op2_type == IS_CONST && Z_TYPE(CONSTANT(opline->op2.constant)) == IS_STRING) {
+		zend_alloc_polymorphic_cache_slot(opline->op2.constant TSRMLS_CC);
 	}
-	if (Z_CONSTANT(value->u.constant)) {
-		CG(active_class_entry)->ce_flags &= ~ZEND_ACC_CONSTANTS_UPDATED;
+
+	return opline;
+}
+
+static zend_op *zend_compile_prop_common(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC) {
+	uint32_t offset = zend_delayed_compile_begin(TSRMLS_C);
+	zend_delayed_compile_prop(result, ast, type TSRMLS_CC);
+	return zend_delayed_compile_end(offset TSRMLS_CC);
+}
+
+void zend_compile_prop(znode *result, zend_ast *ast, int type TSRMLS_DC) {
+	zend_op *opline = zend_compile_prop_common(result, ast, type TSRMLS_CC);
+	zend_adjust_for_fetch_type(opline, type);
+}
+
+zend_op *zend_compile_static_prop_common(znode *result, zend_ast *ast, int type TSRMLS_DC) {
+	zend_ast *class_ast = ast->child[0];
+	zend_ast *prop_ast = ast->child[1];
+
+	znode class_node, prop_node;
+	zend_op *opline;
+
+	if (zend_is_const_default_class_ref(class_ast)) {
+		class_node.op_type = IS_CONST;
+		ZVAL_STR(&class_node.u.constant, zend_resolve_class_name_ast(class_ast TSRMLS_CC));
+	} else {
+		zend_compile_class_ref(&class_node, class_ast TSRMLS_CC);
 	}
-	if (zend_hash_add(&CG(active_class_entry)->constants_table, Z_STR(var_name->u.constant), &value->u.constant) == NULL) {
-		zend_error_noreturn(E_COMPILE_ERROR, "Cannot redefine class constant %s::%s", CG(active_class_entry)->name->val, Z_STRVAL(var_name->u.constant));
+
+	zend_compile_expr(&prop_node, prop_ast TSRMLS_CC);
+
+	opline = zend_emit_op(result, ZEND_FETCH_R, &prop_node, NULL TSRMLS_CC);
+	if (opline->op1_type == IS_CONST) {
+		zend_alloc_polymorphic_cache_slot(opline->op1.constant TSRMLS_CC);
 	}
-	FREE_PNODE(var_name);
+	if (class_node.op_type == IS_CONST) {
+		opline->op2_type = IS_CONST;
+		opline->op2.constant = zend_add_class_name_literal(
+			CG(active_op_array), Z_STR(class_node.u.constant) TSRMLS_CC);
+	} else {
+		SET_NODE(opline->op2, &class_node);
+	}
+	opline->extended_value |= ZEND_FETCH_STATIC_MEMBER;
 
-	if (CG(doc_comment)) {
-		zend_string_release(CG(doc_comment));
-		CG(doc_comment) = NULL;
+	return opline;
+}
+
+void zend_compile_static_prop(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC) {
+	zend_op *opline = zend_compile_static_prop_common(result, ast, type TSRMLS_CC);
+	zend_adjust_for_fetch_type(opline, type);
+}
+
+static inline zend_uchar get_list_fetch_opcode(zend_uchar op_type) {
+	switch (op_type) {
+		case IS_VAR:
+		case IS_CV:
+			return ZEND_FETCH_DIM_R;
+		case IS_TMP_VAR:
+		case IS_CONST:
+			return ZEND_FETCH_DIM_TMP_VAR;
+		EMPTY_SWITCH_DEFAULT_CASE()
 	}
 }
-/* }}} */
 
-void zend_do_fetch_property(znode *result, znode *object, znode *property TSRMLS_DC) /* {{{ */
-{
-	zend_op opline;
-	zend_llist *fetch_list_ptr = zend_stack_top(&CG(bp_stack));
-
-	if (object->op_type == IS_CV) {
-		if (object->u.op.var == CG(active_op_array)->this_var) {
-			object->op_type = IS_UNUSED; /* this means $this for objects */
-		}
-	} else if (fetch_list_ptr->count == 1) {
-		zend_llist_element *le = fetch_list_ptr->head;
-		zend_op *opline_ptr = (zend_op *) le->data;
-
-		if (opline_is_fetch_this(opline_ptr TSRMLS_CC)) {
-			zend_del_literal(CG(active_op_array), opline_ptr->op1.constant);
-			SET_UNUSED(opline_ptr->op1); /* this means $this for objects */
-			SET_NODE(opline_ptr->op2, property);
-			/* if it was usual fetch, we change it to object fetch */
-			switch (opline_ptr->opcode) {
-				case ZEND_FETCH_W:
-					opline_ptr->opcode = ZEND_FETCH_OBJ_W;
-					break;
-				case ZEND_FETCH_R:
-					opline_ptr->opcode = ZEND_FETCH_OBJ_R;
-					break;
-				case ZEND_FETCH_RW:
-					opline_ptr->opcode = ZEND_FETCH_OBJ_RW;
-					break;
-				case ZEND_FETCH_IS:
-					opline_ptr->opcode = ZEND_FETCH_OBJ_IS;
-					break;
-				case ZEND_FETCH_UNSET:
-					opline_ptr->opcode = ZEND_FETCH_OBJ_UNSET;
-					break;
-				case ZEND_FETCH_FUNC_ARG:
-					opline_ptr->opcode = ZEND_FETCH_OBJ_FUNC_ARG;
-					break;
-			}
-			if (opline_ptr->op2_type == IS_CONST && Z_TYPE(CONSTANT(opline_ptr->op2.constant)) == IS_STRING) {
-				GET_POLYMORPHIC_CACHE_SLOT(opline_ptr->op2.constant);
+static void zend_compile_list_assign(znode *result, zend_ast *ast, znode *expr_node TSRMLS_DC) {
+	zend_ast_list *list = zend_ast_get_list(ast);
+	uint32_t i;
+
+	if (list->children == 1 && !list->child[0]) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Cannot use empty list");
+	}
+
+	for (i = 0; i < list->children; ++i) {
+		zend_ast *var_ast = list->child[i];
+		znode fetch_result, dim_node, var_node, assign_result;
+		zend_op *opline;
+
+		if (var_ast == NULL) {
+			continue;
+		}
+
+		dim_node.op_type = IS_CONST;
+		ZVAL_LONG(&dim_node.u.constant, i);
+
+		if (expr_node->op_type == IS_CONST) {
+			Z_TRY_ADDREF(expr_node->u.constant);
+		}
+
+		opline = zend_emit_op(&fetch_result,
+			get_list_fetch_opcode(expr_node->op_type), expr_node, &dim_node TSRMLS_CC);
+		opline->extended_value |= ZEND_FETCH_ADD_LOCK;
+
+		if (var_ast->kind != ZEND_AST_LIST) {
+			if (is_this_fetch(var_ast)) {
+				zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this");
 			}
-			GET_NODE(result, opline_ptr->result);
-			return;
+			zend_compile_var(&var_node, var_ast, BP_VAR_W TSRMLS_CC);
+			zend_emit_op(&assign_result, ZEND_ASSIGN, &var_node, &fetch_result TSRMLS_CC);
+			zend_do_free(&assign_result TSRMLS_CC);
+		} else {
+			zend_compile_list_assign(&assign_result, var_ast, &fetch_result TSRMLS_CC);
+			zend_do_free(&assign_result TSRMLS_CC);
 		}
 	}
+	*result = *expr_node;
+}
+
+void zend_ensure_writable_variable(const zend_ast *ast) {
+	if (ast->kind == ZEND_AST_CALL) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Can't use function return value in write context");
+	}
+	if (ast->kind == ZEND_AST_METHOD_CALL || ast->kind == ZEND_AST_STATIC_CALL) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Can't use method return value in write context");
+	}
+}
 
-	if (zend_is_function_or_method_call(object)) {
-		init_op(&opline TSRMLS_CC);
-		opline.opcode = ZEND_SEPARATE;
-		SET_NODE(opline.op1, object);
-		SET_UNUSED(opline.op2);
-		opline.result_type = IS_VAR;
-		opline.result.var = opline.op1.var;
-		zend_llist_add_element(fetch_list_ptr, &opline);
+/* Detects $a... = $a pattern */
+zend_bool zend_is_assign_to_self(zend_ast *var_ast, zend_ast *expr_ast TSRMLS_DC) {
+	if (expr_ast->kind != ZEND_AST_VAR || expr_ast->child[0]->kind != ZEND_AST_ZVAL) {
+		return 0;
 	}
 
-	init_op(&opline TSRMLS_CC);
-	opline.opcode = ZEND_FETCH_OBJ_W;	/* the backpatching routine assumes W */
-	opline.result_type = IS_VAR;
-	opline.result.var = get_temporary_variable(CG(active_op_array));
-	SET_NODE(opline.op1, object);
-	SET_NODE(opline.op2, property);
-	if (opline.op2_type == IS_CONST && Z_TYPE(CONSTANT(opline.op2.constant)) == IS_STRING) {
-		GET_POLYMORPHIC_CACHE_SLOT(opline.op2.constant);
+	while (zend_is_variable(var_ast) && var_ast->kind != ZEND_AST_VAR) {
+		var_ast = var_ast->child[0];
 	}
-	GET_NODE(result, opline.result);
 
-	zend_llist_add_element(fetch_list_ptr, &opline);
+	if (var_ast->kind != ZEND_AST_VAR || var_ast->child[0]->kind != ZEND_AST_ZVAL) {
+		return 0;
+	}
+
+	{
+		zend_string *name1 = zval_get_string(zend_ast_get_zval(var_ast->child[0]));
+		zend_string *name2 = zval_get_string(zend_ast_get_zval(expr_ast->child[0]));
+		zend_bool result = zend_str_equals_str(name1, name2);
+		zend_string_release(name1);
+		zend_string_release(name2);
+		return result;
+	}
 }
-/* }}} */
 
-void zend_do_halt_compiler_register(TSRMLS_D) /* {{{ */
-{
-	zend_string *name;
-	zend_string *cfilename;
-	char haltoff[] = "__COMPILER_HALT_OFFSET__";
+void zend_compile_assign(znode *result, zend_ast *ast TSRMLS_DC) {
+	zend_ast *var_ast = ast->child[0];
+	zend_ast *expr_ast = ast->child[1];
 
-	if (CG(has_bracketed_namespaces) && CG(in_namespace)) {
-		zend_error_noreturn(E_COMPILE_ERROR, "__HALT_COMPILER() can only be used from the outermost scope");
+	znode var_node, expr_node;
+	zend_op *opline;
+	uint32_t offset;
+
+	if (is_this_fetch(var_ast)) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this");
 	}
 
-	cfilename = zend_get_compiled_filename(TSRMLS_C);
-	name = zend_mangle_property_name(haltoff, sizeof(haltoff) - 1, cfilename->val, cfilename->len, 0);
-	zend_register_long_constant(name->val, name->len, zend_get_scanned_file_offset(TSRMLS_C), CONST_CS, 0 TSRMLS_CC);
-	zend_string_free(name);
+	zend_ensure_writable_variable(var_ast);
+
+	switch (var_ast->kind) {
+		case ZEND_AST_VAR:
+		case ZEND_AST_STATIC_PROP:
+			zend_compile_var(&var_node, var_ast, BP_VAR_W TSRMLS_CC);
+			zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
+			zend_emit_op(result, ZEND_ASSIGN, &var_node, &expr_node TSRMLS_CC);
+			return;
+		case ZEND_AST_DIM:
+			offset = zend_delayed_compile_begin(TSRMLS_C);
+			zend_delayed_compile_dim(result, var_ast, BP_VAR_W TSRMLS_CC);
+
+			if (zend_is_assign_to_self(var_ast, expr_ast TSRMLS_CC)) {
+				/* $a[0] = $a should evaluate the right $a first */
+				zend_compile_simple_var_no_cv(&expr_node, expr_ast, BP_VAR_R TSRMLS_CC);
+			} else {
+				zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
+			}
+
+			opline = zend_delayed_compile_end(offset TSRMLS_CC);
+			opline->opcode = ZEND_ASSIGN_DIM;
 
-	if (CG(in_namespace)) {
-		zend_do_end_namespace(TSRMLS_C);
+			opline = zend_emit_op_data(&expr_node TSRMLS_CC);
+			opline->op2.var = get_temporary_variable(CG(active_op_array));
+			opline->op2_type = IS_VAR;
+			return;
+		case ZEND_AST_PROP:
+			offset = zend_delayed_compile_begin(TSRMLS_C);
+			zend_delayed_compile_prop(result, var_ast, BP_VAR_W TSRMLS_CC);
+			zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
+
+			opline = zend_delayed_compile_end(offset TSRMLS_CC);
+			opline->opcode = ZEND_ASSIGN_OBJ;
+
+			zend_emit_op_data(&expr_node TSRMLS_CC);
+			return;
+		case ZEND_AST_LIST:
+			zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
+			zend_compile_list_assign(result, var_ast, &expr_node TSRMLS_CC);
+			return;
+		EMPTY_SWITCH_DEFAULT_CASE();
 	}
 }
-/* }}} */
 
-void zend_do_push_object(const znode *object TSRMLS_DC) /* {{{ */
-{
-	zend_stack_push(&CG(object_stack), object);
+static inline void zend_emit_assign_znode(zend_ast *var_ast, znode *value_node TSRMLS_DC) {
+	znode dummy_node;
+	zend_ast *assign_ast = zend_ast_create(ZEND_AST_ASSIGN, var_ast,
+		zend_ast_create_znode(value_node));
+	zend_compile_assign(&dummy_node, assign_ast TSRMLS_CC);
+	zend_do_free(&dummy_node TSRMLS_CC);
 }
-/* }}} */
 
-void zend_do_pop_object(znode *object TSRMLS_DC) /* {{{ */
-{
-	if (object) {
-		znode *tmp = zend_stack_top(&CG(object_stack));
-		*object = *tmp;
+void zend_compile_assign_ref(znode *result, zend_ast *ast TSRMLS_DC) {
+	zend_ast *target_ast = ast->child[0];
+	zend_ast *source_ast = ast->child[1];
+
+	znode target_node, source_node;
+	zend_op *opline;
+
+	if (is_this_fetch(target_ast)) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this");
+	}
+	zend_ensure_writable_variable(target_ast);
+
+	zend_compile_var(&target_node, target_ast, BP_VAR_W TSRMLS_CC);
+	zend_compile_var(&source_node, source_ast, BP_VAR_REF TSRMLS_CC);
+
+	opline = zend_emit_op(result, ZEND_ASSIGN_REF, &target_node, &source_node TSRMLS_CC);
+	if (!result) {
+		opline->result_type |= EXT_TYPE_UNUSED;
+	}
+
+	if (zend_is_call(source_ast)) {
+		opline->extended_value = ZEND_RETURNS_FUNCTION;
+	} else if (source_ast->kind == ZEND_AST_NEW) {
+		opline->extended_value = ZEND_RETURNS_NEW;
 	}
-	zend_stack_del_top(&CG(object_stack));
 }
-/* }}} */
 
-void zend_do_begin_new_object(znode *new_token, znode *class_type TSRMLS_DC) /* {{{ */
-{
+static inline void zend_emit_assign_ref_znode(zend_ast *var_ast, znode *value_node TSRMLS_DC) {
+	zend_ast *assign_ast = zend_ast_create(ZEND_AST_ASSIGN_REF, var_ast,
+		zend_ast_create_znode(value_node));
+	zend_compile_assign_ref(NULL, assign_ast TSRMLS_CC);
+}
+
+void zend_compile_compound_assign(znode *result, zend_ast *ast TSRMLS_DC) {
+	zend_ast *var_ast = ast->child[0];
+	zend_ast *expr_ast = ast->child[1];
+	uint32_t opcode = ast->attr;
+
+	znode var_node, expr_node;
 	zend_op *opline;
+	uint32_t offset;
 
-	new_token->u.op.opline_num = get_next_op_number(CG(active_op_array));
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	opline->opcode = ZEND_NEW;
-	opline->result_type = IS_VAR;
-	opline->result.var = get_temporary_variable(CG(active_op_array));
-	SET_NODE(opline->op1, class_type);
-	SET_UNUSED(opline->op2);
+	zend_ensure_writable_variable(var_ast);
 
-	zend_push_function_call_entry(NULL, new_token->u.op.opline_num TSRMLS_CC);
+	switch (var_ast->kind) {
+		case ZEND_AST_VAR:
+		case ZEND_AST_STATIC_PROP:
+			zend_compile_var(&var_node, var_ast, BP_VAR_RW TSRMLS_CC);
+			zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
+			zend_emit_op(result, opcode, &var_node, &expr_node TSRMLS_CC);
+			return;
+		case ZEND_AST_DIM:
+			offset = zend_delayed_compile_begin(TSRMLS_C);
+			zend_delayed_compile_dim(result, var_ast, BP_VAR_RW TSRMLS_CC);
+			zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
+
+			opline = zend_delayed_compile_end(offset TSRMLS_CC);
+			opline->opcode = opcode;
+			opline->extended_value = ZEND_ASSIGN_DIM;
+
+			opline = zend_emit_op_data(&expr_node TSRMLS_CC);
+			opline->op2.var = get_temporary_variable(CG(active_op_array));
+			opline->op2_type = IS_VAR;
+			return;
+		case ZEND_AST_PROP:
+			offset = zend_delayed_compile_begin(TSRMLS_C);
+			zend_delayed_compile_prop(result, var_ast, BP_VAR_RW TSRMLS_CC);
+			zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
+
+			opline = zend_delayed_compile_end(offset TSRMLS_CC);
+			opline->opcode = opcode;
+			opline->extended_value = ZEND_ASSIGN_OBJ;
+
+			zend_emit_op_data(&expr_node TSRMLS_CC);
+			return;
+		EMPTY_SWITCH_DEFAULT_CASE()
+	}
 }
-/* }}} */
 
-void zend_do_end_new_object(znode *result, const znode *new_token TSRMLS_DC) /* {{{ */
-{
-	znode ctor_result;
+uint32_t zend_compile_args(zend_ast *ast, zend_function *fbc TSRMLS_DC) {
+	// TODO.AST &var error
+	zend_ast_list *args = zend_ast_get_list(ast);
+	uint32_t i;
+	zend_bool uses_arg_unpack = 0;
+	uint32_t arg_count = 0; /* number of arguments not including unpacks */
 
-	zend_do_end_function_call(NULL, &ctor_result, 1, 0 TSRMLS_CC);
-	zend_do_free(&ctor_result TSRMLS_CC);
+	for (i = 0; i < args->children; ++i) {
+		zend_ast *arg = args->child[i];
+		uint32_t arg_num = i + 1;
 
-	CG(active_op_array)->opcodes[new_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array));
-	GET_NODE(result, CG(active_op_array)->opcodes[new_token->u.op.opline_num].result);
-}
-/* }}} */
+		znode arg_node;
+		zend_op *opline;
+		zend_uchar opcode;
+		zend_ulong flags = 0;
 
-static zend_constant* zend_get_ct_const(const zval *const_name, int all_internal_constants_substitution TSRMLS_DC) /* {{{ */
-{
-	zend_constant *c = NULL;
-	char *lookup_name;
+		if (arg->kind == ZEND_AST_UNPACK) {
+			uses_arg_unpack = 1;
+			fbc = NULL;
+			
+			zend_compile_expr(&arg_node, arg->child[0] TSRMLS_CC);
+			opline = zend_emit_op(NULL, ZEND_SEND_UNPACK, &arg_node, NULL TSRMLS_CC);
+			opline->op2.num = arg_count;
+			continue;
+		}
 
-	if (Z_STRVAL_P(const_name)[0] == '\\') {
-		if ((c = zend_hash_str_find_ptr(EG(zend_constants), Z_STRVAL_P(const_name)+1, Z_STRLEN_P(const_name)-1)) == NULL) {
-			lookup_name = zend_str_tolower_dup(Z_STRVAL_P(const_name)+1, Z_STRLEN_P(const_name)-1);
-			if ((c = zend_hash_str_find_ptr(EG(zend_constants), lookup_name, Z_STRLEN_P(const_name)-1)) != NULL) {
-				if ((c->flags & CONST_CT_SUBST) && !(c->flags & CONST_CS)) {
-					efree(lookup_name);
-					return c;
+		if (uses_arg_unpack) {
+			zend_error_noreturn(E_COMPILE_ERROR,
+				"Cannot use positional argument after argument unpacking");
+		}
+
+		arg_count++;
+		if (zend_is_variable(arg)) {
+			if (zend_is_call(arg)) {
+				zend_compile_var(&arg_node, arg, BP_VAR_R TSRMLS_CC);
+				opcode = ZEND_SEND_VAR_NO_REF;
+				flags |= ZEND_ARG_SEND_FUNCTION;
+				if (fbc && ARG_SHOULD_BE_SENT_BY_REF(fbc, arg_num)) {
+					flags |= ZEND_ARG_SEND_BY_REF;
+					if (ARG_MAY_BE_SENT_BY_REF(fbc, arg_num)) {
+						flags |= ZEND_ARG_SEND_SILENT;
+					}
+				}
+			} else if (fbc) {
+				if (ARG_SHOULD_BE_SENT_BY_REF(fbc, arg_num)) {
+					zend_compile_var(&arg_node, arg, BP_VAR_W TSRMLS_CC);
+					opcode = ZEND_SEND_REF;
+				} else {
+					zend_compile_var(&arg_node, arg, BP_VAR_R TSRMLS_CC);
+					opcode = ZEND_SEND_VAR;
+				}
+			} else {
+				zend_compile_var(&arg_node, arg,
+					BP_VAR_FUNC_ARG | (arg_num << BP_VAR_SHIFT) TSRMLS_CC);
+				opcode = ZEND_SEND_VAR_EX;
+			}
+		} else {
+			zend_compile_expr(&arg_node, arg TSRMLS_CC);
+			if (arg_node.op_type & (IS_VAR|IS_CV)) {
+				opcode = ZEND_SEND_VAR_NO_REF;
+				if (fbc && ARG_MUST_BE_SENT_BY_REF(fbc, arg_num)) {
+					flags |= ZEND_ARG_SEND_BY_REF;
+				}
+			} else {
+				if (fbc) {
+					opcode = ZEND_SEND_VAL;
+					if (ARG_MUST_BE_SENT_BY_REF(fbc, arg_num)) {
+						zend_error_noreturn(E_COMPILE_ERROR, "Only variables can be passed by reference");
+					}
+				} else {
+					opcode = ZEND_SEND_VAL_EX;
 				}
 			}
-			efree(lookup_name);
-			return NULL;
 		}
-	} else if ((c = zend_hash_find_ptr(EG(zend_constants), Z_STR_P(const_name))) == NULL) {
-		lookup_name = zend_str_tolower_dup(Z_STRVAL_P(const_name), Z_STRLEN_P(const_name));
-		if ((c = zend_hash_str_find_ptr(EG(zend_constants), lookup_name, Z_STRLEN_P(const_name))) != NULL) {
-			if ((c->flags & CONST_CT_SUBST) && !(c->flags & CONST_CS)) {
-				efree(lookup_name);
-				return c;
+
+		opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+		opline->opcode = opcode;
+		SET_NODE(opline->op1, &arg_node);
+		SET_UNUSED(opline->op2);
+		opline->op2.opline_num = arg_num;
+
+		if (opcode == ZEND_SEND_VAR_NO_REF) {
+			if (fbc) {
+				flags |= ZEND_ARG_COMPILE_TIME_BOUND;
 			}
+			opline->extended_value = flags;
+		} else if (fbc) {
+			opline->extended_value = ZEND_ARG_COMPILE_TIME_BOUND;
 		}
-		efree(lookup_name);
-		return NULL;
 	}
-	if (c->flags & CONST_CT_SUBST) {
-		return c;
+
+	return arg_count;
+}
+
+void zend_compile_call_common(znode *result, zend_ast *args_ast, zend_function *fbc TSRMLS_DC) {
+	zend_op *opline;
+	uint32_t opnum_init = get_next_op_number(CG(active_op_array)) - 1;
+	uint32_t arg_count;
+	uint32_t call_flags;
+
+	zend_do_extended_fcall_begin(TSRMLS_C);
+
+	arg_count = zend_compile_args(args_ast, fbc TSRMLS_CC);
+
+	opline = &CG(active_op_array)->opcodes[opnum_init];
+	opline->extended_value = arg_count;
+
+	call_flags = (opline->opcode == ZEND_NEW ? ZEND_CALL_CTOR : 0);
+	opline = zend_emit_op(result, ZEND_DO_FCALL, NULL, NULL TSRMLS_CC);
+	opline->op1.num = call_flags;
+
+	zend_do_extended_fcall_end(TSRMLS_C);
+}
+
+zend_bool zend_compile_function_name(znode *name_node, zend_ast *name_ast TSRMLS_DC) {
+	zend_string *orig_name = zend_ast_get_str(name_ast);
+	zend_bool is_fully_qualified;
+
+	name_node->op_type = IS_CONST;
+	ZVAL_STR(&name_node->u.constant, zend_resolve_function_name(
+		orig_name, name_ast->attr, &is_fully_qualified TSRMLS_CC));
+
+	return !is_fully_qualified && CG(current_namespace);
+}
+
+void zend_compile_ns_call(znode *result, znode *name_node, zend_ast *args_ast TSRMLS_DC) {
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	opline->opcode = ZEND_INIT_NS_FCALL_BY_NAME;
+	SET_UNUSED(opline->op1);
+	opline->op2_type = IS_CONST;
+	opline->op2.constant = zend_add_ns_func_name_literal(
+		CG(active_op_array), &name_node->u.constant TSRMLS_CC);
+	zend_alloc_cache_slot(opline->op2.constant TSRMLS_CC);
+
+	zend_compile_call_common(result, args_ast, NULL TSRMLS_CC);
+}
+
+void zend_compile_dynamic_call(znode *result, znode *name_node, zend_ast *args_ast TSRMLS_DC) {
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	opline->opcode = ZEND_INIT_FCALL_BY_NAME;
+	SET_UNUSED(opline->op1);
+	if (name_node->op_type == IS_CONST && Z_TYPE(name_node->u.constant) == IS_STRING) {
+		opline->op2_type = IS_CONST;
+		opline->op2.constant
+			= zend_add_func_name_literal(CG(active_op_array), &name_node->u.constant TSRMLS_CC);
+		zend_alloc_cache_slot(opline->op2.constant TSRMLS_CC);
+	} else {
+		SET_NODE(opline->op2, name_node);
 	}
-	if (all_internal_constants_substitution &&
-	    (c->flags & CONST_PERSISTENT) &&
-	    !(CG(compiler_options) & ZEND_COMPILE_NO_CONSTANT_SUBSTITUTION) &&
-	    !Z_CONSTANT(c->value)) {
-		return c;
+
+	zend_compile_call_common(result, args_ast, NULL TSRMLS_CC);
+}
+
+static zend_bool zend_args_contain_unpack(zend_ast_list *args) {
+	uint32_t i;
+	for (i = 0; i < args->children; ++i) {
+		if (args->child[i]->kind == ZEND_AST_UNPACK) {
+			return 1;
+		}
 	}
-	return NULL;
+	return 0;
 }
-/* }}} */
 
-static int zend_constant_ct_subst(znode *result, zval *const_name, int all_internal_constants_substitution TSRMLS_DC) /* {{{ */
-{
-	zend_constant *c = zend_get_ct_const(const_name, all_internal_constants_substitution TSRMLS_CC);
+int zend_compile_func_strlen(znode *result, zend_ast_list *args TSRMLS_DC) {
+	znode arg_node;
 
-	if (c) {
-		zval_dtor(const_name);
-		result->op_type = IS_CONST;
-		result->u.constant = c->value;
-		zval_copy_ctor(&result->u.constant);
-		return 1;
+	if ((CG(compiler_options) & ZEND_COMPILE_NO_BUILTIN_STRLEN)
+		|| args->children != 1 || args->child[0]->kind == ZEND_AST_UNPACK
+	) {
+		return FAILURE;
 	}
-	return 0;
+
+	zend_compile_expr(&arg_node, args->child[0] TSRMLS_CC);
+	zend_emit_op(result, ZEND_STRLEN, &arg_node, NULL TSRMLS_CC);
+	return SUCCESS;
 }
-/* }}} */
 
-void zend_do_fetch_constant(znode *result, znode *constant_container, znode *constant_name, int mode, zend_bool check_namespace TSRMLS_DC) /* {{{ */
-{
-	znode tmp;
+int zend_compile_func_typecheck(znode *result, zend_ast_list *args, uint32_t type TSRMLS_DC) {
+	znode arg_node;
 	zend_op *opline;
-	int type;
-	char *compound;
-	zend_ulong fetch_type = 0;
-
-	if (constant_container) {
-		switch (mode) {
-			case ZEND_CT:
-				/* this is a class constant */
-				type = zend_get_class_fetch_type(Z_STRVAL(constant_container->u.constant), Z_STRLEN(constant_container->u.constant));
-
-				if (ZEND_FETCH_CLASS_STATIC == type) {
-					zend_error(E_ERROR, "\"static::\" is not allowed in compile-time constants");
-				} else if (ZEND_FETCH_CLASS_DEFAULT == type) {
-					zend_resolve_class_name(constant_container TSRMLS_CC);
-				}
-				zend_do_build_full_name(NULL, constant_container, constant_name, 1 TSRMLS_CC);
-				*result = *constant_container;
-				Z_TYPE_INFO(result->u.constant) = IS_CONSTANT_EX;
-				if (IS_INTERNED(Z_STR(result->u.constant))) {
-					Z_TYPE_FLAGS(result->u.constant) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE);
-				}
-				Z_CONST_FLAGS(result->u.constant) = fetch_type;
-				break;
-			case ZEND_RT:
-				if (constant_container->op_type == IS_CONST &&
-				ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(constant_container->u.constant), Z_STRLEN(constant_container->u.constant))) {
-					zend_resolve_class_name(constant_container TSRMLS_CC);
-				} else {
-					zend_do_fetch_class(&tmp, constant_container TSRMLS_CC);
-					constant_container = &tmp;
-				}
-				opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-				opline->opcode = ZEND_FETCH_CONSTANT;
-				opline->result_type = IS_TMP_VAR;
-				opline->result.var = get_temporary_variable(CG(active_op_array));
-				if (constant_container->op_type == IS_CONST) {
-					opline->op1_type = IS_CONST;
-					opline->op1.constant = zend_add_class_name_literal(CG(active_op_array), &constant_container->u.constant TSRMLS_CC);
-				} else {
-					SET_NODE(opline->op1, constant_container);
-				}
-				SET_NODE(opline->op2, constant_name);
-				if (opline->op1_type == IS_CONST) {
-					GET_CACHE_SLOT(opline->op2.constant);
-				} else {
-					GET_POLYMORPHIC_CACHE_SLOT(opline->op2.constant);
-				}
-				GET_NODE(result, opline->result);
-				break;
-		}
-		return;
+
+	if (args->children != 1 || args->child[0]->kind == ZEND_AST_UNPACK) {
+		return FAILURE;
 	}
-	/* namespace constant */
-	/* only one that did not contain \ from the start can be converted to string if unknown */
-	switch (mode) {
-		case ZEND_CT:
-			compound = memchr(Z_STRVAL(constant_name->u.constant), '\\', Z_STRLEN(constant_name->u.constant));
-			/* this is a namespace constant, or an unprefixed constant */
+	
+	zend_compile_expr(&arg_node, args->child[0] TSRMLS_CC);
+	opline = zend_emit_op(result, ZEND_TYPE_CHECK, &arg_node, NULL TSRMLS_CC);
+	opline->extended_value = type;
+	return SUCCESS;
+}
 
-			if (zend_constant_ct_subst(result, &constant_name->u.constant, 0 TSRMLS_CC)) {
-				break;
-			}
+int zend_compile_func_defined(znode *result, zend_ast_list *args TSRMLS_DC) {
+	zend_string *name;
+	zend_op *opline;
 
-			zend_resolve_const_name(constant_name, &check_namespace TSRMLS_CC);
+	if (args->children != 1 || args->child[0]->kind != ZEND_AST_ZVAL) {
+		return FAILURE;
+	}
 
-			if(!compound) {
-				fetch_type |= IS_CONSTANT_UNQUALIFIED;
-			}
+	name = zval_get_string(zend_ast_get_zval(args->child[0]));
+	if (zend_memrchr(name->val, '\\', name->len) || zend_memrchr(name->val, ':', name->len)) {
+		zend_string_release(name);
+		return FAILURE;
+	}
 
-			*result = *constant_name;
-			Z_TYPE_INFO(result->u.constant) = IS_CONSTANT_EX;
-			if (IS_INTERNED(Z_STR(result->u.constant))) {
-				Z_TYPE_FLAGS(result->u.constant) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE);
-			}
-			Z_CONST_FLAGS(result->u.constant) = fetch_type;
-			break;
-		case ZEND_RT:
-			compound = memchr(Z_STRVAL(constant_name->u.constant), '\\', Z_STRLEN(constant_name->u.constant));
+	opline = zend_emit_op(result, ZEND_DEFINED, NULL, NULL TSRMLS_CC);
+	opline->op1_type = IS_CONST;
+	LITERAL_STR(opline->op1, name);
+	zend_alloc_cache_slot(opline->op1.constant TSRMLS_CC);
 
-			zend_resolve_const_name(constant_name, &check_namespace TSRMLS_CC);
+	/* Lowercase constant name in a separate literal */
+	{
+		zval c;
+		zend_string *lcname = zend_string_alloc(name->len, 0);
+		zend_str_tolower_copy(lcname->val, name->val, name->len);
+		ZVAL_NEW_STR(&c, lcname);
+		zend_add_literal(CG(active_op_array), &c TSRMLS_CC);
+	}
+	return SUCCESS;
+}
 
-			if(zend_constant_ct_subst(result, &constant_name->u.constant, 1 TSRMLS_CC)) {
-				break;
-			}
+static int zend_try_compile_ct_bound_init_user_func(
+	znode *result, zend_ast *name_ast, uint32_t num_args TSRMLS_DC
+) {
+	zend_string *name, *lcname;
+	zend_function *fbc;
+	zend_op *opline;
 
-			opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-			opline->opcode = ZEND_FETCH_CONSTANT;
-			opline->result_type = IS_TMP_VAR;
-			opline->result.var = get_temporary_variable(CG(active_op_array));
-			GET_NODE(result, opline->result);
-			SET_UNUSED(opline->op1);
-			opline->op2_type = IS_CONST;
-			if (compound) {
-				/* the name is unambiguous */
-				opline->extended_value = 0;
-				opline->op2.constant = zend_add_const_name_literal(CG(active_op_array), &constant_name->u.constant, 0 TSRMLS_CC);
-			} else {
-				opline->extended_value = IS_CONSTANT_UNQUALIFIED;
-				if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
-					opline->extended_value |= IS_CONSTANT_IN_NAMESPACE;
-					opline->op2.constant = zend_add_const_name_literal(CG(active_op_array), &constant_name->u.constant, 1 TSRMLS_CC);
-				} else {
-					opline->op2.constant = zend_add_const_name_literal(CG(active_op_array), &constant_name->u.constant, 0 TSRMLS_CC);
-				}
-			}
-			GET_CACHE_SLOT(opline->op2.constant);
-			break;
+	if (name_ast->kind != ZEND_AST_CONST || Z_TYPE_P(zend_ast_get_zval(name_ast)) != IS_STRING) {
+		return FAILURE;
 	}
-}
-/* }}} */
 
-void zend_do_shell_exec(znode *result, znode *cmd TSRMLS_DC) /* {{{ */
-{
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	name = zend_ast_get_str(name_ast);
+	lcname = zend_string_alloc(name->len, 0);
+	zend_str_tolower_copy(lcname->val, name->val, name->len);
 
-	opline->opcode = ZEND_INIT_FCALL;
-	opline->extended_value = 1;
-	SET_UNUSED(opline->op1);
+	fbc = zend_hash_find_ptr(CG(function_table), lcname);
+	if (!fbc || (fbc->type == ZEND_INTERNAL_FUNCTION &&
+		(CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_FUNCTIONS))
+	) {
+		zend_string_free(lcname);
+		return FAILURE;
+	}
+
+	opline = zend_emit_op(NULL, ZEND_INIT_FCALL, NULL, NULL TSRMLS_CC);
 	opline->op2_type = IS_CONST;
-	LITERAL_STR(opline->op2, zend_string_init("shell_exec", sizeof("shell_exec")-1, 0));
-	GET_CACHE_SLOT(opline->op2.constant);
+	LITERAL_STR(opline->op2, lcname);
+	opline->extended_value = num_args;
 
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	switch (cmd->op_type) {
-		case IS_CONST:
-		case IS_TMP_VAR:
-			opline->opcode = ZEND_SEND_VAL;
-			break;
-		default:
-			opline->opcode = ZEND_SEND_VAR;
-			break;
+	return SUCCESS;
+}
+
+static void zend_compile_init_user_func(
+	znode *result, zend_ast *name_ast, uint32_t num_args, zend_string *orig_func_name TSRMLS_DC
+) {
+	zend_op *opline;
+	znode name_node;
+
+	if (zend_try_compile_ct_bound_init_user_func(result, name_ast, num_args TSRMLS_CC) == SUCCESS) {
+		return;
 	}
-	SET_NODE(opline->op1, cmd);
-	opline->op2.opline_num = 1;
-	SET_UNUSED(opline->op2);
 
-	/* FIXME: exception support not added to this op2 */
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	opline->opcode = ZEND_DO_FCALL;
-	opline->extended_value = 1;
-	opline->result.var = get_temporary_variable(CG(active_op_array));
-	opline->result_type = IS_VAR;
-	SET_UNUSED(opline->op1);
-	SET_UNUSED(opline->op2);
-	GET_NODE(result, opline->result);
+	zend_compile_expr(&name_node, name_ast TSRMLS_CC);
+
+	opline = zend_emit_op(NULL, ZEND_INIT_USER_CALL, NULL, &name_node TSRMLS_CC);
+	opline->op1_type = IS_CONST;
+	LITERAL_STR(opline->op1, zend_string_copy(orig_func_name));
+	opline->extended_value = num_args;
 }
-/* }}} */
 
-void zend_do_init_array(znode *result, znode *expr, znode *offset, zend_bool is_ref TSRMLS_DC) /* {{{ */
-{
-	int op_num = get_next_op_number(CG(active_op_array));
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+/* cufa = call_user_func_array */
+int zend_compile_func_cufa(znode *result, zend_ast_list *args, zend_string *lcname TSRMLS_DC) {
+	znode arg_node;
 
-	result->u.op.opline_num = op_num;
+	if (args->children != 2 || zend_args_contain_unpack(args)) {
+		return FAILURE;
+	}
 
-	opline->opcode = ZEND_INIT_ARRAY;
-	opline->result.var = get_temporary_variable(CG(active_op_array));
-	opline->result_type = IS_TMP_VAR;
-	opline->extended_value = is_ref; /* extval = size << 2 | not_packed << 1 | is_ref */
-
-	if (expr) {
-		opline->extended_value += 1 << ZEND_ARRAY_SIZE_SHIFT; /* increment size */
-		SET_NODE(opline->op1, expr);
-		if (offset) {
-			SET_NODE(opline->op2, offset);
-			if (opline->op2_type == IS_CONST && Z_TYPE(CONSTANT(opline->op2.constant)) == IS_STRING) {
-				zend_ulong index;
-
-				opline->extended_value |= ZEND_ARRAY_NOT_PACKED;
-				if (ZEND_HANDLE_NUMERIC(Z_STR(CONSTANT(opline->op2.constant)), index)) {
-					zval_dtor(&CONSTANT(opline->op2.constant));
-					ZVAL_LONG(&CONSTANT(opline->op2.constant), index);
-				}
+	zend_compile_init_user_func(NULL, args->child[0], 1, lcname TSRMLS_CC);
+	zend_compile_expr(&arg_node, args->child[1] TSRMLS_CC);
+	zend_emit_op(NULL, ZEND_SEND_ARRAY, &arg_node, NULL TSRMLS_CC);
+	zend_emit_op(result, ZEND_DO_FCALL, NULL, NULL TSRMLS_CC);
+
+	return SUCCESS;
+}
+
+/* cuf = call_user_func */
+int zend_compile_func_cuf(znode *result, zend_ast_list *args, zend_string *lcname TSRMLS_DC) {
+	uint32_t i;
+
+	if (args->children < 1 || zend_args_contain_unpack(args)) {
+		return FAILURE;
+	}
+
+	zend_compile_init_user_func(NULL, args->child[0], args->children - 1, lcname TSRMLS_CC);
+	for (i = 1; i < args->children; ++i) {
+		zend_ast *arg_ast = args->child[i];
+		znode arg_node;
+		zend_op *opline;
+		zend_bool send_user = 0;
+
+		if (zend_is_variable(arg_ast) && !zend_is_call(arg_ast)) {
+			zend_compile_var(&arg_node, arg_ast, BP_VAR_FUNC_ARG | (i << BP_VAR_SHIFT) TSRMLS_CC);
+			send_user = 1;
+		} else {
+			zend_compile_expr(&arg_node, arg_ast TSRMLS_CC);
+			if (arg_node.op_type & (IS_VAR|IS_CV)) {
+				send_user = 1;
 			}
+		}
+
+		if (send_user) {
+			opline = zend_emit_op(NULL, ZEND_SEND_USER, &arg_node, NULL TSRMLS_CC);
 		} else {
-			SET_UNUSED(opline->op2);
+			opline = zend_emit_op(NULL, ZEND_SEND_VAL, &arg_node, NULL TSRMLS_CC);
 		}
-	} else {
-		SET_UNUSED(opline->op1);
-		SET_UNUSED(opline->op2);
+
+		opline->op2.opline_num = i;
 	}
+	zend_emit_op(result, ZEND_DO_FCALL, NULL, NULL TSRMLS_CC);
+
+	return SUCCESS;
 }
-/* }}} */
 
-void zend_do_add_array_element(znode *result, znode *expr, znode *offset, zend_bool is_ref TSRMLS_DC) /* {{{ */
-{
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	zend_op *init_opline = &CG(active_op_array)->opcodes[result->u.op.opline_num];
-	init_opline->extended_value += 1 << ZEND_ARRAY_SIZE_SHIFT; /* increment size */
-
-	opline->opcode = ZEND_ADD_ARRAY_ELEMENT;
-	COPY_NODE(opline->result, init_opline->result);
-	SET_NODE(opline->op1, expr);
-	if (offset) {
-		SET_NODE(opline->op2, offset);
-		if (opline->op2_type == IS_CONST && Z_TYPE(CONSTANT(opline->op2.constant)) == IS_STRING) {
-			zend_ulong index;
-
-			init_opline->extended_value |= ZEND_ARRAY_NOT_PACKED;
-			if (ZEND_HANDLE_NUMERIC(Z_STR(CONSTANT(opline->op2.constant)), index)) {
-				zval_dtor(&CONSTANT(opline->op2.constant));
-				ZVAL_LONG(&CONSTANT(opline->op2.constant), index);
-			}
-		}
+int zend_try_compile_special_func(
+	znode *result, zend_string *lcname, zend_ast_list *args TSRMLS_DC
+) {
+	if (zend_str_equals_literal(lcname, "strlen")) {
+		return zend_compile_func_strlen(result, args TSRMLS_CC);
+	} else if (zend_str_equals_literal(lcname, "is_null")) {
+		return zend_compile_func_typecheck(result, args, IS_NULL TSRMLS_CC);
+	} else if (zend_str_equals_literal(lcname, "is_bool")) {
+		return zend_compile_func_typecheck(result, args, _IS_BOOL TSRMLS_CC);
+	} else if (zend_str_equals_literal(lcname, "is_long")) {
+		return zend_compile_func_typecheck(result, args, IS_LONG TSRMLS_CC);
+	} else if (zend_str_equals_literal(lcname, "is_float")) {
+		return zend_compile_func_typecheck(result, args, IS_DOUBLE TSRMLS_CC);
+	} else if (zend_str_equals_literal(lcname, "is_string")) {
+		return zend_compile_func_typecheck(result, args, IS_STRING TSRMLS_CC);
+	} else if (zend_str_equals_literal(lcname, "is_array")) {
+		return zend_compile_func_typecheck(result, args, IS_ARRAY TSRMLS_CC);
+	} else if (zend_str_equals_literal(lcname, "is_object")) {
+		return zend_compile_func_typecheck(result, args, IS_OBJECT TSRMLS_CC);
+	} else if (zend_str_equals_literal(lcname, "is_resource")) {
+		return zend_compile_func_typecheck(result, args, IS_RESOURCE TSRMLS_CC);
+	} else if (zend_str_equals_literal(lcname, "defined")) {
+		return zend_compile_func_defined(result, args TSRMLS_CC);
+	} else if (zend_str_equals_literal(lcname, "call_user_func_array")) {
+		return zend_compile_func_cufa(result, args, lcname TSRMLS_CC);
+	} else if (zend_str_equals_literal(lcname, "call_user_func")) {
+		return zend_compile_func_cuf(result, args, lcname TSRMLS_CC);
 	} else {
-		SET_UNUSED(opline->op2);
+		return FAILURE;
 	}
-	opline->extended_value = is_ref;
 }
-/* }}} */
 
-void zend_do_end_array(znode *result, const znode *array_node TSRMLS_DC) /* {{{ */
-{
-	int next_op_num = get_next_op_number(CG(active_op_array));
-	zend_op *init_opline = &CG(active_op_array)->opcodes[array_node->u.op.opline_num];
-	zend_op *opline;
-	int i;
-	int constant_array = 0;
-	zval array;
-
-	/* check if constructed array consists only from constants */
-	if ((init_opline->op1_type & (IS_UNUSED | IS_CONST)) &&
-		(init_opline->op2_type & (IS_UNUSED | IS_CONST))) {
-		if (next_op_num == array_node->u.op.opline_num + 1) {
-			constant_array = 1;
-		} else if ((init_opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT) == next_op_num - array_node->u.op.opline_num) {
-			opline = init_opline + 1;
-			i = next_op_num - array_node->u.op.opline_num - 1;
-			while (i > 0) {
-				if (opline->opcode != ZEND_ADD_ARRAY_ELEMENT ||
-				    opline->op1_type != IS_CONST ||
-		            !(opline->op2_type & (IS_UNUSED | IS_CONST))) {
-					break;
-				}
-				opline++;
-				i--;
-			}
-			if (i == 0) {
-				constant_array = 1;
-			}
-		}
+void zend_compile_call(znode *result, zend_ast *ast, int type TSRMLS_DC) {
+	zend_ast *name_ast = ast->child[0];
+	zend_ast *args_ast = ast->child[1];
+
+	znode name_node;
+
+	if (name_ast->kind != ZEND_AST_ZVAL || Z_TYPE_P(zend_ast_get_zval(name_ast)) != IS_STRING) {
+		zend_compile_expr(&name_node, name_ast TSRMLS_CC);
+		zend_compile_dynamic_call(result, &name_node, args_ast TSRMLS_CC);
+		return;
 	}
-	
-	if (constant_array) {
-		/* try to construct constant array */
-		uint32_t size;
-		zend_long num;
-		zend_string *str;
-
-		if (init_opline->op1_type != IS_UNUSED) {
-			size = init_opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
-		} else {
-			size = 0;
+
+	{
+		zend_bool runtime_resolution = zend_compile_function_name(&name_node, name_ast TSRMLS_CC);
+		if (runtime_resolution) {
+			zend_compile_ns_call(result, &name_node, args_ast TSRMLS_CC);
+			return;
 		}
-		ZVAL_NEW_ARR(&array);
-		zend_hash_init(Z_ARRVAL(array), size, NULL, ZVAL_PTR_DTOR, 0);
+	}
 
-		if (init_opline->op1_type != IS_UNUSED) {
-			/* Explicitly initialize array as not-packed if flag is set */
-			if (init_opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
-				zend_hash_real_init(Z_ARRVAL(array), 0);
-			}
+	{
+		zval *name = &name_node.u.constant;
+		zend_string *lcname = zend_string_alloc(Z_STRLEN_P(name), 0);
+		zend_function *fbc;
+		zend_op *opline;
 
-			opline = init_opline;
-			i = next_op_num - array_node->u.op.opline_num;
-			while (i > 0 && constant_array) {
-				if (opline->op2_type == IS_CONST) {
-					switch (Z_TYPE(CONSTANT(opline->op2.constant))) {
-						case IS_LONG:
-							num = Z_LVAL(CONSTANT(opline->op2.constant));
-num_index:
-							zend_hash_index_update(Z_ARRVAL(array), num, &CONSTANT(opline->op1.constant));
-							if (Z_REFCOUNTED(CONSTANT(opline->op1.constant))) Z_ADDREF(CONSTANT(opline->op1.constant));
-							break;
-						case IS_STRING:
-							str = Z_STR(CONSTANT(opline->op2.constant));
-str_index:
-							zend_hash_update(Z_ARRVAL(array), str, &CONSTANT(opline->op1.constant));
-							if (Z_REFCOUNTED(CONSTANT(opline->op1.constant))) Z_ADDREF(CONSTANT(opline->op1.constant));
-							break;
-						case IS_DOUBLE:
-							num = zend_dval_to_lval(Z_DVAL(CONSTANT(opline->op2.constant)));
-							goto num_index;
-						case IS_FALSE:
-							num = 0;
-							goto num_index;
-						case IS_TRUE:
-							num = 1;
-							goto num_index;
-						case IS_NULL:
-							str = STR_EMPTY_ALLOC();
-							goto str_index;
-						default:
-							constant_array = 0;
-							break;
-					}
-				} else {
-					zend_hash_next_index_insert(Z_ARRVAL(array), &CONSTANT(opline->op1.constant));
-					if (Z_REFCOUNTED(CONSTANT(opline->op1.constant))) Z_ADDREF(CONSTANT(opline->op1.constant));
-				}
-				opline++;
-				i--;
-			}
-			if (!constant_array) {
-				zval_dtor(&array);
-			}
+		zend_str_tolower_copy(lcname->val, Z_STRVAL_P(name), Z_STRLEN_P(name));
+
+		fbc = zend_hash_find_ptr(CG(function_table), lcname);
+		if (!fbc || (fbc->type == ZEND_INTERNAL_FUNCTION &&
+			(CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_FUNCTIONS))
+		) {
+			zend_string_release(lcname);
+			zend_compile_dynamic_call(result, &name_node, args_ast TSRMLS_CC);
+			return;
 		}
-	}
 
-	if (constant_array) {
-		/* remove run-time array construction and use constant array instead */
-		opline = &CG(active_op_array)->opcodes[next_op_num-1];
-		while (1) {
-			if (opline->op2_type == IS_CONST) {
-				zend_del_literal(CG(active_op_array), opline->op2.constant);
-			}
-			if (opline->op1_type == IS_CONST) {
-				if (Z_TYPE(CONSTANT(opline->op1.constant)) == IS_ARRAY && 
-				    Z_REFCOUNTED(CONSTANT(opline->op1.constant)) &&
-				    Z_REFCOUNT(CONSTANT(opline->op1.constant)) == 2) {
-				    /* don't delete nested arrays */
-					Z_DELREF(CONSTANT(opline->op1.constant));
-					ZVAL_UNDEF(&CONSTANT(opline->op1.constant));
-				}
-				zend_del_literal(CG(active_op_array), opline->op1.constant);
-			}
-			if (opline == init_opline) {
-				break;
-			}
-			opline--;
+		if (zend_try_compile_special_func(result, lcname,
+				zend_ast_get_list(args_ast) TSRMLS_CC) == SUCCESS
+		) {
+			zend_string_release(lcname);
+			zval_ptr_dtor(&name_node.u.constant);
+			return;
 		}
-		CG(active_op_array)->last = array_node->u.op.opline_num;
 
-		result->op_type = IS_CONST;
-		ZVAL_COPY_VALUE(&result->u.constant, &array);		
-	} else {
-		GET_NODE(result, init_opline->result);
+		zval_ptr_dtor(&name_node.u.constant);
+		ZVAL_NEW_STR(&name_node.u.constant, lcname);
+
+		opline = zend_emit_op(NULL, ZEND_INIT_FCALL, NULL, &name_node TSRMLS_CC);
+		zend_alloc_cache_slot(opline->op2.constant TSRMLS_CC);
+
+		zend_compile_call_common(result, args_ast, fbc TSRMLS_CC);
 	}
-	result->EA = 0;
 }
-/* }}} */
 
-void zend_do_add_list_element(const znode *element TSRMLS_DC) /* {{{ */
-{
-	list_llist_element lle;
+void zend_compile_method_call(znode *result, zend_ast *ast, int type TSRMLS_DC) {
+	zend_ast *obj_ast = ast->child[0];
+	zend_ast *method_ast = ast->child[1];
+	zend_ast *args_ast = ast->child[2];
 
-	if (element) {
-		zend_check_writable_variable(element);
+	znode obj_node, method_node;
+	zend_op *opline;
 
-		lle.var = *element;
-		zend_llist_copy(&lle.dimensions, &CG(dimension_llist));
-		zend_llist_prepend_element(&CG(list_llist), &lle);
+	if (is_this_fetch(obj_ast)) {
+		obj_node.op_type = IS_UNUSED;
+	} else {
+		zend_compile_var(&obj_node, obj_ast, type TSRMLS_CC);
 	}
-	(*((int *)CG(dimension_llist).tail->data))++;
-}
-/* }}} */
 
-void zend_do_new_list_begin(TSRMLS_D) /* {{{ */
-{
-	int current_dimension = 0;
-	zend_llist_add_element(&CG(dimension_llist), &current_dimension);
-}
-/* }}} */
+	zend_compile_expr(&method_node, method_ast TSRMLS_CC);
+	opline = zend_emit_op(NULL, ZEND_INIT_METHOD_CALL, &obj_node, NULL TSRMLS_CC);
+	
+	if (method_node.op_type == IS_CONST) {
+		if (Z_TYPE(method_node.u.constant) != IS_STRING) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Method name must be a string");
+		}
 
-void zend_do_new_list_end(TSRMLS_D) /* {{{ */
-{
-	zend_llist_remove_tail(&CG(dimension_llist));
-	(*((int *)CG(dimension_llist).tail->data))++;
+		opline->op2_type = IS_CONST;
+		opline->op2.constant =
+			zend_add_func_name_literal(CG(active_op_array), &method_node.u.constant TSRMLS_CC);
+		zend_alloc_polymorphic_cache_slot(opline->op2.constant TSRMLS_CC);
+	} else {
+		SET_NODE(opline->op2, &method_node);
+	}
+
+	zend_compile_call_common(result, args_ast, NULL TSRMLS_CC);
 }
-/* }}} */
 
-void zend_do_list_init(TSRMLS_D) /* {{{ */
-{
-	zend_stack_push(&CG(list_stack), &CG(list_llist));
-	zend_stack_push(&CG(list_stack), &CG(dimension_llist));
-	zend_llist_init(&CG(list_llist), sizeof(list_llist_element), NULL, 0);
-	zend_llist_init(&CG(dimension_llist), sizeof(int), NULL, 0);
-	zend_do_new_list_begin(TSRMLS_C);
+zend_bool zend_is_constructor(zend_string *name) {
+	return zend_str_equals_literal_ci(name, ZEND_CONSTRUCTOR_FUNC_NAME);
 }
-/* }}} */
 
-void zend_do_list_end(znode *result, znode *expr TSRMLS_DC) /* {{{ */
-{
-	zend_llist_element *le;
-	zend_llist_element *dimension;
+void zend_compile_static_call(znode *result, zend_ast *ast, int type TSRMLS_DC) {
+	zend_ast *class_ast = ast->child[0];
+	zend_ast *method_ast = ast->child[1];
+	zend_ast *args_ast = ast->child[2];
+
+	znode class_node, method_node;
 	zend_op *opline;
-	znode last_container;
+	zend_ulong extended_value = 0;
 
-	le = CG(list_llist).head;
-	while (le) {
-		zend_llist *tmp_dimension_llist = &((list_llist_element *)le->data)->dimensions;
-		dimension = tmp_dimension_llist->head;
-		while (dimension) {
-			opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-			if (dimension == tmp_dimension_llist->head) { /* first */
-				last_container = *expr;
-				switch (expr->op_type) {
-					case IS_VAR:
-					case IS_CV:
-						opline->opcode = ZEND_FETCH_DIM_R;
-						break;
-					case IS_TMP_VAR:
-						opline->opcode = ZEND_FETCH_DIM_TMP_VAR;
-						break;
-					case IS_CONST: /* fetch_dim_tmp_var will handle this bogus fetch */
-						zval_copy_ctor(&expr->u.constant);
-						opline->opcode = ZEND_FETCH_DIM_TMP_VAR;
-						break;
-				}
-				opline->extended_value |= ZEND_FETCH_ADD_LOCK;
-			} else {
-				opline->opcode = ZEND_FETCH_DIM_R;
-			}
-			opline->result_type = IS_VAR;
-			opline->result.var = get_temporary_variable(CG(active_op_array));
-			SET_NODE(opline->op1, &last_container);
-			opline->op2_type = IS_CONST;
-			LITERAL_LONG(opline->op2, *((int *) dimension->data));
-			GET_NODE(&last_container, opline->result);
-			dimension = dimension->next;
+	if (zend_is_const_default_class_ref(class_ast)) {
+		class_node.op_type = IS_CONST;
+		ZVAL_STR(&class_node.u.constant, zend_resolve_class_name_ast(class_ast TSRMLS_CC));
+	} else {
+		opline = zend_compile_class_ref(&class_node, class_ast TSRMLS_CC);
+		extended_value = opline->extended_value;
+	}
+
+	zend_compile_expr(&method_node, method_ast TSRMLS_CC);
+	if (method_node.op_type == IS_CONST) {
+		zval *name = &method_node.u.constant;
+		if (Z_TYPE_P(name) != IS_STRING) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Method name must be a string");
+		}
+		if (zend_is_constructor(Z_STR_P(name))) {
+			zval_ptr_dtor(name);
+			method_node.op_type = IS_UNUSED;
 		}
-		((list_llist_element *) le->data)->value = last_container;
-		zend_llist_destroy(&((list_llist_element *) le->data)->dimensions);
-		zend_do_assign(result, &((list_llist_element *) le->data)->var, &((list_llist_element *) le->data)->value TSRMLS_CC);
-		zend_do_free(result TSRMLS_CC);
-		le = le->next;
 	}
-	zend_llist_destroy(&CG(dimension_llist));
-	zend_llist_destroy(&CG(list_llist));
-	*result = *expr;
-	{
-		zend_llist *p;
 
-		/* restore previous lists */
-		p = zend_stack_top(&CG(list_stack));
-		CG(dimension_llist) = *p;
-		zend_stack_del_top(&CG(list_stack));
-		p = zend_stack_top(&CG(list_stack));
-		CG(list_llist) = *p;
-		zend_stack_del_top(&CG(list_stack));
+	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	opline->opcode = ZEND_INIT_STATIC_METHOD_CALL;
+	opline->extended_value = extended_value;
+
+	zend_set_class_name_op1(opline, &class_node TSRMLS_CC);
+
+	if (method_node.op_type == IS_CONST) {
+		opline->op2_type = IS_CONST;
+		opline->op2.constant =
+			zend_add_func_name_literal(CG(active_op_array), &method_node.u.constant TSRMLS_CC);
+		if (opline->op1_type == IS_CONST) {
+			zend_alloc_cache_slot(opline->op2.constant TSRMLS_CC);
+		} else {
+			zend_alloc_polymorphic_cache_slot(opline->op2.constant TSRMLS_CC);
+		}
+	} else {
+		SET_NODE(opline->op2, &method_node);
 	}
+
+	zend_compile_call_common(result, args_ast, NULL TSRMLS_CC);
 }
-/* }}} */
 
-void zend_init_list(void *result, void *item TSRMLS_DC) /* {{{ */
-{
-	void** list = emalloc(sizeof(void*) * 2);
+void zend_compile_new(znode *result, zend_ast *ast TSRMLS_DC) {
+	zend_ast *class_ast = ast->child[0];
+	zend_ast *args_ast = ast->child[1];
 
-	list[0] = item;
-	list[1] = NULL;
+	znode class_node, ctor_result;
+	zend_op *opline;
+	uint32_t opnum;
 
-	*(void**)result = list;
+	zend_compile_class_ref(&class_node, class_ast TSRMLS_CC);
+
+	opnum = get_next_op_number(CG(active_op_array));
+	opline = zend_emit_op(result, ZEND_NEW, &class_node, NULL TSRMLS_CC);
+
+	zend_compile_call_common(&ctor_result, args_ast, NULL TSRMLS_CC);
+	zend_do_free(&ctor_result TSRMLS_CC);
+
+	/* New jumps over ctor call if ctor does not exist */
+	opline = &CG(active_op_array)->opcodes[opnum];
+	opline->op2.opline_num = get_next_op_number(CG(active_op_array));
 }
-/* }}} */
 
-void zend_add_to_list(void *result, void *item TSRMLS_DC) /* {{{ */
-{
-	void** list = *(void**)result;
-	size_t n = 0;
+void zend_compile_clone(znode *result, zend_ast *ast TSRMLS_DC) {
+	zend_ast *obj_ast = ast->child[0];
 
-	if (list) {
-		while (list[n]) {
-			n++;
+	znode obj_node;
+	zend_compile_expr(&obj_node, obj_ast TSRMLS_CC);
+
+	zend_emit_op(result, ZEND_CLONE, &obj_node, NULL TSRMLS_CC);
+}
+
+void zend_compile_global_var(zend_ast *ast TSRMLS_DC) {
+	zend_ast *var_ast = ast->child[0];
+	zend_ast *name_ast = var_ast->child[0];
+
+	znode name_node, result;
+
+	zend_compile_expr(&name_node, name_ast TSRMLS_CC);
+	if (name_node.op_type == IS_CONST) {
+		if (Z_TYPE(name_node.u.constant) != IS_STRING) {
+			convert_to_string(&name_node.u.constant);
 		}
 	}
 
-	list = erealloc(list, sizeof(void*) * (n+2));
+	if (zend_try_compile_cv(&result, var_ast TSRMLS_CC) == SUCCESS) {
+		zend_emit_op(NULL, ZEND_BIND_GLOBAL, &result, &name_node TSRMLS_CC);
+	} else {
+		zend_emit_op(&result, ZEND_FETCH_W, &name_node, NULL TSRMLS_CC);
 
-	list[n]   = item;
-	list[n+1] = NULL;
+		// TODO.AST Avoid double fetch
+		//opline->extended_value = ZEND_FETCH_GLOBAL_LOCK;
 
-	*(void**)result = list;
+		zend_emit_assign_ref_znode(var_ast, &result TSRMLS_CC);
+	}
 }
-/* }}} */
 
-void zend_do_fetch_static_variable(znode *varname, znode *static_assignment, int fetch_type TSRMLS_DC) /* {{{ */
-{
-	zval tmp;
+static void zend_compile_static_var_common(
+	zend_ast *var_ast, zval *value, zend_bool by_ref TSRMLS_DC
+) {
+	znode var_node, result;
 	zend_op *opline;
-	znode lval;
-	znode result;
 
-	if (static_assignment) {
-		ZVAL_COPY_VALUE(&tmp, &static_assignment->u.constant);
-	} else {
-		ZVAL_NULL(&tmp);
-		Z_CONST_FLAGS(tmp) = 0;
-	}
+	zend_compile_expr(&var_node, var_ast TSRMLS_CC);
+
 	if (!CG(active_op_array)->static_variables) {
 		if (CG(active_op_array)->scope) {
 			CG(active_op_array)->scope->ce_flags |= ZEND_HAS_STATIC_IN_METHODS;
@@ -6561,1402 +4524,3169 @@ void zend_do_fetch_static_variable(znode *varname, znode *static_assignment, int
 		ALLOC_HASHTABLE(CG(active_op_array)->static_variables);
 		zend_hash_init(CG(active_op_array)->static_variables, 8, NULL, ZVAL_PTR_DTOR, 0);
 	}
-	zend_hash_update(CG(active_op_array)->static_variables, Z_STR(varname->u.constant), &tmp);
 
-	if (varname->op_type == IS_CONST) {
-		if (Z_TYPE(varname->u.constant) != IS_STRING) {
-			convert_to_string(&varname->u.constant);
-		}
-	}
+	zend_hash_update(CG(active_op_array)->static_variables, Z_STR(var_node.u.constant), value);
 
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	opline->opcode = (fetch_type == ZEND_FETCH_LEXICAL) ? ZEND_FETCH_R : ZEND_FETCH_W;		/* the default mode must be Write, since fetch_simple_variable() is used to define function arguments */
-	opline->result_type = IS_VAR;
-	opline->result.var = get_temporary_variable(CG(active_op_array));
-	SET_NODE(opline->op1, varname);
-	SET_UNUSED(opline->op2);
+	opline = zend_emit_op(&result, by_ref ? ZEND_FETCH_W : ZEND_FETCH_R, &var_node, NULL TSRMLS_CC);
 	opline->extended_value = ZEND_FETCH_STATIC;
-	GET_NODE(&result, opline->result);
 
-	if (varname->op_type == IS_CONST) {
-		zval_copy_ctor(&varname->u.constant);
+	if (by_ref) {
+		zend_ast *fetch_ast = zend_ast_create(ZEND_AST_VAR, var_ast);
+		zend_emit_assign_ref_znode(fetch_ast, &result TSRMLS_CC);
+	} else {
+		zend_ast *fetch_ast = zend_ast_create(ZEND_AST_VAR, var_ast);
+		zend_emit_assign_znode(fetch_ast, &result TSRMLS_CC);
 	}
-	fetch_simple_variable(&lval, varname, 0 TSRMLS_CC); /* Relies on the fact that the default fetch is BP_VAR_W */
+}
 
-	if (fetch_type == ZEND_FETCH_LEXICAL) {
-		znode dummy;
+void zend_compile_static_var(zend_ast *ast TSRMLS_DC) {
+	zend_ast *var_ast = ast->child[0];
+	zend_ast *value_ast = ast->child[1];
+	zval value_zv;
 
-		zend_do_begin_variable_parse(TSRMLS_C);
-		zend_do_assign(&dummy, &lval, &result TSRMLS_CC);
-		zend_do_free(&dummy TSRMLS_CC);
+	if (value_ast) {
+		zend_const_expr_to_zval(&value_zv, value_ast TSRMLS_CC);
 	} else {
-		zend_do_assign_ref(NULL, &lval, &result TSRMLS_CC);
+		ZVAL_NULL(&value_zv);
 	}
-	CG(active_op_array)->opcodes[CG(active_op_array)->last-1].result_type |= EXT_TYPE_UNUSED;
+
+	zend_compile_static_var_common(var_ast, &value_zv, 1 TSRMLS_CC);
 }
-/* }}} */
 
-void zend_do_fetch_lexical_variable(znode *varname, zend_bool is_ref TSRMLS_DC) /* {{{ */
-{
-	znode value;
+void zend_compile_unset(zend_ast *ast TSRMLS_DC) {
+	zend_ast *var_ast = ast->child[0];
 
-	if (Z_STRLEN(varname->u.constant) == sizeof("this") - 1 &&
-	    memcmp(Z_STRVAL(varname->u.constant), "this", sizeof("this") - 1) == 0) {
-		zend_error_noreturn(E_COMPILE_ERROR, "Cannot use $this as lexical variable");
-		return;
+	znode var_node;
+	zend_op *opline;
+	switch (var_ast->kind) {
+		case ZEND_AST_VAR:
+			if (zend_try_compile_cv(&var_node, var_ast TSRMLS_CC) == SUCCESS) {
+				opline = zend_emit_op(NULL, ZEND_UNSET_VAR, &var_node, NULL TSRMLS_CC);
+				opline->extended_value = ZEND_FETCH_LOCAL | ZEND_QUICK_SET;
+			} else {
+				opline = zend_compile_simple_var_no_cv(NULL, var_ast, BP_VAR_UNSET TSRMLS_CC);
+				opline->opcode = ZEND_UNSET_VAR;
+			}
+			return;
+		case ZEND_AST_DIM:
+			opline = zend_compile_dim_common(NULL, var_ast, BP_VAR_UNSET TSRMLS_CC);
+			opline->opcode = ZEND_UNSET_DIM;
+			return;
+		case ZEND_AST_PROP:
+			opline = zend_compile_prop_common(NULL, var_ast, BP_VAR_UNSET TSRMLS_CC);
+			opline->opcode = ZEND_UNSET_OBJ;
+			return;
+		case ZEND_AST_STATIC_PROP:
+			opline = zend_compile_static_prop_common(NULL, var_ast, BP_VAR_UNSET TSRMLS_CC);
+			opline->opcode = ZEND_UNSET_VAR;
+			return;
+		EMPTY_SWITCH_DEFAULT_CASE()
 	}
+}
+
+static void zend_free_foreach_and_switch_variables(TSRMLS_D) {
+	uint32_t opnum_start, opnum_end, i;
+
+	opnum_start = get_next_op_number(CG(active_op_array));
 
-	value.op_type = IS_CONST;
-	ZVAL_NULL(&value.u.constant);
-	Z_CONST_FLAGS(value.u.constant) = is_ref ? IS_LEXICAL_REF : IS_LEXICAL_VAR;
-	zend_do_fetch_static_variable(varname, &value, is_ref ? ZEND_FETCH_STATIC : ZEND_FETCH_LEXICAL TSRMLS_CC);
+#ifdef ZTS
+	zend_stack_apply_with_argument(&CG(switch_cond_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element, void *)) generate_free_switch_expr TSRMLS_CC);
+	zend_stack_apply_with_argument(&CG(foreach_copy_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element, void *)) generate_free_foreach_copy TSRMLS_CC);
+#else
+	zend_stack_apply(&CG(switch_cond_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element)) generate_free_switch_expr);
+	zend_stack_apply(&CG(foreach_copy_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element)) generate_free_foreach_copy);
+#endif
+
+	opnum_end = get_next_op_number(CG(active_op_array));
+
+	for (i = opnum_start; i < opnum_end; ++i) {
+		CG(active_op_array)->opcodes[i].extended_value |= EXT_TYPE_FREE_ON_RETURN;
+	}
 }
-/* }}} */
 
-void zend_do_fetch_global_variable(znode *varname, const znode *static_assignment, int fetch_type TSRMLS_DC) /* {{{ */
-{
+void zend_compile_return(zend_ast *ast TSRMLS_DC) {
+	zend_ast *expr_ast = ast->child[0];
+	zend_bool by_ref = (CG(active_op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0;
+
+	znode expr_node;
 	zend_op *opline;
-	znode lval;
-	znode result;
 
-	if (varname->op_type == IS_CONST) {
-		if (Z_TYPE(varname->u.constant) != IS_STRING) {
-			convert_to_string(&varname->u.constant);
-		}
+	if (!expr_ast) {
+		expr_node.op_type = IS_CONST;
+		ZVAL_NULL(&expr_node.u.constant);
+	} else if (by_ref && zend_is_variable(expr_ast) && !zend_is_call(expr_ast)) {
+		zend_compile_var(&expr_node, expr_ast, BP_VAR_REF TSRMLS_CC);
+	} else {
+		zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
 	}
 
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	zend_free_foreach_and_switch_variables(TSRMLS_C);
 
-	if (varname->op_type == IS_CONST &&
-	   !zend_is_auto_global(Z_STR(varname->u.constant) TSRMLS_CC) &&
-	    !(Z_STRLEN(varname->u.constant) == (sizeof("this")-1) &&
-	      !memcmp(Z_STRVAL(varname->u.constant), "this", sizeof("this") - 1))) {
-		opline->opcode = ZEND_BIND_GLOBAL;
-		SET_NODE(opline->op2, varname);
-		opline->op1_type = IS_CV;
-		zval_copy_ctor(&varname->u.constant);
-		opline->op1.var = lookup_cv(CG(active_op_array), Z_STR(varname->u.constant) TSRMLS_CC);
-	} else {
-		opline->opcode = ZEND_FETCH_W;		/* the default mode must be Write, since fetch_simple_variable() is used to define function arguments */
-		opline->result_type = IS_VAR;
-		opline->result.var = get_temporary_variable(CG(active_op_array));
-		SET_NODE(opline->op1, varname);
-		SET_UNUSED(opline->op2);
-		opline->extended_value = fetch_type;
-		GET_NODE(&result, opline->result);
+	if (CG(context).in_finally) {
+		zend_emit_op(NULL, ZEND_DISCARD_EXCEPTION, NULL, NULL TSRMLS_CC);
+	}
 
-		if (varname->op_type == IS_CONST) {
-			zval_copy_ctor(&varname->u.constant);
-		}
-		fetch_simple_variable(&lval, varname, 0 TSRMLS_CC); /* Relies on the fact that the default fetch is BP_VAR_W */
+	opline = zend_emit_op(NULL, by_ref ? ZEND_RETURN_BY_REF : ZEND_RETURN,
+		&expr_node, NULL TSRMLS_CC);
 
-		zend_do_assign_ref(NULL, &lval, &result TSRMLS_CC);
-		CG(active_op_array)->opcodes[CG(active_op_array)->last-1].result_type |= EXT_TYPE_UNUSED;
+	if (expr_ast) {
+		if (zend_is_call(expr_ast)) {
+			opline->extended_value = ZEND_RETURNS_FUNCTION;
+		} else if (!zend_is_variable(expr_ast)) {
+			opline->extended_value = ZEND_RETURNS_VALUE;
+		}
 	}
 }
-/* }}} */
 
-void zend_do_cast(znode *result, znode *expr, int type TSRMLS_DC) /* {{{ */
-{
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+void zend_compile_echo(zend_ast *ast TSRMLS_DC) {
+	zend_ast *expr_ast = ast->child[0];
 
-	opline->opcode = ZEND_CAST;
-	opline->result_type = IS_VAR;
-	opline->result.var = get_temporary_variable(CG(active_op_array));
-	SET_NODE(opline->op1, expr);
-	SET_UNUSED(opline->op2);
-	opline->extended_value = type;
-	GET_NODE(result, opline->result);
+	znode expr_node;
+	zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
+
+	zend_emit_op(NULL, ZEND_ECHO, &expr_node, NULL TSRMLS_CC);
 }
-/* }}} */
 
-void zend_do_include_or_eval(int type, znode *result, znode *op1 TSRMLS_DC) /* {{{ */
-{
-	zend_do_extended_fcall_begin(TSRMLS_C);
-	{
-		zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+void zend_compile_throw(zend_ast *ast TSRMLS_DC) {
+	zend_ast *expr_ast = ast->child[0];
 
-		opline->opcode = ZEND_INCLUDE_OR_EVAL;
-		opline->result_type = IS_VAR;
-		opline->result.var = get_temporary_variable(CG(active_op_array));
-		SET_NODE(opline->op1, op1);
-		SET_UNUSED(opline->op2);
-		opline->extended_value = type;
-		GET_NODE(result, opline->result);
+	znode expr_node;
+	zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
+
+	zend_emit_op(NULL, ZEND_THROW, &expr_node, NULL TSRMLS_CC);
+}
+
+void zend_compile_break_continue(zend_ast *ast TSRMLS_DC) {
+	zend_ast *depth_ast = ast->child[0];
+
+	znode depth_node;
+	zend_op *opline;
+
+	ZEND_ASSERT(ast->kind == ZEND_AST_BREAK || ast->kind == ZEND_AST_CONTINUE);
+
+	if (depth_ast) {
+		if (depth_ast->kind != ZEND_AST_ZVAL) {
+			zend_error_noreturn(E_COMPILE_ERROR, "'%s' operator with non-constant operand "
+				"is no longer supported", ast->kind == ZEND_AST_BREAK ? "break" : "continue");
+		}
+
+		zend_compile_expr(&depth_node, depth_ast TSRMLS_CC);
+
+		if (Z_TYPE(depth_node.u.constant) != IS_LONG || Z_LVAL(depth_node.u.constant) < 1) {
+			zend_error_noreturn(E_COMPILE_ERROR, "'%s' operator accepts only positive numbers",
+				ast->kind == ZEND_AST_BREAK ? "break" : "continue");
+		}
+	} else {
+		depth_node.op_type = IS_CONST;
+		ZVAL_LONG(&depth_node.u.constant, 1);
 	}
-	zend_do_extended_fcall_end(TSRMLS_C);
+
+	opline = zend_emit_op(NULL, ast->kind == ZEND_AST_BREAK ? ZEND_BRK : ZEND_CONT,
+		NULL, &depth_node TSRMLS_CC);
+	opline->op1.opline_num = CG(context).current_brk_cont;
 }
-/* }}} */
 
-void zend_do_indirect_references(znode *result, const znode *num_references, znode *variable TSRMLS_DC) /* {{{ */
-{
-	int i;
+void zend_compile_goto(zend_ast *ast TSRMLS_DC) {
+	zend_ast *label_ast = ast->child[0];
+	znode label_node;
+	zend_op *opline;
 
-	zend_do_end_variable_parse(variable, BP_VAR_R, 0 TSRMLS_CC);
-	for (i=1; i<Z_LVAL(num_references->u.constant); i++) {
-		fetch_simple_variable_ex(result, variable, 0, ZEND_FETCH_R TSRMLS_CC);
-		*variable = *result;
+	zend_compile_expr(&label_node, label_ast TSRMLS_CC);
+	opline = zend_emit_op(NULL, ZEND_GOTO, NULL, &label_node TSRMLS_CC);
+	opline->extended_value = CG(context).current_brk_cont;
+	zend_resolve_goto_label(CG(active_op_array), opline, 0 TSRMLS_CC);
+}
+
+void zend_compile_label(zend_ast *ast TSRMLS_DC) {
+	zval *label = zend_ast_get_zval(ast->child[0]);
+	zend_label dest;
+
+	ZEND_ASSERT(Z_TYPE_P(label) == IS_STRING);
+
+	if (!CG(context).labels) {
+		ALLOC_HASHTABLE(CG(context).labels);
+		zend_hash_init(CG(context).labels, 8, NULL, ptr_dtor, 0);
 	}
-	zend_do_begin_variable_parse(TSRMLS_C);
-	fetch_simple_variable(result, variable, 1 TSRMLS_CC);
-	/* there is a chance someone is accessing $this */
-	if (CG(active_op_array)->scope && CG(active_op_array)->this_var == -1) {
-		zend_string *key = zend_string_init("this", sizeof("this")-1, 0);
-		CG(active_op_array)->this_var = lookup_cv(CG(active_op_array), key TSRMLS_CC);
+
+	dest.brk_cont = CG(context).current_brk_cont;
+	dest.opline_num = get_next_op_number(CG(active_op_array));
+
+	if (!zend_hash_add_mem(CG(context).labels, Z_STR_P(label), &dest, sizeof(zend_label))) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Label '%s' already defined", Z_STRVAL_P(label));
 	}
 }
-/* }}} */
 
-void zend_do_unset(znode *variable TSRMLS_DC) /* {{{ */
-{
-	zend_op *last_op;
+void zend_compile_while(zend_ast *ast TSRMLS_DC) {
+	zend_ast *cond_ast = ast->child[0];
+	zend_ast *stmt_ast = ast->child[1];
 
-	zend_check_writable_variable(variable);
+	znode cond_node;
+	uint32_t opnum_start, opnum_jmpz;
 
-	if (variable->op_type == IS_CV) {
-		zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-		opline->opcode = ZEND_UNSET_VAR;
-		SET_NODE(opline->op1, variable);
-		SET_UNUSED(opline->op2);
-		SET_UNUSED(opline->result);
-		opline->extended_value = ZEND_FETCH_LOCAL | ZEND_QUICK_SET;
-	} else {
-		last_op = &CG(active_op_array)->opcodes[get_next_op_number(CG(active_op_array))-1];
+	opnum_start = get_next_op_number(CG(active_op_array));
+	zend_compile_expr(&cond_node, cond_ast TSRMLS_CC);
 
-		switch (last_op->opcode) {
-			case ZEND_FETCH_UNSET:
-				last_op->opcode = ZEND_UNSET_VAR;
-				SET_UNUSED(last_op->result);
-				break;
-			case ZEND_FETCH_DIM_UNSET:
-				last_op->opcode = ZEND_UNSET_DIM;
-				SET_UNUSED(last_op->result);
-				break;
-			case ZEND_FETCH_OBJ_UNSET:
-				last_op->opcode = ZEND_UNSET_OBJ;
-				SET_UNUSED(last_op->result);
-				break;
+	opnum_jmpz = zend_emit_cond_jump(ZEND_JMPZ, &cond_node, 0 TSRMLS_CC);
+	zend_begin_loop(TSRMLS_C);
 
-		}
-	}
+	zend_compile_stmt(stmt_ast TSRMLS_CC);
+
+	zend_emit_jump(opnum_start TSRMLS_CC);
+
+	zend_update_jump_target_to_next(opnum_jmpz TSRMLS_CC);
+
+	zend_end_loop(opnum_start, 0 TSRMLS_CC);
 }
-/* }}} */
 
-void zend_do_isset_or_isempty(int type, znode *result, znode *variable TSRMLS_DC) /* {{{ */
-{
-	zend_op *last_op;
+void zend_compile_do_while(zend_ast *ast TSRMLS_DC) {
+	zend_ast *stmt_ast = ast->child[0];
+	zend_ast *cond_ast = ast->child[1];
 
-	zend_do_end_variable_parse(variable, BP_VAR_IS, 0 TSRMLS_CC);
+	znode cond_node;
+	uint32_t opnum_start, opnum_cond;
 
-	if (zend_is_function_or_method_call(variable)) {
-		if (type == ZEND_ISEMPTY) {
-			/* empty(func()) can be transformed to !func() */
-			zend_do_unary_op(ZEND_BOOL_NOT, result, variable TSRMLS_CC);
-		} else {
-			zend_error_noreturn(E_COMPILE_ERROR, "Cannot use isset() on the result of a function call (you can use \"null !== func()\" instead)");
-		}
+	zend_begin_loop(TSRMLS_C);
 
-		return;
-	}
+	opnum_start = get_next_op_number(CG(active_op_array));
+	zend_compile_stmt(stmt_ast TSRMLS_CC);
 
-	if (variable->op_type == IS_CV) {
-		last_op = get_next_op(CG(active_op_array) TSRMLS_CC);
-		last_op->opcode = ZEND_ISSET_ISEMPTY_VAR;
-		SET_NODE(last_op->op1, variable);
-		SET_UNUSED(last_op->op2);
-		last_op->result.var = get_temporary_variable(CG(active_op_array));
-		last_op->extended_value = ZEND_FETCH_LOCAL | ZEND_QUICK_SET;
-	} else {
-		last_op = &CG(active_op_array)->opcodes[get_next_op_number(CG(active_op_array))-1];
+	opnum_cond = get_next_op_number(CG(active_op_array));
+	zend_compile_expr(&cond_node, cond_ast TSRMLS_CC);
 
-		switch (last_op->opcode) {
-			case ZEND_FETCH_IS:
-				last_op->opcode = ZEND_ISSET_ISEMPTY_VAR;
-				break;
-			case ZEND_FETCH_DIM_IS:
-				last_op->opcode = ZEND_ISSET_ISEMPTY_DIM_OBJ;
-				break;
-			case ZEND_FETCH_OBJ_IS:
-				last_op->opcode = ZEND_ISSET_ISEMPTY_PROP_OBJ;
-				break;
-		}
-	}
-	last_op->result_type = IS_TMP_VAR;
-	last_op->extended_value |= type;
+	zend_emit_cond_jump(ZEND_JMPNZ, &cond_node, opnum_start TSRMLS_CC);
 
-	GET_NODE(result, last_op->result);
+	zend_end_loop(opnum_cond, 0 TSRMLS_CC);
 }
-/* }}} */
 
-void zend_do_instanceof(znode *result, znode *expr, znode *class_znode, int type TSRMLS_DC) /* {{{ */
-{
-	int last_op_number = get_next_op_number(CG(active_op_array));
-	zend_op *opline;
+void zend_compile_expr_list(znode *result, zend_ast *ast TSRMLS_DC) {
+	zend_ast_list *list;
+	uint32_t i;
 
-	if (last_op_number > 0) {
-		opline = &CG(active_op_array)->opcodes[last_op_number-1];
-		if (opline->opcode == ZEND_FETCH_CLASS) {
-			opline->extended_value |= ZEND_FETCH_CLASS_NO_AUTOLOAD;
-		}
+	result->op_type = IS_CONST;
+	ZVAL_TRUE(&result->u.constant);
+
+	if (!ast) {
+		return;
 	}
 
-	if (expr->op_type == IS_CONST) {
-		zend_error_noreturn(E_COMPILE_ERROR, "instanceof expects an object instance, constant given");
+	list = zend_ast_get_list(ast);
+	for (i = 0; i < list->children; ++i) {
+		zend_ast *expr_ast = list->child[i];
+
+		zend_do_free(result TSRMLS_CC);
+		zend_compile_expr(result, expr_ast TSRMLS_CC);
 	}
+}
 
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	opline->opcode = ZEND_INSTANCEOF;
-	opline->result_type = IS_TMP_VAR;
-	opline->result.var = get_temporary_variable(CG(active_op_array));
-	SET_NODE(opline->op1, expr);
+void zend_compile_for(zend_ast *ast TSRMLS_DC) {
+	zend_ast *init_ast = ast->child[0];
+	zend_ast *cond_ast = ast->child[1];
+	zend_ast *loop_ast = ast->child[2];
+	zend_ast *stmt_ast = ast->child[3];
 
-	SET_NODE(opline->op2, class_znode);
+	znode result;
+	uint32_t opnum_cond, opnum_jmpz, opnum_loop;
 
-	GET_NODE(result, opline->result);
+	zend_compile_expr_list(&result, init_ast TSRMLS_CC);
+	zend_do_free(&result TSRMLS_CC);
+
+	opnum_cond = get_next_op_number(CG(active_op_array));
+	zend_compile_expr_list(&result, cond_ast TSRMLS_CC);
+	zend_do_extended_info(TSRMLS_C);
+
+	opnum_jmpz = zend_emit_cond_jump(ZEND_JMPZ, &result, 0 TSRMLS_CC);
+	zend_begin_loop(TSRMLS_C);
+
+	zend_compile_stmt(stmt_ast TSRMLS_CC);
+
+	opnum_loop = get_next_op_number(CG(active_op_array));
+	zend_compile_expr_list(&result, loop_ast TSRMLS_CC);
+	zend_do_free(&result TSRMLS_CC);
+
+	zend_emit_jump(opnum_cond TSRMLS_CC);
+
+	zend_update_jump_target_to_next(opnum_jmpz TSRMLS_CC);
+
+	zend_end_loop(opnum_loop, 0 TSRMLS_CC);
 }
-/* }}} */
 
-void zend_do_foreach_begin(znode *foreach_token, znode *open_brackets_token, znode *array, znode *as_token, int variable TSRMLS_DC) /* {{{ */
-{
+void zend_compile_foreach(zend_ast *ast TSRMLS_DC) {
+	zend_ast *expr_ast = ast->child[0];
+	zend_ast *value_ast = ast->child[1];
+	zend_ast *key_ast = ast->child[2];
+	zend_ast *stmt_ast = ast->child[3];
+	zend_bool by_ref = value_ast->kind == ZEND_AST_REF;
+	zend_bool is_variable = zend_is_variable(expr_ast) && !zend_is_call(expr_ast)
+		&& zend_can_write_to_variable(expr_ast);
+
+	znode expr_node, reset_node, value_node, key_node, dummy_node;
 	zend_op *opline;
-	zend_bool is_variable;
-	zend_op dummy_opline;
+	uint32_t opnum_reset, opnum_fetch;
+	zend_op foreach_stack_opline;
 
-	if (variable) {
-		if (zend_is_function_or_method_call(array)) {
-			is_variable = 0;
-		} else {
-			is_variable = 1;
+	if (key_ast) {
+		if (key_ast->kind == ZEND_AST_REF) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Key element cannot be a reference");
+		}
+		if (key_ast->kind == ZEND_AST_LIST) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Cannot use list as key element");
 		}
-		/* save the location of FETCH_W instruction(s) */
-		open_brackets_token->u.op.opline_num = get_next_op_number(CG(active_op_array));
-		zend_do_end_variable_parse(array, BP_VAR_W, 0 TSRMLS_CC);
-	} else {
-		is_variable = 0;
-		open_brackets_token->u.op.opline_num = get_next_op_number(CG(active_op_array));
 	}
 
-	/* save the location of FE_RESET */
-	foreach_token->u.op.opline_num = get_next_op_number(CG(active_op_array));
+	if (by_ref) {
+		value_ast = value_ast->child[0];
+	}
 
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	if (by_ref && is_variable) {
+		zend_compile_var(&expr_node, expr_ast, BP_VAR_W TSRMLS_CC);
+	} else {
+		zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
+	}
 
-	/* Preform array reset */
-	opline->opcode = ZEND_FE_RESET;
-	opline->result_type = IS_VAR;
-	opline->result.var = get_temporary_variable(CG(active_op_array));
-	SET_NODE(opline->op1, array);
-	SET_UNUSED(opline->op2);
-	opline->extended_value = is_variable ? ZEND_FE_RESET_VARIABLE : 0;
+	opnum_reset = get_next_op_number(CG(active_op_array));
+	opline = zend_emit_op(&reset_node, ZEND_FE_RESET, &expr_node, NULL TSRMLS_CC);
+	if (by_ref && is_variable) {
+		opline->extended_value = ZEND_FE_RESET_VARIABLE | ZEND_FE_RESET_REFERENCE; // ???
+	}
 
-	COPY_NODE(dummy_opline.result, opline->result);
-	zend_stack_push(&CG(foreach_copy_stack), (void *) &dummy_opline);
+	SET_NODE(foreach_stack_opline.result, &reset_node);
+	zend_stack_push(&CG(foreach_copy_stack), &foreach_stack_opline);
 
-	/* save the location of FE_FETCH */
-	as_token->u.op.opline_num = get_next_op_number(CG(active_op_array));
+	opnum_fetch = get_next_op_number(CG(active_op_array));
+	opline = zend_emit_op(&value_node, ZEND_FE_FETCH, &reset_node, NULL TSRMLS_CC);
+	if (by_ref) {
+		opline->extended_value |= ZEND_FE_FETCH_BYREF;
+	}
+	if (key_ast) {
+		opline->extended_value |= ZEND_FE_FETCH_WITH_KEY;
+	}
 
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	opline->opcode = ZEND_FE_FETCH;
-	opline->result_type = IS_VAR;
-	opline->result.var = get_temporary_variable(CG(active_op_array));
-	COPY_NODE(opline->op1, dummy_opline.result);
-	opline->extended_value = 0;
-	SET_UNUSED(opline->op2);
+	opline = zend_emit_op(NULL, ZEND_OP_DATA, NULL, NULL TSRMLS_CC);
 
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	opline->opcode = ZEND_OP_DATA;
 	/* Allocate enough space to keep HashPointer on VM stack */
 	opline->op1_type = IS_TMP_VAR;
 	opline->op1.var = get_temporary_variable(CG(active_op_array));
 	if (sizeof(HashPointer) > sizeof(zval)) {
-		/* Make shure 1 zval is enough for HashPointer (2 must be enough) */
+		/* Make sure 1 zval is enough for HashPointer (2 must be enough) */
 		get_temporary_variable(CG(active_op_array));
 	}
-	SET_UNUSED(opline->op2);
-	SET_UNUSED(opline->result);
-}
-/* }}} */
 
-void zend_do_foreach_cont(znode *foreach_token, const znode *open_brackets_token, const znode *as_token, znode *value, znode *key TSRMLS_DC) /* {{{ */
-{
-	zend_op *opline;
-	znode dummy, value_node;
-	zend_bool assign_by_ref=0;
+	if (key_ast) {
+		zend_make_tmp_result(&key_node, opline TSRMLS_CC);
+	}
+
+	if (value_ast->attr == ZEND_AST_LIST) {
+		zend_compile_list_assign(&dummy_node, value_ast, &value_node TSRMLS_CC);
+		zend_do_free(&dummy_node TSRMLS_CC);
+	} else if (by_ref) {
+		zend_emit_assign_ref_znode(value_ast, &value_node TSRMLS_CC);
+	} else {
+		zend_emit_assign_znode(value_ast, &value_node TSRMLS_CC);
+	}
+
+	if (key_ast) {
+		zend_emit_assign_znode(key_ast, &key_node TSRMLS_CC);
+	}
 
-	opline = &CG(active_op_array)->opcodes[as_token->u.op.opline_num];
-	if (key->op_type != IS_UNUSED) {
-		znode *tmp;
+	zend_begin_loop(TSRMLS_C);
 
-		/* switch between the key and value... */
-		tmp = key;
-		key = value;
-		value = tmp;
+	zend_compile_stmt(stmt_ast TSRMLS_CC);
 
-		/* Mark extended_value in case both key and value are being used */
-		opline->extended_value |= ZEND_FE_FETCH_WITH_KEY;
+	zend_emit_jump(opnum_fetch TSRMLS_CC);
+
+	opline = &CG(active_op_array)->opcodes[opnum_reset];
+	opline->op2.opline_num = get_next_op_number(CG(active_op_array));
+
+	opline = &CG(active_op_array)->opcodes[opnum_fetch];
+	opline->op2.opline_num = get_next_op_number(CG(active_op_array));
+
+	zend_end_loop(opnum_fetch, 1 TSRMLS_CC);
+
+	{
+		zend_op *container_ptr = zend_stack_top(&CG(foreach_copy_stack));
+		generate_free_foreach_copy(container_ptr TSRMLS_CC);
+		zend_stack_del_top(&CG(foreach_copy_stack));
 	}
+}
 
-	if ((key->op_type != IS_UNUSED)) {
-		if (key->EA & ZEND_PARSED_REFERENCE_VARIABLE) {
-			zend_error_noreturn(E_COMPILE_ERROR, "Key element cannot be a reference");
+void zend_compile_if(zend_ast *ast TSRMLS_DC) {
+	zend_ast_list *list = zend_ast_get_list(ast);
+	uint32_t i;
+	uint32_t *jmp_opnums = safe_emalloc(sizeof(uint32_t), list->children - 1, 0);
+
+	for (i = 0; i < list->children; ++i) {
+		zend_ast *elem_ast = list->child[i];
+		zend_ast *cond_ast = elem_ast->child[0];
+		zend_ast *stmt_ast = elem_ast->child[1];
+
+		znode cond_node;
+		uint32_t opnum_jmpz;
+		if (cond_ast) {
+			zend_compile_expr(&cond_node, cond_ast TSRMLS_CC);
+			opnum_jmpz = zend_emit_cond_jump(ZEND_JMPZ, &cond_node, 0 TSRMLS_CC);
 		}
-		if (key->EA & ZEND_PARSED_LIST_EXPR) {
-			zend_error_noreturn(E_COMPILE_ERROR, "Cannot use list as key element");
+
+		zend_compile_stmt(stmt_ast TSRMLS_CC);
+
+		if (i != list->children - 1) {
+			jmp_opnums[i] = zend_emit_jump(0 TSRMLS_CC);
+		}
+
+		if (cond_ast) {
+			zend_update_jump_target_to_next(opnum_jmpz TSRMLS_CC);
 		}
 	}
 
-	if (value->EA & ZEND_PARSED_REFERENCE_VARIABLE) {
-		assign_by_ref = 1;
+	for (i = 0; i < list->children - 1; ++i) {
+		zend_update_jump_target_to_next(jmp_opnums[i] TSRMLS_CC);
+	}
 
-		/* Mark extended_value for assign-by-reference */
-		opline->extended_value |= ZEND_FE_FETCH_BYREF;
-		CG(active_op_array)->opcodes[foreach_token->u.op.opline_num].extended_value |= ZEND_FE_RESET_REFERENCE;
-	} else {
-		zend_op *fetch = &CG(active_op_array)->opcodes[foreach_token->u.op.opline_num];
-		zend_op	*end = &CG(active_op_array)->opcodes[open_brackets_token->u.op.opline_num];
-
-		/* Change "write context" into "read context" */
-		fetch->extended_value = 0;  /* reset ZEND_FE_RESET_VARIABLE */
-		while (fetch != end) {
-			--fetch;
-			if (fetch->opcode == ZEND_FETCH_DIM_W && fetch->op2_type == IS_UNUSED) {
-				zend_error_noreturn(E_COMPILE_ERROR, "Cannot use [] for reading");
-			}
-			if (fetch->opcode == ZEND_SEPARATE) {
-				MAKE_NOP(fetch);
-			} else {
-				fetch->opcode -= 3; /* FETCH_W -> FETCH_R */
-			}
+	efree(jmp_opnums);
+}
+
+void zend_compile_switch(zend_ast *ast TSRMLS_DC) {
+	zend_ast *expr_ast = ast->child[0];
+	zend_ast_list *cases = zend_ast_get_list(ast->child[1]);
+
+	uint32_t i;
+	zend_bool has_default_case = 0;
+	zend_switch_entry switch_entry;
+
+	znode expr_node, case_node;
+	zend_op *opline;
+	uint32_t *jmpnz_opnums = safe_emalloc(sizeof(uint32_t), cases->children, 0);
+	uint32_t opnum_default_jmp;
+
+	zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
+
+	switch_entry.cond = expr_node;
+	switch_entry.default_case = -1;
+	switch_entry.control_var = -1;
+	zend_stack_push(&CG(switch_cond_stack), (void *) &switch_entry);
+
+	zend_begin_loop(TSRMLS_C);
+
+	case_node.op_type = IS_TMP_VAR;
+	case_node.u.op.var = get_temporary_variable(CG(active_op_array));
+
+	for (i = 0; i < cases->children; ++i) {
+		zend_ast *case_ast = cases->child[i];
+		zend_ast *cond_ast = case_ast->child[0];
+		znode cond_node;
+
+		if (!cond_ast) {
+			has_default_case = 1;
+			continue;
 		}
-	}
 
-	GET_NODE(&value_node, opline->result);
+		zend_compile_expr(&cond_node, cond_ast TSRMLS_CC);
 
-	if (value->EA & ZEND_PARSED_LIST_EXPR) {
-		if (!CG(list_llist).head) {
-			zend_error_noreturn(E_COMPILE_ERROR, "Cannot use empty list");
+		opline = zend_emit_op(NULL, ZEND_CASE, &expr_node, &cond_node TSRMLS_CC);
+		SET_NODE(opline->result, &case_node);
+		if (opline->op1_type == IS_CONST) {
+			zval_copy_ctor(&CONSTANT(opline->op1.constant));
 		}
-		zend_do_list_end(&dummy, &value_node TSRMLS_CC);
-		zend_do_free(&dummy TSRMLS_CC);
-	} else {
-		if (assign_by_ref) {
-			zend_do_end_variable_parse(value, BP_VAR_W, 0 TSRMLS_CC);
-			/* Mark FE_FETCH as IS_VAR as it holds the data directly as a value */
-			zend_do_assign_ref(NULL, value, &value_node TSRMLS_CC);
+
+		jmpnz_opnums[i] = zend_emit_cond_jump(ZEND_JMPNZ, &case_node, 0 TSRMLS_CC);
+	}
+
+	opnum_default_jmp = zend_emit_jump(0 TSRMLS_CC);
+
+	for (i = 0; i < cases->children; ++i) {
+		zend_ast *case_ast = cases->child[i];
+		zend_ast *cond_ast = case_ast->child[0];
+		zend_ast *stmt_ast = case_ast->child[1];
+
+		if (cond_ast) {
+			zend_update_jump_target_to_next(jmpnz_opnums[i] TSRMLS_CC);
 		} else {
-			zend_do_assign(&dummy, value, &value_node TSRMLS_CC);
-			zend_do_free(&dummy TSRMLS_CC);
+			zend_update_jump_target_to_next(opnum_default_jmp TSRMLS_CC);
 		}
+
+		zend_compile_stmt(stmt_ast TSRMLS_CC);
 	}
 
-	if (key->op_type != IS_UNUSED) {
-		znode key_node;
+	if (!has_default_case) {
+		zend_update_jump_target_to_next(opnum_default_jmp TSRMLS_CC);
+	}
 
-		opline = &CG(active_op_array)->opcodes[as_token->u.op.opline_num+1];
-		opline->result_type = IS_TMP_VAR;
-		opline->result.opline_num = get_temporary_variable(CG(active_op_array));
-		GET_NODE(&key_node, opline->result);
+	zend_end_loop(get_next_op_number(CG(active_op_array)), 1 TSRMLS_CC);
 
-		zend_do_assign(&dummy, key, &key_node TSRMLS_CC);
-		zend_do_free(&dummy TSRMLS_CC);
+	if (expr_node.op_type == IS_VAR || expr_node.op_type == IS_TMP_VAR) {
+		zend_emit_op(NULL, expr_node.op_type == IS_TMP_VAR ? ZEND_FREE : ZEND_SWITCH_FREE,
+			&expr_node, NULL TSRMLS_CC);
+	} else if (expr_node.op_type == IS_CONST) {
+		zval_dtor(&expr_node.u.constant);
 	}
 
-	do_begin_loop(TSRMLS_C);
-	INC_BPC(CG(active_op_array));
+	zend_stack_del_top(&CG(switch_cond_stack));
+	efree(jmpnz_opnums);
 }
-/* }}} */
 
-void zend_do_foreach_end(const znode *foreach_token, const znode *as_token TSRMLS_DC) /* {{{ */
-{
-	zend_op *container_ptr;
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+void zend_compile_try(zend_ast *ast TSRMLS_DC) {
+	zend_ast *try_ast = ast->child[0];
+	zend_ast_list *catches = zend_ast_get_list(ast->child[1]);
+	zend_ast *finally_ast = ast->child[2];
 
-	opline->opcode = ZEND_JMP;
-	opline->op1.opline_num = as_token->u.op.opline_num;
-	SET_UNUSED(opline->op1);
-	SET_UNUSED(opline->op2);
+	uint32_t i;
+	zend_op *opline;
+	uint32_t try_catch_offset = zend_add_try_element(
+		get_next_op_number(CG(active_op_array)) TSRMLS_CC);
+	uint32_t *jmp_opnums = safe_emalloc(sizeof(uint32_t), catches->children, 0);
+
+	if (catches->children == 0 && !finally_ast) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Cannot use try without catch or finally");
+	}
 
-	CG(active_op_array)->opcodes[foreach_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array)); /* FE_RESET */
-	CG(active_op_array)->opcodes[as_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array)); /* FE_FETCH */
+	zend_compile_stmt(try_ast TSRMLS_CC);
 
-	do_end_loop(as_token->u.op.opline_num, 1 TSRMLS_CC);
+	if (catches->children != 0) {
+		jmp_opnums[0] = zend_emit_jump(0 TSRMLS_CC);
+	}
 
-	container_ptr = zend_stack_top(&CG(foreach_copy_stack));
-	generate_free_foreach_copy(container_ptr TSRMLS_CC);
-	zend_stack_del_top(&CG(foreach_copy_stack));
+	for (i = 0; i < catches->children; ++i) {
+		zend_ast *catch_ast = catches->child[i];
+		zend_ast *class_ast = catch_ast->child[0];
+		zend_ast *var_ast = catch_ast->child[1];
+		zend_ast *stmt_ast = catch_ast->child[2];
+		zval *var_name = zend_ast_get_zval(var_ast);
+		zend_bool is_last_catch = (i + 1 == catches->children);
+
+		uint32_t opnum_catch;
+
+		if (!zend_is_const_default_class_ref(class_ast)) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Bad class name in the catch statement");
+		}
+
+		opnum_catch = get_next_op_number(CG(active_op_array));
+		if (i == 0) {
+			CG(active_op_array)->try_catch_array[try_catch_offset].catch_op = opnum_catch;
+		}
+
+		CG(zend_lineno) = catch_ast->lineno;
+
+		opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+		opline->opcode = ZEND_CATCH;
+		opline->op1_type = IS_CONST;
+		opline->op1.constant = zend_add_class_name_literal(CG(active_op_array),
+			zend_resolve_class_name_ast(class_ast TSRMLS_CC) TSRMLS_CC);
+
+		opline->op2_type = IS_CV;
+		opline->op2.var = lookup_cv(CG(active_op_array), zend_string_copy(Z_STR_P(var_name)) TSRMLS_CC);
+		opline->result.num = is_last_catch;
+
+		zend_compile_stmt(stmt_ast TSRMLS_CC);
 
-	DEC_BPC(CG(active_op_array));
+		if (!is_last_catch) {
+			jmp_opnums[i + 1] = zend_emit_jump(0 TSRMLS_CC);
+		}
+
+		opline = &CG(active_op_array)->opcodes[opnum_catch];
+		opline->extended_value = get_next_op_number(CG(active_op_array));
+	}
+
+	for (i = 0; i < catches->children; ++i) {
+		zend_update_jump_target_to_next(jmp_opnums[i] TSRMLS_CC);
+	}
+
+	if (finally_ast) {
+		uint32_t opnum_jmp = get_next_op_number(CG(active_op_array)) + 1;
+
+		opline = zend_emit_op(NULL, ZEND_FAST_CALL, NULL, NULL TSRMLS_CC);
+		opline->op1.opline_num = opnum_jmp + 1;
+
+		zend_emit_op(NULL, ZEND_JMP, NULL, NULL TSRMLS_CC);
+
+		CG(context).in_finally++;
+		zend_compile_stmt(finally_ast TSRMLS_CC);
+		CG(context).in_finally--;
+
+		CG(active_op_array)->try_catch_array[try_catch_offset].finally_op = opnum_jmp + 1;
+		CG(active_op_array)->try_catch_array[try_catch_offset].finally_end
+			= get_next_op_number(CG(active_op_array));
+		CG(active_op_array)->has_finally_block = 1;
+
+		zend_emit_op(NULL, ZEND_FAST_RET, NULL, NULL TSRMLS_CC);
+
+		zend_update_jump_target_to_next(opnum_jmp TSRMLS_CC);
+	}
+
+	efree(jmp_opnums);
 }
-/* }}} */
 
-void zend_do_declare_begin(TSRMLS_D) /* {{{ */
-{
-	zend_stack_push(&CG(declare_stack), &CG(declarables));
+/* Encoding declarations must already be handled during parsing */
+void zend_handle_encoding_declaration(zend_ast_list *declares TSRMLS_DC) {
+	uint32_t i;
+	for (i = 0; i < declares->children; ++i) {
+		zend_ast *declare_ast = declares->child[i];
+		zend_ast *name_ast = declare_ast->child[0];
+		zend_ast *value_ast = declare_ast->child[1];
+		zend_string *name = zend_ast_get_str(name_ast);
+
+		if (zend_str_equals_literal_ci(name, "encoding")) {
+			if (value_ast->kind != ZEND_AST_ZVAL) {
+				zend_error_noreturn(E_COMPILE_ERROR, "Encoding must be a literal");
+			}
+
+			if (CG(multibyte)) {
+				zend_string *encoding_name = zval_get_string(zend_ast_get_zval(value_ast));
+
+				const zend_encoding *new_encoding, *old_encoding;
+				zend_encoding_filter old_input_filter;
+
+				CG(encoding_declared) = 1;
+
+				new_encoding = zend_multibyte_fetch_encoding(encoding_name->val TSRMLS_CC);
+				if (!new_encoding) {
+					zend_error(E_COMPILE_WARNING, "Unsupported encoding [%s]", encoding_name->val);
+				} else {
+					old_input_filter = LANG_SCNG(input_filter);
+					old_encoding = LANG_SCNG(script_encoding);
+					zend_multibyte_set_filter(new_encoding TSRMLS_CC);
+
+					/* need to re-scan if input filter changed */
+					if (old_input_filter != LANG_SCNG(input_filter) ||
+						 (old_input_filter && new_encoding != old_encoding)) {
+						zend_multibyte_yyinput_again(old_input_filter, old_encoding TSRMLS_CC);
+					}
+				}
+
+				zend_string_release(encoding_name);
+			} else {
+				zend_error(E_COMPILE_WARNING, "declare(encoding=...) ignored because "
+					"Zend multibyte feature is turned off by settings");
+			}
+		}
+	}
 }
-/* }}} */
 
-void zend_do_declare_stmt(znode *var, znode *val TSRMLS_DC) /* {{{ */
-{
-	if (!zend_binary_strcasecmp(Z_STRVAL(var->u.constant), Z_STRLEN(var->u.constant), "ticks", sizeof("ticks")-1)) {
-		convert_to_long(&val->u.constant);
-		CG(declarables).ticks = val->u.constant;
-	} else if (!zend_binary_strcasecmp(Z_STRVAL(var->u.constant), Z_STRLEN(var->u.constant), "encoding", sizeof("encoding")-1)) {
-		if (Z_TYPE(val->u.constant) == IS_CONSTANT) {
-			zend_error_noreturn(E_COMPILE_ERROR, "Cannot use constants as encoding");
-		}
-
-		/*
-		 * Check that the pragma comes before any opcodes. If the compilation
-		 * got as far as this, the previous portion of the script must have been
-		 * parseable according to the .ini script_encoding setting. We still
-		 * want to tell them to put declare() at the top.
-		 */
-		{
-			int num = CG(active_op_array)->last;
-			/* ignore ZEND_EXT_STMT and ZEND_TICKS */
+void zend_compile_declare(zend_ast *ast TSRMLS_DC) {
+	zend_ast_list *declares = zend_ast_get_list(ast->child[0]);
+	zend_ast *stmt_ast = ast->child[1];
+	zend_declarables orig_declarables = CG(declarables);
+	uint32_t i;
+
+	for (i = 0; i < declares->children; ++i) {
+		zend_ast *declare_ast = declares->child[i];
+		zend_ast *name_ast = declare_ast->child[0];
+		zend_ast *value_ast = declare_ast->child[1];
+
+		zend_string *name = zend_ast_get_str(name_ast);
+		if (zend_str_equals_literal_ci(name, "ticks")) {
+			zval value_zv;
+			zend_const_expr_to_zval(&value_zv, value_ast TSRMLS_CC);
+			convert_to_long(&value_zv);
+			ZVAL_COPY_VALUE(&CG(declarables).ticks, &value_zv);
+			zval_dtor(&value_zv);
+		} else if (zend_str_equals_literal_ci(name, "encoding")) {
+			/* Encoding declaration was already handled during parsing. Here we
+			 * only check that it is the first statement in the file. */
+			uint32_t num = CG(active_op_array)->last;
 			while (num > 0 &&
-			       (CG(active_op_array)->opcodes[num-1].opcode == ZEND_EXT_STMT ||
-			        CG(active_op_array)->opcodes[num-1].opcode == ZEND_TICKS)) {
+				   (CG(active_op_array)->opcodes[num-1].opcode == ZEND_EXT_STMT ||
+					CG(active_op_array)->opcodes[num-1].opcode == ZEND_TICKS)) {
 				--num;
 			}
 
 			if (num > 0) {
-				zend_error_noreturn(E_COMPILE_ERROR, "Encoding declaration pragma must be the very first statement in the script");
+				zend_error_noreturn(E_COMPILE_ERROR, "Encoding declaration pragma must be "
+					"the very first statement in the script");
+			}
+		} else {
+			zend_error(E_COMPILE_WARNING, "Unsupported declare '%s'", name->val);
+		}
+	}
+
+	if (stmt_ast) {
+		zend_compile_stmt(stmt_ast TSRMLS_CC);
+
+		CG(declarables) = orig_declarables;
+	}
+}
+
+void zend_compile_stmt_list(zend_ast *ast TSRMLS_DC) {
+	zend_ast_list *list = zend_ast_get_list(ast);
+	uint32_t i;
+	for (i = 0; i < list->children; ++i) {
+		zend_compile_stmt(list->child[i] TSRMLS_CC);
+	}
+}
+
+void zend_compile_params(zend_ast *ast TSRMLS_DC) {
+	zend_ast_list *list = zend_ast_get_list(ast);
+	uint32_t i;
+	zend_op_array *op_array = CG(active_op_array);
+	zend_arg_info *arg_infos;
+
+	if (list->children == 0) {
+		return;
+	}
+	
+	arg_infos = safe_emalloc(sizeof(zend_arg_info), list->children, 0);
+	for (i = 0; i < list->children; ++i) {
+		zend_ast *param_ast = list->child[i];
+		zend_ast *type_ast = param_ast->child[0];
+		zend_ast *var_ast = param_ast->child[1];
+		zend_ast *default_ast = param_ast->child[2];
+		zend_string *name = zend_ast_get_str(var_ast);
+		zend_bool is_ref = (param_ast->attr & ZEND_PARAM_REF) != 0;
+		zend_bool is_variadic = (param_ast->attr & ZEND_PARAM_VARIADIC) != 0;
+
+		znode var_node, default_node;
+		zend_uchar opcode;
+		zend_op *opline;
+		zend_arg_info *arg_info;
+
+		if (zend_is_auto_global(name TSRMLS_CC)) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign auto-global variable %s",
+				name->val);
+		}
+
+		var_node.op_type = IS_CV;
+		var_node.u.op.var = lookup_cv(CG(active_op_array), zend_string_copy(name) TSRMLS_CC);
+
+		if (EX_VAR_TO_NUM(var_node.u.op.var) != i) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Redefinition of parameter $%s",
+				name->val);
+		} else if (zend_str_equals_literal(name, "this")) {
+			if (op_array->scope && (op_array->fn_flags & ZEND_ACC_STATIC) == 0) {
+				zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this");
 			}
+			op_array->this_var = var_node.u.op.var;
 		}
 
-		if (CG(multibyte)) {
-			const zend_encoding *new_encoding, *old_encoding;
-			zend_encoding_filter old_input_filter;
+		if (op_array->fn_flags & ZEND_ACC_VARIADIC) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Only the last parameter can be variadic");
+		}
 
-			CG(encoding_declared) = 1;
+		if (is_variadic) {
+			opcode = ZEND_RECV_VARIADIC;
+			default_node.op_type = IS_UNUSED;
+			op_array->fn_flags |= ZEND_ACC_VARIADIC;
 
-			convert_to_string(&val->u.constant);
-			new_encoding = zend_multibyte_fetch_encoding(Z_STRVAL(val->u.constant) TSRMLS_CC);
-			if (!new_encoding) {
-				zend_error(E_COMPILE_WARNING, "Unsupported encoding [%s]", Z_STRVAL(val->u.constant));
+			if (default_ast) {
+				zend_error_noreturn(E_COMPILE_ERROR,
+					"Variadic parameter cannot have a default value");
+			}
+		} else if (default_ast) {
+			opcode = ZEND_RECV_INIT;
+			default_node.op_type = IS_CONST;
+			zend_const_expr_to_zval(&default_node.u.constant, default_ast TSRMLS_CC);
+		} else {
+			opcode = ZEND_RECV;
+			default_node.op_type = IS_UNUSED;
+			op_array->required_num_args = i + 1;
+		}
+
+		opline = zend_emit_op(NULL, opcode, NULL, &default_node TSRMLS_CC);
+		SET_NODE(opline->result, &var_node);
+		opline->op1.num = i + 1;
+
+		arg_info = &arg_infos[i];
+		arg_info->name = estrndup(name->val, name->len);
+		arg_info->name_len = name->len;
+		arg_info->pass_by_reference = is_ref;
+		arg_info->is_variadic = is_variadic;
+		arg_info->type_hint = 0;
+		arg_info->allow_null = 1;
+		arg_info->class_name = NULL;
+		arg_info->class_name_len = 0;
+
+		if (type_ast) {
+			zend_bool has_null_default = default_ast
+				&& (Z_TYPE(default_node.u.constant) == IS_NULL
+					|| (Z_TYPE(default_node.u.constant) == IS_CONSTANT
+						&& strcasecmp(Z_STRVAL(default_node.u.constant), "NULL"))
+					|| Z_TYPE(default_node.u.constant) == IS_CONSTANT_AST); // ???
+
+			op_array->fn_flags |= ZEND_ACC_HAS_TYPE_HINTS;
+			arg_info->allow_null = has_null_default;
+
+			if (type_ast->kind == ZEND_AST_TYPE) {
+				arg_info->type_hint = type_ast->attr;
+				if (arg_info->type_hint == IS_ARRAY) {
+					if (default_ast && !has_null_default
+						&& Z_TYPE(default_node.u.constant) != IS_ARRAY
+					) {
+						zend_error_noreturn(E_COMPILE_ERROR, "Default value for parameters "
+							"with array type hint can only be an array or NULL");
+					}
+				} else if (arg_info->type_hint == IS_CALLABLE && default_ast) {
+					if (default_ast && !has_null_default) {
+						zend_error_noreturn(E_COMPILE_ERROR, "Default value for parameters "
+							"with callable type hint can only be NULL");
+					}
+				}
 			} else {
-				old_input_filter = LANG_SCNG(input_filter);
-				old_encoding = LANG_SCNG(script_encoding);
-				zend_multibyte_set_filter(new_encoding TSRMLS_CC);
-
-				/* need to re-scan if input filter changed */
-				if (old_input_filter != LANG_SCNG(input_filter) ||
-					 (old_input_filter && new_encoding != old_encoding)) {
-					zend_multibyte_yyinput_again(old_input_filter, old_encoding TSRMLS_CC);
+				zend_string *class_name = zend_ast_get_str(type_ast);
+
+				if (zend_is_const_default_class_ref(type_ast)) {
+					class_name = zend_resolve_class_name_ast(type_ast TSRMLS_CC);
+				} else {
+					zend_string_addref(class_name);
+				}
+
+				arg_info->type_hint = IS_OBJECT;
+				arg_info->class_name = estrndup(class_name->val, class_name->len);
+				arg_info->class_name_len = class_name->len;
+
+				zend_string_release(class_name);
+
+				if (default_ast && !has_null_default) {
+						zend_error_noreturn(E_COMPILE_ERROR, "Default value for parameters "
+							"with a class type hint can only be NULL");
 				}
 			}
-		} else {
-			zend_error(E_COMPILE_WARNING, "declare(encoding=...) ignored because Zend multibyte feature is turned off by settings");
 		}
-		zval_dtor(&val->u.constant);
-	} else {
-		zend_error(E_COMPILE_WARNING, "Unsupported declare '%s'", Z_STRVAL(var->u.constant));
-		zval_dtor(&val->u.constant);
 	}
-	zval_dtor(&var->u.constant);
+
+	/* These are assigned at the end to avoid unitialized memory in case of an error */
+	op_array->num_args = list->children;
+	op_array->arg_info = arg_infos;
 }
-/* }}} */
 
-void zend_do_declare_end(const znode *declare_token TSRMLS_DC) /* {{{ */
-{
-	zend_declarables *declarables = zend_stack_top(&CG(declare_stack));
-	/* We should restore if there was more than (current - start) - (ticks?1:0) opcodes */
-	if ((get_next_op_number(CG(active_op_array)) - declare_token->u.op.opline_num) - ((Z_LVAL(CG(declarables).ticks))?1:0)) {
-		CG(declarables) = *declarables;
+void zend_compile_closure_uses(zend_ast *ast TSRMLS_DC) {
+	zend_ast_list *list = zend_ast_get_list(ast);
+	uint32_t i;
+
+	for (i = 0; i < list->children; ++i) {
+		zend_ast *var_ast = list->child[i];
+		zend_string *name = zend_ast_get_str(var_ast);
+		zend_bool by_ref = var_ast->attr;
+		zval zv;
+
+		if (zend_str_equals_literal(name, "this")) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Cannot use $this as lexical variable");
+		}
+
+		ZVAL_NULL(&zv);
+		Z_CONST_FLAGS(zv) = by_ref ? IS_LEXICAL_REF : IS_LEXICAL_VAR;
+
+		zend_compile_static_var_common(var_ast, &zv, by_ref TSRMLS_CC);
 	}
 }
-/* }}} */
 
-void zend_do_exit(znode *result, znode *message TSRMLS_DC) /* {{{ */
-{
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+void zend_begin_method_decl(
+	zend_op_array *op_array, zend_string *name, zend_bool has_body TSRMLS_DC
+) {
+	zend_class_entry *ce = CG(active_class_entry);
+	zend_bool in_interface = (ce->ce_flags & ZEND_ACC_INTERFACE) != 0;
+	zend_bool in_trait = ZEND_CE_IS_TRAIT(ce);
+	zend_bool is_public = (op_array->fn_flags & ZEND_ACC_PUBLIC) != 0;
+	zend_bool is_static = (op_array->fn_flags & ZEND_ACC_STATIC) != 0;
 
-	opline->opcode = ZEND_EXIT;
-	SET_NODE(opline->op1, message);
-	SET_UNUSED(opline->op2);
+	zend_string *lcname;
 
-	result->op_type = IS_CONST;
-	ZVAL_BOOL(&result->u.constant, 1);
-}
-/* }}} */
+	if (in_interface) {
+		if ((op_array->fn_flags & ZEND_ACC_PPP_MASK) != ZEND_ACC_PUBLIC) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Access type for interface method "
+				"%s::%s() must be omitted", ce->name->val, name->val);
+		}
+		op_array->fn_flags |= ZEND_ACC_ABSTRACT;
+	} else if (is_static && (op_array->fn_flags & ZEND_ACC_ABSTRACT)) {
+		zend_error(E_STRICT, "Static function %s::%s() should not be abstract",
+			ce->name->val, name->val);
+	}
 
-void zend_do_begin_silence(znode *strudel_token TSRMLS_DC) /* {{{ */
-{
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	if (op_array->fn_flags & ZEND_ACC_ABSTRACT) {
+		//zend_op *opline;
 
-	opline->opcode = ZEND_BEGIN_SILENCE;
-	opline->result_type = IS_TMP_VAR;
-	opline->result.var = get_temporary_variable(CG(active_op_array));
-	SET_UNUSED(opline->op1);
-	SET_UNUSED(opline->op2);
-	GET_NODE(strudel_token, opline->result);
-}
-/* }}} */
+		if (op_array->fn_flags & ZEND_ACC_PRIVATE) {
+			zend_error_noreturn(E_COMPILE_ERROR, "%s function %s::%s() cannot be declared private",
+				in_interface ? "Interface" : "Abstract", ce->name->val, name->val);
+		}
 
-void zend_do_end_silence(znode *strudel_token TSRMLS_DC) /* {{{ */
-{
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+		if (has_body) {
+			zend_error_noreturn(E_COMPILE_ERROR, "%s function %s::%s() cannot contain body",
+				in_interface ? "Interface" : "Abstract", ce->name->val, name->val);
+		}
 
-	opline->opcode = ZEND_END_SILENCE;
-	SET_NODE(opline->op1, strudel_token);
-	SET_UNUSED(opline->op2);
-}
-/* }}} */
+		ce->ce_flags |= ZEND_ACC_IMPLICIT_ABSTRACT_CLASS;
 
-void zend_do_jmp_set(znode *value, znode *jmp_token, znode *colon_token TSRMLS_DC) /* {{{ */
-{
-	int op_number = get_next_op_number(CG(active_op_array));
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+		/*opline = get_next_op(op_array TSRMLS_CC);
+		opline->opcode = ZEND_RAISE_ABSTRACT_ERROR;
+		SET_UNUSED(opline->op1);
+		SET_UNUSED(opline->op2);*/
+	} else if (!has_body) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Non-abstract method %s::%s() must contain body",
+			ce->name->val, name->val);
+	}
 
-	if (value->op_type == IS_VAR || value->op_type == IS_CV) {
-		opline->opcode = ZEND_JMP_SET_VAR;
-		opline->result_type = IS_VAR;
+	op_array->scope = ce;
+	op_array->function_name = zend_string_copy(name);
+
+	lcname = zend_string_alloc(name->len, 0);
+	zend_str_tolower_copy(lcname->val, name->val, name->len);
+	lcname = zend_new_interned_string(lcname TSRMLS_CC);
+
+	if (zend_hash_add_ptr(&ce->function_table, lcname, op_array) == NULL) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare %s::%s()",
+			ce->name->val, name->val);
+	}
+
+	if (in_interface) {
+		if (zend_str_equals_literal(lcname, ZEND_CALL_FUNC_NAME)) {
+			if (!is_public || is_static) {
+				zend_error(E_WARNING, "The magic method __call() must have "
+					"public visibility and cannot be static");
+			}
+		} else if (zend_str_equals_literal(lcname, ZEND_CALLSTATIC_FUNC_NAME)) {
+			if (!is_public || !is_static) {
+				zend_error(E_WARNING, "The magic method __callStatic() must have "
+					"public visibility and be static");
+			}
+		} else if (zend_str_equals_literal(lcname, ZEND_GET_FUNC_NAME)) {
+			if (!is_public || is_static) {
+				zend_error(E_WARNING, "The magic method __get() must have "
+					"public visibility and cannot be static");
+			}
+		} else if (zend_str_equals_literal(lcname, ZEND_SET_FUNC_NAME)) {
+			if (!is_public || is_static) {
+				zend_error(E_WARNING, "The magic method __set() must have "
+					"public visibility and cannot be static");
+			}
+		} else if (zend_str_equals_literal(lcname, ZEND_UNSET_FUNC_NAME)) {
+			if (!is_public || is_static) {
+				zend_error(E_WARNING, "The magic method __unset() must have "
+					"public visibility and cannot be static");
+			}
+		} else if (zend_str_equals_literal(lcname, ZEND_ISSET_FUNC_NAME)) {
+			if (!is_public || is_static) {
+				zend_error(E_WARNING, "The magic method __isset() must have "
+					"public visibility and cannot be static");
+			}
+		} else if (zend_str_equals_literal(lcname, ZEND_TOSTRING_FUNC_NAME)) {
+			if (!is_public || is_static) {
+				zend_error(E_WARNING, "The magic method __toString() must have "
+					"public visibility and cannot be static");
+			}
+		} else if (zend_str_equals_literal(lcname, ZEND_INVOKE_FUNC_NAME)) {
+			if (!is_public || is_static) {
+				zend_error(E_WARNING, "The magic method __invoke() must have "
+					"public visibility and cannot be static");
+			}
+		} else if (zend_str_equals_literal(lcname, ZEND_DEBUGINFO_FUNC_NAME)) {
+			if (!is_public || is_static) {
+				zend_error(E_WARNING, "The magic method __debugInfo() must have "
+					"public visibility and cannot be static");
+			}
+		}
 	} else {
-		opline->opcode = ZEND_JMP_SET;
-		opline->result_type = IS_TMP_VAR;
+		if (!in_trait && zend_str_equals_str_ci(lcname, ce->name)) {
+			if (!ce->constructor) {
+				ce->constructor = (zend_function *) op_array;
+			}
+		} else if (zend_str_equals_literal(lcname, ZEND_CONSTRUCTOR_FUNC_NAME)) {
+			if (CG(active_class_entry)->constructor) {
+				zend_error(E_STRICT, "Redefining already defined constructor for class %s",
+					ce->name->val);
+			}
+			ce->constructor = (zend_function *) op_array;
+		} else if (zend_str_equals_literal(lcname, ZEND_DESTRUCTOR_FUNC_NAME)) {
+			ce->destructor = (zend_function *) op_array;
+		} else if (zend_str_equals_literal(lcname, ZEND_CLONE_FUNC_NAME)) {
+			ce->clone = (zend_function *) op_array;
+		} else if (zend_str_equals_literal(lcname, ZEND_CALL_FUNC_NAME)) {
+			if (!is_public || is_static) {
+				zend_error(E_WARNING, "The magic method __call() must have "
+					"public visibility and cannot be static");
+			}
+			ce->__call = (zend_function *) op_array;
+		} else if (zend_str_equals_literal(lcname, ZEND_CALLSTATIC_FUNC_NAME)) {
+			if (!is_public || !is_static) {
+				zend_error(E_WARNING, "The magic method __callStatic() must have "
+					"public visibility and be static");
+			}
+			ce->__callstatic = (zend_function *) op_array;
+		} else if (zend_str_equals_literal(lcname, ZEND_GET_FUNC_NAME)) {
+			if (!is_public || is_static) {
+				zend_error(E_WARNING, "The magic method __get() must have "
+					"public visibility and cannot be static");
+			}
+			ce->__get = (zend_function *) op_array;
+		} else if (zend_str_equals_literal(lcname, ZEND_SET_FUNC_NAME)) {
+			if (!is_public || is_static) {
+				zend_error(E_WARNING, "The magic method __set() must have "
+					"public visibility and cannot be static");
+			}
+			ce->__set = (zend_function *) op_array;
+		} else if (zend_str_equals_literal(lcname, ZEND_UNSET_FUNC_NAME)) {
+			if (!is_public || is_static) {
+				zend_error(E_WARNING, "The magic method __unset() must have "
+					"public visibility and cannot be static");
+			}
+			ce->__unset = (zend_function *) op_array;
+		} else if (zend_str_equals_literal(lcname, ZEND_ISSET_FUNC_NAME)) {
+			if (!is_public || is_static) {
+				zend_error(E_WARNING, "The magic method __isset() must have "
+					"public visibility and cannot be static");
+			}
+			ce->__isset = (zend_function *) op_array;
+		} else if (zend_str_equals_literal(lcname, ZEND_TOSTRING_FUNC_NAME)) {
+			if (!is_public || is_static) {
+				zend_error(E_WARNING, "The magic method __toString() must have "
+					"public visibility and cannot be static");
+			}
+			ce->__tostring = (zend_function *) op_array;
+		} else if (zend_str_equals_literal(lcname, ZEND_INVOKE_FUNC_NAME)) {
+			if (!is_public || is_static) {
+				zend_error(E_WARNING, "The magic method __invoke() must have "
+					"public visibility and cannot be static");
+			}
+		} else if (zend_str_equals_literal(lcname, ZEND_DEBUGINFO_FUNC_NAME)) {
+			if (!is_public || is_static) {
+				zend_error(E_WARNING, "The magic method __debugInfo() must have "
+					"public visibility and cannot be static");
+			}
+			ce->__debugInfo = (zend_function *) op_array;
+		} else if (!is_static) {
+			op_array->fn_flags |= ZEND_ACC_ALLOW_STATIC;
+		}
 	}
-	opline->result.var = get_temporary_variable(CG(active_op_array));
-	SET_NODE(opline->op1, value);
-	SET_UNUSED(opline->op2);
 
-	GET_NODE(colon_token, opline->result);
+	zend_string_release(lcname);
+}
 
-	jmp_token->u.op.opline_num = op_number;
+static void zend_begin_func_decl(
+	znode *result, zend_op_array *op_array, zend_ast_decl *decl TSRMLS_DC
+) {
+	zend_ast *params_ast = decl->child[0];
+	zend_string *name = decl->name, *lcname;
+	zend_op *opline;
 
-	INC_BPC(CG(active_op_array));
-}
-/* }}} */
+	op_array->function_name = name = zend_prefix_with_ns(name TSRMLS_CC);
 
-void zend_do_jmp_set_else(znode *result, znode *false_value, const znode *jmp_token, znode *colon_token TSRMLS_DC) /* {{{ */
-{
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	lcname = zend_string_alloc(name->len, 0);
+	zend_str_tolower_copy(lcname->val, name->val, name->len);
 
-	SET_NODE(opline->result, colon_token);
-	if (colon_token->op_type == IS_TMP_VAR) {
-		if (false_value->op_type == IS_VAR || false_value->op_type == IS_CV) {
-			CG(active_op_array)->opcodes[jmp_token->u.op.opline_num].opcode = ZEND_JMP_SET_VAR;
-			CG(active_op_array)->opcodes[jmp_token->u.op.opline_num].result_type = IS_VAR;
-			opline->opcode = ZEND_QM_ASSIGN_VAR;
-			opline->result_type = IS_VAR;
-		} else {
-			opline->opcode = ZEND_QM_ASSIGN;
+	if (CG(current_import_function)) {
+		zend_string *import_name = zend_hash_find_ptr(CG(current_import_function), lcname);
+		if (import_name && !zend_str_equals_str_ci(lcname, import_name)) {
+			zend_error(E_COMPILE_ERROR, "Cannot declare function %s "
+				"because the name is already in use", name->val);
 		}
+	}
+
+	if (zend_str_equals_literal(lcname, ZEND_AUTOLOAD_FUNC_NAME)
+		&& zend_ast_get_list(params_ast)->children != 1
+	) {
+		zend_error_noreturn(E_COMPILE_ERROR, "%s() must take exactly 1 argument",
+			ZEND_AUTOLOAD_FUNC_NAME);
+	}
+
+	if (op_array->fn_flags & ZEND_ACC_CLOSURE) {
+		opline = zend_emit_op_tmp(result, ZEND_DECLARE_LAMBDA_FUNCTION, NULL, NULL TSRMLS_CC);
 	} else {
-		opline->opcode = ZEND_QM_ASSIGN_VAR;
+		opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+		opline->opcode = ZEND_DECLARE_FUNCTION;
+		opline->op2_type = IS_CONST;
+		LITERAL_STR(opline->op2, zend_string_copy(lcname));
 	}
-	opline->extended_value = 0;
-	SET_NODE(opline->op1, false_value);
-	SET_UNUSED(opline->op2);
 
-	GET_NODE(result, opline->result);
+	{
+		zend_string *key = zend_build_runtime_definition_key(lcname, decl->lex_pos TSRMLS_CC);
+
+		opline->op1_type = IS_CONST;
+		LITERAL_STR(opline->op1, key);
 
-	CG(active_op_array)->opcodes[jmp_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array));
+		zend_hash_update_ptr(CG(function_table), key, op_array);
+	}
 
-	DEC_BPC(CG(active_op_array));
+	zend_string_release(lcname);
 }
-/* }}} */
 
-void zend_do_begin_qm_op(znode *cond, znode *qm_token TSRMLS_DC) /* {{{ */
-{
-	int jmpz_op_number = get_next_op_number(CG(active_op_array));
-	zend_op *opline;
+void zend_compile_func_decl(znode *result, zend_ast *ast TSRMLS_DC) {
+	zend_ast_decl *decl = (zend_ast_decl *) ast;
+	zend_ast *params_ast = decl->child[0];
+	zend_ast *uses_ast = decl->child[1];
+	zend_ast *stmt_ast = decl->child[2];
+	zend_bool is_method = decl->kind == ZEND_AST_METHOD;
 
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	zend_op_array *orig_op_array = CG(active_op_array);
+	zend_op_array *op_array = zend_arena_alloc(&CG(arena), sizeof(zend_op_array));
 
-	opline->opcode = ZEND_JMPZ;
-	SET_NODE(opline->op1, cond);
-	SET_UNUSED(opline->op2);
-	opline->op2.opline_num = jmpz_op_number;
-	GET_NODE(qm_token, opline->op2);
+	// TODO.AST interactive (not just here - also bpc etc!)
+	
+	init_op_array(op_array, ZEND_USER_FUNCTION, INITIAL_OP_ARRAY_SIZE TSRMLS_CC);
 
-	INC_BPC(CG(active_op_array));
-}
-/* }}} */
+	op_array->fn_flags |= decl->flags;
+	op_array->line_start = decl->start_lineno;
+	op_array->line_end = decl->end_lineno;
+	if (decl->doc_comment) {
+		op_array->doc_comment = zend_string_copy(decl->doc_comment);
+	}
+	if (decl->kind == ZEND_AST_CLOSURE) {
+		op_array->fn_flags |= ZEND_ACC_CLOSURE;
+	}
 
-void zend_do_qm_true(znode *true_value, znode *qm_token, znode *colon_token TSRMLS_DC) /* {{{ */
-{
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	if (is_method) {
+		zend_bool has_body = stmt_ast != NULL;
+		zend_begin_method_decl(op_array, decl->name, has_body TSRMLS_CC);
+	} else {
+		zend_begin_func_decl(result, op_array, decl TSRMLS_CC);
+	}
 
-	CG(active_op_array)->opcodes[qm_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array))+1; /* jmp over the ZEND_JMP */
+	CG(active_op_array) = op_array;
+	zend_stack_push(&CG(context_stack), (void *) &CG(context));
+	zend_init_compiler_context(TSRMLS_C);
 
-	if (true_value->op_type == IS_VAR || true_value->op_type == IS_CV) {
-		opline->opcode = ZEND_QM_ASSIGN_VAR;
-		opline->result_type = IS_VAR;
-	} else {
-		opline->opcode = ZEND_QM_ASSIGN;
-		opline->result_type = IS_TMP_VAR;
+	if (CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO) {
+		zend_op *opline_ext = zend_emit_op(NULL, ZEND_EXT_NOP, NULL, NULL TSRMLS_CC);
+		opline_ext->lineno = decl->start_lineno;
 	}
-	opline->result.var = get_temporary_variable(CG(active_op_array));
-	SET_NODE(opline->op1, true_value);
-	SET_UNUSED(opline->op2);
 
-	GET_NODE(qm_token, opline->result);
-	colon_token->u.op.opline_num = get_next_op_number(CG(active_op_array));
+	{
+		/* Push a separator to the switch stack */
+		zend_switch_entry switch_entry;
+
+		switch_entry.cond.op_type = IS_UNUSED;
+		switch_entry.default_case = 0;
+		switch_entry.control_var = 0;
 
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	opline->opcode = ZEND_JMP;
-	SET_UNUSED(opline->op1);
-	SET_UNUSED(opline->op2);
+		zend_stack_push(&CG(switch_cond_stack), (void *) &switch_entry);
+	}
+
+	{
+		/* Push a separator to the foreach stack */
+		zend_op dummy_opline;
+
+		dummy_opline.result_type = IS_UNUSED;
+
+		zend_stack_push(&CG(foreach_copy_stack), (void *) &dummy_opline);
+	}
+
+	zend_compile_params(params_ast TSRMLS_CC);
+	if (uses_ast) {
+		zend_compile_closure_uses(uses_ast TSRMLS_CC);
+	}
+	zend_compile_stmt(stmt_ast TSRMLS_CC);
+
+	if (is_method) {
+		zend_check_magic_method_implementation(
+			CG(active_class_entry), (zend_function *) op_array, E_COMPILE_ERROR TSRMLS_CC);
+	}
+
+	zend_do_extended_info(TSRMLS_C);
+	zend_emit_final_return(NULL TSRMLS_CC);
+
+	pass_two(CG(active_op_array) TSRMLS_CC);
+	zend_release_labels(0 TSRMLS_CC);
+
+	/* Pop the switch and foreach separators */
+	zend_stack_del_top(&CG(switch_cond_stack));
+	zend_stack_del_top(&CG(foreach_copy_stack));
+
+	CG(active_op_array) = orig_op_array;
 }
-/* }}} */
 
-void zend_do_qm_false(znode *result, znode *false_value, znode *qm_token, const znode *colon_token TSRMLS_DC) /* {{{ */
-{
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+void zend_compile_prop_decl(zend_ast *ast TSRMLS_DC) {
+	zend_ast_list *list = zend_ast_get_list(ast);
+	uint32_t flags = list->attr;
+	zend_class_entry *ce = CG(active_class_entry);
+	uint32_t i, children = list->children;
+	zend_string *doc_comment = NULL;
+
+	if (ce->ce_flags & ZEND_ACC_INTERFACE) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Interfaces may not include member variables");
+	}
+
+	if (flags & ZEND_ACC_ABSTRACT) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Properties cannot be declared abstract");
+	}
+
+	/* Doc comment has been appended as last element in property list */
+	if (list->child[children - 1]->kind == ZEND_AST_ZVAL) {
+		doc_comment = zend_string_copy(zend_ast_get_str(list->child[children - 1]));
+		children -= 1;
+	}
 
-	SET_NODE(opline->result, qm_token);
-	if (qm_token->op_type == IS_TMP_VAR) {
-		if (false_value->op_type == IS_VAR || false_value->op_type == IS_CV) {
-			CG(active_op_array)->opcodes[colon_token->u.op.opline_num - 1].opcode = ZEND_QM_ASSIGN_VAR;
-			CG(active_op_array)->opcodes[colon_token->u.op.opline_num - 1].result_type = IS_VAR;
-			opline->opcode = ZEND_QM_ASSIGN_VAR;
-			opline->result_type = IS_VAR;
+	for (i = 0; i < children; ++i) {
+		zend_ast *prop_ast = list->child[i];
+		zend_ast *name_ast = prop_ast->child[0];
+		zend_ast *value_ast = prop_ast->child[1];
+		zend_string *name = zend_ast_get_str(name_ast);
+		zval value_zv;
+
+		if (flags & ZEND_ACC_FINAL) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Cannot declare property %s::$%s final, "
+				"the final modifier is allowed only for methods and classes",
+				ce->name->val, name->val);
+		}
+
+		if (zend_hash_exists(&ce->properties_info, name)) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare %s::$%s",
+				ce->name->val, name->val);
+		}
+
+		if (value_ast) {
+			zend_const_expr_to_zval(&value_zv, value_ast TSRMLS_CC);
 		} else {
-			opline->opcode = ZEND_QM_ASSIGN;
+			ZVAL_NULL(&value_zv);
 		}
+
+		name = zend_new_interned_string_safe(name TSRMLS_CC);
+		zend_declare_property_ex(ce, name, &value_zv, flags, doc_comment TSRMLS_CC);
+
+		/* Doc comment is only assigned to first property */
+		doc_comment = NULL;
+	}
+}
+
+void zend_compile_class_const_decl(zend_ast *ast TSRMLS_DC) {
+	zend_ast_list *list = zend_ast_get_list(ast);
+	zend_class_entry *ce = CG(active_class_entry);
+	uint32_t i;
+
+	for (i = 0; i < list->children; ++i) {
+		zend_ast *const_ast = list->child[i];
+		zend_ast *name_ast = const_ast->child[0];
+		zend_ast *value_ast = const_ast->child[1];
+		zend_string *name = zend_ast_get_str(name_ast);
+		zval value_zv;
+
+		if (ZEND_CE_IS_TRAIT(ce)) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Traits cannot have constants");
+			return;
+		}
+
+		zend_const_expr_to_zval(&value_zv, value_ast TSRMLS_CC);
+
+		name = zend_new_interned_string_safe(name TSRMLS_CC);
+		if (zend_hash_add(&ce->constants_table, name, &value_zv) == NULL) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Cannot redefine class constant %s::%s",
+				ce->name->val, name->val);
+		}
+
+		if (Z_CONSTANT(value_zv)) {
+			ce->ce_flags &= ~ZEND_ACC_CONSTANTS_UPDATED;
+		}
+	}
+}
+
+static zend_trait_method_reference *zend_compile_method_ref(zend_ast *ast TSRMLS_DC) {
+	zend_ast *class_ast = ast->child[0];
+	zend_ast *method_ast = ast->child[1];
+
+	zend_trait_method_reference *method_ref = emalloc(sizeof(zend_trait_method_reference));
+	method_ref->ce = NULL;
+	method_ref->method_name = zend_string_copy(zend_ast_get_str(method_ast));
+
+	if (class_ast) {
+		method_ref->class_name = zend_resolve_class_name_ast(class_ast TSRMLS_CC);
 	} else {
-		opline->opcode = ZEND_QM_ASSIGN_VAR;
+		method_ref->class_name = NULL;
 	}
-	SET_NODE(opline->op1, false_value);
-	SET_UNUSED(opline->op2);
 
-	CG(active_op_array)->opcodes[colon_token->u.op.opline_num].op1.opline_num = get_next_op_number(CG(active_op_array));
+	return method_ref;
+}
 
-	GET_NODE(result, opline->result);
+static zend_string **zend_compile_name_list(zend_ast *ast TSRMLS_DC) {
+	zend_ast_list *list = zend_ast_get_list(ast);
+	zend_string **names = safe_emalloc(sizeof(zend_string *), list->children + 1, 0);
+	uint32_t i;
+
+	for (i = 0; i < list->children; ++i) {
+		zend_ast *name_ast = list->child[i];
+		names[i] = zend_resolve_class_name_ast(name_ast TSRMLS_CC);
+	}
+
+	names[list->children] = NULL;
 
-	DEC_BPC(CG(active_op_array));
+	return names;
 }
-/* }}} */
 
-void zend_do_extended_info(TSRMLS_D) /* {{{ */
-{
-	zend_op *opline;
+static void zend_compile_trait_precedence(zend_ast *ast TSRMLS_DC) {
+	zend_ast *method_ref_ast = ast->child[0];
+	zend_ast *insteadof_ast = ast->child[1];
+	
+	zend_trait_precedence *precedence = emalloc(sizeof(zend_trait_precedence));
+	precedence->trait_method = zend_compile_method_ref(method_ref_ast TSRMLS_CC);
+	precedence->exclude_from_classes
+		= (void *) zend_compile_name_list(insteadof_ast TSRMLS_CC);
 
-	if (!(CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO)) {
-		return;
+	zend_add_to_list(&CG(active_class_entry)->trait_precedences, precedence TSRMLS_CC);
+}
+
+static void zend_compile_trait_alias(zend_ast *ast TSRMLS_DC) {
+	zend_ast *method_ref_ast = ast->child[0];
+	zend_ast *alias_ast = ast->child[1];
+	uint32_t modifiers = ast->attr;
+
+	zend_trait_alias *alias;
+
+	if (modifiers == ZEND_ACC_STATIC) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Cannot use 'static' as method modifier");
+	} else if (modifiers == ZEND_ACC_ABSTRACT) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Cannot use 'abstract' as method modifier");
+	} else if (modifiers == ZEND_ACC_FINAL) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Cannot use 'final' as method modifier");
 	}
 
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	alias = emalloc(sizeof(zend_trait_alias));
+	alias->trait_method = zend_compile_method_ref(method_ref_ast TSRMLS_CC);
+	alias->modifiers = modifiers;
 
-	opline->opcode = ZEND_EXT_STMT;
-	SET_UNUSED(opline->op1);
-	SET_UNUSED(opline->op2);
+	if (alias_ast) {
+		alias->alias = zend_string_copy(zend_ast_get_str(alias_ast));
+	} else {
+		alias->alias = NULL;
+	}
+
+	zend_add_to_list(&CG(active_class_entry)->trait_aliases, alias TSRMLS_CC);
 }
-/* }}} */
 
-void zend_do_extended_fcall_begin(TSRMLS_D) /* {{{ */
-{
+void zend_compile_use_trait(zend_ast *ast TSRMLS_DC) {
+	zend_ast_list *traits = zend_ast_get_list(ast->child[0]);
+	zend_ast_list *adaptations = ast->child[1] ? zend_ast_get_list(ast->child[1]) : NULL;
+	zend_class_entry *ce = CG(active_class_entry);
 	zend_op *opline;
+	uint32_t i;
 
-	if (!(CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO)) {
+	for (i = 0; i < traits->children; ++i) {
+		zend_ast *trait_ast = traits->child[i];
+		zend_string *name = zend_ast_get_str(trait_ast);
+
+		if (ce->ce_flags & ZEND_ACC_INTERFACE) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Cannot use traits inside of interfaces. "
+				"%s is used in %s", name->val, ce->name->val);
+		}
+
+		switch (zend_get_class_fetch_type(name)) {
+			case ZEND_FETCH_CLASS_SELF:
+			case ZEND_FETCH_CLASS_PARENT:
+			case ZEND_FETCH_CLASS_STATIC:
+				zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as trait name "
+					"as it is reserved", name->val);
+				break;
+		}
+
+		opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+		opline->opcode = ZEND_ADD_TRAIT;
+		SET_NODE(opline->op1, &CG(implementing_class));
+		opline->extended_value = ZEND_FETCH_CLASS_TRAIT;
+		opline->op2_type = IS_CONST;
+		opline->op2.constant = zend_add_class_name_literal(CG(active_op_array),
+			zend_resolve_class_name_ast(trait_ast TSRMLS_CC) TSRMLS_CC);
+
+		ce->num_traits++;
+	}
+
+	if (!adaptations) {
 		return;
 	}
 
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	for (i = 0; i < adaptations->children; ++i) {
+		zend_ast *adaptation_ast = adaptations->child[i];
+		switch (adaptation_ast->kind) {
+			case ZEND_AST_TRAIT_PRECEDENCE:
+				zend_compile_trait_precedence(adaptation_ast TSRMLS_CC);
+				break;
+			case ZEND_AST_TRAIT_ALIAS:
+				zend_compile_trait_alias(adaptation_ast TSRMLS_CC);
+				break;
+			EMPTY_SWITCH_DEFAULT_CASE()
+		}
+	}
+}
 
-	opline->opcode = ZEND_EXT_FCALL_BEGIN;
-	SET_UNUSED(opline->op1);
-	SET_UNUSED(opline->op2);
+void zend_compile_implements(znode *class_node, zend_ast *ast TSRMLS_DC) {
+	zend_ast_list *list = zend_ast_get_list(ast);
+	uint32_t i;
+	for (i = 0; i < list->children; ++i) {
+		zend_ast *class_ast = list->child[i];
+		zend_string *name = zend_ast_get_str(class_ast);
+
+		zend_op *opline;
+
+		/* Traits can not implement interfaces */
+		if (ZEND_CE_IS_TRAIT(CG(active_class_entry))) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as interface on '%s' "
+				"since it is a Trait", name->val, CG(active_class_entry)->name->val);
+		}
+
+		if (!zend_is_const_default_class_ref(class_ast)) {
+			zend_error_noreturn(E_COMPILE_ERROR,
+				"Cannot use '%s' as interface name as it is reserved", name->val);
+		}
+
+		opline = zend_emit_op(NULL, ZEND_ADD_INTERFACE, class_node, NULL TSRMLS_CC);
+		opline->extended_value = ZEND_FETCH_CLASS_INTERFACE;
+		opline->op2_type = IS_CONST;
+		opline->op2.constant = zend_add_class_name_literal(CG(active_op_array),
+			zend_resolve_class_name_ast(class_ast TSRMLS_CC) TSRMLS_CC);
+
+		CG(active_class_entry)->num_interfaces++;
+	}
 }
-/* }}} */
 
-void zend_do_extended_fcall_end(TSRMLS_D) /* {{{ */
-{
+void zend_compile_class_decl(zend_ast *ast TSRMLS_DC) {
+	zend_ast_decl *decl = (zend_ast_decl *) ast;
+	zend_ast *extends_ast = decl->child[0];
+	zend_ast *implements_ast = decl->child[1];
+	zend_ast *stmt_ast = decl->child[2];
+
+	zend_string *name = decl->name, *lcname, *import_name = NULL;
+	zend_class_entry *ce = zend_arena_alloc(&CG(arena), sizeof(zend_class_entry));
 	zend_op *opline;
+	znode declare_node, extends_node;
 
-	if (!(CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO)) {
+	if (CG(active_class_entry)) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Class declarations may not be nested");
 		return;
 	}
 
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	if (ZEND_FETCH_CLASS_DEFAULT != zend_get_class_fetch_type(name)) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as class name as it is reserved",
+			name->val);
+	}
 
-	opline->opcode = ZEND_EXT_FCALL_END;
-	SET_UNUSED(opline->op1);
-	SET_UNUSED(opline->op2);
-}
-/* }}} */
+	lcname = zend_string_alloc(name->len, 0);
+	zend_str_tolower_copy(lcname->val, name->val, name->len);
 
-void zend_do_ticks(TSRMLS_D) /* {{{ */
-{
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	if (CG(current_import)) {
+		import_name = zend_hash_find_ptr(CG(current_import), lcname);
+	}
 
-	opline->opcode = ZEND_TICKS;
-	SET_UNUSED(opline->op1);
-	SET_UNUSED(opline->op2);
-	opline->extended_value = Z_LVAL(CG(declarables).ticks);
-}
-/* }}} */
+	if (CG(current_namespace)) {
+		name = zend_prefix_with_ns(name TSRMLS_CC);
 
-zend_bool zend_is_auto_global(zend_string *name TSRMLS_DC) /* {{{ */
-{
-	zend_auto_global *auto_global;
+		zend_string_release(lcname);
+		lcname = zend_string_alloc(name->len, 0);
+		zend_str_tolower_copy(lcname->val, name->val, name->len);
+	} else {
+		zend_string_addref(name);
+	}
 
-	if ((auto_global = zend_hash_find_ptr(CG(auto_globals), name)) != NULL) {
-		if (auto_global->armed) {
-			auto_global->armed = auto_global->auto_global_callback(auto_global->name TSRMLS_CC);
+	if (import_name && !zend_str_equals_str_ci(lcname, import_name)) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Cannot declare class %s "
+			"because the name is already in use", name->val);
+	}
+
+	name = zend_new_interned_string(name TSRMLS_CC);
+	lcname = zend_new_interned_string(lcname TSRMLS_CC);
+
+	ce->type = ZEND_USER_CLASS;
+	ce->name = name;
+	zend_initialize_class_data(ce, 1 TSRMLS_CC);
+
+	ce->ce_flags |= decl->flags;
+	ce->info.user.filename = zend_get_compiled_filename(TSRMLS_C);
+	ce->info.user.line_start = decl->start_lineno;
+	ce->info.user.line_end = decl->end_lineno;
+	if (decl->doc_comment) {
+		ce->info.user.doc_comment = zend_string_copy(decl->doc_comment);
+	}
+
+	if (extends_ast) {
+		if (ZEND_CE_IS_TRAIT(ce)) {
+			zend_error_noreturn(E_COMPILE_ERROR, "A trait (%s) cannot extend a class. "
+				"Traits can only be composed from other traits with the 'use' keyword. Error",
+				name->val);
 		}
-		return 1;
+
+		if (!zend_is_const_default_class_ref(extends_ast)) {
+			zend_string *extends_name = zend_ast_get_str(extends_ast);
+			zend_error_noreturn(E_COMPILE_ERROR,
+				"Cannot use '%s' as class name as it is reserved", extends_name->val);
+		}
+
+		zend_compile_class_ref(&extends_node, extends_ast TSRMLS_CC);
 	}
-	return 0;
-}
-/* }}} */
 
-int zend_register_auto_global(zend_string *name, zend_bool jit, zend_auto_global_callback auto_global_callback TSRMLS_DC) /* {{{ */
-{
-	zend_auto_global auto_global;
-	int retval;
+	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	zend_make_var_result(&declare_node, opline TSRMLS_CC);
 
-	auto_global.name = zend_new_interned_string(name TSRMLS_CC);
-	auto_global.auto_global_callback = auto_global_callback;
-	auto_global.jit = jit;
+	// TODO.AST drop this
+	GET_NODE(&CG(implementing_class), opline->result);
 
-	retval = zend_hash_add_mem(CG(auto_globals), name, &auto_global, sizeof(zend_auto_global)) != NULL ? SUCCESS : FAILURE;
+	opline->op2_type = IS_CONST;
+	LITERAL_STR(opline->op2, lcname);
 
-	zend_string_release(auto_global.name);
-	return retval;
-}
-/* }}} */
+	if (extends_ast) {
+		opline->opcode = ZEND_DECLARE_INHERITED_CLASS;
+		opline->extended_value = extends_node.u.op.var;
+	} else {
+		opline->opcode = ZEND_DECLARE_CLASS;
+	}
 
-ZEND_API void zend_activate_auto_globals(TSRMLS_D) /* {{{ */
-{
-	zend_auto_global *auto_global;
+	{
+		zend_string *key = zend_build_runtime_definition_key(lcname, decl->lex_pos TSRMLS_CC);
 
-	ZEND_HASH_FOREACH_PTR(CG(auto_globals), auto_global) {
-		if (auto_global->jit) {
-			auto_global->armed = 1;
-		} else if (auto_global->auto_global_callback) {
-			auto_global->armed = auto_global->auto_global_callback(auto_global->name TSRMLS_CC);
-		} else {
-			auto_global->armed = 0;
+		opline->op1_type = IS_CONST;
+		LITERAL_STR(opline->op1, key);
+
+		zend_hash_update_ptr(CG(class_table), key, ce);
+	}
+
+	CG(active_class_entry) = ce;
+
+	if (implements_ast) {
+		zend_compile_implements(&declare_node, implements_ast TSRMLS_CC);
+	}
+
+	zend_compile_stmt(stmt_ast TSRMLS_CC);
+
+	if (ce->constructor) {
+		ce->constructor->common.fn_flags |= ZEND_ACC_CTOR;
+		if (ce->constructor->common.fn_flags & ZEND_ACC_STATIC) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Constructor %s::%s() cannot be static",
+				ce->name->val, ce->constructor->common.function_name->val);
 		}
-	} ZEND_HASH_FOREACH_END();
-}
-/* }}} */
+	}
+	if (ce->destructor) {
+		ce->destructor->common.fn_flags |= ZEND_ACC_DTOR;
+		if (ce->destructor->common.fn_flags & ZEND_ACC_STATIC) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Destructor %s::%s() cannot be static",
+				ce->name->val, ce->destructor->common.function_name->val);
+		}
+	}
+	if (ce->clone) {
+		ce->clone->common.fn_flags |= ZEND_ACC_CLONE;
+		if (ce->clone->common.fn_flags & ZEND_ACC_STATIC) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Clone method %s::%s() cannot be static",
+				ce->name->val, ce->clone->common.function_name->val);
+		}
+	}
 
-int zendlex(znode *zendlval TSRMLS_DC) /* {{{ */
-{
-	int retval;
+	/* Check for traits and proceed like with interfaces.
+	 * The only difference will be a combined handling of them in the end.
+	 * Thus, we need another opcode here. */
+	if (ce->num_traits > 0) {
+		ce->traits = NULL;
+		ce->num_traits = 0;
+		ce->ce_flags |= ZEND_ACC_IMPLEMENT_TRAITS;
 
-	if (CG(increment_lineno)) {
-		CG(zend_lineno)++;
-		CG(increment_lineno) = 0;
+		zend_emit_op(NULL, ZEND_BIND_TRAITS, &declare_node, NULL TSRMLS_CC);
 	}
 
-again:
-	Z_TYPE_INFO(zendlval->u.constant) = IS_LONG;
-	retval = lex_scan(&zendlval->u.constant TSRMLS_CC);
-	switch (retval) {
-		case T_COMMENT:
-		case T_DOC_COMMENT:
-		case T_OPEN_TAG:
-		case T_WHITESPACE:
-			goto again;
+	if (!(ce->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS))
+		&& (extends_ast || ce->num_interfaces > 0)
+	) {
+		zend_verify_abstract_class(ce TSRMLS_CC);
+		if (ce->num_interfaces && !(ce->ce_flags & ZEND_ACC_IMPLEMENT_TRAITS)) {
+			zend_emit_op(NULL, ZEND_VERIFY_ABSTRACT_CLASS, &declare_node, NULL TSRMLS_CC);
+		}
+	}
 
-		case T_CLOSE_TAG:
-			if (LANG_SCNG(yy_text)[LANG_SCNG(yy_leng)-1] != '>') {
-				CG(increment_lineno) = 1;
+	/* Inherit interfaces; reset number to zero, we need it for above check and
+	 * will restore it during actual implementation.
+	 * The ZEND_ACC_IMPLEMENT_INTERFACES flag disables double call to
+	 * zend_verify_abstract_class() */
+	if (ce->num_interfaces > 0) {
+		ce->interfaces = NULL;
+		ce->num_interfaces = 0;
+		ce->ce_flags |= ZEND_ACC_IMPLEMENT_INTERFACES;
+	}
+
+	CG(active_class_entry) = NULL;
+}
+
+static HashTable *zend_get_import_ht(uint32_t type TSRMLS_DC) {
+	switch (type) {
+		case T_CLASS:
+			if (!CG(current_import)) {
+				CG(current_import) = emalloc(sizeof(HashTable));
+				zend_hash_init(CG(current_import), 8, NULL, str_dtor, 0);
 			}
-			if (CG(has_bracketed_namespaces) && !CG(in_namespace)) {
-				goto again;
+			return CG(current_import);
+		case T_FUNCTION:
+			if (!CG(current_import_function)) {
+				CG(current_import_function) = emalloc(sizeof(HashTable));
+				zend_hash_init(CG(current_import_function), 8, NULL, str_dtor, 0);
 			}
-			retval = ';'; /* implicit ; */
-			break;
-		case T_OPEN_TAG_WITH_ECHO:
-			retval = T_ECHO;
-			break;
+			return CG(current_import_function);
+		case T_CONST:
+			if (!CG(current_import_const)) {
+				CG(current_import_const) = emalloc(sizeof(HashTable));
+				zend_hash_init(CG(current_import_const), 8, NULL, str_dtor, 0);
+			}
+			return CG(current_import_const);
+		EMPTY_SWITCH_DEFAULT_CASE()
 	}
+}
 
-	zendlval->op_type = IS_CONST;
-	return retval;
+static char *zend_get_use_type_str(uint32_t type) {
+	switch (type) {
+		case T_CLASS:
+			return "";
+		case T_FUNCTION:
+			return " function";
+		case T_CONST:
+			return " const";
+		EMPTY_SWITCH_DEFAULT_CASE()
+	}
 }
-/* }}} */
 
-ZEND_API void zend_initialize_class_data(zend_class_entry *ce, zend_bool nullify_handlers TSRMLS_DC) /* {{{ */
-{
-	zend_bool persistent_hashes = (ce->type == ZEND_INTERNAL_CLASS) ? 1 : 0;
-	dtor_func_t zval_ptr_dtor_func = ((persistent_hashes) ? ZVAL_INTERNAL_PTR_DTOR : ZVAL_PTR_DTOR);
+static void zend_check_already_in_use(
+	uint32_t type, zend_string *old_name, zend_string *new_name, zend_string *check_name
+) {
+	if (zend_str_equals_str_ci(old_name, check_name)) {
+		return;
+	}
 
-	ce->refcount = 1;
-	ce->ce_flags = ZEND_ACC_CONSTANTS_UPDATED;
+	zend_error_noreturn(E_COMPILE_ERROR, "Cannot use%s %s as %s because the name "
+		"is already in use", zend_get_use_type_str(type), old_name->val, new_name->val);
+}
 
-	ce->default_properties_table = NULL;
-	ce->default_static_members_table = NULL;
-	zend_hash_init_ex(&ce->properties_info, 8, NULL, (persistent_hashes ? zend_destroy_property_info_internal : zend_destroy_property_info), persistent_hashes, 0);
-	zend_hash_init_ex(&ce->constants_table, 8, NULL, zval_ptr_dtor_func, persistent_hashes, 0);
-	zend_hash_init_ex(&ce->function_table, 8, NULL, ZEND_FUNCTION_DTOR, persistent_hashes, 0);
+void zend_compile_use(zend_ast *ast TSRMLS_DC) {
+	zend_ast_list *list = zend_ast_get_list(ast);
+	uint32_t i;
+	zend_string *current_ns = CG(current_namespace);
+	uint32_t type = ast->attr;
+	HashTable *current_import = zend_get_import_ht(type TSRMLS_CC);
+	zend_bool case_sensitive = type == T_CONST;
+
+	for (i = 0; i < list->children; ++i) {
+		zend_ast *use_ast = list->child[i];
+		zend_ast *old_name_ast = use_ast->child[0];
+		zend_ast *new_name_ast = use_ast->child[1];
+		zend_string *old_name = zend_ast_get_str(old_name_ast);
+		zend_string *new_name, *lookup_name;
+
+		if (new_name_ast) {
+			new_name = zend_string_copy(zend_ast_get_str(new_name_ast));
+		} else {
+			/* The form "use A\B" is eqivalent to "use A\B as B" */
+			const char *p = zend_memrchr(old_name->val, '\\', old_name->len);
+			if (p) {
+				new_name = zend_string_init(p + 1, old_name->len - (p - old_name->val + 1), 0);
+			} else {
+				new_name = zend_string_copy(old_name);
 
-	if (ce->type == ZEND_INTERNAL_CLASS) {
-#ifdef ZTS
-		int n = zend_hash_num_elements(CG(class_table));
+				if (!current_ns) {
+					if (type == T_CLASS && zend_str_equals_literal(new_name, "strict")) {
+						zend_error_noreturn(E_COMPILE_ERROR,
+							"You seem to be trying to use a different language...");
+					}
 
-		if (CG(static_members_table) && n >= CG(last_static_member)) {
-			/* Support for run-time declaration: dl() */
-			CG(last_static_member) = n+1;
-			CG(static_members_table) = realloc(CG(static_members_table), (n+1)*sizeof(zval*));
-			CG(static_members_table)[n] = NULL;
+					zend_error(E_WARNING, "The use statement with non-compound name '%s' "
+						"has no effect", new_name->val);
+				}
+			}
 		}
-		ce->static_members_table = (zval*)(zend_intptr_t)n;
-#else
-		ce->static_members_table = NULL;
-#endif
-	} else {
-		ce->static_members_table = ce->default_static_members_table;
-		ce->info.user.doc_comment = NULL;
-	}
 
-	ce->default_properties_count = 0;
-	ce->default_static_members_count = 0;
+		if (case_sensitive) {
+			lookup_name = zend_string_copy(new_name);
+		} else {
+			lookup_name = zend_string_alloc(new_name->len, 0);
+			zend_str_tolower_copy(lookup_name->val, new_name->val, new_name->len);
+		}
 
-	if (nullify_handlers) {
-		ce->constructor = NULL;
-		ce->destructor = NULL;
-		ce->clone = NULL;
-		ce->__get = NULL;
-		ce->__set = NULL;
-		ce->__unset = NULL;
-		ce->__isset = NULL;
-		ce->__call = NULL;
-		ce->__callstatic = NULL;
-		ce->__tostring = NULL;
-		ce->create_object = NULL;
-		ce->get_iterator = NULL;
-		ce->iterator_funcs.funcs = NULL;
-		ce->interface_gets_implemented = NULL;
-		ce->get_static_method = NULL;
-		ce->parent = NULL;
-		ce->num_interfaces = 0;
-		ce->interfaces = NULL;
-		ce->num_traits = 0;
-		ce->traits = NULL;
-		ce->trait_aliases = NULL;
-		ce->trait_precedences = NULL;
-		ce->serialize = NULL;
-		ce->unserialize = NULL;
-		ce->serialize_func = NULL;
-		ce->unserialize_func = NULL;
-		ce->__debugInfo = NULL;
-		if (ce->type == ZEND_INTERNAL_CLASS) {
-			ce->info.internal.module = NULL;
-			ce->info.internal.builtin_functions = NULL;
+		if (type == T_CLASS && (zend_str_equals_literal(lookup_name, "self")
+			|| zend_str_equals_literal(lookup_name, "parent"))
+		) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Cannot use %s as %s because '%s' "
+				"is a special class name", old_name->val, new_name->val, new_name->val);
 		}
-	}
-}
-/* }}} */
 
-int zend_get_class_fetch_type(const char *class_name, uint class_name_len) /* {{{ */
-{
-	if ((class_name_len == sizeof("self")-1) &&
-		!strncasecmp(class_name, "self", sizeof("self")-1)) {
-		return ZEND_FETCH_CLASS_SELF;
-	} else if ((class_name_len == sizeof("parent")-1) &&
-		!strncasecmp(class_name, "parent", sizeof("parent")-1)) {
-		return ZEND_FETCH_CLASS_PARENT;
-	} else if ((class_name_len == sizeof("static")-1) &&
-		!strncasecmp(class_name, "static", sizeof("static")-1)) {
-		return ZEND_FETCH_CLASS_STATIC;
-	} else {
-		return ZEND_FETCH_CLASS_DEFAULT;
+		if (current_ns) {
+			zend_string *ns_name = zend_string_alloc(current_ns->len + 1 + new_name->len, 0);
+			zend_str_tolower_copy(ns_name->val, current_ns->val, current_ns->len);
+			ns_name->val[current_ns->len] = '\\';
+			memcpy(ns_name->val + current_ns->len + 1, lookup_name->val, lookup_name->len);
+
+			if (zend_hash_exists(CG(class_table), ns_name)) {
+				zend_check_already_in_use(type, old_name, new_name, ns_name);
+			}
+
+			zend_string_free(ns_name);
+		} else {
+			switch (type) {
+				case T_CLASS:
+				{
+					zend_class_entry *ce = zend_hash_find_ptr(CG(class_table), lookup_name);
+					if (ce && ce->type == ZEND_USER_CLASS
+						&& ce->info.user.filename == CG(compiled_filename)
+					) {
+						zend_check_already_in_use(type, old_name, new_name, lookup_name);
+					}
+					break;
+				}
+				case T_FUNCTION:
+				{
+					zend_function *fn = zend_hash_find_ptr(CG(function_table), lookup_name);
+					if (fn && fn->type == ZEND_USER_FUNCTION
+						&& fn->op_array.filename == CG(compiled_filename)
+					) {
+						zend_check_already_in_use(type, old_name, new_name, lookup_name);
+					}
+					break;
+				}
+				case T_CONST:
+				{
+					zend_string *filename = zend_hash_find_ptr(&CG(const_filenames), lookup_name);
+					if (filename && filename == CG(compiled_filename)) {
+						zend_check_already_in_use(type, old_name, new_name, lookup_name);
+					}
+					break;
+				}
+				EMPTY_SWITCH_DEFAULT_CASE()
+			}
+		}
+
+		zend_string_addref(old_name);
+		if (!zend_hash_add_ptr(current_import, lookup_name, old_name)) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Cannot use%s %s as %s because the name "
+				"is already in use", zend_get_use_type_str(type), old_name->val, new_name->val);
+		}
+
+		zend_string_release(lookup_name);
+		zend_string_release(new_name);
 	}
 }
-/* }}} */
 
-ZEND_API zend_string *zend_get_compiled_variable_name(const zend_op_array *op_array, uint32_t var) /* {{{ */
-{
-	return op_array->vars[EX_VAR_TO_NUM(var)];
-}
-/* }}} */
+void zend_compile_const_decl(zend_ast *ast TSRMLS_DC) {
+	zend_ast_list *list = zend_ast_get_list(ast);
+	uint32_t i;
+	for (i = 0; i < list->children; ++i) {
+		zend_ast *const_ast = list->child[i];
+		zend_ast *name_ast = const_ast->child[0];
+		zend_ast *value_ast = const_ast->child[1];
+		zend_string *name = zend_ast_get_str(name_ast);
 
-void zend_do_build_namespace_name(znode *result, znode *prefix, znode *name TSRMLS_DC) /* {{{ */
-{
-	if (prefix) {
-		*result = *prefix;
-		if (Z_TYPE(result->u.constant) == IS_STRING &&
-		    Z_STRLEN(result->u.constant) == 0) {
-			/* namespace\ */
-			if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
-				znode tmp;
-
-				zval_dtor(&result->u.constant);
-				tmp.op_type = IS_CONST;
-				ZVAL_DUP(&tmp.u.constant, &CG(current_namespace));
-				zend_do_build_namespace_name(result, NULL, &tmp TSRMLS_CC);
+		zend_string *import_name;
+		znode name_node, value_node;
+		zval *value_zv = &value_node.u.constant;
+
+		value_node.op_type = IS_CONST;
+		zend_const_expr_to_zval(value_zv, value_ast TSRMLS_CC);
+
+		if (zend_get_ct_const(name, 0 TSRMLS_CC)) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare constant '%s'", name->val);
+		}
+
+		name = zend_prefix_with_ns(name TSRMLS_CC);
+
+		if (CG(current_import_const)
+			&& (import_name = zend_hash_find_ptr(CG(current_import_const), name))
+		) {
+			if (!zend_str_equals_str(import_name, name)) {
+				zend_error(E_COMPILE_ERROR, "Cannot declare const %s because "
+					"the name is already in use", name->val);
 			}
 		}
-	} else {
-		result->op_type = IS_CONST;
-		ZVAL_EMPTY_STRING(&result->u.constant);
+
+		name_node.op_type = IS_CONST;
+		ZVAL_STR(&name_node.u.constant, name);
+
+		zend_emit_op(NULL, ZEND_DECLARE_CONST, &name_node, &value_node TSRMLS_CC);
+
+		zend_hash_add_ptr(&CG(const_filenames), name, CG(compiled_filename));
 	}
-	/* prefix = result */
-	zend_do_build_full_name(NULL, result, name, 0 TSRMLS_CC);
 }
-/* }}} */
 
-void zend_do_begin_namespace(znode *name, zend_bool with_bracket TSRMLS_DC) /* {{{ */
-{
-	char *lcname;
+void zend_compile_namespace(zend_ast *ast TSRMLS_DC) {
+	zend_ast *name_ast = ast->child[0];
+	zend_ast *stmt_ast = ast->child[1];
+	zend_string *name;
+	zend_bool with_bracket = stmt_ast != NULL;
 
 	/* handle mixed syntax declaration or nested namespaces */
 	if (!CG(has_bracketed_namespaces)) {
-		if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
+		if (CG(current_namespace)) {
 			/* previous namespace declarations were unbracketed */
 			if (with_bracket) {
-				zend_error_noreturn(E_COMPILE_ERROR, "Cannot mix bracketed namespace declarations with unbracketed namespace declarations");
+				zend_error_noreturn(E_COMPILE_ERROR, "Cannot mix bracketed namespace declarations "
+					"with unbracketed namespace declarations");
 			}
 		}
 	} else {
 		/* previous namespace declarations were bracketed */
 		if (!with_bracket) {
-			zend_error_noreturn(E_COMPILE_ERROR, "Cannot mix bracketed namespace declarations with unbracketed namespace declarations");
-		} else if (Z_TYPE(CG(current_namespace)) != IS_UNDEF || CG(in_namespace)) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Cannot mix bracketed namespace declarations "
+				"with unbracketed namespace declarations");
+		} else if (CG(current_namespace) || CG(in_namespace)) {
 			zend_error_noreturn(E_COMPILE_ERROR, "Namespace declarations cannot be nested");
 		}
 	}
 
-	if (((!with_bracket && Z_TYPE(CG(current_namespace)) == IS_UNDEF) || (with_bracket && !CG(has_bracketed_namespaces))) && CG(active_op_array)->last > 0) {
+	if (((!with_bracket && !CG(current_namespace))
+		 || (with_bracket && !CG(has_bracketed_namespaces))) && CG(active_op_array)->last > 0
+	) {
 		/* ignore ZEND_EXT_STMT and ZEND_TICKS */
-		int num = CG(active_op_array)->last;
+		uint32_t num = CG(active_op_array)->last;
 		while (num > 0 &&
 		       (CG(active_op_array)->opcodes[num-1].opcode == ZEND_EXT_STMT ||
 		        CG(active_op_array)->opcodes[num-1].opcode == ZEND_TICKS)) {
 			--num;
 		}
 		if (num > 0) {
-			zend_error_noreturn(E_COMPILE_ERROR, "Namespace declaration statement has to be the very first statement in the script");
+			zend_error_noreturn(E_COMPILE_ERROR, "Namespace declaration statement has to be "
+				"the very first statement in the script");
+		}
+	}
+
+	if (CG(current_namespace)) {
+		zend_string_release(CG(current_namespace));
+	}
+
+	if (name_ast) {
+		name = zend_ast_get_str(name_ast);
+
+		if (ZEND_FETCH_CLASS_DEFAULT != zend_get_class_fetch_type(name)) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as namespace name", name->val);
 		}
+
+		CG(current_namespace) = zend_string_copy(name);
+	} else {
+		CG(current_namespace) = NULL;
 	}
 
+	zend_reset_import_tables(TSRMLS_C);
+
 	CG(in_namespace) = 1;
 	if (with_bracket) {
 		CG(has_bracketed_namespaces) = 1;
 	}
 
-	if (name) {
-		lcname = zend_str_tolower_dup(Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant));
-		if (((Z_STRLEN(name->u.constant) == sizeof("self")-1) &&
-		      !memcmp(lcname, "self", sizeof("self")-1)) ||
-		    ((Z_STRLEN(name->u.constant) == sizeof("parent")-1) &&
-	          !memcmp(lcname, "parent", sizeof("parent")-1))) {
-			zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as namespace name", Z_STRVAL(name->u.constant));
-		}
-		efree(lcname);
+	if (stmt_ast) {
+		zend_compile_top_stmt(stmt_ast TSRMLS_CC);
+		zend_end_namespace(TSRMLS_C);
+	}
+}
+
+void zend_compile_halt_compiler(zend_ast *ast TSRMLS_DC) {
+	zend_ast *offset_ast = ast->child[0];
+	zend_long offset = Z_LVAL_P(zend_ast_get_zval(offset_ast));
+
+	zend_string *filename, *name;
+	const char const_name[] = "__COMPILER_HALT_OFFSET__";
+
+	if (CG(has_bracketed_namespaces) && CG(in_namespace)) {
+		zend_error_noreturn(E_COMPILE_ERROR,
+			"__HALT_COMPILER() can only be used from the outermost scope");
+	}
+
+	filename = zend_get_compiled_filename(TSRMLS_C);
+	name = zend_mangle_property_name(const_name, sizeof(const_name) - 1,
+		filename->val, filename->len, 0);
+
+	zend_register_long_constant(name->val, name->len, offset, CONST_CS, 0 TSRMLS_CC);
+	zend_string_release(name);
+}
+
+static zend_bool zend_try_ct_eval_magic_const(zval *zv, zend_ast *ast TSRMLS_DC) {
+	zend_op_array *op_array = CG(active_op_array);
+	zend_class_entry *ce = CG(active_class_entry);
+
+	switch (ast->attr) {
+		case T_FUNC_C:
+			if (op_array && op_array->function_name) {
+				ZVAL_STR(zv, zend_string_copy(op_array->function_name));
+			} else {
+				ZVAL_EMPTY_STRING(zv);
+			}
+			break;
+		case T_METHOD_C:
+			if (ce) {
+				if (op_array && op_array->function_name) {
+					ZVAL_STR(zv, zend_concat3(ce->name->val, ce->name->len, "::", 2,
+						op_array->function_name->val, op_array->function_name->len));
+				} else {
+					ZVAL_STR(zv, zend_string_copy(ce->name));
+				}
+			} else if (op_array && op_array->function_name) {
+				ZVAL_STR(zv, zend_string_copy(op_array->function_name));
+			} else {
+				ZVAL_EMPTY_STRING(zv);
+			}
+			break;
+		case T_CLASS_C:
+			if (ce) {
+				if (ZEND_CE_IS_TRAIT(ce)) {
+					return 0;
+				} else {
+					ZVAL_STR(zv, zend_string_copy(ce->name));
+				}
+			} else {
+				ZVAL_EMPTY_STRING(zv);
+			}
+			break;
+		case T_TRAIT_C:
+			if (ce && ZEND_CE_IS_TRAIT(ce)) {
+				ZVAL_STR(zv, zend_string_copy(ce->name));
+			} else {
+				ZVAL_EMPTY_STRING(zv);
+			}
+			break;
+		case T_NS_C:
+			if (CG(current_namespace)) {
+				ZVAL_STR(zv, zend_string_copy(CG(current_namespace)));
+			} else {
+				ZVAL_EMPTY_STRING(zv);
+			}
+			break;
+		EMPTY_SWITCH_DEFAULT_CASE()
+	}
+
+	return 1;
+}
+
+static inline void zend_ct_eval_binary_op(
+	zval *result, uint32_t opcode, zval *op1, zval *op2 TSRMLS_DC
+) {
+	binary_op_type fn = get_binary_op(opcode);
+	fn(result, op1, op2 TSRMLS_CC);
+}
+
+static inline void zend_ct_eval_unary_pm(zval *result, zend_ast_kind kind, zval *op TSRMLS_DC) {
+	binary_op_type fn = kind == ZEND_AST_UNARY_PLUS
+		? add_function : sub_function;
+
+	zval left;
+	ZVAL_LONG(&left, 0);
+	fn(result, &left, op TSRMLS_CC);
+}
 
-		if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
-			zval_dtor(&CG(current_namespace));
+static inline void zend_ct_eval_greater(
+	zval *result, zend_ast_kind kind, zval *op1, zval *op2 TSRMLS_DC
+) {
+	binary_op_type fn = kind == ZEND_AST_GREATER
+		? is_smaller_function : is_smaller_or_equal_function;
+	fn(result, op2, op1 TSRMLS_CC);
+}
+
+static zend_bool zend_try_ct_eval_array(zval *result, zend_ast *ast TSRMLS_DC) {
+	zend_ast_list *list = zend_ast_get_list(ast);
+	uint32_t i;
+
+	/* First ensure that *all* child nodes are constant and by-val */
+	for (i = 0; i < list->children; ++i) {
+		zend_ast *elem_ast = list->child[i];
+		zend_bool by_ref = elem_ast->attr;
+		zend_eval_const_expr(&elem_ast->child[0] TSRMLS_CC);
+		zend_eval_const_expr(&elem_ast->child[1] TSRMLS_CC);
+
+		if (by_ref || elem_ast->child[0]->kind != ZEND_AST_ZVAL
+			|| (elem_ast->child[1] && elem_ast->child[1]->kind != ZEND_AST_ZVAL)
+		) {
+			return 0;
 		}
-		ZVAL_COPY_VALUE(&CG(current_namespace), &name->u.constant);
-	} else {
-		if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
-			zval_dtor(&CG(current_namespace));
-			ZVAL_UNDEF(&CG(current_namespace));
+	}
+
+	array_init_size(result, list->children);
+	for (i = 0; i < list->children; ++i) {
+		zend_ast *elem_ast = list->child[i];
+		zend_ast *value_ast = elem_ast->child[0];
+		zend_ast *key_ast = elem_ast->child[1];
+
+		zval *value = zend_ast_get_zval(value_ast);
+		if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
+
+		if (key_ast) {
+			zval *key = zend_ast_get_zval(key_ast);
+			switch (Z_TYPE_P(key)) {
+				case IS_LONG:
+					zend_hash_index_update(Z_ARRVAL_P(result), Z_LVAL_P(key), value);
+					break;
+				case IS_STRING:
+					zend_symtable_update(Z_ARRVAL_P(result), Z_STR_P(key), value);
+					break;
+				case IS_DOUBLE:
+					zend_hash_index_update(Z_ARRVAL_P(result),
+						zend_dval_to_lval(Z_DVAL_P(key)), value);
+					break;
+				case IS_FALSE:
+					zend_hash_index_update(Z_ARRVAL_P(result), 0, value);
+					break;
+				case IS_TRUE:
+					zend_hash_index_update(Z_ARRVAL_P(result), 1, value);
+					break;
+				case IS_NULL:
+					zend_hash_update(Z_ARRVAL_P(result), STR_EMPTY_ALLOC(), value);
+					break;
+				default:
+					zend_error(E_COMPILE_ERROR, "Illegal offset type");
+					break;
+			}
+		} else {
+			zend_hash_next_index_insert(Z_ARRVAL_P(result), value);
 		}
 	}
 
-	if (CG(current_import)) {
-		zend_hash_destroy(CG(current_import));
-		efree(CG(current_import));
-		CG(current_import) = NULL;
+	return 1;
+}
+
+void zend_compile_binary_op(znode *result, zend_ast *ast TSRMLS_DC) {
+	zend_ast *left_ast = ast->child[0];
+	zend_ast *right_ast = ast->child[1];
+	uint32_t opcode = ast->attr;
+
+	znode left_node, right_node;
+	zend_compile_expr(&left_node, left_ast TSRMLS_CC);
+	zend_compile_expr(&right_node, right_ast TSRMLS_CC);
+
+	if (left_node.op_type == IS_CONST && right_node.op_type == IS_CONST) {
+		result->op_type = IS_CONST;
+		zend_ct_eval_binary_op(&result->u.constant, opcode,
+			&left_node.u.constant, &right_node.u.constant TSRMLS_CC);
+		zval_ptr_dtor(&left_node.u.constant);
+		zval_ptr_dtor(&right_node.u.constant);
+		return;
 	}
 
-	if (CG(current_import_function)) {
-		zend_hash_destroy(CG(current_import_function));
-		efree(CG(current_import_function));
-		CG(current_import_function) = NULL;
+	zend_emit_op_tmp(result, opcode, &left_node, &right_node TSRMLS_CC);
+}
+
+/* We do not use zend_compile_binary_op for this because we want to retain the left-to-right
+ * evaluation order. */
+void zend_compile_greater(znode *result, zend_ast *ast TSRMLS_DC) {
+	zend_ast *left_ast = ast->child[0];
+	zend_ast *right_ast = ast->child[1];
+	znode left_node, right_node;
+
+	ZEND_ASSERT(ast->kind == ZEND_AST_GREATER || ast->kind == ZEND_AST_GREATER_EQUAL);
+
+	zend_compile_expr(&left_node, left_ast TSRMLS_CC);
+	zend_compile_expr(&right_node, right_ast TSRMLS_CC);
+
+	if (left_node.op_type == IS_CONST && right_node.op_type == IS_CONST) {
+		result->op_type = IS_CONST;
+		zend_ct_eval_greater(&result->u.constant, ast->kind,
+			&left_node.u.constant, &right_node.u.constant TSRMLS_CC);
+		zval_ptr_dtor(&left_node.u.constant);
+		zval_ptr_dtor(&right_node.u.constant);
+		return;
 	}
 
-	if (CG(current_import_const)) {
-		zend_hash_destroy(CG(current_import_const));
-		efree(CG(current_import_const));
-		CG(current_import_const) = NULL;
+	zend_emit_op_tmp(result,
+		ast->kind == ZEND_AST_GREATER ? ZEND_IS_SMALLER : ZEND_IS_SMALLER_OR_EQUAL,
+		&right_node, &left_node TSRMLS_CC);
+}
+
+void zend_compile_unary_op(znode *result, zend_ast *ast TSRMLS_DC) {
+	zend_ast *expr_ast = ast->child[0];
+	uint32_t opcode = ast->attr;
+
+	znode expr_node;
+	zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
+
+	zend_emit_op_tmp(result, opcode, &expr_node, NULL TSRMLS_CC);
+}
+
+void zend_compile_unary_pm(znode *result, zend_ast *ast TSRMLS_DC) {
+	zend_ast *expr_ast = ast->child[0];
+	znode zero_node, expr_node;
+
+	ZEND_ASSERT(ast->kind == ZEND_AST_UNARY_PLUS || ast->kind == ZEND_AST_UNARY_MINUS);
+
+	zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
+
+	if (expr_node.op_type == IS_CONST) {
+		result->op_type = IS_CONST;
+		zend_ct_eval_unary_pm(&result->u.constant, ast->kind, &expr_node.u.constant TSRMLS_CC);
+		zval_ptr_dtor(&expr_node.u.constant);
+		return;
 	}
 
-	if (CG(doc_comment)) {
-		zend_string_release(CG(doc_comment));
-		CG(doc_comment) = NULL;
+	zero_node.op_type = IS_CONST;
+	ZVAL_LONG(&zero_node.u.constant, 0);
+
+	zend_emit_op_tmp(result, ast->kind == ZEND_AST_UNARY_PLUS ? ZEND_ADD : ZEND_SUB,
+		&zero_node, &expr_node TSRMLS_CC);
+}
+
+void zend_compile_short_circuiting(znode *result, zend_ast *ast TSRMLS_DC) {
+	zend_ast *left_ast = ast->child[0];
+	zend_ast *right_ast = ast->child[1];
+
+	znode left_node, right_node;
+	zend_op *opline_jmpz, *opline_bool;
+	uint32_t opnum_jmpz;
+
+	ZEND_ASSERT(ast->kind == ZEND_AST_AND || ast->kind == ZEND_AST_OR);
+
+	zend_compile_expr(&left_node, left_ast TSRMLS_CC);
+
+	opnum_jmpz = get_next_op_number(CG(active_op_array));
+	opline_jmpz = zend_emit_op(NULL, ast->kind == ZEND_AST_AND ? ZEND_JMPZ_EX : ZEND_JMPNZ_EX,
+		&left_node, NULL TSRMLS_CC);
+
+	if (left_node.op_type == IS_TMP_VAR) {
+		SET_NODE(opline_jmpz->result, &left_node);
+	} else {
+		opline_jmpz->result.var = get_temporary_variable(CG(active_op_array));
+		opline_jmpz->result_type = IS_TMP_VAR;
 	}
+	GET_NODE(result, opline_jmpz->result);
+
+	zend_compile_expr(&right_node, right_ast TSRMLS_CC);
+
+	opline_bool = zend_emit_op(NULL, ZEND_BOOL, &right_node, NULL TSRMLS_CC);
+	SET_NODE(opline_bool->result, result);
+
+	zend_update_jump_target_to_next(opnum_jmpz TSRMLS_CC);
 }
-/* }}} */
 
-void zend_do_use(znode *ns_name, znode *new_name, int is_global TSRMLS_DC) /* {{{ */
-{
-	zend_string *lcname;
-	zval *name, ns, tmp;
-	zend_bool warn = 0;
-	zend_class_entry *ce;
+void zend_compile_post_incdec(znode *result, zend_ast *ast TSRMLS_DC) {
+	zend_ast *var_ast = ast->child[0];
+	ZEND_ASSERT(ast->kind == ZEND_AST_POST_INC || ast->kind == ZEND_AST_POST_DEC);
+
+	if (var_ast->kind == ZEND_AST_PROP) {
+		zend_op *opline = zend_compile_prop_common(NULL, var_ast, BP_VAR_RW TSRMLS_CC);
+		opline->opcode = ast->kind == ZEND_AST_POST_INC ? ZEND_POST_INC_OBJ : ZEND_POST_DEC_OBJ;
+		zend_make_tmp_result(result, opline TSRMLS_CC);
+	} else {
+		znode var_node;
+		zend_compile_var(&var_node, var_ast, BP_VAR_RW TSRMLS_CC);
+		zend_emit_op_tmp(result, ast->kind == ZEND_AST_POST_INC ? ZEND_POST_INC : ZEND_POST_DEC,
+			&var_node, NULL TSRMLS_CC);
+	}
+}
+
+void zend_compile_pre_incdec(znode *result, zend_ast *ast TSRMLS_DC) {
+	zend_ast *var_ast = ast->child[0];
+	ZEND_ASSERT(ast->kind == ZEND_AST_PRE_INC || ast->kind == ZEND_AST_PRE_DEC);
+
+	if (var_ast->kind == ZEND_AST_PROP) {
+		zend_op *opline = zend_compile_prop_common(result, var_ast, BP_VAR_RW TSRMLS_CC);
+		opline->opcode = ast->kind == ZEND_AST_PRE_INC ? ZEND_PRE_INC_OBJ : ZEND_PRE_DEC_OBJ;
+	} else {
+		znode var_node;
+		zend_compile_var(&var_node, var_ast, BP_VAR_RW TSRMLS_CC);
+		zend_emit_op(result, ast->kind == ZEND_AST_PRE_INC ? ZEND_PRE_INC : ZEND_PRE_DEC,
+			&var_node, NULL TSRMLS_CC);
+	}
+}
+
+void zend_compile_cast(znode *result, zend_ast *ast TSRMLS_DC) {
+	zend_ast *expr_ast = ast->child[0];
+	znode expr_node;
+	zend_op *opline;
+
+	zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
+
+	opline = zend_emit_op(result, ZEND_CAST, &expr_node, NULL TSRMLS_CC);
+	opline->extended_value = ast->attr;
+}
+
+static void zend_compile_shorthand_conditional(znode *result, zend_ast *ast TSRMLS_DC) {
+	zend_ast *cond_ast = ast->child[0];
+	zend_ast *false_ast = ast->child[2];
+
+	znode cond_node, false_node;
+	zend_op *opline_jmp_set, *opline_qm_assign;
+	uint32_t opnum_jmp_set;
+
+	ZEND_ASSERT(ast->child[1] == NULL);
+
+	zend_compile_expr(&cond_node, cond_ast TSRMLS_CC);
+
+	opnum_jmp_set = get_next_op_number(CG(active_op_array));
+	zend_emit_op_tmp(result, ZEND_JMP_SET, &cond_node, NULL TSRMLS_CC);
+
+	zend_compile_expr(&false_node, false_ast TSRMLS_CC);
+
+	opline_jmp_set = &CG(active_op_array)->opcodes[opnum_jmp_set];
+	opline_jmp_set->op2.opline_num = get_next_op_number(CG(active_op_array)) + 1;
+	if (cond_node.op_type == IS_VAR || cond_node.op_type == IS_CV
+		|| false_node.op_type == IS_VAR || false_node.op_type == IS_CV
+	) {
+		opline_jmp_set->opcode = ZEND_JMP_SET_VAR;
+		opline_jmp_set->result_type = IS_VAR;
+		GET_NODE(result, opline_jmp_set->result);
+
+		opline_qm_assign = zend_emit_op(NULL, ZEND_QM_ASSIGN_VAR, &false_node, NULL TSRMLS_CC);
+	} else {
+		opline_qm_assign = zend_emit_op(NULL, ZEND_QM_ASSIGN, &false_node, NULL TSRMLS_CC);
+	}
+	SET_NODE(opline_qm_assign->result, result);
+}
+
+void zend_compile_conditional(znode *result, zend_ast *ast TSRMLS_DC) {
+	zend_ast *cond_ast = ast->child[0];
+	zend_ast *true_ast = ast->child[1];
+	zend_ast *false_ast = ast->child[2];
+
+	znode cond_node, true_node, false_node;
+	zend_op *opline_qm_assign1, *opline_qm_assign2;
+	uint32_t opnum_jmpz, opnum_jmp, opnum_qm_assign1;
+
+	if (!true_ast) {
+		zend_compile_shorthand_conditional(result, ast TSRMLS_CC);
+		return;
+	}
+	
+	zend_compile_expr(&cond_node, cond_ast TSRMLS_CC);
+
+	opnum_jmpz = zend_emit_cond_jump(ZEND_JMPZ, &cond_node, 0 TSRMLS_CC);
+
+	zend_compile_expr(&true_node, true_ast TSRMLS_CC);
+
+	opnum_qm_assign1 = get_next_op_number(CG(active_op_array));
+	zend_emit_op(result, ZEND_QM_ASSIGN, &true_node, NULL TSRMLS_CC);
+
+	opnum_jmp = zend_emit_jump(0 TSRMLS_CC);
+
+	zend_update_jump_target_to_next(opnum_jmpz TSRMLS_CC);
+
+	zend_compile_expr(&false_node, false_ast TSRMLS_CC);
 
-	if (!CG(current_import)) {
-		CG(current_import) = emalloc(sizeof(HashTable));
-		zend_hash_init(CG(current_import), 8, NULL, ZVAL_PTR_DTOR, 0);
+	opline_qm_assign1 = &CG(active_op_array)->opcodes[opnum_qm_assign1];
+	if (true_node.op_type == IS_VAR || true_node.op_type == IS_CV
+		|| false_node.op_type == IS_VAR || false_node.op_type == IS_CV
+	) {
+		opline_qm_assign1->opcode = ZEND_QM_ASSIGN_VAR;
+		opline_qm_assign1->result_type = IS_VAR;
+		GET_NODE(result, opline_qm_assign1->result);
 	}
 
-	ZVAL_ZVAL(&ns, &ns_name->u.constant, 0, 0);
-	if (new_name) {
-		name = &new_name->u.constant;
+	opline_qm_assign2 = zend_emit_op(NULL, opline_qm_assign1->opcode, &false_node, NULL TSRMLS_CC);
+	SET_NODE(opline_qm_assign2->result, result);
+
+	zend_update_jump_target_to_next(opnum_jmp TSRMLS_CC);
+}
+
+void zend_compile_print(znode *result, zend_ast *ast TSRMLS_DC) {
+	zend_ast *expr_ast = ast->child[0];
+
+	znode expr_node;
+	zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
+
+	zend_emit_op_tmp(result, ZEND_PRINT, &expr_node, NULL TSRMLS_CC);
+}
+
+void zend_compile_exit(znode *result, zend_ast *ast TSRMLS_DC) {
+	zend_ast *expr_ast = ast->child[0];
+
+	if (expr_ast) {
+		znode expr_node;
+		zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
+		zend_emit_op(NULL, ZEND_EXIT, &expr_node, NULL TSRMLS_CC);
 	} else {
-		const char *p;
-
-		/* The form "use A\B" is eqivalent to "use A\B as B".
-		   So we extract the last part of compound name to use as a new_name */
-		name = &tmp;
-		p = zend_memrchr(Z_STRVAL(ns), '\\', Z_STRLEN(ns));
-		if (p) {
-			ZVAL_STRING(name, p+1);
+		zend_emit_op(NULL, ZEND_EXIT, NULL, NULL TSRMLS_CC);
+	}
+
+	result->op_type = IS_CONST;
+	ZVAL_BOOL(&result->u.constant, 1);
+}
+
+void zend_compile_yield(znode *result, zend_ast *ast TSRMLS_DC) {
+	zend_ast *value_ast = ast->child[0];
+	zend_ast *key_ast = ast->child[1];
+
+	znode value_node, key_node;
+	znode *value_node_ptr = NULL, *key_node_ptr = NULL;
+	zend_op *opline;
+	zend_bool returns_by_ref = (CG(active_op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0;
+
+	if (!CG(active_op_array)->function_name) {
+		zend_error_noreturn(E_COMPILE_ERROR,
+			"The \"yield\" expression can only be used inside a function");
+	}
+
+	CG(active_op_array)->fn_flags |= ZEND_ACC_GENERATOR;
+
+	if (key_ast) {
+		zend_compile_expr(&key_node, key_ast TSRMLS_CC);
+		key_node_ptr = &key_node;
+	}
+
+	if (value_ast) {
+		if (returns_by_ref && zend_is_variable(value_ast) && !zend_is_call(value_ast)) {
+			zend_compile_var(&value_node, value_ast, BP_VAR_REF TSRMLS_CC);
 		} else {
-			ZVAL_ZVAL(name, &ns, 1, 0);
-			warn = !is_global && Z_TYPE(CG(current_namespace)) == IS_UNDEF;
+			zend_compile_expr(&value_node, value_ast TSRMLS_CC);
 		}
+		value_node_ptr = &value_node;
 	}
 
-	lcname = zend_string_alloc(Z_STRLEN_P(name), 0);
-	zend_str_tolower_copy(lcname->val, Z_STRVAL_P(name), Z_STRLEN_P(name));
+	opline = zend_emit_op(result, ZEND_YIELD, value_node_ptr, key_node_ptr TSRMLS_CC);
 
-	if (((Z_STRLEN_P(name) == sizeof("self")-1) &&
-				!memcmp(lcname->val, "self", sizeof("self")-1)) ||
-			((Z_STRLEN_P(name) == sizeof("parent")-1) &&
-	   !memcmp(lcname->val, "parent", sizeof("parent")-1))) {
-		zend_error_noreturn(E_COMPILE_ERROR, "Cannot use %s as %s because '%s' is a special class name", Z_STRVAL(ns), Z_STRVAL_P(name), Z_STRVAL_P(name));
+	if (value_ast && returns_by_ref && zend_is_call(value_ast)) {
+		opline->extended_value = ZEND_RETURNS_FUNCTION;
 	}
+}
+
+void zend_compile_instanceof(znode *result, zend_ast *ast TSRMLS_DC) {
+	zend_ast *obj_ast = ast->child[0];
+	zend_ast *class_ast = ast->child[1];
+
+	znode obj_node, class_node;
+	zend_op *opline;
+
+	zend_compile_expr(&obj_node, obj_ast TSRMLS_CC);
+	if (obj_node.op_type == IS_CONST) {
+		zend_error_noreturn(E_COMPILE_ERROR,
+			"instanceof expects an object instance, constant given");
+	}
+
+	opline = zend_compile_class_ref(&class_node, class_ast TSRMLS_CC);
+	opline->extended_value |= ZEND_FETCH_CLASS_NO_AUTOLOAD;
+
+	zend_emit_op_tmp(result, ZEND_INSTANCEOF, &obj_node, &class_node TSRMLS_CC);
+}
+
+void zend_compile_include_or_eval(znode *result, zend_ast *ast TSRMLS_DC) {
+	zend_ast *expr_ast = ast->child[0];
+	znode expr_node;
+	zend_op *opline;
+
+	zend_do_extended_fcall_begin(TSRMLS_C);
+	zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
+
+	opline = zend_emit_op(result, ZEND_INCLUDE_OR_EVAL, &expr_node, NULL TSRMLS_CC);
+	opline->extended_value = ast->attr;
 
-	if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
-		/* Prefix import name with current namespace name to avoid conflicts with classes */
-		zend_string *c_ns_name = zend_string_alloc(Z_STRLEN(CG(current_namespace)) + 1 + Z_STRLEN_P(name), 0);
+	zend_do_extended_fcall_end(TSRMLS_C);
+}
 
-		zend_str_tolower_copy(c_ns_name->val, Z_STRVAL(CG(current_namespace)), Z_STRLEN(CG(current_namespace)));
-		c_ns_name->val[Z_STRLEN(CG(current_namespace))] = '\\';
-		memcpy(c_ns_name->val+Z_STRLEN(CG(current_namespace))+1, lcname->val, Z_STRLEN_P(name)+1);
-		if (zend_hash_exists(CG(class_table), c_ns_name)) {
-			char *tmp2 = zend_str_tolower_dup(Z_STRVAL(ns), Z_STRLEN(ns));
+void zend_compile_isset_or_empty(znode *result, zend_ast *ast TSRMLS_DC) {
+	zend_ast *var_ast = ast->child[0];
+
+	znode var_node;
+	zend_op *opline;
+
+	ZEND_ASSERT(ast->kind == ZEND_AST_ISSET || ast->kind == ZEND_AST_EMPTY);
+
+	if (!zend_is_variable(var_ast) || zend_is_call(var_ast)) {
+		if (ast->kind == ZEND_AST_EMPTY) {
+			/* empty(expr) can be transformed to !expr */
+			zend_ast *not_ast = zend_ast_create_ex(ZEND_AST_UNARY_OP, ZEND_BOOL_NOT, var_ast);
+			zend_compile_expr(result, not_ast TSRMLS_CC);
+			return;
+		} else {
+			zend_error_noreturn(E_COMPILE_ERROR,
+				"Cannot use isset() on the result of an expression "
+				"(you can use \"null !== expression\" instead)");
+		}
+	}
 
-			if (Z_STRLEN(ns) != Z_STRLEN(CG(current_namespace)) + 1 + Z_STRLEN_P(name) ||
-				memcmp(tmp2, c_ns_name->val, Z_STRLEN(ns))) {
-				zend_error_noreturn(E_COMPILE_ERROR, "Cannot use %s as %s because the name is already in use", Z_STRVAL(ns), Z_STRVAL_P(name));
+	switch (var_ast->kind) {
+		case ZEND_AST_VAR:
+			if (zend_try_compile_cv(&var_node, var_ast TSRMLS_CC) == SUCCESS) {
+				opline = zend_emit_op(result, ZEND_ISSET_ISEMPTY_VAR, &var_node, NULL TSRMLS_CC);
+				opline->extended_value = ZEND_FETCH_LOCAL | ZEND_QUICK_SET;
+			} else {
+				opline = zend_compile_simple_var_no_cv(result, var_ast, BP_VAR_IS TSRMLS_CC);
+				opline->opcode = ZEND_ISSET_ISEMPTY_VAR;
 			}
-			efree(tmp2);
+			break;
+		case ZEND_AST_DIM:
+			opline = zend_compile_dim_common(result, var_ast, BP_VAR_IS TSRMLS_CC);
+			opline->opcode = ZEND_ISSET_ISEMPTY_DIM_OBJ;
+			break;
+		case ZEND_AST_PROP:
+			opline = zend_compile_prop_common(result, var_ast, BP_VAR_IS TSRMLS_CC);
+			opline->opcode = ZEND_ISSET_ISEMPTY_PROP_OBJ;
+			break;
+		case ZEND_AST_STATIC_PROP:
+			opline = zend_compile_static_prop_common(result, var_ast, BP_VAR_IS TSRMLS_CC);
+			opline->opcode = ZEND_ISSET_ISEMPTY_VAR;
+			break;
+		EMPTY_SWITCH_DEFAULT_CASE()
+	}
+
+	opline->result_type = IS_TMP_VAR;
+	opline->extended_value |= ast->kind == ZEND_AST_ISSET ? ZEND_ISSET : ZEND_ISEMPTY;
+}
+
+void zend_compile_silence(znode *result, zend_ast *ast TSRMLS_DC) {
+	zend_ast *expr_ast = ast->child[0];
+	znode silence_node;
+
+	zend_emit_op_tmp(&silence_node, ZEND_BEGIN_SILENCE, NULL, NULL TSRMLS_CC);
+
+	if (expr_ast->kind == ZEND_AST_VAR) {
+		/* For @$var we need to force a FETCH instruction, otherwise the CV access will
+		 * happen outside the silenced section. */
+		zend_compile_simple_var_no_cv(result, expr_ast, BP_VAR_R TSRMLS_CC);
+	} else {
+		zend_compile_expr(result, expr_ast TSRMLS_CC);
+	}
+
+	zend_emit_op(NULL, ZEND_END_SILENCE, &silence_node, NULL TSRMLS_CC);
+}
+
+void zend_compile_shell_exec(znode *result, zend_ast *ast TSRMLS_DC) {
+	zend_ast *expr_ast = ast->child[0];
+
+	zval fn_name;
+	zend_ast *name_ast, *args_ast, *call_ast;
+
+	ZVAL_STRING(&fn_name, "shell_exec");
+	name_ast = zend_ast_create_zval(&fn_name);
+	args_ast = (zend_ast *) zend_ast_create_list(1, ZEND_AST_ARG_LIST, expr_ast);
+	call_ast = zend_ast_create(ZEND_AST_CALL, name_ast, args_ast);
+
+	zend_compile_expr(result, call_ast TSRMLS_CC);
+
+	zval_ptr_dtor(&fn_name);
+}
+
+void zend_compile_array(znode *result, zend_ast *ast TSRMLS_DC) {
+	zend_ast_list *list = zend_ast_get_list(ast);
+	zend_op *opline;
+	uint32_t i, opnum_init;
+	zend_bool packed = 1;
+
+	if (zend_try_ct_eval_array(&result->u.constant, ast TSRMLS_CC)) {
+		result->op_type = IS_CONST;
+		return;
+	}
+
+	opnum_init = get_next_op_number(CG(active_op_array));
+
+	for (i = 0; i < list->children; ++i) {
+		zend_ast *elem_ast = list->child[i];
+		zend_ast *value_ast = elem_ast->child[0];
+		zend_ast *key_ast = elem_ast->child[1];
+		zend_bool by_ref = elem_ast->attr;
+
+		znode value_node, key_node, *key_node_ptr = NULL;
+
+		if (key_ast) {
+			zend_compile_expr(&key_node, key_ast TSRMLS_CC);
+			zend_handle_numeric_op(&key_node TSRMLS_CC);
+			key_node_ptr = &key_node;
+		}
+
+		if (by_ref) {
+			zend_ensure_writable_variable(value_ast);
+			zend_compile_var(&value_node, value_ast, BP_VAR_W TSRMLS_CC);
+		} else {
+			zend_compile_expr(&value_node, value_ast TSRMLS_CC);
+		}
+
+		if (i == 0) {
+			opline = zend_emit_op_tmp(result, ZEND_INIT_ARRAY, &value_node, key_node_ptr TSRMLS_CC);
+			opline->extended_value = list->children << ZEND_ARRAY_SIZE_SHIFT;
+		} else {
+			opline = zend_emit_op(NULL, ZEND_ADD_ARRAY_ELEMENT,
+				&value_node, key_node_ptr TSRMLS_CC);
+			SET_NODE(opline->result, result);
 		}
-		zend_string_free(c_ns_name);
-	} else if ((ce = zend_hash_find_ptr(CG(class_table), lcname)) != NULL &&
-	           ce->type == ZEND_USER_CLASS &&
-	           ce->info.user.filename == CG(compiled_filename)) {
-		char *c_tmp = zend_str_tolower_dup(Z_STRVAL(ns), Z_STRLEN(ns));
+		opline->extended_value |= by_ref;
 
-		if (Z_STRLEN(ns) != Z_STRLEN_P(name) ||
-			memcmp(c_tmp, lcname->val, Z_STRLEN(ns))) {
-			zend_error_noreturn(E_COMPILE_ERROR, "Cannot use %s as %s because the name is already in use", Z_STRVAL(ns), Z_STRVAL_P(name));
+		if (key_ast && key_node.op_type == IS_CONST && Z_TYPE(key_node.u.constant) == IS_STRING) {
+			packed = 0;
 		}
-		efree(c_tmp);
 	}
 
-	if (zend_hash_add(CG(current_import), lcname, &ns) == NULL) {
-		zend_error_noreturn(E_COMPILE_ERROR, "Cannot use %s as %s because the name is already in use", Z_STRVAL(ns), Z_STRVAL_P(name));
+	/* Handle empty array */
+	if (!list->children) {
+		zend_emit_op_tmp(result, ZEND_INIT_ARRAY, NULL, NULL TSRMLS_CC);
 	}
-	if (warn) {
-		if (!strcmp(Z_STRVAL_P(name), "strict")) {
-			zend_error_noreturn(E_COMPILE_ERROR, "You seem to be trying to use a different language...");
-		}
-		zend_error(E_WARNING, "The use statement with non-compound name '%s' has no effect", Z_STRVAL_P(name));
+
+	/* Add a flag to INIT_ARRAY if we know this array cannot be packed */
+	if (!packed) {
+		opline = &CG(active_op_array)->opcodes[opnum_init];
+		opline->extended_value |= ZEND_ARRAY_NOT_PACKED;
 	}
-	zend_string_release(lcname);
-	zval_dtor(name);
 }
-/* }}} */
 
-void zend_do_use_non_class(znode *ns_name, znode *new_name, int is_global, int is_function, zend_bool case_sensitive, HashTable *current_import_sub, HashTable *lookup_table TSRMLS_DC) /* {{{ */
-{
-	zend_string *lookup_name;
-	zval *name, ns, tmp;
-	zend_bool warn = 0;
+void zend_compile_const(znode *result, zend_ast *ast TSRMLS_DC) {
+	zend_ast *name_ast = ast->child[0];
+	zend_string *orig_name = zend_ast_get_str(name_ast);
+	zend_bool is_fully_qualified;
+
+	zval resolved_name;
+	zend_op *opline;
 
-	ZVAL_ZVAL(&ns, &ns_name->u.constant, 0, 0);
-	if (new_name) {
-		name = &new_name->u.constant;
+	ZVAL_STR(&resolved_name, zend_resolve_const_name(
+		orig_name, name_ast->attr, &is_fully_qualified TSRMLS_CC));
+
+	if (zend_constant_ct_subst(result, &resolved_name, 1 TSRMLS_CC)) {
+		zval_dtor(&resolved_name);
+		return;
+	}
+
+	opline = zend_emit_op_tmp(result, ZEND_FETCH_CONSTANT, NULL, NULL TSRMLS_CC);
+	opline->op2_type = IS_CONST;
+
+	if (is_fully_qualified) {
+		opline->op2.constant = zend_add_const_name_literal(
+			CG(active_op_array), &resolved_name, 0 TSRMLS_CC);
 	} else {
-		const char *p;
-
-		/* The form "use A\B" is eqivalent to "use A\B as B".
-		   So we extract the last part of compound name to use as a new_name */
-		name = &tmp;
-		p = zend_memrchr(Z_STRVAL(ns), '\\', Z_STRLEN(ns));
-		if (p) {
-			ZVAL_STRING(name, p+1);
+		opline->extended_value = IS_CONSTANT_UNQUALIFIED;
+		if (CG(current_namespace)) {
+			opline->extended_value |= IS_CONSTANT_IN_NAMESPACE;
+			opline->op2.constant = zend_add_const_name_literal(
+				CG(active_op_array), &resolved_name, 1 TSRMLS_CC);
 		} else {
-			ZVAL_ZVAL(name, &ns, 1, 0);
-			warn = !is_global && Z_TYPE(CG(current_namespace)) == IS_UNDEF;
+			opline->op2.constant = zend_add_const_name_literal(
+				CG(active_op_array), &resolved_name, 0 TSRMLS_CC);
 		}
 	}
+	zend_alloc_cache_slot(opline->op2.constant TSRMLS_CC);
+}
+
+void zend_compile_class_const(znode *result, zend_ast *ast TSRMLS_DC) {
+	zend_ast *class_ast = ast->child[0];
+	zend_ast *const_ast = ast->child[1];
 
-	if (case_sensitive) {
-		lookup_name = zend_string_copy(Z_STR_P(name));
+	znode class_node, const_node;
+	zend_op *opline;
+
+	if (zend_is_const_default_class_ref(class_ast)) {
+		class_node.op_type = IS_CONST;
+		ZVAL_STR(&class_node.u.constant, zend_resolve_class_name_ast(class_ast TSRMLS_CC));
 	} else {
-		lookup_name = zend_string_alloc(Z_STRLEN_P(name), 0);
-		zend_str_tolower_copy(lookup_name->val, Z_STRVAL_P(name), Z_STRLEN_P(name));
+		zend_compile_class_ref(&class_node, class_ast TSRMLS_CC);
 	}
 
-	if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
-		/* Prefix import name with current namespace name to avoid conflicts with functions/consts */
-		zend_string *c_ns_name = zend_string_alloc(Z_STRLEN(CG(current_namespace)) + 1 + Z_STRLEN_P(name), 0);
+	zend_compile_expr(&const_node, const_ast TSRMLS_CC);
+
+	opline = zend_emit_op_tmp(result, ZEND_FETCH_CONSTANT, NULL, &const_node TSRMLS_CC);
+
+	zend_set_class_name_op1(opline, &class_node TSRMLS_CC);
+
+	if (opline->op1_type == IS_CONST) {
+		zend_alloc_cache_slot(opline->op2.constant TSRMLS_CC);
+	} else {
+		zend_alloc_polymorphic_cache_slot(opline->op2.constant TSRMLS_CC);
+	}
+}
 
-		zend_str_tolower_copy(c_ns_name->val, Z_STRVAL(CG(current_namespace)), Z_STRLEN(CG(current_namespace)));
-		c_ns_name->val[Z_STRLEN(CG(current_namespace))] = '\\';
-		memcpy(c_ns_name->val+Z_STRLEN(CG(current_namespace))+1, lookup_name, Z_STRLEN_P(name)+1);
-		if (zend_hash_exists(lookup_table, c_ns_name)) {
-			char *tmp2 = zend_str_tolower_dup(Z_STRVAL(ns), Z_STRLEN(ns));
+void zend_compile_resolve_class_name(znode *result, zend_ast *ast TSRMLS_DC) {
+	zend_ast *name_ast = ast->child[0];
+	uint32_t fetch_type = zend_get_class_fetch_type(zend_ast_get_str(name_ast));
 
-			if (Z_STRLEN(ns) != Z_STRLEN(CG(current_namespace)) + 1 + Z_STRLEN_P(name) ||
-				memcmp(tmp2, c_ns_name->val, Z_STRLEN(ns))) {
-				zend_error(E_COMPILE_ERROR, "Cannot use %s %s as %s because the name is already in use", is_function ? "function" : "const", Z_STRVAL(ns), Z_STRVAL_P(name));
+	switch (fetch_type) {
+		case ZEND_FETCH_CLASS_SELF:
+			if (!CG(active_class_entry)) {
+				zend_error_noreturn(E_COMPILE_ERROR,
+					"Cannot access self::class when no class scope is active");
 			}
-			efree(tmp2);
-		}
-		zend_string_free(c_ns_name);
-	} else if (is_function) {
-		zend_function *function;
+			result->op_type = IS_CONST;
+			ZVAL_STR(&result->u.constant, zend_string_copy(CG(active_class_entry)->name));
+			break;
+        case ZEND_FETCH_CLASS_STATIC:
+        case ZEND_FETCH_CLASS_PARENT:
+			if (!CG(active_class_entry)) {
+				zend_error_noreturn(E_COMPILE_ERROR,
+					"Cannot access %s::class when no class scope is active",
+					fetch_type == ZEND_FETCH_CLASS_STATIC ? "static" : "parent");
+			} else {
+				zval class_str_zv;
+				zend_ast *class_str_ast, *class_const_ast;
+
+				ZVAL_STRING(&class_str_zv, "class");
+				class_str_ast = zend_ast_create_zval(&class_str_zv);
+				class_const_ast = zend_ast_create(
+					ZEND_AST_CLASS_CONST, name_ast, class_str_ast);
 
-		if ((function = zend_hash_find_ptr(lookup_table, lookup_name)) != NULL && function->type == ZEND_USER_FUNCTION && strcmp(function->op_array.filename->val, CG(compiled_filename)->val) == 0) {
-			char *c_tmp = zend_str_tolower_dup(Z_STRVAL(ns), Z_STRLEN(ns));
+				zend_compile_expr(result, class_const_ast TSRMLS_CC);
 
-			if (Z_STRLEN(ns) != Z_STRLEN_P(name) ||
-				memcmp(c_tmp, lookup_name->val, Z_STRLEN(ns))) {
-				zend_error(E_COMPILE_ERROR, "Cannot use function %s as %s because the name is already in use", Z_STRVAL(ns), Z_STRVAL_P(name));
+				zval_ptr_dtor(&class_str_zv);
 			}
-			efree(c_tmp);
-		}
-	} else {
-		zend_string *filename;
+			break;
+		case ZEND_FETCH_CLASS_DEFAULT:
+			result->op_type = IS_CONST;
+			ZVAL_STR(&result->u.constant, zend_resolve_class_name_ast(name_ast TSRMLS_CC));
+			break;
+		EMPTY_SWITCH_DEFAULT_CASE()
+	}
+}
+
+void zend_compile_encaps_list(znode *result, zend_ast *ast TSRMLS_DC) {
+	zend_ast_list *list = zend_ast_get_list(ast);
+	uint32_t i;
 
-		if ((filename = zend_hash_find_ptr(lookup_table, lookup_name)) != NULL && strcmp(filename->val, CG(compiled_filename)->val) == 0) {
-			char *c_tmp = zend_str_tolower_dup(Z_STRVAL(ns), Z_STRLEN(ns));
+	ZEND_ASSERT(list->children > 0);
 
-			if (Z_STRLEN(ns) != Z_STRLEN_P(name) ||
-				memcmp(c_tmp, lookup_name->val, Z_STRLEN(ns))) {
-				zend_error(E_COMPILE_ERROR, "Cannot use const %s as %s because the name is already in use", Z_STRVAL(ns), Z_STRVAL_P(name));
+	result->op_type = IS_TMP_VAR;
+	result->u.op.var = get_temporary_variable(CG(active_op_array));
+
+	for (i = 0; i < list->children; ++i) {
+		zend_ast *elem_ast = list->child[i];
+		znode elem_node;
+		zend_op *opline;
+
+		zend_compile_expr(&elem_node, elem_ast TSRMLS_CC);
+
+		if (elem_ast->kind == ZEND_AST_ZVAL) {
+			zval *zv = &elem_node.u.constant;
+			ZEND_ASSERT(Z_TYPE_P(zv) == IS_STRING);
+
+			if (Z_STRLEN_P(zv) > 1) {
+				opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+				opline->opcode = ZEND_ADD_STRING;
+			} else if (Z_STRLEN_P(zv) == 1) {
+				char ch = *Z_STRVAL_P(zv);
+				zend_string_release(Z_STR_P(zv));
+				ZVAL_LONG(zv, ch);
+
+				opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+				opline->opcode = ZEND_ADD_CHAR;
+			} else {
+				/* String can be empty after a variable at the end of a heredoc */
+				zend_string_release(Z_STR_P(zv));
+				continue;
 			}
-			efree(c_tmp);
+		} else {
+			opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+			opline->opcode = ZEND_ADD_VAR;
+			ZEND_ASSERT(elem_node.op_type != IS_CONST);
 		}
+
+		if (i == 0) {
+			SET_UNUSED(opline->op1);
+		} else {
+			SET_NODE(opline->op1, result);
+		}
+		SET_NODE(opline->op2, &elem_node);
+		SET_NODE(opline->result, result);
 	}
+}
 
-	if (zend_hash_add(current_import_sub, lookup_name, &ns) == NULL) {
-		zend_error(E_COMPILE_ERROR, "Cannot use %s %s as %s because the name is already in use", is_function ? "function" : "const", Z_STRVAL(ns), Z_STRVAL_P(name));
+void zend_compile_magic_const(znode *result, zend_ast *ast TSRMLS_DC) {
+	zend_class_entry *ce = CG(active_class_entry);
+
+	if (zend_try_ct_eval_magic_const(&result->u.constant, ast TSRMLS_CC)) {
+		result->op_type = IS_CONST;
+		return;
 	}
-	if (warn) {
-		zend_error(E_WARNING, "The use %s statement with non-compound name '%s' has no effect", is_function ? "function" : "const", Z_STRVAL_P(name));
+
+	ZEND_ASSERT(ast->attr == T_CLASS_C && ce && ZEND_CE_IS_TRAIT(ce));
+
+	{
+		zend_ast *const_ast = zend_ast_create(ZEND_AST_CONST,
+			zend_ast_create_zval_from_str(zend_string_init("__CLASS__", sizeof("__CLASS__") - 1, 0)));
+		zend_compile_const(result, const_ast TSRMLS_CC);
+		zend_ast_destroy(const_ast);
+	}
+}
+
+zend_bool zend_is_allowed_in_const_expr(zend_ast_kind kind) {
+	return kind == ZEND_AST_ZVAL || kind == ZEND_AST_BINARY_OP
+		|| kind == ZEND_AST_GREATER || kind == ZEND_AST_GREATER_EQUAL
+		|| kind == ZEND_AST_AND || kind == ZEND_AST_OR
+		|| kind == ZEND_AST_UNARY_OP
+		|| kind == ZEND_AST_UNARY_PLUS || kind == ZEND_AST_UNARY_MINUS
+		|| kind == ZEND_AST_CONDITIONAL || kind == ZEND_AST_DIM
+		|| kind == ZEND_AST_ARRAY || kind == ZEND_AST_ARRAY_ELEM
+		|| kind == ZEND_AST_CONST || kind == ZEND_AST_CLASS_CONST
+		|| kind == ZEND_AST_RESOLVE_CLASS_NAME || kind == ZEND_AST_MAGIC_CONST;
+}
+
+void zend_compile_const_expr_class_const(zend_ast **ast_ptr TSRMLS_DC) {
+	zend_ast *ast = *ast_ptr;
+	zend_ast *class_ast = ast->child[0];
+	zend_ast *const_ast = ast->child[1];
+	zend_string *class_name = zend_ast_get_str(class_ast);
+	zend_string *const_name = zend_ast_get_str(const_ast);
+	zval result;
+	int fetch_type;
+
+	if (class_ast->kind != ZEND_AST_ZVAL) {
+		zend_error_noreturn(E_COMPILE_ERROR,
+			"Dynamic class names are not allowed in compile-time class constant references");
 	}
-	zend_string_release(lookup_name);
-	zval_dtor(name);
-}
-/* }}} */
 
-void zend_do_use_function(znode *ns_name, znode *new_name, int is_global TSRMLS_DC) /* {{{ */
-{
-	if (!CG(current_import_function)) {
-		CG(current_import_function) = emalloc(sizeof(HashTable));
-		zend_hash_init(CG(current_import_function), 8, NULL, ZVAL_PTR_DTOR, 0);
+	fetch_type = zend_get_class_fetch_type(class_name);
+
+	if (ZEND_FETCH_CLASS_STATIC == fetch_type) {
+		zend_error_noreturn(E_COMPILE_ERROR,
+			"\"static::\" is not allowed in compile-time constants");
+	}
+	
+	if (ZEND_FETCH_CLASS_DEFAULT == fetch_type) {
+		class_name = zend_resolve_class_name_ast(class_ast TSRMLS_CC);
+	} else {
+		zend_string_addref(class_name);
 	}
 
-	zend_do_use_non_class(ns_name, new_name, is_global, 1, 0, CG(current_import_function), CG(function_table) TSRMLS_CC);
-}
-/* }}} */
+	Z_STR(result) = zend_concat3(
+		class_name->val, class_name->len, "::", 2, const_name->val, const_name->len);
 
-void zend_do_use_const(znode *ns_name, znode *new_name, int is_global TSRMLS_DC) /* {{{ */
-{
-	if (!CG(current_import_const)) {
-		CG(current_import_const) = emalloc(sizeof(HashTable));
-		zend_hash_init(CG(current_import_const), 8, NULL, ZVAL_PTR_DTOR, 0);
+	Z_TYPE_INFO(result) = IS_CONSTANT_EX;
+	if (IS_INTERNED(Z_STR(result))) {
+		Z_TYPE_FLAGS(result) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE);
 	}
+	Z_CONST_FLAGS(result) = fetch_type;
 
-	zend_do_use_non_class(ns_name, new_name, is_global, 0, 1, CG(current_import_const), &CG(const_filenames) TSRMLS_CC);
+	zend_ast_destroy(ast);
+	zend_string_release(class_name);
+
+	*ast_ptr = zend_ast_create_zval(&result);
 }
-/* }}} */
 
-void zend_do_declare_constant(znode *name, znode *value TSRMLS_DC) /* {{{ */
-{
-	zend_op *opline;
-	zval *ns_name;
+void zend_compile_const_expr_const(zend_ast **ast_ptr TSRMLS_DC) {
+	zend_ast *ast = *ast_ptr;
+	zend_ast *name_ast = ast->child[0];
+	zval *orig_name = zend_ast_get_zval(name_ast);
+	zend_bool is_fully_qualified;
 
-	if (zend_get_ct_const(&name->u.constant, 0 TSRMLS_CC)) {
-		zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare constant '%s'", Z_STRVAL(name->u.constant));
+	znode result;
+	zval resolved_name;
+
+	if (zend_constant_ct_subst(&result, orig_name, 0 TSRMLS_CC)) {
+		zend_ast_destroy(ast);
+		*ast_ptr = zend_ast_create_zval(&result.u.constant);
+		return;
 	}
 
-	if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
-		/* Prefix constant name with name of current namespace, lowercased */
-		znode tmp;
+	ZVAL_STR(&resolved_name, zend_resolve_const_name(
+		Z_STR_P(orig_name), name_ast->attr, &is_fully_qualified TSRMLS_CC));
 
-		tmp.op_type = IS_CONST;
-		ZVAL_NEW_STR(&tmp.u.constant, zend_string_alloc(Z_STRLEN(CG(current_namespace)), 0));
-		zend_str_tolower_copy(Z_STRVAL(tmp.u.constant), Z_STRVAL(CG(current_namespace)), Z_STRLEN(CG(current_namespace)));
-		zend_do_build_namespace_name(&tmp, &tmp, name TSRMLS_CC);
-		*name = tmp;
+	Z_TYPE_INFO(resolved_name) = IS_CONSTANT_EX;
+	if (!is_fully_qualified) {
+		Z_CONST_FLAGS(resolved_name) = IS_CONSTANT_UNQUALIFIED;
 	}
 
-	/* Constant name must not conflict with import names */
-	if (CG(current_import_const) &&
-	    (ns_name = zend_hash_find(CG(current_import_const), Z_STR(name->u.constant))) != NULL) {
+	zend_ast_destroy(ast);
+	*ast_ptr = zend_ast_create_zval(&resolved_name);
+}
 
-		char *tmp = estrndup(Z_STRVAL_P(ns_name), Z_STRLEN_P(ns_name));
+void zend_compile_const_expr_resolve_class_name(zend_ast **ast_ptr TSRMLS_DC) {
+	zend_ast *ast = *ast_ptr;
+	zend_ast *name_ast = ast->child[0];
+	uint32_t fetch_type = zend_get_class_fetch_type(zend_ast_get_str(name_ast));
+	zval result;
 
-		if (Z_STRLEN_P(ns_name) != Z_STRLEN(name->u.constant) ||
-			memcmp(tmp, Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant))) {
-			zend_error(E_COMPILE_ERROR, "Cannot declare const %s because the name is already in use", Z_STRVAL(name->u.constant));
-		}
-		efree(tmp);
+	switch (fetch_type) {
+		case ZEND_FETCH_CLASS_SELF:
+			if (!CG(active_class_entry)) {
+				zend_error_noreturn(E_COMPILE_ERROR,
+					"Cannot access self::class when no class scope is active");
+			}
+			ZVAL_STR(&result, zend_string_copy(CG(active_class_entry)->name));
+			break;
+        case ZEND_FETCH_CLASS_STATIC:
+        case ZEND_FETCH_CLASS_PARENT:
+			zend_error_noreturn(E_COMPILE_ERROR,
+				"%s::class cannot be used for compile-time class name resolution",
+				fetch_type == ZEND_FETCH_CLASS_STATIC ? "static" : "parent"
+			);
+			break;
+		case ZEND_FETCH_CLASS_DEFAULT:
+			ZVAL_STR(&result, zend_resolve_class_name_ast(name_ast TSRMLS_CC));
+			break;
+		EMPTY_SWITCH_DEFAULT_CASE()
 	}
 
-	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-	opline->opcode = ZEND_DECLARE_CONST;
-	SET_UNUSED(opline->result);
-	SET_NODE(opline->op1, name);
-	SET_NODE(opline->op2, value);
-
-	zend_hash_add_ptr(&CG(const_filenames), Z_STR(name->u.constant), CG(compiled_filename));
+	zend_ast_destroy(ast);
+	*ast_ptr = zend_ast_create_zval(&result);
 }
-/* }}} */
 
-void zend_verify_namespace(TSRMLS_D) /* {{{ */
-{
-	if (CG(has_bracketed_namespaces) && !CG(in_namespace)) {
-		zend_error_noreturn(E_COMPILE_ERROR, "No code may exist outside of namespace {}");
+void zend_compile_const_expr_magic_const(zend_ast **ast_ptr TSRMLS_DC) {
+	zend_ast *ast = *ast_ptr;
+	zend_class_entry *ce = CG(active_class_entry);
+
+	/* Other cases already resolved by constant folding */
+	ZEND_ASSERT(ast->attr == T_CLASS_C && ce && ZEND_CE_IS_TRAIT(ce));
+
+	{
+		zval const_zv;
+		ZVAL_STRING(&const_zv, "__CLASS__");
+		Z_TYPE_INFO(const_zv) = IS_CONSTANT_EX;
+
+		zend_ast_destroy(ast);
+		*ast_ptr = zend_ast_create_zval(&const_zv);
 	}
 }
-/* }}} */
 
-void zend_do_end_namespace(TSRMLS_D) /* {{{ */
-{
-	CG(in_namespace) = 0;
-	if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
-		zval_dtor(&CG(current_namespace));
-		ZVAL_UNDEF(&CG(current_namespace));
-	}
-	if (CG(current_import)) {
-		zend_hash_destroy(CG(current_import));
-		efree(CG(current_import));
-		CG(current_import) = NULL;
+void zend_compile_const_expr(zend_ast **ast_ptr TSRMLS_DC) {
+	zend_ast *ast = *ast_ptr;
+	if (ast == NULL || ast->kind == ZEND_AST_ZVAL) {
+		return;
 	}
-	if (CG(current_import_function)) {
-		zend_hash_destroy(CG(current_import_function));
-		efree(CG(current_import_function));
-		CG(current_import_function) = NULL;
+
+	if (!zend_is_allowed_in_const_expr(ast->kind)) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Constant expression contains invalid operations");
 	}
-	if (CG(current_import_const)) {
-		zend_hash_destroy(CG(current_import_const));
-		efree(CG(current_import_const));
-		CG(current_import_const) = NULL;
+
+	switch (ast->kind) {
+		case ZEND_AST_CLASS_CONST:
+			zend_compile_const_expr_class_const(ast_ptr TSRMLS_CC);
+			break;
+		case ZEND_AST_CONST:
+			zend_compile_const_expr_const(ast_ptr TSRMLS_CC);
+			break;
+		case ZEND_AST_RESOLVE_CLASS_NAME:
+			zend_compile_const_expr_resolve_class_name(ast_ptr TSRMLS_CC);
+			break;
+		case ZEND_AST_MAGIC_CONST:
+			zend_compile_const_expr_magic_const(ast_ptr TSRMLS_CC);
+			break;
+		default:
+			zend_ast_apply(ast, zend_compile_const_expr TSRMLS_CC);
+			break;
 	}
 }
-/* }}} */
 
-void zend_do_end_compilation(TSRMLS_D) /* {{{ */
-{
-	CG(has_bracketed_namespaces) = 0;
-	zend_do_end_namespace(TSRMLS_C);
-}
-/* }}} */
+void zend_const_expr_to_zval(zval *result, zend_ast *ast TSRMLS_DC) {
+	zend_ast *orig_ast = ast;
+	zend_eval_const_expr(&ast TSRMLS_CC);
+	zend_compile_const_expr(&ast TSRMLS_CC);
+	if (ast->kind == ZEND_AST_ZVAL) {
+		ZVAL_COPY_VALUE(result, zend_ast_get_zval(ast));
 
-void zend_do_constant_expression(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
-{
-	if (ast->kind == ZEND_CONST) {
-		ZVAL_COPY_VALUE(&result->u.constant, &ast->u.val);
-		efree(ast);
-	} else if (zend_ast_is_ct_constant(ast)) {
-		zend_ast_evaluate(&result->u.constant, ast, NULL TSRMLS_CC);
-		zend_ast_destroy(ast);
+		/* Kill this branch of the original AST, as it was already destroyed.
+		 * It would be nice to find a better solution to this problem in the
+		 * future. */
+		orig_ast->kind = 0;
 	} else {
-		ZVAL_NEW_AST(&result->u.constant, ast);
+		ZVAL_NEW_AST(result, zend_ast_copy(ast));
 	}
 }
-/* }}} */
 
-/* {{{ zend_dirname
-   Returns directory name component of path */
-ZEND_API size_t zend_dirname(char *path, size_t len)
-{
-	register char *end = path + len - 1;
-	unsigned int len_adjust = 0;
+/* Same as compile_stmt, but with early binding */
+void zend_compile_top_stmt(zend_ast *ast TSRMLS_DC) {
+	if (!ast) {
+		return;
+	}
 
-#ifdef PHP_WIN32
-	/* Note that on Win32 CWD is per drive (heritage from CP/M).
-	 * This means dirname("c:foo") maps to "c:." or "c:" - which means CWD on C: drive.
-	 */
-	if ((2 <= len) && isalpha((int)((unsigned char *)path)[0]) && (':' == path[1])) {
-		/* Skip over the drive spec (if any) so as not to change */
-		path += 2;
-		len_adjust += 2;
-		if (2 == len) {
-			/* Return "c:" on Win32 for dirname("c:").
-			 * It would be more consistent to return "c:."
-			 * but that would require making the string *longer*.
-			 */
-			return len;
+	if (ast->kind == ZEND_AST_STMT_LIST) {
+		zend_ast_list *list = zend_ast_get_list(ast);
+		uint32_t i;
+		for (i = 0; i < list->children; ++i) {
+			zend_compile_top_stmt(list->child[i] TSRMLS_CC);
 		}
+		return;
 	}
-#elif defined(NETWARE)
-	/*
-	 * Find the first occurrence of : from the left
-	 * move the path pointer to the position just after :
-	 * increment the len_adjust to the length of path till colon character(inclusive)
-	 * If there is no character beyond : simple return len
-	 */
-	char *colonpos = NULL;
-	colonpos = strchr(path, ':');
-	if (colonpos != NULL) {
-		len_adjust = ((colonpos - path) + 1);
-		path += len_adjust;
-		if (len_adjust == len) {
-			return len;
-		}
+
+	zend_compile_stmt(ast TSRMLS_CC);
+
+	if (ast->kind != ZEND_AST_NAMESPACE && ast->kind != ZEND_AST_HALT_COMPILER) {
+		zend_verify_namespace(TSRMLS_C);
 	}
-#endif
+	if (ast->kind == ZEND_AST_FUNC_DECL || ast->kind == ZEND_AST_CLASS) {
+		CG(zend_lineno) = ((zend_ast_decl *) ast)->end_lineno;
+		zend_do_early_binding(TSRMLS_C);
+	}
+}
 
-	if (len == 0) {
-		/* Illegal use of this function */
-		return 0;
+void zend_compile_stmt(zend_ast *ast TSRMLS_DC) {
+	if (!ast) {
+		return;
 	}
 
-	/* Strip trailing slashes */
-	while (end >= path && IS_SLASH_P(end)) {
-		end--;
+	CG(zend_lineno) = ast->lineno;
+
+	switch (ast->kind) {
+		case ZEND_AST_STMT_LIST:
+			zend_compile_stmt_list(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_GLOBAL:
+			zend_compile_global_var(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_STATIC:
+			zend_compile_static_var(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_UNSET:
+			zend_compile_unset(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_RETURN:
+			zend_compile_return(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_ECHO:
+			zend_compile_echo(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_THROW:
+			zend_compile_throw(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_BREAK:
+		case ZEND_AST_CONTINUE:
+			zend_compile_break_continue(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_GOTO:
+			zend_compile_goto(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_LABEL:
+			zend_compile_label(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_WHILE:
+			zend_compile_while(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_DO_WHILE:
+			zend_compile_do_while(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_FOR:
+			zend_compile_for(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_FOREACH:
+			zend_compile_foreach(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_IF:
+			zend_compile_if(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_SWITCH:
+			zend_compile_switch(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_TRY:
+			zend_compile_try(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_DECLARE:
+			zend_compile_declare(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_FUNC_DECL:
+		case ZEND_AST_METHOD:
+			zend_compile_func_decl(NULL, ast TSRMLS_CC);
+			break;
+		case ZEND_AST_PROP_DECL:
+			zend_compile_prop_decl(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_CLASS_CONST_DECL:
+			zend_compile_class_const_decl(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_USE_TRAIT:
+			zend_compile_use_trait(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_CLASS:
+			zend_compile_class_decl(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_USE:
+			zend_compile_use(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_CONST_DECL:
+			zend_compile_const_decl(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_NAMESPACE:
+			zend_compile_namespace(ast TSRMLS_CC);
+			break;
+		case ZEND_AST_HALT_COMPILER:
+			zend_compile_halt_compiler(ast TSRMLS_CC);
+			break;
+		default:
+		{
+			znode result;
+			zend_compile_expr(&result, ast TSRMLS_CC);
+			zend_do_free(&result TSRMLS_CC);
+		}
 	}
-	if (end < path) {
-		/* The path only contained slashes */
-		path[0] = DEFAULT_SLASH;
-		path[1] = '\0';
-		return 1 + len_adjust;
+
+	if (Z_LVAL(CG(declarables).ticks) && !zend_is_unticked_stmt(ast)) {
+		zend_emit_tick(TSRMLS_C);
 	}
+}
 
-	/* Strip filename */
-	while (end >= path && !IS_SLASH_P(end)) {
-		end--;
+void zend_compile_expr(znode *result, zend_ast *ast TSRMLS_DC) {
+	//CG(zend_lineno) = ast->lineno;
+	CG(zend_lineno) = zend_ast_get_lineno(ast);
+
+	switch (ast->kind) {
+		case ZEND_AST_ZVAL:
+			ZVAL_COPY(&result->u.constant, zend_ast_get_zval(ast));
+			result->op_type = IS_CONST;
+			return;
+		case ZEND_AST_ZNODE:
+			*result = *zend_ast_get_znode(ast);
+			return;
+		case ZEND_AST_VAR:
+		case ZEND_AST_DIM:
+		case ZEND_AST_PROP:
+		case ZEND_AST_STATIC_PROP:
+		case ZEND_AST_CALL:
+		case ZEND_AST_METHOD_CALL:
+		case ZEND_AST_STATIC_CALL:
+			zend_compile_var(result, ast, BP_VAR_R TSRMLS_CC);
+			return;
+		case ZEND_AST_ASSIGN:
+			zend_compile_assign(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_ASSIGN_REF:
+			zend_compile_assign_ref(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_NEW:
+			zend_compile_new(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_CLONE:
+			zend_compile_clone(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_ASSIGN_OP:
+			zend_compile_compound_assign(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_BINARY_OP:
+			zend_compile_binary_op(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_GREATER:
+		case ZEND_AST_GREATER_EQUAL:
+			zend_compile_greater(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_UNARY_OP:
+			zend_compile_unary_op(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_UNARY_PLUS:
+		case ZEND_AST_UNARY_MINUS:
+			zend_compile_unary_pm(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_AND:
+		case ZEND_AST_OR:
+			zend_compile_short_circuiting(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_POST_INC:
+		case ZEND_AST_POST_DEC:
+			zend_compile_post_incdec(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_PRE_INC:
+		case ZEND_AST_PRE_DEC:
+			zend_compile_pre_incdec(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_CAST:
+			zend_compile_cast(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_CONDITIONAL:
+			zend_compile_conditional(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_PRINT:
+			zend_compile_print(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_EXIT:
+			zend_compile_exit(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_YIELD:
+			zend_compile_yield(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_INSTANCEOF:
+			zend_compile_instanceof(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_INCLUDE_OR_EVAL:
+			zend_compile_include_or_eval(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_ISSET:
+		case ZEND_AST_EMPTY:
+			zend_compile_isset_or_empty(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_SILENCE:
+			zend_compile_silence(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_SHELL_EXEC:
+			zend_compile_shell_exec(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_ARRAY:
+			zend_compile_array(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_CONST:
+			zend_compile_const(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_CLASS_CONST:
+			zend_compile_class_const(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_RESOLVE_CLASS_NAME:
+			zend_compile_resolve_class_name(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_ENCAPS_LIST:
+			zend_compile_encaps_list(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_MAGIC_CONST:
+			zend_compile_magic_const(result, ast TSRMLS_CC);
+			return;
+		case ZEND_AST_CLOSURE:
+			zend_compile_func_decl(result, ast TSRMLS_CC);
+			return;
+		default:
+			ZEND_ASSERT(0 /* not supported */);
 	}
-	if (end < path) {
-		/* No slash found, therefore return '.' */
-#ifdef NETWARE
-		if (len_adjust == 0) {
-			path[0] = '.';
-			path[1] = '\0';
-			return 1; /* only one character */
-		} else {
-			path[0] = '\0';
-			return len_adjust;
-		}
-#else
-		path[0] = '.';
-		path[1] = '\0';
-		return 1 + len_adjust;
-#endif
+}
+
+void zend_compile_var(znode *result, zend_ast *ast, int type TSRMLS_DC) {
+	switch (ast->kind) {
+		case ZEND_AST_VAR:
+			zend_compile_simple_var(result, ast, type TSRMLS_CC);
+			return;
+		case ZEND_AST_DIM:
+			zend_compile_dim(result, ast, type TSRMLS_CC);
+			return;
+		case ZEND_AST_PROP:
+			zend_compile_prop(result, ast, type TSRMLS_CC);
+			return;
+		case ZEND_AST_STATIC_PROP:
+			zend_compile_static_prop(result, ast, type TSRMLS_CC);
+			return;
+		case ZEND_AST_CALL:
+			zend_compile_call(result, ast, type TSRMLS_CC);
+			return;
+		case ZEND_AST_METHOD_CALL:
+			zend_compile_method_call(result, ast, type TSRMLS_CC);
+			return;
+		case ZEND_AST_STATIC_CALL:
+			zend_compile_static_call(result, ast, type TSRMLS_CC);
+			return;
+		case ZEND_AST_ZNODE:
+			*result = *zend_ast_get_znode(ast);
+			return;
+		default:
+			if (type == BP_VAR_W || type == BP_VAR_REF
+				|| type == BP_VAR_RW || type == BP_VAR_UNSET
+			) {
+				/* For BC reasons =& new Foo is allowed */
+				if (type != BP_VAR_REF || ast->kind != ZEND_AST_NEW) {
+					zend_error_noreturn(E_COMPILE_ERROR,
+						"Cannot use temporary expression in write context");
+				}
+			}
+
+			zend_compile_expr(result, ast TSRMLS_CC);
+			return;
 	}
+}
 
-	/* Strip slashes which came before the file name */
-	while (end >= path && IS_SLASH_P(end)) {
-		end--;
+void zend_delayed_compile_var(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC) {
+	zend_op *opline;
+	switch (ast->kind) {
+		case ZEND_AST_DIM:
+			opline = zend_delayed_compile_dim(result, ast, type TSRMLS_CC);
+			zend_adjust_for_fetch_type(opline, type);
+			return;
+		case ZEND_AST_PROP:
+			opline = zend_delayed_compile_prop(result, ast, type TSRMLS_CC);
+			zend_adjust_for_fetch_type(opline, type);
+			return;
+		default:
+			zend_compile_var(result, ast, type TSRMLS_CC);
+			return;
 	}
-	if (end < path) {
-		path[0] = DEFAULT_SLASH;
-		path[1] = '\0';
-		return 1 + len_adjust;
+}
+
+void zend_eval_const_expr(zend_ast **ast_ptr TSRMLS_DC) {
+	zend_ast *ast = *ast_ptr;
+	zval result;
+
+	if (!ast) {
+		return;
 	}
-	*(end+1) = '\0';
 
-	return (size_t)(end + 1 - path) + len_adjust;
+	switch (ast->kind) {
+		case ZEND_AST_BINARY_OP:
+			zend_eval_const_expr(&ast->child[0] TSRMLS_CC);
+			zend_eval_const_expr(&ast->child[1] TSRMLS_CC);
+			if (ast->child[0]->kind != ZEND_AST_ZVAL || ast->child[1]->kind != ZEND_AST_ZVAL) {
+				return;
+			}
+
+			zend_ct_eval_binary_op(&result, ast->attr,
+				zend_ast_get_zval(ast->child[0]), zend_ast_get_zval(ast->child[1]) TSRMLS_CC);
+			break;
+		case ZEND_AST_GREATER:
+		case ZEND_AST_GREATER_EQUAL:
+			zend_eval_const_expr(&ast->child[0] TSRMLS_CC);
+			zend_eval_const_expr(&ast->child[1] TSRMLS_CC);
+			if (ast->child[0]->kind != ZEND_AST_ZVAL || ast->child[1]->kind != ZEND_AST_ZVAL) {
+				return;
+			}
+
+			zend_ct_eval_greater(&result, ast->kind,
+				zend_ast_get_zval(ast->child[0]), zend_ast_get_zval(ast->child[1]) TSRMLS_CC);
+			break;
+		case ZEND_AST_UNARY_PLUS:
+		case ZEND_AST_UNARY_MINUS:
+			zend_eval_const_expr(&ast->child[0] TSRMLS_CC);
+			if (ast->child[0]->kind != ZEND_AST_ZVAL) {
+				return;
+			}
+
+			zend_ct_eval_unary_pm(&result, ast->kind,
+				zend_ast_get_zval(ast->child[0]) TSRMLS_CC);
+			break;
+		case ZEND_AST_ARRAY:
+			if (!zend_try_ct_eval_array(&result, ast TSRMLS_CC)) {
+				return;
+			}
+			break;
+		case ZEND_AST_MAGIC_CONST:
+			if (!zend_try_ct_eval_magic_const(&result, ast TSRMLS_CC)) {
+				return;
+			}
+			break;
+		default:
+			return;
+	}
+
+	zend_ast_destroy(ast);
+	*ast_ptr = zend_ast_create_zval(&result);
 }
-/* }}} */
 
 /*
  * Local variables:
diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h
index 1b4d05bcaf..7eebf4baff 100644
--- a/Zend/zend_compile.h
+++ b/Zend/zend_compile.h
@@ -33,22 +33,18 @@
 
 #define DEBUG_ZEND 0
 
-#define FREE_PNODE(znode)	zval_dtor(&znode->u.constant);
-
 #define SET_UNUSED(op)  op ## _type = IS_UNUSED
 
 #define INC_BPC(op_array)	if (op_array->fn_flags & ZEND_ACC_INTERACTIVE) { (CG(context).backpatch_count++); }
 #define DEC_BPC(op_array)	if (op_array->fn_flags & ZEND_ACC_INTERACTIVE) { (CG(context).backpatch_count--); }
 #define HANDLE_INTERACTIVE()  if (CG(active_op_array)->fn_flags & ZEND_ACC_INTERACTIVE) { execute_new_code(TSRMLS_C); }
-#define DO_TICKS()            if (Z_LVAL(CG(declarables).ticks)) { zend_do_ticks(TSRMLS_C); }
 
-#define RESET_DOC_COMMENT()        \
-    {                              \
-        if (CG(doc_comment)) {     \
-          zend_string_release(CG(doc_comment));  \
-          CG(doc_comment) = NULL;  \
-        }                          \
-    }
+#define RESET_DOC_COMMENT() do { \
+	if (CG(doc_comment)) { \
+		zend_string_release(CG(doc_comment)); \
+		CG(doc_comment) = NULL; \
+	} \
+} while (0)
 
 typedef struct _zend_op_array zend_op_array;
 typedef struct _zend_op zend_op;
@@ -79,12 +75,36 @@ typedef struct _znode { /* used only during compilation */
 	union {
 		znode_op op;
 		zval constant; /* replaced by literal/zv */
-		zend_op_array *op_array;
-		zend_ast *ast;
 	} u;
-	uint32_t EA;      /* extended attributes */
 } znode;
 
+/* Temporarily defined here, to avoid header ordering issues */
+typedef struct _zend_ast_znode {
+	zend_ast_kind kind;
+	zend_ast_attr attr;
+	uint32_t lineno;
+	znode node;
+} zend_ast_znode;
+ZEND_API zend_ast *zend_ast_create_znode(znode *node);
+
+static inline znode *zend_ast_get_znode(zend_ast *ast) {
+	return &((zend_ast_znode *) ast)->node;
+}
+
+typedef union _zend_parser_stack_elem {
+	zend_ast *ast;
+	zend_ast_list *list;
+	zend_string *str;
+	zend_ulong num;
+} zend_parser_stack_elem;
+
+void zend_compile_top_stmt(zend_ast *ast TSRMLS_DC);
+void zend_compile_stmt(zend_ast *ast TSRMLS_DC);
+void zend_compile_expr(znode *node, zend_ast *ast TSRMLS_DC);
+void zend_compile_var(znode *node, zend_ast *ast, int type TSRMLS_DC);
+void zend_eval_const_expr(zend_ast **ast_ptr TSRMLS_DC);
+void zend_const_expr_to_zval(zval *result, zend_ast *ast TSRMLS_DC);
+
 typedef struct _zend_execute_data zend_execute_data;
 
 #define ZEND_OPCODE_HANDLER_ARGS zend_execute_data *execute_data TSRMLS_DC
@@ -208,8 +228,9 @@ typedef struct _zend_try_catch_element {
 /* function has arguments with type hinting */
 #define ZEND_ACC_HAS_TYPE_HINTS			0x10000000
 
-char *zend_visibility_string(uint32_t fn_flags);
+#define ZEND_CE_IS_TRAIT(ce) (((ce)->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT)
 
+char *zend_visibility_string(uint32_t fn_flags);
 
 typedef struct _zend_property_info {
 	uint32_t flags;
@@ -335,26 +356,12 @@ union _zend_function {
 	zend_internal_function internal_function;
 };
 
-typedef struct _zend_function_call_entry {
-	zend_function *fbc;
-	uint32_t op_number;
-	uint32_t arg_num;
-	zend_bool uses_argument_unpacking;
-} zend_function_call_entry;
-
 typedef struct _zend_switch_entry {
 	znode cond;
 	int default_case;
 	int control_var;
 } zend_switch_entry;
 
-
-typedef struct _list_llist_element {
-	znode var;
-	zend_llist dimensions;
-	znode value;
-} list_llist_element;
-
 typedef enum _vm_frame_kind {
 	VM_FRAME_NESTED_FUNCTION,	/* stackless VM call to function */
 	VM_FRAME_NESTED_CODE,		/* stackless VM call to include/require/eval */
@@ -431,10 +438,6 @@ ZEND_API zend_string *zend_get_compiled_filename(TSRMLS_D);
 ZEND_API int zend_get_compiled_lineno(TSRMLS_D);
 ZEND_API size_t zend_get_scanned_file_offset(TSRMLS_D);
 
-void zend_resolve_non_class_name(znode *element_name, zend_bool *check_namespace, zend_bool case_sensitive, HashTable *current_import_sub TSRMLS_DC);
-void zend_resolve_function_name(znode *element_name, zend_bool *check_namespace TSRMLS_DC);
-void zend_resolve_const_name(znode *element_name, zend_bool *check_namespace TSRMLS_DC);
-void zend_resolve_class_name(znode *class_name TSRMLS_DC);
 ZEND_API zend_string *zend_get_compiled_variable_name(const zend_op_array *op_array, uint32_t var);
 
 #ifdef ZTS
@@ -443,95 +446,26 @@ int zend_get_zendleng(TSRMLS_D);
 #endif
 
 
-/* parser-driven code generators */
-void zend_do_binary_op(zend_uchar op, znode *result, znode *op1, znode *op2 TSRMLS_DC);
-void zend_do_unary_op(zend_uchar op, znode *result, znode *op1 TSRMLS_DC);
-void zend_do_binary_assign_op(zend_uchar op, znode *result, znode *op1, znode *op2 TSRMLS_DC);
-void zend_do_assign(znode *result, znode *variable, znode *value TSRMLS_DC);
-void zend_do_assign_ref(znode *result, znode *lvar, znode *rvar TSRMLS_DC);
-void fetch_simple_variable(znode *result, znode *varname, int bp TSRMLS_DC);
-void fetch_simple_variable_ex(znode *result, znode *varname, int bp, zend_uchar op TSRMLS_DC);
-void zend_do_indirect_references(znode *result, const znode *num_references, znode *variable TSRMLS_DC);
-void zend_do_fetch_static_variable(znode *varname, znode *static_assignment, int fetch_type TSRMLS_DC);
-void zend_do_fetch_global_variable(znode *varname, const znode *static_assignment, int fetch_type TSRMLS_DC);
-
-void fetch_array_begin(znode *result, znode *varname, znode *first_dim TSRMLS_DC);
-void fetch_array_dim(znode *result, znode *parent, znode *dim TSRMLS_DC);
-void fetch_string_offset(znode *result, znode *parent, znode *offset TSRMLS_DC);
-void zend_do_fetch_static_member(znode *result, znode *class_znode TSRMLS_DC);
-void zend_do_print(znode *result, znode *arg TSRMLS_DC);
-void zend_do_echo(znode *arg TSRMLS_DC);
 typedef int (*unary_op_type)(zval *, zval * TSRMLS_DC);
 typedef int (*binary_op_type)(zval *, zval *, zval * TSRMLS_DC);
 ZEND_API unary_op_type get_unary_op(int opcode);
 ZEND_API binary_op_type get_binary_op(int opcode);
 
-void zend_do_while_cond(znode *expr, znode *close_bracket_token TSRMLS_DC);
-void zend_do_while_end(const znode *while_token, const znode *close_bracket_token TSRMLS_DC);
-void zend_do_do_while_begin(TSRMLS_D);
-void zend_do_do_while_end(const znode *do_token, const znode *expr_open_bracket, znode *expr TSRMLS_DC);
-
-
-void zend_do_if_cond(znode *cond, znode *closing_bracket_token TSRMLS_DC);
-void zend_do_if_after_statement(const znode *closing_bracket_token, unsigned char initialize TSRMLS_DC);
-void zend_do_if_end(TSRMLS_D);
-
-void zend_do_for_cond(znode *expr, znode *second_semicolon_token TSRMLS_DC);
-void zend_do_for_before_statement(const znode *cond_start, const znode *second_semicolon_token TSRMLS_DC);
-void zend_do_for_end(const znode *second_semicolon_token TSRMLS_DC);
-
-void zend_do_pre_incdec(znode *result, znode *op1, zend_uchar op TSRMLS_DC);
-void zend_do_post_incdec(znode *result, znode *op1, zend_uchar op TSRMLS_DC);
-
-void zend_do_begin_variable_parse(TSRMLS_D);
-void zend_do_end_variable_parse(znode *variable, int type, int arg_offset TSRMLS_DC);
-
-void zend_check_writable_variable(const znode *variable);
+void zend_stop_lexing(TSRMLS_D);
+void zend_emit_final_return(zval *zv TSRMLS_DC);
+zend_ast *zend_ast_append_str(zend_ast *left, zend_ast *right);
+uint32_t zend_add_member_modifier(uint32_t flags, uint32_t new_flag);
+zend_ast_list *zend_ast_append_doc_comment(zend_ast_list *list TSRMLS_DC);
+void zend_handle_encoding_declaration(zend_ast_list *declares TSRMLS_DC);
 
+/* parser-driven code generators */
 void zend_do_free(znode *op1 TSRMLS_DC);
 
-void zend_do_add_string(znode *result, znode *op1, znode *op2 TSRMLS_DC);
-void zend_do_add_variable(znode *result, znode *op1, znode *op2 TSRMLS_DC);
-
-int zend_do_verify_access_types(const znode *current_access_type, const znode *new_modifier);
-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_do_end_function_declaration(const znode *function_token TSRMLS_DC);
-void zend_do_receive_param(zend_uchar op, znode *varname, znode *initialization, znode *class_type, zend_bool pass_by_reference, zend_bool is_variadic TSRMLS_DC);
-int zend_do_begin_function_call(znode *function_name, zend_bool check_namespace TSRMLS_DC);
-void zend_do_begin_method_call(znode *left_bracket TSRMLS_DC);
-void zend_do_clone(znode *result, znode *expr TSRMLS_DC);
-void zend_do_begin_dynamic_function_call(znode *function_name, int prefix_len TSRMLS_DC);
-void zend_do_fetch_class(znode *result, znode *class_name TSRMLS_DC);
-void zend_do_build_full_name(znode *result, znode *prefix, znode *name, int is_class_member TSRMLS_DC);
-int zend_do_begin_class_member_function_call(znode *class_name, znode *method_name TSRMLS_DC);
-void zend_do_end_function_call(znode *function_name, znode *result, int is_method, int is_dynamic_fcall TSRMLS_DC);
-void zend_do_return(znode *expr, int do_end_vparse TSRMLS_DC);
-void zend_do_yield(znode *result, znode *value, znode *key, zend_bool is_variable TSRMLS_DC);
-void zend_do_handle_exception(TSRMLS_D);
-
-void zend_do_begin_lambda_function_declaration(znode *result, znode *function_token, int return_reference, int is_static TSRMLS_DC);
-void zend_do_fetch_lexical_variable(znode *varname, zend_bool is_ref TSRMLS_DC);
-
-void zend_do_try(znode *try_token TSRMLS_DC);
-void zend_do_begin_catch(znode *try_token, znode *catch_class, znode *catch_var, znode *first_catch TSRMLS_DC);
-void zend_do_bind_catch(znode *try_token, znode *catch_token TSRMLS_DC);
-void zend_do_end_catch(znode *catch_token TSRMLS_DC);
-void zend_do_finally(znode *finally_token TSRMLS_DC);
-void zend_do_end_finally(znode *try_token, znode* catch_token, znode *finally_token TSRMLS_DC);
-void zend_do_throw(znode *expr TSRMLS_DC);
-
 ZEND_API int do_bind_function(const zend_op_array *op_array, zend_op *opline, HashTable *function_table, zend_bool compile_time TSRMLS_DC);
 ZEND_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_API zend_class_entry *do_bind_inherited_class(const zend_op_array *op_array, const zend_op *opline, HashTable *class_table, zend_class_entry *parent_ce, zend_bool compile_time TSRMLS_DC);
 ZEND_API void zend_do_inherit_interfaces(zend_class_entry *ce, const zend_class_entry *iface TSRMLS_DC);
 ZEND_API void zend_do_implement_interface(zend_class_entry *ce, zend_class_entry *iface TSRMLS_DC);
-void zend_do_implements_interface(znode *interface_znode TSRMLS_DC);
-
-/* Trait related functions */
-void zend_do_use_trait(znode *trait_znode TSRMLS_DC);
-void zend_prepare_reference(znode *result, znode *class_name, znode *method_name TSRMLS_DC);
-void zend_add_trait_precedence(znode *method_reference, znode *trait_list TSRMLS_DC);
-void zend_add_trait_alias(znode *method_reference, znode *modifiers, znode *alias TSRMLS_DC);
 
 ZEND_API void zend_do_implement_trait(zend_class_entry *ce, zend_class_entry *trait TSRMLS_DC);
 ZEND_API void zend_do_bind_traits(zend_class_entry *ce TSRMLS_DC);
@@ -540,109 +474,17 @@ ZEND_API void zend_do_inheritance(zend_class_entry *ce, zend_class_entry *parent
 void zend_do_early_binding(TSRMLS_D);
 ZEND_API void zend_do_delayed_early_binding(const zend_op_array *op_array TSRMLS_DC);
 
-void zend_do_pass_param(znode *param, zend_uchar op TSRMLS_DC);
-void zend_do_unpack_params(znode *params TSRMLS_DC);
-
-
-void zend_do_boolean_or_begin(znode *expr1, znode *op_token TSRMLS_DC);
-void zend_do_boolean_or_end(znode *result, znode *expr1, znode *expr2, const znode *op_token TSRMLS_DC);
-void zend_do_boolean_and_begin(znode *expr1, znode *op_token TSRMLS_DC);
-void zend_do_boolean_and_end(znode *result, znode *expr1, znode *expr2, const znode *op_token TSRMLS_DC);
-
-void zend_do_brk_cont(zend_uchar op, znode *expr TSRMLS_DC);
-
-void zend_do_switch_cond(const znode *cond TSRMLS_DC);
-void zend_do_switch_end(const znode *case_list TSRMLS_DC);
-void zend_do_case_before_statement(const znode *case_list, znode *case_token, znode *case_expr TSRMLS_DC);
-void zend_do_case_after_statement(znode *result, const znode *case_token TSRMLS_DC);
-void zend_do_default_before_statement(const znode *case_list, znode *default_token TSRMLS_DC);
-
-void zend_do_begin_class_declaration(const znode *class_token, znode *class_name, const znode *parent_class_name TSRMLS_DC);
-void zend_do_end_class_declaration(const znode *class_token, const znode *parent_token TSRMLS_DC);
-void zend_do_declare_property(znode *var_name, znode *value, uint32_t access_type TSRMLS_DC);
-void zend_do_declare_class_constant(znode *var_name, znode *value TSRMLS_DC);
-
-void zend_do_fetch_property(znode *result, znode *object, znode *property TSRMLS_DC);
-
-void zend_do_halt_compiler_register(TSRMLS_D);
-
-void zend_do_push_object(const znode *object TSRMLS_DC);
-void zend_do_pop_object(znode *object TSRMLS_DC);
-
-
-void zend_do_begin_new_object(znode *new_token, znode *class_type TSRMLS_DC);
-void zend_do_end_new_object(znode *result, const znode *new_token TSRMLS_DC);
-
-void zend_do_fetch_constant(znode *result, znode *constant_container, znode *constant_name, int mode, zend_bool check_namespace TSRMLS_DC);
-
-void zend_do_shell_exec(znode *result, znode *cmd TSRMLS_DC);
-
-void zend_do_init_array(znode *result, znode *expr, znode *offset, zend_bool is_ref TSRMLS_DC);
-void zend_do_add_array_element(znode *result, znode *expr, znode *offset, zend_bool is_ref TSRMLS_DC);
-void zend_do_end_array(znode *result, const znode *array_node TSRMLS_DC);
-void zend_do_list_init(TSRMLS_D);
-void zend_do_list_end(znode *result, znode *expr TSRMLS_DC);
-void zend_do_add_list_element(const znode *element TSRMLS_DC);
-void zend_do_new_list_begin(TSRMLS_D);
-void zend_do_new_list_end(TSRMLS_D);
-
 /* Functions for a null terminated pointer list, used for traits parsing and compilation */
 void zend_init_list(void *result, void *item TSRMLS_DC);
 void zend_add_to_list(void *result, void *item TSRMLS_DC);
 
-
-void zend_do_cast(znode *result, znode *expr, int type TSRMLS_DC);
-void zend_do_include_or_eval(int type, znode *result, znode *op1 TSRMLS_DC);
-
-void zend_do_unset(znode *variable TSRMLS_DC);
-void zend_do_isset_or_isempty(int type, znode *result, znode *variable TSRMLS_DC);
-
-void zend_do_instanceof(znode *result, znode *expr, znode *class_znode, int type TSRMLS_DC);
-
-void zend_do_foreach_begin(znode *foreach_token, znode *open_brackets_token, znode *array, znode *as_token, int variable TSRMLS_DC);
-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_do_foreach_end(const znode *foreach_token, const znode *as_token TSRMLS_DC);
-
-void zend_do_declare_begin(TSRMLS_D);
-void zend_do_declare_stmt(znode *var, znode *val TSRMLS_DC);
-void zend_do_declare_end(const znode *declare_token TSRMLS_DC);
-
-void zend_do_exit(znode *result, znode *message TSRMLS_DC);
-
-void zend_do_begin_silence(znode *strudel_token TSRMLS_DC);
-void zend_do_end_silence(znode *strudel_token TSRMLS_DC);
-
-void zend_do_jmp_set(znode *value, znode *jmp_token, znode *colon_token TSRMLS_DC);
-void zend_do_jmp_set_else(znode *result, znode *false_value, const znode *jmp_token, znode *colon_token TSRMLS_DC);
-
-void zend_do_begin_qm_op(znode *cond, znode *qm_token TSRMLS_DC);
-void zend_do_qm_true(znode *true_value, znode *qm_token, znode *colon_token TSRMLS_DC);
-void zend_do_qm_false(znode *result, znode *false_value, znode *qm_token, const znode *colon_token TSRMLS_DC);
-
 void zend_do_extended_info(TSRMLS_D);
 void zend_do_extended_fcall_begin(TSRMLS_D);
 void zend_do_extended_fcall_end(TSRMLS_D);
 
-void zend_do_ticks(TSRMLS_D);
-
-void zend_do_abstract_method(const znode *function_name, znode *modifiers, const znode *body TSRMLS_DC);
-
-void zend_do_declare_constant(znode *name, znode *value TSRMLS_DC);
-void zend_do_build_namespace_name(znode *result, znode *prefix, znode *name TSRMLS_DC);
-void zend_do_begin_namespace(znode *name, zend_bool with_brackets TSRMLS_DC);
-void zend_do_end_namespace(TSRMLS_D);
 void zend_verify_namespace(TSRMLS_D);
-void zend_do_use(znode *name, znode *new_name, int is_global TSRMLS_DC);
-void zend_do_use_non_class(znode *ns_name, znode *new_name, int is_global, int is_function, zend_bool case_sensitive, HashTable *current_import_sub, HashTable *lookup_table TSRMLS_DC);
-void zend_do_use_function(znode *name, znode *new_name, int is_global TSRMLS_DC);
-void zend_do_use_const(znode *name, znode *new_name, int is_global TSRMLS_DC);
 void zend_do_end_compilation(TSRMLS_D);
-void zend_do_constant_expression(znode *result, zend_ast *ast TSRMLS_DC);
-
-void zend_do_resolve_class_name(znode *result, znode *class_name, int is_static TSRMLS_DC);
 
-void zend_do_label(znode *label TSRMLS_DC);
-void zend_do_goto(znode *label TSRMLS_DC);
 void zend_resolve_goto_label(zend_op_array *op_array, zend_op *opline, int pass2 TSRMLS_DC);
 void zend_release_labels(int temporary TSRMLS_DC);
 
@@ -686,13 +528,10 @@ int print_class(zend_class_entry *class_entry TSRMLS_DC);
 void print_op_array(zend_op_array *op_array, int optimizations);
 ZEND_API int pass_two(zend_op_array *op_array TSRMLS_DC);
 zend_brk_cont_element *get_next_brk_cont_element(zend_op_array *op_array);
-void zend_do_first_catch(znode *open_parentheses TSRMLS_DC);
-void zend_initialize_try_catch_element(znode *catch_token TSRMLS_DC);
-void zend_do_mark_last_catch(const znode *first_catch, const znode *last_additional_catch TSRMLS_DC);
 ZEND_API zend_bool zend_is_compiling(TSRMLS_D);
 ZEND_API char *zend_make_compiled_string_description(const char *name TSRMLS_DC);
 ZEND_API void zend_initialize_class_data(zend_class_entry *ce, zend_bool nullify_handlers TSRMLS_DC);
-int zend_get_class_fetch_type(const char *class_name, uint class_name_len);
+uint32_t zend_get_class_fetch_type(zend_string *name);
 
 typedef zend_bool (*zend_auto_global_callback)(zend_string *name TSRMLS_DC);
 typedef struct _zend_auto_global {
@@ -707,7 +546,7 @@ ZEND_API void zend_activate_auto_globals(TSRMLS_D);
 ZEND_API zend_bool zend_is_auto_global(zend_string *name TSRMLS_DC);
 ZEND_API size_t zend_dirname(char *path, size_t len);
 
-int zendlex(znode *zendlval TSRMLS_DC);
+int zendlex(zend_parser_stack_elem *elem TSRMLS_DC);
 
 int zend_add_literal(zend_op_array *op_array, zval *zv TSRMLS_DC);
 
@@ -741,6 +580,13 @@ int zend_add_literal(zend_op_array *op_array, zval *zv TSRMLS_DC);
 #define ZEND_PARSED_NEW					(1<<6)
 #define ZEND_PARSED_LIST_EXPR			(1<<7)
 
+#define ZEND_PARAM_REF      (1<<0)
+#define ZEND_PARAM_VARIADIC (1<<1)
+
+#define ZEND_NAME_FQ       0
+#define ZEND_NAME_NOT_FQ   1
+#define ZEND_NAME_RELATIVE 2
+
 /* unset types */
 #define ZEND_UNSET_REG 0
 
@@ -749,9 +595,13 @@ int zend_add_literal(zend_op_array *op_array, zval *zv TSRMLS_DC);
 #define BP_VAR_W			1
 #define BP_VAR_RW			2
 #define BP_VAR_IS			3
-#define BP_VAR_NA			4	/* if not applicable */
-#define BP_VAR_FUNC_ARG		5
-#define BP_VAR_UNSET		6
+#define BP_VAR_FUNC_ARG		4
+#define BP_VAR_UNSET		5
+#define BP_VAR_REF          6   /* right-hand side of by-ref assignment */
+
+/* Bottom 3 bits are the type, top bits are arg num for BP_VAR_FUNC_ARG */
+#define BP_VAR_SHIFT 3
+#define BP_VAR_MASK  7
 
 
 #define ZEND_INTERNAL_FUNCTION				1
diff --git a/Zend/zend_execute_API.c b/Zend/zend_execute_API.c
index af309c5e64..461225da99 100644
--- a/Zend/zend_execute_API.c
+++ b/Zend/zend_execute_API.c
@@ -606,7 +606,7 @@ ZEND_API int zval_update_constant_ex(zval *p, zend_bool inline_change, zend_clas
 
 		zend_ast_evaluate(&tmp, Z_ASTVAL_P(p), scope TSRMLS_CC);
 		if (inline_change) {
-			zend_ast_destroy(Z_ASTVAL_P(p));
+			zend_ast_destroy_and_free(Z_ASTVAL_P(p));
 			efree(Z_AST_P(p));
 		}
 		ZVAL_COPY_VALUE(p, &tmp);
@@ -1468,7 +1468,7 @@ check_fetch_type:
 			}
 			return EG(current_execute_data)->called_scope;
 		case ZEND_FETCH_CLASS_AUTO: {
-				fetch_type = zend_get_class_fetch_type(class_name->val, class_name->len);
+				fetch_type = zend_get_class_fetch_type(class_name);
 				if (fetch_type!=ZEND_FETCH_CLASS_DEFAULT) {
 					goto check_fetch_type;
 				}
diff --git a/Zend/zend_globals.h b/Zend/zend_globals.h
index 758e373ac2..c4a24486d9 100644
--- a/Zend/zend_globals.h
+++ b/Zend/zend_globals.h
@@ -71,21 +71,11 @@ typedef struct _zend_ini_entry zend_ini_entry;
 
 
 struct _zend_compiler_globals {
-	zend_stack bp_stack;
 	zend_stack switch_cond_stack;
 	zend_stack foreach_copy_stack;
-	zend_stack object_stack;
-	zend_stack declare_stack;
 
 	zend_class_entry *active_class_entry;
 
-	/* variables for list() compilation */
-	zend_llist list_llist;
-	zend_llist dimension_llist;
-	zend_stack list_stack;
-
-	zend_stack function_call_stack;
-
 	zend_string *compiled_filename;
 
 	int zend_lineno;
@@ -112,8 +102,6 @@ struct _zend_compiler_globals {
 
 	zend_llist open_files;
 
-	zend_long catch_begin;
-
 	struct _zend_ini_parser_param *ini_parser_param;
 
 	int interactive;
@@ -123,13 +111,11 @@ struct _zend_compiler_globals {
 
 	znode implementing_class;
 
-	uint32_t access_type;
-
 	zend_string *doc_comment;
 
 	uint32_t compiler_options; /* set of ZEND_COMPILE_* constants */
 
-	zval       current_namespace;
+	zend_string *current_namespace;
 	HashTable *current_import;
 	HashTable *current_import_function;
 	HashTable *current_import_const;
@@ -154,6 +140,11 @@ struct _zend_compiler_globals {
 	zend_bool detect_unicode;
 	zend_bool encoding_declared;
 
+	zend_ast *ast;
+	zend_arena *ast_arena;
+
+	zend_stack delayed_oplines_stack;
+
 #ifdef ZTS
 	zval **static_members_table;
 	int last_static_member;
diff --git a/Zend/zend_language_parser.y b/Zend/zend_language_parser.y
index a6e3182d96..8622fbb441 100644
--- a/Zend/zend_language_parser.y
+++ b/Zend/zend_language_parser.y
@@ -15,6 +15,7 @@
    +----------------------------------------------------------------------+
    | Authors: Andi Gutmans <andi@zend.com>                                |
    |          Zeev Suraski <zeev@zend.com>                                |
+   |          Nikita Popov <nikic@php.net>                                |
    +----------------------------------------------------------------------+
 */
 
@@ -40,12 +41,12 @@
 static YYSIZE_T zend_yytnamerr(char*, const char*);
 
 #define YYERROR_VERBOSE
-#define YYSTYPE znode
+#define YYSTYPE zend_parser_stack_elem
 
 %}
 
 %pure_parser
-%expect 3
+%expect 2
 
 %code requires {
 #ifdef ZTS
@@ -188,6 +189,7 @@ static YYSIZE_T zend_yytnamerr(char*, const char*);
 %token T_EXTENDS    "extends (T_EXTENDS)"
 %token T_IMPLEMENTS "implements (T_IMPLEMENTS)"
 %token T_OBJECT_OPERATOR "-> (T_OBJECT_OPERATOR)"
+%right T_DOUBLE_ARROW
 %token T_DOUBLE_ARROW    "=> (T_DOUBLE_ARROW)"
 %token T_LIST            "list (T_LIST)"
 %token T_ARRAY           "array (T_ARRAY)"
@@ -220,299 +222,263 @@ static YYSIZE_T zend_yytnamerr(char*, const char*);
 %% /* Rules */
 
 start:
-	top_statement_list	{ zend_do_end_compilation(TSRMLS_C); }
+	top_statement_list	{ CG(ast) = $1.ast; }
 ;
 
 top_statement_list:
-		top_statement_list  { zend_do_extended_info(TSRMLS_C); } top_statement { HANDLE_INTERACTIVE(); }
-	|	/* empty */
+		top_statement_list top_statement { $$.list = zend_ast_list_add($1.list, $2.ast); }
+	|	/* empty */ { $$.list = zend_ast_create_list(0, ZEND_AST_STMT_LIST); }
 ;
 
 namespace_name:
-		T_STRING { $$ = $1; }
-	|	namespace_name T_NS_SEPARATOR T_STRING { zend_do_build_namespace_name(&$$, &$1, &$3 TSRMLS_CC); }
+		T_STRING { $$.ast = $1.ast; }
+	|	namespace_name T_NS_SEPARATOR T_STRING
+			{ $$.ast = zend_ast_append_str($1.ast, $3.ast); }
+;
+
+name:
+		namespace_name
+			{ $$.ast = $1.ast; $$.ast->attr = ZEND_NAME_NOT_FQ; }
+	|	T_NAMESPACE T_NS_SEPARATOR namespace_name
+			{ $$.ast = $3.ast; $$.ast->attr = ZEND_NAME_RELATIVE; }
+	|	T_NS_SEPARATOR namespace_name
+			{ $$.ast = $2.ast; $$.ast->attr = ZEND_NAME_FQ; }
 ;
 
 top_statement:
-		statement						{ zend_verify_namespace(TSRMLS_C); }
-	|	function_declaration_statement	{ zend_verify_namespace(TSRMLS_C); zend_do_early_binding(TSRMLS_C); }
-	|	class_declaration_statement		{ zend_verify_namespace(TSRMLS_C); zend_do_early_binding(TSRMLS_C); }
-	|	T_HALT_COMPILER '(' ')' ';'		{ zend_do_halt_compiler_register(TSRMLS_C); YYACCEPT; }
-	|	T_NAMESPACE namespace_name ';'	{ zend_do_begin_namespace(&$2, 0 TSRMLS_CC); }
-	|	T_NAMESPACE namespace_name '{'	{ zend_do_begin_namespace(&$2, 1 TSRMLS_CC); }
-		top_statement_list '}'		    { zend_do_end_namespace(TSRMLS_C); }
-	|	T_NAMESPACE '{'					{ zend_do_begin_namespace(NULL, 1 TSRMLS_CC); }
-		top_statement_list '}'			{ zend_do_end_namespace(TSRMLS_C); }
-	|	T_USE use_declarations ';'      { zend_verify_namespace(TSRMLS_C); }
-	|	T_USE T_FUNCTION use_function_declarations ';' { zend_verify_namespace(TSRMLS_C); }
-	|	T_USE T_CONST use_const_declarations ';'       { zend_verify_namespace(TSRMLS_C); }
-	|	constant_declaration ';'		{ zend_verify_namespace(TSRMLS_C); }
+		statement						{ $$.ast = $1.ast; }
+	|	function_declaration_statement	{ $$.ast = $1.ast; }
+	|	class_declaration_statement		{ $$.ast = $1.ast; }
+	|	T_HALT_COMPILER '(' ')' ';'
+			{ $$.ast = zend_ast_create(ZEND_AST_HALT_COMPILER,
+			      zend_ast_create_zval_from_long(zend_get_scanned_file_offset(TSRMLS_C)));
+			  zend_stop_lexing(TSRMLS_C); }
+	|	T_NAMESPACE namespace_name ';'
+			{ $$.ast = zend_ast_create(ZEND_AST_NAMESPACE, $2.ast, NULL);
+			  RESET_DOC_COMMENT(); }
+	|	T_NAMESPACE namespace_name { RESET_DOC_COMMENT(); }
+		'{' top_statement_list '}'
+			{ $$.ast = zend_ast_create(ZEND_AST_NAMESPACE, $2.ast, $5.ast); }
+	|	T_NAMESPACE { RESET_DOC_COMMENT(); }
+		'{' top_statement_list '}'
+			{ $$.ast = zend_ast_create(ZEND_AST_NAMESPACE, NULL, $4.ast); }
+	|	T_USE use_declarations ';'
+			{ $$.ast = $2.ast; $$.ast->attr = T_CLASS; }
+	|	T_USE T_FUNCTION use_declarations ';'
+			{ $$.ast = $3.ast; $$.ast->attr = T_FUNCTION; }
+	|	T_USE T_CONST use_declarations ';'
+			{ $$.ast = $3.ast; $$.ast->attr = T_CONST; }
+	|	T_CONST const_list ';'			{ $$.ast = $2.ast; }
 ;
 
 use_declarations:
 		use_declarations ',' use_declaration
+			{ $$.list = zend_ast_list_add($1.list, $3.ast); }
 	|	use_declaration
+			{ $$.list = zend_ast_create_list(1, ZEND_AST_USE, $1.ast); }
 ;
 
 use_declaration:
-		namespace_name 			{ zend_do_use(&$1, NULL, 0 TSRMLS_CC); }
-	|	namespace_name T_AS T_STRING	{ zend_do_use(&$1, &$3, 0 TSRMLS_CC); }
-	|	T_NS_SEPARATOR namespace_name { zend_do_use(&$2, NULL, 1 TSRMLS_CC); }
-	|	T_NS_SEPARATOR namespace_name T_AS T_STRING { zend_do_use(&$2, &$4, 1 TSRMLS_CC); }
-;
-
-use_function_declarations:
-		use_function_declarations ',' use_function_declaration
-	|	use_function_declaration
+		namespace_name
+			{ $$.ast = zend_ast_create(ZEND_AST_USE_ELEM, $1.ast, NULL); }
+	|	namespace_name T_AS T_STRING
+			{ $$.ast = zend_ast_create(ZEND_AST_USE_ELEM, $1.ast, $3.ast); }
+	|	T_NS_SEPARATOR namespace_name
+			{ $$.ast = zend_ast_create(ZEND_AST_USE_ELEM, $2.ast, NULL); }
+	|	T_NS_SEPARATOR namespace_name T_AS T_STRING
+			{ $$.ast = zend_ast_create(ZEND_AST_USE_ELEM, $2.ast, $4.ast); }
 ;
 
-use_function_declaration:
-		namespace_name 			{ zend_do_use_function(&$1, NULL, 0 TSRMLS_CC); }
-	|	namespace_name T_AS T_STRING	{ zend_do_use_function(&$1, &$3, 0 TSRMLS_CC); }
-	|	T_NS_SEPARATOR namespace_name { zend_do_use_function(&$2, NULL, 1 TSRMLS_CC); }
-	|	T_NS_SEPARATOR namespace_name T_AS T_STRING { zend_do_use_function(&$2, &$4, 1 TSRMLS_CC); }
-;
-
-use_const_declarations:
-		use_const_declarations ',' use_const_declaration
-	|	use_const_declaration
-;
-
-use_const_declaration:
-		namespace_name 			{ zend_do_use_const(&$1, NULL, 0 TSRMLS_CC); }
-	|	namespace_name T_AS T_STRING	{ zend_do_use_const(&$1, &$3, 0 TSRMLS_CC); }
-	|	T_NS_SEPARATOR namespace_name { zend_do_use_const(&$2, NULL, 1 TSRMLS_CC); }
-	|	T_NS_SEPARATOR namespace_name T_AS T_STRING { zend_do_use_const(&$2, &$4, 1 TSRMLS_CC); }
-;
-
-constant_declaration:
-		constant_declaration ',' T_STRING '=' static_scalar	{ zend_do_declare_constant(&$3, &$5 TSRMLS_CC); }
-	|	T_CONST T_STRING '=' static_scalar { zend_do_declare_constant(&$2, &$4 TSRMLS_CC); }
+const_list:
+		const_list ',' const_decl { $$.list = zend_ast_list_add($1.list, $3.ast); }
+	|	const_decl { $$.list = zend_ast_create_list(1, ZEND_AST_CONST_DECL, $1.ast); }
 ;
 
 inner_statement_list:
-		inner_statement_list  { zend_do_extended_info(TSRMLS_C); } inner_statement { HANDLE_INTERACTIVE(); }
+		inner_statement_list inner_statement
+			{ $$.list = zend_ast_list_add($1.list, $2.ast); }
 	|	/* empty */
+			{ $$.list = zend_ast_create_list(0, ZEND_AST_STMT_LIST); }
 ;
 
 
 inner_statement:
-		statement
-	|	function_declaration_statement
-	|	class_declaration_statement
-	|	T_HALT_COMPILER '(' ')' ';'   { zend_error_noreturn(E_COMPILE_ERROR, "__HALT_COMPILER() can only be used from the outermost scope"); }
+		statement { $$.ast = $1.ast; }
+	|	function_declaration_statement { $$.ast = $1.ast; }
+	|	class_declaration_statement { $$.ast = $1.ast; }
+	|	T_HALT_COMPILER '(' ')' ';'
+			{ zend_error_noreturn(E_COMPILE_ERROR, "__HALT_COMPILER() can only be used from the outermost scope"); }
 ;
 
 
 statement:
-		unticked_statement { DO_TICKS(); }
-	|	T_STRING ':' { zend_do_label(&$1 TSRMLS_CC); }
+		unticked_statement { $$.ast = $1.ast; }
+	|	T_STRING ':' { $$.ast = zend_ast_create(ZEND_AST_LABEL, $1.ast); }
 ;
 
 unticked_statement:
-		'{' inner_statement_list '}'
-	|	T_IF parenthesis_expr { zend_do_if_cond(&$2, &$1 TSRMLS_CC); } statement { zend_do_if_after_statement(&$1, 1 TSRMLS_CC); } elseif_list else_single { zend_do_if_end(TSRMLS_C); }
-	|	T_IF parenthesis_expr ':' { zend_do_if_cond(&$2, &$1 TSRMLS_CC); } inner_statement_list { zend_do_if_after_statement(&$1, 1 TSRMLS_CC); } new_elseif_list new_else_single T_ENDIF ';' { zend_do_if_end(TSRMLS_C); }
-	|	T_WHILE { $1.u.op.opline_num = get_next_op_number(CG(active_op_array)); } parenthesis_expr { zend_do_while_cond(&$3, &$$ TSRMLS_CC); } while_statement { zend_do_while_end(&$1, &$4 TSRMLS_CC); }
-	|	T_DO { $1.u.op.opline_num = get_next_op_number(CG(active_op_array));  zend_do_do_while_begin(TSRMLS_C); } statement T_WHILE { $4.u.op.opline_num = get_next_op_number(CG(active_op_array)); } parenthesis_expr ';' { zend_do_do_while_end(&$1, &$4, &$6 TSRMLS_CC); }
-	|	T_FOR
-			'('
-				for_expr
-			';' { zend_do_free(&$3 TSRMLS_CC); $4.u.op.opline_num = get_next_op_number(CG(active_op_array)); }
-				for_expr
-			';' { zend_do_extended_info(TSRMLS_C); zend_do_for_cond(&$6, &$7 TSRMLS_CC); }
-				for_expr
-			')' { zend_do_free(&$9 TSRMLS_CC); zend_do_for_before_statement(&$4, &$7 TSRMLS_CC); }
-			for_statement { zend_do_for_end(&$7 TSRMLS_CC); }
-	|	T_SWITCH parenthesis_expr	{ zend_do_switch_cond(&$2 TSRMLS_CC); } switch_case_list { zend_do_switch_end(&$4 TSRMLS_CC); }
-	|	T_BREAK ';'				{ zend_do_brk_cont(ZEND_BRK, NULL TSRMLS_CC); }
-	|	T_BREAK expr ';'		{ zend_do_brk_cont(ZEND_BRK, &$2 TSRMLS_CC); }
-	|	T_CONTINUE ';'			{ zend_do_brk_cont(ZEND_CONT, NULL TSRMLS_CC); }
-	|	T_CONTINUE expr ';'		{ zend_do_brk_cont(ZEND_CONT, &$2 TSRMLS_CC); }
-	|	T_RETURN ';'						{ zend_do_return(NULL, 0 TSRMLS_CC); }
-	|	T_RETURN expr_without_variable ';'	{ zend_do_return(&$2, 0 TSRMLS_CC); }
-	|	T_RETURN variable ';'				{ zend_do_return(&$2, 1 TSRMLS_CC); }
-	|	yield_expr ';' { zend_do_free(&$1 TSRMLS_CC); }
-	|	T_GLOBAL global_var_list ';'
-	|	T_STATIC static_var_list ';'
-	|	T_ECHO echo_expr_list ';'
-	|	T_INLINE_HTML			{ zend_do_echo(&$1 TSRMLS_CC); }
-	|	expr ';'				{ zend_do_free(&$1 TSRMLS_CC); }
-	|	T_UNSET '(' unset_variables ')' ';'
-	|	T_FOREACH '(' variable T_AS
-		{ zend_do_foreach_begin(&$1, &$2, &$3, &$4, 1 TSRMLS_CC); }
-		foreach_variable foreach_optional_arg ')' { zend_do_foreach_cont(&$1, &$2, &$4, &$6, &$7 TSRMLS_CC); }
-		foreach_statement { zend_do_foreach_end(&$1, &$4 TSRMLS_CC); }
-	|	T_FOREACH '(' expr_without_variable T_AS
-		{ zend_do_foreach_begin(&$1, &$2, &$3, &$4, 0 TSRMLS_CC); }
-		foreach_variable foreach_optional_arg ')' { zend_do_foreach_cont(&$1, &$2, &$4, &$6, &$7 TSRMLS_CC); }
-		foreach_statement { zend_do_foreach_end(&$1, &$4 TSRMLS_CC); }
-	|	T_DECLARE { $1.u.op.opline_num = get_next_op_number(CG(active_op_array)); zend_do_declare_begin(TSRMLS_C); } '(' declare_list ')' declare_statement { zend_do_declare_end(&$1 TSRMLS_CC); }
-	|	';'		/* empty statement */
-	|	T_TRY { zend_do_try(&$1 TSRMLS_CC); } '{' inner_statement_list '}'
-		catch_statement { zend_do_bind_catch(&$1, &$6 TSRMLS_CC); }
-		finally_statement { zend_do_end_finally(&$1, &$6, &$8 TSRMLS_CC); }
-	|	T_THROW expr ';' { zend_do_throw(&$2 TSRMLS_CC); }
-	|	T_GOTO T_STRING ';' { zend_do_goto(&$2 TSRMLS_CC); }
-;
-
-catch_statement:
-				/* empty */ { $$.op_type = IS_UNUSED; }
-	|	T_CATCH '(' { zend_initialize_try_catch_element(&$1 TSRMLS_CC); } 
-		fully_qualified_class_name { zend_do_first_catch(&$2 TSRMLS_CC); }
-		T_VARIABLE ')' { zend_do_begin_catch(&$1, &$4, &$6, &$2 TSRMLS_CC); }
-		'{' inner_statement_list '}' { zend_do_end_catch(&$1 TSRMLS_CC); }
-		additional_catches { zend_do_mark_last_catch(&$2, &$13 TSRMLS_CC); $$ = $1;}
-
-finally_statement:
-					/* empty */ { $$.op_type = IS_UNUSED; }
-	|	T_FINALLY { zend_do_finally(&$1 TSRMLS_CC); } '{' inner_statement_list '}' { $$ = $1; }
-;
-
-additional_catches:
-		non_empty_additional_catches { $$ = $1; }
-	|	/* empty */ { $$.u.op.opline_num = -1; }
-;
-
-non_empty_additional_catches:
-		additional_catch { $$ = $1; }
-	|	non_empty_additional_catches additional_catch { $$ = $2; }
+		'{' inner_statement_list '}' { $$.ast = $2.ast; }
+	|	if_stmt { $$.ast = $1.ast; }
+	|	alt_if_stmt { $$.ast = $1.ast; }
+	|	T_WHILE parenthesis_expr while_statement
+			{ $$.ast = zend_ast_create(ZEND_AST_WHILE, $2.ast, $3.ast); }
+	|	T_DO statement T_WHILE parenthesis_expr ';'
+			{ $$.ast = zend_ast_create(ZEND_AST_DO_WHILE, $2.ast, $4.ast); }
+	|	T_FOR '(' for_expr ';' for_expr ';' for_expr ')' for_statement
+			{ $$.ast = zend_ast_create(ZEND_AST_FOR, $3.ast, $5.ast, $7.ast, $9.ast); }
+	|	T_SWITCH parenthesis_expr switch_case_list
+			{ $$.ast = zend_ast_create(ZEND_AST_SWITCH, $2.ast, $3.ast); }
+	|	T_BREAK ';'			{ $$.ast = zend_ast_create(ZEND_AST_BREAK, NULL); }
+	|	T_BREAK expr ';'	{ $$.ast = zend_ast_create(ZEND_AST_BREAK, $2.ast); }
+	|	T_CONTINUE ';'		{ $$.ast = zend_ast_create(ZEND_AST_CONTINUE, NULL); }
+	|	T_CONTINUE expr ';'	{ $$.ast = zend_ast_create(ZEND_AST_CONTINUE, $2.ast); }
+	|	T_RETURN ';'
+			{ $$.ast = zend_ast_create(ZEND_AST_RETURN, NULL); }
+	|	T_RETURN expr ';'
+			{ $$.ast = zend_ast_create(ZEND_AST_RETURN, $2.ast); }
+	|	T_GLOBAL global_var_list ';' { $$.ast = $2.ast; }
+	|	T_STATIC static_var_list ';' { $$.ast = $2.ast; }
+	|	T_ECHO echo_expr_list ';' { $$.ast = $2.ast; }
+	|	T_INLINE_HTML { $$.ast = zend_ast_create(ZEND_AST_ECHO, $1.ast); }
+	|	expr ';' { $$.ast = $1.ast; }
+	|	T_UNSET '(' unset_variables ')' ';' { $$.ast = $3.ast; }
+	|	T_FOREACH '(' expr T_AS foreach_variable ')' foreach_statement
+			{ $$.ast = zend_ast_create(ZEND_AST_FOREACH,
+			      $3.ast, $5.ast, NULL, $7.ast); }
+	|	T_FOREACH '(' expr T_AS foreach_variable T_DOUBLE_ARROW foreach_variable ')'
+		foreach_statement
+			{ $$.ast = zend_ast_create(ZEND_AST_FOREACH,
+			      $3.ast, $7.ast, $5.ast, $9.ast); }
+	|	T_DECLARE '(' const_list ')'
+			{ zend_handle_encoding_declaration($3.list TSRMLS_CC); }
+				declare_statement
+			{ $$.ast = zend_ast_create(ZEND_AST_DECLARE, $3.ast, $6.ast); }
+	|	';'	/* empty statement */ { $$.ast = NULL; }
+	|	T_TRY '{' inner_statement_list '}' catch_list finally_statement
+			{ $$.ast = zend_ast_create(ZEND_AST_TRY, $3.ast, $5.ast, $6.ast); }
+	|	T_THROW expr ';' { $$.ast = zend_ast_create(ZEND_AST_THROW, $2.ast); }
+	|	T_GOTO T_STRING ';' { $$.ast = zend_ast_create(ZEND_AST_GOTO, $2.ast); }
+;
+
+catch_list:
+		/* empty */
+			{ $$.list = zend_ast_create_list(0, ZEND_AST_CATCH_LIST); }
+	|	catch_list T_CATCH '(' name T_VARIABLE ')' '{' inner_statement_list '}'
+			{ $$.list = zend_ast_list_add($1.list,
+			      zend_ast_create(ZEND_AST_CATCH, $4.ast, $5.ast, $8.ast)); }
 ;
 
-additional_catch:
-	T_CATCH '(' fully_qualified_class_name { $$.u.op.opline_num = get_next_op_number(CG(active_op_array)); } T_VARIABLE ')' { zend_do_begin_catch(&$1, &$3, &$5, NULL TSRMLS_CC); } '{' inner_statement_list '}' { zend_do_end_catch(&$1 TSRMLS_CC); }
+finally_statement:
+		/* empty */ { $$.ast = NULL; }
+	|	T_FINALLY '{' inner_statement_list '}' { $$.ast = $3.ast; }
 ;
 
 unset_variables:
-		unset_variable
-	|	unset_variables ',' unset_variable
+		unset_variable { $$.list = zend_ast_create_list(1, ZEND_AST_STMT_LIST, $1.ast); }
+	|	unset_variables ',' unset_variable { $$.list = zend_ast_list_add($1.list, $3.ast); }
 ;
 
 unset_variable:
-		variable	{ zend_do_end_variable_parse(&$1, BP_VAR_UNSET, 0 TSRMLS_CC); zend_do_unset(&$1 TSRMLS_CC); }
+		variable { $$.ast = zend_ast_create(ZEND_AST_UNSET, $1.ast); }
 ;
 
 function_declaration_statement:
-		unticked_function_declaration_statement	{ DO_TICKS(); }
-;
-
-class_declaration_statement:
-		unticked_class_declaration_statement	{ DO_TICKS(); }
+	function returns_ref T_STRING '(' parameter_list ')'
+		{ $$.str = CG(doc_comment); CG(doc_comment) = NULL; }
+	'{' inner_statement_list '}'
+		{ $$.ast = zend_ast_create_decl(ZEND_AST_FUNC_DECL, $2.num, $1.num, $7.str,
+		      zend_ast_get_str($3.ast), $5.ast, NULL, $9.ast); }
 ;
 
 is_reference:
-		/* empty */	{ $$.op_type = 0; }
-	|	'&'			{ $$.op_type = 1; }
+		/* empty */	{ $$.num = 0; }
+	|	'&'			{ $$.num = ZEND_PARAM_REF; }
 ;
 
 is_variadic:
-		/* empty */ { $$.op_type = 0; }
-	|	T_ELLIPSIS  { $$.op_type = 1; }
-;
-
-unticked_function_declaration_statement:
-		function is_reference T_STRING { zend_do_begin_function_declaration(&$1, &$3, 0, $2.op_type, NULL TSRMLS_CC); }
-		'(' parameter_list ')'
-		'{' inner_statement_list '}' { zend_do_end_function_declaration(&$1 TSRMLS_CC); }
-;
-
-unticked_class_declaration_statement:
-		class_entry_type T_STRING extends_from
-			{ zend_do_begin_class_declaration(&$1, &$2, &$3 TSRMLS_CC); }
-			implements_list
-			'{'
-				class_statement_list
-			'}' { zend_do_end_class_declaration(&$1, &$3 TSRMLS_CC); }
-	|	interface_entry T_STRING
-			{ zend_do_begin_class_declaration(&$1, &$2, NULL TSRMLS_CC); }
-			interface_extends_list
-			'{'
-				class_statement_list
-			'}' { zend_do_end_class_declaration(&$1, NULL TSRMLS_CC); }
+		/* empty */ { $$.num = 0; }
+	|	T_ELLIPSIS  { $$.num = ZEND_PARAM_VARIADIC; }
 ;
 
-
-class_entry_type:
-		T_CLASS			{ $$.u.op.opline_num = CG(zend_lineno); $$.EA = 0; }
-	|	T_ABSTRACT T_CLASS { $$.u.op.opline_num = CG(zend_lineno); $$.EA = ZEND_ACC_EXPLICIT_ABSTRACT_CLASS; }
-	|	T_TRAIT { $$.u.op.opline_num = CG(zend_lineno); $$.EA = ZEND_ACC_TRAIT; }
-	|	T_FINAL T_CLASS { $$.u.op.opline_num = CG(zend_lineno); $$.EA = ZEND_ACC_FINAL_CLASS; }
+class_declaration_statement:
+		class_type
+			{ $$.num = CG(zend_lineno); }
+		T_STRING extends_from implements_list
+			{ $$.str = CG(doc_comment); CG(doc_comment) = NULL; }	
+		'{' class_statement_list '}'
+			{ $$.ast = zend_ast_create_decl(ZEND_AST_CLASS, $1.num, $2.num, $6.str,
+				  zend_ast_get_str($3.ast), $4.ast, $5.ast, $8.ast); }
+	|	T_INTERFACE
+			{ $$.num = CG(zend_lineno); }
+		T_STRING interface_extends_list
+			{ $$.str = CG(doc_comment); CG(doc_comment) = NULL; }	
+		'{' class_statement_list '}'
+			{ $$.ast = zend_ast_create_decl(ZEND_AST_CLASS, ZEND_ACC_INTERFACE, $2.num, $5.str,
+				  zend_ast_get_str($3.ast), NULL, $4.ast, $7.ast); }
+;
+
+class_type:
+		T_CLASS				{ $$.num = 0; }
+	|	T_ABSTRACT T_CLASS	{ $$.num = ZEND_ACC_EXPLICIT_ABSTRACT_CLASS; }
+	|	T_FINAL T_CLASS		{ $$.num = ZEND_ACC_FINAL_CLASS; }
+	|	T_TRAIT				{ $$.num = ZEND_ACC_TRAIT; }
 ;
 
 extends_from:
-		/* empty */					{ $$.op_type = IS_UNUSED; }
-	|	T_EXTENDS fully_qualified_class_name	{ zend_do_fetch_class(&$$, &$2 TSRMLS_CC); }
-;
-
-interface_entry:
-	T_INTERFACE		{ $$.u.op.opline_num = CG(zend_lineno); $$.EA = ZEND_ACC_INTERFACE; }
+		/* empty */		{ $$.ast = NULL; }
+	|	T_EXTENDS name	{ $$.ast = $2.ast; }
 ;
 
 interface_extends_list:
-		/* empty */
-	|	T_EXTENDS interface_list
+		/* empty */				{ $$.ast = NULL; }
+	|	T_EXTENDS name_list	{ $$.ast = $2.ast; }
 ;
 
 implements_list:
-		/* empty */
-	|	T_IMPLEMENTS interface_list
-;
-
-interface_list:
-		fully_qualified_class_name			{ zend_do_implements_interface(&$1 TSRMLS_CC); }
-	|	interface_list ',' fully_qualified_class_name { zend_do_implements_interface(&$3 TSRMLS_CC); }
-;
-
-foreach_optional_arg:
-		/* empty */						{ $$.op_type = IS_UNUSED; }
-	|	T_DOUBLE_ARROW foreach_variable	{ $$ = $2; }
+		/* empty */				{ $$.ast = NULL; }
+	|	T_IMPLEMENTS name_list	{ $$.ast = $2.ast; }
 ;
 
 foreach_variable:
-		variable			{ zend_check_writable_variable(&$1); $$ = $1; }
-	|	'&' variable		{ zend_check_writable_variable(&$2); $$ = $2;  $$.EA |= ZEND_PARSED_REFERENCE_VARIABLE; }
-	|	T_LIST '(' { zend_do_list_init(TSRMLS_C); } assignment_list ')' { $$ = $1; $$.EA = ZEND_PARSED_LIST_EXPR; }
+		variable			{ $$.ast = $1.ast; }
+	|	'&' variable		{ $$.ast = zend_ast_create(ZEND_AST_REF, $2.ast); }
+	|	T_LIST '(' assignment_list ')' { $$.ast = $3.ast; }
 ;
 
 for_statement:
-		statement
-	|	':' inner_statement_list T_ENDFOR ';'
+		statement { $$.ast = $1.ast; }
+	|	':' inner_statement_list T_ENDFOR ';' { $$.ast = $2.ast; }
 ;
 
 
 foreach_statement:
-		statement
-	|	':' inner_statement_list T_ENDFOREACH ';'
+		statement { $$.ast = $1.ast; }
+	|	':' inner_statement_list T_ENDFOREACH ';' { $$.ast = $2.ast; }
 ;
 
 
 declare_statement:
-		statement
-	|	':' inner_statement_list T_ENDDECLARE ';'
+		statement { $$.ast = $1.ast; }
+	|	':' inner_statement_list T_ENDDECLARE ';' { $$.ast = $2.ast; }
 ;
 
-
-declare_list:
-		T_STRING '=' static_scalar					{ zend_do_declare_stmt(&$1, &$3 TSRMLS_CC); }
-	|	declare_list ',' T_STRING '=' static_scalar	{ zend_do_declare_stmt(&$3, &$5 TSRMLS_CC); }
-;
-
-
 switch_case_list:
-		'{' case_list '}'					{ $$ = $2; }
-	|	'{' ';' case_list '}'				{ $$ = $3; }
-	|	':' case_list T_ENDSWITCH ';'		{ $$ = $2; }
-	|	':' ';' case_list T_ENDSWITCH ';'	{ $$ = $3; }
+		'{' case_list '}'					{ $$.ast = $2.ast; }
+	|	'{' ';' case_list '}'				{ $$.ast = $3.ast; }
+	|	':' case_list T_ENDSWITCH ';'		{ $$.ast = $2.ast; }
+	|	':' ';' case_list T_ENDSWITCH ';'	{ $$.ast = $3.ast; }
 ;
 
-
 case_list:
-		/* empty */	{ $$.op_type = IS_UNUSED; }
-	|	case_list T_CASE expr case_separator { zend_do_extended_info(TSRMLS_C);  zend_do_case_before_statement(&$1, &$2, &$3 TSRMLS_CC); } inner_statement_list { zend_do_case_after_statement(&$$, &$2 TSRMLS_CC); $$.op_type = IS_CONST; }
-	|	case_list T_DEFAULT case_separator { zend_do_extended_info(TSRMLS_C);  zend_do_default_before_statement(&$1, &$2 TSRMLS_CC); } inner_statement_list { zend_do_case_after_statement(&$$, &$2 TSRMLS_CC); $$.op_type = IS_CONST; }
+		/* empty */ { $$.list = zend_ast_create_list(0, ZEND_AST_SWITCH_LIST); }
+	|	case_list T_CASE expr case_separator inner_statement_list
+			{ $$.list = zend_ast_list_add($1.list,
+			      zend_ast_create(ZEND_AST_SWITCH_CASE, $3.ast, $5.ast)); }
+	|	case_list T_DEFAULT case_separator inner_statement_list
+			{ $$.list = zend_ast_list_add($1.list,
+			      zend_ast_create(ZEND_AST_SWITCH_CASE, NULL, $4.ast)); }
 ;
 
-
 case_separator:
 		':'
 	|	';'
@@ -520,547 +486,496 @@ case_separator:
 
 
 while_statement:
-		statement
-	|	':' inner_statement_list T_ENDWHILE ';'
+		statement { $$.ast = $1.ast; }
+	|	':' inner_statement_list T_ENDWHILE ';' { $$.ast = $2.ast; }
 ;
 
 
-
-elseif_list:
-		/* empty */
-	|	elseif_list T_ELSEIF parenthesis_expr { zend_do_if_cond(&$3, &$2 TSRMLS_CC); } statement { zend_do_if_after_statement(&$2, 0 TSRMLS_CC); }
+if_stmt_without_else:
+		T_IF parenthesis_expr statement
+			{ $$.list = zend_ast_create_list(1, ZEND_AST_IF,
+			      zend_ast_create(ZEND_AST_IF_ELEM, $2.ast, $3.ast)); }
+	|	if_stmt_without_else T_ELSEIF parenthesis_expr statement
+			{ $$.list = zend_ast_list_add($1.list,
+			      zend_ast_create(ZEND_AST_IF_ELEM, $3.ast, $4.ast)); }
 ;
 
-
-new_elseif_list:
-		/* empty */
-	|	new_elseif_list T_ELSEIF parenthesis_expr ':' { zend_do_if_cond(&$3, &$2 TSRMLS_CC); } inner_statement_list { zend_do_if_after_statement(&$2, 0 TSRMLS_CC); }
+if_stmt:
+		if_stmt_without_else { $$.ast = $1.ast; }
+	|	if_stmt_without_else T_ELSE statement
+			{ $$.list = zend_ast_list_add($1.list,
+			      zend_ast_create(ZEND_AST_IF_ELEM, NULL, $3.ast)); }
 ;
 
-
-else_single:
-		/* empty */
-	|	T_ELSE statement
+alt_if_stmt_without_else:
+		T_IF parenthesis_expr ':' inner_statement_list
+			{ $$.list = zend_ast_create_list(1, ZEND_AST_IF,
+			      zend_ast_create(ZEND_AST_IF_ELEM, $2.ast, $4.ast)); }
+	|	alt_if_stmt_without_else T_ELSEIF parenthesis_expr ':' inner_statement_list
+			{ $$.list = zend_ast_list_add($1.list,
+			      zend_ast_create(ZEND_AST_IF_ELEM, $3.ast, $5.ast)); }
 ;
 
-
-new_else_single:
-		/* empty */
-	|	T_ELSE ':' inner_statement_list
+alt_if_stmt:
+		alt_if_stmt_without_else T_ENDIF ';' { $$.ast = $1.ast; }
+	|	alt_if_stmt_without_else T_ELSE ':' inner_statement_list T_ENDIF ';'
+			{ $$.list = zend_ast_list_add($1.list,
+			      zend_ast_create(ZEND_AST_IF_ELEM, NULL, $4.ast)); }
 ;
 
-
 parameter_list:
-		non_empty_parameter_list
-	|	/* empty */
+		non_empty_parameter_list { $$.ast = $1.ast; }
+	|	/* empty */	{ $$.list = zend_ast_create_list(0, ZEND_AST_PARAM_LIST); }
 ;
 
 
 non_empty_parameter_list:
 		parameter
+			{ $$.list = zend_ast_create_list(1, ZEND_AST_PARAM_LIST, $1.ast); }
 	|	non_empty_parameter_list ',' parameter
+			{ $$.list = zend_ast_list_add($1.list, $3.ast); }
 ;
 
 parameter:
-		optional_class_type is_reference is_variadic T_VARIABLE
-			{ zend_do_receive_param(ZEND_RECV, &$4, NULL, &$1, $2.op_type, $3.op_type TSRMLS_CC); }
-	|	optional_class_type is_reference is_variadic T_VARIABLE '=' static_scalar
-			{ zend_do_receive_param(ZEND_RECV_INIT, &$4, &$6, &$1, $2.op_type, $3.op_type TSRMLS_CC); }
+		optional_type is_reference is_variadic T_VARIABLE
+			{ $$.ast = zend_ast_create_ex(ZEND_AST_PARAM, $2.num | $3.num,
+			      $1.ast, $4.ast, NULL); }
+	|	optional_type is_reference is_variadic T_VARIABLE '=' expr
+			{ $$.ast = zend_ast_create_ex(ZEND_AST_PARAM, $2.num | $3.num,
+			      $1.ast, $4.ast, $6.ast); }
 ;
 
 
-optional_class_type:
-		/* empty */					{ $$.op_type = IS_UNUSED; }
-	|	T_ARRAY						{ $$.op_type = IS_CONST; Z_TYPE_INFO($$.u.constant)=IS_ARRAY; }
-	|	T_CALLABLE					{ $$.op_type = IS_CONST; Z_TYPE_INFO($$.u.constant)=IS_CALLABLE; }
-	|	fully_qualified_class_name			{ $$ = $1; }
+optional_type:
+		/* empty */	{ $$.ast = NULL; }
+	|	T_ARRAY		{ $$.ast = zend_ast_create_ex(ZEND_AST_TYPE, IS_ARRAY); }
+	|	T_CALLABLE	{ $$.ast = zend_ast_create_ex(ZEND_AST_TYPE, IS_CALLABLE); }
+	|	name		{ $$.ast = $1.ast; }
 ;
 
-
-function_call_parameter_list:
-		'(' ')'	{ Z_LVAL($$.u.constant) = 0; }
-	|	'(' non_empty_function_call_parameter_list ')'	{ $$ = $2; }
-	|	'(' yield_expr ')'	{ zend_do_pass_param(&$2, ZEND_SEND_VAL TSRMLS_CC); }
+argument_list:
+		'(' ')'	{ $$.list = zend_ast_create_list(0, ZEND_AST_ARG_LIST); }
+	|	'(' non_empty_argument_list ')' { $$.ast = $2.ast; }
 ;
 
-
-non_empty_function_call_parameter_list:
-		function_call_parameter
-	|	non_empty_function_call_parameter_list ',' function_call_parameter
+non_empty_argument_list:
+		argument
+			{ $$.list = zend_ast_create_list(1, ZEND_AST_ARG_LIST, $1.ast); }
+	|	non_empty_argument_list ',' argument
+			{ $$.list = zend_ast_list_add($1.list, $3.ast); }
 ;
 
-function_call_parameter:
-		expr_without_variable	{ zend_do_pass_param(&$1, ZEND_SEND_VAL TSRMLS_CC); }
-	|	variable				{ zend_do_pass_param(&$1, ZEND_SEND_VAR TSRMLS_CC); }
-	|	'&' w_variable 			{ zend_do_pass_param(&$2, ZEND_SEND_REF TSRMLS_CC); }
-	|	T_ELLIPSIS expr			{ zend_do_unpack_params(&$2 TSRMLS_CC); }
+argument:
+		expr_without_variable	{ $$.ast = $1.ast; }
+	|	variable				{ $$.ast = $1.ast; }
+	/*|	'&' variable 			{ ZEND_ASSERT(0); } */
+	|	T_ELLIPSIS expr			{ $$.ast = zend_ast_create(ZEND_AST_UNPACK, $2.ast); }
 ;
 
 global_var_list:
-		global_var_list ',' global_var	{ zend_do_fetch_global_variable(&$3, NULL, ZEND_FETCH_GLOBAL_LOCK TSRMLS_CC); }
-	|	global_var						{ zend_do_fetch_global_variable(&$1, NULL, ZEND_FETCH_GLOBAL_LOCK TSRMLS_CC); }
+		global_var_list ',' global_var { $$.list = zend_ast_list_add($1.list, $3.ast); }
+	|	global_var { $$.list = zend_ast_create_list(1, ZEND_AST_STMT_LIST, $1.ast); }
 ;
 
-
 global_var:
-		T_VARIABLE			{ $$ = $1; }
-	|	'$' r_variable		{ $$ = $2; }
-	|	'$' '{' expr '}'	{ $$ = $3; }
+	simple_variable
+		{ $$.ast = zend_ast_create(ZEND_AST_GLOBAL,
+		      zend_ast_create(ZEND_AST_VAR, $1.ast)); }
 ;
 
 
 static_var_list:
-		static_var_list ',' T_VARIABLE { zend_do_fetch_static_variable(&$3, NULL, ZEND_FETCH_STATIC TSRMLS_CC); }
-	|	static_var_list ',' T_VARIABLE '=' static_scalar { Z_CONST_FLAGS($5.u.constant) = 0; zend_do_fetch_static_variable(&$3, &$5, ZEND_FETCH_STATIC TSRMLS_CC); }
-	|	T_VARIABLE  { zend_do_fetch_static_variable(&$1, NULL, ZEND_FETCH_STATIC TSRMLS_CC); }
-	|	T_VARIABLE '=' static_scalar { Z_CONST_FLAGS($3.u.constant) = 0; zend_do_fetch_static_variable(&$1, &$3, ZEND_FETCH_STATIC TSRMLS_CC); }
+		static_var_list ',' static_var { $$.list = zend_ast_list_add($1.list, $3.ast); }
+	|	static_var { $$.list = zend_ast_create_list(1, ZEND_AST_STMT_LIST, $1.ast); }
+;
 
+static_var:
+		T_VARIABLE
+			{ $$.ast = zend_ast_create(ZEND_AST_STATIC, $1.ast, NULL); }
+	|	T_VARIABLE '=' expr
+			{ $$.ast = zend_ast_create(ZEND_AST_STATIC, $1.ast, $3.ast); }
 ;
 
 
 class_statement_list:
 		class_statement_list class_statement
+			{ $$.list = zend_ast_list_add($1.list, $2.ast); }
 	|	/* empty */
+			{ $$.list = zend_ast_create_list(0, ZEND_AST_STMT_LIST); }
 ;
 
 
 class_statement:
-		variable_modifiers { CG(access_type) = Z_LVAL($1.u.constant); } class_variable_declaration ';'
-	|	class_constant_declaration ';'
-	|	trait_use_statement
-	|	method_modifiers function is_reference T_STRING { zend_do_begin_function_declaration(&$2, &$4, 1, $3.op_type, &$1 TSRMLS_CC); }
-		'(' parameter_list ')'
-		method_body { zend_do_abstract_method(&$4, &$1, &$9 TSRMLS_CC); zend_do_end_function_declaration(&$2 TSRMLS_CC); }
+		variable_modifiers property_list ';'
+			{ $$.list = zend_ast_append_doc_comment($2.list TSRMLS_CC); $$.ast->attr = $1.num; }
+	|	T_CONST class_const_list ';'
+			{ $$.ast = $2.ast; RESET_DOC_COMMENT(); }
+	|	T_USE name_list trait_adaptations
+			{ $$.ast = zend_ast_create(ZEND_AST_USE_TRAIT, $2.ast, $3.ast); }
+	|	method_modifiers function returns_ref T_STRING '(' parameter_list ')'
+			{ $$.str = CG(doc_comment); CG(doc_comment) = NULL; }
+		method_body
+			{ $$.ast = zend_ast_create_decl(ZEND_AST_METHOD, $3.num | $1.num, $2.num, $8.str,
+				  zend_ast_get_str($4.ast), $6.ast, NULL, $9.ast); }
 ;
 
-trait_use_statement:
-		T_USE trait_list trait_adaptations
-;
-
-trait_list:
-		fully_qualified_class_name						{ zend_do_use_trait(&$1 TSRMLS_CC); }
-	|	trait_list ',' fully_qualified_class_name		{ zend_do_use_trait(&$3 TSRMLS_CC); }
+name_list:
+		name { $$.list = zend_ast_create_list(1, ZEND_AST_NAME_LIST, $1.ast); }
+	|	name_list ',' name { $$.list = zend_ast_list_add($1.list, $3.ast); }
 ;
 
 trait_adaptations:
-		';'
-	|	'{' trait_adaptation_list '}'
+		';'								{ $$.ast = NULL; }
+	|	'{' '}'							{ $$.ast = NULL; }
+	|	'{' trait_adaptation_list '}'	{ $$.ast = $2.ast; }
 ;
 
 trait_adaptation_list:
-		/* empty */
-	|	non_empty_trait_adaptation_list
-;
-
-non_empty_trait_adaptation_list:
-		trait_adaptation_statement
-	|	non_empty_trait_adaptation_list trait_adaptation_statement
+		trait_adaptation
+			{ $$.list = zend_ast_create_list(1, ZEND_AST_TRAIT_ADAPTATIONS, $1.ast); }
+	|	trait_adaptation_list trait_adaptation
+			{ $$.list = zend_ast_list_add($1.list, $2.ast); }
 ;
 
-trait_adaptation_statement:
-		trait_precedence ';'
-	|	trait_alias ';'
+trait_adaptation:
+		trait_precedence ';'	{ $$.ast = $1.ast; }
+	|	trait_alias ';'			{ $$.ast = $1.ast; }
 ;
 
 trait_precedence:
-	trait_method_reference_fully_qualified T_INSTEADOF trait_reference_list	{ zend_add_trait_precedence(&$1, &$3 TSRMLS_CC); }
+	absolute_trait_method_reference T_INSTEADOF name_list
+		{ $$.ast = zend_ast_create(ZEND_AST_TRAIT_PRECEDENCE, $1.ast, $3.ast); }
 ;
 
-trait_reference_list:
-		fully_qualified_class_name									{ zend_resolve_class_name(&$1 TSRMLS_CC); zend_init_list(&$$.u.op.ptr, Z_STR($1.u.constant) TSRMLS_CC); }
-	|	trait_reference_list ',' fully_qualified_class_name			{ zend_resolve_class_name(&$3 TSRMLS_CC); zend_add_to_list(&$1.u.op.ptr, Z_STR($3.u.constant) TSRMLS_CC); $$ = $1; }
+trait_alias:
+		trait_method_reference T_AS trait_modifiers T_STRING
+			{ $$.ast = zend_ast_create_ex(ZEND_AST_TRAIT_ALIAS, $3.num, $1.ast, $4.ast); }
+	|	trait_method_reference T_AS member_modifier
+			{ $$.ast = zend_ast_create_ex(ZEND_AST_TRAIT_ALIAS, $3.num, $1.ast, NULL); }
 ;
 
 trait_method_reference:
-		T_STRING													{ zend_prepare_reference(&$$, NULL, &$1 TSRMLS_CC); }
-	|	trait_method_reference_fully_qualified						{ $$ = $1; }
-;
-
-trait_method_reference_fully_qualified:
-	fully_qualified_class_name T_PAAMAYIM_NEKUDOTAYIM T_STRING		{ zend_prepare_reference(&$$, &$1, &$3 TSRMLS_CC); }
+		T_STRING
+			{ $$.ast = zend_ast_create(ZEND_AST_METHOD_REFERENCE, NULL, $1.ast); }
+	|	absolute_trait_method_reference { $$.ast = $1.ast; }
 ;
 
-trait_alias:
-		trait_method_reference T_AS trait_modifiers T_STRING		{ zend_add_trait_alias(&$1, &$3, &$4 TSRMLS_CC); }
-	|	trait_method_reference T_AS member_modifier					{ zend_add_trait_alias(&$1, &$3, NULL TSRMLS_CC); }
+absolute_trait_method_reference:
+	name T_PAAMAYIM_NEKUDOTAYIM T_STRING
+		{ $$.ast = zend_ast_create(ZEND_AST_METHOD_REFERENCE, $1.ast, $3.ast); }
 ;
 
 trait_modifiers:
-		/* empty */					{ Z_LVAL($$.u.constant) = 0x0; } /* No change of methods visibility */
-	|	member_modifier	{ $$ = $1; } /* REM: Keep in mind, there are not only visibility modifiers */
+		/* empty */		{ $$.num = 0; }
+	|	member_modifier	{ $$.num = $1.num; }
 ;
 
 method_body:
-		';' /* abstract method */		{ Z_LVAL($$.u.constant) = ZEND_ACC_ABSTRACT; }
-	|	'{' inner_statement_list '}'	{ Z_LVAL($$.u.constant) = 0;	}
+		';' /* abstract method */		{ $$.ast = NULL; }
+	|	'{' inner_statement_list '}'	{ $$.ast = $2.ast; }
 ;
 
 variable_modifiers:
-		non_empty_member_modifiers		{ $$ = $1; }
-	|	T_VAR							{ Z_LVAL($$.u.constant) = ZEND_ACC_PUBLIC; }
+		non_empty_member_modifiers		{ $$.num = $1.num; }
+	|	T_VAR							{ $$.num = ZEND_ACC_PUBLIC; }
 ;
 
 method_modifiers:
-		/* empty */							{ Z_LVAL($$.u.constant) = ZEND_ACC_PUBLIC; }
-	|	non_empty_member_modifiers			{ $$ = $1;  if (!(Z_LVAL($$.u.constant) & ZEND_ACC_PPP_MASK)) { Z_LVAL($$.u.constant) |= ZEND_ACC_PUBLIC; } }
+		/* empty */						{ $$.num = ZEND_ACC_PUBLIC; }
+	|	non_empty_member_modifiers
+			{ $$.num = $1.num; if (!($$.num & ZEND_ACC_PPP_MASK)) { $$.num |= ZEND_ACC_PUBLIC; } }
 ;
 
 non_empty_member_modifiers:
-		member_modifier						{ $$ = $1; }
-	|	non_empty_member_modifiers member_modifier	{ Z_LVAL($$.u.constant) = zend_do_verify_access_types(&$1, &$2); }
+		member_modifier			{ $$.num = $1.num; }
+	|	non_empty_member_modifiers member_modifier
+			{ $$.num = zend_add_member_modifier($1.num, $2.num); }
 ;
 
 member_modifier:
-		T_PUBLIC				{ Z_LVAL($$.u.constant) = ZEND_ACC_PUBLIC; }
-	|	T_PROTECTED				{ Z_LVAL($$.u.constant) = ZEND_ACC_PROTECTED; }
-	|	T_PRIVATE				{ Z_LVAL($$.u.constant) = ZEND_ACC_PRIVATE; }
-	|	T_STATIC				{ Z_LVAL($$.u.constant) = ZEND_ACC_STATIC; }
-	|	T_ABSTRACT				{ Z_LVAL($$.u.constant) = ZEND_ACC_ABSTRACT; }
-	|	T_FINAL					{ Z_LVAL($$.u.constant) = ZEND_ACC_FINAL; }
+		T_PUBLIC				{ $$.num = ZEND_ACC_PUBLIC; }
+	|	T_PROTECTED				{ $$.num = ZEND_ACC_PROTECTED; }
+	|	T_PRIVATE				{ $$.num = ZEND_ACC_PRIVATE; }
+	|	T_STATIC				{ $$.num = ZEND_ACC_STATIC; }
+	|	T_ABSTRACT				{ $$.num = ZEND_ACC_ABSTRACT; }
+	|	T_FINAL					{ $$.num = ZEND_ACC_FINAL; }
 ;
 
-class_variable_declaration:
-		class_variable_declaration ',' T_VARIABLE					{ zend_do_declare_property(&$3, NULL, CG(access_type) TSRMLS_CC); }
-	|	class_variable_declaration ',' T_VARIABLE '=' static_scalar	{ zend_do_declare_property(&$3, &$5, CG(access_type) TSRMLS_CC); }
-	|	T_VARIABLE						{ zend_do_declare_property(&$1, NULL, CG(access_type) TSRMLS_CC); }
-	|	T_VARIABLE '=' static_scalar	{ zend_do_declare_property(&$1, &$3, CG(access_type) TSRMLS_CC); }
+property_list:
+		property_list ',' property { $$.list = zend_ast_list_add($1.list, $3.ast); }
+	|	property { $$.list = zend_ast_create_list(1, ZEND_AST_PROP_DECL, $1.ast); }
 ;
 
-class_constant_declaration:
-		class_constant_declaration ',' T_STRING '=' static_scalar	{ zend_do_declare_class_constant(&$3, &$5 TSRMLS_CC); }
-	|	T_CONST T_STRING '=' static_scalar	{ zend_do_declare_class_constant(&$2, &$4 TSRMLS_CC); }
+property:
+		T_VARIABLE { $$.ast = zend_ast_create(ZEND_AST_PROP_ELEM, $1.ast, NULL); }
+	|	T_VARIABLE '=' expr
+			{ $$.ast = zend_ast_create(ZEND_AST_PROP_ELEM, $1.ast, $3.ast); }
 ;
 
-echo_expr_list:
-		echo_expr_list ',' expr { zend_do_echo(&$3 TSRMLS_CC); }
-	|	expr					{ zend_do_echo(&$1 TSRMLS_CC); }
+class_const_list:
+		class_const_list ',' const_decl { $$.list = zend_ast_list_add($1.list, $3.ast); }
+	|	const_decl
+			{ $$.list = zend_ast_create_list(1, ZEND_AST_CLASS_CONST_DECL, $1.ast); }
 ;
 
-
-for_expr:
-		/* empty */			{ $$.op_type = IS_CONST;  ZVAL_BOOL(&$$.u.constant, 1); }
-	|	non_empty_for_expr	{ $$ = $1; }
+const_decl:
+	T_STRING '=' expr
+		{ $$.ast = zend_ast_create(ZEND_AST_CONST_ELEM, $1.ast, $3.ast); }
 ;
 
-non_empty_for_expr:
-		non_empty_for_expr ','	{ zend_do_free(&$1 TSRMLS_CC); } expr { $$ = $4; }
-	|	expr					{ $$ = $1; }
-;
-
-chaining_method_or_property:
-		chaining_method_or_property variable_property 	{ $$.EA = $2.EA; }
-	|	variable_property 								{ $$.EA = $1.EA; }
+echo_expr_list:
+		echo_expr_list ',' echo_expr { $$.list = zend_ast_list_add($1.list, $3.ast); }
+	|	echo_expr { $$.list = zend_ast_create_list(1, ZEND_AST_STMT_LIST, $1.ast); }
 ;
-
-chaining_dereference:
-		chaining_dereference '[' dim_offset ']'	{ fetch_array_dim(&$$, &$1, &$3 TSRMLS_CC); }
-	|	'[' dim_offset ']'		{ zend_do_pop_object(&$1 TSRMLS_CC); fetch_array_dim(&$$, &$1, &$2 TSRMLS_CC); }
+echo_expr:
+	expr { $$.ast = zend_ast_create(ZEND_AST_ECHO, $1.ast); }
 ;
 
-chaining_instance_call:
-		chaining_dereference 		{ zend_do_push_object(&$1 TSRMLS_CC); } chaining_method_or_property { $$ = $3; }
-	|	chaining_dereference 		{ zend_do_push_object(&$1 TSRMLS_CC); $$ = $1; }
-	|	chaining_method_or_property { $$ = $1; }
+for_expr:
+		/* empty */			{ $$.ast = NULL; }
+	|	non_empty_for_expr	{ $$.ast = $1.ast; }
 ;
 
-instance_call:
-		/* empty */ 		{ $$ = $0; }
-	|	{ zend_do_push_object(&$0 TSRMLS_CC); zend_do_begin_variable_parse(TSRMLS_C); }
-		chaining_instance_call	{ zend_do_pop_object(&$$ TSRMLS_CC); zend_do_end_variable_parse(&$2, BP_VAR_R, 0 TSRMLS_CC); }
+non_empty_for_expr:
+		non_empty_for_expr ',' expr { $$.list = zend_ast_list_add($1.list, $3.ast); }
+	|	expr { $$.list = zend_ast_create_list(1, ZEND_AST_EXPR_LIST, $1.ast); }
 ;
 
 new_expr:
-		T_NEW class_name_reference { zend_do_extended_fcall_begin(TSRMLS_C); zend_do_begin_new_object(&$1, &$2 TSRMLS_CC); } ctor_arguments { zend_do_end_new_object(&$$, &$1 TSRMLS_CC); zend_do_extended_fcall_end(TSRMLS_C);}
+		T_NEW class_name_reference ctor_arguments
+			{ $$.ast = zend_ast_create(ZEND_AST_NEW, $2.ast, $3.ast); }
 ;
 
 expr_without_variable:
-		T_LIST '(' { zend_do_list_init(TSRMLS_C); } assignment_list ')' '=' expr { zend_do_list_end(&$$, &$7 TSRMLS_CC); }
-	|	variable '=' expr		{ zend_check_writable_variable(&$1); zend_do_assign(&$$, &$1, &$3 TSRMLS_CC); }
-	|	variable '=' '&' variable { zend_check_writable_variable(&$1); zend_do_end_variable_parse(&$4, BP_VAR_W, 1 TSRMLS_CC); zend_do_end_variable_parse(&$1, BP_VAR_W, 0 TSRMLS_CC); zend_do_assign_ref(&$$, &$1, &$4 TSRMLS_CC); }
-	|	variable '=' '&' T_NEW class_name_reference { zend_error(E_DEPRECATED, "Assigning the return value of new by reference is deprecated");  zend_check_writable_variable(&$1); zend_do_extended_fcall_begin(TSRMLS_C); zend_do_begin_new_object(&$4, &$5 TSRMLS_CC); } ctor_arguments { zend_do_end_new_object(&$3, &$4 TSRMLS_CC); zend_do_extended_fcall_end(TSRMLS_C); zend_do_end_variable_parse(&$1, BP_VAR_W, 0 TSRMLS_CC); $3.EA = ZEND_PARSED_NEW; zend_do_assign_ref(&$$, &$1, &$3 TSRMLS_CC); }
-	|	T_CLONE expr { zend_do_clone(&$$, &$2 TSRMLS_CC); }
-	|	variable T_PLUS_EQUAL expr 	{ zend_check_writable_variable(&$1); zend_do_end_variable_parse(&$1, BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_ADD, &$$, &$1, &$3 TSRMLS_CC); }
-	|	variable T_MINUS_EQUAL expr	{ zend_check_writable_variable(&$1); zend_do_end_variable_parse(&$1, BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_SUB, &$$, &$1, &$3 TSRMLS_CC); }
-	|	variable T_MUL_EQUAL expr		{ zend_check_writable_variable(&$1); zend_do_end_variable_parse(&$1, BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_MUL, &$$, &$1, &$3 TSRMLS_CC); }
-	|	variable T_POW_EQUAL expr		{ zend_check_writable_variable(&$1); zend_do_end_variable_parse(&$1, BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_POW, &$$, &$1, &$3 TSRMLS_CC); }
-	|	variable T_DIV_EQUAL expr		{ zend_check_writable_variable(&$1); zend_do_end_variable_parse(&$1, BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_DIV, &$$, &$1, &$3 TSRMLS_CC); }
-	|	variable T_CONCAT_EQUAL expr	{ zend_check_writable_variable(&$1); zend_do_end_variable_parse(&$1, BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_CONCAT, &$$, &$1, &$3 TSRMLS_CC); }
-	|	variable T_MOD_EQUAL expr		{ zend_check_writable_variable(&$1); zend_do_end_variable_parse(&$1, BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_MOD, &$$, &$1, &$3 TSRMLS_CC); }
-	|	variable T_AND_EQUAL expr		{ zend_check_writable_variable(&$1); zend_do_end_variable_parse(&$1, BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_BW_AND, &$$, &$1, &$3 TSRMLS_CC); }
-	|	variable T_OR_EQUAL expr 		{ zend_check_writable_variable(&$1); zend_do_end_variable_parse(&$1, BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_BW_OR, &$$, &$1, &$3 TSRMLS_CC); }
-	|	variable T_XOR_EQUAL expr 		{ zend_check_writable_variable(&$1); zend_do_end_variable_parse(&$1, BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_BW_XOR, &$$, &$1, &$3 TSRMLS_CC); }
-	|	variable T_SL_EQUAL expr	{ zend_check_writable_variable(&$1); zend_do_end_variable_parse(&$1, BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_SL, &$$, &$1, &$3 TSRMLS_CC); }
-	|	variable T_SR_EQUAL expr	{ zend_check_writable_variable(&$1); zend_do_end_variable_parse(&$1, BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_SR, &$$, &$1, &$3 TSRMLS_CC); }
-	|	rw_variable T_INC { zend_do_post_incdec(&$$, &$1, ZEND_POST_INC TSRMLS_CC); }
-	|	T_INC rw_variable { zend_do_pre_incdec(&$$, &$2, ZEND_PRE_INC TSRMLS_CC); }
-	|	rw_variable T_DEC { zend_do_post_incdec(&$$, &$1, ZEND_POST_DEC TSRMLS_CC); }
-	|	T_DEC rw_variable { zend_do_pre_incdec(&$$, &$2, ZEND_PRE_DEC TSRMLS_CC); }
-	|	expr T_BOOLEAN_OR { zend_do_boolean_or_begin(&$1, &$2 TSRMLS_CC); } expr { zend_do_boolean_or_end(&$$, &$1, &$4, &$2 TSRMLS_CC); }
-	|	expr T_BOOLEAN_AND { zend_do_boolean_and_begin(&$1, &$2 TSRMLS_CC); } expr { zend_do_boolean_and_end(&$$, &$1, &$4, &$2 TSRMLS_CC); }
-	|	expr T_LOGICAL_OR { zend_do_boolean_or_begin(&$1, &$2 TSRMLS_CC); } expr { zend_do_boolean_or_end(&$$, &$1, &$4, &$2 TSRMLS_CC); }
-	|	expr T_LOGICAL_AND { zend_do_boolean_and_begin(&$1, &$2 TSRMLS_CC); } expr { zend_do_boolean_and_end(&$$, &$1, &$4, &$2 TSRMLS_CC); }
-	|	expr T_LOGICAL_XOR expr { zend_do_binary_op(ZEND_BOOL_XOR, &$$, &$1, &$3 TSRMLS_CC); }
-	|	expr '|' expr	{ zend_do_binary_op(ZEND_BW_OR, &$$, &$1, &$3 TSRMLS_CC); }
-	|	expr '&' expr	{ zend_do_binary_op(ZEND_BW_AND, &$$, &$1, &$3 TSRMLS_CC); }
-	|	expr '^' expr	{ zend_do_binary_op(ZEND_BW_XOR, &$$, &$1, &$3 TSRMLS_CC); }
-	|	expr '.' expr 	{ zend_do_binary_op(ZEND_CONCAT, &$$, &$1, &$3 TSRMLS_CC); }
-	|	expr '+' expr 	{ zend_do_binary_op(ZEND_ADD, &$$, &$1, &$3 TSRMLS_CC); }
-	|	expr '-' expr 	{ zend_do_binary_op(ZEND_SUB, &$$, &$1, &$3 TSRMLS_CC); }
-	|	expr '*' expr	{ zend_do_binary_op(ZEND_MUL, &$$, &$1, &$3 TSRMLS_CC); }
-	|	expr T_POW expr	{ zend_do_binary_op(ZEND_POW, &$$, &$1, &$3 TSRMLS_CC); }
-	|	expr '/' expr	{ zend_do_binary_op(ZEND_DIV, &$$, &$1, &$3 TSRMLS_CC); }
-	|	expr '%' expr 	{ zend_do_binary_op(ZEND_MOD, &$$, &$1, &$3 TSRMLS_CC); }
-	| 	expr T_SL expr	{ zend_do_binary_op(ZEND_SL, &$$, &$1, &$3 TSRMLS_CC); }
-	|	expr T_SR expr	{ zend_do_binary_op(ZEND_SR, &$$, &$1, &$3 TSRMLS_CC); }
-	|	'+' expr %prec T_INC { ZVAL_LONG(&$1.u.constant, 0); if ($2.op_type == IS_CONST) { add_function(&$2.u.constant, &$1.u.constant, &$2.u.constant TSRMLS_CC); $$ = $2; } else { $1.op_type = IS_CONST; zend_do_binary_op(ZEND_ADD, &$$, &$1, &$2 TSRMLS_CC); } }
-	|	'-' expr %prec T_INC { ZVAL_LONG(&$1.u.constant, 0); if ($2.op_type == IS_CONST) { sub_function(&$2.u.constant, &$1.u.constant, &$2.u.constant TSRMLS_CC); $$ = $2; } else { $1.op_type = IS_CONST; zend_do_binary_op(ZEND_SUB, &$$, &$1, &$2 TSRMLS_CC); } }
-	|	'!' expr { zend_do_unary_op(ZEND_BOOL_NOT, &$$, &$2 TSRMLS_CC); }
-	|	'~' expr { zend_do_unary_op(ZEND_BW_NOT, &$$, &$2 TSRMLS_CC); }
-	|	expr T_IS_IDENTICAL expr		{ zend_do_binary_op(ZEND_IS_IDENTICAL, &$$, &$1, &$3 TSRMLS_CC); }
-	|	expr T_IS_NOT_IDENTICAL expr	{ zend_do_binary_op(ZEND_IS_NOT_IDENTICAL, &$$, &$1, &$3 TSRMLS_CC); }
-	|	expr T_IS_EQUAL expr			{ zend_do_binary_op(ZEND_IS_EQUAL, &$$, &$1, &$3 TSRMLS_CC); }
-	|	expr T_IS_NOT_EQUAL expr 		{ zend_do_binary_op(ZEND_IS_NOT_EQUAL, &$$, &$1, &$3 TSRMLS_CC); }
-	|	expr '<' expr 					{ zend_do_binary_op(ZEND_IS_SMALLER, &$$, &$1, &$3 TSRMLS_CC); }
-	|	expr T_IS_SMALLER_OR_EQUAL expr { zend_do_binary_op(ZEND_IS_SMALLER_OR_EQUAL, &$$, &$1, &$3 TSRMLS_CC); }
-	|	expr '>' expr 					{ zend_do_binary_op(ZEND_IS_SMALLER, &$$, &$3, &$1 TSRMLS_CC); }
-	|	expr T_IS_GREATER_OR_EQUAL expr { zend_do_binary_op(ZEND_IS_SMALLER_OR_EQUAL, &$$, &$3, &$1 TSRMLS_CC); }
-	|	expr T_INSTANCEOF class_name_reference { zend_do_instanceof(&$$, &$1, &$3, 0 TSRMLS_CC); }
-	|	parenthesis_expr 	{ $$ = $1; }
-	|	new_expr		{ $$ = $1; }
-	|	'(' new_expr ')' { $$ = $2; } instance_call { $$ = $5; }
-	|	expr '?' { zend_do_begin_qm_op(&$1, &$2 TSRMLS_CC); }
-		expr ':' { zend_do_qm_true(&$4, &$2, &$5 TSRMLS_CC); }
-		expr	 { zend_do_qm_false(&$$, &$7, &$2, &$5 TSRMLS_CC); }
-	|	expr '?' ':' { zend_do_jmp_set(&$1, &$2, &$3 TSRMLS_CC); }
-		expr     { zend_do_jmp_set_else(&$$, &$5, &$2, &$3 TSRMLS_CC); }
-	|	internal_functions_in_yacc { $$ = $1; }
-	|	T_INT_CAST expr 	{ zend_do_cast(&$$, &$2, IS_LONG TSRMLS_CC); }
-	|	T_DOUBLE_CAST expr 	{ zend_do_cast(&$$, &$2, IS_DOUBLE TSRMLS_CC); }
-	|	T_STRING_CAST expr	{ zend_do_cast(&$$, &$2, IS_STRING TSRMLS_CC); }
-	|	T_ARRAY_CAST expr 	{ zend_do_cast(&$$, &$2, IS_ARRAY TSRMLS_CC); }
-	|	T_OBJECT_CAST expr 	{ zend_do_cast(&$$, &$2, IS_OBJECT TSRMLS_CC); }
-	|	T_BOOL_CAST expr	{ zend_do_cast(&$$, &$2, _IS_BOOL TSRMLS_CC); }
-	|	T_UNSET_CAST expr	{ zend_do_cast(&$$, &$2, IS_NULL TSRMLS_CC); }
-	|	T_EXIT exit_expr	{ zend_do_exit(&$$, &$2 TSRMLS_CC); }
-	|	'@' { zend_do_begin_silence(&$1 TSRMLS_CC); } expr { zend_do_end_silence(&$1 TSRMLS_CC); $$ = $3; }
-	|	scalar				{ $$ = $1; }
-	|	combined_scalar_offset { zend_do_end_variable_parse(&$1, BP_VAR_R, 0 TSRMLS_CC); }
-	|	combined_scalar { $$ = $1; }
-	|	'`' backticks_expr '`' { zend_do_shell_exec(&$$, &$2 TSRMLS_CC); }
-	|	T_PRINT expr  { zend_do_print(&$$, &$2 TSRMLS_CC); }
-	|	T_YIELD { zend_do_yield(&$$, NULL, NULL, 0 TSRMLS_CC); }
-	|	function is_reference { zend_do_begin_lambda_function_declaration(&$$, &$1, $2.op_type, 0 TSRMLS_CC); }
-		'(' parameter_list ')' lexical_vars
-		'{' inner_statement_list '}' { zend_do_end_function_declaration(&$1 TSRMLS_CC); $$ = $3; }
-	|	T_STATIC function is_reference { zend_do_begin_lambda_function_declaration(&$$, &$2, $3.op_type, 1 TSRMLS_CC); }
-		'(' parameter_list ')' lexical_vars
-		'{' inner_statement_list '}' { zend_do_end_function_declaration(&$2 TSRMLS_CC); $$ = $4; }
-;
-
-yield_expr:
-		T_YIELD expr_without_variable { zend_do_yield(&$$, &$2, NULL, 0 TSRMLS_CC); }
-	|	T_YIELD variable { zend_do_yield(&$$, &$2, NULL, 1 TSRMLS_CC); }
-	|	T_YIELD expr T_DOUBLE_ARROW expr_without_variable { zend_do_yield(&$$, &$4, &$2, 0 TSRMLS_CC); }
-	|	T_YIELD expr T_DOUBLE_ARROW variable { zend_do_yield(&$$, &$4, &$2, 1 TSRMLS_CC); }
-;
-
-combined_scalar_offset:
-		combined_scalar '[' dim_offset ']' { zend_do_begin_variable_parse(TSRMLS_C); fetch_array_dim(&$$, &$1, &$3 TSRMLS_CC); }
-	|	combined_scalar_offset '[' dim_offset ']' { fetch_array_dim(&$$, &$1, &$3 TSRMLS_CC); }
-	|	T_CONSTANT_ENCAPSED_STRING '[' dim_offset ']' { $1.EA = 0; zend_do_begin_variable_parse(TSRMLS_C); fetch_array_dim(&$$, &$1, &$3 TSRMLS_CC); }
-	|	general_constant '[' dim_offset ']' { zend_do_begin_variable_parse(TSRMLS_C); fetch_array_dim(&$$, &$1, &$3 TSRMLS_CC); }
-;
-
-combined_scalar:
-		T_ARRAY '(' array_pair_list ')' { $$ = $3; }
-	|	'[' array_pair_list ']' { $$ = $2; }
+		T_LIST '(' assignment_list ')' '=' expr
+			{ $$.ast = zend_ast_create(ZEND_AST_ASSIGN, $3.ast, $6.ast); }
+	|	variable '=' expr
+			{ $$.ast = zend_ast_create(ZEND_AST_ASSIGN, $1.ast, $3.ast); }
+	|	variable '=' '&' variable
+			{ $$.ast = zend_ast_create(ZEND_AST_ASSIGN_REF, $1.ast, $4.ast); }
+	|	variable '=' '&' T_NEW class_name_reference ctor_arguments
+			{ zend_error(E_DEPRECATED, "Assigning the return value of new by reference is deprecated");
+			  $$.ast = zend_ast_create(ZEND_AST_ASSIGN_REF, $1.ast,
+			      zend_ast_create(ZEND_AST_NEW, $5.ast, $6.ast)); }
+	|	T_CLONE expr { $$.ast = zend_ast_create(ZEND_AST_CLONE, $2.ast); }
+	|	variable T_PLUS_EQUAL expr
+			{ $$.ast = zend_ast_create_assign_op(ZEND_ASSIGN_ADD, $1.ast, $3.ast); }
+	|	variable T_MINUS_EQUAL expr
+			{ $$.ast = zend_ast_create_assign_op(ZEND_ASSIGN_SUB, $1.ast, $3.ast); }
+	|	variable T_MUL_EQUAL expr
+			{ $$.ast = zend_ast_create_assign_op(ZEND_ASSIGN_MUL, $1.ast, $3.ast); }
+	|	variable T_POW_EQUAL expr
+			{ $$.ast = zend_ast_create_assign_op(ZEND_ASSIGN_POW, $1.ast, $3.ast); }
+	|	variable T_DIV_EQUAL expr
+			{ $$.ast = zend_ast_create_assign_op(ZEND_ASSIGN_DIV, $1.ast, $3.ast); }
+	|	variable T_CONCAT_EQUAL expr
+			{ $$.ast = zend_ast_create_assign_op(ZEND_ASSIGN_CONCAT, $1.ast, $3.ast); }
+	|	variable T_MOD_EQUAL expr
+			{ $$.ast = zend_ast_create_assign_op(ZEND_ASSIGN_MOD, $1.ast, $3.ast); }
+	|	variable T_AND_EQUAL expr
+			{ $$.ast = zend_ast_create_assign_op(ZEND_ASSIGN_BW_AND, $1.ast, $3.ast); }
+	|	variable T_OR_EQUAL expr 
+			{ $$.ast = zend_ast_create_assign_op(ZEND_ASSIGN_BW_OR, $1.ast, $3.ast); }
+	|	variable T_XOR_EQUAL expr 
+			{ $$.ast = zend_ast_create_assign_op(ZEND_ASSIGN_BW_XOR, $1.ast, $3.ast); }
+	|	variable T_SL_EQUAL expr
+			{ $$.ast = zend_ast_create_assign_op(ZEND_ASSIGN_SL, $1.ast, $3.ast); }
+	|	variable T_SR_EQUAL expr
+			{ $$.ast = zend_ast_create_assign_op(ZEND_ASSIGN_SR, $1.ast, $3.ast); }
+	|	variable T_INC { $$.ast = zend_ast_create(ZEND_AST_POST_INC, $1.ast); }
+	|	T_INC variable { $$.ast = zend_ast_create(ZEND_AST_PRE_INC, $2.ast); }
+	|	variable T_DEC { $$.ast = zend_ast_create(ZEND_AST_POST_DEC, $1.ast); }
+	|	T_DEC variable { $$.ast = zend_ast_create(ZEND_AST_PRE_DEC, $2.ast); }
+	|	expr T_BOOLEAN_OR expr
+			{ $$.ast = zend_ast_create(ZEND_AST_OR, $1.ast, $3.ast); }
+	|	expr T_BOOLEAN_AND expr
+			{ $$.ast = zend_ast_create(ZEND_AST_AND, $1.ast, $3.ast); }
+	|	expr T_LOGICAL_OR expr
+			{ $$.ast = zend_ast_create(ZEND_AST_OR, $1.ast, $3.ast); }
+	|	expr T_LOGICAL_AND expr
+			{ $$.ast = zend_ast_create(ZEND_AST_AND, $1.ast, $3.ast); }
+	|	expr T_LOGICAL_XOR expr
+			{ $$.ast = zend_ast_create_binary_op(ZEND_BOOL_XOR, $1.ast, $3.ast); }
+	|	expr '|' expr	{ $$.ast = zend_ast_create_binary_op(ZEND_BW_OR, $1.ast, $3.ast); }
+	|	expr '&' expr	{ $$.ast = zend_ast_create_binary_op(ZEND_BW_AND, $1.ast, $3.ast); }
+	|	expr '^' expr	{ $$.ast = zend_ast_create_binary_op(ZEND_BW_XOR, $1.ast, $3.ast); }
+	|	expr '.' expr 	{ $$.ast = zend_ast_create_binary_op(ZEND_CONCAT, $1.ast, $3.ast); }
+	|	expr '+' expr 	{ $$.ast = zend_ast_create_binary_op(ZEND_ADD, $1.ast, $3.ast); }
+	|	expr '-' expr 	{ $$.ast = zend_ast_create_binary_op(ZEND_SUB, $1.ast, $3.ast); }
+	|	expr '*' expr	{ $$.ast = zend_ast_create_binary_op(ZEND_MUL, $1.ast, $3.ast); }
+	|	expr T_POW expr	{ $$.ast = zend_ast_create_binary_op(ZEND_POW, $1.ast, $3.ast); }
+	|	expr '/' expr	{ $$.ast = zend_ast_create_binary_op(ZEND_DIV, $1.ast, $3.ast); }
+	|	expr '%' expr 	{ $$.ast = zend_ast_create_binary_op(ZEND_MOD, $1.ast, $3.ast); }
+	| 	expr T_SL expr	{ $$.ast = zend_ast_create_binary_op(ZEND_SL, $1.ast, $3.ast); }
+	|	expr T_SR expr	{ $$.ast = zend_ast_create_binary_op(ZEND_SR, $1.ast, $3.ast); }
+	|	'+' expr %prec T_INC { $$.ast = zend_ast_create(ZEND_AST_UNARY_PLUS, $2.ast); }
+	|	'-' expr %prec T_INC { $$.ast = zend_ast_create(ZEND_AST_UNARY_MINUS, $2.ast); }
+	|	'!' expr { $$.ast = zend_ast_create_ex(ZEND_AST_UNARY_OP, ZEND_BOOL_NOT, $2.ast); }
+	|	'~' expr { $$.ast = zend_ast_create_ex(ZEND_AST_UNARY_OP, ZEND_BW_NOT, $2.ast); }
+	|	expr T_IS_IDENTICAL expr
+			{ $$.ast = zend_ast_create_binary_op(ZEND_IS_IDENTICAL, $1.ast, $3.ast); }
+	|	expr T_IS_NOT_IDENTICAL expr
+			{ $$.ast = zend_ast_create_binary_op(ZEND_IS_NOT_IDENTICAL, $1.ast, $3.ast); }
+	|	expr T_IS_EQUAL expr
+			{ $$.ast = zend_ast_create_binary_op(ZEND_IS_EQUAL, $1.ast, $3.ast); }
+	|	expr T_IS_NOT_EQUAL expr
+			{ $$.ast = zend_ast_create_binary_op(ZEND_IS_NOT_EQUAL, $1.ast, $3.ast); }
+	|	expr '<' expr
+			{ $$.ast = zend_ast_create_binary_op(ZEND_IS_SMALLER, $1.ast, $3.ast); }
+	|	expr T_IS_SMALLER_OR_EQUAL expr
+			{ $$.ast = zend_ast_create_binary_op(ZEND_IS_SMALLER_OR_EQUAL, $1.ast, $3.ast); }
+	|	expr '>' expr
+			{ $$.ast = zend_ast_create(ZEND_AST_GREATER, $1.ast, $3.ast); }
+	|	expr T_IS_GREATER_OR_EQUAL expr
+			{ $$.ast = zend_ast_create(ZEND_AST_GREATER_EQUAL, $1.ast, $3.ast); }
+	|	expr T_INSTANCEOF class_name_reference
+			{ $$.ast = zend_ast_create(ZEND_AST_INSTANCEOF, $1.ast, $3.ast); }
+	|	parenthesis_expr { $$.ast = $1.ast; }
+	|	new_expr { $$.ast = $1.ast; }
+	|	expr '?' expr ':' expr
+			{ $$.ast = zend_ast_create(ZEND_AST_CONDITIONAL, $1.ast, $3.ast, $5.ast); }
+	|	expr '?' ':' expr
+			{ $$.ast = zend_ast_create(ZEND_AST_CONDITIONAL, $1.ast, NULL, $4.ast); }
+	|	internal_functions_in_yacc { $$.ast = $1.ast; }
+	|	T_INT_CAST expr
+			{ $$.ast = zend_ast_create_cast(IS_LONG, $2.ast); }
+	|	T_DOUBLE_CAST expr
+			{ $$.ast = zend_ast_create_cast(IS_DOUBLE, $2.ast); }
+	|	T_STRING_CAST expr
+			{ $$.ast = zend_ast_create_cast(IS_STRING, $2.ast); }
+	|	T_ARRAY_CAST expr
+			{ $$.ast = zend_ast_create_cast(IS_ARRAY, $2.ast); }
+	|	T_OBJECT_CAST expr
+			{ $$.ast = zend_ast_create_cast(IS_OBJECT, $2.ast); }
+	|	T_BOOL_CAST expr
+			{ $$.ast = zend_ast_create_cast(_IS_BOOL, $2.ast); }
+	|	T_UNSET_CAST expr
+			{ $$.ast = zend_ast_create_cast(IS_NULL, $2.ast); }
+	|	T_EXIT exit_expr { $$.ast = zend_ast_create(ZEND_AST_EXIT, $2.ast); }
+	|	'@' expr { $$.ast = zend_ast_create(ZEND_AST_SILENCE, $2.ast); }
+	|	scalar { $$.ast = $1.ast; }
+	|	'`' backticks_expr '`' { $$.ast = zend_ast_create(ZEND_AST_SHELL_EXEC, $2.ast); }
+	|	T_PRINT expr { $$.ast = zend_ast_create(ZEND_AST_PRINT, $2.ast); }
+	|	T_YIELD { $$.ast = zend_ast_create(ZEND_AST_YIELD, NULL, NULL); }
+	|	T_YIELD expr { $$.ast = zend_ast_create(ZEND_AST_YIELD, $2.ast, NULL); }
+	|	T_YIELD expr T_DOUBLE_ARROW expr
+			{ $$.ast = zend_ast_create(ZEND_AST_YIELD, $4.ast, $2.ast); }
+	|	function returns_ref '(' parameter_list ')' lexical_vars
+			{ $$.str = CG(doc_comment); CG(doc_comment) = NULL; }
+		'{' inner_statement_list '}'
+			{ $$.ast = zend_ast_create_decl(ZEND_AST_CLOSURE, $2.num, $1.num, $7.str,
+				  zend_string_init("{closure}", sizeof("{closure}") - 1, 0),
+			      $4.ast, $6.ast, $9.ast); }
+	|	T_STATIC function returns_ref '(' parameter_list ')' lexical_vars
+			{ $$.str = CG(doc_comment); CG(doc_comment) = NULL; }
+		'{' inner_statement_list '}'
+			{ $$.ast = zend_ast_create_decl(ZEND_AST_CLOSURE, $3.num | ZEND_ACC_STATIC, $2.num,
+			      $8.str, zend_string_init("{closure}", sizeof("{closure}") - 1, 0),
+			      $5.ast, $7.ast, $10.ast); }
 ;
 
 function:
-	T_FUNCTION { $$.u.op.opline_num = CG(zend_lineno); }
+	T_FUNCTION { $$.num = CG(zend_lineno); }
+;
+
+returns_ref:
+		/* empty */	{ $$.num = 0; }
+	|	'&'			{ $$.num = ZEND_ACC_RETURN_REFERENCE; }
 ;
 
 lexical_vars:
-		/* empty */
-	|	T_USE '(' lexical_var_list ')'
+		/* empty */ { $$.ast = NULL; }
+	|	T_USE '(' lexical_var_list ')' { $$.ast = $3.ast; }
 ;
 
 lexical_var_list:
-		lexical_var_list ',' T_VARIABLE			{ zend_do_fetch_lexical_variable(&$3, 0 TSRMLS_CC); }
-	|	lexical_var_list ',' '&' T_VARIABLE		{ zend_do_fetch_lexical_variable(&$4, 1 TSRMLS_CC); }
-	|	T_VARIABLE								{ zend_do_fetch_lexical_variable(&$1, 0 TSRMLS_CC); }
-	|	'&' T_VARIABLE							{ zend_do_fetch_lexical_variable(&$2, 1 TSRMLS_CC); }
+		lexical_var_list ',' lexical_var { $$.list = zend_ast_list_add($1.list, $3.ast); }
+	|	lexical_var { $$.list = zend_ast_create_list(1, ZEND_AST_CLOSURE_USES, $1.ast); }
 ;
 
-function_call:
-		namespace_name { $$.u.op.opline_num = zend_do_begin_function_call(&$1, 1 TSRMLS_CC); }
-		function_call_parameter_list { zend_do_end_function_call(&$1, &$$, 0, $2.u.op.opline_num TSRMLS_CC); zend_do_extended_fcall_end(TSRMLS_C); }
-	|	T_NAMESPACE T_NS_SEPARATOR namespace_name { $1.op_type = IS_CONST; ZVAL_EMPTY_STRING(&$1.u.constant);  zend_do_build_namespace_name(&$1, &$1, &$3 TSRMLS_CC); $$.u.op.opline_num = zend_do_begin_function_call(&$1, 0 TSRMLS_CC); }
-		function_call_parameter_list { zend_do_end_function_call(&$1, &$$, 0, $4.u.op.opline_num TSRMLS_CC); zend_do_extended_fcall_end(TSRMLS_C); }
-	|	T_NS_SEPARATOR namespace_name { $$.u.op.opline_num = zend_do_begin_function_call(&$2, 0 TSRMLS_CC); }
-		function_call_parameter_list { zend_do_end_function_call(&$2, &$$, 0, $3.u.op.opline_num TSRMLS_CC); zend_do_extended_fcall_end(TSRMLS_C); }
-	|	class_name T_PAAMAYIM_NEKUDOTAYIM variable_name { $$.u.op.opline_num = zend_do_begin_class_member_function_call(&$1, &$3 TSRMLS_CC); }
-		function_call_parameter_list { zend_do_end_function_call($4.u.op.opline_num?NULL:&$3, &$$, $4.u.op.opline_num, $4.u.op.opline_num TSRMLS_CC); zend_do_extended_fcall_end(TSRMLS_C);}
-	|	class_name T_PAAMAYIM_NEKUDOTAYIM variable_without_objects { zend_do_end_variable_parse(&$3, BP_VAR_R, 0 TSRMLS_CC); zend_do_begin_class_member_function_call(&$1, &$3 TSRMLS_CC); }
-		function_call_parameter_list { zend_do_end_function_call(NULL, &$$, 1, 1 TSRMLS_CC); zend_do_extended_fcall_end(TSRMLS_C);}
-	|	variable_class_name T_PAAMAYIM_NEKUDOTAYIM variable_name { zend_do_begin_class_member_function_call(&$1, &$3 TSRMLS_CC); }
-		function_call_parameter_list { zend_do_end_function_call(NULL, &$$, 1, 1 TSRMLS_CC); zend_do_extended_fcall_end(TSRMLS_C);}
-	|	variable_class_name T_PAAMAYIM_NEKUDOTAYIM variable_without_objects { zend_do_end_variable_parse(&$3, BP_VAR_R, 0 TSRMLS_CC); zend_do_begin_class_member_function_call(&$1, &$3 TSRMLS_CC); }
-		function_call_parameter_list { zend_do_end_function_call(NULL, &$$, 1, 1 TSRMLS_CC); zend_do_extended_fcall_end(TSRMLS_C);}
-	|	variable_without_objects { zend_do_end_variable_parse(&$1, BP_VAR_R, 0 TSRMLS_CC); zend_do_begin_dynamic_function_call(&$1, 0 TSRMLS_CC); }
-		function_call_parameter_list { zend_do_end_function_call(&$1, &$$, 0, 1 TSRMLS_CC); zend_do_extended_fcall_end(TSRMLS_C);}
+lexical_var:
+		T_VARIABLE		{ $$.ast = $1.ast; }
+	|	'&' T_VARIABLE	{ $$.ast = $2.ast; $$.ast->attr = 1; }
 ;
 
-class_name:
-		T_STATIC { $$.op_type = IS_CONST; ZVAL_STRINGL(&$$.u.constant, "static", sizeof("static")-1);}
-	|	namespace_name { $$ = $1; }
-	|	T_NAMESPACE T_NS_SEPARATOR namespace_name { $$.op_type = IS_CONST; ZVAL_EMPTY_STRING(&$$.u.constant);  zend_do_build_namespace_name(&$$, &$$, &$3 TSRMLS_CC); }
-	|	T_NS_SEPARATOR namespace_name { zval tmp; ZVAL_NEW_STR(&tmp, zend_string_alloc(Z_STRLEN($2.u.constant)+1, 0)); Z_STRVAL(tmp)[0] = '\\'; memcpy(Z_STRVAL(tmp) + 1, Z_STRVAL($2.u.constant), Z_STRLEN($2.u.constant)+1); if (Z_DELREF($2.u.constant) == 0) {efree(Z_STR($2.u.constant));} Z_STR($2.u.constant) = Z_STR(tmp); $$ = $2; }
+function_call:
+		name argument_list
+			{ $$.ast = zend_ast_create(ZEND_AST_CALL, $1.ast, $2.ast); }
+	|	class_name T_PAAMAYIM_NEKUDOTAYIM member_name argument_list
+			{ $$.ast = zend_ast_create(ZEND_AST_STATIC_CALL,
+			      $1.ast, $3.ast, $4.ast); }
+	|	variable_class_name T_PAAMAYIM_NEKUDOTAYIM member_name argument_list
+			{ $$.ast = zend_ast_create(ZEND_AST_STATIC_CALL,
+			      $1.ast, $3.ast, $4.ast); }
+	|	callable_expr argument_list
+			{ $$.ast = zend_ast_create(ZEND_AST_CALL, $1.ast, $2.ast); }
 ;
 
-fully_qualified_class_name:
-		namespace_name { $$ = $1; }
-	|	T_NAMESPACE T_NS_SEPARATOR namespace_name { $$.op_type = IS_CONST; ZVAL_EMPTY_STRING(&$$.u.constant);  zend_do_build_namespace_name(&$$, &$$, &$3 TSRMLS_CC); }
-	|	T_NS_SEPARATOR namespace_name { zval tmp; ZVAL_NEW_STR(&tmp, zend_string_alloc(Z_STRLEN($2.u.constant)+1, 0)); Z_STRVAL(tmp)[0] = '\\'; memcpy(Z_STRVAL(tmp) + 1, Z_STRVAL($2.u.constant), Z_STRLEN($2.u.constant)+1); if (Z_DELREF($2.u.constant) == 0) {efree(Z_STR($2.u.constant));} Z_STR($2.u.constant) = Z_STR(tmp); $$ = $2; }
+class_name:
+		T_STATIC
+			{ zval zv; ZVAL_STRINGL(&zv, "static", sizeof("static")-1);
+			  $$.ast = zend_ast_create_zval_ex(&zv, ZEND_NAME_NOT_FQ); }
+	|	name { $$.ast = $1.ast; }
 ;
 
-
-
 class_name_reference:
-		class_name						{ zend_do_fetch_class(&$$, &$1 TSRMLS_CC); }
-	|	dynamic_class_name_reference	{ zend_do_end_variable_parse(&$1, BP_VAR_R, 0 TSRMLS_CC); zend_do_fetch_class(&$$, &$1 TSRMLS_CC); }
-;
-
-
-dynamic_class_name_reference:
-		base_variable T_OBJECT_OPERATOR { zend_do_push_object(&$1 TSRMLS_CC); }
-			object_property { zend_do_push_object(&$4 TSRMLS_CC); } dynamic_class_name_variable_properties
-			{ zend_do_pop_object(&$$ TSRMLS_CC); $$.EA = ZEND_PARSED_MEMBER; }
-	|	base_variable { $$ = $1; }
-;
-
-
-dynamic_class_name_variable_properties:
-		dynamic_class_name_variable_properties dynamic_class_name_variable_property
-	|	/* empty */
-;
-
-
-dynamic_class_name_variable_property:
-		T_OBJECT_OPERATOR object_property { zend_do_push_object(&$2 TSRMLS_CC); }
+		class_name		{ $$.ast = $1.ast; }
+	|	new_variable	{ $$.ast = $1.ast; }
 ;
 
 exit_expr:
-		/* empty */	{ memset(&$$, 0, sizeof(znode)); $$.op_type = IS_UNUSED; }
-	|	'(' ')'		{ memset(&$$, 0, sizeof(znode)); $$.op_type = IS_UNUSED; }
-	|	parenthesis_expr	{ $$ = $1; }
+		/* empty */			{ $$.ast = NULL; }
+	|	'(' ')'				{ $$.ast = NULL; }
+	|	parenthesis_expr	{ $$.ast = $1.ast; }
 ;
 
 backticks_expr:
-		/* empty */	{ ZVAL_EMPTY_STRING(&$$.u.constant); $$.op_type = IS_CONST; }
-	|	T_ENCAPSED_AND_WHITESPACE	{ $$ = $1; }
-	|	encaps_list	{ $$ = $1; }
+		/* empty */
+			{ $$.ast = zend_ast_create_zval_from_str(STR_EMPTY_ALLOC()); }
+	|	T_ENCAPSED_AND_WHITESPACE { $$.ast = $1.ast; }
+	|	encaps_list { $$.ast = $1.ast; }
 ;
 
 
 ctor_arguments:
-		/* empty */	{ Z_LVAL($$.u.constant) = 0; }
-	|	function_call_parameter_list 	{ $$ = $1; }
-;
-
-
-common_scalar:
-		T_LNUMBER 					{ $$ = $1; }
-	|	T_DNUMBER 					{ $$ = $1; }
-	|	T_CONSTANT_ENCAPSED_STRING	{ $$ = $1; }
-	|	T_LINE 						{ $$ = $1; }
-	|	T_FILE 						{ $$ = $1; }
-	|	T_DIR   					{ $$ = $1; }
-	|	T_TRAIT_C					{ $$ = $1; }
-	|	T_METHOD_C					{ $$ = $1; }
-	|	T_FUNC_C					{ $$ = $1; }
-	|	T_NS_C						{ $$ = $1; }
-	|	T_START_HEREDOC T_ENCAPSED_AND_WHITESPACE T_END_HEREDOC { $$ = $2; }
-	|	T_START_HEREDOC T_END_HEREDOC { ZVAL_EMPTY_STRING(&$$.u.constant); $$.op_type = IS_CONST; }
-;
-
-static_class_constant:
-		class_name T_PAAMAYIM_NEKUDOTAYIM T_STRING { zend_do_fetch_constant(&$$, &$1, &$3, ZEND_CT, 0 TSRMLS_CC); }
-;
-
-static_scalar: /* compile-time evaluated scalars */
-	static_scalar_value { zend_do_constant_expression(&$$, $1.u.ast TSRMLS_CC); }
-;
-
-static_scalar_value:
-		common_scalar	{ $$.u.ast = zend_ast_create_constant(&$1.u.constant); }
-	|	static_class_name_scalar	{ $$.u.ast = zend_ast_create_constant(&$1.u.constant); }
-	|	namespace_name 		{ zend_do_fetch_constant(&$$, NULL, &$1, ZEND_CT, 1 TSRMLS_CC); $$.u.ast = zend_ast_create_constant(&$$.u.constant); }
-	|	T_NAMESPACE T_NS_SEPARATOR namespace_name { $$.op_type = IS_CONST; ZVAL_EMPTY_STRING(&$$.u.constant);  zend_do_build_namespace_name(&$$, &$$, &$3 TSRMLS_CC); $3 = $$; zend_do_fetch_constant(&$$, NULL, &$3, ZEND_CT, 0 TSRMLS_CC); $$.u.ast = zend_ast_create_constant(&$$.u.constant); }
-	|	T_NS_SEPARATOR namespace_name { zval tmp; ZVAL_NEW_STR(&tmp, zend_string_alloc(Z_STRLEN($2.u.constant)+1, 0)); Z_STRVAL(tmp)[0] = '\\'; memcpy(Z_STRVAL(tmp) + 1, Z_STRVAL($2.u.constant), Z_STRLEN($2.u.constant)+1); if (Z_DELREF($2.u.constant) == 0) {efree(Z_STR($2.u.constant));} Z_STR($2.u.constant) = Z_STR(tmp); zend_do_fetch_constant(&$$, NULL, &$2, ZEND_CT, 0 TSRMLS_CC); $$.u.ast = zend_ast_create_constant(&$$.u.constant); }
-	|	T_ARRAY '(' static_array_pair_list ')' { $$ = $3; }
-	|	'[' static_array_pair_list ']' { $$ = $2; }
-	|	static_class_constant { $$.u.ast = zend_ast_create_constant(&$1.u.constant); }
-	|	T_CLASS_C			{ $$.u.ast = zend_ast_create_constant(&$1.u.constant); }
-	|	static_operation { $$ = $1; }
-;
-
-static_operation:
-		static_scalar_value '[' static_scalar_value ']' { $$.u.ast = zend_ast_create_binary(ZEND_FETCH_DIM_R, $1.u.ast, $3.u.ast); }
-	|	static_scalar_value '+' static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_ADD, $1.u.ast, $3.u.ast); }
-	|	static_scalar_value '-' static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_SUB, $1.u.ast, $3.u.ast); }
-	|	static_scalar_value '*' static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_MUL, $1.u.ast, $3.u.ast); }
-	|	static_scalar_value T_POW static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_POW, $1.u.ast, $3.u.ast); }
-	|	static_scalar_value '/' static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_DIV, $1.u.ast, $3.u.ast); }
-	|	static_scalar_value '%' static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_MOD, $1.u.ast, $3.u.ast); }
-	|	'!' static_scalar_value { $$.u.ast = zend_ast_create_unary(ZEND_BOOL_NOT, $2.u.ast); }
-	|	'~' static_scalar_value { $$.u.ast = zend_ast_create_unary(ZEND_BW_NOT, $2.u.ast); }
-	|	static_scalar_value '|' static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_BW_OR, $1.u.ast, $3.u.ast); }
-	|	static_scalar_value '&' static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_BW_AND, $1.u.ast, $3.u.ast); }
-	|	static_scalar_value '^' static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_BW_XOR, $1.u.ast, $3.u.ast); }
-	|	static_scalar_value T_SL static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_SL, $1.u.ast, $3.u.ast); }
-	|	static_scalar_value T_SR static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_SR, $1.u.ast, $3.u.ast); }
-	|	static_scalar_value '.' static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_CONCAT, $1.u.ast, $3.u.ast); }
-	|	static_scalar_value T_LOGICAL_XOR static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_BOOL_XOR, $1.u.ast, $3.u.ast); }
-	|	static_scalar_value T_LOGICAL_AND static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_BOOL_AND, $1.u.ast, $3.u.ast); }
-	|	static_scalar_value T_LOGICAL_OR static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_BOOL_OR, $1.u.ast, $3.u.ast); }
-	|	static_scalar_value T_BOOLEAN_AND static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_BOOL_AND, $1.u.ast, $3.u.ast); }
-	|	static_scalar_value T_BOOLEAN_OR static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_BOOL_OR, $1.u.ast, $3.u.ast); }
-	|	static_scalar_value T_IS_IDENTICAL static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_IS_IDENTICAL, $1.u.ast, $3.u.ast); }
-	|	static_scalar_value T_IS_NOT_IDENTICAL static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_IS_NOT_IDENTICAL, $1.u.ast, $3.u.ast); }
-	|	static_scalar_value T_IS_EQUAL static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_IS_EQUAL, $1.u.ast, $3.u.ast); }
-	|	static_scalar_value T_IS_NOT_EQUAL static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_IS_NOT_EQUAL, $1.u.ast, $3.u.ast); }
-	|	static_scalar_value '<' static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_IS_SMALLER, $1.u.ast, $3.u.ast); }
-	|	static_scalar_value '>' static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_IS_SMALLER, $3.u.ast, $1.u.ast); }
-	|	static_scalar_value T_IS_SMALLER_OR_EQUAL static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_IS_SMALLER_OR_EQUAL, $1.u.ast, $3.u.ast); }
-	|	static_scalar_value T_IS_GREATER_OR_EQUAL static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_IS_SMALLER_OR_EQUAL, $3.u.ast, $1.u.ast); }
-	|	static_scalar_value '?' ':' static_scalar_value { $$.u.ast = zend_ast_create_ternary(ZEND_SELECT, $1.u.ast, NULL, $4.u.ast); }
-	|	static_scalar_value '?' static_scalar_value ':' static_scalar_value { $$.u.ast = zend_ast_create_ternary(ZEND_SELECT, $1.u.ast, $3.u.ast, $5.u.ast); }
-	|	'+' static_scalar_value { $$.u.ast = zend_ast_create_unary(ZEND_UNARY_PLUS, $2.u.ast); }
-	|	'-' static_scalar_value { $$.u.ast = zend_ast_create_unary(ZEND_UNARY_MINUS, $2.u.ast); }
-	|	'(' static_scalar_value ')' { $$ = $2; }
-;
-
-general_constant:
-		class_constant { $$ = $1; }
-	|	namespace_name	{ zend_do_fetch_constant(&$$, NULL, &$1, ZEND_RT, 1 TSRMLS_CC); }
-	|	T_NAMESPACE T_NS_SEPARATOR namespace_name { $$.op_type = IS_CONST; ZVAL_EMPTY_STRING(&$$.u.constant);  zend_do_build_namespace_name(&$$, &$$, &$3 TSRMLS_CC); $3 = $$; zend_do_fetch_constant(&$$, NULL, &$3, ZEND_RT, 0 TSRMLS_CC); }
-	|	T_NS_SEPARATOR namespace_name { zval tmp; ZVAL_NEW_STR(&tmp, zend_string_alloc(Z_STRLEN($2.u.constant)+1, 0)); Z_STRVAL(tmp)[0] = '\\'; memcpy(Z_STRVAL(tmp) + 1, Z_STRVAL($2.u.constant), Z_STRLEN($2.u.constant)+1); if (Z_DELREF($2.u.constant) == 0) {efree(Z_STR($2.u.constant));} Z_STR($2.u.constant) = Z_STR(tmp); zend_do_fetch_constant(&$$, NULL, &$2, ZEND_RT, 0 TSRMLS_CC); }
+		/* empty */	{ $$.list = zend_ast_create_list(0, ZEND_AST_ARG_LIST); }
+	|	argument_list { $$.ast = $1.ast; }
 ;
 
-scalar:
-		T_STRING_VARNAME { $$ = $1; }
-	|	general_constant { $$ = $1; }
-	|	class_name_scalar { $$ = $1; }
-	|	common_scalar { $$ = $1; }
-	|	'"' encaps_list '"' { $$ = $2; }
-	|	T_START_HEREDOC encaps_list T_END_HEREDOC { $$ = $2; }
-	|	T_CLASS_C { if (Z_TYPE($1.u.constant) == IS_CONSTANT) {zend_do_fetch_constant(&$$, NULL, &$1, ZEND_RT, 1 TSRMLS_CC);} else {$$ = $1;} }
+
+dereferencable_scalar:
+		T_ARRAY '(' array_pair_list ')'	{ $$.ast = $3.ast; }
+	|	'[' array_pair_list ']'			{ $$.ast = $2.ast; }
+	|	T_CONSTANT_ENCAPSED_STRING		{ $$.ast = $1.ast; }
 ;
 
-static_array_pair_list:
-		/* empty */ { $$.op_type = IS_CONST; array_init(&$$.u.constant); $$.u.ast = zend_ast_create_constant(&$$.u.constant); }
-	|	non_empty_static_array_pair_list possible_comma	{ zend_ast_dynamic_shrink(&$1.u.ast); $$ = $1; }
+scalar:
+		T_LNUMBER 	{ $$.ast = $1.ast; }
+	|	T_DNUMBER 	{ $$.ast = $1.ast; }
+	|	T_LINE 		{ $$.ast = $1.ast; }
+	|	T_FILE 		{ $$.ast = $1.ast; }
+	|	T_DIR   	{ $$.ast = $1.ast; }
+	|	T_TRAIT_C	{ $$.ast = zend_ast_create_ex(ZEND_AST_MAGIC_CONST, T_TRAIT_C); }
+	|	T_METHOD_C	{ $$.ast = zend_ast_create_ex(ZEND_AST_MAGIC_CONST, T_METHOD_C); }
+	|	T_FUNC_C	{ $$.ast = zend_ast_create_ex(ZEND_AST_MAGIC_CONST, T_FUNC_C); }
+	|	T_NS_C		{ $$.ast = zend_ast_create_ex(ZEND_AST_MAGIC_CONST, T_NS_C); }
+	|	T_CLASS_C	{ $$.ast = zend_ast_create_ex(ZEND_AST_MAGIC_CONST, T_CLASS_C); }
+	|	T_START_HEREDOC T_ENCAPSED_AND_WHITESPACE T_END_HEREDOC { $$.ast = $2.ast; }
+	|	T_START_HEREDOC T_END_HEREDOC
+			{ $$.ast = zend_ast_create_zval_from_str(STR_EMPTY_ALLOC()); }
+	|	'"' encaps_list '"' 	{ $$.ast = $2.ast; }
+	|	T_START_HEREDOC encaps_list T_END_HEREDOC { $$.ast = $2.ast; }
+	|	dereferencable_scalar	{ $$.ast = $1.ast; }
+	|	class_name_scalar	{ $$.ast = $1.ast; }
+	|	constant			{ $$.ast = $1.ast; }
+;
+
+constant:
+		name { $$.ast = zend_ast_create(ZEND_AST_CONST, $1.ast); }
+	|	class_name T_PAAMAYIM_NEKUDOTAYIM T_STRING
+			{ $$.ast = zend_ast_create(ZEND_AST_CLASS_CONST, $1.ast, $3.ast); }
+	|	variable_class_name T_PAAMAYIM_NEKUDOTAYIM T_STRING
+			{ $$.ast = zend_ast_create(ZEND_AST_CLASS_CONST, $1.ast, $3.ast); }
 ;
 
 possible_comma:
@@ -1068,232 +983,197 @@ possible_comma:
 	|	','
 ;
 
-non_empty_static_array_pair_list:
-		non_empty_static_array_pair_list ',' static_scalar_value T_DOUBLE_ARROW static_scalar_value { zend_ast_dynamic_add(&$$.u.ast, $3.u.ast); zend_ast_dynamic_add(&$$.u.ast, $5.u.ast); }
-	|	non_empty_static_array_pair_list ',' static_scalar_value { zend_ast_dynamic_add(&$$.u.ast, NULL); zend_ast_dynamic_add(&$$.u.ast, $3.u.ast); }
-	|	static_scalar_value T_DOUBLE_ARROW static_scalar_value { $$.u.ast = zend_ast_create_dynamic(ZEND_INIT_ARRAY); zend_ast_dynamic_add(&$$.u.ast, $1.u.ast); zend_ast_dynamic_add(&$$.u.ast, $3.u.ast); }
-	|	static_scalar_value { $$.u.ast = zend_ast_create_dynamic(ZEND_INIT_ARRAY); zend_ast_dynamic_add(&$$.u.ast, NULL); zend_ast_dynamic_add(&$$.u.ast, $1.u.ast); }
-;
-
 expr:
-		r_variable					{ $$ = $1; }
-	|	expr_without_variable		{ $$ = $1; }
+		variable					{ $$.ast = $1.ast; }
+	|	expr_without_variable		{ $$.ast = $1.ast; }
 ;
 
 parenthesis_expr:
-		'(' expr ')'		{ $$ = $2; }
-	|	'(' yield_expr ')'	{ $$ = $2; }
+		'(' expr ')' { $$.ast = $2.ast; }
 ;
 
-
-r_variable:
-	variable { zend_do_end_variable_parse(&$1, BP_VAR_R, 0 TSRMLS_CC); $$ = $1; }
-;
-
-
-w_variable:
-	variable	{ zend_do_end_variable_parse(&$1, BP_VAR_W, 0 TSRMLS_CC); $$ = $1;
-				  zend_check_writable_variable(&$1); }
-;
-
-rw_variable:
-	variable	{ zend_do_end_variable_parse(&$1, BP_VAR_RW, 0 TSRMLS_CC); $$ = $1;
-				  zend_check_writable_variable(&$1); }
-;
-
-variable:
-		base_variable_with_function_calls T_OBJECT_OPERATOR { zend_do_push_object(&$1 TSRMLS_CC); }
-			object_property { zend_do_push_object(&$4 TSRMLS_CC); } method_or_not variable_properties
-			{ zend_do_pop_object(&$$ TSRMLS_CC); $$.EA = $1.EA | ($7.EA ? $7.EA : $6.EA); }
-	|	base_variable_with_function_calls { $$ = $1; }
-;
-
-variable_properties:
-		variable_properties variable_property { $$.EA = $2.EA; }
-	|	/* empty */ { $$.EA = 0; }
+variable_class_name:
+	dereferencable { $$.ast = $1.ast; }
 ;
 
-
-variable_property:
-		T_OBJECT_OPERATOR object_property { zend_do_push_object(&$2 TSRMLS_CC); } method_or_not { $$.EA = $4.EA; }
+dereferencable:
+		variable				{ $$.ast = $1.ast; }
+	|	'(' expr ')'			{ $$.ast = $2.ast; }
+	|	dereferencable_scalar	{ $$.ast = $1.ast; }
 ;
 
-array_method_dereference:
-		array_method_dereference '[' dim_offset ']' { fetch_array_dim(&$$, &$1, &$3 TSRMLS_CC); }
-	|	method '[' dim_offset ']' { $1.EA = ZEND_PARSED_METHOD_CALL; fetch_array_dim(&$$, &$1, &$3 TSRMLS_CC); }
+callable_expr:
+		callable_variable		{ $$.ast = $1.ast; }
+	|	'(' expr ')'			{ $$.ast = $2.ast; }
+	|	dereferencable_scalar	{ $$.ast = $1.ast; }
 ;
 
-method:
-		{ zend_do_pop_object(&$$ TSRMLS_CC); zend_do_begin_method_call(&$$ TSRMLS_CC); }
-		function_call_parameter_list { zend_do_end_function_call(&$1, &$$, 1, 1 TSRMLS_CC); zend_do_extended_fcall_end(TSRMLS_C); }
+callable_variable:
+		simple_variable
+			{ $$.ast = zend_ast_create(ZEND_AST_VAR, $1.ast); }
+	|	dereferencable '[' dim_offset ']'
+			{ $$.ast = zend_ast_create(ZEND_AST_DIM, $1.ast, $3.ast); }
+	|	constant '[' dim_offset ']'
+			{ $$.ast = zend_ast_create(ZEND_AST_DIM, $1.ast, $3.ast); }
+	|	dereferencable '{' expr '}'
+			{ $$.ast = zend_ast_create(ZEND_AST_DIM, $1.ast, $3.ast); }
+	|	dereferencable T_OBJECT_OPERATOR member_name argument_list
+			{ $$.ast = zend_ast_create(ZEND_AST_METHOD_CALL, $1.ast, $3.ast, $4.ast); }
+	|	function_call { $$.ast = $1.ast; }
 ;
 
-method_or_not:
-		method						{ $$ = $1; $$.EA = ZEND_PARSED_METHOD_CALL; zend_do_push_object(&$$ TSRMLS_CC); }
-	|	array_method_dereference	{ $$ = $1; zend_do_push_object(&$$ TSRMLS_CC); }
-	|	/* empty */ { $$.EA = ZEND_PARSED_MEMBER; }
+variable:
+		callable_variable
+			{ $$.ast = $1.ast; }
+	|	static_member
+			{ $$.ast = $1.ast; }
+	|	dereferencable T_OBJECT_OPERATOR member_name
+			{ $$.ast = zend_ast_create(ZEND_AST_PROP, $1.ast, $3.ast); }
 ;
 
-variable_without_objects:
-		reference_variable { $$ = $1; }
-	|	simple_indirect_reference reference_variable { zend_do_indirect_references(&$$, &$1, &$2 TSRMLS_CC); }
+simple_variable:
+		T_VARIABLE
+			{ $$.ast = $1.ast; }
+	|	'$' '{' expr '}'
+			{ $$.ast = $3.ast; }
+	|	'$' simple_variable
+			{ $$.ast = zend_ast_create(ZEND_AST_VAR, $2.ast); }
 ;
 
 static_member:
-		class_name T_PAAMAYIM_NEKUDOTAYIM variable_without_objects { $$ = $3; zend_do_fetch_static_member(&$$, &$1 TSRMLS_CC); }
-	|	variable_class_name T_PAAMAYIM_NEKUDOTAYIM variable_without_objects { $$ = $3; zend_do_fetch_static_member(&$$, &$1 TSRMLS_CC); }
-
-;
-
-variable_class_name:
-		reference_variable { zend_do_end_variable_parse(&$1, BP_VAR_R, 0 TSRMLS_CC); $$=$1;; }
-;
-
-array_function_dereference:
-		array_function_dereference '[' dim_offset ']' { fetch_array_dim(&$$, &$1, &$3 TSRMLS_CC); }
-	|	function_call { zend_do_begin_variable_parse(TSRMLS_C); $1.EA = ZEND_PARSED_FUNCTION_CALL; }
-		'[' dim_offset ']' { fetch_array_dim(&$$, &$1, &$4 TSRMLS_CC); }
-;
-
-base_variable_with_function_calls:
-		base_variable				{ $$ = $1; }
-	|	array_function_dereference	{ $$ = $1; }
-	|	function_call { zend_do_begin_variable_parse(TSRMLS_C); $$ = $1; $$.EA = ZEND_PARSED_FUNCTION_CALL; }
-;
-
-
-base_variable:
-		reference_variable { $$ = $1; $$.EA = ZEND_PARSED_VARIABLE; }
-	|	simple_indirect_reference reference_variable { zend_do_indirect_references(&$$, &$1, &$2 TSRMLS_CC); $$.EA = ZEND_PARSED_VARIABLE; }
-	|	static_member { $$ = $1; $$.EA = ZEND_PARSED_STATIC_MEMBER; }
-;
-
-reference_variable:
-		reference_variable '[' dim_offset ']'	{ fetch_array_dim(&$$, &$1, &$3 TSRMLS_CC); }
-	|	reference_variable '{' expr '}'		{ fetch_string_offset(&$$, &$1, &$3 TSRMLS_CC); }
-	|	compound_variable			{ zend_do_begin_variable_parse(TSRMLS_C); fetch_simple_variable(&$$, &$1, 1 TSRMLS_CC); }
-;
-
-
-compound_variable:
-		T_VARIABLE			{ $$ = $1; }
-	|	'$' '{' expr '}'	{ $$ = $3; }
+		class_name T_PAAMAYIM_NEKUDOTAYIM simple_variable
+			{ $$.ast = zend_ast_create(ZEND_AST_STATIC_PROP, $1.ast, $3.ast); }
+	|	variable_class_name T_PAAMAYIM_NEKUDOTAYIM simple_variable
+			{ $$.ast = zend_ast_create(ZEND_AST_STATIC_PROP, $1.ast, $3.ast); }
+;
+
+new_variable:
+		simple_variable
+			{ $$.ast = zend_ast_create(ZEND_AST_VAR, $1.ast); }
+	|	new_variable '[' dim_offset ']'
+			{ $$.ast = zend_ast_create(ZEND_AST_DIM, $1.ast, $3.ast); }
+	|	new_variable '{' expr '}'
+			{ $$.ast = zend_ast_create(ZEND_AST_DIM, $1.ast, $3.ast); }
+	|	new_variable T_OBJECT_OPERATOR member_name
+			{ $$.ast = zend_ast_create(ZEND_AST_PROP, $1.ast, $3.ast); }
+	|	class_name T_PAAMAYIM_NEKUDOTAYIM simple_variable
+			{ $$.ast = zend_ast_create(ZEND_AST_STATIC_PROP, $1.ast, $3.ast); }
+	|	new_variable T_PAAMAYIM_NEKUDOTAYIM simple_variable
+			{ $$.ast = zend_ast_create(ZEND_AST_STATIC_PROP, $1.ast, $3.ast); }
 ;
 
 dim_offset:
-		/* empty */		{ $$.op_type = IS_UNUSED; }
-	|	expr			{ $$ = $1; }
+		/* empty */		{ $$.ast = NULL; }
+	|	expr			{ $$.ast = $1.ast; }
 ;
 
-
-object_property:
-		object_dim_list { $$ = $1; }
-	|	variable_without_objects { zend_do_end_variable_parse(&$1, BP_VAR_R, 0 TSRMLS_CC); } { znode tmp_znode;  zend_do_pop_object(&tmp_znode TSRMLS_CC);  zend_do_fetch_property(&$$, &tmp_znode, &$1 TSRMLS_CC);}
-;
-
-object_dim_list:
-		object_dim_list '[' dim_offset ']'	{ fetch_array_dim(&$$, &$1, &$3 TSRMLS_CC); }
-	|	object_dim_list '{' expr '}'		{ fetch_string_offset(&$$, &$1, &$3 TSRMLS_CC); }
-	|	variable_name { znode tmp_znode;  zend_do_pop_object(&tmp_znode TSRMLS_CC);  zend_do_fetch_property(&$$, &tmp_znode, &$1 TSRMLS_CC);}
-;
-
-variable_name:
-		T_STRING		{ $$ = $1; }
-	|	'{' expr '}'	{ $$ = $2; }
-;
-
-simple_indirect_reference:
-		'$' { Z_LVAL($$.u.constant) = 1; }
-	|	simple_indirect_reference '$' { Z_LVAL($$.u.constant)++; }
+member_name:
+		T_STRING		{ $$.ast = $1.ast; }
+	|	'{' expr '}'	{ $$.ast = $2.ast; }
+	|	simple_variable	{ $$.ast = zend_ast_create(ZEND_AST_VAR, $1.ast); }
 ;
 
 assignment_list:
 		assignment_list ',' assignment_list_element
+			{ $$.list = zend_ast_list_add($1.list, $3.ast); }
 	|	assignment_list_element
+			{ $$.list = zend_ast_create_list(1, ZEND_AST_LIST, $1.ast); }
 ;
 
-
 assignment_list_element:
-		variable								{ zend_do_add_list_element(&$1 TSRMLS_CC); }
-	|	T_LIST '(' { zend_do_new_list_begin(TSRMLS_C); } assignment_list ')'	{ zend_do_new_list_end(TSRMLS_C); }
-	|	/* empty */							{ zend_do_add_list_element(NULL TSRMLS_CC); }
+		variable						{ $$.ast = $1.ast; }
+	|	T_LIST '(' assignment_list ')'	{ $$.ast = $3.ast; }
+	|	/* empty */						{ $$.ast = NULL; }
 ;
 
 
 array_pair_list:
-		/* empty */ { zend_do_init_array(&$$, NULL, NULL, 0 TSRMLS_CC); zend_do_end_array(&$$, &$$ TSRMLS_CC); }
-	|	non_empty_array_pair_list possible_comma	{ zend_do_end_array(&$$, &$1 TSRMLS_CC); }
+		/* empty */ { $$.list = zend_ast_create_list(0, ZEND_AST_ARRAY); }
+	|	non_empty_array_pair_list possible_comma { $$.ast = $1.ast; }
 ;
 
 non_empty_array_pair_list:
-		non_empty_array_pair_list ',' expr T_DOUBLE_ARROW expr	{ zend_do_add_array_element(&$$, &$5, &$3, 0 TSRMLS_CC); }
-	|	non_empty_array_pair_list ',' expr			{ zend_do_add_array_element(&$$, &$3, NULL, 0 TSRMLS_CC); }
-	|	expr T_DOUBLE_ARROW expr	{ zend_do_init_array(&$$, &$3, &$1, 0 TSRMLS_CC); }
-	|	expr 				{ zend_do_init_array(&$$, &$1, NULL, 0 TSRMLS_CC); }
-	|	non_empty_array_pair_list ',' expr T_DOUBLE_ARROW '&' w_variable { zend_do_add_array_element(&$$, &$6, &$3, 1 TSRMLS_CC); }
-	|	non_empty_array_pair_list ',' '&' w_variable { zend_do_add_array_element(&$$, &$4, NULL, 1 TSRMLS_CC); }
-	|	expr T_DOUBLE_ARROW '&' w_variable	{ zend_do_init_array(&$$, &$4, &$1, 1 TSRMLS_CC); }
-	|	'&' w_variable 			{ zend_do_init_array(&$$, &$2, NULL, 1 TSRMLS_CC); }
+		non_empty_array_pair_list ',' array_pair
+			{ $$.list = zend_ast_list_add($1.list, $3.ast); }
+	|	array_pair
+			{ $$.list = zend_ast_create_list(1, ZEND_AST_ARRAY, $1.ast); }
 ;
 
-encaps_list:
-		encaps_list encaps_var { zend_do_end_variable_parse(&$2, BP_VAR_R, 0 TSRMLS_CC);  zend_do_add_variable(&$$, &$1, &$2 TSRMLS_CC); }
-	|	encaps_list T_ENCAPSED_AND_WHITESPACE	{ zend_do_add_string(&$$, &$1, &$2 TSRMLS_CC); }
-	|	encaps_var { zend_do_end_variable_parse(&$1, BP_VAR_R, 0 TSRMLS_CC); zend_do_add_variable(&$$, NULL, &$1 TSRMLS_CC); }
-	|	T_ENCAPSED_AND_WHITESPACE encaps_var	{ zend_do_add_string(&$$, NULL, &$1 TSRMLS_CC); zend_do_end_variable_parse(&$2, BP_VAR_R, 0 TSRMLS_CC); zend_do_add_variable(&$$, &$$, &$2 TSRMLS_CC); }
+array_pair:
+		expr T_DOUBLE_ARROW expr
+			{ $$.ast = zend_ast_create(ZEND_AST_ARRAY_ELEM, $3.ast, $1.ast); }
+	|	expr { $$.ast = zend_ast_create(ZEND_AST_ARRAY_ELEM, $1.ast, NULL); }
+	|	expr T_DOUBLE_ARROW '&' variable
+			{ $$.ast = zend_ast_create_ex(ZEND_AST_ARRAY_ELEM, 1, $4.ast, $1.ast); }
+	|	'&' variable
+			{ $$.ast = zend_ast_create_ex(ZEND_AST_ARRAY_ELEM, 1, $2.ast, NULL); }
 ;
 
-
+encaps_list:
+		encaps_list encaps_var
+			{ $$.list = zend_ast_list_add($1.list, $2.ast); }
+	|	encaps_list T_ENCAPSED_AND_WHITESPACE
+			{ $$.list = zend_ast_list_add($1.list, $2.ast); }
+	|	encaps_var
+			{ $$.list = zend_ast_create_list(1, ZEND_AST_ENCAPS_LIST, $1.ast); }
+	|	T_ENCAPSED_AND_WHITESPACE encaps_var
+			{ $$.list = zend_ast_create_list(2, ZEND_AST_ENCAPS_LIST, $1.ast, $2.ast); }
+;
 
 encaps_var:
-		T_VARIABLE { zend_do_begin_variable_parse(TSRMLS_C); fetch_simple_variable(&$$, &$1, 1 TSRMLS_CC); }
-	|	T_VARIABLE '[' { zend_do_begin_variable_parse(TSRMLS_C); } encaps_var_offset ']'	{ fetch_array_begin(&$$, &$1, &$4 TSRMLS_CC); }
-	|	T_VARIABLE T_OBJECT_OPERATOR T_STRING { zend_do_begin_variable_parse(TSRMLS_C); fetch_simple_variable(&$2, &$1, 1 TSRMLS_CC); zend_do_fetch_property(&$$, &$2, &$3 TSRMLS_CC); }
-	|	T_DOLLAR_OPEN_CURLY_BRACES expr '}' { zend_do_begin_variable_parse(TSRMLS_C);  fetch_simple_variable(&$$, &$2, 1 TSRMLS_CC); }
-	|	T_DOLLAR_OPEN_CURLY_BRACES T_STRING_VARNAME '[' expr ']' '}' { zend_do_begin_variable_parse(TSRMLS_C);  fetch_array_begin(&$$, &$2, &$4 TSRMLS_CC); }
-	|	T_CURLY_OPEN variable '}' { $$ = $2; }
+		T_VARIABLE
+			{ $$.ast = zend_ast_create(ZEND_AST_VAR, $1.ast); }
+	|	T_VARIABLE '[' encaps_var_offset ']'
+			{ $$.ast = zend_ast_create(ZEND_AST_DIM,
+			      zend_ast_create(ZEND_AST_VAR, $1.ast), $3.ast); }
+	|	T_VARIABLE T_OBJECT_OPERATOR T_STRING
+			{ $$.ast = zend_ast_create(ZEND_AST_PROP,
+			      zend_ast_create(ZEND_AST_VAR, $1.ast), $3.ast); }
+	|	T_DOLLAR_OPEN_CURLY_BRACES expr '}'
+			{ $$.ast = zend_ast_create(ZEND_AST_VAR, $2.ast); }
+	|	T_DOLLAR_OPEN_CURLY_BRACES T_STRING_VARNAME '}'
+			{ $$.ast = zend_ast_create(ZEND_AST_VAR, $2.ast); }
+	|	T_DOLLAR_OPEN_CURLY_BRACES T_STRING_VARNAME '[' expr ']' '}'
+			{ $$.ast = zend_ast_create(ZEND_AST_DIM,
+			      zend_ast_create(ZEND_AST_VAR, $2.ast), $4.ast); }
+	|	T_CURLY_OPEN variable '}' { $$.ast = $2.ast; }
 ;
 
-
 encaps_var_offset:
-		T_STRING		{ $$ = $1; }
-	|	T_NUM_STRING	{ $$ = $1; }
-	|	T_VARIABLE		{ fetch_simple_variable(&$$, &$1, 1 TSRMLS_CC); }
+		T_STRING		{ $$.ast = $1.ast; }
+	|	T_NUM_STRING	{ $$.ast = $1.ast; }
+	|	T_VARIABLE		{ $$.ast = zend_ast_create(ZEND_AST_VAR, $1.ast); }
 ;
 
 
 internal_functions_in_yacc:
-		T_ISSET '(' isset_variables ')' { $$ = $3; }
-	|	T_EMPTY '(' variable ')'	{ zend_do_isset_or_isempty(ZEND_ISEMPTY, &$$, &$3 TSRMLS_CC); }
-	|	T_EMPTY '(' expr_without_variable ')' { zend_do_unary_op(ZEND_BOOL_NOT, &$$, &$3 TSRMLS_CC); }
-	|	T_INCLUDE expr 			{ zend_do_include_or_eval(ZEND_INCLUDE, &$$, &$2 TSRMLS_CC); }
-	|	T_INCLUDE_ONCE expr 	{ zend_do_include_or_eval(ZEND_INCLUDE_ONCE, &$$, &$2 TSRMLS_CC); }
-	|	T_EVAL '(' expr ')' 	{ zend_do_include_or_eval(ZEND_EVAL, &$$, &$3 TSRMLS_CC); }
-	|	T_REQUIRE expr			{ zend_do_include_or_eval(ZEND_REQUIRE, &$$, &$2 TSRMLS_CC); }
-	|	T_REQUIRE_ONCE expr		{ zend_do_include_or_eval(ZEND_REQUIRE_ONCE, &$$, &$2 TSRMLS_CC); }
+		T_ISSET '(' isset_variables ')' { $$.ast  = $3.ast; }
+	|	T_EMPTY '(' expr ')' { $$.ast = zend_ast_create(ZEND_AST_EMPTY, $3.ast); }
+	|	T_INCLUDE expr
+			{ $$.ast = zend_ast_create_ex(ZEND_AST_INCLUDE_OR_EVAL, ZEND_INCLUDE, $2.ast); }
+	|	T_INCLUDE_ONCE expr
+			{ $$.ast = zend_ast_create_ex(ZEND_AST_INCLUDE_OR_EVAL, ZEND_INCLUDE_ONCE, $2.ast); }
+	|	T_EVAL '(' expr ')'
+			{ $$.ast = zend_ast_create_ex(ZEND_AST_INCLUDE_OR_EVAL, ZEND_EVAL, $3.ast); }
+	|	T_REQUIRE expr
+			{ $$.ast = zend_ast_create_ex(ZEND_AST_INCLUDE_OR_EVAL, ZEND_REQUIRE, $2.ast); }
+	|	T_REQUIRE_ONCE expr
+			{ $$.ast = zend_ast_create_ex(ZEND_AST_INCLUDE_OR_EVAL, ZEND_REQUIRE_ONCE, $2.ast); }
 ;
 
 isset_variables:
-		isset_variable			{ $$ = $1; }
-	|	isset_variables ',' { zend_do_boolean_and_begin(&$1, &$2 TSRMLS_CC); } isset_variable { zend_do_boolean_and_end(&$$, &$1, &$4, &$2 TSRMLS_CC); }
+		isset_variable { $$.ast = $1.ast; }
+	|	isset_variables ',' isset_variable
+			{ $$.ast = zend_ast_create(ZEND_AST_AND, $1.ast, $3.ast); }
 ;
 
 isset_variable:
-		variable				{ zend_do_isset_or_isempty(ZEND_ISSET, &$$, &$1 TSRMLS_CC); }
-	|	expr_without_variable	{ zend_error_noreturn(E_COMPILE_ERROR, "Cannot use isset() on the result of an expression (you can use \"null !== expression\" instead)"); }
-;
-
-class_constant:
-		class_name T_PAAMAYIM_NEKUDOTAYIM T_STRING { zend_do_fetch_constant(&$$, &$1, &$3, ZEND_RT, 0 TSRMLS_CC); }
-	|	variable_class_name T_PAAMAYIM_NEKUDOTAYIM T_STRING { zend_do_fetch_constant(&$$, &$1, &$3, ZEND_RT, 0 TSRMLS_CC); }
-;
-
-static_class_name_scalar:
-	class_name T_PAAMAYIM_NEKUDOTAYIM T_CLASS { zend_do_resolve_class_name(&$$, &$1, 1 TSRMLS_CC); }
+		expr { $$.ast = zend_ast_create(ZEND_AST_ISSET, $1.ast); }
 ;
 
 class_name_scalar:
-	class_name T_PAAMAYIM_NEKUDOTAYIM T_CLASS { zend_do_resolve_class_name(&$$, &$1, 0 TSRMLS_CC); }
+	class_name T_PAAMAYIM_NEKUDOTAYIM T_CLASS
+		{ $$.ast = zend_ast_create(ZEND_AST_RESOLVE_CLASS_NAME, $1.ast); }
 ;
 
 %%
diff --git a/Zend/zend_language_scanner.c b/Zend/zend_language_scanner.c
index 3b10615513..90fe7c4597 100644
--- a/Zend/zend_language_scanner.c
+++ b/Zend/zend_language_scanner.c
@@ -561,11 +561,10 @@ ZEND_API zend_op_array *compile_file(zend_file_handle *file_handle, int type TSR
 	zend_op_array *retval=NULL;
 	int compiler_result;
 	zend_bool compilation_successful=0;
-	znode retval_znode;
+	zval retval_zv;
 	zend_bool original_in_compilation = CG(in_compilation);
 
-	retval_znode.op_type = IS_CONST;
-	ZVAL_LONG(&retval_znode.u.constant, 1);
+	ZVAL_LONG(&retval_zv, 1);
 
 	zend_save_lexical_state(&original_lex_state TSRMLS_CC);
 
@@ -585,12 +584,17 @@ ZEND_API zend_op_array *compile_file(zend_file_handle *file_handle, int type TSR
 		CG(active_op_array) = op_array;
 		zend_stack_push(&CG(context_stack), (void *) &CG(context));
 		zend_init_compiler_context(TSRMLS_C);
+		CG(ast_arena) = zend_arena_create(1024 * 32);
 		compiler_result = zendparse(TSRMLS_C);
-		zend_do_return(&retval_znode, 0 TSRMLS_CC);
-		CG(in_compilation) = original_in_compilation;
 		if (compiler_result != 0) { /* parser error */
 			zend_bailout();
 		}
+		zend_compile_top_stmt(CG(ast) TSRMLS_CC);
+		zend_ast_destroy(CG(ast));
+		zend_arena_destroy(CG(ast_arena));
+		zend_do_end_compilation(TSRMLS_C);
+		zend_emit_final_return(&retval_zv TSRMLS_CC);
+		CG(in_compilation) = original_in_compilation;
 		compilation_successful=1;
 	}
 
@@ -752,6 +756,7 @@ zend_op_array *compile_string(zval *source_string, char *filename TSRMLS_DC)
 		zend_stack_push(&CG(context_stack), (void *) &CG(context));
 		zend_init_compiler_context(TSRMLS_C);
 		BEGIN(ST_IN_SCRIPTING);
+		CG(ast_arena) = zend_arena_create(1024 * 32);
 		compiler_result = zendparse(TSRMLS_C);
 
 		if (SCNG(script_filtered)) {
@@ -766,7 +771,11 @@ zend_op_array *compile_string(zval *source_string, char *filename TSRMLS_DC)
 			efree(op_array);
 			retval = NULL;
 		} else {
-			zend_do_return(NULL, 0 TSRMLS_CC);
+			zend_compile_top_stmt(CG(ast) TSRMLS_CC);
+			zend_ast_destroy(CG(ast));
+			zend_arena_destroy(CG(ast_arena));
+			zend_do_end_compilation(TSRMLS_C);
+			zend_emit_final_return(NULL TSRMLS_CC);
 			CG(active_op_array) = original_active_op_array;
 			pass_two(op_array TSRMLS_CC);
 			zend_release_labels(0 TSRMLS_CC);
@@ -876,15 +885,6 @@ ZEND_API void zend_multibyte_yyinput_again(zend_encoding_filter old_input_filter
 		ZVAL_STRINGL(zendlval, yytext, yyleng); \
 	}
 
-// TODO: some extensions might need content, but we don't copy it intentional ???
-#if 0
-# define DUMMY_STRINGL(zendlval, yytext, yyleng) \
-	ZVAL_STRINGL(zendlval, yytext, yyleng)
-#else
-# define DUMMY_STRINGL(zendlval, yytext, yyleng) \
-	ZVAL_EMPTY_STRING(zendlval)
-#endif
-
 static void zend_scan_escape_string(zval *zendlval, char *str, int len, char quote_type TSRMLS_DC)
 {
 	register char *s, *t;
@@ -1115,7 +1115,7 @@ yyc_INITIAL:
 yy3:
 		YYDEBUG(3, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1779 "Zend/zend_language_scanner.l"
+#line 1714 "Zend/zend_language_scanner.l"
 		{
 	if (YYCURSOR > YYLIMIT) {
 		return 0;
@@ -1194,34 +1194,32 @@ yy5:
 yy6:
 		YYDEBUG(6, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1769 "Zend/zend_language_scanner.l"
+#line 1705 "Zend/zend_language_scanner.l"
 		{
 	if (CG(short_tags)) {
-		DUMMY_STRINGL(zendlval, yytext, yyleng);
 		BEGIN(ST_IN_SCRIPTING);
 		return T_OPEN_TAG;
 	} else {
 		goto inline_char_handler;
 	}
 }
-#line 1208 "Zend/zend_language_scanner.c"
+#line 1207 "Zend/zend_language_scanner.c"
 yy7:
 		YYDEBUG(7, *YYCURSOR);
 		++YYCURSOR;
 		if ((yych = *YYCURSOR) == '=') goto yy43;
 		YYDEBUG(8, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1750 "Zend/zend_language_scanner.l"
+#line 1688 "Zend/zend_language_scanner.l"
 		{
 	if (CG(asp_tags)) {
-		DUMMY_STRINGL(zendlval, yytext, yyleng);
 		BEGIN(ST_IN_SCRIPTING);
 		return T_OPEN_TAG;
 	} else {
 		goto inline_char_handler;
 	}
 }
-#line 1225 "Zend/zend_language_scanner.c"
+#line 1223 "Zend/zend_language_scanner.c"
 yy9:
 		YYDEBUG(9, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -1407,7 +1405,7 @@ yy35:
 		++YYCURSOR;
 		YYDEBUG(38, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1716 "Zend/zend_language_scanner.l"
+#line 1657 "Zend/zend_language_scanner.l"
 		{
 	YYCTYPE *bracket = (YYCTYPE*)zend_memrchr(yytext, '<', yyleng - (sizeof("script language=php>") - 1));
 
@@ -1418,11 +1416,10 @@ yy35:
 	}
 
 	HANDLE_NEWLINES(yytext, yyleng);
-	DUMMY_STRINGL(zendlval, yytext, yyleng);
 	BEGIN(ST_IN_SCRIPTING);
 	return T_OPEN_TAG;
 }
-#line 1426 "Zend/zend_language_scanner.c"
+#line 1423 "Zend/zend_language_scanner.c"
 yy39:
 		YYDEBUG(39, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -1449,29 +1446,27 @@ yy43:
 		++YYCURSOR;
 		YYDEBUG(44, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1732 "Zend/zend_language_scanner.l"
+#line 1672 "Zend/zend_language_scanner.l"
 		{
 	if (CG(asp_tags)) {
-		DUMMY_STRINGL(zendlval, yytext, yyleng);
 		BEGIN(ST_IN_SCRIPTING);
 		return T_OPEN_TAG_WITH_ECHO;
 	} else {
 		goto inline_char_handler;
 	}
 }
-#line 1463 "Zend/zend_language_scanner.c"
+#line 1459 "Zend/zend_language_scanner.c"
 yy45:
 		YYDEBUG(45, *YYCURSOR);
 		++YYCURSOR;
 		YYDEBUG(46, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1743 "Zend/zend_language_scanner.l"
+#line 1682 "Zend/zend_language_scanner.l"
 		{
-	DUMMY_STRINGL(zendlval, yytext, yyleng);
 	BEGIN(ST_IN_SCRIPTING);
 	return T_OPEN_TAG_WITH_ECHO;
 }
-#line 1475 "Zend/zend_language_scanner.c"
+#line 1470 "Zend/zend_language_scanner.c"
 yy47:
 		YYDEBUG(47, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -1498,14 +1493,13 @@ yy50:
 yy51:
 		YYDEBUG(51, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1761 "Zend/zend_language_scanner.l"
+#line 1698 "Zend/zend_language_scanner.l"
 		{
-	DUMMY_STRINGL(zendlval, yytext, yyleng);
 	HANDLE_NEWLINE(yytext[yyleng-1]);
 	BEGIN(ST_IN_SCRIPTING);
 	return T_OPEN_TAG;
 }
-#line 1509 "Zend/zend_language_scanner.c"
+#line 1503 "Zend/zend_language_scanner.c"
 yy52:
 		YYDEBUG(52, *YYCURSOR);
 		++YYCURSOR;
@@ -1576,7 +1570,7 @@ yyc_ST_BACKQUOTE:
 yy56:
 		YYDEBUG(56, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 2222 "Zend/zend_language_scanner.l"
+#line 2155 "Zend/zend_language_scanner.l"
 		{
 	if (YYCURSOR > YYLIMIT) {
 		return 0;
@@ -1617,7 +1611,7 @@ yy56:
 	zend_scan_escape_string(zendlval, yytext, yyleng, '`' TSRMLS_CC);
 	return T_ENCAPSED_AND_WHITESPACE;
 }
-#line 1621 "Zend/zend_language_scanner.c"
+#line 1615 "Zend/zend_language_scanner.c"
 yy57:
 		YYDEBUG(57, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -1628,12 +1622,12 @@ yy58:
 		++YYCURSOR;
 		YYDEBUG(59, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 2166 "Zend/zend_language_scanner.l"
+#line 2099 "Zend/zend_language_scanner.l"
 		{
 	BEGIN(ST_IN_SCRIPTING);
 	return '`';
 }
-#line 1637 "Zend/zend_language_scanner.c"
+#line 1631 "Zend/zend_language_scanner.c"
 yy60:
 		YYDEBUG(60, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -1643,14 +1637,14 @@ yy61:
 		++YYCURSOR;
 		YYDEBUG(62, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 2153 "Zend/zend_language_scanner.l"
+#line 2086 "Zend/zend_language_scanner.l"
 		{
 	Z_LVAL_P(zendlval) = (zend_long) '{';
 	yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
 	yyless(1);
 	return T_CURLY_OPEN;
 }
-#line 1654 "Zend/zend_language_scanner.c"
+#line 1648 "Zend/zend_language_scanner.c"
 yy63:
 		YYDEBUG(63, *YYCURSOR);
 		yyaccept = 0;
@@ -1666,23 +1660,23 @@ yy63:
 yy65:
 		YYDEBUG(65, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1860 "Zend/zend_language_scanner.l"
+#line 1795 "Zend/zend_language_scanner.l"
 		{
 	zend_copy_value(zendlval, (yytext+1), (yyleng-1));
 	return T_VARIABLE;
 }
-#line 1675 "Zend/zend_language_scanner.c"
+#line 1669 "Zend/zend_language_scanner.c"
 yy66:
 		YYDEBUG(66, *YYCURSOR);
 		++YYCURSOR;
 		YYDEBUG(67, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1483 "Zend/zend_language_scanner.l"
+#line 1482 "Zend/zend_language_scanner.l"
 		{
 	yy_push_state(ST_LOOKING_FOR_VARNAME TSRMLS_CC);
 	return T_DOLLAR_OPEN_CURLY_BRACES;
 }
-#line 1686 "Zend/zend_language_scanner.c"
+#line 1680 "Zend/zend_language_scanner.c"
 yy68:
 		YYDEBUG(68, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -1696,14 +1690,14 @@ yy70:
 		++YYCURSOR;
 		YYDEBUG(71, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1853 "Zend/zend_language_scanner.l"
+#line 1788 "Zend/zend_language_scanner.l"
 		{
 	yyless(yyleng - 1);
 	yy_push_state(ST_VAR_OFFSET TSRMLS_CC);
 	zend_copy_value(zendlval, (yytext+1), (yyleng-1));
 	return T_VARIABLE;
 }
-#line 1707 "Zend/zend_language_scanner.c"
+#line 1701 "Zend/zend_language_scanner.c"
 yy72:
 		YYDEBUG(72, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -1721,14 +1715,14 @@ yy73:
 		++YYCURSOR;
 		YYDEBUG(74, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1844 "Zend/zend_language_scanner.l"
+#line 1779 "Zend/zend_language_scanner.l"
 		{
 	yyless(yyleng - 3);
 	yy_push_state(ST_LOOKING_FOR_PROPERTY TSRMLS_CC);
 	zend_copy_value(zendlval, (yytext+1), (yyleng-1));
 	return T_VARIABLE;
 }
-#line 1732 "Zend/zend_language_scanner.c"
+#line 1726 "Zend/zend_language_scanner.c"
 	}
 /* *********************************** */
 yyc_ST_DOUBLE_QUOTES:
@@ -1796,7 +1790,7 @@ yy77:
 yy78:
 		YYDEBUG(78, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 2172 "Zend/zend_language_scanner.l"
+#line 2105 "Zend/zend_language_scanner.l"
 		{
 	if (GET_DOUBLE_QUOTES_SCANNED_LENGTH()) {
 		YYCURSOR += GET_DOUBLE_QUOTES_SCANNED_LENGTH() - 1;
@@ -1845,7 +1839,7 @@ double_quotes_scan_done:
 	zend_scan_escape_string(zendlval, yytext, yyleng, '"' TSRMLS_CC);
 	return T_ENCAPSED_AND_WHITESPACE;
 }
-#line 1849 "Zend/zend_language_scanner.c"
+#line 1843 "Zend/zend_language_scanner.c"
 yy79:
 		YYDEBUG(79, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -1856,12 +1850,12 @@ yy80:
 		++YYCURSOR;
 		YYDEBUG(81, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 2161 "Zend/zend_language_scanner.l"
+#line 2094 "Zend/zend_language_scanner.l"
 		{
 	BEGIN(ST_IN_SCRIPTING);
 	return '"';
 }
-#line 1865 "Zend/zend_language_scanner.c"
+#line 1859 "Zend/zend_language_scanner.c"
 yy82:
 		YYDEBUG(82, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -1871,14 +1865,14 @@ yy83:
 		++YYCURSOR;
 		YYDEBUG(84, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 2153 "Zend/zend_language_scanner.l"
+#line 2086 "Zend/zend_language_scanner.l"
 		{
 	Z_LVAL_P(zendlval) = (zend_long) '{';
 	yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
 	yyless(1);
 	return T_CURLY_OPEN;
 }
-#line 1882 "Zend/zend_language_scanner.c"
+#line 1876 "Zend/zend_language_scanner.c"
 yy85:
 		YYDEBUG(85, *YYCURSOR);
 		yyaccept = 0;
@@ -1894,23 +1888,23 @@ yy85:
 yy87:
 		YYDEBUG(87, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1860 "Zend/zend_language_scanner.l"
+#line 1795 "Zend/zend_language_scanner.l"
 		{
 	zend_copy_value(zendlval, (yytext+1), (yyleng-1));
 	return T_VARIABLE;
 }
-#line 1903 "Zend/zend_language_scanner.c"
+#line 1897 "Zend/zend_language_scanner.c"
 yy88:
 		YYDEBUG(88, *YYCURSOR);
 		++YYCURSOR;
 		YYDEBUG(89, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1483 "Zend/zend_language_scanner.l"
+#line 1482 "Zend/zend_language_scanner.l"
 		{
 	yy_push_state(ST_LOOKING_FOR_VARNAME TSRMLS_CC);
 	return T_DOLLAR_OPEN_CURLY_BRACES;
 }
-#line 1914 "Zend/zend_language_scanner.c"
+#line 1908 "Zend/zend_language_scanner.c"
 yy90:
 		YYDEBUG(90, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -1924,14 +1918,14 @@ yy92:
 		++YYCURSOR;
 		YYDEBUG(93, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1853 "Zend/zend_language_scanner.l"
+#line 1788 "Zend/zend_language_scanner.l"
 		{
 	yyless(yyleng - 1);
 	yy_push_state(ST_VAR_OFFSET TSRMLS_CC);
 	zend_copy_value(zendlval, (yytext+1), (yyleng-1));
 	return T_VARIABLE;
 }
-#line 1935 "Zend/zend_language_scanner.c"
+#line 1929 "Zend/zend_language_scanner.c"
 yy94:
 		YYDEBUG(94, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -1949,14 +1943,14 @@ yy95:
 		++YYCURSOR;
 		YYDEBUG(96, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1844 "Zend/zend_language_scanner.l"
+#line 1779 "Zend/zend_language_scanner.l"
 		{
 	yyless(yyleng - 3);
 	yy_push_state(ST_LOOKING_FOR_PROPERTY TSRMLS_CC);
 	zend_copy_value(zendlval, (yytext+1), (yyleng-1));
 	return T_VARIABLE;
 }
-#line 1960 "Zend/zend_language_scanner.c"
+#line 1954 "Zend/zend_language_scanner.c"
 	}
 /* *********************************** */
 yyc_ST_END_HEREDOC:
@@ -1967,7 +1961,7 @@ yyc_ST_END_HEREDOC:
 	++YYCURSOR;
 	YYDEBUG(100, *YYCURSOR);
 	yyleng = YYCURSOR - SCNG(yy_text);
-#line 2139 "Zend/zend_language_scanner.l"
+#line 2072 "Zend/zend_language_scanner.l"
 	{
 	zend_heredoc_label *heredoc_label = zend_ptr_stack_pop(&SCNG(heredoc_label_stack));
 
@@ -1980,7 +1974,7 @@ yyc_ST_END_HEREDOC:
 	BEGIN(ST_IN_SCRIPTING);
 	return T_END_HEREDOC;
 }
-#line 1984 "Zend/zend_language_scanner.c"
+#line 1978 "Zend/zend_language_scanner.c"
 /* *********************************** */
 yyc_ST_HEREDOC:
 	{
@@ -2042,7 +2036,7 @@ yy103:
 yy104:
 		YYDEBUG(104, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 2264 "Zend/zend_language_scanner.l"
+#line 2197 "Zend/zend_language_scanner.l"
 		{
 	int newline = 0;
 
@@ -2115,7 +2109,7 @@ heredoc_scan_done:
 	zend_scan_escape_string(zendlval, yytext, yyleng - newline, 0 TSRMLS_CC);
 	return T_ENCAPSED_AND_WHITESPACE;
 }
-#line 2119 "Zend/zend_language_scanner.c"
+#line 2113 "Zend/zend_language_scanner.c"
 yy105:
 		YYDEBUG(105, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -2130,14 +2124,14 @@ yy107:
 		++YYCURSOR;
 		YYDEBUG(108, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 2153 "Zend/zend_language_scanner.l"
+#line 2086 "Zend/zend_language_scanner.l"
 		{
 	Z_LVAL_P(zendlval) = (zend_long) '{';
 	yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
 	yyless(1);
 	return T_CURLY_OPEN;
 }
-#line 2141 "Zend/zend_language_scanner.c"
+#line 2135 "Zend/zend_language_scanner.c"
 yy109:
 		YYDEBUG(109, *YYCURSOR);
 		yyaccept = 0;
@@ -2153,23 +2147,23 @@ yy109:
 yy111:
 		YYDEBUG(111, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1860 "Zend/zend_language_scanner.l"
+#line 1795 "Zend/zend_language_scanner.l"
 		{
 	zend_copy_value(zendlval, (yytext+1), (yyleng-1));
 	return T_VARIABLE;
 }
-#line 2162 "Zend/zend_language_scanner.c"
+#line 2156 "Zend/zend_language_scanner.c"
 yy112:
 		YYDEBUG(112, *YYCURSOR);
 		++YYCURSOR;
 		YYDEBUG(113, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1483 "Zend/zend_language_scanner.l"
+#line 1482 "Zend/zend_language_scanner.l"
 		{
 	yy_push_state(ST_LOOKING_FOR_VARNAME TSRMLS_CC);
 	return T_DOLLAR_OPEN_CURLY_BRACES;
 }
-#line 2173 "Zend/zend_language_scanner.c"
+#line 2167 "Zend/zend_language_scanner.c"
 yy114:
 		YYDEBUG(114, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -2183,14 +2177,14 @@ yy116:
 		++YYCURSOR;
 		YYDEBUG(117, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1853 "Zend/zend_language_scanner.l"
+#line 1788 "Zend/zend_language_scanner.l"
 		{
 	yyless(yyleng - 1);
 	yy_push_state(ST_VAR_OFFSET TSRMLS_CC);
 	zend_copy_value(zendlval, (yytext+1), (yyleng-1));
 	return T_VARIABLE;
 }
-#line 2194 "Zend/zend_language_scanner.c"
+#line 2188 "Zend/zend_language_scanner.c"
 yy118:
 		YYDEBUG(118, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -2208,14 +2202,14 @@ yy119:
 		++YYCURSOR;
 		YYDEBUG(120, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1844 "Zend/zend_language_scanner.l"
+#line 1779 "Zend/zend_language_scanner.l"
 		{
 	yyless(yyleng - 3);
 	yy_push_state(ST_LOOKING_FOR_PROPERTY TSRMLS_CC);
 	zend_copy_value(zendlval, (yytext+1), (yyleng-1));
 	return T_VARIABLE;
 }
-#line 2219 "Zend/zend_language_scanner.c"
+#line 2213 "Zend/zend_language_scanner.c"
 	}
 /* *********************************** */
 yyc_ST_IN_SCRIPTING:
@@ -2398,12 +2392,12 @@ yy123:
 yy124:
 		YYDEBUG(124, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1882 "Zend/zend_language_scanner.l"
+#line 1817 "Zend/zend_language_scanner.l"
 		{
 	zend_copy_value(zendlval, yytext, yyleng);
 	return T_STRING;
 }
-#line 2407 "Zend/zend_language_scanner.c"
+#line 2401 "Zend/zend_language_scanner.c"
 yy125:
 		YYDEBUG(125, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -2635,11 +2629,11 @@ yy138:
 yy139:
 		YYDEBUG(139, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1472 "Zend/zend_language_scanner.l"
+#line 1471 "Zend/zend_language_scanner.l"
 		{
 	return yytext[0];
 }
-#line 2643 "Zend/zend_language_scanner.c"
+#line 2637 "Zend/zend_language_scanner.c"
 yy140:
 		YYDEBUG(140, *YYCURSOR);
 		++YYCURSOR;
@@ -2650,11 +2644,10 @@ yy141:
 		yyleng = YYCURSOR - SCNG(yy_text);
 #line 1194 "Zend/zend_language_scanner.l"
 		{
-	DUMMY_STRINGL(zendlval, yytext, yyleng);
 	HANDLE_NEWLINES(yytext, yyleng);
 	return T_WHITESPACE;
 }
-#line 2658 "Zend/zend_language_scanner.c"
+#line 2651 "Zend/zend_language_scanner.c"
 yy142:
 		YYDEBUG(142, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -2665,11 +2658,11 @@ yy143:
 		++YYCURSOR;
 		YYDEBUG(144, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1220 "Zend/zend_language_scanner.l"
+#line 1219 "Zend/zend_language_scanner.l"
 		{
 	return T_NS_SEPARATOR;
 }
-#line 2673 "Zend/zend_language_scanner.c"
+#line 2666 "Zend/zend_language_scanner.c"
 yy145:
 		YYDEBUG(145, *YYCURSOR);
 		yyaccept = 1;
@@ -2903,18 +2896,18 @@ yy168:
 		++YYCURSOR;
 		YYDEBUG(169, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1477 "Zend/zend_language_scanner.l"
+#line 1476 "Zend/zend_language_scanner.l"
 		{
 	yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
 	return '{';
 }
-#line 2912 "Zend/zend_language_scanner.c"
+#line 2905 "Zend/zend_language_scanner.c"
 yy170:
 		YYDEBUG(170, *YYCURSOR);
 		++YYCURSOR;
 		YYDEBUG(171, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1489 "Zend/zend_language_scanner.l"
+#line 1488 "Zend/zend_language_scanner.l"
 		{
 	RESET_DOC_COMMENT();
 	if (!zend_stack_is_empty(&SCNG(state_stack))) {
@@ -2922,7 +2915,7 @@ yy170:
 	}
 	return '}';
 }
-#line 2926 "Zend/zend_language_scanner.c"
+#line 2919 "Zend/zend_language_scanner.c"
 yy172:
 		YYDEBUG(172, *YYCURSOR);
 		yyaccept = 2;
@@ -2950,7 +2943,7 @@ yy172:
 yy173:
 		YYDEBUG(173, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1537 "Zend/zend_language_scanner.l"
+#line 1536 "Zend/zend_language_scanner.l"
 		{
 	if (yyleng < MAX_LENGTH_OF_LONG - 1) { /* Won't overflow */
 		ZVAL_LONG(zendlval, ZEND_STRTOL(yytext, NULL, 0));
@@ -2968,7 +2961,7 @@ yy173:
 	}
 	return T_LNUMBER;
 }
-#line 2972 "Zend/zend_language_scanner.c"
+#line 2965 "Zend/zend_language_scanner.c"
 yy174:
 		YYDEBUG(174, *YYCURSOR);
 		yyaccept = 2;
@@ -2996,7 +2989,7 @@ yy176:
 yy177:
 		YYDEBUG(177, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1888 "Zend/zend_language_scanner.l"
+#line 1823 "Zend/zend_language_scanner.l"
 		{
 	while (YYCURSOR < YYLIMIT) {
 		switch (*YYCURSOR++) {
@@ -3030,14 +3023,14 @@ yy177:
 
 	return T_COMMENT;
 }
-#line 3034 "Zend/zend_language_scanner.c"
+#line 3027 "Zend/zend_language_scanner.c"
 yy178:
 		YYDEBUG(178, *YYCURSOR);
 		++YYCURSOR;
 yy179:
 		YYDEBUG(179, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1974 "Zend/zend_language_scanner.l"
+#line 1907 "Zend/zend_language_scanner.l"
 		{
 	register char *s, *t;
 	char *end;
@@ -3105,14 +3098,14 @@ yy179:
 	}
 	return T_CONSTANT_ENCAPSED_STRING;
 }
-#line 3109 "Zend/zend_language_scanner.c"
+#line 3102 "Zend/zend_language_scanner.c"
 yy180:
 		YYDEBUG(180, *YYCURSOR);
 		++YYCURSOR;
 yy181:
 		YYDEBUG(181, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 2043 "Zend/zend_language_scanner.l"
+#line 1976 "Zend/zend_language_scanner.l"
 		{
 	int bprefix = (yytext[0] != '"') ? 1 : 0;
 
@@ -3153,24 +3146,24 @@ yy181:
 	BEGIN(ST_DOUBLE_QUOTES);
 	return '"';
 }
-#line 3157 "Zend/zend_language_scanner.c"
+#line 3150 "Zend/zend_language_scanner.c"
 yy182:
 		YYDEBUG(182, *YYCURSOR);
 		++YYCURSOR;
 		YYDEBUG(183, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 2133 "Zend/zend_language_scanner.l"
+#line 2066 "Zend/zend_language_scanner.l"
 		{
 	BEGIN(ST_BACKQUOTE);
 	return '`';
 }
-#line 3168 "Zend/zend_language_scanner.c"
+#line 3161 "Zend/zend_language_scanner.c"
 yy184:
 		YYDEBUG(184, *YYCURSOR);
 		++YYCURSOR;
 		YYDEBUG(185, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 2395 "Zend/zend_language_scanner.l"
+#line 2328 "Zend/zend_language_scanner.l"
 		{
 	if (YYCURSOR > YYLIMIT) {
 		return 0;
@@ -3179,7 +3172,7 @@ yy184:
 	zend_error(E_COMPILE_WARNING,"Unexpected character in input:  '%c' (ASCII=%d) state=%d", yytext[0], yytext[0], YYSTATE);
 	goto restart;
 }
-#line 3183 "Zend/zend_language_scanner.c"
+#line 3176 "Zend/zend_language_scanner.c"
 yy186:
 		YYDEBUG(186, *YYCURSOR);
 		++YYCURSOR;
@@ -3206,12 +3199,12 @@ yy188:
 yy190:
 		YYDEBUG(190, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1592 "Zend/zend_language_scanner.l"
+#line 1591 "Zend/zend_language_scanner.l"
 		{
 	ZVAL_DOUBLE(zendlval, zend_strtod(yytext, NULL));
 	return T_DNUMBER;
 }
-#line 3215 "Zend/zend_language_scanner.c"
+#line 3208 "Zend/zend_language_scanner.c"
 yy191:
 		YYDEBUG(191, *YYCURSOR);
 		yyaccept = 2;
@@ -3303,7 +3296,7 @@ yy200:
 		}
 		YYDEBUG(202, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1514 "Zend/zend_language_scanner.l"
+#line 1513 "Zend/zend_language_scanner.l"
 		{
 	char *bin = yytext + 2; /* Skip "0b" */
 	int len = yyleng - 2;
@@ -3326,7 +3319,7 @@ yy200:
 		return T_DNUMBER;
 	}
 }
-#line 3330 "Zend/zend_language_scanner.c"
+#line 3323 "Zend/zend_language_scanner.c"
 yy203:
 		YYDEBUG(203, *YYCURSOR);
 		++YYCURSOR;
@@ -3338,7 +3331,7 @@ yy203:
 		}
 		YYDEBUG(205, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1555 "Zend/zend_language_scanner.l"
+#line 1554 "Zend/zend_language_scanner.l"
 		{
 	char *hex = yytext + 2; /* Skip "0x" */
 	int len = yyleng - 2;
@@ -3361,7 +3354,7 @@ yy203:
 		return T_DNUMBER;
 	}
 }
-#line 3365 "Zend/zend_language_scanner.c"
+#line 3358 "Zend/zend_language_scanner.c"
 yy206:
 		YYDEBUG(206, *YYCURSOR);
 		++YYCURSOR;
@@ -3370,13 +3363,12 @@ yy206:
 yy207:
 		YYDEBUG(207, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1955 "Zend/zend_language_scanner.l"
+#line 1890 "Zend/zend_language_scanner.l"
 		{
-	DUMMY_STRINGL(zendlval, yytext, yyleng);
 	BEGIN(INITIAL);
 	return T_CLOSE_TAG;  /* implicit ';' at php-end tag */
 }
-#line 3380 "Zend/zend_language_scanner.c"
+#line 3372 "Zend/zend_language_scanner.c"
 yy208:
 		YYDEBUG(208, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -3410,12 +3402,12 @@ yy210:
 yy212:
 		YYDEBUG(212, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1860 "Zend/zend_language_scanner.l"
+#line 1795 "Zend/zend_language_scanner.l"
 		{
 	zend_copy_value(zendlval, (yytext+1), (yyleng-1));
 	return T_VARIABLE;
 }
-#line 3419 "Zend/zend_language_scanner.c"
+#line 3411 "Zend/zend_language_scanner.c"
 yy213:
 		YYDEBUG(213, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -3429,11 +3421,11 @@ yy214:
 		}
 		YYDEBUG(215, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1460 "Zend/zend_language_scanner.l"
+#line 1459 "Zend/zend_language_scanner.l"
 		{
 	return T_LOGICAL_XOR;
 }
-#line 3437 "Zend/zend_language_scanner.c"
+#line 3429 "Zend/zend_language_scanner.c"
 yy216:
 		YYDEBUG(216, *YYCURSOR);
 		++YYCURSOR;
@@ -3442,61 +3434,61 @@ yy216:
 		}
 		YYDEBUG(217, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1452 "Zend/zend_language_scanner.l"
+#line 1451 "Zend/zend_language_scanner.l"
 		{
 	return T_LOGICAL_OR;
 }
-#line 3450 "Zend/zend_language_scanner.c"
+#line 3442 "Zend/zend_language_scanner.c"
 yy218:
 		YYDEBUG(218, *YYCURSOR);
 		++YYCURSOR;
 		YYDEBUG(219, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1440 "Zend/zend_language_scanner.l"
+#line 1439 "Zend/zend_language_scanner.l"
 		{
 	return T_XOR_EQUAL;
 }
-#line 3460 "Zend/zend_language_scanner.c"
+#line 3452 "Zend/zend_language_scanner.c"
 yy220:
 		YYDEBUG(220, *YYCURSOR);
 		++YYCURSOR;
 		YYDEBUG(221, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1444 "Zend/zend_language_scanner.l"
+#line 1443 "Zend/zend_language_scanner.l"
 		{
 	return T_BOOLEAN_OR;
 }
-#line 3470 "Zend/zend_language_scanner.c"
+#line 3462 "Zend/zend_language_scanner.c"
 yy222:
 		YYDEBUG(222, *YYCURSOR);
 		++YYCURSOR;
 		YYDEBUG(223, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1436 "Zend/zend_language_scanner.l"
+#line 1435 "Zend/zend_language_scanner.l"
 		{
 	return T_OR_EQUAL;
 }
-#line 3480 "Zend/zend_language_scanner.c"
+#line 3472 "Zend/zend_language_scanner.c"
 yy224:
 		YYDEBUG(224, *YYCURSOR);
 		++YYCURSOR;
 		YYDEBUG(225, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1448 "Zend/zend_language_scanner.l"
+#line 1447 "Zend/zend_language_scanner.l"
 		{
 	return T_BOOLEAN_AND;
 }
-#line 3490 "Zend/zend_language_scanner.c"
+#line 3482 "Zend/zend_language_scanner.c"
 yy226:
 		YYDEBUG(226, *YYCURSOR);
 		++YYCURSOR;
 		YYDEBUG(227, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1432 "Zend/zend_language_scanner.l"
+#line 1431 "Zend/zend_language_scanner.l"
 		{
 	return T_AND_EQUAL;
 }
-#line 3500 "Zend/zend_language_scanner.c"
+#line 3492 "Zend/zend_language_scanner.c"
 yy228:
 		YYDEBUG(228, *YYCURSOR);
 		++YYCURSOR;
@@ -3505,28 +3497,27 @@ yy228:
 yy229:
 		YYDEBUG(229, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1962 "Zend/zend_language_scanner.l"
+#line 1896 "Zend/zend_language_scanner.l"
 		{
 	if (CG(asp_tags)) {
 		BEGIN(INITIAL);
-		DUMMY_STRINGL(zendlval, yytext, yyleng);
 		return T_CLOSE_TAG;  /* implicit ';' at php-end tag */
 	} else {
 		yyless(1);
 		return yytext[0];
 	}
 }
-#line 3520 "Zend/zend_language_scanner.c"
+#line 3511 "Zend/zend_language_scanner.c"
 yy230:
 		YYDEBUG(230, *YYCURSOR);
 		++YYCURSOR;
 		YYDEBUG(231, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1420 "Zend/zend_language_scanner.l"
+#line 1419 "Zend/zend_language_scanner.l"
 		{
 	return T_MOD_EQUAL;
 }
-#line 3530 "Zend/zend_language_scanner.c"
+#line 3521 "Zend/zend_language_scanner.c"
 yy232:
 		YYDEBUG(232, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -3544,7 +3535,7 @@ yy234:
 yy235:
 		YYDEBUG(235, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1922 "Zend/zend_language_scanner.l"
+#line 1857 "Zend/zend_language_scanner.l"
 		{
 	int doc_com;
 
@@ -3577,7 +3568,7 @@ yy235:
 
 	return T_COMMENT;
 }
-#line 3581 "Zend/zend_language_scanner.c"
+#line 3572 "Zend/zend_language_scanner.c"
 yy236:
 		YYDEBUG(236, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -3587,11 +3578,11 @@ yy237:
 		++YYCURSOR;
 		YYDEBUG(238, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1412 "Zend/zend_language_scanner.l"
+#line 1411 "Zend/zend_language_scanner.l"
 		{
 	return T_DIV_EQUAL;
 }
-#line 3595 "Zend/zend_language_scanner.c"
+#line 3586 "Zend/zend_language_scanner.c"
 yy239:
 		YYDEBUG(239, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -3615,62 +3606,62 @@ yy242:
 		if ((yych = *YYCURSOR) == '=') goto yy246;
 		YYDEBUG(243, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1404 "Zend/zend_language_scanner.l"
+#line 1403 "Zend/zend_language_scanner.l"
 		{
 	return T_POW;
 }
-#line 3623 "Zend/zend_language_scanner.c"
+#line 3614 "Zend/zend_language_scanner.c"
 yy244:
 		YYDEBUG(244, *YYCURSOR);
 		++YYCURSOR;
 		YYDEBUG(245, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1400 "Zend/zend_language_scanner.l"
+#line 1399 "Zend/zend_language_scanner.l"
 		{
 	return T_MUL_EQUAL;
 }
-#line 3633 "Zend/zend_language_scanner.c"
+#line 3624 "Zend/zend_language_scanner.c"
 yy246:
 		YYDEBUG(246, *YYCURSOR);
 		++YYCURSOR;
 		YYDEBUG(247, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1408 "Zend/zend_language_scanner.l"
+#line 1407 "Zend/zend_language_scanner.l"
 		{
 	return T_POW_EQUAL;
 }
-#line 3643 "Zend/zend_language_scanner.c"
+#line 3634 "Zend/zend_language_scanner.c"
 yy248:
 		YYDEBUG(248, *YYCURSOR);
 		++YYCURSOR;
 		if ((yych = *YYCURSOR) == '=') goto yy252;
 		YYDEBUG(249, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1468 "Zend/zend_language_scanner.l"
+#line 1467 "Zend/zend_language_scanner.l"
 		{
 	return T_SR;
 }
-#line 3654 "Zend/zend_language_scanner.c"
+#line 3645 "Zend/zend_language_scanner.c"
 yy250:
 		YYDEBUG(250, *YYCURSOR);
 		++YYCURSOR;
 		YYDEBUG(251, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1388 "Zend/zend_language_scanner.l"
+#line 1387 "Zend/zend_language_scanner.l"
 		{
 	return T_IS_GREATER_OR_EQUAL;
 }
-#line 3664 "Zend/zend_language_scanner.c"
+#line 3655 "Zend/zend_language_scanner.c"
 yy252:
 		YYDEBUG(252, *YYCURSOR);
 		++YYCURSOR;
 		YYDEBUG(253, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1428 "Zend/zend_language_scanner.l"
+#line 1427 "Zend/zend_language_scanner.l"
 		{
 	return T_SR_EQUAL;
 }
-#line 3674 "Zend/zend_language_scanner.c"
+#line 3665 "Zend/zend_language_scanner.c"
 yy254:
 		YYDEBUG(254, *YYCURSOR);
 		yyaccept = 5;
@@ -3681,11 +3672,11 @@ yy254:
 yy255:
 		YYDEBUG(255, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1464 "Zend/zend_language_scanner.l"
+#line 1463 "Zend/zend_language_scanner.l"
 		{
 	return T_SL;
 }
-#line 3689 "Zend/zend_language_scanner.c"
+#line 3680 "Zend/zend_language_scanner.c"
 yy256:
 		YYDEBUG(256, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -3697,22 +3688,22 @@ yy257:
 		++YYCURSOR;
 		YYDEBUG(258, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1384 "Zend/zend_language_scanner.l"
+#line 1383 "Zend/zend_language_scanner.l"
 		{
 	return T_IS_SMALLER_OR_EQUAL;
 }
-#line 3705 "Zend/zend_language_scanner.c"
+#line 3696 "Zend/zend_language_scanner.c"
 yy259:
 		YYDEBUG(259, *YYCURSOR);
 		++YYCURSOR;
 yy260:
 		YYDEBUG(260, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1380 "Zend/zend_language_scanner.l"
+#line 1379 "Zend/zend_language_scanner.l"
 		{
 	return T_IS_NOT_EQUAL;
 }
-#line 3716 "Zend/zend_language_scanner.c"
+#line 3707 "Zend/zend_language_scanner.c"
 yy261:
 		YYDEBUG(261, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -3763,11 +3754,11 @@ yy268:
 		++YYCURSOR;
 		YYDEBUG(269, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1424 "Zend/zend_language_scanner.l"
+#line 1423 "Zend/zend_language_scanner.l"
 		{
 	return T_SL_EQUAL;
 }
-#line 3771 "Zend/zend_language_scanner.c"
+#line 3762 "Zend/zend_language_scanner.c"
 yy270:
 		YYDEBUG(270, *YYCURSOR);
 		++YYCURSOR;
@@ -3872,7 +3863,7 @@ yy279:
 yy280:
 		YYDEBUG(280, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 2085 "Zend/zend_language_scanner.l"
+#line 2018 "Zend/zend_language_scanner.l"
 		{
 	char *s;
 	int bprefix = (yytext[0] != '<') ? 1 : 0;
@@ -3919,7 +3910,7 @@ yy280:
 
 	return T_START_HEREDOC;
 }
-#line 3923 "Zend/zend_language_scanner.c"
+#line 3914 "Zend/zend_language_scanner.c"
 yy281:
 		YYDEBUG(281, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -3959,31 +3950,31 @@ yy284:
 		++YYCURSOR;
 		YYDEBUG(286, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1372 "Zend/zend_language_scanner.l"
+#line 1371 "Zend/zend_language_scanner.l"
 		{
 	return T_IS_NOT_IDENTICAL;
 }
-#line 3967 "Zend/zend_language_scanner.c"
+#line 3958 "Zend/zend_language_scanner.c"
 yy287:
 		YYDEBUG(287, *YYCURSOR);
 		++YYCURSOR;
 		YYDEBUG(288, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1392 "Zend/zend_language_scanner.l"
+#line 1391 "Zend/zend_language_scanner.l"
 		{
 	return T_PLUS_EQUAL;
 }
-#line 3977 "Zend/zend_language_scanner.c"
+#line 3968 "Zend/zend_language_scanner.c"
 yy289:
 		YYDEBUG(289, *YYCURSOR);
 		++YYCURSOR;
 		YYDEBUG(290, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1360 "Zend/zend_language_scanner.l"
+#line 1359 "Zend/zend_language_scanner.l"
 		{
 	return T_INC;
 }
-#line 3987 "Zend/zend_language_scanner.c"
+#line 3978 "Zend/zend_language_scanner.c"
 yy291:
 		YYDEBUG(291, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -4002,42 +3993,42 @@ yy293:
 		}
 		YYDEBUG(294, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1348 "Zend/zend_language_scanner.l"
+#line 1347 "Zend/zend_language_scanner.l"
 		{
 	return T_LIST;
 }
-#line 4010 "Zend/zend_language_scanner.c"
+#line 4001 "Zend/zend_language_scanner.c"
 yy295:
 		YYDEBUG(295, *YYCURSOR);
 		++YYCURSOR;
 		if ((yych = *YYCURSOR) == '=') goto yy299;
 		YYDEBUG(296, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1376 "Zend/zend_language_scanner.l"
+#line 1375 "Zend/zend_language_scanner.l"
 		{
 	return T_IS_EQUAL;
 }
-#line 4021 "Zend/zend_language_scanner.c"
+#line 4012 "Zend/zend_language_scanner.c"
 yy297:
 		YYDEBUG(297, *YYCURSOR);
 		++YYCURSOR;
 		YYDEBUG(298, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1344 "Zend/zend_language_scanner.l"
+#line 1343 "Zend/zend_language_scanner.l"
 		{
 	return T_DOUBLE_ARROW;
 }
-#line 4031 "Zend/zend_language_scanner.c"
+#line 4022 "Zend/zend_language_scanner.c"
 yy299:
 		YYDEBUG(299, *YYCURSOR);
 		++YYCURSOR;
 		YYDEBUG(300, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1368 "Zend/zend_language_scanner.l"
+#line 1367 "Zend/zend_language_scanner.l"
 		{
 	return T_IS_IDENTICAL;
 }
-#line 4041 "Zend/zend_language_scanner.c"
+#line 4032 "Zend/zend_language_scanner.c"
 yy301:
 		YYDEBUG(301, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -4167,16 +4158,11 @@ yy317:
 		}
 		YYDEBUG(320, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1707 "Zend/zend_language_scanner.l"
+#line 1653 "Zend/zend_language_scanner.l"
 		{
-	if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
-		ZVAL_DUP(zendlval, &CG(current_namespace));
-	} else {
-		ZVAL_EMPTY_STRING(zendlval);
-	}
 	return T_NS_C;
 }
-#line 4180 "Zend/zend_language_scanner.c"
+#line 4166 "Zend/zend_language_scanner.c"
 yy321:
 		YYDEBUG(321, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -4196,7 +4182,7 @@ yy322:
 		}
 		YYDEBUG(325, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1682 "Zend/zend_language_scanner.l"
+#line 1628 "Zend/zend_language_scanner.l"
 		{
 	zend_string *filename = zend_get_compiled_filename(TSRMLS_C);
 	zend_string *dirname;
@@ -4221,7 +4207,7 @@ yy322:
 	ZVAL_STR(zendlval, dirname);
 	return T_DIR;
 }
-#line 4225 "Zend/zend_language_scanner.c"
+#line 4211 "Zend/zend_language_scanner.c"
 yy326:
 		YYDEBUG(326, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -4246,12 +4232,12 @@ yy328:
 		}
 		YYDEBUG(331, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1666 "Zend/zend_language_scanner.l"
+#line 1612 "Zend/zend_language_scanner.l"
 		{
 	ZVAL_LONG(zendlval, CG(zend_lineno));
 	return T_LINE;
 }
-#line 4255 "Zend/zend_language_scanner.c"
+#line 4241 "Zend/zend_language_scanner.c"
 yy332:
 		YYDEBUG(332, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -4286,39 +4272,11 @@ yy336:
 		}
 		YYDEBUG(339, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1634 "Zend/zend_language_scanner.l"
+#line 1608 "Zend/zend_language_scanner.l"
 		{
-	if (CG(active_class_entry)) {
-		int len = 0;
-
-		if (CG(active_class_entry)->name) {
-			len += CG(active_class_entry)->name->len;
-		}
-		if (CG(active_op_array) && CG(active_op_array)->function_name) {
-			len += sizeof("::")-1;
-			len += CG(active_op_array)->function_name->len;
-		}
-		ZVAL_NEW_STR(zendlval, zend_string_alloc(len, 0));
-		len = 0;
-		if (CG(active_class_entry)->name) {
-			memcpy(Z_STRVAL_P(zendlval), CG(active_class_entry)->name->val, CG(active_class_entry)->name->len);
-			len += CG(active_class_entry)->name->len;
-		}
-		if (CG(active_op_array) && CG(active_op_array)->function_name) {
-			memcpy(Z_STRVAL_P(zendlval) + len, "::", sizeof("::")-1);
-			len += sizeof("::")-1;
-			memcpy(Z_STRVAL_P(zendlval) + len, CG(active_op_array)->function_name->val, CG(active_op_array)->function_name->len);
-			len += CG(active_op_array)->function_name->len;
-		}
-		Z_STRVAL_P(zendlval)[len] = 0;
-	} else if (CG(active_op_array) && CG(active_op_array)->function_name) {
-		ZVAL_STR(zendlval, zend_string_copy(CG(active_op_array)->function_name));
-	} else {
-		ZVAL_EMPTY_STRING(zendlval);
-	}
 	return T_METHOD_C;
 }
-#line 4322 "Zend/zend_language_scanner.c"
+#line 4280 "Zend/zend_language_scanner.c"
 yy340:
 		YYDEBUG(340, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -4369,17 +4327,11 @@ yy347:
 		}
 		YYDEBUG(350, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1624 "Zend/zend_language_scanner.l"
+#line 1604 "Zend/zend_language_scanner.l"
 		{
-	zend_op_array *op_array = CG(active_op_array);
-	if (op_array && op_array->function_name) {
-		ZVAL_STR(zendlval, zend_string_copy(op_array->function_name));
-	} else {
-		ZVAL_EMPTY_STRING(zendlval);
-	}
 	return T_FUNC_C;
 }
-#line 4383 "Zend/zend_language_scanner.c"
+#line 4335 "Zend/zend_language_scanner.c"
 yy351:
 		YYDEBUG(351, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -4399,7 +4351,7 @@ yy352:
 		}
 		YYDEBUG(355, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1671 "Zend/zend_language_scanner.l"
+#line 1617 "Zend/zend_language_scanner.l"
 		{
 	zend_string *filename = zend_get_compiled_filename(TSRMLS_C);
 
@@ -4410,7 +4362,7 @@ yy352:
 	}
 	return T_FILE;
 }
-#line 4414 "Zend/zend_language_scanner.c"
+#line 4366 "Zend/zend_language_scanner.c"
 yy356:
 		YYDEBUG(356, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -4440,17 +4392,11 @@ yy359:
 		}
 		YYDEBUG(362, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1614 "Zend/zend_language_scanner.l"
+#line 1600 "Zend/zend_language_scanner.l"
 		{
-	zend_class_entry *ce = CG(active_class_entry);
-	if (ce && ce->name && ZEND_ACC_TRAIT == (ce->ce_flags & ZEND_ACC_TRAIT)) {
-		ZVAL_STR(zendlval, zend_string_copy(ce->name));
-	} else {
-		ZVAL_EMPTY_STRING(zendlval);
-	}
 	return T_TRAIT_C;
 }
-#line 4454 "Zend/zend_language_scanner.c"
+#line 4400 "Zend/zend_language_scanner.c"
 yy363:
 		YYDEBUG(363, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -4480,24 +4426,11 @@ yy366:
 		}
 		YYDEBUG(369, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1597 "Zend/zend_language_scanner.l"
+#line 1596 "Zend/zend_language_scanner.l"
 		{
-	zend_class_entry *ce = CG(active_class_entry);
-	if (ce && ZEND_ACC_TRAIT == (ce->ce_flags & ZEND_ACC_TRAIT)) {
-		/* We create a special __CLASS__ constant that is going to be resolved
-		   at run-time */
-		ZVAL_STRINGL(zendlval, "__CLASS__", sizeof("__CLASS__") - 1);
-		Z_TYPE_INFO_P(zendlval) = IS_CONSTANT_EX;
-	} else {
-		if (ce && ce->name) {
-			ZVAL_STR(zendlval, zend_string_copy(ce->name));
-		} else {
-			ZVAL_EMPTY_STRING(zendlval);
-		}
-	}
 	return T_CLASS_C;
 }
-#line 4501 "Zend/zend_language_scanner.c"
+#line 4434 "Zend/zend_language_scanner.c"
 yy370:
 		YYDEBUG(370, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -4559,11 +4492,11 @@ yy381:
 		}
 		YYDEBUG(382, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1312 "Zend/zend_language_scanner.l"
+#line 1311 "Zend/zend_language_scanner.l"
 		{
 	return T_HALT_COMPILER;
 }
-#line 4567 "Zend/zend_language_scanner.c"
+#line 4500 "Zend/zend_language_scanner.c"
 yy383:
 		YYDEBUG(383, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -4583,11 +4516,11 @@ yy385:
 		}
 		YYDEBUG(386, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1292 "Zend/zend_language_scanner.l"
+#line 1291 "Zend/zend_language_scanner.l"
 		{
 	return T_USE;
 }
-#line 4591 "Zend/zend_language_scanner.c"
+#line 4524 "Zend/zend_language_scanner.c"
 yy387:
 		YYDEBUG(387, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -4606,11 +4539,11 @@ yy389:
 		}
 		YYDEBUG(390, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1340 "Zend/zend_language_scanner.l"
+#line 1339 "Zend/zend_language_scanner.l"
 		{
 	return T_UNSET;
 }
-#line 4614 "Zend/zend_language_scanner.c"
+#line 4547 "Zend/zend_language_scanner.c"
 yy391:
 		YYDEBUG(391, *YYCURSOR);
 		++YYCURSOR;
@@ -4782,11 +4715,11 @@ yy406:
 		++YYCURSOR;
 		YYDEBUG(408, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1240 "Zend/zend_language_scanner.l"
+#line 1239 "Zend/zend_language_scanner.l"
 		{
 	return T_INT_CAST;
 }
-#line 4790 "Zend/zend_language_scanner.c"
+#line 4723 "Zend/zend_language_scanner.c"
 yy409:
 		YYDEBUG(409, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -4830,11 +4763,11 @@ yy414:
 		++YYCURSOR;
 		YYDEBUG(417, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1244 "Zend/zend_language_scanner.l"
+#line 1243 "Zend/zend_language_scanner.l"
 		{
 	return T_DOUBLE_CAST;
 }
-#line 4838 "Zend/zend_language_scanner.c"
+#line 4771 "Zend/zend_language_scanner.c"
 yy418:
 		YYDEBUG(418, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -4904,11 +4837,11 @@ yy428:
 		++YYCURSOR;
 		YYDEBUG(431, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1248 "Zend/zend_language_scanner.l"
+#line 1247 "Zend/zend_language_scanner.l"
 		{
 	return T_STRING_CAST;
 }
-#line 4912 "Zend/zend_language_scanner.c"
+#line 4845 "Zend/zend_language_scanner.c"
 yy432:
 		YYDEBUG(432, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -4941,11 +4874,11 @@ yy435:
 		++YYCURSOR;
 		YYDEBUG(438, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1252 "Zend/zend_language_scanner.l"
+#line 1251 "Zend/zend_language_scanner.l"
 		{
 	return T_ARRAY_CAST;
 }
-#line 4949 "Zend/zend_language_scanner.c"
+#line 4882 "Zend/zend_language_scanner.c"
 yy439:
 		YYDEBUG(439, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -4983,11 +4916,11 @@ yy443:
 		++YYCURSOR;
 		YYDEBUG(446, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1256 "Zend/zend_language_scanner.l"
+#line 1255 "Zend/zend_language_scanner.l"
 		{
 	return T_OBJECT_CAST;
 }
-#line 4991 "Zend/zend_language_scanner.c"
+#line 4924 "Zend/zend_language_scanner.c"
 yy447:
 		YYDEBUG(447, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -5028,11 +4961,11 @@ yy452:
 		++YYCURSOR;
 		YYDEBUG(454, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1260 "Zend/zend_language_scanner.l"
+#line 1259 "Zend/zend_language_scanner.l"
 		{
 	return T_BOOL_CAST;
 }
-#line 5036 "Zend/zend_language_scanner.c"
+#line 4969 "Zend/zend_language_scanner.c"
 yy455:
 		YYDEBUG(455, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -5092,11 +5025,11 @@ yy463:
 		++YYCURSOR;
 		YYDEBUG(466, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1264 "Zend/zend_language_scanner.l"
+#line 1263 "Zend/zend_language_scanner.l"
 		{
 	return T_UNSET_CAST;
 }
-#line 5100 "Zend/zend_language_scanner.c"
+#line 5033 "Zend/zend_language_scanner.c"
 yy467:
 		YYDEBUG(467, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -5110,11 +5043,11 @@ yy468:
 		}
 		YYDEBUG(469, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1236 "Zend/zend_language_scanner.l"
+#line 1235 "Zend/zend_language_scanner.l"
 		{
 	return T_VAR;
 }
-#line 5118 "Zend/zend_language_scanner.c"
+#line 5051 "Zend/zend_language_scanner.c"
 yy470:
 		YYDEBUG(470, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -5134,11 +5067,11 @@ yy472:
 		}
 		YYDEBUG(473, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1228 "Zend/zend_language_scanner.l"
+#line 1227 "Zend/zend_language_scanner.l"
 		{
 	return T_NEW;
 }
-#line 5142 "Zend/zend_language_scanner.c"
+#line 5075 "Zend/zend_language_scanner.c"
 yy474:
 		YYDEBUG(474, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -5177,11 +5110,11 @@ yy480:
 		}
 		YYDEBUG(481, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1288 "Zend/zend_language_scanner.l"
+#line 1287 "Zend/zend_language_scanner.l"
 		{
 	return T_NAMESPACE;
 }
-#line 5185 "Zend/zend_language_scanner.c"
+#line 5118 "Zend/zend_language_scanner.c"
 yy482:
 		YYDEBUG(482, *YYCURSOR);
 		yyaccept = 3;
@@ -5203,11 +5136,11 @@ yy484:
 		++YYCURSOR;
 		YYDEBUG(485, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1416 "Zend/zend_language_scanner.l"
+#line 1415 "Zend/zend_language_scanner.l"
 		{
 	return T_CONCAT_EQUAL;
 }
-#line 5211 "Zend/zend_language_scanner.c"
+#line 5144 "Zend/zend_language_scanner.c"
 yy486:
 		YYDEBUG(486, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -5216,21 +5149,21 @@ yy486:
 		++YYCURSOR;
 		YYDEBUG(488, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1224 "Zend/zend_language_scanner.l"
+#line 1223 "Zend/zend_language_scanner.l"
 		{
 	return T_ELLIPSIS;
 }
-#line 5224 "Zend/zend_language_scanner.c"
+#line 5157 "Zend/zend_language_scanner.c"
 yy489:
 		YYDEBUG(489, *YYCURSOR);
 		++YYCURSOR;
 		YYDEBUG(490, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1216 "Zend/zend_language_scanner.l"
+#line 1215 "Zend/zend_language_scanner.l"
 		{
 	return T_PAAMAYIM_NEKUDOTAYIM;
 }
-#line 5234 "Zend/zend_language_scanner.c"
+#line 5167 "Zend/zend_language_scanner.c"
 yy491:
 		YYDEBUG(491, *YYCURSOR);
 		++YYCURSOR;
@@ -5252,21 +5185,21 @@ yy493:
 		++YYCURSOR;
 		YYDEBUG(494, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1396 "Zend/zend_language_scanner.l"
+#line 1395 "Zend/zend_language_scanner.l"
 		{
 	return T_MINUS_EQUAL;
 }
-#line 5260 "Zend/zend_language_scanner.c"
+#line 5193 "Zend/zend_language_scanner.c"
 yy495:
 		YYDEBUG(495, *YYCURSOR);
 		++YYCURSOR;
 		YYDEBUG(496, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1364 "Zend/zend_language_scanner.l"
+#line 1363 "Zend/zend_language_scanner.l"
 		{
 	return T_DEC;
 }
-#line 5270 "Zend/zend_language_scanner.c"
+#line 5203 "Zend/zend_language_scanner.c"
 yy497:
 		YYDEBUG(497, *YYCURSOR);
 		++YYCURSOR;
@@ -5277,7 +5210,7 @@ yy497:
 	yy_push_state(ST_LOOKING_FOR_PROPERTY TSRMLS_CC);
 	return T_OBJECT_OPERATOR;
 }
-#line 5281 "Zend/zend_language_scanner.c"
+#line 5214 "Zend/zend_language_scanner.c"
 yy499:
 		YYDEBUG(499, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -5322,11 +5255,11 @@ yy504:
 		}
 		YYDEBUG(505, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1336 "Zend/zend_language_scanner.l"
+#line 1335 "Zend/zend_language_scanner.l"
 		{
 	return T_PUBLIC;
 }
-#line 5330 "Zend/zend_language_scanner.c"
+#line 5263 "Zend/zend_language_scanner.c"
 yy506:
 		YYDEBUG(506, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -5381,11 +5314,11 @@ yy513:
 		}
 		YYDEBUG(514, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1332 "Zend/zend_language_scanner.l"
+#line 1331 "Zend/zend_language_scanner.l"
 		{
 	return T_PROTECTED;
 }
-#line 5389 "Zend/zend_language_scanner.c"
+#line 5322 "Zend/zend_language_scanner.c"
 yy515:
 		YYDEBUG(515, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -5415,11 +5348,11 @@ yy519:
 		}
 		YYDEBUG(520, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1328 "Zend/zend_language_scanner.l"
+#line 1327 "Zend/zend_language_scanner.l"
 		{
 	return T_PRIVATE;
 }
-#line 5423 "Zend/zend_language_scanner.c"
+#line 5356 "Zend/zend_language_scanner.c"
 yy521:
 		YYDEBUG(521, *YYCURSOR);
 		++YYCURSOR;
@@ -5432,7 +5365,7 @@ yy521:
 		{
 	return T_PRINT;
 }
-#line 5436 "Zend/zend_language_scanner.c"
+#line 5369 "Zend/zend_language_scanner.c"
 yy523:
 		YYDEBUG(523, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -5461,7 +5394,7 @@ yy526:
 		{
 	return T_GOTO;
 }
-#line 5465 "Zend/zend_language_scanner.c"
+#line 5398 "Zend/zend_language_scanner.c"
 yy528:
 		YYDEBUG(528, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -5485,11 +5418,11 @@ yy531:
 		}
 		YYDEBUG(532, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1300 "Zend/zend_language_scanner.l"
+#line 1299 "Zend/zend_language_scanner.l"
 		{
 	return T_GLOBAL;
 }
-#line 5493 "Zend/zend_language_scanner.c"
+#line 5426 "Zend/zend_language_scanner.c"
 yy533:
 		YYDEBUG(533, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -5530,7 +5463,7 @@ yy539:
 		{
 	return T_BREAK;
 }
-#line 5534 "Zend/zend_language_scanner.c"
+#line 5467 "Zend/zend_language_scanner.c"
 yy541:
 		YYDEBUG(541, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -5574,7 +5507,7 @@ yy547:
 		{
 	return T_SWITCH;
 }
-#line 5578 "Zend/zend_language_scanner.c"
+#line 5511 "Zend/zend_language_scanner.c"
 yy549:
 		YYDEBUG(549, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -5598,11 +5531,11 @@ yy552:
 		}
 		YYDEBUG(553, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1316 "Zend/zend_language_scanner.l"
+#line 1315 "Zend/zend_language_scanner.l"
 		{
 	return T_STATIC;
 }
-#line 5606 "Zend/zend_language_scanner.c"
+#line 5539 "Zend/zend_language_scanner.c"
 yy554:
 		YYDEBUG(554, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -5633,7 +5566,7 @@ yy557:
 		{
 	return T_AS;
 }
-#line 5637 "Zend/zend_language_scanner.c"
+#line 5570 "Zend/zend_language_scanner.c"
 yy559:
 		YYDEBUG(559, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -5652,11 +5585,11 @@ yy561:
 		}
 		YYDEBUG(562, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1352 "Zend/zend_language_scanner.l"
+#line 1351 "Zend/zend_language_scanner.l"
 		{
 	return T_ARRAY;
 }
-#line 5660 "Zend/zend_language_scanner.c"
+#line 5593 "Zend/zend_language_scanner.c"
 yy563:
 		YYDEBUG(563, *YYCURSOR);
 		++YYCURSOR;
@@ -5665,11 +5598,11 @@ yy563:
 		}
 		YYDEBUG(564, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1456 "Zend/zend_language_scanner.l"
+#line 1455 "Zend/zend_language_scanner.l"
 		{
 	return T_LOGICAL_AND;
 }
-#line 5673 "Zend/zend_language_scanner.c"
+#line 5606 "Zend/zend_language_scanner.c"
 yy565:
 		YYDEBUG(565, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -5703,11 +5636,11 @@ yy570:
 		}
 		YYDEBUG(571, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1320 "Zend/zend_language_scanner.l"
+#line 1319 "Zend/zend_language_scanner.l"
 		{
 	return T_ABSTRACT;
 }
-#line 5711 "Zend/zend_language_scanner.c"
+#line 5644 "Zend/zend_language_scanner.c"
 yy572:
 		YYDEBUG(572, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -5735,7 +5668,7 @@ yy575:
 		{
 	return T_WHILE;
 }
-#line 5739 "Zend/zend_language_scanner.c"
+#line 5672 "Zend/zend_language_scanner.c"
 yy577:
 		YYDEBUG(577, *YYCURSOR);
 		++YYCURSOR;
@@ -5748,7 +5681,7 @@ yy577:
 		{
 	return T_IF;
 }
-#line 5752 "Zend/zend_language_scanner.c"
+#line 5685 "Zend/zend_language_scanner.c"
 yy579:
 		YYDEBUG(579, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -5800,11 +5733,11 @@ yy584:
 		}
 		YYDEBUG(585, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1304 "Zend/zend_language_scanner.l"
+#line 1303 "Zend/zend_language_scanner.l"
 		{
 	return T_ISSET;
 }
-#line 5808 "Zend/zend_language_scanner.c"
+#line 5741 "Zend/zend_language_scanner.c"
 yy586:
 		YYDEBUG(586, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -5858,11 +5791,11 @@ yy592:
 yy593:
 		YYDEBUG(593, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1272 "Zend/zend_language_scanner.l"
+#line 1271 "Zend/zend_language_scanner.l"
 		{
 	return T_INCLUDE;
 }
-#line 5866 "Zend/zend_language_scanner.c"
+#line 5799 "Zend/zend_language_scanner.c"
 yy594:
 		YYDEBUG(594, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -5891,11 +5824,11 @@ yy598:
 		}
 		YYDEBUG(599, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1276 "Zend/zend_language_scanner.l"
+#line 1275 "Zend/zend_language_scanner.l"
 		{
 	return T_INCLUDE_ONCE;
 }
-#line 5899 "Zend/zend_language_scanner.c"
+#line 5832 "Zend/zend_language_scanner.c"
 yy600:
 		YYDEBUG(600, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -5933,7 +5866,7 @@ yy605:
 		{
 	return T_INTERFACE;
 }
-#line 5937 "Zend/zend_language_scanner.c"
+#line 5870 "Zend/zend_language_scanner.c"
 yy607:
 		YYDEBUG(607, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -5983,11 +5916,11 @@ yy613:
 		}
 		YYDEBUG(614, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1296 "Zend/zend_language_scanner.l"
+#line 1295 "Zend/zend_language_scanner.l"
 		{
         return T_INSTEADOF;
 }
-#line 5991 "Zend/zend_language_scanner.c"
+#line 5924 "Zend/zend_language_scanner.c"
 yy615:
 		YYDEBUG(615, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -6020,7 +5953,7 @@ yy619:
 		{
 	return T_INSTANCEOF;
 }
-#line 6024 "Zend/zend_language_scanner.c"
+#line 5957 "Zend/zend_language_scanner.c"
 yy621:
 		YYDEBUG(621, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -6068,7 +6001,7 @@ yy628:
 		{
 	return T_IMPLEMENTS;
 }
-#line 6072 "Zend/zend_language_scanner.c"
+#line 6005 "Zend/zend_language_scanner.c"
 yy630:
 		YYDEBUG(630, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -6100,7 +6033,7 @@ yy631:
 		{
 	return T_TRY;
 }
-#line 6104 "Zend/zend_language_scanner.c"
+#line 6037 "Zend/zend_language_scanner.c"
 yy634:
 		YYDEBUG(634, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -6123,7 +6056,7 @@ yy636:
 		{
 	return T_TRAIT;
 }
-#line 6127 "Zend/zend_language_scanner.c"
+#line 6060 "Zend/zend_language_scanner.c"
 yy638:
 		YYDEBUG(638, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -6146,7 +6079,7 @@ yy640:
 		{
 	return T_THROW;
 }
-#line 6150 "Zend/zend_language_scanner.c"
+#line 6083 "Zend/zend_language_scanner.c"
 yy642:
 		YYDEBUG(642, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -6174,7 +6107,7 @@ yy645:
 		{
 	return T_YIELD;
 }
-#line 6178 "Zend/zend_language_scanner.c"
+#line 6111 "Zend/zend_language_scanner.c"
 yy647:
 		YYDEBUG(647, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -6235,11 +6168,11 @@ yy653:
 yy654:
 		YYDEBUG(654, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1280 "Zend/zend_language_scanner.l"
+#line 1279 "Zend/zend_language_scanner.l"
 		{
 	return T_REQUIRE;
 }
-#line 6243 "Zend/zend_language_scanner.c"
+#line 6176 "Zend/zend_language_scanner.c"
 yy655:
 		YYDEBUG(655, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -6268,11 +6201,11 @@ yy659:
 		}
 		YYDEBUG(660, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1284 "Zend/zend_language_scanner.l"
+#line 1283 "Zend/zend_language_scanner.l"
 		{
 	return T_REQUIRE_ONCE;
 }
-#line 6276 "Zend/zend_language_scanner.c"
+#line 6209 "Zend/zend_language_scanner.c"
 yy661:
 		YYDEBUG(661, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -6295,7 +6228,7 @@ yy663:
 		{
 	return T_RETURN;
 }
-#line 6299 "Zend/zend_language_scanner.c"
+#line 6232 "Zend/zend_language_scanner.c"
 yy665:
 		YYDEBUG(665, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -6389,7 +6322,7 @@ yy674:
 		{
 	return T_CONTINUE;
 }
-#line 6393 "Zend/zend_language_scanner.c"
+#line 6326 "Zend/zend_language_scanner.c"
 yy676:
 		YYDEBUG(676, *YYCURSOR);
 		++YYCURSOR;
@@ -6402,7 +6335,7 @@ yy676:
 		{
 	return T_CONST;
 }
-#line 6406 "Zend/zend_language_scanner.c"
+#line 6339 "Zend/zend_language_scanner.c"
 yy678:
 		YYDEBUG(678, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -6427,11 +6360,11 @@ yy681:
 		}
 		YYDEBUG(682, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1232 "Zend/zend_language_scanner.l"
+#line 1231 "Zend/zend_language_scanner.l"
 		{
 	return T_CLONE;
 }
-#line 6435 "Zend/zend_language_scanner.c"
+#line 6368 "Zend/zend_language_scanner.c"
 yy683:
 		YYDEBUG(683, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -6449,7 +6382,7 @@ yy684:
 		{
 	return T_CLASS;
 }
-#line 6453 "Zend/zend_language_scanner.c"
+#line 6386 "Zend/zend_language_scanner.c"
 yy686:
 		YYDEBUG(686, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -6495,11 +6428,11 @@ yy693:
 		}
 		YYDEBUG(694, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1356 "Zend/zend_language_scanner.l"
+#line 1355 "Zend/zend_language_scanner.l"
 		{
  return T_CALLABLE;
 }
-#line 6503 "Zend/zend_language_scanner.c"
+#line 6436 "Zend/zend_language_scanner.c"
 yy695:
 		YYDEBUG(695, *YYCURSOR);
 		++YYCURSOR;
@@ -6512,7 +6445,7 @@ yy695:
 		{
 	return T_CASE;
 }
-#line 6516 "Zend/zend_language_scanner.c"
+#line 6449 "Zend/zend_language_scanner.c"
 yy697:
 		YYDEBUG(697, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -6530,7 +6463,7 @@ yy698:
 		{
 	return T_CATCH;
 }
-#line 6534 "Zend/zend_language_scanner.c"
+#line 6467 "Zend/zend_language_scanner.c"
 yy700:
 		YYDEBUG(700, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -6585,7 +6518,7 @@ yy708:
 		{
 	return T_FUNCTION;
 }
-#line 6589 "Zend/zend_language_scanner.c"
+#line 6522 "Zend/zend_language_scanner.c"
 yy710:
 		YYDEBUG(710, *YYCURSOR);
 		++YYCURSOR;
@@ -6613,7 +6546,7 @@ yy711:
 		{
 	return T_FOR;
 }
-#line 6617 "Zend/zend_language_scanner.c"
+#line 6550 "Zend/zend_language_scanner.c"
 yy712:
 		YYDEBUG(712, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -6641,7 +6574,7 @@ yy715:
 		{
 	return T_FOREACH;
 }
-#line 6645 "Zend/zend_language_scanner.c"
+#line 6578 "Zend/zend_language_scanner.c"
 yy717:
 		YYDEBUG(717, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -6675,11 +6608,11 @@ yy719:
 yy720:
 		YYDEBUG(720, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1324 "Zend/zend_language_scanner.l"
+#line 1323 "Zend/zend_language_scanner.l"
 		{
 	return T_FINAL;
 }
-#line 6683 "Zend/zend_language_scanner.c"
+#line 6616 "Zend/zend_language_scanner.c"
 yy721:
 		YYDEBUG(721, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -6697,7 +6630,7 @@ yy722:
 		{
 	return T_FINALLY;
 }
-#line 6701 "Zend/zend_language_scanner.c"
+#line 6634 "Zend/zend_language_scanner.c"
 yy724:
 		YYDEBUG(724, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -6732,7 +6665,7 @@ yy726:
 		{
 	return T_DO;
 }
-#line 6736 "Zend/zend_language_scanner.c"
+#line 6669 "Zend/zend_language_scanner.c"
 yy728:
 		YYDEBUG(728, *YYCURSOR);
 		++YYCURSOR;
@@ -6745,7 +6678,7 @@ yy728:
 		{
 	return T_EXIT;
 }
-#line 6749 "Zend/zend_language_scanner.c"
+#line 6682 "Zend/zend_language_scanner.c"
 yy730:
 		YYDEBUG(730, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -6784,7 +6717,7 @@ yy735:
 		{
 	return T_DEFAULT;
 }
-#line 6788 "Zend/zend_language_scanner.c"
+#line 6721 "Zend/zend_language_scanner.c"
 yy737:
 		YYDEBUG(737, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -6812,7 +6745,7 @@ yy740:
 		{
 	return T_DECLARE;
 }
-#line 6816 "Zend/zend_language_scanner.c"
+#line 6749 "Zend/zend_language_scanner.c"
 yy742:
 		YYDEBUG(742, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -6896,7 +6829,7 @@ yy753:
 		{
 	return T_EXTENDS;
 }
-#line 6900 "Zend/zend_language_scanner.c"
+#line 6833 "Zend/zend_language_scanner.c"
 yy755:
 		YYDEBUG(755, *YYCURSOR);
 		++YYCURSOR;
@@ -6909,7 +6842,7 @@ yy755:
 		{
 	return T_EXIT;
 }
-#line 6913 "Zend/zend_language_scanner.c"
+#line 6846 "Zend/zend_language_scanner.c"
 yy757:
 		YYDEBUG(757, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -6923,11 +6856,11 @@ yy758:
 		}
 		YYDEBUG(759, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1268 "Zend/zend_language_scanner.l"
+#line 1267 "Zend/zend_language_scanner.l"
 		{
 	return T_EVAL;
 }
-#line 6931 "Zend/zend_language_scanner.c"
+#line 6864 "Zend/zend_language_scanner.c"
 yy760:
 		YYDEBUG(760, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -7001,7 +6934,7 @@ yy769:
 		{
 	return T_ENDWHILE;
 }
-#line 7005 "Zend/zend_language_scanner.c"
+#line 6938 "Zend/zend_language_scanner.c"
 yy771:
 		YYDEBUG(771, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -7034,7 +6967,7 @@ yy775:
 		{
 	return T_ENDSWITCH;
 }
-#line 7038 "Zend/zend_language_scanner.c"
+#line 6971 "Zend/zend_language_scanner.c"
 yy777:
 		YYDEBUG(777, *YYCURSOR);
 		++YYCURSOR;
@@ -7047,7 +6980,7 @@ yy777:
 		{
 	return T_ENDIF;
 }
-#line 7051 "Zend/zend_language_scanner.c"
+#line 6984 "Zend/zend_language_scanner.c"
 yy779:
 		YYDEBUG(779, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -7080,7 +7013,7 @@ yy781:
 		{
 	return T_ENDFOR;
 }
-#line 7084 "Zend/zend_language_scanner.c"
+#line 7017 "Zend/zend_language_scanner.c"
 yy782:
 		YYDEBUG(782, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -7108,7 +7041,7 @@ yy785:
 		{
 	return T_ENDFOREACH;
 }
-#line 7112 "Zend/zend_language_scanner.c"
+#line 7045 "Zend/zend_language_scanner.c"
 yy787:
 		YYDEBUG(787, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -7146,7 +7079,7 @@ yy792:
 		{
 	return T_ENDDECLARE;
 }
-#line 7150 "Zend/zend_language_scanner.c"
+#line 7083 "Zend/zend_language_scanner.c"
 yy794:
 		YYDEBUG(794, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -7165,11 +7098,11 @@ yy796:
 		}
 		YYDEBUG(797, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1308 "Zend/zend_language_scanner.l"
+#line 1307 "Zend/zend_language_scanner.l"
 		{
 	return T_EMPTY;
 }
-#line 7173 "Zend/zend_language_scanner.c"
+#line 7106 "Zend/zend_language_scanner.c"
 yy798:
 		YYDEBUG(798, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -7202,7 +7135,7 @@ yy800:
 		{
 	return T_ELSE;
 }
-#line 7206 "Zend/zend_language_scanner.c"
+#line 7139 "Zend/zend_language_scanner.c"
 yy801:
 		YYDEBUG(801, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -7220,7 +7153,7 @@ yy802:
 		{
 	return T_ELSEIF;
 }
-#line 7224 "Zend/zend_language_scanner.c"
+#line 7157 "Zend/zend_language_scanner.c"
 yy804:
 		YYDEBUG(804, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -7238,7 +7171,7 @@ yy805:
 		{
 	return T_ECHO;
 }
-#line 7242 "Zend/zend_language_scanner.c"
+#line 7175 "Zend/zend_language_scanner.c"
 	}
 /* *********************************** */
 yyc_ST_LOOKING_FOR_PROPERTY:
@@ -7313,11 +7246,10 @@ yy810:
 		yyleng = YYCURSOR - SCNG(yy_text);
 #line 1194 "Zend/zend_language_scanner.l"
 		{
-	DUMMY_STRINGL(zendlval, yytext, yyleng);
 	HANDLE_NEWLINES(yytext, yyleng);
 	return T_WHITESPACE;
 }
-#line 7321 "Zend/zend_language_scanner.c"
+#line 7253 "Zend/zend_language_scanner.c"
 yy811:
 		YYDEBUG(811, *YYCURSOR);
 		++YYCURSOR;
@@ -7325,13 +7257,13 @@ yy811:
 yy812:
 		YYDEBUG(812, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1210 "Zend/zend_language_scanner.l"
+#line 1209 "Zend/zend_language_scanner.l"
 		{
 	yyless(0);
 	yy_pop_state(TSRMLS_C);
 	goto restart;
 }
-#line 7335 "Zend/zend_language_scanner.c"
+#line 7267 "Zend/zend_language_scanner.c"
 yy813:
 		YYDEBUG(813, *YYCURSOR);
 		++YYCURSOR;
@@ -7340,13 +7272,13 @@ yy813:
 yy814:
 		YYDEBUG(814, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1204 "Zend/zend_language_scanner.l"
+#line 1203 "Zend/zend_language_scanner.l"
 		{
 	yy_pop_state(TSRMLS_C);
 	zend_copy_value(zendlval, yytext, yyleng);
 	return T_STRING;
 }
-#line 7350 "Zend/zend_language_scanner.c"
+#line 7282 "Zend/zend_language_scanner.c"
 yy815:
 		YYDEBUG(815, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -7367,11 +7299,11 @@ yy818:
 		++YYCURSOR;
 		YYDEBUG(819, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1200 "Zend/zend_language_scanner.l"
+#line 1199 "Zend/zend_language_scanner.l"
 		{
 	return T_OBJECT_OPERATOR;
 }
-#line 7375 "Zend/zend_language_scanner.c"
+#line 7307 "Zend/zend_language_scanner.c"
 yy820:
 		YYDEBUG(820, *YYCURSOR);
 		++YYCURSOR;
@@ -7456,14 +7388,14 @@ yy824:
 yy825:
 		YYDEBUG(825, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1507 "Zend/zend_language_scanner.l"
+#line 1506 "Zend/zend_language_scanner.l"
 		{
 	yyless(0);
 	yy_pop_state(TSRMLS_C);
 	yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
 	goto restart;
 }
-#line 7467 "Zend/zend_language_scanner.c"
+#line 7399 "Zend/zend_language_scanner.c"
 yy826:
 		YYDEBUG(826, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -7488,7 +7420,7 @@ yy830:
 		++YYCURSOR;
 		YYDEBUG(831, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1498 "Zend/zend_language_scanner.l"
+#line 1497 "Zend/zend_language_scanner.l"
 		{
 	yyless(yyleng - 1);
 	zend_copy_value(zendlval, yytext, yyleng);
@@ -7496,7 +7428,7 @@ yy830:
 	yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
 	return T_STRING_VARNAME;
 }
-#line 7500 "Zend/zend_language_scanner.c"
+#line 7432 "Zend/zend_language_scanner.c"
 	}
 /* *********************************** */
 yyc_ST_NOWDOC:
@@ -7507,7 +7439,7 @@ yyc_ST_NOWDOC:
 	++YYCURSOR;
 	YYDEBUG(835, *YYCURSOR);
 	yyleng = YYCURSOR - SCNG(yy_text);
-#line 2338 "Zend/zend_language_scanner.l"
+#line 2271 "Zend/zend_language_scanner.l"
 	{
 	int newline = 0;
 
@@ -7563,7 +7495,7 @@ nowdoc_scan_done:
 	HANDLE_NEWLINES(yytext, yyleng - newline);
 	return T_ENCAPSED_AND_WHITESPACE;
 }
-#line 7567 "Zend/zend_language_scanner.c"
+#line 7499 "Zend/zend_language_scanner.c"
 /* *********************************** */
 yyc_ST_VAR_OFFSET:
 	{
@@ -7670,7 +7602,7 @@ yy838:
 yy839:
 		YYDEBUG(839, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1578 "Zend/zend_language_scanner.l"
+#line 1577 "Zend/zend_language_scanner.l"
 		{ /* Offset could be treated as a long */
 	if (yyleng < MAX_LENGTH_OF_LONG - 1 || (yyleng == MAX_LENGTH_OF_LONG - 1 && strcmp(yytext, long_min_digits) < 0)) {
 		ZVAL_LONG(zendlval, ZEND_STRTOL(yytext, NULL, 10));
@@ -7679,7 +7611,7 @@ yy839:
 	}
 	return T_NUM_STRING;
 }
-#line 7683 "Zend/zend_language_scanner.c"
+#line 7615 "Zend/zend_language_scanner.c"
 yy840:
 		YYDEBUG(840, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -7699,23 +7631,23 @@ yy841:
 yy842:
 		YYDEBUG(842, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1870 "Zend/zend_language_scanner.l"
+#line 1805 "Zend/zend_language_scanner.l"
 		{
 	/* Only '[' can be valid, but returning other tokens will allow a more explicit parse error */
 	return yytext[0];
 }
-#line 7708 "Zend/zend_language_scanner.c"
+#line 7640 "Zend/zend_language_scanner.c"
 yy843:
 		YYDEBUG(843, *YYCURSOR);
 		++YYCURSOR;
 		YYDEBUG(844, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1865 "Zend/zend_language_scanner.l"
+#line 1800 "Zend/zend_language_scanner.l"
 		{
 	yy_pop_state(TSRMLS_C);
 	return ']';
 }
-#line 7719 "Zend/zend_language_scanner.c"
+#line 7651 "Zend/zend_language_scanner.c"
 yy845:
 		YYDEBUG(845, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -7725,14 +7657,14 @@ yy846:
 		++YYCURSOR;
 		YYDEBUG(847, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1875 "Zend/zend_language_scanner.l"
+#line 1810 "Zend/zend_language_scanner.l"
 		{
 	/* Invalid rule to return a more explicit parse error with proper line number */
 	yyless(0);
 	yy_pop_state(TSRMLS_C);
 	return T_ENCAPSED_AND_WHITESPACE;
 }
-#line 7736 "Zend/zend_language_scanner.c"
+#line 7668 "Zend/zend_language_scanner.c"
 yy848:
 		YYDEBUG(848, *YYCURSOR);
 		++YYCURSOR;
@@ -7741,18 +7673,18 @@ yy848:
 yy849:
 		YYDEBUG(849, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1882 "Zend/zend_language_scanner.l"
+#line 1817 "Zend/zend_language_scanner.l"
 		{
 	zend_copy_value(zendlval, yytext, yyleng);
 	return T_STRING;
 }
-#line 7750 "Zend/zend_language_scanner.c"
+#line 7682 "Zend/zend_language_scanner.c"
 yy850:
 		YYDEBUG(850, *YYCURSOR);
 		++YYCURSOR;
 		YYDEBUG(851, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 2395 "Zend/zend_language_scanner.l"
+#line 2328 "Zend/zend_language_scanner.l"
 		{
 	if (YYCURSOR > YYLIMIT) {
 		return 0;
@@ -7761,7 +7693,7 @@ yy850:
 	zend_error(E_COMPILE_WARNING,"Unexpected character in input:  '%c' (ASCII=%d) state=%d", yytext[0], yytext[0], YYSTATE);
 	goto restart;
 }
-#line 7765 "Zend/zend_language_scanner.c"
+#line 7697 "Zend/zend_language_scanner.c"
 yy852:
 		YYDEBUG(852, *YYCURSOR);
 		++YYCURSOR;
@@ -7797,12 +7729,12 @@ yy854:
 yy856:
 		YYDEBUG(856, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1860 "Zend/zend_language_scanner.l"
+#line 1795 "Zend/zend_language_scanner.l"
 		{
 	zend_copy_value(zendlval, (yytext+1), (yyleng-1));
 	return T_VARIABLE;
 }
-#line 7806 "Zend/zend_language_scanner.c"
+#line 7738 "Zend/zend_language_scanner.c"
 yy857:
 		YYDEBUG(857, *YYCURSOR);
 		++YYCURSOR;
@@ -7842,12 +7774,12 @@ yy862:
 yy864:
 		YYDEBUG(864, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1587 "Zend/zend_language_scanner.l"
+#line 1586 "Zend/zend_language_scanner.l"
 		{ /* Offset must be treated as a string */
 	ZVAL_STRINGL(zendlval, yytext, yyleng);
 	return T_NUM_STRING;
 }
-#line 7851 "Zend/zend_language_scanner.c"
+#line 7783 "Zend/zend_language_scanner.c"
 yy865:
 		YYDEBUG(865, *YYCURSOR);
 		++YYCURSOR;
@@ -7870,6 +7802,6 @@ yy867:
 		goto yy864;
 	}
 }
-#line 2404 "Zend/zend_language_scanner.l"
+#line 2337 "Zend/zend_language_scanner.l"
 
 }
diff --git a/Zend/zend_language_scanner.l b/Zend/zend_language_scanner.l
index 66fa0cc7bf..fb016b4af8 100644
--- a/Zend/zend_language_scanner.l
+++ b/Zend/zend_language_scanner.l
@@ -559,11 +559,10 @@ ZEND_API zend_op_array *compile_file(zend_file_handle *file_handle, int type TSR
 	zend_op_array *retval=NULL;
 	int compiler_result;
 	zend_bool compilation_successful=0;
-	znode retval_znode;
+	zval retval_zv;
 	zend_bool original_in_compilation = CG(in_compilation);
 
-	retval_znode.op_type = IS_CONST;
-	ZVAL_LONG(&retval_znode.u.constant, 1);
+	ZVAL_LONG(&retval_zv, 1);
 
 	zend_save_lexical_state(&original_lex_state TSRMLS_CC);
 
@@ -583,12 +582,17 @@ ZEND_API zend_op_array *compile_file(zend_file_handle *file_handle, int type TSR
 		CG(active_op_array) = op_array;
 		zend_stack_push(&CG(context_stack), (void *) &CG(context));
 		zend_init_compiler_context(TSRMLS_C);
+		CG(ast_arena) = zend_arena_create(1024 * 32);
 		compiler_result = zendparse(TSRMLS_C);
-		zend_do_return(&retval_znode, 0 TSRMLS_CC);
-		CG(in_compilation) = original_in_compilation;
 		if (compiler_result != 0) { /* parser error */
 			zend_bailout();
 		}
+		zend_compile_top_stmt(CG(ast) TSRMLS_CC);
+		zend_ast_destroy(CG(ast));
+		zend_arena_destroy(CG(ast_arena));
+		zend_do_end_compilation(TSRMLS_C);
+		zend_emit_final_return(&retval_zv TSRMLS_CC);
+		CG(in_compilation) = original_in_compilation;
 		compilation_successful=1;
 	}
 
@@ -750,6 +754,7 @@ zend_op_array *compile_string(zval *source_string, char *filename TSRMLS_DC)
 		zend_stack_push(&CG(context_stack), (void *) &CG(context));
 		zend_init_compiler_context(TSRMLS_C);
 		BEGIN(ST_IN_SCRIPTING);
+		CG(ast_arena) = zend_arena_create(1024 * 32);
 		compiler_result = zendparse(TSRMLS_C);
 
 		if (SCNG(script_filtered)) {
@@ -764,7 +769,11 @@ zend_op_array *compile_string(zval *source_string, char *filename TSRMLS_DC)
 			efree(op_array);
 			retval = NULL;
 		} else {
-			zend_do_return(NULL, 0 TSRMLS_CC);
+			zend_compile_top_stmt(CG(ast) TSRMLS_CC);
+			zend_ast_destroy(CG(ast));
+			zend_arena_destroy(CG(ast_arena));
+			zend_do_end_compilation(TSRMLS_C);
+			zend_emit_final_return(NULL TSRMLS_CC);
 			CG(active_op_array) = original_active_op_array;
 			pass_two(op_array TSRMLS_CC);
 			zend_release_labels(0 TSRMLS_CC);
@@ -874,15 +883,6 @@ ZEND_API void zend_multibyte_yyinput_again(zend_encoding_filter old_input_filter
 		ZVAL_STRINGL(zendlval, yytext, yyleng); \
 	}
 
-// TODO: some extensions might need content, but we don't copy it intentional ???
-#if 0
-# define DUMMY_STRINGL(zendlval, yytext, yyleng) \
-	ZVAL_STRINGL(zendlval, yytext, yyleng)
-#else
-# define DUMMY_STRINGL(zendlval, yytext, yyleng) \
-	ZVAL_EMPTY_STRING(zendlval)
-#endif
-
 static void zend_scan_escape_string(zval *zendlval, char *str, int len, char quote_type TSRMLS_DC)
 {
 	register char *s, *t;
@@ -1192,7 +1192,6 @@ NEWLINE ("\r"|"\n"|"\r\n")
 }
 
 <ST_IN_SCRIPTING,ST_LOOKING_FOR_PROPERTY>{WHITESPACE}+ {
-	DUMMY_STRINGL(zendlval, yytext, yyleng);
 	HANDLE_NEWLINES(yytext, yyleng);
 	return T_WHITESPACE;
 }
@@ -1595,71 +1594,18 @@ NEWLINE ("\r"|"\n"|"\r\n")
 }
 
 <ST_IN_SCRIPTING>"__CLASS__" {
-	zend_class_entry *ce = CG(active_class_entry);
-	if (ce && ZEND_ACC_TRAIT == (ce->ce_flags & ZEND_ACC_TRAIT)) {
-		/* We create a special __CLASS__ constant that is going to be resolved
-		   at run-time */
-		ZVAL_STRINGL(zendlval, "__CLASS__", sizeof("__CLASS__") - 1);
-		Z_TYPE_INFO_P(zendlval) = IS_CONSTANT_EX;
-	} else {
-		if (ce && ce->name) {
-			ZVAL_STR(zendlval, zend_string_copy(ce->name));
-		} else {
-			ZVAL_EMPTY_STRING(zendlval);
-		}
-	}
 	return T_CLASS_C;
 }
 
 <ST_IN_SCRIPTING>"__TRAIT__" {
-	zend_class_entry *ce = CG(active_class_entry);
-	if (ce && ce->name && ZEND_ACC_TRAIT == (ce->ce_flags & ZEND_ACC_TRAIT)) {
-		ZVAL_STR(zendlval, zend_string_copy(ce->name));
-	} else {
-		ZVAL_EMPTY_STRING(zendlval);
-	}
 	return T_TRAIT_C;
 }
 
 <ST_IN_SCRIPTING>"__FUNCTION__" {
-	zend_op_array *op_array = CG(active_op_array);
-	if (op_array && op_array->function_name) {
-		ZVAL_STR(zendlval, zend_string_copy(op_array->function_name));
-	} else {
-		ZVAL_EMPTY_STRING(zendlval);
-	}
 	return T_FUNC_C;
 }
 
 <ST_IN_SCRIPTING>"__METHOD__" {
-	if (CG(active_class_entry)) {
-		int len = 0;
-
-		if (CG(active_class_entry)->name) {
-			len += CG(active_class_entry)->name->len;
-		}
-		if (CG(active_op_array) && CG(active_op_array)->function_name) {
-			len += sizeof("::")-1;
-			len += CG(active_op_array)->function_name->len;
-		}
-		ZVAL_NEW_STR(zendlval, zend_string_alloc(len, 0));
-		len = 0;
-		if (CG(active_class_entry)->name) {
-			memcpy(Z_STRVAL_P(zendlval), CG(active_class_entry)->name->val, CG(active_class_entry)->name->len);
-			len += CG(active_class_entry)->name->len;
-		}
-		if (CG(active_op_array) && CG(active_op_array)->function_name) {
-			memcpy(Z_STRVAL_P(zendlval) + len, "::", sizeof("::")-1);
-			len += sizeof("::")-1;
-			memcpy(Z_STRVAL_P(zendlval) + len, CG(active_op_array)->function_name->val, CG(active_op_array)->function_name->len);
-			len += CG(active_op_array)->function_name->len;
-		}
-		Z_STRVAL_P(zendlval)[len] = 0;
-	} else if (CG(active_op_array) && CG(active_op_array)->function_name) {
-		ZVAL_STR(zendlval, zend_string_copy(CG(active_op_array)->function_name));
-	} else {
-		ZVAL_EMPTY_STRING(zendlval);
-	}
 	return T_METHOD_C;
 }
 
@@ -1705,11 +1651,6 @@ NEWLINE ("\r"|"\n"|"\r\n")
 }
 
 <ST_IN_SCRIPTING>"__NAMESPACE__" {
-	if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
-		ZVAL_DUP(zendlval, &CG(current_namespace));
-	} else {
-		ZVAL_EMPTY_STRING(zendlval);
-	}
 	return T_NS_C;
 }
 
@@ -1723,7 +1664,6 @@ NEWLINE ("\r"|"\n"|"\r\n")
 	}
 
 	HANDLE_NEWLINES(yytext, yyleng);
-	DUMMY_STRINGL(zendlval, yytext, yyleng);
 	BEGIN(ST_IN_SCRIPTING);
 	return T_OPEN_TAG;
 }
@@ -1731,7 +1671,6 @@ NEWLINE ("\r"|"\n"|"\r\n")
 
 <INITIAL>"<%=" {
 	if (CG(asp_tags)) {
-		DUMMY_STRINGL(zendlval, yytext, yyleng);
 		BEGIN(ST_IN_SCRIPTING);
 		return T_OPEN_TAG_WITH_ECHO;
 	} else {
@@ -1741,7 +1680,6 @@ NEWLINE ("\r"|"\n"|"\r\n")
 
 
 <INITIAL>"<?=" {
-	DUMMY_STRINGL(zendlval, yytext, yyleng);
 	BEGIN(ST_IN_SCRIPTING);
 	return T_OPEN_TAG_WITH_ECHO;
 }
@@ -1749,7 +1687,6 @@ NEWLINE ("\r"|"\n"|"\r\n")
 
 <INITIAL>"<%" {
 	if (CG(asp_tags)) {
-		DUMMY_STRINGL(zendlval, yytext, yyleng);
 		BEGIN(ST_IN_SCRIPTING);
 		return T_OPEN_TAG;
 	} else {
@@ -1759,7 +1696,6 @@ NEWLINE ("\r"|"\n"|"\r\n")
 
 
 <INITIAL>"<?php"([ \t]|{NEWLINE}) {
-	DUMMY_STRINGL(zendlval, yytext, yyleng);
 	HANDLE_NEWLINE(yytext[yyleng-1]);
 	BEGIN(ST_IN_SCRIPTING);
 	return T_OPEN_TAG;
@@ -1768,7 +1704,6 @@ NEWLINE ("\r"|"\n"|"\r\n")
 
 <INITIAL>"<?" {
 	if (CG(short_tags)) {
-		DUMMY_STRINGL(zendlval, yytext, yyleng);
 		BEGIN(ST_IN_SCRIPTING);
 		return T_OPEN_TAG;
 	} else {
@@ -1953,7 +1888,6 @@ inline_html:
 }
 
 <ST_IN_SCRIPTING>("?>"|"</script"{WHITESPACE}*">"){NEWLINE}? {
-	DUMMY_STRINGL(zendlval, yytext, yyleng);
 	BEGIN(INITIAL);
 	return T_CLOSE_TAG;  /* implicit ';' at php-end tag */
 }
@@ -1962,7 +1896,6 @@ inline_html:
 <ST_IN_SCRIPTING>"%>"{NEWLINE}? {
 	if (CG(asp_tags)) {
 		BEGIN(INITIAL);
-		DUMMY_STRINGL(zendlval, yytext, yyleng);
 		return T_CLOSE_TAG;  /* implicit ';' at php-end tag */
 	} else {
 		yyless(1);
diff --git a/Zend/zend_opcode.c b/Zend/zend_opcode.c
index d09f28b0dc..a893a34078 100644
--- a/Zend/zend_opcode.c
+++ b/Zend/zend_opcode.c
@@ -79,6 +79,7 @@ void init_op_array(zend_op_array *op_array, zend_uchar type, int initial_ops_siz
 	op_array->required_num_args = 0;
 
 	op_array->scope = NULL;
+	op_array->prototype = NULL;
 
 	op_array->brk_cont_array = NULL;
 	op_array->try_catch_array = NULL;
@@ -795,13 +796,10 @@ ZEND_API unary_op_type get_unary_op(int opcode)
 	switch (opcode) {
 		case ZEND_BW_NOT:
 			return (unary_op_type) bitwise_not_function;
-			break;
 		case ZEND_BOOL_NOT:
 			return (unary_op_type) boolean_not_function;
-			break;
 		default:
 			return (unary_op_type) NULL;
-			break;
 	}
 }
 
@@ -811,74 +809,54 @@ ZEND_API binary_op_type get_binary_op(int opcode)
 		case ZEND_ADD:
 		case ZEND_ASSIGN_ADD:
 			return (binary_op_type) add_function;
-			break;
 		case ZEND_SUB:
 		case ZEND_ASSIGN_SUB:
 			return (binary_op_type) sub_function;
-			break;
 		case ZEND_MUL:
 		case ZEND_ASSIGN_MUL:
 			return (binary_op_type) mul_function;
-			break;
 		case ZEND_POW:
 			return (binary_op_type) pow_function;
-			break;
 		case ZEND_DIV:
 		case ZEND_ASSIGN_DIV:
 			return (binary_op_type) div_function;
-			break;
 		case ZEND_MOD:
 		case ZEND_ASSIGN_MOD:
 			return (binary_op_type) mod_function;
-			break;
 		case ZEND_SL:
 		case ZEND_ASSIGN_SL:
 			return (binary_op_type) shift_left_function;
-			break;
 		case ZEND_SR:
 		case ZEND_ASSIGN_SR:
 			return (binary_op_type) shift_right_function;
-			break;
 		case ZEND_CONCAT:
 		case ZEND_ASSIGN_CONCAT:
 			return (binary_op_type) concat_function;
-			break;
 		case ZEND_IS_IDENTICAL:
 			return (binary_op_type) is_identical_function;
-			break;
 		case ZEND_IS_NOT_IDENTICAL:
 			return (binary_op_type) is_not_identical_function;
-			break;
 		case ZEND_IS_EQUAL:
 			return (binary_op_type) is_equal_function;
-			break;
 		case ZEND_IS_NOT_EQUAL:
 			return (binary_op_type) is_not_equal_function;
-			break;
 		case ZEND_IS_SMALLER:
 			return (binary_op_type) is_smaller_function;
-			break;
 		case ZEND_IS_SMALLER_OR_EQUAL:
 			return (binary_op_type) is_smaller_or_equal_function;
-			break;
 		case ZEND_BW_OR:
 		case ZEND_ASSIGN_BW_OR:
 			return (binary_op_type) bitwise_or_function;
-			break;
 		case ZEND_BW_AND:
 		case ZEND_ASSIGN_BW_AND:
 			return (binary_op_type) bitwise_and_function;
-			break;
 		case ZEND_BW_XOR:
 		case ZEND_ASSIGN_BW_XOR:
 			return (binary_op_type) bitwise_xor_function;
-			break;
 		case ZEND_BOOL_XOR:
 			return (binary_op_type) boolean_xor_function;
-			break;
 		default:
 			return (binary_op_type) NULL;
-			break;
 	}
 }
 
diff --git a/Zend/zend_operators.h b/Zend/zend_operators.h
index a7f920bbac..a5b324e8b9 100644
--- a/Zend/zend_operators.h
+++ b/Zend/zend_operators.h
@@ -448,7 +448,7 @@ END_EXTERN_C()
 	}
 
 #define convert_to_boolean_ex(pzv)	convert_to_ex_master(pzv, boolean, _IS_BOOL)
-#define convert_to_long_ex(pzv)		convert_to_ex_master(pzv, int, IS_LONG)
+#define convert_to_long_ex(pzv)		convert_to_ex_master(pzv, long, IS_LONG)
 #define convert_to_double_ex(pzv)	convert_to_ex_master(pzv, double, IS_DOUBLE)
 #define convert_to_string_ex(pzv)	convert_to_ex_master(pzv, string, IS_STRING)
 #define convert_to_array_ex(pzv)	convert_to_ex_master(pzv, array, IS_ARRAY)
diff --git a/Zend/zend_types.h b/Zend/zend_types.h
index a76704beed..d2b562ecd9 100644
--- a/Zend/zend_types.h
+++ b/Zend/zend_types.h
@@ -132,6 +132,7 @@ struct _zval_struct {
 		uint32_t     next;                 /* hash collision chain */
 		uint32_t     str_offset;           /* string offset */
 		uint32_t     cache_slot;           /* literal cache slot */
+		uint32_t     lineno;               /* line number (for ast nodes) */
 	} u2;
 };
 
diff --git a/Zend/zend_variables.c b/Zend/zend_variables.c
index 1ec3ffb7ca..df6dbd179a 100644
--- a/Zend/zend_variables.c
+++ b/Zend/zend_variables.c
@@ -53,7 +53,7 @@ ZEND_API void _zval_dtor_func(zend_refcounted *p ZEND_FILE_LINE_DC)
 		case IS_CONSTANT_AST: {
 				zend_ast_ref *ast = (zend_ast_ref*)p;
 		
-				zend_ast_destroy(ast->ast);
+				zend_ast_destroy_and_free(ast->ast);
 				efree(ast);
 				break;
 			}
@@ -113,7 +113,7 @@ ZEND_API void _zval_dtor_func_for_ptr(zend_refcounted *p ZEND_FILE_LINE_DC)
 		case IS_CONSTANT_AST: {
 				zend_ast_ref *ast = (zend_ast_ref*)p;
 
-				zend_ast_destroy(ast->ast);
+				zend_ast_destroy_and_free(ast->ast);
 				efree(ast);
 				break;
 			}
diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index 8358ff5862..1586b4441c 100644
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -1318,7 +1318,7 @@ ZEND_VM_HANDLER(87, ZEND_FETCH_DIM_RW, VAR|CV, CONST|TMP|VAR|UNUSED|CV)
 	ZEND_VM_NEXT_OPCODE();
 }
 
-ZEND_VM_HANDLER(90, ZEND_FETCH_DIM_IS, VAR|CV, CONST|TMP|VAR|CV)
+ZEND_VM_HANDLER(90, ZEND_FETCH_DIM_IS, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
@@ -1333,7 +1333,7 @@ ZEND_VM_HANDLER(90, ZEND_FETCH_DIM_IS, VAR|CV, CONST|TMP|VAR|CV)
 	ZEND_VM_NEXT_OPCODE();
 }
 
-ZEND_VM_HANDLER(93, ZEND_FETCH_DIM_FUNC_ARG, VAR|CV, CONST|TMP|VAR|UNUSED|CV)
+ZEND_VM_HANDLER(93, ZEND_FETCH_DIM_FUNC_ARG, CONST|TMP|VAR|CV, CONST|TMP|VAR|UNUSED|CV)
 {
 	USE_OPLINE
 	zval *container;
@@ -1342,6 +1342,9 @@ ZEND_VM_HANDLER(93, ZEND_FETCH_DIM_FUNC_ARG, VAR|CV, CONST|TMP|VAR|UNUSED|CV)
 	SAVE_OPLINE();
 
 	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
+        if (OP1_TYPE == IS_CONST || OP1_TYPE == IS_TMP_VAR) {
+            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
+        }
 		container = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
 		if (OP1_TYPE == IS_VAR && UNEXPECTED(container == NULL)) {
 			zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
@@ -1387,7 +1390,7 @@ ZEND_VM_HANDLER(96, ZEND_FETCH_DIM_UNSET, VAR|CV, CONST|TMP|VAR|CV)
 	ZEND_VM_NEXT_OPCODE();
 }
 
-ZEND_VM_HELPER(zend_fetch_property_address_read_helper, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
+ZEND_VM_HELPER(zend_fetch_property_address_read_helper, CONST|TMP|VAR|UNUSED|CV, CONST|TMP|VAR|CV)
 {
 	USE_OPLINE
 	zend_free_op free_op1;
@@ -1420,7 +1423,7 @@ ZEND_VM_HELPER(zend_fetch_property_address_read_helper, VAR|UNUSED|CV, CONST|TMP
 	ZEND_VM_NEXT_OPCODE();
 }
 
-ZEND_VM_HANDLER(82, ZEND_FETCH_OBJ_R, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
+ZEND_VM_HANDLER(82, ZEND_FETCH_OBJ_R, CONST|TMP|VAR|UNUSED|CV, CONST|TMP|VAR|CV)
 {
 	ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_property_address_read_helper);
 }
@@ -1474,7 +1477,7 @@ ZEND_VM_HANDLER(88, ZEND_FETCH_OBJ_RW, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
 	ZEND_VM_NEXT_OPCODE();
 }
 
-ZEND_VM_HANDLER(91, ZEND_FETCH_OBJ_IS, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
+ZEND_VM_HANDLER(91, ZEND_FETCH_OBJ_IS, CONST|TMP|VAR|UNUSED|CV, CONST|TMP|VAR|CV)
 {
 	USE_OPLINE
 	zend_free_op free_op1;
@@ -1506,7 +1509,7 @@ ZEND_VM_HANDLER(91, ZEND_FETCH_OBJ_IS, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
 	ZEND_VM_NEXT_OPCODE();
 }
 
-ZEND_VM_HANDLER(94, ZEND_FETCH_OBJ_FUNC_ARG, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
+ZEND_VM_HANDLER(94, ZEND_FETCH_OBJ_FUNC_ARG, CONST|TMP|VAR|UNUSED|CV, CONST|TMP|VAR|CV)
 {
 	USE_OPLINE
 	zval *container;
@@ -1520,6 +1523,9 @@ ZEND_VM_HANDLER(94, ZEND_FETCH_OBJ_FUNC_ARG, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
 		property = GET_OP2_ZVAL_PTR(BP_VAR_R);
 		container = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_W);
 
+        if (OP1_TYPE == IS_CONST || OP1_TYPE == IS_TMP_VAR) {
+            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
+        }
 		if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 		}
@@ -2382,7 +2388,7 @@ ZEND_VM_HANDLER(59, ZEND_INIT_FCALL_BY_NAME, ANY, CONST|TMP|VAR|CV)
 	zend_function *fbc;
 	zval *function_name, *func;
 
-	if (OP2_TYPE == IS_CONST) {
+	if (OP2_TYPE == IS_CONST && Z_TYPE_P(opline->op2.zv) == IS_STRING) {
 		function_name = (zval*)(opline->op2.zv+1);
 		if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
 			fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
@@ -2423,10 +2429,11 @@ ZEND_VM_HANDLER(59, ZEND_INIT_FCALL_BY_NAME, ANY, CONST|TMP|VAR|CV)
 			}
 			zend_string_free(lcname);
 			FREE_OP2();
+
 			fbc = Z_FUNC_P(func);
 			called_scope = NULL;
 			object = NULL;
-		} else if (OP2_TYPE != IS_CONST && OP2_TYPE != IS_TMP_VAR &&
+		} else if (OP2_TYPE != IS_CONST &&
 		    EXPECTED(Z_TYPE_P(function_name) == IS_OBJECT) &&
 			Z_OBJ_HANDLER_P(function_name, get_closure) &&
 			Z_OBJ_HANDLER_P(function_name, get_closure)(function_name, &called_scope, &fbc, &object TSRMLS_CC) == SUCCESS) {
@@ -2437,11 +2444,10 @@ ZEND_VM_HANDLER(59, ZEND_INIT_FCALL_BY_NAME, ANY, CONST|TMP|VAR|CV)
 			    fbc->common.fn_flags & ZEND_ACC_CLOSURE) {
 				/* Delay closure destruction until its invocation */
 				fbc->common.prototype = (zend_function*)Z_OBJ_P(function_name_ptr);
-			} else {
+			} else if (OP2_TYPE == IS_CV) {
 				FREE_OP2();
 			}
-		} else if (OP2_TYPE != IS_CONST &&
-				EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY) &&
+		} else if (EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY) &&
 				zend_hash_num_elements(Z_ARRVAL_P(function_name)) == 2) {
 			zval *obj;
 			zval *method;
@@ -4868,7 +4874,7 @@ ZEND_VM_HANDLER(114, ZEND_ISSET_ISEMPTY_VAR, CONST|TMP|VAR|CV, UNUSED|CONST|VAR)
 	ZEND_VM_NEXT_OPCODE();
 }
 
-ZEND_VM_HANDLER(115, ZEND_ISSET_ISEMPTY_DIM_OBJ, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
+ZEND_VM_HANDLER(115, ZEND_ISSET_ISEMPTY_DIM_OBJ, CONST|TMP|VAR|UNUSED|CV, CONST|TMP|VAR|CV)
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
@@ -4977,12 +4983,12 @@ ZEND_VM_C_LABEL(num_index_prop):
 
 	FREE_OP2();
 	ZVAL_BOOL(EX_VAR(opline->result.var), result);
-	FREE_OP1_IF_VAR();
+	FREE_OP1();
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
 
-ZEND_VM_HANDLER(148, ZEND_ISSET_ISEMPTY_PROP_OBJ, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
+ZEND_VM_HANDLER(148, ZEND_ISSET_ISEMPTY_PROP_OBJ, CONST|TMP|VAR|UNUSED|CV, CONST|TMP|VAR|CV)
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
@@ -5010,7 +5016,7 @@ ZEND_VM_HANDLER(148, ZEND_ISSET_ISEMPTY_PROP_OBJ, VAR|UNUSED|CV, CONST|TMP|VAR|C
 
 	FREE_OP2();
 	ZVAL_BOOL(EX_VAR(opline->result.var), result);
-	FREE_OP1_IF_VAR();
+	FREE_OP1();
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -5945,8 +5951,8 @@ ZEND_VM_HANDLER(123, ZEND_TYPE_CHECK, CONST|TMP|VAR|CV, ANY)
 			} else {
 				ZVAL_FALSE(EX_VAR(opline->result.var));
 			}
+			break;
 		EMPTY_SWITCH_DEFAULT_CASE()
-
 	}
 	FREE_OP1();
 	CHECK_EXCEPTION();
diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index 08e6205978..b772753ea4 100644
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -1553,7 +1553,7 @@ static int ZEND_FASTCALL  ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE
 	zend_function *fbc;
 	zval *function_name, *func;
 
-	if (IS_CONST == IS_CONST) {
+	if (IS_CONST == IS_CONST && Z_TYPE_P(opline->op2.zv) == IS_STRING) {
 		function_name = (zval*)(opline->op2.zv+1);
 		if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
 			fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
@@ -1597,7 +1597,7 @@ static int ZEND_FASTCALL  ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE
 			fbc = Z_FUNC_P(func);
 			called_scope = NULL;
 			object = NULL;
-		} else if (IS_CONST != IS_CONST && IS_CONST != IS_TMP_VAR &&
+		} else if (IS_CONST != IS_CONST &&
 		    EXPECTED(Z_TYPE_P(function_name) == IS_OBJECT) &&
 			Z_OBJ_HANDLER_P(function_name, get_closure) &&
 			Z_OBJ_HANDLER_P(function_name, get_closure)(function_name, &called_scope, &fbc, &object TSRMLS_CC) == SUCCESS) {
@@ -1608,11 +1608,10 @@ static int ZEND_FASTCALL  ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE
 			    fbc->common.fn_flags & ZEND_ACC_CLOSURE) {
 				/* Delay closure destruction until its invocation */
 				fbc->common.prototype = (zend_function*)Z_OBJ_P(function_name_ptr);
-			} else {
+			} else if (IS_CONST == IS_CV) {
 
 			}
-		} else if (IS_CONST != IS_CONST &&
-				EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY) &&
+		} else if (EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY) &&
 				zend_hash_num_elements(Z_ARRVAL_P(function_name)) == 2) {
 			zval *obj;
 			zval *method;
@@ -1882,7 +1881,7 @@ static int ZEND_FASTCALL  ZEND_INIT_FCALL_BY_NAME_SPEC_TMP_HANDLER(ZEND_OPCODE_H
 	zend_function *fbc;
 	zval *function_name, *func;
 
-	if (IS_TMP_VAR == IS_CONST) {
+	if (IS_TMP_VAR == IS_CONST && Z_TYPE_P(opline->op2.zv) == IS_STRING) {
 		function_name = (zval*)(opline->op2.zv+1);
 		if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
 			fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
@@ -1923,10 +1922,11 @@ static int ZEND_FASTCALL  ZEND_INIT_FCALL_BY_NAME_SPEC_TMP_HANDLER(ZEND_OPCODE_H
 			}
 			zend_string_free(lcname);
 			zval_dtor(free_op2.var);
+
 			fbc = Z_FUNC_P(func);
 			called_scope = NULL;
 			object = NULL;
-		} else if (IS_TMP_VAR != IS_CONST && IS_TMP_VAR != IS_TMP_VAR &&
+		} else if (IS_TMP_VAR != IS_CONST &&
 		    EXPECTED(Z_TYPE_P(function_name) == IS_OBJECT) &&
 			Z_OBJ_HANDLER_P(function_name, get_closure) &&
 			Z_OBJ_HANDLER_P(function_name, get_closure)(function_name, &called_scope, &fbc, &object TSRMLS_CC) == SUCCESS) {
@@ -1937,11 +1937,10 @@ static int ZEND_FASTCALL  ZEND_INIT_FCALL_BY_NAME_SPEC_TMP_HANDLER(ZEND_OPCODE_H
 			    fbc->common.fn_flags & ZEND_ACC_CLOSURE) {
 				/* Delay closure destruction until its invocation */
 				fbc->common.prototype = (zend_function*)Z_OBJ_P(function_name_ptr);
-			} else {
+			} else if (IS_TMP_VAR == IS_CV) {
 				zval_dtor(free_op2.var);
 			}
-		} else if (IS_TMP_VAR != IS_CONST &&
-				EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY) &&
+		} else if (EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY) &&
 				zend_hash_num_elements(Z_ARRVAL_P(function_name)) == 2) {
 			zval *obj;
 			zval *method;
@@ -2056,7 +2055,7 @@ static int ZEND_FASTCALL  ZEND_INIT_FCALL_BY_NAME_SPEC_VAR_HANDLER(ZEND_OPCODE_H
 	zend_function *fbc;
 	zval *function_name, *func;
 
-	if (IS_VAR == IS_CONST) {
+	if (IS_VAR == IS_CONST && Z_TYPE_P(opline->op2.zv) == IS_STRING) {
 		function_name = (zval*)(opline->op2.zv+1);
 		if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
 			fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
@@ -2097,10 +2096,11 @@ static int ZEND_FASTCALL  ZEND_INIT_FCALL_BY_NAME_SPEC_VAR_HANDLER(ZEND_OPCODE_H
 			}
 			zend_string_free(lcname);
 			zval_ptr_dtor_nogc(free_op2.var);
+
 			fbc = Z_FUNC_P(func);
 			called_scope = NULL;
 			object = NULL;
-		} else if (IS_VAR != IS_CONST && IS_VAR != IS_TMP_VAR &&
+		} else if (IS_VAR != IS_CONST &&
 		    EXPECTED(Z_TYPE_P(function_name) == IS_OBJECT) &&
 			Z_OBJ_HANDLER_P(function_name, get_closure) &&
 			Z_OBJ_HANDLER_P(function_name, get_closure)(function_name, &called_scope, &fbc, &object TSRMLS_CC) == SUCCESS) {
@@ -2111,11 +2111,10 @@ static int ZEND_FASTCALL  ZEND_INIT_FCALL_BY_NAME_SPEC_VAR_HANDLER(ZEND_OPCODE_H
 			    fbc->common.fn_flags & ZEND_ACC_CLOSURE) {
 				/* Delay closure destruction until its invocation */
 				fbc->common.prototype = (zend_function*)Z_OBJ_P(function_name_ptr);
-			} else {
+			} else if (IS_VAR == IS_CV) {
 				zval_ptr_dtor_nogc(free_op2.var);
 			}
-		} else if (IS_VAR != IS_CONST &&
-				EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY) &&
+		} else if (EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY) &&
 				zend_hash_num_elements(Z_ARRVAL_P(function_name)) == 2) {
 			zval *obj;
 			zval *method;
@@ -2268,7 +2267,7 @@ static int ZEND_FASTCALL  ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER(ZEND_OPCODE_HA
 	zend_function *fbc;
 	zval *function_name, *func;
 
-	if (IS_CV == IS_CONST) {
+	if (IS_CV == IS_CONST && Z_TYPE_P(opline->op2.zv) == IS_STRING) {
 		function_name = (zval*)(opline->op2.zv+1);
 		if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
 			fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
@@ -2312,7 +2311,7 @@ static int ZEND_FASTCALL  ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER(ZEND_OPCODE_HA
 			fbc = Z_FUNC_P(func);
 			called_scope = NULL;
 			object = NULL;
-		} else if (IS_CV != IS_CONST && IS_CV != IS_TMP_VAR &&
+		} else if (IS_CV != IS_CONST &&
 		    EXPECTED(Z_TYPE_P(function_name) == IS_OBJECT) &&
 			Z_OBJ_HANDLER_P(function_name, get_closure) &&
 			Z_OBJ_HANDLER_P(function_name, get_closure)(function_name, &called_scope, &fbc, &object TSRMLS_CC) == SUCCESS) {
@@ -2323,11 +2322,10 @@ static int ZEND_FASTCALL  ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER(ZEND_OPCODE_HA
 			    fbc->common.fn_flags & ZEND_ACC_CLOSURE) {
 				/* Delay closure destruction until its invocation */
 				fbc->common.prototype = (zend_function*)Z_OBJ_P(function_name_ptr);
-			} else {
+			} else if (IS_CV == IS_CV) {
 
 			}
-		} else if (IS_CV != IS_CONST &&
-				EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY) &&
+		} else if (EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY) &&
 				zend_hash_num_elements(Z_ARRVAL_P(function_name)) == 2) {
 			zval *obj;
 			zval *method;
@@ -3450,8 +3448,8 @@ static int ZEND_FASTCALL  ZEND_TYPE_CHECK_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER
 			} else {
 				ZVAL_FALSE(EX_VAR(opline->result.var));
 			}
+			break;
 		EMPTY_SWITCH_DEFAULT_CASE()
-
 	}
 
 	CHECK_EXCEPTION();
@@ -3923,6 +3921,157 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_
 	ZEND_VM_NEXT_OPCODE();
 }
 
+static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+
+	zval *container;
+
+	SAVE_OPLINE();
+	container = opline->op1.zv;
+	zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC);
+
+
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *container;
+	zend_free_op free_op1;
+
+	SAVE_OPLINE();
+
+	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
+        if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) {
+            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
+        }
+		container = NULL;
+		if (IS_CONST == IS_VAR && UNEXPECTED(container == NULL)) {
+			zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
+		}
+		zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC);
+		if (IS_CONST == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
+			EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
+		}
+
+
+	} else {
+		if (IS_CONST == IS_UNUSED) {
+			zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
+		}
+		container = opline->op1.zv;
+		zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC);
+
+
+	}
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CONST_CONST(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+
+	zval *container;
+
+	zval *offset;
+
+	SAVE_OPLINE();
+	container = opline->op1.zv;
+	offset  = opline->op2.zv;
+
+	if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
+	    UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
+		zend_error(E_NOTICE, "Trying to get property of non-object");
+		ZVAL_NULL(EX_VAR(opline->result.var));
+	} else {
+		zval *retval;
+
+		/* here we are sure we are dealing with an object */
+		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC);
+
+		if (retval != EX_VAR(opline->result.var)) {
+			ZVAL_COPY(EX_VAR(opline->result.var), retval);
+		}
+	}
+
+
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_OBJ_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	return zend_fetch_property_address_read_helper_SPEC_CONST_CONST(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+
+	zval *container;
+
+	zval *offset;
+
+	SAVE_OPLINE();
+	container = opline->op1.zv;
+	offset  = opline->op2.zv;
+
+	if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
+	    UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
+		ZVAL_NULL(EX_VAR(opline->result.var));
+	} else {
+		zval *retval;
+
+		/* here we are sure we are dealing with an object */
+		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC);
+
+		if (retval != EX_VAR(opline->result.var)) {
+			ZVAL_COPY(EX_VAR(opline->result.var), retval);
+		}
+	}
+
+
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *container;
+
+	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
+		/* Behave like FETCH_OBJ_W */
+		zend_free_op free_op1;
+		zval *property;
+
+		SAVE_OPLINE();
+		property = opline->op2.zv;
+		container = NULL;
+
+        if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) {
+            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
+        }
+		if (IS_CONST == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
+			zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
+		}
+		zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W, 0 TSRMLS_CC);
+
+		if (IS_CONST == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
+			EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
+		}
+
+		CHECK_EXCEPTION();
+		ZEND_VM_NEXT_OPCODE();
+	} else {
+		return zend_fetch_property_address_read_helper_SPEC_CONST_CONST(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
+}
+
 static int ZEND_FASTCALL  ZEND_FETCH_DIM_TMP_VAR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -4485,6 +4634,151 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_CONST_HANDLER(ZEND_O
 	ZEND_VM_NEXT_OPCODE();
 }
 
+static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+
+	zval *container;
+	int result;
+	zend_ulong hval;
+	zval *offset;
+
+	SAVE_OPLINE();
+	container = opline->op1.zv;
+	offset = opline->op2.zv;
+
+	if (Z_TYPE_P(container) == IS_ARRAY) {
+		HashTable *ht = Z_ARRVAL_P(container);
+		zval *value;
+		zend_string *str;
+
+isset_again:
+		if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
+			str = Z_STR_P(offset);
+			if (IS_CONST != IS_CONST) {
+				if (ZEND_HANDLE_NUMERIC(str, hval)) {
+					goto num_index_prop;
+				}
+			}
+str_index_prop:
+			value = zend_hash_find_ind(ht, str);
+		} else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
+			hval = Z_LVAL_P(offset);
+num_index_prop:
+			value = zend_hash_index_find(ht, hval);
+		} else {
+			switch (Z_TYPE_P(offset)) {
+				case IS_DOUBLE:
+					hval = zend_dval_to_lval(Z_DVAL_P(offset));
+					goto num_index_prop;
+				case IS_NULL:
+					str = STR_EMPTY_ALLOC();
+					goto str_index_prop;
+				case IS_FALSE:
+					hval = 0;
+					goto num_index_prop;
+				case IS_TRUE:
+					hval = 1;
+					goto num_index_prop;
+				case IS_RESOURCE:
+					hval = Z_RES_HANDLE_P(offset);
+					goto num_index_prop;
+				case IS_REFERENCE:
+					offset = Z_REFVAL_P(offset);
+					goto isset_again;
+				default:
+					zend_error(E_WARNING, "Illegal offset type in isset or empty");
+					value = NULL;
+					break;
+			}
+		}
+
+		if (opline->extended_value & ZEND_ISSET) {
+			/* > IS_NULL means not IS_UNDEF and not IS_NULL */
+			result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
+			    (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
+		} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
+			result = (value == NULL || !i_zend_is_true(value TSRMLS_CC));
+		}
+	} else if (Z_TYPE_P(container) == IS_OBJECT) {
+		if (Z_OBJ_HT_P(container)->has_dimension) {
+			result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC);
+		} else {
+			zend_error(E_NOTICE, "Trying to check element of non-array");
+			result = 0;
+		}
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
+	} else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */
+		zval tmp;
+
+		result = 0;
+		if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) {
+			if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
+				ZVAL_DEREF(offset);
+			}
+			if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
+					|| (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
+						&& IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
+				ZVAL_DUP(&tmp, offset);
+				convert_to_long(&tmp);
+				offset = &tmp;
+			}
+		}
+		if (Z_TYPE_P(offset) == IS_LONG) {
+			if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
+				if ((opline->extended_value & ZEND_ISSET) ||
+				    Z_STRVAL_P(container)[offset->value.lval] != '0') {
+					result = 1;
+				}
+			}
+		}
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
+	} else {
+		result = ((opline->extended_value & ZEND_ISSET) == 0);
+	}
+
+	ZVAL_BOOL(EX_VAR(opline->result.var), result);
+
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+
+	zval *container;
+	int result;
+	zval *offset;
+
+	SAVE_OPLINE();
+	container = opline->op1.zv;
+	offset = opline->op2.zv;
+
+	if (Z_TYPE_P(container) == IS_OBJECT) {
+		if (Z_OBJ_HT_P(container)->has_property) {
+			result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC);
+		} else {
+			zend_error(E_NOTICE, "Trying to check property of non-object");
+			result = 0;
+		}
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
+	} else {
+		result = ((opline->extended_value & ZEND_ISSET) == 0);
+	}
+
+	ZVAL_BOOL(EX_VAR(opline->result.var), result);
+
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
 static int ZEND_FASTCALL  ZEND_DECLARE_CONST_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -4955,6 +5249,159 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HA
 	ZEND_VM_NEXT_OPCODE();
 }
 
+static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_free_op free_op2;
+	zval *container;
+
+	SAVE_OPLINE();
+	container = opline->op1.zv;
+	zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR TSRMLS_CC);
+	zval_dtor(free_op2.var);
+
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *container;
+	zend_free_op free_op1, free_op2;
+
+	SAVE_OPLINE();
+
+	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
+        if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) {
+            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
+        }
+		container = NULL;
+		if (IS_CONST == IS_VAR && UNEXPECTED(container == NULL)) {
+			zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
+		}
+		zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR TSRMLS_CC);
+		if (IS_CONST == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
+			EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
+		}
+		zval_dtor(free_op2.var);
+
+	} else {
+		if (IS_TMP_VAR == IS_UNUSED) {
+			zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
+		}
+		container = opline->op1.zv;
+		zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR TSRMLS_CC);
+		zval_dtor(free_op2.var);
+
+	}
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CONST_TMP(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+
+	zval *container;
+	zend_free_op free_op2;
+	zval *offset;
+
+	SAVE_OPLINE();
+	container = opline->op1.zv;
+	offset  = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+
+	if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
+	    UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
+		zend_error(E_NOTICE, "Trying to get property of non-object");
+		ZVAL_NULL(EX_VAR(opline->result.var));
+	} else {
+		zval *retval;
+
+		/* here we are sure we are dealing with an object */
+		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC);
+
+		if (retval != EX_VAR(opline->result.var)) {
+			ZVAL_COPY(EX_VAR(opline->result.var), retval);
+		}
+	}
+
+	zval_dtor(free_op2.var);
+
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_OBJ_R_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	return zend_fetch_property_address_read_helper_SPEC_CONST_TMP(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+
+	zval *container;
+	zend_free_op free_op2;
+	zval *offset;
+
+	SAVE_OPLINE();
+	container = opline->op1.zv;
+	offset  = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+
+	if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
+	    UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
+		ZVAL_NULL(EX_VAR(opline->result.var));
+	} else {
+		zval *retval;
+
+		/* here we are sure we are dealing with an object */
+		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_TMP_VAR == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC);
+
+		if (retval != EX_VAR(opline->result.var)) {
+			ZVAL_COPY(EX_VAR(opline->result.var), retval);
+		}
+	}
+
+	zval_dtor(free_op2.var);
+
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *container;
+
+	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
+		/* Behave like FETCH_OBJ_W */
+		zend_free_op free_op1, free_op2;
+		zval *property;
+
+		SAVE_OPLINE();
+		property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+		container = NULL;
+
+        if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) {
+            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
+        }
+		if (IS_CONST == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
+			zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
+		}
+		zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W, 0 TSRMLS_CC);
+		zval_dtor(free_op2.var);
+		if (IS_CONST == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
+			EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
+		}
+
+		CHECK_EXCEPTION();
+		ZEND_VM_NEXT_OPCODE();
+	} else {
+		return zend_fetch_property_address_read_helper_SPEC_CONST_TMP(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
+}
+
 static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -5248,6 +5695,153 @@ static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HAN
 	}
 }
 
+static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_free_op free_op2;
+	zval *container;
+	int result;
+	zend_ulong hval;
+	zval *offset;
+
+	SAVE_OPLINE();
+	container = opline->op1.zv;
+	offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+
+	if (Z_TYPE_P(container) == IS_ARRAY) {
+		HashTable *ht = Z_ARRVAL_P(container);
+		zval *value;
+		zend_string *str;
+
+isset_again:
+		if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
+			str = Z_STR_P(offset);
+			if (IS_TMP_VAR != IS_CONST) {
+				if (ZEND_HANDLE_NUMERIC(str, hval)) {
+					goto num_index_prop;
+				}
+			}
+str_index_prop:
+			value = zend_hash_find_ind(ht, str);
+		} else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
+			hval = Z_LVAL_P(offset);
+num_index_prop:
+			value = zend_hash_index_find(ht, hval);
+		} else {
+			switch (Z_TYPE_P(offset)) {
+				case IS_DOUBLE:
+					hval = zend_dval_to_lval(Z_DVAL_P(offset));
+					goto num_index_prop;
+				case IS_NULL:
+					str = STR_EMPTY_ALLOC();
+					goto str_index_prop;
+				case IS_FALSE:
+					hval = 0;
+					goto num_index_prop;
+				case IS_TRUE:
+					hval = 1;
+					goto num_index_prop;
+				case IS_RESOURCE:
+					hval = Z_RES_HANDLE_P(offset);
+					goto num_index_prop;
+				case IS_REFERENCE:
+					offset = Z_REFVAL_P(offset);
+					goto isset_again;
+				default:
+					zend_error(E_WARNING, "Illegal offset type in isset or empty");
+					value = NULL;
+					break;
+			}
+		}
+
+		if (opline->extended_value & ZEND_ISSET) {
+			/* > IS_NULL means not IS_UNDEF and not IS_NULL */
+			result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
+			    (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
+		} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
+			result = (value == NULL || !i_zend_is_true(value TSRMLS_CC));
+		}
+	} else if (Z_TYPE_P(container) == IS_OBJECT) {
+		if (Z_OBJ_HT_P(container)->has_dimension) {
+			result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC);
+		} else {
+			zend_error(E_NOTICE, "Trying to check element of non-array");
+			result = 0;
+		}
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
+	} else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */
+		zval tmp;
+
+		result = 0;
+		if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) {
+			if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
+				ZVAL_DEREF(offset);
+			}
+			if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
+					|| (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
+						&& IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
+				ZVAL_DUP(&tmp, offset);
+				convert_to_long(&tmp);
+				offset = &tmp;
+			}
+		}
+		if (Z_TYPE_P(offset) == IS_LONG) {
+			if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
+				if ((opline->extended_value & ZEND_ISSET) ||
+				    Z_STRVAL_P(container)[offset->value.lval] != '0') {
+					result = 1;
+				}
+			}
+		}
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
+	} else {
+		result = ((opline->extended_value & ZEND_ISSET) == 0);
+	}
+
+	zval_dtor(free_op2.var);
+	ZVAL_BOOL(EX_VAR(opline->result.var), result);
+
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_free_op free_op2;
+	zval *container;
+	int result;
+	zval *offset;
+
+	SAVE_OPLINE();
+	container = opline->op1.zv;
+	offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+
+	if (Z_TYPE_P(container) == IS_OBJECT) {
+		if (Z_OBJ_HT_P(container)->has_property) {
+			result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_TMP_VAR == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC);
+		} else {
+			zend_error(E_NOTICE, "Trying to check property of non-object");
+			result = 0;
+		}
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
+	} else {
+		result = ((opline->extended_value & ZEND_ISSET) == 0);
+	}
+
+	zval_dtor(free_op2.var);
+	ZVAL_BOOL(EX_VAR(opline->result.var), result);
+
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
 static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -5838,6 +6432,159 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HA
 	ZEND_VM_NEXT_OPCODE();
 }
 
+static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_free_op free_op2;
+	zval *container;
+
+	SAVE_OPLINE();
+	container = opline->op1.zv;
+	zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR TSRMLS_CC);
+	zval_ptr_dtor_nogc(free_op2.var);
+
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *container;
+	zend_free_op free_op1, free_op2;
+
+	SAVE_OPLINE();
+
+	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
+        if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) {
+            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
+        }
+		container = NULL;
+		if (IS_CONST == IS_VAR && UNEXPECTED(container == NULL)) {
+			zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
+		}
+		zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR TSRMLS_CC);
+		if (IS_CONST == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
+			EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
+		}
+		zval_ptr_dtor_nogc(free_op2.var);
+
+	} else {
+		if (IS_VAR == IS_UNUSED) {
+			zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
+		}
+		container = opline->op1.zv;
+		zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR TSRMLS_CC);
+		zval_ptr_dtor_nogc(free_op2.var);
+
+	}
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CONST_VAR(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+
+	zval *container;
+	zend_free_op free_op2;
+	zval *offset;
+
+	SAVE_OPLINE();
+	container = opline->op1.zv;
+	offset  = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+
+	if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
+	    UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
+		zend_error(E_NOTICE, "Trying to get property of non-object");
+		ZVAL_NULL(EX_VAR(opline->result.var));
+	} else {
+		zval *retval;
+
+		/* here we are sure we are dealing with an object */
+		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_VAR == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC);
+
+		if (retval != EX_VAR(opline->result.var)) {
+			ZVAL_COPY(EX_VAR(opline->result.var), retval);
+		}
+	}
+
+	zval_ptr_dtor_nogc(free_op2.var);
+
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_OBJ_R_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	return zend_fetch_property_address_read_helper_SPEC_CONST_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+
+	zval *container;
+	zend_free_op free_op2;
+	zval *offset;
+
+	SAVE_OPLINE();
+	container = opline->op1.zv;
+	offset  = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+
+	if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
+	    UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
+		ZVAL_NULL(EX_VAR(opline->result.var));
+	} else {
+		zval *retval;
+
+		/* here we are sure we are dealing with an object */
+		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_VAR == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC);
+
+		if (retval != EX_VAR(opline->result.var)) {
+			ZVAL_COPY(EX_VAR(opline->result.var), retval);
+		}
+	}
+
+	zval_ptr_dtor_nogc(free_op2.var);
+
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *container;
+
+	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
+		/* Behave like FETCH_OBJ_W */
+		zend_free_op free_op1, free_op2;
+		zval *property;
+
+		SAVE_OPLINE();
+		property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+		container = NULL;
+
+        if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) {
+            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
+        }
+		if (IS_CONST == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
+			zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
+		}
+		zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W, 0 TSRMLS_CC);
+		zval_ptr_dtor_nogc(free_op2.var);
+		if (IS_CONST == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
+			EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
+		}
+
+		CHECK_EXCEPTION();
+		ZEND_VM_NEXT_OPCODE();
+	} else {
+		return zend_fetch_property_address_read_helper_SPEC_CONST_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
+}
+
 static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -6283,6 +7030,153 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_VAR_HANDLER(ZEND_OPC
 	ZEND_VM_NEXT_OPCODE();
 }
 
+static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_free_op free_op2;
+	zval *container;
+	int result;
+	zend_ulong hval;
+	zval *offset;
+
+	SAVE_OPLINE();
+	container = opline->op1.zv;
+	offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+
+	if (Z_TYPE_P(container) == IS_ARRAY) {
+		HashTable *ht = Z_ARRVAL_P(container);
+		zval *value;
+		zend_string *str;
+
+isset_again:
+		if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
+			str = Z_STR_P(offset);
+			if (IS_VAR != IS_CONST) {
+				if (ZEND_HANDLE_NUMERIC(str, hval)) {
+					goto num_index_prop;
+				}
+			}
+str_index_prop:
+			value = zend_hash_find_ind(ht, str);
+		} else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
+			hval = Z_LVAL_P(offset);
+num_index_prop:
+			value = zend_hash_index_find(ht, hval);
+		} else {
+			switch (Z_TYPE_P(offset)) {
+				case IS_DOUBLE:
+					hval = zend_dval_to_lval(Z_DVAL_P(offset));
+					goto num_index_prop;
+				case IS_NULL:
+					str = STR_EMPTY_ALLOC();
+					goto str_index_prop;
+				case IS_FALSE:
+					hval = 0;
+					goto num_index_prop;
+				case IS_TRUE:
+					hval = 1;
+					goto num_index_prop;
+				case IS_RESOURCE:
+					hval = Z_RES_HANDLE_P(offset);
+					goto num_index_prop;
+				case IS_REFERENCE:
+					offset = Z_REFVAL_P(offset);
+					goto isset_again;
+				default:
+					zend_error(E_WARNING, "Illegal offset type in isset or empty");
+					value = NULL;
+					break;
+			}
+		}
+
+		if (opline->extended_value & ZEND_ISSET) {
+			/* > IS_NULL means not IS_UNDEF and not IS_NULL */
+			result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
+			    (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
+		} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
+			result = (value == NULL || !i_zend_is_true(value TSRMLS_CC));
+		}
+	} else if (Z_TYPE_P(container) == IS_OBJECT) {
+		if (Z_OBJ_HT_P(container)->has_dimension) {
+			result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC);
+		} else {
+			zend_error(E_NOTICE, "Trying to check element of non-array");
+			result = 0;
+		}
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
+	} else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */
+		zval tmp;
+
+		result = 0;
+		if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) {
+			if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
+				ZVAL_DEREF(offset);
+			}
+			if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
+					|| (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
+						&& IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
+				ZVAL_DUP(&tmp, offset);
+				convert_to_long(&tmp);
+				offset = &tmp;
+			}
+		}
+		if (Z_TYPE_P(offset) == IS_LONG) {
+			if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
+				if ((opline->extended_value & ZEND_ISSET) ||
+				    Z_STRVAL_P(container)[offset->value.lval] != '0') {
+					result = 1;
+				}
+			}
+		}
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
+	} else {
+		result = ((opline->extended_value & ZEND_ISSET) == 0);
+	}
+
+	zval_ptr_dtor_nogc(free_op2.var);
+	ZVAL_BOOL(EX_VAR(opline->result.var), result);
+
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_free_op free_op2;
+	zval *container;
+	int result;
+	zval *offset;
+
+	SAVE_OPLINE();
+	container = opline->op1.zv;
+	offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+
+	if (Z_TYPE_P(container) == IS_OBJECT) {
+		if (Z_OBJ_HT_P(container)->has_property) {
+			result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_VAR == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC);
+		} else {
+			zend_error(E_NOTICE, "Trying to check property of non-object");
+			result = 0;
+		}
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
+	} else {
+		result = ((opline->extended_value & ZEND_ISSET) == 0);
+	}
+
+	zval_ptr_dtor_nogc(free_op2.var);
+	ZVAL_BOOL(EX_VAR(opline->result.var), result);
+
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
 static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -6581,6 +7475,41 @@ static int ZEND_FASTCALL  ZEND_FETCH_IS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HA
 	return zend_fetch_var_address_helper_SPEC_CONST_UNUSED(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 }
 
+static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *container;
+	zend_free_op free_op1;
+
+	SAVE_OPLINE();
+
+	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
+        if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) {
+            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
+        }
+		container = NULL;
+		if (IS_CONST == IS_VAR && UNEXPECTED(container == NULL)) {
+			zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
+		}
+		zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, NULL, IS_UNUSED TSRMLS_CC);
+		if (IS_CONST == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
+			EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
+		}
+
+
+	} else {
+		if (IS_UNUSED == IS_UNUSED) {
+			zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
+		}
+		container = opline->op1.zv;
+		zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, NULL, IS_UNUSED TSRMLS_CC);
+
+
+	}
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
 static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -7415,6 +8344,157 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HAN
 	ZEND_VM_NEXT_OPCODE();
 }
 
+static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+
+	zval *container;
+
+	SAVE_OPLINE();
+	container = opline->op1.zv;
+	zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
+
+
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *container;
+	zend_free_op free_op1;
+
+	SAVE_OPLINE();
+
+	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
+        if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) {
+            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
+        }
+		container = NULL;
+		if (IS_CONST == IS_VAR && UNEXPECTED(container == NULL)) {
+			zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
+		}
+		zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
+		if (IS_CONST == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
+			EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
+		}
+
+
+	} else {
+		if (IS_CV == IS_UNUSED) {
+			zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
+		}
+		container = opline->op1.zv;
+		zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
+
+
+	}
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CONST_CV(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+
+	zval *container;
+
+	zval *offset;
+
+	SAVE_OPLINE();
+	container = opline->op1.zv;
+	offset  = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
+
+	if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
+	    UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
+		zend_error(E_NOTICE, "Trying to get property of non-object");
+		ZVAL_NULL(EX_VAR(opline->result.var));
+	} else {
+		zval *retval;
+
+		/* here we are sure we are dealing with an object */
+		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC);
+
+		if (retval != EX_VAR(opline->result.var)) {
+			ZVAL_COPY(EX_VAR(opline->result.var), retval);
+		}
+	}
+
+
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_OBJ_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	return zend_fetch_property_address_read_helper_SPEC_CONST_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+
+	zval *container;
+
+	zval *offset;
+
+	SAVE_OPLINE();
+	container = opline->op1.zv;
+	offset  = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
+
+	if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
+	    UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
+		ZVAL_NULL(EX_VAR(opline->result.var));
+	} else {
+		zval *retval;
+
+		/* here we are sure we are dealing with an object */
+		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC);
+
+		if (retval != EX_VAR(opline->result.var)) {
+			ZVAL_COPY(EX_VAR(opline->result.var), retval);
+		}
+	}
+
+
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *container;
+
+	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
+		/* Behave like FETCH_OBJ_W */
+		zend_free_op free_op1;
+		zval *property;
+
+		SAVE_OPLINE();
+		property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
+		container = NULL;
+
+        if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) {
+            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
+        }
+		if (IS_CONST == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
+			zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
+		}
+		zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W, 0 TSRMLS_CC);
+
+		if (IS_CONST == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
+			EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
+		}
+
+		CHECK_EXCEPTION();
+		ZEND_VM_NEXT_OPCODE();
+	} else {
+		return zend_fetch_property_address_read_helper_SPEC_CONST_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
+}
+
 static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -7759,6 +8839,151 @@ static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HAND
 	}
 }
 
+static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+
+	zval *container;
+	int result;
+	zend_ulong hval;
+	zval *offset;
+
+	SAVE_OPLINE();
+	container = opline->op1.zv;
+	offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
+
+	if (Z_TYPE_P(container) == IS_ARRAY) {
+		HashTable *ht = Z_ARRVAL_P(container);
+		zval *value;
+		zend_string *str;
+
+isset_again:
+		if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
+			str = Z_STR_P(offset);
+			if (IS_CV != IS_CONST) {
+				if (ZEND_HANDLE_NUMERIC(str, hval)) {
+					goto num_index_prop;
+				}
+			}
+str_index_prop:
+			value = zend_hash_find_ind(ht, str);
+		} else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
+			hval = Z_LVAL_P(offset);
+num_index_prop:
+			value = zend_hash_index_find(ht, hval);
+		} else {
+			switch (Z_TYPE_P(offset)) {
+				case IS_DOUBLE:
+					hval = zend_dval_to_lval(Z_DVAL_P(offset));
+					goto num_index_prop;
+				case IS_NULL:
+					str = STR_EMPTY_ALLOC();
+					goto str_index_prop;
+				case IS_FALSE:
+					hval = 0;
+					goto num_index_prop;
+				case IS_TRUE:
+					hval = 1;
+					goto num_index_prop;
+				case IS_RESOURCE:
+					hval = Z_RES_HANDLE_P(offset);
+					goto num_index_prop;
+				case IS_REFERENCE:
+					offset = Z_REFVAL_P(offset);
+					goto isset_again;
+				default:
+					zend_error(E_WARNING, "Illegal offset type in isset or empty");
+					value = NULL;
+					break;
+			}
+		}
+
+		if (opline->extended_value & ZEND_ISSET) {
+			/* > IS_NULL means not IS_UNDEF and not IS_NULL */
+			result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
+			    (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
+		} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
+			result = (value == NULL || !i_zend_is_true(value TSRMLS_CC));
+		}
+	} else if (Z_TYPE_P(container) == IS_OBJECT) {
+		if (Z_OBJ_HT_P(container)->has_dimension) {
+			result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC);
+		} else {
+			zend_error(E_NOTICE, "Trying to check element of non-array");
+			result = 0;
+		}
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
+	} else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */
+		zval tmp;
+
+		result = 0;
+		if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) {
+			if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
+				ZVAL_DEREF(offset);
+			}
+			if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
+					|| (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
+						&& IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
+				ZVAL_DUP(&tmp, offset);
+				convert_to_long(&tmp);
+				offset = &tmp;
+			}
+		}
+		if (Z_TYPE_P(offset) == IS_LONG) {
+			if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
+				if ((opline->extended_value & ZEND_ISSET) ||
+				    Z_STRVAL_P(container)[offset->value.lval] != '0') {
+					result = 1;
+				}
+			}
+		}
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
+	} else {
+		result = ((opline->extended_value & ZEND_ISSET) == 0);
+	}
+
+	ZVAL_BOOL(EX_VAR(opline->result.var), result);
+
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+
+	zval *container;
+	int result;
+	zval *offset;
+
+	SAVE_OPLINE();
+	container = opline->op1.zv;
+	offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
+
+	if (Z_TYPE_P(container) == IS_OBJECT) {
+		if (Z_OBJ_HT_P(container)->has_property) {
+			result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC);
+		} else {
+			zend_error(E_NOTICE, "Trying to check property of non-object");
+			result = 0;
+		}
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
+	} else {
+		result = ((opline->extended_value & ZEND_ISSET) == 0);
+	}
+
+	ZVAL_BOOL(EX_VAR(opline->result.var), result);
+
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
 static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -9024,8 +10249,8 @@ static int ZEND_FASTCALL  ZEND_TYPE_CHECK_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_A
 			} else {
 				ZVAL_FALSE(EX_VAR(opline->result.var));
 			}
+			break;
 		EMPTY_SWITCH_DEFAULT_CASE()
-
 	}
 	zval_dtor(free_op1.var);
 	CHECK_EXCEPTION();
@@ -9477,6 +10702,157 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HA
 	ZEND_VM_NEXT_OPCODE();
 }
 
+static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_free_op free_op1;
+	zval *container;
+
+	SAVE_OPLINE();
+	container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC);
+
+	zval_dtor(free_op1.var);
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *container;
+	zend_free_op free_op1;
+
+	SAVE_OPLINE();
+
+	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
+        if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) {
+            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
+        }
+		container = NULL;
+		if (IS_TMP_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
+			zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
+		}
+		zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC);
+		if (IS_TMP_VAR == IS_VAR && 1 && READY_TO_DESTROY(free_op1.var)) {
+			EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
+		}
+
+
+	} else {
+		if (IS_CONST == IS_UNUSED) {
+			zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
+		}
+		container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+		zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC);
+
+		zval_dtor(free_op1.var);
+	}
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_TMP_CONST(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_free_op free_op1;
+	zval *container;
+
+	zval *offset;
+
+	SAVE_OPLINE();
+	container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	offset  = opline->op2.zv;
+
+	if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
+	    UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
+		zend_error(E_NOTICE, "Trying to get property of non-object");
+		ZVAL_NULL(EX_VAR(opline->result.var));
+	} else {
+		zval *retval;
+
+		/* here we are sure we are dealing with an object */
+		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC);
+
+		if (retval != EX_VAR(opline->result.var)) {
+			ZVAL_COPY(EX_VAR(opline->result.var), retval);
+		}
+	}
+
+	zval_dtor(free_op1.var);
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_OBJ_R_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	return zend_fetch_property_address_read_helper_SPEC_TMP_CONST(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_free_op free_op1;
+	zval *container;
+
+	zval *offset;
+
+	SAVE_OPLINE();
+	container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	offset  = opline->op2.zv;
+
+	if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
+	    UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
+		ZVAL_NULL(EX_VAR(opline->result.var));
+	} else {
+		zval *retval;
+
+		/* here we are sure we are dealing with an object */
+		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC);
+
+		if (retval != EX_VAR(opline->result.var)) {
+			ZVAL_COPY(EX_VAR(opline->result.var), retval);
+		}
+	}
+
+	zval_dtor(free_op1.var);
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *container;
+
+	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
+		/* Behave like FETCH_OBJ_W */
+		zend_free_op free_op1;
+		zval *property;
+
+		SAVE_OPLINE();
+		property = opline->op2.zv;
+		container = NULL;
+
+        if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) {
+            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
+        }
+		if (IS_TMP_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
+			zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
+		}
+		zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W, 0 TSRMLS_CC);
+
+		if (IS_TMP_VAR == IS_VAR && 1 && READY_TO_DESTROY(free_op1.var)) {
+			EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
+		}
+
+		CHECK_EXCEPTION();
+		ZEND_VM_NEXT_OPCODE();
+	} else {
+		return zend_fetch_property_address_read_helper_SPEC_TMP_CONST(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
+}
+
 static int ZEND_FASTCALL  ZEND_FETCH_DIM_TMP_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -9893,6 +11269,151 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPC
 	ZEND_VM_NEXT_OPCODE();
 }
 
+static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_free_op free_op1;
+	zval *container;
+	int result;
+	zend_ulong hval;
+	zval *offset;
+
+	SAVE_OPLINE();
+	container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	offset = opline->op2.zv;
+
+	if (Z_TYPE_P(container) == IS_ARRAY) {
+		HashTable *ht = Z_ARRVAL_P(container);
+		zval *value;
+		zend_string *str;
+
+isset_again:
+		if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
+			str = Z_STR_P(offset);
+			if (IS_CONST != IS_CONST) {
+				if (ZEND_HANDLE_NUMERIC(str, hval)) {
+					goto num_index_prop;
+				}
+			}
+str_index_prop:
+			value = zend_hash_find_ind(ht, str);
+		} else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
+			hval = Z_LVAL_P(offset);
+num_index_prop:
+			value = zend_hash_index_find(ht, hval);
+		} else {
+			switch (Z_TYPE_P(offset)) {
+				case IS_DOUBLE:
+					hval = zend_dval_to_lval(Z_DVAL_P(offset));
+					goto num_index_prop;
+				case IS_NULL:
+					str = STR_EMPTY_ALLOC();
+					goto str_index_prop;
+				case IS_FALSE:
+					hval = 0;
+					goto num_index_prop;
+				case IS_TRUE:
+					hval = 1;
+					goto num_index_prop;
+				case IS_RESOURCE:
+					hval = Z_RES_HANDLE_P(offset);
+					goto num_index_prop;
+				case IS_REFERENCE:
+					offset = Z_REFVAL_P(offset);
+					goto isset_again;
+				default:
+					zend_error(E_WARNING, "Illegal offset type in isset or empty");
+					value = NULL;
+					break;
+			}
+		}
+
+		if (opline->extended_value & ZEND_ISSET) {
+			/* > IS_NULL means not IS_UNDEF and not IS_NULL */
+			result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
+			    (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
+		} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
+			result = (value == NULL || !i_zend_is_true(value TSRMLS_CC));
+		}
+	} else if (Z_TYPE_P(container) == IS_OBJECT) {
+		if (Z_OBJ_HT_P(container)->has_dimension) {
+			result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC);
+		} else {
+			zend_error(E_NOTICE, "Trying to check element of non-array");
+			result = 0;
+		}
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
+	} else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */
+		zval tmp;
+
+		result = 0;
+		if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) {
+			if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
+				ZVAL_DEREF(offset);
+			}
+			if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
+					|| (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
+						&& IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
+				ZVAL_DUP(&tmp, offset);
+				convert_to_long(&tmp);
+				offset = &tmp;
+			}
+		}
+		if (Z_TYPE_P(offset) == IS_LONG) {
+			if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
+				if ((opline->extended_value & ZEND_ISSET) ||
+				    Z_STRVAL_P(container)[offset->value.lval] != '0') {
+					result = 1;
+				}
+			}
+		}
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
+	} else {
+		result = ((opline->extended_value & ZEND_ISSET) == 0);
+	}
+
+	ZVAL_BOOL(EX_VAR(opline->result.var), result);
+	zval_dtor(free_op1.var);
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_free_op free_op1;
+	zval *container;
+	int result;
+	zval *offset;
+
+	SAVE_OPLINE();
+	container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	offset = opline->op2.zv;
+
+	if (Z_TYPE_P(container) == IS_OBJECT) {
+		if (Z_OBJ_HT_P(container)->has_property) {
+			result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC);
+		} else {
+			zend_error(E_NOTICE, "Trying to check property of non-object");
+			result = 0;
+		}
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
+	} else {
+		result = ((opline->extended_value & ZEND_ISSET) == 0);
+	}
+
+	ZVAL_BOOL(EX_VAR(opline->result.var), result);
+	zval_dtor(free_op1.var);
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
 static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -10330,6 +11851,159 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HAND
 	ZEND_VM_NEXT_OPCODE();
 }
 
+static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_free_op free_op1, free_op2;
+	zval *container;
+
+	SAVE_OPLINE();
+	container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR TSRMLS_CC);
+	zval_dtor(free_op2.var);
+	zval_dtor(free_op1.var);
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *container;
+	zend_free_op free_op1, free_op2;
+
+	SAVE_OPLINE();
+
+	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
+        if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) {
+            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
+        }
+		container = NULL;
+		if (IS_TMP_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
+			zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
+		}
+		zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR TSRMLS_CC);
+		if (IS_TMP_VAR == IS_VAR && 1 && READY_TO_DESTROY(free_op1.var)) {
+			EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
+		}
+		zval_dtor(free_op2.var);
+
+	} else {
+		if (IS_TMP_VAR == IS_UNUSED) {
+			zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
+		}
+		container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+		zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR TSRMLS_CC);
+		zval_dtor(free_op2.var);
+		zval_dtor(free_op1.var);
+	}
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_TMP_TMP(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_free_op free_op1;
+	zval *container;
+	zend_free_op free_op2;
+	zval *offset;
+
+	SAVE_OPLINE();
+	container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	offset  = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+
+	if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
+	    UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
+		zend_error(E_NOTICE, "Trying to get property of non-object");
+		ZVAL_NULL(EX_VAR(opline->result.var));
+	} else {
+		zval *retval;
+
+		/* here we are sure we are dealing with an object */
+		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC);
+
+		if (retval != EX_VAR(opline->result.var)) {
+			ZVAL_COPY(EX_VAR(opline->result.var), retval);
+		}
+	}
+
+	zval_dtor(free_op2.var);
+	zval_dtor(free_op1.var);
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_OBJ_R_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	return zend_fetch_property_address_read_helper_SPEC_TMP_TMP(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_free_op free_op1;
+	zval *container;
+	zend_free_op free_op2;
+	zval *offset;
+
+	SAVE_OPLINE();
+	container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	offset  = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+
+	if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
+	    UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
+		ZVAL_NULL(EX_VAR(opline->result.var));
+	} else {
+		zval *retval;
+
+		/* here we are sure we are dealing with an object */
+		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_TMP_VAR == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC);
+
+		if (retval != EX_VAR(opline->result.var)) {
+			ZVAL_COPY(EX_VAR(opline->result.var), retval);
+		}
+	}
+
+	zval_dtor(free_op2.var);
+	zval_dtor(free_op1.var);
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *container;
+
+	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
+		/* Behave like FETCH_OBJ_W */
+		zend_free_op free_op1, free_op2;
+		zval *property;
+
+		SAVE_OPLINE();
+		property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+		container = NULL;
+
+        if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) {
+            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
+        }
+		if (IS_TMP_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
+			zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
+		}
+		zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W, 0 TSRMLS_CC);
+		zval_dtor(free_op2.var);
+		if (IS_TMP_VAR == IS_VAR && 1 && READY_TO_DESTROY(free_op1.var)) {
+			EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
+		}
+
+		CHECK_EXCEPTION();
+		ZEND_VM_NEXT_OPCODE();
+	} else {
+		return zend_fetch_property_address_read_helper_SPEC_TMP_TMP(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
+}
+
 static int ZEND_FASTCALL  ZEND_ADD_VAR_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -10580,6 +12254,153 @@ static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDL
 	}
 }
 
+static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_free_op free_op1, free_op2;
+	zval *container;
+	int result;
+	zend_ulong hval;
+	zval *offset;
+
+	SAVE_OPLINE();
+	container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+
+	if (Z_TYPE_P(container) == IS_ARRAY) {
+		HashTable *ht = Z_ARRVAL_P(container);
+		zval *value;
+		zend_string *str;
+
+isset_again:
+		if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
+			str = Z_STR_P(offset);
+			if (IS_TMP_VAR != IS_CONST) {
+				if (ZEND_HANDLE_NUMERIC(str, hval)) {
+					goto num_index_prop;
+				}
+			}
+str_index_prop:
+			value = zend_hash_find_ind(ht, str);
+		} else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
+			hval = Z_LVAL_P(offset);
+num_index_prop:
+			value = zend_hash_index_find(ht, hval);
+		} else {
+			switch (Z_TYPE_P(offset)) {
+				case IS_DOUBLE:
+					hval = zend_dval_to_lval(Z_DVAL_P(offset));
+					goto num_index_prop;
+				case IS_NULL:
+					str = STR_EMPTY_ALLOC();
+					goto str_index_prop;
+				case IS_FALSE:
+					hval = 0;
+					goto num_index_prop;
+				case IS_TRUE:
+					hval = 1;
+					goto num_index_prop;
+				case IS_RESOURCE:
+					hval = Z_RES_HANDLE_P(offset);
+					goto num_index_prop;
+				case IS_REFERENCE:
+					offset = Z_REFVAL_P(offset);
+					goto isset_again;
+				default:
+					zend_error(E_WARNING, "Illegal offset type in isset or empty");
+					value = NULL;
+					break;
+			}
+		}
+
+		if (opline->extended_value & ZEND_ISSET) {
+			/* > IS_NULL means not IS_UNDEF and not IS_NULL */
+			result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
+			    (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
+		} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
+			result = (value == NULL || !i_zend_is_true(value TSRMLS_CC));
+		}
+	} else if (Z_TYPE_P(container) == IS_OBJECT) {
+		if (Z_OBJ_HT_P(container)->has_dimension) {
+			result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC);
+		} else {
+			zend_error(E_NOTICE, "Trying to check element of non-array");
+			result = 0;
+		}
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
+	} else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */
+		zval tmp;
+
+		result = 0;
+		if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) {
+			if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
+				ZVAL_DEREF(offset);
+			}
+			if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
+					|| (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
+						&& IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
+				ZVAL_DUP(&tmp, offset);
+				convert_to_long(&tmp);
+				offset = &tmp;
+			}
+		}
+		if (Z_TYPE_P(offset) == IS_LONG) {
+			if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
+				if ((opline->extended_value & ZEND_ISSET) ||
+				    Z_STRVAL_P(container)[offset->value.lval] != '0') {
+					result = 1;
+				}
+			}
+		}
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
+	} else {
+		result = ((opline->extended_value & ZEND_ISSET) == 0);
+	}
+
+	zval_dtor(free_op2.var);
+	ZVAL_BOOL(EX_VAR(opline->result.var), result);
+	zval_dtor(free_op1.var);
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_free_op free_op1, free_op2;
+	zval *container;
+	int result;
+	zval *offset;
+
+	SAVE_OPLINE();
+	container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+
+	if (Z_TYPE_P(container) == IS_OBJECT) {
+		if (Z_OBJ_HT_P(container)->has_property) {
+			result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_TMP_VAR == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC);
+		} else {
+			zend_error(E_NOTICE, "Trying to check property of non-object");
+			result = 0;
+		}
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
+	} else {
+		result = ((opline->extended_value & ZEND_ISSET) == 0);
+	}
+
+	zval_dtor(free_op2.var);
+	ZVAL_BOOL(EX_VAR(opline->result.var), result);
+	zval_dtor(free_op1.var);
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
 static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -11170,6 +12991,159 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HAND
 	ZEND_VM_NEXT_OPCODE();
 }
 
+static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_free_op free_op1, free_op2;
+	zval *container;
+
+	SAVE_OPLINE();
+	container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR TSRMLS_CC);
+	zval_ptr_dtor_nogc(free_op2.var);
+	zval_dtor(free_op1.var);
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *container;
+	zend_free_op free_op1, free_op2;
+
+	SAVE_OPLINE();
+
+	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
+        if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) {
+            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
+        }
+		container = NULL;
+		if (IS_TMP_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
+			zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
+		}
+		zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR TSRMLS_CC);
+		if (IS_TMP_VAR == IS_VAR && 1 && READY_TO_DESTROY(free_op1.var)) {
+			EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
+		}
+		zval_ptr_dtor_nogc(free_op2.var);
+
+	} else {
+		if (IS_VAR == IS_UNUSED) {
+			zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
+		}
+		container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+		zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR TSRMLS_CC);
+		zval_ptr_dtor_nogc(free_op2.var);
+		zval_dtor(free_op1.var);
+	}
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_TMP_VAR(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_free_op free_op1;
+	zval *container;
+	zend_free_op free_op2;
+	zval *offset;
+
+	SAVE_OPLINE();
+	container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	offset  = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+
+	if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
+	    UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
+		zend_error(E_NOTICE, "Trying to get property of non-object");
+		ZVAL_NULL(EX_VAR(opline->result.var));
+	} else {
+		zval *retval;
+
+		/* here we are sure we are dealing with an object */
+		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_VAR == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC);
+
+		if (retval != EX_VAR(opline->result.var)) {
+			ZVAL_COPY(EX_VAR(opline->result.var), retval);
+		}
+	}
+
+	zval_ptr_dtor_nogc(free_op2.var);
+	zval_dtor(free_op1.var);
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_OBJ_R_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	return zend_fetch_property_address_read_helper_SPEC_TMP_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_free_op free_op1;
+	zval *container;
+	zend_free_op free_op2;
+	zval *offset;
+
+	SAVE_OPLINE();
+	container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	offset  = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+
+	if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
+	    UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
+		ZVAL_NULL(EX_VAR(opline->result.var));
+	} else {
+		zval *retval;
+
+		/* here we are sure we are dealing with an object */
+		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_VAR == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC);
+
+		if (retval != EX_VAR(opline->result.var)) {
+			ZVAL_COPY(EX_VAR(opline->result.var), retval);
+		}
+	}
+
+	zval_ptr_dtor_nogc(free_op2.var);
+	zval_dtor(free_op1.var);
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *container;
+
+	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
+		/* Behave like FETCH_OBJ_W */
+		zend_free_op free_op1, free_op2;
+		zval *property;
+
+		SAVE_OPLINE();
+		property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+		container = NULL;
+
+        if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) {
+            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
+        }
+		if (IS_TMP_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
+			zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
+		}
+		zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W, 0 TSRMLS_CC);
+		zval_ptr_dtor_nogc(free_op2.var);
+		if (IS_TMP_VAR == IS_VAR && 1 && READY_TO_DESTROY(free_op1.var)) {
+			EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
+		}
+
+		CHECK_EXCEPTION();
+		ZEND_VM_NEXT_OPCODE();
+	} else {
+		return zend_fetch_property_address_read_helper_SPEC_TMP_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
+}
+
 static int ZEND_FASTCALL  ZEND_ADD_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -11572,6 +13546,153 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCOD
 	ZEND_VM_NEXT_OPCODE();
 }
 
+static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_free_op free_op1, free_op2;
+	zval *container;
+	int result;
+	zend_ulong hval;
+	zval *offset;
+
+	SAVE_OPLINE();
+	container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+
+	if (Z_TYPE_P(container) == IS_ARRAY) {
+		HashTable *ht = Z_ARRVAL_P(container);
+		zval *value;
+		zend_string *str;
+
+isset_again:
+		if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
+			str = Z_STR_P(offset);
+			if (IS_VAR != IS_CONST) {
+				if (ZEND_HANDLE_NUMERIC(str, hval)) {
+					goto num_index_prop;
+				}
+			}
+str_index_prop:
+			value = zend_hash_find_ind(ht, str);
+		} else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
+			hval = Z_LVAL_P(offset);
+num_index_prop:
+			value = zend_hash_index_find(ht, hval);
+		} else {
+			switch (Z_TYPE_P(offset)) {
+				case IS_DOUBLE:
+					hval = zend_dval_to_lval(Z_DVAL_P(offset));
+					goto num_index_prop;
+				case IS_NULL:
+					str = STR_EMPTY_ALLOC();
+					goto str_index_prop;
+				case IS_FALSE:
+					hval = 0;
+					goto num_index_prop;
+				case IS_TRUE:
+					hval = 1;
+					goto num_index_prop;
+				case IS_RESOURCE:
+					hval = Z_RES_HANDLE_P(offset);
+					goto num_index_prop;
+				case IS_REFERENCE:
+					offset = Z_REFVAL_P(offset);
+					goto isset_again;
+				default:
+					zend_error(E_WARNING, "Illegal offset type in isset or empty");
+					value = NULL;
+					break;
+			}
+		}
+
+		if (opline->extended_value & ZEND_ISSET) {
+			/* > IS_NULL means not IS_UNDEF and not IS_NULL */
+			result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
+			    (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
+		} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
+			result = (value == NULL || !i_zend_is_true(value TSRMLS_CC));
+		}
+	} else if (Z_TYPE_P(container) == IS_OBJECT) {
+		if (Z_OBJ_HT_P(container)->has_dimension) {
+			result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC);
+		} else {
+			zend_error(E_NOTICE, "Trying to check element of non-array");
+			result = 0;
+		}
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
+	} else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */
+		zval tmp;
+
+		result = 0;
+		if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) {
+			if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
+				ZVAL_DEREF(offset);
+			}
+			if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
+					|| (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
+						&& IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
+				ZVAL_DUP(&tmp, offset);
+				convert_to_long(&tmp);
+				offset = &tmp;
+			}
+		}
+		if (Z_TYPE_P(offset) == IS_LONG) {
+			if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
+				if ((opline->extended_value & ZEND_ISSET) ||
+				    Z_STRVAL_P(container)[offset->value.lval] != '0') {
+					result = 1;
+				}
+			}
+		}
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
+	} else {
+		result = ((opline->extended_value & ZEND_ISSET) == 0);
+	}
+
+	zval_ptr_dtor_nogc(free_op2.var);
+	ZVAL_BOOL(EX_VAR(opline->result.var), result);
+	zval_dtor(free_op1.var);
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_free_op free_op1, free_op2;
+	zval *container;
+	int result;
+	zval *offset;
+
+	SAVE_OPLINE();
+	container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+
+	if (Z_TYPE_P(container) == IS_OBJECT) {
+		if (Z_OBJ_HT_P(container)->has_property) {
+			result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_VAR == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC);
+		} else {
+			zend_error(E_NOTICE, "Trying to check property of non-object");
+			result = 0;
+		}
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
+	} else {
+		result = ((opline->extended_value & ZEND_ISSET) == 0);
+	}
+
+	zval_ptr_dtor_nogc(free_op2.var);
+	ZVAL_BOOL(EX_VAR(opline->result.var), result);
+	zval_dtor(free_op1.var);
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
 static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -11870,6 +13991,41 @@ static int ZEND_FASTCALL  ZEND_FETCH_IS_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HAND
 	return zend_fetch_var_address_helper_SPEC_TMP_UNUSED(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 }
 
+static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *container;
+	zend_free_op free_op1;
+
+	SAVE_OPLINE();
+
+	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
+        if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) {
+            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
+        }
+		container = NULL;
+		if (IS_TMP_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
+			zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
+		}
+		zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, NULL, IS_UNUSED TSRMLS_CC);
+		if (IS_TMP_VAR == IS_VAR && 1 && READY_TO_DESTROY(free_op1.var)) {
+			EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
+		}
+
+
+	} else {
+		if (IS_UNUSED == IS_UNUSED) {
+			zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
+		}
+		container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+		zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, NULL, IS_UNUSED TSRMLS_CC);
+
+		zval_dtor(free_op1.var);
+	}
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
 static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -12563,6 +14719,157 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDL
 	ZEND_VM_NEXT_OPCODE();
 }
 
+static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_free_op free_op1;
+	zval *container;
+
+	SAVE_OPLINE();
+	container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
+
+	zval_dtor(free_op1.var);
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *container;
+	zend_free_op free_op1;
+
+	SAVE_OPLINE();
+
+	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
+        if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) {
+            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
+        }
+		container = NULL;
+		if (IS_TMP_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
+			zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
+		}
+		zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
+		if (IS_TMP_VAR == IS_VAR && 1 && READY_TO_DESTROY(free_op1.var)) {
+			EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
+		}
+
+
+	} else {
+		if (IS_CV == IS_UNUSED) {
+			zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
+		}
+		container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+		zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
+
+		zval_dtor(free_op1.var);
+	}
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_TMP_CV(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_free_op free_op1;
+	zval *container;
+
+	zval *offset;
+
+	SAVE_OPLINE();
+	container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	offset  = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
+
+	if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
+	    UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
+		zend_error(E_NOTICE, "Trying to get property of non-object");
+		ZVAL_NULL(EX_VAR(opline->result.var));
+	} else {
+		zval *retval;
+
+		/* here we are sure we are dealing with an object */
+		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC);
+
+		if (retval != EX_VAR(opline->result.var)) {
+			ZVAL_COPY(EX_VAR(opline->result.var), retval);
+		}
+	}
+
+	zval_dtor(free_op1.var);
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_OBJ_R_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	return zend_fetch_property_address_read_helper_SPEC_TMP_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_free_op free_op1;
+	zval *container;
+
+	zval *offset;
+
+	SAVE_OPLINE();
+	container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	offset  = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
+
+	if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
+	    UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
+		ZVAL_NULL(EX_VAR(opline->result.var));
+	} else {
+		zval *retval;
+
+		/* here we are sure we are dealing with an object */
+		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC);
+
+		if (retval != EX_VAR(opline->result.var)) {
+			ZVAL_COPY(EX_VAR(opline->result.var), retval);
+		}
+	}
+
+	zval_dtor(free_op1.var);
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *container;
+
+	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
+		/* Behave like FETCH_OBJ_W */
+		zend_free_op free_op1;
+		zval *property;
+
+		SAVE_OPLINE();
+		property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
+		container = NULL;
+
+        if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) {
+            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
+        }
+		if (IS_TMP_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
+			zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
+		}
+		zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W, 0 TSRMLS_CC);
+
+		if (IS_TMP_VAR == IS_VAR && 1 && READY_TO_DESTROY(free_op1.var)) {
+			EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
+		}
+
+		CHECK_EXCEPTION();
+		ZEND_VM_NEXT_OPCODE();
+	} else {
+		return zend_fetch_property_address_read_helper_SPEC_TMP_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
+}
+
 static int ZEND_FASTCALL  ZEND_ADD_VAR_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -12810,6 +15117,151 @@ static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLE
 	}
 }
 
+static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_free_op free_op1;
+	zval *container;
+	int result;
+	zend_ulong hval;
+	zval *offset;
+
+	SAVE_OPLINE();
+	container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
+
+	if (Z_TYPE_P(container) == IS_ARRAY) {
+		HashTable *ht = Z_ARRVAL_P(container);
+		zval *value;
+		zend_string *str;
+
+isset_again:
+		if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
+			str = Z_STR_P(offset);
+			if (IS_CV != IS_CONST) {
+				if (ZEND_HANDLE_NUMERIC(str, hval)) {
+					goto num_index_prop;
+				}
+			}
+str_index_prop:
+			value = zend_hash_find_ind(ht, str);
+		} else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
+			hval = Z_LVAL_P(offset);
+num_index_prop:
+			value = zend_hash_index_find(ht, hval);
+		} else {
+			switch (Z_TYPE_P(offset)) {
+				case IS_DOUBLE:
+					hval = zend_dval_to_lval(Z_DVAL_P(offset));
+					goto num_index_prop;
+				case IS_NULL:
+					str = STR_EMPTY_ALLOC();
+					goto str_index_prop;
+				case IS_FALSE:
+					hval = 0;
+					goto num_index_prop;
+				case IS_TRUE:
+					hval = 1;
+					goto num_index_prop;
+				case IS_RESOURCE:
+					hval = Z_RES_HANDLE_P(offset);
+					goto num_index_prop;
+				case IS_REFERENCE:
+					offset = Z_REFVAL_P(offset);
+					goto isset_again;
+				default:
+					zend_error(E_WARNING, "Illegal offset type in isset or empty");
+					value = NULL;
+					break;
+			}
+		}
+
+		if (opline->extended_value & ZEND_ISSET) {
+			/* > IS_NULL means not IS_UNDEF and not IS_NULL */
+			result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
+			    (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
+		} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
+			result = (value == NULL || !i_zend_is_true(value TSRMLS_CC));
+		}
+	} else if (Z_TYPE_P(container) == IS_OBJECT) {
+		if (Z_OBJ_HT_P(container)->has_dimension) {
+			result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC);
+		} else {
+			zend_error(E_NOTICE, "Trying to check element of non-array");
+			result = 0;
+		}
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
+	} else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */
+		zval tmp;
+
+		result = 0;
+		if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) {
+			if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
+				ZVAL_DEREF(offset);
+			}
+			if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
+					|| (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
+						&& IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
+				ZVAL_DUP(&tmp, offset);
+				convert_to_long(&tmp);
+				offset = &tmp;
+			}
+		}
+		if (Z_TYPE_P(offset) == IS_LONG) {
+			if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
+				if ((opline->extended_value & ZEND_ISSET) ||
+				    Z_STRVAL_P(container)[offset->value.lval] != '0') {
+					result = 1;
+				}
+			}
+		}
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
+	} else {
+		result = ((opline->extended_value & ZEND_ISSET) == 0);
+	}
+
+	ZVAL_BOOL(EX_VAR(opline->result.var), result);
+	zval_dtor(free_op1.var);
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_free_op free_op1;
+	zval *container;
+	int result;
+	zval *offset;
+
+	SAVE_OPLINE();
+	container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
+
+	if (Z_TYPE_P(container) == IS_OBJECT) {
+		if (Z_OBJ_HT_P(container)->has_property) {
+			result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC);
+		} else {
+			zend_error(E_NOTICE, "Trying to check property of non-object");
+			result = 0;
+		}
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
+	} else {
+		result = ((opline->extended_value & ZEND_ISSET) == 0);
+	}
+
+	ZVAL_BOOL(EX_VAR(opline->result.var), result);
+	zval_dtor(free_op1.var);
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
 static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -14591,8 +17043,8 @@ static int ZEND_FASTCALL  ZEND_TYPE_CHECK_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_A
 			} else {
 				ZVAL_FALSE(EX_VAR(opline->result.var));
 			}
+			break;
 		EMPTY_SWITCH_DEFAULT_CASE()
-
 	}
 	zval_ptr_dtor_nogc(free_op1.var);
 	CHECK_EXCEPTION();
@@ -15645,6 +18097,9 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OP
 	SAVE_OPLINE();
 
 	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
+        if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) {
+            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
+        }
 		container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 		if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
 			zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
@@ -15821,6 +18276,9 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OP
 		property = opline->op2.zv;
 		container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
+        if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) {
+            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
+        }
 		if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 		}
@@ -17876,6 +20334,9 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMP_HANDLER(ZEND_OPCO
 	SAVE_OPLINE();
 
 	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
+        if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) {
+            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
+        }
 		container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 		if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
 			zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
@@ -18054,6 +20515,9 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMP_HANDLER(ZEND_OPCO
 		property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 		container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
+        if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) {
+            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
+        }
 		if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 		}
@@ -20018,6 +22482,9 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_VAR_HANDLER(ZEND_OPCO
 	SAVE_OPLINE();
 
 	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
+        if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) {
+            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
+        }
 		container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 		if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
 			zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
@@ -20196,6 +22663,9 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_VAR_HANDLER(ZEND_OPCO
 		property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 		container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
+        if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) {
+            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
+        }
 		if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 		}
@@ -21888,6 +24358,9 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_O
 	SAVE_OPLINE();
 
 	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
+        if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) {
+            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
+        }
 		container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 		if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
 			zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
@@ -23408,6 +25881,9 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCOD
 	SAVE_OPLINE();
 
 	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
+        if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) {
+            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
+        }
 		container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 		if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
 			zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
@@ -23584,6 +26060,9 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCOD
 		property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 		container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
+        if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) {
+            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
+        }
 		if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 		}
@@ -25295,6 +27774,9 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER(ZEND
 		property = opline->op2.zv;
 		container = _get_obj_zval_ptr_unused(TSRMLS_C);
 
+        if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR) {
+            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
+        }
 		if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 		}
@@ -26665,6 +29147,9 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMP_HANDLER(ZEND_O
 		property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 		container = _get_obj_zval_ptr_unused(TSRMLS_C);
 
+        if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR) {
+            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
+        }
 		if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 		}
@@ -27947,6 +30432,9 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_VAR_HANDLER(ZEND_O
 		property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 		container = _get_obj_zval_ptr_unused(TSRMLS_C);
 
+        if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR) {
+            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
+        }
 		if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 		}
@@ -29740,6 +32228,9 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_HANDLER(ZEND_OP
 		property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 		container = _get_obj_zval_ptr_unused(TSRMLS_C);
 
+        if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR) {
+            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
+        }
 		if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 		}
@@ -31804,8 +34295,8 @@ static int ZEND_FASTCALL  ZEND_TYPE_CHECK_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_AR
 			} else {
 				ZVAL_FALSE(EX_VAR(opline->result.var));
 			}
+			break;
 		EMPTY_SWITCH_DEFAULT_CASE()
-
 	}
 
 	CHECK_EXCEPTION();
@@ -32857,6 +35348,9 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPC
 	SAVE_OPLINE();
 
 	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
+        if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) {
+            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
+        }
 		container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
 		if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
 			zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
@@ -33033,6 +35527,9 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPC
 		property = opline->op2.zv;
 		container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
 
+        if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) {
+            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
+        }
 		if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 		}
@@ -34902,6 +37399,9 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMP_HANDLER(ZEND_OPCOD
 	SAVE_OPLINE();
 
 	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
+        if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) {
+            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
+        }
 		container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
 		if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
 			zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
@@ -35080,6 +37580,9 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMP_HANDLER(ZEND_OPCOD
 		property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 		container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
 
+        if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) {
+            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
+        }
 		if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 		}
@@ -36925,6 +39428,9 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_VAR_HANDLER(ZEND_OPCOD
 	SAVE_OPLINE();
 
 	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
+        if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) {
+            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
+        }
 		container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
 		if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
 			zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
@@ -37103,6 +39609,9 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_VAR_HANDLER(ZEND_OPCOD
 		property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 		container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
 
+        if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) {
+            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
+        }
 		if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 		}
@@ -38675,6 +41184,9 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OP
 	SAVE_OPLINE();
 
 	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
+        if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) {
+            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
+        }
 		container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
 		if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
 			zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
@@ -40059,6 +42571,9 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE
 	SAVE_OPLINE();
 
 	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
+        if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) {
+            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
+        }
 		container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
 		if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
 			zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
@@ -40235,6 +42750,9 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE
 		property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 		container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
 
+        if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) {
+            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
+        }
 		if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 		}
@@ -43148,16 +45666,16 @@ void zend_init_opcodes_handlers(void)
   	ZEND_FETCH_DIM_R_SPEC_CV_VAR_HANDLER,
   	ZEND_NULL_HANDLER,
   	ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER,
+  	ZEND_FETCH_OBJ_R_SPEC_CONST_CONST_HANDLER,
+  	ZEND_FETCH_OBJ_R_SPEC_CONST_TMP_HANDLER,
+  	ZEND_FETCH_OBJ_R_SPEC_CONST_VAR_HANDLER,
   	ZEND_NULL_HANDLER,
+  	ZEND_FETCH_OBJ_R_SPEC_CONST_CV_HANDLER,
+  	ZEND_FETCH_OBJ_R_SPEC_TMP_CONST_HANDLER,
+  	ZEND_FETCH_OBJ_R_SPEC_TMP_TMP_HANDLER,
+  	ZEND_FETCH_OBJ_R_SPEC_TMP_VAR_HANDLER,
   	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
+  	ZEND_FETCH_OBJ_R_SPEC_TMP_CV_HANDLER,
   	ZEND_FETCH_OBJ_R_SPEC_VAR_CONST_HANDLER,
   	ZEND_FETCH_OBJ_R_SPEC_VAR_TMP_HANDLER,
   	ZEND_FETCH_OBJ_R_SPEC_VAR_VAR_HANDLER,
@@ -43348,16 +45866,16 @@ void zend_init_opcodes_handlers(void)
   	ZEND_FETCH_IS_SPEC_CV_VAR_HANDLER,
   	ZEND_FETCH_IS_SPEC_CV_UNUSED_HANDLER,
   	ZEND_NULL_HANDLER,
+  	ZEND_FETCH_DIM_IS_SPEC_CONST_CONST_HANDLER,
+  	ZEND_FETCH_DIM_IS_SPEC_CONST_TMP_HANDLER,
+  	ZEND_FETCH_DIM_IS_SPEC_CONST_VAR_HANDLER,
   	ZEND_NULL_HANDLER,
+  	ZEND_FETCH_DIM_IS_SPEC_CONST_CV_HANDLER,
+  	ZEND_FETCH_DIM_IS_SPEC_TMP_CONST_HANDLER,
+  	ZEND_FETCH_DIM_IS_SPEC_TMP_TMP_HANDLER,
+  	ZEND_FETCH_DIM_IS_SPEC_TMP_VAR_HANDLER,
   	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
+  	ZEND_FETCH_DIM_IS_SPEC_TMP_CV_HANDLER,
   	ZEND_FETCH_DIM_IS_SPEC_VAR_CONST_HANDLER,
   	ZEND_FETCH_DIM_IS_SPEC_VAR_TMP_HANDLER,
   	ZEND_FETCH_DIM_IS_SPEC_VAR_VAR_HANDLER,
@@ -43373,16 +45891,16 @@ void zend_init_opcodes_handlers(void)
   	ZEND_FETCH_DIM_IS_SPEC_CV_VAR_HANDLER,
   	ZEND_NULL_HANDLER,
   	ZEND_FETCH_DIM_IS_SPEC_CV_CV_HANDLER,
+  	ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST_HANDLER,
+  	ZEND_FETCH_OBJ_IS_SPEC_CONST_TMP_HANDLER,
+  	ZEND_FETCH_OBJ_IS_SPEC_CONST_VAR_HANDLER,
   	ZEND_NULL_HANDLER,
+  	ZEND_FETCH_OBJ_IS_SPEC_CONST_CV_HANDLER,
+  	ZEND_FETCH_OBJ_IS_SPEC_TMP_CONST_HANDLER,
+  	ZEND_FETCH_OBJ_IS_SPEC_TMP_TMP_HANDLER,
+  	ZEND_FETCH_OBJ_IS_SPEC_TMP_VAR_HANDLER,
   	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
+  	ZEND_FETCH_OBJ_IS_SPEC_TMP_CV_HANDLER,
   	ZEND_FETCH_OBJ_IS_SPEC_VAR_CONST_HANDLER,
   	ZEND_FETCH_OBJ_IS_SPEC_VAR_TMP_HANDLER,
   	ZEND_FETCH_OBJ_IS_SPEC_VAR_VAR_HANDLER,
@@ -43423,16 +45941,16 @@ void zend_init_opcodes_handlers(void)
   	ZEND_FETCH_FUNC_ARG_SPEC_CV_VAR_HANDLER,
   	ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED_HANDLER,
   	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
+  	ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST_HANDLER,
+  	ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMP_HANDLER,
+  	ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_VAR_HANDLER,
+  	ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER,
+  	ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV_HANDLER,
+  	ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST_HANDLER,
+  	ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMP_HANDLER,
+  	ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_VAR_HANDLER,
+  	ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED_HANDLER,
+  	ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV_HANDLER,
   	ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_HANDLER,
   	ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMP_HANDLER,
   	ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_VAR_HANDLER,
@@ -43448,16 +45966,16 @@ void zend_init_opcodes_handlers(void)
   	ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_VAR_HANDLER,
   	ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_HANDLER,
   	ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_HANDLER,
+  	ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST_HANDLER,
+  	ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMP_HANDLER,
+  	ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_VAR_HANDLER,
   	ZEND_NULL_HANDLER,
+  	ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV_HANDLER,
+  	ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST_HANDLER,
+  	ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMP_HANDLER,
+  	ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_VAR_HANDLER,
   	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
+  	ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV_HANDLER,
   	ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_HANDLER,
   	ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMP_HANDLER,
   	ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_VAR_HANDLER,
@@ -43973,16 +46491,16 @@ void zend_init_opcodes_handlers(void)
   	ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_VAR_HANDLER,
   	ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER,
   	ZEND_NULL_HANDLER,
+  	ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST_HANDLER,
+  	ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMP_HANDLER,
+  	ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_VAR_HANDLER,
   	ZEND_NULL_HANDLER,
+  	ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV_HANDLER,
+  	ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_CONST_HANDLER,
+  	ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_TMP_HANDLER,
+  	ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_VAR_HANDLER,
   	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
+  	ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_CV_HANDLER,
   	ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_CONST_HANDLER,
   	ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_TMP_HANDLER,
   	ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_VAR_HANDLER,
@@ -44798,16 +47316,16 @@ void zend_init_opcodes_handlers(void)
   	ZEND_ASSIGN_DIM_SPEC_CV_VAR_HANDLER,
   	ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_HANDLER,
   	ZEND_ASSIGN_DIM_SPEC_CV_CV_HANDLER,
+  	ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST_HANDLER,
+  	ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMP_HANDLER,
+  	ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_VAR_HANDLER,
   	ZEND_NULL_HANDLER,
+  	ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV_HANDLER,
+  	ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_CONST_HANDLER,
+  	ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_TMP_HANDLER,
+  	ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_VAR_HANDLER,
   	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
-  	ZEND_NULL_HANDLER,
+  	ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_CV_HANDLER,
   	ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_CONST_HANDLER,
   	ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_TMP_HANDLER,
   	ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_VAR_HANDLER,
diff --git a/ext/opcache/Optimizer/optimize_func_calls.c b/ext/opcache/Optimizer/optimize_func_calls.c
index ead951ac73..853d4bd7f4 100644
--- a/ext/opcache/Optimizer/optimize_func_calls.c
+++ b/ext/opcache/Optimizer/optimize_func_calls.c
@@ -20,6 +20,11 @@
 /* pass 4
  * - optimize INIT_FCALL_BY_NAME to DO_FCALL
  */
+
+#define ZEND_OP2_IS_CONST_STRING(opline) \
+	(ZEND_OP2_TYPE(opline) == IS_CONST && \
+	Z_TYPE(op_array->literals[(opline)->op2.constant]) == IS_STRING)
+
 typedef struct _optimizer_call_info {
 	zend_function *func;
 	zend_op       *opline;
@@ -42,7 +47,7 @@ static void optimize_func_calls(zend_op_array *op_array, zend_optimizer_ctx *ctx
 		switch (opline->opcode) {
 			case ZEND_INIT_FCALL_BY_NAME:
 			case ZEND_INIT_NS_FCALL_BY_NAME:
-				if (ZEND_OP2_TYPE(opline) == IS_CONST) {
+				if (ZEND_OP2_IS_CONST_STRING(opline)) {
 					zend_function *func;
 					zval *function_name = &op_array->literals[opline->op2.constant + 1];
 					if ((func = zend_hash_find_ptr(&ctx->script->function_table,
@@ -81,7 +86,7 @@ static void optimize_func_calls(zend_op_array *op_array, zend_optimizer_ctx *ctx
 				} else if (opline->extended_value == 0 &&
 				           call_stack[call].opline &&
 				           call_stack[call].opline->opcode == ZEND_INIT_FCALL_BY_NAME &&
-				           ZEND_OP2_TYPE(call_stack[call].opline) == IS_CONST) {
+						   ZEND_OP2_IS_CONST_STRING(call_stack[call].opline)) {
 
 					zend_op *fcall = call_stack[call].opline;
 
diff --git a/ext/opcache/Optimizer/pass1_5.c b/ext/opcache/Optimizer/pass1_5.c
index de09e89123..cae4d0445d 100644
--- a/ext/opcache/Optimizer/pass1_5.c
+++ b/ext/opcache/Optimizer/pass1_5.c
@@ -472,7 +472,7 @@ if (ZEND_OPTIMIZER_PASS_1 & OPTIMIZATION_LEVEL) {
 				zval t;
 
 				ZVAL_LONG(&t, Z_STRLEN(ZEND_OP1_LITERAL(opline)));
-				replace_tmp_by_const(op_array, opline + 1, ZEND_RESULT(opline).var, &t TSRMLS_CC);
+				replace_var_by_const(op_array, opline + 1, ZEND_RESULT(opline).var, &t TSRMLS_CC);
 				literal_dtor(&ZEND_OP1_LITERAL(opline));
 				MAKE_NOP(opline);
 			}
@@ -485,7 +485,7 @@ if (ZEND_OPTIMIZER_PASS_1 & OPTIMIZATION_LEVEL) {
 					break;
 				}
 				ZVAL_TRUE(&c);
-				replace_tmp_by_const(op_array, opline, tv, &c TSRMLS_CC);
+				replace_var_by_const(op_array, opline, tv, &c TSRMLS_CC);
 				literal_dtor(&ZEND_OP1_LITERAL(opline));
 				MAKE_NOP(opline);
 			}
diff --git a/ext/opcache/zend_accelerator_util_funcs.c b/ext/opcache/zend_accelerator_util_funcs.c
index dd5340e572..f8554776a3 100644
--- a/ext/opcache/zend_accelerator_util_funcs.c
+++ b/ext/opcache/zend_accelerator_util_funcs.c
@@ -305,28 +305,44 @@ static inline void zend_clone_zval(zval *src, int bind TSRMLS_DC)
 
 static zend_ast *zend_ast_clone(zend_ast *ast TSRMLS_DC)
 {
-	int i;
-	zend_ast *node;
-
-	if (ast->kind == ZEND_CONST) {
-		node = emalloc(sizeof(zend_ast) + sizeof(zval));
-		node->kind = ZEND_CONST;
-		node->children = 0;
-		ZVAL_COPY_VALUE(&node->u.val, &ast->u.val);
-		zend_clone_zval(&node->u.val, 0 TSRMLS_CC);
+	uint32_t i;
+
+	if (ast->kind == ZEND_AST_ZVAL) {
+		zend_ast_zval *copy = emalloc(sizeof(zend_ast_zval));
+		copy->kind = ZEND_AST_ZVAL;
+		copy->attr = ast->attr;
+		ZVAL_COPY_VALUE(&copy->val, zend_ast_get_zval(ast));
+		zend_clone_zval(&copy->val, 0 TSRMLS_CC);
+		return (zend_ast *) copy;
+	} else if (zend_ast_is_list(ast)) {
+		zend_ast_list *list = zend_ast_get_list(ast);
+		zend_ast_list *copy = emalloc(
+			sizeof(zend_ast_list) + sizeof(zend_ast *) * (list->children - 1));
+		copy->kind = list->kind;
+		copy->attr = list->attr;
+		copy->children = list->children;
+		for (i = 0; i < list->children; i++) {
+			if (list->child[i]) {
+				copy->child[i] = zend_ast_clone(list->child[i] TSRMLS_CC);
+			} else {
+				copy->child[i] = NULL;
+			}
+		}
+		return (zend_ast *) copy;
 	} else {
-		node = emalloc(sizeof(zend_ast) + sizeof(zend_ast*) * (ast->children - 1));
-		node->kind = ast->kind;
-		node->children = ast->children;
-		for (i = 0; i < ast->children; i++) {
-			if ((&ast->u.child)[i]) {
-				(&node->u.child)[i] = zend_ast_clone((&ast->u.child)[i] TSRMLS_CC);
+		uint32_t children = zend_ast_get_num_children(ast);
+		zend_ast *copy = emalloc(sizeof(zend_ast) + sizeof(zend_ast *) * (children - 1));
+		copy->kind = ast->kind;
+		copy->attr = ast->attr;
+		for (i = 0; i < children; i++) {
+			if (ast->child[i]) {
+				copy->child[i] = zend_ast_clone(ast->child[i] TSRMLS_CC);
 			} else {
-				(&node->u.child)[i] = NULL;
+				copy->child[i] = NULL;
 			}
 		}
+		return copy;
 	}
-	return node;
 }
 
 static void zend_hash_clone_zval(HashTable *ht, HashTable *source, int bind)
diff --git a/ext/opcache/zend_persist.c b/ext/opcache/zend_persist.c
index 2427cfdec8..5e290745bd 100644
--- a/ext/opcache/zend_persist.c
+++ b/ext/opcache/zend_persist.c
@@ -144,20 +144,33 @@ static void zend_hash_persist_immutable(HashTable *ht TSRMLS_DC)
 
 static zend_ast *zend_persist_ast(zend_ast *ast TSRMLS_DC)
 {
-	int i;
+	uint32_t i;
 	zend_ast *node;
 
-	if (ast->kind == ZEND_CONST) {
-		node = zend_accel_memdup(ast, sizeof(zend_ast));
-		zend_persist_zval(&node->u.val TSRMLS_CC);
+	if (ast->kind == ZEND_AST_ZVAL) {
+		zend_ast_zval *copy = zend_accel_memdup(ast, sizeof(zend_ast_zval));
+		zend_persist_zval(&copy->val TSRMLS_CC);
+		node = (zend_ast *) copy;
+	} else if (zend_ast_is_list(ast)) {
+		zend_ast_list *list = zend_ast_get_list(ast);
+		zend_ast_list *copy = zend_accel_memdup(ast,
+			sizeof(zend_ast_list) + sizeof(zend_ast *) * (list->children - 1));
+		for (i = 0; i < list->children; i++) {
+			if (copy->child[i]) {
+				copy->child[i] = zend_persist_ast(copy->child[i] TSRMLS_CC);
+			}
+		}
+		node = (zend_ast *) copy;
 	} else {
-		node = zend_accel_memdup(ast, sizeof(zend_ast) + sizeof(zend_ast*) * (ast->children - 1));
-		for (i = 0; i < ast->children; i++) {
-			if ((&node->u.child)[i]) {
-				(&node->u.child)[i] = zend_persist_ast((&node->u.child)[i] TSRMLS_CC);
+		uint32_t children = zend_ast_get_num_children(ast);
+		node = zend_accel_memdup(ast, sizeof(zend_ast) + sizeof(zend_ast *) * (children - 1));
+		for (i = 0; i < children; i++) {
+			if (node->child[i]) {
+				node->child[i] = zend_persist_ast(node->child[i] TSRMLS_CC);
 			}
 		}
 	}
+
 	efree(ast);
 	return node;
 }
diff --git a/ext/opcache/zend_persist_calc.c b/ext/opcache/zend_persist_calc.c
index 1328213397..989195119c 100644
--- a/ext/opcache/zend_persist_calc.c
+++ b/ext/opcache/zend_persist_calc.c
@@ -83,17 +83,26 @@ static uint zend_hash_persist_calc(HashTable *ht, uint (*pPersistElement)(zval *
 
 static uint zend_persist_ast_calc(zend_ast *ast TSRMLS_DC)
 {
-	int i;
+	uint32_t i;
 	START_SIZE();
 
-	if (ast->kind == ZEND_CONST) {
-		ADD_SIZE(sizeof(zend_ast));
-		ADD_SIZE(zend_persist_zval_calc(&ast->u.val TSRMLS_CC));
+	if (ast->kind == ZEND_AST_ZVAL) {
+		ADD_SIZE(sizeof(zend_ast_zval));
+		ADD_SIZE(zend_persist_zval_calc(zend_ast_get_zval(ast) TSRMLS_CC));
+	} else if (zend_ast_is_list(ast)) {
+		zend_ast_list *list = zend_ast_get_list(ast);
+		ADD_SIZE(sizeof(zend_ast_list) + sizeof(zend_ast *) * (list->children - 1));
+		for (i = 0; i < list->children; i++) {
+			if (list->child[i]) {
+				ADD_SIZE(zend_persist_ast_calc(list->child[i] TSRMLS_CC));
+			}
+		}
 	} else {
-		ADD_SIZE(sizeof(zend_ast) + sizeof(zend_ast*) * (ast->children - 1));
-		for (i = 0; i < ast->children; i++) {
-			if ((&ast->u.child)[i]) {
-				ADD_SIZE(zend_persist_ast_calc((&ast->u.child)[i] TSRMLS_CC));
+		uint32_t children = zend_ast_get_num_children(ast);
+		ADD_SIZE(sizeof(zend_ast) + sizeof(zend_ast *) * (children - 1));
+		for (i = 0; i < children; i++) {
+			if (ast->child[i]) {
+				ADD_SIZE(zend_persist_ast_calc(ast->child[i] TSRMLS_CC));
 			}
 		}
 	}
diff --git a/ext/standard/tests/array/array_keys_error.phpt b/ext/standard/tests/array/array_keys_error.phpt
index 316e91d7e6..685547f0ec 100644
--- a/ext/standard/tests/array/array_keys_error.phpt
+++ b/ext/standard/tests/array/array_keys_error.phpt
@@ -9,7 +9,7 @@ var_dump(array_keys("string"));
 var_dump(array_keys(new stdclass));  // object
 var_dump(array_keys());  // Zero arguments
 var_dump(array_keys(array(), "", TRUE, 100));  // args > expected
-var_dump(array_keys(array(1,2,3, array() => array())));  // (W)illegal offset
+var_dump(array_keys(array(1,2,3, new stdClass => array())));  // (W)illegal offset
 
 echo "Done\n";
 ?>
diff --git a/ext/standard/tests/general_functions/bug41037.phpt b/ext/standard/tests/general_functions/bug41037.phpt
index eab2c334c9..0ffc8d58f6 100644
--- a/ext/standard/tests/general_functions/bug41037.phpt
+++ b/ext/standard/tests/general_functions/bug41037.phpt
@@ -8,10 +8,11 @@ function a() {
 			unregister_tick_function('a');
 }
 
-declare (ticks=1);
-register_tick_function('a');
+declare (ticks=1) {
+    register_tick_function('a');
 
-echo "Done\n";
+    echo "Done\n";
+}
 ?>
 --EXPECTF--	
 hello
@@ -19,5 +20,3 @@ Warning: unregister_tick_function(): Unable to delete tick function executed at
 Done
 hello
 Warning: unregister_tick_function(): Unable to delete tick function executed at the moment in %s on line %d
-hello
-Warning: unregister_tick_function(): Unable to delete tick function executed at the moment in %s on line %d
diff --git a/ext/standard/tests/serialize/serialization_arrays_002.phpt b/ext/standard/tests/serialize/serialization_arrays_002.phpt
index f8cef7818e..c62ff6a91c 100644
--- a/ext/standard/tests/serialize/serialization_arrays_002.phpt
+++ b/ext/standard/tests/serialize/serialization_arrays_002.phpt
@@ -37,16 +37,16 @@ check($a);
 
 echo "\n\n--- 0 refs 1:\n";
 $a = array();
-$a[0] = &$a[1];
 $a[1] = 1;
+$a[0] = &$a[1];
 $a[2] = 1;
 check($a);
 
 echo "\n\n--- 0 refs 2:\n";
 $a = array();
+$a[2] = 1;
 $a[0] = &$a[2];
 $a[1] = 1;
-$a[2] = 1;
 check($a);
 
 echo "\n\n--- 1 refs 0:\n";
@@ -59,8 +59,8 @@ check($a);
 echo "\n\n--- 1 refs 2:\n";
 $a = array();
 $a[0] = 1;
-$a[1] = &$a[2];
 $a[2] = 1;
+$a[1] = &$a[2];
 check($a);
 
 echo "\n\n--- 2 refs 0:\n";
@@ -79,15 +79,15 @@ check($a);
 
 echo "\n\n--- 0,1 ref 2:\n";
 $a = array();
+$a[2] = 1;
 $a[0] = &$a[2];
 $a[1] = &$a[2];
-$a[2] = 1;
 check($a);
 
 echo "\n\n--- 0,2 ref 1:\n";
 $a = array();
-$a[0] = &$a[1];
 $a[1] = 1;
+$a[0] = &$a[1];
 $a[2] = &$a[1];
 check($a);
 
@@ -541,4 +541,4 @@ array(3) {
   [2]=>
   &string(10) "b2.changed"
 }
-Done
\ No newline at end of file
+Done
diff --git a/ext/standard/tests/serialize/serialization_objects_013.phpt b/ext/standard/tests/serialize/serialization_objects_013.phpt
index 01b623cb0d..403f9de08c 100644
--- a/ext/standard/tests/serialize/serialization_objects_013.phpt
+++ b/ext/standard/tests/serialize/serialization_objects_013.phpt
@@ -32,16 +32,16 @@ function check(&$obj) {
 
 echo "\n\n--- a refs b:\n";
 $obj = new stdClass;
-$obj->a = &$obj->b;
 $obj->b = 1;
+$obj->a = &$obj->b;
 $obj->c = 1;
 check($obj);
 
 echo "\n\n--- a refs c:\n";
 $obj = new stdClass;
+$obj->c = 1;
 $obj->a = &$obj->c;
 $obj->b = 1;
-$obj->c = 1;
 check($obj);
 
 echo "\n\n--- b refs a:\n";
@@ -54,8 +54,8 @@ check($obj);
 echo "\n\n--- b refs c:\n";
 $obj = new stdClass;
 $obj->a = 1;
-$obj->b = &$obj->c;
 $obj->c = 1;
+$obj->b = &$obj->c;
 check($obj);
 
 echo "\n\n--- c refs a:\n";
@@ -74,15 +74,15 @@ check($obj);
 
 echo "\n\n--- a,b refs c:\n";
 $obj = new stdClass;
+$obj->c = 1;
 $obj->a = &$obj->c;
 $obj->b = &$obj->c;
-$obj->c = 1;
 check($obj);
 
 echo "\n\n--- a,c refs b:\n";
 $obj = new stdClass;
-$obj->a = &$obj->b;
 $obj->b = 1;
+$obj->a = &$obj->b;
 $obj->c = &$obj->b;
 check($obj);
 
@@ -491,4 +491,4 @@ object(stdClass)#%d (3) {
   ["c"]=>
   &string(14) "obj->c.changed"
 }
-Done
\ No newline at end of file
+Done
diff --git a/tests/classes/constants_error_005.phpt b/tests/classes/constants_error_005.phpt
index 1283783de7..25f36460b7 100644
--- a/tests/classes/constants_error_005.phpt
+++ b/tests/classes/constants_error_005.phpt
@@ -8,5 +8,4 @@ Error case: class constant as an encapsed containing a variable
   }
 ?>
 --EXPECTF--
-
-Parse error: %s in %s on line %d
+Fatal error: Constant expression contains invalid operations in %s on line %d
diff --git a/tests/classes/interface_method.phpt b/tests/classes/interface_method.phpt
index 3570b35928..f80bd756f3 100644
--- a/tests/classes/interface_method.phpt
+++ b/tests/classes/interface_method.phpt
@@ -6,7 +6,7 @@ ZE2 An interface method must be abstract
 <?php
 
 interface if_a {
-	function err() {};
+	function err() {}
 }
 
 ?>
diff --git a/tests/classes/method_call_variation_001.phpt b/tests/classes/method_call_variation_001.phpt
index dd43cfd1cb..7950b7deb3 100644
--- a/tests/classes/method_call_variation_001.phpt
+++ b/tests/classes/method_call_variation_001.phpt
@@ -1,37 +1,27 @@
 --TEST--
-In $a->$b[Y](), $b[Y] represents a method name on $a. But in $a->X[Y](), $a->X[Y] represents a global function name.
+In $a->$b[Y]() and $a->X[Y]() both $a->$b[Y] and $a->X[Y] represent a global function name
 --FILE--
 <?php
-  class C
-  {
-      function foo($a, $b)
-      {
-          echo "Called C::foo($a, $b)\n";
-      }
-  }
-  
-  $c = new C;
-  
-  $functions[0] = 'foo';
-  $functions[1][2][3][4] = 'foo';
-  
-  $c->$functions[0](1, 2);
-  $c->$functions[1][2][3][4](3, 4);
-  
-  
-  function foo($a, $b)
-  {
+  class C {}
+
+  function foo($a, $b) {
       echo "Called global foo($a, $b)\n";
   }
-  
+
+  $name = 'functions';
+
+  $c = new C;
   $c->functions[0] = 'foo';
   $c->functions[1][2][3][4] = 'foo';
   
+  $c->$name[0](1, 2);
+  $c->$name[1][2][3][4](3, 4);
+  
   $c->functions[0](5, 6);
   $c->functions[1][2][3][4](7, 8);
 ?>
 --EXPECTF--
-Called C::foo(1, 2)
-Called C::foo(3, 4)
+Called global foo(1, 2)
+Called global foo(3, 4)
 Called global foo(5, 6)
 Called global foo(7, 8)
diff --git a/tests/lang/engine_assignExecutionOrder_002.phpt b/tests/lang/engine_assignExecutionOrder_002.phpt
index ba88150dd4..c090a452c3 100644
--- a/tests/lang/engine_assignExecutionOrder_002.phpt
+++ b/tests/lang/engine_assignExecutionOrder_002.phpt
@@ -26,7 +26,7 @@ $g1 = array(10,10);
 $g2 = array(20,20);
 $g3 = array(30,30);
 $g = array($g1,$g2,$g3);
-list($e[$f++],$e[$f++]) = $g[$f];
+list($e[$f++],$e[$f++]) = $g[2];
 // expect 30,30
 var_dump($e); 
 
@@ -39,7 +39,7 @@ $i = array($i1,$i2,$i3,$i4);
 $j = array(0,0,0);
 $h = 0;
 // a list of lists 
-list(list($j[$h++],$j[$h++]),$j[$h++]) = $i[$h];
+list(list($j[$h++],$j[$h++]),$j[$h++]) = $i[3];
 var_dump($j);
 
 
@@ -116,9 +116,9 @@ L=100 M=200 N=300
 O= and P=
 10 20 40 50 60 70 80
 
-Notice: Undefined offset: 1 in %s on line %d
-
 Notice: Undefined offset: 0 in %s on line %d
+
+Notice: Undefined offset: 1 in %s on line %d
 Y=,Z=
 
 Notice: Undefined offset: 1 in %s on line %d
diff --git a/tests/lang/engine_assignExecutionOrder_004.phpt b/tests/lang/engine_assignExecutionOrder_004.phpt
index 86bc87f9c7..9471b7f063 100644
--- a/tests/lang/engine_assignExecutionOrder_004.phpt
+++ b/tests/lang/engine_assignExecutionOrder_004.phpt
@@ -18,15 +18,8 @@ function i3() {
         return 3;
 }
 
-function i4() {
-        global $a;
-        $a = array(10, 11, 12, 13, 14);
-        echo "i4\n";
-        return 4;
-}
-
-$a = 0; // $a should not be indexable till the i4 has been executed
-list($a[i1()+i2()], , list($a[i3()], $a[i4()]), $a[]) = array (0, 1, array(30, 40), 3, 4);
+$a = array(10, 11, 12, 13);
+list($a[i1()+i2()], , list($a[i3()], $a[])) = array(0, 1, array(30, 40), 3);
 
 var_dump($a);
 
@@ -35,8 +28,7 @@ var_dump($a);
 i1
 i2
 i3
-i4
-array(6) {
+array(5) {
   [0]=>
   int(10)
   [1]=>
@@ -47,6 +39,4 @@ array(6) {
   int(30)
   [4]=>
   int(40)
-  [5]=>
-  int(3)
 }
diff --git a/tests/run-test/test005.phpt b/tests/run-test/test005.phpt
index 3d51531ed9..5dcb650444 100644
--- a/tests/run-test/test005.phpt
+++ b/tests/run-test/test005.phpt
@@ -19,7 +19,8 @@ var_dump(ini_get('track_errors'));
 ini_set('display_errors', 0);
 var_dump(ini_get('display_errors'));
 var_dump($php_errormsg);
-$error = 1 / 0;
+$zero = 0;
+$error = 1 / $zero;
 var_dump($php_errormsg);
 ?>
 --EXPECTF--
diff --git a/tests/run-test/test008a.phpt b/tests/run-test/test008a.phpt
index 27da085e04..ff2a93be0f 100644
--- a/tests/run-test/test008a.phpt
+++ b/tests/run-test/test008a.phpt
@@ -19,7 +19,8 @@ var_dump(ini_get('track_errors'));
 ini_set('display_errors', 0);
 var_dump(ini_get('display_errors'));
 var_dump($php_errormsg);
-$error = 1 / 0;
+$zero = 0;
+$error = 1 / $zero;
 var_dump($php_errormsg);
 ?>
 --EXPECTF--