diff options
author | Nikita Popov <nikic@php.net> | 2014-08-25 21:59:30 +0200 |
---|---|---|
committer | Nikita Popov <nikic@php.net> | 2014-08-25 22:04:33 +0200 |
commit | 899a1ed59a2f7133367dc39f95b143c019822520 (patch) | |
tree | a8fc518673cf0c94ad363d04bc3474eb3f3bfa66 | |
parent | af59e92b24c8f624672720d47ef65bd8457728b9 (diff) | |
parent | 6db293d5e043d35c281a6b11cb68460f5d7188a9 (diff) | |
download | php-git-899a1ed59a2f7133367dc39f95b143c019822520.tar.gz |
Merge branch 'ast'POST_AST_MERGE
Conflicts:
Zend/zend_compile.c
62 files changed, 9060 insertions, 6801 deletions
diff --git a/Zend/tests/024.phpt b/Zend/tests/024.phpt index ff35a5c895..f89c49e613 100644 --- a/Zend/tests/024.phpt +++ b/Zend/tests/024.phpt @@ -11,7 +11,7 @@ var_dump($a++); var_dump(++$b); var_dump($a->$b); var_dump($a->$b); -var_dump($a->$b->$c[1]); +var_dump($a->$b->{$c[1]}); ?> --EXPECTF-- diff --git a/Zend/tests/bug27669.phpt b/Zend/tests/bug27669.phpt index 4d513e91aa..43591a9386 100644 --- a/Zend/tests/bug27669.phpt +++ b/Zend/tests/bug27669.phpt @@ -10,7 +10,7 @@ Bug #27669 (PHP 5 didn't support all possibilities for calling static methods dy } } $y[0] = 'hello'; - A::$y[0](); + A::{$y[0]}(); ?> ===DONE=== --EXPECTF-- diff --git a/Zend/tests/bug30080.phpt b/Zend/tests/bug30080.phpt index bd8401e1be..8cac75ab8d 100644 --- a/Zend/tests/bug30080.phpt +++ b/Zend/tests/bug30080.phpt @@ -10,9 +10,9 @@ class foo { new foo(array(new stdClass)); ?> ---EXPECT-- +--EXPECTF-- array(1) { [0]=> - object(stdClass)#2 (0) { + object(stdClass)#%d (0) { } } diff --git a/Zend/tests/bug39304.phpt b/Zend/tests/bug39304.phpt index 8303b82573..5540135fa4 100644 --- a/Zend/tests/bug39304.phpt +++ b/Zend/tests/bug39304.phpt @@ -9,8 +9,8 @@ echo "I am alive"; --EXPECTF-- Notice: Uninitialized string offset: 0 in %sbug39304.php on line %d -Notice: Uninitialized string offset: 1 in %sbug39304.php on line %d - Notice: Uninitialized string offset: 0 in %sbug39304.php on line %d + +Notice: Uninitialized string offset: 1 in %sbug39304.php on line %d I am alive diff --git a/Zend/tests/bug39304_2_4.phpt b/Zend/tests/bug39304_2_4.phpt index b0e6ddc72c..cc0709b424 100644 --- a/Zend/tests/bug39304_2_4.phpt +++ b/Zend/tests/bug39304_2_4.phpt @@ -11,8 +11,8 @@ Bug #39304 (Segmentation fault with list unpacking of string offset) --EXPECTF-- Notice: Uninitialized string offset: 0 in %sbug39304_2_4.php on line %d -Notice: Uninitialized string offset: 1 in %sbug39304_2_4.php on line %d - Notice: Uninitialized string offset: 0 in %sbug39304_2_4.php on line %d + +Notice: Uninitialized string offset: 1 in %sbug39304_2_4.php on line %d string(0) "" string(0) "" diff --git a/Zend/tests/bug43450.phpt b/Zend/tests/bug43450.phpt index a94eba312e..f0cd4f75bc 100644 --- a/Zend/tests/bug43450.phpt +++ b/Zend/tests/bug43450.phpt @@ -18,15 +18,15 @@ class Foo $num_repeats = 100000; -$start = (memory_get_usage() / 1024) + 16; +$start = memory_get_usage() / 1024; for ($i=1;$i<$num_repeats;$i++) { $foo = new Foo(); md5($foo); } -$end = memory_get_peak_usage() / 1024; +$end = memory_get_usage() / 1024; -if ($start < $end) { +if ($start + 16 < $end) { echo 'FAIL'; } else { echo 'PASS'; diff --git a/Zend/tests/bug44414.phpt b/Zend/tests/bug44414.phpt index 1f3a2583d7..e9e6de7b45 100644 --- a/Zend/tests/bug44414.phpt +++ b/Zend/tests/bug44414.phpt @@ -12,4 +12,4 @@ class C extends A implements B { } ?> --EXPECTF-- -Fatal error: Class C contains 2 abstract methods and must therefore be declared abstract or implement the remaining methods (A::foo, B::bar) in %sbug44414.php on line 9 +Fatal error: Class C contains 2 abstract methods and must therefore be declared abstract or implement the remaining methods (A::foo, B::bar) in %sbug44414.php on line 8 diff --git a/Zend/tests/bug55007.phpt b/Zend/tests/bug55007.phpt index 12fbf120a8..425ce8f296 100644 --- a/Zend/tests/bug55007.phpt +++ b/Zend/tests/bug55007.phpt @@ -4,7 +4,7 @@ Bug #55007 (compiler fail after previous fail) <?php function __autoload($classname) { - if ('CompileErrorClass'==$classname) eval('class CompileErrorClass { function foo() { $a[] } }'); + if ('CompileErrorClass'==$classname) eval('class CompileErrorClass { function foo() { $a[]; } }'); if ('MyErrorHandler'==$classname) eval('class MyErrorHandler { function __construct() { print "My error handler runs.\n"; } }'); } diff --git a/Zend/tests/bug60099.phpt b/Zend/tests/bug60099.phpt index 13e2f54b09..8cca3440fb 100644 --- a/Zend/tests/bug60099.phpt +++ b/Zend/tests/bug60099.phpt @@ -7,4 +7,4 @@ namespace foo { ?> --EXPECTF-- -Fatal error: __HALT_COMPILER() can only be used from the outermost scope in %s on line %d +Parse error: syntax error, unexpected end of file in %s on line %d diff --git a/Zend/tests/declare_001.phpt b/Zend/tests/declare_001.phpt index 21d797880e..4eff18045c 100644 --- a/Zend/tests/declare_001.phpt +++ b/Zend/tests/declare_001.phpt @@ -13,7 +13,6 @@ zend.multibyte=1 declare(encoding = 1); declare(encoding = 112313123213131232100); -declare(encoding = NULL); declare(encoding = 'utf-8'); declare(encoding = M_PI); @@ -25,6 +24,4 @@ Warning: Unsupported encoding [1] in %sdeclare_001.php on line %d Warning: Unsupported encoding [1.1231312321313E+20] in %sdeclare_001.php on line %d -Warning: Unsupported encoding [] in %sdeclare_001.php on line %d - -Fatal error: Cannot use constants as encoding in %sdeclare_001.php on line %d +Fatal error: Encoding must be a literal in %s on line %d diff --git a/Zend/tests/declare_003.phpt b/Zend/tests/declare_003.phpt index 2980f7589b..2f3e887380 100644 --- a/Zend/tests/declare_003.phpt +++ b/Zend/tests/declare_003.phpt @@ -8,7 +8,6 @@ zend.multibyte=1 declare(encoding = 1); declare(encoding = 11111111111111); -declare(encoding = NULL); declare(encoding = M_PI); print 'DONE'; @@ -19,6 +18,4 @@ Warning: Unsupported encoding [1] in %sdeclare_003.php on line %d Warning: Unsupported encoding [11111111111111] in %sdeclare_003.php on line %d -Warning: Unsupported encoding [] in %sdeclare_003.php on line %d - -Fatal error: Cannot use constants as encoding in %sdeclare_003.php on line %d +Fatal error: Encoding must be a literal in %s on line %d diff --git a/Zend/tests/errmsg_014.phpt b/Zend/tests/errmsg_014.phpt deleted file mode 100644 index 77e12b05e9..0000000000 --- a/Zend/tests/errmsg_014.phpt +++ /dev/null @@ -1,17 +0,0 @@ ---TEST-- -errmsg: cannot call __clone() method on objects ---FILE-- -<?php - -class test { - function __clone() { - } -} - -$t = new test; -$t->__clone(); - -echo "Done\n"; -?> ---EXPECTF-- -Fatal error: Cannot call __clone() method on objects - use 'clone $obj' instead in %s on line %d diff --git a/Zend/tests/foreach_list_002.phpt b/Zend/tests/foreach_list_002.phpt index 251870ba09..bc17d94268 100644 --- a/Zend/tests/foreach_list_002.phpt +++ b/Zend/tests/foreach_list_002.phpt @@ -9,7 +9,7 @@ foreach (array(array(1,2), array(3,4)) as list($a, )) { $array = [['a', 'b'], 'c', 'd']; -foreach($array as list(list(), $a)) { +foreach($array as list(, $a)) { var_dump($a); } diff --git a/Zend/tests/isset_003.phpt b/Zend/tests/isset_003.phpt index 4db42a933b..92225b5906 100644 --- a/Zend/tests/isset_003.phpt +++ b/Zend/tests/isset_003.phpt @@ -14,7 +14,7 @@ var_dump(isset($a[0]->a)); var_dump(isset($c[0][1][2]->a->b->c->d)); -var_dump(isset(${$a}->{$b->$c[$d]})); +var_dump(isset(${$a}->{$b->{$c[$d]}})); var_dump(isset($GLOBALS)); diff --git a/Zend/tests/isset_003_2_4.phpt b/Zend/tests/isset_003_2_4.phpt index c05f3e26f4..42d8cc6a08 100644 --- a/Zend/tests/isset_003_2_4.phpt +++ b/Zend/tests/isset_003_2_4.phpt @@ -16,7 +16,7 @@ var_dump(isset($a[0]->a)); var_dump(isset($c[0][1][2]->a->b->c->d)); -var_dump(isset(${$a}->{$b->$c[$d]})); +var_dump(isset(${$a}->{$b->{$c[$d]}})); var_dump(isset($GLOBALS)); diff --git a/Zend/tests/isset_func_error.phpt b/Zend/tests/isset_func_error.phpt index 7d1036def8..7d6616b96d 100644 --- a/Zend/tests/isset_func_error.phpt +++ b/Zend/tests/isset_func_error.phpt @@ -5,4 +5,4 @@ Error message for isset(func()) isset(abc()); ?> --EXPECTF-- -Fatal error: Cannot use isset() on the result of a function call (you can use "null !== func()" instead) in %s on line %d +Fatal error: Cannot use isset() on the result of an expression (you can use "null !== expression" instead) in %s on line %d diff --git a/Zend/tests/list_005.phpt b/Zend/tests/list_005.phpt index 4afc353b2f..ec5640a60a 100644 --- a/Zend/tests/list_005.phpt +++ b/Zend/tests/list_005.phpt @@ -3,33 +3,33 @@ Testing list() with several variables --FILE-- <?php -$a = "foo"; +$str = "foo"; -list($a, $b, $c) = $a; +list($a, $b, $c) = $str; var_dump($a, $b, $c); print "----\n"; -$a = 1; +$int = 1; -list($a, $b, $c) = $a; +list($a, $b, $c) = $int; var_dump($a, $b, $c); print "----\n"; -$a = new stdClass; +$obj = new stdClass; -list($a, $b, $c) = $a; +list($a, $b, $c) = $obj; var_dump($a, $b, $c); print "----\n"; -$a = array(1, 2, 3); +$arr = array(1, 2, 3); -list($a, $b, $c) = $a; +list($a, $b, $c) = $arr; var_dump($a, $b, $c); diff --git a/Zend/tests/list_006.phpt b/Zend/tests/list_006.phpt index f5f5970be4..d380235d25 100644 --- a/Zend/tests/list_006.phpt +++ b/Zend/tests/list_006.phpt @@ -7,8 +7,6 @@ list($a, list($b, list(list($d)))) = array(); ?> --EXPECTF-- -Notice: Undefined offset: 1 in %s on line %d +Notice: Undefined offset: 0 in %s on line %d Notice: Undefined offset: 1 in %s on line %d - -Notice: Undefined offset: 0 in %s on line %d diff --git a/Zend/tests/use_const/no_global_fallback.phpt b/Zend/tests/use_const/no_global_fallback.phpt index a128f353ed..64e2a154ce 100644 --- a/Zend/tests/use_const/no_global_fallback.phpt +++ b/Zend/tests/use_const/no_global_fallback.phpt @@ -10,5 +10,4 @@ var_dump(baz); ?> --EXPECTF-- -Notice: Use of undefined constant baz - assumed 'baz' in %s on line %d -string(3) "baz" +Fatal error: Undefined constant 'foo\bar\baz' in %s on line %d diff --git a/Zend/tests/varSyntax/globalNonSimpleVariableError.phpt b/Zend/tests/varSyntax/globalNonSimpleVariableError.phpt new file mode 100644 index 0000000000..ed04921f89 --- /dev/null +++ b/Zend/tests/varSyntax/globalNonSimpleVariableError.phpt @@ -0,0 +1,10 @@ +--TEST-- +Global keyword only accepts simple variables +--FILE-- +<?php + +global $$foo->bar; + +?> +--EXPECTF-- +Parse error: syntax error, unexpected '->' (T_OBJECT_OPERATOR), expecting ',' or ';' in %s on line %d diff --git a/Zend/tests/varSyntax/indirectFcall.phpt b/Zend/tests/varSyntax/indirectFcall.phpt new file mode 100644 index 0000000000..4cc5c1171a --- /dev/null +++ b/Zend/tests/varSyntax/indirectFcall.phpt @@ -0,0 +1,53 @@ +--TEST-- +Indirect function calls +--FILE-- +<?php + +function id($x = 'id') { return $x; } + +var_dump(0); + +id('var_dump')(1); +id('id')('var_dump')(2); +id('id')('id')('var_dump')(3); +id()()('var_dump')(4); + +id(['udef', 'id'])[1]()('var_dump')(5); +(id((object) ['a' => 'id', 'b' => 'udef'])->a)()()()()('var_dump')(6); + +$id = function($x) { return $x; }; + +$id($id)('var_dump')(7); + +(function($x) { return $x; })('id')('var_dump')(8); + +($f = function($x = null) use (&$f) { + return $x ?: $f; +})()()()('var_dump')(9); + +class Test { + public static function id($x = [__CLASS__, 'id']) { return $x; } +} + +$obj = new Test; +[$obj, 'id']()('id')($id)('var_dump')(10); +['Test', 'id']()()('var_dump')(11); +'id'()('id')('var_dump')(12); +('i' . 'd')()('var_dump')(13); + +?> +--EXPECT-- +int(0) +int(1) +int(2) +int(3) +int(4) +int(5) +int(6) +int(7) +int(8) +int(9) +int(10) +int(11) +int(12) +int(13) diff --git a/Zend/tests/varSyntax/issetOnTemp.phpt b/Zend/tests/varSyntax/issetOnTemp.phpt new file mode 100644 index 0000000000..cd7bc006cd --- /dev/null +++ b/Zend/tests/varSyntax/issetOnTemp.phpt @@ -0,0 +1,26 @@ +--TEST-- +isset() can be used on dereferences of temporary expressions +--FILE-- +<?php + +var_dump(isset([0, 1][0])); +var_dump(isset(([0, 1] + [])[0])); +var_dump(isset([[0, 1]][0][0])); +var_dump(isset(([[0, 1]] + [])[0][0])); +var_dump(isset(((object) ['a' => 'b'])->a)); +var_dump(isset(['a' => 'b']->a)); +var_dump(isset("str"->a)); +var_dump(isset((['a' => 'b'] + [])->a)); +var_dump(isset((['a' => 'b'] + [])->a->b)); + +?> +--EXPECT-- +bool(true) +bool(true) +bool(true) +bool(true) +bool(true) +bool(false) +bool(false) +bool(false) +bool(false) diff --git a/Zend/tests/varSyntax/newVariable.phpt b/Zend/tests/varSyntax/newVariable.phpt new file mode 100644 index 0000000000..360f99ac36 --- /dev/null +++ b/Zend/tests/varSyntax/newVariable.phpt @@ -0,0 +1,39 @@ +--TEST-- +Variable as class name for new expression +--FILE-- +<?php + +$className = 'stdClass'; +$array = ['className' => 'stdClass']; +$obj = (object) ['className' => 'stdClass']; + +class Test { + public static $className = 'stdClass'; +} +$test = 'Test'; +$weird = [0 => (object) ['foo' => 'Test']]; + +var_dump(new $className); +var_dump(new $array['className']); +var_dump(new $array{'className'}); +var_dump(new $obj->className); +var_dump(new Test::$className); +var_dump(new $test::$className); +var_dump(new $weird[0]->foo::$className); + +?> +--EXPECTF-- +object(stdClass)#%d (0) { +} +object(stdClass)#%d (0) { +} +object(stdClass)#%d (0) { +} +object(stdClass)#%d (0) { +} +object(stdClass)#%d (0) { +} +object(stdClass)#%d (0) { +} +object(stdClass)#%d (0) { +} diff --git a/Zend/tests/varSyntax/parenthesesDeref.phpt b/Zend/tests/varSyntax/parenthesesDeref.phpt new file mode 100644 index 0000000000..0ebfe9c5d7 --- /dev/null +++ b/Zend/tests/varSyntax/parenthesesDeref.phpt @@ -0,0 +1,20 @@ +--TEST-- +Dereferencing expression parentheses +--FILE-- +<?php + +$array = [&$array, 1]; +var_dump(($array)[1]); +var_dump((($array[0][0])[0])[1]); + +var_dump(((object) ['a' => 0, 'b' => 1])->b); + +$obj = (object) ['a' => 0, 'b' => ['var_dump', 1]]; +(clone $obj)->b[0](1); + +?> +--EXPECT-- +int(1) +int(1) +int(1) +int(1) diff --git a/Zend/tests/varSyntax/propertyOfStringError.phpt b/Zend/tests/varSyntax/propertyOfStringError.phpt new file mode 100644 index 0000000000..85abc5849a --- /dev/null +++ b/Zend/tests/varSyntax/propertyOfStringError.phpt @@ -0,0 +1,10 @@ +--TEST-- +Cannot take property of a string +--FILE-- +<?php + +"foo"->bar; + +?> +--EXPECTF-- +Notice: Trying to get property of non-object in %s on line %d diff --git a/Zend/tests/varSyntax/staticMember.phpt b/Zend/tests/varSyntax/staticMember.phpt new file mode 100644 index 0000000000..22a1fa2b13 --- /dev/null +++ b/Zend/tests/varSyntax/staticMember.phpt @@ -0,0 +1,37 @@ +--TEST-- +Static member access +--FILE-- +<?php + +class A { + public static $b = 0; + public static $c = [0, 1]; + public static $A_str = 'A'; +} + +$A_str = 'A'; +$A_obj = new A; +$b_str = 'b'; +$c_str = 'c'; + +var_dump(A::$b); +var_dump($A_str::$b); +var_dump($A_obj::$b); +var_dump(('A' . '')::$b); +var_dump('A'::$b); +var_dump('A'[0]::$b); +var_dump(A::$$b_str); +var_dump(A::$$c_str[1]); +var_dump(A::$A_str::$b); + +?> +--EXPECT-- +int(0) +int(0) +int(0) +int(0) +int(0) +int(0) +int(0) +int(1) +int(0) diff --git a/Zend/tests/varSyntax/tempDimFetchByRefError.phpt b/Zend/tests/varSyntax/tempDimFetchByRefError.phpt new file mode 100644 index 0000000000..dbcac75ea9 --- /dev/null +++ b/Zend/tests/varSyntax/tempDimFetchByRefError.phpt @@ -0,0 +1,11 @@ +--TEST-- +Passing a dimention fetch on a temporary by reference is not allowed +--FILE-- +<?php + +$fn = function(&$ref) {}; +$fn([0, 1][0]); + +?> +--EXPECTF-- +Fatal error: Cannot use temporary expression in write context in %s on line %d diff --git a/Zend/tests/varSyntax/tempPropFetchByRefError.phpt b/Zend/tests/varSyntax/tempPropFetchByRefError.phpt new file mode 100644 index 0000000000..f8298a936d --- /dev/null +++ b/Zend/tests/varSyntax/tempPropFetchByRefError.phpt @@ -0,0 +1,11 @@ +--TEST-- +Passing a property fetch on a temporary by reference is not allowed +--FILE-- +<?php + +$fn = function(&$ref) {}; +$fn([0, 1]->prop); + +?> +--EXPECTF-- +Fatal error: Cannot use temporary expression in write context in %s on line %d diff --git a/Zend/tests/varSyntax/writeToTempExpr.phpt b/Zend/tests/varSyntax/writeToTempExpr.phpt new file mode 100644 index 0000000000..daeaf24938 --- /dev/null +++ b/Zend/tests/varSyntax/writeToTempExpr.phpt @@ -0,0 +1,10 @@ +--TEST-- +Writing to a temporary expression is not allowed +--FILE-- +<?php + +[0, 1][0] = 1; + +?> +--EXPECTF-- +Fatal error: Cannot use temporary expression in write context in %s on line %d diff --git a/Zend/zend.c b/Zend/zend.c index 413c799a37..2d4232ee98 100644 --- a/Zend/zend.c +++ b/Zend/zend.c @@ -1021,13 +1021,9 @@ ZEND_API void zend_error(int type, const char *format, ...) /* {{{ */ zval orig_user_error_handler; zend_bool in_compilation; zend_class_entry *saved_class_entry; - zend_stack bp_stack; - zend_stack function_call_stack; zend_stack switch_cond_stack; zend_stack foreach_copy_stack; - zend_stack object_stack; - zend_stack declare_stack; - zend_stack list_stack; + zend_stack delayed_oplines_stack; zend_stack context_stack; zend_array *symbol_table; TSRMLS_FETCH(); @@ -1190,13 +1186,9 @@ ZEND_API void zend_error(int type, const char *format, ...) /* {{{ */ if (in_compilation) { saved_class_entry = CG(active_class_entry); CG(active_class_entry) = NULL; - SAVE_STACK(bp_stack); - SAVE_STACK(function_call_stack); SAVE_STACK(switch_cond_stack); SAVE_STACK(foreach_copy_stack); - SAVE_STACK(object_stack); - SAVE_STACK(declare_stack); - SAVE_STACK(list_stack); + SAVE_STACK(delayed_oplines_stack); SAVE_STACK(context_stack); CG(in_compilation) = 0; } @@ -1216,13 +1208,9 @@ ZEND_API void zend_error(int type, const char *format, ...) /* {{{ */ if (in_compilation) { CG(active_class_entry) = saved_class_entry; - RESTORE_STACK(bp_stack); - RESTORE_STACK(function_call_stack); RESTORE_STACK(switch_cond_stack); RESTORE_STACK(foreach_copy_stack); - RESTORE_STACK(object_stack); - RESTORE_STACK(declare_stack); - RESTORE_STACK(list_stack); + RESTORE_STACK(delayed_oplines_stack); RESTORE_STACK(context_stack); CG(in_compilation) = 1; } diff --git a/Zend/zend.h b/Zend/zend.h index 0e8de14cb4..c667b6c45a 100644 --- a/Zend/zend.h +++ b/Zend/zend.h @@ -309,7 +309,6 @@ void zend_error_noreturn(int type, const char *format, ...) __attribute__ ((nore #endif #include "zend_object_handlers.h" -#include "zend_ast.h" /* overloaded elements data types */ #define OE_IS_ARRAY (1<<0) @@ -401,6 +400,7 @@ void zend_error_noreturn(int type, const char *format, ...) __attribute__ ((nore #endif #include "zend_string.h" +#include "zend_ast.h" static zend_always_inline uint32_t zval_refcount_p(zval* pz) { ZEND_ASSERT(Z_REFCOUNTED_P(pz) || Z_IMMUTABLE_P(pz)); diff --git a/Zend/zend_ast.c b/Zend/zend_ast.c index 810b9b1fe8..2532018274 100644 --- a/Zend/zend_ast.c +++ b/Zend/zend_ast.c @@ -23,82 +23,146 @@ #include "zend_API.h" #include "zend_operators.h" -ZEND_API zend_ast *zend_ast_create_constant(zval *zv) -{ - zend_ast *ast = emalloc(sizeof(zend_ast) + sizeof(zval)); - ast->kind = ZEND_CONST; - ast->children = 0; - ZVAL_COPY_VALUE(&ast->u.val, zv); - return ast; +static inline void *zend_ast_alloc(size_t size TSRMLS_DC) { + return zend_arena_alloc(&CG(ast_arena), size); } -ZEND_API zend_ast* zend_ast_create_unary(uint kind, zend_ast *op0) -{ - zend_ast *ast = emalloc(sizeof(zend_ast)); +static inline void *zend_ast_realloc(void *old, size_t old_size, size_t new_size TSRMLS_DC) { + void *new = zend_ast_alloc(new_size TSRMLS_CC); + memcpy(new, old, old_size); + return new; +} + +static inline size_t zend_ast_size(uint32_t children) { + return sizeof(zend_ast) - sizeof(zend_ast *) + sizeof(zend_ast *) * children; +} + +static inline size_t zend_ast_list_size(uint32_t children) { + return sizeof(zend_ast_list) - sizeof(zend_ast *) + sizeof(zend_ast *) * children; +} + +ZEND_API zend_ast *zend_ast_create_znode(znode *node) { + TSRMLS_FETCH(); + zend_ast_znode *ast = zend_ast_alloc(sizeof(zend_ast_znode) TSRMLS_CC); + ast->kind = ZEND_AST_ZNODE; + ast->attr = 0; + ast->lineno = CG(zend_lineno); + ast->node = *node; + return (zend_ast *) ast; +} + +ZEND_API zend_ast *zend_ast_create_zval_ex(zval *zv, zend_ast_attr attr) { + TSRMLS_FETCH(); + zend_ast_zval *ast = zend_ast_alloc(sizeof(zend_ast_zval) TSRMLS_CC); + ast->kind = ZEND_AST_ZVAL; + ast->attr = attr; + ZVAL_COPY_VALUE(&ast->val, zv); + ast->val.u2.lineno = CG(zend_lineno); + return (zend_ast *) ast; +} + +ZEND_API zend_ast *zend_ast_create_decl( + zend_ast_kind kind, uint32_t flags, uint32_t start_lineno, zend_string *doc_comment, + zend_string *name, zend_ast *child0, zend_ast *child1, zend_ast *child2 +) { + TSRMLS_FETCH(); + zend_ast_decl *ast = zend_ast_alloc(sizeof(zend_ast_decl) TSRMLS_CC); + ast->kind = kind; - ast->children = 1; - (&ast->u.child)[0] = op0; - return ast; + ast->attr = 0; + ast->start_lineno = start_lineno; + ast->end_lineno = CG(zend_lineno); + ast->flags = flags; + ast->lex_pos = LANG_SCNG(yy_text); + ast->doc_comment = doc_comment; + ast->name = name; + ast->child[0] = child0; + ast->child[1] = child1; + ast->child[2] = child2; + + return (zend_ast *) ast; } -ZEND_API zend_ast* zend_ast_create_binary(uint kind, zend_ast *op0, zend_ast *op1) -{ - zend_ast *ast = emalloc(sizeof(zend_ast) + sizeof(zend_ast*)); +static zend_ast *zend_ast_create_from_va_list(zend_ast_kind kind, zend_ast_attr attr, va_list va) { + TSRMLS_FETCH(); + uint32_t i, children = kind >> ZEND_AST_NUM_CHILDREN_SHIFT; + zend_ast *ast = zend_ast_alloc(zend_ast_size(children) TSRMLS_CC); ast->kind = kind; - ast->children = 2; - (&ast->u.child)[0] = op0; - (&ast->u.child)[1] = op1; + ast->attr = attr; + ast->lineno = (uint32_t) -1; + + for (i = 0; i < children; ++i) { + ast->child[i] = va_arg(va, zend_ast *); + if (ast->child[i] != NULL) { + uint32_t lineno = zend_ast_get_lineno(ast->child[i]); + if (lineno < ast->lineno) { + ast->lineno = lineno; + } + } + } + + if (ast->lineno == UINT_MAX) { + ast->lineno = CG(zend_lineno); + } + return ast; } -ZEND_API zend_ast* zend_ast_create_ternary(uint kind, zend_ast *op0, zend_ast *op1, zend_ast *op2) -{ - zend_ast *ast = emalloc(sizeof(zend_ast) + sizeof(zend_ast*) * 2); - ast->kind = kind; - ast->children = 3; - (&ast->u.child)[0] = op0; - (&ast->u.child)[1] = op1; - (&ast->u.child)[2] = op2; +ZEND_API zend_ast *zend_ast_create_ex(zend_ast_kind kind, zend_ast_attr attr, ...) { + va_list va; + zend_ast *ast; + + va_start(va, attr); + ast = zend_ast_create_from_va_list(kind, attr, va); + va_end(va); + return ast; } -ZEND_API zend_ast* zend_ast_create_dynamic(uint kind) -{ - zend_ast *ast = emalloc(sizeof(zend_ast) + sizeof(zend_ast*) * 3); /* use 4 children as deafult */ - ast->kind = kind; - ast->children = 0; +ZEND_API zend_ast *zend_ast_create(zend_ast_kind kind, ...) { + va_list va; + zend_ast *ast; + + va_start(va, kind); + ast = zend_ast_create_from_va_list(kind, 0, va); + va_end(va); + return ast; } -ZEND_API void zend_ast_dynamic_add(zend_ast **ast, zend_ast *op) -{ - if ((*ast)->children >= 4 && (*ast)->children == ((*ast)->children & -(*ast)->children)) { - *ast = erealloc(*ast, sizeof(zend_ast) + sizeof(zend_ast*) * ((*ast)->children * 2 + 1)); +ZEND_API zend_ast_list *zend_ast_create_list(uint32_t init_children, zend_ast_kind kind, ...) { + TSRMLS_FETCH(); + zend_ast_list *list = zend_ast_alloc(zend_ast_list_size(4) TSRMLS_CC); + list->kind = kind; + list->attr = 0; + list->lineno = CG(zend_lineno); + list->children = 0; + + { + va_list va; + uint32_t i; + va_start(va, kind); + for (i = 0; i < init_children; ++i) { + list = zend_ast_list_add(list, va_arg(va, zend_ast *)); + } + va_end(va); } - (&(*ast)->u.child)[(*ast)->children++] = op; -} -ZEND_API void zend_ast_dynamic_shrink(zend_ast **ast) -{ - *ast = erealloc(*ast, sizeof(zend_ast) + sizeof(zend_ast*) * ((*ast)->children - 1)); + return list; } -ZEND_API int zend_ast_is_ct_constant(zend_ast *ast) -{ - int i; +static inline zend_bool is_power_of_two(uint32_t n) { + return n == (n & -n); +} - if (ast->kind == ZEND_CONST) { - return !Z_CONSTANT(ast->u.val); - } else { - for (i = 0; i < ast->children; i++) { - if ((&ast->u.child)[i]) { - if (!zend_ast_is_ct_constant((&ast->u.child)[i])) { - return 0; - } - } - } - return 1; +ZEND_API zend_ast_list *zend_ast_list_add(zend_ast_list *list, zend_ast *op) { + if (list->children >= 4 && is_power_of_two(list->children)) { + TSRMLS_FETCH(); + list = zend_ast_realloc(list, + zend_ast_list_size(list->children), zend_ast_list_size(list->children * 2) TSRMLS_CC); } + list->child[list->children++] = op; + return list; } static void zend_ast_add_array_element(zval *result, zval *offset, zval *expr TSRMLS_DC) @@ -137,167 +201,58 @@ ZEND_API void zend_ast_evaluate(zval *result, zend_ast *ast, zend_class_entry *s zval op1, op2; switch (ast->kind) { - case ZEND_ADD: - zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC); - zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC); - add_function(result, &op1, &op2 TSRMLS_CC); - zval_dtor(&op1); - zval_dtor(&op2); - break; - case ZEND_SUB: - zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC); - zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC); - sub_function(result, &op1, &op2 TSRMLS_CC); - zval_dtor(&op1); - zval_dtor(&op2); - break; - case ZEND_MUL: - zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC); - zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC); - mul_function(result, &op1, &op2 TSRMLS_CC); - zval_dtor(&op1); - zval_dtor(&op2); - break; - case ZEND_POW: - zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC); - zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC); - pow_function(result, &op1, &op2 TSRMLS_CC); - zval_dtor(&op1); - zval_dtor(&op2); - break; - case ZEND_DIV: - zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC); - zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC); - div_function(result, &op1, &op2 TSRMLS_CC); - zval_dtor(&op1); - zval_dtor(&op2); - break; - case ZEND_MOD: - zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC); - zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC); - mod_function(result, &op1, &op2 TSRMLS_CC); - zval_dtor(&op1); - zval_dtor(&op2); - break; - case ZEND_SL: - zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC); - zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC); - shift_left_function(result, &op1, &op2 TSRMLS_CC); - zval_dtor(&op1); - zval_dtor(&op2); - break; - case ZEND_SR: - zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC); - zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC); - shift_right_function(result, &op1, &op2 TSRMLS_CC); - zval_dtor(&op1); - zval_dtor(&op2); - break; - case ZEND_CONCAT: - zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC); - zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC); - concat_function(result, &op1, &op2 TSRMLS_CC); - zval_dtor(&op1); - zval_dtor(&op2); - break; - case ZEND_BW_OR: - zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC); - zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC); - bitwise_or_function(result, &op1, &op2 TSRMLS_CC); - zval_dtor(&op1); - zval_dtor(&op2); - break; - case ZEND_BW_AND: - zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC); - zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC); - bitwise_and_function(result, &op1, &op2 TSRMLS_CC); - zval_dtor(&op1); - zval_dtor(&op2); - break; - case ZEND_BW_XOR: - zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC); - zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC); - bitwise_xor_function(result, &op1, &op2 TSRMLS_CC); - zval_dtor(&op1); - zval_dtor(&op2); - break; - case ZEND_BW_NOT: - zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC); - bitwise_not_function(result, &op1 TSRMLS_CC); - zval_dtor(&op1); - break; - case ZEND_BOOL_NOT: - zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC); - boolean_not_function(result, &op1 TSRMLS_CC); - zval_dtor(&op1); - break; - case ZEND_BOOL_XOR: - zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC); - zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC); - boolean_xor_function(result, &op1, &op2 TSRMLS_CC); - zval_dtor(&op1); - zval_dtor(&op2); - break; - case ZEND_IS_IDENTICAL: - zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC); - zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC); - is_identical_function(result, &op1, &op2 TSRMLS_CC); - zval_dtor(&op1); - zval_dtor(&op2); - break; - case ZEND_IS_NOT_IDENTICAL: - zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC); - zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC); - is_not_identical_function(result, &op1, &op2 TSRMLS_CC); - zval_dtor(&op1); - zval_dtor(&op2); - break; - case ZEND_IS_EQUAL: - zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC); - zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC); - is_equal_function(result, &op1, &op2 TSRMLS_CC); - zval_dtor(&op1); - zval_dtor(&op2); - break; - case ZEND_IS_NOT_EQUAL: - zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC); - zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC); - is_not_equal_function(result, &op1, &op2 TSRMLS_CC); + case ZEND_AST_BINARY_OP: + { + binary_op_type op = get_binary_op(ast->attr); + zend_ast_evaluate(&op1, ast->child[0], scope TSRMLS_CC); + zend_ast_evaluate(&op2, ast->child[1], scope TSRMLS_CC); + op(result, &op1, &op2 TSRMLS_CC); zval_dtor(&op1); zval_dtor(&op2); break; - case ZEND_IS_SMALLER: - zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC); - zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC); - is_smaller_function(result, &op1, &op2 TSRMLS_CC); + } + case ZEND_AST_GREATER: + case ZEND_AST_GREATER_EQUAL: + { + /* op1 > op2 is the same as op2 < op1 */ + binary_op_type op = ast->kind == ZEND_AST_GREATER + ? is_smaller_function : is_smaller_or_equal_function; + zend_ast_evaluate(&op1, ast->child[0], scope TSRMLS_CC); + zend_ast_evaluate(&op2, ast->child[1], scope TSRMLS_CC); + op(result, &op2, &op1 TSRMLS_CC); zval_dtor(&op1); zval_dtor(&op2); break; - case ZEND_IS_SMALLER_OR_EQUAL: - zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC); - zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC); - is_smaller_or_equal_function(result, &op1, &op2 TSRMLS_CC); + } + case ZEND_AST_UNARY_OP: + { + unary_op_type op = get_unary_op(ast->attr); + zend_ast_evaluate(&op1, ast->child[0], scope TSRMLS_CC); + op(result, &op1 TSRMLS_CC); zval_dtor(&op1); - zval_dtor(&op2); break; - case ZEND_CONST: - /* class constants may be updated in-place */ + } + case ZEND_AST_ZVAL: + { + zval *zv = zend_ast_get_zval(ast); if (scope) { - if (Z_OPT_CONSTANT(ast->u.val)) { - zval_update_constant_ex(&ast->u.val, 1, scope TSRMLS_CC); + /* class constants may be updated in-place */ + if (Z_OPT_CONSTANT_P(zv)) { + zval_update_constant_ex(zv, 1, scope TSRMLS_CC); } - ZVAL_DUP(result, &ast->u.val); + ZVAL_DUP(result, zv); } else { - ZVAL_DUP(result, &ast->u.val); + ZVAL_DUP(result, zv); if (Z_OPT_CONSTANT_P(result)) { zval_update_constant_ex(result, 1, scope TSRMLS_CC); } } break; - case ZEND_BOOL_AND: - zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC); + } + case ZEND_AST_AND: + zend_ast_evaluate(&op1, ast->child[0], scope TSRMLS_CC); if (zend_is_true(&op1 TSRMLS_CC)) { - zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC); + zend_ast_evaluate(&op2, ast->child[1], scope TSRMLS_CC); ZVAL_BOOL(result, zend_is_true(&op2 TSRMLS_CC)); zval_dtor(&op2); } else { @@ -305,61 +260,63 @@ ZEND_API void zend_ast_evaluate(zval *result, zend_ast *ast, zend_class_entry *s } zval_dtor(&op1); break; - case ZEND_BOOL_OR: - zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC); + case ZEND_AST_OR: + zend_ast_evaluate(&op1, ast->child[0], scope TSRMLS_CC); if (zend_is_true(&op1 TSRMLS_CC)) { ZVAL_BOOL(result, 1); } else { - zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC); + zend_ast_evaluate(&op2, ast->child[1], scope TSRMLS_CC); ZVAL_BOOL(result, zend_is_true(&op2 TSRMLS_CC)); zval_dtor(&op2); } zval_dtor(&op1); break; - case ZEND_SELECT: - zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC); + case ZEND_AST_CONDITIONAL: + zend_ast_evaluate(&op1, ast->child[0], scope TSRMLS_CC); if (zend_is_true(&op1 TSRMLS_CC)) { - if (!(&ast->u.child)[1]) { + if (!ast->child[1]) { *result = op1; } else { - zend_ast_evaluate(result, (&ast->u.child)[1], scope TSRMLS_CC); + zend_ast_evaluate(result, ast->child[1], scope TSRMLS_CC); zval_dtor(&op1); } } else { - zend_ast_evaluate(result, (&ast->u.child)[2], scope TSRMLS_CC); + zend_ast_evaluate(result, ast->child[2], scope TSRMLS_CC); zval_dtor(&op1); } break; - case ZEND_UNARY_PLUS: + case ZEND_AST_UNARY_PLUS: ZVAL_LONG(&op1, 0); - zend_ast_evaluate(&op2, (&ast->u.child)[0], scope TSRMLS_CC); + zend_ast_evaluate(&op2, ast->child[0], scope TSRMLS_CC); add_function(result, &op1, &op2 TSRMLS_CC); zval_dtor(&op2); break; - case ZEND_UNARY_MINUS: + case ZEND_AST_UNARY_MINUS: ZVAL_LONG(&op1, 0); - zend_ast_evaluate(&op2, (&ast->u.child)[0], scope TSRMLS_CC); + zend_ast_evaluate(&op2, ast->child[0], scope TSRMLS_CC); sub_function(result, &op1, &op2 TSRMLS_CC); zval_dtor(&op2); break; - case ZEND_INIT_ARRAY: + case ZEND_AST_ARRAY: array_init(result); { - int i; - for (i = 0; i < ast->children; i+=2) { - if ((&ast->u.child)[i]) { - zend_ast_evaluate(&op1, (&ast->u.child)[i], scope TSRMLS_CC); + uint32_t i; + zend_ast_list *list = zend_ast_get_list(ast); + for (i = 0; i < list->children; i++) { + zend_ast *elem = list->child[i]; + if (elem->child[1]) { + zend_ast_evaluate(&op1, elem->child[1], scope TSRMLS_CC); } else { ZVAL_UNDEF(&op1); } - zend_ast_evaluate(&op2, (&ast->u.child)[i+1], scope TSRMLS_CC); + zend_ast_evaluate(&op2, elem->child[0], scope TSRMLS_CC); zend_ast_add_array_element(result, &op1, &op2 TSRMLS_CC); } } break; - case ZEND_FETCH_DIM_R: - zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC); - zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC); + case ZEND_AST_DIM: + zend_ast_evaluate(&op1, ast->child[0], scope TSRMLS_CC); + zend_ast_evaluate(&op2, ast->child[1], scope TSRMLS_CC); { zval tmp; zend_fetch_dimension_by_zval(&tmp, &op1, &op2 TSRMLS_CC); @@ -377,35 +334,105 @@ ZEND_API zend_ast *zend_ast_copy(zend_ast *ast) { if (ast == NULL) { return NULL; - } else if (ast->kind == ZEND_CONST) { - zend_ast *copy = zend_ast_create_constant(&ast->u.val); - zval_copy_ctor(©->u.val); - return copy; - } else if (ast->children) { - zend_ast *new = emalloc(sizeof(zend_ast) + sizeof(zend_ast*) * (ast->children - 1)); - int i; + } else if (ast->kind == ZEND_AST_ZVAL) { + zend_ast_zval *new = emalloc(sizeof(zend_ast_zval)); + new->kind = ZEND_AST_ZVAL; + new->attr = ast->attr; + ZVAL_COPY(&new->val, zend_ast_get_zval(ast)); + return (zend_ast *) new; + } else if (zend_ast_is_list(ast)) { + zend_ast_list *list = zend_ast_get_list(ast); + zend_ast_list *new = emalloc(zend_ast_list_size(list->children)); + uint32_t i; + new->kind = list->kind; + new->attr = list->attr; + new->children = list->children; + for (i = 0; i < list->children; i++) { + new->child[i] = zend_ast_copy(list->child[i]); + } + return (zend_ast *) new; + } else { + uint32_t i, children = zend_ast_get_num_children(ast); + zend_ast *new = emalloc(zend_ast_size(children)); new->kind = ast->kind; - new->children = ast->children; - for (i = 0; i < ast->children; i++) { - (&new->u.child)[i] = zend_ast_copy((&ast->u.child)[i]); + new->attr = ast->attr; + for (i = 0; i < children; i++) { + new->child[i] = zend_ast_copy(ast->child[i]); } return new; } - return zend_ast_create_dynamic(ast->kind); } -ZEND_API void zend_ast_destroy(zend_ast *ast) -{ - int i; +static void zend_ast_destroy_ex(zend_ast *ast, zend_bool free) { + if (!ast) { + return; + } - if (ast->kind == ZEND_CONST) { - zval_dtor(&ast->u.val); - } else { - for (i = 0; i < ast->children; i++) { - if ((&ast->u.child)[i]) { - zend_ast_destroy((&ast->u.child)[i]); + switch (ast->kind) { + case ZEND_AST_ZVAL: + { + /* Destroy value without using GC: When opcache moves arrays into SHM it will + * free the zend_array structure, so references to it from outside the op array + * become invalid. GC would cause such a reference in the root buffer. */ + zval *zv = zend_ast_get_zval(ast); + if (Z_REFCOUNTED_P(zv) && !Z_DELREF_P(zv)) { + _zval_dtor_func_for_ptr(Z_COUNTED_P(zv) ZEND_FILE_LINE_CC); + } + break; + } + case ZEND_AST_FUNC_DECL: + case ZEND_AST_CLOSURE: + case ZEND_AST_METHOD: + case ZEND_AST_CLASS: + { + zend_ast_decl *decl = (zend_ast_decl *) ast; + zend_string_release(decl->name); + if (decl->doc_comment) { + zend_string_release(decl->doc_comment); + } + zend_ast_destroy_ex(decl->child[0], free); + zend_ast_destroy_ex(decl->child[1], free); + zend_ast_destroy_ex(decl->child[2], free); + break; + } + default: + if (zend_ast_is_list(ast)) { + zend_ast_list *list = zend_ast_get_list(ast); + uint32_t i; + for (i = 0; i < list->children; i++) { + zend_ast_destroy_ex(list->child[i], free); + } + } else { + uint32_t i, children = zend_ast_get_num_children(ast); + for (i = 0; i < children; i++) { + zend_ast_destroy_ex(ast->child[i], free); + } } + } + + if (free) { + efree(ast); + } +} + +ZEND_API void zend_ast_destroy(zend_ast *ast) { + zend_ast_destroy_ex(ast, 0); +} +ZEND_API void zend_ast_destroy_and_free(zend_ast *ast) { + zend_ast_destroy_ex(ast, 1); +} + +ZEND_API void zend_ast_apply(zend_ast *ast, zend_ast_apply_func fn TSRMLS_DC) { + if (zend_ast_is_list(ast)) { + zend_ast_list *list = zend_ast_get_list(ast); + uint32_t i; + for (i = 0; i < list->children; ++i) { + fn(&list->child[i] TSRMLS_CC); + } + } else { + uint32_t i, children = zend_ast_get_num_children(ast); + for (i = 0; i < children; ++i) { + fn(&ast->child[i] TSRMLS_CC); } } - efree(ast); } diff --git a/Zend/zend_ast.h b/Zend/zend_ast.h index 8678299f0f..24d2aa6308 100644 --- a/Zend/zend_ast.h +++ b/Zend/zend_ast.h @@ -14,6 +14,7 @@ +----------------------------------------------------------------------+ | Authors: Bob Weinand <bwoebi@php.net> | | Dmitry Stogov <dmitry@zend.com> | + | Nikita Popov <nikic@php.net> | +----------------------------------------------------------------------+ */ @@ -24,39 +25,239 @@ #include "zend.h" -typedef enum _zend_ast_kind { - /* first 256 kinds are reserved for opcodes */ - ZEND_CONST = 256, - ZEND_BOOL_AND, - ZEND_BOOL_OR, - ZEND_SELECT, - ZEND_UNARY_PLUS, - ZEND_UNARY_MINUS, -} zend_ast_kind; +#define ZEND_AST_SPECIAL_SHIFT 6 +#define ZEND_AST_IS_LIST_SHIFT 7 +#define ZEND_AST_NUM_CHILDREN_SHIFT 8 + +enum _zend_ast_kind { + /* special nodes */ + ZEND_AST_ZVAL = 1 << ZEND_AST_SPECIAL_SHIFT, + ZEND_AST_ZNODE, + + /* declaration nodes */ + ZEND_AST_FUNC_DECL, + ZEND_AST_CLOSURE, + ZEND_AST_METHOD, + ZEND_AST_CLASS, + + /* list nodes */ + ZEND_AST_ARG_LIST = 1 << ZEND_AST_IS_LIST_SHIFT, + ZEND_AST_LIST, + ZEND_AST_ARRAY, + ZEND_AST_ENCAPS_LIST, + ZEND_AST_EXPR_LIST, + ZEND_AST_STMT_LIST, + ZEND_AST_IF, + ZEND_AST_SWITCH_LIST, + ZEND_AST_CATCH_LIST, + ZEND_AST_PARAM_LIST, + ZEND_AST_CLOSURE_USES, + ZEND_AST_PROP_DECL, + ZEND_AST_CONST_DECL, + ZEND_AST_CLASS_CONST_DECL, + ZEND_AST_NAME_LIST, + ZEND_AST_TRAIT_ADAPTATIONS, + ZEND_AST_USE, + + /* 0 child nodes */ + ZEND_AST_MAGIC_CONST = 0 << ZEND_AST_NUM_CHILDREN_SHIFT, + ZEND_AST_TYPE, + + /* 1 child node */ + ZEND_AST_VAR = 1 << ZEND_AST_NUM_CHILDREN_SHIFT, + ZEND_AST_CONST, + ZEND_AST_RESOLVE_CLASS_NAME, + ZEND_AST_UNPACK, + ZEND_AST_UNARY_PLUS, + ZEND_AST_UNARY_MINUS, + ZEND_AST_CAST, + ZEND_AST_EMPTY, + ZEND_AST_ISSET, + ZEND_AST_SILENCE, + ZEND_AST_SHELL_EXEC, + ZEND_AST_CLONE, + ZEND_AST_EXIT, + ZEND_AST_PRINT, + ZEND_AST_INCLUDE_OR_EVAL, + ZEND_AST_UNARY_OP, + ZEND_AST_PRE_INC, + ZEND_AST_PRE_DEC, + ZEND_AST_POST_INC, + ZEND_AST_POST_DEC, + + ZEND_AST_GLOBAL, + ZEND_AST_UNSET, + ZEND_AST_RETURN, + ZEND_AST_LABEL, + ZEND_AST_REF, + ZEND_AST_HALT_COMPILER, + ZEND_AST_ECHO, + ZEND_AST_THROW, + ZEND_AST_GOTO, + ZEND_AST_BREAK, + ZEND_AST_CONTINUE, + + /* 2 child nodes */ + ZEND_AST_DIM = 2 << ZEND_AST_NUM_CHILDREN_SHIFT, + ZEND_AST_PROP, + ZEND_AST_STATIC_PROP, + ZEND_AST_CALL, + ZEND_AST_CLASS_CONST, + ZEND_AST_ASSIGN, + ZEND_AST_ASSIGN_REF, + ZEND_AST_ASSIGN_OP, + ZEND_AST_BINARY_OP, + ZEND_AST_GREATER, + ZEND_AST_GREATER_EQUAL, + ZEND_AST_AND, + ZEND_AST_OR, + ZEND_AST_ARRAY_ELEM, + ZEND_AST_NEW, + ZEND_AST_INSTANCEOF, + ZEND_AST_YIELD, + + ZEND_AST_STATIC, + ZEND_AST_WHILE, + ZEND_AST_DO_WHILE, + ZEND_AST_IF_ELEM, + ZEND_AST_SWITCH, + ZEND_AST_SWITCH_CASE, + ZEND_AST_DECLARE, + ZEND_AST_PROP_ELEM, + ZEND_AST_CONST_ELEM, + ZEND_AST_USE_TRAIT, + ZEND_AST_TRAIT_PRECEDENCE, + ZEND_AST_METHOD_REFERENCE, + ZEND_AST_NAMESPACE, + ZEND_AST_USE_ELEM, + ZEND_AST_TRAIT_ALIAS, + + /* 3 child nodes */ + ZEND_AST_METHOD_CALL = 3 << ZEND_AST_NUM_CHILDREN_SHIFT, + ZEND_AST_STATIC_CALL, + ZEND_AST_CONDITIONAL, + + ZEND_AST_TRY, + ZEND_AST_CATCH, + ZEND_AST_PARAM, + + /* 4 child nodes */ + ZEND_AST_FOR = 4 << ZEND_AST_NUM_CHILDREN_SHIFT, + ZEND_AST_FOREACH, +}; + +typedef uint16_t zend_ast_kind; +typedef uint16_t zend_ast_attr; struct _zend_ast { - unsigned short kind; - unsigned short children; - union { - zval val; - zend_ast *child; - } u; + zend_ast_kind kind; /* Type of the node (ZEND_AST_* enum constant) */ + zend_ast_attr attr; /* Additional attribute, use depending on node type */ + uint32_t lineno; /* Line number */ + zend_ast *child[1]; /* Array of children (using struct hack) */ }; -ZEND_API zend_ast *zend_ast_create_constant(zval *zv); +/* Same as zend_ast, but with children count, which is updated dynamically */ +typedef struct _zend_ast_list { + zend_ast_kind kind; + zend_ast_attr attr; + uint32_t lineno; + uint32_t children; + zend_ast *child[1]; +} zend_ast_list; + +/* Lineno is stored in val.u2.lineno */ +typedef struct _zend_ast_zval { + zend_ast_kind kind; + zend_ast_attr attr; + zval val; +} zend_ast_zval; + +/* Separate structure for function and class declaration, as they need extra information. */ +typedef struct _zend_ast_decl { + zend_ast_kind kind; + zend_ast_attr attr; /* Unused - for structure compatibility */ + uint32_t start_lineno; + uint32_t end_lineno; + uint32_t flags; + unsigned char *lex_pos; + zend_string *doc_comment; + zend_string *name; + zend_ast *child[3]; +} zend_ast_decl; -ZEND_API zend_ast *zend_ast_create_unary(uint kind, zend_ast *op0); -ZEND_API zend_ast *zend_ast_create_binary(uint kind, zend_ast *op0, zend_ast *op1); -ZEND_API zend_ast *zend_ast_create_ternary(uint kind, zend_ast *op0, zend_ast *op1, zend_ast *op2); -ZEND_API zend_ast* zend_ast_create_dynamic(uint kind); -ZEND_API void zend_ast_dynamic_add(zend_ast **ast, zend_ast *op); -ZEND_API void zend_ast_dynamic_shrink(zend_ast **ast); +ZEND_API zend_ast *zend_ast_create_zval_ex(zval *zv, zend_ast_attr attr); -ZEND_API int zend_ast_is_ct_constant(zend_ast *ast); +ZEND_API zend_ast *zend_ast_create_ex(zend_ast_kind kind, zend_ast_attr attr, ...); +ZEND_API zend_ast *zend_ast_create(zend_ast_kind kind, ...); + +ZEND_API zend_ast *zend_ast_create_decl( + zend_ast_kind kind, uint32_t flags, uint32_t start_lineno, zend_string *doc_comment, + zend_string *name, zend_ast *child0, zend_ast *child1, zend_ast *child2 +); + +ZEND_API zend_ast_list *zend_ast_create_list(uint32_t init_children, zend_ast_kind kind, ...); +ZEND_API zend_ast_list *zend_ast_list_add(zend_ast_list *list, zend_ast *op); ZEND_API void zend_ast_evaluate(zval *result, zend_ast *ast, zend_class_entry *scope TSRMLS_DC); ZEND_API zend_ast *zend_ast_copy(zend_ast *ast); ZEND_API void zend_ast_destroy(zend_ast *ast); +ZEND_API void zend_ast_destroy_and_free(zend_ast *ast); + +typedef void (*zend_ast_apply_func)(zend_ast **ast_ptr TSRMLS_DC); +ZEND_API void zend_ast_apply(zend_ast *ast, zend_ast_apply_func fn TSRMLS_DC); + +static inline zend_bool zend_ast_is_list(zend_ast *ast) { + return (ast->kind >> ZEND_AST_IS_LIST_SHIFT) & 1; +} +static inline zend_ast_list *zend_ast_get_list(zend_ast *ast) { + ZEND_ASSERT(zend_ast_is_list(ast)); + return (zend_ast_list *) ast; +} + +static inline zval *zend_ast_get_zval(zend_ast *ast) { + ZEND_ASSERT(ast->kind == ZEND_AST_ZVAL); + return &((zend_ast_zval *) ast)->val; +} +static inline zend_string *zend_ast_get_str(zend_ast *ast) { + return Z_STR_P(zend_ast_get_zval(ast)); +} + +static inline uint32_t zend_ast_get_num_children(zend_ast *ast) { + ZEND_ASSERT(!zend_ast_is_list(ast)); + return ast->kind >> ZEND_AST_NUM_CHILDREN_SHIFT; +} +static inline uint32_t zend_ast_get_lineno(zend_ast *ast) { + if (ast->kind == ZEND_AST_ZVAL) { + zval *zv = zend_ast_get_zval(ast); + return zv->u2.lineno; + } else { + return ast->lineno; + } +} + +static inline zend_ast *zend_ast_create_zval(zval *zv) { + return zend_ast_create_zval_ex(zv, 0); +} +static inline zend_ast *zend_ast_create_zval_from_str(zend_string *str) { + zval zv; + ZVAL_STR(&zv, str); + return zend_ast_create_zval(&zv); +} +static inline zend_ast *zend_ast_create_zval_from_long(zend_long lval) { + zval zv; + ZVAL_LONG(&zv, lval); + return zend_ast_create_zval(&zv); +} + +static inline zend_ast *zend_ast_create_binary_op(uint32_t opcode, zend_ast *op0, zend_ast *op1) { + return zend_ast_create_ex(ZEND_AST_BINARY_OP, opcode, op0, op1); +} +static inline zend_ast *zend_ast_create_assign_op(uint32_t opcode, zend_ast *op0, zend_ast *op1) { + return zend_ast_create_ex(ZEND_AST_ASSIGN_OP, opcode, op0, op1); +} +static inline zend_ast *zend_ast_create_cast(uint32_t type, zend_ast *op0) { + return zend_ast_create_ex(ZEND_AST_CAST, type, op0); +} #endif diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index a37ca45265..4a4afa2de6 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -14,6 +14,7 @@ +----------------------------------------------------------------------+ | Authors: Andi Gutmans <andi@zend.com> | | Zeev Suraski <zeev@zend.com> | + | Nikita Popov <nikic@php.net> | +----------------------------------------------------------------------+ */ @@ -51,7 +52,6 @@ (target)->u.constant = CONSTANT(src.constant); \ } else { \ (target)->u.op = src; \ - (target)->EA = 0; \ } \ } while (0) @@ -60,34 +60,29 @@ target = src; \ } while (0) -#define GET_CACHE_SLOT(literal) do { \ - Z_CACHE_SLOT(CG(active_op_array)->literals[literal]) = CG(active_op_array)->last_cache_slot++; \ - if ((CG(active_op_array)->fn_flags & ZEND_ACC_INTERACTIVE) && CG(active_op_array)->run_time_cache) { \ - CG(active_op_array)->run_time_cache = erealloc(CG(active_op_array)->run_time_cache, CG(active_op_array)->last_cache_slot * sizeof(void*)); \ - CG(active_op_array)->run_time_cache[CG(active_op_array)->last_cache_slot - 1] = NULL; \ - } \ - } while (0) +static inline void zend_alloc_cache_slot(uint32_t literal TSRMLS_DC) { + zend_op_array *op_array = CG(active_op_array); + Z_CACHE_SLOT(op_array->literals[literal]) = op_array->last_cache_slot++; + if ((op_array->fn_flags & ZEND_ACC_INTERACTIVE) && op_array->run_time_cache) { + op_array->run_time_cache = erealloc(op_array->run_time_cache, + op_array->last_cache_slot * sizeof(void*)); + op_array->run_time_cache[CG(active_op_array)->last_cache_slot - 1] = NULL; + } +} #define POLYMORPHIC_CACHE_SLOT_SIZE 2 -#define GET_POLYMORPHIC_CACHE_SLOT(literal) do { \ - Z_CACHE_SLOT(CG(active_op_array)->literals[literal]) = CG(active_op_array)->last_cache_slot; \ - CG(active_op_array)->last_cache_slot += POLYMORPHIC_CACHE_SLOT_SIZE; \ - if ((CG(active_op_array)->fn_flags & ZEND_ACC_INTERACTIVE) && CG(active_op_array)->run_time_cache) { \ - CG(active_op_array)->run_time_cache = erealloc(CG(active_op_array)->run_time_cache, CG(active_op_array)->last_cache_slot * sizeof(void*)); \ - CG(active_op_array)->run_time_cache[CG(active_op_array)->last_cache_slot - 1] = NULL; \ - CG(active_op_array)->run_time_cache[CG(active_op_array)->last_cache_slot - 2] = NULL; \ - } \ - } while (0) - -#define FREE_POLYMORPHIC_CACHE_SLOT(literal) do { \ - if (Z_CACHE_SLOT(CG(active_op_array)->literals[literal]) != -1 && \ - Z_CACHE_SLOT(CG(active_op_array)->literals[literal]) == \ - CG(active_op_array)->last_cache_slot - POLYMORPHIC_CACHE_SLOT_SIZE) { \ - Z_CACHE_SLOT(CG(active_op_array)->literals[literal]) = -1; \ - CG(active_op_array)->last_cache_slot -= POLYMORPHIC_CACHE_SLOT_SIZE; \ - } \ - } while (0) +static inline void zend_alloc_polymorphic_cache_slot(uint32_t literal TSRMLS_DC) { + zend_op_array *op_array = CG(active_op_array); + Z_CACHE_SLOT(op_array->literals[literal]) = op_array->last_cache_slot; + op_array->last_cache_slot += POLYMORPHIC_CACHE_SLOT_SIZE; + if ((op_array->fn_flags & ZEND_ACC_INTERACTIVE) && op_array->run_time_cache) { + op_array->run_time_cache = erealloc( + op_array->run_time_cache, op_array->last_cache_slot * sizeof(void *)); + op_array->run_time_cache[op_array->last_cache_slot - 1] = NULL; + op_array->run_time_cache[op_array->last_cache_slot - 2] = NULL; + } +} ZEND_API zend_op_array *(*zend_compile_file)(zend_file_handle *file_handle, int type TSRMLS_DC); ZEND_API zend_op_array *(*zend_compile_string)(zval *source_string, char *filename TSRMLS_DC); @@ -97,13 +92,6 @@ ZEND_API zend_compiler_globals compiler_globals; ZEND_API zend_executor_globals executor_globals; #endif -static void zend_push_function_call_entry(zend_function *fbc, uint32_t opline_num TSRMLS_DC) /* {{{ */ -{ - zend_function_call_entry fcall = { fbc, opline_num }; - zend_stack_push(&CG(function_call_stack), &fcall); -} -/* }}} */ - static zend_property_info *zend_duplicate_property_info(zend_property_info *property_info TSRMLS_DC) /* {{{ */ { zend_property_info* new_property_info; @@ -147,13 +135,27 @@ static void zend_destroy_property_info_internal(zval *zv) /* {{{ */ } /* }}} */ -static void build_runtime_defined_function_key(zval *result, const char *name, int name_length TSRMLS_DC) /* {{{ */ -{ +static zend_string *zend_new_interned_string_safe(zend_string *str TSRMLS_DC) { + zend_string *interned_str; + + zend_string_addref(str); + interned_str = zend_new_interned_string(str TSRMLS_CC); + if (str != interned_str) { + return interned_str; + } else { + zend_string_release(str); + return str; + } +} + +static zend_string *zend_build_runtime_definition_key( + zend_string *name, unsigned char *lex_pos TSRMLS_DC +) { + zend_string *result; char char_pos_buf[32]; - uint char_pos_len; - const char *filename; + size_t char_pos_len = zend_sprintf(char_pos_buf, "%p", lex_pos); - char_pos_len = zend_sprintf(char_pos_buf, "%p", LANG_SCNG(yy_text)); + const char *filename; if (CG(active_op_array)->filename) { filename = CG(active_op_array)->filename->val; } else { @@ -161,13 +163,12 @@ static void build_runtime_defined_function_key(zval *result, const char *name, i } /* NULL, name length, filename length, last accepting char position length */ - ZVAL_NEW_STR(result, zend_string_alloc(1+name_length+strlen(filename)+char_pos_len, 0)); + result = zend_string_alloc(1 + name->len + strlen(filename) + char_pos_len, 0); - /* must be binary safe */ - Z_STRVAL_P(result)[0] = '\0'; - sprintf(Z_STRVAL_P(result)+1, "%s%s%s", name, filename, char_pos_buf); + result->val[0] = '\0'; + sprintf(result->val + 1, "%s%s%s", name->val, filename, char_pos_buf); + return result; } -/* }}} */ static void init_compiler_declarables(TSRMLS_D) /* {{{ */ { @@ -189,19 +190,13 @@ void zend_init_compiler_context(TSRMLS_D) /* {{{ */ void zend_init_compiler_data_structures(TSRMLS_D) /* {{{ */ { - zend_stack_init(&CG(bp_stack), sizeof(zend_llist)); - zend_stack_init(&CG(function_call_stack), sizeof(zend_function_call_entry)); zend_stack_init(&CG(switch_cond_stack), sizeof(zend_switch_entry)); zend_stack_init(&CG(foreach_copy_stack), sizeof(zend_op)); - zend_stack_init(&CG(object_stack), sizeof(znode)); - zend_stack_init(&CG(declare_stack), sizeof(zend_declarables)); + zend_stack_init(&CG(delayed_oplines_stack), sizeof(zend_op)); CG(active_class_entry) = NULL; - zend_llist_init(&CG(list_llist), sizeof(list_llist_element), NULL, 0); - zend_llist_init(&CG(dimension_llist), sizeof(int), NULL, 0); - zend_stack_init(&CG(list_stack), sizeof(zend_llist)); CG(in_compilation) = 0; CG(start_lineno) = 0; - ZVAL_UNDEF(&CG(current_namespace)); + CG(current_namespace) = NULL; CG(in_namespace) = 0; CG(has_bracketed_namespaces) = 0; CG(current_import) = NULL; @@ -238,13 +233,9 @@ void init_compiler(TSRMLS_D) /* {{{ */ void shutdown_compiler(TSRMLS_D) /* {{{ */ { - zend_stack_destroy(&CG(bp_stack)); - zend_stack_destroy(&CG(function_call_stack)); zend_stack_destroy(&CG(switch_cond_stack)); zend_stack_destroy(&CG(foreach_copy_stack)); - zend_stack_destroy(&CG(object_stack)); - zend_stack_destroy(&CG(declare_stack)); - zend_stack_destroy(&CG(list_stack)); + zend_stack_destroy(&CG(delayed_oplines_stack)); zend_hash_destroy(&CG(filenames_table)); zend_hash_destroy(&CG(const_filenames)); zend_stack_destroy(&CG(context_stack)); @@ -429,32 +420,23 @@ static int zend_add_ns_func_name_literal(zend_op_array *op_array, zval *zv TSRML } /* }}} */ -static int zend_add_class_name_literal(zend_op_array *op_array, zval *zv TSRMLS_DC) /* {{{ */ -{ +static int zend_add_class_name_literal(zend_op_array *op_array, zend_string *name TSRMLS_DC) { int ret; zend_string *lc_name; - zval c; - if (op_array->last_literal > 0 && - &op_array->literals[op_array->last_literal - 1] == zv && - Z_CACHE_SLOT(op_array->literals[op_array->last_literal - 1]) == -1) { - /* we already have function name as last literal (do nothing) */ - ret = op_array->last_literal - 1; - } else { - ret = zend_add_literal(op_array, zv TSRMLS_CC); - } + zval zv; + ZVAL_STR(&zv, name); - if (Z_STRVAL_P(zv)[0] == '\\') { - lc_name = zend_string_alloc(Z_STRLEN_P(zv) - 1, 0); - zend_str_tolower_copy(lc_name->val, Z_STRVAL_P(zv) + 1, Z_STRLEN_P(zv) - 1); - } else { - lc_name = zend_string_alloc(Z_STRLEN_P(zv), 0); - zend_str_tolower_copy(lc_name->val, Z_STRVAL_P(zv), Z_STRLEN_P(zv)); - } - ZVAL_NEW_STR(&c, lc_name); - zend_add_literal(CG(active_op_array), &c TSRMLS_CC); + ret = zend_add_literal(op_array, &zv TSRMLS_CC); + name = Z_STR(zv); /* Load new name string in case it was interned */ + + lc_name = zend_string_alloc(name->len, 0); + zend_str_tolower_copy(lc_name->val, name->val, name->len); - GET_CACHE_SLOT(ret); + ZVAL_NEW_STR(&zv, lc_name); + zend_add_literal(CG(active_op_array), &zv TSRMLS_CC); + + zend_alloc_cache_slot(ret TSRMLS_CC); return ret; } @@ -537,511 +519,19 @@ static int zend_add_const_name_literal(zend_op_array *op_array, zval *zv, int un op.constant = zend_add_literal(CG(active_op_array), &_c TSRMLS_CC); \ } while (0) -#define LITERAL_STRINGL(op, str, len) do { \ - zval _c; \ - ZVAL_STRINGL(&_c, str, len); \ - op.constant = zend_add_literal(CG(active_op_array), &_c TSRMLS_CC); \ - } while (0) - -#define LITERAL_LONG(op, val) do { \ - zval _c; \ - ZVAL_LONG(&_c, val); \ - op.constant = zend_add_literal(CG(active_op_array), &_c TSRMLS_CC); \ - } while (0) - -#define LITERAL_LONG_EX(op_array, op, val) do { \ - zval _c; \ - ZVAL_LONG(&_c, val); \ - op.constant = zend_add_literal(op_array, &_c TSRMLS_CC); \ - } while (0) - -#define LITERAL_NULL(op) do { \ - zval _c; \ - ZVAL_NULL(&_c); \ - op.constant = zend_add_literal(CG(active_op_array), &_c TSRMLS_CC); \ - } while (0) - -static inline zend_bool zend_is_function_or_method_call(const znode *variable) /* {{{ */ -{ - uint32_t type = variable->EA; - - return ((type & ZEND_PARSED_METHOD_CALL) || (type == ZEND_PARSED_FUNCTION_CALL)); -} -/* }}} */ - -void zend_do_binary_op(zend_uchar op, znode *result, znode *op1, znode *op2 TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - opline->opcode = op; - opline->result_type = IS_TMP_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - SET_NODE(opline->op1, op1); - SET_NODE(opline->op2, op2); - GET_NODE(result, opline->result); -} -/* }}} */ - -void zend_do_unary_op(zend_uchar op, znode *result, znode *op1 TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - opline->opcode = op; - opline->result_type = IS_TMP_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - SET_NODE(opline->op1, op1); - GET_NODE(result, opline->result); - SET_UNUSED(opline->op2); -} -/* }}} */ - -#define MAKE_NOP(opline) { opline->opcode = ZEND_NOP; memset(&opline->result,0,sizeof(opline->result)); memset(&opline->op1,0,sizeof(opline->op1)); memset(&opline->op2,0,sizeof(opline->op2)); opline->result_type=opline->op1_type=opline->op2_type=IS_UNUSED; } - -static void zend_do_op_data(zend_op *data_op, znode *value TSRMLS_DC) /* {{{ */ -{ - data_op->opcode = ZEND_OP_DATA; - SET_NODE(data_op->op1, value); - SET_UNUSED(data_op->op2); -} -/* }}} */ - -void zend_do_binary_assign_op(zend_uchar op, znode *result, znode *op1, znode *op2 TSRMLS_DC) /* {{{ */ -{ - int last_op_number = get_next_op_number(CG(active_op_array)); - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - if (last_op_number > 0) { - zend_op *last_op = &CG(active_op_array)->opcodes[last_op_number-1]; - - switch (last_op->opcode) { - case ZEND_FETCH_OBJ_RW: - last_op->opcode = op; - last_op->extended_value = ZEND_ASSIGN_OBJ; - - zend_do_op_data(opline, op2 TSRMLS_CC); - SET_UNUSED(opline->result); - GET_NODE(result, last_op->result); - return; - case ZEND_FETCH_DIM_RW: - last_op->opcode = op; - last_op->extended_value = ZEND_ASSIGN_DIM; - - zend_do_op_data(opline, op2 TSRMLS_CC); - opline->op2.var = get_temporary_variable(CG(active_op_array)); - opline->op2_type = IS_VAR; - SET_UNUSED(opline->result); - GET_NODE(result,last_op->result); - return; - default: - break; - } - } - - opline->opcode = op; - SET_NODE(opline->op1, op1); - SET_NODE(opline->op2, op2); - opline->result_type = IS_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - GET_NODE(result, opline->result); -} -/* }}} */ - -void fetch_simple_variable_ex(znode *result, znode *varname, int bp, zend_uchar op TSRMLS_DC) /* {{{ */ -{ - zend_op opline; - zend_op *opline_ptr; - - if (varname->op_type == IS_CONST) { - if (Z_TYPE(varname->u.constant) != IS_STRING) { - convert_to_string(&varname->u.constant); - } - - if (!zend_is_auto_global(Z_STR(varname->u.constant) TSRMLS_CC) && - !(Z_STRLEN(varname->u.constant) == (sizeof("this")-1) && - !memcmp(Z_STRVAL(varname->u.constant), "this", sizeof("this") - 1)) && - (CG(active_op_array)->last == 0 || - CG(active_op_array)->opcodes[CG(active_op_array)->last-1].opcode != ZEND_BEGIN_SILENCE)) { - result->op_type = IS_CV; - result->u.op.var = lookup_cv(CG(active_op_array), Z_STR(varname->u.constant) TSRMLS_CC); - Z_STR(varname->u.constant) = CG(active_op_array)->vars[EX_VAR_TO_NUM(result->u.op.var)]; - result->EA = 0; - return; - } - } - - if (bp) { - opline_ptr = &opline; - init_op(opline_ptr TSRMLS_CC); - } else { - opline_ptr = get_next_op(CG(active_op_array) TSRMLS_CC); - } - - opline_ptr->opcode = op; - opline_ptr->result_type = IS_VAR; - opline_ptr->result.var = get_temporary_variable(CG(active_op_array)); - SET_NODE(opline_ptr->op1, varname); - GET_NODE(result, opline_ptr->result); - SET_UNUSED(opline_ptr->op2); - opline_ptr->extended_value = ZEND_FETCH_LOCAL; - - if (varname->op_type == IS_CONST) { - if (zend_is_auto_global(Z_STR(varname->u.constant) TSRMLS_CC)) { - opline_ptr->extended_value = ZEND_FETCH_GLOBAL; - } - } +#define MAKE_NOP(opline) do { \ + opline->opcode = ZEND_NOP; \ + memset(&opline->result, 0, sizeof(opline->result)); \ + memset(&opline->op1, 0, sizeof(opline->op1)); \ + memset(&opline->op2, 0, sizeof(opline->op2)); \ + opline->result_type = opline->op1_type = opline->op2_type = IS_UNUSED; \ +} while (0) - if (bp) { - zend_llist *fetch_list_ptr = zend_stack_top(&CG(bp_stack)); - zend_llist_add_element(fetch_list_ptr, opline_ptr); - } -} -/* }}} */ - -void fetch_simple_variable(znode *result, znode *varname, int bp TSRMLS_DC) /* {{{ */ -{ - /* the default mode must be Write, since fetch_simple_variable() is used to define function arguments */ - fetch_simple_variable_ex(result, varname, bp, ZEND_FETCH_W TSRMLS_CC); -} -/* }}} */ - -void zend_do_fetch_static_member(znode *result, znode *class_name TSRMLS_DC) /* {{{ */ -{ - znode class_node; - zend_llist *fetch_list_ptr; - zend_llist_element *le; - zend_op *opline_ptr; - zend_op opline; - - if (class_name->op_type == IS_CONST && - ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant))) { - zend_resolve_class_name(class_name TSRMLS_CC); - class_node = *class_name; - } else { - zend_do_fetch_class(&class_node, class_name TSRMLS_CC); - } - fetch_list_ptr = zend_stack_top(&CG(bp_stack)); - if (result->op_type == IS_CV) { - init_op(&opline TSRMLS_CC); - - opline.opcode = ZEND_FETCH_W; - opline.result_type = IS_VAR; - opline.result.var = get_temporary_variable(CG(active_op_array)); - opline.op1_type = IS_CONST; - LITERAL_STR(opline.op1, zend_string_copy(CG(active_op_array)->vars[EX_VAR_TO_NUM(result->u.op.var)])); - GET_POLYMORPHIC_CACHE_SLOT(opline.op1.constant); - if (class_node.op_type == IS_CONST) { - opline.op2_type = IS_CONST; - opline.op2.constant = - zend_add_class_name_literal(CG(active_op_array), &class_node.u.constant TSRMLS_CC); - } else { - SET_NODE(opline.op2, &class_node); - } - GET_NODE(result,opline.result); - opline.extended_value |= ZEND_FETCH_STATIC_MEMBER; - opline_ptr = &opline; - - zend_llist_add_element(fetch_list_ptr, &opline); - } else { - le = fetch_list_ptr->head; - - opline_ptr = (zend_op *)le->data; - if (opline_ptr->opcode != ZEND_FETCH_W && opline_ptr->op1_type == IS_CV) { - init_op(&opline TSRMLS_CC); - opline.opcode = ZEND_FETCH_W; - opline.result_type = IS_VAR; - opline.result.var = get_temporary_variable(CG(active_op_array)); - opline.op1_type = IS_CONST; - LITERAL_STR(opline.op1, zend_string_copy(CG(active_op_array)->vars[EX_VAR_TO_NUM(opline_ptr->op1.var)])); - GET_POLYMORPHIC_CACHE_SLOT(opline.op1.constant); - if (class_node.op_type == IS_CONST) { - opline.op2_type = IS_CONST; - opline.op2.constant = - zend_add_class_name_literal(CG(active_op_array), &class_node.u.constant TSRMLS_CC); - } else { - SET_NODE(opline.op2, &class_node); - } - opline.extended_value |= ZEND_FETCH_STATIC_MEMBER; - COPY_NODE(opline_ptr->op1, opline.result); - - zend_llist_prepend_element(fetch_list_ptr, &opline); - } else { - if (opline_ptr->op1_type == IS_CONST) { - GET_POLYMORPHIC_CACHE_SLOT(opline_ptr->op1.constant); - } - if (class_node.op_type == IS_CONST) { - opline_ptr->op2_type = IS_CONST; - opline_ptr->op2.constant = - zend_add_class_name_literal(CG(active_op_array), &class_node.u.constant TSRMLS_CC); - } else { - SET_NODE(opline_ptr->op2, &class_node); - } - opline_ptr->extended_value |= ZEND_FETCH_STATIC_MEMBER; - } - } -} -/* }}} */ - -void fetch_array_begin(znode *result, znode *varname, znode *first_dim TSRMLS_DC) /* {{{ */ -{ - fetch_simple_variable(result, varname, 1 TSRMLS_CC); - - fetch_array_dim(result, result, first_dim TSRMLS_CC); -} -/* }}} */ - -void fetch_array_dim(znode *result, znode *parent, znode *dim TSRMLS_DC) /* {{{ */ -{ - zend_op opline; - zend_llist *fetch_list_ptr = zend_stack_top(&CG(bp_stack)); - - if (zend_is_function_or_method_call(parent)) { - init_op(&opline TSRMLS_CC); - opline.opcode = ZEND_SEPARATE; - SET_NODE(opline.op1, parent); - SET_UNUSED(opline.op2); - opline.result_type = IS_VAR; - opline.result.var = opline.op1.var; - zend_llist_add_element(fetch_list_ptr, &opline); - } - - init_op(&opline TSRMLS_CC); - opline.opcode = ZEND_FETCH_DIM_W; /* the backpatching routine assumes W */ - opline.result_type = IS_VAR; - opline.result.var = get_temporary_variable(CG(active_op_array)); - SET_NODE(opline.op1, parent); - SET_NODE(opline.op2, dim); - if (opline.op2_type == IS_CONST && Z_TYPE(CONSTANT(opline.op2.constant)) == IS_STRING) { - zend_ulong index; - - if (ZEND_HANDLE_NUMERIC(Z_STR(CONSTANT(opline.op2.constant)), index)) { - zval_dtor(&CONSTANT(opline.op2.constant)); - ZVAL_LONG(&CONSTANT(opline.op2.constant), index); - } - } - - GET_NODE(result, opline.result); - - zend_llist_add_element(fetch_list_ptr, &opline); -} -/* }}} */ - -void fetch_string_offset(znode *result, znode *parent, znode *offset TSRMLS_DC) /* {{{ */ -{ - fetch_array_dim(result, parent, offset TSRMLS_CC); -} -/* }}} */ - -void zend_do_print(znode *result, znode *arg TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - opline->result_type = IS_TMP_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - opline->opcode = ZEND_PRINT; - SET_NODE(opline->op1, arg); - SET_UNUSED(opline->op2); - GET_NODE(result, opline->result); -} -/* }}} */ - -void zend_do_echo(znode *arg TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - opline->opcode = ZEND_ECHO; - SET_NODE(opline->op1, arg); - SET_UNUSED(opline->op2); -} -/* }}} */ - -void zend_do_abstract_method(const znode *function_name, znode *modifiers, const znode *body TSRMLS_DC) /* {{{ */ -{ - char *method_type; - - if (CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE) { - Z_LVAL(modifiers->u.constant) |= ZEND_ACC_ABSTRACT; - method_type = "Interface"; - } else { - method_type = "Abstract"; - } - - if (Z_LVAL(modifiers->u.constant) & ZEND_ACC_ABSTRACT) { - if(Z_LVAL(modifiers->u.constant) & ZEND_ACC_PRIVATE) { - zend_error_noreturn(E_COMPILE_ERROR, "%s function %s::%s() cannot be declared private", method_type, CG(active_class_entry)->name->val, Z_STRVAL(function_name->u.constant)); - } - if (Z_LVAL(body->u.constant) == ZEND_ACC_ABSTRACT) { - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - opline->opcode = ZEND_RAISE_ABSTRACT_ERROR; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); - } else { - /* we had code in the function body */ - zend_error_noreturn(E_COMPILE_ERROR, "%s function %s::%s() cannot contain body", method_type, CG(active_class_entry)->name->val, Z_STRVAL(function_name->u.constant)); - } - } else { - if (Z_LVAL(body->u.constant) == ZEND_ACC_ABSTRACT) { - zend_error_noreturn(E_COMPILE_ERROR, "Non-abstract method %s::%s() must contain body", CG(active_class_entry)->name->val, Z_STRVAL(function_name->u.constant)); - } - } -} -/* }}} */ - -static zend_bool opline_is_fetch_this(const zend_op *opline TSRMLS_DC) /* {{{ */ -{ - if ((opline->opcode == ZEND_FETCH_W) && (opline->op1_type == IS_CONST) - && (Z_TYPE(CONSTANT(opline->op1.constant)) == IS_STRING) - && ((opline->extended_value & ZEND_FETCH_STATIC_MEMBER) != ZEND_FETCH_STATIC_MEMBER) - && (Z_STRHASH(CONSTANT(opline->op1.constant)) == THIS_HASHVAL) - && (Z_STRLEN(CONSTANT(opline->op1.constant)) == (sizeof("this")-1)) - && !memcmp(Z_STRVAL(CONSTANT(opline->op1.constant)), "this", sizeof("this") - 1)) { - return 1; - } else { - return 0; - } -} -/* }}} */ - -void zend_do_assign(znode *result, znode *variable, znode *value TSRMLS_DC) /* {{{ */ -{ - int last_op_number; - zend_op *opline; - - if (value->op_type == IS_CV) { - zend_llist *fetch_list_ptr = zend_stack_top(&CG(bp_stack)); - if (fetch_list_ptr && fetch_list_ptr->head) { - opline = (zend_op *)fetch_list_ptr->head->data; - - if (opline->opcode == ZEND_FETCH_DIM_W && - opline->op1_type == IS_CV && - opline->op1.var == value->u.op.var) { - - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_FETCH_R; - opline->result_type = IS_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - opline->op1_type = IS_CONST; - LITERAL_STR(opline->op1, - zend_string_copy(CG(active_op_array)->vars[EX_VAR_TO_NUM(value->u.op.var)])); - SET_UNUSED(opline->op2); - opline->extended_value = ZEND_FETCH_LOCAL; - GET_NODE(value, opline->result); - } - } - } - - zend_do_end_variable_parse(variable, BP_VAR_W, 0 TSRMLS_CC); - - last_op_number = get_next_op_number(CG(active_op_array)); - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - if (variable->op_type == IS_CV) { - if (variable->u.op.var == CG(active_op_array)->this_var) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this"); - } - } else if (variable->op_type == IS_VAR) { - int n = 0; - - while (last_op_number - n > 0) { - zend_op *last_op; - - last_op = &CG(active_op_array)->opcodes[last_op_number-n-1]; - - if (last_op->result_type == IS_VAR && - last_op->result.var == variable->u.op.var) { - if (last_op->opcode == ZEND_FETCH_OBJ_W) { - if (n > 0) { - int opline_no = (opline-CG(active_op_array)->opcodes)/sizeof(*opline); - *opline = *last_op; - MAKE_NOP(last_op); - /* last_op = opline; */ - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - /* get_next_op can realloc, we need to move last_op */ - last_op = &CG(active_op_array)->opcodes[opline_no]; - } - last_op->opcode = ZEND_ASSIGN_OBJ; - zend_do_op_data(opline, value TSRMLS_CC); - SET_UNUSED(opline->result); - GET_NODE(result, last_op->result); - return; - } else if (last_op->opcode == ZEND_FETCH_DIM_W) { - if (n > 0) { - int opline_no = (opline-CG(active_op_array)->opcodes)/sizeof(*opline); - *opline = *last_op; - MAKE_NOP(last_op); - /* last_op = opline; */ - /* TBFixed: this can realloc opcodes, leaving last_op pointing wrong */ - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - /* get_next_op can realloc, we need to move last_op */ - last_op = &CG(active_op_array)->opcodes[opline_no]; - } - last_op->opcode = ZEND_ASSIGN_DIM; - zend_do_op_data(opline, value TSRMLS_CC); - opline->op2.var = get_temporary_variable(CG(active_op_array)); - opline->op2_type = IS_VAR; - SET_UNUSED(opline->result); - GET_NODE(result, last_op->result); - return; - } else if (opline_is_fetch_this(last_op TSRMLS_CC)) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this"); - } else { - break; - } - } - n++; - } - } - - opline->opcode = ZEND_ASSIGN; - SET_NODE(opline->op1, variable); - SET_NODE(opline->op2, value); - opline->result_type = IS_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - GET_NODE(result, opline->result); -} -/* }}} */ - -void zend_do_assign_ref(znode *result, znode *lvar, znode *rvar TSRMLS_DC) /* {{{ */ -{ - zend_op *opline; - - if (lvar->op_type == IS_CV) { - if (lvar->u.op.var == CG(active_op_array)->this_var) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this"); - } - } else if (lvar->op_type == IS_VAR) { - int last_op_number = get_next_op_number(CG(active_op_array)); - - if (last_op_number > 0) { - opline = &CG(active_op_array)->opcodes[last_op_number-1]; - if (opline_is_fetch_this(opline TSRMLS_CC)) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this"); - } - } - } - - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_ASSIGN_REF; - if (zend_is_function_or_method_call(rvar)) { - opline->extended_value = ZEND_RETURNS_FUNCTION; - } else if (rvar->EA & ZEND_PARSED_NEW) { - opline->extended_value = ZEND_RETURNS_NEW; - } else { - opline->extended_value = 0; - } - if (result) { - opline->result_type = IS_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - GET_NODE(result, opline->result); - } else { - opline->result_type = IS_UNUSED | EXT_TYPE_UNUSED; - } - SET_NODE(opline->op1, lvar); - SET_NODE(opline->op2, rvar); +void zend_stop_lexing(TSRMLS_D) { + LANG_SCNG(yy_cursor) = LANG_SCNG(yy_limit); } -/* }}} */ -static inline void do_begin_loop(TSRMLS_D) /* {{{ */ +static inline void zend_begin_loop(TSRMLS_D) /* {{{ */ { zend_brk_cont_element *brk_cont_element; int parent; @@ -1054,7 +544,7 @@ static inline void do_begin_loop(TSRMLS_D) /* {{{ */ } /* }}} */ -static inline void do_end_loop(int cont_addr, int has_loop_var TSRMLS_DC) /* {{{ */ +static inline void zend_end_loop(int cont_addr, int has_loop_var TSRMLS_DC) /* {{{ */ { if (!has_loop_var) { /* The start fileld is used to free temporary variables in case of exceptions. @@ -1068,355 +558,6 @@ static inline void do_end_loop(int cont_addr, int has_loop_var TSRMLS_DC) /* {{{ } /* }}} */ -void zend_do_while_cond(znode *expr, znode *close_bracket_token TSRMLS_DC) /* {{{ */ -{ - int while_cond_op_number = get_next_op_number(CG(active_op_array)); - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - opline->opcode = ZEND_JMPZ; - SET_NODE(opline->op1, expr); - close_bracket_token->u.op.opline_num = while_cond_op_number; - SET_UNUSED(opline->op2); - - do_begin_loop(TSRMLS_C); - INC_BPC(CG(active_op_array)); -} -/* }}} */ - -void zend_do_while_end(const znode *while_token, const znode *close_bracket_token TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - /* add unconditional jump */ - opline->opcode = ZEND_JMP; - opline->op1.opline_num = while_token->u.op.opline_num; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); - - /* update while's conditional jmp */ - CG(active_op_array)->opcodes[close_bracket_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array)); - - do_end_loop(while_token->u.op.opline_num, 0 TSRMLS_CC); - - DEC_BPC(CG(active_op_array)); -} -/* }}} */ - -void zend_do_for_cond(znode *expr, znode *second_semicolon_token TSRMLS_DC) /* {{{ */ -{ - int for_cond_op_number = get_next_op_number(CG(active_op_array)); - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - opline->opcode = ZEND_JMPZNZ; - SET_NODE(opline->op1, expr); /* the conditional expression */ - second_semicolon_token->u.op.opline_num = for_cond_op_number; - SET_UNUSED(opline->op2); -} -/* }}} */ - -void zend_do_for_before_statement(const znode *cond_start, const znode *second_semicolon_token TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - opline->opcode = ZEND_JMP; - opline->op1.opline_num = cond_start->u.op.opline_num; - CG(active_op_array)->opcodes[second_semicolon_token->u.op.opline_num].extended_value = get_next_op_number(CG(active_op_array)); - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); - - do_begin_loop(TSRMLS_C); - - INC_BPC(CG(active_op_array)); -} -/* }}} */ - -void zend_do_for_end(const znode *second_semicolon_token TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - opline->opcode = ZEND_JMP; - opline->op1.opline_num = second_semicolon_token->u.op.opline_num+1; - CG(active_op_array)->opcodes[second_semicolon_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array)); - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); - - do_end_loop(second_semicolon_token->u.op.opline_num+1, 0 TSRMLS_CC); - - DEC_BPC(CG(active_op_array)); -} -/* }}} */ - -void zend_do_pre_incdec(znode *result, znode *op1, zend_uchar op TSRMLS_DC) /* {{{ */ -{ - int last_op_number = get_next_op_number(CG(active_op_array)); - zend_op *opline; - - if (last_op_number > 0) { - zend_op *last_op = &CG(active_op_array)->opcodes[last_op_number-1]; - - if (last_op->opcode == ZEND_FETCH_OBJ_RW) { - last_op->opcode = (op==ZEND_PRE_INC)?ZEND_PRE_INC_OBJ:ZEND_PRE_DEC_OBJ; - last_op->result_type = IS_VAR; - last_op->result.var = get_temporary_variable(CG(active_op_array)); - GET_NODE(result, last_op->result); - return; - } - } - - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = op; - SET_NODE(opline->op1, op1); - SET_UNUSED(opline->op2); - opline->result_type = IS_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - GET_NODE(result, opline->result); -} -/* }}} */ - -void zend_do_post_incdec(znode *result, znode *op1, zend_uchar op TSRMLS_DC) /* {{{ */ -{ - int last_op_number = get_next_op_number(CG(active_op_array)); - zend_op *opline; - - if (last_op_number > 0) { - zend_op *last_op = &CG(active_op_array)->opcodes[last_op_number-1]; - - if (last_op->opcode == ZEND_FETCH_OBJ_RW) { - last_op->opcode = (op==ZEND_POST_INC)?ZEND_POST_INC_OBJ:ZEND_POST_DEC_OBJ; - last_op->result_type = IS_TMP_VAR; - last_op->result.var = get_temporary_variable(CG(active_op_array)); - GET_NODE(result, last_op->result); - return; - } - } - - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = op; - SET_NODE(opline->op1, op1); - SET_UNUSED(opline->op2); - opline->result_type = IS_TMP_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - GET_NODE(result, opline->result); -} -/* }}} */ - -void zend_do_if_cond(znode *cond, znode *closing_bracket_token TSRMLS_DC) /* {{{ */ -{ - int if_cond_op_number = get_next_op_number(CG(active_op_array)); - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - opline->opcode = ZEND_JMPZ; - SET_NODE(opline->op1, cond); - closing_bracket_token->u.op.opline_num = if_cond_op_number; - SET_UNUSED(opline->op2); - INC_BPC(CG(active_op_array)); -} -/* }}} */ - -void zend_do_if_after_statement(const znode *closing_bracket_token, unsigned char initialize TSRMLS_DC) /* {{{ */ -{ - int if_end_op_number = get_next_op_number(CG(active_op_array)); - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - zend_llist *jmp_list_ptr; - - opline->opcode = ZEND_JMP; - /* save for backpatching */ - if (initialize) { - zend_llist jmp_list; - - zend_llist_init(&jmp_list, sizeof(int), NULL, 0); - zend_stack_push(&CG(bp_stack), (void *) &jmp_list); - } - jmp_list_ptr = zend_stack_top(&CG(bp_stack)); - zend_llist_add_element(jmp_list_ptr, &if_end_op_number); - - CG(active_op_array)->opcodes[closing_bracket_token->u.op.opline_num].op2.opline_num = if_end_op_number+1; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); -} -/* }}} */ - -void zend_do_if_end(TSRMLS_D) /* {{{ */ -{ - int next_op_number = get_next_op_number(CG(active_op_array)); - zend_llist *jmp_list_ptr = zend_stack_top(&CG(bp_stack)); - zend_llist_element *le; - - for (le=jmp_list_ptr->head; le; le = le->next) { - CG(active_op_array)->opcodes[*((int *) le->data)].op1.opline_num = next_op_number; - } - zend_llist_destroy(jmp_list_ptr); - zend_stack_del_top(&CG(bp_stack)); - DEC_BPC(CG(active_op_array)); -} -/* }}} */ - -void zend_check_writable_variable(const znode *variable) /* {{{ */ -{ - uint32_t type = variable->EA; - - if (type & ZEND_PARSED_METHOD_CALL) { - zend_error_noreturn(E_COMPILE_ERROR, "Can't use method return value in write context"); - } - if (type == ZEND_PARSED_FUNCTION_CALL) { - zend_error_noreturn(E_COMPILE_ERROR, "Can't use function return value in write context"); - } -} -/* }}} */ - -void zend_do_begin_variable_parse(TSRMLS_D) /* {{{ */ -{ - zend_llist fetch_list; - - zend_llist_init(&fetch_list, sizeof(zend_op), NULL, 0); - zend_stack_push(&CG(bp_stack), (void *) &fetch_list); -} -/* }}} */ - -void zend_do_end_variable_parse(znode *variable, int type, int arg_offset TSRMLS_DC) /* {{{ */ -{ - zend_llist *fetch_list_ptr = zend_stack_top(&CG(bp_stack)); - zend_llist_element *le = fetch_list_ptr->head; - zend_op *opline = NULL; - zend_op *opline_ptr; - uint32_t this_var = -1; - - /* TODO: $foo->x->y->z = 1 should fetch "x" and "y" for R or RW, not just W */ - - if (le) { - opline_ptr = (zend_op *)le->data; - if (opline_is_fetch_this(opline_ptr TSRMLS_CC)) { - /* convert to FETCH_?(this) into IS_CV */ - if (CG(active_op_array)->last == 0 || - CG(active_op_array)->opcodes[CG(active_op_array)->last-1].opcode != ZEND_BEGIN_SILENCE) { - - this_var = opline_ptr->result.var; - if (CG(active_op_array)->this_var == -1) { - CG(active_op_array)->this_var = lookup_cv(CG(active_op_array), Z_STR(CONSTANT(opline_ptr->op1.constant)) TSRMLS_CC); - ZVAL_UNDEF(&CONSTANT(opline_ptr->op1.constant)); - } else { - zend_del_literal(CG(active_op_array), opline_ptr->op1.constant); - } - le = le->next; - if (variable->op_type == IS_VAR && - variable->u.op.var == this_var) { - variable->op_type = IS_CV; - variable->u.op.var = CG(active_op_array)->this_var; - } - } else if (CG(active_op_array)->this_var == -1) { - CG(active_op_array)->this_var = lookup_cv(CG(active_op_array), zend_string_init("this", sizeof("this")-1, 0) TSRMLS_CC); - } - } - - while (le) { - opline_ptr = (zend_op *)le->data; - if (opline_ptr->opcode == ZEND_SEPARATE) { - if (type != BP_VAR_R && type != BP_VAR_IS) { - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - memcpy(opline, opline_ptr, sizeof(zend_op)); - } - le = le->next; - continue; - } - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - memcpy(opline, opline_ptr, sizeof(zend_op)); - if (opline->op1_type == IS_VAR && - opline->op1.var == this_var) { - opline->op1_type = IS_CV; - opline->op1.var = CG(active_op_array)->this_var; - } - switch (type) { - case BP_VAR_R: - if (opline->opcode == ZEND_FETCH_DIM_W && opline->op2_type == IS_UNUSED) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use [] for reading"); - } - opline->opcode -= 3; - break; - case BP_VAR_W: - break; - case BP_VAR_RW: - opline->opcode += 3; - break; - case BP_VAR_IS: - if (opline->opcode == ZEND_FETCH_DIM_W && opline->op2_type == IS_UNUSED) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use [] for reading"); - } - opline->opcode += 6; /* 3+3 */ - break; - case BP_VAR_FUNC_ARG: - opline->opcode += 9; /* 3+3+3 */ - opline->extended_value |= arg_offset; - break; - case BP_VAR_UNSET: - if (opline->opcode == ZEND_FETCH_DIM_W && opline->op2_type == IS_UNUSED) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use [] for unsetting"); - } - opline->opcode += 12; /* 3+3+3+3 */ - break; - } - le = le->next; - } - if (opline && type == BP_VAR_W && arg_offset) { - opline->extended_value |= ZEND_FETCH_MAKE_REF; - } - } - zend_llist_destroy(fetch_list_ptr); - zend_stack_del_top(&CG(bp_stack)); -} -/* }}} */ - -void zend_do_add_string(znode *result, znode *op1, znode *op2 TSRMLS_DC) /* {{{ */ -{ - zend_op *opline; - - if (Z_STRLEN(op2->u.constant) > 1) { - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_ADD_STRING; - } else if (Z_STRLEN(op2->u.constant) == 1) { - int ch = *Z_STRVAL(op2->u.constant); - - /* Free memory and use ZEND_ADD_CHAR in case of 1 character strings */ - zend_string_free(Z_STR(op2->u.constant)); - ZVAL_LONG(&op2->u.constant, ch); - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_ADD_CHAR; - } else { /* String can be empty after a variable at the end of a heredoc */ - zend_string_free(Z_STR(op2->u.constant)); - return; - } - - if (op1) { - SET_NODE(opline->op1, op1); - SET_NODE(opline->result, op1); - } else { - SET_UNUSED(opline->op1); - opline->result_type = IS_TMP_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - } - SET_NODE(opline->op2, op2); - GET_NODE(result, opline->result); -} -/* }}} */ - -void zend_do_add_variable(znode *result, znode *op1, znode *op2 TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - opline->opcode = ZEND_ADD_VAR; - - if (op1) { - SET_NODE(opline->op1, op1); - SET_NODE(opline->result, op1); - } else { - SET_UNUSED(opline->op1); - opline->result_type = IS_TMP_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - } - SET_NODE(opline->op2, op2); - GET_NODE(result, opline->result); -} -/* }}} */ - void zend_do_free(znode *op1 TSRMLS_DC) /* {{{ */ { if (op1->op_type==IS_TMP_VAR) { @@ -1473,869 +614,197 @@ void zend_do_free(znode *op1 TSRMLS_DC) /* {{{ */ } } } else if (op1->op_type == IS_CONST) { - zval_dtor(&op1->u.constant); + /* Destroy value without using GC: When opcache moves arrays into SHM it will + * free the zend_array structure, so references to it from outside the op array + * become invalid. GC would cause such a reference in the root buffer. */ + zval *zv = &op1->u.constant; + if (Z_REFCOUNTED_P(zv) && !Z_DELREF_P(zv)) { + _zval_dtor_func_for_ptr(Z_COUNTED_P(zv) ZEND_FILE_LINE_CC); + } } } /* }}} */ -int zend_do_verify_access_types(const znode *current_access_type, const znode *new_modifier) /* {{{ */ -{ - if ((Z_LVAL(current_access_type->u.constant) & ZEND_ACC_PPP_MASK) - && (Z_LVAL(new_modifier->u.constant) & ZEND_ACC_PPP_MASK)) { +uint32_t zend_add_member_modifier(uint32_t flags, uint32_t new_flag) { + uint32_t new_flags = flags | new_flag; + if ((flags & ZEND_ACC_PPP_MASK) && (new_flag & ZEND_ACC_PPP_MASK)) { zend_error_noreturn(E_COMPILE_ERROR, "Multiple access type modifiers are not allowed"); } - if ((Z_LVAL(current_access_type->u.constant) & ZEND_ACC_ABSTRACT) - && (Z_LVAL(new_modifier->u.constant) & ZEND_ACC_ABSTRACT)) { + if ((flags & ZEND_ACC_ABSTRACT) && (new_flag & ZEND_ACC_ABSTRACT)) { zend_error_noreturn(E_COMPILE_ERROR, "Multiple abstract modifiers are not allowed"); } - if ((Z_LVAL(current_access_type->u.constant) & ZEND_ACC_STATIC) - && (Z_LVAL(new_modifier->u.constant) & ZEND_ACC_STATIC)) { + if ((flags & ZEND_ACC_STATIC) && (new_flag & ZEND_ACC_STATIC)) { zend_error_noreturn(E_COMPILE_ERROR, "Multiple static modifiers are not allowed"); } - if ((Z_LVAL(current_access_type->u.constant) & ZEND_ACC_FINAL) - && (Z_LVAL(new_modifier->u.constant) & ZEND_ACC_FINAL)) { + if ((flags & ZEND_ACC_FINAL) && (new_flag & ZEND_ACC_FINAL)) { zend_error_noreturn(E_COMPILE_ERROR, "Multiple final modifiers are not allowed"); } - if (((Z_LVAL(current_access_type->u.constant) | Z_LVAL(new_modifier->u.constant)) & (ZEND_ACC_ABSTRACT | ZEND_ACC_FINAL)) == (ZEND_ACC_ABSTRACT | ZEND_ACC_FINAL)) { + if ((new_flags & ZEND_ACC_ABSTRACT) && (new_flags & ZEND_ACC_FINAL)) { zend_error_noreturn(E_COMPILE_ERROR, "Cannot use the final modifier on an abstract class member"); } - return (Z_LVAL(current_access_type->u.constant) | Z_LVAL(new_modifier->u.constant)); + return new_flags; } -/* }}} */ - -void zend_do_begin_function_declaration(znode *function_token, znode *function_name, int is_method, int return_reference, znode *fn_flags_znode TSRMLS_DC) /* {{{ */ -{ - zend_op_array op_array; - zend_string *name = Z_STR(function_name->u.constant); - int function_begin_line = function_token->u.op.opline_num; - uint32_t fn_flags; - zend_string *lcname; - zend_bool orig_interactive; - ALLOCA_FLAG(use_heap) - - if (is_method) { - if (CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE) { - if ((Z_LVAL(fn_flags_znode->u.constant) & ~(ZEND_ACC_STATIC|ZEND_ACC_PUBLIC))) { - zend_error_noreturn(E_COMPILE_ERROR, "Access type for interface method %s::%s() must be omitted", CG(active_class_entry)->name->val, Z_STRVAL(function_name->u.constant)); - } - Z_LVAL(fn_flags_znode->u.constant) |= ZEND_ACC_ABSTRACT; /* propagates to the rest of the parser */ - } - fn_flags = Z_LVAL(fn_flags_znode->u.constant); /* must be done *after* the above check */ - } else { - fn_flags = 0; - } - if ((fn_flags & ZEND_ACC_STATIC) && (fn_flags & ZEND_ACC_ABSTRACT) && !(CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE)) { - zend_error(E_STRICT, "Static function %s%s%s() should not be abstract", is_method ? CG(active_class_entry)->name->val : "", is_method ? "::" : "", Z_STRVAL(function_name->u.constant)); - } - - function_token->u.op_array = CG(active_op_array); - - orig_interactive = CG(interactive); - CG(interactive) = 0; - init_op_array(&op_array, ZEND_USER_FUNCTION, INITIAL_OP_ARRAY_SIZE TSRMLS_CC); - CG(interactive) = orig_interactive; - - op_array.function_name = name; - if (return_reference) { - op_array.fn_flags |= ZEND_ACC_RETURN_REFERENCE; - } - op_array.fn_flags |= fn_flags; - - op_array.scope = is_method?CG(active_class_entry):NULL; - op_array.prototype = NULL; - op_array.line_start = zend_get_compiled_lineno(TSRMLS_C); +zend_string *zend_concat3( + char *str1, size_t str1_len, char *str2, size_t str2_len, char *str3, size_t str3_len +) { + size_t len = str1_len + str2_len + str3_len; + zend_string *res = zend_string_alloc(len, 0); - if (is_method) { - lcname = zend_string_alloc(name->len, 0); - zend_str_tolower_copy(lcname->val, name->val, name->len); - lcname = zend_new_interned_string(lcname TSRMLS_CC); - CG(active_op_array) = zend_arena_alloc(&CG(arena), sizeof(zend_op_array)); - memcpy(CG(active_op_array), &op_array, sizeof(zend_op_array)); - if (zend_hash_add_ptr(&CG(active_class_entry)->function_table, lcname, CG(active_op_array)) == NULL) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare %s::%s()", CG(active_class_entry)->name->val, name->val); - } - - zend_stack_push(&CG(context_stack), (void *) &CG(context)); - zend_init_compiler_context(TSRMLS_C); - - if (fn_flags & ZEND_ACC_ABSTRACT) { - CG(active_class_entry)->ce_flags |= ZEND_ACC_IMPLICIT_ABSTRACT_CLASS; - } + memcpy(res->val, str1, str1_len); + memcpy(res->val + str1_len, str2, str2_len); + memcpy(res->val + str1_len + str2_len, str3, str3_len); + res->val[len] = '\0'; - if (!(fn_flags & ZEND_ACC_PPP_MASK)) { - fn_flags |= ZEND_ACC_PUBLIC; - } - - if (CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE) { - if ((name->len == sizeof(ZEND_CALL_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_CALL_FUNC_NAME, sizeof(ZEND_CALL_FUNC_NAME)-1))) { - if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) { - zend_error(E_WARNING, "The magic method __call() must have public visibility and cannot be static"); - } - } else if ((name->len == sizeof(ZEND_CALLSTATIC_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_CALLSTATIC_FUNC_NAME, sizeof(ZEND_CALLSTATIC_FUNC_NAME)-1))) { - if ((fn_flags & (ZEND_ACC_PPP_MASK ^ ZEND_ACC_PUBLIC)) || (fn_flags & ZEND_ACC_STATIC) == 0) { - zend_error(E_WARNING, "The magic method __callStatic() must have public visibility and be static"); - } - } else if ((name->len == sizeof(ZEND_GET_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_GET_FUNC_NAME, sizeof(ZEND_GET_FUNC_NAME)-1))) { - if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) { - zend_error(E_WARNING, "The magic method __get() must have public visibility and cannot be static"); - } - } else if ((name->len == sizeof(ZEND_SET_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_SET_FUNC_NAME, sizeof(ZEND_SET_FUNC_NAME)-1))) { - if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) { - zend_error(E_WARNING, "The magic method __set() must have public visibility and cannot be static"); - } - } else if ((name->len == sizeof(ZEND_UNSET_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_UNSET_FUNC_NAME, sizeof(ZEND_UNSET_FUNC_NAME)-1))) { - if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) { - zend_error(E_WARNING, "The magic method __unset() must have public visibility and cannot be static"); - } - } else if ((name->len == sizeof(ZEND_ISSET_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_ISSET_FUNC_NAME, sizeof(ZEND_ISSET_FUNC_NAME)-1))) { - if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) { - zend_error(E_WARNING, "The magic method __isset() must have public visibility and cannot be static"); - } - } else if ((name->len == sizeof(ZEND_TOSTRING_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_TOSTRING_FUNC_NAME, sizeof(ZEND_TOSTRING_FUNC_NAME)-1))) { - if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) { - zend_error(E_WARNING, "The magic method __toString() must have public visibility and cannot be static"); - } - } else if ((name->len == sizeof(ZEND_INVOKE_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1))) { - if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) { - zend_error(E_WARNING, "The magic method __invoke() must have public visibility and cannot be static"); - } - - } else if ((name->len == sizeof(ZEND_DEBUGINFO_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_DEBUGINFO_FUNC_NAME, sizeof(ZEND_DEBUGINFO_FUNC_NAME)-1))) { - if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) { - zend_error(E_WARNING, "The magic method __debugInfo() must have public visibility and cannot be static"); - } - } - } else { - char *class_lcname; - - class_lcname = do_alloca(CG(active_class_entry)->name->len + 1, use_heap); - zend_str_tolower_copy(class_lcname, CG(active_class_entry)->name->val, CG(active_class_entry)->name->len); - /* Improve after RC: cache the lowercase class name */ - - if ((CG(active_class_entry)->name->len == name->len) && ((CG(active_class_entry)->ce_flags & ZEND_ACC_TRAIT) != ZEND_ACC_TRAIT) && (!memcmp(class_lcname, lcname->val, name->len))) { - if (!CG(active_class_entry)->constructor) { - CG(active_class_entry)->constructor = (zend_function *) CG(active_op_array); - } - } else if ((name->len == sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_CONSTRUCTOR_FUNC_NAME, sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)-1))) { - if (CG(active_class_entry)->constructor) { - zend_error(E_STRICT, "Redefining already defined constructor for class %s", CG(active_class_entry)->name->val); - } - CG(active_class_entry)->constructor = (zend_function *) CG(active_op_array); - } else if ((name->len == sizeof(ZEND_DESTRUCTOR_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_DESTRUCTOR_FUNC_NAME, sizeof(ZEND_DESTRUCTOR_FUNC_NAME)-1))) { - CG(active_class_entry)->destructor = (zend_function *) CG(active_op_array); - } else if ((name->len == sizeof(ZEND_CLONE_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_CLONE_FUNC_NAME, sizeof(ZEND_CLONE_FUNC_NAME)-1))) { - CG(active_class_entry)->clone = (zend_function *) CG(active_op_array); - } else if ((name->len == sizeof(ZEND_CALL_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_CALL_FUNC_NAME, sizeof(ZEND_CALL_FUNC_NAME)-1))) { - if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) { - zend_error(E_WARNING, "The magic method __call() must have public visibility and cannot be static"); - } - CG(active_class_entry)->__call = (zend_function *) CG(active_op_array); - } else if ((name->len == sizeof(ZEND_CALLSTATIC_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_CALLSTATIC_FUNC_NAME, sizeof(ZEND_CALLSTATIC_FUNC_NAME)-1))) { - if ((fn_flags & (ZEND_ACC_PPP_MASK ^ ZEND_ACC_PUBLIC)) || (fn_flags & ZEND_ACC_STATIC) == 0) { - zend_error(E_WARNING, "The magic method __callStatic() must have public visibility and be static"); - } - CG(active_class_entry)->__callstatic = (zend_function *) CG(active_op_array); - } else if ((name->len == sizeof(ZEND_GET_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_GET_FUNC_NAME, sizeof(ZEND_GET_FUNC_NAME)-1))) { - if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) { - zend_error(E_WARNING, "The magic method __get() must have public visibility and cannot be static"); - } - CG(active_class_entry)->__get = (zend_function *) CG(active_op_array); - } else if ((name->len == sizeof(ZEND_SET_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_SET_FUNC_NAME, sizeof(ZEND_SET_FUNC_NAME)-1))) { - if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) { - zend_error(E_WARNING, "The magic method __set() must have public visibility and cannot be static"); - } - CG(active_class_entry)->__set = (zend_function *) CG(active_op_array); - } else if ((name->len == sizeof(ZEND_UNSET_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_UNSET_FUNC_NAME, sizeof(ZEND_UNSET_FUNC_NAME)-1))) { - if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) { - zend_error(E_WARNING, "The magic method __unset() must have public visibility and cannot be static"); - } - CG(active_class_entry)->__unset = (zend_function *) CG(active_op_array); - } else if ((name->len == sizeof(ZEND_ISSET_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_ISSET_FUNC_NAME, sizeof(ZEND_ISSET_FUNC_NAME)-1))) { - if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) { - zend_error(E_WARNING, "The magic method __isset() must have public visibility and cannot be static"); - } - CG(active_class_entry)->__isset = (zend_function *) CG(active_op_array); - } else if ((name->len == sizeof(ZEND_TOSTRING_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_TOSTRING_FUNC_NAME, sizeof(ZEND_TOSTRING_FUNC_NAME)-1))) { - if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) { - zend_error(E_WARNING, "The magic method __toString() must have public visibility and cannot be static"); - } - CG(active_class_entry)->__tostring = (zend_function *) CG(active_op_array); - } else if ((name->len == sizeof(ZEND_INVOKE_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1))) { - if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) { - zend_error(E_WARNING, "The magic method __invoke() must have public visibility and cannot be static"); - } - } else if ((name->len == sizeof(ZEND_DEBUGINFO_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_DEBUGINFO_FUNC_NAME, sizeof(ZEND_DEBUGINFO_FUNC_NAME)-1))) { - if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) { - zend_error(E_WARNING, "The magic method __debugInfo() must have public visibility and cannot be static"); - } - CG(active_class_entry)->__debugInfo = (zend_function *) CG(active_op_array); - } else if (!(fn_flags & ZEND_ACC_STATIC)) { - CG(active_op_array)->fn_flags |= ZEND_ACC_ALLOW_STATIC; - } - free_alloca(class_lcname, use_heap); - } - - zend_string_release(lcname); - } else { - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - zval key; - zval *ns_name; - - if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) { - /* Prefix function name with current namespace name */ - znode tmp; - - ZVAL_DUP(&tmp.u.constant, &CG(current_namespace)); - zend_do_build_namespace_name(&tmp, &tmp, function_name TSRMLS_CC); - op_array.function_name = Z_STR(tmp.u.constant); - lcname = zend_string_alloc(Z_STRLEN(tmp.u.constant), 0); - zend_str_tolower_copy(lcname->val, Z_STRVAL(tmp.u.constant), Z_STRLEN(tmp.u.constant)); - } else { - lcname = zend_string_alloc(name->len, 0); - zend_str_tolower_copy(lcname->val, name->val, name->len); - } - - /* Function name must not conflict with import names */ - if (CG(current_import_function) && - (ns_name = zend_hash_find(CG(current_import_function), lcname)) != NULL) { - - char *tmp = zend_str_tolower_dup(Z_STRVAL_P(ns_name), Z_STRLEN_P(ns_name)); - - if (Z_STRLEN_P(ns_name) != Z_STRLEN(function_name->u.constant) || - memcmp(tmp, lcname->val, Z_STRLEN(function_name->u.constant))) { - zend_error(E_COMPILE_ERROR, "Cannot declare function %s because the name is already in use", Z_STRVAL(function_name->u.constant)); - } - efree(tmp); - } - - opline->opcode = ZEND_DECLARE_FUNCTION; - opline->op1_type = IS_CONST; - build_runtime_defined_function_key(&key, lcname->val, lcname->len TSRMLS_CC); - opline->op1.constant = zend_add_literal(CG(active_op_array), &key TSRMLS_CC); - opline->op2_type = IS_CONST; - LITERAL_STR(opline->op2, zend_string_copy(lcname)); - opline->extended_value = ZEND_DECLARE_FUNCTION; - CG(active_op_array) = zend_arena_alloc(&CG(arena), sizeof(zend_op_array)); - memcpy(CG(active_op_array), &op_array, sizeof(zend_op_array)); - zend_hash_update_ptr(CG(function_table), Z_STR(key), CG(active_op_array)); - zend_stack_push(&CG(context_stack), (void *) &CG(context)); - zend_init_compiler_context(TSRMLS_C); - zend_string_release(lcname); - } - - if (CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO) { - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - opline->opcode = ZEND_EXT_NOP; - opline->lineno = function_begin_line; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); - } - - { - /* Push a separator to the switch stack */ - zend_switch_entry switch_entry; - - switch_entry.cond.op_type = IS_UNUSED; - switch_entry.default_case = 0; - switch_entry.control_var = 0; - - zend_stack_push(&CG(switch_cond_stack), (void *) &switch_entry); - } - - { - /* Push a separator to the foreach stack */ - zend_op dummy_opline; - - dummy_opline.result_type = IS_UNUSED; - - zend_stack_push(&CG(foreach_copy_stack), (void *) &dummy_opline); - } - - if (CG(doc_comment)) { - CG(active_op_array)->doc_comment = CG(doc_comment); - CG(doc_comment) = NULL; - } + return res; } -/* }}} */ - -void zend_do_begin_lambda_function_declaration(znode *result, znode *function_token, int return_reference, int is_static TSRMLS_DC) /* {{{ */ -{ - znode function_name; - zend_op_array *current_op_array = CG(active_op_array); - int current_op_number = get_next_op_number(CG(active_op_array)); - zend_op *current_op; - - function_name.op_type = IS_CONST; - ZVAL_STRINGL(&function_name.u.constant, "{closure}", sizeof("{closure}")-1); - - zend_do_begin_function_declaration(function_token, &function_name, 0, return_reference, NULL TSRMLS_CC); - - result->op_type = IS_TMP_VAR; - result->u.op.var = get_temporary_variable(current_op_array); - - current_op = ¤t_op_array->opcodes[current_op_number]; - current_op->opcode = ZEND_DECLARE_LAMBDA_FUNCTION; - zend_del_literal(current_op_array, current_op->op2.constant); - SET_UNUSED(current_op->op2); - SET_NODE(current_op->result, result); - if (is_static) { - CG(active_op_array)->fn_flags |= ZEND_ACC_STATIC; - } - CG(active_op_array)->fn_flags |= ZEND_ACC_CLOSURE; -} -/* }}} */ -void zend_do_handle_exception(TSRMLS_D) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - opline->opcode = ZEND_HANDLE_EXCEPTION; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); +zend_string *zend_concat_names(char *name1, size_t name1_len, char *name2, size_t name2_len) { + return zend_concat3(name1, name1_len, "\\", 1, name2, name2_len); } -/* }}} */ - -void zend_do_end_function_declaration(const znode *function_token TSRMLS_DC) /* {{{ */ -{ - char lcname[16]; - int name_len; - zend_do_extended_info(TSRMLS_C); - zend_do_return(NULL, 0 TSRMLS_CC); - - pass_two(CG(active_op_array) TSRMLS_CC); - zend_release_labels(0 TSRMLS_CC); - - if (CG(active_class_entry)) { - zend_check_magic_method_implementation(CG(active_class_entry), (zend_function*)CG(active_op_array), E_COMPILE_ERROR TSRMLS_CC); +zend_string *zend_prefix_with_ns(zend_string *name TSRMLS_DC) { + if (CG(current_namespace)) { + zend_string *ns = CG(current_namespace); + return zend_concat_names(ns->val, ns->len, name->val, name->len); } else { - /* we don't care if the function name is longer, in fact lowercasing only - * the beginning of the name speeds up the check process */ - name_len = CG(active_op_array)->function_name->len; - zend_str_tolower_copy(lcname, CG(active_op_array)->function_name->val, MIN(name_len, sizeof(lcname)-1)); - lcname[sizeof(lcname)-1] = '\0'; /* zend_str_tolower_copy won't necessarily set the zero byte */ - if (name_len == sizeof(ZEND_AUTOLOAD_FUNC_NAME) - 1 && !memcmp(lcname, ZEND_AUTOLOAD_FUNC_NAME, sizeof(ZEND_AUTOLOAD_FUNC_NAME)) && CG(active_op_array)->num_args != 1) { - zend_error_noreturn(E_COMPILE_ERROR, "%s() must take exactly 1 argument", ZEND_AUTOLOAD_FUNC_NAME); - } + return zend_string_copy(name); } +} - CG(active_op_array)->line_end = zend_get_compiled_lineno(TSRMLS_C); - CG(active_op_array) = function_token->u.op_array; - - - /* Pop the switch and foreach separators */ - zend_stack_del_top(&CG(switch_cond_stack)); - zend_stack_del_top(&CG(foreach_copy_stack)); +void *zend_hash_find_ptr_lc(HashTable *ht, char *str, size_t len) { + void *result; + zend_string *lcname = zend_string_alloc(len, 0); + zend_str_tolower_copy(lcname->val, str, len); + result = zend_hash_find_ptr(ht, lcname); + zend_string_free(lcname); + return result; } -/* }}} */ -void zend_do_receive_param(zend_uchar op, znode *varname, znode *initialization, znode *class_type, zend_uchar pass_by_reference, zend_bool is_variadic TSRMLS_DC) /* {{{ */ -{ - zend_op *opline; - zend_arg_info *cur_arg_info; - znode var; +zend_string *zend_resolve_non_class_name( + zend_string *name, uint32_t type, zend_bool *is_fully_qualified, + zend_bool case_sensitive, HashTable *current_import_sub TSRMLS_DC +) { + char *compound; + *is_fully_qualified = 0; - if (zend_is_auto_global(Z_STR(varname->u.constant) TSRMLS_CC)) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign auto-global variable %s", Z_STRVAL(varname->u.constant)); - } else { - var.op_type = IS_CV; - var.u.op.var = lookup_cv(CG(active_op_array), Z_STR(varname->u.constant) TSRMLS_CC); - Z_STR(varname->u.constant) = CG(active_op_array)->vars[EX_VAR_TO_NUM(var.u.op.var)]; - var.EA = 0; - if (EX_VAR_TO_NUM(var.u.op.var) != CG(active_op_array)->num_args) { - zend_error_noreturn(E_COMPILE_ERROR, "Redefinition of parameter $%s", Z_STRVAL(varname->u.constant)); - } else if (Z_STRHASH(varname->u.constant) == THIS_HASHVAL && - Z_STRLEN(varname->u.constant) == sizeof("this")-1 && - !memcmp(Z_STRVAL(varname->u.constant), "this", sizeof("this")-1)) { - if (CG(active_op_array)->scope && - (CG(active_op_array)->fn_flags & ZEND_ACC_STATIC) == 0) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this"); - } - CG(active_op_array)->this_var = var.u.op.var; - } + if (name->val[0] == '\\') { + /* Remove \ prefix (only relevant if this is a string rather than a label) */ + return zend_string_init(name->val + 1, name->len - 1, 0); } - if (CG(active_op_array)->fn_flags & ZEND_ACC_VARIADIC) { - zend_error_noreturn(E_COMPILE_ERROR, "Only the last parameter can be variadic"); + if (type == ZEND_NAME_FQ) { + *is_fully_qualified = 1; + return zend_string_copy(name); } - if (is_variadic) { - if (op == ZEND_RECV_INIT) { - zend_error_noreturn(E_COMPILE_ERROR, "Variadic parameter cannot have a default value"); - } - - op = ZEND_RECV_VARIADIC; - CG(active_op_array)->fn_flags |= ZEND_ACC_VARIADIC; + if (type == ZEND_NAME_RELATIVE) { + *is_fully_qualified = 1; + return zend_prefix_with_ns(name TSRMLS_CC); } - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - CG(active_op_array)->num_args++; - opline->opcode = op; - SET_NODE(opline->result, &var); - opline->op1_type = IS_UNUSED; - opline->op1.num = CG(active_op_array)->num_args; - if (op == ZEND_RECV_INIT) { - SET_NODE(opline->op2, initialization); - } else { - SET_UNUSED(opline->op2); - if (!is_variadic) { - CG(active_op_array)->required_num_args = CG(active_op_array)->num_args; - } - } - CG(active_op_array)->arg_info = erealloc(CG(active_op_array)->arg_info, sizeof(zend_arg_info)*(CG(active_op_array)->num_args)); - cur_arg_info = &CG(active_op_array)->arg_info[CG(active_op_array)->num_args-1]; - cur_arg_info->name = estrndup(Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant)); - cur_arg_info->name_len = Z_STRLEN(varname->u.constant); - cur_arg_info->type_hint = 0; - cur_arg_info->pass_by_reference = pass_by_reference; - cur_arg_info->allow_null = 1; - cur_arg_info->is_variadic = is_variadic; - cur_arg_info->class_name = NULL; - cur_arg_info->class_name_len = 0; - - if (class_type->op_type != IS_UNUSED) { - cur_arg_info->allow_null = 0; - - if (Z_TYPE(class_type->u.constant) != IS_NULL) { - if (Z_TYPE(class_type->u.constant) == IS_ARRAY) { - cur_arg_info->type_hint = IS_ARRAY; - if (op == ZEND_RECV_INIT) { - if (Z_TYPE(initialization->u.constant) == IS_NULL || (Z_TYPE(initialization->u.constant) == IS_CONSTANT && !strcasecmp(Z_STRVAL(initialization->u.constant), "NULL")) || Z_TYPE(initialization->u.constant) == IS_CONSTANT_AST) { - cur_arg_info->allow_null = 1; - } else if (Z_TYPE(initialization->u.constant) != IS_ARRAY) { - zend_error_noreturn(E_COMPILE_ERROR, "Default value for parameters with array type hint can only be an array or NULL"); - } - } - } else if (Z_TYPE(class_type->u.constant) == IS_CALLABLE) { - cur_arg_info->type_hint = IS_CALLABLE; - if (op == ZEND_RECV_INIT) { - if (Z_TYPE(initialization->u.constant) == IS_NULL || (Z_TYPE(initialization->u.constant) == IS_CONSTANT && !strcasecmp(Z_STRVAL(initialization->u.constant), "NULL")) || Z_TYPE(initialization->u.constant) == IS_CONSTANT_AST) { - cur_arg_info->allow_null = 1; - } else { - zend_error_noreturn(E_COMPILE_ERROR, "Default value for parameters with callable type hint can only be NULL"); - } - } - } else { - cur_arg_info->type_hint = IS_OBJECT; - if (ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(class_type->u.constant), Z_STRLEN(class_type->u.constant))) { - zend_resolve_class_name(class_type TSRMLS_CC); - } - Z_STR(class_type->u.constant) = zend_new_interned_string(Z_STR(class_type->u.constant) TSRMLS_CC); - if (IS_INTERNED(Z_STR(class_type->u.constant))) { - Z_TYPE_FLAGS(class_type->u.constant) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE); - } -// TODO: for now we have to copy it ??? -#if 1 - cur_arg_info->class_name = estrndup(Z_STRVAL(class_type->u.constant), Z_STRLEN(class_type->u.constant)); - cur_arg_info->class_name_len = Z_STRLEN(class_type->u.constant); - zend_string_release(Z_STR(class_type->u.constant)); -#else - cur_arg_info->class_name = Z_STRVAL(class_type->u.constant); - cur_arg_info->class_name_len = Z_STRLEN(class_type->u.constant); -#endif - if (op == ZEND_RECV_INIT) { - if (Z_TYPE(initialization->u.constant) == IS_NULL || (Z_TYPE(initialization->u.constant) == IS_CONSTANT && !strcasecmp(Z_STRVAL(initialization->u.constant), "NULL")) || Z_TYPE(initialization->u.constant) == IS_CONSTANT_AST) { - cur_arg_info->allow_null = 1; - } else { - zend_error_noreturn(E_COMPILE_ERROR, "Default value for parameters with a class type hint can only be NULL"); - } - } - } + if (current_import_sub) { + /* If an unqualified name is a function/const alias, replace it. */ + zend_string *import_name; + if (case_sensitive) { + import_name = zend_hash_find_ptr(current_import_sub, name); + } else { + import_name = zend_hash_find_ptr_lc(current_import_sub, name->val, name->len); } - } - if (cur_arg_info->class_name || cur_arg_info->type_hint) { - CG(active_op_array)->fn_flags |= ZEND_ACC_HAS_TYPE_HINTS; + if (import_name) { + *is_fully_qualified = 1; + return zend_string_copy(import_name); + } } -} -/* }}} */ - -int zend_do_begin_function_call(znode *function_name, zend_bool check_namespace TSRMLS_DC) /* {{{ */ -{ - zend_op *opline; - uint32_t op_number; - zend_function *function; - zend_string *lcname; - char *is_compound = memchr(Z_STRVAL(function_name->u.constant), '\\', Z_STRLEN(function_name->u.constant)); - zend_resolve_function_name(function_name, &check_namespace TSRMLS_CC); - - if (check_namespace && Z_TYPE(CG(current_namespace)) != IS_UNDEF && !is_compound) { - /* We assume we call function from the current namespace - if it is not prefixed. */ - - /* In run-time PHP will check for function with full name and - internal function with short name */ - zend_do_begin_dynamic_function_call(function_name, 1 TSRMLS_CC); - return 1; + compound = memchr(name->val, '\\', name->len); + if (compound) { + *is_fully_qualified = 1; } - lcname = zend_string_alloc(Z_STRLEN(function_name->u.constant), 0); - zend_str_tolower_copy(lcname->val, Z_STRVAL(function_name->u.constant), Z_STRLEN(function_name->u.constant)); - if (((function = zend_hash_find_ptr(CG(function_table), lcname)) == NULL) || - ((CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_FUNCTIONS) && - (function->type == ZEND_INTERNAL_FUNCTION))) { - zend_do_begin_dynamic_function_call(function_name, 0 TSRMLS_CC); - efree(lcname); - return 1; /* Dynamic */ - } - zend_string_release(Z_STR(function_name->u.constant)); - Z_STR(function_name->u.constant) = lcname; - - op_number = get_next_op_number(CG(active_op_array)); - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_INIT_FCALL; - SET_UNUSED(opline->op1); - SET_NODE(opline->op2, function_name); - GET_CACHE_SLOT(opline->op2.constant); - - zend_push_function_call_entry(function, op_number TSRMLS_CC); - zend_do_extended_fcall_begin(TSRMLS_C); - return 0; -} -/* }}} */ - -void zend_do_begin_method_call(znode *left_bracket TSRMLS_DC) /* {{{ */ -{ - zend_op *last_op; - int last_op_number; - - zend_do_end_variable_parse(left_bracket, BP_VAR_R, 0 TSRMLS_CC); - zend_do_begin_variable_parse(TSRMLS_C); - - last_op_number = get_next_op_number(CG(active_op_array))-1; - last_op = &CG(active_op_array)->opcodes[last_op_number]; - - if ((last_op->op2_type == IS_CONST) && (Z_TYPE(CONSTANT(last_op->op2.constant)) == IS_STRING) && (Z_STRLEN(CONSTANT(last_op->op2.constant)) == sizeof(ZEND_CLONE_FUNC_NAME)-1) - && !zend_binary_strcasecmp(Z_STRVAL(CONSTANT(last_op->op2.constant)), Z_STRLEN(CONSTANT(last_op->op2.constant)), ZEND_CLONE_FUNC_NAME, sizeof(ZEND_CLONE_FUNC_NAME)-1)) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot call __clone() method on objects - use 'clone $obj' instead"); - } + if (compound && CG(current_import)) { + /* If the first part of a qualified name is an alias, substitute it. */ + size_t len = compound - name->val; + zend_string *import_name = zend_hash_find_ptr_lc(CG(current_import), name->val, len); - if (last_op->opcode == ZEND_FETCH_OBJ_R) { - if (last_op->op2_type == IS_CONST) { - zval name; - name = CONSTANT(last_op->op2.constant); - if (Z_TYPE(name) != IS_STRING) { - zend_error_noreturn(E_COMPILE_ERROR, "Method name must be a string"); - } - Z_STR(name) = zend_string_copy(Z_STR(name)); - FREE_POLYMORPHIC_CACHE_SLOT(last_op->op2.constant); - last_op->op2.constant = - zend_add_func_name_literal(CG(active_op_array), &name TSRMLS_CC); - GET_POLYMORPHIC_CACHE_SLOT(last_op->op2.constant); - } - last_op->opcode = ZEND_INIT_METHOD_CALL; - last_op->result_type = IS_UNUSED; - Z_LVAL(left_bracket->u.constant) = ZEND_INIT_FCALL_BY_NAME; - } else { - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_INIT_FCALL_BY_NAME; - SET_UNUSED(opline->op1); - if (left_bracket->op_type == IS_CONST) { - opline->op2_type = IS_CONST; - opline->op2.constant = zend_add_func_name_literal(CG(active_op_array), &left_bracket->u.constant TSRMLS_CC); - GET_CACHE_SLOT(opline->op2.constant); - } else { - SET_NODE(opline->op2, left_bracket); + if (import_name) { + return zend_concat_names( + import_name->val, import_name->len, name->val + len + 1, name->len - len - 1); } } - zend_push_function_call_entry(NULL, last_op_number TSRMLS_CC); - zend_do_extended_fcall_begin(TSRMLS_C); + return zend_prefix_with_ns(name TSRMLS_CC); } /* }}} */ -void zend_do_clone(znode *result, znode *expr TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - opline->opcode = ZEND_CLONE; - SET_NODE(opline->op1, expr); - SET_UNUSED(opline->op2); - opline->result_type = IS_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - GET_NODE(result, opline->result); +zend_string *zend_resolve_function_name( + zend_string *name, uint32_t type, zend_bool *is_fully_qualified TSRMLS_DC +) { + return zend_resolve_non_class_name( + name, type, is_fully_qualified, 0, CG(current_import_function) TSRMLS_CC); } -/* }}} */ - -void zend_do_begin_dynamic_function_call(znode *function_name, int ns_call TSRMLS_DC) /* {{{ */ -{ - uint32_t op_number; - zend_op *opline; - - op_number = get_next_op_number(CG(active_op_array)); - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - if (ns_call) { - /* In run-time PHP will check for function with full name and - internal function with short name */ - opline->opcode = ZEND_INIT_NS_FCALL_BY_NAME; - SET_UNUSED(opline->op1); - opline->op2_type = IS_CONST; - opline->op2.constant = zend_add_ns_func_name_literal(CG(active_op_array), &function_name->u.constant TSRMLS_CC); - GET_CACHE_SLOT(opline->op2.constant); - } else { - opline->opcode = ZEND_INIT_FCALL_BY_NAME; - SET_UNUSED(opline->op1); - if (function_name->op_type == IS_CONST) { - opline->op2_type = IS_CONST; - opline->op2.constant = zend_add_func_name_literal(CG(active_op_array), &function_name->u.constant TSRMLS_CC); - GET_CACHE_SLOT(opline->op2.constant); - } else { - SET_NODE(opline->op2, function_name); - } - } - zend_push_function_call_entry(NULL, op_number TSRMLS_CC); - zend_do_extended_fcall_begin(TSRMLS_C); +zend_string *zend_resolve_const_name( + zend_string *name, uint32_t type, zend_bool *is_fully_qualified TSRMLS_DC +) { + return zend_resolve_non_class_name( + name, type, is_fully_qualified, 1, CG(current_import_const) TSRMLS_CC); } -/* }}} */ -void zend_resolve_non_class_name(znode *element_name, zend_bool *check_namespace, zend_bool case_sensitive, HashTable *current_import_sub TSRMLS_DC) /* {{{ */ -{ - znode tmp; - int len; - zval *ns; - zend_string *lookup_name; - char *compound = memchr(Z_STRVAL(element_name->u.constant), '\\', Z_STRLEN(element_name->u.constant)); - - if (Z_STRVAL(element_name->u.constant)[0] == '\\') { - /* name starts with \ so it is known and unambiguos, nothing to do here but shorten it */ - memmove(Z_STRVAL(element_name->u.constant), Z_STRVAL(element_name->u.constant)+1, Z_STRLEN(element_name->u.constant)); - --Z_STRLEN(element_name->u.constant); - return; - } +zend_string *zend_resolve_class_name( + zend_string *name, uint32_t type TSRMLS_DC +) { + char *compound; - if(!*check_namespace) { - return; + if (type == ZEND_NAME_RELATIVE) { + return zend_prefix_with_ns(name TSRMLS_CC); } - if (current_import_sub) { - len = Z_STRLEN(element_name->u.constant); - if (case_sensitive) { - lookup_name = zend_string_init(Z_STRVAL(element_name->u.constant), len, 0); + if (type == ZEND_NAME_FQ || name->val[0] == '\\') { + /* Remove \ prefix (only relevant if this is a string rather than a label) */ + if (name->val[0] == '\\') { + name = zend_string_init(name->val + 1, name->len - 1, 0); } else { - lookup_name = zend_string_alloc(len, 0); - zend_str_tolower_copy(lookup_name->val, Z_STRVAL(element_name->u.constant), len); - } - /* Check if function/const matches imported name */ - if ((ns = zend_hash_find(current_import_sub, lookup_name)) != NULL) { - zval_dtor(&element_name->u.constant); - ZVAL_DUP(&element_name->u.constant, ns); - zend_string_free(lookup_name); - *check_namespace = 0; - return; + zend_string_addref(name); } - zend_string_free(lookup_name); - } - - if (compound && CG(current_import)) { - len = compound - Z_STRVAL(element_name->u.constant); - /* namespace is always lowercase */ - lookup_name = zend_string_alloc(len, 0); - zend_str_tolower_copy(lookup_name->val, Z_STRVAL(element_name->u.constant), len); - /* Check if first part of compound name is an import name */ - if ((ns = zend_hash_find(CG(current_import), lookup_name)) != NULL) { - /* Substitute import name */ - tmp.op_type = IS_CONST; - ZVAL_DUP(&tmp.u.constant, ns); - len += 1; - Z_STRLEN(element_name->u.constant) -= len; - memmove(Z_STRVAL(element_name->u.constant), Z_STRVAL(element_name->u.constant)+len, Z_STRLEN(element_name->u.constant)+1); - zend_do_build_namespace_name(&tmp, &tmp, element_name TSRMLS_CC); - *element_name = tmp; - zend_string_free(lookup_name); - *check_namespace = 0; - return; + /* Ensure that \self, \parent and \static are not used */ + if (ZEND_FETCH_CLASS_DEFAULT != zend_get_class_fetch_type(name)) { + zend_error_noreturn(E_COMPILE_ERROR, "'\\%s' is an invalid class name", name->val); } - zend_string_free(lookup_name); - } - - if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) { - tmp = *element_name; - Z_STR(tmp.u.constant) = zend_string_alloc(sizeof("\\")-1 + Z_STRLEN(element_name->u.constant) + Z_STRLEN(CG(current_namespace)), 0); - Z_TYPE_FLAGS(tmp.u.constant) = IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE; - memcpy(Z_STRVAL(tmp.u.constant), Z_STRVAL(CG(current_namespace)), Z_STRLEN(CG(current_namespace))); - memcpy(&(Z_STRVAL(tmp.u.constant)[Z_STRLEN(CG(current_namespace))]), "\\", sizeof("\\")-1); - memcpy(&(Z_STRVAL(tmp.u.constant)[Z_STRLEN(CG(current_namespace)) + sizeof("\\")-1]), Z_STRVAL(element_name->u.constant), Z_STRLEN(element_name->u.constant)+1); - zend_string_release(Z_STR(element_name->u.constant)); - *element_name = tmp; + return name; } -} -/* }}} */ - -void zend_resolve_function_name(znode *element_name, zend_bool *check_namespace TSRMLS_DC) /* {{{ */ -{ - zend_resolve_non_class_name(element_name, check_namespace, 0, CG(current_import_function) TSRMLS_CC); -} -/* }}} */ - -void zend_resolve_const_name(znode *element_name, zend_bool *check_namespace TSRMLS_DC) /* {{{ */ -{ - zend_resolve_non_class_name(element_name, check_namespace, 1, CG(current_import_const) TSRMLS_CC); -} -/* }}} */ - -void zend_do_resolve_class_name(znode *result, znode *class_name, int is_static TSRMLS_DC) /* {{{ */ -{ - char *lcname; - int lctype; - znode constant_name; - lcname = zend_str_tolower_dup(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant)); - lctype = zend_get_class_fetch_type(lcname, strlen(lcname)); - switch (lctype) { - case ZEND_FETCH_CLASS_SELF: - if (!CG(active_class_entry)) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot access self::class when no class scope is active"); - } - zval_dtor(&class_name->u.constant); - class_name->op_type = IS_CONST; - ZVAL_STR(&class_name->u.constant, zend_string_copy(CG(active_class_entry)->name)); - *result = *class_name; - break; - case ZEND_FETCH_CLASS_STATIC: - case ZEND_FETCH_CLASS_PARENT: - if (is_static) { - zend_error_noreturn(E_COMPILE_ERROR, - "%s::class cannot be used for compile-time class name resolution", - lctype == ZEND_FETCH_CLASS_STATIC ? "static" : "parent" - ); - } - if (!CG(active_class_entry)) { - zend_error_noreturn(E_COMPILE_ERROR, - "Cannot access %s::class when no class scope is active", - lctype == ZEND_FETCH_CLASS_STATIC ? "static" : "parent" - ); - } - constant_name.op_type = IS_CONST; - ZVAL_STRINGL(&constant_name.u.constant, "class", sizeof("class")-1); - zend_do_fetch_constant(result, class_name, &constant_name, ZEND_RT, 1 TSRMLS_CC); - break; - case ZEND_FETCH_CLASS_DEFAULT: - zend_resolve_class_name(class_name TSRMLS_CC); - *result = *class_name; - break; - } - - efree(lcname); - -} -/* }}} */ - -void zend_resolve_class_name(znode *class_name TSRMLS_DC) /* {{{ */ -{ - char *compound; - zend_string *lcname; - zval *ns; - znode tmp; - int len; - - compound = memchr(Z_STRVAL(class_name->u.constant), '\\', Z_STRLEN(class_name->u.constant)); - if (compound) { - /* This is a compound class name that contains namespace prefix */ - if (Z_STRVAL(class_name->u.constant)[0] == '\\') { - /* The STRING name has "\" prefix */ - memmove(Z_STRVAL(class_name->u.constant), Z_STRVAL(class_name->u.constant)+1, Z_STRLEN(class_name->u.constant)); - Z_STR(class_name->u.constant) = zend_string_realloc( - Z_STR(class_name->u.constant), - Z_STRLEN(class_name->u.constant) - 1, 0); - Z_TYPE_FLAGS(class_name->u.constant) = IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE; - - if (ZEND_FETCH_CLASS_DEFAULT != zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant))) { - zend_error_noreturn(E_COMPILE_ERROR, "'\\%s' is an invalid class name", Z_STRVAL(class_name->u.constant)); + if (CG(current_import)) { + compound = memchr(name->val, '\\', name->len); + if (compound) { + /* If the first part of a qualified name is an alias, substitute it. */ + size_t len = compound - name->val; + zend_string *import_name = zend_hash_find_ptr_lc(CG(current_import), name->val, len); + + if (import_name) { + return zend_concat_names( + import_name->val, import_name->len, name->val + len + 1, name->len - len - 1); } } else { - if (CG(current_import)) { - len = compound - Z_STRVAL(class_name->u.constant); - lcname = zend_string_alloc(len, 0); - zend_str_tolower_copy(lcname->val, Z_STRVAL(class_name->u.constant), len); - /* Check if first part of compound name is an import name */ - if ((ns = zend_hash_find(CG(current_import), lcname)) != NULL) { - /* Substitute import name */ - tmp.op_type = IS_CONST; - ZVAL_DUP(&tmp.u.constant, ns); - len += 1; - Z_STRLEN(class_name->u.constant) -= len; - memmove(Z_STRVAL(class_name->u.constant), Z_STRVAL(class_name->u.constant)+len, Z_STRLEN(class_name->u.constant)+1); - zend_do_build_namespace_name(&tmp, &tmp, class_name TSRMLS_CC); - *class_name = tmp; - zend_string_free(lcname); - return; - } - zend_string_free(lcname); - } - /* Here name is not prefixed with \ and not imported */ - if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) { - tmp.op_type = IS_CONST; - ZVAL_DUP(&tmp.u.constant, &CG(current_namespace)); - zend_do_build_namespace_name(&tmp, &tmp, class_name TSRMLS_CC); - *class_name = tmp; + /* If an unqualified name is an alias, replace it. */ + zend_string *import_name + = zend_hash_find_ptr_lc(CG(current_import), name->val, name->len); + + if (import_name) { + return zend_string_copy(import_name); } } - } else if (CG(current_import) || Z_TYPE(CG(current_namespace)) != IS_UNDEF) { - /* this is a plain name (without \) */ - lcname = zend_string_alloc(Z_STRLEN(class_name->u.constant), 0); - zend_str_tolower_copy(lcname->val, Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant)); - - if (CG(current_import) && - (ns = zend_hash_find(CG(current_import), lcname)) != NULL) { - /* The given name is an import name. Substitute it. */ - zval_dtor(&class_name->u.constant); - ZVAL_DUP(&class_name->u.constant, ns); - } else if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) { - /* plain name, no import - prepend current namespace to it */ - tmp.op_type = IS_CONST; - ZVAL_DUP(&tmp.u.constant, &CG(current_namespace)); - zend_do_build_namespace_name(&tmp, &tmp, class_name TSRMLS_CC); - *class_name = tmp; - } - zend_string_free(lcname); } -} -/* }}} */ - -void zend_do_fetch_class(znode *result, znode *class_name TSRMLS_DC) /* {{{ */ -{ - zend_long fetch_class_op_number; - zend_op *opline; - - fetch_class_op_number = get_next_op_number(CG(active_op_array)); - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_FETCH_CLASS; - SET_UNUSED(opline->op1); - opline->extended_value = ZEND_FETCH_CLASS_DEFAULT; - CG(catch_begin) = fetch_class_op_number; - if (class_name->op_type == IS_CONST) { - int fetch_type; + /* If not fully qualified and not an alias, prepend the current namespace */ + return zend_prefix_with_ns(name TSRMLS_CC); +} - fetch_type = zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant)); - switch (fetch_type) { - case ZEND_FETCH_CLASS_SELF: - case ZEND_FETCH_CLASS_PARENT: - case ZEND_FETCH_CLASS_STATIC: - SET_UNUSED(opline->op2); - opline->extended_value = fetch_type; - zval_dtor(&class_name->u.constant); - break; - default: - zend_resolve_class_name(class_name TSRMLS_CC); - opline->op2_type = IS_CONST; - opline->op2.constant = - zend_add_class_name_literal(CG(active_op_array), &class_name->u.constant TSRMLS_CC); - break; - } - } else { - SET_NODE(opline->op2, class_name); - } - opline->result.var = get_temporary_variable(CG(active_op_array)); - opline->result_type = IS_VAR; /* FIXME: Hack so that INIT_FCALL_BY_NAME still knows this is a class */ - GET_NODE(result, opline->result); - result->EA = opline->extended_value; +zend_string *zend_resolve_class_name_ast(zend_ast *ast TSRMLS_DC) { + zend_string *name = zend_ast_get_str(ast); + return zend_resolve_class_name(name, ast->attr TSRMLS_CC); } -/* }}} */ static void ptr_dtor(zval *zv) /* {{{ */ { @@ -2343,26 +812,9 @@ static void ptr_dtor(zval *zv) /* {{{ */ } /* }}} */ -void zend_do_label(znode *label TSRMLS_DC) /* {{{ */ -{ - zend_label dest; - - if (!CG(context).labels) { - ALLOC_HASHTABLE(CG(context).labels); - zend_hash_init(CG(context).labels, 8, NULL, ptr_dtor, 0); - } - - dest.brk_cont = CG(context).current_brk_cont; - dest.opline_num = get_next_op_number(CG(active_op_array)); - - if (zend_hash_add_mem(CG(context).labels, Z_STR(label->u.constant), &dest, sizeof(zend_label)) == NULL) { - zend_error_noreturn(E_COMPILE_ERROR, "Label '%s' already defined", Z_STRVAL(label->u.constant)); - } - - /* Done with label now */ - zval_dtor(&label->u.constant); +static void str_dtor(zval *zv) { + zend_string_release(Z_STR_P(zv)); } -/* }}} */ void zend_resolve_goto_label(zend_op_array *op_array, zend_op *opline, int pass2 TSRMLS_DC) /* {{{ */ { @@ -2424,18 +876,6 @@ void zend_resolve_goto_label(zend_op_array *op_array, zend_op *opline, int pass2 } /* }}} */ -void zend_do_goto(znode *label TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - opline->opcode = ZEND_GOTO; - opline->extended_value = CG(context).current_brk_cont; - SET_UNUSED(opline->op1); - SET_NODE(opline->op2, label); - zend_resolve_goto_label(CG(active_op_array), opline, 0 TSRMLS_CC); -} -/* }}} */ - void zend_release_labels(int temporary TSRMLS_DC) /* {{{ */ { if (CG(context).labels) { @@ -2451,658 +891,7 @@ void zend_release_labels(int temporary TSRMLS_DC) /* {{{ */ } /* }}} */ -void zend_do_build_full_name(znode *result, znode *prefix, znode *name, int is_class_member TSRMLS_DC) /* {{{ */ -{ - uint32_t length; - - if (!result) { - result = prefix; - } else { - *result = *prefix; - } - - if (is_class_member) { - int old_len = Z_STRLEN(result->u.constant); - length = sizeof("::")-1 + old_len + Z_STRLEN(name->u.constant); - Z_STR(result->u.constant) = zend_string_realloc(Z_STR(result->u.constant), length, 0); - Z_TYPE_FLAGS(result->u.constant) = IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE; - memcpy(&Z_STRVAL(result->u.constant)[old_len], "::", sizeof("::")-1); - memcpy(&Z_STRVAL(result->u.constant)[old_len + sizeof("::")-1], Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant)+1); - zend_string_release(Z_STR(name->u.constant)); - } else { - int old_len = Z_STRLEN(result->u.constant); - length = sizeof("\\")-1 + old_len + Z_STRLEN(name->u.constant); - Z_STR(result->u.constant) = zend_string_realloc(Z_STR(result->u.constant), length, 0); - Z_TYPE_FLAGS(result->u.constant) = IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE; - memcpy(&Z_STRVAL(result->u.constant)[old_len], "\\", sizeof("\\")-1); - memcpy(&Z_STRVAL(result->u.constant)[old_len + sizeof("\\")-1], Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant)+1); - zend_string_release(Z_STR(name->u.constant)); - } -} -/* }}} */ - -int zend_do_begin_class_member_function_call(znode *class_name, znode *method_name TSRMLS_DC) /* {{{ */ -{ - znode class_node; - uint32_t op_number; - zend_op *opline; - - if (method_name->op_type == IS_CONST) { - char *lcname; - if (Z_TYPE(method_name->u.constant) != IS_STRING) { - zend_error_noreturn(E_COMPILE_ERROR, "Method name must be a string"); - } - lcname = zend_str_tolower_dup(Z_STRVAL(method_name->u.constant), Z_STRLEN(method_name->u.constant)); - if ((sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)-1) == Z_STRLEN(method_name->u.constant) && - memcmp(lcname, ZEND_CONSTRUCTOR_FUNC_NAME, sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)-1) == 0) { - zval_dtor(&method_name->u.constant); - method_name->op_type = IS_UNUSED; - } - efree(lcname); - } - - if (class_name->op_type == IS_CONST && - ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant))) { - zend_resolve_class_name(class_name TSRMLS_CC); - class_node = *class_name; - op_number = get_next_op_number(CG(active_op_array)); - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - } else { - zend_do_fetch_class(&class_node, class_name TSRMLS_CC); - op_number = get_next_op_number(CG(active_op_array)); - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - } - opline->opcode = ZEND_INIT_STATIC_METHOD_CALL; - if (class_node.op_type == IS_CONST) { - opline->op1_type = IS_CONST; - opline->op1.constant = - zend_add_class_name_literal(CG(active_op_array), &class_node.u.constant TSRMLS_CC); - } else { - SET_NODE(opline->op1, &class_node); - } - if (method_name->op_type == IS_CONST) { - opline->op2_type = IS_CONST; - opline->op2.constant = - zend_add_func_name_literal(CG(active_op_array), &method_name->u.constant TSRMLS_CC); - if (opline->op1_type == IS_CONST) { - GET_CACHE_SLOT(opline->op2.constant); - } else { - GET_POLYMORPHIC_CACHE_SLOT(opline->op2.constant); - } - } else { - SET_NODE(opline->op2, method_name); - } - - zend_push_function_call_entry(NULL, op_number TSRMLS_CC); - zend_do_extended_fcall_begin(TSRMLS_C); - return 1; /* Dynamic */ -} -/* }}} */ - -static int zend_do_convert_call(zend_op *init_opline, zend_op *opline, zend_long num_args, zend_function **func_ptr TSRMLS_DC) /* {{{ */ -{ - zval *function_name; - zend_string *lcname; - zend_function *function; - - *func_ptr = NULL; - if (opline->op1_type == IS_CONST && Z_TYPE(CONSTANT(opline->op1.constant)) == IS_STRING) { - function_name = &CONSTANT(opline->op1.constant); - lcname = zend_string_alloc(Z_STRLEN_P(function_name), 0); - zend_str_tolower_copy(lcname->val, Z_STRVAL_P(function_name), Z_STRLEN_P(function_name)); - if (((function = zend_hash_find_ptr(CG(function_table), lcname)) == NULL) || - ((CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_FUNCTIONS) && - (function->type == ZEND_INTERNAL_FUNCTION))) { - function = NULL; - zend_string_release(lcname); - opline->opcode = ZEND_INIT_USER_CALL; - opline->extended_value = num_args; - opline->op2_type = opline->op1_type; - opline->op2 = opline->op1; - opline->op1_type = IS_CONST; - opline->op1 = init_opline->op2; - SET_UNUSED(opline->result); - MAKE_NOP(init_opline); - return 1; - } else { - zend_string_release(Z_STR_P(function_name)); - Z_STR_P(function_name) = zend_new_interned_string(lcname TSRMLS_CC); - opline->opcode = ZEND_INIT_FCALL; - opline->extended_value = num_args; - opline->op2_type = IS_CONST; - opline->op2.constant = opline->op1.constant; - GET_CACHE_SLOT(opline->op2.constant); - SET_UNUSED(opline->op1); - SET_UNUSED(opline->result); - MAKE_NOP(init_opline); - *func_ptr = function; - return 1; - } - } else { - opline->opcode = ZEND_INIT_USER_CALL; - opline->extended_value = num_args; - opline->op2_type = opline->op1_type; - opline->op2 = opline->op1; - opline->op1_type = IS_CONST; - opline->op1 = init_opline->op2; - SET_UNUSED(opline->result); - MAKE_NOP(init_opline); - return 1; - } - return 0; -} -/* }}} */ - -static int zend_do_convert_call_user_func(zend_op *init_opline, uint32_t num_args TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = init_opline + 1; - int level = 0; - int converted = 0; - uint32_t arg_num = 0; - zend_function *func = NULL; - - while (1) { - switch (opline->opcode) { - case ZEND_SEND_VAL: - case ZEND_SEND_VAL_EX: - case ZEND_SEND_VAR: - case ZEND_SEND_VAR_EX: - case ZEND_SEND_VAR_NO_REF: - case ZEND_SEND_REF: - case ZEND_SEND_UNPACK: - if (level == 0) { - if (!converted) { - if (opline->opcode == ZEND_SEND_UNPACK) { - return 0; - } - if (!zend_do_convert_call(init_opline, opline, init_opline->extended_value - 1, &func TSRMLS_CC)) { - return 0; - } - converted = 1; - } else { - /* Use ZEND_SEND_USER instruction for parameters that may pass by reference */ - if (opline->opcode != ZEND_SEND_VAL && - (func == NULL || - ARG_SHOULD_BE_SENT_BY_REF(func, opline->op2.num-1))) { - opline->opcode = ZEND_SEND_USER; - } - opline->op2.num--; - } - if (++arg_num == num_args) { - return 1; - } - } - break; - case ZEND_INIT_FCALL_BY_NAME: - case ZEND_INIT_NS_FCALL_BY_NAME: - case ZEND_NEW: - case ZEND_INIT_METHOD_CALL: - case ZEND_INIT_STATIC_METHOD_CALL: - case ZEND_INIT_FCALL: - level++; - break; - case ZEND_DO_FCALL: - level--; - break; - } - opline++; - } -} -/* }}} */ - -static int zend_do_convert_call_user_func_array(zend_op *init_opline TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = init_opline + 1; - zend_op *send1 = NULL, *send2 = NULL; - int level = 0; - zend_function *func; - - do { - switch (opline->opcode) { - case ZEND_SEND_VAL: - case ZEND_SEND_VAL_EX: - case ZEND_SEND_VAR: - case ZEND_SEND_VAR_EX: - case ZEND_SEND_VAR_NO_REF: - case ZEND_SEND_REF: - case ZEND_SEND_UNPACK: - if (level == 0) { - if (opline->opcode == ZEND_SEND_UNPACK) { - return 0; - } - if (send1 == NULL) { - send1 = opline; - } else { - send2 = opline; - } - } - break; - case ZEND_INIT_FCALL_BY_NAME: - case ZEND_INIT_NS_FCALL_BY_NAME: - case ZEND_NEW: - case ZEND_INIT_METHOD_CALL: - case ZEND_INIT_STATIC_METHOD_CALL: - case ZEND_INIT_FCALL: - level++; - break; - case ZEND_DO_FCALL: - level--; - break; - } - opline++; - } while (send2 == NULL); - - if (!zend_do_convert_call(init_opline, send1, 0, &func TSRMLS_CC)) { - return 0; - } - - send2->opcode = ZEND_SEND_ARRAY; - send2->extended_value = 0; - send2->op2.num--; - return 1; -} -/* }}} */ - -static int zend_do_convert_strlen(zend_op *init_opline, znode *result TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = init_opline + 1; - zend_op *send = NULL; - int level = 0; - - do { - switch (opline->opcode) { - case ZEND_SEND_VAL: - case ZEND_SEND_VAL_EX: - case ZEND_SEND_VAR: - case ZEND_SEND_VAR_EX: - case ZEND_SEND_VAR_NO_REF: - case ZEND_SEND_REF: - case ZEND_SEND_UNPACK: - if (level == 0) { - if (opline->opcode == ZEND_SEND_UNPACK) { - return 0; - } - send = opline; - } - break; - case ZEND_INIT_FCALL_BY_NAME: - case ZEND_INIT_NS_FCALL_BY_NAME: - case ZEND_NEW: - case ZEND_INIT_METHOD_CALL: - case ZEND_INIT_STATIC_METHOD_CALL: - case ZEND_INIT_FCALL: - level++; - break; - case ZEND_DO_FCALL: - level--; - break; - } - opline++; - } while (send == NULL); - - MAKE_NOP(init_opline); - send->opcode = ZEND_STRLEN; - send->extended_value = 0; - SET_UNUSED(send->op2); - send->result.var = get_temporary_variable(CG(active_op_array)); - send->result_type = IS_TMP_VAR; - GET_NODE(result, send->result); - return 1; -} -/* }}} */ - -static int zend_do_convert_type_check(zend_op *init_opline, znode *result, uint32_t type TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = init_opline + 1; - zend_op *send = NULL; - int level = 0; - - do { - switch (opline->opcode) { - case ZEND_SEND_VAL: - case ZEND_SEND_VAL_EX: - case ZEND_SEND_VAR: - case ZEND_SEND_VAR_EX: - case ZEND_SEND_VAR_NO_REF: - case ZEND_SEND_REF: - case ZEND_SEND_UNPACK: - if (level == 0) { - if (opline->opcode == ZEND_SEND_UNPACK) { - return 0; - } - send = opline; - } - break; - case ZEND_INIT_FCALL_BY_NAME: - case ZEND_INIT_NS_FCALL_BY_NAME: - case ZEND_NEW: - case ZEND_INIT_METHOD_CALL: - case ZEND_INIT_STATIC_METHOD_CALL: - case ZEND_INIT_FCALL: - level++; - break; - case ZEND_DO_FCALL: - level--; - break; - } - opline++; - } while (send == NULL); - - MAKE_NOP(init_opline); - send->opcode = ZEND_TYPE_CHECK; - send->extended_value = type; - SET_UNUSED(send->op2); - send->result.var = get_temporary_variable(CG(active_op_array)); - send->result_type = IS_TMP_VAR; - GET_NODE(result, send->result); - return 1; -} -/* }}} */ - -static int zend_do_convert_defined(zend_op *init_opline, znode *result TSRMLS_DC) /* {{{ */ -{ - zval c; - zend_string *lc_name; - zend_op *opline = init_opline + 1; - - if (opline->opcode != ZEND_SEND_VAL || - opline->op1_type != IS_CONST || - Z_TYPE(CONSTANT(opline->op1.constant)) != IS_STRING - || zend_memrchr(Z_STRVAL(CONSTANT(opline->op1.constant)), '\\', Z_STRLEN(CONSTANT(opline->op1.constant))) != NULL - || zend_memrchr(Z_STRVAL(CONSTANT(opline->op1.constant)), ':', Z_STRLEN(CONSTANT(opline->op1.constant))) != NULL) { - return 0; - } - - MAKE_NOP(init_opline); - opline->opcode = ZEND_DEFINED; - opline->extended_value = 0; - GET_CACHE_SLOT(opline->op1.constant); - /* lowcase constant name */ - lc_name = zend_string_alloc(Z_STRLEN(CONSTANT(opline->op1.constant)), 0); - zend_str_tolower_copy(lc_name->val, Z_STRVAL(CONSTANT(opline->op1.constant)), Z_STRLEN(CONSTANT(opline->op1.constant))); - ZVAL_NEW_STR(&c, lc_name); - zend_add_literal(CG(active_op_array), &c TSRMLS_CC); - opline->result.var = get_temporary_variable(CG(active_op_array)); - opline->result_type = IS_TMP_VAR; - GET_NODE(result, opline->result); - return 1; -} -/* }}} */ - -void zend_do_end_function_call(znode *function_name, znode *result, int is_method, int is_dynamic_fcall TSRMLS_DC) /* {{{ */ -{ - zend_op *opline; - zend_function_call_entry *fcall = zend_stack_top(&CG(function_call_stack)); - - if (is_method && function_name && function_name->op_type == IS_UNUSED) { - /* clone */ - if (fcall->arg_num != 0) { - zend_error(E_WARNING, "Clone method does not require arguments"); - } - opline = &CG(active_op_array)->opcodes[Z_LVAL(function_name->u.constant)]; - } else { - uint32_t call_flags = 0; - - opline = &CG(active_op_array)->opcodes[fcall->op_number]; - opline->extended_value = fcall->arg_num; - - if (opline->opcode == ZEND_NEW) { - call_flags = ZEND_CALL_CTOR; - } else { - zend_function *func = fcall->fbc; - if (func && func->type == ZEND_INTERNAL_FUNCTION) { - /* Convert calls to some internal functions into built-ins */ - if (func->common.function_name->len == sizeof("call_user_func")-1 && - memcmp(func->common.function_name->val, "call_user_func", sizeof("call_user_func")-1) == 0) { - if (fcall->arg_num > 0) { - if (zend_do_convert_call_user_func(opline, fcall->arg_num TSRMLS_CC)) { - fcall->arg_num--; - } - } - } else if (func->common.function_name->len == sizeof("call_user_func_array")-1 && - memcmp(func->common.function_name->val, "call_user_func_array", sizeof("call_user_func_array")-1) == 0) { - if (fcall->arg_num == 2) { - if (zend_do_convert_call_user_func_array(opline TSRMLS_CC)) { - fcall->arg_num = 0; - } - } - } else if (func->common.function_name->len == sizeof("defined")-1 && - memcmp(func->common.function_name->val, "defined", sizeof("defined")-1) == 0) { - if (fcall->arg_num == 1) { - if (zend_do_convert_defined(opline, result TSRMLS_CC)) { - zend_stack_del_top(&CG(function_call_stack)); - return; - } - } - } else if ((CG(compiler_options) & ZEND_COMPILE_NO_BUILTIN_STRLEN) == 0 && - func->common.function_name->len == sizeof("strlen")-1 && - memcmp(func->common.function_name->val, "strlen", sizeof("strlen")-1) == 0) { - if (fcall->arg_num == 1) { - if (zend_do_convert_strlen(opline, result TSRMLS_CC)) { - zend_stack_del_top(&CG(function_call_stack)); - return; - } - } - } else if (func->common.function_name->len == sizeof("is_null")-1 && - memcmp(func->common.function_name->val, "is_null", sizeof("is_null")-1) == 0) { - if (fcall->arg_num == 1) { - if (zend_do_convert_type_check(opline, result, IS_NULL TSRMLS_CC)) { - zend_stack_del_top(&CG(function_call_stack)); - return; - } - } - } else if (func->common.function_name->len == sizeof("is_bool")-1 && - memcmp(func->common.function_name->val, "is_bool", sizeof("is_bool")-1) == 0) { - if (fcall->arg_num == 1) { - if (zend_do_convert_type_check(opline, result, _IS_BOOL TSRMLS_CC)) { - zend_stack_del_top(&CG(function_call_stack)); - return; - } - } - } else if (func->common.function_name->len == sizeof("is_long")-1 && - memcmp(func->common.function_name->val, "is_long", sizeof("is_long")-1) == 0) { - if (fcall->arg_num == 1) { - if (zend_do_convert_type_check(opline, result, IS_LONG TSRMLS_CC)) { - zend_stack_del_top(&CG(function_call_stack)); - return; - } - } - } else if (func->common.function_name->len == sizeof("is_float")-1 && - memcmp(func->common.function_name->val, "is_float", sizeof("is_float")-1) == 0) { - if (fcall->arg_num == 1) { - if (zend_do_convert_type_check(opline, result, IS_DOUBLE TSRMLS_CC)) { - zend_stack_del_top(&CG(function_call_stack)); - return; - } - } - } else if (func->common.function_name->len == sizeof("is_string")-1 && - memcmp(func->common.function_name->val, "is_string", sizeof("is_string")-1) == 0) { - if (fcall->arg_num == 1) { - if (zend_do_convert_type_check(opline, result, IS_STRING TSRMLS_CC)) { - zend_stack_del_top(&CG(function_call_stack)); - return; - } - } - } else if (func->common.function_name->len == sizeof("is_array")-1 && - memcmp(func->common.function_name->val, "is_array", sizeof("is_array")-1) == 0) { - if (fcall->arg_num == 1) { - if (zend_do_convert_type_check(opline, result, IS_ARRAY TSRMLS_CC)) { - zend_stack_del_top(&CG(function_call_stack)); - return; - } - } - } else if (func->common.function_name->len == sizeof("is_object")-1 && - memcmp(func->common.function_name->val, "is_object", sizeof("is_object")-1) == 0) { - if (fcall->arg_num == 1) { - if (zend_do_convert_type_check(opline, result, IS_OBJECT TSRMLS_CC)) { - zend_stack_del_top(&CG(function_call_stack)); - return; - } - } - } else if (func->common.function_name->len == sizeof("is_resouce")-1 && - memcmp(func->common.function_name->val, "is_resource", sizeof("is_resource")-1) == 0) { - if (fcall->arg_num == 1) { - if (zend_do_convert_type_check(opline, result, IS_RESOURCE TSRMLS_CC)) { - zend_stack_del_top(&CG(function_call_stack)); - return; - } - } - } - } - } - - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_DO_FCALL; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); - opline->op1.num = call_flags; - } - - opline->result.var = get_temporary_variable(CG(active_op_array)); - opline->result_type = IS_VAR; - GET_NODE(result, opline->result); - opline->extended_value = fcall->arg_num; - - zend_stack_del_top(&CG(function_call_stack)); -} -/* }}} */ - -void zend_do_pass_param(znode *param, zend_uchar op TSRMLS_DC) /* {{{ */ -{ - zend_op *opline; - int original_op = op; - zend_function_call_entry *fcall = zend_stack_top(&CG(function_call_stack)); - zend_function *function_ptr = fcall->fbc; - int send_by_reference = 0; - int send_function = 0; - - fcall->arg_num++; - - if (fcall->uses_argument_unpacking) { - zend_error_noreturn(E_COMPILE_ERROR, - "Cannot use positional argument after argument unpacking"); - } - - if (op == ZEND_SEND_VAR && (param->op_type & (IS_CONST|IS_TMP_VAR))) { - /* Function call was converted into builtin instruction */ - zend_llist *fetch_list_ptr = zend_stack_top(&CG(bp_stack)); - zend_llist_destroy(fetch_list_ptr); - zend_stack_del_top(&CG(bp_stack)); - original_op = op = ZEND_SEND_VAL; - } - - if (original_op == ZEND_SEND_REF) { - if (function_ptr && - function_ptr->common.function_name && - function_ptr->common.type == ZEND_USER_FUNCTION && - !ARG_SHOULD_BE_SENT_BY_REF(function_ptr, fcall->arg_num)) { - zend_error_noreturn(E_COMPILE_ERROR, - "Call-time pass-by-reference has been removed; " - "If you would like to pass argument by reference, modify the declaration of %s().", - function_ptr->common.function_name->val); - } else { - zend_error_noreturn(E_COMPILE_ERROR, "Call-time pass-by-reference has been removed"); - } - return; - } - - if (function_ptr) { - if (ARG_MAY_BE_SENT_BY_REF(function_ptr, fcall->arg_num)) { - if (op == ZEND_SEND_VAR && param->op_type & (IS_VAR|IS_CV)) { - send_by_reference = ZEND_ARG_SEND_BY_REF; - if (zend_is_function_or_method_call(param)) { - /* Method call */ - op = ZEND_SEND_VAR_NO_REF; - send_function = ZEND_ARG_SEND_FUNCTION | ZEND_ARG_SEND_SILENT; - } - } else { - op = ZEND_SEND_VAL; - } - } else if (ARG_SHOULD_BE_SENT_BY_REF(function_ptr, fcall->arg_num)) { - send_by_reference = ZEND_ARG_SEND_BY_REF; - } - } - - if (op == ZEND_SEND_VAR && zend_is_function_or_method_call(param)) { - /* Method call */ - op = ZEND_SEND_VAR_NO_REF; - send_function = ZEND_ARG_SEND_FUNCTION; - } else if (op == ZEND_SEND_VAL && (param->op_type & (IS_VAR|IS_CV))) { - op = ZEND_SEND_VAR_NO_REF; - } - - if (op!=ZEND_SEND_VAR_NO_REF && send_by_reference==ZEND_ARG_SEND_BY_REF) { - /* change to passing by reference */ - switch (param->op_type) { - case IS_VAR: - case IS_CV: - op = ZEND_SEND_REF; - break; - default: - zend_error_noreturn(E_COMPILE_ERROR, "Only variables can be passed by reference"); - break; - } - } - - if (original_op == ZEND_SEND_VAR) { - switch (op) { - case ZEND_SEND_VAR_NO_REF: - zend_do_end_variable_parse(param, BP_VAR_R, 0 TSRMLS_CC); - break; - case ZEND_SEND_VAR: - if (function_ptr) { - zend_do_end_variable_parse(param, BP_VAR_R, 0 TSRMLS_CC); - } else { - zend_do_end_variable_parse(param, BP_VAR_FUNC_ARG, fcall->arg_num TSRMLS_CC); - } - break; - case ZEND_SEND_REF: - zend_do_end_variable_parse(param, BP_VAR_W, 0 TSRMLS_CC); - break; - } - } - - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - if (op == ZEND_SEND_VAR_NO_REF) { - if (function_ptr) { - opline->extended_value = ZEND_ARG_COMPILE_TIME_BOUND | send_by_reference | send_function; - } else { - opline->extended_value = send_function; - } - } else { - if (!function_ptr) { - switch (op) { - case ZEND_SEND_VAL: - op = ZEND_SEND_VAL_EX; - break; - case ZEND_SEND_VAR: - op = ZEND_SEND_VAR_EX; - break; - } - } - } - opline->opcode = op; - SET_NODE(opline->op1, param); - opline->op2.opline_num = fcall->arg_num; - SET_UNUSED(opline->op2); -} -/* }}} */ - -void zend_do_unpack_params(znode *params TSRMLS_DC) /* {{{ */ -{ - zend_op *opline; - zend_function_call_entry *fcall = zend_stack_top(&CG(function_call_stack)); - - fcall->uses_argument_unpacking = 1; - - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_SEND_UNPACK; - SET_NODE(opline->op1, params); - SET_UNUSED(opline->op2); - opline->op2.num = fcall->arg_num; -} -/* }}} */ +static zend_bool zend_is_call(zend_ast *ast); static int generate_free_switch_expr(zend_switch_entry *switch_entry TSRMLS_DC) /* {{{ */ { @@ -3141,292 +930,25 @@ static int generate_free_foreach_copy(const zend_op *foreach_copy TSRMLS_DC) /* } /* }}} */ -void zend_do_return(znode *expr, int do_end_vparse TSRMLS_DC) /* {{{ */ -{ - zend_op *opline; - int start_op_number, end_op_number; - zend_bool returns_reference = (CG(active_op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0; - - /* The error for use of return inside a generator is thrown in pass_two. */ - - if (do_end_vparse) { - if (returns_reference && !zend_is_function_or_method_call(expr)) { - zend_do_end_variable_parse(expr, BP_VAR_W, 1 TSRMLS_CC); - } else { - zend_do_end_variable_parse(expr, BP_VAR_R, 0 TSRMLS_CC); - } - } - - start_op_number = get_next_op_number(CG(active_op_array)); - -#ifdef ZTS - zend_stack_apply_with_argument(&CG(switch_cond_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element, void *)) generate_free_switch_expr TSRMLS_CC); - zend_stack_apply_with_argument(&CG(foreach_copy_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element, void *)) generate_free_foreach_copy TSRMLS_CC); -#else - zend_stack_apply(&CG(switch_cond_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element)) generate_free_switch_expr); - zend_stack_apply(&CG(foreach_copy_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element)) generate_free_foreach_copy); -#endif - - end_op_number = get_next_op_number(CG(active_op_array)); - while (start_op_number < end_op_number) { - CG(active_op_array)->opcodes[start_op_number].extended_value |= EXT_TYPE_FREE_ON_RETURN; - start_op_number++; - } - - if (CG(context).in_finally) { - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_DISCARD_EXCEPTION; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); - } - - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - opline->opcode = returns_reference ? ZEND_RETURN_BY_REF : ZEND_RETURN; - - if (expr) { - SET_NODE(opline->op1, expr); - - if (!do_end_vparse) { - opline->extended_value = ZEND_RETURNS_VALUE; - } else if (zend_is_function_or_method_call(expr)) { - opline->extended_value = ZEND_RETURNS_FUNCTION; - } - } else { - opline->op1_type = IS_CONST; - LITERAL_NULL(opline->op1); - } - - SET_UNUSED(opline->op2); -} -/* }}} */ - -void zend_do_yield(znode *result, znode *value, znode *key, zend_bool is_variable TSRMLS_DC) /* {{{ */ +static uint32_t zend_add_try_element(uint32_t try_op TSRMLS_DC) /* {{{ */ { - zend_op *opline; - - if (!CG(active_op_array)->function_name) { - zend_error_noreturn(E_COMPILE_ERROR, "The \"yield\" expression can only be used inside a function"); - } - - CG(active_op_array)->fn_flags |= ZEND_ACC_GENERATOR; - - if (is_variable) { - if ((CG(active_op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) && !zend_is_function_or_method_call(value)) { - zend_do_end_variable_parse(value, BP_VAR_W, 1 TSRMLS_CC); - } else { - zend_do_end_variable_parse(value, BP_VAR_R, 0 TSRMLS_CC); - } - } - - opline = get_next_op(CG(active_op_array) TSRMLS_CC); + zend_op_array *op_array = CG(active_op_array); + uint32_t try_catch_offset = op_array->last_try_catch++; + zend_try_catch_element *elem; - opline->opcode = ZEND_YIELD; + op_array->try_catch_array = safe_erealloc( + op_array->try_catch_array, sizeof(zend_try_catch_element), op_array->last_try_catch, 0); - if (value) { - SET_NODE(opline->op1, value); + elem = &op_array->try_catch_array[try_catch_offset]; + elem->try_op = try_op; + elem->catch_op = 0; + elem->finally_op = 0; + elem->finally_end = 0; - if (is_variable && zend_is_function_or_method_call(value)) { - opline->extended_value = ZEND_RETURNS_FUNCTION; - } - } else { - SET_UNUSED(opline->op1); - } - - if (key) { - SET_NODE(opline->op2, key); - } else { - SET_UNUSED(opline->op2); - } - - opline->result_type = IS_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - GET_NODE(result, opline->result); -} -/* }}} */ - -static int zend_add_try_element(uint32_t try_op TSRMLS_DC) /* {{{ */ -{ - int try_catch_offset = CG(active_op_array)->last_try_catch++; - - CG(active_op_array)->try_catch_array = erealloc(CG(active_op_array)->try_catch_array, sizeof(zend_try_catch_element)*CG(active_op_array)->last_try_catch); - CG(active_op_array)->try_catch_array[try_catch_offset].try_op = try_op; - CG(active_op_array)->try_catch_array[try_catch_offset].catch_op = 0; - CG(active_op_array)->try_catch_array[try_catch_offset].finally_op = 0; - CG(active_op_array)->try_catch_array[try_catch_offset].finally_end = 0; return try_catch_offset; } /* }}} */ -static void zend_add_catch_element(int offset, uint32_t catch_op TSRMLS_DC) /* {{{ */ -{ - CG(active_op_array)->try_catch_array[offset].catch_op = catch_op; -} -/* }}} */ - -void zend_do_first_catch(znode *open_parentheses TSRMLS_DC) /* {{{ */ -{ - open_parentheses->u.op.opline_num = get_next_op_number(CG(active_op_array)); -} -/* }}} */ - -void zend_initialize_try_catch_element(znode *catch_token TSRMLS_DC) /* {{{ */ -{ - int jmp_op_number = get_next_op_number(CG(active_op_array)); - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - zend_llist jmp_list; - zend_llist *jmp_list_ptr; - - opline->opcode = ZEND_JMP; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); - /* save for backpatching */ - - zend_llist_init(&jmp_list, sizeof(int), NULL, 0); - zend_stack_push(&CG(bp_stack), (void *) &jmp_list); - jmp_list_ptr = zend_stack_top(&CG(bp_stack)); - zend_llist_add_element(jmp_list_ptr, &jmp_op_number); - - catch_token->EA = get_next_op_number(CG(active_op_array)); -} -/* }}} */ - -void zend_do_mark_last_catch(const znode *first_catch, const znode *last_additional_catch TSRMLS_DC) /* {{{ */ -{ - CG(active_op_array)->last--; - zend_do_if_end(TSRMLS_C); - if (last_additional_catch->u.op.opline_num == -1) { - CG(active_op_array)->opcodes[first_catch->u.op.opline_num].result.num = 1; - CG(active_op_array)->opcodes[first_catch->u.op.opline_num].extended_value = get_next_op_number(CG(active_op_array)); - } else { - CG(active_op_array)->opcodes[last_additional_catch->u.op.opline_num].result.num = 1; - CG(active_op_array)->opcodes[last_additional_catch->u.op.opline_num].extended_value = get_next_op_number(CG(active_op_array)); - } - DEC_BPC(CG(active_op_array)); -} -/* }}} */ - -void zend_do_try(znode *try_token TSRMLS_DC) /* {{{ */ -{ - try_token->u.op.opline_num = zend_add_try_element(get_next_op_number(CG(active_op_array)) TSRMLS_CC); - INC_BPC(CG(active_op_array)); -} -/* }}} */ - -void zend_do_finally(znode *finally_token TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - finally_token->u.op.opline_num = get_next_op_number(CG(active_op_array)); - /* call the the "finally" block */ - opline->opcode = ZEND_FAST_CALL; - SET_UNUSED(opline->op1); - opline->op1.opline_num = finally_token->u.op.opline_num + 1; - SET_UNUSED(opline->op2); - /* jump to code after the "finally" block, - * the actual jump address is going to be set in zend_do_end_finally() - */ - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_JMP; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); - - CG(context).in_finally++; -} -/* }}} */ - -void zend_do_begin_catch(znode *catch_token, znode *class_name, znode *catch_var, znode *first_catch TSRMLS_DC) /* {{{ */ -{ - zend_long catch_op_number; - zend_op *opline; - znode catch_class; - - if (class_name->op_type == IS_CONST && - ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant))) { - zend_resolve_class_name(class_name TSRMLS_CC); - catch_class = *class_name; - } else { - zend_error_noreturn(E_COMPILE_ERROR, "Bad class name in the catch statement"); - } - - catch_op_number = get_next_op_number(CG(active_op_array)); - if (first_catch) { - first_catch->u.op.opline_num = catch_op_number; - } - - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_CATCH; - opline->op1_type = IS_CONST; - opline->op1.constant = zend_add_class_name_literal(CG(active_op_array), &catch_class.u.constant TSRMLS_CC); - opline->op2_type = IS_CV; - opline->op2.var = lookup_cv(CG(active_op_array), Z_STR(catch_var->u.constant) TSRMLS_CC); - Z_STR(catch_var->u.constant) = CG(active_op_array)->vars[EX_VAR_TO_NUM(opline->op2.var)]; - opline->result.num = 0; /* 1 means it's the last catch in the block */ - - catch_token->u.op.opline_num = catch_op_number; -} -/* }}} */ - -void zend_do_end_catch(znode *catch_token TSRMLS_DC) /* {{{ */ -{ - int jmp_op_number = get_next_op_number(CG(active_op_array)); - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - zend_llist *jmp_list_ptr; - - opline->opcode = ZEND_JMP; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); - /* save for backpatching */ - - jmp_list_ptr = zend_stack_top(&CG(bp_stack)); - zend_llist_add_element(jmp_list_ptr, &jmp_op_number); - - CG(active_op_array)->opcodes[catch_token->u.op.opline_num].extended_value = get_next_op_number(CG(active_op_array)); -} -/* }}} */ - -void zend_do_bind_catch(znode *try_token, znode *catch_token TSRMLS_DC) /* {{{ */ { - if (catch_token->op_type != IS_UNUSED) { - zend_add_catch_element(try_token->u.op.opline_num, catch_token->EA TSRMLS_CC); - } -} -/* }}} */ - -void zend_do_end_finally(znode *try_token, znode* catch_token, znode *finally_token TSRMLS_DC) /* {{{ */ -{ - if (catch_token->op_type == IS_UNUSED && finally_token->op_type == IS_UNUSED) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use try without catch or finally"); - } - if (finally_token->op_type != IS_UNUSED) { - zend_op *opline; - - CG(active_op_array)->try_catch_array[try_token->u.op.opline_num].finally_op = finally_token->u.op.opline_num + 1; - CG(active_op_array)->try_catch_array[try_token->u.op.opline_num].finally_end = get_next_op_number(CG(active_op_array)); - CG(active_op_array)->has_finally_block = 1; - - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_FAST_RET; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); - - CG(active_op_array)->opcodes[finally_token->u.op.opline_num].op1.opline_num = get_next_op_number(CG(active_op_array)); - - CG(context).in_finally--; - } -} -/* }}} */ - -void zend_do_throw(znode *expr TSRMLS_DC) /* {{{ */ -{ - zend_op *opline; - - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_THROW; - SET_NODE(opline->op1, expr); - SET_UNUSED(opline->op2); -} -/* }}} */ - ZEND_API void function_add_ref(zend_function *function) /* {{{ */ { if (function->type == ZEND_USER_FUNCTION) { @@ -3727,7 +1249,7 @@ static zend_bool zend_do_perform_implementation_check(const zend_function *fe, c buf = erealloc(buf, length); \ } -static char * zend_get_function_declaration(zend_function *fptr TSRMLS_DC) /* {{{ */ +static char *zend_get_function_declaration(zend_function *fptr TSRMLS_DC) /* {{{ */ { char *offset, *buf; uint32_t length = 1024; @@ -3825,7 +1347,7 @@ static char * zend_get_function_declaration(zend_function *fptr TSRMLS_DC) /* {{ ++idx; while (op < end) { if ((op->opcode == ZEND_RECV || op->opcode == ZEND_RECV_INIT) - && op->op1.num == (zend_long)idx) + && op->op1.num == (long)idx) { precv = op; } @@ -5009,67 +2531,6 @@ ZEND_API int do_bind_function(const zend_op_array *op_array, zend_op *opline, Ha } /* }}} */ -void zend_prepare_reference(znode *result, znode *class_name, znode *method_name TSRMLS_DC) /* {{{ */ -{ - zend_trait_method_reference *method_ref = emalloc(sizeof(zend_trait_method_reference)); - method_ref->ce = NULL; - - /* REM: There should not be a need for copying, - zend_do_begin_class_declaration is also just using that string */ - if (class_name) { - zend_resolve_class_name(class_name TSRMLS_CC); - method_ref->class_name = Z_STR(class_name->u.constant); - } else { - method_ref->class_name = NULL; - } - - method_ref->method_name = Z_STR(method_name->u.constant); - - result->u.op.ptr = method_ref; - result->op_type = IS_TMP_VAR; -} -/* }}} */ - -void zend_add_trait_alias(znode *method_reference, znode *modifiers, znode *alias TSRMLS_DC) /* {{{ */ -{ - zend_class_entry *ce = CG(active_class_entry); - zend_trait_alias *trait_alias; - - if (Z_LVAL(modifiers->u.constant) == ZEND_ACC_STATIC) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use 'static' as method modifier"); - return; - } else if (Z_LVAL(modifiers->u.constant) == ZEND_ACC_ABSTRACT) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use 'abstract' as method modifier"); - return; - } else if (Z_LVAL(modifiers->u.constant) == ZEND_ACC_FINAL) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use 'final' as method modifier"); - return; - } - - trait_alias = emalloc(sizeof(zend_trait_alias)); - trait_alias->trait_method = (zend_trait_method_reference*)method_reference->u.op.ptr; - trait_alias->modifiers = Z_LVAL(modifiers->u.constant); - if (alias) { - trait_alias->alias = Z_STR(alias->u.constant); - } else { - trait_alias->alias = NULL; - } - zend_add_to_list(&ce->trait_aliases, trait_alias TSRMLS_CC); -} -/* }}} */ - -void zend_add_trait_precedence(znode *method_reference, znode *trait_list TSRMLS_DC) /* {{{ */ -{ - zend_class_entry *ce = CG(active_class_entry); - zend_trait_precedence *trait_precedence = emalloc(sizeof(zend_trait_precedence)); - - trait_precedence->trait_method = (zend_trait_method_reference*)method_reference->u.op.ptr; - trait_precedence->exclude_from_classes = trait_list->u.op.ptr; - - zend_add_to_list(&ce->trait_precedences, trait_precedence TSRMLS_CC); -} -/* }}} */ - ZEND_API zend_class_entry *do_bind_class(const zend_op_array* op_array, const zend_op *opline, HashTable *class_table, zend_bool compile_time TSRMLS_DC) /* {{{ */ { zend_class_entry *ce; @@ -5245,1315 +2706,1817 @@ ZEND_API void zend_do_delayed_early_binding(const zend_op_array *op_array TSRMLS } /* }}} */ -void zend_do_boolean_or_begin(znode *expr1, znode *op_token TSRMLS_DC) /* {{{ */ +ZEND_API zend_string *zend_mangle_property_name(const char *src1, int src1_length, const char *src2, int src2_length, int internal) /* {{{ */ { - int next_op_number = get_next_op_number(CG(active_op_array)); - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - opline->opcode = ZEND_JMPNZ_EX; - if (expr1->op_type == IS_TMP_VAR) { - SET_NODE(opline->result, expr1); - } else { - opline->result.var = get_temporary_variable(CG(active_op_array)); - opline->result_type = IS_TMP_VAR; - } - SET_NODE(opline->op1, expr1); - SET_UNUSED(opline->op2); - - op_token->u.op.opline_num = next_op_number; + zend_string *prop_name; + int prop_name_length; - GET_NODE(expr1, opline->result); + prop_name_length = 1 + src1_length + 1 + src2_length; + prop_name = zend_string_alloc(prop_name_length, internal); + prop_name->val[0] = '\0'; + memcpy(prop_name->val + 1, src1, src1_length+1); + memcpy(prop_name->val + 1 + src1_length + 1, src2, src2_length+1); + return prop_name; } /* }}} */ -void zend_do_boolean_or_end(znode *result, znode *expr1, znode *expr2, const znode *op_token TSRMLS_DC) /* {{{ */ +static int zend_strnlen(const char* s, int maxlen) /* {{{ */ { - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - *result = *expr1; /* we saved the original result in expr1 */ - opline->opcode = ZEND_BOOL; - SET_NODE(opline->result, result); - SET_NODE(opline->op1, expr2); - SET_UNUSED(opline->op2); - - CG(active_op_array)->opcodes[op_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array)); + int len = 0; + while (*s++ && maxlen--) len++; + return len; } /* }}} */ -void zend_do_boolean_and_begin(znode *expr1, znode *op_token TSRMLS_DC) /* {{{ */ +ZEND_API int zend_unmangle_property_name_ex(const char *mangled_property, int len, const char **class_name, const char **prop_name, int *prop_len) /* {{{ */ { - int next_op_number = get_next_op_number(CG(active_op_array)); - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + int class_name_len; - opline->opcode = ZEND_JMPZ_EX; - if (expr1->op_type == IS_TMP_VAR) { - SET_NODE(opline->result, expr1); - } else { - opline->result.var = get_temporary_variable(CG(active_op_array)); - opline->result_type = IS_TMP_VAR; - } - SET_NODE(opline->op1, expr1); - SET_UNUSED(opline->op2); + *class_name = NULL; - op_token->u.op.opline_num = next_op_number; + if (mangled_property[0]!=0) { + *prop_name = mangled_property; + if (prop_len) { + *prop_len = len; + } + return SUCCESS; + } + if (len < 3 || mangled_property[1]==0) { + zend_error(E_NOTICE, "Illegal member variable name"); + *prop_name = mangled_property; + if (prop_len) { + *prop_len = len; + } + return FAILURE; + } - GET_NODE(expr1, opline->result); + class_name_len = zend_strnlen(mangled_property + 1, --len - 1) + 1; + if (class_name_len >= len || mangled_property[class_name_len]!=0) { + zend_error(E_NOTICE, "Corrupt member variable name"); + *prop_name = mangled_property; + if (prop_len) { + *prop_len = len + 1; + } + return FAILURE; + } + *class_name = mangled_property + 1; + *prop_name = (*class_name) + class_name_len; + if (prop_len) { + *prop_len = len - class_name_len; + } + return SUCCESS; } /* }}} */ -void zend_do_boolean_and_end(znode *result, znode *expr1, znode *expr2, const znode *op_token TSRMLS_DC) /* {{{ */ +static zend_constant *zend_get_ct_const(zend_string *name, int all_internal_constants_substitution TSRMLS_DC) /* {{{ */ { - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + zend_constant *c = NULL; + char *lookup_name; - *result = *expr1; /* we saved the original result in expr1 */ - opline->opcode = ZEND_BOOL; - SET_NODE(opline->result, result); - SET_NODE(opline->op1, expr2); - SET_UNUSED(opline->op2); + if (name->val[0] == '\\') { + c = zend_hash_str_find_ptr(EG(zend_constants), name->val + 1, name->len - 1); + if (!c) { + lookup_name = zend_str_tolower_dup(name->val + 1, name->len - 1); + c = zend_hash_str_find_ptr(EG(zend_constants), lookup_name, name->len - 1); + efree(lookup_name); - CG(active_op_array)->opcodes[op_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array)); + if (c && (c->flags & CONST_CT_SUBST) && !(c->flags & CONST_CS)) { + return c; + } + return NULL; + } + } else if ((c = zend_hash_find_ptr(EG(zend_constants), name)) == NULL) { + lookup_name = zend_str_tolower_dup(name->val, name->len); + c = zend_hash_str_find_ptr(EG(zend_constants), lookup_name, name->len); + efree(lookup_name); + + if (c && (c->flags & CONST_CT_SUBST) && !(c->flags & CONST_CS)) { + return c; + } + return NULL; + } + + if (c->flags & CONST_CT_SUBST) { + return c; + } + if (all_internal_constants_substitution && + (c->flags & CONST_PERSISTENT) && + !(CG(compiler_options) & ZEND_COMPILE_NO_CONSTANT_SUBSTITUTION) && + !Z_CONSTANT(c->value)) { + return c; + } + return NULL; } /* }}} */ -void zend_do_do_while_begin(TSRMLS_D) /* {{{ */ +static int zend_constant_ct_subst(znode *result, zval *const_name, int all_internal_constants_substitution TSRMLS_DC) /* {{{ */ { - do_begin_loop(TSRMLS_C); - INC_BPC(CG(active_op_array)); + zend_constant *c = zend_get_ct_const(Z_STR_P(const_name), + all_internal_constants_substitution TSRMLS_CC); + + if (c) { + result->op_type = IS_CONST; + result->u.constant = c->value; + zval_copy_ctor(&result->u.constant); + return 1; + } + return 0; } /* }}} */ -void zend_do_do_while_end(const znode *do_token, const znode *expr_open_bracket, znode *expr TSRMLS_DC) /* {{{ */ +void zend_init_list(void *result, void *item TSRMLS_DC) /* {{{ */ { - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - opline->opcode = ZEND_JMPNZ; - SET_NODE(opline->op1, expr); - opline->op2.opline_num = do_token->u.op.opline_num; - SET_UNUSED(opline->op2); + void** list = emalloc(sizeof(void*) * 2); - do_end_loop(expr_open_bracket->u.op.opline_num, 0 TSRMLS_CC); + list[0] = item; + list[1] = NULL; - DEC_BPC(CG(active_op_array)); + *(void**)result = list; } /* }}} */ -void zend_do_brk_cont(zend_uchar op, znode *expr TSRMLS_DC) /* {{{ */ +void zend_add_to_list(void *result, void *item TSRMLS_DC) /* {{{ */ { - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + void** list = *(void**)result; + size_t n = 0; - opline->opcode = op; - opline->op1.opline_num = CG(context).current_brk_cont; - SET_UNUSED(opline->op1); - if (expr) { - if (expr->op_type != IS_CONST) { - zend_error_noreturn(E_COMPILE_ERROR, "'%s' operator with non-constant operand is no longer supported", op == ZEND_BRK ? "break" : "continue"); - } else if (Z_TYPE(expr->u.constant) != IS_LONG || Z_LVAL(expr->u.constant) < 1) { - zend_error_noreturn(E_COMPILE_ERROR, "'%s' operator accepts only positive numbers", op == ZEND_BRK ? "break" : "continue"); + if (list) { + while (list[n]) { + n++; } - SET_NODE(opline->op2, expr); - } else { - LITERAL_LONG(opline->op2, 1); - opline->op2_type = IS_CONST; } -} -/* }}} */ - -void zend_do_switch_cond(const znode *cond TSRMLS_DC) /* {{{ */ -{ - zend_switch_entry switch_entry; - switch_entry.cond = *cond; - switch_entry.default_case = -1; - switch_entry.control_var = -1; - zend_stack_push(&CG(switch_cond_stack), (void *) &switch_entry); + list = erealloc(list, sizeof(void*) * (n+2)); - do_begin_loop(TSRMLS_C); + list[n] = item; + list[n+1] = NULL; - INC_BPC(CG(active_op_array)); + *(void**)result = list; } /* }}} */ -void zend_do_switch_end(const znode *case_list TSRMLS_DC) /* {{{ */ +void zend_do_extended_info(TSRMLS_D) /* {{{ */ { zend_op *opline; - zend_switch_entry *switch_entry_ptr = zend_stack_top(&CG(switch_cond_stack)); - /* add code to jmp to default case */ - if (switch_entry_ptr->default_case != -1) { - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_JMP; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); - opline->op1.opline_num = switch_entry_ptr->default_case; + if (!(CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO)) { + return; } - if (case_list->op_type != IS_UNUSED) { /* non-empty switch */ - int next_op_number = get_next_op_number(CG(active_op_array)); + opline = get_next_op(CG(active_op_array) TSRMLS_CC); - CG(active_op_array)->opcodes[case_list->u.op.opline_num].op1.opline_num = next_op_number; - } + opline->opcode = ZEND_EXT_STMT; + SET_UNUSED(opline->op1); + SET_UNUSED(opline->op2); +} +/* }}} */ - /* remember break/continue loop information */ - CG(active_op_array)->brk_cont_array[CG(context).current_brk_cont].cont = CG(active_op_array)->brk_cont_array[CG(context).current_brk_cont].brk = get_next_op_number(CG(active_op_array)); - CG(context).current_brk_cont = CG(active_op_array)->brk_cont_array[CG(context).current_brk_cont].parent; +void zend_do_extended_fcall_begin(TSRMLS_D) /* {{{ */ +{ + zend_op *opline; - if (switch_entry_ptr->cond.op_type==IS_VAR || switch_entry_ptr->cond.op_type==IS_TMP_VAR) { - /* emit free for the switch condition*/ - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = (switch_entry_ptr->cond.op_type == IS_TMP_VAR) ? ZEND_FREE : ZEND_SWITCH_FREE; - SET_NODE(opline->op1, &switch_entry_ptr->cond); - SET_UNUSED(opline->op2); - } - if (switch_entry_ptr->cond.op_type == IS_CONST) { - zval_dtor(&switch_entry_ptr->cond.u.constant); + if (!(CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO)) { + return; } - zend_stack_del_top(&CG(switch_cond_stack)); + opline = get_next_op(CG(active_op_array) TSRMLS_CC); - DEC_BPC(CG(active_op_array)); + opline->opcode = ZEND_EXT_FCALL_BEGIN; + SET_UNUSED(opline->op1); + SET_UNUSED(opline->op2); } /* }}} */ -void zend_do_case_before_statement(const znode *case_list, znode *case_token, znode *case_expr TSRMLS_DC) /* {{{ */ +void zend_do_extended_fcall_end(TSRMLS_D) /* {{{ */ { - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - int next_op_number; - zend_switch_entry *switch_entry_ptr = zend_stack_top(&CG(switch_cond_stack)); - znode result; + zend_op *opline; - if (switch_entry_ptr->control_var == -1) { - switch_entry_ptr->control_var = get_temporary_variable(CG(active_op_array)); - } - opline->opcode = ZEND_CASE; - opline->result.var = switch_entry_ptr->control_var; - opline->result_type = IS_TMP_VAR; - SET_NODE(opline->op1, &switch_entry_ptr->cond); - SET_NODE(opline->op2, case_expr); - if (opline->op1_type == IS_CONST) { - zval_copy_ctor(&CONSTANT(opline->op1.constant)); + if (!(CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO)) { + return; } - GET_NODE(&result, opline->result); - next_op_number = get_next_op_number(CG(active_op_array)); opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_JMPZ; - SET_NODE(opline->op1, &result); - SET_UNUSED(opline->op2); - case_token->u.op.opline_num = next_op_number; - if (case_list->op_type==IS_UNUSED) { - return; - } - next_op_number = get_next_op_number(CG(active_op_array)); - CG(active_op_array)->opcodes[case_list->u.op.opline_num].op1.opline_num = next_op_number; + opline->opcode = ZEND_EXT_FCALL_END; + SET_UNUSED(opline->op1); + SET_UNUSED(opline->op2); } /* }}} */ -void zend_do_case_after_statement(znode *result, const znode *case_token TSRMLS_DC) /* {{{ */ +zend_bool zend_is_auto_global(zend_string *name TSRMLS_DC) /* {{{ */ { - int next_op_number = get_next_op_number(CG(active_op_array)); - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - opline->opcode = ZEND_JMP; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); - result->u.op.opline_num = next_op_number; + zend_auto_global *auto_global; - switch (CG(active_op_array)->opcodes[case_token->u.op.opline_num].opcode) { - case ZEND_JMP: - CG(active_op_array)->opcodes[case_token->u.op.opline_num].op1.opline_num = get_next_op_number(CG(active_op_array)); - break; - case ZEND_JMPZ: - CG(active_op_array)->opcodes[case_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array)); - break; + if ((auto_global = zend_hash_find_ptr(CG(auto_globals), name)) != NULL) { + if (auto_global->armed) { + auto_global->armed = auto_global->auto_global_callback(auto_global->name TSRMLS_CC); + } + return 1; } + return 0; } /* }}} */ -void zend_do_default_before_statement(const znode *case_list, znode *default_token TSRMLS_DC) /* {{{ */ +int zend_register_auto_global(zend_string *name, zend_bool jit, zend_auto_global_callback auto_global_callback TSRMLS_DC) /* {{{ */ { - int next_op_number = get_next_op_number(CG(active_op_array)); - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - zend_switch_entry *switch_entry_ptr = zend_stack_top(&CG(switch_cond_stack)); + zend_auto_global auto_global; + int retval; - opline->opcode = ZEND_JMP; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); - default_token->u.op.opline_num = next_op_number; + auto_global.name = zend_new_interned_string(name TSRMLS_CC); + auto_global.auto_global_callback = auto_global_callback; + auto_global.jit = jit; - next_op_number = get_next_op_number(CG(active_op_array)); - switch_entry_ptr->default_case = next_op_number; + retval = zend_hash_add_mem(CG(auto_globals), name, &auto_global, sizeof(zend_auto_global)) != NULL ? SUCCESS : FAILURE; - if (case_list->op_type==IS_UNUSED) { - return; - } - CG(active_op_array)->opcodes[case_list->u.op.opline_num].op1.opline_num = next_op_number; + zend_string_release(auto_global.name); + return retval; } /* }}} */ -void zend_do_begin_class_declaration(const znode *class_token, znode *class_name, const znode *parent_class_name TSRMLS_DC) /* {{{ */ +ZEND_API void zend_activate_auto_globals(TSRMLS_D) /* {{{ */ { - zend_op *opline; - int doing_inheritance = 0; - zend_class_entry *new_class_entry; - zend_string *lcname; - int error = 0; - zval *ns_name, key; - - if (CG(active_class_entry)) { - zend_error_noreturn(E_COMPILE_ERROR, "Class declarations may not be nested"); - return; - } + zend_auto_global *auto_global; - lcname = zend_string_alloc(Z_STRLEN(class_name->u.constant), 0); - zend_str_tolower_copy(lcname->val, Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant)); + ZEND_HASH_FOREACH_PTR(CG(auto_globals), auto_global) { + if (auto_global->jit) { + auto_global->armed = 1; + } else if (auto_global->auto_global_callback) { + auto_global->armed = auto_global->auto_global_callback(auto_global->name TSRMLS_CC); + } else { + auto_global->armed = 0; + } + } ZEND_HASH_FOREACH_END(); +} +/* }}} */ - if (!(strcmp(lcname->val, "self") && strcmp(lcname->val, "parent"))) { - zend_string_free(lcname); - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as class name as it is reserved", Z_STRVAL(class_name->u.constant)); - } +int zendlex(zend_parser_stack_elem *elem TSRMLS_DC) /* {{{ */ +{ + zval zv; + int retval; - /* Class name must not conflict with import names */ - if (CG(current_import) && - (ns_name = zend_hash_find(CG(current_import), lcname)) != NULL) { - error = 1; + if (CG(increment_lineno)) { + CG(zend_lineno)++; + CG(increment_lineno) = 0; } - if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) { - /* Prefix class name with name of current namespace */ - znode tmp; +again: + ZVAL_UNDEF(&zv); + retval = lex_scan(&zv TSRMLS_CC); + switch (retval) { + case T_COMMENT: + case T_DOC_COMMENT: + case T_OPEN_TAG: + case T_WHITESPACE: + goto again; - tmp.op_type = IS_CONST; - ZVAL_DUP(&tmp.u.constant, &CG(current_namespace)); - zend_do_build_namespace_name(&tmp, &tmp, class_name TSRMLS_CC); - *class_name = tmp; - zend_string_free(lcname); - lcname = zend_string_alloc(Z_STRLEN(class_name->u.constant), 0); - zend_str_tolower_copy(lcname->val, Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant)); + case T_CLOSE_TAG: + if (LANG_SCNG(yy_text)[LANG_SCNG(yy_leng)-1] != '>') { + CG(increment_lineno) = 1; + } + if (CG(has_bracketed_namespaces) && !CG(in_namespace)) { + goto again; + } + retval = ';'; /* implicit ; */ + break; + case T_OPEN_TAG_WITH_ECHO: + retval = T_ECHO; + break; + } + if (Z_TYPE(zv) != IS_UNDEF) { + elem->ast = zend_ast_create_zval(&zv); } - if (error) { - char *tmp = zend_str_tolower_dup(Z_STRVAL_P(ns_name), Z_STRLEN_P(ns_name)); + return retval; +} +/* }}} */ - if (Z_STRLEN_P(ns_name) != Z_STRLEN(class_name->u.constant) || - memcmp(tmp, lcname->val, Z_STRLEN(class_name->u.constant))) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot declare class %s because the name is already in use", Z_STRVAL(class_name->u.constant)); - } - efree(tmp); - } +ZEND_API void zend_initialize_class_data(zend_class_entry *ce, zend_bool nullify_handlers TSRMLS_DC) /* {{{ */ +{ + zend_bool persistent_hashes = (ce->type == ZEND_INTERNAL_CLASS) ? 1 : 0; + dtor_func_t zval_ptr_dtor_func = ((persistent_hashes) ? ZVAL_INTERNAL_PTR_DTOR : ZVAL_PTR_DTOR); - new_class_entry = zend_arena_alloc(&CG(arena), sizeof(zend_class_entry)); - new_class_entry->type = ZEND_USER_CLASS; - new_class_entry->name = zend_new_interned_string(Z_STR(class_name->u.constant) TSRMLS_CC); + ce->refcount = 1; + ce->ce_flags = ZEND_ACC_CONSTANTS_UPDATED; - zend_initialize_class_data(new_class_entry, 1 TSRMLS_CC); - new_class_entry->info.user.filename = zend_get_compiled_filename(TSRMLS_C); - new_class_entry->info.user.line_start = class_token->u.op.opline_num; - new_class_entry->ce_flags |= class_token->EA; + ce->default_properties_table = NULL; + ce->default_static_members_table = NULL; + zend_hash_init_ex(&ce->properties_info, 8, NULL, (persistent_hashes ? zend_destroy_property_info_internal : zend_destroy_property_info), persistent_hashes, 0); + zend_hash_init_ex(&ce->constants_table, 8, NULL, zval_ptr_dtor_func, persistent_hashes, 0); + zend_hash_init_ex(&ce->function_table, 8, NULL, ZEND_FUNCTION_DTOR, persistent_hashes, 0); - if (parent_class_name && parent_class_name->op_type != IS_UNUSED) { - switch (parent_class_name->EA) { - case ZEND_FETCH_CLASS_SELF: - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use 'self' as class name as it is reserved"); - break; - case ZEND_FETCH_CLASS_PARENT: - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use 'parent' as class name as it is reserved"); - break; - case ZEND_FETCH_CLASS_STATIC: - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use 'static' as class name as it is reserved"); - break; - default: - break; + if (ce->type == ZEND_INTERNAL_CLASS) { +#ifdef ZTS + int n = zend_hash_num_elements(CG(class_table)); + + if (CG(static_members_table) && n >= CG(last_static_member)) { + /* Support for run-time declaration: dl() */ + CG(last_static_member) = n+1; + CG(static_members_table) = realloc(CG(static_members_table), (n+1)*sizeof(zval*)); + CG(static_members_table)[n] = NULL; } - doing_inheritance = 1; + ce->static_members_table = (zval*)(zend_intptr_t)n; +#else + ce->static_members_table = NULL; +#endif + } else { + ce->static_members_table = ce->default_static_members_table; + ce->info.user.doc_comment = NULL; } - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->op1_type = IS_CONST; - build_runtime_defined_function_key(&key, lcname->val, lcname->len TSRMLS_CC); - opline->op1.constant = zend_add_literal(CG(active_op_array), &key TSRMLS_CC); - - opline->op2_type = IS_CONST; + ce->default_properties_count = 0; + ce->default_static_members_count = 0; - if (doing_inheritance) { - /* Make sure a trait does not try to extend a class */ - if ((new_class_entry->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) { - zend_error_noreturn(E_COMPILE_ERROR, "A trait (%s) cannot extend a class. Traits can only be composed from other traits with the 'use' keyword. Error", new_class_entry->name->val); + if (nullify_handlers) { + ce->constructor = NULL; + ce->destructor = NULL; + ce->clone = NULL; + ce->__get = NULL; + ce->__set = NULL; + ce->__unset = NULL; + ce->__isset = NULL; + ce->__call = NULL; + ce->__callstatic = NULL; + ce->__tostring = NULL; + ce->create_object = NULL; + ce->get_iterator = NULL; + ce->iterator_funcs.funcs = NULL; + ce->interface_gets_implemented = NULL; + ce->get_static_method = NULL; + ce->parent = NULL; + ce->num_interfaces = 0; + ce->interfaces = NULL; + ce->num_traits = 0; + ce->traits = NULL; + ce->trait_aliases = NULL; + ce->trait_precedences = NULL; + ce->serialize = NULL; + ce->unserialize = NULL; + ce->serialize_func = NULL; + ce->unserialize_func = NULL; + ce->__debugInfo = NULL; + if (ce->type == ZEND_INTERNAL_CLASS) { + ce->info.internal.module = NULL; + ce->info.internal.builtin_functions = NULL; } + } +} +/* }}} */ - opline->extended_value = parent_class_name->u.op.var; - opline->opcode = ZEND_DECLARE_INHERITED_CLASS; +uint32_t zend_get_class_fetch_type(zend_string *name) { + if (name->len == sizeof("self") - 1 && + !strncasecmp(name->val, "self", sizeof("self") - 1)) { + return ZEND_FETCH_CLASS_SELF; + } else if (name->len == sizeof("parent") - 1 && + !strncasecmp(name->val, "parent", sizeof("parent") - 1)) { + return ZEND_FETCH_CLASS_PARENT; + } else if (name->len == sizeof("static") - 1 && + !strncasecmp(name->val, "static", sizeof("static") - 1)) { + return ZEND_FETCH_CLASS_STATIC; } else { - opline->opcode = ZEND_DECLARE_CLASS; + return ZEND_FETCH_CLASS_DEFAULT; } +} - LITERAL_STR(opline->op2, lcname); +ZEND_API zend_string *zend_get_compiled_variable_name(const zend_op_array *op_array, uint32_t var) /* {{{ */ +{ + return op_array->vars[EX_VAR_TO_NUM(var)]; +} +/* }}} */ - zend_hash_update_ptr(CG(class_table), Z_STR(key), new_class_entry); - CG(active_class_entry) = new_class_entry; +zend_ast *zend_ast_append_str(zend_ast *left_ast, zend_ast *right_ast) { + zval *left_zv = zend_ast_get_zval(left_ast); + zend_string *left = Z_STR_P(left_zv); + zend_string *right = zend_ast_get_str(right_ast); - opline->result.var = get_temporary_variable(CG(active_op_array)); - opline->result_type = IS_VAR; - GET_NODE(&CG(implementing_class), opline->result); + zend_string *result; + size_t left_len = left->len; + size_t len = left_len + right->len + 1; /* left\right */ + + result = zend_string_realloc(left, len, 0); + result->val[left_len] = '\\'; + memcpy(&result->val[left_len + 1], right->val, right->len); + result->val[len] = '\0'; + zend_string_release(right); + ZVAL_STR(left_zv, result); + return left_ast; +} + +/* A hacky way that is used to store the doc comment for properties */ +zend_ast_list *zend_ast_append_doc_comment(zend_ast_list *list TSRMLS_DC) { if (CG(doc_comment)) { - CG(active_class_entry)->info.user.doc_comment = CG(doc_comment); + list = zend_ast_list_add(list, zend_ast_create_zval_from_str(CG(doc_comment))); CG(doc_comment) = NULL; } + + return list; +} + +void zend_verify_namespace(TSRMLS_D) /* {{{ */ +{ + if (CG(has_bracketed_namespaces) && !CG(in_namespace)) { + zend_error_noreturn(E_COMPILE_ERROR, "No code may exist outside of namespace {}"); + } } /* }}} */ -static void do_verify_abstract_class(TSRMLS_D) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); +static void zend_reset_import_tables(TSRMLS_D) { + if (CG(current_import)) { + zend_hash_destroy(CG(current_import)); + efree(CG(current_import)); + CG(current_import) = NULL; + } - opline->opcode = ZEND_VERIFY_ABSTRACT_CLASS; - SET_NODE(opline->op1, &CG(implementing_class)); - SET_UNUSED(opline->op2); + if (CG(current_import_function)) { + zend_hash_destroy(CG(current_import_function)); + efree(CG(current_import_function)); + CG(current_import_function) = NULL; + } + + if (CG(current_import_const)) { + zend_hash_destroy(CG(current_import_const)); + efree(CG(current_import_const)); + CG(current_import_const) = NULL; + } +} + +static void zend_end_namespace(TSRMLS_D) { + CG(in_namespace) = 0; + zend_reset_import_tables(TSRMLS_C); + if (CG(current_namespace)) { + zend_string_release(CG(current_namespace)); + CG(current_namespace) = NULL; + } +} + +void zend_do_end_compilation(TSRMLS_D) /* {{{ */ +{ + CG(has_bracketed_namespaces) = 0; + zend_end_namespace(TSRMLS_C); } /* }}} */ -void zend_do_end_class_declaration(const znode *class_token, const znode *parent_token TSRMLS_DC) /* {{{ */ +/* {{{ zend_dirname + Returns directory name component of path */ +ZEND_API size_t zend_dirname(char *path, size_t len) { - zend_class_entry *ce = CG(active_class_entry); + register char *end = path + len - 1; + unsigned int len_adjust = 0; - if (ce->constructor) { - ce->constructor->common.fn_flags |= ZEND_ACC_CTOR; - if (ce->constructor->common.fn_flags & ZEND_ACC_STATIC) { - zend_error_noreturn(E_COMPILE_ERROR, "Constructor %s::%s() cannot be static", ce->name->val, ce->constructor->common.function_name->val); +#ifdef PHP_WIN32 + /* Note that on Win32 CWD is per drive (heritage from CP/M). + * This means dirname("c:foo") maps to "c:." or "c:" - which means CWD on C: drive. + */ + if ((2 <= len) && isalpha((int)((unsigned char *)path)[0]) && (':' == path[1])) { + /* Skip over the drive spec (if any) so as not to change */ + path += 2; + len_adjust += 2; + if (2 == len) { + /* Return "c:" on Win32 for dirname("c:"). + * It would be more consistent to return "c:." + * but that would require making the string *longer*. + */ + return len; } } - if (ce->destructor) { - ce->destructor->common.fn_flags |= ZEND_ACC_DTOR; - if (ce->destructor->common.fn_flags & ZEND_ACC_STATIC) { - zend_error_noreturn(E_COMPILE_ERROR, "Destructor %s::%s() cannot be static", ce->name->val, ce->destructor->common.function_name->val); +#elif defined(NETWARE) + /* + * Find the first occurrence of : from the left + * move the path pointer to the position just after : + * increment the len_adjust to the length of path till colon character(inclusive) + * If there is no character beyond : simple return len + */ + char *colonpos = NULL; + colonpos = strchr(path, ':'); + if (colonpos != NULL) { + len_adjust = ((colonpos - path) + 1); + path += len_adjust; + if (len_adjust == len) { + return len; } } - if (ce->clone) { - ce->clone->common.fn_flags |= ZEND_ACC_CLONE; - if (ce->clone->common.fn_flags & ZEND_ACC_STATIC) { - zend_error_noreturn(E_COMPILE_ERROR, "Clone method %s::%s() cannot be static", ce->name->val, ce->clone->common.function_name->val); +#endif + + if (len == 0) { + /* Illegal use of this function */ + return 0; + } + + /* Strip trailing slashes */ + while (end >= path && IS_SLASH_P(end)) { + end--; + } + if (end < path) { + /* The path only contained slashes */ + path[0] = DEFAULT_SLASH; + path[1] = '\0'; + return 1 + len_adjust; + } + + /* Strip filename */ + while (end >= path && !IS_SLASH_P(end)) { + end--; + } + if (end < path) { + /* No slash found, therefore return '.' */ +#ifdef NETWARE + if (len_adjust == 0) { + path[0] = '.'; + path[1] = '\0'; + return 1; /* only one character */ + } else { + path[0] = '\0'; + return len_adjust; } +#else + path[0] = '.'; + path[1] = '\0'; + return 1 + len_adjust; +#endif } - ce->info.user.line_end = zend_get_compiled_lineno(TSRMLS_C); + /* Strip slashes which came before the file name */ + while (end >= path && IS_SLASH_P(end)) { + end--; + } + if (end < path) { + path[0] = DEFAULT_SLASH; + path[1] = '\0'; + return 1 + len_adjust; + } + *(end+1) = '\0'; - /* Check for traits and proceed like with interfaces. - * The only difference will be a combined handling of them in the end. - * Thus, we need another opcode here. */ - if (ce->num_traits > 0) { - zend_op *opline; + return (size_t)(end + 1 - path) + len_adjust; +} +/* }}} */ - ce->traits = NULL; - ce->num_traits = 0; - ce->ce_flags |= ZEND_ACC_IMPLEMENT_TRAITS; +static inline zend_bool zend_str_equals_str(zend_string *str1, zend_string *str2) { + return str1->len == str2->len && !memcmp(str1->val, str2->val, str2->len); +} +static inline zend_bool zend_str_equals_str_ci(zend_string *str1, zend_string *str2) { + return str1->len == str2->len + && !zend_binary_strcasecmp(str1->val, str1->len, str2->val, str2->len); +} - /* opcode generation: */ - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_BIND_TRAITS; - SET_NODE(opline->op1, &CG(implementing_class)); +#define zend_str_equals_literal(str, c) \ + ((str)->len == sizeof(c) - 1 && !memcmp((str)->val, (c), sizeof(c) - 1)) +#define zend_str_equals_literal_ci(str, c) \ + ((str)->len == sizeof(c) - 1 \ + && !zend_binary_strcasecmp((str)->val, (str)->len, (c), sizeof(c) - 1)) + +static void zend_adjust_for_fetch_type(zend_op *opline, uint32_t type) { + switch (type & BP_VAR_MASK) { + case BP_VAR_R: + return; + case BP_VAR_W: + opline->opcode += 3; + return; + case BP_VAR_REF: + opline->opcode += 3; + opline->extended_value |= ZEND_FETCH_MAKE_REF; + return; + case BP_VAR_RW: + opline->opcode += 6; + return; + case BP_VAR_IS: + opline->opcode += 9; + return; + case BP_VAR_FUNC_ARG: + opline->opcode += 12; + opline->extended_value |= type >> BP_VAR_SHIFT; + return; + case BP_VAR_UNSET: + opline->opcode += 15; + return; + EMPTY_SWITCH_DEFAULT_CASE() } +} - if (!(ce->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS)) - && (parent_token || (ce->num_interfaces > 0))) { - zend_verify_abstract_class(ce TSRMLS_CC); - if (ce->num_interfaces && !(ce->ce_flags & ZEND_ACC_IMPLEMENT_TRAITS)) { - do_verify_abstract_class(TSRMLS_C); - } +static inline void zend_make_var_result(znode *result, zend_op *opline TSRMLS_DC) { + opline->result_type = IS_VAR; + opline->result.var = get_temporary_variable(CG(active_op_array)); + GET_NODE(result, opline->result); +} + +static inline void zend_make_tmp_result(znode *result, zend_op *opline TSRMLS_DC) { + opline->result_type = IS_TMP_VAR; + opline->result.var = get_temporary_variable(CG(active_op_array)); + GET_NODE(result, opline->result); +} + +static zend_op *zend_emit_op(znode *result, zend_uchar opcode, znode *op1, znode *op2 TSRMLS_DC) { + zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + opline->opcode = opcode; + + if (op1 == NULL) { + SET_UNUSED(opline->op1); + } else { + SET_NODE(opline->op1, op1); } - /* Inherit interfaces; reset number to zero, we need it for above check and - * will restore it during actual implementation. - * The ZEND_ACC_IMPLEMENT_INTERFACES flag disables double call to - * zend_verify_abstract_class() */ - if (ce->num_interfaces > 0) { - ce->interfaces = NULL; - ce->num_interfaces = 0; - ce->ce_flags |= ZEND_ACC_IMPLEMENT_INTERFACES; + + if (op2 == NULL) { + SET_UNUSED(opline->op2); + } else { + SET_NODE(opline->op2, op2); } - CG(active_class_entry) = NULL; + if (result) { + zend_make_var_result(result, opline TSRMLS_CC); + } + return opline; } -/* }}} */ -void zend_do_implements_interface(znode *interface_name TSRMLS_DC) /* {{{ */ -{ - zend_op *opline; +static zend_op *zend_emit_op_tmp( + znode *result, zend_uchar opcode, znode *op1, znode *op2 TSRMLS_DC +) { + zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + opline->opcode = opcode; - /* Traits can not implement interfaces */ - if ((CG(active_class_entry)->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as interface on '%s' since it is a Trait", - Z_STRVAL(interface_name->u.constant), - CG(active_class_entry)->name->val); + if (op1 == NULL) { + SET_UNUSED(opline->op1); + } else { + SET_NODE(opline->op1, op1); } - switch (zend_get_class_fetch_type(Z_STRVAL(interface_name->u.constant), Z_STRLEN(interface_name->u.constant))) { - case ZEND_FETCH_CLASS_SELF: - case ZEND_FETCH_CLASS_PARENT: - case ZEND_FETCH_CLASS_STATIC: - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as interface name as it is reserved", Z_STRVAL(interface_name->u.constant)); + if (op2 == NULL) { + SET_UNUSED(opline->op2); + } else { + SET_NODE(opline->op2, op2); + } + + zend_make_tmp_result(result, opline TSRMLS_CC); + + return opline; +} + +static void zend_emit_tick(TSRMLS_D) { + zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + + opline->opcode = ZEND_TICKS; + SET_UNUSED(opline->op1); + SET_UNUSED(opline->op2); + opline->extended_value = Z_LVAL(CG(declarables).ticks); +} + +static inline zend_op *zend_emit_op_data(znode *value TSRMLS_DC) { + return zend_emit_op(NULL, ZEND_OP_DATA, value, NULL TSRMLS_CC); +} + +static inline uint32_t zend_emit_jump(uint32_t opnum_target TSRMLS_DC) { + uint32_t opnum = get_next_op_number(CG(active_op_array)); + zend_op *opline = zend_emit_op(NULL, ZEND_JMP, NULL, NULL TSRMLS_CC); + opline->op1.opline_num = opnum_target; + return opnum; +} + +static inline uint32_t zend_emit_cond_jump( + zend_uchar opcode, znode *cond, uint32_t opnum_target TSRMLS_DC +) { + uint32_t opnum = get_next_op_number(CG(active_op_array)); + zend_op *opline = zend_emit_op(NULL, opcode, cond, NULL TSRMLS_CC); + opline->op2.opline_num = opnum_target; + return opnum; +} + +static inline void zend_update_jump_target(uint32_t opnum_jump, uint32_t opnum_target TSRMLS_DC) { + zend_op *opline = &CG(active_op_array)->opcodes[opnum_jump]; + switch (opline->opcode) { + case ZEND_JMP: + opline->op1.opline_num = opnum_target; break; - default: + case ZEND_JMPZ: + case ZEND_JMPNZ: + case ZEND_JMPZ_EX: + case ZEND_JMPNZ_EX: + opline->op2.opline_num = opnum_target; break; + EMPTY_SWITCH_DEFAULT_CASE() } +} - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_ADD_INTERFACE; - SET_NODE(opline->op1, &CG(implementing_class)); - zend_resolve_class_name(interface_name TSRMLS_CC); - opline->extended_value = (opline->extended_value & ~ZEND_FETCH_CLASS_MASK) | ZEND_FETCH_CLASS_INTERFACE; - opline->op2_type = IS_CONST; - opline->op2.constant = zend_add_class_name_literal(CG(active_op_array), &interface_name->u.constant TSRMLS_CC); - CG(active_class_entry)->num_interfaces++; +static inline void zend_update_jump_target_to_next(uint32_t opnum_jump TSRMLS_DC) { + zend_update_jump_target(opnum_jump, get_next_op_number(CG(active_op_array)) TSRMLS_CC); } -/* }}} */ -void zend_do_use_trait(znode *trait_name TSRMLS_DC) /* {{{ */ -{ - zend_op *opline; +static inline zend_op *zend_delayed_emit_op( + znode *result, zend_uchar opcode, znode *op1, znode *op2 TSRMLS_DC +) { + zend_op tmp_opline; + init_op(&tmp_opline TSRMLS_CC); + tmp_opline.opcode = opcode; + SET_NODE(tmp_opline.op1, op1); + SET_NODE(tmp_opline.op2, op2); + if (result) { + zend_make_var_result(result, &tmp_opline TSRMLS_CC); + } - if ((CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE)) { - zend_error_noreturn(E_COMPILE_ERROR, - "Cannot use traits inside of interfaces. %s is used in %s", - Z_STRVAL(trait_name->u.constant), CG(active_class_entry)->name->val); + zend_stack_push(&CG(delayed_oplines_stack), &tmp_opline); + return zend_stack_top(&CG(delayed_oplines_stack)); +} + +static inline uint32_t zend_delayed_compile_begin(TSRMLS_D) { + return zend_stack_count(&CG(delayed_oplines_stack)); +} + +static zend_op *zend_delayed_compile_end(uint32_t offset TSRMLS_DC) { + zend_op *opline, *oplines = zend_stack_base(&CG(delayed_oplines_stack)); + uint32_t i, count = zend_stack_count(&CG(delayed_oplines_stack)); + + ZEND_ASSERT(count > offset); + for (i = offset; i < count; ++i) { + opline = get_next_op(CG(active_op_array) TSRMLS_CC); + memcpy(opline, &oplines[i], sizeof(zend_op)); } + CG(delayed_oplines_stack).top = offset; + return opline; +} +void zend_emit_final_return(zval *zv TSRMLS_DC) { + znode zn; + zend_bool returns_reference = (CG(active_op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0; - switch (zend_get_class_fetch_type(Z_STRVAL(trait_name->u.constant), Z_STRLEN(trait_name->u.constant))) { - case ZEND_FETCH_CLASS_SELF: - case ZEND_FETCH_CLASS_PARENT: - case ZEND_FETCH_CLASS_STATIC: - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as trait name as it is reserved", Z_STRVAL(trait_name->u.constant)); - break; - default: - break; + zn.op_type = IS_CONST; + if (zv) { + ZVAL_COPY_VALUE(&zn.u.constant, zv); + } else { + ZVAL_NULL(&zn.u.constant); } - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_ADD_TRAIT; - SET_NODE(opline->op1, &CG(implementing_class)); - zend_resolve_class_name(trait_name TSRMLS_CC); - opline->extended_value = ZEND_FETCH_CLASS_TRAIT; - opline->op2_type = IS_CONST; - opline->op2.constant = zend_add_class_name_literal(CG(active_op_array), &trait_name->u.constant TSRMLS_CC); - CG(active_class_entry)->num_traits++; + zend_emit_op(NULL, returns_reference ? ZEND_RETURN_BY_REF : ZEND_RETURN, &zn, NULL TSRMLS_CC); } -/* }}} */ -ZEND_API zend_string *zend_mangle_property_name(const char *src1, int src1_length, const char *src2, int src2_length, int internal) /* {{{ */ -{ - zend_string *prop_name; - int prop_name_length; - prop_name_length = 1 + src1_length + 1 + src2_length; - prop_name = zend_string_alloc(prop_name_length, internal); - prop_name->val[0] = '\0'; - memcpy(prop_name->val + 1, src1, src1_length+1); - memcpy(prop_name->val + 1 + src1_length + 1, src2, src2_length+1); - return prop_name; +static inline zend_bool zend_is_variable(zend_ast *ast) { + return ast->kind == ZEND_AST_VAR || ast->kind == ZEND_AST_DIM + || ast->kind == ZEND_AST_PROP || ast->kind == ZEND_AST_STATIC_PROP + || ast->kind == ZEND_AST_CALL || ast->kind == ZEND_AST_METHOD_CALL + || ast->kind == ZEND_AST_STATIC_CALL; } -/* }}} */ -static int zend_strnlen(const char* s, int maxlen) /* {{{ */ -{ - int len = 0; - while (*s++ && maxlen--) len++; - return len; +static inline zend_bool zend_is_call(zend_ast *ast) { + return ast->kind == ZEND_AST_CALL + || ast->kind == ZEND_AST_METHOD_CALL + || ast->kind == ZEND_AST_STATIC_CALL; } -/* }}} */ -ZEND_API int zend_unmangle_property_name_ex(const char *mangled_property, int len, const char **class_name, const char **prop_name, int *prop_len) /* {{{ */ -{ - int class_name_len; +static inline zend_bool zend_is_unticked_stmt(zend_ast *ast) { + return ast->kind == ZEND_AST_STMT_LIST || ast->kind == ZEND_AST_LABEL; +} - *class_name = NULL; +static inline zend_bool zend_can_write_to_variable(zend_ast *ast) { + while (ast->kind == ZEND_AST_DIM || ast->kind == ZEND_AST_PROP) { + ast = ast->child[0]; + } - if (mangled_property[0]!=0) { - *prop_name = mangled_property; - if (prop_len) { - *prop_len = len; - } - return SUCCESS; + return zend_is_variable(ast); +} + +static inline zend_bool zend_is_const_default_class_ref(zend_ast *name_ast) { + zend_string *name; + + if (name_ast->kind != ZEND_AST_ZVAL) { + return 0; } - if (len < 3 || mangled_property[1]==0) { - zend_error(E_NOTICE, "Illegal member variable name"); - *prop_name = mangled_property; - if (prop_len) { - *prop_len = len; + + /* Fully qualified names are always default refs */ + if (!name_ast->attr) { + return 1; + } + + name = zend_ast_get_str(name_ast); + return ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(name); +} + +static inline void zend_handle_numeric_op(znode *node TSRMLS_DC) { + if (node->op_type == IS_CONST && Z_TYPE(node->u.constant) == IS_STRING) { + zend_ulong index; + + if (ZEND_HANDLE_NUMERIC(Z_STR(node->u.constant), index)) { + zval_ptr_dtor(&node->u.constant); + ZVAL_LONG(&node->u.constant, index); } - return FAILURE; } +} - class_name_len = zend_strnlen(mangled_property + 1, --len - 1) + 1; - if (class_name_len >= len || mangled_property[class_name_len]!=0) { - zend_error(E_NOTICE, "Corrupt member variable name"); - *prop_name = mangled_property; - if (prop_len) { - *prop_len = len + 1; +static inline void zend_set_class_name_op1(zend_op *opline, znode *class_node TSRMLS_DC) { + if (class_node->op_type == IS_CONST) { + opline->op1_type = IS_CONST; + opline->op1.constant = zend_add_class_name_literal( + CG(active_op_array), Z_STR(class_node->u.constant) TSRMLS_CC); + } else { + SET_NODE(opline->op1, class_node); + } +} + +static zend_op *zend_compile_class_ref(znode *result, zend_ast *name_ast TSRMLS_DC) { + zend_op *opline; + znode name_node; + zend_compile_expr(&name_node, name_ast TSRMLS_CC); + + if (name_node.op_type == IS_CONST) { + zend_string *name = Z_STR(name_node.u.constant); + uint32_t fetch_type = zend_get_class_fetch_type(name); + + opline = zend_emit_op(result, ZEND_FETCH_CLASS, NULL, NULL TSRMLS_CC); + opline->extended_value = fetch_type; + + if (fetch_type == ZEND_FETCH_CLASS_DEFAULT) { + uint32_t type = name_ast->kind == ZEND_AST_ZVAL ? name_ast->attr : ZEND_NAME_FQ; + opline->op2_type = IS_CONST; + opline->op2.constant = zend_add_class_name_literal(CG(active_op_array), + zend_resolve_class_name(name, type TSRMLS_CC) TSRMLS_CC); } - return FAILURE; + + zend_string_release(name); + } else { + opline = zend_emit_op(result, ZEND_FETCH_CLASS, NULL, &name_node TSRMLS_CC); + opline->extended_value = ZEND_FETCH_CLASS_DEFAULT; } - *class_name = mangled_property + 1; - *prop_name = (*class_name) + class_name_len; - if (prop_len) { - *prop_len = len - class_name_len; + + return opline; +} + +static int zend_try_compile_cv(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *name_ast = ast->child[0]; + if (name_ast->kind == ZEND_AST_ZVAL) { + zend_string *name = zval_get_string(zend_ast_get_zval(name_ast)); + + if (zend_is_auto_global(name TSRMLS_CC)) { + zend_string_release(name); + return FAILURE; + } + + result->op_type = IS_CV; + result->u.op.var = lookup_cv(CG(active_op_array), name TSRMLS_CC); + + if (zend_str_equals_literal(name, "this")) { + CG(active_op_array)->this_var = result->u.op.var; + } + return SUCCESS; } - return SUCCESS; + + return FAILURE; } -/* }}} */ -void zend_do_declare_property(znode *var_name, znode *value, uint32_t access_type TSRMLS_DC) /* {{{ */ -{ - zval property; - zend_property_info *existing_property_info; - zend_string *comment = NULL; +static zend_op *zend_compile_simple_var_no_cv(znode *result, zend_ast *ast, int type TSRMLS_DC) { + zend_ast *name_ast = ast->child[0]; + znode name_node; + zend_op *opline; - if (CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE) { - zend_error_noreturn(E_COMPILE_ERROR, "Interfaces may not include member variables"); + /* there is a chance someone is accessing $this */ + if (ast->kind != ZEND_AST_ZVAL + && CG(active_op_array)->scope && CG(active_op_array)->this_var == -1 + ) { + zend_string *key = zend_string_init("this", sizeof("this") - 1, 0); + CG(active_op_array)->this_var = lookup_cv(CG(active_op_array), key TSRMLS_CC); } - if (access_type & ZEND_ACC_ABSTRACT) { - zend_error_noreturn(E_COMPILE_ERROR, "Properties cannot be declared abstract"); + zend_compile_expr(&name_node, name_ast TSRMLS_CC); + + opline = get_next_op(CG(active_op_array) TSRMLS_CC); + opline = zend_emit_op(result, ZEND_FETCH_R, &name_node, NULL TSRMLS_CC); + + opline->extended_value = ZEND_FETCH_LOCAL; + if (name_node.op_type == IS_CONST) { + if (zend_is_auto_global(Z_STR(name_node.u.constant) TSRMLS_CC)) { + opline->extended_value = ZEND_FETCH_GLOBAL; + } } - if (access_type & ZEND_ACC_FINAL) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot declare property %s::$%s final, the final modifier is allowed only for methods and classes", - CG(active_class_entry)->name->val, Z_STRVAL(var_name->u.constant)); + return opline; +} + +static void zend_compile_simple_var(znode *result, zend_ast *ast, int type TSRMLS_DC) { + if (zend_try_compile_cv(result, ast TSRMLS_CC) == FAILURE) { + zend_op *opline = zend_compile_simple_var_no_cv(result, ast, type TSRMLS_CC); + zend_adjust_for_fetch_type(opline, type); } +} - if ((existing_property_info = zend_hash_find_ptr(&CG(active_class_entry)->properties_info, Z_STR(var_name->u.constant))) != NULL) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare %s::$%s", CG(active_class_entry)->name->val, Z_STRVAL(var_name->u.constant)); +static void zend_separate_if_call_and_write(znode *node, zend_ast *ast, int type TSRMLS_DC) { + if (type != BP_VAR_R && type != BP_VAR_IS && zend_is_call(ast)) { + zend_op *opline = zend_emit_op(NULL, ZEND_SEPARATE, node, NULL TSRMLS_CC); + opline->result_type = IS_VAR; + opline->result.var = opline->op1.var; } +} + +void zend_delayed_compile_var(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC); - if (value) { - ZVAL_COPY_VALUE(&property, &value->u.constant); +static zend_op *zend_delayed_compile_dim(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC) { + zend_ast *var_ast = ast->child[0]; + zend_ast *dim_ast = ast->child[1]; + + znode var_node, dim_node; + + zend_delayed_compile_var(&var_node, var_ast, type TSRMLS_CC); + zend_separate_if_call_and_write(&var_node, var_ast, type TSRMLS_CC); + + if (dim_ast == NULL) { + if (type == BP_VAR_R || type == BP_VAR_IS) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use [] for reading"); + } + if (type == BP_VAR_UNSET) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use [] for unsetting"); + } + dim_node.op_type = IS_UNUSED; } else { - ZVAL_NULL(&property); + zend_compile_expr(&dim_node, dim_ast TSRMLS_CC); + zend_handle_numeric_op(&dim_node TSRMLS_CC); } - if (CG(doc_comment)) { - comment = CG(doc_comment); - CG(doc_comment) = NULL; - } + return zend_delayed_emit_op(result, ZEND_FETCH_DIM_R, &var_node, &dim_node TSRMLS_CC); +} + +static inline zend_op *zend_compile_dim_common( + znode *result, zend_ast *ast, uint32_t type TSRMLS_DC +) { + uint32_t offset = zend_delayed_compile_begin(TSRMLS_C); + zend_delayed_compile_dim(result, ast, type TSRMLS_CC); + return zend_delayed_compile_end(offset TSRMLS_CC); +} - Z_STR(var_name->u.constant) = zend_new_interned_string(Z_STR(var_name->u.constant) TSRMLS_CC); - if (IS_INTERNED(Z_STR(var_name->u.constant))) { - Z_TYPE_FLAGS(var_name->u.constant) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE); +void zend_compile_dim(znode *result, zend_ast *ast, int type TSRMLS_DC) { + zend_op *opline = zend_compile_dim_common(result, ast, type TSRMLS_CC); + zend_adjust_for_fetch_type(opline, type); +} + +static zend_bool is_this_fetch(zend_ast *ast) { + if (ast->kind == ZEND_AST_VAR && ast->child[0]->kind == ZEND_AST_ZVAL) { + zval *name = zend_ast_get_zval(ast->child[0]); + return Z_TYPE_P(name) == IS_STRING && zend_str_equals_literal(Z_STR_P(name), "this"); } - zend_declare_property_ex(CG(active_class_entry), Z_STR(var_name->u.constant), &property, access_type, comment TSRMLS_CC); - zend_string_release(Z_STR(var_name->u.constant)); + + return 0; } -/* }}} */ -void zend_do_declare_class_constant(znode *var_name, znode *value TSRMLS_DC) /* {{{ */ -{ - if ((CG(active_class_entry)->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) { - zend_error_noreturn(E_COMPILE_ERROR, "Traits cannot have constants"); - return; +static zend_op *zend_delayed_compile_prop( + znode *result, zend_ast *ast, uint32_t type TSRMLS_DC +) { + zend_ast *obj_ast = ast->child[0]; + zend_ast *prop_ast = ast->child[1]; + + znode obj_node, prop_node; + zend_op *opline; + + if (is_this_fetch(obj_ast)) { + obj_node.op_type = IS_UNUSED; + } else { + zend_delayed_compile_var(&obj_node, obj_ast, type TSRMLS_CC); + zend_separate_if_call_and_write(&obj_node, obj_ast, type TSRMLS_CC); } + zend_compile_expr(&prop_node, prop_ast TSRMLS_CC); - Z_STR(var_name->u.constant) = zend_new_interned_string(Z_STR(var_name->u.constant) TSRMLS_CC); - if (IS_INTERNED(Z_STR(var_name->u.constant))) { - Z_TYPE_FLAGS(var_name->u.constant) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE); + opline = zend_delayed_emit_op(result, ZEND_FETCH_OBJ_R, &obj_node, &prop_node TSRMLS_CC); + if (opline->op2_type == IS_CONST && Z_TYPE(CONSTANT(opline->op2.constant)) == IS_STRING) { + zend_alloc_polymorphic_cache_slot(opline->op2.constant TSRMLS_CC); } - if (Z_CONSTANT(value->u.constant)) { - CG(active_class_entry)->ce_flags &= ~ZEND_ACC_CONSTANTS_UPDATED; + + return opline; +} + +static zend_op *zend_compile_prop_common(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC) { + uint32_t offset = zend_delayed_compile_begin(TSRMLS_C); + zend_delayed_compile_prop(result, ast, type TSRMLS_CC); + return zend_delayed_compile_end(offset TSRMLS_CC); +} + +void zend_compile_prop(znode *result, zend_ast *ast, int type TSRMLS_DC) { + zend_op *opline = zend_compile_prop_common(result, ast, type TSRMLS_CC); + zend_adjust_for_fetch_type(opline, type); +} + +zend_op *zend_compile_static_prop_common(znode *result, zend_ast *ast, int type TSRMLS_DC) { + zend_ast *class_ast = ast->child[0]; + zend_ast *prop_ast = ast->child[1]; + + znode class_node, prop_node; + zend_op *opline; + + if (zend_is_const_default_class_ref(class_ast)) { + class_node.op_type = IS_CONST; + ZVAL_STR(&class_node.u.constant, zend_resolve_class_name_ast(class_ast TSRMLS_CC)); + } else { + zend_compile_class_ref(&class_node, class_ast TSRMLS_CC); } - if (zend_hash_add(&CG(active_class_entry)->constants_table, Z_STR(var_name->u.constant), &value->u.constant) == NULL) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot redefine class constant %s::%s", CG(active_class_entry)->name->val, Z_STRVAL(var_name->u.constant)); + + zend_compile_expr(&prop_node, prop_ast TSRMLS_CC); + + opline = zend_emit_op(result, ZEND_FETCH_R, &prop_node, NULL TSRMLS_CC); + if (opline->op1_type == IS_CONST) { + zend_alloc_polymorphic_cache_slot(opline->op1.constant TSRMLS_CC); } - FREE_PNODE(var_name); + if (class_node.op_type == IS_CONST) { + opline->op2_type = IS_CONST; + opline->op2.constant = zend_add_class_name_literal( + CG(active_op_array), Z_STR(class_node.u.constant) TSRMLS_CC); + } else { + SET_NODE(opline->op2, &class_node); + } + opline->extended_value |= ZEND_FETCH_STATIC_MEMBER; - if (CG(doc_comment)) { - zend_string_release(CG(doc_comment)); - CG(doc_comment) = NULL; + return opline; +} + +void zend_compile_static_prop(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC) { + zend_op *opline = zend_compile_static_prop_common(result, ast, type TSRMLS_CC); + zend_adjust_for_fetch_type(opline, type); +} + +static inline zend_uchar get_list_fetch_opcode(zend_uchar op_type) { + switch (op_type) { + case IS_VAR: + case IS_CV: + return ZEND_FETCH_DIM_R; + case IS_TMP_VAR: + case IS_CONST: + return ZEND_FETCH_DIM_TMP_VAR; + EMPTY_SWITCH_DEFAULT_CASE() } } -/* }}} */ -void zend_do_fetch_property(znode *result, znode *object, znode *property TSRMLS_DC) /* {{{ */ -{ - zend_op opline; - zend_llist *fetch_list_ptr = zend_stack_top(&CG(bp_stack)); - - if (object->op_type == IS_CV) { - if (object->u.op.var == CG(active_op_array)->this_var) { - object->op_type = IS_UNUSED; /* this means $this for objects */ - } - } else if (fetch_list_ptr->count == 1) { - zend_llist_element *le = fetch_list_ptr->head; - zend_op *opline_ptr = (zend_op *) le->data; - - if (opline_is_fetch_this(opline_ptr TSRMLS_CC)) { - zend_del_literal(CG(active_op_array), opline_ptr->op1.constant); - SET_UNUSED(opline_ptr->op1); /* this means $this for objects */ - SET_NODE(opline_ptr->op2, property); - /* if it was usual fetch, we change it to object fetch */ - switch (opline_ptr->opcode) { - case ZEND_FETCH_W: - opline_ptr->opcode = ZEND_FETCH_OBJ_W; - break; - case ZEND_FETCH_R: - opline_ptr->opcode = ZEND_FETCH_OBJ_R; - break; - case ZEND_FETCH_RW: - opline_ptr->opcode = ZEND_FETCH_OBJ_RW; - break; - case ZEND_FETCH_IS: - opline_ptr->opcode = ZEND_FETCH_OBJ_IS; - break; - case ZEND_FETCH_UNSET: - opline_ptr->opcode = ZEND_FETCH_OBJ_UNSET; - break; - case ZEND_FETCH_FUNC_ARG: - opline_ptr->opcode = ZEND_FETCH_OBJ_FUNC_ARG; - break; - } - if (opline_ptr->op2_type == IS_CONST && Z_TYPE(CONSTANT(opline_ptr->op2.constant)) == IS_STRING) { - GET_POLYMORPHIC_CACHE_SLOT(opline_ptr->op2.constant); +static void zend_compile_list_assign(znode *result, zend_ast *ast, znode *expr_node TSRMLS_DC) { + zend_ast_list *list = zend_ast_get_list(ast); + uint32_t i; + + if (list->children == 1 && !list->child[0]) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use empty list"); + } + + for (i = 0; i < list->children; ++i) { + zend_ast *var_ast = list->child[i]; + znode fetch_result, dim_node, var_node, assign_result; + zend_op *opline; + + if (var_ast == NULL) { + continue; + } + + dim_node.op_type = IS_CONST; + ZVAL_LONG(&dim_node.u.constant, i); + + if (expr_node->op_type == IS_CONST) { + Z_TRY_ADDREF(expr_node->u.constant); + } + + opline = zend_emit_op(&fetch_result, + get_list_fetch_opcode(expr_node->op_type), expr_node, &dim_node TSRMLS_CC); + opline->extended_value |= ZEND_FETCH_ADD_LOCK; + + if (var_ast->kind != ZEND_AST_LIST) { + if (is_this_fetch(var_ast)) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this"); } - GET_NODE(result, opline_ptr->result); - return; + zend_compile_var(&var_node, var_ast, BP_VAR_W TSRMLS_CC); + zend_emit_op(&assign_result, ZEND_ASSIGN, &var_node, &fetch_result TSRMLS_CC); + zend_do_free(&assign_result TSRMLS_CC); + } else { + zend_compile_list_assign(&assign_result, var_ast, &fetch_result TSRMLS_CC); + zend_do_free(&assign_result TSRMLS_CC); } } + *result = *expr_node; +} + +void zend_ensure_writable_variable(const zend_ast *ast) { + if (ast->kind == ZEND_AST_CALL) { + zend_error_noreturn(E_COMPILE_ERROR, "Can't use function return value in write context"); + } + if (ast->kind == ZEND_AST_METHOD_CALL || ast->kind == ZEND_AST_STATIC_CALL) { + zend_error_noreturn(E_COMPILE_ERROR, "Can't use method return value in write context"); + } +} - if (zend_is_function_or_method_call(object)) { - init_op(&opline TSRMLS_CC); - opline.opcode = ZEND_SEPARATE; - SET_NODE(opline.op1, object); - SET_UNUSED(opline.op2); - opline.result_type = IS_VAR; - opline.result.var = opline.op1.var; - zend_llist_add_element(fetch_list_ptr, &opline); +/* Detects $a... = $a pattern */ +zend_bool zend_is_assign_to_self(zend_ast *var_ast, zend_ast *expr_ast TSRMLS_DC) { + if (expr_ast->kind != ZEND_AST_VAR || expr_ast->child[0]->kind != ZEND_AST_ZVAL) { + return 0; } - init_op(&opline TSRMLS_CC); - opline.opcode = ZEND_FETCH_OBJ_W; /* the backpatching routine assumes W */ - opline.result_type = IS_VAR; - opline.result.var = get_temporary_variable(CG(active_op_array)); - SET_NODE(opline.op1, object); - SET_NODE(opline.op2, property); - if (opline.op2_type == IS_CONST && Z_TYPE(CONSTANT(opline.op2.constant)) == IS_STRING) { - GET_POLYMORPHIC_CACHE_SLOT(opline.op2.constant); + while (zend_is_variable(var_ast) && var_ast->kind != ZEND_AST_VAR) { + var_ast = var_ast->child[0]; } - GET_NODE(result, opline.result); - zend_llist_add_element(fetch_list_ptr, &opline); + if (var_ast->kind != ZEND_AST_VAR || var_ast->child[0]->kind != ZEND_AST_ZVAL) { + return 0; + } + + { + zend_string *name1 = zval_get_string(zend_ast_get_zval(var_ast->child[0])); + zend_string *name2 = zval_get_string(zend_ast_get_zval(expr_ast->child[0])); + zend_bool result = zend_str_equals_str(name1, name2); + zend_string_release(name1); + zend_string_release(name2); + return result; + } } -/* }}} */ -void zend_do_halt_compiler_register(TSRMLS_D) /* {{{ */ -{ - zend_string *name; - zend_string *cfilename; - char haltoff[] = "__COMPILER_HALT_OFFSET__"; +void zend_compile_assign(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *var_ast = ast->child[0]; + zend_ast *expr_ast = ast->child[1]; - if (CG(has_bracketed_namespaces) && CG(in_namespace)) { - zend_error_noreturn(E_COMPILE_ERROR, "__HALT_COMPILER() can only be used from the outermost scope"); + znode var_node, expr_node; + zend_op *opline; + uint32_t offset; + + if (is_this_fetch(var_ast)) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this"); } - cfilename = zend_get_compiled_filename(TSRMLS_C); - name = zend_mangle_property_name(haltoff, sizeof(haltoff) - 1, cfilename->val, cfilename->len, 0); - zend_register_long_constant(name->val, name->len, zend_get_scanned_file_offset(TSRMLS_C), CONST_CS, 0 TSRMLS_CC); - zend_string_free(name); + zend_ensure_writable_variable(var_ast); + + switch (var_ast->kind) { + case ZEND_AST_VAR: + case ZEND_AST_STATIC_PROP: + zend_compile_var(&var_node, var_ast, BP_VAR_W TSRMLS_CC); + zend_compile_expr(&expr_node, expr_ast TSRMLS_CC); + zend_emit_op(result, ZEND_ASSIGN, &var_node, &expr_node TSRMLS_CC); + return; + case ZEND_AST_DIM: + offset = zend_delayed_compile_begin(TSRMLS_C); + zend_delayed_compile_dim(result, var_ast, BP_VAR_W TSRMLS_CC); + + if (zend_is_assign_to_self(var_ast, expr_ast TSRMLS_CC)) { + /* $a[0] = $a should evaluate the right $a first */ + zend_compile_simple_var_no_cv(&expr_node, expr_ast, BP_VAR_R TSRMLS_CC); + } else { + zend_compile_expr(&expr_node, expr_ast TSRMLS_CC); + } + + opline = zend_delayed_compile_end(offset TSRMLS_CC); + opline->opcode = ZEND_ASSIGN_DIM; - if (CG(in_namespace)) { - zend_do_end_namespace(TSRMLS_C); + opline = zend_emit_op_data(&expr_node TSRMLS_CC); + opline->op2.var = get_temporary_variable(CG(active_op_array)); + opline->op2_type = IS_VAR; + return; + case ZEND_AST_PROP: + offset = zend_delayed_compile_begin(TSRMLS_C); + zend_delayed_compile_prop(result, var_ast, BP_VAR_W TSRMLS_CC); + zend_compile_expr(&expr_node, expr_ast TSRMLS_CC); + + opline = zend_delayed_compile_end(offset TSRMLS_CC); + opline->opcode = ZEND_ASSIGN_OBJ; + + zend_emit_op_data(&expr_node TSRMLS_CC); + return; + case ZEND_AST_LIST: + zend_compile_expr(&expr_node, expr_ast TSRMLS_CC); + zend_compile_list_assign(result, var_ast, &expr_node TSRMLS_CC); + return; + EMPTY_SWITCH_DEFAULT_CASE(); } } -/* }}} */ -void zend_do_push_object(const znode *object TSRMLS_DC) /* {{{ */ -{ - zend_stack_push(&CG(object_stack), object); +static inline void zend_emit_assign_znode(zend_ast *var_ast, znode *value_node TSRMLS_DC) { + znode dummy_node; + zend_ast *assign_ast = zend_ast_create(ZEND_AST_ASSIGN, var_ast, + zend_ast_create_znode(value_node)); + zend_compile_assign(&dummy_node, assign_ast TSRMLS_CC); + zend_do_free(&dummy_node TSRMLS_CC); } -/* }}} */ -void zend_do_pop_object(znode *object TSRMLS_DC) /* {{{ */ -{ - if (object) { - znode *tmp = zend_stack_top(&CG(object_stack)); - *object = *tmp; +void zend_compile_assign_ref(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *target_ast = ast->child[0]; + zend_ast *source_ast = ast->child[1]; + + znode target_node, source_node; + zend_op *opline; + + if (is_this_fetch(target_ast)) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this"); + } + zend_ensure_writable_variable(target_ast); + + zend_compile_var(&target_node, target_ast, BP_VAR_W TSRMLS_CC); + zend_compile_var(&source_node, source_ast, BP_VAR_REF TSRMLS_CC); + + opline = zend_emit_op(result, ZEND_ASSIGN_REF, &target_node, &source_node TSRMLS_CC); + if (!result) { + opline->result_type |= EXT_TYPE_UNUSED; + } + + if (zend_is_call(source_ast)) { + opline->extended_value = ZEND_RETURNS_FUNCTION; + } else if (source_ast->kind == ZEND_AST_NEW) { + opline->extended_value = ZEND_RETURNS_NEW; } - zend_stack_del_top(&CG(object_stack)); } -/* }}} */ -void zend_do_begin_new_object(znode *new_token, znode *class_type TSRMLS_DC) /* {{{ */ -{ +static inline void zend_emit_assign_ref_znode(zend_ast *var_ast, znode *value_node TSRMLS_DC) { + zend_ast *assign_ast = zend_ast_create(ZEND_AST_ASSIGN_REF, var_ast, + zend_ast_create_znode(value_node)); + zend_compile_assign_ref(NULL, assign_ast TSRMLS_CC); +} + +void zend_compile_compound_assign(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *var_ast = ast->child[0]; + zend_ast *expr_ast = ast->child[1]; + uint32_t opcode = ast->attr; + + znode var_node, expr_node; zend_op *opline; + uint32_t offset; - new_token->u.op.opline_num = get_next_op_number(CG(active_op_array)); - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_NEW; - opline->result_type = IS_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - SET_NODE(opline->op1, class_type); - SET_UNUSED(opline->op2); + zend_ensure_writable_variable(var_ast); - zend_push_function_call_entry(NULL, new_token->u.op.opline_num TSRMLS_CC); + switch (var_ast->kind) { + case ZEND_AST_VAR: + case ZEND_AST_STATIC_PROP: + zend_compile_var(&var_node, var_ast, BP_VAR_RW TSRMLS_CC); + zend_compile_expr(&expr_node, expr_ast TSRMLS_CC); + zend_emit_op(result, opcode, &var_node, &expr_node TSRMLS_CC); + return; + case ZEND_AST_DIM: + offset = zend_delayed_compile_begin(TSRMLS_C); + zend_delayed_compile_dim(result, var_ast, BP_VAR_RW TSRMLS_CC); + zend_compile_expr(&expr_node, expr_ast TSRMLS_CC); + + opline = zend_delayed_compile_end(offset TSRMLS_CC); + opline->opcode = opcode; + opline->extended_value = ZEND_ASSIGN_DIM; + + opline = zend_emit_op_data(&expr_node TSRMLS_CC); + opline->op2.var = get_temporary_variable(CG(active_op_array)); + opline->op2_type = IS_VAR; + return; + case ZEND_AST_PROP: + offset = zend_delayed_compile_begin(TSRMLS_C); + zend_delayed_compile_prop(result, var_ast, BP_VAR_RW TSRMLS_CC); + zend_compile_expr(&expr_node, expr_ast TSRMLS_CC); + + opline = zend_delayed_compile_end(offset TSRMLS_CC); + opline->opcode = opcode; + opline->extended_value = ZEND_ASSIGN_OBJ; + + zend_emit_op_data(&expr_node TSRMLS_CC); + return; + EMPTY_SWITCH_DEFAULT_CASE() + } } -/* }}} */ -void zend_do_end_new_object(znode *result, const znode *new_token TSRMLS_DC) /* {{{ */ -{ - znode ctor_result; +uint32_t zend_compile_args(zend_ast *ast, zend_function *fbc TSRMLS_DC) { + // TODO.AST &var error + zend_ast_list *args = zend_ast_get_list(ast); + uint32_t i; + zend_bool uses_arg_unpack = 0; + uint32_t arg_count = 0; /* number of arguments not including unpacks */ - zend_do_end_function_call(NULL, &ctor_result, 1, 0 TSRMLS_CC); - zend_do_free(&ctor_result TSRMLS_CC); + for (i = 0; i < args->children; ++i) { + zend_ast *arg = args->child[i]; + uint32_t arg_num = i + 1; - CG(active_op_array)->opcodes[new_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array)); - GET_NODE(result, CG(active_op_array)->opcodes[new_token->u.op.opline_num].result); -} -/* }}} */ + znode arg_node; + zend_op *opline; + zend_uchar opcode; + zend_ulong flags = 0; -static zend_constant* zend_get_ct_const(const zval *const_name, int all_internal_constants_substitution TSRMLS_DC) /* {{{ */ -{ - zend_constant *c = NULL; - char *lookup_name; + if (arg->kind == ZEND_AST_UNPACK) { + uses_arg_unpack = 1; + fbc = NULL; + + zend_compile_expr(&arg_node, arg->child[0] TSRMLS_CC); + opline = zend_emit_op(NULL, ZEND_SEND_UNPACK, &arg_node, NULL TSRMLS_CC); + opline->op2.num = arg_count; + continue; + } - if (Z_STRVAL_P(const_name)[0] == '\\') { - if ((c = zend_hash_str_find_ptr(EG(zend_constants), Z_STRVAL_P(const_name)+1, Z_STRLEN_P(const_name)-1)) == NULL) { - lookup_name = zend_str_tolower_dup(Z_STRVAL_P(const_name)+1, Z_STRLEN_P(const_name)-1); - if ((c = zend_hash_str_find_ptr(EG(zend_constants), lookup_name, Z_STRLEN_P(const_name)-1)) != NULL) { - if ((c->flags & CONST_CT_SUBST) && !(c->flags & CONST_CS)) { - efree(lookup_name); - return c; + if (uses_arg_unpack) { + zend_error_noreturn(E_COMPILE_ERROR, + "Cannot use positional argument after argument unpacking"); + } + + arg_count++; + if (zend_is_variable(arg)) { + if (zend_is_call(arg)) { + zend_compile_var(&arg_node, arg, BP_VAR_R TSRMLS_CC); + opcode = ZEND_SEND_VAR_NO_REF; + flags |= ZEND_ARG_SEND_FUNCTION; + if (fbc && ARG_SHOULD_BE_SENT_BY_REF(fbc, arg_num)) { + flags |= ZEND_ARG_SEND_BY_REF; + if (ARG_MAY_BE_SENT_BY_REF(fbc, arg_num)) { + flags |= ZEND_ARG_SEND_SILENT; + } + } + } else if (fbc) { + if (ARG_SHOULD_BE_SENT_BY_REF(fbc, arg_num)) { + zend_compile_var(&arg_node, arg, BP_VAR_W TSRMLS_CC); + opcode = ZEND_SEND_REF; + } else { + zend_compile_var(&arg_node, arg, BP_VAR_R TSRMLS_CC); + opcode = ZEND_SEND_VAR; + } + } else { + zend_compile_var(&arg_node, arg, + BP_VAR_FUNC_ARG | (arg_num << BP_VAR_SHIFT) TSRMLS_CC); + opcode = ZEND_SEND_VAR_EX; + } + } else { + zend_compile_expr(&arg_node, arg TSRMLS_CC); + if (arg_node.op_type & (IS_VAR|IS_CV)) { + opcode = ZEND_SEND_VAR_NO_REF; + if (fbc && ARG_MUST_BE_SENT_BY_REF(fbc, arg_num)) { + flags |= ZEND_ARG_SEND_BY_REF; + } + } else { + if (fbc) { + opcode = ZEND_SEND_VAL; + if (ARG_MUST_BE_SENT_BY_REF(fbc, arg_num)) { + zend_error_noreturn(E_COMPILE_ERROR, "Only variables can be passed by reference"); + } + } else { + opcode = ZEND_SEND_VAL_EX; } } - efree(lookup_name); - return NULL; } - } else if ((c = zend_hash_find_ptr(EG(zend_constants), Z_STR_P(const_name))) == NULL) { - lookup_name = zend_str_tolower_dup(Z_STRVAL_P(const_name), Z_STRLEN_P(const_name)); - if ((c = zend_hash_str_find_ptr(EG(zend_constants), lookup_name, Z_STRLEN_P(const_name))) != NULL) { - if ((c->flags & CONST_CT_SUBST) && !(c->flags & CONST_CS)) { - efree(lookup_name); - return c; + + opline = get_next_op(CG(active_op_array) TSRMLS_CC); + opline->opcode = opcode; + SET_NODE(opline->op1, &arg_node); + SET_UNUSED(opline->op2); + opline->op2.opline_num = arg_num; + + if (opcode == ZEND_SEND_VAR_NO_REF) { + if (fbc) { + flags |= ZEND_ARG_COMPILE_TIME_BOUND; } + opline->extended_value = flags; + } else if (fbc) { + opline->extended_value = ZEND_ARG_COMPILE_TIME_BOUND; } - efree(lookup_name); - return NULL; } - if (c->flags & CONST_CT_SUBST) { - return c; + + return arg_count; +} + +void zend_compile_call_common(znode *result, zend_ast *args_ast, zend_function *fbc TSRMLS_DC) { + zend_op *opline; + uint32_t opnum_init = get_next_op_number(CG(active_op_array)) - 1; + uint32_t arg_count; + uint32_t call_flags; + + zend_do_extended_fcall_begin(TSRMLS_C); + + arg_count = zend_compile_args(args_ast, fbc TSRMLS_CC); + + opline = &CG(active_op_array)->opcodes[opnum_init]; + opline->extended_value = arg_count; + + call_flags = (opline->opcode == ZEND_NEW ? ZEND_CALL_CTOR : 0); + opline = zend_emit_op(result, ZEND_DO_FCALL, NULL, NULL TSRMLS_CC); + opline->op1.num = call_flags; + + zend_do_extended_fcall_end(TSRMLS_C); +} + +zend_bool zend_compile_function_name(znode *name_node, zend_ast *name_ast TSRMLS_DC) { + zend_string *orig_name = zend_ast_get_str(name_ast); + zend_bool is_fully_qualified; + + name_node->op_type = IS_CONST; + ZVAL_STR(&name_node->u.constant, zend_resolve_function_name( + orig_name, name_ast->attr, &is_fully_qualified TSRMLS_CC)); + + return !is_fully_qualified && CG(current_namespace); +} + +void zend_compile_ns_call(znode *result, znode *name_node, zend_ast *args_ast TSRMLS_DC) { + zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + opline->opcode = ZEND_INIT_NS_FCALL_BY_NAME; + SET_UNUSED(opline->op1); + opline->op2_type = IS_CONST; + opline->op2.constant = zend_add_ns_func_name_literal( + CG(active_op_array), &name_node->u.constant TSRMLS_CC); + zend_alloc_cache_slot(opline->op2.constant TSRMLS_CC); + + zend_compile_call_common(result, args_ast, NULL TSRMLS_CC); +} + +void zend_compile_dynamic_call(znode *result, znode *name_node, zend_ast *args_ast TSRMLS_DC) { + zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + opline->opcode = ZEND_INIT_FCALL_BY_NAME; + SET_UNUSED(opline->op1); + if (name_node->op_type == IS_CONST && Z_TYPE(name_node->u.constant) == IS_STRING) { + opline->op2_type = IS_CONST; + opline->op2.constant + = zend_add_func_name_literal(CG(active_op_array), &name_node->u.constant TSRMLS_CC); + zend_alloc_cache_slot(opline->op2.constant TSRMLS_CC); + } else { + SET_NODE(opline->op2, name_node); } - if (all_internal_constants_substitution && - (c->flags & CONST_PERSISTENT) && - !(CG(compiler_options) & ZEND_COMPILE_NO_CONSTANT_SUBSTITUTION) && - !Z_CONSTANT(c->value)) { - return c; + + zend_compile_call_common(result, args_ast, NULL TSRMLS_CC); +} + +static zend_bool zend_args_contain_unpack(zend_ast_list *args) { + uint32_t i; + for (i = 0; i < args->children; ++i) { + if (args->child[i]->kind == ZEND_AST_UNPACK) { + return 1; + } } - return NULL; + return 0; } -/* }}} */ -static int zend_constant_ct_subst(znode *result, zval *const_name, int all_internal_constants_substitution TSRMLS_DC) /* {{{ */ -{ - zend_constant *c = zend_get_ct_const(const_name, all_internal_constants_substitution TSRMLS_CC); +int zend_compile_func_strlen(znode *result, zend_ast_list *args TSRMLS_DC) { + znode arg_node; - if (c) { - zval_dtor(const_name); - result->op_type = IS_CONST; - result->u.constant = c->value; - zval_copy_ctor(&result->u.constant); - return 1; + if ((CG(compiler_options) & ZEND_COMPILE_NO_BUILTIN_STRLEN) + || args->children != 1 || args->child[0]->kind == ZEND_AST_UNPACK + ) { + return FAILURE; } - return 0; + + zend_compile_expr(&arg_node, args->child[0] TSRMLS_CC); + zend_emit_op(result, ZEND_STRLEN, &arg_node, NULL TSRMLS_CC); + return SUCCESS; } -/* }}} */ -void zend_do_fetch_constant(znode *result, znode *constant_container, znode *constant_name, int mode, zend_bool check_namespace TSRMLS_DC) /* {{{ */ -{ - znode tmp; +int zend_compile_func_typecheck(znode *result, zend_ast_list *args, uint32_t type TSRMLS_DC) { + znode arg_node; zend_op *opline; - int type; - char *compound; - zend_ulong fetch_type = 0; - - if (constant_container) { - switch (mode) { - case ZEND_CT: - /* this is a class constant */ - type = zend_get_class_fetch_type(Z_STRVAL(constant_container->u.constant), Z_STRLEN(constant_container->u.constant)); - - if (ZEND_FETCH_CLASS_STATIC == type) { - zend_error(E_ERROR, "\"static::\" is not allowed in compile-time constants"); - } else if (ZEND_FETCH_CLASS_DEFAULT == type) { - zend_resolve_class_name(constant_container TSRMLS_CC); - } - zend_do_build_full_name(NULL, constant_container, constant_name, 1 TSRMLS_CC); - *result = *constant_container; - Z_TYPE_INFO(result->u.constant) = IS_CONSTANT_EX; - if (IS_INTERNED(Z_STR(result->u.constant))) { - Z_TYPE_FLAGS(result->u.constant) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE); - } - Z_CONST_FLAGS(result->u.constant) = fetch_type; - break; - case ZEND_RT: - if (constant_container->op_type == IS_CONST && - ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(constant_container->u.constant), Z_STRLEN(constant_container->u.constant))) { - zend_resolve_class_name(constant_container TSRMLS_CC); - } else { - zend_do_fetch_class(&tmp, constant_container TSRMLS_CC); - constant_container = &tmp; - } - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_FETCH_CONSTANT; - opline->result_type = IS_TMP_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - if (constant_container->op_type == IS_CONST) { - opline->op1_type = IS_CONST; - opline->op1.constant = zend_add_class_name_literal(CG(active_op_array), &constant_container->u.constant TSRMLS_CC); - } else { - SET_NODE(opline->op1, constant_container); - } - SET_NODE(opline->op2, constant_name); - if (opline->op1_type == IS_CONST) { - GET_CACHE_SLOT(opline->op2.constant); - } else { - GET_POLYMORPHIC_CACHE_SLOT(opline->op2.constant); - } - GET_NODE(result, opline->result); - break; - } - return; + + if (args->children != 1 || args->child[0]->kind == ZEND_AST_UNPACK) { + return FAILURE; } - /* namespace constant */ - /* only one that did not contain \ from the start can be converted to string if unknown */ - switch (mode) { - case ZEND_CT: - compound = memchr(Z_STRVAL(constant_name->u.constant), '\\', Z_STRLEN(constant_name->u.constant)); - /* this is a namespace constant, or an unprefixed constant */ + + zend_compile_expr(&arg_node, args->child[0] TSRMLS_CC); + opline = zend_emit_op(result, ZEND_TYPE_CHECK, &arg_node, NULL TSRMLS_CC); + opline->extended_value = type; + return SUCCESS; +} - if (zend_constant_ct_subst(result, &constant_name->u.constant, 0 TSRMLS_CC)) { - break; - } +int zend_compile_func_defined(znode *result, zend_ast_list *args TSRMLS_DC) { + zend_string *name; + zend_op *opline; - zend_resolve_const_name(constant_name, &check_namespace TSRMLS_CC); + if (args->children != 1 || args->child[0]->kind != ZEND_AST_ZVAL) { + return FAILURE; + } - if(!compound) { - fetch_type |= IS_CONSTANT_UNQUALIFIED; - } + name = zval_get_string(zend_ast_get_zval(args->child[0])); + if (zend_memrchr(name->val, '\\', name->len) || zend_memrchr(name->val, ':', name->len)) { + zend_string_release(name); + return FAILURE; + } - *result = *constant_name; - Z_TYPE_INFO(result->u.constant) = IS_CONSTANT_EX; - if (IS_INTERNED(Z_STR(result->u.constant))) { - Z_TYPE_FLAGS(result->u.constant) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE); - } - Z_CONST_FLAGS(result->u.constant) = fetch_type; - break; - case ZEND_RT: - compound = memchr(Z_STRVAL(constant_name->u.constant), '\\', Z_STRLEN(constant_name->u.constant)); + opline = zend_emit_op(result, ZEND_DEFINED, NULL, NULL TSRMLS_CC); + opline->op1_type = IS_CONST; + LITERAL_STR(opline->op1, name); + zend_alloc_cache_slot(opline->op1.constant TSRMLS_CC); - zend_resolve_const_name(constant_name, &check_namespace TSRMLS_CC); + /* Lowercase constant name in a separate literal */ + { + zval c; + zend_string *lcname = zend_string_alloc(name->len, 0); + zend_str_tolower_copy(lcname->val, name->val, name->len); + ZVAL_NEW_STR(&c, lcname); + zend_add_literal(CG(active_op_array), &c TSRMLS_CC); + } + return SUCCESS; +} - if(zend_constant_ct_subst(result, &constant_name->u.constant, 1 TSRMLS_CC)) { - break; - } +static int zend_try_compile_ct_bound_init_user_func( + znode *result, zend_ast *name_ast, uint32_t num_args TSRMLS_DC +) { + zend_string *name, *lcname; + zend_function *fbc; + zend_op *opline; - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_FETCH_CONSTANT; - opline->result_type = IS_TMP_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - GET_NODE(result, opline->result); - SET_UNUSED(opline->op1); - opline->op2_type = IS_CONST; - if (compound) { - /* the name is unambiguous */ - opline->extended_value = 0; - opline->op2.constant = zend_add_const_name_literal(CG(active_op_array), &constant_name->u.constant, 0 TSRMLS_CC); - } else { - opline->extended_value = IS_CONSTANT_UNQUALIFIED; - if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) { - opline->extended_value |= IS_CONSTANT_IN_NAMESPACE; - opline->op2.constant = zend_add_const_name_literal(CG(active_op_array), &constant_name->u.constant, 1 TSRMLS_CC); - } else { - opline->op2.constant = zend_add_const_name_literal(CG(active_op_array), &constant_name->u.constant, 0 TSRMLS_CC); - } - } - GET_CACHE_SLOT(opline->op2.constant); - break; + if (name_ast->kind != ZEND_AST_CONST || Z_TYPE_P(zend_ast_get_zval(name_ast)) != IS_STRING) { + return FAILURE; } -} -/* }}} */ -void zend_do_shell_exec(znode *result, znode *cmd TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + name = zend_ast_get_str(name_ast); + lcname = zend_string_alloc(name->len, 0); + zend_str_tolower_copy(lcname->val, name->val, name->len); - opline->opcode = ZEND_INIT_FCALL; - opline->extended_value = 1; - SET_UNUSED(opline->op1); + fbc = zend_hash_find_ptr(CG(function_table), lcname); + if (!fbc || (fbc->type == ZEND_INTERNAL_FUNCTION && + (CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_FUNCTIONS)) + ) { + zend_string_free(lcname); + return FAILURE; + } + + opline = zend_emit_op(NULL, ZEND_INIT_FCALL, NULL, NULL TSRMLS_CC); opline->op2_type = IS_CONST; - LITERAL_STR(opline->op2, zend_string_init("shell_exec", sizeof("shell_exec")-1, 0)); - GET_CACHE_SLOT(opline->op2.constant); + LITERAL_STR(opline->op2, lcname); + opline->extended_value = num_args; - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - switch (cmd->op_type) { - case IS_CONST: - case IS_TMP_VAR: - opline->opcode = ZEND_SEND_VAL; - break; - default: - opline->opcode = ZEND_SEND_VAR; - break; + return SUCCESS; +} + +static void zend_compile_init_user_func( + znode *result, zend_ast *name_ast, uint32_t num_args, zend_string *orig_func_name TSRMLS_DC +) { + zend_op *opline; + znode name_node; + + if (zend_try_compile_ct_bound_init_user_func(result, name_ast, num_args TSRMLS_CC) == SUCCESS) { + return; } - SET_NODE(opline->op1, cmd); - opline->op2.opline_num = 1; - SET_UNUSED(opline->op2); - /* FIXME: exception support not added to this op2 */ - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_DO_FCALL; - opline->extended_value = 1; - opline->result.var = get_temporary_variable(CG(active_op_array)); - opline->result_type = IS_VAR; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); - GET_NODE(result, opline->result); + zend_compile_expr(&name_node, name_ast TSRMLS_CC); + + opline = zend_emit_op(NULL, ZEND_INIT_USER_CALL, NULL, &name_node TSRMLS_CC); + opline->op1_type = IS_CONST; + LITERAL_STR(opline->op1, zend_string_copy(orig_func_name)); + opline->extended_value = num_args; } -/* }}} */ -void zend_do_init_array(znode *result, znode *expr, znode *offset, zend_bool is_ref TSRMLS_DC) /* {{{ */ -{ - int op_num = get_next_op_number(CG(active_op_array)); - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); +/* cufa = call_user_func_array */ +int zend_compile_func_cufa(znode *result, zend_ast_list *args, zend_string *lcname TSRMLS_DC) { + znode arg_node; - result->u.op.opline_num = op_num; + if (args->children != 2 || zend_args_contain_unpack(args)) { + return FAILURE; + } - opline->opcode = ZEND_INIT_ARRAY; - opline->result.var = get_temporary_variable(CG(active_op_array)); - opline->result_type = IS_TMP_VAR; - opline->extended_value = is_ref; /* extval = size << 2 | not_packed << 1 | is_ref */ - - if (expr) { - opline->extended_value += 1 << ZEND_ARRAY_SIZE_SHIFT; /* increment size */ - SET_NODE(opline->op1, expr); - if (offset) { - SET_NODE(opline->op2, offset); - if (opline->op2_type == IS_CONST && Z_TYPE(CONSTANT(opline->op2.constant)) == IS_STRING) { - zend_ulong index; - - opline->extended_value |= ZEND_ARRAY_NOT_PACKED; - if (ZEND_HANDLE_NUMERIC(Z_STR(CONSTANT(opline->op2.constant)), index)) { - zval_dtor(&CONSTANT(opline->op2.constant)); - ZVAL_LONG(&CONSTANT(opline->op2.constant), index); - } + zend_compile_init_user_func(NULL, args->child[0], 1, lcname TSRMLS_CC); + zend_compile_expr(&arg_node, args->child[1] TSRMLS_CC); + zend_emit_op(NULL, ZEND_SEND_ARRAY, &arg_node, NULL TSRMLS_CC); + zend_emit_op(result, ZEND_DO_FCALL, NULL, NULL TSRMLS_CC); + + return SUCCESS; +} + +/* cuf = call_user_func */ +int zend_compile_func_cuf(znode *result, zend_ast_list *args, zend_string *lcname TSRMLS_DC) { + uint32_t i; + + if (args->children < 1 || zend_args_contain_unpack(args)) { + return FAILURE; + } + + zend_compile_init_user_func(NULL, args->child[0], args->children - 1, lcname TSRMLS_CC); + for (i = 1; i < args->children; ++i) { + zend_ast *arg_ast = args->child[i]; + znode arg_node; + zend_op *opline; + zend_bool send_user = 0; + + if (zend_is_variable(arg_ast) && !zend_is_call(arg_ast)) { + zend_compile_var(&arg_node, arg_ast, BP_VAR_FUNC_ARG | (i << BP_VAR_SHIFT) TSRMLS_CC); + send_user = 1; + } else { + zend_compile_expr(&arg_node, arg_ast TSRMLS_CC); + if (arg_node.op_type & (IS_VAR|IS_CV)) { + send_user = 1; } + } + + if (send_user) { + opline = zend_emit_op(NULL, ZEND_SEND_USER, &arg_node, NULL TSRMLS_CC); } else { - SET_UNUSED(opline->op2); + opline = zend_emit_op(NULL, ZEND_SEND_VAL, &arg_node, NULL TSRMLS_CC); } - } else { - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); + + opline->op2.opline_num = i; } + zend_emit_op(result, ZEND_DO_FCALL, NULL, NULL TSRMLS_CC); + + return SUCCESS; } -/* }}} */ -void zend_do_add_array_element(znode *result, znode *expr, znode *offset, zend_bool is_ref TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - zend_op *init_opline = &CG(active_op_array)->opcodes[result->u.op.opline_num]; - init_opline->extended_value += 1 << ZEND_ARRAY_SIZE_SHIFT; /* increment size */ - - opline->opcode = ZEND_ADD_ARRAY_ELEMENT; - COPY_NODE(opline->result, init_opline->result); - SET_NODE(opline->op1, expr); - if (offset) { - SET_NODE(opline->op2, offset); - if (opline->op2_type == IS_CONST && Z_TYPE(CONSTANT(opline->op2.constant)) == IS_STRING) { - zend_ulong index; - - init_opline->extended_value |= ZEND_ARRAY_NOT_PACKED; - if (ZEND_HANDLE_NUMERIC(Z_STR(CONSTANT(opline->op2.constant)), index)) { - zval_dtor(&CONSTANT(opline->op2.constant)); - ZVAL_LONG(&CONSTANT(opline->op2.constant), index); - } - } +int zend_try_compile_special_func( + znode *result, zend_string *lcname, zend_ast_list *args TSRMLS_DC +) { + if (zend_str_equals_literal(lcname, "strlen")) { + return zend_compile_func_strlen(result, args TSRMLS_CC); + } else if (zend_str_equals_literal(lcname, "is_null")) { + return zend_compile_func_typecheck(result, args, IS_NULL TSRMLS_CC); + } else if (zend_str_equals_literal(lcname, "is_bool")) { + return zend_compile_func_typecheck(result, args, _IS_BOOL TSRMLS_CC); + } else if (zend_str_equals_literal(lcname, "is_long")) { + return zend_compile_func_typecheck(result, args, IS_LONG TSRMLS_CC); + } else if (zend_str_equals_literal(lcname, "is_float")) { + return zend_compile_func_typecheck(result, args, IS_DOUBLE TSRMLS_CC); + } else if (zend_str_equals_literal(lcname, "is_string")) { + return zend_compile_func_typecheck(result, args, IS_STRING TSRMLS_CC); + } else if (zend_str_equals_literal(lcname, "is_array")) { + return zend_compile_func_typecheck(result, args, IS_ARRAY TSRMLS_CC); + } else if (zend_str_equals_literal(lcname, "is_object")) { + return zend_compile_func_typecheck(result, args, IS_OBJECT TSRMLS_CC); + } else if (zend_str_equals_literal(lcname, "is_resource")) { + return zend_compile_func_typecheck(result, args, IS_RESOURCE TSRMLS_CC); + } else if (zend_str_equals_literal(lcname, "defined")) { + return zend_compile_func_defined(result, args TSRMLS_CC); + } else if (zend_str_equals_literal(lcname, "call_user_func_array")) { + return zend_compile_func_cufa(result, args, lcname TSRMLS_CC); + } else if (zend_str_equals_literal(lcname, "call_user_func")) { + return zend_compile_func_cuf(result, args, lcname TSRMLS_CC); } else { - SET_UNUSED(opline->op2); + return FAILURE; } - opline->extended_value = is_ref; } -/* }}} */ -void zend_do_end_array(znode *result, const znode *array_node TSRMLS_DC) /* {{{ */ -{ - int next_op_num = get_next_op_number(CG(active_op_array)); - zend_op *init_opline = &CG(active_op_array)->opcodes[array_node->u.op.opline_num]; - zend_op *opline; - int i; - int constant_array = 0; - zval array; - - /* check if constructed array consists only from constants */ - if ((init_opline->op1_type & (IS_UNUSED | IS_CONST)) && - (init_opline->op2_type & (IS_UNUSED | IS_CONST))) { - if (next_op_num == array_node->u.op.opline_num + 1) { - constant_array = 1; - } else if ((init_opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT) == next_op_num - array_node->u.op.opline_num) { - opline = init_opline + 1; - i = next_op_num - array_node->u.op.opline_num - 1; - while (i > 0) { - if (opline->opcode != ZEND_ADD_ARRAY_ELEMENT || - opline->op1_type != IS_CONST || - !(opline->op2_type & (IS_UNUSED | IS_CONST))) { - break; - } - opline++; - i--; - } - if (i == 0) { - constant_array = 1; - } - } +void zend_compile_call(znode *result, zend_ast *ast, int type TSRMLS_DC) { + zend_ast *name_ast = ast->child[0]; + zend_ast *args_ast = ast->child[1]; + + znode name_node; + + if (name_ast->kind != ZEND_AST_ZVAL || Z_TYPE_P(zend_ast_get_zval(name_ast)) != IS_STRING) { + zend_compile_expr(&name_node, name_ast TSRMLS_CC); + zend_compile_dynamic_call(result, &name_node, args_ast TSRMLS_CC); + return; } - - if (constant_array) { - /* try to construct constant array */ - uint32_t size; - zend_long num; - zend_string *str; - - if (init_opline->op1_type != IS_UNUSED) { - size = init_opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; - } else { - size = 0; + + { + zend_bool runtime_resolution = zend_compile_function_name(&name_node, name_ast TSRMLS_CC); + if (runtime_resolution) { + zend_compile_ns_call(result, &name_node, args_ast TSRMLS_CC); + return; } - ZVAL_NEW_ARR(&array); - zend_hash_init(Z_ARRVAL(array), size, NULL, ZVAL_PTR_DTOR, 0); + } - if (init_opline->op1_type != IS_UNUSED) { - /* Explicitly initialize array as not-packed if flag is set */ - if (init_opline->extended_value & ZEND_ARRAY_NOT_PACKED) { - zend_hash_real_init(Z_ARRVAL(array), 0); - } + { + zval *name = &name_node.u.constant; + zend_string *lcname = zend_string_alloc(Z_STRLEN_P(name), 0); + zend_function *fbc; + zend_op *opline; - opline = init_opline; - i = next_op_num - array_node->u.op.opline_num; - while (i > 0 && constant_array) { - if (opline->op2_type == IS_CONST) { - switch (Z_TYPE(CONSTANT(opline->op2.constant))) { - case IS_LONG: - num = Z_LVAL(CONSTANT(opline->op2.constant)); -num_index: - zend_hash_index_update(Z_ARRVAL(array), num, &CONSTANT(opline->op1.constant)); - if (Z_REFCOUNTED(CONSTANT(opline->op1.constant))) Z_ADDREF(CONSTANT(opline->op1.constant)); - break; - case IS_STRING: - str = Z_STR(CONSTANT(opline->op2.constant)); -str_index: - zend_hash_update(Z_ARRVAL(array), str, &CONSTANT(opline->op1.constant)); - if (Z_REFCOUNTED(CONSTANT(opline->op1.constant))) Z_ADDREF(CONSTANT(opline->op1.constant)); - break; - case IS_DOUBLE: - num = zend_dval_to_lval(Z_DVAL(CONSTANT(opline->op2.constant))); - goto num_index; - case IS_FALSE: - num = 0; - goto num_index; - case IS_TRUE: - num = 1; - goto num_index; - case IS_NULL: - str = STR_EMPTY_ALLOC(); - goto str_index; - default: - constant_array = 0; - break; - } - } else { - zend_hash_next_index_insert(Z_ARRVAL(array), &CONSTANT(opline->op1.constant)); - if (Z_REFCOUNTED(CONSTANT(opline->op1.constant))) Z_ADDREF(CONSTANT(opline->op1.constant)); - } - opline++; - i--; - } - if (!constant_array) { - zval_dtor(&array); - } + zend_str_tolower_copy(lcname->val, Z_STRVAL_P(name), Z_STRLEN_P(name)); + + fbc = zend_hash_find_ptr(CG(function_table), lcname); + if (!fbc || (fbc->type == ZEND_INTERNAL_FUNCTION && + (CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_FUNCTIONS)) + ) { + zend_string_release(lcname); + zend_compile_dynamic_call(result, &name_node, args_ast TSRMLS_CC); + return; } - } - if (constant_array) { - /* remove run-time array construction and use constant array instead */ - opline = &CG(active_op_array)->opcodes[next_op_num-1]; - while (1) { - if (opline->op2_type == IS_CONST) { - zend_del_literal(CG(active_op_array), opline->op2.constant); - } - if (opline->op1_type == IS_CONST) { - if (Z_TYPE(CONSTANT(opline->op1.constant)) == IS_ARRAY && - Z_REFCOUNTED(CONSTANT(opline->op1.constant)) && - Z_REFCOUNT(CONSTANT(opline->op1.constant)) == 2) { - /* don't delete nested arrays */ - Z_DELREF(CONSTANT(opline->op1.constant)); - ZVAL_UNDEF(&CONSTANT(opline->op1.constant)); - } - zend_del_literal(CG(active_op_array), opline->op1.constant); - } - if (opline == init_opline) { - break; - } - opline--; + if (zend_try_compile_special_func(result, lcname, + zend_ast_get_list(args_ast) TSRMLS_CC) == SUCCESS + ) { + zend_string_release(lcname); + zval_ptr_dtor(&name_node.u.constant); + return; } - CG(active_op_array)->last = array_node->u.op.opline_num; - result->op_type = IS_CONST; - ZVAL_COPY_VALUE(&result->u.constant, &array); - } else { - GET_NODE(result, init_opline->result); + zval_ptr_dtor(&name_node.u.constant); + ZVAL_NEW_STR(&name_node.u.constant, lcname); + + opline = zend_emit_op(NULL, ZEND_INIT_FCALL, NULL, &name_node TSRMLS_CC); + zend_alloc_cache_slot(opline->op2.constant TSRMLS_CC); + + zend_compile_call_common(result, args_ast, fbc TSRMLS_CC); } - result->EA = 0; } -/* }}} */ -void zend_do_add_list_element(const znode *element TSRMLS_DC) /* {{{ */ -{ - list_llist_element lle; +void zend_compile_method_call(znode *result, zend_ast *ast, int type TSRMLS_DC) { + zend_ast *obj_ast = ast->child[0]; + zend_ast *method_ast = ast->child[1]; + zend_ast *args_ast = ast->child[2]; - if (element) { - zend_check_writable_variable(element); + znode obj_node, method_node; + zend_op *opline; - lle.var = *element; - zend_llist_copy(&lle.dimensions, &CG(dimension_llist)); - zend_llist_prepend_element(&CG(list_llist), &lle); + if (is_this_fetch(obj_ast)) { + obj_node.op_type = IS_UNUSED; + } else { + zend_compile_var(&obj_node, obj_ast, type TSRMLS_CC); } - (*((int *)CG(dimension_llist).tail->data))++; -} -/* }}} */ -void zend_do_new_list_begin(TSRMLS_D) /* {{{ */ -{ - int current_dimension = 0; - zend_llist_add_element(&CG(dimension_llist), ¤t_dimension); -} -/* }}} */ + zend_compile_expr(&method_node, method_ast TSRMLS_CC); + opline = zend_emit_op(NULL, ZEND_INIT_METHOD_CALL, &obj_node, NULL TSRMLS_CC); + + if (method_node.op_type == IS_CONST) { + if (Z_TYPE(method_node.u.constant) != IS_STRING) { + zend_error_noreturn(E_COMPILE_ERROR, "Method name must be a string"); + } -void zend_do_new_list_end(TSRMLS_D) /* {{{ */ -{ - zend_llist_remove_tail(&CG(dimension_llist)); - (*((int *)CG(dimension_llist).tail->data))++; + opline->op2_type = IS_CONST; + opline->op2.constant = + zend_add_func_name_literal(CG(active_op_array), &method_node.u.constant TSRMLS_CC); + zend_alloc_polymorphic_cache_slot(opline->op2.constant TSRMLS_CC); + } else { + SET_NODE(opline->op2, &method_node); + } + + zend_compile_call_common(result, args_ast, NULL TSRMLS_CC); } -/* }}} */ -void zend_do_list_init(TSRMLS_D) /* {{{ */ -{ - zend_stack_push(&CG(list_stack), &CG(list_llist)); - zend_stack_push(&CG(list_stack), &CG(dimension_llist)); - zend_llist_init(&CG(list_llist), sizeof(list_llist_element), NULL, 0); - zend_llist_init(&CG(dimension_llist), sizeof(int), NULL, 0); - zend_do_new_list_begin(TSRMLS_C); +zend_bool zend_is_constructor(zend_string *name) { + return zend_str_equals_literal_ci(name, ZEND_CONSTRUCTOR_FUNC_NAME); } -/* }}} */ -void zend_do_list_end(znode *result, znode *expr TSRMLS_DC) /* {{{ */ -{ - zend_llist_element *le; - zend_llist_element *dimension; +void zend_compile_static_call(znode *result, zend_ast *ast, int type TSRMLS_DC) { + zend_ast *class_ast = ast->child[0]; + zend_ast *method_ast = ast->child[1]; + zend_ast *args_ast = ast->child[2]; + + znode class_node, method_node; zend_op *opline; - znode last_container; + zend_ulong extended_value = 0; - le = CG(list_llist).head; - while (le) { - zend_llist *tmp_dimension_llist = &((list_llist_element *)le->data)->dimensions; - dimension = tmp_dimension_llist->head; - while (dimension) { - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - if (dimension == tmp_dimension_llist->head) { /* first */ - last_container = *expr; - switch (expr->op_type) { - case IS_VAR: - case IS_CV: - opline->opcode = ZEND_FETCH_DIM_R; - break; - case IS_TMP_VAR: - opline->opcode = ZEND_FETCH_DIM_TMP_VAR; - break; - case IS_CONST: /* fetch_dim_tmp_var will handle this bogus fetch */ - zval_copy_ctor(&expr->u.constant); - opline->opcode = ZEND_FETCH_DIM_TMP_VAR; - break; - } - opline->extended_value |= ZEND_FETCH_ADD_LOCK; - } else { - opline->opcode = ZEND_FETCH_DIM_R; - } - opline->result_type = IS_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - SET_NODE(opline->op1, &last_container); - opline->op2_type = IS_CONST; - LITERAL_LONG(opline->op2, *((int *) dimension->data)); - GET_NODE(&last_container, opline->result); - dimension = dimension->next; + if (zend_is_const_default_class_ref(class_ast)) { + class_node.op_type = IS_CONST; + ZVAL_STR(&class_node.u.constant, zend_resolve_class_name_ast(class_ast TSRMLS_CC)); + } else { + opline = zend_compile_class_ref(&class_node, class_ast TSRMLS_CC); + extended_value = opline->extended_value; + } + + zend_compile_expr(&method_node, method_ast TSRMLS_CC); + if (method_node.op_type == IS_CONST) { + zval *name = &method_node.u.constant; + if (Z_TYPE_P(name) != IS_STRING) { + zend_error_noreturn(E_COMPILE_ERROR, "Method name must be a string"); + } + if (zend_is_constructor(Z_STR_P(name))) { + zval_ptr_dtor(name); + method_node.op_type = IS_UNUSED; } - ((list_llist_element *) le->data)->value = last_container; - zend_llist_destroy(&((list_llist_element *) le->data)->dimensions); - zend_do_assign(result, &((list_llist_element *) le->data)->var, &((list_llist_element *) le->data)->value TSRMLS_CC); - zend_do_free(result TSRMLS_CC); - le = le->next; } - zend_llist_destroy(&CG(dimension_llist)); - zend_llist_destroy(&CG(list_llist)); - *result = *expr; - { - zend_llist *p; - /* restore previous lists */ - p = zend_stack_top(&CG(list_stack)); - CG(dimension_llist) = *p; - zend_stack_del_top(&CG(list_stack)); - p = zend_stack_top(&CG(list_stack)); - CG(list_llist) = *p; - zend_stack_del_top(&CG(list_stack)); + opline = get_next_op(CG(active_op_array) TSRMLS_CC); + opline->opcode = ZEND_INIT_STATIC_METHOD_CALL; + opline->extended_value = extended_value; + + zend_set_class_name_op1(opline, &class_node TSRMLS_CC); + + if (method_node.op_type == IS_CONST) { + opline->op2_type = IS_CONST; + opline->op2.constant = + zend_add_func_name_literal(CG(active_op_array), &method_node.u.constant TSRMLS_CC); + if (opline->op1_type == IS_CONST) { + zend_alloc_cache_slot(opline->op2.constant TSRMLS_CC); + } else { + zend_alloc_polymorphic_cache_slot(opline->op2.constant TSRMLS_CC); + } + } else { + SET_NODE(opline->op2, &method_node); } + + zend_compile_call_common(result, args_ast, NULL TSRMLS_CC); } -/* }}} */ -void zend_init_list(void *result, void *item TSRMLS_DC) /* {{{ */ -{ - void** list = emalloc(sizeof(void*) * 2); +void zend_compile_new(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *class_ast = ast->child[0]; + zend_ast *args_ast = ast->child[1]; - list[0] = item; - list[1] = NULL; + znode class_node, ctor_result; + zend_op *opline; + uint32_t opnum; - *(void**)result = list; + zend_compile_class_ref(&class_node, class_ast TSRMLS_CC); + + opnum = get_next_op_number(CG(active_op_array)); + opline = zend_emit_op(result, ZEND_NEW, &class_node, NULL TSRMLS_CC); + + zend_compile_call_common(&ctor_result, args_ast, NULL TSRMLS_CC); + zend_do_free(&ctor_result TSRMLS_CC); + + /* New jumps over ctor call if ctor does not exist */ + opline = &CG(active_op_array)->opcodes[opnum]; + opline->op2.opline_num = get_next_op_number(CG(active_op_array)); } -/* }}} */ -void zend_add_to_list(void *result, void *item TSRMLS_DC) /* {{{ */ -{ - void** list = *(void**)result; - size_t n = 0; +void zend_compile_clone(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *obj_ast = ast->child[0]; - if (list) { - while (list[n]) { - n++; + znode obj_node; + zend_compile_expr(&obj_node, obj_ast TSRMLS_CC); + + zend_emit_op(result, ZEND_CLONE, &obj_node, NULL TSRMLS_CC); +} + +void zend_compile_global_var(zend_ast *ast TSRMLS_DC) { + zend_ast *var_ast = ast->child[0]; + zend_ast *name_ast = var_ast->child[0]; + + znode name_node, result; + + zend_compile_expr(&name_node, name_ast TSRMLS_CC); + if (name_node.op_type == IS_CONST) { + if (Z_TYPE(name_node.u.constant) != IS_STRING) { + convert_to_string(&name_node.u.constant); } } - list = erealloc(list, sizeof(void*) * (n+2)); + if (zend_try_compile_cv(&result, var_ast TSRMLS_CC) == SUCCESS) { + zend_emit_op(NULL, ZEND_BIND_GLOBAL, &result, &name_node TSRMLS_CC); + } else { + zend_emit_op(&result, ZEND_FETCH_W, &name_node, NULL TSRMLS_CC); - list[n] = item; - list[n+1] = NULL; + // TODO.AST Avoid double fetch + //opline->extended_value = ZEND_FETCH_GLOBAL_LOCK; - *(void**)result = list; + zend_emit_assign_ref_znode(var_ast, &result TSRMLS_CC); + } } -/* }}} */ -void zend_do_fetch_static_variable(znode *varname, znode *static_assignment, int fetch_type TSRMLS_DC) /* {{{ */ -{ - zval tmp; +static void zend_compile_static_var_common( + zend_ast *var_ast, zval *value, zend_bool by_ref TSRMLS_DC +) { + znode var_node, result; zend_op *opline; - znode lval; - znode result; - if (static_assignment) { - ZVAL_COPY_VALUE(&tmp, &static_assignment->u.constant); - } else { - ZVAL_NULL(&tmp); - Z_CONST_FLAGS(tmp) = 0; - } + zend_compile_expr(&var_node, var_ast TSRMLS_CC); + if (!CG(active_op_array)->static_variables) { if (CG(active_op_array)->scope) { CG(active_op_array)->scope->ce_flags |= ZEND_HAS_STATIC_IN_METHODS; @@ -6561,1402 +4524,3169 @@ void zend_do_fetch_static_variable(znode *varname, znode *static_assignment, int ALLOC_HASHTABLE(CG(active_op_array)->static_variables); zend_hash_init(CG(active_op_array)->static_variables, 8, NULL, ZVAL_PTR_DTOR, 0); } - zend_hash_update(CG(active_op_array)->static_variables, Z_STR(varname->u.constant), &tmp); - if (varname->op_type == IS_CONST) { - if (Z_TYPE(varname->u.constant) != IS_STRING) { - convert_to_string(&varname->u.constant); - } - } + zend_hash_update(CG(active_op_array)->static_variables, Z_STR(var_node.u.constant), value); - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = (fetch_type == ZEND_FETCH_LEXICAL) ? ZEND_FETCH_R : ZEND_FETCH_W; /* the default mode must be Write, since fetch_simple_variable() is used to define function arguments */ - opline->result_type = IS_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - SET_NODE(opline->op1, varname); - SET_UNUSED(opline->op2); + opline = zend_emit_op(&result, by_ref ? ZEND_FETCH_W : ZEND_FETCH_R, &var_node, NULL TSRMLS_CC); opline->extended_value = ZEND_FETCH_STATIC; - GET_NODE(&result, opline->result); - if (varname->op_type == IS_CONST) { - zval_copy_ctor(&varname->u.constant); + if (by_ref) { + zend_ast *fetch_ast = zend_ast_create(ZEND_AST_VAR, var_ast); + zend_emit_assign_ref_znode(fetch_ast, &result TSRMLS_CC); + } else { + zend_ast *fetch_ast = zend_ast_create(ZEND_AST_VAR, var_ast); + zend_emit_assign_znode(fetch_ast, &result TSRMLS_CC); } - fetch_simple_variable(&lval, varname, 0 TSRMLS_CC); /* Relies on the fact that the default fetch is BP_VAR_W */ +} - if (fetch_type == ZEND_FETCH_LEXICAL) { - znode dummy; +void zend_compile_static_var(zend_ast *ast TSRMLS_DC) { + zend_ast *var_ast = ast->child[0]; + zend_ast *value_ast = ast->child[1]; + zval value_zv; - zend_do_begin_variable_parse(TSRMLS_C); - zend_do_assign(&dummy, &lval, &result TSRMLS_CC); - zend_do_free(&dummy TSRMLS_CC); + if (value_ast) { + zend_const_expr_to_zval(&value_zv, value_ast TSRMLS_CC); } else { - zend_do_assign_ref(NULL, &lval, &result TSRMLS_CC); + ZVAL_NULL(&value_zv); } - CG(active_op_array)->opcodes[CG(active_op_array)->last-1].result_type |= EXT_TYPE_UNUSED; + + zend_compile_static_var_common(var_ast, &value_zv, 1 TSRMLS_CC); } -/* }}} */ -void zend_do_fetch_lexical_variable(znode *varname, zend_bool is_ref TSRMLS_DC) /* {{{ */ -{ - znode value; +void zend_compile_unset(zend_ast *ast TSRMLS_DC) { + zend_ast *var_ast = ast->child[0]; - if (Z_STRLEN(varname->u.constant) == sizeof("this") - 1 && - memcmp(Z_STRVAL(varname->u.constant), "this", sizeof("this") - 1) == 0) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use $this as lexical variable"); - return; + znode var_node; + zend_op *opline; + switch (var_ast->kind) { + case ZEND_AST_VAR: + if (zend_try_compile_cv(&var_node, var_ast TSRMLS_CC) == SUCCESS) { + opline = zend_emit_op(NULL, ZEND_UNSET_VAR, &var_node, NULL TSRMLS_CC); + opline->extended_value = ZEND_FETCH_LOCAL | ZEND_QUICK_SET; + } else { + opline = zend_compile_simple_var_no_cv(NULL, var_ast, BP_VAR_UNSET TSRMLS_CC); + opline->opcode = ZEND_UNSET_VAR; + } + return; + case ZEND_AST_DIM: + opline = zend_compile_dim_common(NULL, var_ast, BP_VAR_UNSET TSRMLS_CC); + opline->opcode = ZEND_UNSET_DIM; + return; + case ZEND_AST_PROP: + opline = zend_compile_prop_common(NULL, var_ast, BP_VAR_UNSET TSRMLS_CC); + opline->opcode = ZEND_UNSET_OBJ; + return; + case ZEND_AST_STATIC_PROP: + opline = zend_compile_static_prop_common(NULL, var_ast, BP_VAR_UNSET TSRMLS_CC); + opline->opcode = ZEND_UNSET_VAR; + return; + EMPTY_SWITCH_DEFAULT_CASE() } +} + +static void zend_free_foreach_and_switch_variables(TSRMLS_D) { + uint32_t opnum_start, opnum_end, i; + + opnum_start = get_next_op_number(CG(active_op_array)); - value.op_type = IS_CONST; - ZVAL_NULL(&value.u.constant); - Z_CONST_FLAGS(value.u.constant) = is_ref ? IS_LEXICAL_REF : IS_LEXICAL_VAR; - zend_do_fetch_static_variable(varname, &value, is_ref ? ZEND_FETCH_STATIC : ZEND_FETCH_LEXICAL TSRMLS_CC); +#ifdef ZTS + zend_stack_apply_with_argument(&CG(switch_cond_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element, void *)) generate_free_switch_expr TSRMLS_CC); + zend_stack_apply_with_argument(&CG(foreach_copy_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element, void *)) generate_free_foreach_copy TSRMLS_CC); +#else + zend_stack_apply(&CG(switch_cond_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element)) generate_free_switch_expr); + zend_stack_apply(&CG(foreach_copy_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element)) generate_free_foreach_copy); +#endif + + opnum_end = get_next_op_number(CG(active_op_array)); + + for (i = opnum_start; i < opnum_end; ++i) { + CG(active_op_array)->opcodes[i].extended_value |= EXT_TYPE_FREE_ON_RETURN; + } } -/* }}} */ -void zend_do_fetch_global_variable(znode *varname, const znode *static_assignment, int fetch_type TSRMLS_DC) /* {{{ */ -{ +void zend_compile_return(zend_ast *ast TSRMLS_DC) { + zend_ast *expr_ast = ast->child[0]; + zend_bool by_ref = (CG(active_op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0; + + znode expr_node; zend_op *opline; - znode lval; - znode result; - if (varname->op_type == IS_CONST) { - if (Z_TYPE(varname->u.constant) != IS_STRING) { - convert_to_string(&varname->u.constant); - } + if (!expr_ast) { + expr_node.op_type = IS_CONST; + ZVAL_NULL(&expr_node.u.constant); + } else if (by_ref && zend_is_variable(expr_ast) && !zend_is_call(expr_ast)) { + zend_compile_var(&expr_node, expr_ast, BP_VAR_REF TSRMLS_CC); + } else { + zend_compile_expr(&expr_node, expr_ast TSRMLS_CC); } - opline = get_next_op(CG(active_op_array) TSRMLS_CC); + zend_free_foreach_and_switch_variables(TSRMLS_C); - if (varname->op_type == IS_CONST && - !zend_is_auto_global(Z_STR(varname->u.constant) TSRMLS_CC) && - !(Z_STRLEN(varname->u.constant) == (sizeof("this")-1) && - !memcmp(Z_STRVAL(varname->u.constant), "this", sizeof("this") - 1))) { - opline->opcode = ZEND_BIND_GLOBAL; - SET_NODE(opline->op2, varname); - opline->op1_type = IS_CV; - zval_copy_ctor(&varname->u.constant); - opline->op1.var = lookup_cv(CG(active_op_array), Z_STR(varname->u.constant) TSRMLS_CC); - } else { - opline->opcode = ZEND_FETCH_W; /* the default mode must be Write, since fetch_simple_variable() is used to define function arguments */ - opline->result_type = IS_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - SET_NODE(opline->op1, varname); - SET_UNUSED(opline->op2); - opline->extended_value = fetch_type; - GET_NODE(&result, opline->result); + if (CG(context).in_finally) { + zend_emit_op(NULL, ZEND_DISCARD_EXCEPTION, NULL, NULL TSRMLS_CC); + } - if (varname->op_type == IS_CONST) { - zval_copy_ctor(&varname->u.constant); - } - fetch_simple_variable(&lval, varname, 0 TSRMLS_CC); /* Relies on the fact that the default fetch is BP_VAR_W */ + opline = zend_emit_op(NULL, by_ref ? ZEND_RETURN_BY_REF : ZEND_RETURN, + &expr_node, NULL TSRMLS_CC); - zend_do_assign_ref(NULL, &lval, &result TSRMLS_CC); - CG(active_op_array)->opcodes[CG(active_op_array)->last-1].result_type |= EXT_TYPE_UNUSED; + if (expr_ast) { + if (zend_is_call(expr_ast)) { + opline->extended_value = ZEND_RETURNS_FUNCTION; + } else if (!zend_is_variable(expr_ast)) { + opline->extended_value = ZEND_RETURNS_VALUE; + } } } -/* }}} */ -void zend_do_cast(znode *result, znode *expr, int type TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); +void zend_compile_echo(zend_ast *ast TSRMLS_DC) { + zend_ast *expr_ast = ast->child[0]; - opline->opcode = ZEND_CAST; - opline->result_type = IS_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - SET_NODE(opline->op1, expr); - SET_UNUSED(opline->op2); - opline->extended_value = type; - GET_NODE(result, opline->result); + znode expr_node; + zend_compile_expr(&expr_node, expr_ast TSRMLS_CC); + + zend_emit_op(NULL, ZEND_ECHO, &expr_node, NULL TSRMLS_CC); } -/* }}} */ -void zend_do_include_or_eval(int type, znode *result, znode *op1 TSRMLS_DC) /* {{{ */ -{ - zend_do_extended_fcall_begin(TSRMLS_C); - { - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); +void zend_compile_throw(zend_ast *ast TSRMLS_DC) { + zend_ast *expr_ast = ast->child[0]; - opline->opcode = ZEND_INCLUDE_OR_EVAL; - opline->result_type = IS_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - SET_NODE(opline->op1, op1); - SET_UNUSED(opline->op2); - opline->extended_value = type; - GET_NODE(result, opline->result); + znode expr_node; + zend_compile_expr(&expr_node, expr_ast TSRMLS_CC); + + zend_emit_op(NULL, ZEND_THROW, &expr_node, NULL TSRMLS_CC); +} + +void zend_compile_break_continue(zend_ast *ast TSRMLS_DC) { + zend_ast *depth_ast = ast->child[0]; + + znode depth_node; + zend_op *opline; + + ZEND_ASSERT(ast->kind == ZEND_AST_BREAK || ast->kind == ZEND_AST_CONTINUE); + + if (depth_ast) { + if (depth_ast->kind != ZEND_AST_ZVAL) { + zend_error_noreturn(E_COMPILE_ERROR, "'%s' operator with non-constant operand " + "is no longer supported", ast->kind == ZEND_AST_BREAK ? "break" : "continue"); + } + + zend_compile_expr(&depth_node, depth_ast TSRMLS_CC); + + if (Z_TYPE(depth_node.u.constant) != IS_LONG || Z_LVAL(depth_node.u.constant) < 1) { + zend_error_noreturn(E_COMPILE_ERROR, "'%s' operator accepts only positive numbers", + ast->kind == ZEND_AST_BREAK ? "break" : "continue"); + } + } else { + depth_node.op_type = IS_CONST; + ZVAL_LONG(&depth_node.u.constant, 1); } - zend_do_extended_fcall_end(TSRMLS_C); + + opline = zend_emit_op(NULL, ast->kind == ZEND_AST_BREAK ? ZEND_BRK : ZEND_CONT, + NULL, &depth_node TSRMLS_CC); + opline->op1.opline_num = CG(context).current_brk_cont; } -/* }}} */ -void zend_do_indirect_references(znode *result, const znode *num_references, znode *variable TSRMLS_DC) /* {{{ */ -{ - int i; +void zend_compile_goto(zend_ast *ast TSRMLS_DC) { + zend_ast *label_ast = ast->child[0]; + znode label_node; + zend_op *opline; - zend_do_end_variable_parse(variable, BP_VAR_R, 0 TSRMLS_CC); - for (i=1; i<Z_LVAL(num_references->u.constant); i++) { - fetch_simple_variable_ex(result, variable, 0, ZEND_FETCH_R TSRMLS_CC); - *variable = *result; + zend_compile_expr(&label_node, label_ast TSRMLS_CC); + opline = zend_emit_op(NULL, ZEND_GOTO, NULL, &label_node TSRMLS_CC); + opline->extended_value = CG(context).current_brk_cont; + zend_resolve_goto_label(CG(active_op_array), opline, 0 TSRMLS_CC); +} + +void zend_compile_label(zend_ast *ast TSRMLS_DC) { + zval *label = zend_ast_get_zval(ast->child[0]); + zend_label dest; + + ZEND_ASSERT(Z_TYPE_P(label) == IS_STRING); + + if (!CG(context).labels) { + ALLOC_HASHTABLE(CG(context).labels); + zend_hash_init(CG(context).labels, 8, NULL, ptr_dtor, 0); } - zend_do_begin_variable_parse(TSRMLS_C); - fetch_simple_variable(result, variable, 1 TSRMLS_CC); - /* there is a chance someone is accessing $this */ - if (CG(active_op_array)->scope && CG(active_op_array)->this_var == -1) { - zend_string *key = zend_string_init("this", sizeof("this")-1, 0); - CG(active_op_array)->this_var = lookup_cv(CG(active_op_array), key TSRMLS_CC); + + dest.brk_cont = CG(context).current_brk_cont; + dest.opline_num = get_next_op_number(CG(active_op_array)); + + if (!zend_hash_add_mem(CG(context).labels, Z_STR_P(label), &dest, sizeof(zend_label))) { + zend_error_noreturn(E_COMPILE_ERROR, "Label '%s' already defined", Z_STRVAL_P(label)); } } -/* }}} */ -void zend_do_unset(znode *variable TSRMLS_DC) /* {{{ */ -{ - zend_op *last_op; +void zend_compile_while(zend_ast *ast TSRMLS_DC) { + zend_ast *cond_ast = ast->child[0]; + zend_ast *stmt_ast = ast->child[1]; - zend_check_writable_variable(variable); + znode cond_node; + uint32_t opnum_start, opnum_jmpz; - if (variable->op_type == IS_CV) { - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_UNSET_VAR; - SET_NODE(opline->op1, variable); - SET_UNUSED(opline->op2); - SET_UNUSED(opline->result); - opline->extended_value = ZEND_FETCH_LOCAL | ZEND_QUICK_SET; - } else { - last_op = &CG(active_op_array)->opcodes[get_next_op_number(CG(active_op_array))-1]; + opnum_start = get_next_op_number(CG(active_op_array)); + zend_compile_expr(&cond_node, cond_ast TSRMLS_CC); - switch (last_op->opcode) { - case ZEND_FETCH_UNSET: - last_op->opcode = ZEND_UNSET_VAR; - SET_UNUSED(last_op->result); - break; - case ZEND_FETCH_DIM_UNSET: - last_op->opcode = ZEND_UNSET_DIM; - SET_UNUSED(last_op->result); - break; - case ZEND_FETCH_OBJ_UNSET: - last_op->opcode = ZEND_UNSET_OBJ; - SET_UNUSED(last_op->result); - break; + opnum_jmpz = zend_emit_cond_jump(ZEND_JMPZ, &cond_node, 0 TSRMLS_CC); + zend_begin_loop(TSRMLS_C); - } - } + zend_compile_stmt(stmt_ast TSRMLS_CC); + + zend_emit_jump(opnum_start TSRMLS_CC); + + zend_update_jump_target_to_next(opnum_jmpz TSRMLS_CC); + + zend_end_loop(opnum_start, 0 TSRMLS_CC); } -/* }}} */ -void zend_do_isset_or_isempty(int type, znode *result, znode *variable TSRMLS_DC) /* {{{ */ -{ - zend_op *last_op; +void zend_compile_do_while(zend_ast *ast TSRMLS_DC) { + zend_ast *stmt_ast = ast->child[0]; + zend_ast *cond_ast = ast->child[1]; - zend_do_end_variable_parse(variable, BP_VAR_IS, 0 TSRMLS_CC); + znode cond_node; + uint32_t opnum_start, opnum_cond; - if (zend_is_function_or_method_call(variable)) { - if (type == ZEND_ISEMPTY) { - /* empty(func()) can be transformed to !func() */ - zend_do_unary_op(ZEND_BOOL_NOT, result, variable TSRMLS_CC); - } else { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use isset() on the result of a function call (you can use \"null !== func()\" instead)"); - } + zend_begin_loop(TSRMLS_C); - return; - } + opnum_start = get_next_op_number(CG(active_op_array)); + zend_compile_stmt(stmt_ast TSRMLS_CC); - if (variable->op_type == IS_CV) { - last_op = get_next_op(CG(active_op_array) TSRMLS_CC); - last_op->opcode = ZEND_ISSET_ISEMPTY_VAR; - SET_NODE(last_op->op1, variable); - SET_UNUSED(last_op->op2); - last_op->result.var = get_temporary_variable(CG(active_op_array)); - last_op->extended_value = ZEND_FETCH_LOCAL | ZEND_QUICK_SET; - } else { - last_op = &CG(active_op_array)->opcodes[get_next_op_number(CG(active_op_array))-1]; + opnum_cond = get_next_op_number(CG(active_op_array)); + zend_compile_expr(&cond_node, cond_ast TSRMLS_CC); - switch (last_op->opcode) { - case ZEND_FETCH_IS: - last_op->opcode = ZEND_ISSET_ISEMPTY_VAR; - break; - case ZEND_FETCH_DIM_IS: - last_op->opcode = ZEND_ISSET_ISEMPTY_DIM_OBJ; - break; - case ZEND_FETCH_OBJ_IS: - last_op->opcode = ZEND_ISSET_ISEMPTY_PROP_OBJ; - break; - } - } - last_op->result_type = IS_TMP_VAR; - last_op->extended_value |= type; + zend_emit_cond_jump(ZEND_JMPNZ, &cond_node, opnum_start TSRMLS_CC); - GET_NODE(result, last_op->result); + zend_end_loop(opnum_cond, 0 TSRMLS_CC); } -/* }}} */ -void zend_do_instanceof(znode *result, znode *expr, znode *class_znode, int type TSRMLS_DC) /* {{{ */ -{ - int last_op_number = get_next_op_number(CG(active_op_array)); - zend_op *opline; +void zend_compile_expr_list(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast_list *list; + uint32_t i; - if (last_op_number > 0) { - opline = &CG(active_op_array)->opcodes[last_op_number-1]; - if (opline->opcode == ZEND_FETCH_CLASS) { - opline->extended_value |= ZEND_FETCH_CLASS_NO_AUTOLOAD; - } + result->op_type = IS_CONST; + ZVAL_TRUE(&result->u.constant); + + if (!ast) { + return; } - if (expr->op_type == IS_CONST) { - zend_error_noreturn(E_COMPILE_ERROR, "instanceof expects an object instance, constant given"); + list = zend_ast_get_list(ast); + for (i = 0; i < list->children; ++i) { + zend_ast *expr_ast = list->child[i]; + + zend_do_free(result TSRMLS_CC); + zend_compile_expr(result, expr_ast TSRMLS_CC); } +} - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_INSTANCEOF; - opline->result_type = IS_TMP_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - SET_NODE(opline->op1, expr); +void zend_compile_for(zend_ast *ast TSRMLS_DC) { + zend_ast *init_ast = ast->child[0]; + zend_ast *cond_ast = ast->child[1]; + zend_ast *loop_ast = ast->child[2]; + zend_ast *stmt_ast = ast->child[3]; - SET_NODE(opline->op2, class_znode); + znode result; + uint32_t opnum_cond, opnum_jmpz, opnum_loop; - GET_NODE(result, opline->result); + zend_compile_expr_list(&result, init_ast TSRMLS_CC); + zend_do_free(&result TSRMLS_CC); + + opnum_cond = get_next_op_number(CG(active_op_array)); + zend_compile_expr_list(&result, cond_ast TSRMLS_CC); + zend_do_extended_info(TSRMLS_C); + + opnum_jmpz = zend_emit_cond_jump(ZEND_JMPZ, &result, 0 TSRMLS_CC); + zend_begin_loop(TSRMLS_C); + + zend_compile_stmt(stmt_ast TSRMLS_CC); + + opnum_loop = get_next_op_number(CG(active_op_array)); + zend_compile_expr_list(&result, loop_ast TSRMLS_CC); + zend_do_free(&result TSRMLS_CC); + + zend_emit_jump(opnum_cond TSRMLS_CC); + + zend_update_jump_target_to_next(opnum_jmpz TSRMLS_CC); + + zend_end_loop(opnum_loop, 0 TSRMLS_CC); } -/* }}} */ -void zend_do_foreach_begin(znode *foreach_token, znode *open_brackets_token, znode *array, znode *as_token, int variable TSRMLS_DC) /* {{{ */ -{ +void zend_compile_foreach(zend_ast *ast TSRMLS_DC) { + zend_ast *expr_ast = ast->child[0]; + zend_ast *value_ast = ast->child[1]; + zend_ast *key_ast = ast->child[2]; + zend_ast *stmt_ast = ast->child[3]; + zend_bool by_ref = value_ast->kind == ZEND_AST_REF; + zend_bool is_variable = zend_is_variable(expr_ast) && !zend_is_call(expr_ast) + && zend_can_write_to_variable(expr_ast); + + znode expr_node, reset_node, value_node, key_node, dummy_node; zend_op *opline; - zend_bool is_variable; - zend_op dummy_opline; + uint32_t opnum_reset, opnum_fetch; + zend_op foreach_stack_opline; - if (variable) { - if (zend_is_function_or_method_call(array)) { - is_variable = 0; - } else { - is_variable = 1; + if (key_ast) { + if (key_ast->kind == ZEND_AST_REF) { + zend_error_noreturn(E_COMPILE_ERROR, "Key element cannot be a reference"); + } + if (key_ast->kind == ZEND_AST_LIST) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use list as key element"); } - /* save the location of FETCH_W instruction(s) */ - open_brackets_token->u.op.opline_num = get_next_op_number(CG(active_op_array)); - zend_do_end_variable_parse(array, BP_VAR_W, 0 TSRMLS_CC); - } else { - is_variable = 0; - open_brackets_token->u.op.opline_num = get_next_op_number(CG(active_op_array)); } - /* save the location of FE_RESET */ - foreach_token->u.op.opline_num = get_next_op_number(CG(active_op_array)); + if (by_ref) { + value_ast = value_ast->child[0]; + } - opline = get_next_op(CG(active_op_array) TSRMLS_CC); + if (by_ref && is_variable) { + zend_compile_var(&expr_node, expr_ast, BP_VAR_W TSRMLS_CC); + } else { + zend_compile_expr(&expr_node, expr_ast TSRMLS_CC); + } - /* Preform array reset */ - opline->opcode = ZEND_FE_RESET; - opline->result_type = IS_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - SET_NODE(opline->op1, array); - SET_UNUSED(opline->op2); - opline->extended_value = is_variable ? ZEND_FE_RESET_VARIABLE : 0; + opnum_reset = get_next_op_number(CG(active_op_array)); + opline = zend_emit_op(&reset_node, ZEND_FE_RESET, &expr_node, NULL TSRMLS_CC); + if (by_ref && is_variable) { + opline->extended_value = ZEND_FE_RESET_VARIABLE | ZEND_FE_RESET_REFERENCE; // ??? + } - COPY_NODE(dummy_opline.result, opline->result); - zend_stack_push(&CG(foreach_copy_stack), (void *) &dummy_opline); + SET_NODE(foreach_stack_opline.result, &reset_node); + zend_stack_push(&CG(foreach_copy_stack), &foreach_stack_opline); - /* save the location of FE_FETCH */ - as_token->u.op.opline_num = get_next_op_number(CG(active_op_array)); + opnum_fetch = get_next_op_number(CG(active_op_array)); + opline = zend_emit_op(&value_node, ZEND_FE_FETCH, &reset_node, NULL TSRMLS_CC); + if (by_ref) { + opline->extended_value |= ZEND_FE_FETCH_BYREF; + } + if (key_ast) { + opline->extended_value |= ZEND_FE_FETCH_WITH_KEY; + } - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_FE_FETCH; - opline->result_type = IS_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - COPY_NODE(opline->op1, dummy_opline.result); - opline->extended_value = 0; - SET_UNUSED(opline->op2); + opline = zend_emit_op(NULL, ZEND_OP_DATA, NULL, NULL TSRMLS_CC); - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_OP_DATA; /* Allocate enough space to keep HashPointer on VM stack */ opline->op1_type = IS_TMP_VAR; opline->op1.var = get_temporary_variable(CG(active_op_array)); if (sizeof(HashPointer) > sizeof(zval)) { - /* Make shure 1 zval is enough for HashPointer (2 must be enough) */ + /* Make sure 1 zval is enough for HashPointer (2 must be enough) */ get_temporary_variable(CG(active_op_array)); } - SET_UNUSED(opline->op2); - SET_UNUSED(opline->result); -} -/* }}} */ -void zend_do_foreach_cont(znode *foreach_token, const znode *open_brackets_token, const znode *as_token, znode *value, znode *key TSRMLS_DC) /* {{{ */ -{ - zend_op *opline; - znode dummy, value_node; - zend_bool assign_by_ref=0; + if (key_ast) { + zend_make_tmp_result(&key_node, opline TSRMLS_CC); + } + + if (value_ast->attr == ZEND_AST_LIST) { + zend_compile_list_assign(&dummy_node, value_ast, &value_node TSRMLS_CC); + zend_do_free(&dummy_node TSRMLS_CC); + } else if (by_ref) { + zend_emit_assign_ref_znode(value_ast, &value_node TSRMLS_CC); + } else { + zend_emit_assign_znode(value_ast, &value_node TSRMLS_CC); + } + + if (key_ast) { + zend_emit_assign_znode(key_ast, &key_node TSRMLS_CC); + } - opline = &CG(active_op_array)->opcodes[as_token->u.op.opline_num]; - if (key->op_type != IS_UNUSED) { - znode *tmp; + zend_begin_loop(TSRMLS_C); - /* switch between the key and value... */ - tmp = key; - key = value; - value = tmp; + zend_compile_stmt(stmt_ast TSRMLS_CC); - /* Mark extended_value in case both key and value are being used */ - opline->extended_value |= ZEND_FE_FETCH_WITH_KEY; + zend_emit_jump(opnum_fetch TSRMLS_CC); + + opline = &CG(active_op_array)->opcodes[opnum_reset]; + opline->op2.opline_num = get_next_op_number(CG(active_op_array)); + + opline = &CG(active_op_array)->opcodes[opnum_fetch]; + opline->op2.opline_num = get_next_op_number(CG(active_op_array)); + + zend_end_loop(opnum_fetch, 1 TSRMLS_CC); + + { + zend_op *container_ptr = zend_stack_top(&CG(foreach_copy_stack)); + generate_free_foreach_copy(container_ptr TSRMLS_CC); + zend_stack_del_top(&CG(foreach_copy_stack)); } +} - if ((key->op_type != IS_UNUSED)) { - if (key->EA & ZEND_PARSED_REFERENCE_VARIABLE) { - zend_error_noreturn(E_COMPILE_ERROR, "Key element cannot be a reference"); +void zend_compile_if(zend_ast *ast TSRMLS_DC) { + zend_ast_list *list = zend_ast_get_list(ast); + uint32_t i; + uint32_t *jmp_opnums = safe_emalloc(sizeof(uint32_t), list->children - 1, 0); + + for (i = 0; i < list->children; ++i) { + zend_ast *elem_ast = list->child[i]; + zend_ast *cond_ast = elem_ast->child[0]; + zend_ast *stmt_ast = elem_ast->child[1]; + + znode cond_node; + uint32_t opnum_jmpz; + if (cond_ast) { + zend_compile_expr(&cond_node, cond_ast TSRMLS_CC); + opnum_jmpz = zend_emit_cond_jump(ZEND_JMPZ, &cond_node, 0 TSRMLS_CC); } - if (key->EA & ZEND_PARSED_LIST_EXPR) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use list as key element"); + + zend_compile_stmt(stmt_ast TSRMLS_CC); + + if (i != list->children - 1) { + jmp_opnums[i] = zend_emit_jump(0 TSRMLS_CC); + } + + if (cond_ast) { + zend_update_jump_target_to_next(opnum_jmpz TSRMLS_CC); } } - if (value->EA & ZEND_PARSED_REFERENCE_VARIABLE) { - assign_by_ref = 1; + for (i = 0; i < list->children - 1; ++i) { + zend_update_jump_target_to_next(jmp_opnums[i] TSRMLS_CC); + } - /* Mark extended_value for assign-by-reference */ - opline->extended_value |= ZEND_FE_FETCH_BYREF; - CG(active_op_array)->opcodes[foreach_token->u.op.opline_num].extended_value |= ZEND_FE_RESET_REFERENCE; - } else { - zend_op *fetch = &CG(active_op_array)->opcodes[foreach_token->u.op.opline_num]; - zend_op *end = &CG(active_op_array)->opcodes[open_brackets_token->u.op.opline_num]; - - /* Change "write context" into "read context" */ - fetch->extended_value = 0; /* reset ZEND_FE_RESET_VARIABLE */ - while (fetch != end) { - --fetch; - if (fetch->opcode == ZEND_FETCH_DIM_W && fetch->op2_type == IS_UNUSED) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use [] for reading"); - } - if (fetch->opcode == ZEND_SEPARATE) { - MAKE_NOP(fetch); - } else { - fetch->opcode -= 3; /* FETCH_W -> FETCH_R */ - } + efree(jmp_opnums); +} + +void zend_compile_switch(zend_ast *ast TSRMLS_DC) { + zend_ast *expr_ast = ast->child[0]; + zend_ast_list *cases = zend_ast_get_list(ast->child[1]); + + uint32_t i; + zend_bool has_default_case = 0; + zend_switch_entry switch_entry; + + znode expr_node, case_node; + zend_op *opline; + uint32_t *jmpnz_opnums = safe_emalloc(sizeof(uint32_t), cases->children, 0); + uint32_t opnum_default_jmp; + + zend_compile_expr(&expr_node, expr_ast TSRMLS_CC); + + switch_entry.cond = expr_node; + switch_entry.default_case = -1; + switch_entry.control_var = -1; + zend_stack_push(&CG(switch_cond_stack), (void *) &switch_entry); + + zend_begin_loop(TSRMLS_C); + + case_node.op_type = IS_TMP_VAR; + case_node.u.op.var = get_temporary_variable(CG(active_op_array)); + + for (i = 0; i < cases->children; ++i) { + zend_ast *case_ast = cases->child[i]; + zend_ast *cond_ast = case_ast->child[0]; + znode cond_node; + + if (!cond_ast) { + has_default_case = 1; + continue; } - } - GET_NODE(&value_node, opline->result); + zend_compile_expr(&cond_node, cond_ast TSRMLS_CC); - if (value->EA & ZEND_PARSED_LIST_EXPR) { - if (!CG(list_llist).head) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use empty list"); + opline = zend_emit_op(NULL, ZEND_CASE, &expr_node, &cond_node TSRMLS_CC); + SET_NODE(opline->result, &case_node); + if (opline->op1_type == IS_CONST) { + zval_copy_ctor(&CONSTANT(opline->op1.constant)); } - zend_do_list_end(&dummy, &value_node TSRMLS_CC); - zend_do_free(&dummy TSRMLS_CC); - } else { - if (assign_by_ref) { - zend_do_end_variable_parse(value, BP_VAR_W, 0 TSRMLS_CC); - /* Mark FE_FETCH as IS_VAR as it holds the data directly as a value */ - zend_do_assign_ref(NULL, value, &value_node TSRMLS_CC); + + jmpnz_opnums[i] = zend_emit_cond_jump(ZEND_JMPNZ, &case_node, 0 TSRMLS_CC); + } + + opnum_default_jmp = zend_emit_jump(0 TSRMLS_CC); + + for (i = 0; i < cases->children; ++i) { + zend_ast *case_ast = cases->child[i]; + zend_ast *cond_ast = case_ast->child[0]; + zend_ast *stmt_ast = case_ast->child[1]; + + if (cond_ast) { + zend_update_jump_target_to_next(jmpnz_opnums[i] TSRMLS_CC); } else { - zend_do_assign(&dummy, value, &value_node TSRMLS_CC); - zend_do_free(&dummy TSRMLS_CC); + zend_update_jump_target_to_next(opnum_default_jmp TSRMLS_CC); } + + zend_compile_stmt(stmt_ast TSRMLS_CC); } - if (key->op_type != IS_UNUSED) { - znode key_node; + if (!has_default_case) { + zend_update_jump_target_to_next(opnum_default_jmp TSRMLS_CC); + } - opline = &CG(active_op_array)->opcodes[as_token->u.op.opline_num+1]; - opline->result_type = IS_TMP_VAR; - opline->result.opline_num = get_temporary_variable(CG(active_op_array)); - GET_NODE(&key_node, opline->result); + zend_end_loop(get_next_op_number(CG(active_op_array)), 1 TSRMLS_CC); - zend_do_assign(&dummy, key, &key_node TSRMLS_CC); - zend_do_free(&dummy TSRMLS_CC); + if (expr_node.op_type == IS_VAR || expr_node.op_type == IS_TMP_VAR) { + zend_emit_op(NULL, expr_node.op_type == IS_TMP_VAR ? ZEND_FREE : ZEND_SWITCH_FREE, + &expr_node, NULL TSRMLS_CC); + } else if (expr_node.op_type == IS_CONST) { + zval_dtor(&expr_node.u.constant); } - do_begin_loop(TSRMLS_C); - INC_BPC(CG(active_op_array)); + zend_stack_del_top(&CG(switch_cond_stack)); + efree(jmpnz_opnums); } -/* }}} */ -void zend_do_foreach_end(const znode *foreach_token, const znode *as_token TSRMLS_DC) /* {{{ */ -{ - zend_op *container_ptr; - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); +void zend_compile_try(zend_ast *ast TSRMLS_DC) { + zend_ast *try_ast = ast->child[0]; + zend_ast_list *catches = zend_ast_get_list(ast->child[1]); + zend_ast *finally_ast = ast->child[2]; - opline->opcode = ZEND_JMP; - opline->op1.opline_num = as_token->u.op.opline_num; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); + uint32_t i; + zend_op *opline; + uint32_t try_catch_offset = zend_add_try_element( + get_next_op_number(CG(active_op_array)) TSRMLS_CC); + uint32_t *jmp_opnums = safe_emalloc(sizeof(uint32_t), catches->children, 0); + + if (catches->children == 0 && !finally_ast) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use try without catch or finally"); + } - CG(active_op_array)->opcodes[foreach_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array)); /* FE_RESET */ - CG(active_op_array)->opcodes[as_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array)); /* FE_FETCH */ + zend_compile_stmt(try_ast TSRMLS_CC); - do_end_loop(as_token->u.op.opline_num, 1 TSRMLS_CC); + if (catches->children != 0) { + jmp_opnums[0] = zend_emit_jump(0 TSRMLS_CC); + } - container_ptr = zend_stack_top(&CG(foreach_copy_stack)); - generate_free_foreach_copy(container_ptr TSRMLS_CC); - zend_stack_del_top(&CG(foreach_copy_stack)); + for (i = 0; i < catches->children; ++i) { + zend_ast *catch_ast = catches->child[i]; + zend_ast *class_ast = catch_ast->child[0]; + zend_ast *var_ast = catch_ast->child[1]; + zend_ast *stmt_ast = catch_ast->child[2]; + zval *var_name = zend_ast_get_zval(var_ast); + zend_bool is_last_catch = (i + 1 == catches->children); + + uint32_t opnum_catch; + + if (!zend_is_const_default_class_ref(class_ast)) { + zend_error_noreturn(E_COMPILE_ERROR, "Bad class name in the catch statement"); + } + + opnum_catch = get_next_op_number(CG(active_op_array)); + if (i == 0) { + CG(active_op_array)->try_catch_array[try_catch_offset].catch_op = opnum_catch; + } + + CG(zend_lineno) = catch_ast->lineno; + + opline = get_next_op(CG(active_op_array) TSRMLS_CC); + opline->opcode = ZEND_CATCH; + opline->op1_type = IS_CONST; + opline->op1.constant = zend_add_class_name_literal(CG(active_op_array), + zend_resolve_class_name_ast(class_ast TSRMLS_CC) TSRMLS_CC); + + opline->op2_type = IS_CV; + opline->op2.var = lookup_cv(CG(active_op_array), zend_string_copy(Z_STR_P(var_name)) TSRMLS_CC); + opline->result.num = is_last_catch; + + zend_compile_stmt(stmt_ast TSRMLS_CC); - DEC_BPC(CG(active_op_array)); + if (!is_last_catch) { + jmp_opnums[i + 1] = zend_emit_jump(0 TSRMLS_CC); + } + + opline = &CG(active_op_array)->opcodes[opnum_catch]; + opline->extended_value = get_next_op_number(CG(active_op_array)); + } + + for (i = 0; i < catches->children; ++i) { + zend_update_jump_target_to_next(jmp_opnums[i] TSRMLS_CC); + } + + if (finally_ast) { + uint32_t opnum_jmp = get_next_op_number(CG(active_op_array)) + 1; + + opline = zend_emit_op(NULL, ZEND_FAST_CALL, NULL, NULL TSRMLS_CC); + opline->op1.opline_num = opnum_jmp + 1; + + zend_emit_op(NULL, ZEND_JMP, NULL, NULL TSRMLS_CC); + + CG(context).in_finally++; + zend_compile_stmt(finally_ast TSRMLS_CC); + CG(context).in_finally--; + + CG(active_op_array)->try_catch_array[try_catch_offset].finally_op = opnum_jmp + 1; + CG(active_op_array)->try_catch_array[try_catch_offset].finally_end + = get_next_op_number(CG(active_op_array)); + CG(active_op_array)->has_finally_block = 1; + + zend_emit_op(NULL, ZEND_FAST_RET, NULL, NULL TSRMLS_CC); + + zend_update_jump_target_to_next(opnum_jmp TSRMLS_CC); + } + + efree(jmp_opnums); } -/* }}} */ -void zend_do_declare_begin(TSRMLS_D) /* {{{ */ -{ - zend_stack_push(&CG(declare_stack), &CG(declarables)); +/* Encoding declarations must already be handled during parsing */ +void zend_handle_encoding_declaration(zend_ast_list *declares TSRMLS_DC) { + uint32_t i; + for (i = 0; i < declares->children; ++i) { + zend_ast *declare_ast = declares->child[i]; + zend_ast *name_ast = declare_ast->child[0]; + zend_ast *value_ast = declare_ast->child[1]; + zend_string *name = zend_ast_get_str(name_ast); + + if (zend_str_equals_literal_ci(name, "encoding")) { + if (value_ast->kind != ZEND_AST_ZVAL) { + zend_error_noreturn(E_COMPILE_ERROR, "Encoding must be a literal"); + } + + if (CG(multibyte)) { + zend_string *encoding_name = zval_get_string(zend_ast_get_zval(value_ast)); + + const zend_encoding *new_encoding, *old_encoding; + zend_encoding_filter old_input_filter; + + CG(encoding_declared) = 1; + + new_encoding = zend_multibyte_fetch_encoding(encoding_name->val TSRMLS_CC); + if (!new_encoding) { + zend_error(E_COMPILE_WARNING, "Unsupported encoding [%s]", encoding_name->val); + } else { + old_input_filter = LANG_SCNG(input_filter); + old_encoding = LANG_SCNG(script_encoding); + zend_multibyte_set_filter(new_encoding TSRMLS_CC); + + /* need to re-scan if input filter changed */ + if (old_input_filter != LANG_SCNG(input_filter) || + (old_input_filter && new_encoding != old_encoding)) { + zend_multibyte_yyinput_again(old_input_filter, old_encoding TSRMLS_CC); + } + } + + zend_string_release(encoding_name); + } else { + zend_error(E_COMPILE_WARNING, "declare(encoding=...) ignored because " + "Zend multibyte feature is turned off by settings"); + } + } + } } -/* }}} */ -void zend_do_declare_stmt(znode *var, znode *val TSRMLS_DC) /* {{{ */ -{ - if (!zend_binary_strcasecmp(Z_STRVAL(var->u.constant), Z_STRLEN(var->u.constant), "ticks", sizeof("ticks")-1)) { - convert_to_long(&val->u.constant); - CG(declarables).ticks = val->u.constant; - } else if (!zend_binary_strcasecmp(Z_STRVAL(var->u.constant), Z_STRLEN(var->u.constant), "encoding", sizeof("encoding")-1)) { - if (Z_TYPE(val->u.constant) == IS_CONSTANT) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use constants as encoding"); - } - - /* - * Check that the pragma comes before any opcodes. If the compilation - * got as far as this, the previous portion of the script must have been - * parseable according to the .ini script_encoding setting. We still - * want to tell them to put declare() at the top. - */ - { - int num = CG(active_op_array)->last; - /* ignore ZEND_EXT_STMT and ZEND_TICKS */ +void zend_compile_declare(zend_ast *ast TSRMLS_DC) { + zend_ast_list *declares = zend_ast_get_list(ast->child[0]); + zend_ast *stmt_ast = ast->child[1]; + zend_declarables orig_declarables = CG(declarables); + uint32_t i; + + for (i = 0; i < declares->children; ++i) { + zend_ast *declare_ast = declares->child[i]; + zend_ast *name_ast = declare_ast->child[0]; + zend_ast *value_ast = declare_ast->child[1]; + + zend_string *name = zend_ast_get_str(name_ast); + if (zend_str_equals_literal_ci(name, "ticks")) { + zval value_zv; + zend_const_expr_to_zval(&value_zv, value_ast TSRMLS_CC); + convert_to_long(&value_zv); + ZVAL_COPY_VALUE(&CG(declarables).ticks, &value_zv); + zval_dtor(&value_zv); + } else if (zend_str_equals_literal_ci(name, "encoding")) { + /* Encoding declaration was already handled during parsing. Here we + * only check that it is the first statement in the file. */ + uint32_t num = CG(active_op_array)->last; while (num > 0 && - (CG(active_op_array)->opcodes[num-1].opcode == ZEND_EXT_STMT || - CG(active_op_array)->opcodes[num-1].opcode == ZEND_TICKS)) { + (CG(active_op_array)->opcodes[num-1].opcode == ZEND_EXT_STMT || + CG(active_op_array)->opcodes[num-1].opcode == ZEND_TICKS)) { --num; } if (num > 0) { - zend_error_noreturn(E_COMPILE_ERROR, "Encoding declaration pragma must be the very first statement in the script"); + zend_error_noreturn(E_COMPILE_ERROR, "Encoding declaration pragma must be " + "the very first statement in the script"); + } + } else { + zend_error(E_COMPILE_WARNING, "Unsupported declare '%s'", name->val); + } + } + + if (stmt_ast) { + zend_compile_stmt(stmt_ast TSRMLS_CC); + + CG(declarables) = orig_declarables; + } +} + +void zend_compile_stmt_list(zend_ast *ast TSRMLS_DC) { + zend_ast_list *list = zend_ast_get_list(ast); + uint32_t i; + for (i = 0; i < list->children; ++i) { + zend_compile_stmt(list->child[i] TSRMLS_CC); + } +} + +void zend_compile_params(zend_ast *ast TSRMLS_DC) { + zend_ast_list *list = zend_ast_get_list(ast); + uint32_t i; + zend_op_array *op_array = CG(active_op_array); + zend_arg_info *arg_infos; + + if (list->children == 0) { + return; + } + + arg_infos = safe_emalloc(sizeof(zend_arg_info), list->children, 0); + for (i = 0; i < list->children; ++i) { + zend_ast *param_ast = list->child[i]; + zend_ast *type_ast = param_ast->child[0]; + zend_ast *var_ast = param_ast->child[1]; + zend_ast *default_ast = param_ast->child[2]; + zend_string *name = zend_ast_get_str(var_ast); + zend_bool is_ref = (param_ast->attr & ZEND_PARAM_REF) != 0; + zend_bool is_variadic = (param_ast->attr & ZEND_PARAM_VARIADIC) != 0; + + znode var_node, default_node; + zend_uchar opcode; + zend_op *opline; + zend_arg_info *arg_info; + + if (zend_is_auto_global(name TSRMLS_CC)) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign auto-global variable %s", + name->val); + } + + var_node.op_type = IS_CV; + var_node.u.op.var = lookup_cv(CG(active_op_array), zend_string_copy(name) TSRMLS_CC); + + if (EX_VAR_TO_NUM(var_node.u.op.var) != i) { + zend_error_noreturn(E_COMPILE_ERROR, "Redefinition of parameter $%s", + name->val); + } else if (zend_str_equals_literal(name, "this")) { + if (op_array->scope && (op_array->fn_flags & ZEND_ACC_STATIC) == 0) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this"); } + op_array->this_var = var_node.u.op.var; } - if (CG(multibyte)) { - const zend_encoding *new_encoding, *old_encoding; - zend_encoding_filter old_input_filter; + if (op_array->fn_flags & ZEND_ACC_VARIADIC) { + zend_error_noreturn(E_COMPILE_ERROR, "Only the last parameter can be variadic"); + } - CG(encoding_declared) = 1; + if (is_variadic) { + opcode = ZEND_RECV_VARIADIC; + default_node.op_type = IS_UNUSED; + op_array->fn_flags |= ZEND_ACC_VARIADIC; - convert_to_string(&val->u.constant); - new_encoding = zend_multibyte_fetch_encoding(Z_STRVAL(val->u.constant) TSRMLS_CC); - if (!new_encoding) { - zend_error(E_COMPILE_WARNING, "Unsupported encoding [%s]", Z_STRVAL(val->u.constant)); + if (default_ast) { + zend_error_noreturn(E_COMPILE_ERROR, + "Variadic parameter cannot have a default value"); + } + } else if (default_ast) { + opcode = ZEND_RECV_INIT; + default_node.op_type = IS_CONST; + zend_const_expr_to_zval(&default_node.u.constant, default_ast TSRMLS_CC); + } else { + opcode = ZEND_RECV; + default_node.op_type = IS_UNUSED; + op_array->required_num_args = i + 1; + } + + opline = zend_emit_op(NULL, opcode, NULL, &default_node TSRMLS_CC); + SET_NODE(opline->result, &var_node); + opline->op1.num = i + 1; + + arg_info = &arg_infos[i]; + arg_info->name = estrndup(name->val, name->len); + arg_info->name_len = name->len; + arg_info->pass_by_reference = is_ref; + arg_info->is_variadic = is_variadic; + arg_info->type_hint = 0; + arg_info->allow_null = 1; + arg_info->class_name = NULL; + arg_info->class_name_len = 0; + + if (type_ast) { + zend_bool has_null_default = default_ast + && (Z_TYPE(default_node.u.constant) == IS_NULL + || (Z_TYPE(default_node.u.constant) == IS_CONSTANT + && strcasecmp(Z_STRVAL(default_node.u.constant), "NULL")) + || Z_TYPE(default_node.u.constant) == IS_CONSTANT_AST); // ??? + + op_array->fn_flags |= ZEND_ACC_HAS_TYPE_HINTS; + arg_info->allow_null = has_null_default; + + if (type_ast->kind == ZEND_AST_TYPE) { + arg_info->type_hint = type_ast->attr; + if (arg_info->type_hint == IS_ARRAY) { + if (default_ast && !has_null_default + && Z_TYPE(default_node.u.constant) != IS_ARRAY + ) { + zend_error_noreturn(E_COMPILE_ERROR, "Default value for parameters " + "with array type hint can only be an array or NULL"); + } + } else if (arg_info->type_hint == IS_CALLABLE && default_ast) { + if (default_ast && !has_null_default) { + zend_error_noreturn(E_COMPILE_ERROR, "Default value for parameters " + "with callable type hint can only be NULL"); + } + } } else { - old_input_filter = LANG_SCNG(input_filter); - old_encoding = LANG_SCNG(script_encoding); - zend_multibyte_set_filter(new_encoding TSRMLS_CC); - - /* need to re-scan if input filter changed */ - if (old_input_filter != LANG_SCNG(input_filter) || - (old_input_filter && new_encoding != old_encoding)) { - zend_multibyte_yyinput_again(old_input_filter, old_encoding TSRMLS_CC); + zend_string *class_name = zend_ast_get_str(type_ast); + + if (zend_is_const_default_class_ref(type_ast)) { + class_name = zend_resolve_class_name_ast(type_ast TSRMLS_CC); + } else { + zend_string_addref(class_name); + } + + arg_info->type_hint = IS_OBJECT; + arg_info->class_name = estrndup(class_name->val, class_name->len); + arg_info->class_name_len = class_name->len; + + zend_string_release(class_name); + + if (default_ast && !has_null_default) { + zend_error_noreturn(E_COMPILE_ERROR, "Default value for parameters " + "with a class type hint can only be NULL"); } } - } else { - zend_error(E_COMPILE_WARNING, "declare(encoding=...) ignored because Zend multibyte feature is turned off by settings"); } - zval_dtor(&val->u.constant); - } else { - zend_error(E_COMPILE_WARNING, "Unsupported declare '%s'", Z_STRVAL(var->u.constant)); - zval_dtor(&val->u.constant); } - zval_dtor(&var->u.constant); + + /* These are assigned at the end to avoid unitialized memory in case of an error */ + op_array->num_args = list->children; + op_array->arg_info = arg_infos; } -/* }}} */ -void zend_do_declare_end(const znode *declare_token TSRMLS_DC) /* {{{ */ -{ - zend_declarables *declarables = zend_stack_top(&CG(declare_stack)); - /* We should restore if there was more than (current - start) - (ticks?1:0) opcodes */ - if ((get_next_op_number(CG(active_op_array)) - declare_token->u.op.opline_num) - ((Z_LVAL(CG(declarables).ticks))?1:0)) { - CG(declarables) = *declarables; +void zend_compile_closure_uses(zend_ast *ast TSRMLS_DC) { + zend_ast_list *list = zend_ast_get_list(ast); + uint32_t i; + + for (i = 0; i < list->children; ++i) { + zend_ast *var_ast = list->child[i]; + zend_string *name = zend_ast_get_str(var_ast); + zend_bool by_ref = var_ast->attr; + zval zv; + + if (zend_str_equals_literal(name, "this")) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use $this as lexical variable"); + } + + ZVAL_NULL(&zv); + Z_CONST_FLAGS(zv) = by_ref ? IS_LEXICAL_REF : IS_LEXICAL_VAR; + + zend_compile_static_var_common(var_ast, &zv, by_ref TSRMLS_CC); } } -/* }}} */ -void zend_do_exit(znode *result, znode *message TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); +void zend_begin_method_decl( + zend_op_array *op_array, zend_string *name, zend_bool has_body TSRMLS_DC +) { + zend_class_entry *ce = CG(active_class_entry); + zend_bool in_interface = (ce->ce_flags & ZEND_ACC_INTERFACE) != 0; + zend_bool in_trait = ZEND_CE_IS_TRAIT(ce); + zend_bool is_public = (op_array->fn_flags & ZEND_ACC_PUBLIC) != 0; + zend_bool is_static = (op_array->fn_flags & ZEND_ACC_STATIC) != 0; - opline->opcode = ZEND_EXIT; - SET_NODE(opline->op1, message); - SET_UNUSED(opline->op2); + zend_string *lcname; - result->op_type = IS_CONST; - ZVAL_BOOL(&result->u.constant, 1); -} -/* }}} */ + if (in_interface) { + if ((op_array->fn_flags & ZEND_ACC_PPP_MASK) != ZEND_ACC_PUBLIC) { + zend_error_noreturn(E_COMPILE_ERROR, "Access type for interface method " + "%s::%s() must be omitted", ce->name->val, name->val); + } + op_array->fn_flags |= ZEND_ACC_ABSTRACT; + } else if (is_static && (op_array->fn_flags & ZEND_ACC_ABSTRACT)) { + zend_error(E_STRICT, "Static function %s::%s() should not be abstract", + ce->name->val, name->val); + } -void zend_do_begin_silence(znode *strudel_token TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + if (op_array->fn_flags & ZEND_ACC_ABSTRACT) { + //zend_op *opline; - opline->opcode = ZEND_BEGIN_SILENCE; - opline->result_type = IS_TMP_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); - GET_NODE(strudel_token, opline->result); -} -/* }}} */ + if (op_array->fn_flags & ZEND_ACC_PRIVATE) { + zend_error_noreturn(E_COMPILE_ERROR, "%s function %s::%s() cannot be declared private", + in_interface ? "Interface" : "Abstract", ce->name->val, name->val); + } -void zend_do_end_silence(znode *strudel_token TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + if (has_body) { + zend_error_noreturn(E_COMPILE_ERROR, "%s function %s::%s() cannot contain body", + in_interface ? "Interface" : "Abstract", ce->name->val, name->val); + } - opline->opcode = ZEND_END_SILENCE; - SET_NODE(opline->op1, strudel_token); - SET_UNUSED(opline->op2); -} -/* }}} */ + ce->ce_flags |= ZEND_ACC_IMPLICIT_ABSTRACT_CLASS; -void zend_do_jmp_set(znode *value, znode *jmp_token, znode *colon_token TSRMLS_DC) /* {{{ */ -{ - int op_number = get_next_op_number(CG(active_op_array)); - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + /*opline = get_next_op(op_array TSRMLS_CC); + opline->opcode = ZEND_RAISE_ABSTRACT_ERROR; + SET_UNUSED(opline->op1); + SET_UNUSED(opline->op2);*/ + } else if (!has_body) { + zend_error_noreturn(E_COMPILE_ERROR, "Non-abstract method %s::%s() must contain body", + ce->name->val, name->val); + } - if (value->op_type == IS_VAR || value->op_type == IS_CV) { - opline->opcode = ZEND_JMP_SET_VAR; - opline->result_type = IS_VAR; + op_array->scope = ce; + op_array->function_name = zend_string_copy(name); + + lcname = zend_string_alloc(name->len, 0); + zend_str_tolower_copy(lcname->val, name->val, name->len); + lcname = zend_new_interned_string(lcname TSRMLS_CC); + + if (zend_hash_add_ptr(&ce->function_table, lcname, op_array) == NULL) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare %s::%s()", + ce->name->val, name->val); + } + + if (in_interface) { + if (zend_str_equals_literal(lcname, ZEND_CALL_FUNC_NAME)) { + if (!is_public || is_static) { + zend_error(E_WARNING, "The magic method __call() must have " + "public visibility and cannot be static"); + } + } else if (zend_str_equals_literal(lcname, ZEND_CALLSTATIC_FUNC_NAME)) { + if (!is_public || !is_static) { + zend_error(E_WARNING, "The magic method __callStatic() must have " + "public visibility and be static"); + } + } else if (zend_str_equals_literal(lcname, ZEND_GET_FUNC_NAME)) { + if (!is_public || is_static) { + zend_error(E_WARNING, "The magic method __get() must have " + "public visibility and cannot be static"); + } + } else if (zend_str_equals_literal(lcname, ZEND_SET_FUNC_NAME)) { + if (!is_public || is_static) { + zend_error(E_WARNING, "The magic method __set() must have " + "public visibility and cannot be static"); + } + } else if (zend_str_equals_literal(lcname, ZEND_UNSET_FUNC_NAME)) { + if (!is_public || is_static) { + zend_error(E_WARNING, "The magic method __unset() must have " + "public visibility and cannot be static"); + } + } else if (zend_str_equals_literal(lcname, ZEND_ISSET_FUNC_NAME)) { + if (!is_public || is_static) { + zend_error(E_WARNING, "The magic method __isset() must have " + "public visibility and cannot be static"); + } + } else if (zend_str_equals_literal(lcname, ZEND_TOSTRING_FUNC_NAME)) { + if (!is_public || is_static) { + zend_error(E_WARNING, "The magic method __toString() must have " + "public visibility and cannot be static"); + } + } else if (zend_str_equals_literal(lcname, ZEND_INVOKE_FUNC_NAME)) { + if (!is_public || is_static) { + zend_error(E_WARNING, "The magic method __invoke() must have " + "public visibility and cannot be static"); + } + } else if (zend_str_equals_literal(lcname, ZEND_DEBUGINFO_FUNC_NAME)) { + if (!is_public || is_static) { + zend_error(E_WARNING, "The magic method __debugInfo() must have " + "public visibility and cannot be static"); + } + } } else { - opline->opcode = ZEND_JMP_SET; - opline->result_type = IS_TMP_VAR; + if (!in_trait && zend_str_equals_str_ci(lcname, ce->name)) { + if (!ce->constructor) { + ce->constructor = (zend_function *) op_array; + } + } else if (zend_str_equals_literal(lcname, ZEND_CONSTRUCTOR_FUNC_NAME)) { + if (CG(active_class_entry)->constructor) { + zend_error(E_STRICT, "Redefining already defined constructor for class %s", + ce->name->val); + } + ce->constructor = (zend_function *) op_array; + } else if (zend_str_equals_literal(lcname, ZEND_DESTRUCTOR_FUNC_NAME)) { + ce->destructor = (zend_function *) op_array; + } else if (zend_str_equals_literal(lcname, ZEND_CLONE_FUNC_NAME)) { + ce->clone = (zend_function *) op_array; + } else if (zend_str_equals_literal(lcname, ZEND_CALL_FUNC_NAME)) { + if (!is_public || is_static) { + zend_error(E_WARNING, "The magic method __call() must have " + "public visibility and cannot be static"); + } + ce->__call = (zend_function *) op_array; + } else if (zend_str_equals_literal(lcname, ZEND_CALLSTATIC_FUNC_NAME)) { + if (!is_public || !is_static) { + zend_error(E_WARNING, "The magic method __callStatic() must have " + "public visibility and be static"); + } + ce->__callstatic = (zend_function *) op_array; + } else if (zend_str_equals_literal(lcname, ZEND_GET_FUNC_NAME)) { + if (!is_public || is_static) { + zend_error(E_WARNING, "The magic method __get() must have " + "public visibility and cannot be static"); + } + ce->__get = (zend_function *) op_array; + } else if (zend_str_equals_literal(lcname, ZEND_SET_FUNC_NAME)) { + if (!is_public || is_static) { + zend_error(E_WARNING, "The magic method __set() must have " + "public visibility and cannot be static"); + } + ce->__set = (zend_function *) op_array; + } else if (zend_str_equals_literal(lcname, ZEND_UNSET_FUNC_NAME)) { + if (!is_public || is_static) { + zend_error(E_WARNING, "The magic method __unset() must have " + "public visibility and cannot be static"); + } + ce->__unset = (zend_function *) op_array; + } else if (zend_str_equals_literal(lcname, ZEND_ISSET_FUNC_NAME)) { + if (!is_public || is_static) { + zend_error(E_WARNING, "The magic method __isset() must have " + "public visibility and cannot be static"); + } + ce->__isset = (zend_function *) op_array; + } else if (zend_str_equals_literal(lcname, ZEND_TOSTRING_FUNC_NAME)) { + if (!is_public || is_static) { + zend_error(E_WARNING, "The magic method __toString() must have " + "public visibility and cannot be static"); + } + ce->__tostring = (zend_function *) op_array; + } else if (zend_str_equals_literal(lcname, ZEND_INVOKE_FUNC_NAME)) { + if (!is_public || is_static) { + zend_error(E_WARNING, "The magic method __invoke() must have " + "public visibility and cannot be static"); + } + } else if (zend_str_equals_literal(lcname, ZEND_DEBUGINFO_FUNC_NAME)) { + if (!is_public || is_static) { + zend_error(E_WARNING, "The magic method __debugInfo() must have " + "public visibility and cannot be static"); + } + ce->__debugInfo = (zend_function *) op_array; + } else if (!is_static) { + op_array->fn_flags |= ZEND_ACC_ALLOW_STATIC; + } } - opline->result.var = get_temporary_variable(CG(active_op_array)); - SET_NODE(opline->op1, value); - SET_UNUSED(opline->op2); - GET_NODE(colon_token, opline->result); + zend_string_release(lcname); +} - jmp_token->u.op.opline_num = op_number; +static void zend_begin_func_decl( + znode *result, zend_op_array *op_array, zend_ast_decl *decl TSRMLS_DC +) { + zend_ast *params_ast = decl->child[0]; + zend_string *name = decl->name, *lcname; + zend_op *opline; - INC_BPC(CG(active_op_array)); -} -/* }}} */ + op_array->function_name = name = zend_prefix_with_ns(name TSRMLS_CC); -void zend_do_jmp_set_else(znode *result, znode *false_value, const znode *jmp_token, znode *colon_token TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + lcname = zend_string_alloc(name->len, 0); + zend_str_tolower_copy(lcname->val, name->val, name->len); - SET_NODE(opline->result, colon_token); - if (colon_token->op_type == IS_TMP_VAR) { - if (false_value->op_type == IS_VAR || false_value->op_type == IS_CV) { - CG(active_op_array)->opcodes[jmp_token->u.op.opline_num].opcode = ZEND_JMP_SET_VAR; - CG(active_op_array)->opcodes[jmp_token->u.op.opline_num].result_type = IS_VAR; - opline->opcode = ZEND_QM_ASSIGN_VAR; - opline->result_type = IS_VAR; - } else { - opline->opcode = ZEND_QM_ASSIGN; + if (CG(current_import_function)) { + zend_string *import_name = zend_hash_find_ptr(CG(current_import_function), lcname); + if (import_name && !zend_str_equals_str_ci(lcname, import_name)) { + zend_error(E_COMPILE_ERROR, "Cannot declare function %s " + "because the name is already in use", name->val); } + } + + if (zend_str_equals_literal(lcname, ZEND_AUTOLOAD_FUNC_NAME) + && zend_ast_get_list(params_ast)->children != 1 + ) { + zend_error_noreturn(E_COMPILE_ERROR, "%s() must take exactly 1 argument", + ZEND_AUTOLOAD_FUNC_NAME); + } + + if (op_array->fn_flags & ZEND_ACC_CLOSURE) { + opline = zend_emit_op_tmp(result, ZEND_DECLARE_LAMBDA_FUNCTION, NULL, NULL TSRMLS_CC); } else { - opline->opcode = ZEND_QM_ASSIGN_VAR; + opline = get_next_op(CG(active_op_array) TSRMLS_CC); + opline->opcode = ZEND_DECLARE_FUNCTION; + opline->op2_type = IS_CONST; + LITERAL_STR(opline->op2, zend_string_copy(lcname)); } - opline->extended_value = 0; - SET_NODE(opline->op1, false_value); - SET_UNUSED(opline->op2); - GET_NODE(result, opline->result); + { + zend_string *key = zend_build_runtime_definition_key(lcname, decl->lex_pos TSRMLS_CC); + + opline->op1_type = IS_CONST; + LITERAL_STR(opline->op1, key); - CG(active_op_array)->opcodes[jmp_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array)); + zend_hash_update_ptr(CG(function_table), key, op_array); + } - DEC_BPC(CG(active_op_array)); + zend_string_release(lcname); } -/* }}} */ -void zend_do_begin_qm_op(znode *cond, znode *qm_token TSRMLS_DC) /* {{{ */ -{ - int jmpz_op_number = get_next_op_number(CG(active_op_array)); - zend_op *opline; +void zend_compile_func_decl(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast_decl *decl = (zend_ast_decl *) ast; + zend_ast *params_ast = decl->child[0]; + zend_ast *uses_ast = decl->child[1]; + zend_ast *stmt_ast = decl->child[2]; + zend_bool is_method = decl->kind == ZEND_AST_METHOD; - opline = get_next_op(CG(active_op_array) TSRMLS_CC); + zend_op_array *orig_op_array = CG(active_op_array); + zend_op_array *op_array = zend_arena_alloc(&CG(arena), sizeof(zend_op_array)); - opline->opcode = ZEND_JMPZ; - SET_NODE(opline->op1, cond); - SET_UNUSED(opline->op2); - opline->op2.opline_num = jmpz_op_number; - GET_NODE(qm_token, opline->op2); + // TODO.AST interactive (not just here - also bpc etc!) + + init_op_array(op_array, ZEND_USER_FUNCTION, INITIAL_OP_ARRAY_SIZE TSRMLS_CC); - INC_BPC(CG(active_op_array)); -} -/* }}} */ + op_array->fn_flags |= decl->flags; + op_array->line_start = decl->start_lineno; + op_array->line_end = decl->end_lineno; + if (decl->doc_comment) { + op_array->doc_comment = zend_string_copy(decl->doc_comment); + } + if (decl->kind == ZEND_AST_CLOSURE) { + op_array->fn_flags |= ZEND_ACC_CLOSURE; + } -void zend_do_qm_true(znode *true_value, znode *qm_token, znode *colon_token TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + if (is_method) { + zend_bool has_body = stmt_ast != NULL; + zend_begin_method_decl(op_array, decl->name, has_body TSRMLS_CC); + } else { + zend_begin_func_decl(result, op_array, decl TSRMLS_CC); + } - CG(active_op_array)->opcodes[qm_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array))+1; /* jmp over the ZEND_JMP */ + CG(active_op_array) = op_array; + zend_stack_push(&CG(context_stack), (void *) &CG(context)); + zend_init_compiler_context(TSRMLS_C); - if (true_value->op_type == IS_VAR || true_value->op_type == IS_CV) { - opline->opcode = ZEND_QM_ASSIGN_VAR; - opline->result_type = IS_VAR; - } else { - opline->opcode = ZEND_QM_ASSIGN; - opline->result_type = IS_TMP_VAR; + if (CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO) { + zend_op *opline_ext = zend_emit_op(NULL, ZEND_EXT_NOP, NULL, NULL TSRMLS_CC); + opline_ext->lineno = decl->start_lineno; } - opline->result.var = get_temporary_variable(CG(active_op_array)); - SET_NODE(opline->op1, true_value); - SET_UNUSED(opline->op2); - GET_NODE(qm_token, opline->result); - colon_token->u.op.opline_num = get_next_op_number(CG(active_op_array)); + { + /* Push a separator to the switch stack */ + zend_switch_entry switch_entry; + + switch_entry.cond.op_type = IS_UNUSED; + switch_entry.default_case = 0; + switch_entry.control_var = 0; - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_JMP; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); + zend_stack_push(&CG(switch_cond_stack), (void *) &switch_entry); + } + + { + /* Push a separator to the foreach stack */ + zend_op dummy_opline; + + dummy_opline.result_type = IS_UNUSED; + + zend_stack_push(&CG(foreach_copy_stack), (void *) &dummy_opline); + } + + zend_compile_params(params_ast TSRMLS_CC); + if (uses_ast) { + zend_compile_closure_uses(uses_ast TSRMLS_CC); + } + zend_compile_stmt(stmt_ast TSRMLS_CC); + + if (is_method) { + zend_check_magic_method_implementation( + CG(active_class_entry), (zend_function *) op_array, E_COMPILE_ERROR TSRMLS_CC); + } + + zend_do_extended_info(TSRMLS_C); + zend_emit_final_return(NULL TSRMLS_CC); + + pass_two(CG(active_op_array) TSRMLS_CC); + zend_release_labels(0 TSRMLS_CC); + + /* Pop the switch and foreach separators */ + zend_stack_del_top(&CG(switch_cond_stack)); + zend_stack_del_top(&CG(foreach_copy_stack)); + + CG(active_op_array) = orig_op_array; } -/* }}} */ -void zend_do_qm_false(znode *result, znode *false_value, znode *qm_token, const znode *colon_token TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); +void zend_compile_prop_decl(zend_ast *ast TSRMLS_DC) { + zend_ast_list *list = zend_ast_get_list(ast); + uint32_t flags = list->attr; + zend_class_entry *ce = CG(active_class_entry); + uint32_t i, children = list->children; + zend_string *doc_comment = NULL; + + if (ce->ce_flags & ZEND_ACC_INTERFACE) { + zend_error_noreturn(E_COMPILE_ERROR, "Interfaces may not include member variables"); + } + + if (flags & ZEND_ACC_ABSTRACT) { + zend_error_noreturn(E_COMPILE_ERROR, "Properties cannot be declared abstract"); + } + + /* Doc comment has been appended as last element in property list */ + if (list->child[children - 1]->kind == ZEND_AST_ZVAL) { + doc_comment = zend_string_copy(zend_ast_get_str(list->child[children - 1])); + children -= 1; + } - SET_NODE(opline->result, qm_token); - if (qm_token->op_type == IS_TMP_VAR) { - if (false_value->op_type == IS_VAR || false_value->op_type == IS_CV) { - CG(active_op_array)->opcodes[colon_token->u.op.opline_num - 1].opcode = ZEND_QM_ASSIGN_VAR; - CG(active_op_array)->opcodes[colon_token->u.op.opline_num - 1].result_type = IS_VAR; - opline->opcode = ZEND_QM_ASSIGN_VAR; - opline->result_type = IS_VAR; + for (i = 0; i < children; ++i) { + zend_ast *prop_ast = list->child[i]; + zend_ast *name_ast = prop_ast->child[0]; + zend_ast *value_ast = prop_ast->child[1]; + zend_string *name = zend_ast_get_str(name_ast); + zval value_zv; + + if (flags & ZEND_ACC_FINAL) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot declare property %s::$%s final, " + "the final modifier is allowed only for methods and classes", + ce->name->val, name->val); + } + + if (zend_hash_exists(&ce->properties_info, name)) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare %s::$%s", + ce->name->val, name->val); + } + + if (value_ast) { + zend_const_expr_to_zval(&value_zv, value_ast TSRMLS_CC); } else { - opline->opcode = ZEND_QM_ASSIGN; + ZVAL_NULL(&value_zv); } + + name = zend_new_interned_string_safe(name TSRMLS_CC); + zend_declare_property_ex(ce, name, &value_zv, flags, doc_comment TSRMLS_CC); + + /* Doc comment is only assigned to first property */ + doc_comment = NULL; + } +} + +void zend_compile_class_const_decl(zend_ast *ast TSRMLS_DC) { + zend_ast_list *list = zend_ast_get_list(ast); + zend_class_entry *ce = CG(active_class_entry); + uint32_t i; + + for (i = 0; i < list->children; ++i) { + zend_ast *const_ast = list->child[i]; + zend_ast *name_ast = const_ast->child[0]; + zend_ast *value_ast = const_ast->child[1]; + zend_string *name = zend_ast_get_str(name_ast); + zval value_zv; + + if (ZEND_CE_IS_TRAIT(ce)) { + zend_error_noreturn(E_COMPILE_ERROR, "Traits cannot have constants"); + return; + } + + zend_const_expr_to_zval(&value_zv, value_ast TSRMLS_CC); + + name = zend_new_interned_string_safe(name TSRMLS_CC); + if (zend_hash_add(&ce->constants_table, name, &value_zv) == NULL) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot redefine class constant %s::%s", + ce->name->val, name->val); + } + + if (Z_CONSTANT(value_zv)) { + ce->ce_flags &= ~ZEND_ACC_CONSTANTS_UPDATED; + } + } +} + +static zend_trait_method_reference *zend_compile_method_ref(zend_ast *ast TSRMLS_DC) { + zend_ast *class_ast = ast->child[0]; + zend_ast *method_ast = ast->child[1]; + + zend_trait_method_reference *method_ref = emalloc(sizeof(zend_trait_method_reference)); + method_ref->ce = NULL; + method_ref->method_name = zend_string_copy(zend_ast_get_str(method_ast)); + + if (class_ast) { + method_ref->class_name = zend_resolve_class_name_ast(class_ast TSRMLS_CC); } else { - opline->opcode = ZEND_QM_ASSIGN_VAR; + method_ref->class_name = NULL; } - SET_NODE(opline->op1, false_value); - SET_UNUSED(opline->op2); - CG(active_op_array)->opcodes[colon_token->u.op.opline_num].op1.opline_num = get_next_op_number(CG(active_op_array)); + return method_ref; +} - GET_NODE(result, opline->result); +static zend_string **zend_compile_name_list(zend_ast *ast TSRMLS_DC) { + zend_ast_list *list = zend_ast_get_list(ast); + zend_string **names = safe_emalloc(sizeof(zend_string *), list->children + 1, 0); + uint32_t i; + + for (i = 0; i < list->children; ++i) { + zend_ast *name_ast = list->child[i]; + names[i] = zend_resolve_class_name_ast(name_ast TSRMLS_CC); + } + + names[list->children] = NULL; - DEC_BPC(CG(active_op_array)); + return names; } -/* }}} */ -void zend_do_extended_info(TSRMLS_D) /* {{{ */ -{ - zend_op *opline; +static void zend_compile_trait_precedence(zend_ast *ast TSRMLS_DC) { + zend_ast *method_ref_ast = ast->child[0]; + zend_ast *insteadof_ast = ast->child[1]; + + zend_trait_precedence *precedence = emalloc(sizeof(zend_trait_precedence)); + precedence->trait_method = zend_compile_method_ref(method_ref_ast TSRMLS_CC); + precedence->exclude_from_classes + = (void *) zend_compile_name_list(insteadof_ast TSRMLS_CC); - if (!(CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO)) { - return; + zend_add_to_list(&CG(active_class_entry)->trait_precedences, precedence TSRMLS_CC); +} + +static void zend_compile_trait_alias(zend_ast *ast TSRMLS_DC) { + zend_ast *method_ref_ast = ast->child[0]; + zend_ast *alias_ast = ast->child[1]; + uint32_t modifiers = ast->attr; + + zend_trait_alias *alias; + + if (modifiers == ZEND_ACC_STATIC) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use 'static' as method modifier"); + } else if (modifiers == ZEND_ACC_ABSTRACT) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use 'abstract' as method modifier"); + } else if (modifiers == ZEND_ACC_FINAL) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use 'final' as method modifier"); } - opline = get_next_op(CG(active_op_array) TSRMLS_CC); + alias = emalloc(sizeof(zend_trait_alias)); + alias->trait_method = zend_compile_method_ref(method_ref_ast TSRMLS_CC); + alias->modifiers = modifiers; - opline->opcode = ZEND_EXT_STMT; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); + if (alias_ast) { + alias->alias = zend_string_copy(zend_ast_get_str(alias_ast)); + } else { + alias->alias = NULL; + } + + zend_add_to_list(&CG(active_class_entry)->trait_aliases, alias TSRMLS_CC); } -/* }}} */ -void zend_do_extended_fcall_begin(TSRMLS_D) /* {{{ */ -{ +void zend_compile_use_trait(zend_ast *ast TSRMLS_DC) { + zend_ast_list *traits = zend_ast_get_list(ast->child[0]); + zend_ast_list *adaptations = ast->child[1] ? zend_ast_get_list(ast->child[1]) : NULL; + zend_class_entry *ce = CG(active_class_entry); zend_op *opline; + uint32_t i; - if (!(CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO)) { + for (i = 0; i < traits->children; ++i) { + zend_ast *trait_ast = traits->child[i]; + zend_string *name = zend_ast_get_str(trait_ast); + + if (ce->ce_flags & ZEND_ACC_INTERFACE) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use traits inside of interfaces. " + "%s is used in %s", name->val, ce->name->val); + } + + switch (zend_get_class_fetch_type(name)) { + case ZEND_FETCH_CLASS_SELF: + case ZEND_FETCH_CLASS_PARENT: + case ZEND_FETCH_CLASS_STATIC: + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as trait name " + "as it is reserved", name->val); + break; + } + + opline = get_next_op(CG(active_op_array) TSRMLS_CC); + opline->opcode = ZEND_ADD_TRAIT; + SET_NODE(opline->op1, &CG(implementing_class)); + opline->extended_value = ZEND_FETCH_CLASS_TRAIT; + opline->op2_type = IS_CONST; + opline->op2.constant = zend_add_class_name_literal(CG(active_op_array), + zend_resolve_class_name_ast(trait_ast TSRMLS_CC) TSRMLS_CC); + + ce->num_traits++; + } + + if (!adaptations) { return; } - opline = get_next_op(CG(active_op_array) TSRMLS_CC); + for (i = 0; i < adaptations->children; ++i) { + zend_ast *adaptation_ast = adaptations->child[i]; + switch (adaptation_ast->kind) { + case ZEND_AST_TRAIT_PRECEDENCE: + zend_compile_trait_precedence(adaptation_ast TSRMLS_CC); + break; + case ZEND_AST_TRAIT_ALIAS: + zend_compile_trait_alias(adaptation_ast TSRMLS_CC); + break; + EMPTY_SWITCH_DEFAULT_CASE() + } + } +} - opline->opcode = ZEND_EXT_FCALL_BEGIN; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); +void zend_compile_implements(znode *class_node, zend_ast *ast TSRMLS_DC) { + zend_ast_list *list = zend_ast_get_list(ast); + uint32_t i; + for (i = 0; i < list->children; ++i) { + zend_ast *class_ast = list->child[i]; + zend_string *name = zend_ast_get_str(class_ast); + + zend_op *opline; + + /* Traits can not implement interfaces */ + if (ZEND_CE_IS_TRAIT(CG(active_class_entry))) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as interface on '%s' " + "since it is a Trait", name->val, CG(active_class_entry)->name->val); + } + + if (!zend_is_const_default_class_ref(class_ast)) { + zend_error_noreturn(E_COMPILE_ERROR, + "Cannot use '%s' as interface name as it is reserved", name->val); + } + + opline = zend_emit_op(NULL, ZEND_ADD_INTERFACE, class_node, NULL TSRMLS_CC); + opline->extended_value = ZEND_FETCH_CLASS_INTERFACE; + opline->op2_type = IS_CONST; + opline->op2.constant = zend_add_class_name_literal(CG(active_op_array), + zend_resolve_class_name_ast(class_ast TSRMLS_CC) TSRMLS_CC); + + CG(active_class_entry)->num_interfaces++; + } } -/* }}} */ -void zend_do_extended_fcall_end(TSRMLS_D) /* {{{ */ -{ +void zend_compile_class_decl(zend_ast *ast TSRMLS_DC) { + zend_ast_decl *decl = (zend_ast_decl *) ast; + zend_ast *extends_ast = decl->child[0]; + zend_ast *implements_ast = decl->child[1]; + zend_ast *stmt_ast = decl->child[2]; + + zend_string *name = decl->name, *lcname, *import_name = NULL; + zend_class_entry *ce = zend_arena_alloc(&CG(arena), sizeof(zend_class_entry)); zend_op *opline; + znode declare_node, extends_node; - if (!(CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO)) { + if (CG(active_class_entry)) { + zend_error_noreturn(E_COMPILE_ERROR, "Class declarations may not be nested"); return; } - opline = get_next_op(CG(active_op_array) TSRMLS_CC); + if (ZEND_FETCH_CLASS_DEFAULT != zend_get_class_fetch_type(name)) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as class name as it is reserved", + name->val); + } - opline->opcode = ZEND_EXT_FCALL_END; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); -} -/* }}} */ + lcname = zend_string_alloc(name->len, 0); + zend_str_tolower_copy(lcname->val, name->val, name->len); -void zend_do_ticks(TSRMLS_D) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + if (CG(current_import)) { + import_name = zend_hash_find_ptr(CG(current_import), lcname); + } - opline->opcode = ZEND_TICKS; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); - opline->extended_value = Z_LVAL(CG(declarables).ticks); -} -/* }}} */ + if (CG(current_namespace)) { + name = zend_prefix_with_ns(name TSRMLS_CC); -zend_bool zend_is_auto_global(zend_string *name TSRMLS_DC) /* {{{ */ -{ - zend_auto_global *auto_global; + zend_string_release(lcname); + lcname = zend_string_alloc(name->len, 0); + zend_str_tolower_copy(lcname->val, name->val, name->len); + } else { + zend_string_addref(name); + } - if ((auto_global = zend_hash_find_ptr(CG(auto_globals), name)) != NULL) { - if (auto_global->armed) { - auto_global->armed = auto_global->auto_global_callback(auto_global->name TSRMLS_CC); + if (import_name && !zend_str_equals_str_ci(lcname, import_name)) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot declare class %s " + "because the name is already in use", name->val); + } + + name = zend_new_interned_string(name TSRMLS_CC); + lcname = zend_new_interned_string(lcname TSRMLS_CC); + + ce->type = ZEND_USER_CLASS; + ce->name = name; + zend_initialize_class_data(ce, 1 TSRMLS_CC); + + ce->ce_flags |= decl->flags; + ce->info.user.filename = zend_get_compiled_filename(TSRMLS_C); + ce->info.user.line_start = decl->start_lineno; + ce->info.user.line_end = decl->end_lineno; + if (decl->doc_comment) { + ce->info.user.doc_comment = zend_string_copy(decl->doc_comment); + } + + if (extends_ast) { + if (ZEND_CE_IS_TRAIT(ce)) { + zend_error_noreturn(E_COMPILE_ERROR, "A trait (%s) cannot extend a class. " + "Traits can only be composed from other traits with the 'use' keyword. Error", + name->val); } - return 1; + + if (!zend_is_const_default_class_ref(extends_ast)) { + zend_string *extends_name = zend_ast_get_str(extends_ast); + zend_error_noreturn(E_COMPILE_ERROR, + "Cannot use '%s' as class name as it is reserved", extends_name->val); + } + + zend_compile_class_ref(&extends_node, extends_ast TSRMLS_CC); } - return 0; -} -/* }}} */ -int zend_register_auto_global(zend_string *name, zend_bool jit, zend_auto_global_callback auto_global_callback TSRMLS_DC) /* {{{ */ -{ - zend_auto_global auto_global; - int retval; + opline = get_next_op(CG(active_op_array) TSRMLS_CC); + zend_make_var_result(&declare_node, opline TSRMLS_CC); - auto_global.name = zend_new_interned_string(name TSRMLS_CC); - auto_global.auto_global_callback = auto_global_callback; - auto_global.jit = jit; + // TODO.AST drop this + GET_NODE(&CG(implementing_class), opline->result); - retval = zend_hash_add_mem(CG(auto_globals), name, &auto_global, sizeof(zend_auto_global)) != NULL ? SUCCESS : FAILURE; + opline->op2_type = IS_CONST; + LITERAL_STR(opline->op2, lcname); - zend_string_release(auto_global.name); - return retval; -} -/* }}} */ + if (extends_ast) { + opline->opcode = ZEND_DECLARE_INHERITED_CLASS; + opline->extended_value = extends_node.u.op.var; + } else { + opline->opcode = ZEND_DECLARE_CLASS; + } -ZEND_API void zend_activate_auto_globals(TSRMLS_D) /* {{{ */ -{ - zend_auto_global *auto_global; + { + zend_string *key = zend_build_runtime_definition_key(lcname, decl->lex_pos TSRMLS_CC); - ZEND_HASH_FOREACH_PTR(CG(auto_globals), auto_global) { - if (auto_global->jit) { - auto_global->armed = 1; - } else if (auto_global->auto_global_callback) { - auto_global->armed = auto_global->auto_global_callback(auto_global->name TSRMLS_CC); - } else { - auto_global->armed = 0; + opline->op1_type = IS_CONST; + LITERAL_STR(opline->op1, key); + + zend_hash_update_ptr(CG(class_table), key, ce); + } + + CG(active_class_entry) = ce; + + if (implements_ast) { + zend_compile_implements(&declare_node, implements_ast TSRMLS_CC); + } + + zend_compile_stmt(stmt_ast TSRMLS_CC); + + if (ce->constructor) { + ce->constructor->common.fn_flags |= ZEND_ACC_CTOR; + if (ce->constructor->common.fn_flags & ZEND_ACC_STATIC) { + zend_error_noreturn(E_COMPILE_ERROR, "Constructor %s::%s() cannot be static", + ce->name->val, ce->constructor->common.function_name->val); } - } ZEND_HASH_FOREACH_END(); -} -/* }}} */ + } + if (ce->destructor) { + ce->destructor->common.fn_flags |= ZEND_ACC_DTOR; + if (ce->destructor->common.fn_flags & ZEND_ACC_STATIC) { + zend_error_noreturn(E_COMPILE_ERROR, "Destructor %s::%s() cannot be static", + ce->name->val, ce->destructor->common.function_name->val); + } + } + if (ce->clone) { + ce->clone->common.fn_flags |= ZEND_ACC_CLONE; + if (ce->clone->common.fn_flags & ZEND_ACC_STATIC) { + zend_error_noreturn(E_COMPILE_ERROR, "Clone method %s::%s() cannot be static", + ce->name->val, ce->clone->common.function_name->val); + } + } -int zendlex(znode *zendlval TSRMLS_DC) /* {{{ */ -{ - int retval; + /* Check for traits and proceed like with interfaces. + * The only difference will be a combined handling of them in the end. + * Thus, we need another opcode here. */ + if (ce->num_traits > 0) { + ce->traits = NULL; + ce->num_traits = 0; + ce->ce_flags |= ZEND_ACC_IMPLEMENT_TRAITS; - if (CG(increment_lineno)) { - CG(zend_lineno)++; - CG(increment_lineno) = 0; + zend_emit_op(NULL, ZEND_BIND_TRAITS, &declare_node, NULL TSRMLS_CC); } -again: - Z_TYPE_INFO(zendlval->u.constant) = IS_LONG; - retval = lex_scan(&zendlval->u.constant TSRMLS_CC); - switch (retval) { - case T_COMMENT: - case T_DOC_COMMENT: - case T_OPEN_TAG: - case T_WHITESPACE: - goto again; + if (!(ce->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS)) + && (extends_ast || ce->num_interfaces > 0) + ) { + zend_verify_abstract_class(ce TSRMLS_CC); + if (ce->num_interfaces && !(ce->ce_flags & ZEND_ACC_IMPLEMENT_TRAITS)) { + zend_emit_op(NULL, ZEND_VERIFY_ABSTRACT_CLASS, &declare_node, NULL TSRMLS_CC); + } + } - case T_CLOSE_TAG: - if (LANG_SCNG(yy_text)[LANG_SCNG(yy_leng)-1] != '>') { - CG(increment_lineno) = 1; + /* Inherit interfaces; reset number to zero, we need it for above check and + * will restore it during actual implementation. + * The ZEND_ACC_IMPLEMENT_INTERFACES flag disables double call to + * zend_verify_abstract_class() */ + if (ce->num_interfaces > 0) { + ce->interfaces = NULL; + ce->num_interfaces = 0; + ce->ce_flags |= ZEND_ACC_IMPLEMENT_INTERFACES; + } + + CG(active_class_entry) = NULL; +} + +static HashTable *zend_get_import_ht(uint32_t type TSRMLS_DC) { + switch (type) { + case T_CLASS: + if (!CG(current_import)) { + CG(current_import) = emalloc(sizeof(HashTable)); + zend_hash_init(CG(current_import), 8, NULL, str_dtor, 0); } - if (CG(has_bracketed_namespaces) && !CG(in_namespace)) { - goto again; + return CG(current_import); + case T_FUNCTION: + if (!CG(current_import_function)) { + CG(current_import_function) = emalloc(sizeof(HashTable)); + zend_hash_init(CG(current_import_function), 8, NULL, str_dtor, 0); } - retval = ';'; /* implicit ; */ - break; - case T_OPEN_TAG_WITH_ECHO: - retval = T_ECHO; - break; + return CG(current_import_function); + case T_CONST: + if (!CG(current_import_const)) { + CG(current_import_const) = emalloc(sizeof(HashTable)); + zend_hash_init(CG(current_import_const), 8, NULL, str_dtor, 0); + } + return CG(current_import_const); + EMPTY_SWITCH_DEFAULT_CASE() } +} - zendlval->op_type = IS_CONST; - return retval; +static char *zend_get_use_type_str(uint32_t type) { + switch (type) { + case T_CLASS: + return ""; + case T_FUNCTION: + return " function"; + case T_CONST: + return " const"; + EMPTY_SWITCH_DEFAULT_CASE() + } } -/* }}} */ -ZEND_API void zend_initialize_class_data(zend_class_entry *ce, zend_bool nullify_handlers TSRMLS_DC) /* {{{ */ -{ - zend_bool persistent_hashes = (ce->type == ZEND_INTERNAL_CLASS) ? 1 : 0; - dtor_func_t zval_ptr_dtor_func = ((persistent_hashes) ? ZVAL_INTERNAL_PTR_DTOR : ZVAL_PTR_DTOR); +static void zend_check_already_in_use( + uint32_t type, zend_string *old_name, zend_string *new_name, zend_string *check_name +) { + if (zend_str_equals_str_ci(old_name, check_name)) { + return; + } - ce->refcount = 1; - ce->ce_flags = ZEND_ACC_CONSTANTS_UPDATED; + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use%s %s as %s because the name " + "is already in use", zend_get_use_type_str(type), old_name->val, new_name->val); +} - ce->default_properties_table = NULL; - ce->default_static_members_table = NULL; - zend_hash_init_ex(&ce->properties_info, 8, NULL, (persistent_hashes ? zend_destroy_property_info_internal : zend_destroy_property_info), persistent_hashes, 0); - zend_hash_init_ex(&ce->constants_table, 8, NULL, zval_ptr_dtor_func, persistent_hashes, 0); - zend_hash_init_ex(&ce->function_table, 8, NULL, ZEND_FUNCTION_DTOR, persistent_hashes, 0); +void zend_compile_use(zend_ast *ast TSRMLS_DC) { + zend_ast_list *list = zend_ast_get_list(ast); + uint32_t i; + zend_string *current_ns = CG(current_namespace); + uint32_t type = ast->attr; + HashTable *current_import = zend_get_import_ht(type TSRMLS_CC); + zend_bool case_sensitive = type == T_CONST; + + for (i = 0; i < list->children; ++i) { + zend_ast *use_ast = list->child[i]; + zend_ast *old_name_ast = use_ast->child[0]; + zend_ast *new_name_ast = use_ast->child[1]; + zend_string *old_name = zend_ast_get_str(old_name_ast); + zend_string *new_name, *lookup_name; + + if (new_name_ast) { + new_name = zend_string_copy(zend_ast_get_str(new_name_ast)); + } else { + /* The form "use A\B" is eqivalent to "use A\B as B" */ + const char *p = zend_memrchr(old_name->val, '\\', old_name->len); + if (p) { + new_name = zend_string_init(p + 1, old_name->len - (p - old_name->val + 1), 0); + } else { + new_name = zend_string_copy(old_name); - if (ce->type == ZEND_INTERNAL_CLASS) { -#ifdef ZTS - int n = zend_hash_num_elements(CG(class_table)); + if (!current_ns) { + if (type == T_CLASS && zend_str_equals_literal(new_name, "strict")) { + zend_error_noreturn(E_COMPILE_ERROR, + "You seem to be trying to use a different language..."); + } - if (CG(static_members_table) && n >= CG(last_static_member)) { - /* Support for run-time declaration: dl() */ - CG(last_static_member) = n+1; - CG(static_members_table) = realloc(CG(static_members_table), (n+1)*sizeof(zval*)); - CG(static_members_table)[n] = NULL; + zend_error(E_WARNING, "The use statement with non-compound name '%s' " + "has no effect", new_name->val); + } + } } - ce->static_members_table = (zval*)(zend_intptr_t)n; -#else - ce->static_members_table = NULL; -#endif - } else { - ce->static_members_table = ce->default_static_members_table; - ce->info.user.doc_comment = NULL; - } - ce->default_properties_count = 0; - ce->default_static_members_count = 0; + if (case_sensitive) { + lookup_name = zend_string_copy(new_name); + } else { + lookup_name = zend_string_alloc(new_name->len, 0); + zend_str_tolower_copy(lookup_name->val, new_name->val, new_name->len); + } - if (nullify_handlers) { - ce->constructor = NULL; - ce->destructor = NULL; - ce->clone = NULL; - ce->__get = NULL; - ce->__set = NULL; - ce->__unset = NULL; - ce->__isset = NULL; - ce->__call = NULL; - ce->__callstatic = NULL; - ce->__tostring = NULL; - ce->create_object = NULL; - ce->get_iterator = NULL; - ce->iterator_funcs.funcs = NULL; - ce->interface_gets_implemented = NULL; - ce->get_static_method = NULL; - ce->parent = NULL; - ce->num_interfaces = 0; - ce->interfaces = NULL; - ce->num_traits = 0; - ce->traits = NULL; - ce->trait_aliases = NULL; - ce->trait_precedences = NULL; - ce->serialize = NULL; - ce->unserialize = NULL; - ce->serialize_func = NULL; - ce->unserialize_func = NULL; - ce->__debugInfo = NULL; - if (ce->type == ZEND_INTERNAL_CLASS) { - ce->info.internal.module = NULL; - ce->info.internal.builtin_functions = NULL; + if (type == T_CLASS && (zend_str_equals_literal(lookup_name, "self") + || zend_str_equals_literal(lookup_name, "parent")) + ) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use %s as %s because '%s' " + "is a special class name", old_name->val, new_name->val, new_name->val); } - } -} -/* }}} */ -int zend_get_class_fetch_type(const char *class_name, uint class_name_len) /* {{{ */ -{ - if ((class_name_len == sizeof("self")-1) && - !strncasecmp(class_name, "self", sizeof("self")-1)) { - return ZEND_FETCH_CLASS_SELF; - } else if ((class_name_len == sizeof("parent")-1) && - !strncasecmp(class_name, "parent", sizeof("parent")-1)) { - return ZEND_FETCH_CLASS_PARENT; - } else if ((class_name_len == sizeof("static")-1) && - !strncasecmp(class_name, "static", sizeof("static")-1)) { - return ZEND_FETCH_CLASS_STATIC; - } else { - return ZEND_FETCH_CLASS_DEFAULT; + if (current_ns) { + zend_string *ns_name = zend_string_alloc(current_ns->len + 1 + new_name->len, 0); + zend_str_tolower_copy(ns_name->val, current_ns->val, current_ns->len); + ns_name->val[current_ns->len] = '\\'; + memcpy(ns_name->val + current_ns->len + 1, lookup_name->val, lookup_name->len); + + if (zend_hash_exists(CG(class_table), ns_name)) { + zend_check_already_in_use(type, old_name, new_name, ns_name); + } + + zend_string_free(ns_name); + } else { + switch (type) { + case T_CLASS: + { + zend_class_entry *ce = zend_hash_find_ptr(CG(class_table), lookup_name); + if (ce && ce->type == ZEND_USER_CLASS + && ce->info.user.filename == CG(compiled_filename) + ) { + zend_check_already_in_use(type, old_name, new_name, lookup_name); + } + break; + } + case T_FUNCTION: + { + zend_function *fn = zend_hash_find_ptr(CG(function_table), lookup_name); + if (fn && fn->type == ZEND_USER_FUNCTION + && fn->op_array.filename == CG(compiled_filename) + ) { + zend_check_already_in_use(type, old_name, new_name, lookup_name); + } + break; + } + case T_CONST: + { + zend_string *filename = zend_hash_find_ptr(&CG(const_filenames), lookup_name); + if (filename && filename == CG(compiled_filename)) { + zend_check_already_in_use(type, old_name, new_name, lookup_name); + } + break; + } + EMPTY_SWITCH_DEFAULT_CASE() + } + } + + zend_string_addref(old_name); + if (!zend_hash_add_ptr(current_import, lookup_name, old_name)) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use%s %s as %s because the name " + "is already in use", zend_get_use_type_str(type), old_name->val, new_name->val); + } + + zend_string_release(lookup_name); + zend_string_release(new_name); } } -/* }}} */ -ZEND_API zend_string *zend_get_compiled_variable_name(const zend_op_array *op_array, uint32_t var) /* {{{ */ -{ - return op_array->vars[EX_VAR_TO_NUM(var)]; -} -/* }}} */ +void zend_compile_const_decl(zend_ast *ast TSRMLS_DC) { + zend_ast_list *list = zend_ast_get_list(ast); + uint32_t i; + for (i = 0; i < list->children; ++i) { + zend_ast *const_ast = list->child[i]; + zend_ast *name_ast = const_ast->child[0]; + zend_ast *value_ast = const_ast->child[1]; + zend_string *name = zend_ast_get_str(name_ast); -void zend_do_build_namespace_name(znode *result, znode *prefix, znode *name TSRMLS_DC) /* {{{ */ -{ - if (prefix) { - *result = *prefix; - if (Z_TYPE(result->u.constant) == IS_STRING && - Z_STRLEN(result->u.constant) == 0) { - /* namespace\ */ - if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) { - znode tmp; - - zval_dtor(&result->u.constant); - tmp.op_type = IS_CONST; - ZVAL_DUP(&tmp.u.constant, &CG(current_namespace)); - zend_do_build_namespace_name(result, NULL, &tmp TSRMLS_CC); + zend_string *import_name; + znode name_node, value_node; + zval *value_zv = &value_node.u.constant; + + value_node.op_type = IS_CONST; + zend_const_expr_to_zval(value_zv, value_ast TSRMLS_CC); + + if (zend_get_ct_const(name, 0 TSRMLS_CC)) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare constant '%s'", name->val); + } + + name = zend_prefix_with_ns(name TSRMLS_CC); + + if (CG(current_import_const) + && (import_name = zend_hash_find_ptr(CG(current_import_const), name)) + ) { + if (!zend_str_equals_str(import_name, name)) { + zend_error(E_COMPILE_ERROR, "Cannot declare const %s because " + "the name is already in use", name->val); } } - } else { - result->op_type = IS_CONST; - ZVAL_EMPTY_STRING(&result->u.constant); + + name_node.op_type = IS_CONST; + ZVAL_STR(&name_node.u.constant, name); + + zend_emit_op(NULL, ZEND_DECLARE_CONST, &name_node, &value_node TSRMLS_CC); + + zend_hash_add_ptr(&CG(const_filenames), name, CG(compiled_filename)); } - /* prefix = result */ - zend_do_build_full_name(NULL, result, name, 0 TSRMLS_CC); } -/* }}} */ -void zend_do_begin_namespace(znode *name, zend_bool with_bracket TSRMLS_DC) /* {{{ */ -{ - char *lcname; +void zend_compile_namespace(zend_ast *ast TSRMLS_DC) { + zend_ast *name_ast = ast->child[0]; + zend_ast *stmt_ast = ast->child[1]; + zend_string *name; + zend_bool with_bracket = stmt_ast != NULL; /* handle mixed syntax declaration or nested namespaces */ if (!CG(has_bracketed_namespaces)) { - if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) { + if (CG(current_namespace)) { /* previous namespace declarations were unbracketed */ if (with_bracket) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot mix bracketed namespace declarations with unbracketed namespace declarations"); + zend_error_noreturn(E_COMPILE_ERROR, "Cannot mix bracketed namespace declarations " + "with unbracketed namespace declarations"); } } } else { /* previous namespace declarations were bracketed */ if (!with_bracket) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot mix bracketed namespace declarations with unbracketed namespace declarations"); - } else if (Z_TYPE(CG(current_namespace)) != IS_UNDEF || CG(in_namespace)) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot mix bracketed namespace declarations " + "with unbracketed namespace declarations"); + } else if (CG(current_namespace) || CG(in_namespace)) { zend_error_noreturn(E_COMPILE_ERROR, "Namespace declarations cannot be nested"); } } - if (((!with_bracket && Z_TYPE(CG(current_namespace)) == IS_UNDEF) || (with_bracket && !CG(has_bracketed_namespaces))) && CG(active_op_array)->last > 0) { + if (((!with_bracket && !CG(current_namespace)) + || (with_bracket && !CG(has_bracketed_namespaces))) && CG(active_op_array)->last > 0 + ) { /* ignore ZEND_EXT_STMT and ZEND_TICKS */ - int num = CG(active_op_array)->last; + uint32_t num = CG(active_op_array)->last; while (num > 0 && (CG(active_op_array)->opcodes[num-1].opcode == ZEND_EXT_STMT || CG(active_op_array)->opcodes[num-1].opcode == ZEND_TICKS)) { --num; } if (num > 0) { - zend_error_noreturn(E_COMPILE_ERROR, "Namespace declaration statement has to be the very first statement in the script"); + zend_error_noreturn(E_COMPILE_ERROR, "Namespace declaration statement has to be " + "the very first statement in the script"); + } + } + + if (CG(current_namespace)) { + zend_string_release(CG(current_namespace)); + } + + if (name_ast) { + name = zend_ast_get_str(name_ast); + + if (ZEND_FETCH_CLASS_DEFAULT != zend_get_class_fetch_type(name)) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as namespace name", name->val); } + + CG(current_namespace) = zend_string_copy(name); + } else { + CG(current_namespace) = NULL; } + zend_reset_import_tables(TSRMLS_C); + CG(in_namespace) = 1; if (with_bracket) { CG(has_bracketed_namespaces) = 1; } - if (name) { - lcname = zend_str_tolower_dup(Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant)); - if (((Z_STRLEN(name->u.constant) == sizeof("self")-1) && - !memcmp(lcname, "self", sizeof("self")-1)) || - ((Z_STRLEN(name->u.constant) == sizeof("parent")-1) && - !memcmp(lcname, "parent", sizeof("parent")-1))) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as namespace name", Z_STRVAL(name->u.constant)); - } - efree(lcname); + if (stmt_ast) { + zend_compile_top_stmt(stmt_ast TSRMLS_CC); + zend_end_namespace(TSRMLS_C); + } +} + +void zend_compile_halt_compiler(zend_ast *ast TSRMLS_DC) { + zend_ast *offset_ast = ast->child[0]; + zend_long offset = Z_LVAL_P(zend_ast_get_zval(offset_ast)); + + zend_string *filename, *name; + const char const_name[] = "__COMPILER_HALT_OFFSET__"; + + if (CG(has_bracketed_namespaces) && CG(in_namespace)) { + zend_error_noreturn(E_COMPILE_ERROR, + "__HALT_COMPILER() can only be used from the outermost scope"); + } + + filename = zend_get_compiled_filename(TSRMLS_C); + name = zend_mangle_property_name(const_name, sizeof(const_name) - 1, + filename->val, filename->len, 0); + + zend_register_long_constant(name->val, name->len, offset, CONST_CS, 0 TSRMLS_CC); + zend_string_release(name); +} + +static zend_bool zend_try_ct_eval_magic_const(zval *zv, zend_ast *ast TSRMLS_DC) { + zend_op_array *op_array = CG(active_op_array); + zend_class_entry *ce = CG(active_class_entry); + + switch (ast->attr) { + case T_FUNC_C: + if (op_array && op_array->function_name) { + ZVAL_STR(zv, zend_string_copy(op_array->function_name)); + } else { + ZVAL_EMPTY_STRING(zv); + } + break; + case T_METHOD_C: + if (ce) { + if (op_array && op_array->function_name) { + ZVAL_STR(zv, zend_concat3(ce->name->val, ce->name->len, "::", 2, + op_array->function_name->val, op_array->function_name->len)); + } else { + ZVAL_STR(zv, zend_string_copy(ce->name)); + } + } else if (op_array && op_array->function_name) { + ZVAL_STR(zv, zend_string_copy(op_array->function_name)); + } else { + ZVAL_EMPTY_STRING(zv); + } + break; + case T_CLASS_C: + if (ce) { + if (ZEND_CE_IS_TRAIT(ce)) { + return 0; + } else { + ZVAL_STR(zv, zend_string_copy(ce->name)); + } + } else { + ZVAL_EMPTY_STRING(zv); + } + break; + case T_TRAIT_C: + if (ce && ZEND_CE_IS_TRAIT(ce)) { + ZVAL_STR(zv, zend_string_copy(ce->name)); + } else { + ZVAL_EMPTY_STRING(zv); + } + break; + case T_NS_C: + if (CG(current_namespace)) { + ZVAL_STR(zv, zend_string_copy(CG(current_namespace))); + } else { + ZVAL_EMPTY_STRING(zv); + } + break; + EMPTY_SWITCH_DEFAULT_CASE() + } + + return 1; +} + +static inline void zend_ct_eval_binary_op( + zval *result, uint32_t opcode, zval *op1, zval *op2 TSRMLS_DC +) { + binary_op_type fn = get_binary_op(opcode); + fn(result, op1, op2 TSRMLS_CC); +} + +static inline void zend_ct_eval_unary_pm(zval *result, zend_ast_kind kind, zval *op TSRMLS_DC) { + binary_op_type fn = kind == ZEND_AST_UNARY_PLUS + ? add_function : sub_function; + + zval left; + ZVAL_LONG(&left, 0); + fn(result, &left, op TSRMLS_CC); +} - if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) { - zval_dtor(&CG(current_namespace)); +static inline void zend_ct_eval_greater( + zval *result, zend_ast_kind kind, zval *op1, zval *op2 TSRMLS_DC +) { + binary_op_type fn = kind == ZEND_AST_GREATER + ? is_smaller_function : is_smaller_or_equal_function; + fn(result, op2, op1 TSRMLS_CC); +} + +static zend_bool zend_try_ct_eval_array(zval *result, zend_ast *ast TSRMLS_DC) { + zend_ast_list *list = zend_ast_get_list(ast); + uint32_t i; + + /* First ensure that *all* child nodes are constant and by-val */ + for (i = 0; i < list->children; ++i) { + zend_ast *elem_ast = list->child[i]; + zend_bool by_ref = elem_ast->attr; + zend_eval_const_expr(&elem_ast->child[0] TSRMLS_CC); + zend_eval_const_expr(&elem_ast->child[1] TSRMLS_CC); + + if (by_ref || elem_ast->child[0]->kind != ZEND_AST_ZVAL + || (elem_ast->child[1] && elem_ast->child[1]->kind != ZEND_AST_ZVAL) + ) { + return 0; } - ZVAL_COPY_VALUE(&CG(current_namespace), &name->u.constant); - } else { - if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) { - zval_dtor(&CG(current_namespace)); - ZVAL_UNDEF(&CG(current_namespace)); + } + + array_init_size(result, list->children); + for (i = 0; i < list->children; ++i) { + zend_ast *elem_ast = list->child[i]; + zend_ast *value_ast = elem_ast->child[0]; + zend_ast *key_ast = elem_ast->child[1]; + + zval *value = zend_ast_get_zval(value_ast); + if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value); + + if (key_ast) { + zval *key = zend_ast_get_zval(key_ast); + switch (Z_TYPE_P(key)) { + case IS_LONG: + zend_hash_index_update(Z_ARRVAL_P(result), Z_LVAL_P(key), value); + break; + case IS_STRING: + zend_symtable_update(Z_ARRVAL_P(result), Z_STR_P(key), value); + break; + case IS_DOUBLE: + zend_hash_index_update(Z_ARRVAL_P(result), + zend_dval_to_lval(Z_DVAL_P(key)), value); + break; + case IS_FALSE: + zend_hash_index_update(Z_ARRVAL_P(result), 0, value); + break; + case IS_TRUE: + zend_hash_index_update(Z_ARRVAL_P(result), 1, value); + break; + case IS_NULL: + zend_hash_update(Z_ARRVAL_P(result), STR_EMPTY_ALLOC(), value); + break; + default: + zend_error(E_COMPILE_ERROR, "Illegal offset type"); + break; + } + } else { + zend_hash_next_index_insert(Z_ARRVAL_P(result), value); } } - if (CG(current_import)) { - zend_hash_destroy(CG(current_import)); - efree(CG(current_import)); - CG(current_import) = NULL; + return 1; +} + +void zend_compile_binary_op(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *left_ast = ast->child[0]; + zend_ast *right_ast = ast->child[1]; + uint32_t opcode = ast->attr; + + znode left_node, right_node; + zend_compile_expr(&left_node, left_ast TSRMLS_CC); + zend_compile_expr(&right_node, right_ast TSRMLS_CC); + + if (left_node.op_type == IS_CONST && right_node.op_type == IS_CONST) { + result->op_type = IS_CONST; + zend_ct_eval_binary_op(&result->u.constant, opcode, + &left_node.u.constant, &right_node.u.constant TSRMLS_CC); + zval_ptr_dtor(&left_node.u.constant); + zval_ptr_dtor(&right_node.u.constant); + return; } - if (CG(current_import_function)) { - zend_hash_destroy(CG(current_import_function)); - efree(CG(current_import_function)); - CG(current_import_function) = NULL; + zend_emit_op_tmp(result, opcode, &left_node, &right_node TSRMLS_CC); +} + +/* We do not use zend_compile_binary_op for this because we want to retain the left-to-right + * evaluation order. */ +void zend_compile_greater(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *left_ast = ast->child[0]; + zend_ast *right_ast = ast->child[1]; + znode left_node, right_node; + + ZEND_ASSERT(ast->kind == ZEND_AST_GREATER || ast->kind == ZEND_AST_GREATER_EQUAL); + + zend_compile_expr(&left_node, left_ast TSRMLS_CC); + zend_compile_expr(&right_node, right_ast TSRMLS_CC); + + if (left_node.op_type == IS_CONST && right_node.op_type == IS_CONST) { + result->op_type = IS_CONST; + zend_ct_eval_greater(&result->u.constant, ast->kind, + &left_node.u.constant, &right_node.u.constant TSRMLS_CC); + zval_ptr_dtor(&left_node.u.constant); + zval_ptr_dtor(&right_node.u.constant); + return; } - if (CG(current_import_const)) { - zend_hash_destroy(CG(current_import_const)); - efree(CG(current_import_const)); - CG(current_import_const) = NULL; + zend_emit_op_tmp(result, + ast->kind == ZEND_AST_GREATER ? ZEND_IS_SMALLER : ZEND_IS_SMALLER_OR_EQUAL, + &right_node, &left_node TSRMLS_CC); +} + +void zend_compile_unary_op(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *expr_ast = ast->child[0]; + uint32_t opcode = ast->attr; + + znode expr_node; + zend_compile_expr(&expr_node, expr_ast TSRMLS_CC); + + zend_emit_op_tmp(result, opcode, &expr_node, NULL TSRMLS_CC); +} + +void zend_compile_unary_pm(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *expr_ast = ast->child[0]; + znode zero_node, expr_node; + + ZEND_ASSERT(ast->kind == ZEND_AST_UNARY_PLUS || ast->kind == ZEND_AST_UNARY_MINUS); + + zend_compile_expr(&expr_node, expr_ast TSRMLS_CC); + + if (expr_node.op_type == IS_CONST) { + result->op_type = IS_CONST; + zend_ct_eval_unary_pm(&result->u.constant, ast->kind, &expr_node.u.constant TSRMLS_CC); + zval_ptr_dtor(&expr_node.u.constant); + return; } - if (CG(doc_comment)) { - zend_string_release(CG(doc_comment)); - CG(doc_comment) = NULL; + zero_node.op_type = IS_CONST; + ZVAL_LONG(&zero_node.u.constant, 0); + + zend_emit_op_tmp(result, ast->kind == ZEND_AST_UNARY_PLUS ? ZEND_ADD : ZEND_SUB, + &zero_node, &expr_node TSRMLS_CC); +} + +void zend_compile_short_circuiting(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *left_ast = ast->child[0]; + zend_ast *right_ast = ast->child[1]; + + znode left_node, right_node; + zend_op *opline_jmpz, *opline_bool; + uint32_t opnum_jmpz; + + ZEND_ASSERT(ast->kind == ZEND_AST_AND || ast->kind == ZEND_AST_OR); + + zend_compile_expr(&left_node, left_ast TSRMLS_CC); + + opnum_jmpz = get_next_op_number(CG(active_op_array)); + opline_jmpz = zend_emit_op(NULL, ast->kind == ZEND_AST_AND ? ZEND_JMPZ_EX : ZEND_JMPNZ_EX, + &left_node, NULL TSRMLS_CC); + + if (left_node.op_type == IS_TMP_VAR) { + SET_NODE(opline_jmpz->result, &left_node); + } else { + opline_jmpz->result.var = get_temporary_variable(CG(active_op_array)); + opline_jmpz->result_type = IS_TMP_VAR; } + GET_NODE(result, opline_jmpz->result); + + zend_compile_expr(&right_node, right_ast TSRMLS_CC); + + opline_bool = zend_emit_op(NULL, ZEND_BOOL, &right_node, NULL TSRMLS_CC); + SET_NODE(opline_bool->result, result); + + zend_update_jump_target_to_next(opnum_jmpz TSRMLS_CC); } -/* }}} */ -void zend_do_use(znode *ns_name, znode *new_name, int is_global TSRMLS_DC) /* {{{ */ -{ - zend_string *lcname; - zval *name, ns, tmp; - zend_bool warn = 0; - zend_class_entry *ce; +void zend_compile_post_incdec(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *var_ast = ast->child[0]; + ZEND_ASSERT(ast->kind == ZEND_AST_POST_INC || ast->kind == ZEND_AST_POST_DEC); + + if (var_ast->kind == ZEND_AST_PROP) { + zend_op *opline = zend_compile_prop_common(NULL, var_ast, BP_VAR_RW TSRMLS_CC); + opline->opcode = ast->kind == ZEND_AST_POST_INC ? ZEND_POST_INC_OBJ : ZEND_POST_DEC_OBJ; + zend_make_tmp_result(result, opline TSRMLS_CC); + } else { + znode var_node; + zend_compile_var(&var_node, var_ast, BP_VAR_RW TSRMLS_CC); + zend_emit_op_tmp(result, ast->kind == ZEND_AST_POST_INC ? ZEND_POST_INC : ZEND_POST_DEC, + &var_node, NULL TSRMLS_CC); + } +} + +void zend_compile_pre_incdec(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *var_ast = ast->child[0]; + ZEND_ASSERT(ast->kind == ZEND_AST_PRE_INC || ast->kind == ZEND_AST_PRE_DEC); + + if (var_ast->kind == ZEND_AST_PROP) { + zend_op *opline = zend_compile_prop_common(result, var_ast, BP_VAR_RW TSRMLS_CC); + opline->opcode = ast->kind == ZEND_AST_PRE_INC ? ZEND_PRE_INC_OBJ : ZEND_PRE_DEC_OBJ; + } else { + znode var_node; + zend_compile_var(&var_node, var_ast, BP_VAR_RW TSRMLS_CC); + zend_emit_op(result, ast->kind == ZEND_AST_PRE_INC ? ZEND_PRE_INC : ZEND_PRE_DEC, + &var_node, NULL TSRMLS_CC); + } +} + +void zend_compile_cast(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *expr_ast = ast->child[0]; + znode expr_node; + zend_op *opline; + + zend_compile_expr(&expr_node, expr_ast TSRMLS_CC); + + opline = zend_emit_op(result, ZEND_CAST, &expr_node, NULL TSRMLS_CC); + opline->extended_value = ast->attr; +} + +static void zend_compile_shorthand_conditional(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *cond_ast = ast->child[0]; + zend_ast *false_ast = ast->child[2]; + + znode cond_node, false_node; + zend_op *opline_jmp_set, *opline_qm_assign; + uint32_t opnum_jmp_set; + + ZEND_ASSERT(ast->child[1] == NULL); + + zend_compile_expr(&cond_node, cond_ast TSRMLS_CC); + + opnum_jmp_set = get_next_op_number(CG(active_op_array)); + zend_emit_op_tmp(result, ZEND_JMP_SET, &cond_node, NULL TSRMLS_CC); + + zend_compile_expr(&false_node, false_ast TSRMLS_CC); + + opline_jmp_set = &CG(active_op_array)->opcodes[opnum_jmp_set]; + opline_jmp_set->op2.opline_num = get_next_op_number(CG(active_op_array)) + 1; + if (cond_node.op_type == IS_VAR || cond_node.op_type == IS_CV + || false_node.op_type == IS_VAR || false_node.op_type == IS_CV + ) { + opline_jmp_set->opcode = ZEND_JMP_SET_VAR; + opline_jmp_set->result_type = IS_VAR; + GET_NODE(result, opline_jmp_set->result); + + opline_qm_assign = zend_emit_op(NULL, ZEND_QM_ASSIGN_VAR, &false_node, NULL TSRMLS_CC); + } else { + opline_qm_assign = zend_emit_op(NULL, ZEND_QM_ASSIGN, &false_node, NULL TSRMLS_CC); + } + SET_NODE(opline_qm_assign->result, result); +} + +void zend_compile_conditional(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *cond_ast = ast->child[0]; + zend_ast *true_ast = ast->child[1]; + zend_ast *false_ast = ast->child[2]; + + znode cond_node, true_node, false_node; + zend_op *opline_qm_assign1, *opline_qm_assign2; + uint32_t opnum_jmpz, opnum_jmp, opnum_qm_assign1; + + if (!true_ast) { + zend_compile_shorthand_conditional(result, ast TSRMLS_CC); + return; + } + + zend_compile_expr(&cond_node, cond_ast TSRMLS_CC); + + opnum_jmpz = zend_emit_cond_jump(ZEND_JMPZ, &cond_node, 0 TSRMLS_CC); + + zend_compile_expr(&true_node, true_ast TSRMLS_CC); + + opnum_qm_assign1 = get_next_op_number(CG(active_op_array)); + zend_emit_op(result, ZEND_QM_ASSIGN, &true_node, NULL TSRMLS_CC); + + opnum_jmp = zend_emit_jump(0 TSRMLS_CC); + + zend_update_jump_target_to_next(opnum_jmpz TSRMLS_CC); + + zend_compile_expr(&false_node, false_ast TSRMLS_CC); - if (!CG(current_import)) { - CG(current_import) = emalloc(sizeof(HashTable)); - zend_hash_init(CG(current_import), 8, NULL, ZVAL_PTR_DTOR, 0); + opline_qm_assign1 = &CG(active_op_array)->opcodes[opnum_qm_assign1]; + if (true_node.op_type == IS_VAR || true_node.op_type == IS_CV + || false_node.op_type == IS_VAR || false_node.op_type == IS_CV + ) { + opline_qm_assign1->opcode = ZEND_QM_ASSIGN_VAR; + opline_qm_assign1->result_type = IS_VAR; + GET_NODE(result, opline_qm_assign1->result); } - ZVAL_ZVAL(&ns, &ns_name->u.constant, 0, 0); - if (new_name) { - name = &new_name->u.constant; + opline_qm_assign2 = zend_emit_op(NULL, opline_qm_assign1->opcode, &false_node, NULL TSRMLS_CC); + SET_NODE(opline_qm_assign2->result, result); + + zend_update_jump_target_to_next(opnum_jmp TSRMLS_CC); +} + +void zend_compile_print(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *expr_ast = ast->child[0]; + + znode expr_node; + zend_compile_expr(&expr_node, expr_ast TSRMLS_CC); + + zend_emit_op_tmp(result, ZEND_PRINT, &expr_node, NULL TSRMLS_CC); +} + +void zend_compile_exit(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *expr_ast = ast->child[0]; + + if (expr_ast) { + znode expr_node; + zend_compile_expr(&expr_node, expr_ast TSRMLS_CC); + zend_emit_op(NULL, ZEND_EXIT, &expr_node, NULL TSRMLS_CC); } else { - const char *p; - - /* The form "use A\B" is eqivalent to "use A\B as B". - So we extract the last part of compound name to use as a new_name */ - name = &tmp; - p = zend_memrchr(Z_STRVAL(ns), '\\', Z_STRLEN(ns)); - if (p) { - ZVAL_STRING(name, p+1); + zend_emit_op(NULL, ZEND_EXIT, NULL, NULL TSRMLS_CC); + } + + result->op_type = IS_CONST; + ZVAL_BOOL(&result->u.constant, 1); +} + +void zend_compile_yield(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *value_ast = ast->child[0]; + zend_ast *key_ast = ast->child[1]; + + znode value_node, key_node; + znode *value_node_ptr = NULL, *key_node_ptr = NULL; + zend_op *opline; + zend_bool returns_by_ref = (CG(active_op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0; + + if (!CG(active_op_array)->function_name) { + zend_error_noreturn(E_COMPILE_ERROR, + "The \"yield\" expression can only be used inside a function"); + } + + CG(active_op_array)->fn_flags |= ZEND_ACC_GENERATOR; + + if (key_ast) { + zend_compile_expr(&key_node, key_ast TSRMLS_CC); + key_node_ptr = &key_node; + } + + if (value_ast) { + if (returns_by_ref && zend_is_variable(value_ast) && !zend_is_call(value_ast)) { + zend_compile_var(&value_node, value_ast, BP_VAR_REF TSRMLS_CC); } else { - ZVAL_ZVAL(name, &ns, 1, 0); - warn = !is_global && Z_TYPE(CG(current_namespace)) == IS_UNDEF; + zend_compile_expr(&value_node, value_ast TSRMLS_CC); } + value_node_ptr = &value_node; } - lcname = zend_string_alloc(Z_STRLEN_P(name), 0); - zend_str_tolower_copy(lcname->val, Z_STRVAL_P(name), Z_STRLEN_P(name)); + opline = zend_emit_op(result, ZEND_YIELD, value_node_ptr, key_node_ptr TSRMLS_CC); - if (((Z_STRLEN_P(name) == sizeof("self")-1) && - !memcmp(lcname->val, "self", sizeof("self")-1)) || - ((Z_STRLEN_P(name) == sizeof("parent")-1) && - !memcmp(lcname->val, "parent", sizeof("parent")-1))) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use %s as %s because '%s' is a special class name", Z_STRVAL(ns), Z_STRVAL_P(name), Z_STRVAL_P(name)); + if (value_ast && returns_by_ref && zend_is_call(value_ast)) { + opline->extended_value = ZEND_RETURNS_FUNCTION; } +} + +void zend_compile_instanceof(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *obj_ast = ast->child[0]; + zend_ast *class_ast = ast->child[1]; + + znode obj_node, class_node; + zend_op *opline; + + zend_compile_expr(&obj_node, obj_ast TSRMLS_CC); + if (obj_node.op_type == IS_CONST) { + zend_error_noreturn(E_COMPILE_ERROR, + "instanceof expects an object instance, constant given"); + } + + opline = zend_compile_class_ref(&class_node, class_ast TSRMLS_CC); + opline->extended_value |= ZEND_FETCH_CLASS_NO_AUTOLOAD; + + zend_emit_op_tmp(result, ZEND_INSTANCEOF, &obj_node, &class_node TSRMLS_CC); +} + +void zend_compile_include_or_eval(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *expr_ast = ast->child[0]; + znode expr_node; + zend_op *opline; + + zend_do_extended_fcall_begin(TSRMLS_C); + zend_compile_expr(&expr_node, expr_ast TSRMLS_CC); + + opline = zend_emit_op(result, ZEND_INCLUDE_OR_EVAL, &expr_node, NULL TSRMLS_CC); + opline->extended_value = ast->attr; - if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) { - /* Prefix import name with current namespace name to avoid conflicts with classes */ - zend_string *c_ns_name = zend_string_alloc(Z_STRLEN(CG(current_namespace)) + 1 + Z_STRLEN_P(name), 0); + zend_do_extended_fcall_end(TSRMLS_C); +} - zend_str_tolower_copy(c_ns_name->val, Z_STRVAL(CG(current_namespace)), Z_STRLEN(CG(current_namespace))); - c_ns_name->val[Z_STRLEN(CG(current_namespace))] = '\\'; - memcpy(c_ns_name->val+Z_STRLEN(CG(current_namespace))+1, lcname->val, Z_STRLEN_P(name)+1); - if (zend_hash_exists(CG(class_table), c_ns_name)) { - char *tmp2 = zend_str_tolower_dup(Z_STRVAL(ns), Z_STRLEN(ns)); +void zend_compile_isset_or_empty(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *var_ast = ast->child[0]; + + znode var_node; + zend_op *opline; + + ZEND_ASSERT(ast->kind == ZEND_AST_ISSET || ast->kind == ZEND_AST_EMPTY); + + if (!zend_is_variable(var_ast) || zend_is_call(var_ast)) { + if (ast->kind == ZEND_AST_EMPTY) { + /* empty(expr) can be transformed to !expr */ + zend_ast *not_ast = zend_ast_create_ex(ZEND_AST_UNARY_OP, ZEND_BOOL_NOT, var_ast); + zend_compile_expr(result, not_ast TSRMLS_CC); + return; + } else { + zend_error_noreturn(E_COMPILE_ERROR, + "Cannot use isset() on the result of an expression " + "(you can use \"null !== expression\" instead)"); + } + } - if (Z_STRLEN(ns) != Z_STRLEN(CG(current_namespace)) + 1 + Z_STRLEN_P(name) || - memcmp(tmp2, c_ns_name->val, Z_STRLEN(ns))) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use %s as %s because the name is already in use", Z_STRVAL(ns), Z_STRVAL_P(name)); + switch (var_ast->kind) { + case ZEND_AST_VAR: + if (zend_try_compile_cv(&var_node, var_ast TSRMLS_CC) == SUCCESS) { + opline = zend_emit_op(result, ZEND_ISSET_ISEMPTY_VAR, &var_node, NULL TSRMLS_CC); + opline->extended_value = ZEND_FETCH_LOCAL | ZEND_QUICK_SET; + } else { + opline = zend_compile_simple_var_no_cv(result, var_ast, BP_VAR_IS TSRMLS_CC); + opline->opcode = ZEND_ISSET_ISEMPTY_VAR; } - efree(tmp2); + break; + case ZEND_AST_DIM: + opline = zend_compile_dim_common(result, var_ast, BP_VAR_IS TSRMLS_CC); + opline->opcode = ZEND_ISSET_ISEMPTY_DIM_OBJ; + break; + case ZEND_AST_PROP: + opline = zend_compile_prop_common(result, var_ast, BP_VAR_IS TSRMLS_CC); + opline->opcode = ZEND_ISSET_ISEMPTY_PROP_OBJ; + break; + case ZEND_AST_STATIC_PROP: + opline = zend_compile_static_prop_common(result, var_ast, BP_VAR_IS TSRMLS_CC); + opline->opcode = ZEND_ISSET_ISEMPTY_VAR; + break; + EMPTY_SWITCH_DEFAULT_CASE() + } + + opline->result_type = IS_TMP_VAR; + opline->extended_value |= ast->kind == ZEND_AST_ISSET ? ZEND_ISSET : ZEND_ISEMPTY; +} + +void zend_compile_silence(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *expr_ast = ast->child[0]; + znode silence_node; + + zend_emit_op_tmp(&silence_node, ZEND_BEGIN_SILENCE, NULL, NULL TSRMLS_CC); + + if (expr_ast->kind == ZEND_AST_VAR) { + /* For @$var we need to force a FETCH instruction, otherwise the CV access will + * happen outside the silenced section. */ + zend_compile_simple_var_no_cv(result, expr_ast, BP_VAR_R TSRMLS_CC); + } else { + zend_compile_expr(result, expr_ast TSRMLS_CC); + } + + zend_emit_op(NULL, ZEND_END_SILENCE, &silence_node, NULL TSRMLS_CC); +} + +void zend_compile_shell_exec(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *expr_ast = ast->child[0]; + + zval fn_name; + zend_ast *name_ast, *args_ast, *call_ast; + + ZVAL_STRING(&fn_name, "shell_exec"); + name_ast = zend_ast_create_zval(&fn_name); + args_ast = (zend_ast *) zend_ast_create_list(1, ZEND_AST_ARG_LIST, expr_ast); + call_ast = zend_ast_create(ZEND_AST_CALL, name_ast, args_ast); + + zend_compile_expr(result, call_ast TSRMLS_CC); + + zval_ptr_dtor(&fn_name); +} + +void zend_compile_array(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast_list *list = zend_ast_get_list(ast); + zend_op *opline; + uint32_t i, opnum_init; + zend_bool packed = 1; + + if (zend_try_ct_eval_array(&result->u.constant, ast TSRMLS_CC)) { + result->op_type = IS_CONST; + return; + } + + opnum_init = get_next_op_number(CG(active_op_array)); + + for (i = 0; i < list->children; ++i) { + zend_ast *elem_ast = list->child[i]; + zend_ast *value_ast = elem_ast->child[0]; + zend_ast *key_ast = elem_ast->child[1]; + zend_bool by_ref = elem_ast->attr; + + znode value_node, key_node, *key_node_ptr = NULL; + + if (key_ast) { + zend_compile_expr(&key_node, key_ast TSRMLS_CC); + zend_handle_numeric_op(&key_node TSRMLS_CC); + key_node_ptr = &key_node; + } + + if (by_ref) { + zend_ensure_writable_variable(value_ast); + zend_compile_var(&value_node, value_ast, BP_VAR_W TSRMLS_CC); + } else { + zend_compile_expr(&value_node, value_ast TSRMLS_CC); + } + + if (i == 0) { + opline = zend_emit_op_tmp(result, ZEND_INIT_ARRAY, &value_node, key_node_ptr TSRMLS_CC); + opline->extended_value = list->children << ZEND_ARRAY_SIZE_SHIFT; + } else { + opline = zend_emit_op(NULL, ZEND_ADD_ARRAY_ELEMENT, + &value_node, key_node_ptr TSRMLS_CC); + SET_NODE(opline->result, result); } - zend_string_free(c_ns_name); - } else if ((ce = zend_hash_find_ptr(CG(class_table), lcname)) != NULL && - ce->type == ZEND_USER_CLASS && - ce->info.user.filename == CG(compiled_filename)) { - char *c_tmp = zend_str_tolower_dup(Z_STRVAL(ns), Z_STRLEN(ns)); + opline->extended_value |= by_ref; - if (Z_STRLEN(ns) != Z_STRLEN_P(name) || - memcmp(c_tmp, lcname->val, Z_STRLEN(ns))) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use %s as %s because the name is already in use", Z_STRVAL(ns), Z_STRVAL_P(name)); + if (key_ast && key_node.op_type == IS_CONST && Z_TYPE(key_node.u.constant) == IS_STRING) { + packed = 0; } - efree(c_tmp); } - if (zend_hash_add(CG(current_import), lcname, &ns) == NULL) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use %s as %s because the name is already in use", Z_STRVAL(ns), Z_STRVAL_P(name)); + /* Handle empty array */ + if (!list->children) { + zend_emit_op_tmp(result, ZEND_INIT_ARRAY, NULL, NULL TSRMLS_CC); } - if (warn) { - if (!strcmp(Z_STRVAL_P(name), "strict")) { - zend_error_noreturn(E_COMPILE_ERROR, "You seem to be trying to use a different language..."); - } - zend_error(E_WARNING, "The use statement with non-compound name '%s' has no effect", Z_STRVAL_P(name)); + + /* Add a flag to INIT_ARRAY if we know this array cannot be packed */ + if (!packed) { + opline = &CG(active_op_array)->opcodes[opnum_init]; + opline->extended_value |= ZEND_ARRAY_NOT_PACKED; } - zend_string_release(lcname); - zval_dtor(name); } -/* }}} */ -void zend_do_use_non_class(znode *ns_name, znode *new_name, int is_global, int is_function, zend_bool case_sensitive, HashTable *current_import_sub, HashTable *lookup_table TSRMLS_DC) /* {{{ */ -{ - zend_string *lookup_name; - zval *name, ns, tmp; - zend_bool warn = 0; +void zend_compile_const(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *name_ast = ast->child[0]; + zend_string *orig_name = zend_ast_get_str(name_ast); + zend_bool is_fully_qualified; + + zval resolved_name; + zend_op *opline; - ZVAL_ZVAL(&ns, &ns_name->u.constant, 0, 0); - if (new_name) { - name = &new_name->u.constant; + ZVAL_STR(&resolved_name, zend_resolve_const_name( + orig_name, name_ast->attr, &is_fully_qualified TSRMLS_CC)); + + if (zend_constant_ct_subst(result, &resolved_name, 1 TSRMLS_CC)) { + zval_dtor(&resolved_name); + return; + } + + opline = zend_emit_op_tmp(result, ZEND_FETCH_CONSTANT, NULL, NULL TSRMLS_CC); + opline->op2_type = IS_CONST; + + if (is_fully_qualified) { + opline->op2.constant = zend_add_const_name_literal( + CG(active_op_array), &resolved_name, 0 TSRMLS_CC); } else { - const char *p; - - /* The form "use A\B" is eqivalent to "use A\B as B". - So we extract the last part of compound name to use as a new_name */ - name = &tmp; - p = zend_memrchr(Z_STRVAL(ns), '\\', Z_STRLEN(ns)); - if (p) { - ZVAL_STRING(name, p+1); + opline->extended_value = IS_CONSTANT_UNQUALIFIED; + if (CG(current_namespace)) { + opline->extended_value |= IS_CONSTANT_IN_NAMESPACE; + opline->op2.constant = zend_add_const_name_literal( + CG(active_op_array), &resolved_name, 1 TSRMLS_CC); } else { - ZVAL_ZVAL(name, &ns, 1, 0); - warn = !is_global && Z_TYPE(CG(current_namespace)) == IS_UNDEF; + opline->op2.constant = zend_add_const_name_literal( + CG(active_op_array), &resolved_name, 0 TSRMLS_CC); } } + zend_alloc_cache_slot(opline->op2.constant TSRMLS_CC); +} + +void zend_compile_class_const(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *class_ast = ast->child[0]; + zend_ast *const_ast = ast->child[1]; - if (case_sensitive) { - lookup_name = zend_string_copy(Z_STR_P(name)); + znode class_node, const_node; + zend_op *opline; + + if (zend_is_const_default_class_ref(class_ast)) { + class_node.op_type = IS_CONST; + ZVAL_STR(&class_node.u.constant, zend_resolve_class_name_ast(class_ast TSRMLS_CC)); } else { - lookup_name = zend_string_alloc(Z_STRLEN_P(name), 0); - zend_str_tolower_copy(lookup_name->val, Z_STRVAL_P(name), Z_STRLEN_P(name)); + zend_compile_class_ref(&class_node, class_ast TSRMLS_CC); } - if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) { - /* Prefix import name with current namespace name to avoid conflicts with functions/consts */ - zend_string *c_ns_name = zend_string_alloc(Z_STRLEN(CG(current_namespace)) + 1 + Z_STRLEN_P(name), 0); + zend_compile_expr(&const_node, const_ast TSRMLS_CC); + + opline = zend_emit_op_tmp(result, ZEND_FETCH_CONSTANT, NULL, &const_node TSRMLS_CC); + + zend_set_class_name_op1(opline, &class_node TSRMLS_CC); + + if (opline->op1_type == IS_CONST) { + zend_alloc_cache_slot(opline->op2.constant TSRMLS_CC); + } else { + zend_alloc_polymorphic_cache_slot(opline->op2.constant TSRMLS_CC); + } +} - zend_str_tolower_copy(c_ns_name->val, Z_STRVAL(CG(current_namespace)), Z_STRLEN(CG(current_namespace))); - c_ns_name->val[Z_STRLEN(CG(current_namespace))] = '\\'; - memcpy(c_ns_name->val+Z_STRLEN(CG(current_namespace))+1, lookup_name, Z_STRLEN_P(name)+1); - if (zend_hash_exists(lookup_table, c_ns_name)) { - char *tmp2 = zend_str_tolower_dup(Z_STRVAL(ns), Z_STRLEN(ns)); +void zend_compile_resolve_class_name(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast *name_ast = ast->child[0]; + uint32_t fetch_type = zend_get_class_fetch_type(zend_ast_get_str(name_ast)); - if (Z_STRLEN(ns) != Z_STRLEN(CG(current_namespace)) + 1 + Z_STRLEN_P(name) || - memcmp(tmp2, c_ns_name->val, Z_STRLEN(ns))) { - zend_error(E_COMPILE_ERROR, "Cannot use %s %s as %s because the name is already in use", is_function ? "function" : "const", Z_STRVAL(ns), Z_STRVAL_P(name)); + switch (fetch_type) { + case ZEND_FETCH_CLASS_SELF: + if (!CG(active_class_entry)) { + zend_error_noreturn(E_COMPILE_ERROR, + "Cannot access self::class when no class scope is active"); } - efree(tmp2); - } - zend_string_free(c_ns_name); - } else if (is_function) { - zend_function *function; + result->op_type = IS_CONST; + ZVAL_STR(&result->u.constant, zend_string_copy(CG(active_class_entry)->name)); + break; + case ZEND_FETCH_CLASS_STATIC: + case ZEND_FETCH_CLASS_PARENT: + if (!CG(active_class_entry)) { + zend_error_noreturn(E_COMPILE_ERROR, + "Cannot access %s::class when no class scope is active", + fetch_type == ZEND_FETCH_CLASS_STATIC ? "static" : "parent"); + } else { + zval class_str_zv; + zend_ast *class_str_ast, *class_const_ast; + + ZVAL_STRING(&class_str_zv, "class"); + class_str_ast = zend_ast_create_zval(&class_str_zv); + class_const_ast = zend_ast_create( + ZEND_AST_CLASS_CONST, name_ast, class_str_ast); - if ((function = zend_hash_find_ptr(lookup_table, lookup_name)) != NULL && function->type == ZEND_USER_FUNCTION && strcmp(function->op_array.filename->val, CG(compiled_filename)->val) == 0) { - char *c_tmp = zend_str_tolower_dup(Z_STRVAL(ns), Z_STRLEN(ns)); + zend_compile_expr(result, class_const_ast TSRMLS_CC); - if (Z_STRLEN(ns) != Z_STRLEN_P(name) || - memcmp(c_tmp, lookup_name->val, Z_STRLEN(ns))) { - zend_error(E_COMPILE_ERROR, "Cannot use function %s as %s because the name is already in use", Z_STRVAL(ns), Z_STRVAL_P(name)); + zval_ptr_dtor(&class_str_zv); } - efree(c_tmp); - } - } else { - zend_string *filename; + break; + case ZEND_FETCH_CLASS_DEFAULT: + result->op_type = IS_CONST; + ZVAL_STR(&result->u.constant, zend_resolve_class_name_ast(name_ast TSRMLS_CC)); + break; + EMPTY_SWITCH_DEFAULT_CASE() + } +} + +void zend_compile_encaps_list(znode *result, zend_ast *ast TSRMLS_DC) { + zend_ast_list *list = zend_ast_get_list(ast); + uint32_t i; - if ((filename = zend_hash_find_ptr(lookup_table, lookup_name)) != NULL && strcmp(filename->val, CG(compiled_filename)->val) == 0) { - char *c_tmp = zend_str_tolower_dup(Z_STRVAL(ns), Z_STRLEN(ns)); + ZEND_ASSERT(list->children > 0); - if (Z_STRLEN(ns) != Z_STRLEN_P(name) || - memcmp(c_tmp, lookup_name->val, Z_STRLEN(ns))) { - zend_error(E_COMPILE_ERROR, "Cannot use const %s as %s because the name is already in use", Z_STRVAL(ns), Z_STRVAL_P(name)); + result->op_type = IS_TMP_VAR; + result->u.op.var = get_temporary_variable(CG(active_op_array)); + + for (i = 0; i < list->children; ++i) { + zend_ast *elem_ast = list->child[i]; + znode elem_node; + zend_op *opline; + + zend_compile_expr(&elem_node, elem_ast TSRMLS_CC); + + if (elem_ast->kind == ZEND_AST_ZVAL) { + zval *zv = &elem_node.u.constant; + ZEND_ASSERT(Z_TYPE_P(zv) == IS_STRING); + + if (Z_STRLEN_P(zv) > 1) { + opline = get_next_op(CG(active_op_array) TSRMLS_CC); + opline->opcode = ZEND_ADD_STRING; + } else if (Z_STRLEN_P(zv) == 1) { + char ch = *Z_STRVAL_P(zv); + zend_string_release(Z_STR_P(zv)); + ZVAL_LONG(zv, ch); + + opline = get_next_op(CG(active_op_array) TSRMLS_CC); + opline->opcode = ZEND_ADD_CHAR; + } else { + /* String can be empty after a variable at the end of a heredoc */ + zend_string_release(Z_STR_P(zv)); + continue; } - efree(c_tmp); + } else { + opline = get_next_op(CG(active_op_array) TSRMLS_CC); + opline->opcode = ZEND_ADD_VAR; + ZEND_ASSERT(elem_node.op_type != IS_CONST); } + + if (i == 0) { + SET_UNUSED(opline->op1); + } else { + SET_NODE(opline->op1, result); + } + SET_NODE(opline->op2, &elem_node); + SET_NODE(opline->result, result); } +} - if (zend_hash_add(current_import_sub, lookup_name, &ns) == NULL) { - zend_error(E_COMPILE_ERROR, "Cannot use %s %s as %s because the name is already in use", is_function ? "function" : "const", Z_STRVAL(ns), Z_STRVAL_P(name)); +void zend_compile_magic_const(znode *result, zend_ast *ast TSRMLS_DC) { + zend_class_entry *ce = CG(active_class_entry); + + if (zend_try_ct_eval_magic_const(&result->u.constant, ast TSRMLS_CC)) { + result->op_type = IS_CONST; + return; } - if (warn) { - zend_error(E_WARNING, "The use %s statement with non-compound name '%s' has no effect", is_function ? "function" : "const", Z_STRVAL_P(name)); + + ZEND_ASSERT(ast->attr == T_CLASS_C && ce && ZEND_CE_IS_TRAIT(ce)); + + { + zend_ast *const_ast = zend_ast_create(ZEND_AST_CONST, + zend_ast_create_zval_from_str(zend_string_init("__CLASS__", sizeof("__CLASS__") - 1, 0))); + zend_compile_const(result, const_ast TSRMLS_CC); + zend_ast_destroy(const_ast); + } +} + +zend_bool zend_is_allowed_in_const_expr(zend_ast_kind kind) { + return kind == ZEND_AST_ZVAL || kind == ZEND_AST_BINARY_OP + || kind == ZEND_AST_GREATER || kind == ZEND_AST_GREATER_EQUAL + || kind == ZEND_AST_AND || kind == ZEND_AST_OR + || kind == ZEND_AST_UNARY_OP + || kind == ZEND_AST_UNARY_PLUS || kind == ZEND_AST_UNARY_MINUS + || kind == ZEND_AST_CONDITIONAL || kind == ZEND_AST_DIM + || kind == ZEND_AST_ARRAY || kind == ZEND_AST_ARRAY_ELEM + || kind == ZEND_AST_CONST || kind == ZEND_AST_CLASS_CONST + || kind == ZEND_AST_RESOLVE_CLASS_NAME || kind == ZEND_AST_MAGIC_CONST; +} + +void zend_compile_const_expr_class_const(zend_ast **ast_ptr TSRMLS_DC) { + zend_ast *ast = *ast_ptr; + zend_ast *class_ast = ast->child[0]; + zend_ast *const_ast = ast->child[1]; + zend_string *class_name = zend_ast_get_str(class_ast); + zend_string *const_name = zend_ast_get_str(const_ast); + zval result; + int fetch_type; + + if (class_ast->kind != ZEND_AST_ZVAL) { + zend_error_noreturn(E_COMPILE_ERROR, + "Dynamic class names are not allowed in compile-time class constant references"); } - zend_string_release(lookup_name); - zval_dtor(name); -} -/* }}} */ -void zend_do_use_function(znode *ns_name, znode *new_name, int is_global TSRMLS_DC) /* {{{ */ -{ - if (!CG(current_import_function)) { - CG(current_import_function) = emalloc(sizeof(HashTable)); - zend_hash_init(CG(current_import_function), 8, NULL, ZVAL_PTR_DTOR, 0); + fetch_type = zend_get_class_fetch_type(class_name); + + if (ZEND_FETCH_CLASS_STATIC == fetch_type) { + zend_error_noreturn(E_COMPILE_ERROR, + "\"static::\" is not allowed in compile-time constants"); + } + + if (ZEND_FETCH_CLASS_DEFAULT == fetch_type) { + class_name = zend_resolve_class_name_ast(class_ast TSRMLS_CC); + } else { + zend_string_addref(class_name); } - zend_do_use_non_class(ns_name, new_name, is_global, 1, 0, CG(current_import_function), CG(function_table) TSRMLS_CC); -} -/* }}} */ + Z_STR(result) = zend_concat3( + class_name->val, class_name->len, "::", 2, const_name->val, const_name->len); -void zend_do_use_const(znode *ns_name, znode *new_name, int is_global TSRMLS_DC) /* {{{ */ -{ - if (!CG(current_import_const)) { - CG(current_import_const) = emalloc(sizeof(HashTable)); - zend_hash_init(CG(current_import_const), 8, NULL, ZVAL_PTR_DTOR, 0); + Z_TYPE_INFO(result) = IS_CONSTANT_EX; + if (IS_INTERNED(Z_STR(result))) { + Z_TYPE_FLAGS(result) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE); } + Z_CONST_FLAGS(result) = fetch_type; - zend_do_use_non_class(ns_name, new_name, is_global, 0, 1, CG(current_import_const), &CG(const_filenames) TSRMLS_CC); + zend_ast_destroy(ast); + zend_string_release(class_name); + + *ast_ptr = zend_ast_create_zval(&result); } -/* }}} */ -void zend_do_declare_constant(znode *name, znode *value TSRMLS_DC) /* {{{ */ -{ - zend_op *opline; - zval *ns_name; +void zend_compile_const_expr_const(zend_ast **ast_ptr TSRMLS_DC) { + zend_ast *ast = *ast_ptr; + zend_ast *name_ast = ast->child[0]; + zval *orig_name = zend_ast_get_zval(name_ast); + zend_bool is_fully_qualified; - if (zend_get_ct_const(&name->u.constant, 0 TSRMLS_CC)) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare constant '%s'", Z_STRVAL(name->u.constant)); + znode result; + zval resolved_name; + + if (zend_constant_ct_subst(&result, orig_name, 0 TSRMLS_CC)) { + zend_ast_destroy(ast); + *ast_ptr = zend_ast_create_zval(&result.u.constant); + return; } - if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) { - /* Prefix constant name with name of current namespace, lowercased */ - znode tmp; + ZVAL_STR(&resolved_name, zend_resolve_const_name( + Z_STR_P(orig_name), name_ast->attr, &is_fully_qualified TSRMLS_CC)); - tmp.op_type = IS_CONST; - ZVAL_NEW_STR(&tmp.u.constant, zend_string_alloc(Z_STRLEN(CG(current_namespace)), 0)); - zend_str_tolower_copy(Z_STRVAL(tmp.u.constant), Z_STRVAL(CG(current_namespace)), Z_STRLEN(CG(current_namespace))); - zend_do_build_namespace_name(&tmp, &tmp, name TSRMLS_CC); - *name = tmp; + Z_TYPE_INFO(resolved_name) = IS_CONSTANT_EX; + if (!is_fully_qualified) { + Z_CONST_FLAGS(resolved_name) = IS_CONSTANT_UNQUALIFIED; } - /* Constant name must not conflict with import names */ - if (CG(current_import_const) && - (ns_name = zend_hash_find(CG(current_import_const), Z_STR(name->u.constant))) != NULL) { + zend_ast_destroy(ast); + *ast_ptr = zend_ast_create_zval(&resolved_name); +} - char *tmp = estrndup(Z_STRVAL_P(ns_name), Z_STRLEN_P(ns_name)); +void zend_compile_const_expr_resolve_class_name(zend_ast **ast_ptr TSRMLS_DC) { + zend_ast *ast = *ast_ptr; + zend_ast *name_ast = ast->child[0]; + uint32_t fetch_type = zend_get_class_fetch_type(zend_ast_get_str(name_ast)); + zval result; - if (Z_STRLEN_P(ns_name) != Z_STRLEN(name->u.constant) || - memcmp(tmp, Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant))) { - zend_error(E_COMPILE_ERROR, "Cannot declare const %s because the name is already in use", Z_STRVAL(name->u.constant)); - } - efree(tmp); + switch (fetch_type) { + case ZEND_FETCH_CLASS_SELF: + if (!CG(active_class_entry)) { + zend_error_noreturn(E_COMPILE_ERROR, + "Cannot access self::class when no class scope is active"); + } + ZVAL_STR(&result, zend_string_copy(CG(active_class_entry)->name)); + break; + case ZEND_FETCH_CLASS_STATIC: + case ZEND_FETCH_CLASS_PARENT: + zend_error_noreturn(E_COMPILE_ERROR, + "%s::class cannot be used for compile-time class name resolution", + fetch_type == ZEND_FETCH_CLASS_STATIC ? "static" : "parent" + ); + break; + case ZEND_FETCH_CLASS_DEFAULT: + ZVAL_STR(&result, zend_resolve_class_name_ast(name_ast TSRMLS_CC)); + break; + EMPTY_SWITCH_DEFAULT_CASE() } - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_DECLARE_CONST; - SET_UNUSED(opline->result); - SET_NODE(opline->op1, name); - SET_NODE(opline->op2, value); - - zend_hash_add_ptr(&CG(const_filenames), Z_STR(name->u.constant), CG(compiled_filename)); + zend_ast_destroy(ast); + *ast_ptr = zend_ast_create_zval(&result); } -/* }}} */ -void zend_verify_namespace(TSRMLS_D) /* {{{ */ -{ - if (CG(has_bracketed_namespaces) && !CG(in_namespace)) { - zend_error_noreturn(E_COMPILE_ERROR, "No code may exist outside of namespace {}"); +void zend_compile_const_expr_magic_const(zend_ast **ast_ptr TSRMLS_DC) { + zend_ast *ast = *ast_ptr; + zend_class_entry *ce = CG(active_class_entry); + + /* Other cases already resolved by constant folding */ + ZEND_ASSERT(ast->attr == T_CLASS_C && ce && ZEND_CE_IS_TRAIT(ce)); + + { + zval const_zv; + ZVAL_STRING(&const_zv, "__CLASS__"); + Z_TYPE_INFO(const_zv) = IS_CONSTANT_EX; + + zend_ast_destroy(ast); + *ast_ptr = zend_ast_create_zval(&const_zv); } } -/* }}} */ -void zend_do_end_namespace(TSRMLS_D) /* {{{ */ -{ - CG(in_namespace) = 0; - if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) { - zval_dtor(&CG(current_namespace)); - ZVAL_UNDEF(&CG(current_namespace)); - } - if (CG(current_import)) { - zend_hash_destroy(CG(current_import)); - efree(CG(current_import)); - CG(current_import) = NULL; +void zend_compile_const_expr(zend_ast **ast_ptr TSRMLS_DC) { + zend_ast *ast = *ast_ptr; + if (ast == NULL || ast->kind == ZEND_AST_ZVAL) { + return; } - if (CG(current_import_function)) { - zend_hash_destroy(CG(current_import_function)); - efree(CG(current_import_function)); - CG(current_import_function) = NULL; + + if (!zend_is_allowed_in_const_expr(ast->kind)) { + zend_error_noreturn(E_COMPILE_ERROR, "Constant expression contains invalid operations"); } - if (CG(current_import_const)) { - zend_hash_destroy(CG(current_import_const)); - efree(CG(current_import_const)); - CG(current_import_const) = NULL; + + switch (ast->kind) { + case ZEND_AST_CLASS_CONST: + zend_compile_const_expr_class_const(ast_ptr TSRMLS_CC); + break; + case ZEND_AST_CONST: + zend_compile_const_expr_const(ast_ptr TSRMLS_CC); + break; + case ZEND_AST_RESOLVE_CLASS_NAME: + zend_compile_const_expr_resolve_class_name(ast_ptr TSRMLS_CC); + break; + case ZEND_AST_MAGIC_CONST: + zend_compile_const_expr_magic_const(ast_ptr TSRMLS_CC); + break; + default: + zend_ast_apply(ast, zend_compile_const_expr TSRMLS_CC); + break; } } -/* }}} */ -void zend_do_end_compilation(TSRMLS_D) /* {{{ */ -{ - CG(has_bracketed_namespaces) = 0; - zend_do_end_namespace(TSRMLS_C); -} -/* }}} */ +void zend_const_expr_to_zval(zval *result, zend_ast *ast TSRMLS_DC) { + zend_ast *orig_ast = ast; + zend_eval_const_expr(&ast TSRMLS_CC); + zend_compile_const_expr(&ast TSRMLS_CC); + if (ast->kind == ZEND_AST_ZVAL) { + ZVAL_COPY_VALUE(result, zend_ast_get_zval(ast)); -void zend_do_constant_expression(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */ -{ - if (ast->kind == ZEND_CONST) { - ZVAL_COPY_VALUE(&result->u.constant, &ast->u.val); - efree(ast); - } else if (zend_ast_is_ct_constant(ast)) { - zend_ast_evaluate(&result->u.constant, ast, NULL TSRMLS_CC); - zend_ast_destroy(ast); + /* Kill this branch of the original AST, as it was already destroyed. + * It would be nice to find a better solution to this problem in the + * future. */ + orig_ast->kind = 0; } else { - ZVAL_NEW_AST(&result->u.constant, ast); + ZVAL_NEW_AST(result, zend_ast_copy(ast)); } } -/* }}} */ -/* {{{ zend_dirname - Returns directory name component of path */ -ZEND_API size_t zend_dirname(char *path, size_t len) -{ - register char *end = path + len - 1; - unsigned int len_adjust = 0; +/* Same as compile_stmt, but with early binding */ +void zend_compile_top_stmt(zend_ast *ast TSRMLS_DC) { + if (!ast) { + return; + } -#ifdef PHP_WIN32 - /* Note that on Win32 CWD is per drive (heritage from CP/M). - * This means dirname("c:foo") maps to "c:." or "c:" - which means CWD on C: drive. - */ - if ((2 <= len) && isalpha((int)((unsigned char *)path)[0]) && (':' == path[1])) { - /* Skip over the drive spec (if any) so as not to change */ - path += 2; - len_adjust += 2; - if (2 == len) { - /* Return "c:" on Win32 for dirname("c:"). - * It would be more consistent to return "c:." - * but that would require making the string *longer*. - */ - return len; + if (ast->kind == ZEND_AST_STMT_LIST) { + zend_ast_list *list = zend_ast_get_list(ast); + uint32_t i; + for (i = 0; i < list->children; ++i) { + zend_compile_top_stmt(list->child[i] TSRMLS_CC); } + return; } -#elif defined(NETWARE) - /* - * Find the first occurrence of : from the left - * move the path pointer to the position just after : - * increment the len_adjust to the length of path till colon character(inclusive) - * If there is no character beyond : simple return len - */ - char *colonpos = NULL; - colonpos = strchr(path, ':'); - if (colonpos != NULL) { - len_adjust = ((colonpos - path) + 1); - path += len_adjust; - if (len_adjust == len) { - return len; - } + + zend_compile_stmt(ast TSRMLS_CC); + + if (ast->kind != ZEND_AST_NAMESPACE && ast->kind != ZEND_AST_HALT_COMPILER) { + zend_verify_namespace(TSRMLS_C); } -#endif + if (ast->kind == ZEND_AST_FUNC_DECL || ast->kind == ZEND_AST_CLASS) { + CG(zend_lineno) = ((zend_ast_decl *) ast)->end_lineno; + zend_do_early_binding(TSRMLS_C); + } +} - if (len == 0) { - /* Illegal use of this function */ - return 0; +void zend_compile_stmt(zend_ast *ast TSRMLS_DC) { + if (!ast) { + return; } - /* Strip trailing slashes */ - while (end >= path && IS_SLASH_P(end)) { - end--; + CG(zend_lineno) = ast->lineno; + + switch (ast->kind) { + case ZEND_AST_STMT_LIST: + zend_compile_stmt_list(ast TSRMLS_CC); + break; + case ZEND_AST_GLOBAL: + zend_compile_global_var(ast TSRMLS_CC); + break; + case ZEND_AST_STATIC: + zend_compile_static_var(ast TSRMLS_CC); + break; + case ZEND_AST_UNSET: + zend_compile_unset(ast TSRMLS_CC); + break; + case ZEND_AST_RETURN: + zend_compile_return(ast TSRMLS_CC); + break; + case ZEND_AST_ECHO: + zend_compile_echo(ast TSRMLS_CC); + break; + case ZEND_AST_THROW: + zend_compile_throw(ast TSRMLS_CC); + break; + case ZEND_AST_BREAK: + case ZEND_AST_CONTINUE: + zend_compile_break_continue(ast TSRMLS_CC); + break; + case ZEND_AST_GOTO: + zend_compile_goto(ast TSRMLS_CC); + break; + case ZEND_AST_LABEL: + zend_compile_label(ast TSRMLS_CC); + break; + case ZEND_AST_WHILE: + zend_compile_while(ast TSRMLS_CC); + break; + case ZEND_AST_DO_WHILE: + zend_compile_do_while(ast TSRMLS_CC); + break; + case ZEND_AST_FOR: + zend_compile_for(ast TSRMLS_CC); + break; + case ZEND_AST_FOREACH: + zend_compile_foreach(ast TSRMLS_CC); + break; + case ZEND_AST_IF: + zend_compile_if(ast TSRMLS_CC); + break; + case ZEND_AST_SWITCH: + zend_compile_switch(ast TSRMLS_CC); + break; + case ZEND_AST_TRY: + zend_compile_try(ast TSRMLS_CC); + break; + case ZEND_AST_DECLARE: + zend_compile_declare(ast TSRMLS_CC); + break; + case ZEND_AST_FUNC_DECL: + case ZEND_AST_METHOD: + zend_compile_func_decl(NULL, ast TSRMLS_CC); + break; + case ZEND_AST_PROP_DECL: + zend_compile_prop_decl(ast TSRMLS_CC); + break; + case ZEND_AST_CLASS_CONST_DECL: + zend_compile_class_const_decl(ast TSRMLS_CC); + break; + case ZEND_AST_USE_TRAIT: + zend_compile_use_trait(ast TSRMLS_CC); + break; + case ZEND_AST_CLASS: + zend_compile_class_decl(ast TSRMLS_CC); + break; + case ZEND_AST_USE: + zend_compile_use(ast TSRMLS_CC); + break; + case ZEND_AST_CONST_DECL: + zend_compile_const_decl(ast TSRMLS_CC); + break; + case ZEND_AST_NAMESPACE: + zend_compile_namespace(ast TSRMLS_CC); + break; + case ZEND_AST_HALT_COMPILER: + zend_compile_halt_compiler(ast TSRMLS_CC); + break; + default: + { + znode result; + zend_compile_expr(&result, ast TSRMLS_CC); + zend_do_free(&result TSRMLS_CC); + } } - if (end < path) { - /* The path only contained slashes */ - path[0] = DEFAULT_SLASH; - path[1] = '\0'; - return 1 + len_adjust; + + if (Z_LVAL(CG(declarables).ticks) && !zend_is_unticked_stmt(ast)) { + zend_emit_tick(TSRMLS_C); } +} - /* Strip filename */ - while (end >= path && !IS_SLASH_P(end)) { - end--; +void zend_compile_expr(znode *result, zend_ast *ast TSRMLS_DC) { + //CG(zend_lineno) = ast->lineno; + CG(zend_lineno) = zend_ast_get_lineno(ast); + + switch (ast->kind) { + case ZEND_AST_ZVAL: + ZVAL_COPY(&result->u.constant, zend_ast_get_zval(ast)); + result->op_type = IS_CONST; + return; + case ZEND_AST_ZNODE: + *result = *zend_ast_get_znode(ast); + return; + case ZEND_AST_VAR: + case ZEND_AST_DIM: + case ZEND_AST_PROP: + case ZEND_AST_STATIC_PROP: + case ZEND_AST_CALL: + case ZEND_AST_METHOD_CALL: + case ZEND_AST_STATIC_CALL: + zend_compile_var(result, ast, BP_VAR_R TSRMLS_CC); + return; + case ZEND_AST_ASSIGN: + zend_compile_assign(result, ast TSRMLS_CC); + return; + case ZEND_AST_ASSIGN_REF: + zend_compile_assign_ref(result, ast TSRMLS_CC); + return; + case ZEND_AST_NEW: + zend_compile_new(result, ast TSRMLS_CC); + return; + case ZEND_AST_CLONE: + zend_compile_clone(result, ast TSRMLS_CC); + return; + case ZEND_AST_ASSIGN_OP: + zend_compile_compound_assign(result, ast TSRMLS_CC); + return; + case ZEND_AST_BINARY_OP: + zend_compile_binary_op(result, ast TSRMLS_CC); + return; + case ZEND_AST_GREATER: + case ZEND_AST_GREATER_EQUAL: + zend_compile_greater(result, ast TSRMLS_CC); + return; + case ZEND_AST_UNARY_OP: + zend_compile_unary_op(result, ast TSRMLS_CC); + return; + case ZEND_AST_UNARY_PLUS: + case ZEND_AST_UNARY_MINUS: + zend_compile_unary_pm(result, ast TSRMLS_CC); + return; + case ZEND_AST_AND: + case ZEND_AST_OR: + zend_compile_short_circuiting(result, ast TSRMLS_CC); + return; + case ZEND_AST_POST_INC: + case ZEND_AST_POST_DEC: + zend_compile_post_incdec(result, ast TSRMLS_CC); + return; + case ZEND_AST_PRE_INC: + case ZEND_AST_PRE_DEC: + zend_compile_pre_incdec(result, ast TSRMLS_CC); + return; + case ZEND_AST_CAST: + zend_compile_cast(result, ast TSRMLS_CC); + return; + case ZEND_AST_CONDITIONAL: + zend_compile_conditional(result, ast TSRMLS_CC); + return; + case ZEND_AST_PRINT: + zend_compile_print(result, ast TSRMLS_CC); + return; + case ZEND_AST_EXIT: + zend_compile_exit(result, ast TSRMLS_CC); + return; + case ZEND_AST_YIELD: + zend_compile_yield(result, ast TSRMLS_CC); + return; + case ZEND_AST_INSTANCEOF: + zend_compile_instanceof(result, ast TSRMLS_CC); + return; + case ZEND_AST_INCLUDE_OR_EVAL: + zend_compile_include_or_eval(result, ast TSRMLS_CC); + return; + case ZEND_AST_ISSET: + case ZEND_AST_EMPTY: + zend_compile_isset_or_empty(result, ast TSRMLS_CC); + return; + case ZEND_AST_SILENCE: + zend_compile_silence(result, ast TSRMLS_CC); + return; + case ZEND_AST_SHELL_EXEC: + zend_compile_shell_exec(result, ast TSRMLS_CC); + return; + case ZEND_AST_ARRAY: + zend_compile_array(result, ast TSRMLS_CC); + return; + case ZEND_AST_CONST: + zend_compile_const(result, ast TSRMLS_CC); + return; + case ZEND_AST_CLASS_CONST: + zend_compile_class_const(result, ast TSRMLS_CC); + return; + case ZEND_AST_RESOLVE_CLASS_NAME: + zend_compile_resolve_class_name(result, ast TSRMLS_CC); + return; + case ZEND_AST_ENCAPS_LIST: + zend_compile_encaps_list(result, ast TSRMLS_CC); + return; + case ZEND_AST_MAGIC_CONST: + zend_compile_magic_const(result, ast TSRMLS_CC); + return; + case ZEND_AST_CLOSURE: + zend_compile_func_decl(result, ast TSRMLS_CC); + return; + default: + ZEND_ASSERT(0 /* not supported */); } - if (end < path) { - /* No slash found, therefore return '.' */ -#ifdef NETWARE - if (len_adjust == 0) { - path[0] = '.'; - path[1] = '\0'; - return 1; /* only one character */ - } else { - path[0] = '\0'; - return len_adjust; - } -#else - path[0] = '.'; - path[1] = '\0'; - return 1 + len_adjust; -#endif +} + +void zend_compile_var(znode *result, zend_ast *ast, int type TSRMLS_DC) { + switch (ast->kind) { + case ZEND_AST_VAR: + zend_compile_simple_var(result, ast, type TSRMLS_CC); + return; + case ZEND_AST_DIM: + zend_compile_dim(result, ast, type TSRMLS_CC); + return; + case ZEND_AST_PROP: + zend_compile_prop(result, ast, type TSRMLS_CC); + return; + case ZEND_AST_STATIC_PROP: + zend_compile_static_prop(result, ast, type TSRMLS_CC); + return; + case ZEND_AST_CALL: + zend_compile_call(result, ast, type TSRMLS_CC); + return; + case ZEND_AST_METHOD_CALL: + zend_compile_method_call(result, ast, type TSRMLS_CC); + return; + case ZEND_AST_STATIC_CALL: + zend_compile_static_call(result, ast, type TSRMLS_CC); + return; + case ZEND_AST_ZNODE: + *result = *zend_ast_get_znode(ast); + return; + default: + if (type == BP_VAR_W || type == BP_VAR_REF + || type == BP_VAR_RW || type == BP_VAR_UNSET + ) { + /* For BC reasons =& new Foo is allowed */ + if (type != BP_VAR_REF || ast->kind != ZEND_AST_NEW) { + zend_error_noreturn(E_COMPILE_ERROR, + "Cannot use temporary expression in write context"); + } + } + + zend_compile_expr(result, ast TSRMLS_CC); + return; } +} - /* Strip slashes which came before the file name */ - while (end >= path && IS_SLASH_P(end)) { - end--; +void zend_delayed_compile_var(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC) { + zend_op *opline; + switch (ast->kind) { + case ZEND_AST_DIM: + opline = zend_delayed_compile_dim(result, ast, type TSRMLS_CC); + zend_adjust_for_fetch_type(opline, type); + return; + case ZEND_AST_PROP: + opline = zend_delayed_compile_prop(result, ast, type TSRMLS_CC); + zend_adjust_for_fetch_type(opline, type); + return; + default: + zend_compile_var(result, ast, type TSRMLS_CC); + return; } - if (end < path) { - path[0] = DEFAULT_SLASH; - path[1] = '\0'; - return 1 + len_adjust; +} + +void zend_eval_const_expr(zend_ast **ast_ptr TSRMLS_DC) { + zend_ast *ast = *ast_ptr; + zval result; + + if (!ast) { + return; } - *(end+1) = '\0'; - return (size_t)(end + 1 - path) + len_adjust; + switch (ast->kind) { + case ZEND_AST_BINARY_OP: + zend_eval_const_expr(&ast->child[0] TSRMLS_CC); + zend_eval_const_expr(&ast->child[1] TSRMLS_CC); + if (ast->child[0]->kind != ZEND_AST_ZVAL || ast->child[1]->kind != ZEND_AST_ZVAL) { + return; + } + + zend_ct_eval_binary_op(&result, ast->attr, + zend_ast_get_zval(ast->child[0]), zend_ast_get_zval(ast->child[1]) TSRMLS_CC); + break; + case ZEND_AST_GREATER: + case ZEND_AST_GREATER_EQUAL: + zend_eval_const_expr(&ast->child[0] TSRMLS_CC); + zend_eval_const_expr(&ast->child[1] TSRMLS_CC); + if (ast->child[0]->kind != ZEND_AST_ZVAL || ast->child[1]->kind != ZEND_AST_ZVAL) { + return; + } + + zend_ct_eval_greater(&result, ast->kind, + zend_ast_get_zval(ast->child[0]), zend_ast_get_zval(ast->child[1]) TSRMLS_CC); + break; + case ZEND_AST_UNARY_PLUS: + case ZEND_AST_UNARY_MINUS: + zend_eval_const_expr(&ast->child[0] TSRMLS_CC); + if (ast->child[0]->kind != ZEND_AST_ZVAL) { + return; + } + + zend_ct_eval_unary_pm(&result, ast->kind, + zend_ast_get_zval(ast->child[0]) TSRMLS_CC); + break; + case ZEND_AST_ARRAY: + if (!zend_try_ct_eval_array(&result, ast TSRMLS_CC)) { + return; + } + break; + case ZEND_AST_MAGIC_CONST: + if (!zend_try_ct_eval_magic_const(&result, ast TSRMLS_CC)) { + return; + } + break; + default: + return; + } + + zend_ast_destroy(ast); + *ast_ptr = zend_ast_create_zval(&result); } -/* }}} */ /* * Local variables: diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h index 1b4d05bcaf..7eebf4baff 100644 --- a/Zend/zend_compile.h +++ b/Zend/zend_compile.h @@ -33,22 +33,18 @@ #define DEBUG_ZEND 0 -#define FREE_PNODE(znode) zval_dtor(&znode->u.constant); - #define SET_UNUSED(op) op ## _type = IS_UNUSED #define INC_BPC(op_array) if (op_array->fn_flags & ZEND_ACC_INTERACTIVE) { (CG(context).backpatch_count++); } #define DEC_BPC(op_array) if (op_array->fn_flags & ZEND_ACC_INTERACTIVE) { (CG(context).backpatch_count--); } #define HANDLE_INTERACTIVE() if (CG(active_op_array)->fn_flags & ZEND_ACC_INTERACTIVE) { execute_new_code(TSRMLS_C); } -#define DO_TICKS() if (Z_LVAL(CG(declarables).ticks)) { zend_do_ticks(TSRMLS_C); } -#define RESET_DOC_COMMENT() \ - { \ - if (CG(doc_comment)) { \ - zend_string_release(CG(doc_comment)); \ - CG(doc_comment) = NULL; \ - } \ - } +#define RESET_DOC_COMMENT() do { \ + if (CG(doc_comment)) { \ + zend_string_release(CG(doc_comment)); \ + CG(doc_comment) = NULL; \ + } \ +} while (0) typedef struct _zend_op_array zend_op_array; typedef struct _zend_op zend_op; @@ -79,12 +75,36 @@ typedef struct _znode { /* used only during compilation */ union { znode_op op; zval constant; /* replaced by literal/zv */ - zend_op_array *op_array; - zend_ast *ast; } u; - uint32_t EA; /* extended attributes */ } znode; +/* Temporarily defined here, to avoid header ordering issues */ +typedef struct _zend_ast_znode { + zend_ast_kind kind; + zend_ast_attr attr; + uint32_t lineno; + znode node; +} zend_ast_znode; +ZEND_API zend_ast *zend_ast_create_znode(znode *node); + +static inline znode *zend_ast_get_znode(zend_ast *ast) { + return &((zend_ast_znode *) ast)->node; +} + +typedef union _zend_parser_stack_elem { + zend_ast *ast; + zend_ast_list *list; + zend_string *str; + zend_ulong num; +} zend_parser_stack_elem; + +void zend_compile_top_stmt(zend_ast *ast TSRMLS_DC); +void zend_compile_stmt(zend_ast *ast TSRMLS_DC); +void zend_compile_expr(znode *node, zend_ast *ast TSRMLS_DC); +void zend_compile_var(znode *node, zend_ast *ast, int type TSRMLS_DC); +void zend_eval_const_expr(zend_ast **ast_ptr TSRMLS_DC); +void zend_const_expr_to_zval(zval *result, zend_ast *ast TSRMLS_DC); + typedef struct _zend_execute_data zend_execute_data; #define ZEND_OPCODE_HANDLER_ARGS zend_execute_data *execute_data TSRMLS_DC @@ -208,8 +228,9 @@ typedef struct _zend_try_catch_element { /* function has arguments with type hinting */ #define ZEND_ACC_HAS_TYPE_HINTS 0x10000000 -char *zend_visibility_string(uint32_t fn_flags); +#define ZEND_CE_IS_TRAIT(ce) (((ce)->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) +char *zend_visibility_string(uint32_t fn_flags); typedef struct _zend_property_info { uint32_t flags; @@ -335,26 +356,12 @@ union _zend_function { zend_internal_function internal_function; }; -typedef struct _zend_function_call_entry { - zend_function *fbc; - uint32_t op_number; - uint32_t arg_num; - zend_bool uses_argument_unpacking; -} zend_function_call_entry; - typedef struct _zend_switch_entry { znode cond; int default_case; int control_var; } zend_switch_entry; - -typedef struct _list_llist_element { - znode var; - zend_llist dimensions; - znode value; -} list_llist_element; - typedef enum _vm_frame_kind { VM_FRAME_NESTED_FUNCTION, /* stackless VM call to function */ VM_FRAME_NESTED_CODE, /* stackless VM call to include/require/eval */ @@ -431,10 +438,6 @@ ZEND_API zend_string *zend_get_compiled_filename(TSRMLS_D); ZEND_API int zend_get_compiled_lineno(TSRMLS_D); ZEND_API size_t zend_get_scanned_file_offset(TSRMLS_D); -void zend_resolve_non_class_name(znode *element_name, zend_bool *check_namespace, zend_bool case_sensitive, HashTable *current_import_sub TSRMLS_DC); -void zend_resolve_function_name(znode *element_name, zend_bool *check_namespace TSRMLS_DC); -void zend_resolve_const_name(znode *element_name, zend_bool *check_namespace TSRMLS_DC); -void zend_resolve_class_name(znode *class_name TSRMLS_DC); ZEND_API zend_string *zend_get_compiled_variable_name(const zend_op_array *op_array, uint32_t var); #ifdef ZTS @@ -443,95 +446,26 @@ int zend_get_zendleng(TSRMLS_D); #endif -/* parser-driven code generators */ -void zend_do_binary_op(zend_uchar op, znode *result, znode *op1, znode *op2 TSRMLS_DC); -void zend_do_unary_op(zend_uchar op, znode *result, znode *op1 TSRMLS_DC); -void zend_do_binary_assign_op(zend_uchar op, znode *result, znode *op1, znode *op2 TSRMLS_DC); -void zend_do_assign(znode *result, znode *variable, znode *value TSRMLS_DC); -void zend_do_assign_ref(znode *result, znode *lvar, znode *rvar TSRMLS_DC); -void fetch_simple_variable(znode *result, znode *varname, int bp TSRMLS_DC); -void fetch_simple_variable_ex(znode *result, znode *varname, int bp, zend_uchar op TSRMLS_DC); -void zend_do_indirect_references(znode *result, const znode *num_references, znode *variable TSRMLS_DC); -void zend_do_fetch_static_variable(znode *varname, znode *static_assignment, int fetch_type TSRMLS_DC); -void zend_do_fetch_global_variable(znode *varname, const znode *static_assignment, int fetch_type TSRMLS_DC); - -void fetch_array_begin(znode *result, znode *varname, znode *first_dim TSRMLS_DC); -void fetch_array_dim(znode *result, znode *parent, znode *dim TSRMLS_DC); -void fetch_string_offset(znode *result, znode *parent, znode *offset TSRMLS_DC); -void zend_do_fetch_static_member(znode *result, znode *class_znode TSRMLS_DC); -void zend_do_print(znode *result, znode *arg TSRMLS_DC); -void zend_do_echo(znode *arg TSRMLS_DC); typedef int (*unary_op_type)(zval *, zval * TSRMLS_DC); typedef int (*binary_op_type)(zval *, zval *, zval * TSRMLS_DC); ZEND_API unary_op_type get_unary_op(int opcode); ZEND_API binary_op_type get_binary_op(int opcode); -void zend_do_while_cond(znode *expr, znode *close_bracket_token TSRMLS_DC); -void zend_do_while_end(const znode *while_token, const znode *close_bracket_token TSRMLS_DC); -void zend_do_do_while_begin(TSRMLS_D); -void zend_do_do_while_end(const znode *do_token, const znode *expr_open_bracket, znode *expr TSRMLS_DC); - - -void zend_do_if_cond(znode *cond, znode *closing_bracket_token TSRMLS_DC); -void zend_do_if_after_statement(const znode *closing_bracket_token, unsigned char initialize TSRMLS_DC); -void zend_do_if_end(TSRMLS_D); - -void zend_do_for_cond(znode *expr, znode *second_semicolon_token TSRMLS_DC); -void zend_do_for_before_statement(const znode *cond_start, const znode *second_semicolon_token TSRMLS_DC); -void zend_do_for_end(const znode *second_semicolon_token TSRMLS_DC); - -void zend_do_pre_incdec(znode *result, znode *op1, zend_uchar op TSRMLS_DC); -void zend_do_post_incdec(znode *result, znode *op1, zend_uchar op TSRMLS_DC); - -void zend_do_begin_variable_parse(TSRMLS_D); -void zend_do_end_variable_parse(znode *variable, int type, int arg_offset TSRMLS_DC); - -void zend_check_writable_variable(const znode *variable); +void zend_stop_lexing(TSRMLS_D); +void zend_emit_final_return(zval *zv TSRMLS_DC); +zend_ast *zend_ast_append_str(zend_ast *left, zend_ast *right); +uint32_t zend_add_member_modifier(uint32_t flags, uint32_t new_flag); +zend_ast_list *zend_ast_append_doc_comment(zend_ast_list *list TSRMLS_DC); +void zend_handle_encoding_declaration(zend_ast_list *declares TSRMLS_DC); +/* parser-driven code generators */ void zend_do_free(znode *op1 TSRMLS_DC); -void zend_do_add_string(znode *result, znode *op1, znode *op2 TSRMLS_DC); -void zend_do_add_variable(znode *result, znode *op1, znode *op2 TSRMLS_DC); - -int zend_do_verify_access_types(const znode *current_access_type, const znode *new_modifier); -void zend_do_begin_function_declaration(znode *function_token, znode *function_name, int is_method, int return_reference, znode *fn_flags_znode TSRMLS_DC); -void zend_do_end_function_declaration(const znode *function_token TSRMLS_DC); -void zend_do_receive_param(zend_uchar op, znode *varname, znode *initialization, znode *class_type, zend_bool pass_by_reference, zend_bool is_variadic TSRMLS_DC); -int zend_do_begin_function_call(znode *function_name, zend_bool check_namespace TSRMLS_DC); -void zend_do_begin_method_call(znode *left_bracket TSRMLS_DC); -void zend_do_clone(znode *result, znode *expr TSRMLS_DC); -void zend_do_begin_dynamic_function_call(znode *function_name, int prefix_len TSRMLS_DC); -void zend_do_fetch_class(znode *result, znode *class_name TSRMLS_DC); -void zend_do_build_full_name(znode *result, znode *prefix, znode *name, int is_class_member TSRMLS_DC); -int zend_do_begin_class_member_function_call(znode *class_name, znode *method_name TSRMLS_DC); -void zend_do_end_function_call(znode *function_name, znode *result, int is_method, int is_dynamic_fcall TSRMLS_DC); -void zend_do_return(znode *expr, int do_end_vparse TSRMLS_DC); -void zend_do_yield(znode *result, znode *value, znode *key, zend_bool is_variable TSRMLS_DC); -void zend_do_handle_exception(TSRMLS_D); - -void zend_do_begin_lambda_function_declaration(znode *result, znode *function_token, int return_reference, int is_static TSRMLS_DC); -void zend_do_fetch_lexical_variable(znode *varname, zend_bool is_ref TSRMLS_DC); - -void zend_do_try(znode *try_token TSRMLS_DC); -void zend_do_begin_catch(znode *try_token, znode *catch_class, znode *catch_var, znode *first_catch TSRMLS_DC); -void zend_do_bind_catch(znode *try_token, znode *catch_token TSRMLS_DC); -void zend_do_end_catch(znode *catch_token TSRMLS_DC); -void zend_do_finally(znode *finally_token TSRMLS_DC); -void zend_do_end_finally(znode *try_token, znode* catch_token, znode *finally_token TSRMLS_DC); -void zend_do_throw(znode *expr TSRMLS_DC); - ZEND_API int do_bind_function(const zend_op_array *op_array, zend_op *opline, HashTable *function_table, zend_bool compile_time TSRMLS_DC); ZEND_API zend_class_entry *do_bind_class(const zend_op_array *op_array, const zend_op *opline, HashTable *class_table, zend_bool compile_time TSRMLS_DC); ZEND_API zend_class_entry *do_bind_inherited_class(const zend_op_array *op_array, const zend_op *opline, HashTable *class_table, zend_class_entry *parent_ce, zend_bool compile_time TSRMLS_DC); ZEND_API void zend_do_inherit_interfaces(zend_class_entry *ce, const zend_class_entry *iface TSRMLS_DC); ZEND_API void zend_do_implement_interface(zend_class_entry *ce, zend_class_entry *iface TSRMLS_DC); -void zend_do_implements_interface(znode *interface_znode TSRMLS_DC); - -/* Trait related functions */ -void zend_do_use_trait(znode *trait_znode TSRMLS_DC); -void zend_prepare_reference(znode *result, znode *class_name, znode *method_name TSRMLS_DC); -void zend_add_trait_precedence(znode *method_reference, znode *trait_list TSRMLS_DC); -void zend_add_trait_alias(znode *method_reference, znode *modifiers, znode *alias TSRMLS_DC); ZEND_API void zend_do_implement_trait(zend_class_entry *ce, zend_class_entry *trait TSRMLS_DC); ZEND_API void zend_do_bind_traits(zend_class_entry *ce TSRMLS_DC); @@ -540,109 +474,17 @@ ZEND_API void zend_do_inheritance(zend_class_entry *ce, zend_class_entry *parent void zend_do_early_binding(TSRMLS_D); ZEND_API void zend_do_delayed_early_binding(const zend_op_array *op_array TSRMLS_DC); -void zend_do_pass_param(znode *param, zend_uchar op TSRMLS_DC); -void zend_do_unpack_params(znode *params TSRMLS_DC); - - -void zend_do_boolean_or_begin(znode *expr1, znode *op_token TSRMLS_DC); -void zend_do_boolean_or_end(znode *result, znode *expr1, znode *expr2, const znode *op_token TSRMLS_DC); -void zend_do_boolean_and_begin(znode *expr1, znode *op_token TSRMLS_DC); -void zend_do_boolean_and_end(znode *result, znode *expr1, znode *expr2, const znode *op_token TSRMLS_DC); - -void zend_do_brk_cont(zend_uchar op, znode *expr TSRMLS_DC); - -void zend_do_switch_cond(const znode *cond TSRMLS_DC); -void zend_do_switch_end(const znode *case_list TSRMLS_DC); -void zend_do_case_before_statement(const znode *case_list, znode *case_token, znode *case_expr TSRMLS_DC); -void zend_do_case_after_statement(znode *result, const znode *case_token TSRMLS_DC); -void zend_do_default_before_statement(const znode *case_list, znode *default_token TSRMLS_DC); - -void zend_do_begin_class_declaration(const znode *class_token, znode *class_name, const znode *parent_class_name TSRMLS_DC); -void zend_do_end_class_declaration(const znode *class_token, const znode *parent_token TSRMLS_DC); -void zend_do_declare_property(znode *var_name, znode *value, uint32_t access_type TSRMLS_DC); -void zend_do_declare_class_constant(znode *var_name, znode *value TSRMLS_DC); - -void zend_do_fetch_property(znode *result, znode *object, znode *property TSRMLS_DC); - -void zend_do_halt_compiler_register(TSRMLS_D); - -void zend_do_push_object(const znode *object TSRMLS_DC); -void zend_do_pop_object(znode *object TSRMLS_DC); - - -void zend_do_begin_new_object(znode *new_token, znode *class_type TSRMLS_DC); -void zend_do_end_new_object(znode *result, const znode *new_token TSRMLS_DC); - -void zend_do_fetch_constant(znode *result, znode *constant_container, znode *constant_name, int mode, zend_bool check_namespace TSRMLS_DC); - -void zend_do_shell_exec(znode *result, znode *cmd TSRMLS_DC); - -void zend_do_init_array(znode *result, znode *expr, znode *offset, zend_bool is_ref TSRMLS_DC); -void zend_do_add_array_element(znode *result, znode *expr, znode *offset, zend_bool is_ref TSRMLS_DC); -void zend_do_end_array(znode *result, const znode *array_node TSRMLS_DC); -void zend_do_list_init(TSRMLS_D); -void zend_do_list_end(znode *result, znode *expr TSRMLS_DC); -void zend_do_add_list_element(const znode *element TSRMLS_DC); -void zend_do_new_list_begin(TSRMLS_D); -void zend_do_new_list_end(TSRMLS_D); - /* Functions for a null terminated pointer list, used for traits parsing and compilation */ void zend_init_list(void *result, void *item TSRMLS_DC); void zend_add_to_list(void *result, void *item TSRMLS_DC); - -void zend_do_cast(znode *result, znode *expr, int type TSRMLS_DC); -void zend_do_include_or_eval(int type, znode *result, znode *op1 TSRMLS_DC); - -void zend_do_unset(znode *variable TSRMLS_DC); -void zend_do_isset_or_isempty(int type, znode *result, znode *variable TSRMLS_DC); - -void zend_do_instanceof(znode *result, znode *expr, znode *class_znode, int type TSRMLS_DC); - -void zend_do_foreach_begin(znode *foreach_token, znode *open_brackets_token, znode *array, znode *as_token, int variable TSRMLS_DC); -void zend_do_foreach_cont(znode *foreach_token, const znode *open_brackets_token, const znode *as_token, znode *value, znode *key TSRMLS_DC); -void zend_do_foreach_end(const znode *foreach_token, const znode *as_token TSRMLS_DC); - -void zend_do_declare_begin(TSRMLS_D); -void zend_do_declare_stmt(znode *var, znode *val TSRMLS_DC); -void zend_do_declare_end(const znode *declare_token TSRMLS_DC); - -void zend_do_exit(znode *result, znode *message TSRMLS_DC); - -void zend_do_begin_silence(znode *strudel_token TSRMLS_DC); -void zend_do_end_silence(znode *strudel_token TSRMLS_DC); - -void zend_do_jmp_set(znode *value, znode *jmp_token, znode *colon_token TSRMLS_DC); -void zend_do_jmp_set_else(znode *result, znode *false_value, const znode *jmp_token, znode *colon_token TSRMLS_DC); - -void zend_do_begin_qm_op(znode *cond, znode *qm_token TSRMLS_DC); -void zend_do_qm_true(znode *true_value, znode *qm_token, znode *colon_token TSRMLS_DC); -void zend_do_qm_false(znode *result, znode *false_value, znode *qm_token, const znode *colon_token TSRMLS_DC); - void zend_do_extended_info(TSRMLS_D); void zend_do_extended_fcall_begin(TSRMLS_D); void zend_do_extended_fcall_end(TSRMLS_D); -void zend_do_ticks(TSRMLS_D); - -void zend_do_abstract_method(const znode *function_name, znode *modifiers, const znode *body TSRMLS_DC); - -void zend_do_declare_constant(znode *name, znode *value TSRMLS_DC); -void zend_do_build_namespace_name(znode *result, znode *prefix, znode *name TSRMLS_DC); -void zend_do_begin_namespace(znode *name, zend_bool with_brackets TSRMLS_DC); -void zend_do_end_namespace(TSRMLS_D); void zend_verify_namespace(TSRMLS_D); -void zend_do_use(znode *name, znode *new_name, int is_global TSRMLS_DC); -void zend_do_use_non_class(znode *ns_name, znode *new_name, int is_global, int is_function, zend_bool case_sensitive, HashTable *current_import_sub, HashTable *lookup_table TSRMLS_DC); -void zend_do_use_function(znode *name, znode *new_name, int is_global TSRMLS_DC); -void zend_do_use_const(znode *name, znode *new_name, int is_global TSRMLS_DC); void zend_do_end_compilation(TSRMLS_D); -void zend_do_constant_expression(znode *result, zend_ast *ast TSRMLS_DC); - -void zend_do_resolve_class_name(znode *result, znode *class_name, int is_static TSRMLS_DC); -void zend_do_label(znode *label TSRMLS_DC); -void zend_do_goto(znode *label TSRMLS_DC); void zend_resolve_goto_label(zend_op_array *op_array, zend_op *opline, int pass2 TSRMLS_DC); void zend_release_labels(int temporary TSRMLS_DC); @@ -686,13 +528,10 @@ int print_class(zend_class_entry *class_entry TSRMLS_DC); void print_op_array(zend_op_array *op_array, int optimizations); ZEND_API int pass_two(zend_op_array *op_array TSRMLS_DC); zend_brk_cont_element *get_next_brk_cont_element(zend_op_array *op_array); -void zend_do_first_catch(znode *open_parentheses TSRMLS_DC); -void zend_initialize_try_catch_element(znode *catch_token TSRMLS_DC); -void zend_do_mark_last_catch(const znode *first_catch, const znode *last_additional_catch TSRMLS_DC); ZEND_API zend_bool zend_is_compiling(TSRMLS_D); ZEND_API char *zend_make_compiled_string_description(const char *name TSRMLS_DC); ZEND_API void zend_initialize_class_data(zend_class_entry *ce, zend_bool nullify_handlers TSRMLS_DC); -int zend_get_class_fetch_type(const char *class_name, uint class_name_len); +uint32_t zend_get_class_fetch_type(zend_string *name); typedef zend_bool (*zend_auto_global_callback)(zend_string *name TSRMLS_DC); typedef struct _zend_auto_global { @@ -707,7 +546,7 @@ ZEND_API void zend_activate_auto_globals(TSRMLS_D); ZEND_API zend_bool zend_is_auto_global(zend_string *name TSRMLS_DC); ZEND_API size_t zend_dirname(char *path, size_t len); -int zendlex(znode *zendlval TSRMLS_DC); +int zendlex(zend_parser_stack_elem *elem TSRMLS_DC); int zend_add_literal(zend_op_array *op_array, zval *zv TSRMLS_DC); @@ -741,6 +580,13 @@ int zend_add_literal(zend_op_array *op_array, zval *zv TSRMLS_DC); #define ZEND_PARSED_NEW (1<<6) #define ZEND_PARSED_LIST_EXPR (1<<7) +#define ZEND_PARAM_REF (1<<0) +#define ZEND_PARAM_VARIADIC (1<<1) + +#define ZEND_NAME_FQ 0 +#define ZEND_NAME_NOT_FQ 1 +#define ZEND_NAME_RELATIVE 2 + /* unset types */ #define ZEND_UNSET_REG 0 @@ -749,9 +595,13 @@ int zend_add_literal(zend_op_array *op_array, zval *zv TSRMLS_DC); #define BP_VAR_W 1 #define BP_VAR_RW 2 #define BP_VAR_IS 3 -#define BP_VAR_NA 4 /* if not applicable */ -#define BP_VAR_FUNC_ARG 5 -#define BP_VAR_UNSET 6 +#define BP_VAR_FUNC_ARG 4 +#define BP_VAR_UNSET 5 +#define BP_VAR_REF 6 /* right-hand side of by-ref assignment */ + +/* Bottom 3 bits are the type, top bits are arg num for BP_VAR_FUNC_ARG */ +#define BP_VAR_SHIFT 3 +#define BP_VAR_MASK 7 #define ZEND_INTERNAL_FUNCTION 1 diff --git a/Zend/zend_execute_API.c b/Zend/zend_execute_API.c index af309c5e64..461225da99 100644 --- a/Zend/zend_execute_API.c +++ b/Zend/zend_execute_API.c @@ -606,7 +606,7 @@ ZEND_API int zval_update_constant_ex(zval *p, zend_bool inline_change, zend_clas zend_ast_evaluate(&tmp, Z_ASTVAL_P(p), scope TSRMLS_CC); if (inline_change) { - zend_ast_destroy(Z_ASTVAL_P(p)); + zend_ast_destroy_and_free(Z_ASTVAL_P(p)); efree(Z_AST_P(p)); } ZVAL_COPY_VALUE(p, &tmp); @@ -1468,7 +1468,7 @@ check_fetch_type: } return EG(current_execute_data)->called_scope; case ZEND_FETCH_CLASS_AUTO: { - fetch_type = zend_get_class_fetch_type(class_name->val, class_name->len); + fetch_type = zend_get_class_fetch_type(class_name); if (fetch_type!=ZEND_FETCH_CLASS_DEFAULT) { goto check_fetch_type; } diff --git a/Zend/zend_globals.h b/Zend/zend_globals.h index 758e373ac2..c4a24486d9 100644 --- a/Zend/zend_globals.h +++ b/Zend/zend_globals.h @@ -71,21 +71,11 @@ typedef struct _zend_ini_entry zend_ini_entry; struct _zend_compiler_globals { - zend_stack bp_stack; zend_stack switch_cond_stack; zend_stack foreach_copy_stack; - zend_stack object_stack; - zend_stack declare_stack; zend_class_entry *active_class_entry; - /* variables for list() compilation */ - zend_llist list_llist; - zend_llist dimension_llist; - zend_stack list_stack; - - zend_stack function_call_stack; - zend_string *compiled_filename; int zend_lineno; @@ -112,8 +102,6 @@ struct _zend_compiler_globals { zend_llist open_files; - zend_long catch_begin; - struct _zend_ini_parser_param *ini_parser_param; int interactive; @@ -123,13 +111,11 @@ struct _zend_compiler_globals { znode implementing_class; - uint32_t access_type; - zend_string *doc_comment; uint32_t compiler_options; /* set of ZEND_COMPILE_* constants */ - zval current_namespace; + zend_string *current_namespace; HashTable *current_import; HashTable *current_import_function; HashTable *current_import_const; @@ -154,6 +140,11 @@ struct _zend_compiler_globals { zend_bool detect_unicode; zend_bool encoding_declared; + zend_ast *ast; + zend_arena *ast_arena; + + zend_stack delayed_oplines_stack; + #ifdef ZTS zval **static_members_table; int last_static_member; diff --git a/Zend/zend_language_parser.y b/Zend/zend_language_parser.y index a6e3182d96..8622fbb441 100644 --- a/Zend/zend_language_parser.y +++ b/Zend/zend_language_parser.y @@ -15,6 +15,7 @@ +----------------------------------------------------------------------+ | Authors: Andi Gutmans <andi@zend.com> | | Zeev Suraski <zeev@zend.com> | + | Nikita Popov <nikic@php.net> | +----------------------------------------------------------------------+ */ @@ -40,12 +41,12 @@ static YYSIZE_T zend_yytnamerr(char*, const char*); #define YYERROR_VERBOSE -#define YYSTYPE znode +#define YYSTYPE zend_parser_stack_elem %} %pure_parser -%expect 3 +%expect 2 %code requires { #ifdef ZTS @@ -188,6 +189,7 @@ static YYSIZE_T zend_yytnamerr(char*, const char*); %token T_EXTENDS "extends (T_EXTENDS)" %token T_IMPLEMENTS "implements (T_IMPLEMENTS)" %token T_OBJECT_OPERATOR "-> (T_OBJECT_OPERATOR)" +%right T_DOUBLE_ARROW %token T_DOUBLE_ARROW "=> (T_DOUBLE_ARROW)" %token T_LIST "list (T_LIST)" %token T_ARRAY "array (T_ARRAY)" @@ -220,299 +222,263 @@ static YYSIZE_T zend_yytnamerr(char*, const char*); %% /* Rules */ start: - top_statement_list { zend_do_end_compilation(TSRMLS_C); } + top_statement_list { CG(ast) = $1.ast; } ; top_statement_list: - top_statement_list { zend_do_extended_info(TSRMLS_C); } top_statement { HANDLE_INTERACTIVE(); } - | /* empty */ + top_statement_list top_statement { $$.list = zend_ast_list_add($1.list, $2.ast); } + | /* empty */ { $$.list = zend_ast_create_list(0, ZEND_AST_STMT_LIST); } ; namespace_name: - T_STRING { $$ = $1; } - | namespace_name T_NS_SEPARATOR T_STRING { zend_do_build_namespace_name(&$$, &$1, &$3 TSRMLS_CC); } + T_STRING { $$.ast = $1.ast; } + | namespace_name T_NS_SEPARATOR T_STRING + { $$.ast = zend_ast_append_str($1.ast, $3.ast); } +; + +name: + namespace_name + { $$.ast = $1.ast; $$.ast->attr = ZEND_NAME_NOT_FQ; } + | T_NAMESPACE T_NS_SEPARATOR namespace_name + { $$.ast = $3.ast; $$.ast->attr = ZEND_NAME_RELATIVE; } + | T_NS_SEPARATOR namespace_name + { $$.ast = $2.ast; $$.ast->attr = ZEND_NAME_FQ; } ; top_statement: - statement { zend_verify_namespace(TSRMLS_C); } - | function_declaration_statement { zend_verify_namespace(TSRMLS_C); zend_do_early_binding(TSRMLS_C); } - | class_declaration_statement { zend_verify_namespace(TSRMLS_C); zend_do_early_binding(TSRMLS_C); } - | T_HALT_COMPILER '(' ')' ';' { zend_do_halt_compiler_register(TSRMLS_C); YYACCEPT; } - | T_NAMESPACE namespace_name ';' { zend_do_begin_namespace(&$2, 0 TSRMLS_CC); } - | T_NAMESPACE namespace_name '{' { zend_do_begin_namespace(&$2, 1 TSRMLS_CC); } - top_statement_list '}' { zend_do_end_namespace(TSRMLS_C); } - | T_NAMESPACE '{' { zend_do_begin_namespace(NULL, 1 TSRMLS_CC); } - top_statement_list '}' { zend_do_end_namespace(TSRMLS_C); } - | T_USE use_declarations ';' { zend_verify_namespace(TSRMLS_C); } - | T_USE T_FUNCTION use_function_declarations ';' { zend_verify_namespace(TSRMLS_C); } - | T_USE T_CONST use_const_declarations ';' { zend_verify_namespace(TSRMLS_C); } - | constant_declaration ';' { zend_verify_namespace(TSRMLS_C); } + statement { $$.ast = $1.ast; } + | function_declaration_statement { $$.ast = $1.ast; } + | class_declaration_statement { $$.ast = $1.ast; } + | T_HALT_COMPILER '(' ')' ';' + { $$.ast = zend_ast_create(ZEND_AST_HALT_COMPILER, + zend_ast_create_zval_from_long(zend_get_scanned_file_offset(TSRMLS_C))); + zend_stop_lexing(TSRMLS_C); } + | T_NAMESPACE namespace_name ';' + { $$.ast = zend_ast_create(ZEND_AST_NAMESPACE, $2.ast, NULL); + RESET_DOC_COMMENT(); } + | T_NAMESPACE namespace_name { RESET_DOC_COMMENT(); } + '{' top_statement_list '}' + { $$.ast = zend_ast_create(ZEND_AST_NAMESPACE, $2.ast, $5.ast); } + | T_NAMESPACE { RESET_DOC_COMMENT(); } + '{' top_statement_list '}' + { $$.ast = zend_ast_create(ZEND_AST_NAMESPACE, NULL, $4.ast); } + | T_USE use_declarations ';' + { $$.ast = $2.ast; $$.ast->attr = T_CLASS; } + | T_USE T_FUNCTION use_declarations ';' + { $$.ast = $3.ast; $$.ast->attr = T_FUNCTION; } + | T_USE T_CONST use_declarations ';' + { $$.ast = $3.ast; $$.ast->attr = T_CONST; } + | T_CONST const_list ';' { $$.ast = $2.ast; } ; use_declarations: use_declarations ',' use_declaration + { $$.list = zend_ast_list_add($1.list, $3.ast); } | use_declaration + { $$.list = zend_ast_create_list(1, ZEND_AST_USE, $1.ast); } ; use_declaration: - namespace_name { zend_do_use(&$1, NULL, 0 TSRMLS_CC); } - | namespace_name T_AS T_STRING { zend_do_use(&$1, &$3, 0 TSRMLS_CC); } - | T_NS_SEPARATOR namespace_name { zend_do_use(&$2, NULL, 1 TSRMLS_CC); } - | T_NS_SEPARATOR namespace_name T_AS T_STRING { zend_do_use(&$2, &$4, 1 TSRMLS_CC); } -; - -use_function_declarations: - use_function_declarations ',' use_function_declaration - | use_function_declaration + namespace_name + { $$.ast = zend_ast_create(ZEND_AST_USE_ELEM, $1.ast, NULL); } + | namespace_name T_AS T_STRING + { $$.ast = zend_ast_create(ZEND_AST_USE_ELEM, $1.ast, $3.ast); } + | T_NS_SEPARATOR namespace_name + { $$.ast = zend_ast_create(ZEND_AST_USE_ELEM, $2.ast, NULL); } + | T_NS_SEPARATOR namespace_name T_AS T_STRING + { $$.ast = zend_ast_create(ZEND_AST_USE_ELEM, $2.ast, $4.ast); } ; -use_function_declaration: - namespace_name { zend_do_use_function(&$1, NULL, 0 TSRMLS_CC); } - | namespace_name T_AS T_STRING { zend_do_use_function(&$1, &$3, 0 TSRMLS_CC); } - | T_NS_SEPARATOR namespace_name { zend_do_use_function(&$2, NULL, 1 TSRMLS_CC); } - | T_NS_SEPARATOR namespace_name T_AS T_STRING { zend_do_use_function(&$2, &$4, 1 TSRMLS_CC); } -; - -use_const_declarations: - use_const_declarations ',' use_const_declaration - | use_const_declaration -; - -use_const_declaration: - namespace_name { zend_do_use_const(&$1, NULL, 0 TSRMLS_CC); } - | namespace_name T_AS T_STRING { zend_do_use_const(&$1, &$3, 0 TSRMLS_CC); } - | T_NS_SEPARATOR namespace_name { zend_do_use_const(&$2, NULL, 1 TSRMLS_CC); } - | T_NS_SEPARATOR namespace_name T_AS T_STRING { zend_do_use_const(&$2, &$4, 1 TSRMLS_CC); } -; - -constant_declaration: - constant_declaration ',' T_STRING '=' static_scalar { zend_do_declare_constant(&$3, &$5 TSRMLS_CC); } - | T_CONST T_STRING '=' static_scalar { zend_do_declare_constant(&$2, &$4 TSRMLS_CC); } +const_list: + const_list ',' const_decl { $$.list = zend_ast_list_add($1.list, $3.ast); } + | const_decl { $$.list = zend_ast_create_list(1, ZEND_AST_CONST_DECL, $1.ast); } ; inner_statement_list: - inner_statement_list { zend_do_extended_info(TSRMLS_C); } inner_statement { HANDLE_INTERACTIVE(); } + inner_statement_list inner_statement + { $$.list = zend_ast_list_add($1.list, $2.ast); } | /* empty */ + { $$.list = zend_ast_create_list(0, ZEND_AST_STMT_LIST); } ; inner_statement: - statement - | function_declaration_statement - | class_declaration_statement - | T_HALT_COMPILER '(' ')' ';' { zend_error_noreturn(E_COMPILE_ERROR, "__HALT_COMPILER() can only be used from the outermost scope"); } + statement { $$.ast = $1.ast; } + | function_declaration_statement { $$.ast = $1.ast; } + | class_declaration_statement { $$.ast = $1.ast; } + | T_HALT_COMPILER '(' ')' ';' + { zend_error_noreturn(E_COMPILE_ERROR, "__HALT_COMPILER() can only be used from the outermost scope"); } ; statement: - unticked_statement { DO_TICKS(); } - | T_STRING ':' { zend_do_label(&$1 TSRMLS_CC); } + unticked_statement { $$.ast = $1.ast; } + | T_STRING ':' { $$.ast = zend_ast_create(ZEND_AST_LABEL, $1.ast); } ; unticked_statement: - '{' inner_statement_list '}' - | T_IF parenthesis_expr { zend_do_if_cond(&$2, &$1 TSRMLS_CC); } statement { zend_do_if_after_statement(&$1, 1 TSRMLS_CC); } elseif_list else_single { zend_do_if_end(TSRMLS_C); } - | T_IF parenthesis_expr ':' { zend_do_if_cond(&$2, &$1 TSRMLS_CC); } inner_statement_list { zend_do_if_after_statement(&$1, 1 TSRMLS_CC); } new_elseif_list new_else_single T_ENDIF ';' { zend_do_if_end(TSRMLS_C); } - | T_WHILE { $1.u.op.opline_num = get_next_op_number(CG(active_op_array)); } parenthesis_expr { zend_do_while_cond(&$3, &$$ TSRMLS_CC); } while_statement { zend_do_while_end(&$1, &$4 TSRMLS_CC); } - | T_DO { $1.u.op.opline_num = get_next_op_number(CG(active_op_array)); zend_do_do_while_begin(TSRMLS_C); } statement T_WHILE { $4.u.op.opline_num = get_next_op_number(CG(active_op_array)); } parenthesis_expr ';' { zend_do_do_while_end(&$1, &$4, &$6 TSRMLS_CC); } - | T_FOR - '(' - for_expr - ';' { zend_do_free(&$3 TSRMLS_CC); $4.u.op.opline_num = get_next_op_number(CG(active_op_array)); } - for_expr - ';' { zend_do_extended_info(TSRMLS_C); zend_do_for_cond(&$6, &$7 TSRMLS_CC); } - for_expr - ')' { zend_do_free(&$9 TSRMLS_CC); zend_do_for_before_statement(&$4, &$7 TSRMLS_CC); } - for_statement { zend_do_for_end(&$7 TSRMLS_CC); } - | T_SWITCH parenthesis_expr { zend_do_switch_cond(&$2 TSRMLS_CC); } switch_case_list { zend_do_switch_end(&$4 TSRMLS_CC); } - | T_BREAK ';' { zend_do_brk_cont(ZEND_BRK, NULL TSRMLS_CC); } - | T_BREAK expr ';' { zend_do_brk_cont(ZEND_BRK, &$2 TSRMLS_CC); } - | T_CONTINUE ';' { zend_do_brk_cont(ZEND_CONT, NULL TSRMLS_CC); } - | T_CONTINUE expr ';' { zend_do_brk_cont(ZEND_CONT, &$2 TSRMLS_CC); } - | T_RETURN ';' { zend_do_return(NULL, 0 TSRMLS_CC); } - | T_RETURN expr_without_variable ';' { zend_do_return(&$2, 0 TSRMLS_CC); } - | T_RETURN variable ';' { zend_do_return(&$2, 1 TSRMLS_CC); } - | yield_expr ';' { zend_do_free(&$1 TSRMLS_CC); } - | T_GLOBAL global_var_list ';' - | T_STATIC static_var_list ';' - | T_ECHO echo_expr_list ';' - | T_INLINE_HTML { zend_do_echo(&$1 TSRMLS_CC); } - | expr ';' { zend_do_free(&$1 TSRMLS_CC); } - | T_UNSET '(' unset_variables ')' ';' - | T_FOREACH '(' variable T_AS - { zend_do_foreach_begin(&$1, &$2, &$3, &$4, 1 TSRMLS_CC); } - foreach_variable foreach_optional_arg ')' { zend_do_foreach_cont(&$1, &$2, &$4, &$6, &$7 TSRMLS_CC); } - foreach_statement { zend_do_foreach_end(&$1, &$4 TSRMLS_CC); } - | T_FOREACH '(' expr_without_variable T_AS - { zend_do_foreach_begin(&$1, &$2, &$3, &$4, 0 TSRMLS_CC); } - foreach_variable foreach_optional_arg ')' { zend_do_foreach_cont(&$1, &$2, &$4, &$6, &$7 TSRMLS_CC); } - foreach_statement { zend_do_foreach_end(&$1, &$4 TSRMLS_CC); } - | T_DECLARE { $1.u.op.opline_num = get_next_op_number(CG(active_op_array)); zend_do_declare_begin(TSRMLS_C); } '(' declare_list ')' declare_statement { zend_do_declare_end(&$1 TSRMLS_CC); } - | ';' /* empty statement */ - | T_TRY { zend_do_try(&$1 TSRMLS_CC); } '{' inner_statement_list '}' - catch_statement { zend_do_bind_catch(&$1, &$6 TSRMLS_CC); } - finally_statement { zend_do_end_finally(&$1, &$6, &$8 TSRMLS_CC); } - | T_THROW expr ';' { zend_do_throw(&$2 TSRMLS_CC); } - | T_GOTO T_STRING ';' { zend_do_goto(&$2 TSRMLS_CC); } -; - -catch_statement: - /* empty */ { $$.op_type = IS_UNUSED; } - | T_CATCH '(' { zend_initialize_try_catch_element(&$1 TSRMLS_CC); } - fully_qualified_class_name { zend_do_first_catch(&$2 TSRMLS_CC); } - T_VARIABLE ')' { zend_do_begin_catch(&$1, &$4, &$6, &$2 TSRMLS_CC); } - '{' inner_statement_list '}' { zend_do_end_catch(&$1 TSRMLS_CC); } - additional_catches { zend_do_mark_last_catch(&$2, &$13 TSRMLS_CC); $$ = $1;} - -finally_statement: - /* empty */ { $$.op_type = IS_UNUSED; } - | T_FINALLY { zend_do_finally(&$1 TSRMLS_CC); } '{' inner_statement_list '}' { $$ = $1; } -; - -additional_catches: - non_empty_additional_catches { $$ = $1; } - | /* empty */ { $$.u.op.opline_num = -1; } -; - -non_empty_additional_catches: - additional_catch { $$ = $1; } - | non_empty_additional_catches additional_catch { $$ = $2; } + '{' inner_statement_list '}' { $$.ast = $2.ast; } + | if_stmt { $$.ast = $1.ast; } + | alt_if_stmt { $$.ast = $1.ast; } + | T_WHILE parenthesis_expr while_statement + { $$.ast = zend_ast_create(ZEND_AST_WHILE, $2.ast, $3.ast); } + | T_DO statement T_WHILE parenthesis_expr ';' + { $$.ast = zend_ast_create(ZEND_AST_DO_WHILE, $2.ast, $4.ast); } + | T_FOR '(' for_expr ';' for_expr ';' for_expr ')' for_statement + { $$.ast = zend_ast_create(ZEND_AST_FOR, $3.ast, $5.ast, $7.ast, $9.ast); } + | T_SWITCH parenthesis_expr switch_case_list + { $$.ast = zend_ast_create(ZEND_AST_SWITCH, $2.ast, $3.ast); } + | T_BREAK ';' { $$.ast = zend_ast_create(ZEND_AST_BREAK, NULL); } + | T_BREAK expr ';' { $$.ast = zend_ast_create(ZEND_AST_BREAK, $2.ast); } + | T_CONTINUE ';' { $$.ast = zend_ast_create(ZEND_AST_CONTINUE, NULL); } + | T_CONTINUE expr ';' { $$.ast = zend_ast_create(ZEND_AST_CONTINUE, $2.ast); } + | T_RETURN ';' + { $$.ast = zend_ast_create(ZEND_AST_RETURN, NULL); } + | T_RETURN expr ';' + { $$.ast = zend_ast_create(ZEND_AST_RETURN, $2.ast); } + | T_GLOBAL global_var_list ';' { $$.ast = $2.ast; } + | T_STATIC static_var_list ';' { $$.ast = $2.ast; } + | T_ECHO echo_expr_list ';' { $$.ast = $2.ast; } + | T_INLINE_HTML { $$.ast = zend_ast_create(ZEND_AST_ECHO, $1.ast); } + | expr ';' { $$.ast = $1.ast; } + | T_UNSET '(' unset_variables ')' ';' { $$.ast = $3.ast; } + | T_FOREACH '(' expr T_AS foreach_variable ')' foreach_statement + { $$.ast = zend_ast_create(ZEND_AST_FOREACH, + $3.ast, $5.ast, NULL, $7.ast); } + | T_FOREACH '(' expr T_AS foreach_variable T_DOUBLE_ARROW foreach_variable ')' + foreach_statement + { $$.ast = zend_ast_create(ZEND_AST_FOREACH, + $3.ast, $7.ast, $5.ast, $9.ast); } + | T_DECLARE '(' const_list ')' + { zend_handle_encoding_declaration($3.list TSRMLS_CC); } + declare_statement + { $$.ast = zend_ast_create(ZEND_AST_DECLARE, $3.ast, $6.ast); } + | ';' /* empty statement */ { $$.ast = NULL; } + | T_TRY '{' inner_statement_list '}' catch_list finally_statement + { $$.ast = zend_ast_create(ZEND_AST_TRY, $3.ast, $5.ast, $6.ast); } + | T_THROW expr ';' { $$.ast = zend_ast_create(ZEND_AST_THROW, $2.ast); } + | T_GOTO T_STRING ';' { $$.ast = zend_ast_create(ZEND_AST_GOTO, $2.ast); } +; + +catch_list: + /* empty */ + { $$.list = zend_ast_create_list(0, ZEND_AST_CATCH_LIST); } + | catch_list T_CATCH '(' name T_VARIABLE ')' '{' inner_statement_list '}' + { $$.list = zend_ast_list_add($1.list, + zend_ast_create(ZEND_AST_CATCH, $4.ast, $5.ast, $8.ast)); } ; -additional_catch: - T_CATCH '(' fully_qualified_class_name { $$.u.op.opline_num = get_next_op_number(CG(active_op_array)); } T_VARIABLE ')' { zend_do_begin_catch(&$1, &$3, &$5, NULL TSRMLS_CC); } '{' inner_statement_list '}' { zend_do_end_catch(&$1 TSRMLS_CC); } +finally_statement: + /* empty */ { $$.ast = NULL; } + | T_FINALLY '{' inner_statement_list '}' { $$.ast = $3.ast; } ; unset_variables: - unset_variable - | unset_variables ',' unset_variable + unset_variable { $$.list = zend_ast_create_list(1, ZEND_AST_STMT_LIST, $1.ast); } + | unset_variables ',' unset_variable { $$.list = zend_ast_list_add($1.list, $3.ast); } ; unset_variable: - variable { zend_do_end_variable_parse(&$1, BP_VAR_UNSET, 0 TSRMLS_CC); zend_do_unset(&$1 TSRMLS_CC); } + variable { $$.ast = zend_ast_create(ZEND_AST_UNSET, $1.ast); } ; function_declaration_statement: - unticked_function_declaration_statement { DO_TICKS(); } -; - -class_declaration_statement: - unticked_class_declaration_statement { DO_TICKS(); } + function returns_ref T_STRING '(' parameter_list ')' + { $$.str = CG(doc_comment); CG(doc_comment) = NULL; } + '{' inner_statement_list '}' + { $$.ast = zend_ast_create_decl(ZEND_AST_FUNC_DECL, $2.num, $1.num, $7.str, + zend_ast_get_str($3.ast), $5.ast, NULL, $9.ast); } ; is_reference: - /* empty */ { $$.op_type = 0; } - | '&' { $$.op_type = 1; } + /* empty */ { $$.num = 0; } + | '&' { $$.num = ZEND_PARAM_REF; } ; is_variadic: - /* empty */ { $$.op_type = 0; } - | T_ELLIPSIS { $$.op_type = 1; } -; - -unticked_function_declaration_statement: - function is_reference T_STRING { zend_do_begin_function_declaration(&$1, &$3, 0, $2.op_type, NULL TSRMLS_CC); } - '(' parameter_list ')' - '{' inner_statement_list '}' { zend_do_end_function_declaration(&$1 TSRMLS_CC); } -; - -unticked_class_declaration_statement: - class_entry_type T_STRING extends_from - { zend_do_begin_class_declaration(&$1, &$2, &$3 TSRMLS_CC); } - implements_list - '{' - class_statement_list - '}' { zend_do_end_class_declaration(&$1, &$3 TSRMLS_CC); } - | interface_entry T_STRING - { zend_do_begin_class_declaration(&$1, &$2, NULL TSRMLS_CC); } - interface_extends_list - '{' - class_statement_list - '}' { zend_do_end_class_declaration(&$1, NULL TSRMLS_CC); } + /* empty */ { $$.num = 0; } + | T_ELLIPSIS { $$.num = ZEND_PARAM_VARIADIC; } ; - -class_entry_type: - T_CLASS { $$.u.op.opline_num = CG(zend_lineno); $$.EA = 0; } - | T_ABSTRACT T_CLASS { $$.u.op.opline_num = CG(zend_lineno); $$.EA = ZEND_ACC_EXPLICIT_ABSTRACT_CLASS; } - | T_TRAIT { $$.u.op.opline_num = CG(zend_lineno); $$.EA = ZEND_ACC_TRAIT; } - | T_FINAL T_CLASS { $$.u.op.opline_num = CG(zend_lineno); $$.EA = ZEND_ACC_FINAL_CLASS; } +class_declaration_statement: + class_type + { $$.num = CG(zend_lineno); } + T_STRING extends_from implements_list + { $$.str = CG(doc_comment); CG(doc_comment) = NULL; } + '{' class_statement_list '}' + { $$.ast = zend_ast_create_decl(ZEND_AST_CLASS, $1.num, $2.num, $6.str, + zend_ast_get_str($3.ast), $4.ast, $5.ast, $8.ast); } + | T_INTERFACE + { $$.num = CG(zend_lineno); } + T_STRING interface_extends_list + { $$.str = CG(doc_comment); CG(doc_comment) = NULL; } + '{' class_statement_list '}' + { $$.ast = zend_ast_create_decl(ZEND_AST_CLASS, ZEND_ACC_INTERFACE, $2.num, $5.str, + zend_ast_get_str($3.ast), NULL, $4.ast, $7.ast); } +; + +class_type: + T_CLASS { $$.num = 0; } + | T_ABSTRACT T_CLASS { $$.num = ZEND_ACC_EXPLICIT_ABSTRACT_CLASS; } + | T_FINAL T_CLASS { $$.num = ZEND_ACC_FINAL_CLASS; } + | T_TRAIT { $$.num = ZEND_ACC_TRAIT; } ; extends_from: - /* empty */ { $$.op_type = IS_UNUSED; } - | T_EXTENDS fully_qualified_class_name { zend_do_fetch_class(&$$, &$2 TSRMLS_CC); } -; - -interface_entry: - T_INTERFACE { $$.u.op.opline_num = CG(zend_lineno); $$.EA = ZEND_ACC_INTERFACE; } + /* empty */ { $$.ast = NULL; } + | T_EXTENDS name { $$.ast = $2.ast; } ; interface_extends_list: - /* empty */ - | T_EXTENDS interface_list + /* empty */ { $$.ast = NULL; } + | T_EXTENDS name_list { $$.ast = $2.ast; } ; implements_list: - /* empty */ - | T_IMPLEMENTS interface_list -; - -interface_list: - fully_qualified_class_name { zend_do_implements_interface(&$1 TSRMLS_CC); } - | interface_list ',' fully_qualified_class_name { zend_do_implements_interface(&$3 TSRMLS_CC); } -; - -foreach_optional_arg: - /* empty */ { $$.op_type = IS_UNUSED; } - | T_DOUBLE_ARROW foreach_variable { $$ = $2; } + /* empty */ { $$.ast = NULL; } + | T_IMPLEMENTS name_list { $$.ast = $2.ast; } ; foreach_variable: - variable { zend_check_writable_variable(&$1); $$ = $1; } - | '&' variable { zend_check_writable_variable(&$2); $$ = $2; $$.EA |= ZEND_PARSED_REFERENCE_VARIABLE; } - | T_LIST '(' { zend_do_list_init(TSRMLS_C); } assignment_list ')' { $$ = $1; $$.EA = ZEND_PARSED_LIST_EXPR; } + variable { $$.ast = $1.ast; } + | '&' variable { $$.ast = zend_ast_create(ZEND_AST_REF, $2.ast); } + | T_LIST '(' assignment_list ')' { $$.ast = $3.ast; } ; for_statement: - statement - | ':' inner_statement_list T_ENDFOR ';' + statement { $$.ast = $1.ast; } + | ':' inner_statement_list T_ENDFOR ';' { $$.ast = $2.ast; } ; foreach_statement: - statement - | ':' inner_statement_list T_ENDFOREACH ';' + statement { $$.ast = $1.ast; } + | ':' inner_statement_list T_ENDFOREACH ';' { $$.ast = $2.ast; } ; declare_statement: - statement - | ':' inner_statement_list T_ENDDECLARE ';' + statement { $$.ast = $1.ast; } + | ':' inner_statement_list T_ENDDECLARE ';' { $$.ast = $2.ast; } ; - -declare_list: - T_STRING '=' static_scalar { zend_do_declare_stmt(&$1, &$3 TSRMLS_CC); } - | declare_list ',' T_STRING '=' static_scalar { zend_do_declare_stmt(&$3, &$5 TSRMLS_CC); } -; - - switch_case_list: - '{' case_list '}' { $$ = $2; } - | '{' ';' case_list '}' { $$ = $3; } - | ':' case_list T_ENDSWITCH ';' { $$ = $2; } - | ':' ';' case_list T_ENDSWITCH ';' { $$ = $3; } + '{' case_list '}' { $$.ast = $2.ast; } + | '{' ';' case_list '}' { $$.ast = $3.ast; } + | ':' case_list T_ENDSWITCH ';' { $$.ast = $2.ast; } + | ':' ';' case_list T_ENDSWITCH ';' { $$.ast = $3.ast; } ; - case_list: - /* empty */ { $$.op_type = IS_UNUSED; } - | case_list T_CASE expr case_separator { zend_do_extended_info(TSRMLS_C); zend_do_case_before_statement(&$1, &$2, &$3 TSRMLS_CC); } inner_statement_list { zend_do_case_after_statement(&$$, &$2 TSRMLS_CC); $$.op_type = IS_CONST; } - | case_list T_DEFAULT case_separator { zend_do_extended_info(TSRMLS_C); zend_do_default_before_statement(&$1, &$2 TSRMLS_CC); } inner_statement_list { zend_do_case_after_statement(&$$, &$2 TSRMLS_CC); $$.op_type = IS_CONST; } + /* empty */ { $$.list = zend_ast_create_list(0, ZEND_AST_SWITCH_LIST); } + | case_list T_CASE expr case_separator inner_statement_list + { $$.list = zend_ast_list_add($1.list, + zend_ast_create(ZEND_AST_SWITCH_CASE, $3.ast, $5.ast)); } + | case_list T_DEFAULT case_separator inner_statement_list + { $$.list = zend_ast_list_add($1.list, + zend_ast_create(ZEND_AST_SWITCH_CASE, NULL, $4.ast)); } ; - case_separator: ':' | ';' @@ -520,547 +486,496 @@ case_separator: while_statement: - statement - | ':' inner_statement_list T_ENDWHILE ';' + statement { $$.ast = $1.ast; } + | ':' inner_statement_list T_ENDWHILE ';' { $$.ast = $2.ast; } ; - -elseif_list: - /* empty */ - | elseif_list T_ELSEIF parenthesis_expr { zend_do_if_cond(&$3, &$2 TSRMLS_CC); } statement { zend_do_if_after_statement(&$2, 0 TSRMLS_CC); } +if_stmt_without_else: + T_IF parenthesis_expr statement + { $$.list = zend_ast_create_list(1, ZEND_AST_IF, + zend_ast_create(ZEND_AST_IF_ELEM, $2.ast, $3.ast)); } + | if_stmt_without_else T_ELSEIF parenthesis_expr statement + { $$.list = zend_ast_list_add($1.list, + zend_ast_create(ZEND_AST_IF_ELEM, $3.ast, $4.ast)); } ; - -new_elseif_list: - /* empty */ - | new_elseif_list T_ELSEIF parenthesis_expr ':' { zend_do_if_cond(&$3, &$2 TSRMLS_CC); } inner_statement_list { zend_do_if_after_statement(&$2, 0 TSRMLS_CC); } +if_stmt: + if_stmt_without_else { $$.ast = $1.ast; } + | if_stmt_without_else T_ELSE statement + { $$.list = zend_ast_list_add($1.list, + zend_ast_create(ZEND_AST_IF_ELEM, NULL, $3.ast)); } ; - -else_single: - /* empty */ - | T_ELSE statement +alt_if_stmt_without_else: + T_IF parenthesis_expr ':' inner_statement_list + { $$.list = zend_ast_create_list(1, ZEND_AST_IF, + zend_ast_create(ZEND_AST_IF_ELEM, $2.ast, $4.ast)); } + | alt_if_stmt_without_else T_ELSEIF parenthesis_expr ':' inner_statement_list + { $$.list = zend_ast_list_add($1.list, + zend_ast_create(ZEND_AST_IF_ELEM, $3.ast, $5.ast)); } ; - -new_else_single: - /* empty */ - | T_ELSE ':' inner_statement_list +alt_if_stmt: + alt_if_stmt_without_else T_ENDIF ';' { $$.ast = $1.ast; } + | alt_if_stmt_without_else T_ELSE ':' inner_statement_list T_ENDIF ';' + { $$.list = zend_ast_list_add($1.list, + zend_ast_create(ZEND_AST_IF_ELEM, NULL, $4.ast)); } ; - parameter_list: - non_empty_parameter_list - | /* empty */ + non_empty_parameter_list { $$.ast = $1.ast; } + | /* empty */ { $$.list = zend_ast_create_list(0, ZEND_AST_PARAM_LIST); } ; non_empty_parameter_list: parameter + { $$.list = zend_ast_create_list(1, ZEND_AST_PARAM_LIST, $1.ast); } | non_empty_parameter_list ',' parameter + { $$.list = zend_ast_list_add($1.list, $3.ast); } ; parameter: - optional_class_type is_reference is_variadic T_VARIABLE - { zend_do_receive_param(ZEND_RECV, &$4, NULL, &$1, $2.op_type, $3.op_type TSRMLS_CC); } - | optional_class_type is_reference is_variadic T_VARIABLE '=' static_scalar - { zend_do_receive_param(ZEND_RECV_INIT, &$4, &$6, &$1, $2.op_type, $3.op_type TSRMLS_CC); } + optional_type is_reference is_variadic T_VARIABLE + { $$.ast = zend_ast_create_ex(ZEND_AST_PARAM, $2.num | $3.num, + $1.ast, $4.ast, NULL); } + | optional_type is_reference is_variadic T_VARIABLE '=' expr + { $$.ast = zend_ast_create_ex(ZEND_AST_PARAM, $2.num | $3.num, + $1.ast, $4.ast, $6.ast); } ; -optional_class_type: - /* empty */ { $$.op_type = IS_UNUSED; } - | T_ARRAY { $$.op_type = IS_CONST; Z_TYPE_INFO($$.u.constant)=IS_ARRAY; } - | T_CALLABLE { $$.op_type = IS_CONST; Z_TYPE_INFO($$.u.constant)=IS_CALLABLE; } - | fully_qualified_class_name { $$ = $1; } +optional_type: + /* empty */ { $$.ast = NULL; } + | T_ARRAY { $$.ast = zend_ast_create_ex(ZEND_AST_TYPE, IS_ARRAY); } + | T_CALLABLE { $$.ast = zend_ast_create_ex(ZEND_AST_TYPE, IS_CALLABLE); } + | name { $$.ast = $1.ast; } ; - -function_call_parameter_list: - '(' ')' { Z_LVAL($$.u.constant) = 0; } - | '(' non_empty_function_call_parameter_list ')' { $$ = $2; } - | '(' yield_expr ')' { zend_do_pass_param(&$2, ZEND_SEND_VAL TSRMLS_CC); } +argument_list: + '(' ')' { $$.list = zend_ast_create_list(0, ZEND_AST_ARG_LIST); } + | '(' non_empty_argument_list ')' { $$.ast = $2.ast; } ; - -non_empty_function_call_parameter_list: - function_call_parameter - | non_empty_function_call_parameter_list ',' function_call_parameter +non_empty_argument_list: + argument + { $$.list = zend_ast_create_list(1, ZEND_AST_ARG_LIST, $1.ast); } + | non_empty_argument_list ',' argument + { $$.list = zend_ast_list_add($1.list, $3.ast); } ; -function_call_parameter: - expr_without_variable { zend_do_pass_param(&$1, ZEND_SEND_VAL TSRMLS_CC); } - | variable { zend_do_pass_param(&$1, ZEND_SEND_VAR TSRMLS_CC); } - | '&' w_variable { zend_do_pass_param(&$2, ZEND_SEND_REF TSRMLS_CC); } - | T_ELLIPSIS expr { zend_do_unpack_params(&$2 TSRMLS_CC); } +argument: + expr_without_variable { $$.ast = $1.ast; } + | variable { $$.ast = $1.ast; } + /*| '&' variable { ZEND_ASSERT(0); } */ + | T_ELLIPSIS expr { $$.ast = zend_ast_create(ZEND_AST_UNPACK, $2.ast); } ; global_var_list: - global_var_list ',' global_var { zend_do_fetch_global_variable(&$3, NULL, ZEND_FETCH_GLOBAL_LOCK TSRMLS_CC); } - | global_var { zend_do_fetch_global_variable(&$1, NULL, ZEND_FETCH_GLOBAL_LOCK TSRMLS_CC); } + global_var_list ',' global_var { $$.list = zend_ast_list_add($1.list, $3.ast); } + | global_var { $$.list = zend_ast_create_list(1, ZEND_AST_STMT_LIST, $1.ast); } ; - global_var: - T_VARIABLE { $$ = $1; } - | '$' r_variable { $$ = $2; } - | '$' '{' expr '}' { $$ = $3; } + simple_variable + { $$.ast = zend_ast_create(ZEND_AST_GLOBAL, + zend_ast_create(ZEND_AST_VAR, $1.ast)); } ; static_var_list: - static_var_list ',' T_VARIABLE { zend_do_fetch_static_variable(&$3, NULL, ZEND_FETCH_STATIC TSRMLS_CC); } - | static_var_list ',' T_VARIABLE '=' static_scalar { Z_CONST_FLAGS($5.u.constant) = 0; zend_do_fetch_static_variable(&$3, &$5, ZEND_FETCH_STATIC TSRMLS_CC); } - | T_VARIABLE { zend_do_fetch_static_variable(&$1, NULL, ZEND_FETCH_STATIC TSRMLS_CC); } - | T_VARIABLE '=' static_scalar { Z_CONST_FLAGS($3.u.constant) = 0; zend_do_fetch_static_variable(&$1, &$3, ZEND_FETCH_STATIC TSRMLS_CC); } + static_var_list ',' static_var { $$.list = zend_ast_list_add($1.list, $3.ast); } + | static_var { $$.list = zend_ast_create_list(1, ZEND_AST_STMT_LIST, $1.ast); } +; +static_var: + T_VARIABLE + { $$.ast = zend_ast_create(ZEND_AST_STATIC, $1.ast, NULL); } + | T_VARIABLE '=' expr + { $$.ast = zend_ast_create(ZEND_AST_STATIC, $1.ast, $3.ast); } ; class_statement_list: class_statement_list class_statement + { $$.list = zend_ast_list_add($1.list, $2.ast); } | /* empty */ + { $$.list = zend_ast_create_list(0, ZEND_AST_STMT_LIST); } ; class_statement: - variable_modifiers { CG(access_type) = Z_LVAL($1.u.constant); } class_variable_declaration ';' - | class_constant_declaration ';' - | trait_use_statement - | method_modifiers function is_reference T_STRING { zend_do_begin_function_declaration(&$2, &$4, 1, $3.op_type, &$1 TSRMLS_CC); } - '(' parameter_list ')' - method_body { zend_do_abstract_method(&$4, &$1, &$9 TSRMLS_CC); zend_do_end_function_declaration(&$2 TSRMLS_CC); } + variable_modifiers property_list ';' + { $$.list = zend_ast_append_doc_comment($2.list TSRMLS_CC); $$.ast->attr = $1.num; } + | T_CONST class_const_list ';' + { $$.ast = $2.ast; RESET_DOC_COMMENT(); } + | T_USE name_list trait_adaptations + { $$.ast = zend_ast_create(ZEND_AST_USE_TRAIT, $2.ast, $3.ast); } + | method_modifiers function returns_ref T_STRING '(' parameter_list ')' + { $$.str = CG(doc_comment); CG(doc_comment) = NULL; } + method_body + { $$.ast = zend_ast_create_decl(ZEND_AST_METHOD, $3.num | $1.num, $2.num, $8.str, + zend_ast_get_str($4.ast), $6.ast, NULL, $9.ast); } ; -trait_use_statement: - T_USE trait_list trait_adaptations -; - -trait_list: - fully_qualified_class_name { zend_do_use_trait(&$1 TSRMLS_CC); } - | trait_list ',' fully_qualified_class_name { zend_do_use_trait(&$3 TSRMLS_CC); } +name_list: + name { $$.list = zend_ast_create_list(1, ZEND_AST_NAME_LIST, $1.ast); } + | name_list ',' name { $$.list = zend_ast_list_add($1.list, $3.ast); } ; trait_adaptations: - ';' - | '{' trait_adaptation_list '}' + ';' { $$.ast = NULL; } + | '{' '}' { $$.ast = NULL; } + | '{' trait_adaptation_list '}' { $$.ast = $2.ast; } ; trait_adaptation_list: - /* empty */ - | non_empty_trait_adaptation_list -; - -non_empty_trait_adaptation_list: - trait_adaptation_statement - | non_empty_trait_adaptation_list trait_adaptation_statement + trait_adaptation + { $$.list = zend_ast_create_list(1, ZEND_AST_TRAIT_ADAPTATIONS, $1.ast); } + | trait_adaptation_list trait_adaptation + { $$.list = zend_ast_list_add($1.list, $2.ast); } ; -trait_adaptation_statement: - trait_precedence ';' - | trait_alias ';' +trait_adaptation: + trait_precedence ';' { $$.ast = $1.ast; } + | trait_alias ';' { $$.ast = $1.ast; } ; trait_precedence: - trait_method_reference_fully_qualified T_INSTEADOF trait_reference_list { zend_add_trait_precedence(&$1, &$3 TSRMLS_CC); } + absolute_trait_method_reference T_INSTEADOF name_list + { $$.ast = zend_ast_create(ZEND_AST_TRAIT_PRECEDENCE, $1.ast, $3.ast); } ; -trait_reference_list: - fully_qualified_class_name { zend_resolve_class_name(&$1 TSRMLS_CC); zend_init_list(&$$.u.op.ptr, Z_STR($1.u.constant) TSRMLS_CC); } - | trait_reference_list ',' fully_qualified_class_name { zend_resolve_class_name(&$3 TSRMLS_CC); zend_add_to_list(&$1.u.op.ptr, Z_STR($3.u.constant) TSRMLS_CC); $$ = $1; } +trait_alias: + trait_method_reference T_AS trait_modifiers T_STRING + { $$.ast = zend_ast_create_ex(ZEND_AST_TRAIT_ALIAS, $3.num, $1.ast, $4.ast); } + | trait_method_reference T_AS member_modifier + { $$.ast = zend_ast_create_ex(ZEND_AST_TRAIT_ALIAS, $3.num, $1.ast, NULL); } ; trait_method_reference: - T_STRING { zend_prepare_reference(&$$, NULL, &$1 TSRMLS_CC); } - | trait_method_reference_fully_qualified { $$ = $1; } -; - -trait_method_reference_fully_qualified: - fully_qualified_class_name T_PAAMAYIM_NEKUDOTAYIM T_STRING { zend_prepare_reference(&$$, &$1, &$3 TSRMLS_CC); } + T_STRING + { $$.ast = zend_ast_create(ZEND_AST_METHOD_REFERENCE, NULL, $1.ast); } + | absolute_trait_method_reference { $$.ast = $1.ast; } ; -trait_alias: - trait_method_reference T_AS trait_modifiers T_STRING { zend_add_trait_alias(&$1, &$3, &$4 TSRMLS_CC); } - | trait_method_reference T_AS member_modifier { zend_add_trait_alias(&$1, &$3, NULL TSRMLS_CC); } +absolute_trait_method_reference: + name T_PAAMAYIM_NEKUDOTAYIM T_STRING + { $$.ast = zend_ast_create(ZEND_AST_METHOD_REFERENCE, $1.ast, $3.ast); } ; trait_modifiers: - /* empty */ { Z_LVAL($$.u.constant) = 0x0; } /* No change of methods visibility */ - | member_modifier { $$ = $1; } /* REM: Keep in mind, there are not only visibility modifiers */ + /* empty */ { $$.num = 0; } + | member_modifier { $$.num = $1.num; } ; method_body: - ';' /* abstract method */ { Z_LVAL($$.u.constant) = ZEND_ACC_ABSTRACT; } - | '{' inner_statement_list '}' { Z_LVAL($$.u.constant) = 0; } + ';' /* abstract method */ { $$.ast = NULL; } + | '{' inner_statement_list '}' { $$.ast = $2.ast; } ; variable_modifiers: - non_empty_member_modifiers { $$ = $1; } - | T_VAR { Z_LVAL($$.u.constant) = ZEND_ACC_PUBLIC; } + non_empty_member_modifiers { $$.num = $1.num; } + | T_VAR { $$.num = ZEND_ACC_PUBLIC; } ; method_modifiers: - /* empty */ { Z_LVAL($$.u.constant) = ZEND_ACC_PUBLIC; } - | non_empty_member_modifiers { $$ = $1; if (!(Z_LVAL($$.u.constant) & ZEND_ACC_PPP_MASK)) { Z_LVAL($$.u.constant) |= ZEND_ACC_PUBLIC; } } + /* empty */ { $$.num = ZEND_ACC_PUBLIC; } + | non_empty_member_modifiers + { $$.num = $1.num; if (!($$.num & ZEND_ACC_PPP_MASK)) { $$.num |= ZEND_ACC_PUBLIC; } } ; non_empty_member_modifiers: - member_modifier { $$ = $1; } - | non_empty_member_modifiers member_modifier { Z_LVAL($$.u.constant) = zend_do_verify_access_types(&$1, &$2); } + member_modifier { $$.num = $1.num; } + | non_empty_member_modifiers member_modifier + { $$.num = zend_add_member_modifier($1.num, $2.num); } ; member_modifier: - T_PUBLIC { Z_LVAL($$.u.constant) = ZEND_ACC_PUBLIC; } - | T_PROTECTED { Z_LVAL($$.u.constant) = ZEND_ACC_PROTECTED; } - | T_PRIVATE { Z_LVAL($$.u.constant) = ZEND_ACC_PRIVATE; } - | T_STATIC { Z_LVAL($$.u.constant) = ZEND_ACC_STATIC; } - | T_ABSTRACT { Z_LVAL($$.u.constant) = ZEND_ACC_ABSTRACT; } - | T_FINAL { Z_LVAL($$.u.constant) = ZEND_ACC_FINAL; } + T_PUBLIC { $$.num = ZEND_ACC_PUBLIC; } + | T_PROTECTED { $$.num = ZEND_ACC_PROTECTED; } + | T_PRIVATE { $$.num = ZEND_ACC_PRIVATE; } + | T_STATIC { $$.num = ZEND_ACC_STATIC; } + | T_ABSTRACT { $$.num = ZEND_ACC_ABSTRACT; } + | T_FINAL { $$.num = ZEND_ACC_FINAL; } ; -class_variable_declaration: - class_variable_declaration ',' T_VARIABLE { zend_do_declare_property(&$3, NULL, CG(access_type) TSRMLS_CC); } - | class_variable_declaration ',' T_VARIABLE '=' static_scalar { zend_do_declare_property(&$3, &$5, CG(access_type) TSRMLS_CC); } - | T_VARIABLE { zend_do_declare_property(&$1, NULL, CG(access_type) TSRMLS_CC); } - | T_VARIABLE '=' static_scalar { zend_do_declare_property(&$1, &$3, CG(access_type) TSRMLS_CC); } +property_list: + property_list ',' property { $$.list = zend_ast_list_add($1.list, $3.ast); } + | property { $$.list = zend_ast_create_list(1, ZEND_AST_PROP_DECL, $1.ast); } ; -class_constant_declaration: - class_constant_declaration ',' T_STRING '=' static_scalar { zend_do_declare_class_constant(&$3, &$5 TSRMLS_CC); } - | T_CONST T_STRING '=' static_scalar { zend_do_declare_class_constant(&$2, &$4 TSRMLS_CC); } +property: + T_VARIABLE { $$.ast = zend_ast_create(ZEND_AST_PROP_ELEM, $1.ast, NULL); } + | T_VARIABLE '=' expr + { $$.ast = zend_ast_create(ZEND_AST_PROP_ELEM, $1.ast, $3.ast); } ; -echo_expr_list: - echo_expr_list ',' expr { zend_do_echo(&$3 TSRMLS_CC); } - | expr { zend_do_echo(&$1 TSRMLS_CC); } +class_const_list: + class_const_list ',' const_decl { $$.list = zend_ast_list_add($1.list, $3.ast); } + | const_decl + { $$.list = zend_ast_create_list(1, ZEND_AST_CLASS_CONST_DECL, $1.ast); } ; - -for_expr: - /* empty */ { $$.op_type = IS_CONST; ZVAL_BOOL(&$$.u.constant, 1); } - | non_empty_for_expr { $$ = $1; } +const_decl: + T_STRING '=' expr + { $$.ast = zend_ast_create(ZEND_AST_CONST_ELEM, $1.ast, $3.ast); } ; -non_empty_for_expr: - non_empty_for_expr ',' { zend_do_free(&$1 TSRMLS_CC); } expr { $$ = $4; } - | expr { $$ = $1; } -; - -chaining_method_or_property: - chaining_method_or_property variable_property { $$.EA = $2.EA; } - | variable_property { $$.EA = $1.EA; } +echo_expr_list: + echo_expr_list ',' echo_expr { $$.list = zend_ast_list_add($1.list, $3.ast); } + | echo_expr { $$.list = zend_ast_create_list(1, ZEND_AST_STMT_LIST, $1.ast); } ; - -chaining_dereference: - chaining_dereference '[' dim_offset ']' { fetch_array_dim(&$$, &$1, &$3 TSRMLS_CC); } - | '[' dim_offset ']' { zend_do_pop_object(&$1 TSRMLS_CC); fetch_array_dim(&$$, &$1, &$2 TSRMLS_CC); } +echo_expr: + expr { $$.ast = zend_ast_create(ZEND_AST_ECHO, $1.ast); } ; -chaining_instance_call: - chaining_dereference { zend_do_push_object(&$1 TSRMLS_CC); } chaining_method_or_property { $$ = $3; } - | chaining_dereference { zend_do_push_object(&$1 TSRMLS_CC); $$ = $1; } - | chaining_method_or_property { $$ = $1; } +for_expr: + /* empty */ { $$.ast = NULL; } + | non_empty_for_expr { $$.ast = $1.ast; } ; -instance_call: - /* empty */ { $$ = $0; } - | { zend_do_push_object(&$0 TSRMLS_CC); zend_do_begin_variable_parse(TSRMLS_C); } - chaining_instance_call { zend_do_pop_object(&$$ TSRMLS_CC); zend_do_end_variable_parse(&$2, BP_VAR_R, 0 TSRMLS_CC); } +non_empty_for_expr: + non_empty_for_expr ',' expr { $$.list = zend_ast_list_add($1.list, $3.ast); } + | expr { $$.list = zend_ast_create_list(1, ZEND_AST_EXPR_LIST, $1.ast); } ; new_expr: - T_NEW class_name_reference { zend_do_extended_fcall_begin(TSRMLS_C); zend_do_begin_new_object(&$1, &$2 TSRMLS_CC); } ctor_arguments { zend_do_end_new_object(&$$, &$1 TSRMLS_CC); zend_do_extended_fcall_end(TSRMLS_C);} + T_NEW class_name_reference ctor_arguments + { $$.ast = zend_ast_create(ZEND_AST_NEW, $2.ast, $3.ast); } ; expr_without_variable: - T_LIST '(' { zend_do_list_init(TSRMLS_C); } assignment_list ')' '=' expr { zend_do_list_end(&$$, &$7 TSRMLS_CC); } - | variable '=' expr { zend_check_writable_variable(&$1); zend_do_assign(&$$, &$1, &$3 TSRMLS_CC); } - | variable '=' '&' variable { zend_check_writable_variable(&$1); zend_do_end_variable_parse(&$4, BP_VAR_W, 1 TSRMLS_CC); zend_do_end_variable_parse(&$1, BP_VAR_W, 0 TSRMLS_CC); zend_do_assign_ref(&$$, &$1, &$4 TSRMLS_CC); } - | variable '=' '&' T_NEW class_name_reference { zend_error(E_DEPRECATED, "Assigning the return value of new by reference is deprecated"); zend_check_writable_variable(&$1); zend_do_extended_fcall_begin(TSRMLS_C); zend_do_begin_new_object(&$4, &$5 TSRMLS_CC); } ctor_arguments { zend_do_end_new_object(&$3, &$4 TSRMLS_CC); zend_do_extended_fcall_end(TSRMLS_C); zend_do_end_variable_parse(&$1, BP_VAR_W, 0 TSRMLS_CC); $3.EA = ZEND_PARSED_NEW; zend_do_assign_ref(&$$, &$1, &$3 TSRMLS_CC); } - | T_CLONE expr { zend_do_clone(&$$, &$2 TSRMLS_CC); } - | variable T_PLUS_EQUAL expr { zend_check_writable_variable(&$1); zend_do_end_variable_parse(&$1, BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_ADD, &$$, &$1, &$3 TSRMLS_CC); } - | variable T_MINUS_EQUAL expr { zend_check_writable_variable(&$1); zend_do_end_variable_parse(&$1, BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_SUB, &$$, &$1, &$3 TSRMLS_CC); } - | variable T_MUL_EQUAL expr { zend_check_writable_variable(&$1); zend_do_end_variable_parse(&$1, BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_MUL, &$$, &$1, &$3 TSRMLS_CC); } - | variable T_POW_EQUAL expr { zend_check_writable_variable(&$1); zend_do_end_variable_parse(&$1, BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_POW, &$$, &$1, &$3 TSRMLS_CC); } - | variable T_DIV_EQUAL expr { zend_check_writable_variable(&$1); zend_do_end_variable_parse(&$1, BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_DIV, &$$, &$1, &$3 TSRMLS_CC); } - | variable T_CONCAT_EQUAL expr { zend_check_writable_variable(&$1); zend_do_end_variable_parse(&$1, BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_CONCAT, &$$, &$1, &$3 TSRMLS_CC); } - | variable T_MOD_EQUAL expr { zend_check_writable_variable(&$1); zend_do_end_variable_parse(&$1, BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_MOD, &$$, &$1, &$3 TSRMLS_CC); } - | variable T_AND_EQUAL expr { zend_check_writable_variable(&$1); zend_do_end_variable_parse(&$1, BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_BW_AND, &$$, &$1, &$3 TSRMLS_CC); } - | variable T_OR_EQUAL expr { zend_check_writable_variable(&$1); zend_do_end_variable_parse(&$1, BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_BW_OR, &$$, &$1, &$3 TSRMLS_CC); } - | variable T_XOR_EQUAL expr { zend_check_writable_variable(&$1); zend_do_end_variable_parse(&$1, BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_BW_XOR, &$$, &$1, &$3 TSRMLS_CC); } - | variable T_SL_EQUAL expr { zend_check_writable_variable(&$1); zend_do_end_variable_parse(&$1, BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_SL, &$$, &$1, &$3 TSRMLS_CC); } - | variable T_SR_EQUAL expr { zend_check_writable_variable(&$1); zend_do_end_variable_parse(&$1, BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_SR, &$$, &$1, &$3 TSRMLS_CC); } - | rw_variable T_INC { zend_do_post_incdec(&$$, &$1, ZEND_POST_INC TSRMLS_CC); } - | T_INC rw_variable { zend_do_pre_incdec(&$$, &$2, ZEND_PRE_INC TSRMLS_CC); } - | rw_variable T_DEC { zend_do_post_incdec(&$$, &$1, ZEND_POST_DEC TSRMLS_CC); } - | T_DEC rw_variable { zend_do_pre_incdec(&$$, &$2, ZEND_PRE_DEC TSRMLS_CC); } - | expr T_BOOLEAN_OR { zend_do_boolean_or_begin(&$1, &$2 TSRMLS_CC); } expr { zend_do_boolean_or_end(&$$, &$1, &$4, &$2 TSRMLS_CC); } - | expr T_BOOLEAN_AND { zend_do_boolean_and_begin(&$1, &$2 TSRMLS_CC); } expr { zend_do_boolean_and_end(&$$, &$1, &$4, &$2 TSRMLS_CC); } - | expr T_LOGICAL_OR { zend_do_boolean_or_begin(&$1, &$2 TSRMLS_CC); } expr { zend_do_boolean_or_end(&$$, &$1, &$4, &$2 TSRMLS_CC); } - | expr T_LOGICAL_AND { zend_do_boolean_and_begin(&$1, &$2 TSRMLS_CC); } expr { zend_do_boolean_and_end(&$$, &$1, &$4, &$2 TSRMLS_CC); } - | expr T_LOGICAL_XOR expr { zend_do_binary_op(ZEND_BOOL_XOR, &$$, &$1, &$3 TSRMLS_CC); } - | expr '|' expr { zend_do_binary_op(ZEND_BW_OR, &$$, &$1, &$3 TSRMLS_CC); } - | expr '&' expr { zend_do_binary_op(ZEND_BW_AND, &$$, &$1, &$3 TSRMLS_CC); } - | expr '^' expr { zend_do_binary_op(ZEND_BW_XOR, &$$, &$1, &$3 TSRMLS_CC); } - | expr '.' expr { zend_do_binary_op(ZEND_CONCAT, &$$, &$1, &$3 TSRMLS_CC); } - | expr '+' expr { zend_do_binary_op(ZEND_ADD, &$$, &$1, &$3 TSRMLS_CC); } - | expr '-' expr { zend_do_binary_op(ZEND_SUB, &$$, &$1, &$3 TSRMLS_CC); } - | expr '*' expr { zend_do_binary_op(ZEND_MUL, &$$, &$1, &$3 TSRMLS_CC); } - | expr T_POW expr { zend_do_binary_op(ZEND_POW, &$$, &$1, &$3 TSRMLS_CC); } - | expr '/' expr { zend_do_binary_op(ZEND_DIV, &$$, &$1, &$3 TSRMLS_CC); } - | expr '%' expr { zend_do_binary_op(ZEND_MOD, &$$, &$1, &$3 TSRMLS_CC); } - | expr T_SL expr { zend_do_binary_op(ZEND_SL, &$$, &$1, &$3 TSRMLS_CC); } - | expr T_SR expr { zend_do_binary_op(ZEND_SR, &$$, &$1, &$3 TSRMLS_CC); } - | '+' expr %prec T_INC { ZVAL_LONG(&$1.u.constant, 0); if ($2.op_type == IS_CONST) { add_function(&$2.u.constant, &$1.u.constant, &$2.u.constant TSRMLS_CC); $$ = $2; } else { $1.op_type = IS_CONST; zend_do_binary_op(ZEND_ADD, &$$, &$1, &$2 TSRMLS_CC); } } - | '-' expr %prec T_INC { ZVAL_LONG(&$1.u.constant, 0); if ($2.op_type == IS_CONST) { sub_function(&$2.u.constant, &$1.u.constant, &$2.u.constant TSRMLS_CC); $$ = $2; } else { $1.op_type = IS_CONST; zend_do_binary_op(ZEND_SUB, &$$, &$1, &$2 TSRMLS_CC); } } - | '!' expr { zend_do_unary_op(ZEND_BOOL_NOT, &$$, &$2 TSRMLS_CC); } - | '~' expr { zend_do_unary_op(ZEND_BW_NOT, &$$, &$2 TSRMLS_CC); } - | expr T_IS_IDENTICAL expr { zend_do_binary_op(ZEND_IS_IDENTICAL, &$$, &$1, &$3 TSRMLS_CC); } - | expr T_IS_NOT_IDENTICAL expr { zend_do_binary_op(ZEND_IS_NOT_IDENTICAL, &$$, &$1, &$3 TSRMLS_CC); } - | expr T_IS_EQUAL expr { zend_do_binary_op(ZEND_IS_EQUAL, &$$, &$1, &$3 TSRMLS_CC); } - | expr T_IS_NOT_EQUAL expr { zend_do_binary_op(ZEND_IS_NOT_EQUAL, &$$, &$1, &$3 TSRMLS_CC); } - | expr '<' expr { zend_do_binary_op(ZEND_IS_SMALLER, &$$, &$1, &$3 TSRMLS_CC); } - | expr T_IS_SMALLER_OR_EQUAL expr { zend_do_binary_op(ZEND_IS_SMALLER_OR_EQUAL, &$$, &$1, &$3 TSRMLS_CC); } - | expr '>' expr { zend_do_binary_op(ZEND_IS_SMALLER, &$$, &$3, &$1 TSRMLS_CC); } - | expr T_IS_GREATER_OR_EQUAL expr { zend_do_binary_op(ZEND_IS_SMALLER_OR_EQUAL, &$$, &$3, &$1 TSRMLS_CC); } - | expr T_INSTANCEOF class_name_reference { zend_do_instanceof(&$$, &$1, &$3, 0 TSRMLS_CC); } - | parenthesis_expr { $$ = $1; } - | new_expr { $$ = $1; } - | '(' new_expr ')' { $$ = $2; } instance_call { $$ = $5; } - | expr '?' { zend_do_begin_qm_op(&$1, &$2 TSRMLS_CC); } - expr ':' { zend_do_qm_true(&$4, &$2, &$5 TSRMLS_CC); } - expr { zend_do_qm_false(&$$, &$7, &$2, &$5 TSRMLS_CC); } - | expr '?' ':' { zend_do_jmp_set(&$1, &$2, &$3 TSRMLS_CC); } - expr { zend_do_jmp_set_else(&$$, &$5, &$2, &$3 TSRMLS_CC); } - | internal_functions_in_yacc { $$ = $1; } - | T_INT_CAST expr { zend_do_cast(&$$, &$2, IS_LONG TSRMLS_CC); } - | T_DOUBLE_CAST expr { zend_do_cast(&$$, &$2, IS_DOUBLE TSRMLS_CC); } - | T_STRING_CAST expr { zend_do_cast(&$$, &$2, IS_STRING TSRMLS_CC); } - | T_ARRAY_CAST expr { zend_do_cast(&$$, &$2, IS_ARRAY TSRMLS_CC); } - | T_OBJECT_CAST expr { zend_do_cast(&$$, &$2, IS_OBJECT TSRMLS_CC); } - | T_BOOL_CAST expr { zend_do_cast(&$$, &$2, _IS_BOOL TSRMLS_CC); } - | T_UNSET_CAST expr { zend_do_cast(&$$, &$2, IS_NULL TSRMLS_CC); } - | T_EXIT exit_expr { zend_do_exit(&$$, &$2 TSRMLS_CC); } - | '@' { zend_do_begin_silence(&$1 TSRMLS_CC); } expr { zend_do_end_silence(&$1 TSRMLS_CC); $$ = $3; } - | scalar { $$ = $1; } - | combined_scalar_offset { zend_do_end_variable_parse(&$1, BP_VAR_R, 0 TSRMLS_CC); } - | combined_scalar { $$ = $1; } - | '`' backticks_expr '`' { zend_do_shell_exec(&$$, &$2 TSRMLS_CC); } - | T_PRINT expr { zend_do_print(&$$, &$2 TSRMLS_CC); } - | T_YIELD { zend_do_yield(&$$, NULL, NULL, 0 TSRMLS_CC); } - | function is_reference { zend_do_begin_lambda_function_declaration(&$$, &$1, $2.op_type, 0 TSRMLS_CC); } - '(' parameter_list ')' lexical_vars - '{' inner_statement_list '}' { zend_do_end_function_declaration(&$1 TSRMLS_CC); $$ = $3; } - | T_STATIC function is_reference { zend_do_begin_lambda_function_declaration(&$$, &$2, $3.op_type, 1 TSRMLS_CC); } - '(' parameter_list ')' lexical_vars - '{' inner_statement_list '}' { zend_do_end_function_declaration(&$2 TSRMLS_CC); $$ = $4; } -; - -yield_expr: - T_YIELD expr_without_variable { zend_do_yield(&$$, &$2, NULL, 0 TSRMLS_CC); } - | T_YIELD variable { zend_do_yield(&$$, &$2, NULL, 1 TSRMLS_CC); } - | T_YIELD expr T_DOUBLE_ARROW expr_without_variable { zend_do_yield(&$$, &$4, &$2, 0 TSRMLS_CC); } - | T_YIELD expr T_DOUBLE_ARROW variable { zend_do_yield(&$$, &$4, &$2, 1 TSRMLS_CC); } -; - -combined_scalar_offset: - combined_scalar '[' dim_offset ']' { zend_do_begin_variable_parse(TSRMLS_C); fetch_array_dim(&$$, &$1, &$3 TSRMLS_CC); } - | combined_scalar_offset '[' dim_offset ']' { fetch_array_dim(&$$, &$1, &$3 TSRMLS_CC); } - | T_CONSTANT_ENCAPSED_STRING '[' dim_offset ']' { $1.EA = 0; zend_do_begin_variable_parse(TSRMLS_C); fetch_array_dim(&$$, &$1, &$3 TSRMLS_CC); } - | general_constant '[' dim_offset ']' { zend_do_begin_variable_parse(TSRMLS_C); fetch_array_dim(&$$, &$1, &$3 TSRMLS_CC); } -; - -combined_scalar: - T_ARRAY '(' array_pair_list ')' { $$ = $3; } - | '[' array_pair_list ']' { $$ = $2; } + T_LIST '(' assignment_list ')' '=' expr + { $$.ast = zend_ast_create(ZEND_AST_ASSIGN, $3.ast, $6.ast); } + | variable '=' expr + { $$.ast = zend_ast_create(ZEND_AST_ASSIGN, $1.ast, $3.ast); } + | variable '=' '&' variable + { $$.ast = zend_ast_create(ZEND_AST_ASSIGN_REF, $1.ast, $4.ast); } + | variable '=' '&' T_NEW class_name_reference ctor_arguments + { zend_error(E_DEPRECATED, "Assigning the return value of new by reference is deprecated"); + $$.ast = zend_ast_create(ZEND_AST_ASSIGN_REF, $1.ast, + zend_ast_create(ZEND_AST_NEW, $5.ast, $6.ast)); } + | T_CLONE expr { $$.ast = zend_ast_create(ZEND_AST_CLONE, $2.ast); } + | variable T_PLUS_EQUAL expr + { $$.ast = zend_ast_create_assign_op(ZEND_ASSIGN_ADD, $1.ast, $3.ast); } + | variable T_MINUS_EQUAL expr + { $$.ast = zend_ast_create_assign_op(ZEND_ASSIGN_SUB, $1.ast, $3.ast); } + | variable T_MUL_EQUAL expr + { $$.ast = zend_ast_create_assign_op(ZEND_ASSIGN_MUL, $1.ast, $3.ast); } + | variable T_POW_EQUAL expr + { $$.ast = zend_ast_create_assign_op(ZEND_ASSIGN_POW, $1.ast, $3.ast); } + | variable T_DIV_EQUAL expr + { $$.ast = zend_ast_create_assign_op(ZEND_ASSIGN_DIV, $1.ast, $3.ast); } + | variable T_CONCAT_EQUAL expr + { $$.ast = zend_ast_create_assign_op(ZEND_ASSIGN_CONCAT, $1.ast, $3.ast); } + | variable T_MOD_EQUAL expr + { $$.ast = zend_ast_create_assign_op(ZEND_ASSIGN_MOD, $1.ast, $3.ast); } + | variable T_AND_EQUAL expr + { $$.ast = zend_ast_create_assign_op(ZEND_ASSIGN_BW_AND, $1.ast, $3.ast); } + | variable T_OR_EQUAL expr + { $$.ast = zend_ast_create_assign_op(ZEND_ASSIGN_BW_OR, $1.ast, $3.ast); } + | variable T_XOR_EQUAL expr + { $$.ast = zend_ast_create_assign_op(ZEND_ASSIGN_BW_XOR, $1.ast, $3.ast); } + | variable T_SL_EQUAL expr + { $$.ast = zend_ast_create_assign_op(ZEND_ASSIGN_SL, $1.ast, $3.ast); } + | variable T_SR_EQUAL expr + { $$.ast = zend_ast_create_assign_op(ZEND_ASSIGN_SR, $1.ast, $3.ast); } + | variable T_INC { $$.ast = zend_ast_create(ZEND_AST_POST_INC, $1.ast); } + | T_INC variable { $$.ast = zend_ast_create(ZEND_AST_PRE_INC, $2.ast); } + | variable T_DEC { $$.ast = zend_ast_create(ZEND_AST_POST_DEC, $1.ast); } + | T_DEC variable { $$.ast = zend_ast_create(ZEND_AST_PRE_DEC, $2.ast); } + | expr T_BOOLEAN_OR expr + { $$.ast = zend_ast_create(ZEND_AST_OR, $1.ast, $3.ast); } + | expr T_BOOLEAN_AND expr + { $$.ast = zend_ast_create(ZEND_AST_AND, $1.ast, $3.ast); } + | expr T_LOGICAL_OR expr + { $$.ast = zend_ast_create(ZEND_AST_OR, $1.ast, $3.ast); } + | expr T_LOGICAL_AND expr + { $$.ast = zend_ast_create(ZEND_AST_AND, $1.ast, $3.ast); } + | expr T_LOGICAL_XOR expr + { $$.ast = zend_ast_create_binary_op(ZEND_BOOL_XOR, $1.ast, $3.ast); } + | expr '|' expr { $$.ast = zend_ast_create_binary_op(ZEND_BW_OR, $1.ast, $3.ast); } + | expr '&' expr { $$.ast = zend_ast_create_binary_op(ZEND_BW_AND, $1.ast, $3.ast); } + | expr '^' expr { $$.ast = zend_ast_create_binary_op(ZEND_BW_XOR, $1.ast, $3.ast); } + | expr '.' expr { $$.ast = zend_ast_create_binary_op(ZEND_CONCAT, $1.ast, $3.ast); } + | expr '+' expr { $$.ast = zend_ast_create_binary_op(ZEND_ADD, $1.ast, $3.ast); } + | expr '-' expr { $$.ast = zend_ast_create_binary_op(ZEND_SUB, $1.ast, $3.ast); } + | expr '*' expr { $$.ast = zend_ast_create_binary_op(ZEND_MUL, $1.ast, $3.ast); } + | expr T_POW expr { $$.ast = zend_ast_create_binary_op(ZEND_POW, $1.ast, $3.ast); } + | expr '/' expr { $$.ast = zend_ast_create_binary_op(ZEND_DIV, $1.ast, $3.ast); } + | expr '%' expr { $$.ast = zend_ast_create_binary_op(ZEND_MOD, $1.ast, $3.ast); } + | expr T_SL expr { $$.ast = zend_ast_create_binary_op(ZEND_SL, $1.ast, $3.ast); } + | expr T_SR expr { $$.ast = zend_ast_create_binary_op(ZEND_SR, $1.ast, $3.ast); } + | '+' expr %prec T_INC { $$.ast = zend_ast_create(ZEND_AST_UNARY_PLUS, $2.ast); } + | '-' expr %prec T_INC { $$.ast = zend_ast_create(ZEND_AST_UNARY_MINUS, $2.ast); } + | '!' expr { $$.ast = zend_ast_create_ex(ZEND_AST_UNARY_OP, ZEND_BOOL_NOT, $2.ast); } + | '~' expr { $$.ast = zend_ast_create_ex(ZEND_AST_UNARY_OP, ZEND_BW_NOT, $2.ast); } + | expr T_IS_IDENTICAL expr + { $$.ast = zend_ast_create_binary_op(ZEND_IS_IDENTICAL, $1.ast, $3.ast); } + | expr T_IS_NOT_IDENTICAL expr + { $$.ast = zend_ast_create_binary_op(ZEND_IS_NOT_IDENTICAL, $1.ast, $3.ast); } + | expr T_IS_EQUAL expr + { $$.ast = zend_ast_create_binary_op(ZEND_IS_EQUAL, $1.ast, $3.ast); } + | expr T_IS_NOT_EQUAL expr + { $$.ast = zend_ast_create_binary_op(ZEND_IS_NOT_EQUAL, $1.ast, $3.ast); } + | expr '<' expr + { $$.ast = zend_ast_create_binary_op(ZEND_IS_SMALLER, $1.ast, $3.ast); } + | expr T_IS_SMALLER_OR_EQUAL expr + { $$.ast = zend_ast_create_binary_op(ZEND_IS_SMALLER_OR_EQUAL, $1.ast, $3.ast); } + | expr '>' expr + { $$.ast = zend_ast_create(ZEND_AST_GREATER, $1.ast, $3.ast); } + | expr T_IS_GREATER_OR_EQUAL expr + { $$.ast = zend_ast_create(ZEND_AST_GREATER_EQUAL, $1.ast, $3.ast); } + | expr T_INSTANCEOF class_name_reference + { $$.ast = zend_ast_create(ZEND_AST_INSTANCEOF, $1.ast, $3.ast); } + | parenthesis_expr { $$.ast = $1.ast; } + | new_expr { $$.ast = $1.ast; } + | expr '?' expr ':' expr + { $$.ast = zend_ast_create(ZEND_AST_CONDITIONAL, $1.ast, $3.ast, $5.ast); } + | expr '?' ':' expr + { $$.ast = zend_ast_create(ZEND_AST_CONDITIONAL, $1.ast, NULL, $4.ast); } + | internal_functions_in_yacc { $$.ast = $1.ast; } + | T_INT_CAST expr + { $$.ast = zend_ast_create_cast(IS_LONG, $2.ast); } + | T_DOUBLE_CAST expr + { $$.ast = zend_ast_create_cast(IS_DOUBLE, $2.ast); } + | T_STRING_CAST expr + { $$.ast = zend_ast_create_cast(IS_STRING, $2.ast); } + | T_ARRAY_CAST expr + { $$.ast = zend_ast_create_cast(IS_ARRAY, $2.ast); } + | T_OBJECT_CAST expr + { $$.ast = zend_ast_create_cast(IS_OBJECT, $2.ast); } + | T_BOOL_CAST expr + { $$.ast = zend_ast_create_cast(_IS_BOOL, $2.ast); } + | T_UNSET_CAST expr + { $$.ast = zend_ast_create_cast(IS_NULL, $2.ast); } + | T_EXIT exit_expr { $$.ast = zend_ast_create(ZEND_AST_EXIT, $2.ast); } + | '@' expr { $$.ast = zend_ast_create(ZEND_AST_SILENCE, $2.ast); } + | scalar { $$.ast = $1.ast; } + | '`' backticks_expr '`' { $$.ast = zend_ast_create(ZEND_AST_SHELL_EXEC, $2.ast); } + | T_PRINT expr { $$.ast = zend_ast_create(ZEND_AST_PRINT, $2.ast); } + | T_YIELD { $$.ast = zend_ast_create(ZEND_AST_YIELD, NULL, NULL); } + | T_YIELD expr { $$.ast = zend_ast_create(ZEND_AST_YIELD, $2.ast, NULL); } + | T_YIELD expr T_DOUBLE_ARROW expr + { $$.ast = zend_ast_create(ZEND_AST_YIELD, $4.ast, $2.ast); } + | function returns_ref '(' parameter_list ')' lexical_vars + { $$.str = CG(doc_comment); CG(doc_comment) = NULL; } + '{' inner_statement_list '}' + { $$.ast = zend_ast_create_decl(ZEND_AST_CLOSURE, $2.num, $1.num, $7.str, + zend_string_init("{closure}", sizeof("{closure}") - 1, 0), + $4.ast, $6.ast, $9.ast); } + | T_STATIC function returns_ref '(' parameter_list ')' lexical_vars + { $$.str = CG(doc_comment); CG(doc_comment) = NULL; } + '{' inner_statement_list '}' + { $$.ast = zend_ast_create_decl(ZEND_AST_CLOSURE, $3.num | ZEND_ACC_STATIC, $2.num, + $8.str, zend_string_init("{closure}", sizeof("{closure}") - 1, 0), + $5.ast, $7.ast, $10.ast); } ; function: - T_FUNCTION { $$.u.op.opline_num = CG(zend_lineno); } + T_FUNCTION { $$.num = CG(zend_lineno); } +; + +returns_ref: + /* empty */ { $$.num = 0; } + | '&' { $$.num = ZEND_ACC_RETURN_REFERENCE; } ; lexical_vars: - /* empty */ - | T_USE '(' lexical_var_list ')' + /* empty */ { $$.ast = NULL; } + | T_USE '(' lexical_var_list ')' { $$.ast = $3.ast; } ; lexical_var_list: - lexical_var_list ',' T_VARIABLE { zend_do_fetch_lexical_variable(&$3, 0 TSRMLS_CC); } - | lexical_var_list ',' '&' T_VARIABLE { zend_do_fetch_lexical_variable(&$4, 1 TSRMLS_CC); } - | T_VARIABLE { zend_do_fetch_lexical_variable(&$1, 0 TSRMLS_CC); } - | '&' T_VARIABLE { zend_do_fetch_lexical_variable(&$2, 1 TSRMLS_CC); } + lexical_var_list ',' lexical_var { $$.list = zend_ast_list_add($1.list, $3.ast); } + | lexical_var { $$.list = zend_ast_create_list(1, ZEND_AST_CLOSURE_USES, $1.ast); } ; -function_call: - namespace_name { $$.u.op.opline_num = zend_do_begin_function_call(&$1, 1 TSRMLS_CC); } - function_call_parameter_list { zend_do_end_function_call(&$1, &$$, 0, $2.u.op.opline_num TSRMLS_CC); zend_do_extended_fcall_end(TSRMLS_C); } - | T_NAMESPACE T_NS_SEPARATOR namespace_name { $1.op_type = IS_CONST; ZVAL_EMPTY_STRING(&$1.u.constant); zend_do_build_namespace_name(&$1, &$1, &$3 TSRMLS_CC); $$.u.op.opline_num = zend_do_begin_function_call(&$1, 0 TSRMLS_CC); } - function_call_parameter_list { zend_do_end_function_call(&$1, &$$, 0, $4.u.op.opline_num TSRMLS_CC); zend_do_extended_fcall_end(TSRMLS_C); } - | T_NS_SEPARATOR namespace_name { $$.u.op.opline_num = zend_do_begin_function_call(&$2, 0 TSRMLS_CC); } - function_call_parameter_list { zend_do_end_function_call(&$2, &$$, 0, $3.u.op.opline_num TSRMLS_CC); zend_do_extended_fcall_end(TSRMLS_C); } - | class_name T_PAAMAYIM_NEKUDOTAYIM variable_name { $$.u.op.opline_num = zend_do_begin_class_member_function_call(&$1, &$3 TSRMLS_CC); } - function_call_parameter_list { zend_do_end_function_call($4.u.op.opline_num?NULL:&$3, &$$, $4.u.op.opline_num, $4.u.op.opline_num TSRMLS_CC); zend_do_extended_fcall_end(TSRMLS_C);} - | class_name T_PAAMAYIM_NEKUDOTAYIM variable_without_objects { zend_do_end_variable_parse(&$3, BP_VAR_R, 0 TSRMLS_CC); zend_do_begin_class_member_function_call(&$1, &$3 TSRMLS_CC); } - function_call_parameter_list { zend_do_end_function_call(NULL, &$$, 1, 1 TSRMLS_CC); zend_do_extended_fcall_end(TSRMLS_C);} - | variable_class_name T_PAAMAYIM_NEKUDOTAYIM variable_name { zend_do_begin_class_member_function_call(&$1, &$3 TSRMLS_CC); } - function_call_parameter_list { zend_do_end_function_call(NULL, &$$, 1, 1 TSRMLS_CC); zend_do_extended_fcall_end(TSRMLS_C);} - | variable_class_name T_PAAMAYIM_NEKUDOTAYIM variable_without_objects { zend_do_end_variable_parse(&$3, BP_VAR_R, 0 TSRMLS_CC); zend_do_begin_class_member_function_call(&$1, &$3 TSRMLS_CC); } - function_call_parameter_list { zend_do_end_function_call(NULL, &$$, 1, 1 TSRMLS_CC); zend_do_extended_fcall_end(TSRMLS_C);} - | variable_without_objects { zend_do_end_variable_parse(&$1, BP_VAR_R, 0 TSRMLS_CC); zend_do_begin_dynamic_function_call(&$1, 0 TSRMLS_CC); } - function_call_parameter_list { zend_do_end_function_call(&$1, &$$, 0, 1 TSRMLS_CC); zend_do_extended_fcall_end(TSRMLS_C);} +lexical_var: + T_VARIABLE { $$.ast = $1.ast; } + | '&' T_VARIABLE { $$.ast = $2.ast; $$.ast->attr = 1; } ; -class_name: - T_STATIC { $$.op_type = IS_CONST; ZVAL_STRINGL(&$$.u.constant, "static", sizeof("static")-1);} - | namespace_name { $$ = $1; } - | T_NAMESPACE T_NS_SEPARATOR namespace_name { $$.op_type = IS_CONST; ZVAL_EMPTY_STRING(&$$.u.constant); zend_do_build_namespace_name(&$$, &$$, &$3 TSRMLS_CC); } - | T_NS_SEPARATOR namespace_name { zval tmp; ZVAL_NEW_STR(&tmp, zend_string_alloc(Z_STRLEN($2.u.constant)+1, 0)); Z_STRVAL(tmp)[0] = '\\'; memcpy(Z_STRVAL(tmp) + 1, Z_STRVAL($2.u.constant), Z_STRLEN($2.u.constant)+1); if (Z_DELREF($2.u.constant) == 0) {efree(Z_STR($2.u.constant));} Z_STR($2.u.constant) = Z_STR(tmp); $$ = $2; } +function_call: + name argument_list + { $$.ast = zend_ast_create(ZEND_AST_CALL, $1.ast, $2.ast); } + | class_name T_PAAMAYIM_NEKUDOTAYIM member_name argument_list + { $$.ast = zend_ast_create(ZEND_AST_STATIC_CALL, + $1.ast, $3.ast, $4.ast); } + | variable_class_name T_PAAMAYIM_NEKUDOTAYIM member_name argument_list + { $$.ast = zend_ast_create(ZEND_AST_STATIC_CALL, + $1.ast, $3.ast, $4.ast); } + | callable_expr argument_list + { $$.ast = zend_ast_create(ZEND_AST_CALL, $1.ast, $2.ast); } ; -fully_qualified_class_name: - namespace_name { $$ = $1; } - | T_NAMESPACE T_NS_SEPARATOR namespace_name { $$.op_type = IS_CONST; ZVAL_EMPTY_STRING(&$$.u.constant); zend_do_build_namespace_name(&$$, &$$, &$3 TSRMLS_CC); } - | T_NS_SEPARATOR namespace_name { zval tmp; ZVAL_NEW_STR(&tmp, zend_string_alloc(Z_STRLEN($2.u.constant)+1, 0)); Z_STRVAL(tmp)[0] = '\\'; memcpy(Z_STRVAL(tmp) + 1, Z_STRVAL($2.u.constant), Z_STRLEN($2.u.constant)+1); if (Z_DELREF($2.u.constant) == 0) {efree(Z_STR($2.u.constant));} Z_STR($2.u.constant) = Z_STR(tmp); $$ = $2; } +class_name: + T_STATIC + { zval zv; ZVAL_STRINGL(&zv, "static", sizeof("static")-1); + $$.ast = zend_ast_create_zval_ex(&zv, ZEND_NAME_NOT_FQ); } + | name { $$.ast = $1.ast; } ; - - class_name_reference: - class_name { zend_do_fetch_class(&$$, &$1 TSRMLS_CC); } - | dynamic_class_name_reference { zend_do_end_variable_parse(&$1, BP_VAR_R, 0 TSRMLS_CC); zend_do_fetch_class(&$$, &$1 TSRMLS_CC); } -; - - -dynamic_class_name_reference: - base_variable T_OBJECT_OPERATOR { zend_do_push_object(&$1 TSRMLS_CC); } - object_property { zend_do_push_object(&$4 TSRMLS_CC); } dynamic_class_name_variable_properties - { zend_do_pop_object(&$$ TSRMLS_CC); $$.EA = ZEND_PARSED_MEMBER; } - | base_variable { $$ = $1; } -; - - -dynamic_class_name_variable_properties: - dynamic_class_name_variable_properties dynamic_class_name_variable_property - | /* empty */ -; - - -dynamic_class_name_variable_property: - T_OBJECT_OPERATOR object_property { zend_do_push_object(&$2 TSRMLS_CC); } + class_name { $$.ast = $1.ast; } + | new_variable { $$.ast = $1.ast; } ; exit_expr: - /* empty */ { memset(&$$, 0, sizeof(znode)); $$.op_type = IS_UNUSED; } - | '(' ')' { memset(&$$, 0, sizeof(znode)); $$.op_type = IS_UNUSED; } - | parenthesis_expr { $$ = $1; } + /* empty */ { $$.ast = NULL; } + | '(' ')' { $$.ast = NULL; } + | parenthesis_expr { $$.ast = $1.ast; } ; backticks_expr: - /* empty */ { ZVAL_EMPTY_STRING(&$$.u.constant); $$.op_type = IS_CONST; } - | T_ENCAPSED_AND_WHITESPACE { $$ = $1; } - | encaps_list { $$ = $1; } + /* empty */ + { $$.ast = zend_ast_create_zval_from_str(STR_EMPTY_ALLOC()); } + | T_ENCAPSED_AND_WHITESPACE { $$.ast = $1.ast; } + | encaps_list { $$.ast = $1.ast; } ; ctor_arguments: - /* empty */ { Z_LVAL($$.u.constant) = 0; } - | function_call_parameter_list { $$ = $1; } -; - - -common_scalar: - T_LNUMBER { $$ = $1; } - | T_DNUMBER { $$ = $1; } - | T_CONSTANT_ENCAPSED_STRING { $$ = $1; } - | T_LINE { $$ = $1; } - | T_FILE { $$ = $1; } - | T_DIR { $$ = $1; } - | T_TRAIT_C { $$ = $1; } - | T_METHOD_C { $$ = $1; } - | T_FUNC_C { $$ = $1; } - | T_NS_C { $$ = $1; } - | T_START_HEREDOC T_ENCAPSED_AND_WHITESPACE T_END_HEREDOC { $$ = $2; } - | T_START_HEREDOC T_END_HEREDOC { ZVAL_EMPTY_STRING(&$$.u.constant); $$.op_type = IS_CONST; } -; - -static_class_constant: - class_name T_PAAMAYIM_NEKUDOTAYIM T_STRING { zend_do_fetch_constant(&$$, &$1, &$3, ZEND_CT, 0 TSRMLS_CC); } -; - -static_scalar: /* compile-time evaluated scalars */ - static_scalar_value { zend_do_constant_expression(&$$, $1.u.ast TSRMLS_CC); } -; - -static_scalar_value: - common_scalar { $$.u.ast = zend_ast_create_constant(&$1.u.constant); } - | static_class_name_scalar { $$.u.ast = zend_ast_create_constant(&$1.u.constant); } - | namespace_name { zend_do_fetch_constant(&$$, NULL, &$1, ZEND_CT, 1 TSRMLS_CC); $$.u.ast = zend_ast_create_constant(&$$.u.constant); } - | T_NAMESPACE T_NS_SEPARATOR namespace_name { $$.op_type = IS_CONST; ZVAL_EMPTY_STRING(&$$.u.constant); zend_do_build_namespace_name(&$$, &$$, &$3 TSRMLS_CC); $3 = $$; zend_do_fetch_constant(&$$, NULL, &$3, ZEND_CT, 0 TSRMLS_CC); $$.u.ast = zend_ast_create_constant(&$$.u.constant); } - | T_NS_SEPARATOR namespace_name { zval tmp; ZVAL_NEW_STR(&tmp, zend_string_alloc(Z_STRLEN($2.u.constant)+1, 0)); Z_STRVAL(tmp)[0] = '\\'; memcpy(Z_STRVAL(tmp) + 1, Z_STRVAL($2.u.constant), Z_STRLEN($2.u.constant)+1); if (Z_DELREF($2.u.constant) == 0) {efree(Z_STR($2.u.constant));} Z_STR($2.u.constant) = Z_STR(tmp); zend_do_fetch_constant(&$$, NULL, &$2, ZEND_CT, 0 TSRMLS_CC); $$.u.ast = zend_ast_create_constant(&$$.u.constant); } - | T_ARRAY '(' static_array_pair_list ')' { $$ = $3; } - | '[' static_array_pair_list ']' { $$ = $2; } - | static_class_constant { $$.u.ast = zend_ast_create_constant(&$1.u.constant); } - | T_CLASS_C { $$.u.ast = zend_ast_create_constant(&$1.u.constant); } - | static_operation { $$ = $1; } -; - -static_operation: - static_scalar_value '[' static_scalar_value ']' { $$.u.ast = zend_ast_create_binary(ZEND_FETCH_DIM_R, $1.u.ast, $3.u.ast); } - | static_scalar_value '+' static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_ADD, $1.u.ast, $3.u.ast); } - | static_scalar_value '-' static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_SUB, $1.u.ast, $3.u.ast); } - | static_scalar_value '*' static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_MUL, $1.u.ast, $3.u.ast); } - | static_scalar_value T_POW static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_POW, $1.u.ast, $3.u.ast); } - | static_scalar_value '/' static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_DIV, $1.u.ast, $3.u.ast); } - | static_scalar_value '%' static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_MOD, $1.u.ast, $3.u.ast); } - | '!' static_scalar_value { $$.u.ast = zend_ast_create_unary(ZEND_BOOL_NOT, $2.u.ast); } - | '~' static_scalar_value { $$.u.ast = zend_ast_create_unary(ZEND_BW_NOT, $2.u.ast); } - | static_scalar_value '|' static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_BW_OR, $1.u.ast, $3.u.ast); } - | static_scalar_value '&' static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_BW_AND, $1.u.ast, $3.u.ast); } - | static_scalar_value '^' static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_BW_XOR, $1.u.ast, $3.u.ast); } - | static_scalar_value T_SL static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_SL, $1.u.ast, $3.u.ast); } - | static_scalar_value T_SR static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_SR, $1.u.ast, $3.u.ast); } - | static_scalar_value '.' static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_CONCAT, $1.u.ast, $3.u.ast); } - | static_scalar_value T_LOGICAL_XOR static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_BOOL_XOR, $1.u.ast, $3.u.ast); } - | static_scalar_value T_LOGICAL_AND static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_BOOL_AND, $1.u.ast, $3.u.ast); } - | static_scalar_value T_LOGICAL_OR static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_BOOL_OR, $1.u.ast, $3.u.ast); } - | static_scalar_value T_BOOLEAN_AND static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_BOOL_AND, $1.u.ast, $3.u.ast); } - | static_scalar_value T_BOOLEAN_OR static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_BOOL_OR, $1.u.ast, $3.u.ast); } - | static_scalar_value T_IS_IDENTICAL static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_IS_IDENTICAL, $1.u.ast, $3.u.ast); } - | static_scalar_value T_IS_NOT_IDENTICAL static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_IS_NOT_IDENTICAL, $1.u.ast, $3.u.ast); } - | static_scalar_value T_IS_EQUAL static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_IS_EQUAL, $1.u.ast, $3.u.ast); } - | static_scalar_value T_IS_NOT_EQUAL static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_IS_NOT_EQUAL, $1.u.ast, $3.u.ast); } - | static_scalar_value '<' static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_IS_SMALLER, $1.u.ast, $3.u.ast); } - | static_scalar_value '>' static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_IS_SMALLER, $3.u.ast, $1.u.ast); } - | static_scalar_value T_IS_SMALLER_OR_EQUAL static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_IS_SMALLER_OR_EQUAL, $1.u.ast, $3.u.ast); } - | static_scalar_value T_IS_GREATER_OR_EQUAL static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_IS_SMALLER_OR_EQUAL, $3.u.ast, $1.u.ast); } - | static_scalar_value '?' ':' static_scalar_value { $$.u.ast = zend_ast_create_ternary(ZEND_SELECT, $1.u.ast, NULL, $4.u.ast); } - | static_scalar_value '?' static_scalar_value ':' static_scalar_value { $$.u.ast = zend_ast_create_ternary(ZEND_SELECT, $1.u.ast, $3.u.ast, $5.u.ast); } - | '+' static_scalar_value { $$.u.ast = zend_ast_create_unary(ZEND_UNARY_PLUS, $2.u.ast); } - | '-' static_scalar_value { $$.u.ast = zend_ast_create_unary(ZEND_UNARY_MINUS, $2.u.ast); } - | '(' static_scalar_value ')' { $$ = $2; } -; - -general_constant: - class_constant { $$ = $1; } - | namespace_name { zend_do_fetch_constant(&$$, NULL, &$1, ZEND_RT, 1 TSRMLS_CC); } - | T_NAMESPACE T_NS_SEPARATOR namespace_name { $$.op_type = IS_CONST; ZVAL_EMPTY_STRING(&$$.u.constant); zend_do_build_namespace_name(&$$, &$$, &$3 TSRMLS_CC); $3 = $$; zend_do_fetch_constant(&$$, NULL, &$3, ZEND_RT, 0 TSRMLS_CC); } - | T_NS_SEPARATOR namespace_name { zval tmp; ZVAL_NEW_STR(&tmp, zend_string_alloc(Z_STRLEN($2.u.constant)+1, 0)); Z_STRVAL(tmp)[0] = '\\'; memcpy(Z_STRVAL(tmp) + 1, Z_STRVAL($2.u.constant), Z_STRLEN($2.u.constant)+1); if (Z_DELREF($2.u.constant) == 0) {efree(Z_STR($2.u.constant));} Z_STR($2.u.constant) = Z_STR(tmp); zend_do_fetch_constant(&$$, NULL, &$2, ZEND_RT, 0 TSRMLS_CC); } + /* empty */ { $$.list = zend_ast_create_list(0, ZEND_AST_ARG_LIST); } + | argument_list { $$.ast = $1.ast; } ; -scalar: - T_STRING_VARNAME { $$ = $1; } - | general_constant { $$ = $1; } - | class_name_scalar { $$ = $1; } - | common_scalar { $$ = $1; } - | '"' encaps_list '"' { $$ = $2; } - | T_START_HEREDOC encaps_list T_END_HEREDOC { $$ = $2; } - | T_CLASS_C { if (Z_TYPE($1.u.constant) == IS_CONSTANT) {zend_do_fetch_constant(&$$, NULL, &$1, ZEND_RT, 1 TSRMLS_CC);} else {$$ = $1;} } + +dereferencable_scalar: + T_ARRAY '(' array_pair_list ')' { $$.ast = $3.ast; } + | '[' array_pair_list ']' { $$.ast = $2.ast; } + | T_CONSTANT_ENCAPSED_STRING { $$.ast = $1.ast; } ; -static_array_pair_list: - /* empty */ { $$.op_type = IS_CONST; array_init(&$$.u.constant); $$.u.ast = zend_ast_create_constant(&$$.u.constant); } - | non_empty_static_array_pair_list possible_comma { zend_ast_dynamic_shrink(&$1.u.ast); $$ = $1; } +scalar: + T_LNUMBER { $$.ast = $1.ast; } + | T_DNUMBER { $$.ast = $1.ast; } + | T_LINE { $$.ast = $1.ast; } + | T_FILE { $$.ast = $1.ast; } + | T_DIR { $$.ast = $1.ast; } + | T_TRAIT_C { $$.ast = zend_ast_create_ex(ZEND_AST_MAGIC_CONST, T_TRAIT_C); } + | T_METHOD_C { $$.ast = zend_ast_create_ex(ZEND_AST_MAGIC_CONST, T_METHOD_C); } + | T_FUNC_C { $$.ast = zend_ast_create_ex(ZEND_AST_MAGIC_CONST, T_FUNC_C); } + | T_NS_C { $$.ast = zend_ast_create_ex(ZEND_AST_MAGIC_CONST, T_NS_C); } + | T_CLASS_C { $$.ast = zend_ast_create_ex(ZEND_AST_MAGIC_CONST, T_CLASS_C); } + | T_START_HEREDOC T_ENCAPSED_AND_WHITESPACE T_END_HEREDOC { $$.ast = $2.ast; } + | T_START_HEREDOC T_END_HEREDOC + { $$.ast = zend_ast_create_zval_from_str(STR_EMPTY_ALLOC()); } + | '"' encaps_list '"' { $$.ast = $2.ast; } + | T_START_HEREDOC encaps_list T_END_HEREDOC { $$.ast = $2.ast; } + | dereferencable_scalar { $$.ast = $1.ast; } + | class_name_scalar { $$.ast = $1.ast; } + | constant { $$.ast = $1.ast; } +; + +constant: + name { $$.ast = zend_ast_create(ZEND_AST_CONST, $1.ast); } + | class_name T_PAAMAYIM_NEKUDOTAYIM T_STRING + { $$.ast = zend_ast_create(ZEND_AST_CLASS_CONST, $1.ast, $3.ast); } + | variable_class_name T_PAAMAYIM_NEKUDOTAYIM T_STRING + { $$.ast = zend_ast_create(ZEND_AST_CLASS_CONST, $1.ast, $3.ast); } ; possible_comma: @@ -1068,232 +983,197 @@ possible_comma: | ',' ; -non_empty_static_array_pair_list: - non_empty_static_array_pair_list ',' static_scalar_value T_DOUBLE_ARROW static_scalar_value { zend_ast_dynamic_add(&$$.u.ast, $3.u.ast); zend_ast_dynamic_add(&$$.u.ast, $5.u.ast); } - | non_empty_static_array_pair_list ',' static_scalar_value { zend_ast_dynamic_add(&$$.u.ast, NULL); zend_ast_dynamic_add(&$$.u.ast, $3.u.ast); } - | static_scalar_value T_DOUBLE_ARROW static_scalar_value { $$.u.ast = zend_ast_create_dynamic(ZEND_INIT_ARRAY); zend_ast_dynamic_add(&$$.u.ast, $1.u.ast); zend_ast_dynamic_add(&$$.u.ast, $3.u.ast); } - | static_scalar_value { $$.u.ast = zend_ast_create_dynamic(ZEND_INIT_ARRAY); zend_ast_dynamic_add(&$$.u.ast, NULL); zend_ast_dynamic_add(&$$.u.ast, $1.u.ast); } -; - expr: - r_variable { $$ = $1; } - | expr_without_variable { $$ = $1; } + variable { $$.ast = $1.ast; } + | expr_without_variable { $$.ast = $1.ast; } ; parenthesis_expr: - '(' expr ')' { $$ = $2; } - | '(' yield_expr ')' { $$ = $2; } + '(' expr ')' { $$.ast = $2.ast; } ; - -r_variable: - variable { zend_do_end_variable_parse(&$1, BP_VAR_R, 0 TSRMLS_CC); $$ = $1; } -; - - -w_variable: - variable { zend_do_end_variable_parse(&$1, BP_VAR_W, 0 TSRMLS_CC); $$ = $1; - zend_check_writable_variable(&$1); } -; - -rw_variable: - variable { zend_do_end_variable_parse(&$1, BP_VAR_RW, 0 TSRMLS_CC); $$ = $1; - zend_check_writable_variable(&$1); } -; - -variable: - base_variable_with_function_calls T_OBJECT_OPERATOR { zend_do_push_object(&$1 TSRMLS_CC); } - object_property { zend_do_push_object(&$4 TSRMLS_CC); } method_or_not variable_properties - { zend_do_pop_object(&$$ TSRMLS_CC); $$.EA = $1.EA | ($7.EA ? $7.EA : $6.EA); } - | base_variable_with_function_calls { $$ = $1; } -; - -variable_properties: - variable_properties variable_property { $$.EA = $2.EA; } - | /* empty */ { $$.EA = 0; } +variable_class_name: + dereferencable { $$.ast = $1.ast; } ; - -variable_property: - T_OBJECT_OPERATOR object_property { zend_do_push_object(&$2 TSRMLS_CC); } method_or_not { $$.EA = $4.EA; } +dereferencable: + variable { $$.ast = $1.ast; } + | '(' expr ')' { $$.ast = $2.ast; } + | dereferencable_scalar { $$.ast = $1.ast; } ; -array_method_dereference: - array_method_dereference '[' dim_offset ']' { fetch_array_dim(&$$, &$1, &$3 TSRMLS_CC); } - | method '[' dim_offset ']' { $1.EA = ZEND_PARSED_METHOD_CALL; fetch_array_dim(&$$, &$1, &$3 TSRMLS_CC); } +callable_expr: + callable_variable { $$.ast = $1.ast; } + | '(' expr ')' { $$.ast = $2.ast; } + | dereferencable_scalar { $$.ast = $1.ast; } ; -method: - { zend_do_pop_object(&$$ TSRMLS_CC); zend_do_begin_method_call(&$$ TSRMLS_CC); } - function_call_parameter_list { zend_do_end_function_call(&$1, &$$, 1, 1 TSRMLS_CC); zend_do_extended_fcall_end(TSRMLS_C); } +callable_variable: + simple_variable + { $$.ast = zend_ast_create(ZEND_AST_VAR, $1.ast); } + | dereferencable '[' dim_offset ']' + { $$.ast = zend_ast_create(ZEND_AST_DIM, $1.ast, $3.ast); } + | constant '[' dim_offset ']' + { $$.ast = zend_ast_create(ZEND_AST_DIM, $1.ast, $3.ast); } + | dereferencable '{' expr '}' + { $$.ast = zend_ast_create(ZEND_AST_DIM, $1.ast, $3.ast); } + | dereferencable T_OBJECT_OPERATOR member_name argument_list + { $$.ast = zend_ast_create(ZEND_AST_METHOD_CALL, $1.ast, $3.ast, $4.ast); } + | function_call { $$.ast = $1.ast; } ; -method_or_not: - method { $$ = $1; $$.EA = ZEND_PARSED_METHOD_CALL; zend_do_push_object(&$$ TSRMLS_CC); } - | array_method_dereference { $$ = $1; zend_do_push_object(&$$ TSRMLS_CC); } - | /* empty */ { $$.EA = ZEND_PARSED_MEMBER; } +variable: + callable_variable + { $$.ast = $1.ast; } + | static_member + { $$.ast = $1.ast; } + | dereferencable T_OBJECT_OPERATOR member_name + { $$.ast = zend_ast_create(ZEND_AST_PROP, $1.ast, $3.ast); } ; -variable_without_objects: - reference_variable { $$ = $1; } - | simple_indirect_reference reference_variable { zend_do_indirect_references(&$$, &$1, &$2 TSRMLS_CC); } +simple_variable: + T_VARIABLE + { $$.ast = $1.ast; } + | '$' '{' expr '}' + { $$.ast = $3.ast; } + | '$' simple_variable + { $$.ast = zend_ast_create(ZEND_AST_VAR, $2.ast); } ; static_member: - class_name T_PAAMAYIM_NEKUDOTAYIM variable_without_objects { $$ = $3; zend_do_fetch_static_member(&$$, &$1 TSRMLS_CC); } - | variable_class_name T_PAAMAYIM_NEKUDOTAYIM variable_without_objects { $$ = $3; zend_do_fetch_static_member(&$$, &$1 TSRMLS_CC); } - -; - -variable_class_name: - reference_variable { zend_do_end_variable_parse(&$1, BP_VAR_R, 0 TSRMLS_CC); $$=$1;; } -; - -array_function_dereference: - array_function_dereference '[' dim_offset ']' { fetch_array_dim(&$$, &$1, &$3 TSRMLS_CC); } - | function_call { zend_do_begin_variable_parse(TSRMLS_C); $1.EA = ZEND_PARSED_FUNCTION_CALL; } - '[' dim_offset ']' { fetch_array_dim(&$$, &$1, &$4 TSRMLS_CC); } -; - -base_variable_with_function_calls: - base_variable { $$ = $1; } - | array_function_dereference { $$ = $1; } - | function_call { zend_do_begin_variable_parse(TSRMLS_C); $$ = $1; $$.EA = ZEND_PARSED_FUNCTION_CALL; } -; - - -base_variable: - reference_variable { $$ = $1; $$.EA = ZEND_PARSED_VARIABLE; } - | simple_indirect_reference reference_variable { zend_do_indirect_references(&$$, &$1, &$2 TSRMLS_CC); $$.EA = ZEND_PARSED_VARIABLE; } - | static_member { $$ = $1; $$.EA = ZEND_PARSED_STATIC_MEMBER; } -; - -reference_variable: - reference_variable '[' dim_offset ']' { fetch_array_dim(&$$, &$1, &$3 TSRMLS_CC); } - | reference_variable '{' expr '}' { fetch_string_offset(&$$, &$1, &$3 TSRMLS_CC); } - | compound_variable { zend_do_begin_variable_parse(TSRMLS_C); fetch_simple_variable(&$$, &$1, 1 TSRMLS_CC); } -; - - -compound_variable: - T_VARIABLE { $$ = $1; } - | '$' '{' expr '}' { $$ = $3; } + class_name T_PAAMAYIM_NEKUDOTAYIM simple_variable + { $$.ast = zend_ast_create(ZEND_AST_STATIC_PROP, $1.ast, $3.ast); } + | variable_class_name T_PAAMAYIM_NEKUDOTAYIM simple_variable + { $$.ast = zend_ast_create(ZEND_AST_STATIC_PROP, $1.ast, $3.ast); } +; + +new_variable: + simple_variable + { $$.ast = zend_ast_create(ZEND_AST_VAR, $1.ast); } + | new_variable '[' dim_offset ']' + { $$.ast = zend_ast_create(ZEND_AST_DIM, $1.ast, $3.ast); } + | new_variable '{' expr '}' + { $$.ast = zend_ast_create(ZEND_AST_DIM, $1.ast, $3.ast); } + | new_variable T_OBJECT_OPERATOR member_name + { $$.ast = zend_ast_create(ZEND_AST_PROP, $1.ast, $3.ast); } + | class_name T_PAAMAYIM_NEKUDOTAYIM simple_variable + { $$.ast = zend_ast_create(ZEND_AST_STATIC_PROP, $1.ast, $3.ast); } + | new_variable T_PAAMAYIM_NEKUDOTAYIM simple_variable + { $$.ast = zend_ast_create(ZEND_AST_STATIC_PROP, $1.ast, $3.ast); } ; dim_offset: - /* empty */ { $$.op_type = IS_UNUSED; } - | expr { $$ = $1; } + /* empty */ { $$.ast = NULL; } + | expr { $$.ast = $1.ast; } ; - -object_property: - object_dim_list { $$ = $1; } - | variable_without_objects { zend_do_end_variable_parse(&$1, BP_VAR_R, 0 TSRMLS_CC); } { znode tmp_znode; zend_do_pop_object(&tmp_znode TSRMLS_CC); zend_do_fetch_property(&$$, &tmp_znode, &$1 TSRMLS_CC);} -; - -object_dim_list: - object_dim_list '[' dim_offset ']' { fetch_array_dim(&$$, &$1, &$3 TSRMLS_CC); } - | object_dim_list '{' expr '}' { fetch_string_offset(&$$, &$1, &$3 TSRMLS_CC); } - | variable_name { znode tmp_znode; zend_do_pop_object(&tmp_znode TSRMLS_CC); zend_do_fetch_property(&$$, &tmp_znode, &$1 TSRMLS_CC);} -; - -variable_name: - T_STRING { $$ = $1; } - | '{' expr '}' { $$ = $2; } -; - -simple_indirect_reference: - '$' { Z_LVAL($$.u.constant) = 1; } - | simple_indirect_reference '$' { Z_LVAL($$.u.constant)++; } +member_name: + T_STRING { $$.ast = $1.ast; } + | '{' expr '}' { $$.ast = $2.ast; } + | simple_variable { $$.ast = zend_ast_create(ZEND_AST_VAR, $1.ast); } ; assignment_list: assignment_list ',' assignment_list_element + { $$.list = zend_ast_list_add($1.list, $3.ast); } | assignment_list_element + { $$.list = zend_ast_create_list(1, ZEND_AST_LIST, $1.ast); } ; - assignment_list_element: - variable { zend_do_add_list_element(&$1 TSRMLS_CC); } - | T_LIST '(' { zend_do_new_list_begin(TSRMLS_C); } assignment_list ')' { zend_do_new_list_end(TSRMLS_C); } - | /* empty */ { zend_do_add_list_element(NULL TSRMLS_CC); } + variable { $$.ast = $1.ast; } + | T_LIST '(' assignment_list ')' { $$.ast = $3.ast; } + | /* empty */ { $$.ast = NULL; } ; array_pair_list: - /* empty */ { zend_do_init_array(&$$, NULL, NULL, 0 TSRMLS_CC); zend_do_end_array(&$$, &$$ TSRMLS_CC); } - | non_empty_array_pair_list possible_comma { zend_do_end_array(&$$, &$1 TSRMLS_CC); } + /* empty */ { $$.list = zend_ast_create_list(0, ZEND_AST_ARRAY); } + | non_empty_array_pair_list possible_comma { $$.ast = $1.ast; } ; non_empty_array_pair_list: - non_empty_array_pair_list ',' expr T_DOUBLE_ARROW expr { zend_do_add_array_element(&$$, &$5, &$3, 0 TSRMLS_CC); } - | non_empty_array_pair_list ',' expr { zend_do_add_array_element(&$$, &$3, NULL, 0 TSRMLS_CC); } - | expr T_DOUBLE_ARROW expr { zend_do_init_array(&$$, &$3, &$1, 0 TSRMLS_CC); } - | expr { zend_do_init_array(&$$, &$1, NULL, 0 TSRMLS_CC); } - | non_empty_array_pair_list ',' expr T_DOUBLE_ARROW '&' w_variable { zend_do_add_array_element(&$$, &$6, &$3, 1 TSRMLS_CC); } - | non_empty_array_pair_list ',' '&' w_variable { zend_do_add_array_element(&$$, &$4, NULL, 1 TSRMLS_CC); } - | expr T_DOUBLE_ARROW '&' w_variable { zend_do_init_array(&$$, &$4, &$1, 1 TSRMLS_CC); } - | '&' w_variable { zend_do_init_array(&$$, &$2, NULL, 1 TSRMLS_CC); } + non_empty_array_pair_list ',' array_pair + { $$.list = zend_ast_list_add($1.list, $3.ast); } + | array_pair + { $$.list = zend_ast_create_list(1, ZEND_AST_ARRAY, $1.ast); } ; -encaps_list: - encaps_list encaps_var { zend_do_end_variable_parse(&$2, BP_VAR_R, 0 TSRMLS_CC); zend_do_add_variable(&$$, &$1, &$2 TSRMLS_CC); } - | encaps_list T_ENCAPSED_AND_WHITESPACE { zend_do_add_string(&$$, &$1, &$2 TSRMLS_CC); } - | encaps_var { zend_do_end_variable_parse(&$1, BP_VAR_R, 0 TSRMLS_CC); zend_do_add_variable(&$$, NULL, &$1 TSRMLS_CC); } - | T_ENCAPSED_AND_WHITESPACE encaps_var { zend_do_add_string(&$$, NULL, &$1 TSRMLS_CC); zend_do_end_variable_parse(&$2, BP_VAR_R, 0 TSRMLS_CC); zend_do_add_variable(&$$, &$$, &$2 TSRMLS_CC); } +array_pair: + expr T_DOUBLE_ARROW expr + { $$.ast = zend_ast_create(ZEND_AST_ARRAY_ELEM, $3.ast, $1.ast); } + | expr { $$.ast = zend_ast_create(ZEND_AST_ARRAY_ELEM, $1.ast, NULL); } + | expr T_DOUBLE_ARROW '&' variable + { $$.ast = zend_ast_create_ex(ZEND_AST_ARRAY_ELEM, 1, $4.ast, $1.ast); } + | '&' variable + { $$.ast = zend_ast_create_ex(ZEND_AST_ARRAY_ELEM, 1, $2.ast, NULL); } ; - +encaps_list: + encaps_list encaps_var + { $$.list = zend_ast_list_add($1.list, $2.ast); } + | encaps_list T_ENCAPSED_AND_WHITESPACE + { $$.list = zend_ast_list_add($1.list, $2.ast); } + | encaps_var + { $$.list = zend_ast_create_list(1, ZEND_AST_ENCAPS_LIST, $1.ast); } + | T_ENCAPSED_AND_WHITESPACE encaps_var + { $$.list = zend_ast_create_list(2, ZEND_AST_ENCAPS_LIST, $1.ast, $2.ast); } +; encaps_var: - T_VARIABLE { zend_do_begin_variable_parse(TSRMLS_C); fetch_simple_variable(&$$, &$1, 1 TSRMLS_CC); } - | T_VARIABLE '[' { zend_do_begin_variable_parse(TSRMLS_C); } encaps_var_offset ']' { fetch_array_begin(&$$, &$1, &$4 TSRMLS_CC); } - | T_VARIABLE T_OBJECT_OPERATOR T_STRING { zend_do_begin_variable_parse(TSRMLS_C); fetch_simple_variable(&$2, &$1, 1 TSRMLS_CC); zend_do_fetch_property(&$$, &$2, &$3 TSRMLS_CC); } - | T_DOLLAR_OPEN_CURLY_BRACES expr '}' { zend_do_begin_variable_parse(TSRMLS_C); fetch_simple_variable(&$$, &$2, 1 TSRMLS_CC); } - | T_DOLLAR_OPEN_CURLY_BRACES T_STRING_VARNAME '[' expr ']' '}' { zend_do_begin_variable_parse(TSRMLS_C); fetch_array_begin(&$$, &$2, &$4 TSRMLS_CC); } - | T_CURLY_OPEN variable '}' { $$ = $2; } + T_VARIABLE + { $$.ast = zend_ast_create(ZEND_AST_VAR, $1.ast); } + | T_VARIABLE '[' encaps_var_offset ']' + { $$.ast = zend_ast_create(ZEND_AST_DIM, + zend_ast_create(ZEND_AST_VAR, $1.ast), $3.ast); } + | T_VARIABLE T_OBJECT_OPERATOR T_STRING + { $$.ast = zend_ast_create(ZEND_AST_PROP, + zend_ast_create(ZEND_AST_VAR, $1.ast), $3.ast); } + | T_DOLLAR_OPEN_CURLY_BRACES expr '}' + { $$.ast = zend_ast_create(ZEND_AST_VAR, $2.ast); } + | T_DOLLAR_OPEN_CURLY_BRACES T_STRING_VARNAME '}' + { $$.ast = zend_ast_create(ZEND_AST_VAR, $2.ast); } + | T_DOLLAR_OPEN_CURLY_BRACES T_STRING_VARNAME '[' expr ']' '}' + { $$.ast = zend_ast_create(ZEND_AST_DIM, + zend_ast_create(ZEND_AST_VAR, $2.ast), $4.ast); } + | T_CURLY_OPEN variable '}' { $$.ast = $2.ast; } ; - encaps_var_offset: - T_STRING { $$ = $1; } - | T_NUM_STRING { $$ = $1; } - | T_VARIABLE { fetch_simple_variable(&$$, &$1, 1 TSRMLS_CC); } + T_STRING { $$.ast = $1.ast; } + | T_NUM_STRING { $$.ast = $1.ast; } + | T_VARIABLE { $$.ast = zend_ast_create(ZEND_AST_VAR, $1.ast); } ; internal_functions_in_yacc: - T_ISSET '(' isset_variables ')' { $$ = $3; } - | T_EMPTY '(' variable ')' { zend_do_isset_or_isempty(ZEND_ISEMPTY, &$$, &$3 TSRMLS_CC); } - | T_EMPTY '(' expr_without_variable ')' { zend_do_unary_op(ZEND_BOOL_NOT, &$$, &$3 TSRMLS_CC); } - | T_INCLUDE expr { zend_do_include_or_eval(ZEND_INCLUDE, &$$, &$2 TSRMLS_CC); } - | T_INCLUDE_ONCE expr { zend_do_include_or_eval(ZEND_INCLUDE_ONCE, &$$, &$2 TSRMLS_CC); } - | T_EVAL '(' expr ')' { zend_do_include_or_eval(ZEND_EVAL, &$$, &$3 TSRMLS_CC); } - | T_REQUIRE expr { zend_do_include_or_eval(ZEND_REQUIRE, &$$, &$2 TSRMLS_CC); } - | T_REQUIRE_ONCE expr { zend_do_include_or_eval(ZEND_REQUIRE_ONCE, &$$, &$2 TSRMLS_CC); } + T_ISSET '(' isset_variables ')' { $$.ast = $3.ast; } + | T_EMPTY '(' expr ')' { $$.ast = zend_ast_create(ZEND_AST_EMPTY, $3.ast); } + | T_INCLUDE expr + { $$.ast = zend_ast_create_ex(ZEND_AST_INCLUDE_OR_EVAL, ZEND_INCLUDE, $2.ast); } + | T_INCLUDE_ONCE expr + { $$.ast = zend_ast_create_ex(ZEND_AST_INCLUDE_OR_EVAL, ZEND_INCLUDE_ONCE, $2.ast); } + | T_EVAL '(' expr ')' + { $$.ast = zend_ast_create_ex(ZEND_AST_INCLUDE_OR_EVAL, ZEND_EVAL, $3.ast); } + | T_REQUIRE expr + { $$.ast = zend_ast_create_ex(ZEND_AST_INCLUDE_OR_EVAL, ZEND_REQUIRE, $2.ast); } + | T_REQUIRE_ONCE expr + { $$.ast = zend_ast_create_ex(ZEND_AST_INCLUDE_OR_EVAL, ZEND_REQUIRE_ONCE, $2.ast); } ; isset_variables: - isset_variable { $$ = $1; } - | isset_variables ',' { zend_do_boolean_and_begin(&$1, &$2 TSRMLS_CC); } isset_variable { zend_do_boolean_and_end(&$$, &$1, &$4, &$2 TSRMLS_CC); } + isset_variable { $$.ast = $1.ast; } + | isset_variables ',' isset_variable + { $$.ast = zend_ast_create(ZEND_AST_AND, $1.ast, $3.ast); } ; isset_variable: - variable { zend_do_isset_or_isempty(ZEND_ISSET, &$$, &$1 TSRMLS_CC); } - | expr_without_variable { zend_error_noreturn(E_COMPILE_ERROR, "Cannot use isset() on the result of an expression (you can use \"null !== expression\" instead)"); } -; - -class_constant: - class_name T_PAAMAYIM_NEKUDOTAYIM T_STRING { zend_do_fetch_constant(&$$, &$1, &$3, ZEND_RT, 0 TSRMLS_CC); } - | variable_class_name T_PAAMAYIM_NEKUDOTAYIM T_STRING { zend_do_fetch_constant(&$$, &$1, &$3, ZEND_RT, 0 TSRMLS_CC); } -; - -static_class_name_scalar: - class_name T_PAAMAYIM_NEKUDOTAYIM T_CLASS { zend_do_resolve_class_name(&$$, &$1, 1 TSRMLS_CC); } + expr { $$.ast = zend_ast_create(ZEND_AST_ISSET, $1.ast); } ; class_name_scalar: - class_name T_PAAMAYIM_NEKUDOTAYIM T_CLASS { zend_do_resolve_class_name(&$$, &$1, 0 TSRMLS_CC); } + class_name T_PAAMAYIM_NEKUDOTAYIM T_CLASS + { $$.ast = zend_ast_create(ZEND_AST_RESOLVE_CLASS_NAME, $1.ast); } ; %% diff --git a/Zend/zend_language_scanner.c b/Zend/zend_language_scanner.c index 3b10615513..90fe7c4597 100644 --- a/Zend/zend_language_scanner.c +++ b/Zend/zend_language_scanner.c @@ -561,11 +561,10 @@ ZEND_API zend_op_array *compile_file(zend_file_handle *file_handle, int type TSR zend_op_array *retval=NULL; int compiler_result; zend_bool compilation_successful=0; - znode retval_znode; + zval retval_zv; zend_bool original_in_compilation = CG(in_compilation); - retval_znode.op_type = IS_CONST; - ZVAL_LONG(&retval_znode.u.constant, 1); + ZVAL_LONG(&retval_zv, 1); zend_save_lexical_state(&original_lex_state TSRMLS_CC); @@ -585,12 +584,17 @@ ZEND_API zend_op_array *compile_file(zend_file_handle *file_handle, int type TSR CG(active_op_array) = op_array; zend_stack_push(&CG(context_stack), (void *) &CG(context)); zend_init_compiler_context(TSRMLS_C); + CG(ast_arena) = zend_arena_create(1024 * 32); compiler_result = zendparse(TSRMLS_C); - zend_do_return(&retval_znode, 0 TSRMLS_CC); - CG(in_compilation) = original_in_compilation; if (compiler_result != 0) { /* parser error */ zend_bailout(); } + zend_compile_top_stmt(CG(ast) TSRMLS_CC); + zend_ast_destroy(CG(ast)); + zend_arena_destroy(CG(ast_arena)); + zend_do_end_compilation(TSRMLS_C); + zend_emit_final_return(&retval_zv TSRMLS_CC); + CG(in_compilation) = original_in_compilation; compilation_successful=1; } @@ -752,6 +756,7 @@ zend_op_array *compile_string(zval *source_string, char *filename TSRMLS_DC) zend_stack_push(&CG(context_stack), (void *) &CG(context)); zend_init_compiler_context(TSRMLS_C); BEGIN(ST_IN_SCRIPTING); + CG(ast_arena) = zend_arena_create(1024 * 32); compiler_result = zendparse(TSRMLS_C); if (SCNG(script_filtered)) { @@ -766,7 +771,11 @@ zend_op_array *compile_string(zval *source_string, char *filename TSRMLS_DC) efree(op_array); retval = NULL; } else { - zend_do_return(NULL, 0 TSRMLS_CC); + zend_compile_top_stmt(CG(ast) TSRMLS_CC); + zend_ast_destroy(CG(ast)); + zend_arena_destroy(CG(ast_arena)); + zend_do_end_compilation(TSRMLS_C); + zend_emit_final_return(NULL TSRMLS_CC); CG(active_op_array) = original_active_op_array; pass_two(op_array TSRMLS_CC); zend_release_labels(0 TSRMLS_CC); @@ -876,15 +885,6 @@ ZEND_API void zend_multibyte_yyinput_again(zend_encoding_filter old_input_filter ZVAL_STRINGL(zendlval, yytext, yyleng); \ } -// TODO: some extensions might need content, but we don't copy it intentional ??? -#if 0 -# define DUMMY_STRINGL(zendlval, yytext, yyleng) \ - ZVAL_STRINGL(zendlval, yytext, yyleng) -#else -# define DUMMY_STRINGL(zendlval, yytext, yyleng) \ - ZVAL_EMPTY_STRING(zendlval) -#endif - static void zend_scan_escape_string(zval *zendlval, char *str, int len, char quote_type TSRMLS_DC) { register char *s, *t; @@ -1115,7 +1115,7 @@ yyc_INITIAL: yy3: YYDEBUG(3, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1779 "Zend/zend_language_scanner.l" +#line 1714 "Zend/zend_language_scanner.l" { if (YYCURSOR > YYLIMIT) { return 0; @@ -1194,34 +1194,32 @@ yy5: yy6: YYDEBUG(6, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1769 "Zend/zend_language_scanner.l" +#line 1705 "Zend/zend_language_scanner.l" { if (CG(short_tags)) { - DUMMY_STRINGL(zendlval, yytext, yyleng); BEGIN(ST_IN_SCRIPTING); return T_OPEN_TAG; } else { goto inline_char_handler; } } -#line 1208 "Zend/zend_language_scanner.c" +#line 1207 "Zend/zend_language_scanner.c" yy7: YYDEBUG(7, *YYCURSOR); ++YYCURSOR; if ((yych = *YYCURSOR) == '=') goto yy43; YYDEBUG(8, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1750 "Zend/zend_language_scanner.l" +#line 1688 "Zend/zend_language_scanner.l" { if (CG(asp_tags)) { - DUMMY_STRINGL(zendlval, yytext, yyleng); BEGIN(ST_IN_SCRIPTING); return T_OPEN_TAG; } else { goto inline_char_handler; } } -#line 1225 "Zend/zend_language_scanner.c" +#line 1223 "Zend/zend_language_scanner.c" yy9: YYDEBUG(9, *YYCURSOR); yych = *++YYCURSOR; @@ -1407,7 +1405,7 @@ yy35: ++YYCURSOR; YYDEBUG(38, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1716 "Zend/zend_language_scanner.l" +#line 1657 "Zend/zend_language_scanner.l" { YYCTYPE *bracket = (YYCTYPE*)zend_memrchr(yytext, '<', yyleng - (sizeof("script language=php>") - 1)); @@ -1418,11 +1416,10 @@ yy35: } HANDLE_NEWLINES(yytext, yyleng); - DUMMY_STRINGL(zendlval, yytext, yyleng); BEGIN(ST_IN_SCRIPTING); return T_OPEN_TAG; } -#line 1426 "Zend/zend_language_scanner.c" +#line 1423 "Zend/zend_language_scanner.c" yy39: YYDEBUG(39, *YYCURSOR); yych = *++YYCURSOR; @@ -1449,29 +1446,27 @@ yy43: ++YYCURSOR; YYDEBUG(44, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1732 "Zend/zend_language_scanner.l" +#line 1672 "Zend/zend_language_scanner.l" { if (CG(asp_tags)) { - DUMMY_STRINGL(zendlval, yytext, yyleng); BEGIN(ST_IN_SCRIPTING); return T_OPEN_TAG_WITH_ECHO; } else { goto inline_char_handler; } } -#line 1463 "Zend/zend_language_scanner.c" +#line 1459 "Zend/zend_language_scanner.c" yy45: YYDEBUG(45, *YYCURSOR); ++YYCURSOR; YYDEBUG(46, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1743 "Zend/zend_language_scanner.l" +#line 1682 "Zend/zend_language_scanner.l" { - DUMMY_STRINGL(zendlval, yytext, yyleng); BEGIN(ST_IN_SCRIPTING); return T_OPEN_TAG_WITH_ECHO; } -#line 1475 "Zend/zend_language_scanner.c" +#line 1470 "Zend/zend_language_scanner.c" yy47: YYDEBUG(47, *YYCURSOR); yych = *++YYCURSOR; @@ -1498,14 +1493,13 @@ yy50: yy51: YYDEBUG(51, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1761 "Zend/zend_language_scanner.l" +#line 1698 "Zend/zend_language_scanner.l" { - DUMMY_STRINGL(zendlval, yytext, yyleng); HANDLE_NEWLINE(yytext[yyleng-1]); BEGIN(ST_IN_SCRIPTING); return T_OPEN_TAG; } -#line 1509 "Zend/zend_language_scanner.c" +#line 1503 "Zend/zend_language_scanner.c" yy52: YYDEBUG(52, *YYCURSOR); ++YYCURSOR; @@ -1576,7 +1570,7 @@ yyc_ST_BACKQUOTE: yy56: YYDEBUG(56, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 2222 "Zend/zend_language_scanner.l" +#line 2155 "Zend/zend_language_scanner.l" { if (YYCURSOR > YYLIMIT) { return 0; @@ -1617,7 +1611,7 @@ yy56: zend_scan_escape_string(zendlval, yytext, yyleng, '`' TSRMLS_CC); return T_ENCAPSED_AND_WHITESPACE; } -#line 1621 "Zend/zend_language_scanner.c" +#line 1615 "Zend/zend_language_scanner.c" yy57: YYDEBUG(57, *YYCURSOR); yych = *++YYCURSOR; @@ -1628,12 +1622,12 @@ yy58: ++YYCURSOR; YYDEBUG(59, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 2166 "Zend/zend_language_scanner.l" +#line 2099 "Zend/zend_language_scanner.l" { BEGIN(ST_IN_SCRIPTING); return '`'; } -#line 1637 "Zend/zend_language_scanner.c" +#line 1631 "Zend/zend_language_scanner.c" yy60: YYDEBUG(60, *YYCURSOR); yych = *++YYCURSOR; @@ -1643,14 +1637,14 @@ yy61: ++YYCURSOR; YYDEBUG(62, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 2153 "Zend/zend_language_scanner.l" +#line 2086 "Zend/zend_language_scanner.l" { Z_LVAL_P(zendlval) = (zend_long) '{'; yy_push_state(ST_IN_SCRIPTING TSRMLS_CC); yyless(1); return T_CURLY_OPEN; } -#line 1654 "Zend/zend_language_scanner.c" +#line 1648 "Zend/zend_language_scanner.c" yy63: YYDEBUG(63, *YYCURSOR); yyaccept = 0; @@ -1666,23 +1660,23 @@ yy63: yy65: YYDEBUG(65, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1860 "Zend/zend_language_scanner.l" +#line 1795 "Zend/zend_language_scanner.l" { zend_copy_value(zendlval, (yytext+1), (yyleng-1)); return T_VARIABLE; } -#line 1675 "Zend/zend_language_scanner.c" +#line 1669 "Zend/zend_language_scanner.c" yy66: YYDEBUG(66, *YYCURSOR); ++YYCURSOR; YYDEBUG(67, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1483 "Zend/zend_language_scanner.l" +#line 1482 "Zend/zend_language_scanner.l" { yy_push_state(ST_LOOKING_FOR_VARNAME TSRMLS_CC); return T_DOLLAR_OPEN_CURLY_BRACES; } -#line 1686 "Zend/zend_language_scanner.c" +#line 1680 "Zend/zend_language_scanner.c" yy68: YYDEBUG(68, *YYCURSOR); yych = *++YYCURSOR; @@ -1696,14 +1690,14 @@ yy70: ++YYCURSOR; YYDEBUG(71, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1853 "Zend/zend_language_scanner.l" +#line 1788 "Zend/zend_language_scanner.l" { yyless(yyleng - 1); yy_push_state(ST_VAR_OFFSET TSRMLS_CC); zend_copy_value(zendlval, (yytext+1), (yyleng-1)); return T_VARIABLE; } -#line 1707 "Zend/zend_language_scanner.c" +#line 1701 "Zend/zend_language_scanner.c" yy72: YYDEBUG(72, *YYCURSOR); yych = *++YYCURSOR; @@ -1721,14 +1715,14 @@ yy73: ++YYCURSOR; YYDEBUG(74, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1844 "Zend/zend_language_scanner.l" +#line 1779 "Zend/zend_language_scanner.l" { yyless(yyleng - 3); yy_push_state(ST_LOOKING_FOR_PROPERTY TSRMLS_CC); zend_copy_value(zendlval, (yytext+1), (yyleng-1)); return T_VARIABLE; } -#line 1732 "Zend/zend_language_scanner.c" +#line 1726 "Zend/zend_language_scanner.c" } /* *********************************** */ yyc_ST_DOUBLE_QUOTES: @@ -1796,7 +1790,7 @@ yy77: yy78: YYDEBUG(78, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 2172 "Zend/zend_language_scanner.l" +#line 2105 "Zend/zend_language_scanner.l" { if (GET_DOUBLE_QUOTES_SCANNED_LENGTH()) { YYCURSOR += GET_DOUBLE_QUOTES_SCANNED_LENGTH() - 1; @@ -1845,7 +1839,7 @@ double_quotes_scan_done: zend_scan_escape_string(zendlval, yytext, yyleng, '"' TSRMLS_CC); return T_ENCAPSED_AND_WHITESPACE; } -#line 1849 "Zend/zend_language_scanner.c" +#line 1843 "Zend/zend_language_scanner.c" yy79: YYDEBUG(79, *YYCURSOR); yych = *++YYCURSOR; @@ -1856,12 +1850,12 @@ yy80: ++YYCURSOR; YYDEBUG(81, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 2161 "Zend/zend_language_scanner.l" +#line 2094 "Zend/zend_language_scanner.l" { BEGIN(ST_IN_SCRIPTING); return '"'; } -#line 1865 "Zend/zend_language_scanner.c" +#line 1859 "Zend/zend_language_scanner.c" yy82: YYDEBUG(82, *YYCURSOR); yych = *++YYCURSOR; @@ -1871,14 +1865,14 @@ yy83: ++YYCURSOR; YYDEBUG(84, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 2153 "Zend/zend_language_scanner.l" +#line 2086 "Zend/zend_language_scanner.l" { Z_LVAL_P(zendlval) = (zend_long) '{'; yy_push_state(ST_IN_SCRIPTING TSRMLS_CC); yyless(1); return T_CURLY_OPEN; } -#line 1882 "Zend/zend_language_scanner.c" +#line 1876 "Zend/zend_language_scanner.c" yy85: YYDEBUG(85, *YYCURSOR); yyaccept = 0; @@ -1894,23 +1888,23 @@ yy85: yy87: YYDEBUG(87, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1860 "Zend/zend_language_scanner.l" +#line 1795 "Zend/zend_language_scanner.l" { zend_copy_value(zendlval, (yytext+1), (yyleng-1)); return T_VARIABLE; } -#line 1903 "Zend/zend_language_scanner.c" +#line 1897 "Zend/zend_language_scanner.c" yy88: YYDEBUG(88, *YYCURSOR); ++YYCURSOR; YYDEBUG(89, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1483 "Zend/zend_language_scanner.l" +#line 1482 "Zend/zend_language_scanner.l" { yy_push_state(ST_LOOKING_FOR_VARNAME TSRMLS_CC); return T_DOLLAR_OPEN_CURLY_BRACES; } -#line 1914 "Zend/zend_language_scanner.c" +#line 1908 "Zend/zend_language_scanner.c" yy90: YYDEBUG(90, *YYCURSOR); yych = *++YYCURSOR; @@ -1924,14 +1918,14 @@ yy92: ++YYCURSOR; YYDEBUG(93, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1853 "Zend/zend_language_scanner.l" +#line 1788 "Zend/zend_language_scanner.l" { yyless(yyleng - 1); yy_push_state(ST_VAR_OFFSET TSRMLS_CC); zend_copy_value(zendlval, (yytext+1), (yyleng-1)); return T_VARIABLE; } -#line 1935 "Zend/zend_language_scanner.c" +#line 1929 "Zend/zend_language_scanner.c" yy94: YYDEBUG(94, *YYCURSOR); yych = *++YYCURSOR; @@ -1949,14 +1943,14 @@ yy95: ++YYCURSOR; YYDEBUG(96, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1844 "Zend/zend_language_scanner.l" +#line 1779 "Zend/zend_language_scanner.l" { yyless(yyleng - 3); yy_push_state(ST_LOOKING_FOR_PROPERTY TSRMLS_CC); zend_copy_value(zendlval, (yytext+1), (yyleng-1)); return T_VARIABLE; } -#line 1960 "Zend/zend_language_scanner.c" +#line 1954 "Zend/zend_language_scanner.c" } /* *********************************** */ yyc_ST_END_HEREDOC: @@ -1967,7 +1961,7 @@ yyc_ST_END_HEREDOC: ++YYCURSOR; YYDEBUG(100, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 2139 "Zend/zend_language_scanner.l" +#line 2072 "Zend/zend_language_scanner.l" { zend_heredoc_label *heredoc_label = zend_ptr_stack_pop(&SCNG(heredoc_label_stack)); @@ -1980,7 +1974,7 @@ yyc_ST_END_HEREDOC: BEGIN(ST_IN_SCRIPTING); return T_END_HEREDOC; } -#line 1984 "Zend/zend_language_scanner.c" +#line 1978 "Zend/zend_language_scanner.c" /* *********************************** */ yyc_ST_HEREDOC: { @@ -2042,7 +2036,7 @@ yy103: yy104: YYDEBUG(104, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 2264 "Zend/zend_language_scanner.l" +#line 2197 "Zend/zend_language_scanner.l" { int newline = 0; @@ -2115,7 +2109,7 @@ heredoc_scan_done: zend_scan_escape_string(zendlval, yytext, yyleng - newline, 0 TSRMLS_CC); return T_ENCAPSED_AND_WHITESPACE; } -#line 2119 "Zend/zend_language_scanner.c" +#line 2113 "Zend/zend_language_scanner.c" yy105: YYDEBUG(105, *YYCURSOR); yych = *++YYCURSOR; @@ -2130,14 +2124,14 @@ yy107: ++YYCURSOR; YYDEBUG(108, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 2153 "Zend/zend_language_scanner.l" +#line 2086 "Zend/zend_language_scanner.l" { Z_LVAL_P(zendlval) = (zend_long) '{'; yy_push_state(ST_IN_SCRIPTING TSRMLS_CC); yyless(1); return T_CURLY_OPEN; } -#line 2141 "Zend/zend_language_scanner.c" +#line 2135 "Zend/zend_language_scanner.c" yy109: YYDEBUG(109, *YYCURSOR); yyaccept = 0; @@ -2153,23 +2147,23 @@ yy109: yy111: YYDEBUG(111, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1860 "Zend/zend_language_scanner.l" +#line 1795 "Zend/zend_language_scanner.l" { zend_copy_value(zendlval, (yytext+1), (yyleng-1)); return T_VARIABLE; } -#line 2162 "Zend/zend_language_scanner.c" +#line 2156 "Zend/zend_language_scanner.c" yy112: YYDEBUG(112, *YYCURSOR); ++YYCURSOR; YYDEBUG(113, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1483 "Zend/zend_language_scanner.l" +#line 1482 "Zend/zend_language_scanner.l" { yy_push_state(ST_LOOKING_FOR_VARNAME TSRMLS_CC); return T_DOLLAR_OPEN_CURLY_BRACES; } -#line 2173 "Zend/zend_language_scanner.c" +#line 2167 "Zend/zend_language_scanner.c" yy114: YYDEBUG(114, *YYCURSOR); yych = *++YYCURSOR; @@ -2183,14 +2177,14 @@ yy116: ++YYCURSOR; YYDEBUG(117, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1853 "Zend/zend_language_scanner.l" +#line 1788 "Zend/zend_language_scanner.l" { yyless(yyleng - 1); yy_push_state(ST_VAR_OFFSET TSRMLS_CC); zend_copy_value(zendlval, (yytext+1), (yyleng-1)); return T_VARIABLE; } -#line 2194 "Zend/zend_language_scanner.c" +#line 2188 "Zend/zend_language_scanner.c" yy118: YYDEBUG(118, *YYCURSOR); yych = *++YYCURSOR; @@ -2208,14 +2202,14 @@ yy119: ++YYCURSOR; YYDEBUG(120, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1844 "Zend/zend_language_scanner.l" +#line 1779 "Zend/zend_language_scanner.l" { yyless(yyleng - 3); yy_push_state(ST_LOOKING_FOR_PROPERTY TSRMLS_CC); zend_copy_value(zendlval, (yytext+1), (yyleng-1)); return T_VARIABLE; } -#line 2219 "Zend/zend_language_scanner.c" +#line 2213 "Zend/zend_language_scanner.c" } /* *********************************** */ yyc_ST_IN_SCRIPTING: @@ -2398,12 +2392,12 @@ yy123: yy124: YYDEBUG(124, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1882 "Zend/zend_language_scanner.l" +#line 1817 "Zend/zend_language_scanner.l" { zend_copy_value(zendlval, yytext, yyleng); return T_STRING; } -#line 2407 "Zend/zend_language_scanner.c" +#line 2401 "Zend/zend_language_scanner.c" yy125: YYDEBUG(125, *YYCURSOR); yych = *++YYCURSOR; @@ -2635,11 +2629,11 @@ yy138: yy139: YYDEBUG(139, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1472 "Zend/zend_language_scanner.l" +#line 1471 "Zend/zend_language_scanner.l" { return yytext[0]; } -#line 2643 "Zend/zend_language_scanner.c" +#line 2637 "Zend/zend_language_scanner.c" yy140: YYDEBUG(140, *YYCURSOR); ++YYCURSOR; @@ -2650,11 +2644,10 @@ yy141: yyleng = YYCURSOR - SCNG(yy_text); #line 1194 "Zend/zend_language_scanner.l" { - DUMMY_STRINGL(zendlval, yytext, yyleng); HANDLE_NEWLINES(yytext, yyleng); return T_WHITESPACE; } -#line 2658 "Zend/zend_language_scanner.c" +#line 2651 "Zend/zend_language_scanner.c" yy142: YYDEBUG(142, *YYCURSOR); yych = *++YYCURSOR; @@ -2665,11 +2658,11 @@ yy143: ++YYCURSOR; YYDEBUG(144, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1220 "Zend/zend_language_scanner.l" +#line 1219 "Zend/zend_language_scanner.l" { return T_NS_SEPARATOR; } -#line 2673 "Zend/zend_language_scanner.c" +#line 2666 "Zend/zend_language_scanner.c" yy145: YYDEBUG(145, *YYCURSOR); yyaccept = 1; @@ -2903,18 +2896,18 @@ yy168: ++YYCURSOR; YYDEBUG(169, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1477 "Zend/zend_language_scanner.l" +#line 1476 "Zend/zend_language_scanner.l" { yy_push_state(ST_IN_SCRIPTING TSRMLS_CC); return '{'; } -#line 2912 "Zend/zend_language_scanner.c" +#line 2905 "Zend/zend_language_scanner.c" yy170: YYDEBUG(170, *YYCURSOR); ++YYCURSOR; YYDEBUG(171, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1489 "Zend/zend_language_scanner.l" +#line 1488 "Zend/zend_language_scanner.l" { RESET_DOC_COMMENT(); if (!zend_stack_is_empty(&SCNG(state_stack))) { @@ -2922,7 +2915,7 @@ yy170: } return '}'; } -#line 2926 "Zend/zend_language_scanner.c" +#line 2919 "Zend/zend_language_scanner.c" yy172: YYDEBUG(172, *YYCURSOR); yyaccept = 2; @@ -2950,7 +2943,7 @@ yy172: yy173: YYDEBUG(173, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1537 "Zend/zend_language_scanner.l" +#line 1536 "Zend/zend_language_scanner.l" { if (yyleng < MAX_LENGTH_OF_LONG - 1) { /* Won't overflow */ ZVAL_LONG(zendlval, ZEND_STRTOL(yytext, NULL, 0)); @@ -2968,7 +2961,7 @@ yy173: } return T_LNUMBER; } -#line 2972 "Zend/zend_language_scanner.c" +#line 2965 "Zend/zend_language_scanner.c" yy174: YYDEBUG(174, *YYCURSOR); yyaccept = 2; @@ -2996,7 +2989,7 @@ yy176: yy177: YYDEBUG(177, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1888 "Zend/zend_language_scanner.l" +#line 1823 "Zend/zend_language_scanner.l" { while (YYCURSOR < YYLIMIT) { switch (*YYCURSOR++) { @@ -3030,14 +3023,14 @@ yy177: return T_COMMENT; } -#line 3034 "Zend/zend_language_scanner.c" +#line 3027 "Zend/zend_language_scanner.c" yy178: YYDEBUG(178, *YYCURSOR); ++YYCURSOR; yy179: YYDEBUG(179, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1974 "Zend/zend_language_scanner.l" +#line 1907 "Zend/zend_language_scanner.l" { register char *s, *t; char *end; @@ -3105,14 +3098,14 @@ yy179: } return T_CONSTANT_ENCAPSED_STRING; } -#line 3109 "Zend/zend_language_scanner.c" +#line 3102 "Zend/zend_language_scanner.c" yy180: YYDEBUG(180, *YYCURSOR); ++YYCURSOR; yy181: YYDEBUG(181, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 2043 "Zend/zend_language_scanner.l" +#line 1976 "Zend/zend_language_scanner.l" { int bprefix = (yytext[0] != '"') ? 1 : 0; @@ -3153,24 +3146,24 @@ yy181: BEGIN(ST_DOUBLE_QUOTES); return '"'; } -#line 3157 "Zend/zend_language_scanner.c" +#line 3150 "Zend/zend_language_scanner.c" yy182: YYDEBUG(182, *YYCURSOR); ++YYCURSOR; YYDEBUG(183, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 2133 "Zend/zend_language_scanner.l" +#line 2066 "Zend/zend_language_scanner.l" { BEGIN(ST_BACKQUOTE); return '`'; } -#line 3168 "Zend/zend_language_scanner.c" +#line 3161 "Zend/zend_language_scanner.c" yy184: YYDEBUG(184, *YYCURSOR); ++YYCURSOR; YYDEBUG(185, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 2395 "Zend/zend_language_scanner.l" +#line 2328 "Zend/zend_language_scanner.l" { if (YYCURSOR > YYLIMIT) { return 0; @@ -3179,7 +3172,7 @@ yy184: zend_error(E_COMPILE_WARNING,"Unexpected character in input: '%c' (ASCII=%d) state=%d", yytext[0], yytext[0], YYSTATE); goto restart; } -#line 3183 "Zend/zend_language_scanner.c" +#line 3176 "Zend/zend_language_scanner.c" yy186: YYDEBUG(186, *YYCURSOR); ++YYCURSOR; @@ -3206,12 +3199,12 @@ yy188: yy190: YYDEBUG(190, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1592 "Zend/zend_language_scanner.l" +#line 1591 "Zend/zend_language_scanner.l" { ZVAL_DOUBLE(zendlval, zend_strtod(yytext, NULL)); return T_DNUMBER; } -#line 3215 "Zend/zend_language_scanner.c" +#line 3208 "Zend/zend_language_scanner.c" yy191: YYDEBUG(191, *YYCURSOR); yyaccept = 2; @@ -3303,7 +3296,7 @@ yy200: } YYDEBUG(202, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1514 "Zend/zend_language_scanner.l" +#line 1513 "Zend/zend_language_scanner.l" { char *bin = yytext + 2; /* Skip "0b" */ int len = yyleng - 2; @@ -3326,7 +3319,7 @@ yy200: return T_DNUMBER; } } -#line 3330 "Zend/zend_language_scanner.c" +#line 3323 "Zend/zend_language_scanner.c" yy203: YYDEBUG(203, *YYCURSOR); ++YYCURSOR; @@ -3338,7 +3331,7 @@ yy203: } YYDEBUG(205, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1555 "Zend/zend_language_scanner.l" +#line 1554 "Zend/zend_language_scanner.l" { char *hex = yytext + 2; /* Skip "0x" */ int len = yyleng - 2; @@ -3361,7 +3354,7 @@ yy203: return T_DNUMBER; } } -#line 3365 "Zend/zend_language_scanner.c" +#line 3358 "Zend/zend_language_scanner.c" yy206: YYDEBUG(206, *YYCURSOR); ++YYCURSOR; @@ -3370,13 +3363,12 @@ yy206: yy207: YYDEBUG(207, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1955 "Zend/zend_language_scanner.l" +#line 1890 "Zend/zend_language_scanner.l" { - DUMMY_STRINGL(zendlval, yytext, yyleng); BEGIN(INITIAL); return T_CLOSE_TAG; /* implicit ';' at php-end tag */ } -#line 3380 "Zend/zend_language_scanner.c" +#line 3372 "Zend/zend_language_scanner.c" yy208: YYDEBUG(208, *YYCURSOR); yych = *++YYCURSOR; @@ -3410,12 +3402,12 @@ yy210: yy212: YYDEBUG(212, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1860 "Zend/zend_language_scanner.l" +#line 1795 "Zend/zend_language_scanner.l" { zend_copy_value(zendlval, (yytext+1), (yyleng-1)); return T_VARIABLE; } -#line 3419 "Zend/zend_language_scanner.c" +#line 3411 "Zend/zend_language_scanner.c" yy213: YYDEBUG(213, *YYCURSOR); yych = *++YYCURSOR; @@ -3429,11 +3421,11 @@ yy214: } YYDEBUG(215, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1460 "Zend/zend_language_scanner.l" +#line 1459 "Zend/zend_language_scanner.l" { return T_LOGICAL_XOR; } -#line 3437 "Zend/zend_language_scanner.c" +#line 3429 "Zend/zend_language_scanner.c" yy216: YYDEBUG(216, *YYCURSOR); ++YYCURSOR; @@ -3442,61 +3434,61 @@ yy216: } YYDEBUG(217, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1452 "Zend/zend_language_scanner.l" +#line 1451 "Zend/zend_language_scanner.l" { return T_LOGICAL_OR; } -#line 3450 "Zend/zend_language_scanner.c" +#line 3442 "Zend/zend_language_scanner.c" yy218: YYDEBUG(218, *YYCURSOR); ++YYCURSOR; YYDEBUG(219, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1440 "Zend/zend_language_scanner.l" +#line 1439 "Zend/zend_language_scanner.l" { return T_XOR_EQUAL; } -#line 3460 "Zend/zend_language_scanner.c" +#line 3452 "Zend/zend_language_scanner.c" yy220: YYDEBUG(220, *YYCURSOR); ++YYCURSOR; YYDEBUG(221, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1444 "Zend/zend_language_scanner.l" +#line 1443 "Zend/zend_language_scanner.l" { return T_BOOLEAN_OR; } -#line 3470 "Zend/zend_language_scanner.c" +#line 3462 "Zend/zend_language_scanner.c" yy222: YYDEBUG(222, *YYCURSOR); ++YYCURSOR; YYDEBUG(223, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1436 "Zend/zend_language_scanner.l" +#line 1435 "Zend/zend_language_scanner.l" { return T_OR_EQUAL; } -#line 3480 "Zend/zend_language_scanner.c" +#line 3472 "Zend/zend_language_scanner.c" yy224: YYDEBUG(224, *YYCURSOR); ++YYCURSOR; YYDEBUG(225, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1448 "Zend/zend_language_scanner.l" +#line 1447 "Zend/zend_language_scanner.l" { return T_BOOLEAN_AND; } -#line 3490 "Zend/zend_language_scanner.c" +#line 3482 "Zend/zend_language_scanner.c" yy226: YYDEBUG(226, *YYCURSOR); ++YYCURSOR; YYDEBUG(227, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1432 "Zend/zend_language_scanner.l" +#line 1431 "Zend/zend_language_scanner.l" { return T_AND_EQUAL; } -#line 3500 "Zend/zend_language_scanner.c" +#line 3492 "Zend/zend_language_scanner.c" yy228: YYDEBUG(228, *YYCURSOR); ++YYCURSOR; @@ -3505,28 +3497,27 @@ yy228: yy229: YYDEBUG(229, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1962 "Zend/zend_language_scanner.l" +#line 1896 "Zend/zend_language_scanner.l" { if (CG(asp_tags)) { BEGIN(INITIAL); - DUMMY_STRINGL(zendlval, yytext, yyleng); return T_CLOSE_TAG; /* implicit ';' at php-end tag */ } else { yyless(1); return yytext[0]; } } -#line 3520 "Zend/zend_language_scanner.c" +#line 3511 "Zend/zend_language_scanner.c" yy230: YYDEBUG(230, *YYCURSOR); ++YYCURSOR; YYDEBUG(231, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1420 "Zend/zend_language_scanner.l" +#line 1419 "Zend/zend_language_scanner.l" { return T_MOD_EQUAL; } -#line 3530 "Zend/zend_language_scanner.c" +#line 3521 "Zend/zend_language_scanner.c" yy232: YYDEBUG(232, *YYCURSOR); yych = *++YYCURSOR; @@ -3544,7 +3535,7 @@ yy234: yy235: YYDEBUG(235, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1922 "Zend/zend_language_scanner.l" +#line 1857 "Zend/zend_language_scanner.l" { int doc_com; @@ -3577,7 +3568,7 @@ yy235: return T_COMMENT; } -#line 3581 "Zend/zend_language_scanner.c" +#line 3572 "Zend/zend_language_scanner.c" yy236: YYDEBUG(236, *YYCURSOR); yych = *++YYCURSOR; @@ -3587,11 +3578,11 @@ yy237: ++YYCURSOR; YYDEBUG(238, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1412 "Zend/zend_language_scanner.l" +#line 1411 "Zend/zend_language_scanner.l" { return T_DIV_EQUAL; } -#line 3595 "Zend/zend_language_scanner.c" +#line 3586 "Zend/zend_language_scanner.c" yy239: YYDEBUG(239, *YYCURSOR); yych = *++YYCURSOR; @@ -3615,62 +3606,62 @@ yy242: if ((yych = *YYCURSOR) == '=') goto yy246; YYDEBUG(243, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1404 "Zend/zend_language_scanner.l" +#line 1403 "Zend/zend_language_scanner.l" { return T_POW; } -#line 3623 "Zend/zend_language_scanner.c" +#line 3614 "Zend/zend_language_scanner.c" yy244: YYDEBUG(244, *YYCURSOR); ++YYCURSOR; YYDEBUG(245, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1400 "Zend/zend_language_scanner.l" +#line 1399 "Zend/zend_language_scanner.l" { return T_MUL_EQUAL; } -#line 3633 "Zend/zend_language_scanner.c" +#line 3624 "Zend/zend_language_scanner.c" yy246: YYDEBUG(246, *YYCURSOR); ++YYCURSOR; YYDEBUG(247, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1408 "Zend/zend_language_scanner.l" +#line 1407 "Zend/zend_language_scanner.l" { return T_POW_EQUAL; } -#line 3643 "Zend/zend_language_scanner.c" +#line 3634 "Zend/zend_language_scanner.c" yy248: YYDEBUG(248, *YYCURSOR); ++YYCURSOR; if ((yych = *YYCURSOR) == '=') goto yy252; YYDEBUG(249, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1468 "Zend/zend_language_scanner.l" +#line 1467 "Zend/zend_language_scanner.l" { return T_SR; } -#line 3654 "Zend/zend_language_scanner.c" +#line 3645 "Zend/zend_language_scanner.c" yy250: YYDEBUG(250, *YYCURSOR); ++YYCURSOR; YYDEBUG(251, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1388 "Zend/zend_language_scanner.l" +#line 1387 "Zend/zend_language_scanner.l" { return T_IS_GREATER_OR_EQUAL; } -#line 3664 "Zend/zend_language_scanner.c" +#line 3655 "Zend/zend_language_scanner.c" yy252: YYDEBUG(252, *YYCURSOR); ++YYCURSOR; YYDEBUG(253, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1428 "Zend/zend_language_scanner.l" +#line 1427 "Zend/zend_language_scanner.l" { return T_SR_EQUAL; } -#line 3674 "Zend/zend_language_scanner.c" +#line 3665 "Zend/zend_language_scanner.c" yy254: YYDEBUG(254, *YYCURSOR); yyaccept = 5; @@ -3681,11 +3672,11 @@ yy254: yy255: YYDEBUG(255, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1464 "Zend/zend_language_scanner.l" +#line 1463 "Zend/zend_language_scanner.l" { return T_SL; } -#line 3689 "Zend/zend_language_scanner.c" +#line 3680 "Zend/zend_language_scanner.c" yy256: YYDEBUG(256, *YYCURSOR); yych = *++YYCURSOR; @@ -3697,22 +3688,22 @@ yy257: ++YYCURSOR; YYDEBUG(258, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1384 "Zend/zend_language_scanner.l" +#line 1383 "Zend/zend_language_scanner.l" { return T_IS_SMALLER_OR_EQUAL; } -#line 3705 "Zend/zend_language_scanner.c" +#line 3696 "Zend/zend_language_scanner.c" yy259: YYDEBUG(259, *YYCURSOR); ++YYCURSOR; yy260: YYDEBUG(260, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1380 "Zend/zend_language_scanner.l" +#line 1379 "Zend/zend_language_scanner.l" { return T_IS_NOT_EQUAL; } -#line 3716 "Zend/zend_language_scanner.c" +#line 3707 "Zend/zend_language_scanner.c" yy261: YYDEBUG(261, *YYCURSOR); yych = *++YYCURSOR; @@ -3763,11 +3754,11 @@ yy268: ++YYCURSOR; YYDEBUG(269, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1424 "Zend/zend_language_scanner.l" +#line 1423 "Zend/zend_language_scanner.l" { return T_SL_EQUAL; } -#line 3771 "Zend/zend_language_scanner.c" +#line 3762 "Zend/zend_language_scanner.c" yy270: YYDEBUG(270, *YYCURSOR); ++YYCURSOR; @@ -3872,7 +3863,7 @@ yy279: yy280: YYDEBUG(280, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 2085 "Zend/zend_language_scanner.l" +#line 2018 "Zend/zend_language_scanner.l" { char *s; int bprefix = (yytext[0] != '<') ? 1 : 0; @@ -3919,7 +3910,7 @@ yy280: return T_START_HEREDOC; } -#line 3923 "Zend/zend_language_scanner.c" +#line 3914 "Zend/zend_language_scanner.c" yy281: YYDEBUG(281, *YYCURSOR); yych = *++YYCURSOR; @@ -3959,31 +3950,31 @@ yy284: ++YYCURSOR; YYDEBUG(286, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1372 "Zend/zend_language_scanner.l" +#line 1371 "Zend/zend_language_scanner.l" { return T_IS_NOT_IDENTICAL; } -#line 3967 "Zend/zend_language_scanner.c" +#line 3958 "Zend/zend_language_scanner.c" yy287: YYDEBUG(287, *YYCURSOR); ++YYCURSOR; YYDEBUG(288, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1392 "Zend/zend_language_scanner.l" +#line 1391 "Zend/zend_language_scanner.l" { return T_PLUS_EQUAL; } -#line 3977 "Zend/zend_language_scanner.c" +#line 3968 "Zend/zend_language_scanner.c" yy289: YYDEBUG(289, *YYCURSOR); ++YYCURSOR; YYDEBUG(290, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1360 "Zend/zend_language_scanner.l" +#line 1359 "Zend/zend_language_scanner.l" { return T_INC; } -#line 3987 "Zend/zend_language_scanner.c" +#line 3978 "Zend/zend_language_scanner.c" yy291: YYDEBUG(291, *YYCURSOR); yych = *++YYCURSOR; @@ -4002,42 +3993,42 @@ yy293: } YYDEBUG(294, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1348 "Zend/zend_language_scanner.l" +#line 1347 "Zend/zend_language_scanner.l" { return T_LIST; } -#line 4010 "Zend/zend_language_scanner.c" +#line 4001 "Zend/zend_language_scanner.c" yy295: YYDEBUG(295, *YYCURSOR); ++YYCURSOR; if ((yych = *YYCURSOR) == '=') goto yy299; YYDEBUG(296, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1376 "Zend/zend_language_scanner.l" +#line 1375 "Zend/zend_language_scanner.l" { return T_IS_EQUAL; } -#line 4021 "Zend/zend_language_scanner.c" +#line 4012 "Zend/zend_language_scanner.c" yy297: YYDEBUG(297, *YYCURSOR); ++YYCURSOR; YYDEBUG(298, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1344 "Zend/zend_language_scanner.l" +#line 1343 "Zend/zend_language_scanner.l" { return T_DOUBLE_ARROW; } -#line 4031 "Zend/zend_language_scanner.c" +#line 4022 "Zend/zend_language_scanner.c" yy299: YYDEBUG(299, *YYCURSOR); ++YYCURSOR; YYDEBUG(300, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1368 "Zend/zend_language_scanner.l" +#line 1367 "Zend/zend_language_scanner.l" { return T_IS_IDENTICAL; } -#line 4041 "Zend/zend_language_scanner.c" +#line 4032 "Zend/zend_language_scanner.c" yy301: YYDEBUG(301, *YYCURSOR); yych = *++YYCURSOR; @@ -4167,16 +4158,11 @@ yy317: } YYDEBUG(320, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1707 "Zend/zend_language_scanner.l" +#line 1653 "Zend/zend_language_scanner.l" { - if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) { - ZVAL_DUP(zendlval, &CG(current_namespace)); - } else { - ZVAL_EMPTY_STRING(zendlval); - } return T_NS_C; } -#line 4180 "Zend/zend_language_scanner.c" +#line 4166 "Zend/zend_language_scanner.c" yy321: YYDEBUG(321, *YYCURSOR); yych = *++YYCURSOR; @@ -4196,7 +4182,7 @@ yy322: } YYDEBUG(325, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1682 "Zend/zend_language_scanner.l" +#line 1628 "Zend/zend_language_scanner.l" { zend_string *filename = zend_get_compiled_filename(TSRMLS_C); zend_string *dirname; @@ -4221,7 +4207,7 @@ yy322: ZVAL_STR(zendlval, dirname); return T_DIR; } -#line 4225 "Zend/zend_language_scanner.c" +#line 4211 "Zend/zend_language_scanner.c" yy326: YYDEBUG(326, *YYCURSOR); yych = *++YYCURSOR; @@ -4246,12 +4232,12 @@ yy328: } YYDEBUG(331, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1666 "Zend/zend_language_scanner.l" +#line 1612 "Zend/zend_language_scanner.l" { ZVAL_LONG(zendlval, CG(zend_lineno)); return T_LINE; } -#line 4255 "Zend/zend_language_scanner.c" +#line 4241 "Zend/zend_language_scanner.c" yy332: YYDEBUG(332, *YYCURSOR); yych = *++YYCURSOR; @@ -4286,39 +4272,11 @@ yy336: } YYDEBUG(339, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1634 "Zend/zend_language_scanner.l" +#line 1608 "Zend/zend_language_scanner.l" { - if (CG(active_class_entry)) { - int len = 0; - - if (CG(active_class_entry)->name) { - len += CG(active_class_entry)->name->len; - } - if (CG(active_op_array) && CG(active_op_array)->function_name) { - len += sizeof("::")-1; - len += CG(active_op_array)->function_name->len; - } - ZVAL_NEW_STR(zendlval, zend_string_alloc(len, 0)); - len = 0; - if (CG(active_class_entry)->name) { - memcpy(Z_STRVAL_P(zendlval), CG(active_class_entry)->name->val, CG(active_class_entry)->name->len); - len += CG(active_class_entry)->name->len; - } - if (CG(active_op_array) && CG(active_op_array)->function_name) { - memcpy(Z_STRVAL_P(zendlval) + len, "::", sizeof("::")-1); - len += sizeof("::")-1; - memcpy(Z_STRVAL_P(zendlval) + len, CG(active_op_array)->function_name->val, CG(active_op_array)->function_name->len); - len += CG(active_op_array)->function_name->len; - } - Z_STRVAL_P(zendlval)[len] = 0; - } else if (CG(active_op_array) && CG(active_op_array)->function_name) { - ZVAL_STR(zendlval, zend_string_copy(CG(active_op_array)->function_name)); - } else { - ZVAL_EMPTY_STRING(zendlval); - } return T_METHOD_C; } -#line 4322 "Zend/zend_language_scanner.c" +#line 4280 "Zend/zend_language_scanner.c" yy340: YYDEBUG(340, *YYCURSOR); yych = *++YYCURSOR; @@ -4369,17 +4327,11 @@ yy347: } YYDEBUG(350, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1624 "Zend/zend_language_scanner.l" +#line 1604 "Zend/zend_language_scanner.l" { - zend_op_array *op_array = CG(active_op_array); - if (op_array && op_array->function_name) { - ZVAL_STR(zendlval, zend_string_copy(op_array->function_name)); - } else { - ZVAL_EMPTY_STRING(zendlval); - } return T_FUNC_C; } -#line 4383 "Zend/zend_language_scanner.c" +#line 4335 "Zend/zend_language_scanner.c" yy351: YYDEBUG(351, *YYCURSOR); yych = *++YYCURSOR; @@ -4399,7 +4351,7 @@ yy352: } YYDEBUG(355, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1671 "Zend/zend_language_scanner.l" +#line 1617 "Zend/zend_language_scanner.l" { zend_string *filename = zend_get_compiled_filename(TSRMLS_C); @@ -4410,7 +4362,7 @@ yy352: } return T_FILE; } -#line 4414 "Zend/zend_language_scanner.c" +#line 4366 "Zend/zend_language_scanner.c" yy356: YYDEBUG(356, *YYCURSOR); yych = *++YYCURSOR; @@ -4440,17 +4392,11 @@ yy359: } YYDEBUG(362, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1614 "Zend/zend_language_scanner.l" +#line 1600 "Zend/zend_language_scanner.l" { - zend_class_entry *ce = CG(active_class_entry); - if (ce && ce->name && ZEND_ACC_TRAIT == (ce->ce_flags & ZEND_ACC_TRAIT)) { - ZVAL_STR(zendlval, zend_string_copy(ce->name)); - } else { - ZVAL_EMPTY_STRING(zendlval); - } return T_TRAIT_C; } -#line 4454 "Zend/zend_language_scanner.c" +#line 4400 "Zend/zend_language_scanner.c" yy363: YYDEBUG(363, *YYCURSOR); yych = *++YYCURSOR; @@ -4480,24 +4426,11 @@ yy366: } YYDEBUG(369, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1597 "Zend/zend_language_scanner.l" +#line 1596 "Zend/zend_language_scanner.l" { - zend_class_entry *ce = CG(active_class_entry); - if (ce && ZEND_ACC_TRAIT == (ce->ce_flags & ZEND_ACC_TRAIT)) { - /* We create a special __CLASS__ constant that is going to be resolved - at run-time */ - ZVAL_STRINGL(zendlval, "__CLASS__", sizeof("__CLASS__") - 1); - Z_TYPE_INFO_P(zendlval) = IS_CONSTANT_EX; - } else { - if (ce && ce->name) { - ZVAL_STR(zendlval, zend_string_copy(ce->name)); - } else { - ZVAL_EMPTY_STRING(zendlval); - } - } return T_CLASS_C; } -#line 4501 "Zend/zend_language_scanner.c" +#line 4434 "Zend/zend_language_scanner.c" yy370: YYDEBUG(370, *YYCURSOR); yych = *++YYCURSOR; @@ -4559,11 +4492,11 @@ yy381: } YYDEBUG(382, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1312 "Zend/zend_language_scanner.l" +#line 1311 "Zend/zend_language_scanner.l" { return T_HALT_COMPILER; } -#line 4567 "Zend/zend_language_scanner.c" +#line 4500 "Zend/zend_language_scanner.c" yy383: YYDEBUG(383, *YYCURSOR); yych = *++YYCURSOR; @@ -4583,11 +4516,11 @@ yy385: } YYDEBUG(386, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1292 "Zend/zend_language_scanner.l" +#line 1291 "Zend/zend_language_scanner.l" { return T_USE; } -#line 4591 "Zend/zend_language_scanner.c" +#line 4524 "Zend/zend_language_scanner.c" yy387: YYDEBUG(387, *YYCURSOR); yych = *++YYCURSOR; @@ -4606,11 +4539,11 @@ yy389: } YYDEBUG(390, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1340 "Zend/zend_language_scanner.l" +#line 1339 "Zend/zend_language_scanner.l" { return T_UNSET; } -#line 4614 "Zend/zend_language_scanner.c" +#line 4547 "Zend/zend_language_scanner.c" yy391: YYDEBUG(391, *YYCURSOR); ++YYCURSOR; @@ -4782,11 +4715,11 @@ yy406: ++YYCURSOR; YYDEBUG(408, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1240 "Zend/zend_language_scanner.l" +#line 1239 "Zend/zend_language_scanner.l" { return T_INT_CAST; } -#line 4790 "Zend/zend_language_scanner.c" +#line 4723 "Zend/zend_language_scanner.c" yy409: YYDEBUG(409, *YYCURSOR); yych = *++YYCURSOR; @@ -4830,11 +4763,11 @@ yy414: ++YYCURSOR; YYDEBUG(417, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1244 "Zend/zend_language_scanner.l" +#line 1243 "Zend/zend_language_scanner.l" { return T_DOUBLE_CAST; } -#line 4838 "Zend/zend_language_scanner.c" +#line 4771 "Zend/zend_language_scanner.c" yy418: YYDEBUG(418, *YYCURSOR); yych = *++YYCURSOR; @@ -4904,11 +4837,11 @@ yy428: ++YYCURSOR; YYDEBUG(431, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1248 "Zend/zend_language_scanner.l" +#line 1247 "Zend/zend_language_scanner.l" { return T_STRING_CAST; } -#line 4912 "Zend/zend_language_scanner.c" +#line 4845 "Zend/zend_language_scanner.c" yy432: YYDEBUG(432, *YYCURSOR); yych = *++YYCURSOR; @@ -4941,11 +4874,11 @@ yy435: ++YYCURSOR; YYDEBUG(438, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1252 "Zend/zend_language_scanner.l" +#line 1251 "Zend/zend_language_scanner.l" { return T_ARRAY_CAST; } -#line 4949 "Zend/zend_language_scanner.c" +#line 4882 "Zend/zend_language_scanner.c" yy439: YYDEBUG(439, *YYCURSOR); yych = *++YYCURSOR; @@ -4983,11 +4916,11 @@ yy443: ++YYCURSOR; YYDEBUG(446, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1256 "Zend/zend_language_scanner.l" +#line 1255 "Zend/zend_language_scanner.l" { return T_OBJECT_CAST; } -#line 4991 "Zend/zend_language_scanner.c" +#line 4924 "Zend/zend_language_scanner.c" yy447: YYDEBUG(447, *YYCURSOR); yych = *++YYCURSOR; @@ -5028,11 +4961,11 @@ yy452: ++YYCURSOR; YYDEBUG(454, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1260 "Zend/zend_language_scanner.l" +#line 1259 "Zend/zend_language_scanner.l" { return T_BOOL_CAST; } -#line 5036 "Zend/zend_language_scanner.c" +#line 4969 "Zend/zend_language_scanner.c" yy455: YYDEBUG(455, *YYCURSOR); yych = *++YYCURSOR; @@ -5092,11 +5025,11 @@ yy463: ++YYCURSOR; YYDEBUG(466, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1264 "Zend/zend_language_scanner.l" +#line 1263 "Zend/zend_language_scanner.l" { return T_UNSET_CAST; } -#line 5100 "Zend/zend_language_scanner.c" +#line 5033 "Zend/zend_language_scanner.c" yy467: YYDEBUG(467, *YYCURSOR); yych = *++YYCURSOR; @@ -5110,11 +5043,11 @@ yy468: } YYDEBUG(469, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1236 "Zend/zend_language_scanner.l" +#line 1235 "Zend/zend_language_scanner.l" { return T_VAR; } -#line 5118 "Zend/zend_language_scanner.c" +#line 5051 "Zend/zend_language_scanner.c" yy470: YYDEBUG(470, *YYCURSOR); yych = *++YYCURSOR; @@ -5134,11 +5067,11 @@ yy472: } YYDEBUG(473, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1228 "Zend/zend_language_scanner.l" +#line 1227 "Zend/zend_language_scanner.l" { return T_NEW; } -#line 5142 "Zend/zend_language_scanner.c" +#line 5075 "Zend/zend_language_scanner.c" yy474: YYDEBUG(474, *YYCURSOR); yych = *++YYCURSOR; @@ -5177,11 +5110,11 @@ yy480: } YYDEBUG(481, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1288 "Zend/zend_language_scanner.l" +#line 1287 "Zend/zend_language_scanner.l" { return T_NAMESPACE; } -#line 5185 "Zend/zend_language_scanner.c" +#line 5118 "Zend/zend_language_scanner.c" yy482: YYDEBUG(482, *YYCURSOR); yyaccept = 3; @@ -5203,11 +5136,11 @@ yy484: ++YYCURSOR; YYDEBUG(485, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1416 "Zend/zend_language_scanner.l" +#line 1415 "Zend/zend_language_scanner.l" { return T_CONCAT_EQUAL; } -#line 5211 "Zend/zend_language_scanner.c" +#line 5144 "Zend/zend_language_scanner.c" yy486: YYDEBUG(486, *YYCURSOR); yych = *++YYCURSOR; @@ -5216,21 +5149,21 @@ yy486: ++YYCURSOR; YYDEBUG(488, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1224 "Zend/zend_language_scanner.l" +#line 1223 "Zend/zend_language_scanner.l" { return T_ELLIPSIS; } -#line 5224 "Zend/zend_language_scanner.c" +#line 5157 "Zend/zend_language_scanner.c" yy489: YYDEBUG(489, *YYCURSOR); ++YYCURSOR; YYDEBUG(490, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1216 "Zend/zend_language_scanner.l" +#line 1215 "Zend/zend_language_scanner.l" { return T_PAAMAYIM_NEKUDOTAYIM; } -#line 5234 "Zend/zend_language_scanner.c" +#line 5167 "Zend/zend_language_scanner.c" yy491: YYDEBUG(491, *YYCURSOR); ++YYCURSOR; @@ -5252,21 +5185,21 @@ yy493: ++YYCURSOR; YYDEBUG(494, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1396 "Zend/zend_language_scanner.l" +#line 1395 "Zend/zend_language_scanner.l" { return T_MINUS_EQUAL; } -#line 5260 "Zend/zend_language_scanner.c" +#line 5193 "Zend/zend_language_scanner.c" yy495: YYDEBUG(495, *YYCURSOR); ++YYCURSOR; YYDEBUG(496, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1364 "Zend/zend_language_scanner.l" +#line 1363 "Zend/zend_language_scanner.l" { return T_DEC; } -#line 5270 "Zend/zend_language_scanner.c" +#line 5203 "Zend/zend_language_scanner.c" yy497: YYDEBUG(497, *YYCURSOR); ++YYCURSOR; @@ -5277,7 +5210,7 @@ yy497: yy_push_state(ST_LOOKING_FOR_PROPERTY TSRMLS_CC); return T_OBJECT_OPERATOR; } -#line 5281 "Zend/zend_language_scanner.c" +#line 5214 "Zend/zend_language_scanner.c" yy499: YYDEBUG(499, *YYCURSOR); yych = *++YYCURSOR; @@ -5322,11 +5255,11 @@ yy504: } YYDEBUG(505, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1336 "Zend/zend_language_scanner.l" +#line 1335 "Zend/zend_language_scanner.l" { return T_PUBLIC; } -#line 5330 "Zend/zend_language_scanner.c" +#line 5263 "Zend/zend_language_scanner.c" yy506: YYDEBUG(506, *YYCURSOR); yych = *++YYCURSOR; @@ -5381,11 +5314,11 @@ yy513: } YYDEBUG(514, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1332 "Zend/zend_language_scanner.l" +#line 1331 "Zend/zend_language_scanner.l" { return T_PROTECTED; } -#line 5389 "Zend/zend_language_scanner.c" +#line 5322 "Zend/zend_language_scanner.c" yy515: YYDEBUG(515, *YYCURSOR); yych = *++YYCURSOR; @@ -5415,11 +5348,11 @@ yy519: } YYDEBUG(520, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1328 "Zend/zend_language_scanner.l" +#line 1327 "Zend/zend_language_scanner.l" { return T_PRIVATE; } -#line 5423 "Zend/zend_language_scanner.c" +#line 5356 "Zend/zend_language_scanner.c" yy521: YYDEBUG(521, *YYCURSOR); ++YYCURSOR; @@ -5432,7 +5365,7 @@ yy521: { return T_PRINT; } -#line 5436 "Zend/zend_language_scanner.c" +#line 5369 "Zend/zend_language_scanner.c" yy523: YYDEBUG(523, *YYCURSOR); yych = *++YYCURSOR; @@ -5461,7 +5394,7 @@ yy526: { return T_GOTO; } -#line 5465 "Zend/zend_language_scanner.c" +#line 5398 "Zend/zend_language_scanner.c" yy528: YYDEBUG(528, *YYCURSOR); yych = *++YYCURSOR; @@ -5485,11 +5418,11 @@ yy531: } YYDEBUG(532, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1300 "Zend/zend_language_scanner.l" +#line 1299 "Zend/zend_language_scanner.l" { return T_GLOBAL; } -#line 5493 "Zend/zend_language_scanner.c" +#line 5426 "Zend/zend_language_scanner.c" yy533: YYDEBUG(533, *YYCURSOR); yych = *++YYCURSOR; @@ -5530,7 +5463,7 @@ yy539: { return T_BREAK; } -#line 5534 "Zend/zend_language_scanner.c" +#line 5467 "Zend/zend_language_scanner.c" yy541: YYDEBUG(541, *YYCURSOR); yych = *++YYCURSOR; @@ -5574,7 +5507,7 @@ yy547: { return T_SWITCH; } -#line 5578 "Zend/zend_language_scanner.c" +#line 5511 "Zend/zend_language_scanner.c" yy549: YYDEBUG(549, *YYCURSOR); yych = *++YYCURSOR; @@ -5598,11 +5531,11 @@ yy552: } YYDEBUG(553, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1316 "Zend/zend_language_scanner.l" +#line 1315 "Zend/zend_language_scanner.l" { return T_STATIC; } -#line 5606 "Zend/zend_language_scanner.c" +#line 5539 "Zend/zend_language_scanner.c" yy554: YYDEBUG(554, *YYCURSOR); yych = *++YYCURSOR; @@ -5633,7 +5566,7 @@ yy557: { return T_AS; } -#line 5637 "Zend/zend_language_scanner.c" +#line 5570 "Zend/zend_language_scanner.c" yy559: YYDEBUG(559, *YYCURSOR); yych = *++YYCURSOR; @@ -5652,11 +5585,11 @@ yy561: } YYDEBUG(562, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1352 "Zend/zend_language_scanner.l" +#line 1351 "Zend/zend_language_scanner.l" { return T_ARRAY; } -#line 5660 "Zend/zend_language_scanner.c" +#line 5593 "Zend/zend_language_scanner.c" yy563: YYDEBUG(563, *YYCURSOR); ++YYCURSOR; @@ -5665,11 +5598,11 @@ yy563: } YYDEBUG(564, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1456 "Zend/zend_language_scanner.l" +#line 1455 "Zend/zend_language_scanner.l" { return T_LOGICAL_AND; } -#line 5673 "Zend/zend_language_scanner.c" +#line 5606 "Zend/zend_language_scanner.c" yy565: YYDEBUG(565, *YYCURSOR); yych = *++YYCURSOR; @@ -5703,11 +5636,11 @@ yy570: } YYDEBUG(571, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1320 "Zend/zend_language_scanner.l" +#line 1319 "Zend/zend_language_scanner.l" { return T_ABSTRACT; } -#line 5711 "Zend/zend_language_scanner.c" +#line 5644 "Zend/zend_language_scanner.c" yy572: YYDEBUG(572, *YYCURSOR); yych = *++YYCURSOR; @@ -5735,7 +5668,7 @@ yy575: { return T_WHILE; } -#line 5739 "Zend/zend_language_scanner.c" +#line 5672 "Zend/zend_language_scanner.c" yy577: YYDEBUG(577, *YYCURSOR); ++YYCURSOR; @@ -5748,7 +5681,7 @@ yy577: { return T_IF; } -#line 5752 "Zend/zend_language_scanner.c" +#line 5685 "Zend/zend_language_scanner.c" yy579: YYDEBUG(579, *YYCURSOR); yych = *++YYCURSOR; @@ -5800,11 +5733,11 @@ yy584: } YYDEBUG(585, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1304 "Zend/zend_language_scanner.l" +#line 1303 "Zend/zend_language_scanner.l" { return T_ISSET; } -#line 5808 "Zend/zend_language_scanner.c" +#line 5741 "Zend/zend_language_scanner.c" yy586: YYDEBUG(586, *YYCURSOR); yych = *++YYCURSOR; @@ -5858,11 +5791,11 @@ yy592: yy593: YYDEBUG(593, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1272 "Zend/zend_language_scanner.l" +#line 1271 "Zend/zend_language_scanner.l" { return T_INCLUDE; } -#line 5866 "Zend/zend_language_scanner.c" +#line 5799 "Zend/zend_language_scanner.c" yy594: YYDEBUG(594, *YYCURSOR); yych = *++YYCURSOR; @@ -5891,11 +5824,11 @@ yy598: } YYDEBUG(599, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1276 "Zend/zend_language_scanner.l" +#line 1275 "Zend/zend_language_scanner.l" { return T_INCLUDE_ONCE; } -#line 5899 "Zend/zend_language_scanner.c" +#line 5832 "Zend/zend_language_scanner.c" yy600: YYDEBUG(600, *YYCURSOR); yych = *++YYCURSOR; @@ -5933,7 +5866,7 @@ yy605: { return T_INTERFACE; } -#line 5937 "Zend/zend_language_scanner.c" +#line 5870 "Zend/zend_language_scanner.c" yy607: YYDEBUG(607, *YYCURSOR); yych = *++YYCURSOR; @@ -5983,11 +5916,11 @@ yy613: } YYDEBUG(614, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1296 "Zend/zend_language_scanner.l" +#line 1295 "Zend/zend_language_scanner.l" { return T_INSTEADOF; } -#line 5991 "Zend/zend_language_scanner.c" +#line 5924 "Zend/zend_language_scanner.c" yy615: YYDEBUG(615, *YYCURSOR); yych = *++YYCURSOR; @@ -6020,7 +5953,7 @@ yy619: { return T_INSTANCEOF; } -#line 6024 "Zend/zend_language_scanner.c" +#line 5957 "Zend/zend_language_scanner.c" yy621: YYDEBUG(621, *YYCURSOR); yych = *++YYCURSOR; @@ -6068,7 +6001,7 @@ yy628: { return T_IMPLEMENTS; } -#line 6072 "Zend/zend_language_scanner.c" +#line 6005 "Zend/zend_language_scanner.c" yy630: YYDEBUG(630, *YYCURSOR); yych = *++YYCURSOR; @@ -6100,7 +6033,7 @@ yy631: { return T_TRY; } -#line 6104 "Zend/zend_language_scanner.c" +#line 6037 "Zend/zend_language_scanner.c" yy634: YYDEBUG(634, *YYCURSOR); yych = *++YYCURSOR; @@ -6123,7 +6056,7 @@ yy636: { return T_TRAIT; } -#line 6127 "Zend/zend_language_scanner.c" +#line 6060 "Zend/zend_language_scanner.c" yy638: YYDEBUG(638, *YYCURSOR); yych = *++YYCURSOR; @@ -6146,7 +6079,7 @@ yy640: { return T_THROW; } -#line 6150 "Zend/zend_language_scanner.c" +#line 6083 "Zend/zend_language_scanner.c" yy642: YYDEBUG(642, *YYCURSOR); yych = *++YYCURSOR; @@ -6174,7 +6107,7 @@ yy645: { return T_YIELD; } -#line 6178 "Zend/zend_language_scanner.c" +#line 6111 "Zend/zend_language_scanner.c" yy647: YYDEBUG(647, *YYCURSOR); yych = *++YYCURSOR; @@ -6235,11 +6168,11 @@ yy653: yy654: YYDEBUG(654, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1280 "Zend/zend_language_scanner.l" +#line 1279 "Zend/zend_language_scanner.l" { return T_REQUIRE; } -#line 6243 "Zend/zend_language_scanner.c" +#line 6176 "Zend/zend_language_scanner.c" yy655: YYDEBUG(655, *YYCURSOR); yych = *++YYCURSOR; @@ -6268,11 +6201,11 @@ yy659: } YYDEBUG(660, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1284 "Zend/zend_language_scanner.l" +#line 1283 "Zend/zend_language_scanner.l" { return T_REQUIRE_ONCE; } -#line 6276 "Zend/zend_language_scanner.c" +#line 6209 "Zend/zend_language_scanner.c" yy661: YYDEBUG(661, *YYCURSOR); yych = *++YYCURSOR; @@ -6295,7 +6228,7 @@ yy663: { return T_RETURN; } -#line 6299 "Zend/zend_language_scanner.c" +#line 6232 "Zend/zend_language_scanner.c" yy665: YYDEBUG(665, *YYCURSOR); yych = *++YYCURSOR; @@ -6389,7 +6322,7 @@ yy674: { return T_CONTINUE; } -#line 6393 "Zend/zend_language_scanner.c" +#line 6326 "Zend/zend_language_scanner.c" yy676: YYDEBUG(676, *YYCURSOR); ++YYCURSOR; @@ -6402,7 +6335,7 @@ yy676: { return T_CONST; } -#line 6406 "Zend/zend_language_scanner.c" +#line 6339 "Zend/zend_language_scanner.c" yy678: YYDEBUG(678, *YYCURSOR); yych = *++YYCURSOR; @@ -6427,11 +6360,11 @@ yy681: } YYDEBUG(682, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1232 "Zend/zend_language_scanner.l" +#line 1231 "Zend/zend_language_scanner.l" { return T_CLONE; } -#line 6435 "Zend/zend_language_scanner.c" +#line 6368 "Zend/zend_language_scanner.c" yy683: YYDEBUG(683, *YYCURSOR); yych = *++YYCURSOR; @@ -6449,7 +6382,7 @@ yy684: { return T_CLASS; } -#line 6453 "Zend/zend_language_scanner.c" +#line 6386 "Zend/zend_language_scanner.c" yy686: YYDEBUG(686, *YYCURSOR); yych = *++YYCURSOR; @@ -6495,11 +6428,11 @@ yy693: } YYDEBUG(694, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1356 "Zend/zend_language_scanner.l" +#line 1355 "Zend/zend_language_scanner.l" { return T_CALLABLE; } -#line 6503 "Zend/zend_language_scanner.c" +#line 6436 "Zend/zend_language_scanner.c" yy695: YYDEBUG(695, *YYCURSOR); ++YYCURSOR; @@ -6512,7 +6445,7 @@ yy695: { return T_CASE; } -#line 6516 "Zend/zend_language_scanner.c" +#line 6449 "Zend/zend_language_scanner.c" yy697: YYDEBUG(697, *YYCURSOR); yych = *++YYCURSOR; @@ -6530,7 +6463,7 @@ yy698: { return T_CATCH; } -#line 6534 "Zend/zend_language_scanner.c" +#line 6467 "Zend/zend_language_scanner.c" yy700: YYDEBUG(700, *YYCURSOR); yych = *++YYCURSOR; @@ -6585,7 +6518,7 @@ yy708: { return T_FUNCTION; } -#line 6589 "Zend/zend_language_scanner.c" +#line 6522 "Zend/zend_language_scanner.c" yy710: YYDEBUG(710, *YYCURSOR); ++YYCURSOR; @@ -6613,7 +6546,7 @@ yy711: { return T_FOR; } -#line 6617 "Zend/zend_language_scanner.c" +#line 6550 "Zend/zend_language_scanner.c" yy712: YYDEBUG(712, *YYCURSOR); yych = *++YYCURSOR; @@ -6641,7 +6574,7 @@ yy715: { return T_FOREACH; } -#line 6645 "Zend/zend_language_scanner.c" +#line 6578 "Zend/zend_language_scanner.c" yy717: YYDEBUG(717, *YYCURSOR); yych = *++YYCURSOR; @@ -6675,11 +6608,11 @@ yy719: yy720: YYDEBUG(720, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1324 "Zend/zend_language_scanner.l" +#line 1323 "Zend/zend_language_scanner.l" { return T_FINAL; } -#line 6683 "Zend/zend_language_scanner.c" +#line 6616 "Zend/zend_language_scanner.c" yy721: YYDEBUG(721, *YYCURSOR); yych = *++YYCURSOR; @@ -6697,7 +6630,7 @@ yy722: { return T_FINALLY; } -#line 6701 "Zend/zend_language_scanner.c" +#line 6634 "Zend/zend_language_scanner.c" yy724: YYDEBUG(724, *YYCURSOR); yych = *++YYCURSOR; @@ -6732,7 +6665,7 @@ yy726: { return T_DO; } -#line 6736 "Zend/zend_language_scanner.c" +#line 6669 "Zend/zend_language_scanner.c" yy728: YYDEBUG(728, *YYCURSOR); ++YYCURSOR; @@ -6745,7 +6678,7 @@ yy728: { return T_EXIT; } -#line 6749 "Zend/zend_language_scanner.c" +#line 6682 "Zend/zend_language_scanner.c" yy730: YYDEBUG(730, *YYCURSOR); yych = *++YYCURSOR; @@ -6784,7 +6717,7 @@ yy735: { return T_DEFAULT; } -#line 6788 "Zend/zend_language_scanner.c" +#line 6721 "Zend/zend_language_scanner.c" yy737: YYDEBUG(737, *YYCURSOR); yych = *++YYCURSOR; @@ -6812,7 +6745,7 @@ yy740: { return T_DECLARE; } -#line 6816 "Zend/zend_language_scanner.c" +#line 6749 "Zend/zend_language_scanner.c" yy742: YYDEBUG(742, *YYCURSOR); yych = *++YYCURSOR; @@ -6896,7 +6829,7 @@ yy753: { return T_EXTENDS; } -#line 6900 "Zend/zend_language_scanner.c" +#line 6833 "Zend/zend_language_scanner.c" yy755: YYDEBUG(755, *YYCURSOR); ++YYCURSOR; @@ -6909,7 +6842,7 @@ yy755: { return T_EXIT; } -#line 6913 "Zend/zend_language_scanner.c" +#line 6846 "Zend/zend_language_scanner.c" yy757: YYDEBUG(757, *YYCURSOR); yych = *++YYCURSOR; @@ -6923,11 +6856,11 @@ yy758: } YYDEBUG(759, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1268 "Zend/zend_language_scanner.l" +#line 1267 "Zend/zend_language_scanner.l" { return T_EVAL; } -#line 6931 "Zend/zend_language_scanner.c" +#line 6864 "Zend/zend_language_scanner.c" yy760: YYDEBUG(760, *YYCURSOR); yych = *++YYCURSOR; @@ -7001,7 +6934,7 @@ yy769: { return T_ENDWHILE; } -#line 7005 "Zend/zend_language_scanner.c" +#line 6938 "Zend/zend_language_scanner.c" yy771: YYDEBUG(771, *YYCURSOR); yych = *++YYCURSOR; @@ -7034,7 +6967,7 @@ yy775: { return T_ENDSWITCH; } -#line 7038 "Zend/zend_language_scanner.c" +#line 6971 "Zend/zend_language_scanner.c" yy777: YYDEBUG(777, *YYCURSOR); ++YYCURSOR; @@ -7047,7 +6980,7 @@ yy777: { return T_ENDIF; } -#line 7051 "Zend/zend_language_scanner.c" +#line 6984 "Zend/zend_language_scanner.c" yy779: YYDEBUG(779, *YYCURSOR); yych = *++YYCURSOR; @@ -7080,7 +7013,7 @@ yy781: { return T_ENDFOR; } -#line 7084 "Zend/zend_language_scanner.c" +#line 7017 "Zend/zend_language_scanner.c" yy782: YYDEBUG(782, *YYCURSOR); yych = *++YYCURSOR; @@ -7108,7 +7041,7 @@ yy785: { return T_ENDFOREACH; } -#line 7112 "Zend/zend_language_scanner.c" +#line 7045 "Zend/zend_language_scanner.c" yy787: YYDEBUG(787, *YYCURSOR); yych = *++YYCURSOR; @@ -7146,7 +7079,7 @@ yy792: { return T_ENDDECLARE; } -#line 7150 "Zend/zend_language_scanner.c" +#line 7083 "Zend/zend_language_scanner.c" yy794: YYDEBUG(794, *YYCURSOR); yych = *++YYCURSOR; @@ -7165,11 +7098,11 @@ yy796: } YYDEBUG(797, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1308 "Zend/zend_language_scanner.l" +#line 1307 "Zend/zend_language_scanner.l" { return T_EMPTY; } -#line 7173 "Zend/zend_language_scanner.c" +#line 7106 "Zend/zend_language_scanner.c" yy798: YYDEBUG(798, *YYCURSOR); yych = *++YYCURSOR; @@ -7202,7 +7135,7 @@ yy800: { return T_ELSE; } -#line 7206 "Zend/zend_language_scanner.c" +#line 7139 "Zend/zend_language_scanner.c" yy801: YYDEBUG(801, *YYCURSOR); yych = *++YYCURSOR; @@ -7220,7 +7153,7 @@ yy802: { return T_ELSEIF; } -#line 7224 "Zend/zend_language_scanner.c" +#line 7157 "Zend/zend_language_scanner.c" yy804: YYDEBUG(804, *YYCURSOR); yych = *++YYCURSOR; @@ -7238,7 +7171,7 @@ yy805: { return T_ECHO; } -#line 7242 "Zend/zend_language_scanner.c" +#line 7175 "Zend/zend_language_scanner.c" } /* *********************************** */ yyc_ST_LOOKING_FOR_PROPERTY: @@ -7313,11 +7246,10 @@ yy810: yyleng = YYCURSOR - SCNG(yy_text); #line 1194 "Zend/zend_language_scanner.l" { - DUMMY_STRINGL(zendlval, yytext, yyleng); HANDLE_NEWLINES(yytext, yyleng); return T_WHITESPACE; } -#line 7321 "Zend/zend_language_scanner.c" +#line 7253 "Zend/zend_language_scanner.c" yy811: YYDEBUG(811, *YYCURSOR); ++YYCURSOR; @@ -7325,13 +7257,13 @@ yy811: yy812: YYDEBUG(812, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1210 "Zend/zend_language_scanner.l" +#line 1209 "Zend/zend_language_scanner.l" { yyless(0); yy_pop_state(TSRMLS_C); goto restart; } -#line 7335 "Zend/zend_language_scanner.c" +#line 7267 "Zend/zend_language_scanner.c" yy813: YYDEBUG(813, *YYCURSOR); ++YYCURSOR; @@ -7340,13 +7272,13 @@ yy813: yy814: YYDEBUG(814, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1204 "Zend/zend_language_scanner.l" +#line 1203 "Zend/zend_language_scanner.l" { yy_pop_state(TSRMLS_C); zend_copy_value(zendlval, yytext, yyleng); return T_STRING; } -#line 7350 "Zend/zend_language_scanner.c" +#line 7282 "Zend/zend_language_scanner.c" yy815: YYDEBUG(815, *YYCURSOR); yych = *++YYCURSOR; @@ -7367,11 +7299,11 @@ yy818: ++YYCURSOR; YYDEBUG(819, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1200 "Zend/zend_language_scanner.l" +#line 1199 "Zend/zend_language_scanner.l" { return T_OBJECT_OPERATOR; } -#line 7375 "Zend/zend_language_scanner.c" +#line 7307 "Zend/zend_language_scanner.c" yy820: YYDEBUG(820, *YYCURSOR); ++YYCURSOR; @@ -7456,14 +7388,14 @@ yy824: yy825: YYDEBUG(825, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1507 "Zend/zend_language_scanner.l" +#line 1506 "Zend/zend_language_scanner.l" { yyless(0); yy_pop_state(TSRMLS_C); yy_push_state(ST_IN_SCRIPTING TSRMLS_CC); goto restart; } -#line 7467 "Zend/zend_language_scanner.c" +#line 7399 "Zend/zend_language_scanner.c" yy826: YYDEBUG(826, *YYCURSOR); yych = *++YYCURSOR; @@ -7488,7 +7420,7 @@ yy830: ++YYCURSOR; YYDEBUG(831, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1498 "Zend/zend_language_scanner.l" +#line 1497 "Zend/zend_language_scanner.l" { yyless(yyleng - 1); zend_copy_value(zendlval, yytext, yyleng); @@ -7496,7 +7428,7 @@ yy830: yy_push_state(ST_IN_SCRIPTING TSRMLS_CC); return T_STRING_VARNAME; } -#line 7500 "Zend/zend_language_scanner.c" +#line 7432 "Zend/zend_language_scanner.c" } /* *********************************** */ yyc_ST_NOWDOC: @@ -7507,7 +7439,7 @@ yyc_ST_NOWDOC: ++YYCURSOR; YYDEBUG(835, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 2338 "Zend/zend_language_scanner.l" +#line 2271 "Zend/zend_language_scanner.l" { int newline = 0; @@ -7563,7 +7495,7 @@ nowdoc_scan_done: HANDLE_NEWLINES(yytext, yyleng - newline); return T_ENCAPSED_AND_WHITESPACE; } -#line 7567 "Zend/zend_language_scanner.c" +#line 7499 "Zend/zend_language_scanner.c" /* *********************************** */ yyc_ST_VAR_OFFSET: { @@ -7670,7 +7602,7 @@ yy838: yy839: YYDEBUG(839, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1578 "Zend/zend_language_scanner.l" +#line 1577 "Zend/zend_language_scanner.l" { /* Offset could be treated as a long */ if (yyleng < MAX_LENGTH_OF_LONG - 1 || (yyleng == MAX_LENGTH_OF_LONG - 1 && strcmp(yytext, long_min_digits) < 0)) { ZVAL_LONG(zendlval, ZEND_STRTOL(yytext, NULL, 10)); @@ -7679,7 +7611,7 @@ yy839: } return T_NUM_STRING; } -#line 7683 "Zend/zend_language_scanner.c" +#line 7615 "Zend/zend_language_scanner.c" yy840: YYDEBUG(840, *YYCURSOR); yych = *++YYCURSOR; @@ -7699,23 +7631,23 @@ yy841: yy842: YYDEBUG(842, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1870 "Zend/zend_language_scanner.l" +#line 1805 "Zend/zend_language_scanner.l" { /* Only '[' can be valid, but returning other tokens will allow a more explicit parse error */ return yytext[0]; } -#line 7708 "Zend/zend_language_scanner.c" +#line 7640 "Zend/zend_language_scanner.c" yy843: YYDEBUG(843, *YYCURSOR); ++YYCURSOR; YYDEBUG(844, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1865 "Zend/zend_language_scanner.l" +#line 1800 "Zend/zend_language_scanner.l" { yy_pop_state(TSRMLS_C); return ']'; } -#line 7719 "Zend/zend_language_scanner.c" +#line 7651 "Zend/zend_language_scanner.c" yy845: YYDEBUG(845, *YYCURSOR); yych = *++YYCURSOR; @@ -7725,14 +7657,14 @@ yy846: ++YYCURSOR; YYDEBUG(847, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1875 "Zend/zend_language_scanner.l" +#line 1810 "Zend/zend_language_scanner.l" { /* Invalid rule to return a more explicit parse error with proper line number */ yyless(0); yy_pop_state(TSRMLS_C); return T_ENCAPSED_AND_WHITESPACE; } -#line 7736 "Zend/zend_language_scanner.c" +#line 7668 "Zend/zend_language_scanner.c" yy848: YYDEBUG(848, *YYCURSOR); ++YYCURSOR; @@ -7741,18 +7673,18 @@ yy848: yy849: YYDEBUG(849, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1882 "Zend/zend_language_scanner.l" +#line 1817 "Zend/zend_language_scanner.l" { zend_copy_value(zendlval, yytext, yyleng); return T_STRING; } -#line 7750 "Zend/zend_language_scanner.c" +#line 7682 "Zend/zend_language_scanner.c" yy850: YYDEBUG(850, *YYCURSOR); ++YYCURSOR; YYDEBUG(851, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 2395 "Zend/zend_language_scanner.l" +#line 2328 "Zend/zend_language_scanner.l" { if (YYCURSOR > YYLIMIT) { return 0; @@ -7761,7 +7693,7 @@ yy850: zend_error(E_COMPILE_WARNING,"Unexpected character in input: '%c' (ASCII=%d) state=%d", yytext[0], yytext[0], YYSTATE); goto restart; } -#line 7765 "Zend/zend_language_scanner.c" +#line 7697 "Zend/zend_language_scanner.c" yy852: YYDEBUG(852, *YYCURSOR); ++YYCURSOR; @@ -7797,12 +7729,12 @@ yy854: yy856: YYDEBUG(856, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1860 "Zend/zend_language_scanner.l" +#line 1795 "Zend/zend_language_scanner.l" { zend_copy_value(zendlval, (yytext+1), (yyleng-1)); return T_VARIABLE; } -#line 7806 "Zend/zend_language_scanner.c" +#line 7738 "Zend/zend_language_scanner.c" yy857: YYDEBUG(857, *YYCURSOR); ++YYCURSOR; @@ -7842,12 +7774,12 @@ yy862: yy864: YYDEBUG(864, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1587 "Zend/zend_language_scanner.l" +#line 1586 "Zend/zend_language_scanner.l" { /* Offset must be treated as a string */ ZVAL_STRINGL(zendlval, yytext, yyleng); return T_NUM_STRING; } -#line 7851 "Zend/zend_language_scanner.c" +#line 7783 "Zend/zend_language_scanner.c" yy865: YYDEBUG(865, *YYCURSOR); ++YYCURSOR; @@ -7870,6 +7802,6 @@ yy867: goto yy864; } } -#line 2404 "Zend/zend_language_scanner.l" +#line 2337 "Zend/zend_language_scanner.l" } diff --git a/Zend/zend_language_scanner.l b/Zend/zend_language_scanner.l index 66fa0cc7bf..fb016b4af8 100644 --- a/Zend/zend_language_scanner.l +++ b/Zend/zend_language_scanner.l @@ -559,11 +559,10 @@ ZEND_API zend_op_array *compile_file(zend_file_handle *file_handle, int type TSR zend_op_array *retval=NULL; int compiler_result; zend_bool compilation_successful=0; - znode retval_znode; + zval retval_zv; zend_bool original_in_compilation = CG(in_compilation); - retval_znode.op_type = IS_CONST; - ZVAL_LONG(&retval_znode.u.constant, 1); + ZVAL_LONG(&retval_zv, 1); zend_save_lexical_state(&original_lex_state TSRMLS_CC); @@ -583,12 +582,17 @@ ZEND_API zend_op_array *compile_file(zend_file_handle *file_handle, int type TSR CG(active_op_array) = op_array; zend_stack_push(&CG(context_stack), (void *) &CG(context)); zend_init_compiler_context(TSRMLS_C); + CG(ast_arena) = zend_arena_create(1024 * 32); compiler_result = zendparse(TSRMLS_C); - zend_do_return(&retval_znode, 0 TSRMLS_CC); - CG(in_compilation) = original_in_compilation; if (compiler_result != 0) { /* parser error */ zend_bailout(); } + zend_compile_top_stmt(CG(ast) TSRMLS_CC); + zend_ast_destroy(CG(ast)); + zend_arena_destroy(CG(ast_arena)); + zend_do_end_compilation(TSRMLS_C); + zend_emit_final_return(&retval_zv TSRMLS_CC); + CG(in_compilation) = original_in_compilation; compilation_successful=1; } @@ -750,6 +754,7 @@ zend_op_array *compile_string(zval *source_string, char *filename TSRMLS_DC) zend_stack_push(&CG(context_stack), (void *) &CG(context)); zend_init_compiler_context(TSRMLS_C); BEGIN(ST_IN_SCRIPTING); + CG(ast_arena) = zend_arena_create(1024 * 32); compiler_result = zendparse(TSRMLS_C); if (SCNG(script_filtered)) { @@ -764,7 +769,11 @@ zend_op_array *compile_string(zval *source_string, char *filename TSRMLS_DC) efree(op_array); retval = NULL; } else { - zend_do_return(NULL, 0 TSRMLS_CC); + zend_compile_top_stmt(CG(ast) TSRMLS_CC); + zend_ast_destroy(CG(ast)); + zend_arena_destroy(CG(ast_arena)); + zend_do_end_compilation(TSRMLS_C); + zend_emit_final_return(NULL TSRMLS_CC); CG(active_op_array) = original_active_op_array; pass_two(op_array TSRMLS_CC); zend_release_labels(0 TSRMLS_CC); @@ -874,15 +883,6 @@ ZEND_API void zend_multibyte_yyinput_again(zend_encoding_filter old_input_filter ZVAL_STRINGL(zendlval, yytext, yyleng); \ } -// TODO: some extensions might need content, but we don't copy it intentional ??? -#if 0 -# define DUMMY_STRINGL(zendlval, yytext, yyleng) \ - ZVAL_STRINGL(zendlval, yytext, yyleng) -#else -# define DUMMY_STRINGL(zendlval, yytext, yyleng) \ - ZVAL_EMPTY_STRING(zendlval) -#endif - static void zend_scan_escape_string(zval *zendlval, char *str, int len, char quote_type TSRMLS_DC) { register char *s, *t; @@ -1192,7 +1192,6 @@ NEWLINE ("\r"|"\n"|"\r\n") } <ST_IN_SCRIPTING,ST_LOOKING_FOR_PROPERTY>{WHITESPACE}+ { - DUMMY_STRINGL(zendlval, yytext, yyleng); HANDLE_NEWLINES(yytext, yyleng); return T_WHITESPACE; } @@ -1595,71 +1594,18 @@ NEWLINE ("\r"|"\n"|"\r\n") } <ST_IN_SCRIPTING>"__CLASS__" { - zend_class_entry *ce = CG(active_class_entry); - if (ce && ZEND_ACC_TRAIT == (ce->ce_flags & ZEND_ACC_TRAIT)) { - /* We create a special __CLASS__ constant that is going to be resolved - at run-time */ - ZVAL_STRINGL(zendlval, "__CLASS__", sizeof("__CLASS__") - 1); - Z_TYPE_INFO_P(zendlval) = IS_CONSTANT_EX; - } else { - if (ce && ce->name) { - ZVAL_STR(zendlval, zend_string_copy(ce->name)); - } else { - ZVAL_EMPTY_STRING(zendlval); - } - } return T_CLASS_C; } <ST_IN_SCRIPTING>"__TRAIT__" { - zend_class_entry *ce = CG(active_class_entry); - if (ce && ce->name && ZEND_ACC_TRAIT == (ce->ce_flags & ZEND_ACC_TRAIT)) { - ZVAL_STR(zendlval, zend_string_copy(ce->name)); - } else { - ZVAL_EMPTY_STRING(zendlval); - } return T_TRAIT_C; } <ST_IN_SCRIPTING>"__FUNCTION__" { - zend_op_array *op_array = CG(active_op_array); - if (op_array && op_array->function_name) { - ZVAL_STR(zendlval, zend_string_copy(op_array->function_name)); - } else { - ZVAL_EMPTY_STRING(zendlval); - } return T_FUNC_C; } <ST_IN_SCRIPTING>"__METHOD__" { - if (CG(active_class_entry)) { - int len = 0; - - if (CG(active_class_entry)->name) { - len += CG(active_class_entry)->name->len; - } - if (CG(active_op_array) && CG(active_op_array)->function_name) { - len += sizeof("::")-1; - len += CG(active_op_array)->function_name->len; - } - ZVAL_NEW_STR(zendlval, zend_string_alloc(len, 0)); - len = 0; - if (CG(active_class_entry)->name) { - memcpy(Z_STRVAL_P(zendlval), CG(active_class_entry)->name->val, CG(active_class_entry)->name->len); - len += CG(active_class_entry)->name->len; - } - if (CG(active_op_array) && CG(active_op_array)->function_name) { - memcpy(Z_STRVAL_P(zendlval) + len, "::", sizeof("::")-1); - len += sizeof("::")-1; - memcpy(Z_STRVAL_P(zendlval) + len, CG(active_op_array)->function_name->val, CG(active_op_array)->function_name->len); - len += CG(active_op_array)->function_name->len; - } - Z_STRVAL_P(zendlval)[len] = 0; - } else if (CG(active_op_array) && CG(active_op_array)->function_name) { - ZVAL_STR(zendlval, zend_string_copy(CG(active_op_array)->function_name)); - } else { - ZVAL_EMPTY_STRING(zendlval); - } return T_METHOD_C; } @@ -1705,11 +1651,6 @@ NEWLINE ("\r"|"\n"|"\r\n") } <ST_IN_SCRIPTING>"__NAMESPACE__" { - if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) { - ZVAL_DUP(zendlval, &CG(current_namespace)); - } else { - ZVAL_EMPTY_STRING(zendlval); - } return T_NS_C; } @@ -1723,7 +1664,6 @@ NEWLINE ("\r"|"\n"|"\r\n") } HANDLE_NEWLINES(yytext, yyleng); - DUMMY_STRINGL(zendlval, yytext, yyleng); BEGIN(ST_IN_SCRIPTING); return T_OPEN_TAG; } @@ -1731,7 +1671,6 @@ NEWLINE ("\r"|"\n"|"\r\n") <INITIAL>"<%=" { if (CG(asp_tags)) { - DUMMY_STRINGL(zendlval, yytext, yyleng); BEGIN(ST_IN_SCRIPTING); return T_OPEN_TAG_WITH_ECHO; } else { @@ -1741,7 +1680,6 @@ NEWLINE ("\r"|"\n"|"\r\n") <INITIAL>"<?=" { - DUMMY_STRINGL(zendlval, yytext, yyleng); BEGIN(ST_IN_SCRIPTING); return T_OPEN_TAG_WITH_ECHO; } @@ -1749,7 +1687,6 @@ NEWLINE ("\r"|"\n"|"\r\n") <INITIAL>"<%" { if (CG(asp_tags)) { - DUMMY_STRINGL(zendlval, yytext, yyleng); BEGIN(ST_IN_SCRIPTING); return T_OPEN_TAG; } else { @@ -1759,7 +1696,6 @@ NEWLINE ("\r"|"\n"|"\r\n") <INITIAL>"<?php"([ \t]|{NEWLINE}) { - DUMMY_STRINGL(zendlval, yytext, yyleng); HANDLE_NEWLINE(yytext[yyleng-1]); BEGIN(ST_IN_SCRIPTING); return T_OPEN_TAG; @@ -1768,7 +1704,6 @@ NEWLINE ("\r"|"\n"|"\r\n") <INITIAL>"<?" { if (CG(short_tags)) { - DUMMY_STRINGL(zendlval, yytext, yyleng); BEGIN(ST_IN_SCRIPTING); return T_OPEN_TAG; } else { @@ -1953,7 +1888,6 @@ inline_html: } <ST_IN_SCRIPTING>("?>"|"</script"{WHITESPACE}*">"){NEWLINE}? { - DUMMY_STRINGL(zendlval, yytext, yyleng); BEGIN(INITIAL); return T_CLOSE_TAG; /* implicit ';' at php-end tag */ } @@ -1962,7 +1896,6 @@ inline_html: <ST_IN_SCRIPTING>"%>"{NEWLINE}? { if (CG(asp_tags)) { BEGIN(INITIAL); - DUMMY_STRINGL(zendlval, yytext, yyleng); return T_CLOSE_TAG; /* implicit ';' at php-end tag */ } else { yyless(1); diff --git a/Zend/zend_opcode.c b/Zend/zend_opcode.c index d09f28b0dc..a893a34078 100644 --- a/Zend/zend_opcode.c +++ b/Zend/zend_opcode.c @@ -79,6 +79,7 @@ void init_op_array(zend_op_array *op_array, zend_uchar type, int initial_ops_siz op_array->required_num_args = 0; op_array->scope = NULL; + op_array->prototype = NULL; op_array->brk_cont_array = NULL; op_array->try_catch_array = NULL; @@ -795,13 +796,10 @@ ZEND_API unary_op_type get_unary_op(int opcode) switch (opcode) { case ZEND_BW_NOT: return (unary_op_type) bitwise_not_function; - break; case ZEND_BOOL_NOT: return (unary_op_type) boolean_not_function; - break; default: return (unary_op_type) NULL; - break; } } @@ -811,74 +809,54 @@ ZEND_API binary_op_type get_binary_op(int opcode) case ZEND_ADD: case ZEND_ASSIGN_ADD: return (binary_op_type) add_function; - break; case ZEND_SUB: case ZEND_ASSIGN_SUB: return (binary_op_type) sub_function; - break; case ZEND_MUL: case ZEND_ASSIGN_MUL: return (binary_op_type) mul_function; - break; case ZEND_POW: return (binary_op_type) pow_function; - break; case ZEND_DIV: case ZEND_ASSIGN_DIV: return (binary_op_type) div_function; - break; case ZEND_MOD: case ZEND_ASSIGN_MOD: return (binary_op_type) mod_function; - break; case ZEND_SL: case ZEND_ASSIGN_SL: return (binary_op_type) shift_left_function; - break; case ZEND_SR: case ZEND_ASSIGN_SR: return (binary_op_type) shift_right_function; - break; case ZEND_CONCAT: case ZEND_ASSIGN_CONCAT: return (binary_op_type) concat_function; - break; case ZEND_IS_IDENTICAL: return (binary_op_type) is_identical_function; - break; case ZEND_IS_NOT_IDENTICAL: return (binary_op_type) is_not_identical_function; - break; case ZEND_IS_EQUAL: return (binary_op_type) is_equal_function; - break; case ZEND_IS_NOT_EQUAL: return (binary_op_type) is_not_equal_function; - break; case ZEND_IS_SMALLER: return (binary_op_type) is_smaller_function; - break; case ZEND_IS_SMALLER_OR_EQUAL: return (binary_op_type) is_smaller_or_equal_function; - break; case ZEND_BW_OR: case ZEND_ASSIGN_BW_OR: return (binary_op_type) bitwise_or_function; - break; case ZEND_BW_AND: case ZEND_ASSIGN_BW_AND: return (binary_op_type) bitwise_and_function; - break; case ZEND_BW_XOR: case ZEND_ASSIGN_BW_XOR: return (binary_op_type) bitwise_xor_function; - break; case ZEND_BOOL_XOR: return (binary_op_type) boolean_xor_function; - break; default: return (binary_op_type) NULL; - break; } } diff --git a/Zend/zend_operators.h b/Zend/zend_operators.h index a7f920bbac..a5b324e8b9 100644 --- a/Zend/zend_operators.h +++ b/Zend/zend_operators.h @@ -448,7 +448,7 @@ END_EXTERN_C() } #define convert_to_boolean_ex(pzv) convert_to_ex_master(pzv, boolean, _IS_BOOL) -#define convert_to_long_ex(pzv) convert_to_ex_master(pzv, int, IS_LONG) +#define convert_to_long_ex(pzv) convert_to_ex_master(pzv, long, IS_LONG) #define convert_to_double_ex(pzv) convert_to_ex_master(pzv, double, IS_DOUBLE) #define convert_to_string_ex(pzv) convert_to_ex_master(pzv, string, IS_STRING) #define convert_to_array_ex(pzv) convert_to_ex_master(pzv, array, IS_ARRAY) diff --git a/Zend/zend_types.h b/Zend/zend_types.h index a76704beed..d2b562ecd9 100644 --- a/Zend/zend_types.h +++ b/Zend/zend_types.h @@ -132,6 +132,7 @@ struct _zval_struct { uint32_t next; /* hash collision chain */ uint32_t str_offset; /* string offset */ uint32_t cache_slot; /* literal cache slot */ + uint32_t lineno; /* line number (for ast nodes) */ } u2; }; diff --git a/Zend/zend_variables.c b/Zend/zend_variables.c index 1ec3ffb7ca..df6dbd179a 100644 --- a/Zend/zend_variables.c +++ b/Zend/zend_variables.c @@ -53,7 +53,7 @@ ZEND_API void _zval_dtor_func(zend_refcounted *p ZEND_FILE_LINE_DC) case IS_CONSTANT_AST: { zend_ast_ref *ast = (zend_ast_ref*)p; - zend_ast_destroy(ast->ast); + zend_ast_destroy_and_free(ast->ast); efree(ast); break; } @@ -113,7 +113,7 @@ ZEND_API void _zval_dtor_func_for_ptr(zend_refcounted *p ZEND_FILE_LINE_DC) case IS_CONSTANT_AST: { zend_ast_ref *ast = (zend_ast_ref*)p; - zend_ast_destroy(ast->ast); + zend_ast_destroy_and_free(ast->ast); efree(ast); break; } diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 8358ff5862..1586b4441c 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -1318,7 +1318,7 @@ ZEND_VM_HANDLER(87, ZEND_FETCH_DIM_RW, VAR|CV, CONST|TMP|VAR|UNUSED|CV) ZEND_VM_NEXT_OPCODE(); } -ZEND_VM_HANDLER(90, ZEND_FETCH_DIM_IS, VAR|CV, CONST|TMP|VAR|CV) +ZEND_VM_HANDLER(90, ZEND_FETCH_DIM_IS, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV) { USE_OPLINE zend_free_op free_op1, free_op2; @@ -1333,7 +1333,7 @@ ZEND_VM_HANDLER(90, ZEND_FETCH_DIM_IS, VAR|CV, CONST|TMP|VAR|CV) ZEND_VM_NEXT_OPCODE(); } -ZEND_VM_HANDLER(93, ZEND_FETCH_DIM_FUNC_ARG, VAR|CV, CONST|TMP|VAR|UNUSED|CV) +ZEND_VM_HANDLER(93, ZEND_FETCH_DIM_FUNC_ARG, CONST|TMP|VAR|CV, CONST|TMP|VAR|UNUSED|CV) { USE_OPLINE zval *container; @@ -1342,6 +1342,9 @@ ZEND_VM_HANDLER(93, ZEND_FETCH_DIM_FUNC_ARG, VAR|CV, CONST|TMP|VAR|UNUSED|CV) SAVE_OPLINE(); if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { + if (OP1_TYPE == IS_CONST || OP1_TYPE == IS_TMP_VAR) { + zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context"); + } container = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W); if (OP1_TYPE == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); @@ -1387,7 +1390,7 @@ ZEND_VM_HANDLER(96, ZEND_FETCH_DIM_UNSET, VAR|CV, CONST|TMP|VAR|CV) ZEND_VM_NEXT_OPCODE(); } -ZEND_VM_HELPER(zend_fetch_property_address_read_helper, VAR|UNUSED|CV, CONST|TMP|VAR|CV) +ZEND_VM_HELPER(zend_fetch_property_address_read_helper, CONST|TMP|VAR|UNUSED|CV, CONST|TMP|VAR|CV) { USE_OPLINE zend_free_op free_op1; @@ -1420,7 +1423,7 @@ ZEND_VM_HELPER(zend_fetch_property_address_read_helper, VAR|UNUSED|CV, CONST|TMP ZEND_VM_NEXT_OPCODE(); } -ZEND_VM_HANDLER(82, ZEND_FETCH_OBJ_R, VAR|UNUSED|CV, CONST|TMP|VAR|CV) +ZEND_VM_HANDLER(82, ZEND_FETCH_OBJ_R, CONST|TMP|VAR|UNUSED|CV, CONST|TMP|VAR|CV) { ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_property_address_read_helper); } @@ -1474,7 +1477,7 @@ ZEND_VM_HANDLER(88, ZEND_FETCH_OBJ_RW, VAR|UNUSED|CV, CONST|TMP|VAR|CV) ZEND_VM_NEXT_OPCODE(); } -ZEND_VM_HANDLER(91, ZEND_FETCH_OBJ_IS, VAR|UNUSED|CV, CONST|TMP|VAR|CV) +ZEND_VM_HANDLER(91, ZEND_FETCH_OBJ_IS, CONST|TMP|VAR|UNUSED|CV, CONST|TMP|VAR|CV) { USE_OPLINE zend_free_op free_op1; @@ -1506,7 +1509,7 @@ ZEND_VM_HANDLER(91, ZEND_FETCH_OBJ_IS, VAR|UNUSED|CV, CONST|TMP|VAR|CV) ZEND_VM_NEXT_OPCODE(); } -ZEND_VM_HANDLER(94, ZEND_FETCH_OBJ_FUNC_ARG, VAR|UNUSED|CV, CONST|TMP|VAR|CV) +ZEND_VM_HANDLER(94, ZEND_FETCH_OBJ_FUNC_ARG, CONST|TMP|VAR|UNUSED|CV, CONST|TMP|VAR|CV) { USE_OPLINE zval *container; @@ -1520,6 +1523,9 @@ ZEND_VM_HANDLER(94, ZEND_FETCH_OBJ_FUNC_ARG, VAR|UNUSED|CV, CONST|TMP|VAR|CV) property = GET_OP2_ZVAL_PTR(BP_VAR_R); container = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_W); + if (OP1_TYPE == IS_CONST || OP1_TYPE == IS_TMP_VAR) { + zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context"); + } if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } @@ -2382,7 +2388,7 @@ ZEND_VM_HANDLER(59, ZEND_INIT_FCALL_BY_NAME, ANY, CONST|TMP|VAR|CV) zend_function *fbc; zval *function_name, *func; - if (OP2_TYPE == IS_CONST) { + if (OP2_TYPE == IS_CONST && Z_TYPE_P(opline->op2.zv) == IS_STRING) { function_name = (zval*)(opline->op2.zv+1); if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); @@ -2423,10 +2429,11 @@ ZEND_VM_HANDLER(59, ZEND_INIT_FCALL_BY_NAME, ANY, CONST|TMP|VAR|CV) } zend_string_free(lcname); FREE_OP2(); + fbc = Z_FUNC_P(func); called_scope = NULL; object = NULL; - } else if (OP2_TYPE != IS_CONST && OP2_TYPE != IS_TMP_VAR && + } else if (OP2_TYPE != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_OBJECT) && Z_OBJ_HANDLER_P(function_name, get_closure) && Z_OBJ_HANDLER_P(function_name, get_closure)(function_name, &called_scope, &fbc, &object TSRMLS_CC) == SUCCESS) { @@ -2437,11 +2444,10 @@ ZEND_VM_HANDLER(59, ZEND_INIT_FCALL_BY_NAME, ANY, CONST|TMP|VAR|CV) fbc->common.fn_flags & ZEND_ACC_CLOSURE) { /* Delay closure destruction until its invocation */ fbc->common.prototype = (zend_function*)Z_OBJ_P(function_name_ptr); - } else { + } else if (OP2_TYPE == IS_CV) { FREE_OP2(); } - } else if (OP2_TYPE != IS_CONST && - EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY) && + } else if (EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY) && zend_hash_num_elements(Z_ARRVAL_P(function_name)) == 2) { zval *obj; zval *method; @@ -4868,7 +4874,7 @@ ZEND_VM_HANDLER(114, ZEND_ISSET_ISEMPTY_VAR, CONST|TMP|VAR|CV, UNUSED|CONST|VAR) ZEND_VM_NEXT_OPCODE(); } -ZEND_VM_HANDLER(115, ZEND_ISSET_ISEMPTY_DIM_OBJ, VAR|UNUSED|CV, CONST|TMP|VAR|CV) +ZEND_VM_HANDLER(115, ZEND_ISSET_ISEMPTY_DIM_OBJ, CONST|TMP|VAR|UNUSED|CV, CONST|TMP|VAR|CV) { USE_OPLINE zend_free_op free_op1, free_op2; @@ -4977,12 +4983,12 @@ ZEND_VM_C_LABEL(num_index_prop): FREE_OP2(); ZVAL_BOOL(EX_VAR(opline->result.var), result); - FREE_OP1_IF_VAR(); + FREE_OP1(); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } -ZEND_VM_HANDLER(148, ZEND_ISSET_ISEMPTY_PROP_OBJ, VAR|UNUSED|CV, CONST|TMP|VAR|CV) +ZEND_VM_HANDLER(148, ZEND_ISSET_ISEMPTY_PROP_OBJ, CONST|TMP|VAR|UNUSED|CV, CONST|TMP|VAR|CV) { USE_OPLINE zend_free_op free_op1, free_op2; @@ -5010,7 +5016,7 @@ ZEND_VM_HANDLER(148, ZEND_ISSET_ISEMPTY_PROP_OBJ, VAR|UNUSED|CV, CONST|TMP|VAR|C FREE_OP2(); ZVAL_BOOL(EX_VAR(opline->result.var), result); - FREE_OP1_IF_VAR(); + FREE_OP1(); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -5945,8 +5951,8 @@ ZEND_VM_HANDLER(123, ZEND_TYPE_CHECK, CONST|TMP|VAR|CV, ANY) } else { ZVAL_FALSE(EX_VAR(opline->result.var)); } + break; EMPTY_SWITCH_DEFAULT_CASE() - } FREE_OP1(); CHECK_EXCEPTION(); diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 08e6205978..b772753ea4 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -1553,7 +1553,7 @@ static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE zend_function *fbc; zval *function_name, *func; - if (IS_CONST == IS_CONST) { + if (IS_CONST == IS_CONST && Z_TYPE_P(opline->op2.zv) == IS_STRING) { function_name = (zval*)(opline->op2.zv+1); if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); @@ -1597,7 +1597,7 @@ static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE fbc = Z_FUNC_P(func); called_scope = NULL; object = NULL; - } else if (IS_CONST != IS_CONST && IS_CONST != IS_TMP_VAR && + } else if (IS_CONST != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_OBJECT) && Z_OBJ_HANDLER_P(function_name, get_closure) && Z_OBJ_HANDLER_P(function_name, get_closure)(function_name, &called_scope, &fbc, &object TSRMLS_CC) == SUCCESS) { @@ -1608,11 +1608,10 @@ static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE fbc->common.fn_flags & ZEND_ACC_CLOSURE) { /* Delay closure destruction until its invocation */ fbc->common.prototype = (zend_function*)Z_OBJ_P(function_name_ptr); - } else { + } else if (IS_CONST == IS_CV) { } - } else if (IS_CONST != IS_CONST && - EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY) && + } else if (EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY) && zend_hash_num_elements(Z_ARRVAL_P(function_name)) == 2) { zval *obj; zval *method; @@ -1882,7 +1881,7 @@ static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_TMP_HANDLER(ZEND_OPCODE_H zend_function *fbc; zval *function_name, *func; - if (IS_TMP_VAR == IS_CONST) { + if (IS_TMP_VAR == IS_CONST && Z_TYPE_P(opline->op2.zv) == IS_STRING) { function_name = (zval*)(opline->op2.zv+1); if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); @@ -1923,10 +1922,11 @@ static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_TMP_HANDLER(ZEND_OPCODE_H } zend_string_free(lcname); zval_dtor(free_op2.var); + fbc = Z_FUNC_P(func); called_scope = NULL; object = NULL; - } else if (IS_TMP_VAR != IS_CONST && IS_TMP_VAR != IS_TMP_VAR && + } else if (IS_TMP_VAR != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_OBJECT) && Z_OBJ_HANDLER_P(function_name, get_closure) && Z_OBJ_HANDLER_P(function_name, get_closure)(function_name, &called_scope, &fbc, &object TSRMLS_CC) == SUCCESS) { @@ -1937,11 +1937,10 @@ static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_TMP_HANDLER(ZEND_OPCODE_H fbc->common.fn_flags & ZEND_ACC_CLOSURE) { /* Delay closure destruction until its invocation */ fbc->common.prototype = (zend_function*)Z_OBJ_P(function_name_ptr); - } else { + } else if (IS_TMP_VAR == IS_CV) { zval_dtor(free_op2.var); } - } else if (IS_TMP_VAR != IS_CONST && - EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY) && + } else if (EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY) && zend_hash_num_elements(Z_ARRVAL_P(function_name)) == 2) { zval *obj; zval *method; @@ -2056,7 +2055,7 @@ static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_VAR_HANDLER(ZEND_OPCODE_H zend_function *fbc; zval *function_name, *func; - if (IS_VAR == IS_CONST) { + if (IS_VAR == IS_CONST && Z_TYPE_P(opline->op2.zv) == IS_STRING) { function_name = (zval*)(opline->op2.zv+1); if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); @@ -2097,10 +2096,11 @@ static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_VAR_HANDLER(ZEND_OPCODE_H } zend_string_free(lcname); zval_ptr_dtor_nogc(free_op2.var); + fbc = Z_FUNC_P(func); called_scope = NULL; object = NULL; - } else if (IS_VAR != IS_CONST && IS_VAR != IS_TMP_VAR && + } else if (IS_VAR != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_OBJECT) && Z_OBJ_HANDLER_P(function_name, get_closure) && Z_OBJ_HANDLER_P(function_name, get_closure)(function_name, &called_scope, &fbc, &object TSRMLS_CC) == SUCCESS) { @@ -2111,11 +2111,10 @@ static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_VAR_HANDLER(ZEND_OPCODE_H fbc->common.fn_flags & ZEND_ACC_CLOSURE) { /* Delay closure destruction until its invocation */ fbc->common.prototype = (zend_function*)Z_OBJ_P(function_name_ptr); - } else { + } else if (IS_VAR == IS_CV) { zval_ptr_dtor_nogc(free_op2.var); } - } else if (IS_VAR != IS_CONST && - EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY) && + } else if (EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY) && zend_hash_num_elements(Z_ARRVAL_P(function_name)) == 2) { zval *obj; zval *method; @@ -2268,7 +2267,7 @@ static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER(ZEND_OPCODE_HA zend_function *fbc; zval *function_name, *func; - if (IS_CV == IS_CONST) { + if (IS_CV == IS_CONST && Z_TYPE_P(opline->op2.zv) == IS_STRING) { function_name = (zval*)(opline->op2.zv+1); if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); @@ -2312,7 +2311,7 @@ static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER(ZEND_OPCODE_HA fbc = Z_FUNC_P(func); called_scope = NULL; object = NULL; - } else if (IS_CV != IS_CONST && IS_CV != IS_TMP_VAR && + } else if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_OBJECT) && Z_OBJ_HANDLER_P(function_name, get_closure) && Z_OBJ_HANDLER_P(function_name, get_closure)(function_name, &called_scope, &fbc, &object TSRMLS_CC) == SUCCESS) { @@ -2323,11 +2322,10 @@ static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER(ZEND_OPCODE_HA fbc->common.fn_flags & ZEND_ACC_CLOSURE) { /* Delay closure destruction until its invocation */ fbc->common.prototype = (zend_function*)Z_OBJ_P(function_name_ptr); - } else { + } else if (IS_CV == IS_CV) { } - } else if (IS_CV != IS_CONST && - EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY) && + } else if (EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY) && zend_hash_num_elements(Z_ARRVAL_P(function_name)) == 2) { zval *obj; zval *method; @@ -3450,8 +3448,8 @@ static int ZEND_FASTCALL ZEND_TYPE_CHECK_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER } else { ZVAL_FALSE(EX_VAR(opline->result.var)); } + break; EMPTY_SWITCH_DEFAULT_CASE() - } CHECK_EXCEPTION(); @@ -3923,6 +3921,157 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_ ZEND_VM_NEXT_OPCODE(); } +static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + + zval *container; + + SAVE_OPLINE(); + container = opline->op1.zv; + zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC); + + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *container; + zend_free_op free_op1; + + SAVE_OPLINE(); + + if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { + if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) { + zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context"); + } + container = NULL; + if (IS_CONST == IS_VAR && UNEXPECTED(container == NULL)) { + zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); + } + zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC); + if (IS_CONST == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); + } + + + } else { + if (IS_CONST == IS_UNUSED) { + zend_error_noreturn(E_ERROR, "Cannot use [] for reading"); + } + container = opline->op1.zv; + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC); + + + } + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CONST_CONST(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + + zval *container; + + zval *offset; + + SAVE_OPLINE(); + container = opline->op1.zv; + offset = opline->op2.zv; + + if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || + UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { + zend_error(E_NOTICE, "Trying to get property of non-object"); + ZVAL_NULL(EX_VAR(opline->result.var)); + } else { + zval *retval; + + /* here we are sure we are dealing with an object */ + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); + + if (retval != EX_VAR(opline->result.var)) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); + } + } + + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + return zend_fetch_property_address_read_helper_SPEC_CONST_CONST(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +} + +static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + + zval *container; + + zval *offset; + + SAVE_OPLINE(); + container = opline->op1.zv; + offset = opline->op2.zv; + + if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || + UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } else { + zval *retval; + + /* here we are sure we are dealing with an object */ + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); + + if (retval != EX_VAR(opline->result.var)) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); + } + } + + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *container; + + if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { + /* Behave like FETCH_OBJ_W */ + zend_free_op free_op1; + zval *property; + + SAVE_OPLINE(); + property = opline->op2.zv; + container = NULL; + + if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) { + zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context"); + } + if (IS_CONST == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { + zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); + } + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W, 0 TSRMLS_CC); + + if (IS_CONST == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); + } + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); + } else { + return zend_fetch_property_address_read_helper_SPEC_CONST_CONST(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +} + static int ZEND_FASTCALL ZEND_FETCH_DIM_TMP_VAR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -4485,6 +4634,151 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_CONST_HANDLER(ZEND_O ZEND_VM_NEXT_OPCODE(); } +static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + + zval *container; + int result; + zend_ulong hval; + zval *offset; + + SAVE_OPLINE(); + container = opline->op1.zv; + offset = opline->op2.zv; + + if (Z_TYPE_P(container) == IS_ARRAY) { + HashTable *ht = Z_ARRVAL_P(container); + zval *value; + zend_string *str; + +isset_again: + if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { + str = Z_STR_P(offset); + if (IS_CONST != IS_CONST) { + if (ZEND_HANDLE_NUMERIC(str, hval)) { + goto num_index_prop; + } + } +str_index_prop: + value = zend_hash_find_ind(ht, str); + } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { + hval = Z_LVAL_P(offset); +num_index_prop: + value = zend_hash_index_find(ht, hval); + } else { + switch (Z_TYPE_P(offset)) { + case IS_DOUBLE: + hval = zend_dval_to_lval(Z_DVAL_P(offset)); + goto num_index_prop; + case IS_NULL: + str = STR_EMPTY_ALLOC(); + goto str_index_prop; + case IS_FALSE: + hval = 0; + goto num_index_prop; + case IS_TRUE: + hval = 1; + goto num_index_prop; + case IS_RESOURCE: + hval = Z_RES_HANDLE_P(offset); + goto num_index_prop; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto isset_again; + default: + zend_error(E_WARNING, "Illegal offset type in isset or empty"); + value = NULL; + break; + } + } + + if (opline->extended_value & ZEND_ISSET) { + /* > IS_NULL means not IS_UNDEF and not IS_NULL */ + result = value != NULL && Z_TYPE_P(value) > IS_NULL && + (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL); + } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { + result = (value == NULL || !i_zend_is_true(value TSRMLS_CC)); + } + } else if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->has_dimension) { + result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC); + } else { + zend_error(E_NOTICE, "Trying to check element of non-array"); + result = 0; + } + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } + } else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */ + zval tmp; + + result = 0; + if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) { + if (IS_CONST == IS_CV || IS_CONST == IS_VAR) { + ZVAL_DEREF(offset); + } + if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */ + || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */ + && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) { + ZVAL_DUP(&tmp, offset); + convert_to_long(&tmp); + offset = &tmp; + } + } + if (Z_TYPE_P(offset) == IS_LONG) { + if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) { + if ((opline->extended_value & ZEND_ISSET) || + Z_STRVAL_P(container)[offset->value.lval] != '0') { + result = 1; + } + } + } + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } + } else { + result = ((opline->extended_value & ZEND_ISSET) == 0); + } + + ZVAL_BOOL(EX_VAR(opline->result.var), result); + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + + zval *container; + int result; + zval *offset; + + SAVE_OPLINE(); + container = opline->op1.zv; + offset = opline->op2.zv; + + if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->has_property) { + result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); + } else { + zend_error(E_NOTICE, "Trying to check property of non-object"); + result = 0; + } + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } + } else { + result = ((opline->extended_value & ZEND_ISSET) == 0); + } + + ZVAL_BOOL(EX_VAR(opline->result.var), result); + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + static int ZEND_FASTCALL ZEND_DECLARE_CONST_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -4955,6 +5249,159 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HA ZEND_VM_NEXT_OPCODE(); } +static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_free_op free_op2; + zval *container; + + SAVE_OPLINE(); + container = opline->op1.zv; + zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR TSRMLS_CC); + zval_dtor(free_op2.var); + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *container; + zend_free_op free_op1, free_op2; + + SAVE_OPLINE(); + + if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { + if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) { + zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context"); + } + container = NULL; + if (IS_CONST == IS_VAR && UNEXPECTED(container == NULL)) { + zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); + } + zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR TSRMLS_CC); + if (IS_CONST == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); + } + zval_dtor(free_op2.var); + + } else { + if (IS_TMP_VAR == IS_UNUSED) { + zend_error_noreturn(E_ERROR, "Cannot use [] for reading"); + } + container = opline->op1.zv; + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR TSRMLS_CC); + zval_dtor(free_op2.var); + + } + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CONST_TMP(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + + zval *container; + zend_free_op free_op2; + zval *offset; + + SAVE_OPLINE(); + container = opline->op1.zv; + offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + + if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || + UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { + zend_error(E_NOTICE, "Trying to get property of non-object"); + ZVAL_NULL(EX_VAR(opline->result.var)); + } else { + zval *retval; + + /* here we are sure we are dealing with an object */ + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); + + if (retval != EX_VAR(opline->result.var)) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); + } + } + + zval_dtor(free_op2.var); + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + return zend_fetch_property_address_read_helper_SPEC_CONST_TMP(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +} + +static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + + zval *container; + zend_free_op free_op2; + zval *offset; + + SAVE_OPLINE(); + container = opline->op1.zv; + offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + + if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || + UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } else { + zval *retval; + + /* here we are sure we are dealing with an object */ + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_TMP_VAR == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); + + if (retval != EX_VAR(opline->result.var)) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); + } + } + + zval_dtor(free_op2.var); + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *container; + + if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { + /* Behave like FETCH_OBJ_W */ + zend_free_op free_op1, free_op2; + zval *property; + + SAVE_OPLINE(); + property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + container = NULL; + + if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) { + zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context"); + } + if (IS_CONST == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { + zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); + } + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W, 0 TSRMLS_CC); + zval_dtor(free_op2.var); + if (IS_CONST == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); + } + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); + } else { + return zend_fetch_property_address_read_helper_SPEC_CONST_TMP(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +} + static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -5248,6 +5695,153 @@ static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HAN } } +static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_free_op free_op2; + zval *container; + int result; + zend_ulong hval; + zval *offset; + + SAVE_OPLINE(); + container = opline->op1.zv; + offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + + if (Z_TYPE_P(container) == IS_ARRAY) { + HashTable *ht = Z_ARRVAL_P(container); + zval *value; + zend_string *str; + +isset_again: + if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { + str = Z_STR_P(offset); + if (IS_TMP_VAR != IS_CONST) { + if (ZEND_HANDLE_NUMERIC(str, hval)) { + goto num_index_prop; + } + } +str_index_prop: + value = zend_hash_find_ind(ht, str); + } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { + hval = Z_LVAL_P(offset); +num_index_prop: + value = zend_hash_index_find(ht, hval); + } else { + switch (Z_TYPE_P(offset)) { + case IS_DOUBLE: + hval = zend_dval_to_lval(Z_DVAL_P(offset)); + goto num_index_prop; + case IS_NULL: + str = STR_EMPTY_ALLOC(); + goto str_index_prop; + case IS_FALSE: + hval = 0; + goto num_index_prop; + case IS_TRUE: + hval = 1; + goto num_index_prop; + case IS_RESOURCE: + hval = Z_RES_HANDLE_P(offset); + goto num_index_prop; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto isset_again; + default: + zend_error(E_WARNING, "Illegal offset type in isset or empty"); + value = NULL; + break; + } + } + + if (opline->extended_value & ZEND_ISSET) { + /* > IS_NULL means not IS_UNDEF and not IS_NULL */ + result = value != NULL && Z_TYPE_P(value) > IS_NULL && + (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL); + } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { + result = (value == NULL || !i_zend_is_true(value TSRMLS_CC)); + } + } else if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->has_dimension) { + result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC); + } else { + zend_error(E_NOTICE, "Trying to check element of non-array"); + result = 0; + } + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } + } else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */ + zval tmp; + + result = 0; + if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) { + if (IS_CONST == IS_CV || IS_CONST == IS_VAR) { + ZVAL_DEREF(offset); + } + if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */ + || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */ + && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) { + ZVAL_DUP(&tmp, offset); + convert_to_long(&tmp); + offset = &tmp; + } + } + if (Z_TYPE_P(offset) == IS_LONG) { + if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) { + if ((opline->extended_value & ZEND_ISSET) || + Z_STRVAL_P(container)[offset->value.lval] != '0') { + result = 1; + } + } + } + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } + } else { + result = ((opline->extended_value & ZEND_ISSET) == 0); + } + + zval_dtor(free_op2.var); + ZVAL_BOOL(EX_VAR(opline->result.var), result); + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_free_op free_op2; + zval *container; + int result; + zval *offset; + + SAVE_OPLINE(); + container = opline->op1.zv; + offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + + if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->has_property) { + result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_TMP_VAR == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); + } else { + zend_error(E_NOTICE, "Trying to check property of non-object"); + result = 0; + } + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } + } else { + result = ((opline->extended_value & ZEND_ISSET) == 0); + } + + zval_dtor(free_op2.var); + ZVAL_BOOL(EX_VAR(opline->result.var), result); + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + static int ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -5838,6 +6432,159 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HA ZEND_VM_NEXT_OPCODE(); } +static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_free_op free_op2; + zval *container; + + SAVE_OPLINE(); + container = opline->op1.zv; + zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR TSRMLS_CC); + zval_ptr_dtor_nogc(free_op2.var); + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *container; + zend_free_op free_op1, free_op2; + + SAVE_OPLINE(); + + if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { + if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) { + zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context"); + } + container = NULL; + if (IS_CONST == IS_VAR && UNEXPECTED(container == NULL)) { + zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); + } + zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR TSRMLS_CC); + if (IS_CONST == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); + } + zval_ptr_dtor_nogc(free_op2.var); + + } else { + if (IS_VAR == IS_UNUSED) { + zend_error_noreturn(E_ERROR, "Cannot use [] for reading"); + } + container = opline->op1.zv; + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR TSRMLS_CC); + zval_ptr_dtor_nogc(free_op2.var); + + } + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CONST_VAR(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + + zval *container; + zend_free_op free_op2; + zval *offset; + + SAVE_OPLINE(); + container = opline->op1.zv; + offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + + if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || + UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { + zend_error(E_NOTICE, "Trying to get property of non-object"); + ZVAL_NULL(EX_VAR(opline->result.var)); + } else { + zval *retval; + + /* here we are sure we are dealing with an object */ + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_VAR == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); + + if (retval != EX_VAR(opline->result.var)) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); + } + } + + zval_ptr_dtor_nogc(free_op2.var); + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + return zend_fetch_property_address_read_helper_SPEC_CONST_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +} + +static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + + zval *container; + zend_free_op free_op2; + zval *offset; + + SAVE_OPLINE(); + container = opline->op1.zv; + offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + + if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || + UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } else { + zval *retval; + + /* here we are sure we are dealing with an object */ + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_VAR == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); + + if (retval != EX_VAR(opline->result.var)) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); + } + } + + zval_ptr_dtor_nogc(free_op2.var); + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *container; + + if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { + /* Behave like FETCH_OBJ_W */ + zend_free_op free_op1, free_op2; + zval *property; + + SAVE_OPLINE(); + property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + container = NULL; + + if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) { + zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context"); + } + if (IS_CONST == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { + zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); + } + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W, 0 TSRMLS_CC); + zval_ptr_dtor_nogc(free_op2.var); + if (IS_CONST == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); + } + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); + } else { + return zend_fetch_property_address_read_helper_SPEC_CONST_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +} + static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -6283,6 +7030,153 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_VAR_HANDLER(ZEND_OPC ZEND_VM_NEXT_OPCODE(); } +static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_free_op free_op2; + zval *container; + int result; + zend_ulong hval; + zval *offset; + + SAVE_OPLINE(); + container = opline->op1.zv; + offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + + if (Z_TYPE_P(container) == IS_ARRAY) { + HashTable *ht = Z_ARRVAL_P(container); + zval *value; + zend_string *str; + +isset_again: + if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { + str = Z_STR_P(offset); + if (IS_VAR != IS_CONST) { + if (ZEND_HANDLE_NUMERIC(str, hval)) { + goto num_index_prop; + } + } +str_index_prop: + value = zend_hash_find_ind(ht, str); + } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { + hval = Z_LVAL_P(offset); +num_index_prop: + value = zend_hash_index_find(ht, hval); + } else { + switch (Z_TYPE_P(offset)) { + case IS_DOUBLE: + hval = zend_dval_to_lval(Z_DVAL_P(offset)); + goto num_index_prop; + case IS_NULL: + str = STR_EMPTY_ALLOC(); + goto str_index_prop; + case IS_FALSE: + hval = 0; + goto num_index_prop; + case IS_TRUE: + hval = 1; + goto num_index_prop; + case IS_RESOURCE: + hval = Z_RES_HANDLE_P(offset); + goto num_index_prop; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto isset_again; + default: + zend_error(E_WARNING, "Illegal offset type in isset or empty"); + value = NULL; + break; + } + } + + if (opline->extended_value & ZEND_ISSET) { + /* > IS_NULL means not IS_UNDEF and not IS_NULL */ + result = value != NULL && Z_TYPE_P(value) > IS_NULL && + (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL); + } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { + result = (value == NULL || !i_zend_is_true(value TSRMLS_CC)); + } + } else if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->has_dimension) { + result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC); + } else { + zend_error(E_NOTICE, "Trying to check element of non-array"); + result = 0; + } + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } + } else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */ + zval tmp; + + result = 0; + if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) { + if (IS_CONST == IS_CV || IS_CONST == IS_VAR) { + ZVAL_DEREF(offset); + } + if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */ + || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */ + && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) { + ZVAL_DUP(&tmp, offset); + convert_to_long(&tmp); + offset = &tmp; + } + } + if (Z_TYPE_P(offset) == IS_LONG) { + if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) { + if ((opline->extended_value & ZEND_ISSET) || + Z_STRVAL_P(container)[offset->value.lval] != '0') { + result = 1; + } + } + } + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } + } else { + result = ((opline->extended_value & ZEND_ISSET) == 0); + } + + zval_ptr_dtor_nogc(free_op2.var); + ZVAL_BOOL(EX_VAR(opline->result.var), result); + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_free_op free_op2; + zval *container; + int result; + zval *offset; + + SAVE_OPLINE(); + container = opline->op1.zv; + offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + + if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->has_property) { + result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_VAR == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); + } else { + zend_error(E_NOTICE, "Trying to check property of non-object"); + result = 0; + } + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } + } else { + result = ((opline->extended_value & ZEND_ISSET) == 0); + } + + zval_ptr_dtor_nogc(free_op2.var); + ZVAL_BOOL(EX_VAR(opline->result.var), result); + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + static int ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -6581,6 +7475,41 @@ static int ZEND_FASTCALL ZEND_FETCH_IS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HA return zend_fetch_var_address_helper_SPEC_CONST_UNUSED(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } +static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *container; + zend_free_op free_op1; + + SAVE_OPLINE(); + + if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { + if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) { + zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context"); + } + container = NULL; + if (IS_CONST == IS_VAR && UNEXPECTED(container == NULL)) { + zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); + } + zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, NULL, IS_UNUSED TSRMLS_CC); + if (IS_CONST == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); + } + + + } else { + if (IS_UNUSED == IS_UNUSED) { + zend_error_noreturn(E_ERROR, "Cannot use [] for reading"); + } + container = opline->op1.zv; + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, NULL, IS_UNUSED TSRMLS_CC); + + + } + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -7415,6 +8344,157 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HAN ZEND_VM_NEXT_OPCODE(); } +static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + + zval *container; + + SAVE_OPLINE(); + container = opline->op1.zv; + zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC); + + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *container; + zend_free_op free_op1; + + SAVE_OPLINE(); + + if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { + if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) { + zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context"); + } + container = NULL; + if (IS_CONST == IS_VAR && UNEXPECTED(container == NULL)) { + zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); + } + zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC); + if (IS_CONST == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); + } + + + } else { + if (IS_CV == IS_UNUSED) { + zend_error_noreturn(E_ERROR, "Cannot use [] for reading"); + } + container = opline->op1.zv; + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC); + + + } + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CONST_CV(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + + zval *container; + + zval *offset; + + SAVE_OPLINE(); + container = opline->op1.zv; + offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); + + if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || + UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { + zend_error(E_NOTICE, "Trying to get property of non-object"); + ZVAL_NULL(EX_VAR(opline->result.var)); + } else { + zval *retval; + + /* here we are sure we are dealing with an object */ + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); + + if (retval != EX_VAR(opline->result.var)) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); + } + } + + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + return zend_fetch_property_address_read_helper_SPEC_CONST_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +} + +static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + + zval *container; + + zval *offset; + + SAVE_OPLINE(); + container = opline->op1.zv; + offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); + + if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || + UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } else { + zval *retval; + + /* here we are sure we are dealing with an object */ + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); + + if (retval != EX_VAR(opline->result.var)) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); + } + } + + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *container; + + if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { + /* Behave like FETCH_OBJ_W */ + zend_free_op free_op1; + zval *property; + + SAVE_OPLINE(); + property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); + container = NULL; + + if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) { + zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context"); + } + if (IS_CONST == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { + zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); + } + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W, 0 TSRMLS_CC); + + if (IS_CONST == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); + } + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); + } else { + return zend_fetch_property_address_read_helper_SPEC_CONST_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +} + static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -7759,6 +8839,151 @@ static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HAND } } +static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + + zval *container; + int result; + zend_ulong hval; + zval *offset; + + SAVE_OPLINE(); + container = opline->op1.zv; + offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); + + if (Z_TYPE_P(container) == IS_ARRAY) { + HashTable *ht = Z_ARRVAL_P(container); + zval *value; + zend_string *str; + +isset_again: + if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { + str = Z_STR_P(offset); + if (IS_CV != IS_CONST) { + if (ZEND_HANDLE_NUMERIC(str, hval)) { + goto num_index_prop; + } + } +str_index_prop: + value = zend_hash_find_ind(ht, str); + } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { + hval = Z_LVAL_P(offset); +num_index_prop: + value = zend_hash_index_find(ht, hval); + } else { + switch (Z_TYPE_P(offset)) { + case IS_DOUBLE: + hval = zend_dval_to_lval(Z_DVAL_P(offset)); + goto num_index_prop; + case IS_NULL: + str = STR_EMPTY_ALLOC(); + goto str_index_prop; + case IS_FALSE: + hval = 0; + goto num_index_prop; + case IS_TRUE: + hval = 1; + goto num_index_prop; + case IS_RESOURCE: + hval = Z_RES_HANDLE_P(offset); + goto num_index_prop; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto isset_again; + default: + zend_error(E_WARNING, "Illegal offset type in isset or empty"); + value = NULL; + break; + } + } + + if (opline->extended_value & ZEND_ISSET) { + /* > IS_NULL means not IS_UNDEF and not IS_NULL */ + result = value != NULL && Z_TYPE_P(value) > IS_NULL && + (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL); + } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { + result = (value == NULL || !i_zend_is_true(value TSRMLS_CC)); + } + } else if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->has_dimension) { + result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC); + } else { + zend_error(E_NOTICE, "Trying to check element of non-array"); + result = 0; + } + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } + } else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */ + zval tmp; + + result = 0; + if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) { + if (IS_CONST == IS_CV || IS_CONST == IS_VAR) { + ZVAL_DEREF(offset); + } + if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */ + || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */ + && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) { + ZVAL_DUP(&tmp, offset); + convert_to_long(&tmp); + offset = &tmp; + } + } + if (Z_TYPE_P(offset) == IS_LONG) { + if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) { + if ((opline->extended_value & ZEND_ISSET) || + Z_STRVAL_P(container)[offset->value.lval] != '0') { + result = 1; + } + } + } + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } + } else { + result = ((opline->extended_value & ZEND_ISSET) == 0); + } + + ZVAL_BOOL(EX_VAR(opline->result.var), result); + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + + zval *container; + int result; + zval *offset; + + SAVE_OPLINE(); + container = opline->op1.zv; + offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); + + if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->has_property) { + result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); + } else { + zend_error(E_NOTICE, "Trying to check property of non-object"); + result = 0; + } + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } + } else { + result = ((opline->extended_value & ZEND_ISSET) == 0); + } + + ZVAL_BOOL(EX_VAR(opline->result.var), result); + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + static int ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -9024,8 +10249,8 @@ static int ZEND_FASTCALL ZEND_TYPE_CHECK_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_A } else { ZVAL_FALSE(EX_VAR(opline->result.var)); } + break; EMPTY_SWITCH_DEFAULT_CASE() - } zval_dtor(free_op1.var); CHECK_EXCEPTION(); @@ -9477,6 +10702,157 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HA ZEND_VM_NEXT_OPCODE(); } +static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_free_op free_op1; + zval *container; + + SAVE_OPLINE(); + container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC); + + zval_dtor(free_op1.var); + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *container; + zend_free_op free_op1; + + SAVE_OPLINE(); + + if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { + if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) { + zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context"); + } + container = NULL; + if (IS_TMP_VAR == IS_VAR && UNEXPECTED(container == NULL)) { + zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); + } + zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC); + if (IS_TMP_VAR == IS_VAR && 1 && READY_TO_DESTROY(free_op1.var)) { + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); + } + + + } else { + if (IS_CONST == IS_UNUSED) { + zend_error_noreturn(E_ERROR, "Cannot use [] for reading"); + } + container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC); + + zval_dtor(free_op1.var); + } + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_TMP_CONST(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_free_op free_op1; + zval *container; + + zval *offset; + + SAVE_OPLINE(); + container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + offset = opline->op2.zv; + + if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || + UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { + zend_error(E_NOTICE, "Trying to get property of non-object"); + ZVAL_NULL(EX_VAR(opline->result.var)); + } else { + zval *retval; + + /* here we are sure we are dealing with an object */ + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); + + if (retval != EX_VAR(opline->result.var)) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); + } + } + + zval_dtor(free_op1.var); + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + return zend_fetch_property_address_read_helper_SPEC_TMP_CONST(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +} + +static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_free_op free_op1; + zval *container; + + zval *offset; + + SAVE_OPLINE(); + container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + offset = opline->op2.zv; + + if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || + UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } else { + zval *retval; + + /* here we are sure we are dealing with an object */ + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); + + if (retval != EX_VAR(opline->result.var)) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); + } + } + + zval_dtor(free_op1.var); + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *container; + + if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { + /* Behave like FETCH_OBJ_W */ + zend_free_op free_op1; + zval *property; + + SAVE_OPLINE(); + property = opline->op2.zv; + container = NULL; + + if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) { + zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context"); + } + if (IS_TMP_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { + zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); + } + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W, 0 TSRMLS_CC); + + if (IS_TMP_VAR == IS_VAR && 1 && READY_TO_DESTROY(free_op1.var)) { + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); + } + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); + } else { + return zend_fetch_property_address_read_helper_SPEC_TMP_CONST(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +} + static int ZEND_FASTCALL ZEND_FETCH_DIM_TMP_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -9893,6 +11269,151 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPC ZEND_VM_NEXT_OPCODE(); } +static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_free_op free_op1; + zval *container; + int result; + zend_ulong hval; + zval *offset; + + SAVE_OPLINE(); + container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + offset = opline->op2.zv; + + if (Z_TYPE_P(container) == IS_ARRAY) { + HashTable *ht = Z_ARRVAL_P(container); + zval *value; + zend_string *str; + +isset_again: + if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { + str = Z_STR_P(offset); + if (IS_CONST != IS_CONST) { + if (ZEND_HANDLE_NUMERIC(str, hval)) { + goto num_index_prop; + } + } +str_index_prop: + value = zend_hash_find_ind(ht, str); + } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { + hval = Z_LVAL_P(offset); +num_index_prop: + value = zend_hash_index_find(ht, hval); + } else { + switch (Z_TYPE_P(offset)) { + case IS_DOUBLE: + hval = zend_dval_to_lval(Z_DVAL_P(offset)); + goto num_index_prop; + case IS_NULL: + str = STR_EMPTY_ALLOC(); + goto str_index_prop; + case IS_FALSE: + hval = 0; + goto num_index_prop; + case IS_TRUE: + hval = 1; + goto num_index_prop; + case IS_RESOURCE: + hval = Z_RES_HANDLE_P(offset); + goto num_index_prop; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto isset_again; + default: + zend_error(E_WARNING, "Illegal offset type in isset or empty"); + value = NULL; + break; + } + } + + if (opline->extended_value & ZEND_ISSET) { + /* > IS_NULL means not IS_UNDEF and not IS_NULL */ + result = value != NULL && Z_TYPE_P(value) > IS_NULL && + (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL); + } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { + result = (value == NULL || !i_zend_is_true(value TSRMLS_CC)); + } + } else if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->has_dimension) { + result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC); + } else { + zend_error(E_NOTICE, "Trying to check element of non-array"); + result = 0; + } + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } + } else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */ + zval tmp; + + result = 0; + if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) { + if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { + ZVAL_DEREF(offset); + } + if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */ + || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */ + && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) { + ZVAL_DUP(&tmp, offset); + convert_to_long(&tmp); + offset = &tmp; + } + } + if (Z_TYPE_P(offset) == IS_LONG) { + if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) { + if ((opline->extended_value & ZEND_ISSET) || + Z_STRVAL_P(container)[offset->value.lval] != '0') { + result = 1; + } + } + } + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } + } else { + result = ((opline->extended_value & ZEND_ISSET) == 0); + } + + ZVAL_BOOL(EX_VAR(opline->result.var), result); + zval_dtor(free_op1.var); + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_free_op free_op1; + zval *container; + int result; + zval *offset; + + SAVE_OPLINE(); + container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + offset = opline->op2.zv; + + if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->has_property) { + result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); + } else { + zend_error(E_NOTICE, "Trying to check property of non-object"); + result = 0; + } + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } + } else { + result = ((opline->extended_value & ZEND_ISSET) == 0); + } + + ZVAL_BOOL(EX_VAR(opline->result.var), result); + zval_dtor(free_op1.var); + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + static int ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -10330,6 +11851,159 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HAND ZEND_VM_NEXT_OPCODE(); } +static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_free_op free_op1, free_op2; + zval *container; + + SAVE_OPLINE(); + container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR TSRMLS_CC); + zval_dtor(free_op2.var); + zval_dtor(free_op1.var); + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *container; + zend_free_op free_op1, free_op2; + + SAVE_OPLINE(); + + if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { + if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) { + zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context"); + } + container = NULL; + if (IS_TMP_VAR == IS_VAR && UNEXPECTED(container == NULL)) { + zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); + } + zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR TSRMLS_CC); + if (IS_TMP_VAR == IS_VAR && 1 && READY_TO_DESTROY(free_op1.var)) { + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); + } + zval_dtor(free_op2.var); + + } else { + if (IS_TMP_VAR == IS_UNUSED) { + zend_error_noreturn(E_ERROR, "Cannot use [] for reading"); + } + container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR TSRMLS_CC); + zval_dtor(free_op2.var); + zval_dtor(free_op1.var); + } + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_TMP_TMP(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_free_op free_op1; + zval *container; + zend_free_op free_op2; + zval *offset; + + SAVE_OPLINE(); + container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + + if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || + UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { + zend_error(E_NOTICE, "Trying to get property of non-object"); + ZVAL_NULL(EX_VAR(opline->result.var)); + } else { + zval *retval; + + /* here we are sure we are dealing with an object */ + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); + + if (retval != EX_VAR(opline->result.var)) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); + } + } + + zval_dtor(free_op2.var); + zval_dtor(free_op1.var); + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + return zend_fetch_property_address_read_helper_SPEC_TMP_TMP(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +} + +static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_free_op free_op1; + zval *container; + zend_free_op free_op2; + zval *offset; + + SAVE_OPLINE(); + container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + + if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || + UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } else { + zval *retval; + + /* here we are sure we are dealing with an object */ + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_TMP_VAR == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); + + if (retval != EX_VAR(opline->result.var)) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); + } + } + + zval_dtor(free_op2.var); + zval_dtor(free_op1.var); + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *container; + + if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { + /* Behave like FETCH_OBJ_W */ + zend_free_op free_op1, free_op2; + zval *property; + + SAVE_OPLINE(); + property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + container = NULL; + + if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) { + zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context"); + } + if (IS_TMP_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { + zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); + } + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W, 0 TSRMLS_CC); + zval_dtor(free_op2.var); + if (IS_TMP_VAR == IS_VAR && 1 && READY_TO_DESTROY(free_op1.var)) { + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); + } + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); + } else { + return zend_fetch_property_address_read_helper_SPEC_TMP_TMP(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +} + static int ZEND_FASTCALL ZEND_ADD_VAR_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -10580,6 +12254,153 @@ static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDL } } +static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_free_op free_op1, free_op2; + zval *container; + int result; + zend_ulong hval; + zval *offset; + + SAVE_OPLINE(); + container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + + if (Z_TYPE_P(container) == IS_ARRAY) { + HashTable *ht = Z_ARRVAL_P(container); + zval *value; + zend_string *str; + +isset_again: + if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { + str = Z_STR_P(offset); + if (IS_TMP_VAR != IS_CONST) { + if (ZEND_HANDLE_NUMERIC(str, hval)) { + goto num_index_prop; + } + } +str_index_prop: + value = zend_hash_find_ind(ht, str); + } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { + hval = Z_LVAL_P(offset); +num_index_prop: + value = zend_hash_index_find(ht, hval); + } else { + switch (Z_TYPE_P(offset)) { + case IS_DOUBLE: + hval = zend_dval_to_lval(Z_DVAL_P(offset)); + goto num_index_prop; + case IS_NULL: + str = STR_EMPTY_ALLOC(); + goto str_index_prop; + case IS_FALSE: + hval = 0; + goto num_index_prop; + case IS_TRUE: + hval = 1; + goto num_index_prop; + case IS_RESOURCE: + hval = Z_RES_HANDLE_P(offset); + goto num_index_prop; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto isset_again; + default: + zend_error(E_WARNING, "Illegal offset type in isset or empty"); + value = NULL; + break; + } + } + + if (opline->extended_value & ZEND_ISSET) { + /* > IS_NULL means not IS_UNDEF and not IS_NULL */ + result = value != NULL && Z_TYPE_P(value) > IS_NULL && + (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL); + } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { + result = (value == NULL || !i_zend_is_true(value TSRMLS_CC)); + } + } else if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->has_dimension) { + result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC); + } else { + zend_error(E_NOTICE, "Trying to check element of non-array"); + result = 0; + } + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } + } else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */ + zval tmp; + + result = 0; + if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) { + if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { + ZVAL_DEREF(offset); + } + if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */ + || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */ + && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) { + ZVAL_DUP(&tmp, offset); + convert_to_long(&tmp); + offset = &tmp; + } + } + if (Z_TYPE_P(offset) == IS_LONG) { + if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) { + if ((opline->extended_value & ZEND_ISSET) || + Z_STRVAL_P(container)[offset->value.lval] != '0') { + result = 1; + } + } + } + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } + } else { + result = ((opline->extended_value & ZEND_ISSET) == 0); + } + + zval_dtor(free_op2.var); + ZVAL_BOOL(EX_VAR(opline->result.var), result); + zval_dtor(free_op1.var); + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_free_op free_op1, free_op2; + zval *container; + int result; + zval *offset; + + SAVE_OPLINE(); + container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + + if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->has_property) { + result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_TMP_VAR == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); + } else { + zend_error(E_NOTICE, "Trying to check property of non-object"); + result = 0; + } + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } + } else { + result = ((opline->extended_value & ZEND_ISSET) == 0); + } + + zval_dtor(free_op2.var); + ZVAL_BOOL(EX_VAR(opline->result.var), result); + zval_dtor(free_op1.var); + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + static int ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -11170,6 +12991,159 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HAND ZEND_VM_NEXT_OPCODE(); } +static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_free_op free_op1, free_op2; + zval *container; + + SAVE_OPLINE(); + container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR TSRMLS_CC); + zval_ptr_dtor_nogc(free_op2.var); + zval_dtor(free_op1.var); + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *container; + zend_free_op free_op1, free_op2; + + SAVE_OPLINE(); + + if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { + if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) { + zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context"); + } + container = NULL; + if (IS_TMP_VAR == IS_VAR && UNEXPECTED(container == NULL)) { + zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); + } + zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR TSRMLS_CC); + if (IS_TMP_VAR == IS_VAR && 1 && READY_TO_DESTROY(free_op1.var)) { + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); + } + zval_ptr_dtor_nogc(free_op2.var); + + } else { + if (IS_VAR == IS_UNUSED) { + zend_error_noreturn(E_ERROR, "Cannot use [] for reading"); + } + container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR TSRMLS_CC); + zval_ptr_dtor_nogc(free_op2.var); + zval_dtor(free_op1.var); + } + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_TMP_VAR(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_free_op free_op1; + zval *container; + zend_free_op free_op2; + zval *offset; + + SAVE_OPLINE(); + container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + + if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || + UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { + zend_error(E_NOTICE, "Trying to get property of non-object"); + ZVAL_NULL(EX_VAR(opline->result.var)); + } else { + zval *retval; + + /* here we are sure we are dealing with an object */ + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_VAR == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); + + if (retval != EX_VAR(opline->result.var)) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); + } + } + + zval_ptr_dtor_nogc(free_op2.var); + zval_dtor(free_op1.var); + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + return zend_fetch_property_address_read_helper_SPEC_TMP_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +} + +static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_free_op free_op1; + zval *container; + zend_free_op free_op2; + zval *offset; + + SAVE_OPLINE(); + container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + + if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || + UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } else { + zval *retval; + + /* here we are sure we are dealing with an object */ + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_VAR == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); + + if (retval != EX_VAR(opline->result.var)) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); + } + } + + zval_ptr_dtor_nogc(free_op2.var); + zval_dtor(free_op1.var); + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *container; + + if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { + /* Behave like FETCH_OBJ_W */ + zend_free_op free_op1, free_op2; + zval *property; + + SAVE_OPLINE(); + property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + container = NULL; + + if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) { + zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context"); + } + if (IS_TMP_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { + zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); + } + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W, 0 TSRMLS_CC); + zval_ptr_dtor_nogc(free_op2.var); + if (IS_TMP_VAR == IS_VAR && 1 && READY_TO_DESTROY(free_op1.var)) { + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); + } + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); + } else { + return zend_fetch_property_address_read_helper_SPEC_TMP_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +} + static int ZEND_FASTCALL ZEND_ADD_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -11572,6 +13546,153 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCOD ZEND_VM_NEXT_OPCODE(); } +static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_free_op free_op1, free_op2; + zval *container; + int result; + zend_ulong hval; + zval *offset; + + SAVE_OPLINE(); + container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + + if (Z_TYPE_P(container) == IS_ARRAY) { + HashTable *ht = Z_ARRVAL_P(container); + zval *value; + zend_string *str; + +isset_again: + if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { + str = Z_STR_P(offset); + if (IS_VAR != IS_CONST) { + if (ZEND_HANDLE_NUMERIC(str, hval)) { + goto num_index_prop; + } + } +str_index_prop: + value = zend_hash_find_ind(ht, str); + } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { + hval = Z_LVAL_P(offset); +num_index_prop: + value = zend_hash_index_find(ht, hval); + } else { + switch (Z_TYPE_P(offset)) { + case IS_DOUBLE: + hval = zend_dval_to_lval(Z_DVAL_P(offset)); + goto num_index_prop; + case IS_NULL: + str = STR_EMPTY_ALLOC(); + goto str_index_prop; + case IS_FALSE: + hval = 0; + goto num_index_prop; + case IS_TRUE: + hval = 1; + goto num_index_prop; + case IS_RESOURCE: + hval = Z_RES_HANDLE_P(offset); + goto num_index_prop; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto isset_again; + default: + zend_error(E_WARNING, "Illegal offset type in isset or empty"); + value = NULL; + break; + } + } + + if (opline->extended_value & ZEND_ISSET) { + /* > IS_NULL means not IS_UNDEF and not IS_NULL */ + result = value != NULL && Z_TYPE_P(value) > IS_NULL && + (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL); + } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { + result = (value == NULL || !i_zend_is_true(value TSRMLS_CC)); + } + } else if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->has_dimension) { + result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC); + } else { + zend_error(E_NOTICE, "Trying to check element of non-array"); + result = 0; + } + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } + } else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */ + zval tmp; + + result = 0; + if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) { + if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { + ZVAL_DEREF(offset); + } + if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */ + || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */ + && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) { + ZVAL_DUP(&tmp, offset); + convert_to_long(&tmp); + offset = &tmp; + } + } + if (Z_TYPE_P(offset) == IS_LONG) { + if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) { + if ((opline->extended_value & ZEND_ISSET) || + Z_STRVAL_P(container)[offset->value.lval] != '0') { + result = 1; + } + } + } + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } + } else { + result = ((opline->extended_value & ZEND_ISSET) == 0); + } + + zval_ptr_dtor_nogc(free_op2.var); + ZVAL_BOOL(EX_VAR(opline->result.var), result); + zval_dtor(free_op1.var); + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_free_op free_op1, free_op2; + zval *container; + int result; + zval *offset; + + SAVE_OPLINE(); + container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + + if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->has_property) { + result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_VAR == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); + } else { + zend_error(E_NOTICE, "Trying to check property of non-object"); + result = 0; + } + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } + } else { + result = ((opline->extended_value & ZEND_ISSET) == 0); + } + + zval_ptr_dtor_nogc(free_op2.var); + ZVAL_BOOL(EX_VAR(opline->result.var), result); + zval_dtor(free_op1.var); + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + static int ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -11870,6 +13991,41 @@ static int ZEND_FASTCALL ZEND_FETCH_IS_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HAND return zend_fetch_var_address_helper_SPEC_TMP_UNUSED(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } +static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *container; + zend_free_op free_op1; + + SAVE_OPLINE(); + + if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { + if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) { + zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context"); + } + container = NULL; + if (IS_TMP_VAR == IS_VAR && UNEXPECTED(container == NULL)) { + zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); + } + zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, NULL, IS_UNUSED TSRMLS_CC); + if (IS_TMP_VAR == IS_VAR && 1 && READY_TO_DESTROY(free_op1.var)) { + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); + } + + + } else { + if (IS_UNUSED == IS_UNUSED) { + zend_error_noreturn(E_ERROR, "Cannot use [] for reading"); + } + container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, NULL, IS_UNUSED TSRMLS_CC); + + zval_dtor(free_op1.var); + } + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -12563,6 +14719,157 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDL ZEND_VM_NEXT_OPCODE(); } +static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_free_op free_op1; + zval *container; + + SAVE_OPLINE(); + container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC); + + zval_dtor(free_op1.var); + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *container; + zend_free_op free_op1; + + SAVE_OPLINE(); + + if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { + if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) { + zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context"); + } + container = NULL; + if (IS_TMP_VAR == IS_VAR && UNEXPECTED(container == NULL)) { + zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); + } + zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC); + if (IS_TMP_VAR == IS_VAR && 1 && READY_TO_DESTROY(free_op1.var)) { + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); + } + + + } else { + if (IS_CV == IS_UNUSED) { + zend_error_noreturn(E_ERROR, "Cannot use [] for reading"); + } + container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC); + + zval_dtor(free_op1.var); + } + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_TMP_CV(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_free_op free_op1; + zval *container; + + zval *offset; + + SAVE_OPLINE(); + container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); + + if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || + UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { + zend_error(E_NOTICE, "Trying to get property of non-object"); + ZVAL_NULL(EX_VAR(opline->result.var)); + } else { + zval *retval; + + /* here we are sure we are dealing with an object */ + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); + + if (retval != EX_VAR(opline->result.var)) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); + } + } + + zval_dtor(free_op1.var); + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + return zend_fetch_property_address_read_helper_SPEC_TMP_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +} + +static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_free_op free_op1; + zval *container; + + zval *offset; + + SAVE_OPLINE(); + container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); + + if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || + UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } else { + zval *retval; + + /* here we are sure we are dealing with an object */ + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); + + if (retval != EX_VAR(opline->result.var)) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); + } + } + + zval_dtor(free_op1.var); + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *container; + + if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { + /* Behave like FETCH_OBJ_W */ + zend_free_op free_op1; + zval *property; + + SAVE_OPLINE(); + property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); + container = NULL; + + if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) { + zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context"); + } + if (IS_TMP_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { + zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); + } + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W, 0 TSRMLS_CC); + + if (IS_TMP_VAR == IS_VAR && 1 && READY_TO_DESTROY(free_op1.var)) { + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); + } + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); + } else { + return zend_fetch_property_address_read_helper_SPEC_TMP_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +} + static int ZEND_FASTCALL ZEND_ADD_VAR_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -12810,6 +15117,151 @@ static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLE } } +static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_free_op free_op1; + zval *container; + int result; + zend_ulong hval; + zval *offset; + + SAVE_OPLINE(); + container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); + + if (Z_TYPE_P(container) == IS_ARRAY) { + HashTable *ht = Z_ARRVAL_P(container); + zval *value; + zend_string *str; + +isset_again: + if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { + str = Z_STR_P(offset); + if (IS_CV != IS_CONST) { + if (ZEND_HANDLE_NUMERIC(str, hval)) { + goto num_index_prop; + } + } +str_index_prop: + value = zend_hash_find_ind(ht, str); + } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { + hval = Z_LVAL_P(offset); +num_index_prop: + value = zend_hash_index_find(ht, hval); + } else { + switch (Z_TYPE_P(offset)) { + case IS_DOUBLE: + hval = zend_dval_to_lval(Z_DVAL_P(offset)); + goto num_index_prop; + case IS_NULL: + str = STR_EMPTY_ALLOC(); + goto str_index_prop; + case IS_FALSE: + hval = 0; + goto num_index_prop; + case IS_TRUE: + hval = 1; + goto num_index_prop; + case IS_RESOURCE: + hval = Z_RES_HANDLE_P(offset); + goto num_index_prop; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto isset_again; + default: + zend_error(E_WARNING, "Illegal offset type in isset or empty"); + value = NULL; + break; + } + } + + if (opline->extended_value & ZEND_ISSET) { + /* > IS_NULL means not IS_UNDEF and not IS_NULL */ + result = value != NULL && Z_TYPE_P(value) > IS_NULL && + (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL); + } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { + result = (value == NULL || !i_zend_is_true(value TSRMLS_CC)); + } + } else if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->has_dimension) { + result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC); + } else { + zend_error(E_NOTICE, "Trying to check element of non-array"); + result = 0; + } + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } + } else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */ + zval tmp; + + result = 0; + if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) { + if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { + ZVAL_DEREF(offset); + } + if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */ + || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */ + && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) { + ZVAL_DUP(&tmp, offset); + convert_to_long(&tmp); + offset = &tmp; + } + } + if (Z_TYPE_P(offset) == IS_LONG) { + if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) { + if ((opline->extended_value & ZEND_ISSET) || + Z_STRVAL_P(container)[offset->value.lval] != '0') { + result = 1; + } + } + } + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } + } else { + result = ((opline->extended_value & ZEND_ISSET) == 0); + } + + ZVAL_BOOL(EX_VAR(opline->result.var), result); + zval_dtor(free_op1.var); + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_free_op free_op1; + zval *container; + int result; + zval *offset; + + SAVE_OPLINE(); + container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); + + if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->has_property) { + result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); + } else { + zend_error(E_NOTICE, "Trying to check property of non-object"); + result = 0; + } + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } + } else { + result = ((opline->extended_value & ZEND_ISSET) == 0); + } + + ZVAL_BOOL(EX_VAR(opline->result.var), result); + zval_dtor(free_op1.var); + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + static int ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -14591,8 +17043,8 @@ static int ZEND_FASTCALL ZEND_TYPE_CHECK_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_A } else { ZVAL_FALSE(EX_VAR(opline->result.var)); } + break; EMPTY_SWITCH_DEFAULT_CASE() - } zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); @@ -15645,6 +18097,9 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OP SAVE_OPLINE(); if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { + if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) { + zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context"); + } container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); @@ -15821,6 +18276,9 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OP property = opline->op2.zv; container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) { + zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context"); + } if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } @@ -17876,6 +20334,9 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMP_HANDLER(ZEND_OPCO SAVE_OPLINE(); if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { + if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) { + zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context"); + } container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); @@ -18054,6 +20515,9 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMP_HANDLER(ZEND_OPCO property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) { + zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context"); + } if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } @@ -20018,6 +22482,9 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_VAR_HANDLER(ZEND_OPCO SAVE_OPLINE(); if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { + if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) { + zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context"); + } container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); @@ -20196,6 +22663,9 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_VAR_HANDLER(ZEND_OPCO property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) { + zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context"); + } if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } @@ -21888,6 +24358,9 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_O SAVE_OPLINE(); if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { + if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) { + zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context"); + } container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); @@ -23408,6 +25881,9 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCOD SAVE_OPLINE(); if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { + if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) { + zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context"); + } container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); @@ -23584,6 +26060,9 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCOD property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) { + zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context"); + } if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } @@ -25295,6 +27774,9 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER(ZEND property = opline->op2.zv; container = _get_obj_zval_ptr_unused(TSRMLS_C); + if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR) { + zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context"); + } if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } @@ -26665,6 +29147,9 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMP_HANDLER(ZEND_O property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); container = _get_obj_zval_ptr_unused(TSRMLS_C); + if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR) { + zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context"); + } if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } @@ -27947,6 +30432,9 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_VAR_HANDLER(ZEND_O property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); container = _get_obj_zval_ptr_unused(TSRMLS_C); + if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR) { + zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context"); + } if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } @@ -29740,6 +32228,9 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_HANDLER(ZEND_OP property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); container = _get_obj_zval_ptr_unused(TSRMLS_C); + if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR) { + zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context"); + } if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } @@ -31804,8 +34295,8 @@ static int ZEND_FASTCALL ZEND_TYPE_CHECK_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_AR } else { ZVAL_FALSE(EX_VAR(opline->result.var)); } + break; EMPTY_SWITCH_DEFAULT_CASE() - } CHECK_EXCEPTION(); @@ -32857,6 +35348,9 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPC SAVE_OPLINE(); if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { + if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) { + zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context"); + } container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); @@ -33033,6 +35527,9 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPC property = opline->op2.zv; container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); + if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) { + zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context"); + } if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } @@ -34902,6 +37399,9 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMP_HANDLER(ZEND_OPCOD SAVE_OPLINE(); if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { + if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) { + zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context"); + } container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); @@ -35080,6 +37580,9 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMP_HANDLER(ZEND_OPCOD property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); + if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) { + zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context"); + } if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } @@ -36925,6 +39428,9 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_VAR_HANDLER(ZEND_OPCOD SAVE_OPLINE(); if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { + if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) { + zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context"); + } container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); @@ -37103,6 +39609,9 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_VAR_HANDLER(ZEND_OPCOD property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); + if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) { + zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context"); + } if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } @@ -38675,6 +41184,9 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OP SAVE_OPLINE(); if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { + if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) { + zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context"); + } container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); @@ -40059,6 +42571,9 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE SAVE_OPLINE(); if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { + if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) { + zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context"); + } container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); @@ -40235,6 +42750,9 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); + if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) { + zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context"); + } if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } @@ -43148,16 +45666,16 @@ void zend_init_opcodes_handlers(void) ZEND_FETCH_DIM_R_SPEC_CV_VAR_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER, + ZEND_FETCH_OBJ_R_SPEC_CONST_CONST_HANDLER, + ZEND_FETCH_OBJ_R_SPEC_CONST_TMP_HANDLER, + ZEND_FETCH_OBJ_R_SPEC_CONST_VAR_HANDLER, ZEND_NULL_HANDLER, + ZEND_FETCH_OBJ_R_SPEC_CONST_CV_HANDLER, + ZEND_FETCH_OBJ_R_SPEC_TMP_CONST_HANDLER, + ZEND_FETCH_OBJ_R_SPEC_TMP_TMP_HANDLER, + ZEND_FETCH_OBJ_R_SPEC_TMP_VAR_HANDLER, ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_OBJ_R_SPEC_TMP_CV_HANDLER, ZEND_FETCH_OBJ_R_SPEC_VAR_CONST_HANDLER, ZEND_FETCH_OBJ_R_SPEC_VAR_TMP_HANDLER, ZEND_FETCH_OBJ_R_SPEC_VAR_VAR_HANDLER, @@ -43348,16 +45866,16 @@ void zend_init_opcodes_handlers(void) ZEND_FETCH_IS_SPEC_CV_VAR_HANDLER, ZEND_FETCH_IS_SPEC_CV_UNUSED_HANDLER, ZEND_NULL_HANDLER, + ZEND_FETCH_DIM_IS_SPEC_CONST_CONST_HANDLER, + ZEND_FETCH_DIM_IS_SPEC_CONST_TMP_HANDLER, + ZEND_FETCH_DIM_IS_SPEC_CONST_VAR_HANDLER, ZEND_NULL_HANDLER, + ZEND_FETCH_DIM_IS_SPEC_CONST_CV_HANDLER, + ZEND_FETCH_DIM_IS_SPEC_TMP_CONST_HANDLER, + ZEND_FETCH_DIM_IS_SPEC_TMP_TMP_HANDLER, + ZEND_FETCH_DIM_IS_SPEC_TMP_VAR_HANDLER, ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_DIM_IS_SPEC_TMP_CV_HANDLER, ZEND_FETCH_DIM_IS_SPEC_VAR_CONST_HANDLER, ZEND_FETCH_DIM_IS_SPEC_VAR_TMP_HANDLER, ZEND_FETCH_DIM_IS_SPEC_VAR_VAR_HANDLER, @@ -43373,16 +45891,16 @@ void zend_init_opcodes_handlers(void) ZEND_FETCH_DIM_IS_SPEC_CV_VAR_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_DIM_IS_SPEC_CV_CV_HANDLER, + ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST_HANDLER, + ZEND_FETCH_OBJ_IS_SPEC_CONST_TMP_HANDLER, + ZEND_FETCH_OBJ_IS_SPEC_CONST_VAR_HANDLER, ZEND_NULL_HANDLER, + ZEND_FETCH_OBJ_IS_SPEC_CONST_CV_HANDLER, + ZEND_FETCH_OBJ_IS_SPEC_TMP_CONST_HANDLER, + ZEND_FETCH_OBJ_IS_SPEC_TMP_TMP_HANDLER, + ZEND_FETCH_OBJ_IS_SPEC_TMP_VAR_HANDLER, ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_OBJ_IS_SPEC_TMP_CV_HANDLER, ZEND_FETCH_OBJ_IS_SPEC_VAR_CONST_HANDLER, ZEND_FETCH_OBJ_IS_SPEC_VAR_TMP_HANDLER, ZEND_FETCH_OBJ_IS_SPEC_VAR_VAR_HANDLER, @@ -43423,16 +45941,16 @@ void zend_init_opcodes_handlers(void) ZEND_FETCH_FUNC_ARG_SPEC_CV_VAR_HANDLER, ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED_HANDLER, ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST_HANDLER, + ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMP_HANDLER, + ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_VAR_HANDLER, + ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER, + ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV_HANDLER, + ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST_HANDLER, + ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMP_HANDLER, + ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_VAR_HANDLER, + ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED_HANDLER, + ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV_HANDLER, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_HANDLER, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMP_HANDLER, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_VAR_HANDLER, @@ -43448,16 +45966,16 @@ void zend_init_opcodes_handlers(void) ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_VAR_HANDLER, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_HANDLER, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_HANDLER, + ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST_HANDLER, + ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMP_HANDLER, + ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_VAR_HANDLER, ZEND_NULL_HANDLER, + ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV_HANDLER, + ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST_HANDLER, + ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMP_HANDLER, + ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_VAR_HANDLER, ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV_HANDLER, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_HANDLER, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMP_HANDLER, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_VAR_HANDLER, @@ -43973,16 +46491,16 @@ void zend_init_opcodes_handlers(void) ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_VAR_HANDLER, ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER, ZEND_NULL_HANDLER, + ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST_HANDLER, + ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMP_HANDLER, + ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_VAR_HANDLER, ZEND_NULL_HANDLER, + ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV_HANDLER, + ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_CONST_HANDLER, + ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_TMP_HANDLER, + ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_VAR_HANDLER, ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_CV_HANDLER, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_CONST_HANDLER, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_TMP_HANDLER, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_VAR_HANDLER, @@ -44798,16 +47316,16 @@ void zend_init_opcodes_handlers(void) ZEND_ASSIGN_DIM_SPEC_CV_VAR_HANDLER, ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_HANDLER, ZEND_ASSIGN_DIM_SPEC_CV_CV_HANDLER, + ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST_HANDLER, + ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMP_HANDLER, + ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_VAR_HANDLER, ZEND_NULL_HANDLER, + ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV_HANDLER, + ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_CONST_HANDLER, + ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_TMP_HANDLER, + ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_VAR_HANDLER, ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_CV_HANDLER, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_CONST_HANDLER, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_TMP_HANDLER, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_VAR_HANDLER, diff --git a/ext/opcache/Optimizer/optimize_func_calls.c b/ext/opcache/Optimizer/optimize_func_calls.c index ead951ac73..853d4bd7f4 100644 --- a/ext/opcache/Optimizer/optimize_func_calls.c +++ b/ext/opcache/Optimizer/optimize_func_calls.c @@ -20,6 +20,11 @@ /* pass 4 * - optimize INIT_FCALL_BY_NAME to DO_FCALL */ + +#define ZEND_OP2_IS_CONST_STRING(opline) \ + (ZEND_OP2_TYPE(opline) == IS_CONST && \ + Z_TYPE(op_array->literals[(opline)->op2.constant]) == IS_STRING) + typedef struct _optimizer_call_info { zend_function *func; zend_op *opline; @@ -42,7 +47,7 @@ static void optimize_func_calls(zend_op_array *op_array, zend_optimizer_ctx *ctx switch (opline->opcode) { case ZEND_INIT_FCALL_BY_NAME: case ZEND_INIT_NS_FCALL_BY_NAME: - if (ZEND_OP2_TYPE(opline) == IS_CONST) { + if (ZEND_OP2_IS_CONST_STRING(opline)) { zend_function *func; zval *function_name = &op_array->literals[opline->op2.constant + 1]; if ((func = zend_hash_find_ptr(&ctx->script->function_table, @@ -81,7 +86,7 @@ static void optimize_func_calls(zend_op_array *op_array, zend_optimizer_ctx *ctx } else if (opline->extended_value == 0 && call_stack[call].opline && call_stack[call].opline->opcode == ZEND_INIT_FCALL_BY_NAME && - ZEND_OP2_TYPE(call_stack[call].opline) == IS_CONST) { + ZEND_OP2_IS_CONST_STRING(call_stack[call].opline)) { zend_op *fcall = call_stack[call].opline; diff --git a/ext/opcache/Optimizer/pass1_5.c b/ext/opcache/Optimizer/pass1_5.c index de09e89123..cae4d0445d 100644 --- a/ext/opcache/Optimizer/pass1_5.c +++ b/ext/opcache/Optimizer/pass1_5.c @@ -472,7 +472,7 @@ if (ZEND_OPTIMIZER_PASS_1 & OPTIMIZATION_LEVEL) { zval t; ZVAL_LONG(&t, Z_STRLEN(ZEND_OP1_LITERAL(opline))); - replace_tmp_by_const(op_array, opline + 1, ZEND_RESULT(opline).var, &t TSRMLS_CC); + replace_var_by_const(op_array, opline + 1, ZEND_RESULT(opline).var, &t TSRMLS_CC); literal_dtor(&ZEND_OP1_LITERAL(opline)); MAKE_NOP(opline); } @@ -485,7 +485,7 @@ if (ZEND_OPTIMIZER_PASS_1 & OPTIMIZATION_LEVEL) { break; } ZVAL_TRUE(&c); - replace_tmp_by_const(op_array, opline, tv, &c TSRMLS_CC); + replace_var_by_const(op_array, opline, tv, &c TSRMLS_CC); literal_dtor(&ZEND_OP1_LITERAL(opline)); MAKE_NOP(opline); } diff --git a/ext/opcache/zend_accelerator_util_funcs.c b/ext/opcache/zend_accelerator_util_funcs.c index dd5340e572..f8554776a3 100644 --- a/ext/opcache/zend_accelerator_util_funcs.c +++ b/ext/opcache/zend_accelerator_util_funcs.c @@ -305,28 +305,44 @@ static inline void zend_clone_zval(zval *src, int bind TSRMLS_DC) static zend_ast *zend_ast_clone(zend_ast *ast TSRMLS_DC) { - int i; - zend_ast *node; - - if (ast->kind == ZEND_CONST) { - node = emalloc(sizeof(zend_ast) + sizeof(zval)); - node->kind = ZEND_CONST; - node->children = 0; - ZVAL_COPY_VALUE(&node->u.val, &ast->u.val); - zend_clone_zval(&node->u.val, 0 TSRMLS_CC); + uint32_t i; + + if (ast->kind == ZEND_AST_ZVAL) { + zend_ast_zval *copy = emalloc(sizeof(zend_ast_zval)); + copy->kind = ZEND_AST_ZVAL; + copy->attr = ast->attr; + ZVAL_COPY_VALUE(©->val, zend_ast_get_zval(ast)); + zend_clone_zval(©->val, 0 TSRMLS_CC); + return (zend_ast *) copy; + } else if (zend_ast_is_list(ast)) { + zend_ast_list *list = zend_ast_get_list(ast); + zend_ast_list *copy = emalloc( + sizeof(zend_ast_list) + sizeof(zend_ast *) * (list->children - 1)); + copy->kind = list->kind; + copy->attr = list->attr; + copy->children = list->children; + for (i = 0; i < list->children; i++) { + if (list->child[i]) { + copy->child[i] = zend_ast_clone(list->child[i] TSRMLS_CC); + } else { + copy->child[i] = NULL; + } + } + return (zend_ast *) copy; } else { - node = emalloc(sizeof(zend_ast) + sizeof(zend_ast*) * (ast->children - 1)); - node->kind = ast->kind; - node->children = ast->children; - for (i = 0; i < ast->children; i++) { - if ((&ast->u.child)[i]) { - (&node->u.child)[i] = zend_ast_clone((&ast->u.child)[i] TSRMLS_CC); + uint32_t children = zend_ast_get_num_children(ast); + zend_ast *copy = emalloc(sizeof(zend_ast) + sizeof(zend_ast *) * (children - 1)); + copy->kind = ast->kind; + copy->attr = ast->attr; + for (i = 0; i < children; i++) { + if (ast->child[i]) { + copy->child[i] = zend_ast_clone(ast->child[i] TSRMLS_CC); } else { - (&node->u.child)[i] = NULL; + copy->child[i] = NULL; } } + return copy; } - return node; } static void zend_hash_clone_zval(HashTable *ht, HashTable *source, int bind) diff --git a/ext/opcache/zend_persist.c b/ext/opcache/zend_persist.c index 2427cfdec8..5e290745bd 100644 --- a/ext/opcache/zend_persist.c +++ b/ext/opcache/zend_persist.c @@ -144,20 +144,33 @@ static void zend_hash_persist_immutable(HashTable *ht TSRMLS_DC) static zend_ast *zend_persist_ast(zend_ast *ast TSRMLS_DC) { - int i; + uint32_t i; zend_ast *node; - if (ast->kind == ZEND_CONST) { - node = zend_accel_memdup(ast, sizeof(zend_ast)); - zend_persist_zval(&node->u.val TSRMLS_CC); + if (ast->kind == ZEND_AST_ZVAL) { + zend_ast_zval *copy = zend_accel_memdup(ast, sizeof(zend_ast_zval)); + zend_persist_zval(©->val TSRMLS_CC); + node = (zend_ast *) copy; + } else if (zend_ast_is_list(ast)) { + zend_ast_list *list = zend_ast_get_list(ast); + zend_ast_list *copy = zend_accel_memdup(ast, + sizeof(zend_ast_list) + sizeof(zend_ast *) * (list->children - 1)); + for (i = 0; i < list->children; i++) { + if (copy->child[i]) { + copy->child[i] = zend_persist_ast(copy->child[i] TSRMLS_CC); + } + } + node = (zend_ast *) copy; } else { - node = zend_accel_memdup(ast, sizeof(zend_ast) + sizeof(zend_ast*) * (ast->children - 1)); - for (i = 0; i < ast->children; i++) { - if ((&node->u.child)[i]) { - (&node->u.child)[i] = zend_persist_ast((&node->u.child)[i] TSRMLS_CC); + uint32_t children = zend_ast_get_num_children(ast); + node = zend_accel_memdup(ast, sizeof(zend_ast) + sizeof(zend_ast *) * (children - 1)); + for (i = 0; i < children; i++) { + if (node->child[i]) { + node->child[i] = zend_persist_ast(node->child[i] TSRMLS_CC); } } } + efree(ast); return node; } diff --git a/ext/opcache/zend_persist_calc.c b/ext/opcache/zend_persist_calc.c index 1328213397..989195119c 100644 --- a/ext/opcache/zend_persist_calc.c +++ b/ext/opcache/zend_persist_calc.c @@ -83,17 +83,26 @@ static uint zend_hash_persist_calc(HashTable *ht, uint (*pPersistElement)(zval * static uint zend_persist_ast_calc(zend_ast *ast TSRMLS_DC) { - int i; + uint32_t i; START_SIZE(); - if (ast->kind == ZEND_CONST) { - ADD_SIZE(sizeof(zend_ast)); - ADD_SIZE(zend_persist_zval_calc(&ast->u.val TSRMLS_CC)); + if (ast->kind == ZEND_AST_ZVAL) { + ADD_SIZE(sizeof(zend_ast_zval)); + ADD_SIZE(zend_persist_zval_calc(zend_ast_get_zval(ast) TSRMLS_CC)); + } else if (zend_ast_is_list(ast)) { + zend_ast_list *list = zend_ast_get_list(ast); + ADD_SIZE(sizeof(zend_ast_list) + sizeof(zend_ast *) * (list->children - 1)); + for (i = 0; i < list->children; i++) { + if (list->child[i]) { + ADD_SIZE(zend_persist_ast_calc(list->child[i] TSRMLS_CC)); + } + } } else { - ADD_SIZE(sizeof(zend_ast) + sizeof(zend_ast*) * (ast->children - 1)); - for (i = 0; i < ast->children; i++) { - if ((&ast->u.child)[i]) { - ADD_SIZE(zend_persist_ast_calc((&ast->u.child)[i] TSRMLS_CC)); + uint32_t children = zend_ast_get_num_children(ast); + ADD_SIZE(sizeof(zend_ast) + sizeof(zend_ast *) * (children - 1)); + for (i = 0; i < children; i++) { + if (ast->child[i]) { + ADD_SIZE(zend_persist_ast_calc(ast->child[i] TSRMLS_CC)); } } } diff --git a/ext/standard/tests/array/array_keys_error.phpt b/ext/standard/tests/array/array_keys_error.phpt index 316e91d7e6..685547f0ec 100644 --- a/ext/standard/tests/array/array_keys_error.phpt +++ b/ext/standard/tests/array/array_keys_error.phpt @@ -9,7 +9,7 @@ var_dump(array_keys("string")); var_dump(array_keys(new stdclass)); // object var_dump(array_keys()); // Zero arguments var_dump(array_keys(array(), "", TRUE, 100)); // args > expected -var_dump(array_keys(array(1,2,3, array() => array()))); // (W)illegal offset +var_dump(array_keys(array(1,2,3, new stdClass => array()))); // (W)illegal offset echo "Done\n"; ?> diff --git a/ext/standard/tests/general_functions/bug41037.phpt b/ext/standard/tests/general_functions/bug41037.phpt index eab2c334c9..0ffc8d58f6 100644 --- a/ext/standard/tests/general_functions/bug41037.phpt +++ b/ext/standard/tests/general_functions/bug41037.phpt @@ -8,10 +8,11 @@ function a() { unregister_tick_function('a'); } -declare (ticks=1); -register_tick_function('a'); +declare (ticks=1) { + register_tick_function('a'); -echo "Done\n"; + echo "Done\n"; +} ?> --EXPECTF-- hello @@ -19,5 +20,3 @@ Warning: unregister_tick_function(): Unable to delete tick function executed at Done hello Warning: unregister_tick_function(): Unable to delete tick function executed at the moment in %s on line %d -hello -Warning: unregister_tick_function(): Unable to delete tick function executed at the moment in %s on line %d diff --git a/ext/standard/tests/serialize/serialization_arrays_002.phpt b/ext/standard/tests/serialize/serialization_arrays_002.phpt index f8cef7818e..c62ff6a91c 100644 --- a/ext/standard/tests/serialize/serialization_arrays_002.phpt +++ b/ext/standard/tests/serialize/serialization_arrays_002.phpt @@ -37,16 +37,16 @@ check($a); echo "\n\n--- 0 refs 1:\n"; $a = array(); -$a[0] = &$a[1]; $a[1] = 1; +$a[0] = &$a[1]; $a[2] = 1; check($a); echo "\n\n--- 0 refs 2:\n"; $a = array(); +$a[2] = 1; $a[0] = &$a[2]; $a[1] = 1; -$a[2] = 1; check($a); echo "\n\n--- 1 refs 0:\n"; @@ -59,8 +59,8 @@ check($a); echo "\n\n--- 1 refs 2:\n"; $a = array(); $a[0] = 1; -$a[1] = &$a[2]; $a[2] = 1; +$a[1] = &$a[2]; check($a); echo "\n\n--- 2 refs 0:\n"; @@ -79,15 +79,15 @@ check($a); echo "\n\n--- 0,1 ref 2:\n"; $a = array(); +$a[2] = 1; $a[0] = &$a[2]; $a[1] = &$a[2]; -$a[2] = 1; check($a); echo "\n\n--- 0,2 ref 1:\n"; $a = array(); -$a[0] = &$a[1]; $a[1] = 1; +$a[0] = &$a[1]; $a[2] = &$a[1]; check($a); @@ -541,4 +541,4 @@ array(3) { [2]=> &string(10) "b2.changed" } -Done
\ No newline at end of file +Done diff --git a/ext/standard/tests/serialize/serialization_objects_013.phpt b/ext/standard/tests/serialize/serialization_objects_013.phpt index 01b623cb0d..403f9de08c 100644 --- a/ext/standard/tests/serialize/serialization_objects_013.phpt +++ b/ext/standard/tests/serialize/serialization_objects_013.phpt @@ -32,16 +32,16 @@ function check(&$obj) { echo "\n\n--- a refs b:\n"; $obj = new stdClass; -$obj->a = &$obj->b; $obj->b = 1; +$obj->a = &$obj->b; $obj->c = 1; check($obj); echo "\n\n--- a refs c:\n"; $obj = new stdClass; +$obj->c = 1; $obj->a = &$obj->c; $obj->b = 1; -$obj->c = 1; check($obj); echo "\n\n--- b refs a:\n"; @@ -54,8 +54,8 @@ check($obj); echo "\n\n--- b refs c:\n"; $obj = new stdClass; $obj->a = 1; -$obj->b = &$obj->c; $obj->c = 1; +$obj->b = &$obj->c; check($obj); echo "\n\n--- c refs a:\n"; @@ -74,15 +74,15 @@ check($obj); echo "\n\n--- a,b refs c:\n"; $obj = new stdClass; +$obj->c = 1; $obj->a = &$obj->c; $obj->b = &$obj->c; -$obj->c = 1; check($obj); echo "\n\n--- a,c refs b:\n"; $obj = new stdClass; -$obj->a = &$obj->b; $obj->b = 1; +$obj->a = &$obj->b; $obj->c = &$obj->b; check($obj); @@ -491,4 +491,4 @@ object(stdClass)#%d (3) { ["c"]=> &string(14) "obj->c.changed" } -Done
\ No newline at end of file +Done diff --git a/tests/classes/constants_error_005.phpt b/tests/classes/constants_error_005.phpt index 1283783de7..25f36460b7 100644 --- a/tests/classes/constants_error_005.phpt +++ b/tests/classes/constants_error_005.phpt @@ -8,5 +8,4 @@ Error case: class constant as an encapsed containing a variable } ?> --EXPECTF-- - -Parse error: %s in %s on line %d +Fatal error: Constant expression contains invalid operations in %s on line %d diff --git a/tests/classes/interface_method.phpt b/tests/classes/interface_method.phpt index 3570b35928..f80bd756f3 100644 --- a/tests/classes/interface_method.phpt +++ b/tests/classes/interface_method.phpt @@ -6,7 +6,7 @@ ZE2 An interface method must be abstract <?php interface if_a { - function err() {}; + function err() {} } ?> diff --git a/tests/classes/method_call_variation_001.phpt b/tests/classes/method_call_variation_001.phpt index dd43cfd1cb..7950b7deb3 100644 --- a/tests/classes/method_call_variation_001.phpt +++ b/tests/classes/method_call_variation_001.phpt @@ -1,37 +1,27 @@ --TEST-- -In $a->$b[Y](), $b[Y] represents a method name on $a. But in $a->X[Y](), $a->X[Y] represents a global function name. +In $a->$b[Y]() and $a->X[Y]() both $a->$b[Y] and $a->X[Y] represent a global function name --FILE-- <?php - class C - { - function foo($a, $b) - { - echo "Called C::foo($a, $b)\n"; - } - } - - $c = new C; - - $functions[0] = 'foo'; - $functions[1][2][3][4] = 'foo'; - - $c->$functions[0](1, 2); - $c->$functions[1][2][3][4](3, 4); - - - function foo($a, $b) - { + class C {} + + function foo($a, $b) { echo "Called global foo($a, $b)\n"; } - + + $name = 'functions'; + + $c = new C; $c->functions[0] = 'foo'; $c->functions[1][2][3][4] = 'foo'; + $c->$name[0](1, 2); + $c->$name[1][2][3][4](3, 4); + $c->functions[0](5, 6); $c->functions[1][2][3][4](7, 8); ?> --EXPECTF-- -Called C::foo(1, 2) -Called C::foo(3, 4) +Called global foo(1, 2) +Called global foo(3, 4) Called global foo(5, 6) Called global foo(7, 8) diff --git a/tests/lang/engine_assignExecutionOrder_002.phpt b/tests/lang/engine_assignExecutionOrder_002.phpt index ba88150dd4..c090a452c3 100644 --- a/tests/lang/engine_assignExecutionOrder_002.phpt +++ b/tests/lang/engine_assignExecutionOrder_002.phpt @@ -26,7 +26,7 @@ $g1 = array(10,10); $g2 = array(20,20); $g3 = array(30,30); $g = array($g1,$g2,$g3); -list($e[$f++],$e[$f++]) = $g[$f]; +list($e[$f++],$e[$f++]) = $g[2]; // expect 30,30 var_dump($e); @@ -39,7 +39,7 @@ $i = array($i1,$i2,$i3,$i4); $j = array(0,0,0); $h = 0; // a list of lists -list(list($j[$h++],$j[$h++]),$j[$h++]) = $i[$h]; +list(list($j[$h++],$j[$h++]),$j[$h++]) = $i[3]; var_dump($j); @@ -116,9 +116,9 @@ L=100 M=200 N=300 O= and P= 10 20 40 50 60 70 80 -Notice: Undefined offset: 1 in %s on line %d - Notice: Undefined offset: 0 in %s on line %d + +Notice: Undefined offset: 1 in %s on line %d Y=,Z= Notice: Undefined offset: 1 in %s on line %d diff --git a/tests/lang/engine_assignExecutionOrder_004.phpt b/tests/lang/engine_assignExecutionOrder_004.phpt index 86bc87f9c7..9471b7f063 100644 --- a/tests/lang/engine_assignExecutionOrder_004.phpt +++ b/tests/lang/engine_assignExecutionOrder_004.phpt @@ -18,15 +18,8 @@ function i3() { return 3; } -function i4() { - global $a; - $a = array(10, 11, 12, 13, 14); - echo "i4\n"; - return 4; -} - -$a = 0; // $a should not be indexable till the i4 has been executed -list($a[i1()+i2()], , list($a[i3()], $a[i4()]), $a[]) = array (0, 1, array(30, 40), 3, 4); +$a = array(10, 11, 12, 13); +list($a[i1()+i2()], , list($a[i3()], $a[])) = array(0, 1, array(30, 40), 3); var_dump($a); @@ -35,8 +28,7 @@ var_dump($a); i1 i2 i3 -i4 -array(6) { +array(5) { [0]=> int(10) [1]=> @@ -47,6 +39,4 @@ array(6) { int(30) [4]=> int(40) - [5]=> - int(3) } diff --git a/tests/run-test/test005.phpt b/tests/run-test/test005.phpt index 3d51531ed9..5dcb650444 100644 --- a/tests/run-test/test005.phpt +++ b/tests/run-test/test005.phpt @@ -19,7 +19,8 @@ var_dump(ini_get('track_errors')); ini_set('display_errors', 0); var_dump(ini_get('display_errors')); var_dump($php_errormsg); -$error = 1 / 0; +$zero = 0; +$error = 1 / $zero; var_dump($php_errormsg); ?> --EXPECTF-- diff --git a/tests/run-test/test008a.phpt b/tests/run-test/test008a.phpt index 27da085e04..ff2a93be0f 100644 --- a/tests/run-test/test008a.phpt +++ b/tests/run-test/test008a.phpt @@ -19,7 +19,8 @@ var_dump(ini_get('track_errors')); ini_set('display_errors', 0); var_dump(ini_get('display_errors')); var_dump($php_errormsg); -$error = 1 / 0; +$zero = 0; +$error = 1 / $zero; var_dump($php_errormsg); ?> --EXPECTF-- |