Namespace resolution streamlining patch

[DOC] new resolution rules should be documented soon

diff --git a/Zend/tests/bug42802.phpt b/Zend/tests/bug42802.phpt
index 31d9d34ae32c3027da1be92a521910ab6308fe17..2aa7061f35a08b96c32cbdafb098e91cbe9d0129 100755 (executable)
--- a/Zend/tests/bug42802.phpt
+++ b/Zend/tests/bug42802.phpt
@@ -20,26 +20,21 @@ function test3(\foo\bar $bar) {
 function test4(\Exception $e) {
        echo "ok\n";
 }
-function test5(Exception $e) {
-       echo "ok\n";
-}
-function test6(\bar $bar) {
+function test5(\bar $bar) {
         echo "bug\n";
 }
 
 $x = new bar();
-$y = new Exception();
+$y = new \Exception();
 test1($x);
 test2($x);
 test3($x);
 test4($y);
-test5($y);
-test6($x);
+test5($x);
 --EXPECTF--
 ok
 ok
 ok
 ok
-ok
 
-Catchable fatal error: Argument 1 passed to foo\test6() must be an instance of bar, instance of foo\bar given, called in %sbug42802.php on line 23
+Catchable fatal error: Argument 1 passed to foo\test5() must be an instance of bar, instance of foo\bar given, called in %sbug42802.php on line %d and defined in %sbug42802.php on line %d

diff --git a/Zend/tests/bug42819.phpt b/Zend/tests/bug42819.phpt
index d0e0dcc88782a90b84e1db50a9866e788b8efcb9..f4387eb93b5614bc88ab33fd05aa9e1c6434bdb8 100755 (executable)
--- a/Zend/tests/bug42819.phpt
+++ b/Zend/tests/bug42819.phpt
@@ -15,6 +15,7 @@ const C = "foo\\foo\\foo::C\n";
 }
 
 namespace foo;
+use \ArrayObject;
 
 const C = "foo\\C\n";
 const I = 11;
@@ -89,7 +90,6 @@ echo foo::C;
 echo \foo\foo::C;
 echo ArrayObject::STD_PROP_LIST . "\n";
 echo E_ERROR . "\n";
-
 echo "second\n";
 echo \foo\foo::C1;
 echo \foo\foo::C2;

diff --git a/Zend/tests/bug43332_1.phpt b/Zend/tests/bug43332_1.phpt
index 620725ab4ba25148a344a2ce317d2686f96d9425..807c6cb5454d6619ee70abc5a6cce0dd3c1fa1f6 100644 (file)
--- a/Zend/tests/bug43332_1.phpt
+++ b/Zend/tests/bug43332_1.phpt
@@ -10,6 +10,6 @@ class foo {
 
 $foo = new foo;
 $foo->bar($foo); // Ok!
-$foo->bar(new stdclass); // Error, ok!
+$foo->bar(new \stdclass); // Error, ok!
 --EXPECTF--
 Catchable fatal error: Argument 1 passed to foobar\foo::bar() must be an instance of foobar\foo, instance of stdClass given, called in %sbug43332_1.php on line 10 and defined in %sbug43332_1.php on line 5

diff --git a/Zend/tests/class_alias_021.phpt b/Zend/tests/class_alias_021.phpt
index 09144b813c1fc69cb89f37419b9ee448d6f32dae..dd90e127f4dc15e0aa44f85d761db17d2e8571c0 100644 (file)
--- a/Zend/tests/class_alias_021.phpt
+++ b/Zend/tests/class_alias_021.phpt
@@ -11,7 +11,7 @@ class_alias('foo\bar', 'baz');
 
 use \baz as stdClass;
 
-var_dump(new foo\bar);
+var_dump(new bar);
 var_dump(new stdClass);
 var_dump(new \baz);
 

diff --git a/Zend/tests/ns_002.phpt b/Zend/tests/ns_002.phpt
index 000928c3d6be802149a16d1ab8851e54fb69a74d..3d9e09869db63a7d95e6a209f48b59a2f00d9e09 100755 (executable)
--- a/Zend/tests/ns_002.phpt
+++ b/Zend/tests/ns_002.phpt
@@ -15,7 +15,7 @@ use test\ns1 as ns2;
 use test\ns1;
 
 Foo::bar();
-test\ns1\Foo::bar();
+\test\ns1\Foo::bar();
 Bar::bar();
 ns2\Foo::bar();
 ns1\Foo::bar();

diff --git a/Zend/tests/ns_004.phpt b/Zend/tests/ns_004.phpt
index 792367cdf63573902de8c6b276d9f923cae518af..d293f65dce313336628e4a0b699d00f8cdaae6e2 100755 (executable)
--- a/Zend/tests/ns_004.phpt
+++ b/Zend/tests/ns_004.phpt
@@ -1,9 +1,9 @@
 --TEST--
-004: Name conflict (php name)
+004: Using global class name from namespace (unqualified - fail)
 --FILE--
 <?php
 namespace test\ns1;
 
 echo get_class(new Exception()),"\n";
---EXPECT--
-Exception
+--EXPECTF--
+Fatal error: Class 'test\ns1\Exception' not found in %sns_004.php on line %d
\ No newline at end of file

diff --git a/Zend/tests/ns_010.phpt b/Zend/tests/ns_010.phpt
index c921f134bde05d7d1b98e7623b7409a3667a1871..28ef61bcdd2bdaa44803ba0e95ed07e1e8f48669 100755 (executable)
--- a/Zend/tests/ns_010.phpt
+++ b/Zend/tests/ns_010.phpt
@@ -15,35 +15,27 @@ class Foo {
        }
 }
 new Foo();
-new X\Foo();
 new Y\Foo();
 new \X\Foo();
 Foo::bar();
-X\Foo::bar();
 Y\Foo::bar();
 \X\Foo::bar();
 echo Foo::C;
-echo X\Foo::C;
 echo Y\Foo::C;
 echo \X\Foo::C;
 echo Foo::$var;
-echo X\Foo::$var;
 echo Y\Foo::$var;
 echo \X\Foo::$var;
 --EXPECT--
 class ok
 class ok
 class ok
-class ok
-method ok
 method ok
 method ok
 method ok
 const ok
 const ok
 const ok
-const ok
-var ok
 var ok
 var ok
 var ok

diff --git a/Zend/tests/ns_034.phpt b/Zend/tests/ns_034.phpt
index 1ab793e17d95983945f68fde8f5361c8b2a35127..76775f1180df5decf2ab1fe71a2d4aa469d2d7bc 100755 (executable)
--- a/Zend/tests/ns_034.phpt
+++ b/Zend/tests/ns_034.phpt
@@ -10,23 +10,18 @@ class Foo {
 function f1($x=Foo::C) {
        echo $x;
 }
-function f2($x=A\Foo::C) {
+function f2($x=B\Foo::C) {
        echo $x;
 }
-function f3($x=B\Foo::C) {
-       echo $x;
-}
-function f4($x=\A\Foo::C) {
+function f3($x=\A\Foo::C) {
        echo $x;
 }
 echo Foo::C;
-echo A\Foo::C;
 echo B\Foo::C;
 echo \A\Foo::C;
 f1();
 f2();
 f3();
-f4();
 --EXPECT--
 ok
 ok
@@ -34,5 +29,3 @@ ok
 ok
 ok
 ok
-ok
-ok

diff --git a/Zend/tests/ns_035.phpt b/Zend/tests/ns_035.phpt
index b8aa717a071a3a49f21ab0753462133f63c655e1..fcc771a74e7fef85e94e542b55ebc429b6129173 100755 (executable)
--- a/Zend/tests/ns_035.phpt
+++ b/Zend/tests/ns_035.phpt
@@ -5,6 +5,8 @@
 --FILE--
 <?php
 namespace A;
+use \ArrayObject;
+
 function f1($x = ArrayObject::STD_PROP_LIST) {
        var_dump($x);
 }

diff --git a/Zend/tests/ns_036.phpt b/Zend/tests/ns_036.phpt
index e63a7a44484c615cea23de3dcf3a4ee090d1b719..245cf7d5b5319f02aa73aeffb6ab71505552df2b 100755 (executable)
--- a/Zend/tests/ns_036.phpt
+++ b/Zend/tests/ns_036.phpt
@@ -15,25 +15,20 @@ function f1($x = ArrayObject::STD_PROP_LIST) {
 function f2($x = \ArrayObject::STD_PROP_LIST) {
        var_dump($x);
 }
-function f3($x = A\ArrayObject::STD_PROP_LIST) {
+function f3($x = \A\ArrayObject::STD_PROP_LIST) {
        var_dump($x);
 }
 function f4($x = B\ArrayObject::STD_PROP_LIST) {
        var_dump($x);
 }
-function f5($x = \A\ArrayObject::STD_PROP_LIST) {
-       var_dump($x);
-}
 var_dump(ArrayObject::STD_PROP_LIST);
 var_dump(\ArrayObject::STD_PROP_LIST);
-var_dump(A\ArrayObject::STD_PROP_LIST);
 var_dump(B\ArrayObject::STD_PROP_LIST);
 var_dump(\A\ArrayObject::STD_PROP_LIST);
 f1();
 f2();
 f3();
 f4();
-f5();
 ?>
 --EXPECT--
 int(2)
@@ -41,8 +36,6 @@ int(1)
 int(2)
 int(2)
 int(2)
-int(2)
 int(1)
 int(2)
 int(2)
-int(2)

diff --git a/Zend/tests/ns_037.phpt b/Zend/tests/ns_037.phpt
index ba665925b4bd14ff285d52742354e0673df51837..db0a76e940d2407b1919a9fb0b5804b25782b44b 100755 (executable)
--- a/Zend/tests/ns_037.phpt
+++ b/Zend/tests/ns_037.phpt
@@ -15,35 +15,27 @@ class X {
        }
 }
 new X();
-new X\X();
 new Y\X();
 new \X\X();
 X::bar();
-X\X::bar();
 Y\X::bar();
 \X\X::bar();
 echo X::C;
-echo X\X::C;
 echo Y\X::C;
 echo \X\X::C;
 echo X::$var;
-echo X\X::$var;
 echo Y\X::$var;
 echo \X\X::$var;
 --EXPECT--
 class ok
 class ok
 class ok
-class ok
-method ok
 method ok
 method ok
 method ok
 const ok
 const ok
 const ok
-const ok
-var ok
 var ok
 var ok
 var ok

diff --git a/Zend/tests/ns_038.phpt b/Zend/tests/ns_038.phpt
index 86cdaea30d77fee490334eddd159a005b542e573..f3a8c8cc632f74654cf5e9f99821dd70a27ef6aa 100755 (executable)
--- a/Zend/tests/ns_038.phpt
+++ b/Zend/tests/ns_038.phpt
@@ -7,7 +7,7 @@ function foo() {
   echo "ok\n";
 }
 \Exception\foo();
-Exception::bar();
+\Exception::bar();
 --EXPECTF--
 ok
 

diff --git a/Zend/tests/ns_054.phpt b/Zend/tests/ns_054.phpt
index 528a3f8fb269c41411f178c1e33344bf9af31ed7..54ab9586112127e713b2f253dbd19a63c046877f 100755 (executable)
--- a/Zend/tests/ns_054.phpt
+++ b/Zend/tests/ns_054.phpt
@@ -6,13 +6,13 @@
 <?php
 namespace test\ns1;
 
-class Foo implements SplObserver {
+class Foo implements \SplObserver {
        function update(\SplSubject $x) {
                echo "ok\n";
        }
 }
 
-class Bar implements SplSubject {
+class Bar implements \SplSubject {
        function attach(\SplObserver $x) {
                echo "ok\n";
        }

diff --git a/Zend/tests/ns_055.phpt b/Zend/tests/ns_055.phpt
index e10a55c5134c3c15fa105018051e628627654dd1..a692e476014708d8f564c58a21aa9135e86346ce 100755 (executable)
--- a/Zend/tests/ns_055.phpt
+++ b/Zend/tests/ns_055.phpt
@@ -11,23 +11,18 @@ class Foo {
        function test2(\test\ns1\Foo $x) {
                echo "ok\n";
        }
-       function test3(Exception $x) {
-               echo "ok\n";
-       }
-       function test4(\Exception $x) {
+       function test3(\Exception $x) {
                echo "ok\n";
        }
 }
 
 $foo = new Foo();
-$ex = new Exception();
+$ex = new \Exception();
 $foo->test1($foo);
 $foo->test2($foo);
 $foo->test3($ex);
-$foo->test4($ex);
 ?>
 --EXPECT--
 ok
 ok
 ok
-ok

diff --git a/Zend/tests/ns_056.phpt b/Zend/tests/ns_056.phpt
index 2df5d6d6c4fb3331f526b03762708d39771078f0..2390608d4ee078c350ac562a66899a0909c353e9 100755 (executable)
--- a/Zend/tests/ns_056.phpt
+++ b/Zend/tests/ns_056.phpt
@@ -5,14 +5,15 @@
 --FILE--
 <?php
 namespace test\ns1;
+use \SplObserver;
 
 class Foo implements SplObserver {
-       function update(SplSubject $x) {
+       function update(\SplSubject $x) {
                echo "ok\n";
        }
 }
 
-class Bar implements SplSubject {
+class Bar implements \SplSubject {
        function attach(SplObserver $x) {
                echo "ok\n";
        }

diff --git a/Zend/tests/ns_057.phpt b/Zend/tests/ns_057.phpt
index 7a994f618228a15e972cc64c0a809293e240d381..13bf3054ccdd6a121d2b03b464fef462ba44dbca 100755 (executable)
--- a/Zend/tests/ns_057.phpt
+++ b/Zend/tests/ns_057.phpt
@@ -42,6 +42,7 @@ echo namespace\foo::bar();
 echo namespace\f1();
 echo namespace\f2();
 echo namespace\f3(new namespace\foo());
+echo namespace\unknown;
 ?>
 --EXPECTF--
 const ok
@@ -54,3 +55,5 @@ const ok
 const ok
 class ok
 ok
+
+Fatal error: Undefined constant 'Test\ns1\unknown' in %sns_057.php on line %d
\ No newline at end of file

diff --git a/Zend/tests/ns_058.phpt b/Zend/tests/ns_058.phpt
index 7fc5909bef06289b34da4ded916400ce65a5589c..7a0cd97d922aa9a9162ad0527a6d1229230adfd6 100755 (executable)
--- a/Zend/tests/ns_058.phpt
+++ b/Zend/tests/ns_058.phpt
@@ -40,8 +40,9 @@ echo namespace\foo::bar();
 echo namespace\f1();
 echo namespace\f2();
 echo namespace\f3(new namespace\foo());
+echo namespace\unknown;
 ?>
---EXPECT--
+--EXPECTF--
 const ok
 func ok
 const ok
@@ -52,3 +53,5 @@ const ok
 const ok
 class ok
 ok
+
+Fatal error: Undefined constant 'unknown' in %sns_058.php on line %d

diff --git a/Zend/tests/ns_070.phpt b/Zend/tests/ns_070.phpt
index 850b82040c59dfa6aea3d56cf78d3733b1de8f2f..37cb6a006829659c9142c3bfd75a9a0ada9a99bb 100644 (file)
--- a/Zend/tests/ns_070.phpt
+++ b/Zend/tests/ns_070.phpt
@@ -11,7 +11,7 @@ class bar {
        }
 }
 
-new bar(new stdclass);
+new bar(new \stdclass);
 new bar(null);
 
 ?>

diff --git a/Zend/tests/ns_071.phpt b/Zend/tests/ns_071.phpt
index f31e0cc6839a4d18854185ef3c5735bcad236cff..1fdaec9db301360d83c0f42e76994947ca79c80f 100644 (file)
--- a/Zend/tests/ns_071.phpt
+++ b/Zend/tests/ns_071.phpt
@@ -12,7 +12,7 @@ class bar {
 }
 
 new bar(null);
-new bar(new stdclass);
+new bar(new \stdclass);
 
 ?>
 --EXPECTF--

diff --git a/Zend/tests/ns_072.phpt b/Zend/tests/ns_072.phpt
index aaba0ddb5f95a324c5e68e1c1d8f68f26983df14..c500bfddb7e9ce5e7fc4455dd6c05901335d6bfe 100644 (file)
--- a/Zend/tests/ns_072.phpt
+++ b/Zend/tests/ns_072.phpt
@@ -22,7 +22,7 @@ class test implements foo {
 
 new bar(new test);
 new bar(null);
-new bar(new stdclass);
+new bar(new \stdclass);
 
 ?>
 --EXPECTF--

diff --git a/Zend/tests/ns_073.phpt b/Zend/tests/ns_073.phpt
index 4f37aa58b45cfe8ba620b9db8922181b2ba34ac1..bb03308d71b5d821a5b58919308266bcdb93fe76 100644 (file)
--- a/Zend/tests/ns_073.phpt
+++ b/Zend/tests/ns_073.phpt
@@ -11,12 +11,9 @@ $x = function (\stdclass $x = NULL) {
 
 $x(NULL);
 $x(new \stdclass);
-$x(new stdclass);
 
 ?>
 --EXPECTF--
 NULL
 object(stdClass)#%d (0) {
 }
-object(stdClass)#%d (0) {
-}

diff --git a/Zend/tests/ns_074.phpt b/Zend/tests/ns_074.phpt
index 5b15e3b42fa130aabd933434a7abb7fdfb893334..28d8bf96b63aaf93fd74c6352a7df2b2b0504a58 100644 (file)
--- a/Zend/tests/ns_074.phpt
+++ b/Zend/tests/ns_074.phpt
@@ -9,16 +9,16 @@ $x = function (\stdclass $x = NULL) {
        var_dump($x);   
 };
 
-class stdclass { }
+class stdclass extends \stdclass { }
 
 $x(NULL);
 $x(new stdclass);
-$x(new stdclass);
+$x(new \stdclass);
 
 ?>
 --EXPECTF--
 NULL
-object(foo\stdClass)#%d (0) {
+object(foo\stdclass)#%d (0) {
 }
-object(foo\stdClass)#%d (0) {
+object(stdClass)#%d (0) {
 }

diff --git a/Zend/zend.h b/Zend/zend.h
index b499020ef526a8100908a3a4a5ce220b32c3ea6d..af9e09aa1cd1134acf170ee1d6670fdf01be7f7c 100644 (file)
--- a/Zend/zend.h
+++ b/Zend/zend.h
@@ -516,7 +516,7 @@ typedef int (*zend_write_func_t)(const char *str, uint str_length);
 
 /* Ugly hack to support constants as static array indices */
 #define IS_CONSTANT_TYPE_MASK  0x0f
-#define IS_CONSTANT_RT_NS_CHECK        0x10
+#define IS_CONSTANT_UNQUALIFIED        0x10
 #define IS_CONSTANT_INDEX              0x80
 #define IS_LEXICAL_VAR                 0x20
 #define IS_LEXICAL_REF                 0x40

diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
index 90dcad362eb76d59a3acb80d81e6b23c02719284..7c5cfb55bd7daa8daf6f1ca979bb23d327686b9a 100644 (file)
--- a/Zend/zend_compile.c
+++ b/Zend/zend_compile.c
@@ -1535,42 +1535,28 @@ int zend_do_begin_function_call(znode *function_name, zend_bool check_namespace
        zend_function *function;
        char *lcname;
        int prefix_len = 0;
-       char *is_compound = NULL;
+       char *is_compound = memchr(Z_STRVAL(function_name->u.constant), '\\', Z_STRLEN(function_name->u.constant));
 
-       if (Z_STRVAL(function_name->u.constant)[0] == '\\') {
-               is_compound = memchr(Z_STRVAL(function_name->u.constant)+1, '\\', Z_STRLEN(function_name->u.constant)-1);
-       } else {
-               is_compound = memchr(Z_STRVAL(function_name->u.constant), '\\', Z_STRLEN(function_name->u.constant));
-       }
-       if (check_namespace) {
-               ulong unused;
+       zend_resolve_non_class_name(function_name, check_namespace TSRMLS_CC);
 
-               zend_resolve_non_class_name(function_name, &unused, 2, 1 TSRMLS_CC);
-               if (Z_STRVAL(function_name->u.constant)[0] == '\\') {
-                       memmove(Z_STRVAL(function_name->u.constant), Z_STRVAL(function_name->u.constant)+1, Z_STRLEN(function_name->u.constant));
-                       --Z_STRLEN(function_name->u.constant);
-               }
-               if (CG(current_namespace) && !is_compound) {
+       if (check_namespace && CG(current_namespace) && !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 */
-                       prefix_len = Z_STRLEN_P(CG(current_namespace)) + 1;
-               }
-       } else if (Z_STRVAL(function_name->u.constant)[0] == '\\') {
-               memmove(Z_STRVAL(function_name->u.constant), Z_STRVAL(function_name->u.constant)+1, Z_STRLEN(function_name->u.constant));
-               --Z_STRLEN(function_name->u.constant);
-       }
-       
+                       zend_do_begin_dynamic_function_call(function_name, 1 TSRMLS_CC);
+                       return 1;
+       } 
+
        lcname = zend_str_tolower_dup(function_name->u.constant.value.str.val, function_name->u.constant.value.str.len);
        if ((zend_hash_find(CG(function_table), lcname, function_name->u.constant.value.str.len+1, (void **) &function)==FAILURE) ||
-               ((CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_FUNCTIONS) &&
-                (function->type == ZEND_INTERNAL_FUNCTION))) {
-               zend_do_begin_dynamic_function_call(function_name, prefix_len TSRMLS_CC);
-               efree(lcname);
-               return 1; /* Dynamic */
-       }
+               ((CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_FUNCTIONS) &&
+               (function->type == ZEND_INTERNAL_FUNCTION))) {
+                       zend_do_begin_dynamic_function_call(function_name, 0 TSRMLS_CC);
+                       efree(lcname);
+                       return 1; /* Dynamic */
+       } 
        efree(function_name->u.constant.value.str.val);
        function_name->u.constant.value.str.val = lcname;
        
@@ -1636,14 +1622,14 @@ void zend_do_clone(znode *result, const znode *expr TSRMLS_DC)
 }
 
 
-void zend_do_begin_dynamic_function_call(znode *function_name, int prefix_len TSRMLS_DC)
+void zend_do_begin_dynamic_function_call(znode *function_name, int ns_call TSRMLS_DC)
 {
        unsigned char *ptr = NULL;
-       zend_op *opline;
+       zend_op *opline, *opline2;
 
        opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-
-       if (prefix_len) {
+       if (ns_call) {
+               char *slash;
                /* 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;
@@ -1654,15 +1640,18 @@ void zend_do_begin_dynamic_function_call(znode *function_name, int prefix_len TS
                Z_STRVAL(opline->op1.u.constant) = zend_str_tolower_dup(Z_STRVAL(opline->op2.u.constant), Z_STRLEN(opline->op2.u.constant));
                Z_STRLEN(opline->op1.u.constant) = Z_STRLEN(opline->op2.u.constant);
                opline->extended_value = zend_hash_func(Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant) + 1);
-               opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-               opline->opcode = ZEND_OP_DATA;
-               opline->op1.op_type = IS_CONST;
-               Z_TYPE(opline->op1.u.constant) = IS_STRING;
-               Z_STRLEN(opline->op1.u.constant) = Z_STRLEN(function_name->u.constant) - prefix_len;
-               Z_STRVAL(opline->op1.u.constant) = zend_str_tolower_dup(Z_STRVAL(function_name->u.constant) + prefix_len, Z_STRLEN(opline->op1.u.constant));
-               opline->op2.op_type = IS_CONST;
-               ZVAL_BOOL(&opline->op2.u.constant, (memchr(Z_STRVAL(opline->op1.u.constant), '\\', Z_STRLEN(opline->op1.u.constant)) != NULL));
-               opline->extended_value = zend_hash_func(Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant) + 1);
+               opline2 = get_next_op(CG(active_op_array) TSRMLS_CC);
+               opline2->opcode = ZEND_OP_DATA;
+               opline2->op1.op_type = IS_CONST;
+               Z_TYPE(opline2->op1.u.constant) = IS_LONG;
+               slash = zend_memrchr(Z_STRVAL(opline->op1.u.constant), '\\', Z_STRLEN(opline->op1.u.constant));
+               if(!slash) {
+                       zend_error(E_CORE_ERROR, "Namespaced name %s should contain slash", Z_STRVAL(opline->op1.u.constant));
+               }
+               /* this is the length of namespace prefix */
+               Z_LVAL(opline2->op1.u.constant) = slash-Z_STRVAL(opline->op1.u.constant)+1;
+               /* this is the hash of the non-prefixed part, lowercased */
+               opline2->extended_value = zend_hash_func(slash+1, Z_STRLEN(opline->op1.u.constant)-Z_LVAL(opline2->op1.u.constant)+1);
        } else {
                opline->opcode = ZEND_INIT_FCALL_BY_NAME;
                opline->op2 = *function_name;
@@ -1678,34 +1667,33 @@ void zend_do_begin_dynamic_function_call(znode *function_name, int prefix_len TS
                }
        }
 
-
-
        zend_stack_push(&CG(function_call_stack), (void *) &ptr, sizeof(zend_function *));
        zend_do_extended_fcall_begin(TSRMLS_C);
 }
 
-/* type = 1 for constant, 2 for function */
-void zend_resolve_non_class_name(znode *element_name, ulong *fetch_type, int type, int check_namespace TSRMLS_DC)
+void zend_resolve_non_class_name(znode *element_name, zend_bool check_namespace TSRMLS_DC)
 {
        znode tmp;
        int len;
        zval **ns;
-       char *lcname, *check_import = memchr(Z_STRVAL(element_name->u.constant), '\\', Z_STRLEN(element_name->u.constant));
+       char *lcname, *compound = memchr(Z_STRVAL(element_name->u.constant), '\\', Z_STRLEN(element_name->u.constant));
 
        if (Z_STRVAL(element_name->u.constant)[0] == '\\') {
-               check_namespace = 0;
-               check_import = 0;
+               /* name starts with \ so it is known and unambiguos, nothing to do here but shorten it */
+               memmove(Z_STRVAL(element_name->u.constant), Z_STRVAL(element_name->u.constant)+1, Z_STRLEN(element_name->u.constant));
+               --Z_STRLEN(element_name->u.constant);
+               return;
+       }
+
+       if(!check_namespace) {
+               return;
        }
 
-       if (check_import && CG(current_import)) {
-               len = check_import - Z_STRVAL(element_name->u.constant);
+       if (compound && CG(current_import)) {
+               len = compound - Z_STRVAL(element_name->u.constant);
                lcname = zend_str_tolower_dup(Z_STRVAL(element_name->u.constant), len);
                /* Check if first part of compound name is an import name */
                if (zend_hash_find(CG(current_import), lcname, len+1, (void**)&ns) == SUCCESS) {
-                       if (!check_import && type == 1) {
-                               /* tell zend_get_constant_ex this is an ambiguous T_STRING */
-                               *fetch_type |= IS_CONSTANT_RT_NS_CHECK;
-                       }
                        /* Substitute import name */
                        tmp.op_type = IS_CONST;
                        tmp.u.constant = **ns;
@@ -1714,22 +1702,14 @@ void zend_resolve_non_class_name(znode *element_name, ulong *fetch_type, int typ
                        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);
-                       if (Z_STRVAL(tmp.u.constant)[0] != '\\') {
-                               /* make this a \global\namespaced\element */
-                               znode global;
-
-                               zend_do_build_namespace_name(&global, NULL, &tmp TSRMLS_CC);
-                               *element_name = global;
-                       } else {
-                               *element_name = tmp;
-                       }
+                       *element_name = tmp;
                        efree(lcname);
                        return;
                }
                efree(lcname);
        }
 
-       if (check_namespace && CG(current_namespace)) {
+       if (CG(current_namespace)) {
                tmp = *element_name;
                Z_STRLEN(tmp.u.constant) = sizeof("\\")-1 + Z_STRLEN(element_name->u.constant) + Z_STRLEN_P(CG(current_namespace));
                Z_STRVAL(tmp.u.constant) = (char *) emalloc(Z_STRLEN(tmp.u.constant)+1);
@@ -1738,11 +1718,6 @@ void zend_resolve_non_class_name(znode *element_name, ulong *fetch_type, int typ
                memcpy(&(Z_STRVAL(tmp.u.constant)[Z_STRLEN_P(CG(current_namespace)) + sizeof("\\")-1]), Z_STRVAL(element_name->u.constant), Z_STRLEN(element_name->u.constant)+1);
                STR_FREE(Z_STRVAL(element_name->u.constant));
                *element_name = tmp;
-               if (type == 1) {
-                       /* We assume we use constant from the current namespace
-                               if it is not prefixed. */
-                       *fetch_type |= IS_CONSTANT_RT_NS_CHECK;
-               }
        }
 }
 
@@ -1757,8 +1732,7 @@ void zend_resolve_class_name(znode *class_name, ulong *fetch_type, int check_ns_
        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_TYPE(class_name->u.constant) == IS_STRING &&
-                   Z_STRVAL(class_name->u.constant)[0] == '\\') {
+               if (Z_STRVAL(class_name->u.constant)[0] == '\\') {
                    /* The STRING name has "\" prefix */
                    Z_STRLEN(class_name->u.constant) -= 1;
                    memmove(Z_STRVAL(class_name->u.constant), Z_STRVAL(class_name->u.constant)+1, Z_STRLEN(class_name->u.constant)+1);
@@ -1784,11 +1758,12 @@ void zend_resolve_class_name(znode *class_name, ulong *fetch_type, int check_ns_
                                        memmove(Z_STRVAL(class_name->u.constant), Z_STRVAL(class_name->u.constant)+len, Z_STRLEN(class_name->u.constant)+1);
                                        zend_do_build_namespace_name(&tmp, &tmp, class_name TSRMLS_CC);
                                        *class_name = tmp;
+                                       efree(lcname);
+                                       return;
                                }
                                efree(lcname);
-                               return;
                        }
-
+                       /* Here name is not prefixed with \ and not imported */
                        if (CG(current_namespace)) {
                                tmp.op_type = IS_CONST;
                                tmp.u.constant = *CG(current_namespace);
@@ -1808,23 +1783,7 @@ void zend_resolve_class_name(znode *class_name, ulong *fetch_type, int check_ns_
                        class_name->u.constant = **ns;
                        zval_copy_ctor(&class_name->u.constant);
                } else if (CG(current_namespace)) {
-                       zend_class_entry **pce;
-
-                       if (check_ns_name) {
-                           /* PHP will need to perform additional checks at run-time to
-                              determine if we assume namespace or class name. */
-                               *fetch_type |= ZEND_FETCH_CLASS_RT_NS_NAME;
-                       }
-
-                       if ((CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_CLASSES) ||
-                           (zend_hash_find(CG(class_table), lcname, Z_STRLEN(class_name->u.constant)+1, (void**)&pce) == SUCCESS &&
-                           (*pce)->type == ZEND_INTERNAL_CLASS)) {
-                           /* There is an internal class with the same name exists.
-                              PHP will need to perform additional cheks at run-time to
-                              determine if we assume class in current namespace or
-                              internal one. */
-                               *fetch_type |= ZEND_FETCH_CLASS_RT_NS_CHECK;
-                       }
+                       /* plain name, no import - prepend current namespace to it */
                        tmp.op_type = IS_CONST;
                        tmp.u.constant = *CG(current_namespace);
                        zval_copy_ctor(&tmp.u.constant);
@@ -2059,7 +2018,6 @@ int zend_do_begin_class_member_function_call(znode *class_name, znode *method_na
        }
        opline = get_next_op(CG(active_op_array) TSRMLS_CC);
        opline->opcode = ZEND_INIT_STATIC_METHOD_CALL;
-       opline->extended_value = fetch_type & ~ZEND_FETCH_CLASS_RT_NS_NAME;
        opline->op1 = class_node;
        opline->op2 = *method_name;
 
@@ -2077,11 +2035,6 @@ int zend_do_begin_class_member_function_call(znode *class_name, znode *method_na
 
                nsname = Z_STRVAL(class_node.u.constant);
                nsname_len = Z_STRLEN(class_node.u.constant);
-               if (fetch_type & ZEND_FETCH_CLASS_RT_NS_NAME) {
-                       /* Remove namespace name */
-                       nsname = (char *)memchr(nsname, '\\', nsname_len) + 1;
-                       nsname_len -= (nsname - Z_STRVAL(class_node.u.constant));
-               }
                len = nsname_len + 1 + Z_STRLEN(method_name->u.constant);
                fname = emalloc(len + 1);
                memcpy(fname, nsname, nsname_len);
@@ -3924,9 +3877,9 @@ void zend_do_fetch_constant(znode *result, znode *constant_container, znode *con
        znode tmp;
        zend_op *opline;
        int type;
-       char *check_import;
+       char *compound;
        ulong fetch_type = 0;
-       int unknown_should_fatal = 0;
+       int unknown_should_fail = 0;
 
        if (constant_container) {
                switch (mode) {
@@ -3955,7 +3908,6 @@ void zend_do_fetch_constant(znode *result, znode *constant_container, znode *con
                                opline->opcode = ZEND_FETCH_CONSTANT;
                                opline->result.op_type = IS_TMP_VAR;
                                opline->result.u.var = get_temporary_variable(CG(active_op_array));
-                               opline->extended_value = fetch_type & ~ZEND_FETCH_CLASS_RT_NS_NAME;
                                opline->op1 = *constant_container;
                                opline->op2 = *constant_name;
                                *result = opline->result;
@@ -3964,100 +3916,46 @@ void zend_do_fetch_constant(znode *result, znode *constant_container, znode *con
                return;
        }
        /* namespace constant */
+       /* only one that did not contain \ from the start can be converted to string if unknown */
        switch (mode) {
                case ZEND_CT:
-                       if (check_namespace == 2) {
-                               unknown_should_fatal = 1;
-                               check_namespace = 0;
-                       }
-                       type = zend_get_class_fetch_type(Z_STRVAL(constant_name->u.constant), Z_STRLEN(constant_name->u.constant));
-                       check_import = memchr(Z_STRVAL(constant_name->u.constant), '\\', Z_STRLEN(constant_name->u.constant));
+                       compound = memchr(Z_STRVAL(constant_name->u.constant), '\\', Z_STRLEN(constant_name->u.constant));
                        /* this is a namespace constant, or an unprefixed constant */
 
-                       if (Z_STRVAL(constant_name->u.constant)[0] == '\\') {
-                               check_namespace = 0;
-                               if (memchr(Z_STRVAL(constant_name->u.constant)+1, '\\', Z_STRLEN(constant_name->u.constant)-1)) {
-                                       /* tell engine this is an explicit namespaced constant, which
-                                          results in fatal error if constant not found, see
-                                          zend_execute_API.c::zval_update_constant_ex() */
-                                       unknown_should_fatal = 1;
-                               }
-                               check_import = 0;
-                       } else if (check_import) {
-                               unknown_should_fatal = 1;
-                       }
-                       if (ZEND_FETCH_CLASS_STATIC == type) {
-                               zend_error(E_ERROR, "\"static\\\" is not allowed in compile-time constants");
-                       }
-
-                       zend_resolve_non_class_name(constant_name, &fetch_type, 1, check_namespace TSRMLS_CC);
                        if (zend_constant_ct_subst(result, &constant_name->u.constant, 0 TSRMLS_CC)) {
                                break;
                        }
-                       fetch_type &= IS_CONSTANT_RT_NS_CHECK;
-                       if (unknown_should_fatal) {
-                               fetch_type |= ZEND_FETCH_CLASS_RT_NS_CHECK;
+
+                       zend_resolve_non_class_name(constant_name, check_namespace TSRMLS_CC);
+
+                       if(!compound) {
+                               fetch_type |= IS_CONSTANT_UNQUALIFIED;
                        }
+
                        *result = *constant_name;
                        result->u.constant.type = IS_CONSTANT | fetch_type;
                        break;
                case ZEND_RT:
-                       /* this is a namespace constant, or an unprefixed constant */
-                       /* check_namespace = 2 means namespace\ prefix passed in */
-                       /* check_namespace = 0 means \constant\name passed in */
-                       /* check_namespace = 1 means constant\name passed in or name passed in */
+                       compound = memchr(Z_STRVAL(constant_name->u.constant), '\\', Z_STRLEN(constant_name->u.constant));
 
-                       if (check_namespace == 2) {
-                               unknown_should_fatal = 1;
-                               check_namespace = 0;
-                       }
-                       type = zend_get_class_fetch_type(Z_STRVAL(constant_name->u.constant), Z_STRLEN(constant_name->u.constant));
-                       if (ZEND_FETCH_CLASS_STATIC == type) {
-                               zend_error(E_ERROR, "\"static::\" is not allowed in compile-time constants");
+                       zend_resolve_non_class_name(constant_name, check_namespace TSRMLS_CC);
+                       
+                       if(zend_constant_ct_subst(result, &constant_name->u.constant, 1 TSRMLS_CC)) {
+                               break;
                        }
 
-                       if (Z_STRVAL(constant_name->u.constant)[0] == '\\') {
-                               check_namespace = 0;
-                               check_import = 0;
-                               if (memchr(Z_STRVAL(constant_name->u.constant)+1, '\\', Z_STRLEN(constant_name->u.constant)-1)) {
-                                       /* tell engine this is an explicit namespaced constant, which
-                                          results in fatal error if constant not found */
-                                       unknown_should_fatal = 1;
-                               }
-
-                               /* we can only check for compile-time if the constant is explicitly
-                                       \top\level */
-check_compile_time:
-                               if (zend_constant_ct_subst(result, &constant_name->u.constant, 1 TSRMLS_CC)) {
-                                       break;
-                               }
-                       } else {
-                               check_import = memchr(Z_STRVAL(constant_name->u.constant), '\\', Z_STRLEN(constant_name->u.constant));
-                               if (check_import) {
-                                       unknown_should_fatal = 1;
-                               }
-
-                               if (!check_namespace || !CG(current_namespace)) {
-                                       goto check_compile_time;
-                               }
-                       }
-                       /* we reach here if the constant name is ambiguous (not \this) */
-                       /* we will store nsname and <whatever>, where
-                               <whatever> is the actual constant name passed in (foo or foo/foo)
-                               and ZEND_FETCH_CONSTANT will first look for nsname/<whatever> and then
-                               <whatever> after current_import is applied to <whatever> */
                        opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-                       if (unknown_should_fatal) {
-                               fetch_type = ZEND_FETCH_CLASS_RT_NS_CHECK;
-                       }
                        opline->opcode = ZEND_FETCH_CONSTANT;
                        opline->result.op_type = IS_TMP_VAR;
                        opline->result.u.var = get_temporary_variable(CG(active_op_array));
                        *result = opline->result;
-
                        SET_UNUSED(opline->op1);
-                       zend_resolve_non_class_name(constant_name, &fetch_type, 1, check_namespace TSRMLS_CC);
-                       opline->extended_value = fetch_type;
+                       if(compound) {
+                               /* the name is unambiguous */
+                               opline->extended_value = 0;
+                       } else {
+                               opline->extended_value = IS_CONSTANT_UNQUALIFIED;
+                       }
                        opline->op2 = *constant_name;
                        break;
        }
@@ -5308,7 +5206,7 @@ void zend_do_declare_constant(znode *name, znode *value TSRMLS_DC) /* {{{ */
        }
 
        if (CG(current_namespace)) {
-               /* Prefix constant name with name of current namespace */
+               /* Prefix constant name with name of current namespace, lowercased */
                znode tmp;
 
                tmp.op_type = IS_CONST;

diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h
index 25c2c5f13d1541978338a6fa413dce7ad5bba0bf..50f56d9c417ef1c930058351b652fedfb567796b 100644 (file)
--- a/Zend/zend_compile.h
+++ b/Zend/zend_compile.h
@@ -359,7 +359,7 @@ ZEND_API char *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, ulong *fetch_type, int type, int check_namespace TSRMLS_DC);
+void zend_resolve_non_class_name(znode *element_name, zend_bool check_namespace TSRMLS_DC);
 void zend_resolve_class_name(znode *class_name, ulong *fetch_type, int check_ns_name TSRMLS_DC);
 ZEND_API char* zend_get_compiled_variable_name(const zend_op_array *op_array, zend_uint var, int* name_len);
 
@@ -636,8 +636,6 @@ int zendlex(znode *zendlval TSRMLS_DC);
 #define ZEND_FETCH_CLASS_INTERFACE     6
 #define ZEND_FETCH_CLASS_STATIC                7
 #define ZEND_FETCH_CLASS_MASK        0x0f
-#define ZEND_FETCH_CLASS_RT_NS_CHECK 0x20
-#define ZEND_FETCH_CLASS_RT_NS_NAME  0x40
 #define ZEND_FETCH_CLASS_NO_AUTOLOAD 0x80
 #define ZEND_FETCH_CLASS_SILENT      0x0100
 

diff --git a/Zend/zend_constants.c b/Zend/zend_constants.c
index 4bff7b6e7e999c51666db2cd48405e2e1a650325..cdf4dcac65873c5674bf56e3c54af567ff210447 100644 (file)
--- a/Zend/zend_constants.c
+++ b/Zend/zend_constants.c
@@ -281,11 +281,10 @@ ZEND_API int zend_get_constant_ex(const char *name, uint name_len, zval *result,
        char *class_name;
        zval **ret_constant;
 
-       /* Skip leading :: */
+       /* Skip leading \\ */
        if (name[0] == '\\') {
                name += 1;
                name_len -= 1;
-               flags &= ZEND_FETCH_CLASS_SILENT;
        }
 
 
@@ -335,10 +334,7 @@ ZEND_API int zend_get_constant_ex(const char *name, uint name_len, zval *result,
                        efree(lcname);
                } else {
                        efree(lcname);
-                       if ((flags & IS_CONSTANT_RT_NS_CHECK) == 0) {
-                               /* Check for class */
-                               ce = zend_fetch_class(class_name, class_name_len, flags TSRMLS_CC);
-                       }
+                       ce = zend_fetch_class(class_name, class_name_len, flags TSRMLS_CC);
                }
                if (retval && ce) {
                        if (zend_hash_find(&ce->constants_table, constant_name, const_name_len+1, (void **) &ret_constant) != SUCCESS) {
@@ -350,34 +346,28 @@ ZEND_API int zend_get_constant_ex(const char *name, uint name_len, zval *result,
                } else if (!ce) {
                        retval = 0;
                }
+               efree(class_name);
                goto finish;
        }
 
-       if ((colon = zend_memrchr(name, '\\', name_len)) &&
-           colon > name) {
+       /* non-class constant */
+       if ((colon = zend_memrchr(name, '\\', name_len)) != NULL) {
                /* compound constant name */
-               int class_name_len = colon - name;
-               int const_name_len = name_len - class_name_len - 1;
+               int prefix_len = colon - name;
+               int const_name_len = name_len - prefix_len - 1;
                char *constant_name = colon + 1;
                char *lcname;
-               char *nsname;
-               unsigned int nsname_len;
 
-               class_name = estrndup(name, class_name_len);
-               lcname = zend_str_tolower_dup(class_name, class_name_len);
+               lcname = zend_str_tolower_dup(name, prefix_len);
                /* Check for namespace constant */
 
                /* Concatenate lowercase namespace name and constant name */
-               lcname = erealloc(lcname, class_name_len + 1 + const_name_len + 1);
-               lcname[class_name_len] = '\\';
-               memcpy(lcname + class_name_len + 1, constant_name, const_name_len + 1);
+               lcname = erealloc(lcname, prefix_len + 1 + const_name_len + 1);
+               lcname[prefix_len] = '\\';
+               memcpy(lcname + prefix_len + 1, constant_name, const_name_len + 1);
 
-               nsname = lcname;
-               nsname_len = class_name_len + 1 + const_name_len;
-
-               if (zend_hash_find(EG(zend_constants), nsname, nsname_len+1, (void **) &c) == SUCCESS) {
+               if (zend_hash_find(EG(zend_constants), lcname, prefix_len + 1 + const_name_len + 1, (void **) &c) == SUCCESS) {
                        efree(lcname);
-                       efree(class_name);
                        *result = c->value;
                        zval_update_constant_ex(&result, (void*)1, NULL TSRMLS_CC);
                        zval_copy_ctor(result);
@@ -387,17 +377,14 @@ ZEND_API int zend_get_constant_ex(const char *name, uint name_len, zval *result,
                }
 
                efree(lcname);
-
-               if ((flags & IS_CONSTANT_RT_NS_CHECK) != 0) {
+               /* name requires runtime resolution, need to check non-namespaced name */
+               if ((flags & IS_CONSTANT_UNQUALIFIED) != 0) {
                        name = constant_name;
                        name_len = const_name_len;
-                       efree(class_name);
                        return zend_get_constant(name, name_len, result TSRMLS_CC);
                }
                retval = 0;
 finish:
-               efree(class_name);
-
                if (retval) {
                        zval_update_constant_ex(ret_constant, (void*)1, ce TSRMLS_CC);
                        *result = **ret_constant;

diff --git a/Zend/zend_execute_API.c b/Zend/zend_execute_API.c
index d2f3698b429c98efb8cb93cd6f233b8981241258..10f0ad5056c31da7dabc196e1cf9c31bee7eafb5 100644 (file)
--- a/Zend/zend_execute_API.c
+++ b/Zend/zend_execute_API.c
@@ -519,7 +519,7 @@ ZEND_API int zval_update_constant_ex(zval **pp, void *arg, zend_class_entry *sco
                        } else {
                                char *save = actual;
                                int actual_len = Z_STRLEN_P(p);
-                               if (Z_TYPE_P(p) & IS_CONSTANT_RT_NS_CHECK) {
+                               if (Z_TYPE_P(p) & IS_CONSTANT_UNQUALIFIED) {
                                        actual = (char *)zend_memrchr(actual, '\\', actual_len) + 1;
                                        actual_len -= (actual - Z_STRVAL_P(p));
                                        if (inline_change) {
@@ -537,7 +537,7 @@ ZEND_API int zval_update_constant_ex(zval **pp, void *arg, zend_class_entry *sco
                                        }
                                        --actual_len;
                                }
-                               if (Z_TYPE_P(p) & ZEND_FETCH_CLASS_RT_NS_CHECK) {
+                               if ((Z_TYPE_P(p) & IS_CONSTANT_UNQUALIFIED) == 0) {
                                        int fix_save = 0;
                                        if (save[0] == '\\') {
                                                save++;
@@ -612,7 +612,7 @@ ZEND_API int zval_update_constant_ex(zval **pp, void *arg, zend_class_entry *sco
                                        str_index_len -= ((colon - str_index) + 1);
                                        str_index = colon;
                                } else {
-                                       if (str_index[str_index_len - 2] & IS_CONSTANT_RT_NS_CHECK) {
+                                       if (str_index[str_index_len - 2] & IS_CONSTANT_UNQUALIFIED) {
                                                actual = (char *)zend_memrchr(str_index, '\\', str_index_len - 3) + 1;
                                                str_index_len -= (actual - str_index);
                                                str_index = actual;
@@ -624,7 +624,7 @@ ZEND_API int zval_update_constant_ex(zval **pp, void *arg, zend_class_entry *sco
                                        if (save[0] == '\\') {
                                                ++save;
                                        }
-                                       if (str_index[str_index_len - 2] & ZEND_FETCH_CLASS_RT_NS_CHECK) {
+                                       if ((str_index[str_index_len - 2] & IS_CONSTANT_UNQUALIFIED) == 0) {
                                                zend_error(E_ERROR, "Undefined constant '%s'", save);
                                        }
                                        zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'",     str_index, str_index);
@@ -1472,7 +1472,6 @@ zend_class_entry *zend_fetch_class(const char *class_name, uint class_name_len,
 {
        zend_class_entry **pce;
        int use_autoload = (fetch_type & ZEND_FETCH_CLASS_NO_AUTOLOAD) == 0;
-       int rt_ns_check  = (fetch_type & ZEND_FETCH_CLASS_RT_NS_CHECK) ? 1 : 0;
        int silent       = (fetch_type & ZEND_FETCH_CLASS_SILENT) != 0;
 
        fetch_type &= ZEND_FETCH_CLASS_MASK;
@@ -1506,36 +1505,14 @@ check_fetch_type:
                        break;
        }
 
-       if (zend_lookup_class_ex(class_name, class_name_len, (!rt_ns_check & use_autoload), &pce TSRMLS_CC) == FAILURE) {
-               if (rt_ns_check) {
-                       /* Check if we have internal class with the same name */
-                       char *php_name;
-                       uint php_name_len;
-
-                       php_name = zend_memrchr(class_name, '\\', class_name_len);
-                       if (php_name) {
-                               php_name++;
-                               php_name_len = class_name_len - (php_name - class_name);
-                               php_name = zend_str_tolower_dup(php_name, php_name_len);
-                               if (zend_hash_find(EG(class_table), php_name, php_name_len + 1, (void **) &pce) == SUCCESS &&
-                                       (*pce)->type == ZEND_INTERNAL_CLASS
-                               ) {
-                                       efree(php_name);
-                                       return *pce;
-                               }
-                               efree(php_name);
-                       }
-               }
+       if (zend_lookup_class_ex(class_name, class_name_len, use_autoload, &pce TSRMLS_CC) == FAILURE) {
                if (use_autoload) {
-                       if (rt_ns_check && zend_lookup_class_ex(class_name, class_name_len, 1, &pce TSRMLS_CC) == SUCCESS) {
-                               return *pce;
-                       }
                        if (!silent && !EG(exception)) {
                                if (fetch_type == ZEND_FETCH_CLASS_INTERFACE) {
                                        zend_error(E_ERROR, "Interface '%s' not found", class_name);
                                } else {
                                        zend_error(E_ERROR, "Class '%s' not found", class_name);
-                               }
+                               }       
                        }
                }
                return NULL;

diff --git a/Zend/zend_language_parser.y b/Zend/zend_language_parser.y
index b519de4f8822aa10ed1c5e94e8efb00adcb1c2a6..33d20130a9235cb9c2cfdaba089004abd1b8fad3 100644 (file)
--- a/Zend/zend_language_parser.y
+++ b/Zend/zend_language_parser.y
@@ -769,7 +769,7 @@ common_scalar:
 static_scalar: /* compile-time evaluated scalars */
                common_scalar           { $$ = $1; }
        |       namespace_name          { zend_do_fetch_constant(&$$, NULL, &$1, ZEND_CT, 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_CT, 2 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_CT, 0 TSRMLS_CC); }
        |       T_NS_SEPARATOR namespace_name { char *tmp = estrndup(Z_STRVAL($2.u.constant), Z_STRLEN($2.u.constant)+1); memcpy(&(tmp[1]), Z_STRVAL($2.u.constant), Z_STRLEN($2.u.constant)+1); tmp[0] = '\\'; efree(Z_STRVAL($2.u.constant)); Z_STRVAL($2.u.constant) = tmp; ++Z_STRLEN($2.u.constant); zend_do_fetch_constant(&$$, NULL, &$2, ZEND_CT, 0 TSRMLS_CC); }
        |       '+' static_scalar { ZVAL_LONG(&$1.u.constant, 0); add_function(&$2.u.constant, &$1.u.constant, &$2.u.constant TSRMLS_CC); $$ = $2; }
        |       '-' static_scalar { ZVAL_LONG(&$1.u.constant, 0); sub_function(&$2.u.constant, &$1.u.constant, &$2.u.constant TSRMLS_CC); $$ = $2; }
@@ -778,14 +778,14 @@ static_scalar: /* compile-time evaluated scalars */
 ;
 
 static_class_constant:
-               class_name T_PAAMAYIM_NEKUDOTAYIM T_STRING { zend_do_fetch_constant(&$$, &$1, &$3, ZEND_CT, 2 TSRMLS_CC); }
+               class_name T_PAAMAYIM_NEKUDOTAYIM T_STRING { zend_do_fetch_constant(&$$, &$1, &$3, ZEND_CT, 0 TSRMLS_CC); }
 ;
 
 scalar:
                T_STRING_VARNAME                { $$ = $1; }
        |       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, 2 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 { char *tmp = estrndup(Z_STRVAL($2.u.constant), Z_STRLEN($2.u.constant)+1); memcpy(&(tmp[1]), Z_STRVAL($2.u.constant), Z_STRLEN($2.u.constant)+1); tmp[0] = '\\'; efree(Z_STRVAL($2.u.constant)); Z_STRVAL($2.u.constant) = tmp; ++Z_STRLEN($2.u.constant); zend_do_fetch_constant(&$$, NULL, &$2, ZEND_RT, 0 TSRMLS_CC); }
        |       common_scalar                   { $$ = $1; }
        |       '"' encaps_list '"'     { $$ = $2; }
@@ -993,7 +993,7 @@ isset_variables:
 ;
 
 class_constant:
-               class_name T_PAAMAYIM_NEKUDOTAYIM T_STRING { zend_do_fetch_constant(&$$, &$1, &$3, ZEND_RT, 2 TSRMLS_CC); }
+               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); }
 ;
 

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index 95e1c5adfc3bd60f76fad77323eaabc21205c750..954d1eac716fca5475d72d1c3558fc0ed63d011d 100644 (file)
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -2108,8 +2108,8 @@ ZEND_VM_HANDLER(69, ZEND_INIT_NS_FCALL_BY_NAME, ANY, CONST)
        zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
 
        if (zend_hash_quick_find(EG(function_table), Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant)+1, opline->extended_value, (void **) &EX(fbc))==FAILURE) {
-               if (zend_hash_quick_find(EG(function_table), Z_STRVAL(op_data->op1.u.constant), Z_STRLEN(op_data->op1.u.constant)+1, op_data->extended_value, (void **) &EX(fbc))==FAILURE ||
-                   (Z_BVAL(op_data->op2.u.constant) && EX(fbc)->type != ZEND_INTERNAL_FUNCTION)) {
+               char *short_name = Z_STRVAL(opline->op1.u.constant)+Z_LVAL(op_data->op1.u.constant);
+               if (zend_hash_quick_find(EG(function_table), short_name, Z_STRLEN(opline->op1.u.constant)-Z_LVAL(op_data->op1.u.constant)+1, op_data->extended_value, (void **) &EX(fbc))==FAILURE) {
                        zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL(opline->op2.u.constant));
                }
        }
@@ -2974,39 +2974,21 @@ ZEND_VM_HANDLER(99, ZEND_FETCH_CONSTANT, VAR|CONST|UNUSED, CONST)
        if (OP1_TYPE == IS_UNUSED) {
                /* namespaced constant */
                if (!zend_get_constant_ex(Z_STRVAL(opline->op2.u.constant), Z_STRLEN(opline->op2.u.constant), &EX_T(opline->result.u.var).tmp_var, NULL, opline->extended_value TSRMLS_CC)) {
-                       char *actual = Z_STRVAL(opline->op2.u.constant);
-
-                       if (opline->extended_value & IS_CONSTANT_RT_NS_CHECK) {
-                               actual = (char *)zend_memrchr(actual, '\\', Z_STRLEN(opline->op2.u.constant)) + 1;
-                               Z_STRLEN(opline->op2.u.constant) -= (actual - Z_STRVAL(opline->op2.u.constant));
-                               actual = estrndup(actual, Z_STRLEN(opline->op2.u.constant));
-                               efree(Z_STRVAL(opline->op2.u.constant));
-                               Z_STRVAL(opline->op2.u.constant) = actual;
-                       }
-                       if (Z_STRVAL(opline->op2.u.constant)[0] == '\\') {
-                               if (opline->extended_value & ZEND_FETCH_CLASS_RT_NS_CHECK) {
-                                       zend_error_noreturn(E_ERROR, "Undefined constant '%s'",
-                                               Z_STRVAL(opline->op2.u.constant)+1,
-                                               Z_STRVAL(opline->op2.u.constant)+1);
+                       if ((opline->extended_value & IS_CONSTANT_UNQUALIFIED) != 0) {
+                               char *actual = (char *)zend_memrchr(Z_STRVAL(opline->op2.u.constant), '\\', Z_STRLEN(opline->op2.u.constant));
+                               if(!actual) {
+                                       actual = Z_STRVAL(opline->op2.u.constant);
+                               } else {
+                                       actual++;
                                }
-                               zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'",
-                                       Z_STRVAL(opline->op2.u.constant)+1,
-                                       Z_STRVAL(opline->op2.u.constant)+1);
-                               EX_T(opline->result.u.var).tmp_var = opline->op2.u.constant;
-                               ++Z_STRVAL(EX_T(opline->result.u.var).tmp_var);
-                               --Z_STRLEN(EX_T(opline->result.u.var).tmp_var);
+                               /* non-qualified constant - allow text substitution */
+                               zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'", actual, actual);
+                               ZVAL_STRING(&EX_T(opline->result.u.var).tmp_var, actual, Z_STRLEN(opline->op2.u.constant)-(actual - Z_STRVAL(opline->op2.u.constant)));
+                               zval_copy_ctor(&EX_T(opline->result.u.var).tmp_var);
                        } else {
-                               if (opline->extended_value & ZEND_FETCH_CLASS_RT_NS_CHECK) {
-                                       zend_error_noreturn(E_ERROR, "Undefined constant '%s'",
-                                               Z_STRVAL(opline->op2.u.constant),
-                                               Z_STRVAL(opline->op2.u.constant));
-                               }
-                               zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'",
-                                       Z_STRVAL(opline->op2.u.constant),
-                                       Z_STRVAL(opline->op2.u.constant));
-                               EX_T(opline->result.u.var).tmp_var = opline->op2.u.constant;
+                               zend_error_noreturn(E_ERROR, "Undefined constant '%s'",
+                                                       Z_STRVAL(opline->op2.u.constant), Z_STRVAL(opline->op2.u.constant));
                        }
-                       zval_copy_ctor(&EX_T(opline->result.u.var).tmp_var);
                }
                ZEND_VM_NEXT_OPCODE();
        } else {

diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index b76b2261fc8670f30dd2f24e1abdc463abb3941c..5311143291b77d8783ceab8430372c146ff6b434 100644 (file)
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -159,9 +159,9 @@ static int ZEND_FASTCALL zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)
                        cv++;
                }
        }
-
+       
        nested = EX(nested);
-
+       
        zend_vm_stack_free(execute_data TSRMLS_CC);
 
        if (nested) {
@@ -326,7 +326,7 @@ static int ZEND_FASTCALL zend_do_fcall_common_helper_SPEC(ZEND_OPCODE_HANDLER_AR
                EG(active_symbol_table) = NULL;
                EG(active_op_array) = &EX(function_state).function->op_array;
                EG(return_value_ptr_ptr) = NULL;
-               if (RETURN_VALUE_USED(opline)) {
+               if (RETURN_VALUE_USED(opline)) {                        
                        EG(return_value_ptr_ptr) = &EX_T(opline->result.u.var).var.ptr;
                        EX_T(opline->result.u.var).var.ptr = NULL;
                        EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
@@ -607,7 +607,7 @@ static int ZEND_FASTCALL  ZEND_HANDLE_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER
        zend_uint catch_op_num;
        int catched = 0;
        zval restored_error_reporting;
-
+ 
        void **stack_frame = (void**)EX(Ts) +
                (sizeof(temp_variable) * EX(op_array)->T) / sizeof(void*);
 
@@ -711,7 +711,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_CLASS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLE
 {
        zend_op *opline = EX(opline);
        zval *class_name;
-
+       
 
 
        if (IS_CONST == IS_UNUSED) {
@@ -742,7 +742,7 @@ static int ZEND_FASTCALL  ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE
        zval *function_name;
        char *function_name_strval, *lcname;
        int function_name_strlen;
-
+       
 
        zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
 
@@ -796,8 +796,8 @@ static int ZEND_FASTCALL  ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPC
        zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
 
        if (zend_hash_quick_find(EG(function_table), Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant)+1, opline->extended_value, (void **) &EX(fbc))==FAILURE) {
-               if (zend_hash_quick_find(EG(function_table), Z_STRVAL(op_data->op1.u.constant), Z_STRLEN(op_data->op1.u.constant)+1, op_data->extended_value, (void **) &EX(fbc))==FAILURE ||
-                   (Z_BVAL(op_data->op2.u.constant) && EX(fbc)->type != ZEND_INTERNAL_FUNCTION)) {
+               char *short_name = Z_STRVAL(opline->op1.u.constant)+Z_LVAL(op_data->op1.u.constant);
+               if (zend_hash_quick_find(EG(function_table), short_name, Z_STRLEN(opline->op1.u.constant)-Z_LVAL(op_data->op1.u.constant)+1, op_data->extended_value, (void **) &EX(fbc))==FAILURE) {
                        zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL(opline->op2.u.constant));
                }
        }
@@ -841,7 +841,7 @@ static int ZEND_FASTCALL  ZEND_RECV_INIT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_
 static int ZEND_FASTCALL  ZEND_BRK_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zend_brk_cont_element *el;
 
        el = zend_brk_cont(&opline->op2.u.constant, opline->op1.u.opline_num,
@@ -853,7 +853,7 @@ static int ZEND_FASTCALL  ZEND_BRK_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_CONT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zend_brk_cont_element *el;
 
        el = zend_brk_cont(&opline->op2.u.constant, opline->op1.u.opline_num,
@@ -1117,7 +1117,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_CLASS_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDL
 {
        zend_op *opline = EX(opline);
        zval *class_name;
-
+       
 
 
        if (IS_UNUSED == IS_UNUSED) {
@@ -1146,7 +1146,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_CLASS_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_A
 {
        zend_op *opline = EX(opline);
        zval *class_name;
-
+       
 
 
        if (IS_CV == IS_UNUSED) {
@@ -1177,7 +1177,7 @@ static int ZEND_FASTCALL  ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER(ZEND_OPCODE_HA
        zval *function_name;
        char *function_name_strval, *lcname;
        int function_name_strlen;
-
+       
 
        zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
 
@@ -1263,7 +1263,7 @@ static int ZEND_FASTCALL  ZEND_CATCH_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_BRK_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zend_brk_cont_element *el;
 
        el = zend_brk_cont(_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC), opline->op1.u.opline_num,
@@ -1275,7 +1275,7 @@ static int ZEND_FASTCALL  ZEND_BRK_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_CONT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zend_brk_cont_element *el;
 
        el = zend_brk_cont(_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC), opline->op1.u.opline_num,
@@ -1287,7 +1287,7 @@ static int ZEND_FASTCALL  ZEND_CONT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_BW_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        bitwise_not_function(&EX_T(opline->result.u.var).tmp_var,
                &opline->op1.u.constant TSRMLS_CC);
@@ -1298,7 +1298,7 @@ static int ZEND_FASTCALL  ZEND_BW_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG
 static int ZEND_FASTCALL  ZEND_BOOL_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        boolean_not_function(&EX_T(opline->result.u.var).tmp_var,
                &opline->op1.u.constant TSRMLS_CC);
@@ -1309,7 +1309,7 @@ static int ZEND_FASTCALL  ZEND_BOOL_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
 static int ZEND_FASTCALL  ZEND_ECHO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval z_copy;
        zval *z = &opline->op1.u.constant;
 
@@ -1468,7 +1468,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_IS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
 static int ZEND_FASTCALL  ZEND_JMPZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        int ret = i_zend_is_true(&opline->op1.u.constant);
 
        if (!ret) {
@@ -1484,7 +1484,7 @@ static int ZEND_FASTCALL  ZEND_JMPZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_JMPNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        int ret = i_zend_is_true(&opline->op1.u.constant);
 
        if (ret) {
@@ -1500,7 +1500,7 @@ static int ZEND_FASTCALL  ZEND_JMPNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 static int ZEND_FASTCALL  ZEND_JMPZNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        int retval = i_zend_is_true(&opline->op1.u.constant);
 
        if (UNEXPECTED(EG(exception) != NULL)) {
@@ -1523,7 +1523,7 @@ static int ZEND_FASTCALL  ZEND_JMPZNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG
 static int ZEND_FASTCALL  ZEND_JMPZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        int retval = i_zend_is_true(&opline->op1.u.constant);
 
        Z_LVAL(EX_T(opline->result.u.var).tmp_var) = retval;
@@ -1540,7 +1540,7 @@ static int ZEND_FASTCALL  ZEND_JMPZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR
 static int ZEND_FASTCALL  ZEND_JMPNZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        int retval = i_zend_is_true(&opline->op1.u.constant);
 
        Z_LVAL(EX_T(opline->result.u.var).tmp_var) = retval;
@@ -1557,7 +1557,7 @@ static int ZEND_FASTCALL  ZEND_JMPNZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
 static int ZEND_FASTCALL  ZEND_DO_FCALL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *fname = &opline->op1.u.constant;
 
        zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
@@ -1575,7 +1575,7 @@ static int ZEND_FASTCALL  ZEND_RETURN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG
        zend_op *opline = EX(opline);
        zval *retval_ptr;
        zval **retval_ptr_ptr;
-
+       
 
        if (EG(active_op_array)->return_reference == ZEND_RETURN_REF) {
 
@@ -1649,7 +1649,7 @@ static int ZEND_FASTCALL  ZEND_THROW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS
        zend_op *opline = EX(opline);
        zval *value;
        zval *exception;
-
+       
 
        value = &opline->op1.u.constant;
 
@@ -1680,7 +1680,7 @@ static int ZEND_FASTCALL  ZEND_SEND_VAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
        {
                zval *valptr;
                zval *value;
-
+               
 
                value = &opline->op1.u.constant;
 
@@ -1698,7 +1698,7 @@ static int ZEND_FASTCALL  ZEND_SEND_VAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
 static int ZEND_FASTCALL  ZEND_BOOL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        /* PHP 3.0 returned "" for false and 1 for true, here we use 0 and 1 for now */
        Z_LVAL(EX_T(opline->result.u.var).tmp_var) = i_zend_is_true(&opline->op1.u.constant);
@@ -1710,7 +1710,7 @@ static int ZEND_FASTCALL  ZEND_BOOL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_CLONE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *obj = &opline->op1.u.constant;
        zend_class_entry *ce;
        zend_function *clone;
@@ -1771,7 +1771,7 @@ static int ZEND_FASTCALL  ZEND_CLONE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 static int ZEND_FASTCALL  ZEND_CAST_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *expr = &opline->op1.u.constant;
        zval *result = &EX_T(opline->result.u.var).tmp_var;
 
@@ -1828,7 +1828,7 @@ static int ZEND_FASTCALL  ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HA
        zend_op *opline = EX(opline);
        zend_op_array *new_op_array=NULL;
        int return_value_used;
-
+       
        zval *inc_filename = &opline->op1.u.constant;
        zval tmp_inc_filename;
        zend_bool failure_retval=0;
@@ -1958,7 +1958,7 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_
        zend_op *opline = EX(opline);
        zval tmp, *varname;
        HashTable *target_symbol_table;
-
+       
 
        if (IS_CONST == IS_CV && (opline->extended_value & ZEND_QUICK_SET)) {
                if (EG(active_symbol_table)) {
@@ -2040,7 +2040,7 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_
 static int ZEND_FASTCALL  ZEND_FE_RESET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *array_ptr, **array_ptr_ptr;
        HashTable *fe_ht;
        zend_object_iterator *iter = NULL;
@@ -2204,12 +2204,12 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_HANDLER(ZEND_OPCODE_
                        if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
                                isset = 0;
                        }
-               } else {
+               } else {                
                        isset = 0;
                }
        } else {
                HashTable *target_symbol_table;
-
+               
                zval tmp, *varname = &opline->op1.u.constant;
 
                if (Z_TYPE_P(varname) != IS_STRING) {
@@ -2264,7 +2264,7 @@ static int ZEND_FASTCALL  ZEND_EXIT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 #if 0 || (IS_CONST != IS_UNUSED)
        zend_op *opline = EX(opline);
        if (IS_CONST != IS_UNUSED) {
-
+               
                zval *ptr = &opline->op1.u.constant;
 
                if (Z_TYPE_P(ptr) == IS_LONG) {
@@ -2282,7 +2282,7 @@ static int ZEND_FASTCALL  ZEND_EXIT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_JMP_SET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *value = &opline->op1.u.constant;
 
        if (i_zend_is_true(value)) {
@@ -2301,7 +2301,7 @@ static int ZEND_FASTCALL  ZEND_JMP_SET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR
 static int ZEND_FASTCALL  ZEND_QM_ASSIGN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *value = &opline->op1.u.constant;
 
        EX_T(opline->result.u.var).tmp_var = *value;
@@ -2328,7 +2328,7 @@ static int ZEND_FASTCALL  ZEND_TICKS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 static int ZEND_FASTCALL  ZEND_ADD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        add_function(&EX_T(opline->result.u.var).tmp_var,
                &opline->op1.u.constant,
@@ -2341,7 +2341,7 @@ static int ZEND_FASTCALL  ZEND_ADD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_
 static int ZEND_FASTCALL  ZEND_SUB_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        sub_function(&EX_T(opline->result.u.var).tmp_var,
                &opline->op1.u.constant,
@@ -2354,7 +2354,7 @@ static int ZEND_FASTCALL  ZEND_SUB_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_
 static int ZEND_FASTCALL  ZEND_MUL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        mul_function(&EX_T(opline->result.u.var).tmp_var,
                &opline->op1.u.constant,
@@ -2367,7 +2367,7 @@ static int ZEND_FASTCALL  ZEND_MUL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_
 static int ZEND_FASTCALL  ZEND_DIV_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        div_function(&EX_T(opline->result.u.var).tmp_var,
                &opline->op1.u.constant,
@@ -2380,7 +2380,7 @@ static int ZEND_FASTCALL  ZEND_DIV_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_
 static int ZEND_FASTCALL  ZEND_MOD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        mod_function(&EX_T(opline->result.u.var).tmp_var,
                &opline->op1.u.constant,
@@ -2393,7 +2393,7 @@ static int ZEND_FASTCALL  ZEND_MOD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_
 static int ZEND_FASTCALL  ZEND_SL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        shift_left_function(&EX_T(opline->result.u.var).tmp_var,
                &opline->op1.u.constant,
@@ -2406,7 +2406,7 @@ static int ZEND_FASTCALL  ZEND_SL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
 static int ZEND_FASTCALL  ZEND_SR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        shift_right_function(&EX_T(opline->result.u.var).tmp_var,
                &opline->op1.u.constant,
@@ -2419,7 +2419,7 @@ static int ZEND_FASTCALL  ZEND_SR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
 static int ZEND_FASTCALL  ZEND_CONCAT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        concat_function(&EX_T(opline->result.u.var).tmp_var,
                &opline->op1.u.constant,
@@ -2432,7 +2432,7 @@ static int ZEND_FASTCALL  ZEND_CONCAT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDL
 static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        is_identical_function(&EX_T(opline->result.u.var).tmp_var,
                &opline->op1.u.constant,
@@ -2445,7 +2445,7 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE
 static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *result = &EX_T(opline->result.u.var).tmp_var;
 
        is_identical_function(result,
@@ -2460,7 +2460,7 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OP
 static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *result = &EX_T(opline->result.u.var).tmp_var;
 
        compare_function(result,
@@ -2475,7 +2475,7 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HAN
 static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *result = &EX_T(opline->result.u.var).tmp_var;
 
        compare_function(result,
@@ -2490,7 +2490,7 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE
 static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *result = &EX_T(opline->result.u.var).tmp_var;
 
        compare_function(result,
@@ -2505,7 +2505,7 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_H
 static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *result = &EX_T(opline->result.u.var).tmp_var;
 
        compare_function(result,
@@ -2520,7 +2520,7 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND
 static int ZEND_FASTCALL  ZEND_BW_OR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        bitwise_or_function(&EX_T(opline->result.u.var).tmp_var,
                &opline->op1.u.constant,
@@ -2533,7 +2533,7 @@ static int ZEND_FASTCALL  ZEND_BW_OR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLE
 static int ZEND_FASTCALL  ZEND_BW_AND_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        bitwise_and_function(&EX_T(opline->result.u.var).tmp_var,
                &opline->op1.u.constant,
@@ -2546,7 +2546,7 @@ static int ZEND_FASTCALL  ZEND_BW_AND_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDL
 static int ZEND_FASTCALL  ZEND_BW_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        bitwise_xor_function(&EX_T(opline->result.u.var).tmp_var,
                &opline->op1.u.constant,
@@ -2559,7 +2559,7 @@ static int ZEND_FASTCALL  ZEND_BW_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDL
 static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        boolean_xor_function(&EX_T(opline->result.u.var).tmp_var,
                &opline->op1.u.constant,
@@ -2572,7 +2572,7 @@ static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HAN
 static int ZEND_FASTCALL  ZEND_FETCH_DIM_TMP_VAR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *container = &opline->op1.u.constant;
 
        if (Z_TYPE_P(container) != IS_ARRAY) {
@@ -2581,7 +2581,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_TMP_VAR_SPEC_CONST_CONST_HANDLER(ZEND_O
                        PZVAL_LOCK(EG(uninitialized_zval_ptr));
                }
        } else {
-
+               
                zval *dim = &opline->op2.u.constant;
 
                AI_SET_PTR(EX_T(opline->result.u.var).var, *zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, BP_VAR_R TSRMLS_CC));
@@ -2611,7 +2611,7 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER(
                EX(called_scope) = ce;
        } else {
                ce = EX_T(opline->op1.u.var).class_entry;
-
+               
                if (opline->op1.u.EA.type == ZEND_FETCH_CLASS_PARENT || opline->op1.u.EA.type == ZEND_FETCH_CLASS_SELF) {
                        EX(called_scope) = EG(called_scope);
                } else {
@@ -2621,7 +2621,7 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER(
        if(IS_CONST != IS_UNUSED) {
                char *function_name_strval = NULL;
                int function_name_strlen = 0;
-
+               
 
                if (IS_CONST == IS_CONST) {
                        function_name_strval = Z_STRVAL(opline->op2.u.constant);
@@ -2695,7 +2695,7 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER
 {
        zend_op *opline = EX(opline);
        int switch_expr_is_overloaded=0;
-
+       
 
        if (IS_CONST==IS_VAR) {
                if (EX_T(opline->op1.u.var).var.ptr_ptr) {
@@ -2729,39 +2729,21 @@ static int ZEND_FASTCALL  ZEND_FETCH_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCO
        if (IS_CONST == IS_UNUSED) {
                /* namespaced constant */
                if (!zend_get_constant_ex(Z_STRVAL(opline->op2.u.constant), Z_STRLEN(opline->op2.u.constant), &EX_T(opline->result.u.var).tmp_var, NULL, opline->extended_value TSRMLS_CC)) {
-                       char *actual = Z_STRVAL(opline->op2.u.constant);
-
-                       if (opline->extended_value & IS_CONSTANT_RT_NS_CHECK) {
-                               actual = (char *)zend_memrchr(actual, '\\', Z_STRLEN(opline->op2.u.constant)) + 1;
-                               Z_STRLEN(opline->op2.u.constant) -= (actual - Z_STRVAL(opline->op2.u.constant));
-                               actual = estrndup(actual, Z_STRLEN(opline->op2.u.constant));
-                               efree(Z_STRVAL(opline->op2.u.constant));
-                               Z_STRVAL(opline->op2.u.constant) = actual;
-                       }
-                       if (Z_STRVAL(opline->op2.u.constant)[0] == '\\') {
-                               if (opline->extended_value & ZEND_FETCH_CLASS_RT_NS_CHECK) {
-                                       zend_error_noreturn(E_ERROR, "Undefined constant '%s'",
-                                               Z_STRVAL(opline->op2.u.constant)+1,
-                                               Z_STRVAL(opline->op2.u.constant)+1);
-                               }
-                               zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'",
-                                       Z_STRVAL(opline->op2.u.constant)+1,
-                                       Z_STRVAL(opline->op2.u.constant)+1);
-                               EX_T(opline->result.u.var).tmp_var = opline->op2.u.constant;
-                               ++Z_STRVAL(EX_T(opline->result.u.var).tmp_var);
-                               --Z_STRLEN(EX_T(opline->result.u.var).tmp_var);
-                       } else {
-                               if (opline->extended_value & ZEND_FETCH_CLASS_RT_NS_CHECK) {
-                                       zend_error_noreturn(E_ERROR, "Undefined constant '%s'",
-                                               Z_STRVAL(opline->op2.u.constant),
-                                               Z_STRVAL(opline->op2.u.constant));
+                       if ((opline->extended_value & IS_CONSTANT_UNQUALIFIED) != 0) {
+                               char *actual = (char *)zend_memrchr(Z_STRVAL(opline->op2.u.constant), '\\', Z_STRLEN(opline->op2.u.constant));
+                               if(!actual) {
+                                       actual = Z_STRVAL(opline->op2.u.constant);
+                               } else {
+                                       actual++;
                                }
-                               zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'",
-                                       Z_STRVAL(opline->op2.u.constant),
-                                       Z_STRVAL(opline->op2.u.constant));
-                               EX_T(opline->result.u.var).tmp_var = opline->op2.u.constant;
+                               /* non-qualified constant - allow text substitution */
+                               zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'", actual, actual);
+                               ZVAL_STRING(&EX_T(opline->result.u.var).tmp_var, actual, Z_STRLEN(opline->op2.u.constant)-(actual - Z_STRVAL(opline->op2.u.constant)));
+                               zval_copy_ctor(&EX_T(opline->result.u.var).tmp_var);
+                       } else {
+                               zend_error_noreturn(E_ERROR, "Undefined constant '%s'",
+                                                       Z_STRVAL(opline->op2.u.constant), Z_STRVAL(opline->op2.u.constant));
                        }
-                       zval_copy_ctor(&EX_T(opline->result.u.var).tmp_var);
                }
                ZEND_VM_NEXT_OPCODE();
        } else {
@@ -2801,7 +2783,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCO
 static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
        zval *expr_ptr;
        zval *offset=&opline->op2.u.constant;
@@ -2894,7 +2876,7 @@ static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_H
 static int ZEND_FASTCALL  ZEND_DECLARE_CONST_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *name  = &opline->op1.u.constant;
        zval *val   = &opline->op2.u.constant;
        zend_constant c;
@@ -3204,7 +3186,7 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMP_HANDLER(ZE
                EX(called_scope) = ce;
        } else {
                ce = EX_T(opline->op1.u.var).class_entry;
-
+               
                if (opline->op1.u.EA.type == ZEND_FETCH_CLASS_PARENT || opline->op1.u.EA.type == ZEND_FETCH_CLASS_SELF) {
                        EX(called_scope) = EG(called_scope);
                } else {
@@ -3673,7 +3655,7 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_VAR_HANDLER(ZE
                EX(called_scope) = ce;
        } else {
                ce = EX_T(opline->op1.u.var).class_entry;
-
+               
                if (opline->op1.u.EA.type == ZEND_FETCH_CLASS_PARENT || opline->op1.u.EA.type == ZEND_FETCH_CLASS_SELF) {
                        EX(called_scope) = EG(called_scope);
                } else {
@@ -3898,7 +3880,7 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER
                EX(called_scope) = ce;
        } else {
                ce = EX_T(opline->op1.u.var).class_entry;
-
+               
                if (opline->op1.u.EA.type == ZEND_FETCH_CLASS_PARENT || opline->op1.u.EA.type == ZEND_FETCH_CLASS_SELF) {
                        EX(called_scope) = EG(called_scope);
                } else {
@@ -3908,7 +3890,7 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER
        if(IS_UNUSED != IS_UNUSED) {
                char *function_name_strval = NULL;
                int function_name_strlen = 0;
-
+               
 
                if (IS_UNUSED == IS_CONST) {
                        function_name_strval = Z_STRVAL(opline->op2.u.constant);
@@ -3981,7 +3963,7 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER
 static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
        zval *expr_ptr;
        zval *offset=NULL;
@@ -4074,7 +4056,7 @@ static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_
 static int ZEND_FASTCALL  ZEND_ADD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        add_function(&EX_T(opline->result.u.var).tmp_var,
                &opline->op1.u.constant,
@@ -4087,7 +4069,7 @@ static int ZEND_FASTCALL  ZEND_ADD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
 static int ZEND_FASTCALL  ZEND_SUB_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        sub_function(&EX_T(opline->result.u.var).tmp_var,
                &opline->op1.u.constant,
@@ -4100,7 +4082,7 @@ static int ZEND_FASTCALL  ZEND_SUB_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
 static int ZEND_FASTCALL  ZEND_MUL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        mul_function(&EX_T(opline->result.u.var).tmp_var,
                &opline->op1.u.constant,
@@ -4113,7 +4095,7 @@ static int ZEND_FASTCALL  ZEND_MUL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
 static int ZEND_FASTCALL  ZEND_DIV_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        div_function(&EX_T(opline->result.u.var).tmp_var,
                &opline->op1.u.constant,
@@ -4126,7 +4108,7 @@ static int ZEND_FASTCALL  ZEND_DIV_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
 static int ZEND_FASTCALL  ZEND_MOD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        mod_function(&EX_T(opline->result.u.var).tmp_var,
                &opline->op1.u.constant,
@@ -4139,7 +4121,7 @@ static int ZEND_FASTCALL  ZEND_MOD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
 static int ZEND_FASTCALL  ZEND_SL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        shift_left_function(&EX_T(opline->result.u.var).tmp_var,
                &opline->op1.u.constant,
@@ -4152,7 +4134,7 @@ static int ZEND_FASTCALL  ZEND_SL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 static int ZEND_FASTCALL  ZEND_SR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        shift_right_function(&EX_T(opline->result.u.var).tmp_var,
                &opline->op1.u.constant,
@@ -4165,7 +4147,7 @@ static int ZEND_FASTCALL  ZEND_SR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 static int ZEND_FASTCALL  ZEND_CONCAT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        concat_function(&EX_T(opline->result.u.var).tmp_var,
                &opline->op1.u.constant,
@@ -4178,7 +4160,7 @@ static int ZEND_FASTCALL  ZEND_CONCAT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_
 static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        is_identical_function(&EX_T(opline->result.u.var).tmp_var,
                &opline->op1.u.constant,
@@ -4191,7 +4173,7 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HA
 static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *result = &EX_T(opline->result.u.var).tmp_var;
 
        is_identical_function(result,
@@ -4206,7 +4188,7 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CV_HANDLER(ZEND_OPCOD
 static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *result = &EX_T(opline->result.u.var).tmp_var;
 
        compare_function(result,
@@ -4221,7 +4203,7 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLE
 static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *result = &EX_T(opline->result.u.var).tmp_var;
 
        compare_function(result,
@@ -4236,7 +4218,7 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HA
 static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *result = &EX_T(opline->result.u.var).tmp_var;
 
        compare_function(result,
@@ -4251,7 +4233,7 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HAND
 static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *result = &EX_T(opline->result.u.var).tmp_var;
 
        compare_function(result,
@@ -4266,7 +4248,7 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OP
 static int ZEND_FASTCALL  ZEND_BW_OR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        bitwise_or_function(&EX_T(opline->result.u.var).tmp_var,
                &opline->op1.u.constant,
@@ -4279,7 +4261,7 @@ static int ZEND_FASTCALL  ZEND_BW_OR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_A
 static int ZEND_FASTCALL  ZEND_BW_AND_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        bitwise_and_function(&EX_T(opline->result.u.var).tmp_var,
                &opline->op1.u.constant,
@@ -4292,7 +4274,7 @@ static int ZEND_FASTCALL  ZEND_BW_AND_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_
 static int ZEND_FASTCALL  ZEND_BW_XOR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        bitwise_xor_function(&EX_T(opline->result.u.var).tmp_var,
                &opline->op1.u.constant,
@@ -4305,7 +4287,7 @@ static int ZEND_FASTCALL  ZEND_BW_XOR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_
 static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        boolean_xor_function(&EX_T(opline->result.u.var).tmp_var,
                &opline->op1.u.constant,
@@ -4335,7 +4317,7 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEN
                EX(called_scope) = ce;
        } else {
                ce = EX_T(opline->op1.u.var).class_entry;
-
+               
                if (opline->op1.u.EA.type == ZEND_FETCH_CLASS_PARENT || opline->op1.u.EA.type == ZEND_FETCH_CLASS_SELF) {
                        EX(called_scope) = EG(called_scope);
                } else {
@@ -4345,7 +4327,7 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEN
        if(IS_CV != IS_UNUSED) {
                char *function_name_strval = NULL;
                int function_name_strlen = 0;
-
+               
 
                if (IS_CV == IS_CONST) {
                        function_name_strval = Z_STRVAL(opline->op2.u.constant);
@@ -4419,7 +4401,7 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_AR
 {
        zend_op *opline = EX(opline);
        int switch_expr_is_overloaded=0;
-
+       
 
        if (IS_CONST==IS_VAR) {
                if (EX_T(opline->op1.u.var).var.ptr_ptr) {
@@ -4449,7 +4431,7 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_AR
 static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
        zval *expr_ptr;
        zval *offset=_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
@@ -5457,7 +5439,7 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_HANDLER(ZEND_OPCODE_HA
                        if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
                                isset = 0;
                        }
-               } else {
+               } else {                
                        isset = 0;
                }
        } else {
@@ -5857,7 +5839,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_TMP_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPC
                        PZVAL_LOCK(EG(uninitialized_zval_ptr));
                }
        } else {
-
+               
                zval *dim = &opline->op2.u.constant;
 
                AI_SET_PTR(EX_T(opline->result.u.var).var, *zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, BP_VAR_R TSRMLS_CC));
@@ -7358,7 +7340,7 @@ static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_
 static int ZEND_FASTCALL  ZEND_ADD_VAR_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *str = &EX_T(opline->result.u.var).tmp_var;
        zval *var = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
        zval var_copy;
@@ -8903,7 +8885,7 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_HANDLER(ZEND_OPCODE_HA
                        if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
                                isset = 0;
                        }
-               } else {
+               } else {                
                        isset = 0;
                }
        } else {
@@ -9918,7 +9900,7 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_CONST(
                        PZVAL_LOCK(EG(uninitialized_zval_ptr));
                }
        } else {
-
+               
                zval *offset  = &opline->op2.u.constant;
                zval *retval;
 
@@ -9997,7 +9979,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HA
                SEPARATE_ZVAL_TO_MAKE_IS_REF(EX_T(opline->result.u.var).var.ptr_ptr);
                Z_ADDREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
        }
-
+       
        ZEND_VM_NEXT_OPCODE();
 }
 
@@ -10158,7 +10140,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HAN
        }
 
        if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) {
-
+               
                zval *property_name = &opline->op2.u.constant;
 
                if (0) {
@@ -10321,7 +10303,7 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZE
                EX(called_scope) = ce;
        } else {
                ce = EX_T(opline->op1.u.var).class_entry;
-
+               
                if (opline->op1.u.EA.type == ZEND_FETCH_CLASS_PARENT || opline->op1.u.EA.type == ZEND_FETCH_CLASS_SELF) {
                        EX(called_scope) = EG(called_scope);
                } else {
@@ -10331,7 +10313,7 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZE
        if(IS_CONST != IS_UNUSED) {
                char *function_name_strval = NULL;
                int function_name_strlen = 0;
-
+               
 
                if (IS_CONST == IS_CONST) {
                        function_name_strval = Z_STRVAL(opline->op2.u.constant);
@@ -10439,39 +10421,21 @@ static int ZEND_FASTCALL  ZEND_FETCH_CONSTANT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE
        if (IS_VAR == IS_UNUSED) {
                /* namespaced constant */
                if (!zend_get_constant_ex(Z_STRVAL(opline->op2.u.constant), Z_STRLEN(opline->op2.u.constant), &EX_T(opline->result.u.var).tmp_var, NULL, opline->extended_value TSRMLS_CC)) {
-                       char *actual = Z_STRVAL(opline->op2.u.constant);
-
-                       if (opline->extended_value & IS_CONSTANT_RT_NS_CHECK) {
-                               actual = (char *)zend_memrchr(actual, '\\', Z_STRLEN(opline->op2.u.constant)) + 1;
-                               Z_STRLEN(opline->op2.u.constant) -= (actual - Z_STRVAL(opline->op2.u.constant));
-                               actual = estrndup(actual, Z_STRLEN(opline->op2.u.constant));
-                               efree(Z_STRVAL(opline->op2.u.constant));
-                               Z_STRVAL(opline->op2.u.constant) = actual;
-                       }
-                       if (Z_STRVAL(opline->op2.u.constant)[0] == '\\') {
-                               if (opline->extended_value & ZEND_FETCH_CLASS_RT_NS_CHECK) {
-                                       zend_error_noreturn(E_ERROR, "Undefined constant '%s'",
-                                               Z_STRVAL(opline->op2.u.constant)+1,
-                                               Z_STRVAL(opline->op2.u.constant)+1);
-                               }
-                               zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'",
-                                       Z_STRVAL(opline->op2.u.constant)+1,
-                                       Z_STRVAL(opline->op2.u.constant)+1);
-                               EX_T(opline->result.u.var).tmp_var = opline->op2.u.constant;
-                               ++Z_STRVAL(EX_T(opline->result.u.var).tmp_var);
-                               --Z_STRLEN(EX_T(opline->result.u.var).tmp_var);
-                       } else {
-                               if (opline->extended_value & ZEND_FETCH_CLASS_RT_NS_CHECK) {
-                                       zend_error_noreturn(E_ERROR, "Undefined constant '%s'",
-                                               Z_STRVAL(opline->op2.u.constant),
-                                               Z_STRVAL(opline->op2.u.constant));
+                       if ((opline->extended_value & IS_CONSTANT_UNQUALIFIED) != 0) {
+                               char *actual = (char *)zend_memrchr(Z_STRVAL(opline->op2.u.constant), '\\', Z_STRLEN(opline->op2.u.constant));
+                               if(!actual) {
+                                       actual = Z_STRVAL(opline->op2.u.constant);
+                               } else {
+                                       actual++;
                                }
-                               zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'",
-                                       Z_STRVAL(opline->op2.u.constant),
-                                       Z_STRVAL(opline->op2.u.constant));
-                               EX_T(opline->result.u.var).tmp_var = opline->op2.u.constant;
+                               /* non-qualified constant - allow text substitution */
+                               zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'", actual, actual);
+                               ZVAL_STRING(&EX_T(opline->result.u.var).tmp_var, actual, Z_STRLEN(opline->op2.u.constant)-(actual - Z_STRVAL(opline->op2.u.constant)));
+                               zval_copy_ctor(&EX_T(opline->result.u.var).tmp_var);
+                       } else {
+                               zend_error_noreturn(E_ERROR, "Undefined constant '%s'",
+                                                       Z_STRVAL(opline->op2.u.constant), Z_STRVAL(opline->op2.u.constant));
                        }
-                       zval_copy_ctor(&EX_T(opline->result.u.var).tmp_var);
                }
                ZEND_VM_NEXT_OPCODE();
        } else {
@@ -10741,7 +10705,7 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CONST(
        long index;
 
        if (container) {
-
+               
                zval *offset = &opline->op2.u.constant;
 
                if (Z_TYPE_PP(container) == IS_ARRAY) {
@@ -11846,7 +11810,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_W_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HAND
                SEPARATE_ZVAL_TO_MAKE_IS_REF(EX_T(opline->result.u.var).var.ptr_ptr);
                Z_ADDREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
        }
-
+       
        ZEND_VM_NEXT_OPCODE();
 }
 
@@ -12172,7 +12136,7 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMP_HANDLER(ZEND
                EX(called_scope) = ce;
        } else {
                ce = EX_T(opline->op1.u.var).class_entry;
-
+               
                if (opline->op1.u.EA.type == ZEND_FETCH_CLASS_PARENT || opline->op1.u.EA.type == ZEND_FETCH_CLASS_SELF) {
                        EX(called_scope) = EG(called_scope);
                } else {
@@ -13622,7 +13586,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_W_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HAND
                SEPARATE_ZVAL_TO_MAKE_IS_REF(EX_T(opline->result.u.var).var.ptr_ptr);
                Z_ADDREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
        }
-
+       
        ZEND_VM_NEXT_OPCODE();
 }
 
@@ -13999,7 +13963,7 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_VAR_HANDLER(ZEND
                EX(called_scope) = ce;
        } else {
                ce = EX_T(opline->op1.u.var).class_entry;
-
+               
                if (opline->op1.u.EA.type == ZEND_FETCH_CLASS_PARENT || opline->op1.u.EA.type == ZEND_FETCH_CLASS_SELF) {
                        EX(called_scope) = EG(called_scope);
                } else {
@@ -14846,7 +14810,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HA
        }
 
        if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) {
-
+               
                zval *property_name = NULL;
 
                if (0) {
@@ -14919,7 +14883,7 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER(Z
                EX(called_scope) = ce;
        } else {
                ce = EX_T(opline->op1.u.var).class_entry;
-
+               
                if (opline->op1.u.EA.type == ZEND_FETCH_CLASS_PARENT || opline->op1.u.EA.type == ZEND_FETCH_CLASS_SELF) {
                        EX(called_scope) = EG(called_scope);
                } else {
@@ -14929,7 +14893,7 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER(Z
        if(IS_UNUSED != IS_UNUSED) {
                char *function_name_strval = NULL;
                int function_name_strlen = 0;
-
+               
 
                if (IS_UNUSED == IS_CONST) {
                        function_name_strval = Z_STRVAL(opline->op2.u.constant);
@@ -15981,7 +15945,7 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_CV(int
                        PZVAL_LOCK(EG(uninitialized_zval_ptr));
                }
        } else {
-
+               
                zval *offset  = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
                zval *retval;
 
@@ -16060,7 +16024,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDL
                SEPARATE_ZVAL_TO_MAKE_IS_REF(EX_T(opline->result.u.var).var.ptr_ptr);
                Z_ADDREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
        }
-
+       
        ZEND_VM_NEXT_OPCODE();
 }
 
@@ -16221,7 +16185,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLE
        }
 
        if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) {
-
+               
                zval *property_name = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
 
                if (0) {
@@ -16433,7 +16397,7 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_
                EX(called_scope) = ce;
        } else {
                ce = EX_T(opline->op1.u.var).class_entry;
-
+               
                if (opline->op1.u.EA.type == ZEND_FETCH_CLASS_PARENT || opline->op1.u.EA.type == ZEND_FETCH_CLASS_SELF) {
                        EX(called_scope) = EG(called_scope);
                } else {
@@ -16443,7 +16407,7 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_
        if(IS_CV != IS_UNUSED) {
                char *function_name_strval = NULL;
                int function_name_strlen = 0;
-
+               
 
                if (IS_CV == IS_CONST) {
                        function_name_strval = Z_STRVAL(opline->op2.u.constant);
@@ -16777,7 +16741,7 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CV(int
        long index;
 
        if (container) {
-
+               
                zval *offset = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
 
                if (Z_TYPE_PP(container) == IS_ARRAY) {
@@ -16916,7 +16880,7 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_CV_HANDLER(ZEND_O
 static int ZEND_FASTCALL  ZEND_CLONE_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *obj = _get_obj_zval_ptr_unused(TSRMLS_C);
        zend_class_entry *ce;
        zend_function *clone;
@@ -16979,7 +16943,7 @@ static int ZEND_FASTCALL  ZEND_EXIT_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 #if 0 || (IS_UNUSED != IS_UNUSED)
        zend_op *opline = EX(opline);
        if (IS_UNUSED != IS_UNUSED) {
-
+               
                zval *ptr = NULL;
 
                if (Z_TYPE_P(ptr) == IS_LONG) {
@@ -17255,7 +17219,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCO
 static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
        zval *object;
        zval *property = &opline->op2.u.constant;
@@ -17348,7 +17312,7 @@ static int ZEND_FASTCALL  ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE
 static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
        zval *object;
        zval *property = &opline->op2.u.constant;
@@ -17440,7 +17404,7 @@ static int ZEND_FASTCALL  ZEND_POST_DEC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCOD
 static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_CONST(int type, ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *container = _get_obj_zval_ptr_unused(TSRMLS_C);
 
        if (container == EG(error_zval_ptr)) {
@@ -17462,7 +17426,7 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_CON
                        PZVAL_LOCK(EG(uninitialized_zval_ptr));
                }
        } else {
-
+               
                zval *offset  = &opline->op2.u.constant;
                zval *retval;
 
@@ -17539,7 +17503,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE
                SEPARATE_ZVAL_TO_MAKE_IS_REF(EX_T(opline->result.u.var).var.ptr_ptr);
                Z_ADDREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
        }
-
+       
        ZEND_VM_NEXT_OPCODE();
 }
 
@@ -17662,7 +17626,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_
 {
        zend_op *opline = EX(opline);
        zend_op *op_data = opline+1;
-
+       
        zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
        zval *property_name = &opline->op2.u.constant;
 
@@ -17730,7 +17694,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_O
        zval *function_name;
        char *function_name_strval;
        int function_name_strlen;
-
+       
 
        zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
 
@@ -17786,39 +17750,21 @@ static int ZEND_FASTCALL  ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPC
        if (IS_UNUSED == IS_UNUSED) {
                /* namespaced constant */
                if (!zend_get_constant_ex(Z_STRVAL(opline->op2.u.constant), Z_STRLEN(opline->op2.u.constant), &EX_T(opline->result.u.var).tmp_var, NULL, opline->extended_value TSRMLS_CC)) {
-                       char *actual = Z_STRVAL(opline->op2.u.constant);
-
-                       if (opline->extended_value & IS_CONSTANT_RT_NS_CHECK) {
-                               actual = (char *)zend_memrchr(actual, '\\', Z_STRLEN(opline->op2.u.constant)) + 1;
-                               Z_STRLEN(opline->op2.u.constant) -= (actual - Z_STRVAL(opline->op2.u.constant));
-                               actual = estrndup(actual, Z_STRLEN(opline->op2.u.constant));
-                               efree(Z_STRVAL(opline->op2.u.constant));
-                               Z_STRVAL(opline->op2.u.constant) = actual;
-                       }
-                       if (Z_STRVAL(opline->op2.u.constant)[0] == '\\') {
-                               if (opline->extended_value & ZEND_FETCH_CLASS_RT_NS_CHECK) {
-                                       zend_error_noreturn(E_ERROR, "Undefined constant '%s'",
-                                               Z_STRVAL(opline->op2.u.constant)+1,
-                                               Z_STRVAL(opline->op2.u.constant)+1);
-                               }
-                               zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'",
-                                       Z_STRVAL(opline->op2.u.constant)+1,
-                                       Z_STRVAL(opline->op2.u.constant)+1);
-                               EX_T(opline->result.u.var).tmp_var = opline->op2.u.constant;
-                               ++Z_STRVAL(EX_T(opline->result.u.var).tmp_var);
-                               --Z_STRLEN(EX_T(opline->result.u.var).tmp_var);
-                       } else {
-                               if (opline->extended_value & ZEND_FETCH_CLASS_RT_NS_CHECK) {
-                                       zend_error_noreturn(E_ERROR, "Undefined constant '%s'",
-                                               Z_STRVAL(opline->op2.u.constant),
-                                               Z_STRVAL(opline->op2.u.constant));
+                       if ((opline->extended_value & IS_CONSTANT_UNQUALIFIED) != 0) {
+                               char *actual = (char *)zend_memrchr(Z_STRVAL(opline->op2.u.constant), '\\', Z_STRLEN(opline->op2.u.constant));
+                               if(!actual) {
+                                       actual = Z_STRVAL(opline->op2.u.constant);
+                               } else {
+                                       actual++;
                                }
-                               zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'",
-                                       Z_STRVAL(opline->op2.u.constant),
-                                       Z_STRVAL(opline->op2.u.constant));
-                               EX_T(opline->result.u.var).tmp_var = opline->op2.u.constant;
+                               /* non-qualified constant - allow text substitution */
+                               zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'", actual, actual);
+                               ZVAL_STRING(&EX_T(opline->result.u.var).tmp_var, actual, Z_STRLEN(opline->op2.u.constant)-(actual - Z_STRVAL(opline->op2.u.constant)));
+                               zval_copy_ctor(&EX_T(opline->result.u.var).tmp_var);
+                       } else {
+                               zend_error_noreturn(E_ERROR, "Undefined constant '%s'",
+                                                       Z_STRVAL(opline->op2.u.constant), Z_STRVAL(opline->op2.u.constant));
                        }
-                       zval_copy_ctor(&EX_T(opline->result.u.var).tmp_var);
                }
                ZEND_VM_NEXT_OPCODE();
        } else {
@@ -17872,7 +17818,7 @@ static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_
 static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
        zval *offset = &opline->op2.u.constant;
        long index;
@@ -17965,7 +17911,7 @@ static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_H
 static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
        zval *offset = &opline->op2.u.constant;
 
@@ -18000,14 +17946,14 @@ static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_H
 static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CONST(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
        zval **value = NULL;
        int result = 0;
        long index;
 
        if (container) {
-
+               
                zval *offset = &opline->op2.u.constant;
 
                if (Z_TYPE_PP(container) == IS_ARRAY) {
@@ -18588,7 +18534,7 @@ static int ZEND_FASTCALL  ZEND_POST_DEC_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_
 static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_TMP(int type, ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *container = _get_obj_zval_ptr_unused(TSRMLS_C);
 
        if (container == EG(error_zval_ptr)) {
@@ -18687,7 +18633,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_H
                SEPARATE_ZVAL_TO_MAKE_IS_REF(EX_T(opline->result.u.var).var.ptr_ptr);
                Z_ADDREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
        }
-
+       
        ZEND_VM_NEXT_OPCODE();
 }
 
@@ -19074,7 +19020,7 @@ static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HAN
 static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_TMP(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
        zval **value = NULL;
        int result = 0;
@@ -19662,7 +19608,7 @@ static int ZEND_FASTCALL  ZEND_POST_DEC_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_
 static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_VAR(int type, ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *container = _get_obj_zval_ptr_unused(TSRMLS_C);
 
        if (container == EG(error_zval_ptr)) {
@@ -19761,7 +19707,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_W_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_H
                SEPARATE_ZVAL_TO_MAKE_IS_REF(EX_T(opline->result.u.var).var.ptr_ptr);
                Z_ADDREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
        }
-
+       
        ZEND_VM_NEXT_OPCODE();
 }
 
@@ -20148,7 +20094,7 @@ static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HAN
 static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_VAR(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
        zval **value = NULL;
        int result = 0;
@@ -20822,7 +20768,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_
 static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
        zval *object;
        zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
@@ -20915,7 +20861,7 @@ static int ZEND_FASTCALL  ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HA
 static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
        zval *object;
        zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
@@ -21007,7 +20953,7 @@ static int ZEND_FASTCALL  ZEND_POST_DEC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_H
 static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_CV(int type, ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *container = _get_obj_zval_ptr_unused(TSRMLS_C);
 
        if (container == EG(error_zval_ptr)) {
@@ -21029,7 +20975,7 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_CV(
                        PZVAL_LOCK(EG(uninitialized_zval_ptr));
                }
        } else {
-
+               
                zval *offset  = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
                zval *retval;
 
@@ -21106,7 +21052,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HA
                SEPARATE_ZVAL_TO_MAKE_IS_REF(EX_T(opline->result.u.var).var.ptr_ptr);
                Z_ADDREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
        }
-
+       
        ZEND_VM_NEXT_OPCODE();
 }
 
@@ -21229,7 +21175,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HAN
 {
        zend_op *opline = EX(opline);
        zend_op *op_data = opline+1;
-
+       
        zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
        zval *property_name = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
 
@@ -21254,7 +21200,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HAN
 static int ZEND_FASTCALL  ZEND_ADD_VAR_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *str = &EX_T(opline->result.u.var).tmp_var;
        zval *var = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
        zval var_copy;
@@ -21297,7 +21243,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCO
        zval *function_name;
        char *function_name_strval;
        int function_name_strlen;
-
+       
 
        zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
 
@@ -21363,7 +21309,7 @@ static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HAN
 static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
        zval *offset = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
        long index;
@@ -21456,7 +21402,7 @@ static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HAND
 static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
        zval *offset = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
 
@@ -21491,14 +21437,14 @@ static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HAND
 static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CV(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
        zval **value = NULL;
        int result = 0;
        long index;
 
        if (container) {
-
+               
                zval *offset = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
 
                if (Z_TYPE_PP(container) == IS_ARRAY) {
@@ -21635,7 +21581,7 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV_HANDLER(ZEN
 static int ZEND_FASTCALL  ZEND_BW_NOT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        bitwise_not_function(&EX_T(opline->result.u.var).tmp_var,
                _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
@@ -21646,7 +21592,7 @@ static int ZEND_FASTCALL  ZEND_BW_NOT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_BOOL_NOT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        boolean_not_function(&EX_T(opline->result.u.var).tmp_var,
                _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
@@ -21657,7 +21603,7 @@ static int ZEND_FASTCALL  ZEND_BOOL_NOT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 static int ZEND_FASTCALL  ZEND_PRE_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval **var_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC);
 
        if (IS_CV == IS_VAR && !var_ptr) {
@@ -21697,7 +21643,7 @@ static int ZEND_FASTCALL  ZEND_PRE_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_PRE_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval **var_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC);
 
        if (IS_CV == IS_VAR && !var_ptr) {
@@ -21737,7 +21683,7 @@ static int ZEND_FASTCALL  ZEND_PRE_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_POST_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval **var_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC);
 
        if (IS_CV == IS_VAR && !var_ptr) {
@@ -21774,7 +21720,7 @@ static int ZEND_FASTCALL  ZEND_POST_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 static int ZEND_FASTCALL  ZEND_POST_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval **var_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_RW TSRMLS_CC);
 
        if (IS_CV == IS_VAR && !var_ptr) {
@@ -21811,7 +21757,7 @@ static int ZEND_FASTCALL  ZEND_POST_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 static int ZEND_FASTCALL  ZEND_ECHO_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval z_copy;
        zval *z = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
 
@@ -21970,7 +21916,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_IS_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 static int ZEND_FASTCALL  ZEND_JMPZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        int ret = i_zend_is_true(_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC));
 
        if (!ret) {
@@ -21986,7 +21932,7 @@ static int ZEND_FASTCALL  ZEND_JMPZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_JMPNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        int ret = i_zend_is_true(_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC));
 
        if (ret) {
@@ -22002,7 +21948,7 @@ static int ZEND_FASTCALL  ZEND_JMPNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_JMPZNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        int retval = i_zend_is_true(_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC));
 
        if (UNEXPECTED(EG(exception) != NULL)) {
@@ -22025,7 +21971,7 @@ static int ZEND_FASTCALL  ZEND_JMPZNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_JMPZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        int retval = i_zend_is_true(_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC));
 
        Z_LVAL(EX_T(opline->result.u.var).tmp_var) = retval;
@@ -22042,7 +21988,7 @@ static int ZEND_FASTCALL  ZEND_JMPZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_JMPNZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        int retval = i_zend_is_true(_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC));
 
        Z_LVAL(EX_T(opline->result.u.var).tmp_var) = retval;
@@ -22061,7 +22007,7 @@ static int ZEND_FASTCALL  ZEND_RETURN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        zend_op *opline = EX(opline);
        zval *retval_ptr;
        zval **retval_ptr_ptr;
-
+       
 
        if (EG(active_op_array)->return_reference == ZEND_RETURN_REF) {
 
@@ -22135,7 +22081,7 @@ static int ZEND_FASTCALL  ZEND_THROW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        zend_op *opline = EX(opline);
        zval *value;
        zval *exception;
-
+       
 
        value = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
 
@@ -22166,7 +22112,7 @@ static int ZEND_FASTCALL  ZEND_SEND_VAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
        {
                zval *valptr;
                zval *value;
-
+               
 
                value = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
 
@@ -22185,7 +22131,7 @@ static int ZEND_FASTCALL zend_send_by_var_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARG
 {
        zend_op *opline = EX(opline);
        zval *varptr;
-
+       
        varptr = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
 
        if (varptr == &EG(uninitialized_zval)) {
@@ -22257,7 +22203,7 @@ static int ZEND_FASTCALL  ZEND_SEND_VAR_NO_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDL
 static int ZEND_FASTCALL  ZEND_SEND_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval **varptr_ptr;
        zval *varptr;
        varptr_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
@@ -22288,7 +22234,7 @@ static int ZEND_FASTCALL  ZEND_SEND_VAR_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 static int ZEND_FASTCALL  ZEND_BOOL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        /* PHP 3.0 returned "" for false and 1 for true, here we use 0 and 1 for now */
        Z_LVAL(EX_T(opline->result.u.var).tmp_var) = i_zend_is_true(_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC));
@@ -22300,7 +22246,7 @@ static int ZEND_FASTCALL  ZEND_BOOL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_CLONE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *obj = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
        zend_class_entry *ce;
        zend_function *clone;
@@ -22361,7 +22307,7 @@ static int ZEND_FASTCALL  ZEND_CLONE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_CAST_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *expr = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
        zval *result = &EX_T(opline->result.u.var).tmp_var;
 
@@ -22418,7 +22364,7 @@ static int ZEND_FASTCALL  ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDL
        zend_op *opline = EX(opline);
        zend_op_array *new_op_array=NULL;
        int return_value_used;
-
+       
        zval *inc_filename = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
        zval tmp_inc_filename;
        zend_bool failure_retval=0;
@@ -22548,7 +22494,7 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
        zend_op *opline = EX(opline);
        zval tmp, *varname;
        HashTable *target_symbol_table;
-
+       
 
        if (IS_CV == IS_CV && (opline->extended_value & ZEND_QUICK_SET)) {
                if (EG(active_symbol_table)) {
@@ -22630,7 +22576,7 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
 static int ZEND_FASTCALL  ZEND_FE_RESET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *array_ptr, **array_ptr_ptr;
        HashTable *fe_ht;
        zend_object_iterator *iter = NULL;
@@ -22794,12 +22740,12 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_HANDLER(ZEND_OPCODE_HAN
                        if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
                                isset = 0;
                        }
-               } else {
+               } else {                
                        isset = 0;
                }
        } else {
                HashTable *target_symbol_table;
-
+               
                zval tmp, *varname = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_IS TSRMLS_CC);
 
                if (Z_TYPE_P(varname) != IS_STRING) {
@@ -22854,7 +22800,7 @@ static int ZEND_FASTCALL  ZEND_EXIT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 #if 0 || (IS_CV != IS_UNUSED)
        zend_op *opline = EX(opline);
        if (IS_CV != IS_UNUSED) {
-
+               
                zval *ptr = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
 
                if (Z_TYPE_P(ptr) == IS_LONG) {
@@ -22872,7 +22818,7 @@ static int ZEND_FASTCALL  ZEND_EXIT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_JMP_SET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *value = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
 
        if (i_zend_is_true(value)) {
@@ -22891,7 +22837,7 @@ static int ZEND_FASTCALL  ZEND_JMP_SET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_QM_ASSIGN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *value = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
 
        EX_T(opline->result.u.var).tmp_var = *value;
@@ -22905,7 +22851,7 @@ static int ZEND_FASTCALL  ZEND_QM_ASSIGN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
 static int ZEND_FASTCALL  ZEND_INSTANCEOF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *expr = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
        zend_bool result;
 
@@ -22922,7 +22868,7 @@ static int ZEND_FASTCALL  ZEND_INSTANCEOF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_AR
 static int ZEND_FASTCALL  ZEND_ADD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        add_function(&EX_T(opline->result.u.var).tmp_var,
                _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
@@ -22935,7 +22881,7 @@ static int ZEND_FASTCALL  ZEND_ADD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG
 static int ZEND_FASTCALL  ZEND_SUB_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        sub_function(&EX_T(opline->result.u.var).tmp_var,
                _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
@@ -22948,7 +22894,7 @@ static int ZEND_FASTCALL  ZEND_SUB_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG
 static int ZEND_FASTCALL  ZEND_MUL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        mul_function(&EX_T(opline->result.u.var).tmp_var,
                _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
@@ -22961,7 +22907,7 @@ static int ZEND_FASTCALL  ZEND_MUL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG
 static int ZEND_FASTCALL  ZEND_DIV_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        div_function(&EX_T(opline->result.u.var).tmp_var,
                _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
@@ -22974,7 +22920,7 @@ static int ZEND_FASTCALL  ZEND_DIV_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG
 static int ZEND_FASTCALL  ZEND_MOD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        mod_function(&EX_T(opline->result.u.var).tmp_var,
                _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
@@ -22987,7 +22933,7 @@ static int ZEND_FASTCALL  ZEND_MOD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG
 static int ZEND_FASTCALL  ZEND_SL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        shift_left_function(&EX_T(opline->result.u.var).tmp_var,
                _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
@@ -23000,7 +22946,7 @@ static int ZEND_FASTCALL  ZEND_SL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 static int ZEND_FASTCALL  ZEND_SR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        shift_right_function(&EX_T(opline->result.u.var).tmp_var,
                _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
@@ -23013,7 +22959,7 @@ static int ZEND_FASTCALL  ZEND_SR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 static int ZEND_FASTCALL  ZEND_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        concat_function(&EX_T(opline->result.u.var).tmp_var,
                _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
@@ -23026,7 +22972,7 @@ static int ZEND_FASTCALL  ZEND_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_
 static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        is_identical_function(&EX_T(opline->result.u.var).tmp_var,
                _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
@@ -23039,7 +22985,7 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HA
 static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *result = &EX_T(opline->result.u.var).tmp_var;
 
        is_identical_function(result,
@@ -23054,7 +23000,7 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCOD
 static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *result = &EX_T(opline->result.u.var).tmp_var;
 
        compare_function(result,
@@ -23069,7 +23015,7 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLE
 static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *result = &EX_T(opline->result.u.var).tmp_var;
 
        compare_function(result,
@@ -23084,7 +23030,7 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HA
 static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *result = &EX_T(opline->result.u.var).tmp_var;
 
        compare_function(result,
@@ -23099,7 +23045,7 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAND
 static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *result = &EX_T(opline->result.u.var).tmp_var;
 
        compare_function(result,
@@ -23114,7 +23060,7 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OP
 static int ZEND_FASTCALL  ZEND_BW_OR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        bitwise_or_function(&EX_T(opline->result.u.var).tmp_var,
                _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
@@ -23127,7 +23073,7 @@ static int ZEND_FASTCALL  ZEND_BW_OR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
 static int ZEND_FASTCALL  ZEND_BW_AND_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        bitwise_and_function(&EX_T(opline->result.u.var).tmp_var,
                _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
@@ -23140,7 +23086,7 @@ static int ZEND_FASTCALL  ZEND_BW_AND_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_
 static int ZEND_FASTCALL  ZEND_BW_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        bitwise_xor_function(&EX_T(opline->result.u.var).tmp_var,
                _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
@@ -23153,7 +23099,7 @@ static int ZEND_FASTCALL  ZEND_BW_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_
 static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        boolean_xor_function(&EX_T(opline->result.u.var).tmp_var,
                _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
@@ -23424,7 +23370,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_BW_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_H
 static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
        zval *object;
        zval *property = &opline->op2.u.constant;
@@ -23517,7 +23463,7 @@ static int ZEND_FASTCALL  ZEND_PRE_DEC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAN
 static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
        zval *object;
        zval *property = &opline->op2.u.constant;
@@ -23609,7 +23555,7 @@ static int ZEND_FASTCALL  ZEND_POST_DEC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HA
 static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *dim = &opline->op2.u.constant;
        zval **container;
 
@@ -23686,7 +23632,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HA
 static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *dim = &opline->op2.u.constant;
        zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_IS TSRMLS_CC);
 
@@ -23784,7 +23730,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE
 static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_CONST(int type, ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *container = _get_zval_ptr_cv(&opline->op1, EX(Ts), type TSRMLS_CC);
 
        if (container == EG(error_zval_ptr)) {
@@ -23806,7 +23752,7 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_CONST(i
                        PZVAL_LOCK(EG(uninitialized_zval_ptr));
                }
        } else {
-
+               
                zval *offset  = &opline->op2.u.constant;
                zval *retval;
 
@@ -23883,7 +23829,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAN
                SEPARATE_ZVAL_TO_MAKE_IS_REF(EX_T(opline->result.u.var).var.ptr_ptr);
                Z_ADDREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
        }
-
+       
        ZEND_VM_NEXT_OPCODE();
 }
 
@@ -24006,7 +23952,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAND
 {
        zend_op *opline = EX(opline);
        zend_op *op_data = opline+1;
-
+       
        zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
        zval *property_name = &opline->op2.u.constant;
 
@@ -24032,7 +23978,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAND
 {
        zend_op *opline = EX(opline);
        zend_op *op_data = opline+1;
-
+       
        zval **object_ptr;
 
        if (IS_CV == IS_CV || EX_T(opline->op1.u.var).var.ptr_ptr) {
@@ -24043,7 +23989,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAND
        }
 
        if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) {
-
+               
                zval *property_name = &opline->op2.u.constant;
 
                if (0) {
@@ -24099,7 +24045,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAND
 static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *value = &opline->op2.u.constant;
        zval **variable_ptr_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
 
@@ -24134,7 +24080,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER(ZEND_OPCOD
        zval *function_name;
        char *function_name_strval;
        int function_name_strlen;
-
+       
 
        zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
 
@@ -24187,7 +24133,7 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR
 {
        zend_op *opline = EX(opline);
        int switch_expr_is_overloaded=0;
-
+       
 
        if (IS_CV==IS_VAR) {
                if (EX_T(opline->op1.u.var).var.ptr_ptr) {
@@ -24217,7 +24163,7 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR
 static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
        zval *expr_ptr;
        zval *offset=&opline->op2.u.constant;
@@ -24310,7 +24256,7 @@ static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAND
 static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_UNSET TSRMLS_CC);
        zval *offset = &opline->op2.u.constant;
        long index;
@@ -24403,7 +24349,7 @@ static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDL
 static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_UNSET TSRMLS_CC);
        zval *offset = &opline->op2.u.constant;
 
@@ -24438,14 +24384,14 @@ static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDL
 static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CONST(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_IS TSRMLS_CC);
        zval **value = NULL;
        int result = 0;
        long index;
 
        if (container) {
-
+               
                zval *offset = &opline->op2.u.constant;
 
                if (Z_TYPE_PP(container) == IS_ARRAY) {
@@ -25445,7 +25391,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_UNSET_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_H
 static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_TMP(int type, ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *container = _get_zval_ptr_cv(&opline->op1, EX(Ts), type TSRMLS_CC);
 
        if (container == EG(error_zval_ptr)) {
@@ -25544,7 +25490,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_W_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDL
                SEPARATE_ZVAL_TO_MAKE_IS_REF(EX_T(opline->result.u.var).var.ptr_ptr);
                Z_ADDREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
        }
-
+       
        ZEND_VM_NEXT_OPCODE();
 }
 
@@ -25693,7 +25639,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLE
 {
        zend_op *opline = EX(opline);
        zend_op *op_data = opline+1;
-
+       
        zval **object_ptr;
 
        if (IS_CV == IS_CV || EX_T(opline->op1.u.var).var.ptr_ptr) {
@@ -26102,7 +26048,7 @@ static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER
 static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_TMP(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_IS TSRMLS_CC);
        zval **value = NULL;
        int result = 0;
@@ -27109,7 +27055,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_UNSET_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_H
 static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_VAR(int type, ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *container = _get_zval_ptr_cv(&opline->op1, EX(Ts), type TSRMLS_CC);
 
        if (container == EG(error_zval_ptr)) {
@@ -27208,7 +27154,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_W_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDL
                SEPARATE_ZVAL_TO_MAKE_IS_REF(EX_T(opline->result.u.var).var.ptr_ptr);
                Z_ADDREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
        }
-
+       
        ZEND_VM_NEXT_OPCODE();
 }
 
@@ -27357,7 +27303,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLE
 {
        zend_op *opline = EX(opline);
        zend_op *op_data = opline+1;
-
+       
        zval **object_ptr;
 
        if (IS_CV == IS_CV || EX_T(opline->op1.u.var).var.ptr_ptr) {
@@ -27816,7 +27762,7 @@ static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER
 static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_VAR(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_IS TSRMLS_CC);
        zval **value = NULL;
        int result = 0;
@@ -28310,7 +28256,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HAN
 {
        zend_op *opline = EX(opline);
        zend_op *op_data = opline+1;
-
+       
        zval **object_ptr;
 
        if (IS_CV == IS_CV || EX_T(opline->op1.u.var).var.ptr_ptr) {
@@ -28321,7 +28267,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HAN
        }
 
        if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) {
-
+               
                zval *property_name = NULL;
 
                if (0) {
@@ -28377,7 +28323,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HAN
 static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
        zval *expr_ptr;
        zval *offset=NULL;
@@ -28470,7 +28416,7 @@ static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HAN
 static int ZEND_FASTCALL  ZEND_ADD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        add_function(&EX_T(opline->result.u.var).tmp_var,
                _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
@@ -28483,7 +28429,7 @@ static int ZEND_FASTCALL  ZEND_ADD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_SUB_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        sub_function(&EX_T(opline->result.u.var).tmp_var,
                _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
@@ -28496,7 +28442,7 @@ static int ZEND_FASTCALL  ZEND_SUB_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_MUL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        mul_function(&EX_T(opline->result.u.var).tmp_var,
                _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
@@ -28509,7 +28455,7 @@ static int ZEND_FASTCALL  ZEND_MUL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_DIV_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        div_function(&EX_T(opline->result.u.var).tmp_var,
                _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
@@ -28522,7 +28468,7 @@ static int ZEND_FASTCALL  ZEND_DIV_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_MOD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        mod_function(&EX_T(opline->result.u.var).tmp_var,
                _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
@@ -28535,7 +28481,7 @@ static int ZEND_FASTCALL  ZEND_MOD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_SL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        shift_left_function(&EX_T(opline->result.u.var).tmp_var,
                _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
@@ -28548,7 +28494,7 @@ static int ZEND_FASTCALL  ZEND_SL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_SR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        shift_right_function(&EX_T(opline->result.u.var).tmp_var,
                _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
@@ -28561,7 +28507,7 @@ static int ZEND_FASTCALL  ZEND_SR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        concat_function(&EX_T(opline->result.u.var).tmp_var,
                _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
@@ -28574,7 +28520,7 @@ static int ZEND_FASTCALL  ZEND_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
 static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        is_identical_function(&EX_T(opline->result.u.var).tmp_var,
                _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
@@ -28587,7 +28533,7 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDL
 static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *result = &EX_T(opline->result.u.var).tmp_var;
 
        is_identical_function(result,
@@ -28602,7 +28548,7 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_H
 static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *result = &EX_T(opline->result.u.var).tmp_var;
 
        compare_function(result,
@@ -28617,7 +28563,7 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_A
 static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *result = &EX_T(opline->result.u.var).tmp_var;
 
        compare_function(result,
@@ -28632,7 +28578,7 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDL
 static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *result = &EX_T(opline->result.u.var).tmp_var;
 
        compare_function(result,
@@ -28647,7 +28593,7 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER
 static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *result = &EX_T(opline->result.u.var).tmp_var;
 
        compare_function(result,
@@ -28662,7 +28608,7 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCOD
 static int ZEND_FASTCALL  ZEND_BW_OR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        bitwise_or_function(&EX_T(opline->result.u.var).tmp_var,
                _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
@@ -28675,7 +28621,7 @@ static int ZEND_FASTCALL  ZEND_BW_OR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 static int ZEND_FASTCALL  ZEND_BW_AND_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        bitwise_and_function(&EX_T(opline->result.u.var).tmp_var,
                _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
@@ -28688,7 +28634,7 @@ static int ZEND_FASTCALL  ZEND_BW_AND_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
 static int ZEND_FASTCALL  ZEND_BW_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        bitwise_xor_function(&EX_T(opline->result.u.var).tmp_var,
                _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
@@ -28701,7 +28647,7 @@ static int ZEND_FASTCALL  ZEND_BW_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
 static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
 
        boolean_xor_function(&EX_T(opline->result.u.var).tmp_var,
                _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC),
@@ -28972,7 +28918,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_BW_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HAND
 static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
        zval *object;
        zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
@@ -29065,7 +29011,7 @@ static int ZEND_FASTCALL  ZEND_PRE_DEC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLE
 static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
        zval *object;
        zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
@@ -29157,7 +29103,7 @@ static int ZEND_FASTCALL  ZEND_POST_DEC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDL
 static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
        zval **container;
 
@@ -29234,7 +29180,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDL
 static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
        zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_IS TSRMLS_CC);
 
@@ -29332,7 +29278,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HA
 static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_CV(int type, ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *container = _get_zval_ptr_cv(&opline->op1, EX(Ts), type TSRMLS_CC);
 
        if (container == EG(error_zval_ptr)) {
@@ -29354,7 +29300,7 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_CV(int
                        PZVAL_LOCK(EG(uninitialized_zval_ptr));
                }
        } else {
-
+               
                zval *offset  = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
                zval *retval;
 
@@ -29431,7 +29377,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLE
                SEPARATE_ZVAL_TO_MAKE_IS_REF(EX_T(opline->result.u.var).var.ptr_ptr);
                Z_ADDREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
        }
-
+       
        ZEND_VM_NEXT_OPCODE();
 }
 
@@ -29554,7 +29500,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER
 {
        zend_op *opline = EX(opline);
        zend_op *op_data = opline+1;
-
+       
        zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
        zval *property_name = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
 
@@ -29580,7 +29526,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER
 {
        zend_op *opline = EX(opline);
        zend_op *op_data = opline+1;
-
+       
        zval **object_ptr;
 
        if (IS_CV == IS_CV || EX_T(opline->op1.u.var).var.ptr_ptr) {
@@ -29591,7 +29537,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER
        }
 
        if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) {
-
+               
                zval *property_name = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
 
                if (0) {
@@ -29647,7 +29593,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER
 static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *value = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
        zval **variable_ptr_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
 
@@ -29730,7 +29676,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_H
        zval *function_name;
        char *function_name_strval;
        int function_name_strlen;
-
+       
 
        zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
 
@@ -29783,7 +29729,7 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
        int switch_expr_is_overloaded=0;
-
+       
 
        if (IS_CV==IS_VAR) {
                if (EX_T(opline->op1.u.var).var.ptr_ptr) {
@@ -29813,7 +29759,7 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
        zval *expr_ptr;
        zval *offset=_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
@@ -29906,7 +29852,7 @@ static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER
 static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_UNSET TSRMLS_CC);
        zval *offset = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
        long index;
@@ -29999,7 +29945,7 @@ static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_
 static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_UNSET TSRMLS_CC);
        zval *offset = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
 
@@ -30034,14 +29980,14 @@ static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_
 static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CV(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-
+       
        zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_IS TSRMLS_CC);
        zval **value = NULL;
        int result = 0;
        long index;
 
        if (container) {
-
+               
                zval *offset = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
 
                if (Z_TYPE_PP(container) == IS_ARRAY) {