diff options
| author | Xinchen Hui <laruence@gmail.com> | 2015-05-26 14:17:21 +0800 |
|---|---|---|
| committer | Xinchen Hui <laruence@gmail.com> | 2015-05-26 14:17:21 +0800 |
| commit | 49b10ee264c88edc4fc52d4ab9ae1ca843be7c1f (patch) | |
| tree | 37914a2c0af1c7a5a1691d7d2973f9cf0b1263da | |
| parent | 9f1788f00db71cf06f62b02a24973ce2718efeb6 (diff) | |
| parent | 770a4629432a8722bd1ad46eee9bccdd00c61e30 (diff) | |
| download | php-git-49b10ee264c88edc4fc52d4ab9ae1ca843be7c1f.tar.gz | |
Merge branch 'master' into merge-fastcgi
79 files changed, 3088 insertions, 1147 deletions
@@ -77,7 +77,8 @@ . Implemented the RFC `Constructor behaviour of internal classes`. (Dan, Dmitry) . Implemented the RFC `Fix "foreach" behavior`. (Dmitry) . Implemented the RFC `Generator Delegation`. (Bob) - . Implemented the RFC ` Anonymous Class Support`. (Joe, Nikita, Dmitry) + . Implemented the RFC `Anonymous Class Support`. (Joe, Nikita, Dmitry) + . Implemented the RFC `Context Sensitive Lexer`. (Marcio Almada) . Fixed bug #69511 (Off-by-one buffer overflow in php_sys_readlink). (Jan Starke, Anatol) @@ -530,6 +530,8 @@ Other (RFC: https://wiki.php.net/rfc/combined-comparison-operator) . Added the yield from operator for delegating Generators like coroutines. (RFC: https://wiki.php.net/rfc/generator-delegation) + . Reserved keywords can now be used in various new contexts. + (RFC: https://wiki.php.net/rfc/context_sensitive_lexer) - OpenSSL . Added "alpn_protocols" SSL context option allowing encrypted client/server diff --git a/Zend/tests/grammar/regression_001.phpt b/Zend/tests/grammar/regression_001.phpt new file mode 100644 index 0000000000..73d5eacdf6 --- /dev/null +++ b/Zend/tests/grammar/regression_001.phpt @@ -0,0 +1,33 @@ +--TEST-- +Test to check static method calls syntax regression +--FILE-- +<?php + +class Foo { + public static function function(){ echo __METHOD__, PHP_EOL; } +} + +Foo::function(); + +Foo:: +function(); + +Foo:: + function(); + + +Foo:: + function( + +); + +echo "\nDone\n"; + +--EXPECTF-- + +Foo::function +Foo::function +Foo::function +Foo::function + +Done diff --git a/Zend/tests/grammar/regression_002.phpt b/Zend/tests/grammar/regression_002.phpt new file mode 100644 index 0000000000..dd307c99d8 --- /dev/null +++ b/Zend/tests/grammar/regression_002.phpt @@ -0,0 +1,22 @@ +--TEST-- +Test to ensure ::class still works +--FILE-- +<?php + +class Foo {} + +var_dump(Foo::class); + +var_dump(Foo:: class); + +var_dump(Foo:: CLASS); + +var_dump(Foo:: + +CLASS); + +--EXPECTF-- +string(3) "Foo" +string(3) "Foo" +string(3) "Foo" +string(3) "Foo" diff --git a/Zend/tests/grammar/regression_003.phpt b/Zend/tests/grammar/regression_003.phpt new file mode 100644 index 0000000000..e475754ccd --- /dev/null +++ b/Zend/tests/grammar/regression_003.phpt @@ -0,0 +1,13 @@ +--TEST-- +Test to ensure ::class is still reserved in obj scope +--FILE-- +<?php + +class Obj +{ + const CLASS = 'class'; +} + +?> +--EXPECTF-- +Fatal error: A class constant must not be called 'class'; it is reserved for class name fetching in %s on line %d diff --git a/Zend/tests/grammar/regression_004.phpt b/Zend/tests/grammar/regression_004.phpt new file mode 100644 index 0000000000..e95674d8c9 --- /dev/null +++ b/Zend/tests/grammar/regression_004.phpt @@ -0,0 +1,15 @@ +--TEST-- +Test possible function naming regression on procedural scope +--FILE-- +<?php + +class Obj +{ + function echo(){} // valid + function return(){} // valid +} + +function echo(){} // not valid + +--EXPECTF-- +Parse error: syntax error, unexpected 'echo' (T_ECHO), expecting identifier (T_STRING) or '(' in %s on line 9 diff --git a/Zend/tests/grammar/regression_005.phpt b/Zend/tests/grammar/regression_005.phpt new file mode 100644 index 0000000000..7704375d6e --- /dev/null +++ b/Zend/tests/grammar/regression_005.phpt @@ -0,0 +1,14 @@ +--TEST-- +Test possible constant naming regression on procedural scope +--FILE-- +<?php + +class Obj +{ + const return = 'yep'; +} + +const return = 'nope'; + +--EXPECTF-- +Parse error: syntax error, unexpected 'return' (T_RETURN), expecting identifier (T_STRING) in %s on line 8 diff --git a/Zend/tests/grammar/regression_006.phpt b/Zend/tests/grammar/regression_006.phpt new file mode 100644 index 0000000000..6aae0ba24b --- /dev/null +++ b/Zend/tests/grammar/regression_006.phpt @@ -0,0 +1,30 @@ +--TEST-- +Test to ensure const list syntax declaration works +--FILE-- +<?php + +class Obj +{ + const DECLARE = 'declare', + RETURN = 'return', + FUNCTION = 'function', + USE = 'use'; +} + +echo Obj::DECLARE, PHP_EOL; +echo Obj::RETURN, PHP_EOL; +echo Obj::FUNCTION, PHP_EOL; +echo Obj::USE, PHP_EOL; +echo Obj:: + + USE, PHP_EOL; +echo "\nDone\n"; + +--EXPECTF-- +declare +return +function +use +use + +Done diff --git a/Zend/tests/grammar/regression_007.phpt b/Zend/tests/grammar/regression_007.phpt new file mode 100644 index 0000000000..92b22531a4 --- /dev/null +++ b/Zend/tests/grammar/regression_007.phpt @@ -0,0 +1,44 @@ +--TEST-- +Test to ensure semi reserved words allow deference +--FILE-- +<?php + +class Foo { + const use = 'yay'; + + public static function new() { + echo __METHOD__, PHP_EOL; + return new static(); + } + + public function self() { + echo __METHOD__, PHP_EOL; + return $this; + } +} + +Foo::new()::new()::new(); + +var_dump( + (new Foo)->self()::new()->self()->self()::use +); + +Foo::{'new'}(); + +var_dump(Foo::use); + +echo "\nDone\n"; + +--EXPECTF-- +Foo::new +Foo::new +Foo::new +Foo::self +Foo::new +Foo::self +Foo::self +string(3) "yay" +Foo::new +string(3) "yay" + +Done diff --git a/Zend/tests/grammar/regression_008.phpt b/Zend/tests/grammar/regression_008.phpt new file mode 100644 index 0000000000..7741ed036c --- /dev/null +++ b/Zend/tests/grammar/regression_008.phpt @@ -0,0 +1,21 @@ +--TEST-- +Test to check regressions on string interpolation with class members access +--FILE-- +<?php + +class Friday { + public $require = "fun"; +} + +$friday = new Friday; + +echo "$friday->require ($friday->require) {$friday->require}", PHP_EOL; + +echo "\nDone\n"; + + +--EXPECTF-- + +fun (fun) fun + +Done diff --git a/Zend/tests/grammar/regression_009.phpt b/Zend/tests/grammar/regression_009.phpt new file mode 100644 index 0000000000..589d90316b --- /dev/null +++ b/Zend/tests/grammar/regression_009.phpt @@ -0,0 +1,18 @@ +--TEST-- +Test to check regressions on use statements and lexer state +--FILE-- +<?php + +use A\B\C\D; + +class Foo +{ + private static $foo; + +} + +echo PHP_EOL, "Done", PHP_EOL; + +--EXPECTF-- + +Done diff --git a/Zend/tests/grammar/regression_010.phpt b/Zend/tests/grammar/regression_010.phpt new file mode 100644 index 0000000000..5dc90f288a --- /dev/null +++ b/Zend/tests/grammar/regression_010.phpt @@ -0,0 +1,14 @@ +--TEST-- +Test to check regressions on T_IMPLEMENTS followed by a T_NS_SEPARATOR +--FILE-- +<?php + +interface A{} + +class B implements\A {} + +echo "Done", PHP_EOL; + +--EXPECTF-- + +Done diff --git a/Zend/tests/grammar/regression_011.phpt b/Zend/tests/grammar/regression_011.phpt new file mode 100644 index 0000000000..c79c077187 --- /dev/null +++ b/Zend/tests/grammar/regression_011.phpt @@ -0,0 +1,18 @@ +--TEST-- +Testing instantiation using namespace:: prefix +--FILE-- +<?php + +namespace foo; + +class bar { +} + +class_alias('foo\bar', 'foo\baz'); + +var_dump(new namespace\baz); + +?> +--EXPECTF-- +object(foo\bar)#%d (0) { +} diff --git a/Zend/tests/grammar/regression_012.phpt b/Zend/tests/grammar/regression_012.phpt new file mode 100644 index 0000000000..3b4925afa6 --- /dev/null +++ b/Zend/tests/grammar/regression_012.phpt @@ -0,0 +1,13 @@ +--TEST-- +Testing for regression on const list syntax and arrays +--FILE-- +<?php + +class A { + const A = [1, FOREACH]; +} + +?> +--EXPECTF-- + +Parse error: syntax error, unexpected 'FOREACH' (T_FOREACH), expecting ']' in %s on line %d diff --git a/Zend/tests/grammar/regression_013.phpt b/Zend/tests/grammar/regression_013.phpt new file mode 100644 index 0000000000..1c60ffc273 --- /dev/null +++ b/Zend/tests/grammar/regression_013.phpt @@ -0,0 +1,13 @@ +--TEST-- +Testing for regression with encapsed variables in class declaration context +--FILE-- +<?php + +class A { function foo() { "{${$a}}"; } function list() {} } + +echo "Done", PHP_EOL; + +?> +--EXPECTF-- + +Done diff --git a/Zend/tests/grammar/semi_reserved_001.phpt b/Zend/tests/grammar/semi_reserved_001.phpt new file mode 100644 index 0000000000..c6bfd46611 --- /dev/null +++ b/Zend/tests/grammar/semi_reserved_001.phpt @@ -0,0 +1,209 @@ +--TEST-- +Test semi-reserved words as class methods +--FILE-- +<?php + +class Obj +{ + function empty(){ echo __METHOD__, PHP_EOL; } + function callable(){ echo __METHOD__, PHP_EOL; } + function trait(){ echo __METHOD__, PHP_EOL; } + function extends(){ echo __METHOD__, PHP_EOL; } + function implements(){ echo __METHOD__, PHP_EOL; } + function const(){ echo __METHOD__, PHP_EOL; } + function enddeclare(){ echo __METHOD__, PHP_EOL; } + function endfor(){ echo __METHOD__, PHP_EOL; } + function endforeach(){ echo __METHOD__, PHP_EOL; } + function endif(){ echo __METHOD__, PHP_EOL; } + function endwhile(){ echo __METHOD__, PHP_EOL; } + function and(){ echo __METHOD__, PHP_EOL; } + function global(){ echo __METHOD__, PHP_EOL; } + function goto(){ echo __METHOD__, PHP_EOL; } + function instanceof(){ echo __METHOD__, PHP_EOL; } + function insteadof(){ echo __METHOD__, PHP_EOL; } + function interface(){ echo __METHOD__, PHP_EOL; } + function new(){ echo __METHOD__, PHP_EOL; } + function or(){ echo __METHOD__, PHP_EOL; } + function xor(){ echo __METHOD__, PHP_EOL; } + function try(){ echo __METHOD__, PHP_EOL; } + function use(){ echo __METHOD__, PHP_EOL; } + function var(){ echo __METHOD__, PHP_EOL; } + function exit(){ echo __METHOD__, PHP_EOL; } + function list(){ echo __METHOD__, PHP_EOL; } + function clone(){ echo __METHOD__, PHP_EOL; } + function include(){ echo __METHOD__, PHP_EOL; } + function include_once(){ echo __METHOD__, PHP_EOL; } + function throw(){ echo __METHOD__, PHP_EOL; } + function array(){ echo __METHOD__, PHP_EOL; } + function print(){ echo __METHOD__, PHP_EOL; } + function echo(){ echo __METHOD__, PHP_EOL; } + function require(){ echo __METHOD__, PHP_EOL; } + function require_once(){ echo __METHOD__, PHP_EOL; } + function return(){ echo __METHOD__, PHP_EOL; } + function else(){ echo __METHOD__, PHP_EOL; } + function elseif(){ echo __METHOD__, PHP_EOL; } + function default(){ echo __METHOD__, PHP_EOL; } + function break(){ echo __METHOD__, PHP_EOL; } + function continue(){ echo __METHOD__, PHP_EOL; } + function switch(){ echo __METHOD__, PHP_EOL; } + function yield(){ echo __METHOD__, PHP_EOL; } + function function(){ echo __METHOD__, PHP_EOL; } + function if(){ echo __METHOD__, PHP_EOL; } + function endswitch(){ echo __METHOD__, PHP_EOL; } + function finally(){ echo __METHOD__, PHP_EOL; } + function for(){ echo __METHOD__, PHP_EOL; } + function foreach(){ echo __METHOD__, PHP_EOL; } + function declare(){ echo __METHOD__, PHP_EOL; } + function case(){ echo __METHOD__, PHP_EOL; } + function do(){ echo __METHOD__, PHP_EOL; } + function while(){ echo __METHOD__, PHP_EOL; } + function as(){ echo __METHOD__, PHP_EOL; } + function catch(){ echo __METHOD__, PHP_EOL; } + function die(){ echo __METHOD__, PHP_EOL; } + function self(){ echo __METHOD__, PHP_EOL; } + function parent(){ echo __METHOD__, PHP_EOL; } + function public(){ echo __METHOD__, PHP_EOL; } + function protected(){ echo __METHOD__, PHP_EOL; } + function private(){ echo __METHOD__, PHP_EOL; } + function static(){ echo __METHOD__, PHP_EOL; } + function abstract(){ echo __METHOD__, PHP_EOL; } + function final(){ echo __METHOD__, PHP_EOL; } + function class(){ echo __METHOD__, PHP_EOL; } +} + +$obj = new Obj; + +$obj->empty(); +$obj->callable(); +$obj->trait(); +$obj->extends(); +$obj->implements(); +$obj->const(); +$obj->enddeclare(); +$obj->endfor(); +$obj->endforeach(); +$obj->endif(); +$obj->endwhile(); +$obj->and(); +$obj->global(); +$obj->goto(); +$obj->instanceof(); +$obj->insteadof(); +$obj->interface(); +$obj->new(); +$obj->or(); +$obj->xor(); +$obj->try(); +$obj->use(); +$obj->var(); +$obj->exit(); +$obj->list(); +$obj->clone(); +$obj->include(); +$obj->include_once(); +$obj->throw(); +$obj->array(); +$obj->print(); +$obj->echo(); +$obj->require(); +$obj->require_once(); +$obj->return(); +$obj->else(); +$obj->elseif(); +$obj->default(); +$obj->break(); +$obj->continue(); +$obj->switch(); +$obj->yield(); +$obj->function(); +$obj->if(); +$obj->endswitch(); +$obj->finally(); +$obj->for(); +$obj->foreach(); +$obj->declare(); +$obj->case(); +$obj->do(); +$obj->while(); +$obj->as(); +$obj->catch(); +$obj->die(); +$obj->self(); +$obj->parent(); +$obj->public(); +$obj->protected(); +$obj->private(); +$obj->static(); +$obj->abstract(); +$obj->final(); +$obj->class(); + +echo "\nDone\n"; + +--EXPECTF-- +Obj::empty +Obj::callable +Obj::trait +Obj::extends +Obj::implements +Obj::const +Obj::enddeclare +Obj::endfor +Obj::endforeach +Obj::endif +Obj::endwhile +Obj::and +Obj::global +Obj::goto +Obj::instanceof +Obj::insteadof +Obj::interface +Obj::new +Obj::or +Obj::xor +Obj::try +Obj::use +Obj::var +Obj::exit +Obj::list +Obj::clone +Obj::include +Obj::include_once +Obj::throw +Obj::array +Obj::print +Obj::echo +Obj::require +Obj::require_once +Obj::return +Obj::else +Obj::elseif +Obj::default +Obj::break +Obj::continue +Obj::switch +Obj::yield +Obj::function +Obj::if +Obj::endswitch +Obj::finally +Obj::for +Obj::foreach +Obj::declare +Obj::case +Obj::do +Obj::while +Obj::as +Obj::catch +Obj::die +Obj::self +Obj::parent +Obj::public +Obj::protected +Obj::private +Obj::static +Obj::abstract +Obj::final +Obj::class + +Done diff --git a/Zend/tests/grammar/semi_reserved_002.phpt b/Zend/tests/grammar/semi_reserved_002.phpt new file mode 100644 index 0000000000..b2c20028ca --- /dev/null +++ b/Zend/tests/grammar/semi_reserved_002.phpt @@ -0,0 +1,207 @@ +--TEST-- +Test semi-reserved words as static class methods +--FILE-- +<?php + +class Obj +{ + static function empty(){ echo __METHOD__, PHP_EOL; } + static function callable(){ echo __METHOD__, PHP_EOL; } + static function trait(){ echo __METHOD__, PHP_EOL; } + static function extends(){ echo __METHOD__, PHP_EOL; } + static function implements(){ echo __METHOD__, PHP_EOL; } + static function const(){ echo __METHOD__, PHP_EOL; } + static function enddeclare(){ echo __METHOD__, PHP_EOL; } + static function endfor(){ echo __METHOD__, PHP_EOL; } + static function endforeach(){ echo __METHOD__, PHP_EOL; } + static function endif(){ echo __METHOD__, PHP_EOL; } + static function endwhile(){ echo __METHOD__, PHP_EOL; } + static function and(){ echo __METHOD__, PHP_EOL; } + static function global(){ echo __METHOD__, PHP_EOL; } + static function goto(){ echo __METHOD__, PHP_EOL; } + static function instanceof(){ echo __METHOD__, PHP_EOL; } + static function insteadof(){ echo __METHOD__, PHP_EOL; } + static function interface(){ echo __METHOD__, PHP_EOL; } + static function new(){ echo __METHOD__, PHP_EOL; } + static function or(){ echo __METHOD__, PHP_EOL; } + static function xor(){ echo __METHOD__, PHP_EOL; } + static function try(){ echo __METHOD__, PHP_EOL; } + static function use(){ echo __METHOD__, PHP_EOL; } + static function var(){ echo __METHOD__, PHP_EOL; } + static function exit(){ echo __METHOD__, PHP_EOL; } + static function list(){ echo __METHOD__, PHP_EOL; } + static function clone(){ echo __METHOD__, PHP_EOL; } + static function include(){ echo __METHOD__, PHP_EOL; } + static function include_once(){ echo __METHOD__, PHP_EOL; } + static function throw(){ echo __METHOD__, PHP_EOL; } + static function array(){ echo __METHOD__, PHP_EOL; } + static function print(){ echo __METHOD__, PHP_EOL; } + static function echo(){ echo __METHOD__, PHP_EOL; } + static function require(){ echo __METHOD__, PHP_EOL; } + static function require_once(){ echo __METHOD__, PHP_EOL; } + static function return(){ echo __METHOD__, PHP_EOL; } + static function else(){ echo __METHOD__, PHP_EOL; } + static function elseif(){ echo __METHOD__, PHP_EOL; } + static function default(){ echo __METHOD__, PHP_EOL; } + static function break(){ echo __METHOD__, PHP_EOL; } + static function continue(){ echo __METHOD__, PHP_EOL; } + static function switch(){ echo __METHOD__, PHP_EOL; } + static function yield(){ echo __METHOD__, PHP_EOL; } + static function function(){ echo __METHOD__, PHP_EOL; } + static function if(){ echo __METHOD__, PHP_EOL; } + static function endswitch(){ echo __METHOD__, PHP_EOL; } + static function finally(){ echo __METHOD__, PHP_EOL; } + static function for(){ echo __METHOD__, PHP_EOL; } + static function foreach(){ echo __METHOD__, PHP_EOL; } + static function declare(){ echo __METHOD__, PHP_EOL; } + static function case(){ echo __METHOD__, PHP_EOL; } + static function do(){ echo __METHOD__, PHP_EOL; } + static function while(){ echo __METHOD__, PHP_EOL; } + static function as(){ echo __METHOD__, PHP_EOL; } + static function catch(){ echo __METHOD__, PHP_EOL; } + static function die(){ echo __METHOD__, PHP_EOL; } + static function self(){ echo __METHOD__, PHP_EOL; } + static function parent(){ echo __METHOD__, PHP_EOL; } + static function public(){ echo __METHOD__, PHP_EOL; } + static function protected(){ echo __METHOD__, PHP_EOL; } + static function private(){ echo __METHOD__, PHP_EOL; } + static function static(){ echo __METHOD__, PHP_EOL; } + static function abstract(){ echo __METHOD__, PHP_EOL; } + static function final(){ echo __METHOD__, PHP_EOL; } + static function class(){ echo __METHOD__, PHP_EOL; } +} + +Obj::empty(); +Obj::callable(); +Obj::trait(); +Obj::extends(); +Obj::implements(); +Obj::const(); +Obj::enddeclare(); +Obj::endfor(); +Obj::endforeach(); +Obj::endif(); +Obj::endwhile(); +Obj::and(); +Obj::global(); +Obj::goto(); +Obj::instanceof(); +Obj::insteadof(); +Obj::interface(); +Obj::new(); +Obj::or(); +Obj::xor(); +Obj::try(); +Obj::use(); +Obj::var(); +Obj::exit(); +Obj::list(); +Obj::clone(); +Obj::include(); +Obj::include_once(); +Obj::throw(); +Obj::array(); +Obj::print(); +Obj::echo(); +Obj::require(); +Obj::require_once(); +Obj::return(); +Obj::else(); +Obj::elseif(); +Obj::default(); +Obj::break(); +Obj::continue(); +Obj::switch(); +Obj::yield(); +Obj::function(); +Obj::if(); +Obj::endswitch(); +Obj::finally(); +Obj::for(); +Obj::foreach(); +Obj::declare(); +Obj::case(); +Obj::do(); +Obj::while(); +Obj::as(); +Obj::catch(); +Obj::die(); +Obj::self(); +Obj::parent(); +Obj::public(); +Obj::protected(); +Obj::private(); +Obj::static(); +Obj::abstract(); +Obj::final(); +Obj::class(); + +echo "\nDone\n"; + +--EXPECTF-- +Obj::empty +Obj::callable +Obj::trait +Obj::extends +Obj::implements +Obj::const +Obj::enddeclare +Obj::endfor +Obj::endforeach +Obj::endif +Obj::endwhile +Obj::and +Obj::global +Obj::goto +Obj::instanceof +Obj::insteadof +Obj::interface +Obj::new +Obj::or +Obj::xor +Obj::try +Obj::use +Obj::var +Obj::exit +Obj::list +Obj::clone +Obj::include +Obj::include_once +Obj::throw +Obj::array +Obj::print +Obj::echo +Obj::require +Obj::require_once +Obj::return +Obj::else +Obj::elseif +Obj::default +Obj::break +Obj::continue +Obj::switch +Obj::yield +Obj::function +Obj::if +Obj::endswitch +Obj::finally +Obj::for +Obj::foreach +Obj::declare +Obj::case +Obj::do +Obj::while +Obj::as +Obj::catch +Obj::die +Obj::self +Obj::parent +Obj::public +Obj::protected +Obj::private +Obj::static +Obj::abstract +Obj::final +Obj::class + +Done diff --git a/Zend/tests/grammar/semi_reserved_003.phpt b/Zend/tests/grammar/semi_reserved_003.phpt new file mode 100644 index 0000000000..fe2c44dc4c --- /dev/null +++ b/Zend/tests/grammar/semi_reserved_003.phpt @@ -0,0 +1,210 @@ +--TEST-- +Test semi-reserved words as class properties +--FILE-- +<?php + +class Obj +{ + var $empty = 'empty'; + var $callable = 'callable'; + var $class = 'class'; + var $trait = 'trait'; + var $extends = 'extends'; + var $implements = 'implements'; + var $static = 'static'; + var $abstract = 'abstract'; + var $final = 'final'; + var $public = 'public'; + var $protected = 'protected'; + var $private = 'private'; + var $const = 'const'; + var $enddeclare = 'enddeclare'; + var $endfor = 'endfor'; + var $endforeach = 'endforeach'; + var $endif = 'endif'; + var $endwhile = 'endwhile'; + var $and = 'and'; + var $global = 'global'; + var $goto = 'goto'; + var $instanceof = 'instanceof'; + var $insteadof = 'insteadof'; + var $interface = 'interface'; + var $namespace = 'namespace'; + var $new = 'new'; + var $or = 'or'; + var $xor = 'xor'; + var $try = 'try'; + var $use = 'use'; + var $var = 'var'; + var $exit = 'exit'; + var $list = 'list'; + var $clone = 'clone'; + var $include = 'include'; + var $include_once = 'include_once'; + var $throw = 'throw'; + var $array = 'array'; + var $print = 'print'; + var $echo = 'echo'; + var $require = 'require'; + var $require_once = 'require_once'; + var $return = 'return'; + var $else = 'else'; + var $elseif = 'elseif'; + var $default = 'default'; + var $break = 'break'; + var $continue = 'continue'; + var $switch = 'switch'; + var $yield = 'yield'; + var $function = 'function'; + var $if = 'if'; + var $endswitch = 'endswitch'; + var $finally = 'finally'; + var $for = 'for'; + var $foreach = 'foreach'; + var $declare = 'declare'; + var $case = 'case'; + var $do = 'do'; + var $while = 'while'; + var $as = 'as'; + var $catch = 'catch'; + var $die = 'die'; + var $self = 'self'; +} + +$obj = new Obj; + +echo $obj->empty, PHP_EOL; +echo $obj->callable, PHP_EOL; +echo $obj->class, PHP_EOL; +echo $obj->trait, PHP_EOL; +echo $obj->extends, PHP_EOL; +echo $obj->implements, PHP_EOL; +echo $obj->static, PHP_EOL; +echo $obj->abstract, PHP_EOL; +echo $obj->final, PHP_EOL; +echo $obj->public, PHP_EOL; +echo $obj->protected, PHP_EOL; +echo $obj->private, PHP_EOL; +echo $obj->const, PHP_EOL; +echo $obj->enddeclare, PHP_EOL; +echo $obj->endfor, PHP_EOL; +echo $obj->endforeach, PHP_EOL; +echo $obj->endif, PHP_EOL; +echo $obj->endwhile, PHP_EOL; +echo $obj->and, PHP_EOL; +echo $obj->global, PHP_EOL; +echo $obj->goto, PHP_EOL; +echo $obj->instanceof, PHP_EOL; +echo $obj->insteadof, PHP_EOL; +echo $obj->interface, PHP_EOL; +echo $obj->namespace, PHP_EOL; +echo $obj->new, PHP_EOL; +echo $obj->or, PHP_EOL; +echo $obj->xor, PHP_EOL; +echo $obj->try, PHP_EOL; +echo $obj->use, PHP_EOL; +echo $obj->var, PHP_EOL; +echo $obj->exit, PHP_EOL; +echo $obj->list, PHP_EOL; +echo $obj->clone, PHP_EOL; +echo $obj->include, PHP_EOL; +echo $obj->include_once, PHP_EOL; +echo $obj->throw, PHP_EOL; +echo $obj->array, PHP_EOL; +echo $obj->print, PHP_EOL; +echo $obj->echo, PHP_EOL; +echo $obj->require, PHP_EOL; +echo $obj->require_once, PHP_EOL; +echo $obj->return, PHP_EOL; +echo $obj->else, PHP_EOL; +echo $obj->elseif, PHP_EOL; +echo $obj->default, PHP_EOL; +echo $obj->break, PHP_EOL; +echo $obj->continue, PHP_EOL; +echo $obj->switch, PHP_EOL; +echo $obj->yield, PHP_EOL; +echo $obj->function, PHP_EOL; +echo $obj->if, PHP_EOL; +echo $obj->endswitch, PHP_EOL; +echo $obj->finally, PHP_EOL; +echo $obj->for, PHP_EOL; +echo $obj->foreach, PHP_EOL; +echo $obj->declare, PHP_EOL; +echo $obj->case, PHP_EOL; +echo $obj->do, PHP_EOL; +echo $obj->while, PHP_EOL; +echo $obj->as, PHP_EOL; +echo $obj->catch, PHP_EOL; +echo $obj->die, PHP_EOL; +echo $obj->self, PHP_EOL; + +echo "\nDone\n"; + +?> +--EXPECTF-- +empty +callable +class +trait +extends +implements +static +abstract +final +public +protected +private +const +enddeclare +endfor +endforeach +endif +endwhile +and +global +goto +instanceof +insteadof +interface +namespace +new +or +xor +try +use +var +exit +list +clone +include +include_once +throw +array +print +echo +require +require_once +return +else +elseif +default +break +continue +switch +yield +function +if +endswitch +finally +for +foreach +declare +case +do +while +as +catch +die +self + +Done diff --git a/Zend/tests/grammar/semi_reserved_004.phpt b/Zend/tests/grammar/semi_reserved_004.phpt new file mode 100644 index 0000000000..40c5df14ef --- /dev/null +++ b/Zend/tests/grammar/semi_reserved_004.phpt @@ -0,0 +1,210 @@ +--TEST-- +Test semi-reserved words as static class properties +--FILE-- +<?php + +class Obj +{ + static $empty = 'empty'; + static $callable = 'callable'; + static $class = 'class'; + static $trait = 'trait'; + static $extends = 'extends'; + static $implements = 'implements'; + static $static = 'static'; + static $abstract = 'abstract'; + static $final = 'final'; + static $public = 'public'; + static $protected = 'protected'; + static $private = 'private'; + static $const = 'const'; + static $enddeclare = 'enddeclare'; + static $endfor = 'endfor'; + static $endforeach = 'endforeach'; + static $endif = 'endif'; + static $endwhile = 'endwhile'; + static $and = 'and'; + static $global = 'global'; + static $goto = 'goto'; + static $instanceof = 'instanceof'; + static $insteadof = 'insteadof'; + static $interface = 'interface'; + static $namespace = 'namespace'; + static $new = 'new'; + static $or = 'or'; + static $xor = 'xor'; + static $try = 'try'; + static $use = 'use'; + static $var = 'var'; + static $exit = 'exit'; + static $list = 'list'; + static $clone = 'clone'; + static $include = 'include'; + static $include_once = 'include_once'; + static $throw = 'throw'; + static $array = 'array'; + static $print = 'print'; + static $echo = 'echo'; + static $require = 'require'; + static $require_once = 'require_once'; + static $return = 'return'; + static $else = 'else'; + static $elseif = 'elseif'; + static $default = 'default'; + static $break = 'break'; + static $continue = 'continue'; + static $switch = 'switch'; + static $yield = 'yield'; + static $function = 'function'; + static $if = 'if'; + static $endswitch = 'endswitch'; + static $finally = 'finally'; + static $for = 'for'; + static $foreach = 'foreach'; + static $declare = 'declare'; + static $case = 'case'; + static $do = 'do'; + static $while = 'while'; + static $as = 'as'; + static $catch = 'catch'; + static $die = 'die'; + static $self = 'self'; + static $parent = 'parent'; +} + +echo Obj::$empty, PHP_EOL; +echo Obj::$callable, PHP_EOL; +echo Obj::$class, PHP_EOL; +echo Obj::$trait, PHP_EOL; +echo Obj::$extends, PHP_EOL; +echo Obj::$implements, PHP_EOL; +echo Obj::$static, PHP_EOL; +echo Obj::$abstract, PHP_EOL; +echo Obj::$final, PHP_EOL; +echo Obj::$public, PHP_EOL; +echo Obj::$protected, PHP_EOL; +echo Obj::$private, PHP_EOL; +echo Obj::$const, PHP_EOL; +echo Obj::$enddeclare, PHP_EOL; +echo Obj::$endfor, PHP_EOL; +echo Obj::$endforeach, PHP_EOL; +echo Obj::$endif, PHP_EOL; +echo Obj::$endwhile, PHP_EOL; +echo Obj::$and, PHP_EOL; +echo Obj::$global, PHP_EOL; +echo Obj::$goto, PHP_EOL; +echo Obj::$instanceof, PHP_EOL; +echo Obj::$insteadof, PHP_EOL; +echo Obj::$interface, PHP_EOL; +echo Obj::$namespace, PHP_EOL; +echo Obj::$new, PHP_EOL; +echo Obj::$or, PHP_EOL; +echo Obj::$xor, PHP_EOL; +echo Obj::$try, PHP_EOL; +echo Obj::$use, PHP_EOL; +echo Obj::$var, PHP_EOL; +echo Obj::$exit, PHP_EOL; +echo Obj::$list, PHP_EOL; +echo Obj::$clone, PHP_EOL; +echo Obj::$include, PHP_EOL; +echo Obj::$include_once, PHP_EOL; +echo Obj::$throw, PHP_EOL; +echo Obj::$array, PHP_EOL; +echo Obj::$print, PHP_EOL; +echo Obj::$echo, PHP_EOL; +echo Obj::$require, PHP_EOL; +echo Obj::$require_once, PHP_EOL; +echo Obj::$return, PHP_EOL; +echo Obj::$else, PHP_EOL; +echo Obj::$elseif, PHP_EOL; +echo Obj::$default, PHP_EOL; +echo Obj::$break, PHP_EOL; +echo Obj::$continue, PHP_EOL; +echo Obj::$switch, PHP_EOL; +echo Obj::$yield, PHP_EOL; +echo Obj::$function, PHP_EOL; +echo Obj::$if, PHP_EOL; +echo Obj::$endswitch, PHP_EOL; +echo Obj::$finally, PHP_EOL; +echo Obj::$for, PHP_EOL; +echo Obj::$foreach, PHP_EOL; +echo Obj::$declare, PHP_EOL; +echo Obj::$case, PHP_EOL; +echo Obj::$do, PHP_EOL; +echo Obj::$while, PHP_EOL; +echo Obj::$as, PHP_EOL; +echo Obj::$catch, PHP_EOL; +echo Obj::$die, PHP_EOL; +echo Obj::$self, PHP_EOL; +echo Obj::$parent, PHP_EOL; + +echo "\nDone\n"; + +--EXPECTF-- +empty +callable +class +trait +extends +implements +static +abstract +final +public +protected +private +const +enddeclare +endfor +endforeach +endif +endwhile +and +global +goto +instanceof +insteadof +interface +namespace +new +or +xor +try +use +var +exit +list +clone +include +include_once +throw +array +print +echo +require +require_once +return +else +elseif +default +break +continue +switch +yield +function +if +endswitch +finally +for +foreach +declare +case +do +while +as +catch +die +self +parent + +Done diff --git a/Zend/tests/grammar/semi_reserved_005.phpt b/Zend/tests/grammar/semi_reserved_005.phpt new file mode 100644 index 0000000000..3ad0830b09 --- /dev/null +++ b/Zend/tests/grammar/semi_reserved_005.phpt @@ -0,0 +1,207 @@ +--TEST-- +Test semi-reserved words as class constants +--FILE-- +<?php + +class Obj +{ + const EMPTY = 'empty'; + const CALLABLE = 'callable'; + const TRAIT = 'trait'; + const EXTENDS = 'extends'; + const IMPLEMENTS = 'implements'; + const CONST = 'const'; + const ENDDECLARE = 'enddeclare'; + const ENDFOR = 'endfor'; + const ENDFOREACH = 'endforeach'; + const ENDIF = 'endif'; + const ENDWHILE = 'endwhile'; + const AND = 'and'; + const GLOBAL = 'global'; + const GOTO = 'goto'; + const INSTANCEOF = 'instanceof'; + const INSTEADOF = 'insteadof'; + const INTERFACE = 'interface'; + const NAMESPACE = 'namespace'; + const NEW = 'new'; + const OR = 'or'; + const XOR = 'xor'; + const TRY = 'try'; + const USE = 'use'; + const VAR = 'var'; + const EXIT = 'exit'; + const LIST = 'list'; + const CLONE = 'clone'; + const INCLUDE = 'include'; + const INCLUDE_ONCE = 'include_once'; + const THROW = 'throw'; + const ARRAY = 'array'; + const PRINT = 'print'; + const ECHO = 'echo'; + const REQUIRE = 'require'; + const REQUIRE_ONCE = 'require_once'; + const RETURN = 'return'; + const ELSE = 'else'; + const ELSEIF = 'elseif'; + const DEFAULT = 'default'; + const BREAK = 'break'; + const CONTINUE = 'continue'; + const SWITCH = 'switch'; + const YIELD = 'yield'; + const FUNCTION = 'function'; + const IF = 'if'; + const ENDSWITCH = 'endswitch'; + const FINALLY = 'finally'; + const FOR = 'for'; + const FOREACH = 'foreach'; + const DECLARE = 'declare'; + const CASE = 'case'; + const DO = 'do'; + const WHILE = 'while'; + const AS = 'as'; + const CATCH = 'catch'; + const DIE = 'die'; + const SELF = 'self'; + const PARENT = 'parent'; + const PUBLIC = 'public'; + const PROTECTED = 'protected'; + const PRIVATE = 'private'; + const STATIC = 'static'; + const ABSTRACT = 'abstract'; + const FINAL = 'final'; +} + +echo Obj::EMPTY, PHP_EOL; +echo Obj::CALLABLE, PHP_EOL; +echo Obj::TRAIT, PHP_EOL; +echo Obj::EXTENDS, PHP_EOL; +echo Obj::IMPLEMENTS, PHP_EOL; +echo Obj::CONST, PHP_EOL; +echo Obj::ENDDECLARE, PHP_EOL; +echo Obj::ENDFOR, PHP_EOL; +echo Obj::ENDFOREACH, PHP_EOL; +echo Obj::ENDIF, PHP_EOL; +echo Obj::ENDWHILE, PHP_EOL; +echo Obj::AND, PHP_EOL; +echo Obj::GLOBAL, PHP_EOL; +echo Obj::GOTO, PHP_EOL; +echo Obj::INSTANCEOF, PHP_EOL; +echo Obj::INSTEADOF, PHP_EOL; +echo Obj::INTERFACE, PHP_EOL; +echo Obj::NAMESPACE, PHP_EOL; +echo Obj::NEW, PHP_EOL; +echo Obj::OR, PHP_EOL; +echo Obj::XOR, PHP_EOL; +echo Obj::TRY, PHP_EOL; +echo Obj::USE, PHP_EOL; +echo Obj::VAR, PHP_EOL; +echo Obj::EXIT, PHP_EOL; +echo Obj::LIST, PHP_EOL; +echo Obj::CLONE, PHP_EOL; +echo Obj::INCLUDE, PHP_EOL; +echo Obj::INCLUDE_ONCE, PHP_EOL; +echo Obj::THROW, PHP_EOL; +echo Obj::ARRAY, PHP_EOL; +echo Obj::PRINT, PHP_EOL; +echo Obj::ECHO, PHP_EOL; +echo Obj::REQUIRE, PHP_EOL; +echo Obj::REQUIRE_ONCE, PHP_EOL; +echo Obj::RETURN, PHP_EOL; +echo Obj::ELSE, PHP_EOL; +echo Obj::ELSEIF, PHP_EOL; +echo Obj::DEFAULT, PHP_EOL; +echo Obj::BREAK, PHP_EOL; +echo Obj::CONTINUE, PHP_EOL; +echo Obj::SWITCH, PHP_EOL; +echo Obj::YIELD, PHP_EOL; +echo Obj::FUNCTION, PHP_EOL; +echo Obj::IF, PHP_EOL; +echo Obj::ENDSWITCH, PHP_EOL; +echo Obj::FINALLY, PHP_EOL; +echo Obj::FOR, PHP_EOL; +echo Obj::FOREACH, PHP_EOL; +echo Obj::DECLARE, PHP_EOL; +echo Obj::CASE, PHP_EOL; +echo Obj::DO, PHP_EOL; +echo Obj::WHILE, PHP_EOL; +echo Obj::AS, PHP_EOL; +echo Obj::CATCH, PHP_EOL; +echo Obj::DIE, PHP_EOL; +echo Obj::SELF, PHP_EOL; +echo Obj::PARENT, PHP_EOL; +echo Obj::PUBLIC, PHP_EOL; +echo Obj::PROTECTED, PHP_EOL; +echo Obj::PRIVATE, PHP_EOL; +echo Obj::STATIC, PHP_EOL; +echo Obj::ABSTRACT, PHP_EOL; +echo Obj::FINAL, PHP_EOL; + +echo "\nDone\n"; + +--EXPECTF-- +empty +callable +trait +extends +implements +const +enddeclare +endfor +endforeach +endif +endwhile +and +global +goto +instanceof +insteadof +interface +namespace +new +or +xor +try +use +var +exit +list +clone +include +include_once +throw +array +print +echo +require +require_once +return +else +elseif +default +break +continue +switch +yield +function +if +endswitch +finally +for +foreach +declare +case +do +while +as +catch +die +self +parent +public +protected +private +static +abstract +final + +Done diff --git a/Zend/tests/grammar/semi_reserved_006.phpt b/Zend/tests/grammar/semi_reserved_006.phpt new file mode 100644 index 0000000000..334d09ac36 --- /dev/null +++ b/Zend/tests/grammar/semi_reserved_006.phpt @@ -0,0 +1,80 @@ +--TEST-- +Test semi-reserved method and constant names and trait conflict resolution +--FILE-- +<?php + +trait TraitA +{ + public function catch(){ echo __METHOD__, PHP_EOL; } + private function list(){ echo __METHOD__, PHP_EOL; } +} + +trait TraitB +{ + static $list = ['a' => ['b' => ['c']]]; + + public static function catch(){ echo __METHOD__, PHP_EOL; } + private static function throw(){ echo __METHOD__, PHP_EOL; } + private static function self(){ echo __METHOD__, PHP_EOL; } +} + +trait TraitC +{ + public static function exit(){ echo __METHOD__, PHP_EOL; } + protected static function try(){ echo __METHOD__, PHP_EOL; } +} + +class Foo +{ + use TraitA, TraitB { + TraitA + :: + catch insteadof namespace\TraitB; + TraitA::list as public foreach; + TraitB::throw as public; + TraitB::self as public; + } + + use TraitC { + try as public attempt; + exit as die; + \TraitC::exit as bye; + namespace\TraitC::exit as byebye; + TraitC + :: + exit as farewell; + } +} + +(new Foo)->catch(); +(new Foo)->foreach(); +Foo::throw(); +Foo::self(); +var_dump(Foo::$list['a']); +Foo::attempt(); +Foo::die(); +Foo::bye(); +Foo::byebye(); +Foo::farewell(); + +echo "\nDone\n"; + +--EXPECTF-- +TraitA::catch +TraitA::list +TraitB::throw +TraitB::self +array(1) { + ["b"]=> + array(1) { + [0]=> + string(1) "c" + } +} +TraitC::try +TraitC::exit +TraitC::exit +TraitC::exit +TraitC::exit + +Done diff --git a/Zend/tests/grammar/semi_reserved_007.phpt b/Zend/tests/grammar/semi_reserved_007.phpt new file mode 100644 index 0000000000..5105629cbe --- /dev/null +++ b/Zend/tests/grammar/semi_reserved_007.phpt @@ -0,0 +1,37 @@ +--TEST-- +Edge case: self::self, self::parent, parent::self semi reserved constants access +--FILE-- +<?php + +class Foo { + const self = "self"; + const parent = "parent"; + public function __construct() { + echo "From ", __METHOD__, ":", PHP_EOL; + echo self::self, PHP_EOL; + echo self::parent, PHP_EOL; + } +} + +class Bar extends Foo { + public function __construct() { + parent::__construct(); + echo "From ", __METHOD__, ":", PHP_EOL; + echo parent::self, PHP_EOL; + echo parent::parent, PHP_EOL; + } +} + +new Bar; + +echo "\nDone\n"; + +--EXPECTF-- +From Foo::__construct: +self +parent +From Bar::__construct: +self +parent + +Done
\ No newline at end of file diff --git a/Zend/tests/grammar/semi_reserved_008.phpt b/Zend/tests/grammar/semi_reserved_008.phpt new file mode 100644 index 0000000000..43218b1b05 --- /dev/null +++ b/Zend/tests/grammar/semi_reserved_008.phpt @@ -0,0 +1,68 @@ +--TEST-- +Testing with comments around semi-reserved names (not intended to be legible) +--FILE-- +<?php + +trait TraitA +{ + public static function list(){ echo __METHOD__, PHP_EOL; } + public static function /* comment */ catch(){ echo __METHOD__, PHP_EOL; } + private static function // comment + throw(){ echo __METHOD__, PHP_EOL; } + private static function + # comment + self(){ echo __METHOD__, PHP_EOL; } +} + +trait TraitB +{ + public static function exit(){ echo __METHOD__, PHP_EOL; } + protected static function try(){ echo __METHOD__, PHP_EOL; } +} + +class Foo +{ + use TraitA { + TraitA:: + // + /** doc comment */ + # + catch /* comment */ + // comment + # comment + insteadof TraitB; + + TraitA::list as public /**/ foreach; + } + + use TraitB { + try /*comment*/ as public attempt; + exit // comment + as/*comment*/die; // non qualified + \TraitB::exit as bye; // full qualified + namespace\TraitB::exit # + as byebye; // even more full qualified + TraitB + :: + /** */ + exit as farewell; // full qualified with weird spacing + } +} + +Foo /**/ +# +// +/** */ +:: +/**/ +# +// +/** */ +attempt(); + +echo PHP_EOL, "Done", PHP_EOL; + +--EXPECTF-- +TraitB::try + +Done diff --git a/Zend/tests/grammar/semi_reserved_009.phpt b/Zend/tests/grammar/semi_reserved_009.phpt new file mode 100644 index 0000000000..1a7b0fc371 --- /dev/null +++ b/Zend/tests/grammar/semi_reserved_009.phpt @@ -0,0 +1,25 @@ +--TEST-- +Edge case: T_STRING<as> as T_STRING<?> +--FILE-- +<?php + +trait TraitA +{ + public static function as(){ echo __METHOD__, PHP_EOL; } +} + +class Foo +{ + use TraitA { + as as try; + } +} + +Foo::try(); + +echo PHP_EOL, "Done", PHP_EOL; + +--EXPECTF-- +TraitA::as + +Done diff --git a/Zend/tests/grammar/semi_reserved_010.phpt b/Zend/tests/grammar/semi_reserved_010.phpt new file mode 100644 index 0000000000..508a7867a4 --- /dev/null +++ b/Zend/tests/grammar/semi_reserved_010.phpt @@ -0,0 +1,31 @@ +--TEST-- +Edge case: T_STRING<insteadof> insteadof T_STRING<?> +--FILE-- +<?php + +trait TraitA +{ + public static function insteadof(){ echo __METHOD__, PHP_EOL; } +} + +trait TraitB +{ + public static function insteadof(){ echo __METHOD__, PHP_EOL; } +} + +class Foo +{ + use TraitA , TraitB { + TraitB::insteadof + insteadof TraitA; + } +} + +Foo::insteadof(); + +echo PHP_EOL, "Done", PHP_EOL; + +--EXPECTF-- +TraitB::insteadof + +Done diff --git a/Zend/zend_ast.c b/Zend/zend_ast.c index 34a2e132f9..aad9b64ffc 100644 --- a/Zend/zend_ast.c +++ b/Zend/zend_ast.c @@ -1149,9 +1149,6 @@ simple_list: case ZEND_AST_CONST: zend_ast_export_ns_name(str, ast->child[0], 0, indent); break; - case ZEND_AST_RESOLVE_CLASS_NAME: - zend_ast_export_ns_name(str, ast->child[0], 0, indent); - APPEND_STR("::class"); case ZEND_AST_UNPACK: smart_str_appends(str, "..."); ast = ast->child[0]; diff --git a/Zend/zend_ast.h b/Zend/zend_ast.h index 33aa292fb7..2b8d4d37b8 100644 --- a/Zend/zend_ast.h +++ b/Zend/zend_ast.h @@ -66,7 +66,6 @@ enum _zend_ast_kind { /* 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, diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index 4721ecd939..39c7aa302c 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -557,7 +557,10 @@ static int zend_add_const_name_literal(zend_op_array *op_array, zend_string *nam op.constant = zend_add_literal(CG(active_op_array), &_c); \ } while (0) -void zend_stop_lexing(void) { +void zend_stop_lexing(void) +{ + if(LANG_SCNG(on_event)) LANG_SCNG(on_event)(ON_STOP, END, 0); + LANG_SCNG(yy_cursor) = LANG_SCNG(yy_limit); } @@ -1345,6 +1348,88 @@ static inline zend_bool class_name_refers_to_active_ce(zend_string *class_name, } /* }}} */ +uint32_t zend_get_class_fetch_type(zend_string *name) /* {{{ */ +{ + if (zend_string_equals_literal_ci(name, "self")) { + return ZEND_FETCH_CLASS_SELF; + } else if (zend_string_equals_literal_ci(name, "parent")) { + return ZEND_FETCH_CLASS_PARENT; + } else if (zend_string_equals_literal_ci(name, "static")) { + return ZEND_FETCH_CLASS_STATIC; + } else { + return ZEND_FETCH_CLASS_DEFAULT; + } +} +/* }}} */ + +static uint32_t zend_get_class_fetch_type_ast(zend_ast *name_ast) /* {{{ */ +{ + /* Fully qualified names are always default refs */ + if (name_ast->attr == ZEND_NAME_FQ) { + return ZEND_FETCH_CLASS_DEFAULT; + } + + return zend_get_class_fetch_type(zend_ast_get_str(name_ast)); +} +/* }}} */ + +static void zend_ensure_valid_class_fetch_type(uint32_t fetch_type) /* {{{ */ +{ + if (fetch_type != ZEND_FETCH_CLASS_DEFAULT && !CG(active_class_entry) && zend_is_scope_known()) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use \"%s\" when no class scope is active", + fetch_type == ZEND_FETCH_CLASS_SELF ? "self" : + fetch_type == ZEND_FETCH_CLASS_PARENT ? "parent" : "static"); + } +} +/* }}} */ + +static zend_bool zend_try_compile_const_expr_resolve_class_name(zval *zv, zend_ast *class_ast, zend_ast *name_ast, zend_bool constant) /* {{{ */ +{ + uint32_t fetch_type; + + if (name_ast->kind != ZEND_AST_ZVAL) { + return 0; + } + + if (!zend_string_equals_literal_ci(zend_ast_get_str(name_ast), "class")) { + return 0; + } + + if (class_ast->kind != ZEND_AST_ZVAL) { + zend_error_noreturn(E_COMPILE_ERROR, + "Dynamic class names are not allowed in compile-time ::class fetch"); + } + + fetch_type = zend_get_class_fetch_type(zend_ast_get_str(class_ast)); + zend_ensure_valid_class_fetch_type(fetch_type); + + switch (fetch_type) { + case ZEND_FETCH_CLASS_SELF: + if (constant || (CG(active_class_entry) && zend_is_scope_known())) { + ZVAL_STR_COPY(zv, CG(active_class_entry)->name); + } else { + ZVAL_NULL(zv); + } + return 1; + case ZEND_FETCH_CLASS_STATIC: + case ZEND_FETCH_CLASS_PARENT: + if (constant) { + 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" + ); + } else { + ZVAL_NULL(zv); + } + return 1; + case ZEND_FETCH_CLASS_DEFAULT: + ZVAL_STR(zv, zend_resolve_class_name_ast(class_ast)); + return 1; + EMPTY_SWITCH_DEFAULT_CASE() + } +} +/* }}} */ + static zend_bool zend_try_ct_eval_class_const(zval *zv, zend_string *class_name, zend_string *name) /* {{{ */ { uint32_t fetch_type = zend_get_class_fetch_type(class_name); @@ -1625,41 +1710,6 @@ ZEND_API void zend_initialize_class_data(zend_class_entry *ce, zend_bool nullify } /* }}} */ -uint32_t zend_get_class_fetch_type(zend_string *name) /* {{{ */ -{ - if (zend_string_equals_literal_ci(name, "self")) { - return ZEND_FETCH_CLASS_SELF; - } else if (zend_string_equals_literal_ci(name, "parent")) { - return ZEND_FETCH_CLASS_PARENT; - } else if (zend_string_equals_literal_ci(name, "static")) { - return ZEND_FETCH_CLASS_STATIC; - } else { - return ZEND_FETCH_CLASS_DEFAULT; - } -} -/* }}} */ - -static uint32_t zend_get_class_fetch_type_ast(zend_ast *name_ast) /* {{{ */ -{ - /* Fully qualified names are always default refs */ - if (name_ast->attr == ZEND_NAME_FQ) { - return ZEND_FETCH_CLASS_DEFAULT; - } - - return zend_get_class_fetch_type(zend_ast_get_str(name_ast)); -} -/* }}} */ - -static void zend_ensure_valid_class_fetch_type(uint32_t fetch_type) /* {{{ */ -{ - if (fetch_type != ZEND_FETCH_CLASS_DEFAULT && !CG(active_class_entry) && zend_is_scope_known()) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use \"%s\" when no class scope is active", - fetch_type == ZEND_FETCH_CLASS_SELF ? "self" : - fetch_type == ZEND_FETCH_CLASS_PARENT ? "parent" : "static"); - } -} -/* }}} */ - 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)]; @@ -2164,14 +2214,6 @@ static zend_op *zend_compile_simple_var_no_cv(znode *result, zend_ast *ast, uint znode name_node; zend_op *opline; - /* there is a chance someone is accessing $this */ - if (ast->kind != ZEND_AST_ZVAL - && CG(active_op_array)->scope && CG(active_op_array)->this_var == (uint32_t)-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); - } - zend_compile_expr(&name_node, name_ast); if (name_node.op_type == IS_CONST) { convert_to_string(&name_node.u.constant); @@ -2183,10 +2225,18 @@ static zend_op *zend_compile_simple_var_no_cv(znode *result, zend_ast *ast, uint opline = zend_emit_op(result, ZEND_FETCH_R, &name_node, NULL); } - opline->extended_value = ZEND_FETCH_LOCAL; - if (name_node.op_type == IS_CONST) { - if (zend_is_auto_global(Z_STR(name_node.u.constant))) { - opline->extended_value = ZEND_FETCH_GLOBAL; + if (name_node.op_type == IS_CONST && + zend_is_auto_global(Z_STR(name_node.u.constant))) { + + opline->extended_value = ZEND_FETCH_GLOBAL; + } else { + opline->extended_value = ZEND_FETCH_LOCAL; + /* 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 == (uint32_t)-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); } } @@ -4747,6 +4797,11 @@ void zend_compile_class_const_decl(zend_ast *ast) /* {{{ */ zend_string *name = zend_ast_get_str(name_ast); zval value_zv; + if (zend_string_equals_literal_ci(name, "class")) { + zend_error(E_COMPILE_ERROR, + "A class constant must not be called 'class'; it is reserved for class name fetching"); + } + zend_const_expr_to_zval(&value_zv, value_ast); name = zend_new_interned_string_safe(name); @@ -6313,6 +6368,16 @@ void zend_compile_class_const(znode *result, zend_ast *ast) /* {{{ */ zend_op *opline; zend_string *resolved_name; + if (zend_try_compile_const_expr_resolve_class_name(&result->u.constant, class_ast, const_ast, 0)) { + if (Z_TYPE(result->u.constant) == IS_NULL) { + zend_op *opline = zend_emit_op_tmp(result, ZEND_FETCH_CLASS_NAME, NULL, NULL); + opline->extended_value = zend_get_class_fetch_type(zend_ast_get_str(class_ast)); + } else { + result->op_type = IS_CONST; + } + return; + } + zend_eval_const_expr(&class_ast); zend_eval_const_expr(&const_ast); @@ -6324,6 +6389,10 @@ void zend_compile_class_const(znode *result, zend_ast *ast) /* {{{ */ return; } } + if (const_ast->kind == ZEND_AST_ZVAL && zend_string_equals_literal_ci(zend_ast_get_str(const_ast), "class")) { + zend_error_noreturn(E_COMPILE_ERROR, + "Dynamic class names are not allowed in compile-time ::class fetch"); + } if (zend_is_const_default_class_ref(class_ast)) { class_node.op_type = IS_CONST; @@ -6536,7 +6605,7 @@ zend_bool zend_is_allowed_in_const_expr(zend_ast_kind kind) /* {{{ */ || 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; + || kind == ZEND_AST_MAGIC_CONST; } /* }}} */ @@ -6555,6 +6624,11 @@ void zend_compile_const_expr_class_const(zend_ast **ast_ptr) /* {{{ */ "Dynamic class names are not allowed in compile-time class constant references"); } + if (zend_try_compile_const_expr_resolve_class_name(&result, class_ast, const_ast, 1)) { + *ast_ptr = zend_ast_create_zval(&result); + return; + } + class_name = zend_ast_get_str(class_ast); fetch_type = zend_get_class_fetch_type(class_name); @@ -6610,36 +6684,6 @@ void zend_compile_const_expr_const(zend_ast **ast_ptr) /* {{{ */ } /* }}} */ -void zend_compile_const_expr_resolve_class_name(zend_ast **ast_ptr) /* {{{ */ -{ - zend_ast *ast = *ast_ptr; - zend_ast *name_ast = ast->child[0]; - zval result; - uint32_t fetch_type = zend_get_class_fetch_type(zend_ast_get_str(name_ast)); - zend_ensure_valid_class_fetch_type(fetch_type); - - switch (fetch_type) { - case ZEND_FETCH_CLASS_SELF: - ZVAL_STR_COPY(&result, 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)); - break; - EMPTY_SWITCH_DEFAULT_CASE() - } - - zend_ast_destroy(ast); - *ast_ptr = zend_ast_create_zval(&result); -} -/* }}} */ - void zend_compile_const_expr_magic_const(zend_ast **ast_ptr) /* {{{ */ { zend_ast *ast = *ast_ptr; @@ -6678,9 +6722,6 @@ void zend_compile_const_expr(zend_ast **ast_ptr) /* {{{ */ case ZEND_AST_CONST: zend_compile_const_expr_const(ast_ptr); break; - case ZEND_AST_RESOLVE_CLASS_NAME: - zend_compile_const_expr_resolve_class_name(ast_ptr); - break; case ZEND_AST_MAGIC_CONST: zend_compile_const_expr_magic_const(ast_ptr); break; @@ -6955,9 +6996,6 @@ void zend_compile_expr(znode *result, zend_ast *ast) /* {{{ */ case ZEND_AST_CLASS_CONST: zend_compile_class_const(result, ast); return; - case ZEND_AST_RESOLVE_CLASS_NAME: - zend_compile_resolve_class_name(result, ast); - return; case ZEND_AST_ENCAPS_LIST: zend_compile_encaps_list(result, ast); return; @@ -7127,9 +7165,18 @@ void zend_eval_const_expr(zend_ast **ast_ptr) /* {{{ */ zend_ast *name_ast = ast->child[1]; zend_string *resolved_name; + if (zend_try_compile_const_expr_resolve_class_name(&result, class_ast, name_ast, 1)) { + break; + } + zend_eval_const_expr(&class_ast); zend_eval_const_expr(&name_ast); + if (name_ast->kind == ZEND_AST_ZVAL && zend_string_equals_literal_ci(zend_ast_get_str(name_ast), "class")) { + zend_error_noreturn(E_COMPILE_ERROR, + "Dynamic class names are not allowed in compile-time ::class fetch"); + } + if (class_ast->kind != ZEND_AST_ZVAL || name_ast->kind != ZEND_AST_ZVAL) { return; } diff --git a/Zend/zend_globals.h b/Zend/zend_globals.h index 326955a103..28487a2a4a 100644 --- a/Zend/zend_globals.h +++ b/Zend/zend_globals.h @@ -249,6 +249,12 @@ struct _zend_ini_scanner_globals { int scanner_mode; }; +typedef enum { + ON_TOKEN, + ON_FEEDBACK, + ON_STOP +} zend_php_scanner_event; + struct _zend_php_scanner_globals { zend_file_handle *yy_in; zend_file_handle *yy_out; @@ -278,6 +284,9 @@ struct _zend_php_scanner_globals { /* initial string length after scanning to first variable */ int scanned_string_len; + + /* hooks */ + void (* on_event)(zend_php_scanner_event event, int token, int line); }; #endif /* ZEND_GLOBALS_H */ diff --git a/Zend/zend_language_parser.y b/Zend/zend_language_parser.y index 2541c9f571..9f61fabe35 100644 --- a/Zend/zend_language_parser.y +++ b/Zend/zend_language_parser.y @@ -21,20 +21,13 @@ /* $Id$ */ -/* - * LALR shift/reduce conflicts and how they are resolved: - * - * - 2 shift/reduce conflicts due to the dangling elseif/else ambiguity. Solved by shift. - * - */ - - #include "zend_compile.h" #include "zend.h" #include "zend_list.h" #include "zend_globals.h" #include "zend_API.h" #include "zend_constants.h" +#include "zend_language_scanner.h" #define YYSIZE_T size_t #define yytnamerr zend_yytnamerr @@ -51,7 +44,7 @@ static YYSIZE_T zend_yytnamerr(char*, const char*); %} %pure_parser -%expect 2 +%expect 0 %code requires { } @@ -87,6 +80,7 @@ static YYSIZE_T zend_yytnamerr(char*, const char*); %right T_POW %right '[' %nonassoc T_NEW T_CLONE +%left "if_without_else" %left T_ELSEIF %left T_ELSE %left T_ENDIF @@ -243,8 +237,8 @@ static YYSIZE_T zend_yytnamerr(char*, const char*); %type <ast> absolute_trait_method_reference trait_method_reference property echo_expr %type <ast> new_expr anonymous_class class_name class_name_reference simple_variable %type <ast> internal_functions_in_yacc -%type <ast> exit_expr scalar backticks_expr lexical_var function_call member_name -%type <ast> variable_class_name dereferencable_scalar class_name_scalar constant dereferencable +%type <ast> exit_expr scalar backticks_expr lexical_var function_call member_name property_name +%type <ast> variable_class_name dereferencable_scalar constant dereferencable %type <ast> callable_expr callable_variable static_member new_variable %type <ast> assignment_list_element array_pair encaps_var encaps_var_offset isset_variables %type <ast> top_statement_list use_declarations const_list inner_statement_list if_stmt @@ -252,13 +246,14 @@ static YYSIZE_T zend_yytnamerr(char*, const char*); %type <ast> echo_expr_list unset_variables catch_list parameter_list class_statement_list %type <ast> implements_list case_list if_stmt_without_else %type <ast> non_empty_parameter_list argument_list non_empty_argument_list property_list -%type <ast> class_const_list name_list trait_adaptations method_body non_empty_for_exprs +%type <ast> class_const_list class_const_decl name_list trait_adaptations method_body non_empty_for_exprs %type <ast> ctor_arguments alt_if_stmt_without_else trait_adaptation_list lexical_vars %type <ast> lexical_var_list encaps_list array_pair_list non_empty_array_pair_list %type <ast> assignment_list isset_variable type return_type +%type <ast> identifier %type <num> returns_ref function is_reference is_variadic variable_modifiers -%type <num> method_modifiers trait_modifiers non_empty_member_modifiers member_modifier +%type <num> method_modifiers non_empty_member_modifiers member_modifier %type <num> class_modifiers class_modifier use_type %type <str> backup_doc_comment @@ -269,6 +264,29 @@ start: top_statement_list { CG(ast) = $1; } ; +reserved_non_modifiers: + T_INCLUDE | T_INCLUDE_ONCE | T_EVAL | T_REQUIRE | T_REQUIRE_ONCE | T_LOGICAL_OR | T_LOGICAL_XOR | T_LOGICAL_AND + | T_INSTANCEOF | T_NEW | T_CLONE | T_EXIT | T_IF | T_ELSEIF | T_ELSE | T_ENDIF | T_ECHO | T_DO | T_WHILE | T_ENDWHILE + | T_FOR | T_ENDFOR | T_FOREACH | T_ENDFOREACH | T_DECLARE | T_ENDDECLARE | T_AS | T_TRY | T_CATCH | T_FINALLY + | T_THROW | T_USE | T_INSTEADOF | T_GLOBAL | T_VAR | T_UNSET | T_ISSET | T_EMPTY | T_CONTINUE | T_GOTO + | T_FUNCTION | T_CONST | T_RETURN | T_PRINT | T_YIELD | T_LIST | T_SWITCH | T_ENDSWITCH | T_CASE | T_DEFAULT | T_BREAK + | T_ARRAY | T_CALLABLE | T_EXTENDS | T_IMPLEMENTS | T_NAMESPACE | T_TRAIT | T_INTERFACE | T_CLASS +; + +semi_reserved: + reserved_non_modifiers + | T_STATIC | T_ABSTRACT | T_FINAL | T_PRIVATE | T_PROTECTED | T_PUBLIC +; + +identifier: + T_STRING { $$ = $1; } + | semi_reserved { + zval zv; + zend_lex_tstring(&zv); + $$ = zend_ast_create_zval(&zv); + } +; + top_statement_list: top_statement_list top_statement { $$ = zend_ast_list_add($1, $2); } | /* empty */ { $$ = zend_ast_create_list(0, ZEND_AST_STMT_LIST); } @@ -561,7 +579,7 @@ if_stmt_without_else: ; if_stmt: - if_stmt_without_else { $$ = $1; } + if_stmt_without_else %prec "if_without_else" { $$ = $1; } | if_stmt_without_else T_ELSE statement { $$ = zend_ast_list_add($1, zend_ast_create(ZEND_AST_IF_ELEM, NULL, $3)); } ; @@ -673,7 +691,7 @@ class_statement: { $$ = $2; RESET_DOC_COMMENT(); } | T_USE name_list trait_adaptations { $$ = zend_ast_create(ZEND_AST_USE_TRAIT, $2, $3); } - | method_modifiers function returns_ref T_STRING '(' parameter_list ')' + | method_modifiers function returns_ref identifier '(' parameter_list ')' return_type backup_doc_comment method_body { $$ = zend_ast_create_decl(ZEND_AST_METHOD, $3 | $1, $2, $9, zend_ast_get_str($4), $6, NULL, $10, $8); } @@ -708,28 +726,27 @@ trait_precedence: ; trait_alias: - trait_method_reference T_AS trait_modifiers T_STRING + trait_method_reference T_AS T_STRING + { $$ = zend_ast_create_ex(ZEND_AST_TRAIT_ALIAS, 0, $1, $3); } + | trait_method_reference T_AS reserved_non_modifiers + { zval zv; zend_lex_tstring(&zv); $$ = zend_ast_create_ex(ZEND_AST_TRAIT_ALIAS, 0, $1, zend_ast_create_zval(&zv)); } + | trait_method_reference T_AS member_modifier identifier { $$ = zend_ast_create_ex(ZEND_AST_TRAIT_ALIAS, $3, $1, $4); } - | trait_method_reference T_AS member_modifier + | trait_method_reference T_AS member_modifier %prec '+' { $$ = zend_ast_create_ex(ZEND_AST_TRAIT_ALIAS, $3, $1, NULL); } ; trait_method_reference: - T_STRING + identifier { $$ = zend_ast_create(ZEND_AST_METHOD_REFERENCE, NULL, $1); } | absolute_trait_method_reference { $$ = $1; } ; absolute_trait_method_reference: - name T_PAAMAYIM_NEKUDOTAYIM T_STRING + name T_PAAMAYIM_NEKUDOTAYIM identifier { $$ = zend_ast_create(ZEND_AST_METHOD_REFERENCE, $1, $3); } ; -trait_modifiers: - /* empty */ { $$ = 0; } - | member_modifier { $$ = $1; } -; - method_body: ';' /* abstract method */ { $$ = NULL; } | '{' inner_statement_list '}' { $$ = $2; } @@ -773,8 +790,12 @@ property: ; class_const_list: - class_const_list ',' const_decl { $$ = zend_ast_list_add($1, $3); } - | const_decl { $$ = zend_ast_create_list(1, ZEND_AST_CLASS_CONST_DECL, $1); } + class_const_list ',' class_const_decl { $$ = zend_ast_list_add($1, $3); } + | class_const_decl { $$ = zend_ast_create_list(1, ZEND_AST_CLASS_CONST_DECL, $1); } +; + +class_const_decl: + identifier '=' expr { $$ = zend_ast_create(ZEND_AST_CONST_ELEM, $1, $3); } ; const_decl: @@ -1028,15 +1049,14 @@ scalar: | '"' encaps_list '"' { $$ = $2; } | T_START_HEREDOC encaps_list T_END_HEREDOC { $$ = $2; } | dereferencable_scalar { $$ = $1; } - | class_name_scalar { $$ = $1; } | constant { $$ = $1; } ; constant: name { $$ = zend_ast_create(ZEND_AST_CONST, $1); } - | class_name T_PAAMAYIM_NEKUDOTAYIM T_STRING + | class_name T_PAAMAYIM_NEKUDOTAYIM identifier { $$ = zend_ast_create(ZEND_AST_CLASS_CONST, $1, $3); } - | variable_class_name T_PAAMAYIM_NEKUDOTAYIM T_STRING + | variable_class_name T_PAAMAYIM_NEKUDOTAYIM identifier { $$ = zend_ast_create(ZEND_AST_CLASS_CONST, $1, $3); } ; @@ -1080,7 +1100,7 @@ callable_variable: { $$ = zend_ast_create(ZEND_AST_DIM, $1, $3); } | dereferencable '{' expr '}' { $$ = zend_ast_create(ZEND_AST_DIM, $1, $3); } - | dereferencable T_OBJECT_OPERATOR member_name argument_list + | dereferencable T_OBJECT_OPERATOR property_name argument_list { $$ = zend_ast_create(ZEND_AST_METHOD_CALL, $1, $3, $4); } | function_call { $$ = $1; } ; @@ -1090,7 +1110,7 @@ variable: { $$ = $1; } | static_member { $$ = $1; } - | dereferencable T_OBJECT_OPERATOR member_name + | dereferencable T_OBJECT_OPERATOR property_name { $$ = zend_ast_create(ZEND_AST_PROP, $1, $3); } ; @@ -1114,7 +1134,7 @@ new_variable: { $$ = zend_ast_create(ZEND_AST_DIM, $1, $3); } | new_variable '{' expr '}' { $$ = zend_ast_create(ZEND_AST_DIM, $1, $3); } - | new_variable T_OBJECT_OPERATOR member_name + | new_variable T_OBJECT_OPERATOR property_name { $$ = zend_ast_create(ZEND_AST_PROP, $1, $3); } | class_name T_PAAMAYIM_NEKUDOTAYIM simple_variable { $$ = zend_ast_create(ZEND_AST_STATIC_PROP, $1, $3); } @@ -1123,7 +1143,13 @@ new_variable: ; member_name: - T_STRING { $$ = $1; } + identifier { $$ = $1; } + | '{' expr '}' { $$ = $2; } + | simple_variable { $$ = zend_ast_create(ZEND_AST_VAR, $1); } +; + +property_name: + T_STRING { $$ = $1; } | '{' expr '}' { $$ = $2; } | simple_variable { $$ = zend_ast_create(ZEND_AST_VAR, $1); } ; @@ -1226,11 +1252,6 @@ isset_variable: expr { $$ = zend_ast_create(ZEND_AST_ISSET, $1); } ; -class_name_scalar: - class_name T_PAAMAYIM_NEKUDOTAYIM T_CLASS - { $$ = zend_ast_create(ZEND_AST_RESOLVE_CLASS_NAME, $1); } -; - %% /* Copy to YYRES the contents of YYSTR after stripping away unnecessary diff --git a/Zend/zend_language_scanner.c b/Zend/zend_language_scanner.c index abf93d587c..63d19483ba 100644 --- a/Zend/zend_language_scanner.c +++ b/Zend/zend_language_scanner.c @@ -195,6 +195,7 @@ void shutdown_scanner(void) zend_stack_destroy(&SCNG(state_stack)); zend_ptr_stack_clean(&SCNG(heredoc_label_stack), (void (*)(void *)) &heredoc_label_dtor, 1); zend_ptr_stack_destroy(&SCNG(heredoc_label_stack)); + SCNG(on_event) = NULL; } ZEND_API void zend_save_lexical_state(zend_lex_state *lex_state) @@ -225,6 +226,8 @@ ZEND_API void zend_save_lexical_state(zend_lex_state *lex_state) lex_state->output_filter = SCNG(output_filter); lex_state->script_encoding = SCNG(script_encoding); + lex_state->on_event = SCNG(on_event); + lex_state->ast = CG(ast); lex_state->ast_arena = CG(ast_arena); } @@ -262,6 +265,8 @@ ZEND_API void zend_restore_lexical_state(zend_lex_state *lex_state) SCNG(output_filter) = lex_state->output_filter; SCNG(script_encoding) = lex_state->script_encoding; + SCNG(on_event) = lex_state->on_event; + CG(ast) = lex_state->ast; CG(ast_arena) = lex_state->ast_arena; @@ -278,6 +283,13 @@ ZEND_API void zend_destroy_file_handle(zend_file_handle *file_handle) } } +ZEND_API void zend_lex_tstring(zval *zv) +{ + if (SCNG(on_event)) SCNG(on_event)(ON_FEEDBACK, T_STRING, 0); + + ZVAL_STRINGL(zv, (char*)SCNG(yy_text), SCNG(yy_leng)); +} + #define BOM_UTF32_BE "\x00\x00\xfe\xff" #define BOM_UTF32_LE "\xff\xfe\x00\x00" #define BOM_UTF16_BE "\xfe\xff" @@ -1085,14 +1097,25 @@ static int zend_scan_escape_string(zval *zendlval, char *str, int len, char quot return SUCCESS; } +static zend_always_inline int emit_token(int token, int token_line) +{ + if(SCNG(on_event)) SCNG(on_event)(ON_TOKEN, token, token_line); + + return token; +} + +#define RETURN_TOKEN(token) return emit_token(token, start_line); int lex_scan(zval *zendlval) { + +int start_line = CG(zend_lineno); + restart: SCNG(yy_text) = YYCURSOR; -#line 1096 "Zend/zend_language_scanner.c" +#line 1119 "Zend/zend_language_scanner.c" { YYCTYPE yych; unsigned int yyaccept = 0; @@ -1146,10 +1169,10 @@ yyc_INITIAL: yy3: YYDEBUG(3, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1784 "Zend/zend_language_scanner.l" +#line 1807 "Zend/zend_language_scanner.l" { if (YYCURSOR > YYLIMIT) { - return 0; + RETURN_TOKEN(END); } inline_char_handler: @@ -1189,9 +1212,9 @@ inline_char_handler: ZVAL_STRINGL(zendlval, yytext, yyleng); } HANDLE_NEWLINES(yytext, yyleng); - return T_INLINE_HTML; + RETURN_TOKEN(T_INLINE_HTML); } -#line 1195 "Zend/zend_language_scanner.c" +#line 1218 "Zend/zend_language_scanner.c" yy4: YYDEBUG(4, *YYCURSOR); yych = *++YYCURSOR; @@ -1209,27 +1232,27 @@ yy5: yy6: YYDEBUG(6, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1775 "Zend/zend_language_scanner.l" +#line 1798 "Zend/zend_language_scanner.l" { if (CG(short_tags)) { BEGIN(ST_IN_SCRIPTING); - return T_OPEN_TAG; + RETURN_TOKEN(T_OPEN_TAG); } else { goto inline_char_handler; } } -#line 1222 "Zend/zend_language_scanner.c" +#line 1245 "Zend/zend_language_scanner.c" yy7: YYDEBUG(7, *YYCURSOR); ++YYCURSOR; YYDEBUG(8, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1762 "Zend/zend_language_scanner.l" +#line 1785 "Zend/zend_language_scanner.l" { BEGIN(ST_IN_SCRIPTING); - return T_OPEN_TAG_WITH_ECHO; + RETURN_TOKEN(T_OPEN_TAG_WITH_ECHO); } -#line 1233 "Zend/zend_language_scanner.c" +#line 1256 "Zend/zend_language_scanner.c" yy9: YYDEBUG(9, *YYCURSOR); yych = *++YYCURSOR; @@ -1260,13 +1283,13 @@ yy13: yy14: YYDEBUG(14, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1768 "Zend/zend_language_scanner.l" +#line 1791 "Zend/zend_language_scanner.l" { HANDLE_NEWLINE(yytext[yyleng-1]); BEGIN(ST_IN_SCRIPTING); - return T_OPEN_TAG; + RETURN_TOKEN(T_OPEN_TAG); } -#line 1270 "Zend/zend_language_scanner.c" +#line 1293 "Zend/zend_language_scanner.c" yy15: YYDEBUG(15, *YYCURSOR); ++YYCURSOR; @@ -1336,10 +1359,10 @@ yyc_ST_BACKQUOTE: yy19: YYDEBUG(19, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 2198 "Zend/zend_language_scanner.l" +#line 2221 "Zend/zend_language_scanner.l" { if (YYCURSOR > YYLIMIT) { - return 0; + RETURN_TOKEN(END); } if (yytext[0] == '\\' && YYCURSOR < YYLIMIT) { YYCURSOR++; @@ -1375,11 +1398,11 @@ yy19: yyleng = YYCURSOR - SCNG(yy_text); if (zend_scan_escape_string(zendlval, yytext, yyleng, '`') == FAILURE) { - return T_ERROR; + RETURN_TOKEN(T_ERROR); } - return T_ENCAPSED_AND_WHITESPACE; + RETURN_TOKEN(T_ENCAPSED_AND_WHITESPACE); } -#line 1383 "Zend/zend_language_scanner.c" +#line 1406 "Zend/zend_language_scanner.c" yy20: YYDEBUG(20, *YYCURSOR); yych = *++YYCURSOR; @@ -1390,12 +1413,12 @@ yy21: ++YYCURSOR; YYDEBUG(22, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 2140 "Zend/zend_language_scanner.l" +#line 2163 "Zend/zend_language_scanner.l" { BEGIN(ST_IN_SCRIPTING); - return '`'; + RETURN_TOKEN('`'); } -#line 1399 "Zend/zend_language_scanner.c" +#line 1422 "Zend/zend_language_scanner.c" yy23: YYDEBUG(23, *YYCURSOR); yych = *++YYCURSOR; @@ -1405,14 +1428,14 @@ yy24: ++YYCURSOR; YYDEBUG(25, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 2127 "Zend/zend_language_scanner.l" +#line 2150 "Zend/zend_language_scanner.l" { Z_LVAL_P(zendlval) = (zend_long) '{'; yy_push_state(ST_IN_SCRIPTING); yyless(1); - return T_CURLY_OPEN; + RETURN_TOKEN(T_CURLY_OPEN); } -#line 1416 "Zend/zend_language_scanner.c" +#line 1439 "Zend/zend_language_scanner.c" yy26: YYDEBUG(26, *YYCURSOR); yyaccept = 0; @@ -1428,23 +1451,23 @@ yy26: yy28: YYDEBUG(28, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1849 "Zend/zend_language_scanner.l" +#line 1872 "Zend/zend_language_scanner.l" { zend_copy_value(zendlval, (yytext+1), (yyleng-1)); - return T_VARIABLE; + RETURN_TOKEN(T_VARIABLE); } -#line 1437 "Zend/zend_language_scanner.c" +#line 1460 "Zend/zend_language_scanner.c" yy29: YYDEBUG(29, *YYCURSOR); ++YYCURSOR; YYDEBUG(30, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1570 "Zend/zend_language_scanner.l" +#line 1593 "Zend/zend_language_scanner.l" { yy_push_state(ST_LOOKING_FOR_VARNAME); - return T_DOLLAR_OPEN_CURLY_BRACES; + RETURN_TOKEN(T_DOLLAR_OPEN_CURLY_BRACES); } -#line 1448 "Zend/zend_language_scanner.c" +#line 1471 "Zend/zend_language_scanner.c" yy31: YYDEBUG(31, *YYCURSOR); yych = *++YYCURSOR; @@ -1458,14 +1481,14 @@ yy33: ++YYCURSOR; YYDEBUG(34, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1842 "Zend/zend_language_scanner.l" +#line 1865 "Zend/zend_language_scanner.l" { yyless(yyleng - 1); yy_push_state(ST_VAR_OFFSET); zend_copy_value(zendlval, (yytext+1), (yyleng-1)); - return T_VARIABLE; + RETURN_TOKEN(T_VARIABLE); } -#line 1469 "Zend/zend_language_scanner.c" +#line 1492 "Zend/zend_language_scanner.c" yy35: YYDEBUG(35, *YYCURSOR); yych = *++YYCURSOR; @@ -1483,14 +1506,14 @@ yy36: ++YYCURSOR; YYDEBUG(37, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1833 "Zend/zend_language_scanner.l" +#line 1856 "Zend/zend_language_scanner.l" { yyless(yyleng - 3); yy_push_state(ST_LOOKING_FOR_PROPERTY); zend_copy_value(zendlval, (yytext+1), (yyleng-1)); - return T_VARIABLE; + RETURN_TOKEN(T_VARIABLE); } -#line 1494 "Zend/zend_language_scanner.c" +#line 1517 "Zend/zend_language_scanner.c" } /* *********************************** */ yyc_ST_DOUBLE_QUOTES: @@ -1558,7 +1581,7 @@ yy40: yy41: YYDEBUG(41, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 2146 "Zend/zend_language_scanner.l" +#line 2169 "Zend/zend_language_scanner.l" { if (GET_DOUBLE_QUOTES_SCANNED_LENGTH()) { YYCURSOR += GET_DOUBLE_QUOTES_SCANNED_LENGTH() - 1; @@ -1568,7 +1591,7 @@ yy41: } if (YYCURSOR > YYLIMIT) { - return 0; + RETURN_TOKEN(END); } if (yytext[0] == '\\' && YYCURSOR < YYLIMIT) { YYCURSOR++; @@ -1605,11 +1628,11 @@ double_quotes_scan_done: yyleng = YYCURSOR - SCNG(yy_text); if (zend_scan_escape_string(zendlval, yytext, yyleng, '"') == FAILURE) { - return T_ERROR; + RETURN_TOKEN(T_ERROR); } - return T_ENCAPSED_AND_WHITESPACE; + RETURN_TOKEN(T_ENCAPSED_AND_WHITESPACE); } -#line 1613 "Zend/zend_language_scanner.c" +#line 1636 "Zend/zend_language_scanner.c" yy42: YYDEBUG(42, *YYCURSOR); yych = *++YYCURSOR; @@ -1620,12 +1643,12 @@ yy43: ++YYCURSOR; YYDEBUG(44, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 2135 "Zend/zend_language_scanner.l" +#line 2158 "Zend/zend_language_scanner.l" { BEGIN(ST_IN_SCRIPTING); - return '"'; + RETURN_TOKEN('"'); } -#line 1629 "Zend/zend_language_scanner.c" +#line 1652 "Zend/zend_language_scanner.c" yy45: YYDEBUG(45, *YYCURSOR); yych = *++YYCURSOR; @@ -1635,14 +1658,14 @@ yy46: ++YYCURSOR; YYDEBUG(47, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 2127 "Zend/zend_language_scanner.l" +#line 2150 "Zend/zend_language_scanner.l" { Z_LVAL_P(zendlval) = (zend_long) '{'; yy_push_state(ST_IN_SCRIPTING); yyless(1); - return T_CURLY_OPEN; + RETURN_TOKEN(T_CURLY_OPEN); } -#line 1646 "Zend/zend_language_scanner.c" +#line 1669 "Zend/zend_language_scanner.c" yy48: YYDEBUG(48, *YYCURSOR); yyaccept = 0; @@ -1658,23 +1681,23 @@ yy48: yy50: YYDEBUG(50, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1849 "Zend/zend_language_scanner.l" +#line 1872 "Zend/zend_language_scanner.l" { zend_copy_value(zendlval, (yytext+1), (yyleng-1)); - return T_VARIABLE; + RETURN_TOKEN(T_VARIABLE); } -#line 1667 "Zend/zend_language_scanner.c" +#line 1690 "Zend/zend_language_scanner.c" yy51: YYDEBUG(51, *YYCURSOR); ++YYCURSOR; YYDEBUG(52, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1570 "Zend/zend_language_scanner.l" +#line 1593 "Zend/zend_language_scanner.l" { yy_push_state(ST_LOOKING_FOR_VARNAME); - return T_DOLLAR_OPEN_CURLY_BRACES; + RETURN_TOKEN(T_DOLLAR_OPEN_CURLY_BRACES); } -#line 1678 "Zend/zend_language_scanner.c" +#line 1701 "Zend/zend_language_scanner.c" yy53: YYDEBUG(53, *YYCURSOR); yych = *++YYCURSOR; @@ -1688,14 +1711,14 @@ yy55: ++YYCURSOR; YYDEBUG(56, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1842 "Zend/zend_language_scanner.l" +#line 1865 "Zend/zend_language_scanner.l" { yyless(yyleng - 1); yy_push_state(ST_VAR_OFFSET); zend_copy_value(zendlval, (yytext+1), (yyleng-1)); - return T_VARIABLE; + RETURN_TOKEN(T_VARIABLE); } -#line 1699 "Zend/zend_language_scanner.c" +#line 1722 "Zend/zend_language_scanner.c" yy57: YYDEBUG(57, *YYCURSOR); yych = *++YYCURSOR; @@ -1713,14 +1736,14 @@ yy58: ++YYCURSOR; YYDEBUG(59, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1833 "Zend/zend_language_scanner.l" +#line 1856 "Zend/zend_language_scanner.l" { yyless(yyleng - 3); yy_push_state(ST_LOOKING_FOR_PROPERTY); zend_copy_value(zendlval, (yytext+1), (yyleng-1)); - return T_VARIABLE; + RETURN_TOKEN(T_VARIABLE); } -#line 1724 "Zend/zend_language_scanner.c" +#line 1747 "Zend/zend_language_scanner.c" } /* *********************************** */ yyc_ST_END_HEREDOC: @@ -1731,7 +1754,7 @@ yyc_ST_END_HEREDOC: ++YYCURSOR; YYDEBUG(63, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 2113 "Zend/zend_language_scanner.l" +#line 2136 "Zend/zend_language_scanner.l" { zend_heredoc_label *heredoc_label = zend_ptr_stack_pop(&SCNG(heredoc_label_stack)); @@ -1742,9 +1765,9 @@ yyc_ST_END_HEREDOC: efree(heredoc_label); BEGIN(ST_IN_SCRIPTING); - return T_END_HEREDOC; + RETURN_TOKEN(T_END_HEREDOC); } -#line 1748 "Zend/zend_language_scanner.c" +#line 1771 "Zend/zend_language_scanner.c" /* *********************************** */ yyc_ST_HEREDOC: { @@ -1806,14 +1829,14 @@ yy66: yy67: YYDEBUG(67, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 2242 "Zend/zend_language_scanner.l" +#line 2265 "Zend/zend_language_scanner.l" { int newline = 0; zend_heredoc_label *heredoc_label = zend_ptr_stack_top(&SCNG(heredoc_label_stack)); if (YYCURSOR > YYLIMIT) { - return 0; + RETURN_TOKEN(END); } YYCURSOR--; @@ -1877,11 +1900,11 @@ heredoc_scan_done: yyleng = YYCURSOR - SCNG(yy_text); if (zend_scan_escape_string(zendlval, yytext, yyleng - newline, 0) == FAILURE) { - return T_ERROR; + RETURN_TOKEN(T_ERROR); } - return T_ENCAPSED_AND_WHITESPACE; + RETURN_TOKEN(T_ENCAPSED_AND_WHITESPACE); } -#line 1885 "Zend/zend_language_scanner.c" +#line 1908 "Zend/zend_language_scanner.c" yy68: YYDEBUG(68, *YYCURSOR); yych = *++YYCURSOR; @@ -1896,14 +1919,14 @@ yy70: ++YYCURSOR; YYDEBUG(71, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 2127 "Zend/zend_language_scanner.l" +#line 2150 "Zend/zend_language_scanner.l" { Z_LVAL_P(zendlval) = (zend_long) '{'; yy_push_state(ST_IN_SCRIPTING); yyless(1); - return T_CURLY_OPEN; + RETURN_TOKEN(T_CURLY_OPEN); } -#line 1907 "Zend/zend_language_scanner.c" +#line 1930 "Zend/zend_language_scanner.c" yy72: YYDEBUG(72, *YYCURSOR); yyaccept = 0; @@ -1919,23 +1942,23 @@ yy72: yy74: YYDEBUG(74, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1849 "Zend/zend_language_scanner.l" +#line 1872 "Zend/zend_language_scanner.l" { zend_copy_value(zendlval, (yytext+1), (yyleng-1)); - return T_VARIABLE; + RETURN_TOKEN(T_VARIABLE); } -#line 1928 "Zend/zend_language_scanner.c" +#line 1951 "Zend/zend_language_scanner.c" yy75: YYDEBUG(75, *YYCURSOR); ++YYCURSOR; YYDEBUG(76, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1570 "Zend/zend_language_scanner.l" +#line 1593 "Zend/zend_language_scanner.l" { yy_push_state(ST_LOOKING_FOR_VARNAME); - return T_DOLLAR_OPEN_CURLY_BRACES; + RETURN_TOKEN(T_DOLLAR_OPEN_CURLY_BRACES); } -#line 1939 "Zend/zend_language_scanner.c" +#line 1962 "Zend/zend_language_scanner.c" yy77: YYDEBUG(77, *YYCURSOR); yych = *++YYCURSOR; @@ -1949,14 +1972,14 @@ yy79: ++YYCURSOR; YYDEBUG(80, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1842 "Zend/zend_language_scanner.l" +#line 1865 "Zend/zend_language_scanner.l" { yyless(yyleng - 1); yy_push_state(ST_VAR_OFFSET); zend_copy_value(zendlval, (yytext+1), (yyleng-1)); - return T_VARIABLE; + RETURN_TOKEN(T_VARIABLE); } -#line 1960 "Zend/zend_language_scanner.c" +#line 1983 "Zend/zend_language_scanner.c" yy81: YYDEBUG(81, *YYCURSOR); yych = *++YYCURSOR; @@ -1974,14 +1997,14 @@ yy82: ++YYCURSOR; YYDEBUG(83, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1833 "Zend/zend_language_scanner.l" +#line 1856 "Zend/zend_language_scanner.l" { yyless(yyleng - 3); yy_push_state(ST_LOOKING_FOR_PROPERTY); zend_copy_value(zendlval, (yytext+1), (yyleng-1)); - return T_VARIABLE; + RETURN_TOKEN(T_VARIABLE); } -#line 1985 "Zend/zend_language_scanner.c" +#line 2008 "Zend/zend_language_scanner.c" } /* *********************************** */ yyc_ST_IN_SCRIPTING: @@ -2164,12 +2187,12 @@ yy86: yy87: YYDEBUG(87, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1872 "Zend/zend_language_scanner.l" +#line 1895 "Zend/zend_language_scanner.l" { zend_copy_value(zendlval, yytext, yyleng); - return T_STRING; + RETURN_TOKEN(T_STRING); } -#line 2173 "Zend/zend_language_scanner.c" +#line 2196 "Zend/zend_language_scanner.c" yy88: YYDEBUG(88, *YYCURSOR); yych = *++YYCURSOR; @@ -2401,11 +2424,11 @@ yy101: yy102: YYDEBUG(102, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1559 "Zend/zend_language_scanner.l" +#line 1582 "Zend/zend_language_scanner.l" { - return yytext[0]; + RETURN_TOKEN(yytext[0]); } -#line 2409 "Zend/zend_language_scanner.c" +#line 2432 "Zend/zend_language_scanner.c" yy103: YYDEBUG(103, *YYCURSOR); ++YYCURSOR; @@ -2414,12 +2437,12 @@ yy103: yy104: YYDEBUG(104, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1274 "Zend/zend_language_scanner.l" +#line 1297 "Zend/zend_language_scanner.l" { HANDLE_NEWLINES(yytext, yyleng); - return T_WHITESPACE; + RETURN_TOKEN(T_WHITESPACE); } -#line 2423 "Zend/zend_language_scanner.c" +#line 2446 "Zend/zend_language_scanner.c" yy105: YYDEBUG(105, *YYCURSOR); yych = *++YYCURSOR; @@ -2430,11 +2453,11 @@ yy106: ++YYCURSOR; YYDEBUG(107, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1299 "Zend/zend_language_scanner.l" +#line 1322 "Zend/zend_language_scanner.l" { - return T_NS_SEPARATOR; + RETURN_TOKEN(T_NS_SEPARATOR); } -#line 2438 "Zend/zend_language_scanner.c" +#line 2461 "Zend/zend_language_scanner.c" yy108: YYDEBUG(108, *YYCURSOR); yyaccept = 1; @@ -2663,26 +2686,26 @@ yy131: ++YYCURSOR; YYDEBUG(132, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1564 "Zend/zend_language_scanner.l" +#line 1587 "Zend/zend_language_scanner.l" { yy_push_state(ST_IN_SCRIPTING); - return '{'; + RETURN_TOKEN('{'); } -#line 2672 "Zend/zend_language_scanner.c" +#line 2695 "Zend/zend_language_scanner.c" yy133: YYDEBUG(133, *YYCURSOR); ++YYCURSOR; YYDEBUG(134, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1576 "Zend/zend_language_scanner.l" +#line 1599 "Zend/zend_language_scanner.l" { RESET_DOC_COMMENT(); if (!zend_stack_is_empty(&SCNG(state_stack))) { yy_pop_state(); } - return '}'; + RETURN_TOKEN('}'); } -#line 2686 "Zend/zend_language_scanner.c" +#line 2709 "Zend/zend_language_scanner.c" yy135: YYDEBUG(135, *YYCURSOR); yyaccept = 2; @@ -2710,7 +2733,7 @@ yy135: yy136: YYDEBUG(136, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1629 "Zend/zend_language_scanner.l" +#line 1652 "Zend/zend_language_scanner.l" { char *end; if (yyleng < MAX_LENGTH_OF_LONG - 1) { /* Won't overflow */ @@ -2721,7 +2744,7 @@ yy136: */ if (end != yytext + yyleng) { zend_throw_exception(zend_get_parse_exception(), "Invalid numeric literal", E_PARSE); - return T_ERROR; + RETURN_TOKEN(T_ERROR); } } else { errno = 0; @@ -2738,21 +2761,21 @@ yy136: if (end != yytext + yyleng) { zend_throw_exception(zend_get_parse_exception(), "Invalid numeric literal", E_PARSE); - return T_ERROR; + RETURN_TOKEN(T_ERROR); } ZEND_ASSERT(!errno); - return T_DNUMBER; + RETURN_TOKEN(T_DNUMBER); } /* Also not an assert for the same reason */ if (end != yytext + yyleng) { zend_throw_exception(zend_get_parse_exception(), "Invalid numeric literal", E_PARSE); - return T_ERROR; + RETURN_TOKEN(T_ERROR); } } ZEND_ASSERT(!errno); - return T_LNUMBER; + RETURN_TOKEN(T_LNUMBER); } -#line 2756 "Zend/zend_language_scanner.c" +#line 2779 "Zend/zend_language_scanner.c" yy137: YYDEBUG(137, *YYCURSOR); yyaccept = 2; @@ -2780,7 +2803,7 @@ yy139: yy140: YYDEBUG(140, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1878 "Zend/zend_language_scanner.l" +#line 1901 "Zend/zend_language_scanner.l" { while (YYCURSOR < YYLIMIT) { switch (*YYCURSOR++) { @@ -2807,16 +2830,16 @@ yy140: yyleng = YYCURSOR - SCNG(yy_text); - return T_COMMENT; + RETURN_TOKEN(T_COMMENT); } -#line 2813 "Zend/zend_language_scanner.c" +#line 2836 "Zend/zend_language_scanner.c" yy141: YYDEBUG(141, *YYCURSOR); ++YYCURSOR; yy142: YYDEBUG(142, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1946 "Zend/zend_language_scanner.l" +#line 1969 "Zend/zend_language_scanner.l" { register char *s, *t; char *end; @@ -2839,7 +2862,7 @@ yy142: * for ' (unrecognized by parser), instead of old flex fallback to "Unexpected character..." * rule, which continued in ST_IN_SCRIPTING state after the quote */ ZVAL_NULL(zendlval); - return T_ENCAPSED_AND_WHITESPACE; + RETURN_TOKEN(T_ENCAPSED_AND_WHITESPACE); } } @@ -2882,16 +2905,16 @@ yy142: SCNG(output_filter)((unsigned char **)&str, &sz, (unsigned char *)s, (size_t)Z_STRLEN_P(zendlval)); ZVAL_STRINGL(zendlval, str, sz); } - return T_CONSTANT_ENCAPSED_STRING; + RETURN_TOKEN(T_CONSTANT_ENCAPSED_STRING); } -#line 2888 "Zend/zend_language_scanner.c" +#line 2911 "Zend/zend_language_scanner.c" yy143: YYDEBUG(143, *YYCURSOR); ++YYCURSOR; yy144: YYDEBUG(144, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 2015 "Zend/zend_language_scanner.l" +#line 2038 "Zend/zend_language_scanner.l" { int bprefix = (yytext[0] != '"') ? 1 : 0; @@ -2900,9 +2923,9 @@ yy144: case '"': yyleng = YYCURSOR - SCNG(yy_text); if (zend_scan_escape_string(zendlval, yytext+bprefix+1, yyleng-bprefix-2, '"') == FAILURE) { - return T_ERROR; + RETURN_TOKEN(T_ERROR); } - return T_CONSTANT_ENCAPSED_STRING; + RETURN_TOKEN(T_CONSTANT_ENCAPSED_STRING); case '$': if (IS_LABEL_START(*YYCURSOR) || *YYCURSOR == '{') { break; @@ -2932,35 +2955,35 @@ yy144: YYCURSOR = SCNG(yy_text) + yyleng; BEGIN(ST_DOUBLE_QUOTES); - return '"'; + RETURN_TOKEN('"'); } -#line 2938 "Zend/zend_language_scanner.c" +#line 2961 "Zend/zend_language_scanner.c" yy145: YYDEBUG(145, *YYCURSOR); ++YYCURSOR; YYDEBUG(146, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 2107 "Zend/zend_language_scanner.l" +#line 2130 "Zend/zend_language_scanner.l" { BEGIN(ST_BACKQUOTE); - return '`'; + RETURN_TOKEN('`'); } -#line 2949 "Zend/zend_language_scanner.c" +#line 2972 "Zend/zend_language_scanner.c" yy147: YYDEBUG(147, *YYCURSOR); ++YYCURSOR; YYDEBUG(148, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 2375 "Zend/zend_language_scanner.l" +#line 2398 "Zend/zend_language_scanner.l" { if (YYCURSOR > YYLIMIT) { - return 0; + RETURN_TOKEN(END); } zend_error(E_COMPILE_WARNING,"Unexpected character in input: '%c' (ASCII=%d) state=%d", yytext[0], yytext[0], YYSTATE); goto restart; } -#line 2964 "Zend/zend_language_scanner.c" +#line 2987 "Zend/zend_language_scanner.c" yy149: YYDEBUG(149, *YYCURSOR); ++YYCURSOR; @@ -2987,16 +3010,16 @@ yy151: yy153: YYDEBUG(153, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1720 "Zend/zend_language_scanner.l" +#line 1743 "Zend/zend_language_scanner.l" { const char *end; ZVAL_DOUBLE(zendlval, zend_strtod(yytext, &end)); /* errno isn't checked since we allow HUGE_VAL/INF overflow */ ZEND_ASSERT(end == yytext + yyleng); - return T_DNUMBER; + RETURN_TOKEN(T_DNUMBER); } -#line 3000 "Zend/zend_language_scanner.c" +#line 3023 "Zend/zend_language_scanner.c" yy154: YYDEBUG(154, *YYCURSOR); yyaccept = 2; @@ -3092,7 +3115,7 @@ yy163: } YYDEBUG(165, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1601 "Zend/zend_language_scanner.l" +#line 1624 "Zend/zend_language_scanner.l" { char *bin = yytext + 2; /* Skip "0b" */ int len = yyleng - 2; @@ -3112,15 +3135,15 @@ yy163: ZVAL_LONG(zendlval, ZEND_STRTOL(bin, &end, 2)); ZEND_ASSERT(!errno && end == yytext + yyleng); } - return T_LNUMBER; + RETURN_TOKEN(T_LNUMBER); } else { ZVAL_DOUBLE(zendlval, zend_bin_strtod(bin, (const char **)&end)); /* errno isn't checked since we allow HUGE_VAL/INF overflow */ ZEND_ASSERT(end == yytext + yyleng); - return T_DNUMBER; + RETURN_TOKEN(T_DNUMBER); } } -#line 3124 "Zend/zend_language_scanner.c" +#line 3147 "Zend/zend_language_scanner.c" yy166: YYDEBUG(166, *YYCURSOR); ++YYCURSOR; @@ -3132,7 +3155,7 @@ yy166: } YYDEBUG(168, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1671 "Zend/zend_language_scanner.l" +#line 1694 "Zend/zend_language_scanner.l" { char *hex = yytext + 2; /* Skip "0x" */ int len = yyleng - 2; @@ -3152,15 +3175,15 @@ yy166: ZVAL_LONG(zendlval, ZEND_STRTOL(hex, &end, 16)); ZEND_ASSERT(!errno && end == hex + len); } - return T_LNUMBER; + RETURN_TOKEN(T_LNUMBER); } else { ZVAL_DOUBLE(zendlval, zend_hex_strtod(hex, (const char **)&end)); /* errno isn't checked since we allow HUGE_VAL/INF overflow */ ZEND_ASSERT(end == hex + len); - return T_DNUMBER; + RETURN_TOKEN(T_DNUMBER); } } -#line 3164 "Zend/zend_language_scanner.c" +#line 3187 "Zend/zend_language_scanner.c" yy169: YYDEBUG(169, *YYCURSOR); ++YYCURSOR; @@ -3185,12 +3208,12 @@ yy169: yy171: YYDEBUG(171, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1849 "Zend/zend_language_scanner.l" +#line 1872 "Zend/zend_language_scanner.l" { zend_copy_value(zendlval, (yytext+1), (yyleng-1)); - return T_VARIABLE; + RETURN_TOKEN(T_VARIABLE); } -#line 3194 "Zend/zend_language_scanner.c" +#line 3217 "Zend/zend_language_scanner.c" yy172: YYDEBUG(172, *YYCURSOR); yych = *++YYCURSOR; @@ -3204,11 +3227,11 @@ yy173: } YYDEBUG(174, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1547 "Zend/zend_language_scanner.l" +#line 1570 "Zend/zend_language_scanner.l" { - return T_LOGICAL_XOR; + RETURN_TOKEN(T_LOGICAL_XOR); } -#line 3212 "Zend/zend_language_scanner.c" +#line 3235 "Zend/zend_language_scanner.c" yy175: YYDEBUG(175, *YYCURSOR); ++YYCURSOR; @@ -3217,71 +3240,71 @@ yy175: } YYDEBUG(176, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1539 "Zend/zend_language_scanner.l" +#line 1562 "Zend/zend_language_scanner.l" { - return T_LOGICAL_OR; + RETURN_TOKEN(T_LOGICAL_OR); } -#line 3225 "Zend/zend_language_scanner.c" +#line 3248 "Zend/zend_language_scanner.c" yy177: YYDEBUG(177, *YYCURSOR); ++YYCURSOR; YYDEBUG(178, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1527 "Zend/zend_language_scanner.l" +#line 1550 "Zend/zend_language_scanner.l" { - return T_XOR_EQUAL; + RETURN_TOKEN(T_XOR_EQUAL); } -#line 3235 "Zend/zend_language_scanner.c" +#line 3258 "Zend/zend_language_scanner.c" yy179: YYDEBUG(179, *YYCURSOR); ++YYCURSOR; YYDEBUG(180, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1531 "Zend/zend_language_scanner.l" +#line 1554 "Zend/zend_language_scanner.l" { - return T_BOOLEAN_OR; + RETURN_TOKEN(T_BOOLEAN_OR); } -#line 3245 "Zend/zend_language_scanner.c" +#line 3268 "Zend/zend_language_scanner.c" yy181: YYDEBUG(181, *YYCURSOR); ++YYCURSOR; YYDEBUG(182, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1523 "Zend/zend_language_scanner.l" +#line 1546 "Zend/zend_language_scanner.l" { - return T_OR_EQUAL; + RETURN_TOKEN(T_OR_EQUAL); } -#line 3255 "Zend/zend_language_scanner.c" +#line 3278 "Zend/zend_language_scanner.c" yy183: YYDEBUG(183, *YYCURSOR); ++YYCURSOR; YYDEBUG(184, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1535 "Zend/zend_language_scanner.l" +#line 1558 "Zend/zend_language_scanner.l" { - return T_BOOLEAN_AND; + RETURN_TOKEN(T_BOOLEAN_AND); } -#line 3265 "Zend/zend_language_scanner.c" +#line 3288 "Zend/zend_language_scanner.c" yy185: YYDEBUG(185, *YYCURSOR); ++YYCURSOR; YYDEBUG(186, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1519 "Zend/zend_language_scanner.l" +#line 1542 "Zend/zend_language_scanner.l" { - return T_AND_EQUAL; + RETURN_TOKEN(T_AND_EQUAL); } -#line 3275 "Zend/zend_language_scanner.c" +#line 3298 "Zend/zend_language_scanner.c" yy187: YYDEBUG(187, *YYCURSOR); ++YYCURSOR; YYDEBUG(188, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1507 "Zend/zend_language_scanner.l" +#line 1530 "Zend/zend_language_scanner.l" { - return T_MOD_EQUAL; + RETURN_TOKEN(T_MOD_EQUAL); } -#line 3285 "Zend/zend_language_scanner.c" +#line 3308 "Zend/zend_language_scanner.c" yy189: YYDEBUG(189, *YYCURSOR); yyaccept = 4; @@ -3290,7 +3313,7 @@ yy189: yy190: YYDEBUG(190, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1907 "Zend/zend_language_scanner.l" +#line 1930 "Zend/zend_language_scanner.l" { int doc_com; @@ -3318,12 +3341,12 @@ yy190: if (doc_com) { CG(doc_comment) = zend_string_init(yytext, yyleng, 0); - return T_DOC_COMMENT; + RETURN_TOKEN(T_DOC_COMMENT); } - return T_COMMENT; + RETURN_TOKEN(T_COMMENT); } -#line 3327 "Zend/zend_language_scanner.c" +#line 3350 "Zend/zend_language_scanner.c" yy191: YYDEBUG(191, *YYCURSOR); yych = *++YYCURSOR; @@ -3333,11 +3356,11 @@ yy192: ++YYCURSOR; YYDEBUG(193, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1499 "Zend/zend_language_scanner.l" +#line 1522 "Zend/zend_language_scanner.l" { - return T_DIV_EQUAL; + RETURN_TOKEN(T_DIV_EQUAL); } -#line 3341 "Zend/zend_language_scanner.c" +#line 3364 "Zend/zend_language_scanner.c" yy194: YYDEBUG(194, *YYCURSOR); yych = *++YYCURSOR; @@ -3361,62 +3384,62 @@ yy197: if ((yych = *YYCURSOR) == '=') goto yy201; YYDEBUG(198, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1491 "Zend/zend_language_scanner.l" +#line 1514 "Zend/zend_language_scanner.l" { - return T_POW; + RETURN_TOKEN(T_POW); } -#line 3369 "Zend/zend_language_scanner.c" +#line 3392 "Zend/zend_language_scanner.c" yy199: YYDEBUG(199, *YYCURSOR); ++YYCURSOR; YYDEBUG(200, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1487 "Zend/zend_language_scanner.l" +#line 1510 "Zend/zend_language_scanner.l" { - return T_MUL_EQUAL; + RETURN_TOKEN(T_MUL_EQUAL); } -#line 3379 "Zend/zend_language_scanner.c" +#line 3402 "Zend/zend_language_scanner.c" yy201: YYDEBUG(201, *YYCURSOR); ++YYCURSOR; YYDEBUG(202, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1495 "Zend/zend_language_scanner.l" +#line 1518 "Zend/zend_language_scanner.l" { - return T_POW_EQUAL; + RETURN_TOKEN(T_POW_EQUAL); } -#line 3389 "Zend/zend_language_scanner.c" +#line 3412 "Zend/zend_language_scanner.c" yy203: YYDEBUG(203, *YYCURSOR); ++YYCURSOR; if ((yych = *YYCURSOR) == '=') goto yy207; YYDEBUG(204, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1555 "Zend/zend_language_scanner.l" +#line 1578 "Zend/zend_language_scanner.l" { - return T_SR; + RETURN_TOKEN(T_SR); } -#line 3400 "Zend/zend_language_scanner.c" +#line 3423 "Zend/zend_language_scanner.c" yy205: YYDEBUG(205, *YYCURSOR); ++YYCURSOR; YYDEBUG(206, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1475 "Zend/zend_language_scanner.l" +#line 1498 "Zend/zend_language_scanner.l" { - return T_IS_GREATER_OR_EQUAL; + RETURN_TOKEN(T_IS_GREATER_OR_EQUAL); } -#line 3410 "Zend/zend_language_scanner.c" +#line 3433 "Zend/zend_language_scanner.c" yy207: YYDEBUG(207, *YYCURSOR); ++YYCURSOR; YYDEBUG(208, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1515 "Zend/zend_language_scanner.l" +#line 1538 "Zend/zend_language_scanner.l" { - return T_SR_EQUAL; + RETURN_TOKEN(T_SR_EQUAL); } -#line 3420 "Zend/zend_language_scanner.c" +#line 3443 "Zend/zend_language_scanner.c" yy209: YYDEBUG(209, *YYCURSOR); yyaccept = 5; @@ -3427,53 +3450,53 @@ yy209: yy210: YYDEBUG(210, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1551 "Zend/zend_language_scanner.l" +#line 1574 "Zend/zend_language_scanner.l" { - return T_SL; + RETURN_TOKEN(T_SL); } -#line 3435 "Zend/zend_language_scanner.c" +#line 3458 "Zend/zend_language_scanner.c" yy211: YYDEBUG(211, *YYCURSOR); ++YYCURSOR; if ((yych = *YYCURSOR) == '>') goto yy215; YYDEBUG(212, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1471 "Zend/zend_language_scanner.l" +#line 1494 "Zend/zend_language_scanner.l" { - return T_IS_SMALLER_OR_EQUAL; + RETURN_TOKEN(T_IS_SMALLER_OR_EQUAL); } -#line 3446 "Zend/zend_language_scanner.c" +#line 3469 "Zend/zend_language_scanner.c" yy213: YYDEBUG(213, *YYCURSOR); ++YYCURSOR; yy214: YYDEBUG(214, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1463 "Zend/zend_language_scanner.l" +#line 1486 "Zend/zend_language_scanner.l" { - return T_IS_NOT_EQUAL; + RETURN_TOKEN(T_IS_NOT_EQUAL); } -#line 3457 "Zend/zend_language_scanner.c" +#line 3480 "Zend/zend_language_scanner.c" yy215: YYDEBUG(215, *YYCURSOR); ++YYCURSOR; YYDEBUG(216, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1467 "Zend/zend_language_scanner.l" +#line 1490 "Zend/zend_language_scanner.l" { - return T_SPACESHIP; + RETURN_TOKEN(T_SPACESHIP); } -#line 3467 "Zend/zend_language_scanner.c" +#line 3490 "Zend/zend_language_scanner.c" yy217: YYDEBUG(217, *YYCURSOR); ++YYCURSOR; YYDEBUG(218, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1511 "Zend/zend_language_scanner.l" +#line 1534 "Zend/zend_language_scanner.l" { - return T_SL_EQUAL; + RETURN_TOKEN(T_SL_EQUAL); } -#line 3477 "Zend/zend_language_scanner.c" +#line 3500 "Zend/zend_language_scanner.c" yy219: YYDEBUG(219, *YYCURSOR); ++YYCURSOR; @@ -3578,7 +3601,7 @@ yy228: yy229: YYDEBUG(229, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 2059 "Zend/zend_language_scanner.l" +#line 2082 "Zend/zend_language_scanner.l" { char *s; int bprefix = (yytext[0] != '<') ? 1 : 0; @@ -3623,9 +3646,9 @@ yy229: zend_ptr_stack_push(&SCNG(heredoc_label_stack), (void *) heredoc_label); - return T_START_HEREDOC; + RETURN_TOKEN(T_START_HEREDOC); } -#line 3629 "Zend/zend_language_scanner.c" +#line 3652 "Zend/zend_language_scanner.c" yy230: YYDEBUG(230, *YYCURSOR); yych = *++YYCURSOR; @@ -3665,31 +3688,31 @@ yy233: ++YYCURSOR; YYDEBUG(235, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1455 "Zend/zend_language_scanner.l" +#line 1478 "Zend/zend_language_scanner.l" { - return T_IS_NOT_IDENTICAL; + RETURN_TOKEN(T_IS_NOT_IDENTICAL); } -#line 3673 "Zend/zend_language_scanner.c" +#line 3696 "Zend/zend_language_scanner.c" yy236: YYDEBUG(236, *YYCURSOR); ++YYCURSOR; YYDEBUG(237, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1479 "Zend/zend_language_scanner.l" +#line 1502 "Zend/zend_language_scanner.l" { - return T_PLUS_EQUAL; + RETURN_TOKEN(T_PLUS_EQUAL); } -#line 3683 "Zend/zend_language_scanner.c" +#line 3706 "Zend/zend_language_scanner.c" yy238: YYDEBUG(238, *YYCURSOR); ++YYCURSOR; YYDEBUG(239, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1443 "Zend/zend_language_scanner.l" +#line 1466 "Zend/zend_language_scanner.l" { - return T_INC; + RETURN_TOKEN(T_INC); } -#line 3693 "Zend/zend_language_scanner.c" +#line 3716 "Zend/zend_language_scanner.c" yy240: YYDEBUG(240, *YYCURSOR); yych = *++YYCURSOR; @@ -3708,42 +3731,42 @@ yy242: } YYDEBUG(243, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1431 "Zend/zend_language_scanner.l" +#line 1454 "Zend/zend_language_scanner.l" { - return T_LIST; + RETURN_TOKEN(T_LIST); } -#line 3716 "Zend/zend_language_scanner.c" +#line 3739 "Zend/zend_language_scanner.c" yy244: YYDEBUG(244, *YYCURSOR); ++YYCURSOR; if ((yych = *YYCURSOR) == '=') goto yy248; YYDEBUG(245, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1459 "Zend/zend_language_scanner.l" +#line 1482 "Zend/zend_language_scanner.l" { - return T_IS_EQUAL; + RETURN_TOKEN(T_IS_EQUAL); } -#line 3727 "Zend/zend_language_scanner.c" +#line 3750 "Zend/zend_language_scanner.c" yy246: YYDEBUG(246, *YYCURSOR); ++YYCURSOR; YYDEBUG(247, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1427 "Zend/zend_language_scanner.l" +#line 1450 "Zend/zend_language_scanner.l" { - return T_DOUBLE_ARROW; + RETURN_TOKEN(T_DOUBLE_ARROW); } -#line 3737 "Zend/zend_language_scanner.c" +#line 3760 "Zend/zend_language_scanner.c" yy248: YYDEBUG(248, *YYCURSOR); ++YYCURSOR; YYDEBUG(249, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1451 "Zend/zend_language_scanner.l" +#line 1474 "Zend/zend_language_scanner.l" { - return T_IS_IDENTICAL; + RETURN_TOKEN(T_IS_IDENTICAL); } -#line 3747 "Zend/zend_language_scanner.c" +#line 3770 "Zend/zend_language_scanner.c" yy250: YYDEBUG(250, *YYCURSOR); yych = *++YYCURSOR; @@ -3873,11 +3896,11 @@ yy266: } YYDEBUG(269, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1757 "Zend/zend_language_scanner.l" +#line 1780 "Zend/zend_language_scanner.l" { - return T_NS_C; + RETURN_TOKEN(T_NS_C); } -#line 3881 "Zend/zend_language_scanner.c" +#line 3904 "Zend/zend_language_scanner.c" yy270: YYDEBUG(270, *YYCURSOR); yych = *++YYCURSOR; @@ -3897,11 +3920,11 @@ yy271: } YYDEBUG(274, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1753 "Zend/zend_language_scanner.l" +#line 1776 "Zend/zend_language_scanner.l" { - return T_DIR; + RETURN_TOKEN(T_DIR); } -#line 3905 "Zend/zend_language_scanner.c" +#line 3928 "Zend/zend_language_scanner.c" yy275: YYDEBUG(275, *YYCURSOR); yych = *++YYCURSOR; @@ -3926,11 +3949,11 @@ yy277: } YYDEBUG(280, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1745 "Zend/zend_language_scanner.l" +#line 1768 "Zend/zend_language_scanner.l" { - return T_LINE; + RETURN_TOKEN(T_LINE); } -#line 3934 "Zend/zend_language_scanner.c" +#line 3957 "Zend/zend_language_scanner.c" yy281: YYDEBUG(281, *YYCURSOR); yych = *++YYCURSOR; @@ -3965,11 +3988,11 @@ yy285: } YYDEBUG(288, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1741 "Zend/zend_language_scanner.l" +#line 1764 "Zend/zend_language_scanner.l" { - return T_METHOD_C; + RETURN_TOKEN(T_METHOD_C); } -#line 3973 "Zend/zend_language_scanner.c" +#line 3996 "Zend/zend_language_scanner.c" yy289: YYDEBUG(289, *YYCURSOR); yych = *++YYCURSOR; @@ -4020,11 +4043,11 @@ yy296: } YYDEBUG(299, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1737 "Zend/zend_language_scanner.l" +#line 1760 "Zend/zend_language_scanner.l" { - return T_FUNC_C; + RETURN_TOKEN(T_FUNC_C); } -#line 4028 "Zend/zend_language_scanner.c" +#line 4051 "Zend/zend_language_scanner.c" yy300: YYDEBUG(300, *YYCURSOR); yych = *++YYCURSOR; @@ -4044,11 +4067,11 @@ yy301: } YYDEBUG(304, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1749 "Zend/zend_language_scanner.l" +#line 1772 "Zend/zend_language_scanner.l" { - return T_FILE; + RETURN_TOKEN(T_FILE); } -#line 4052 "Zend/zend_language_scanner.c" +#line 4075 "Zend/zend_language_scanner.c" yy305: YYDEBUG(305, *YYCURSOR); yych = *++YYCURSOR; @@ -4078,11 +4101,11 @@ yy308: } YYDEBUG(311, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1733 "Zend/zend_language_scanner.l" +#line 1756 "Zend/zend_language_scanner.l" { - return T_TRAIT_C; + RETURN_TOKEN(T_TRAIT_C); } -#line 4086 "Zend/zend_language_scanner.c" +#line 4109 "Zend/zend_language_scanner.c" yy312: YYDEBUG(312, *YYCURSOR); yych = *++YYCURSOR; @@ -4112,11 +4135,11 @@ yy315: } YYDEBUG(318, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1729 "Zend/zend_language_scanner.l" +#line 1752 "Zend/zend_language_scanner.l" { - return T_CLASS_C; + RETURN_TOKEN(T_CLASS_C); } -#line 4120 "Zend/zend_language_scanner.c" +#line 4143 "Zend/zend_language_scanner.c" yy319: YYDEBUG(319, *YYCURSOR); yych = *++YYCURSOR; @@ -4178,11 +4201,11 @@ yy330: } YYDEBUG(331, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1395 "Zend/zend_language_scanner.l" +#line 1418 "Zend/zend_language_scanner.l" { - return T_HALT_COMPILER; + RETURN_TOKEN(T_HALT_COMPILER); } -#line 4186 "Zend/zend_language_scanner.c" +#line 4209 "Zend/zend_language_scanner.c" yy332: YYDEBUG(332, *YYCURSOR); yych = *++YYCURSOR; @@ -4202,11 +4225,11 @@ yy334: } YYDEBUG(335, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1375 "Zend/zend_language_scanner.l" +#line 1398 "Zend/zend_language_scanner.l" { - return T_USE; + RETURN_TOKEN(T_USE); } -#line 4210 "Zend/zend_language_scanner.c" +#line 4233 "Zend/zend_language_scanner.c" yy336: YYDEBUG(336, *YYCURSOR); yych = *++YYCURSOR; @@ -4225,11 +4248,11 @@ yy338: } YYDEBUG(339, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1423 "Zend/zend_language_scanner.l" +#line 1446 "Zend/zend_language_scanner.l" { - return T_UNSET; + RETURN_TOKEN(T_UNSET); } -#line 4233 "Zend/zend_language_scanner.c" +#line 4256 "Zend/zend_language_scanner.c" yy340: YYDEBUG(340, *YYCURSOR); ++YYCURSOR; @@ -4401,11 +4424,11 @@ yy355: ++YYCURSOR; YYDEBUG(357, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1323 "Zend/zend_language_scanner.l" +#line 1346 "Zend/zend_language_scanner.l" { - return T_INT_CAST; + RETURN_TOKEN(T_INT_CAST); } -#line 4409 "Zend/zend_language_scanner.c" +#line 4432 "Zend/zend_language_scanner.c" yy358: YYDEBUG(358, *YYCURSOR); yych = *++YYCURSOR; @@ -4449,11 +4472,11 @@ yy363: ++YYCURSOR; YYDEBUG(366, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1327 "Zend/zend_language_scanner.l" +#line 1350 "Zend/zend_language_scanner.l" { - return T_DOUBLE_CAST; + RETURN_TOKEN(T_DOUBLE_CAST); } -#line 4457 "Zend/zend_language_scanner.c" +#line 4480 "Zend/zend_language_scanner.c" yy367: YYDEBUG(367, *YYCURSOR); yych = *++YYCURSOR; @@ -4523,11 +4546,11 @@ yy377: ++YYCURSOR; YYDEBUG(380, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1331 "Zend/zend_language_scanner.l" +#line 1354 "Zend/zend_language_scanner.l" { - return T_STRING_CAST; + RETURN_TOKEN(T_STRING_CAST); } -#line 4531 "Zend/zend_language_scanner.c" +#line 4554 "Zend/zend_language_scanner.c" yy381: YYDEBUG(381, *YYCURSOR); yych = *++YYCURSOR; @@ -4560,11 +4583,11 @@ yy384: ++YYCURSOR; YYDEBUG(387, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1335 "Zend/zend_language_scanner.l" +#line 1358 "Zend/zend_language_scanner.l" { - return T_ARRAY_CAST; + RETURN_TOKEN(T_ARRAY_CAST); } -#line 4568 "Zend/zend_language_scanner.c" +#line 4591 "Zend/zend_language_scanner.c" yy388: YYDEBUG(388, *YYCURSOR); yych = *++YYCURSOR; @@ -4602,11 +4625,11 @@ yy392: ++YYCURSOR; YYDEBUG(395, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1339 "Zend/zend_language_scanner.l" +#line 1362 "Zend/zend_language_scanner.l" { - return T_OBJECT_CAST; + RETURN_TOKEN(T_OBJECT_CAST); } -#line 4610 "Zend/zend_language_scanner.c" +#line 4633 "Zend/zend_language_scanner.c" yy396: YYDEBUG(396, *YYCURSOR); yych = *++YYCURSOR; @@ -4647,11 +4670,11 @@ yy401: ++YYCURSOR; YYDEBUG(403, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1343 "Zend/zend_language_scanner.l" +#line 1366 "Zend/zend_language_scanner.l" { - return T_BOOL_CAST; + RETURN_TOKEN(T_BOOL_CAST); } -#line 4655 "Zend/zend_language_scanner.c" +#line 4678 "Zend/zend_language_scanner.c" yy404: YYDEBUG(404, *YYCURSOR); yych = *++YYCURSOR; @@ -4711,11 +4734,11 @@ yy412: ++YYCURSOR; YYDEBUG(415, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1347 "Zend/zend_language_scanner.l" +#line 1370 "Zend/zend_language_scanner.l" { - return T_UNSET_CAST; + RETURN_TOKEN(T_UNSET_CAST); } -#line 4719 "Zend/zend_language_scanner.c" +#line 4742 "Zend/zend_language_scanner.c" yy416: YYDEBUG(416, *YYCURSOR); yych = *++YYCURSOR; @@ -4729,11 +4752,11 @@ yy417: } YYDEBUG(418, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1319 "Zend/zend_language_scanner.l" +#line 1342 "Zend/zend_language_scanner.l" { - return T_VAR; + RETURN_TOKEN(T_VAR); } -#line 4737 "Zend/zend_language_scanner.c" +#line 4760 "Zend/zend_language_scanner.c" yy419: YYDEBUG(419, *YYCURSOR); yych = *++YYCURSOR; @@ -4753,11 +4776,11 @@ yy421: } YYDEBUG(422, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1311 "Zend/zend_language_scanner.l" +#line 1334 "Zend/zend_language_scanner.l" { - return T_NEW; + RETURN_TOKEN(T_NEW); } -#line 4761 "Zend/zend_language_scanner.c" +#line 4784 "Zend/zend_language_scanner.c" yy423: YYDEBUG(423, *YYCURSOR); yych = *++YYCURSOR; @@ -4796,11 +4819,11 @@ yy429: } YYDEBUG(430, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1371 "Zend/zend_language_scanner.l" +#line 1394 "Zend/zend_language_scanner.l" { - return T_NAMESPACE; + RETURN_TOKEN(T_NAMESPACE); } -#line 4804 "Zend/zend_language_scanner.c" +#line 4827 "Zend/zend_language_scanner.c" yy431: YYDEBUG(431, *YYCURSOR); ++YYCURSOR; @@ -4809,22 +4832,22 @@ yy431: yy432: YYDEBUG(432, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1940 "Zend/zend_language_scanner.l" +#line 1963 "Zend/zend_language_scanner.l" { BEGIN(INITIAL); - return T_CLOSE_TAG; /* implicit ';' at php-end tag */ + RETURN_TOKEN(T_CLOSE_TAG); /* implicit ';' at php-end tag */ } -#line 4818 "Zend/zend_language_scanner.c" +#line 4841 "Zend/zend_language_scanner.c" yy433: YYDEBUG(433, *YYCURSOR); ++YYCURSOR; YYDEBUG(434, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1307 "Zend/zend_language_scanner.l" +#line 1330 "Zend/zend_language_scanner.l" { - return T_COALESCE; + RETURN_TOKEN(T_COALESCE); } -#line 4828 "Zend/zend_language_scanner.c" +#line 4851 "Zend/zend_language_scanner.c" yy435: YYDEBUG(435, *YYCURSOR); yych = *++YYCURSOR; @@ -4855,11 +4878,11 @@ yy439: ++YYCURSOR; YYDEBUG(440, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1503 "Zend/zend_language_scanner.l" +#line 1526 "Zend/zend_language_scanner.l" { - return T_CONCAT_EQUAL; + RETURN_TOKEN(T_CONCAT_EQUAL); } -#line 4863 "Zend/zend_language_scanner.c" +#line 4886 "Zend/zend_language_scanner.c" yy441: YYDEBUG(441, *YYCURSOR); yych = *++YYCURSOR; @@ -4868,21 +4891,21 @@ yy441: ++YYCURSOR; YYDEBUG(443, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1303 "Zend/zend_language_scanner.l" +#line 1326 "Zend/zend_language_scanner.l" { - return T_ELLIPSIS; + RETURN_TOKEN(T_ELLIPSIS); } -#line 4876 "Zend/zend_language_scanner.c" +#line 4899 "Zend/zend_language_scanner.c" yy444: YYDEBUG(444, *YYCURSOR); ++YYCURSOR; YYDEBUG(445, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1295 "Zend/zend_language_scanner.l" +#line 1318 "Zend/zend_language_scanner.l" { - return T_PAAMAYIM_NEKUDOTAYIM; + RETURN_TOKEN(T_PAAMAYIM_NEKUDOTAYIM); } -#line 4886 "Zend/zend_language_scanner.c" +#line 4909 "Zend/zend_language_scanner.c" yy446: YYDEBUG(446, *YYCURSOR); ++YYCURSOR; @@ -4904,32 +4927,32 @@ yy448: ++YYCURSOR; YYDEBUG(449, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1483 "Zend/zend_language_scanner.l" +#line 1506 "Zend/zend_language_scanner.l" { - return T_MINUS_EQUAL; + RETURN_TOKEN(T_MINUS_EQUAL); } -#line 4912 "Zend/zend_language_scanner.c" +#line 4935 "Zend/zend_language_scanner.c" yy450: YYDEBUG(450, *YYCURSOR); ++YYCURSOR; YYDEBUG(451, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1447 "Zend/zend_language_scanner.l" +#line 1470 "Zend/zend_language_scanner.l" { - return T_DEC; + RETURN_TOKEN(T_DEC); } -#line 4922 "Zend/zend_language_scanner.c" +#line 4945 "Zend/zend_language_scanner.c" yy452: YYDEBUG(452, *YYCURSOR); ++YYCURSOR; YYDEBUG(453, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1269 "Zend/zend_language_scanner.l" +#line 1292 "Zend/zend_language_scanner.l" { yy_push_state(ST_LOOKING_FOR_PROPERTY); - return T_OBJECT_OPERATOR; + RETURN_TOKEN(T_OBJECT_OPERATOR); } -#line 4933 "Zend/zend_language_scanner.c" +#line 4956 "Zend/zend_language_scanner.c" yy454: YYDEBUG(454, *YYCURSOR); yych = *++YYCURSOR; @@ -4974,11 +4997,11 @@ yy459: } YYDEBUG(460, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1419 "Zend/zend_language_scanner.l" +#line 1442 "Zend/zend_language_scanner.l" { - return T_PUBLIC; + RETURN_TOKEN(T_PUBLIC); } -#line 4982 "Zend/zend_language_scanner.c" +#line 5005 "Zend/zend_language_scanner.c" yy461: YYDEBUG(461, *YYCURSOR); yych = *++YYCURSOR; @@ -5033,11 +5056,11 @@ yy468: } YYDEBUG(469, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1415 "Zend/zend_language_scanner.l" +#line 1438 "Zend/zend_language_scanner.l" { - return T_PROTECTED; + RETURN_TOKEN(T_PROTECTED); } -#line 5041 "Zend/zend_language_scanner.c" +#line 5064 "Zend/zend_language_scanner.c" yy470: YYDEBUG(470, *YYCURSOR); yych = *++YYCURSOR; @@ -5067,11 +5090,11 @@ yy474: } YYDEBUG(475, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1411 "Zend/zend_language_scanner.l" +#line 1434 "Zend/zend_language_scanner.l" { - return T_PRIVATE; + RETURN_TOKEN(T_PRIVATE); } -#line 5075 "Zend/zend_language_scanner.c" +#line 5098 "Zend/zend_language_scanner.c" yy476: YYDEBUG(476, *YYCURSOR); ++YYCURSOR; @@ -5080,11 +5103,11 @@ yy476: } YYDEBUG(477, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1245 "Zend/zend_language_scanner.l" +#line 1268 "Zend/zend_language_scanner.l" { - return T_PRINT; + RETURN_TOKEN(T_PRINT); } -#line 5088 "Zend/zend_language_scanner.c" +#line 5111 "Zend/zend_language_scanner.c" yy478: YYDEBUG(478, *YYCURSOR); yych = *++YYCURSOR; @@ -5109,11 +5132,11 @@ yy481: } YYDEBUG(482, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1237 "Zend/zend_language_scanner.l" +#line 1260 "Zend/zend_language_scanner.l" { - return T_GOTO; + RETURN_TOKEN(T_GOTO); } -#line 5117 "Zend/zend_language_scanner.c" +#line 5140 "Zend/zend_language_scanner.c" yy483: YYDEBUG(483, *YYCURSOR); yych = *++YYCURSOR; @@ -5137,11 +5160,11 @@ yy486: } YYDEBUG(487, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1383 "Zend/zend_language_scanner.l" +#line 1406 "Zend/zend_language_scanner.l" { - return T_GLOBAL; + RETURN_TOKEN(T_GLOBAL); } -#line 5145 "Zend/zend_language_scanner.c" +#line 5168 "Zend/zend_language_scanner.c" yy488: YYDEBUG(488, *YYCURSOR); yych = *++YYCURSOR; @@ -5178,11 +5201,11 @@ yy494: } YYDEBUG(495, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1229 "Zend/zend_language_scanner.l" +#line 1252 "Zend/zend_language_scanner.l" { - return T_BREAK; + RETURN_TOKEN(T_BREAK); } -#line 5186 "Zend/zend_language_scanner.c" +#line 5209 "Zend/zend_language_scanner.c" yy496: YYDEBUG(496, *YYCURSOR); yych = *++YYCURSOR; @@ -5222,11 +5245,11 @@ yy502: } YYDEBUG(503, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1213 "Zend/zend_language_scanner.l" +#line 1236 "Zend/zend_language_scanner.l" { - return T_SWITCH; + RETURN_TOKEN(T_SWITCH); } -#line 5230 "Zend/zend_language_scanner.c" +#line 5253 "Zend/zend_language_scanner.c" yy504: YYDEBUG(504, *YYCURSOR); yych = *++YYCURSOR; @@ -5250,11 +5273,11 @@ yy507: } YYDEBUG(508, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1399 "Zend/zend_language_scanner.l" +#line 1422 "Zend/zend_language_scanner.l" { - return T_STATIC; + RETURN_TOKEN(T_STATIC); } -#line 5258 "Zend/zend_language_scanner.c" +#line 5281 "Zend/zend_language_scanner.c" yy509: YYDEBUG(509, *YYCURSOR); yych = *++YYCURSOR; @@ -5281,11 +5304,11 @@ yy512: } YYDEBUG(513, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1209 "Zend/zend_language_scanner.l" +#line 1232 "Zend/zend_language_scanner.l" { - return T_AS; + RETURN_TOKEN(T_AS); } -#line 5289 "Zend/zend_language_scanner.c" +#line 5312 "Zend/zend_language_scanner.c" yy514: YYDEBUG(514, *YYCURSOR); yych = *++YYCURSOR; @@ -5304,11 +5327,11 @@ yy516: } YYDEBUG(517, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1435 "Zend/zend_language_scanner.l" +#line 1458 "Zend/zend_language_scanner.l" { - return T_ARRAY; + RETURN_TOKEN(T_ARRAY); } -#line 5312 "Zend/zend_language_scanner.c" +#line 5335 "Zend/zend_language_scanner.c" yy518: YYDEBUG(518, *YYCURSOR); ++YYCURSOR; @@ -5317,11 +5340,11 @@ yy518: } YYDEBUG(519, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1543 "Zend/zend_language_scanner.l" +#line 1566 "Zend/zend_language_scanner.l" { - return T_LOGICAL_AND; + RETURN_TOKEN(T_LOGICAL_AND); } -#line 5325 "Zend/zend_language_scanner.c" +#line 5348 "Zend/zend_language_scanner.c" yy520: YYDEBUG(520, *YYCURSOR); yych = *++YYCURSOR; @@ -5355,11 +5378,11 @@ yy525: } YYDEBUG(526, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1403 "Zend/zend_language_scanner.l" +#line 1426 "Zend/zend_language_scanner.l" { - return T_ABSTRACT; + RETURN_TOKEN(T_ABSTRACT); } -#line 5363 "Zend/zend_language_scanner.c" +#line 5386 "Zend/zend_language_scanner.c" yy527: YYDEBUG(527, *YYCURSOR); yych = *++YYCURSOR; @@ -5383,11 +5406,11 @@ yy530: } YYDEBUG(531, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1169 "Zend/zend_language_scanner.l" +#line 1192 "Zend/zend_language_scanner.l" { - return T_WHILE; + RETURN_TOKEN(T_WHILE); } -#line 5391 "Zend/zend_language_scanner.c" +#line 5414 "Zend/zend_language_scanner.c" yy532: YYDEBUG(532, *YYCURSOR); ++YYCURSOR; @@ -5396,11 +5419,11 @@ yy532: } YYDEBUG(533, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1153 "Zend/zend_language_scanner.l" +#line 1176 "Zend/zend_language_scanner.l" { - return T_IF; + RETURN_TOKEN(T_IF); } -#line 5404 "Zend/zend_language_scanner.c" +#line 5427 "Zend/zend_language_scanner.c" yy534: YYDEBUG(534, *YYCURSOR); yych = *++YYCURSOR; @@ -5452,11 +5475,11 @@ yy539: } YYDEBUG(540, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1387 "Zend/zend_language_scanner.l" +#line 1410 "Zend/zend_language_scanner.l" { - return T_ISSET; + RETURN_TOKEN(T_ISSET); } -#line 5460 "Zend/zend_language_scanner.c" +#line 5483 "Zend/zend_language_scanner.c" yy541: YYDEBUG(541, *YYCURSOR); yych = *++YYCURSOR; @@ -5510,11 +5533,11 @@ yy547: yy548: YYDEBUG(548, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1355 "Zend/zend_language_scanner.l" +#line 1378 "Zend/zend_language_scanner.l" { - return T_INCLUDE; + RETURN_TOKEN(T_INCLUDE); } -#line 5518 "Zend/zend_language_scanner.c" +#line 5541 "Zend/zend_language_scanner.c" yy549: YYDEBUG(549, *YYCURSOR); yych = *++YYCURSOR; @@ -5543,11 +5566,11 @@ yy553: } YYDEBUG(554, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1359 "Zend/zend_language_scanner.l" +#line 1382 "Zend/zend_language_scanner.l" { - return T_INCLUDE_ONCE; + RETURN_TOKEN(T_INCLUDE_ONCE); } -#line 5551 "Zend/zend_language_scanner.c" +#line 5574 "Zend/zend_language_scanner.c" yy555: YYDEBUG(555, *YYCURSOR); yych = *++YYCURSOR; @@ -5581,11 +5604,11 @@ yy560: } YYDEBUG(561, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1253 "Zend/zend_language_scanner.l" +#line 1276 "Zend/zend_language_scanner.l" { - return T_INTERFACE; + RETURN_TOKEN(T_INTERFACE); } -#line 5589 "Zend/zend_language_scanner.c" +#line 5612 "Zend/zend_language_scanner.c" yy562: YYDEBUG(562, *YYCURSOR); yych = *++YYCURSOR; @@ -5635,11 +5658,11 @@ yy568: } YYDEBUG(569, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1379 "Zend/zend_language_scanner.l" +#line 1402 "Zend/zend_language_scanner.l" { - return T_INSTEADOF; + RETURN_TOKEN(T_INSTEADOF); } -#line 5643 "Zend/zend_language_scanner.c" +#line 5666 "Zend/zend_language_scanner.c" yy570: YYDEBUG(570, *YYCURSOR); yych = *++YYCURSOR; @@ -5668,11 +5691,11 @@ yy574: } YYDEBUG(575, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1205 "Zend/zend_language_scanner.l" +#line 1228 "Zend/zend_language_scanner.l" { - return T_INSTANCEOF; + RETURN_TOKEN(T_INSTANCEOF); } -#line 5676 "Zend/zend_language_scanner.c" +#line 5699 "Zend/zend_language_scanner.c" yy576: YYDEBUG(576, *YYCURSOR); yych = *++YYCURSOR; @@ -5716,11 +5739,11 @@ yy583: } YYDEBUG(584, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1265 "Zend/zend_language_scanner.l" +#line 1288 "Zend/zend_language_scanner.l" { - return T_IMPLEMENTS; + RETURN_TOKEN(T_IMPLEMENTS); } -#line 5724 "Zend/zend_language_scanner.c" +#line 5747 "Zend/zend_language_scanner.c" yy585: YYDEBUG(585, *YYCURSOR); yych = *++YYCURSOR; @@ -5748,11 +5771,11 @@ yy586: } YYDEBUG(588, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1137 "Zend/zend_language_scanner.l" +#line 1160 "Zend/zend_language_scanner.l" { - return T_TRY; + RETURN_TOKEN(T_TRY); } -#line 5756 "Zend/zend_language_scanner.c" +#line 5779 "Zend/zend_language_scanner.c" yy589: YYDEBUG(589, *YYCURSOR); yych = *++YYCURSOR; @@ -5771,11 +5794,11 @@ yy591: } YYDEBUG(592, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1257 "Zend/zend_language_scanner.l" +#line 1280 "Zend/zend_language_scanner.l" { - return T_TRAIT; + RETURN_TOKEN(T_TRAIT); } -#line 5779 "Zend/zend_language_scanner.c" +#line 5802 "Zend/zend_language_scanner.c" yy593: YYDEBUG(593, *YYCURSOR); yych = *++YYCURSOR; @@ -5794,11 +5817,11 @@ yy595: } YYDEBUG(596, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1149 "Zend/zend_language_scanner.l" +#line 1172 "Zend/zend_language_scanner.l" { - return T_THROW; + RETURN_TOKEN(T_THROW); } -#line 5802 "Zend/zend_language_scanner.c" +#line 5825 "Zend/zend_language_scanner.c" yy597: YYDEBUG(597, *YYCURSOR); yych = *++YYCURSOR; @@ -5831,11 +5854,11 @@ yy600: yy601: YYDEBUG(601, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1133 "Zend/zend_language_scanner.l" +#line 1156 "Zend/zend_language_scanner.l" { - return T_YIELD; + RETURN_TOKEN(T_YIELD); } -#line 5839 "Zend/zend_language_scanner.c" +#line 5862 "Zend/zend_language_scanner.c" yy602: YYDEBUG(602, *YYCURSOR); ++YYCURSOR; @@ -5877,11 +5900,11 @@ yy607: ++YYCURSOR; YYDEBUG(608, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1129 "Zend/zend_language_scanner.l" +#line 1152 "Zend/zend_language_scanner.l" { - return T_YIELD_FROM; + RETURN_TOKEN(T_YIELD_FROM); } -#line 5885 "Zend/zend_language_scanner.c" +#line 5908 "Zend/zend_language_scanner.c" yy609: YYDEBUG(609, *YYCURSOR); yych = *++YYCURSOR; @@ -5942,11 +5965,11 @@ yy615: yy616: YYDEBUG(616, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1363 "Zend/zend_language_scanner.l" +#line 1386 "Zend/zend_language_scanner.l" { - return T_REQUIRE; + RETURN_TOKEN(T_REQUIRE); } -#line 5950 "Zend/zend_language_scanner.c" +#line 5973 "Zend/zend_language_scanner.c" yy617: YYDEBUG(617, *YYCURSOR); yych = *++YYCURSOR; @@ -5975,11 +5998,11 @@ yy621: } YYDEBUG(622, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1367 "Zend/zend_language_scanner.l" +#line 1390 "Zend/zend_language_scanner.l" { - return T_REQUIRE_ONCE; + RETURN_TOKEN(T_REQUIRE_ONCE); } -#line 5983 "Zend/zend_language_scanner.c" +#line 6006 "Zend/zend_language_scanner.c" yy623: YYDEBUG(623, *YYCURSOR); yych = *++YYCURSOR; @@ -5998,11 +6021,11 @@ yy625: } YYDEBUG(626, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1125 "Zend/zend_language_scanner.l" +#line 1148 "Zend/zend_language_scanner.l" { - return T_RETURN; + RETURN_TOKEN(T_RETURN); } -#line 6006 "Zend/zend_language_scanner.c" +#line 6029 "Zend/zend_language_scanner.c" yy627: YYDEBUG(627, *YYCURSOR); yych = *++YYCURSOR; @@ -6092,11 +6115,11 @@ yy636: } YYDEBUG(637, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1233 "Zend/zend_language_scanner.l" +#line 1256 "Zend/zend_language_scanner.l" { - return T_CONTINUE; + RETURN_TOKEN(T_CONTINUE); } -#line 6100 "Zend/zend_language_scanner.c" +#line 6123 "Zend/zend_language_scanner.c" yy638: YYDEBUG(638, *YYCURSOR); ++YYCURSOR; @@ -6105,11 +6128,11 @@ yy638: } YYDEBUG(639, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1121 "Zend/zend_language_scanner.l" +#line 1144 "Zend/zend_language_scanner.l" { - return T_CONST; + RETURN_TOKEN(T_CONST); } -#line 6113 "Zend/zend_language_scanner.c" +#line 6136 "Zend/zend_language_scanner.c" yy640: YYDEBUG(640, *YYCURSOR); yych = *++YYCURSOR; @@ -6134,11 +6157,11 @@ yy643: } YYDEBUG(644, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1315 "Zend/zend_language_scanner.l" +#line 1338 "Zend/zend_language_scanner.l" { - return T_CLONE; + RETURN_TOKEN(T_CLONE); } -#line 6142 "Zend/zend_language_scanner.c" +#line 6165 "Zend/zend_language_scanner.c" yy645: YYDEBUG(645, *YYCURSOR); yych = *++YYCURSOR; @@ -6152,11 +6175,11 @@ yy646: } YYDEBUG(647, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1249 "Zend/zend_language_scanner.l" +#line 1272 "Zend/zend_language_scanner.l" { - return T_CLASS; + RETURN_TOKEN(T_CLASS); } -#line 6160 "Zend/zend_language_scanner.c" +#line 6183 "Zend/zend_language_scanner.c" yy648: YYDEBUG(648, *YYCURSOR); yych = *++YYCURSOR; @@ -6202,11 +6225,11 @@ yy655: } YYDEBUG(656, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1439 "Zend/zend_language_scanner.l" +#line 1462 "Zend/zend_language_scanner.l" { - return T_CALLABLE; + RETURN_TOKEN(T_CALLABLE); } -#line 6210 "Zend/zend_language_scanner.c" +#line 6233 "Zend/zend_language_scanner.c" yy657: YYDEBUG(657, *YYCURSOR); ++YYCURSOR; @@ -6215,11 +6238,11 @@ yy657: } YYDEBUG(658, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1221 "Zend/zend_language_scanner.l" +#line 1244 "Zend/zend_language_scanner.l" { - return T_CASE; + RETURN_TOKEN(T_CASE); } -#line 6223 "Zend/zend_language_scanner.c" +#line 6246 "Zend/zend_language_scanner.c" yy659: YYDEBUG(659, *YYCURSOR); yych = *++YYCURSOR; @@ -6233,11 +6256,11 @@ yy660: } YYDEBUG(661, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1141 "Zend/zend_language_scanner.l" +#line 1164 "Zend/zend_language_scanner.l" { - return T_CATCH; + RETURN_TOKEN(T_CATCH); } -#line 6241 "Zend/zend_language_scanner.c" +#line 6264 "Zend/zend_language_scanner.c" yy662: YYDEBUG(662, *YYCURSOR); yych = *++YYCURSOR; @@ -6288,11 +6311,11 @@ yy670: } YYDEBUG(671, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1117 "Zend/zend_language_scanner.l" +#line 1140 "Zend/zend_language_scanner.l" { - return T_FUNCTION; + RETURN_TOKEN(T_FUNCTION); } -#line 6296 "Zend/zend_language_scanner.c" +#line 6319 "Zend/zend_language_scanner.c" yy672: YYDEBUG(672, *YYCURSOR); ++YYCURSOR; @@ -6316,11 +6339,11 @@ yy672: yy673: YYDEBUG(673, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1181 "Zend/zend_language_scanner.l" +#line 1204 "Zend/zend_language_scanner.l" { - return T_FOR; + RETURN_TOKEN(T_FOR); } -#line 6324 "Zend/zend_language_scanner.c" +#line 6347 "Zend/zend_language_scanner.c" yy674: YYDEBUG(674, *YYCURSOR); yych = *++YYCURSOR; @@ -6344,11 +6367,11 @@ yy677: } YYDEBUG(678, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1189 "Zend/zend_language_scanner.l" +#line 1212 "Zend/zend_language_scanner.l" { - return T_FOREACH; + RETURN_TOKEN(T_FOREACH); } -#line 6352 "Zend/zend_language_scanner.c" +#line 6375 "Zend/zend_language_scanner.c" yy679: YYDEBUG(679, *YYCURSOR); yych = *++YYCURSOR; @@ -6382,11 +6405,11 @@ yy681: yy682: YYDEBUG(682, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1407 "Zend/zend_language_scanner.l" +#line 1430 "Zend/zend_language_scanner.l" { - return T_FINAL; + RETURN_TOKEN(T_FINAL); } -#line 6390 "Zend/zend_language_scanner.c" +#line 6413 "Zend/zend_language_scanner.c" yy683: YYDEBUG(683, *YYCURSOR); yych = *++YYCURSOR; @@ -6400,11 +6423,11 @@ yy684: } YYDEBUG(685, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1145 "Zend/zend_language_scanner.l" +#line 1168 "Zend/zend_language_scanner.l" { - return T_FINALLY; + RETURN_TOKEN(T_FINALLY); } -#line 6408 "Zend/zend_language_scanner.c" +#line 6431 "Zend/zend_language_scanner.c" yy686: YYDEBUG(686, *YYCURSOR); yych = *++YYCURSOR; @@ -6435,11 +6458,11 @@ yy688: } YYDEBUG(689, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1177 "Zend/zend_language_scanner.l" +#line 1200 "Zend/zend_language_scanner.l" { - return T_DO; + RETURN_TOKEN(T_DO); } -#line 6443 "Zend/zend_language_scanner.c" +#line 6466 "Zend/zend_language_scanner.c" yy690: YYDEBUG(690, *YYCURSOR); ++YYCURSOR; @@ -6448,11 +6471,11 @@ yy690: } YYDEBUG(691, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1113 "Zend/zend_language_scanner.l" +#line 1136 "Zend/zend_language_scanner.l" { - return T_EXIT; + RETURN_TOKEN(T_EXIT); } -#line 6456 "Zend/zend_language_scanner.c" +#line 6479 "Zend/zend_language_scanner.c" yy692: YYDEBUG(692, *YYCURSOR); yych = *++YYCURSOR; @@ -6487,11 +6510,11 @@ yy697: } YYDEBUG(698, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1225 "Zend/zend_language_scanner.l" +#line 1248 "Zend/zend_language_scanner.l" { - return T_DEFAULT; + RETURN_TOKEN(T_DEFAULT); } -#line 6495 "Zend/zend_language_scanner.c" +#line 6518 "Zend/zend_language_scanner.c" yy699: YYDEBUG(699, *YYCURSOR); yych = *++YYCURSOR; @@ -6515,11 +6538,11 @@ yy702: } YYDEBUG(703, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1197 "Zend/zend_language_scanner.l" +#line 1220 "Zend/zend_language_scanner.l" { - return T_DECLARE; + RETURN_TOKEN(T_DECLARE); } -#line 6523 "Zend/zend_language_scanner.c" +#line 6546 "Zend/zend_language_scanner.c" yy704: YYDEBUG(704, *YYCURSOR); yych = *++YYCURSOR; @@ -6599,11 +6622,11 @@ yy715: } YYDEBUG(716, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1261 "Zend/zend_language_scanner.l" +#line 1284 "Zend/zend_language_scanner.l" { - return T_EXTENDS; + RETURN_TOKEN(T_EXTENDS); } -#line 6607 "Zend/zend_language_scanner.c" +#line 6630 "Zend/zend_language_scanner.c" yy717: YYDEBUG(717, *YYCURSOR); ++YYCURSOR; @@ -6612,11 +6635,11 @@ yy717: } YYDEBUG(718, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1109 "Zend/zend_language_scanner.l" +#line 1132 "Zend/zend_language_scanner.l" { - return T_EXIT; + RETURN_TOKEN(T_EXIT); } -#line 6620 "Zend/zend_language_scanner.c" +#line 6643 "Zend/zend_language_scanner.c" yy719: YYDEBUG(719, *YYCURSOR); yych = *++YYCURSOR; @@ -6630,11 +6653,11 @@ yy720: } YYDEBUG(721, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1351 "Zend/zend_language_scanner.l" +#line 1374 "Zend/zend_language_scanner.l" { - return T_EVAL; + RETURN_TOKEN(T_EVAL); } -#line 6638 "Zend/zend_language_scanner.c" +#line 6661 "Zend/zend_language_scanner.c" yy722: YYDEBUG(722, *YYCURSOR); yych = *++YYCURSOR; @@ -6704,11 +6727,11 @@ yy731: } YYDEBUG(732, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1173 "Zend/zend_language_scanner.l" +#line 1196 "Zend/zend_language_scanner.l" { - return T_ENDWHILE; + RETURN_TOKEN(T_ENDWHILE); } -#line 6712 "Zend/zend_language_scanner.c" +#line 6735 "Zend/zend_language_scanner.c" yy733: YYDEBUG(733, *YYCURSOR); yych = *++YYCURSOR; @@ -6737,11 +6760,11 @@ yy737: } YYDEBUG(738, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1217 "Zend/zend_language_scanner.l" +#line 1240 "Zend/zend_language_scanner.l" { - return T_ENDSWITCH; + RETURN_TOKEN(T_ENDSWITCH); } -#line 6745 "Zend/zend_language_scanner.c" +#line 6768 "Zend/zend_language_scanner.c" yy739: YYDEBUG(739, *YYCURSOR); ++YYCURSOR; @@ -6750,11 +6773,11 @@ yy739: } YYDEBUG(740, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1161 "Zend/zend_language_scanner.l" +#line 1184 "Zend/zend_language_scanner.l" { - return T_ENDIF; + RETURN_TOKEN(T_ENDIF); } -#line 6758 "Zend/zend_language_scanner.c" +#line 6781 "Zend/zend_language_scanner.c" yy741: YYDEBUG(741, *YYCURSOR); yych = *++YYCURSOR; @@ -6783,11 +6806,11 @@ yy742: yy743: YYDEBUG(743, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1185 "Zend/zend_language_scanner.l" +#line 1208 "Zend/zend_language_scanner.l" { - return T_ENDFOR; + RETURN_TOKEN(T_ENDFOR); } -#line 6791 "Zend/zend_language_scanner.c" +#line 6814 "Zend/zend_language_scanner.c" yy744: YYDEBUG(744, *YYCURSOR); yych = *++YYCURSOR; @@ -6811,11 +6834,11 @@ yy747: } YYDEBUG(748, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1193 "Zend/zend_language_scanner.l" +#line 1216 "Zend/zend_language_scanner.l" { - return T_ENDFOREACH; + RETURN_TOKEN(T_ENDFOREACH); } -#line 6819 "Zend/zend_language_scanner.c" +#line 6842 "Zend/zend_language_scanner.c" yy749: YYDEBUG(749, *YYCURSOR); yych = *++YYCURSOR; @@ -6849,11 +6872,11 @@ yy754: } YYDEBUG(755, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1201 "Zend/zend_language_scanner.l" +#line 1224 "Zend/zend_language_scanner.l" { - return T_ENDDECLARE; + RETURN_TOKEN(T_ENDDECLARE); } -#line 6857 "Zend/zend_language_scanner.c" +#line 6880 "Zend/zend_language_scanner.c" yy756: YYDEBUG(756, *YYCURSOR); yych = *++YYCURSOR; @@ -6872,11 +6895,11 @@ yy758: } YYDEBUG(759, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1391 "Zend/zend_language_scanner.l" +#line 1414 "Zend/zend_language_scanner.l" { - return T_EMPTY; + RETURN_TOKEN(T_EMPTY); } -#line 6880 "Zend/zend_language_scanner.c" +#line 6903 "Zend/zend_language_scanner.c" yy760: YYDEBUG(760, *YYCURSOR); yych = *++YYCURSOR; @@ -6905,11 +6928,11 @@ yy761: yy762: YYDEBUG(762, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1165 "Zend/zend_language_scanner.l" +#line 1188 "Zend/zend_language_scanner.l" { - return T_ELSE; + RETURN_TOKEN(T_ELSE); } -#line 6913 "Zend/zend_language_scanner.c" +#line 6936 "Zend/zend_language_scanner.c" yy763: YYDEBUG(763, *YYCURSOR); yych = *++YYCURSOR; @@ -6923,11 +6946,11 @@ yy764: } YYDEBUG(765, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1157 "Zend/zend_language_scanner.l" +#line 1180 "Zend/zend_language_scanner.l" { - return T_ELSEIF; + RETURN_TOKEN(T_ELSEIF); } -#line 6931 "Zend/zend_language_scanner.c" +#line 6954 "Zend/zend_language_scanner.c" yy766: YYDEBUG(766, *YYCURSOR); yych = *++YYCURSOR; @@ -6941,11 +6964,11 @@ yy767: } YYDEBUG(768, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1241 "Zend/zend_language_scanner.l" +#line 1264 "Zend/zend_language_scanner.l" { - return T_ECHO; + RETURN_TOKEN(T_ECHO); } -#line 6949 "Zend/zend_language_scanner.c" +#line 6972 "Zend/zend_language_scanner.c" } /* *********************************** */ yyc_ST_LOOKING_FOR_PROPERTY: @@ -7018,12 +7041,12 @@ yy771: yy772: YYDEBUG(772, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1274 "Zend/zend_language_scanner.l" +#line 1297 "Zend/zend_language_scanner.l" { HANDLE_NEWLINES(yytext, yyleng); - return T_WHITESPACE; + RETURN_TOKEN(T_WHITESPACE); } -#line 7027 "Zend/zend_language_scanner.c" +#line 7050 "Zend/zend_language_scanner.c" yy773: YYDEBUG(773, *YYCURSOR); ++YYCURSOR; @@ -7031,13 +7054,13 @@ yy773: yy774: YYDEBUG(774, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1289 "Zend/zend_language_scanner.l" +#line 1312 "Zend/zend_language_scanner.l" { yyless(0); yy_pop_state(); goto restart; } -#line 7041 "Zend/zend_language_scanner.c" +#line 7064 "Zend/zend_language_scanner.c" yy775: YYDEBUG(775, *YYCURSOR); ++YYCURSOR; @@ -7046,13 +7069,13 @@ yy775: yy776: YYDEBUG(776, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1283 "Zend/zend_language_scanner.l" +#line 1306 "Zend/zend_language_scanner.l" { yy_pop_state(); zend_copy_value(zendlval, yytext, yyleng); - return T_STRING; + RETURN_TOKEN(T_STRING); } -#line 7056 "Zend/zend_language_scanner.c" +#line 7079 "Zend/zend_language_scanner.c" yy777: YYDEBUG(777, *YYCURSOR); yych = *++YYCURSOR; @@ -7073,11 +7096,11 @@ yy780: ++YYCURSOR; YYDEBUG(781, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1279 "Zend/zend_language_scanner.l" +#line 1302 "Zend/zend_language_scanner.l" { - return T_OBJECT_OPERATOR; + RETURN_TOKEN(T_OBJECT_OPERATOR); } -#line 7081 "Zend/zend_language_scanner.c" +#line 7104 "Zend/zend_language_scanner.c" yy782: YYDEBUG(782, *YYCURSOR); ++YYCURSOR; @@ -7162,14 +7185,14 @@ yy786: yy787: YYDEBUG(787, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1594 "Zend/zend_language_scanner.l" +#line 1617 "Zend/zend_language_scanner.l" { yyless(0); yy_pop_state(); yy_push_state(ST_IN_SCRIPTING); goto restart; } -#line 7173 "Zend/zend_language_scanner.c" +#line 7196 "Zend/zend_language_scanner.c" yy788: YYDEBUG(788, *YYCURSOR); yych = *++YYCURSOR; @@ -7194,15 +7217,15 @@ yy792: ++YYCURSOR; YYDEBUG(793, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1585 "Zend/zend_language_scanner.l" +#line 1608 "Zend/zend_language_scanner.l" { yyless(yyleng - 1); zend_copy_value(zendlval, yytext, yyleng); yy_pop_state(); yy_push_state(ST_IN_SCRIPTING); - return T_STRING_VARNAME; + RETURN_TOKEN(T_STRING_VARNAME); } -#line 7206 "Zend/zend_language_scanner.c" +#line 7229 "Zend/zend_language_scanner.c" } /* *********************************** */ yyc_ST_NOWDOC: @@ -7213,14 +7236,14 @@ yyc_ST_NOWDOC: ++YYCURSOR; YYDEBUG(797, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 2318 "Zend/zend_language_scanner.l" +#line 2341 "Zend/zend_language_scanner.l" { int newline = 0; zend_heredoc_label *heredoc_label = zend_ptr_stack_top(&SCNG(heredoc_label_stack)); if (YYCURSOR > YYLIMIT) { - return 0; + RETURN_TOKEN(END); } YYCURSOR--; @@ -7267,9 +7290,9 @@ nowdoc_scan_done: zend_copy_value(zendlval, yytext, yyleng - newline); HANDLE_NEWLINES(yytext, yyleng - newline); - return T_ENCAPSED_AND_WHITESPACE; + RETURN_TOKEN(T_ENCAPSED_AND_WHITESPACE); } -#line 7273 "Zend/zend_language_scanner.c" +#line 7296 "Zend/zend_language_scanner.c" /* *********************************** */ yyc_ST_VAR_OFFSET: { @@ -7376,7 +7399,7 @@ yy800: yy801: YYDEBUG(801, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1699 "Zend/zend_language_scanner.l" +#line 1722 "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)) { char *end; @@ -7390,9 +7413,9 @@ yy801: string: ZVAL_STRINGL(zendlval, yytext, yyleng); } - return T_NUM_STRING; + RETURN_TOKEN(T_NUM_STRING); } -#line 7396 "Zend/zend_language_scanner.c" +#line 7419 "Zend/zend_language_scanner.c" yy802: YYDEBUG(802, *YYCURSOR); yych = *++YYCURSOR; @@ -7412,23 +7435,23 @@ yy803: yy804: YYDEBUG(804, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1859 "Zend/zend_language_scanner.l" +#line 1882 "Zend/zend_language_scanner.l" { /* Only '[' can be valid, but returning other tokens will allow a more explicit parse error */ - return yytext[0]; + RETURN_TOKEN(yytext[0]); } -#line 7421 "Zend/zend_language_scanner.c" +#line 7444 "Zend/zend_language_scanner.c" yy805: YYDEBUG(805, *YYCURSOR); ++YYCURSOR; YYDEBUG(806, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1854 "Zend/zend_language_scanner.l" +#line 1877 "Zend/zend_language_scanner.l" { yy_pop_state(); - return ']'; + RETURN_TOKEN(']'); } -#line 7432 "Zend/zend_language_scanner.c" +#line 7455 "Zend/zend_language_scanner.c" yy807: YYDEBUG(807, *YYCURSOR); yych = *++YYCURSOR; @@ -7438,15 +7461,15 @@ yy808: ++YYCURSOR; YYDEBUG(809, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1864 "Zend/zend_language_scanner.l" +#line 1887 "Zend/zend_language_scanner.l" { /* Invalid rule to return a more explicit parse error with proper line number */ yyless(0); yy_pop_state(); ZVAL_NULL(zendlval); - return T_ENCAPSED_AND_WHITESPACE; + RETURN_TOKEN(T_ENCAPSED_AND_WHITESPACE); } -#line 7450 "Zend/zend_language_scanner.c" +#line 7473 "Zend/zend_language_scanner.c" yy810: YYDEBUG(810, *YYCURSOR); ++YYCURSOR; @@ -7455,27 +7478,27 @@ yy810: yy811: YYDEBUG(811, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1872 "Zend/zend_language_scanner.l" +#line 1895 "Zend/zend_language_scanner.l" { zend_copy_value(zendlval, yytext, yyleng); - return T_STRING; + RETURN_TOKEN(T_STRING); } -#line 7464 "Zend/zend_language_scanner.c" +#line 7487 "Zend/zend_language_scanner.c" yy812: YYDEBUG(812, *YYCURSOR); ++YYCURSOR; YYDEBUG(813, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 2375 "Zend/zend_language_scanner.l" +#line 2398 "Zend/zend_language_scanner.l" { if (YYCURSOR > YYLIMIT) { - return 0; + RETURN_TOKEN(END); } zend_error(E_COMPILE_WARNING,"Unexpected character in input: '%c' (ASCII=%d) state=%d", yytext[0], yytext[0], YYSTATE); goto restart; } -#line 7479 "Zend/zend_language_scanner.c" +#line 7502 "Zend/zend_language_scanner.c" yy814: YYDEBUG(814, *YYCURSOR); ++YYCURSOR; @@ -7511,12 +7534,12 @@ yy816: yy818: YYDEBUG(818, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1849 "Zend/zend_language_scanner.l" +#line 1872 "Zend/zend_language_scanner.l" { zend_copy_value(zendlval, (yytext+1), (yyleng-1)); - return T_VARIABLE; + RETURN_TOKEN(T_VARIABLE); } -#line 7520 "Zend/zend_language_scanner.c" +#line 7543 "Zend/zend_language_scanner.c" yy819: YYDEBUG(819, *YYCURSOR); ++YYCURSOR; @@ -7556,12 +7579,12 @@ yy824: yy826: YYDEBUG(826, *YYCURSOR); yyleng = YYCURSOR - SCNG(yy_text); -#line 1715 "Zend/zend_language_scanner.l" +#line 1738 "Zend/zend_language_scanner.l" { /* Offset must be treated as a string */ ZVAL_STRINGL(zendlval, yytext, yyleng); - return T_NUM_STRING; + RETURN_TOKEN(T_NUM_STRING); } -#line 7565 "Zend/zend_language_scanner.c" +#line 7588 "Zend/zend_language_scanner.c" yy827: YYDEBUG(827, *YYCURSOR); ++YYCURSOR; @@ -7584,6 +7607,6 @@ yy829: goto yy826; } } -#line 2384 "Zend/zend_language_scanner.l" +#line 2407 "Zend/zend_language_scanner.l" } diff --git a/Zend/zend_language_scanner.h b/Zend/zend_language_scanner.h index c82b3069c5..3b75ff8cc4 100644 --- a/Zend/zend_language_scanner.h +++ b/Zend/zend_language_scanner.h @@ -50,6 +50,9 @@ typedef struct _zend_lex_state { zend_encoding_filter output_filter; const zend_encoding *script_encoding; + /* hooks */ + void (* on_event)(zend_php_scanner_event event, int token, int line); + zend_ast *ast; zend_arena *ast_arena; } zend_lex_state; @@ -66,6 +69,7 @@ ZEND_API void zend_restore_lexical_state(zend_lex_state *lex_state); ZEND_API int zend_prepare_string_for_scanning(zval *str, char *filename); ZEND_API void zend_multibyte_yyinput_again(zend_encoding_filter old_input_filter, const zend_encoding *old_encoding); ZEND_API int zend_multibyte_set_filter(const zend_encoding *onetime_encoding); +ZEND_API void zend_lex_tstring(zval *zv); END_EXTERN_C() diff --git a/Zend/zend_language_scanner.l b/Zend/zend_language_scanner.l index fdba4b9f07..cde0621df0 100644 --- a/Zend/zend_language_scanner.l +++ b/Zend/zend_language_scanner.l @@ -193,6 +193,7 @@ void shutdown_scanner(void) zend_stack_destroy(&SCNG(state_stack)); zend_ptr_stack_clean(&SCNG(heredoc_label_stack), (void (*)(void *)) &heredoc_label_dtor, 1); zend_ptr_stack_destroy(&SCNG(heredoc_label_stack)); + SCNG(on_event) = NULL; } ZEND_API void zend_save_lexical_state(zend_lex_state *lex_state) @@ -223,6 +224,8 @@ ZEND_API void zend_save_lexical_state(zend_lex_state *lex_state) lex_state->output_filter = SCNG(output_filter); lex_state->script_encoding = SCNG(script_encoding); + lex_state->on_event = SCNG(on_event); + lex_state->ast = CG(ast); lex_state->ast_arena = CG(ast_arena); } @@ -260,6 +263,8 @@ ZEND_API void zend_restore_lexical_state(zend_lex_state *lex_state) SCNG(output_filter) = lex_state->output_filter; SCNG(script_encoding) = lex_state->script_encoding; + SCNG(on_event) = lex_state->on_event; + CG(ast) = lex_state->ast; CG(ast_arena) = lex_state->ast_arena; @@ -276,6 +281,13 @@ ZEND_API void zend_destroy_file_handle(zend_file_handle *file_handle) } } +ZEND_API void zend_lex_tstring(zval *zv) +{ + if (SCNG(on_event)) SCNG(on_event)(ON_FEEDBACK, T_STRING, 0); + + ZVAL_STRINGL(zv, (char*)SCNG(yy_text), SCNG(yy_leng)); +} + #define BOM_UTF32_BE "\x00\x00\xfe\xff" #define BOM_UTF32_LE "\xff\xfe\x00\x00" #define BOM_UTF16_BE "\xfe\xff" @@ -1083,9 +1095,20 @@ static int zend_scan_escape_string(zval *zendlval, char *str, int len, char quot return SUCCESS; } +static zend_always_inline int emit_token(int token, int token_line) +{ + if(SCNG(on_event)) SCNG(on_event)(ON_TOKEN, token, token_line); + + return token; +} + +#define RETURN_TOKEN(token) return emit_token(token, start_line); int lex_scan(zval *zendlval) { + +int start_line = CG(zend_lineno); + restart: SCNG(yy_text) = YYCURSOR; @@ -1107,183 +1130,183 @@ NEWLINE ("\r"|"\n"|"\r\n") <!*> := yyleng = YYCURSOR - SCNG(yy_text); <ST_IN_SCRIPTING>"exit" { - return T_EXIT; + RETURN_TOKEN(T_EXIT); } <ST_IN_SCRIPTING>"die" { - return T_EXIT; + RETURN_TOKEN(T_EXIT); } <ST_IN_SCRIPTING>"function" { - return T_FUNCTION; + RETURN_TOKEN(T_FUNCTION); } <ST_IN_SCRIPTING>"const" { - return T_CONST; + RETURN_TOKEN(T_CONST); } <ST_IN_SCRIPTING>"return" { - return T_RETURN; + RETURN_TOKEN(T_RETURN); } <ST_IN_SCRIPTING>"yield"{WHITESPACE}"from" { - return T_YIELD_FROM; + RETURN_TOKEN(T_YIELD_FROM); } <ST_IN_SCRIPTING>"yield" { - return T_YIELD; + RETURN_TOKEN(T_YIELD); } <ST_IN_SCRIPTING>"try" { - return T_TRY; + RETURN_TOKEN(T_TRY); } <ST_IN_SCRIPTING>"catch" { - return T_CATCH; + RETURN_TOKEN(T_CATCH); } <ST_IN_SCRIPTING>"finally" { - return T_FINALLY; + RETURN_TOKEN(T_FINALLY); } <ST_IN_SCRIPTING>"throw" { - return T_THROW; + RETURN_TOKEN(T_THROW); } <ST_IN_SCRIPTING>"if" { - return T_IF; + RETURN_TOKEN(T_IF); } <ST_IN_SCRIPTING>"elseif" { - return T_ELSEIF; + RETURN_TOKEN(T_ELSEIF); } <ST_IN_SCRIPTING>"endif" { - return T_ENDIF; + RETURN_TOKEN(T_ENDIF); } <ST_IN_SCRIPTING>"else" { - return T_ELSE; + RETURN_TOKEN(T_ELSE); } <ST_IN_SCRIPTING>"while" { - return T_WHILE; + RETURN_TOKEN(T_WHILE); } <ST_IN_SCRIPTING>"endwhile" { - return T_ENDWHILE; + RETURN_TOKEN(T_ENDWHILE); } <ST_IN_SCRIPTING>"do" { - return T_DO; + RETURN_TOKEN(T_DO); } <ST_IN_SCRIPTING>"for" { - return T_FOR; + RETURN_TOKEN(T_FOR); } <ST_IN_SCRIPTING>"endfor" { - return T_ENDFOR; + RETURN_TOKEN(T_ENDFOR); } <ST_IN_SCRIPTING>"foreach" { - return T_FOREACH; + RETURN_TOKEN(T_FOREACH); } <ST_IN_SCRIPTING>"endforeach" { - return T_ENDFOREACH; + RETURN_TOKEN(T_ENDFOREACH); } <ST_IN_SCRIPTING>"declare" { - return T_DECLARE; + RETURN_TOKEN(T_DECLARE); } <ST_IN_SCRIPTING>"enddeclare" { - return T_ENDDECLARE; + RETURN_TOKEN(T_ENDDECLARE); } <ST_IN_SCRIPTING>"instanceof" { - return T_INSTANCEOF; + RETURN_TOKEN(T_INSTANCEOF); } <ST_IN_SCRIPTING>"as" { - return T_AS; + RETURN_TOKEN(T_AS); } <ST_IN_SCRIPTING>"switch" { - return T_SWITCH; + RETURN_TOKEN(T_SWITCH); } <ST_IN_SCRIPTING>"endswitch" { - return T_ENDSWITCH; + RETURN_TOKEN(T_ENDSWITCH); } <ST_IN_SCRIPTING>"case" { - return T_CASE; + RETURN_TOKEN(T_CASE); } <ST_IN_SCRIPTING>"default" { - return T_DEFAULT; + RETURN_TOKEN(T_DEFAULT); } <ST_IN_SCRIPTING>"break" { - return T_BREAK; + RETURN_TOKEN(T_BREAK); } <ST_IN_SCRIPTING>"continue" { - return T_CONTINUE; + RETURN_TOKEN(T_CONTINUE); } <ST_IN_SCRIPTING>"goto" { - return T_GOTO; + RETURN_TOKEN(T_GOTO); } <ST_IN_SCRIPTING>"echo" { - return T_ECHO; + RETURN_TOKEN(T_ECHO); } <ST_IN_SCRIPTING>"print" { - return T_PRINT; + RETURN_TOKEN(T_PRINT); } <ST_IN_SCRIPTING>"class" { - return T_CLASS; + RETURN_TOKEN(T_CLASS); } <ST_IN_SCRIPTING>"interface" { - return T_INTERFACE; + RETURN_TOKEN(T_INTERFACE); } <ST_IN_SCRIPTING>"trait" { - return T_TRAIT; + RETURN_TOKEN(T_TRAIT); } <ST_IN_SCRIPTING>"extends" { - return T_EXTENDS; + RETURN_TOKEN(T_EXTENDS); } <ST_IN_SCRIPTING>"implements" { - return T_IMPLEMENTS; + RETURN_TOKEN(T_IMPLEMENTS); } <ST_IN_SCRIPTING>"->" { yy_push_state(ST_LOOKING_FOR_PROPERTY); - return T_OBJECT_OPERATOR; + RETURN_TOKEN(T_OBJECT_OPERATOR); } <ST_IN_SCRIPTING,ST_LOOKING_FOR_PROPERTY>{WHITESPACE}+ { HANDLE_NEWLINES(yytext, yyleng); - return T_WHITESPACE; + RETURN_TOKEN(T_WHITESPACE); } <ST_LOOKING_FOR_PROPERTY>"->" { - return T_OBJECT_OPERATOR; + RETURN_TOKEN(T_OBJECT_OPERATOR); } <ST_LOOKING_FOR_PROPERTY>{LABEL} { yy_pop_state(); zend_copy_value(zendlval, yytext, yyleng); - return T_STRING; + RETURN_TOKEN(T_STRING); } <ST_LOOKING_FOR_PROPERTY>{ANY_CHAR} { @@ -1293,283 +1316,283 @@ NEWLINE ("\r"|"\n"|"\r\n") } <ST_IN_SCRIPTING>"::" { - return T_PAAMAYIM_NEKUDOTAYIM; + RETURN_TOKEN(T_PAAMAYIM_NEKUDOTAYIM); } <ST_IN_SCRIPTING>"\\" { - return T_NS_SEPARATOR; + RETURN_TOKEN(T_NS_SEPARATOR); } <ST_IN_SCRIPTING>"..." { - return T_ELLIPSIS; + RETURN_TOKEN(T_ELLIPSIS); } <ST_IN_SCRIPTING>"??" { - return T_COALESCE; + RETURN_TOKEN(T_COALESCE); } <ST_IN_SCRIPTING>"new" { - return T_NEW; + RETURN_TOKEN(T_NEW); } <ST_IN_SCRIPTING>"clone" { - return T_CLONE; + RETURN_TOKEN(T_CLONE); } <ST_IN_SCRIPTING>"var" { - return T_VAR; + RETURN_TOKEN(T_VAR); } <ST_IN_SCRIPTING>"("{TABS_AND_SPACES}("int"|"integer"){TABS_AND_SPACES}")" { - return T_INT_CAST; + RETURN_TOKEN(T_INT_CAST); } <ST_IN_SCRIPTING>"("{TABS_AND_SPACES}("real"|"double"|"float"){TABS_AND_SPACES}")" { - return T_DOUBLE_CAST; + RETURN_TOKEN(T_DOUBLE_CAST); } <ST_IN_SCRIPTING>"("{TABS_AND_SPACES}("string"|"binary"){TABS_AND_SPACES}")" { - return T_STRING_CAST; + RETURN_TOKEN(T_STRING_CAST); } <ST_IN_SCRIPTING>"("{TABS_AND_SPACES}"array"{TABS_AND_SPACES}")" { - return T_ARRAY_CAST; + RETURN_TOKEN(T_ARRAY_CAST); } <ST_IN_SCRIPTING>"("{TABS_AND_SPACES}"object"{TABS_AND_SPACES}")" { - return T_OBJECT_CAST; + RETURN_TOKEN(T_OBJECT_CAST); } <ST_IN_SCRIPTING>"("{TABS_AND_SPACES}("bool"|"boolean"){TABS_AND_SPACES}")" { - return T_BOOL_CAST; + RETURN_TOKEN(T_BOOL_CAST); } <ST_IN_SCRIPTING>"("{TABS_AND_SPACES}("unset"){TABS_AND_SPACES}")" { - return T_UNSET_CAST; + RETURN_TOKEN(T_UNSET_CAST); } <ST_IN_SCRIPTING>"eval" { - return T_EVAL; + RETURN_TOKEN(T_EVAL); } <ST_IN_SCRIPTING>"include" { - return T_INCLUDE; + RETURN_TOKEN(T_INCLUDE); } <ST_IN_SCRIPTING>"include_once" { - return T_INCLUDE_ONCE; + RETURN_TOKEN(T_INCLUDE_ONCE); } <ST_IN_SCRIPTING>"require" { - return T_REQUIRE; + RETURN_TOKEN(T_REQUIRE); } <ST_IN_SCRIPTING>"require_once" { - return T_REQUIRE_ONCE; + RETURN_TOKEN(T_REQUIRE_ONCE); } <ST_IN_SCRIPTING>"namespace" { - return T_NAMESPACE; + RETURN_TOKEN(T_NAMESPACE); } <ST_IN_SCRIPTING>"use" { - return T_USE; + RETURN_TOKEN(T_USE); } <ST_IN_SCRIPTING>"insteadof" { - return T_INSTEADOF; + RETURN_TOKEN(T_INSTEADOF); } <ST_IN_SCRIPTING>"global" { - return T_GLOBAL; + RETURN_TOKEN(T_GLOBAL); } <ST_IN_SCRIPTING>"isset" { - return T_ISSET; + RETURN_TOKEN(T_ISSET); } <ST_IN_SCRIPTING>"empty" { - return T_EMPTY; + RETURN_TOKEN(T_EMPTY); } <ST_IN_SCRIPTING>"__halt_compiler" { - return T_HALT_COMPILER; + RETURN_TOKEN(T_HALT_COMPILER); } <ST_IN_SCRIPTING>"static" { - return T_STATIC; + RETURN_TOKEN(T_STATIC); } <ST_IN_SCRIPTING>"abstract" { - return T_ABSTRACT; + RETURN_TOKEN(T_ABSTRACT); } <ST_IN_SCRIPTING>"final" { - return T_FINAL; + RETURN_TOKEN(T_FINAL); } <ST_IN_SCRIPTING>"private" { - return T_PRIVATE; + RETURN_TOKEN(T_PRIVATE); } <ST_IN_SCRIPTING>"protected" { - return T_PROTECTED; + RETURN_TOKEN(T_PROTECTED); } <ST_IN_SCRIPTING>"public" { - return T_PUBLIC; + RETURN_TOKEN(T_PUBLIC); } <ST_IN_SCRIPTING>"unset" { - return T_UNSET; + RETURN_TOKEN(T_UNSET); } <ST_IN_SCRIPTING>"=>" { - return T_DOUBLE_ARROW; + RETURN_TOKEN(T_DOUBLE_ARROW); } <ST_IN_SCRIPTING>"list" { - return T_LIST; + RETURN_TOKEN(T_LIST); } <ST_IN_SCRIPTING>"array" { - return T_ARRAY; + RETURN_TOKEN(T_ARRAY); } <ST_IN_SCRIPTING>"callable" { - return T_CALLABLE; + RETURN_TOKEN(T_CALLABLE); } <ST_IN_SCRIPTING>"++" { - return T_INC; + RETURN_TOKEN(T_INC); } <ST_IN_SCRIPTING>"--" { - return T_DEC; + RETURN_TOKEN(T_DEC); } <ST_IN_SCRIPTING>"===" { - return T_IS_IDENTICAL; + RETURN_TOKEN(T_IS_IDENTICAL); } <ST_IN_SCRIPTING>"!==" { - return T_IS_NOT_IDENTICAL; + RETURN_TOKEN(T_IS_NOT_IDENTICAL); } <ST_IN_SCRIPTING>"==" { - return T_IS_EQUAL; + RETURN_TOKEN(T_IS_EQUAL); } <ST_IN_SCRIPTING>"!="|"<>" { - return T_IS_NOT_EQUAL; + RETURN_TOKEN(T_IS_NOT_EQUAL); } <ST_IN_SCRIPTING>"<=>" { - return T_SPACESHIP; + RETURN_TOKEN(T_SPACESHIP); } <ST_IN_SCRIPTING>"<=" { - return T_IS_SMALLER_OR_EQUAL; + RETURN_TOKEN(T_IS_SMALLER_OR_EQUAL); } <ST_IN_SCRIPTING>">=" { - return T_IS_GREATER_OR_EQUAL; + RETURN_TOKEN(T_IS_GREATER_OR_EQUAL); } <ST_IN_SCRIPTING>"+=" { - return T_PLUS_EQUAL; + RETURN_TOKEN(T_PLUS_EQUAL); } <ST_IN_SCRIPTING>"-=" { - return T_MINUS_EQUAL; + RETURN_TOKEN(T_MINUS_EQUAL); } <ST_IN_SCRIPTING>"*=" { - return T_MUL_EQUAL; + RETURN_TOKEN(T_MUL_EQUAL); } <ST_IN_SCRIPTING>"*\*" { - return T_POW; + RETURN_TOKEN(T_POW); } <ST_IN_SCRIPTING>"*\*=" { - return T_POW_EQUAL; + RETURN_TOKEN(T_POW_EQUAL); } <ST_IN_SCRIPTING>"/=" { - return T_DIV_EQUAL; + RETURN_TOKEN(T_DIV_EQUAL); } <ST_IN_SCRIPTING>".=" { - return T_CONCAT_EQUAL; + RETURN_TOKEN(T_CONCAT_EQUAL); } <ST_IN_SCRIPTING>"%=" { - return T_MOD_EQUAL; + RETURN_TOKEN(T_MOD_EQUAL); } <ST_IN_SCRIPTING>"<<=" { - return T_SL_EQUAL; + RETURN_TOKEN(T_SL_EQUAL); } <ST_IN_SCRIPTING>">>=" { - return T_SR_EQUAL; + RETURN_TOKEN(T_SR_EQUAL); } <ST_IN_SCRIPTING>"&=" { - return T_AND_EQUAL; + RETURN_TOKEN(T_AND_EQUAL); } <ST_IN_SCRIPTING>"|=" { - return T_OR_EQUAL; + RETURN_TOKEN(T_OR_EQUAL); } <ST_IN_SCRIPTING>"^=" { - return T_XOR_EQUAL; + RETURN_TOKEN(T_XOR_EQUAL); } <ST_IN_SCRIPTING>"||" { - return T_BOOLEAN_OR; + RETURN_TOKEN(T_BOOLEAN_OR); } <ST_IN_SCRIPTING>"&&" { - return T_BOOLEAN_AND; + RETURN_TOKEN(T_BOOLEAN_AND); } <ST_IN_SCRIPTING>"OR" { - return T_LOGICAL_OR; + RETURN_TOKEN(T_LOGICAL_OR); } <ST_IN_SCRIPTING>"AND" { - return T_LOGICAL_AND; + RETURN_TOKEN(T_LOGICAL_AND); } <ST_IN_SCRIPTING>"XOR" { - return T_LOGICAL_XOR; + RETURN_TOKEN(T_LOGICAL_XOR); } <ST_IN_SCRIPTING>"<<" { - return T_SL; + RETURN_TOKEN(T_SL); } <ST_IN_SCRIPTING>">>" { - return T_SR; + RETURN_TOKEN(T_SR); } <ST_IN_SCRIPTING>{TOKENS} { - return yytext[0]; + RETURN_TOKEN(yytext[0]); } <ST_IN_SCRIPTING>"{" { yy_push_state(ST_IN_SCRIPTING); - return '{'; + RETURN_TOKEN('{'); } <ST_DOUBLE_QUOTES,ST_BACKQUOTE,ST_HEREDOC>"${" { yy_push_state(ST_LOOKING_FOR_VARNAME); - return T_DOLLAR_OPEN_CURLY_BRACES; + RETURN_TOKEN(T_DOLLAR_OPEN_CURLY_BRACES); } @@ -1578,7 +1601,7 @@ NEWLINE ("\r"|"\n"|"\r\n") if (!zend_stack_is_empty(&SCNG(state_stack))) { yy_pop_state(); } - return '}'; + RETURN_TOKEN('}'); } @@ -1587,7 +1610,7 @@ NEWLINE ("\r"|"\n"|"\r\n") zend_copy_value(zendlval, yytext, yyleng); yy_pop_state(); yy_push_state(ST_IN_SCRIPTING); - return T_STRING_VARNAME; + RETURN_TOKEN(T_STRING_VARNAME); } @@ -1617,12 +1640,12 @@ NEWLINE ("\r"|"\n"|"\r\n") ZVAL_LONG(zendlval, ZEND_STRTOL(bin, &end, 2)); ZEND_ASSERT(!errno && end == yytext + yyleng); } - return T_LNUMBER; + RETURN_TOKEN(T_LNUMBER); } else { ZVAL_DOUBLE(zendlval, zend_bin_strtod(bin, (const char **)&end)); /* errno isn't checked since we allow HUGE_VAL/INF overflow */ ZEND_ASSERT(end == yytext + yyleng); - return T_DNUMBER; + RETURN_TOKEN(T_DNUMBER); } } @@ -1636,7 +1659,7 @@ NEWLINE ("\r"|"\n"|"\r\n") */ if (end != yytext + yyleng) { zend_throw_exception(zend_get_parse_exception(), "Invalid numeric literal", E_PARSE); - return T_ERROR; + RETURN_TOKEN(T_ERROR); } } else { errno = 0; @@ -1653,19 +1676,19 @@ NEWLINE ("\r"|"\n"|"\r\n") if (end != yytext + yyleng) { zend_throw_exception(zend_get_parse_exception(), "Invalid numeric literal", E_PARSE); - return T_ERROR; + RETURN_TOKEN(T_ERROR); } ZEND_ASSERT(!errno); - return T_DNUMBER; + RETURN_TOKEN(T_DNUMBER); } /* Also not an assert for the same reason */ if (end != yytext + yyleng) { zend_throw_exception(zend_get_parse_exception(), "Invalid numeric literal", E_PARSE); - return T_ERROR; + RETURN_TOKEN(T_ERROR); } } ZEND_ASSERT(!errno); - return T_LNUMBER; + RETURN_TOKEN(T_LNUMBER); } <ST_IN_SCRIPTING>{HNUM} { @@ -1687,12 +1710,12 @@ NEWLINE ("\r"|"\n"|"\r\n") ZVAL_LONG(zendlval, ZEND_STRTOL(hex, &end, 16)); ZEND_ASSERT(!errno && end == hex + len); } - return T_LNUMBER; + RETURN_TOKEN(T_LNUMBER); } else { ZVAL_DOUBLE(zendlval, zend_hex_strtod(hex, (const char **)&end)); /* errno isn't checked since we allow HUGE_VAL/INF overflow */ ZEND_ASSERT(end == hex + len); - return T_DNUMBER; + RETURN_TOKEN(T_DNUMBER); } } @@ -1709,12 +1732,12 @@ NEWLINE ("\r"|"\n"|"\r\n") string: ZVAL_STRINGL(zendlval, yytext, yyleng); } - return T_NUM_STRING; + RETURN_TOKEN(T_NUM_STRING); } <ST_VAR_OFFSET>{LNUM}|{HNUM}|{BNUM} { /* Offset must be treated as a string */ ZVAL_STRINGL(zendlval, yytext, yyleng); - return T_NUM_STRING; + RETURN_TOKEN(T_NUM_STRING); } <ST_IN_SCRIPTING>{DNUM}|{EXPONENT_DNUM} { @@ -1723,59 +1746,59 @@ string: ZVAL_DOUBLE(zendlval, zend_strtod(yytext, &end)); /* errno isn't checked since we allow HUGE_VAL/INF overflow */ ZEND_ASSERT(end == yytext + yyleng); - return T_DNUMBER; + RETURN_TOKEN(T_DNUMBER); } <ST_IN_SCRIPTING>"__CLASS__" { - return T_CLASS_C; + RETURN_TOKEN(T_CLASS_C); } <ST_IN_SCRIPTING>"__TRAIT__" { - return T_TRAIT_C; + RETURN_TOKEN(T_TRAIT_C); } <ST_IN_SCRIPTING>"__FUNCTION__" { - return T_FUNC_C; + RETURN_TOKEN(T_FUNC_C); } <ST_IN_SCRIPTING>"__METHOD__" { - return T_METHOD_C; + RETURN_TOKEN(T_METHOD_C); } <ST_IN_SCRIPTING>"__LINE__" { - return T_LINE; + RETURN_TOKEN(T_LINE); } <ST_IN_SCRIPTING>"__FILE__" { - return T_FILE; + RETURN_TOKEN(T_FILE); } <ST_IN_SCRIPTING>"__DIR__" { - return T_DIR; + RETURN_TOKEN(T_DIR); } <ST_IN_SCRIPTING>"__NAMESPACE__" { - return T_NS_C; + RETURN_TOKEN(T_NS_C); } <INITIAL>"<?=" { BEGIN(ST_IN_SCRIPTING); - return T_OPEN_TAG_WITH_ECHO; + RETURN_TOKEN(T_OPEN_TAG_WITH_ECHO); } <INITIAL>"<?php"([ \t]|{NEWLINE}) { HANDLE_NEWLINE(yytext[yyleng-1]); BEGIN(ST_IN_SCRIPTING); - return T_OPEN_TAG; + RETURN_TOKEN(T_OPEN_TAG); } <INITIAL>"<?" { if (CG(short_tags)) { BEGIN(ST_IN_SCRIPTING); - return T_OPEN_TAG; + RETURN_TOKEN(T_OPEN_TAG); } else { goto inline_char_handler; } @@ -1783,7 +1806,7 @@ string: <INITIAL>{ANY_CHAR} { if (YYCURSOR > YYLIMIT) { - return 0; + RETURN_TOKEN(END); } inline_char_handler: @@ -1823,7 +1846,7 @@ inline_char_handler: ZVAL_STRINGL(zendlval, yytext, yyleng); } HANDLE_NEWLINES(yytext, yyleng); - return T_INLINE_HTML; + RETURN_TOKEN(T_INLINE_HTML); } @@ -1834,7 +1857,7 @@ inline_char_handler: yyless(yyleng - 3); yy_push_state(ST_LOOKING_FOR_PROPERTY); zend_copy_value(zendlval, (yytext+1), (yyleng-1)); - return T_VARIABLE; + RETURN_TOKEN(T_VARIABLE); } /* A [ always designates a variable offset, regardless of what follows @@ -1843,22 +1866,22 @@ inline_char_handler: yyless(yyleng - 1); yy_push_state(ST_VAR_OFFSET); zend_copy_value(zendlval, (yytext+1), (yyleng-1)); - return T_VARIABLE; + RETURN_TOKEN(T_VARIABLE); } <ST_IN_SCRIPTING,ST_DOUBLE_QUOTES,ST_HEREDOC,ST_BACKQUOTE,ST_VAR_OFFSET>"$"{LABEL} { zend_copy_value(zendlval, (yytext+1), (yyleng-1)); - return T_VARIABLE; + RETURN_TOKEN(T_VARIABLE); } <ST_VAR_OFFSET>"]" { yy_pop_state(); - return ']'; + RETURN_TOKEN(']'); } <ST_VAR_OFFSET>{TOKENS}|[{}"`] { /* Only '[' can be valid, but returning other tokens will allow a more explicit parse error */ - return yytext[0]; + RETURN_TOKEN(yytext[0]); } <ST_VAR_OFFSET>[ \n\r\t\\'#] { @@ -1866,12 +1889,12 @@ inline_char_handler: yyless(0); yy_pop_state(); ZVAL_NULL(zendlval); - return T_ENCAPSED_AND_WHITESPACE; + RETURN_TOKEN(T_ENCAPSED_AND_WHITESPACE); } <ST_IN_SCRIPTING,ST_VAR_OFFSET>{LABEL} { zend_copy_value(zendlval, yytext, yyleng); - return T_STRING; + RETURN_TOKEN(T_STRING); } @@ -1901,7 +1924,7 @@ inline_char_handler: yyleng = YYCURSOR - SCNG(yy_text); - return T_COMMENT; + RETURN_TOKEN(T_COMMENT); } <ST_IN_SCRIPTING>"/*"|"/**"{WHITESPACE} { @@ -1931,15 +1954,15 @@ inline_char_handler: if (doc_com) { CG(doc_comment) = zend_string_init(yytext, yyleng, 0); - return T_DOC_COMMENT; + RETURN_TOKEN(T_DOC_COMMENT); } - return T_COMMENT; + RETURN_TOKEN(T_COMMENT); } <ST_IN_SCRIPTING>"?>"{NEWLINE}? { BEGIN(INITIAL); - return T_CLOSE_TAG; /* implicit ';' at php-end tag */ + RETURN_TOKEN(T_CLOSE_TAG); /* implicit ';' at php-end tag */ } @@ -1965,7 +1988,7 @@ inline_char_handler: * for ' (unrecognized by parser), instead of old flex fallback to "Unexpected character..." * rule, which continued in ST_IN_SCRIPTING state after the quote */ ZVAL_NULL(zendlval); - return T_ENCAPSED_AND_WHITESPACE; + RETURN_TOKEN(T_ENCAPSED_AND_WHITESPACE); } } @@ -2008,7 +2031,7 @@ inline_char_handler: SCNG(output_filter)((unsigned char **)&str, &sz, (unsigned char *)s, (size_t)Z_STRLEN_P(zendlval)); ZVAL_STRINGL(zendlval, str, sz); } - return T_CONSTANT_ENCAPSED_STRING; + RETURN_TOKEN(T_CONSTANT_ENCAPSED_STRING); } @@ -2020,9 +2043,9 @@ inline_char_handler: case '"': yyleng = YYCURSOR - SCNG(yy_text); if (zend_scan_escape_string(zendlval, yytext+bprefix+1, yyleng-bprefix-2, '"') == FAILURE) { - return T_ERROR; + RETURN_TOKEN(T_ERROR); } - return T_CONSTANT_ENCAPSED_STRING; + RETURN_TOKEN(T_CONSTANT_ENCAPSED_STRING); case '$': if (IS_LABEL_START(*YYCURSOR) || *YYCURSOR == '{') { break; @@ -2052,7 +2075,7 @@ inline_char_handler: YYCURSOR = SCNG(yy_text) + yyleng; BEGIN(ST_DOUBLE_QUOTES); - return '"'; + RETURN_TOKEN('"'); } @@ -2100,13 +2123,13 @@ inline_char_handler: zend_ptr_stack_push(&SCNG(heredoc_label_stack), (void *) heredoc_label); - return T_START_HEREDOC; + RETURN_TOKEN(T_START_HEREDOC); } <ST_IN_SCRIPTING>[`] { BEGIN(ST_BACKQUOTE); - return '`'; + RETURN_TOKEN('`'); } @@ -2120,7 +2143,7 @@ inline_char_handler: efree(heredoc_label); BEGIN(ST_IN_SCRIPTING); - return T_END_HEREDOC; + RETURN_TOKEN(T_END_HEREDOC); } @@ -2128,18 +2151,18 @@ inline_char_handler: Z_LVAL_P(zendlval) = (zend_long) '{'; yy_push_state(ST_IN_SCRIPTING); yyless(1); - return T_CURLY_OPEN; + RETURN_TOKEN(T_CURLY_OPEN); } <ST_DOUBLE_QUOTES>["] { BEGIN(ST_IN_SCRIPTING); - return '"'; + RETURN_TOKEN('"'); } <ST_BACKQUOTE>[`] { BEGIN(ST_IN_SCRIPTING); - return '`'; + RETURN_TOKEN('`'); } @@ -2152,7 +2175,7 @@ inline_char_handler: } if (YYCURSOR > YYLIMIT) { - return 0; + RETURN_TOKEN(END); } if (yytext[0] == '\\' && YYCURSOR < YYLIMIT) { YYCURSOR++; @@ -2189,15 +2212,15 @@ double_quotes_scan_done: yyleng = YYCURSOR - SCNG(yy_text); if (zend_scan_escape_string(zendlval, yytext, yyleng, '"') == FAILURE) { - return T_ERROR; + RETURN_TOKEN(T_ERROR); } - return T_ENCAPSED_AND_WHITESPACE; + RETURN_TOKEN(T_ENCAPSED_AND_WHITESPACE); } <ST_BACKQUOTE>{ANY_CHAR} { if (YYCURSOR > YYLIMIT) { - return 0; + RETURN_TOKEN(END); } if (yytext[0] == '\\' && YYCURSOR < YYLIMIT) { YYCURSOR++; @@ -2233,9 +2256,9 @@ double_quotes_scan_done: yyleng = YYCURSOR - SCNG(yy_text); if (zend_scan_escape_string(zendlval, yytext, yyleng, '`') == FAILURE) { - return T_ERROR; + RETURN_TOKEN(T_ERROR); } - return T_ENCAPSED_AND_WHITESPACE; + RETURN_TOKEN(T_ENCAPSED_AND_WHITESPACE); } @@ -2245,7 +2268,7 @@ double_quotes_scan_done: zend_heredoc_label *heredoc_label = zend_ptr_stack_top(&SCNG(heredoc_label_stack)); if (YYCURSOR > YYLIMIT) { - return 0; + RETURN_TOKEN(END); } YYCURSOR--; @@ -2309,9 +2332,9 @@ heredoc_scan_done: yyleng = YYCURSOR - SCNG(yy_text); if (zend_scan_escape_string(zendlval, yytext, yyleng - newline, 0) == FAILURE) { - return T_ERROR; + RETURN_TOKEN(T_ERROR); } - return T_ENCAPSED_AND_WHITESPACE; + RETURN_TOKEN(T_ENCAPSED_AND_WHITESPACE); } @@ -2321,7 +2344,7 @@ heredoc_scan_done: zend_heredoc_label *heredoc_label = zend_ptr_stack_top(&SCNG(heredoc_label_stack)); if (YYCURSOR > YYLIMIT) { - return 0; + RETURN_TOKEN(END); } YYCURSOR--; @@ -2368,13 +2391,13 @@ nowdoc_scan_done: zend_copy_value(zendlval, yytext, yyleng - newline); HANDLE_NEWLINES(yytext, yyleng - newline); - return T_ENCAPSED_AND_WHITESPACE; + RETURN_TOKEN(T_ENCAPSED_AND_WHITESPACE); } <ST_IN_SCRIPTING,ST_VAR_OFFSET>{ANY_CHAR} { if (YYCURSOR > YYLIMIT) { - return 0; + RETURN_TOKEN(END); } zend_error(E_COMPILE_WARNING,"Unexpected character in input: '%c' (ASCII=%d) state=%d", yytext[0], yytext[0], YYSTATE); diff --git a/Zend/zend_virtual_cwd.c b/Zend/zend_virtual_cwd.c index e880775ea7..330fff187d 100644 --- a/Zend/zend_virtual_cwd.c +++ b/Zend/zend_virtual_cwd.c @@ -54,10 +54,6 @@ # endif #endif -#ifndef S_IFLNK -# define S_IFLNK 0120000 -#endif - #ifdef NETWARE #include <fsio.h> #endif @@ -89,14 +85,6 @@ cwd_state main_cwd_state; /* True global */ #include <direct.h> #endif -#ifndef S_ISDIR -#define S_ISDIR(mode) ((mode) & _S_IFDIR) -#endif - -#ifndef S_ISREG -#define S_ISREG(mode) ((mode) & _S_IFREG) -#endif - #ifdef TSRM_WIN32 #include <tchar.h> #define tsrm_strtok_r(a,b,c) _tcstok((a),(b)) diff --git a/Zend/zend_virtual_cwd.h b/Zend/zend_virtual_cwd.h index d7d1067828..019888757f 100644 --- a/Zend/zend_virtual_cwd.h +++ b/Zend/zend_virtual_cwd.h @@ -337,4 +337,33 @@ CWD_API realpath_cache_bucket** realpath_cache_get_buckets(void); #endif +/* Global stat declarations */ +#ifndef _S_IFDIR +#define _S_IFDIR S_IFDIR +#endif + +#ifndef _S_IFREG +#define _S_IFREG S_IFREG +#endif + +#ifndef S_IFLNK +# define S_IFLNK 0120000 +#endif + +#ifndef S_ISDIR +#define S_ISDIR(mode) (((mode)&S_IFMT) == S_IFDIR) +#endif + +#ifndef S_ISREG +#define S_ISREG(mode) (((mode)&S_IFMT) == S_IFREG) +#endif + +#ifndef S_ISLNK +#define S_ISLNK(mode) (((mode)&S_IFMT) == S_IFLNK) +#endif + +#ifndef S_IXROOT +#define S_IXROOT ( S_IXUSR | S_IXGRP | S_IXOTH ) +#endif + #endif /* VIRTUAL_CWD_H */ diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index d3ca96819d..efbb081922 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -2986,7 +2986,8 @@ ZEND_VM_HANDLER(112, ZEND_INIT_METHOD_CALL, CONST|TMPVAR|UNUSED|CV, CONST|TMPVAR call_info = ZEND_CALL_NESTED_FUNCTION; if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) { obj = NULL; - } else if (OP1_TYPE & (IS_VAR|IS_TMP_VAR)) { + } else if (OP1_TYPE & (IS_VAR|IS_TMP_VAR|IS_CV)) { + /* CV may be changed indirectly (e.g. when it's a reference) */ call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_RELEASE_THIS; GC_REFCOUNT(obj)++; /* For $this pointer */ } diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index c174ff4653..cd95564219 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -5647,7 +5647,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CONST_CO call_info = ZEND_CALL_NESTED_FUNCTION; if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) { obj = NULL; - } else if (IS_CONST & (IS_VAR|IS_TMP_VAR)) { + } else if (IS_CONST & (IS_VAR|IS_TMP_VAR|IS_CV)) { + /* CV may be changed indirectly (e.g. when it's a reference) */ call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_RELEASE_THIS; GC_REFCOUNT(obj)++; /* For $this pointer */ } @@ -9284,7 +9285,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CONST_CV call_info = ZEND_CALL_NESTED_FUNCTION; if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) { obj = NULL; - } else if (IS_CONST & (IS_VAR|IS_TMP_VAR)) { + } else if (IS_CONST & (IS_VAR|IS_TMP_VAR|IS_CV)) { + /* CV may be changed indirectly (e.g. when it's a reference) */ call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_RELEASE_THIS; GC_REFCOUNT(obj)++; /* For $this pointer */ } @@ -11009,7 +11011,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CONST_TM call_info = ZEND_CALL_NESTED_FUNCTION; if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) { obj = NULL; - } else if (IS_CONST & (IS_VAR|IS_TMP_VAR)) { + } else if (IS_CONST & (IS_VAR|IS_TMP_VAR|IS_CV)) { + /* CV may be changed indirectly (e.g. when it's a reference) */ call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_RELEASE_THIS; GC_REFCOUNT(obj)++; /* For $this pointer */ } @@ -23937,7 +23940,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_C call_info = ZEND_CALL_NESTED_FUNCTION; if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) { obj = NULL; - } else if (IS_UNUSED & (IS_VAR|IS_TMP_VAR)) { + } else if (IS_UNUSED & (IS_VAR|IS_TMP_VAR|IS_CV)) { + /* CV may be changed indirectly (e.g. when it's a reference) */ call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_RELEASE_THIS; GC_REFCOUNT(obj)++; /* For $this pointer */ } @@ -26350,7 +26354,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_C call_info = ZEND_CALL_NESTED_FUNCTION; if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) { obj = NULL; - } else if (IS_UNUSED & (IS_VAR|IS_TMP_VAR)) { + } else if (IS_UNUSED & (IS_VAR|IS_TMP_VAR|IS_CV)) { + /* CV may be changed indirectly (e.g. when it's a reference) */ call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_RELEASE_THIS; GC_REFCOUNT(obj)++; /* For $this pointer */ } @@ -27885,7 +27890,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_T call_info = ZEND_CALL_NESTED_FUNCTION; if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) { obj = NULL; - } else if (IS_UNUSED & (IS_VAR|IS_TMP_VAR)) { + } else if (IS_UNUSED & (IS_VAR|IS_TMP_VAR|IS_CV)) { + /* CV may be changed indirectly (e.g. when it's a reference) */ call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_RELEASE_THIS; GC_REFCOUNT(obj)++; /* For $this pointer */ } @@ -32184,7 +32190,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_CONST call_info = ZEND_CALL_NESTED_FUNCTION; if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) { obj = NULL; - } else if (IS_CV & (IS_VAR|IS_TMP_VAR)) { + } else if (IS_CV & (IS_VAR|IS_TMP_VAR|IS_CV)) { + /* CV may be changed indirectly (e.g. when it's a reference) */ call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_RELEASE_THIS; GC_REFCOUNT(obj)++; /* For $this pointer */ } @@ -37265,7 +37272,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HA call_info = ZEND_CALL_NESTED_FUNCTION; if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) { obj = NULL; - } else if (IS_CV & (IS_VAR|IS_TMP_VAR)) { + } else if (IS_CV & (IS_VAR|IS_TMP_VAR|IS_CV)) { + /* CV may be changed indirectly (e.g. when it's a reference) */ call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_RELEASE_THIS; GC_REFCOUNT(obj)++; /* For $this pointer */ } @@ -39845,7 +39853,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVA call_info = ZEND_CALL_NESTED_FUNCTION; if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) { obj = NULL; - } else if (IS_CV & (IS_VAR|IS_TMP_VAR)) { + } else if (IS_CV & (IS_VAR|IS_TMP_VAR|IS_CV)) { + /* CV may be changed indirectly (e.g. when it's a reference) */ call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_RELEASE_THIS; GC_REFCOUNT(obj)++; /* For $this pointer */ } @@ -41997,7 +42006,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_C call_info = ZEND_CALL_NESTED_FUNCTION; if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) { obj = NULL; - } else if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) { + } else if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR|IS_CV)) { + /* CV may be changed indirectly (e.g. when it's a reference) */ call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_RELEASE_THIS; GC_REFCOUNT(obj)++; /* For $this pointer */ } @@ -44066,7 +44076,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_C call_info = ZEND_CALL_NESTED_FUNCTION; if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) { obj = NULL; - } else if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) { + } else if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR|IS_CV)) { + /* CV may be changed indirectly (e.g. when it's a reference) */ call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_RELEASE_THIS; GC_REFCOUNT(obj)++; /* For $this pointer */ } @@ -45123,7 +45134,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_T call_info = ZEND_CALL_NESTED_FUNCTION; if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) { obj = NULL; - } else if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) { + } else if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR|IS_CV)) { + /* CV may be changed indirectly (e.g. when it's a reference) */ call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_RELEASE_THIS; GC_REFCOUNT(obj)++; /* For $this pointer */ } diff --git a/ext/date/tests/009_win32.phpt b/ext/date/tests/009_win32.phpt index cbdc8b7c0a..3ad04f5849 100644 --- a/ext/date/tests/009_win32.phpt +++ b/ext/date/tests/009_win32.phpt @@ -4,11 +4,15 @@ strftime() and gmstrftime() tests <?php if (substr(PHP_OS, 0, 3) != 'WIN') die('skip only windows test.'); if (!function_exists('strftime')) die("skip, strftime not available"); +if (false === setlocale(LC_TIME, "en-us")) die("skip, couldn't set the locale to en-us"); ?> --FILE-- <?php date_default_timezone_set('Asia/Jerusalem'); +$loc = setlocale(LC_TIME, "0"); +setlocale(LC_TIME, "en-us"); + $t = mktime(0,0,0, 6, 27, 2006); var_dump(strftime()); @@ -32,19 +36,21 @@ var_dump(gmstrftime("%%q %%a", $t)); var_dump(gmstrftime("blah", $t)); echo "Done\n"; + +setlocale(LC_TIME, $loc); ?> --EXPECTF-- Warning: strftime() expects at least 1 parameter, 0 given in %s on line %d bool(false) bool(false) -string(%d) "Tue Tuesday Jun June 06/27/06 00:00:00 27 00 12 178 06 00 AM 00 26 26 2 06/27/06 00:00:00 06 2006 %s" +string(%d) "Tue Tuesday Jun June 6/27/2006 12:00:00 AM 27 00 12 178 06 00 AM 00 26 26 2 6/27/2006 12:00:00 AM 06 2006 %s" string(5) "%q %a" string(4) "blah" Warning: gmstrftime() expects at least 1 parameter, 0 given in %s on line %d bool(false) bool(false) -string(%d) "Mon Monday Jun June 06/26/06 21:00:00 26 21 09 177 06 00 PM 00 26 26 1 06/26/06 21:00:00 06 2006 %s" +string(%d) "Mon Monday Jun June 6/26/2006 9:00:00 PM 26 21 09 177 06 00 PM 00 26 26 1 6/26/2006 9:00:00 PM 06 2006 %s" string(5) "%q %a" string(4) "blah" Done diff --git a/ext/date/tests/gmstrftime_variation11.phpt b/ext/date/tests/gmstrftime_variation11.phpt index 482ff6d2d7..f90e51ec16 100644 --- a/ext/date/tests/gmstrftime_variation11.phpt +++ b/ext/date/tests/gmstrftime_variation11.phpt @@ -1,5 +1,5 @@ --TEST-- -Test gmstrftime() function : usage variation - Checking month related formats which are not supported on Windows. +Test gmstrftime() function : usage variation - Checking month related formats which was not supported on Windows before VC14. --SKIPIF-- <?php if (strtoupper(substr(PHP_OS, 0, 3)) != 'WIN') { @@ -32,6 +32,6 @@ var_dump( gmstrftime($format, $timestamp) ); *** Testing gmstrftime() : usage variation *** -- Testing gmstrftime() function with Abbreviated month name format %h -- -bool(false) -bool(false) +string(%d) "%s" +string(3) "Aug" ===DONE=== diff --git a/ext/date/tests/gmstrftime_variation13.phpt b/ext/date/tests/gmstrftime_variation13.phpt index 42f33f01ea..cccfa89d42 100644 --- a/ext/date/tests/gmstrftime_variation13.phpt +++ b/ext/date/tests/gmstrftime_variation13.phpt @@ -1,5 +1,5 @@ --TEST-- -Test gmstrftime() function : usage variation - Checking date related formats which are not supported on Windows. +Test gmstrftime() function : usage variation - Checking date related formats which was not supported on Windows before VC14. --SKIPIF-- <?php if (strtoupper(substr(PHP_OS, 0, 3)) != 'WIN') { @@ -18,7 +18,7 @@ echo "*** Testing gmstrftime() : usage variation ***\n"; // Initialise function arguments not being substituted (if any) $timestamp = gmmktime(8, 8, 8, 8, 8, 2008); -setlocale(LC_ALL, "en_US"); +setlocale(LC_ALL, "C"); date_default_timezone_set("Asia/Calcutta"); //array of values to iterate over @@ -43,18 +43,18 @@ foreach($inputs as $key =>$value) { *** Testing gmstrftime() : usage variation *** --Century number-- -bool(false) -bool(false) +string(2) "%d" +string(2) "20" --Month Date Year-- -bool(false) -bool(false) +string(%d) "%d/%d/%d" +string(8) "08/08/08" --Year with century-- -bool(false) -bool(false) +string(%d) "%d" +string(4) "2008" --Year without century-- -bool(false) -bool(false) +string(2) "%d" +string(2) "08" ===DONE=== diff --git a/ext/date/tests/gmstrftime_variation15.phpt b/ext/date/tests/gmstrftime_variation15.phpt index c0df364789..0a32b43322 100644 --- a/ext/date/tests/gmstrftime_variation15.phpt +++ b/ext/date/tests/gmstrftime_variation15.phpt @@ -1,5 +1,5 @@ --TEST-- -Test gmstrftime() function : usage variation - Checking time related formats which are not supported on Windows. +Test gmstrftime() function : usage variation - Checking time related formats which was not supported on Windows before VC14. --SKIPIF-- <?php if (strtoupper(substr(PHP_OS, 0, 3)) != 'WIN') { @@ -18,7 +18,7 @@ echo "*** Testing gmstrftime() : usage variation ***\n"; // Initialise function arguments not being substituted (if any) $timestamp = gmmktime(8, 8, 8, 8, 8, 2008); -setlocale(LC_ALL, "en_US"); +setlocale(LC_ALL, "C"); date_default_timezone_set("Asia/Calcutta"); //array of values to iterate over @@ -42,14 +42,14 @@ foreach($inputs as $key =>$value) { *** Testing gmstrftime() : usage variation *** --Time in a.m/p.m notation-- -bool(false) -bool(false) +string(%d) "%d:%d:%d %c%c" +string(11) "08:08:08 AM" --Time in 24 hour notation-- -bool(false) -bool(false) +string(%d) "%d:%d" +string(5) "08:08" --Current time %H:%M:%S format-- -bool(false) -bool(false) +string(%d) "%d:%d:%d" +string(8) "08:08:08" ===DONE=== diff --git a/ext/date/tests/gmstrftime_variation17.phpt b/ext/date/tests/gmstrftime_variation17.phpt index e3070a5144..5fa308f645 100644 --- a/ext/date/tests/gmstrftime_variation17.phpt +++ b/ext/date/tests/gmstrftime_variation17.phpt @@ -1,5 +1,5 @@ --TEST-- -Test gmstrftime() function : usage variation - Checking day related formats which are not supported on Windows. +Test gmstrftime() function : usage variation - Checking day related formats which was not supported on Windows before vc14. --SKIPIF-- <?php if (strtoupper(substr(PHP_OS, 0, 3)) != 'WIN') { @@ -18,7 +18,7 @@ echo "*** Testing gmstrftime() : usage variation ***\n"; // Initialise function arguments not being substituted (if any) $timestamp = gmmktime(8, 8, 8, 8, 8, 2008); -setlocale(LC_ALL, "en_US"); +setlocale(LC_ALL, "C"); date_default_timezone_set("Asia/Calcutta"); echo "\n-- Testing gmstrftime() function with Day of the month as decimal single digit format --\n"; @@ -32,6 +32,6 @@ var_dump( gmstrftime($format, $timestamp) ); *** Testing gmstrftime() : usage variation *** -- Testing gmstrftime() function with Day of the month as decimal single digit format -- -bool(false) -bool(false) +string(2) "%A%d" +string(2) " 8" ===DONE=== diff --git a/ext/date/tests/gmstrftime_variation19.phpt b/ext/date/tests/gmstrftime_variation19.phpt index 3131e01ca1..9ba714750e 100644 --- a/ext/date/tests/gmstrftime_variation19.phpt +++ b/ext/date/tests/gmstrftime_variation19.phpt @@ -1,5 +1,5 @@ --TEST-- -Test gmstrftime() function : usage variation - Checking newline and tab formats which are not supported on Windows. +Test gmstrftime() function : usage variation - Checking newline and tab formats which was not supported on Windows before VC14. --SKIPIF-- <?php if (strtoupper(substr(PHP_OS, 0, 3)) != 'WIN') { @@ -18,7 +18,7 @@ echo "*** Testing gmstrftime() : usage variation ***\n"; // Initialise function arguments not being substituted (if any) $timestamp = gmmktime(8, 8, 8, 8, 8, 2008); -setlocale(LC_ALL, "en_US"); +setlocale(LC_ALL, "C"); date_default_timezone_set("Asia/Calcutta"); //array of values to iterate over @@ -41,10 +41,12 @@ foreach($inputs as $key =>$value) { *** Testing gmstrftime() : usage variation *** --Newline character-- -bool(false) -bool(false) +string(1) " +" +string(1) " +" --Tab character-- -bool(false) -bool(false) +string(1) " " +string(1) " " ===DONE=== diff --git a/ext/date/tests/gmstrftime_variation21.phpt b/ext/date/tests/gmstrftime_variation21.phpt index 26ed157c3f..08ca2fc606 100644 --- a/ext/date/tests/gmstrftime_variation21.phpt +++ b/ext/date/tests/gmstrftime_variation21.phpt @@ -18,7 +18,7 @@ echo "*** Testing gmstrftime() : usage variation ***\n"; // Initialise function arguments not being substituted (if any) $timestamp = gmmktime(8, 8, 8, 8, 8, 2008); -setlocale(LC_ALL, "en_US"); +setlocale(LC_ALL, "C"); date_default_timezone_set("Asia/Calcutta"); //array of values to iterate over @@ -42,8 +42,8 @@ foreach($inputs as $key =>$value) { *** Testing gmstrftime() : usage variation *** --Preferred date and time representation-- -string(%d) "%d/%d/%d %d:%d:%d" -string(17) "08/08/08 08:08:08" +string(%d) "%s %s %d %d:%d:%d %d" +string(24) "Fri Aug 8 08:08:08 2008" --Preferred date representation-- string(%d) "%d/%d/%d" diff --git a/ext/date/tests/gmstrftime_variation9.phpt b/ext/date/tests/gmstrftime_variation9.phpt index 95b6c904f9..6ba33ac394 100644 --- a/ext/date/tests/gmstrftime_variation9.phpt +++ b/ext/date/tests/gmstrftime_variation9.phpt @@ -1,5 +1,5 @@ --TEST-- -Test gmstrftime() function : usage variation - Checking week related formats which are not supported on Windows. +Test gmstrftime() function : usage variation - Checking week related formats which was not supported on Windows before vc14. --SKIPIF-- <?php if (strtoupper(substr(PHP_OS, 0, 3)) != 'WIN') { @@ -18,7 +18,7 @@ echo "*** Testing gmstrftime() : usage variation ***\n"; // Initialise function arguments not being substituted (if any) $timestamp = gmmktime(8, 8, 8, 8, 8, 2008); -setlocale(LC_ALL, "en_US"); +setlocale(LC_ALL, "C"); date_default_timezone_set("Asia/Calcutta"); //array of values to iterate over @@ -41,10 +41,10 @@ foreach($inputs as $key =>$value) { *** Testing gmstrftime() : usage variation *** --The ISO 8601:1988 week number-- -bool(false) -bool(false) +string(%d) "%d" +string(2) "32" --Weekday as decimal-- -bool(false) -bool(false) +string(1) "%d" +string(1) "5" ===DONE=== diff --git a/ext/date/tests/strftime_variation11.phpt b/ext/date/tests/strftime_variation11.phpt index a063f0ad20..08d5634daa 100644 --- a/ext/date/tests/strftime_variation11.phpt +++ b/ext/date/tests/strftime_variation11.phpt @@ -1,5 +1,5 @@ --TEST-- -Test strftime() function : usage variation - Checking month related formats which are not supported on Windows. +Test strftime() function : usage variation - Checking month related formats which was not supported on Windows before VC14. --SKIPIF-- <?php if (strtoupper(substr(PHP_OS, 0, 3)) != 'WIN') { @@ -17,7 +17,7 @@ if (strtoupper(substr(PHP_OS, 0, 3)) != 'WIN') { echo "*** Testing strftime() : usage variation ***\n"; // Initialise function arguments not being substituted (if any) -setlocale(LC_ALL, "en_US"); +setlocale(LC_ALL, "C"); date_default_timezone_set("Asia/Calcutta"); $timestamp = mktime(8, 8, 8, 8, 8, 2008); @@ -32,6 +32,6 @@ var_dump( strftime($format, $timestamp) ); *** Testing strftime() : usage variation *** -- Testing strftime() function with Abbreviated month name format %h -- -bool(false) -bool(false) +string(%d) "%s" +string(3) "Aug" ===DONE=== diff --git a/ext/date/tests/strftime_variation13.phpt b/ext/date/tests/strftime_variation13.phpt index 58ad283ffd..3218558184 100644 --- a/ext/date/tests/strftime_variation13.phpt +++ b/ext/date/tests/strftime_variation13.phpt @@ -1,5 +1,5 @@ --TEST-- -Test strftime() function : usage variation - Checking date related formats which are not supported on Windows. +Test strftime() function : usage variation - Checking date related formats which was not supported on Windows before VC14. --SKIPIF-- <?php if (strtoupper(substr(PHP_OS, 0, 3)) != 'WIN') { @@ -17,7 +17,7 @@ if (strtoupper(substr(PHP_OS, 0, 3)) != 'WIN') { echo "*** Testing strftime() : usage variation ***\n"; // Initialise function arguments not being substituted (if any) -setlocale(LC_ALL, "en_US"); +setlocale(LC_ALL, "C"); date_default_timezone_set("Asia/Calcutta"); $timestamp = mktime(8, 8, 8, 8, 8, 2008); @@ -43,18 +43,18 @@ foreach($inputs as $key =>$value) { *** Testing strftime() : usage variation *** --Century number-- -bool(false) -bool(false) +string(2) "20" +string(2) "20" --Month Date Year-- -bool(false) -bool(false) +string(%d) "%d/%d/%d" +string(8) "08/08/08" --Year with century-- -bool(false) -bool(false) +string(4) "%d" +string(4) "2008" --Year without century-- -bool(false) -bool(false) +string(2) "%d" +string(2) "08" ===DONE=== diff --git a/ext/date/tests/strftime_variation15.phpt b/ext/date/tests/strftime_variation15.phpt index 5b2946bf5d..962afd89c5 100644 --- a/ext/date/tests/strftime_variation15.phpt +++ b/ext/date/tests/strftime_variation15.phpt @@ -1,5 +1,5 @@ --TEST-- -Test strftime() function : usage variation - Checking time related formats which are not supported on Windows. +Test strftime() function : usage variation - Checking time related formats which was not supported on Windows before VC14. --SKIPIF-- <?php if (strtoupper(substr(PHP_OS, 0, 3)) != 'WIN') { @@ -17,7 +17,7 @@ if (strtoupper(substr(PHP_OS, 0, 3)) != 'WIN') { echo "*** Testing strftime() : usage variation ***\n"; // Initialise function arguments not being substituted (if any) -setlocale(LC_ALL, "en_US"); +setlocale(LC_ALL, "C"); date_default_timezone_set("Asia/Calcutta"); $timestamp = mktime(8, 8, 8, 8, 8, 2008); @@ -42,14 +42,14 @@ foreach($inputs as $key =>$value) { *** Testing strftime() : usage variation *** --Time in a.m/p.m notation-- -bool(false) -bool(false) +string(%d) "%d:%d:%d %s" +string(11) "08:08:08 AM" --Time in 24 hour notation-- -bool(false) -bool(false) +string(%d) "%d:%d" +string(5) "08:08" --Current time %H:%M:%S format-- -bool(false) -bool(false) +string(%d) "%d:%d:%d" +string(8) "08:08:08" ===DONE=== diff --git a/ext/date/tests/strftime_variation17.phpt b/ext/date/tests/strftime_variation17.phpt index 90b3269e83..66527e3436 100644 --- a/ext/date/tests/strftime_variation17.phpt +++ b/ext/date/tests/strftime_variation17.phpt @@ -1,5 +1,5 @@ --TEST-- -Test strftime() function : usage variation - Checking day related formats which are not supported on Windows. +Test strftime() function : usage variation - Checking day related formats which was not supported on Windows before VC14. --SKIPIF-- <?php if (strtoupper(substr(PHP_OS, 0, 3)) != 'WIN') { @@ -17,7 +17,7 @@ if (strtoupper(substr(PHP_OS, 0, 3)) != 'WIN') { echo "*** Testing strftime() : usage variation ***\n"; // Initialise function arguments not being substituted (if any) -setlocale(LC_ALL, "en_US"); +setlocale(LC_ALL, "C"); date_default_timezone_set("Asia/Calcutta"); $timestamp = mktime(8, 8, 8, 8, 8, 2008); @@ -31,6 +31,6 @@ var_dump( strftime($format, $timestamp) ); *** Testing strftime() : usage variation *** -- Testing strftime() function with Day of the month as decimal single digit format -- -bool(false) -bool(false) +string(%d) "%A%d" +string(2) " 8" ===DONE=== diff --git a/ext/date/tests/strftime_variation19.phpt b/ext/date/tests/strftime_variation19.phpt index b41607719c..f36d0a189e 100644 --- a/ext/date/tests/strftime_variation19.phpt +++ b/ext/date/tests/strftime_variation19.phpt @@ -1,5 +1,5 @@ --TEST-- -Test strftime() function : usage variation - Checking newline and tab formats which are not supported on Windows. +Test strftime() function : usage variation - Checking newline and tab formats which was not supported on Windows before VC14. --SKIPIF-- <?php if (strtoupper(substr(PHP_OS, 0, 3)) != 'WIN') { @@ -41,10 +41,12 @@ foreach($inputs as $key =>$value) { *** Testing strftime() : usage variation *** --Newline character-- -bool(false) -bool(false) +string(1) " +" +string(1) " +" --Tab character-- -bool(false) -bool(false) +string(1) " " +string(1) " " ===DONE=== diff --git a/ext/date/tests/strftime_variation21.phpt b/ext/date/tests/strftime_variation21.phpt index f6aed15eff..735659298a 100644 --- a/ext/date/tests/strftime_variation21.phpt +++ b/ext/date/tests/strftime_variation21.phpt @@ -17,7 +17,7 @@ if (strtoupper(substr(PHP_OS, 0, 3)) != 'WIN') { echo "*** Testing strftime() : usage variation ***\n"; // Initialise function arguments not being substituted (if any) -setlocale(LC_ALL, "en_US"); +setlocale(LC_ALL, "C"); date_default_timezone_set("Asia/Calcutta"); $timestamp = mktime(8, 8, 8, 8, 8, 2008); @@ -42,8 +42,8 @@ foreach($inputs as $key =>$value) { *** Testing strftime() : usage variation *** --Preferred date and time representation-- -string(%d) "%d/%d/%d %d:%d:%d" -string(17) "08/08/08 08:08:08" +string(%d) "%s %s %d %d:%d:%d %d" +string(24) "Fri Aug 8 08:08:08 2008" --Preferred date representation-- string(%d) "%d/%d/%d" diff --git a/ext/date/tests/strftime_variation9.phpt b/ext/date/tests/strftime_variation9.phpt index 23aa92d98d..eff030984f 100644 --- a/ext/date/tests/strftime_variation9.phpt +++ b/ext/date/tests/strftime_variation9.phpt @@ -1,5 +1,5 @@ --TEST-- -Test strftime() function : usage variation - Checking week related formats which are not supported on Windows. +Test strftime() function : usage variation - Checking week related formats which was not supported on Windows before VC14. --SKIPIF-- <?php if (strtoupper(substr(PHP_OS, 0, 3)) != 'WIN') { @@ -17,7 +17,7 @@ if (strtoupper(substr(PHP_OS, 0, 3)) != 'WIN') { echo "*** Testing strftime() : usage variation ***\n"; // Initialise function arguments not being substituted (if any) -setlocale(LC_ALL, "en_US"); +setlocale(LC_ALL, "C"); date_default_timezone_set("Asia/Calcutta"); $timestamp = mktime(8, 8, 8, 8, 8, 2008); @@ -41,10 +41,10 @@ foreach($inputs as $key =>$value) { *** Testing strftime() : usage variation *** --The ISO 8601:1988 week number-- -bool(false) -bool(false) +string(2) "%d" +string(2) "32" --Weekday as decimal-- -bool(false) -bool(false) +string(1) "%d" +string(1) "5" ===DONE=== diff --git a/ext/fileinfo/fileinfo.c b/ext/fileinfo/fileinfo.c index 40df99df47..8663372de3 100644 --- a/ext/fileinfo/fileinfo.c +++ b/ext/fileinfo/fileinfo.c @@ -39,10 +39,6 @@ #include "fopen_wrappers.h" /* needed for is_url */ #include "Zend/zend_exceptions.h" -#ifndef _S_IFDIR -# define _S_IFDIR S_IFDIR -#endif - /* {{{ macros and type definitions */ typedef struct _php_fileinfo { zend_long options; diff --git a/ext/gd/libgd/webpimg.c b/ext/gd/libgd/webpimg.c index 1f1c02322e..9d801a29a3 100644 --- a/ext/gd/libgd/webpimg.c +++ b/ext/gd/libgd/webpimg.c @@ -706,14 +706,14 @@ static WebPResult VPXEncode(const uint8* Y, codec_ctl(&enc, VP8E_SET_STATIC_THRESHOLD, 0); codec_ctl(&enc, VP8E_SET_TOKEN_PARTITIONS, 2); - vpx_img_wrap(&img, IMG_FMT_I420, + vpx_img_wrap(&img, VPX_IMG_FMT_I420, y_width, y_height, 16, (uint8*)(Y)); - img.planes[PLANE_Y] = (uint8*)(Y); - img.planes[PLANE_U] = (uint8*)(U); - img.planes[PLANE_V] = (uint8*)(V); - img.stride[PLANE_Y] = y_stride; - img.stride[PLANE_U] = uv_stride; - img.stride[PLANE_V] = uv_stride; + img.planes[VPX_PLANE_Y] = (uint8*)(Y); + img.planes[VPX_PLANE_U] = (uint8*)(U); + img.planes[VPX_PLANE_V] = (uint8*)(V); + img.stride[VPX_PLANE_Y] = y_stride; + img.stride[VPX_PLANE_U] = uv_stride; + img.stride[VPX_PLANE_V] = uv_stride; res = vpx_codec_encode(&enc, &img, 0, 1, 0, VPX_DL_BEST_QUALITY); diff --git a/ext/opcache/zend_accelerator_module.c b/ext/opcache/zend_accelerator_module.c index 13118a0a4e..7a8ef8d3e8 100644 --- a/ext/opcache/zend_accelerator_module.c +++ b/ext/opcache/zend_accelerator_module.c @@ -243,10 +243,6 @@ static ZEND_INI_MH(OnEnable) #ifdef HAVE_OPCACHE_FILE_CACHE -#ifndef S_ISDIR -# define S_ISDIR(mode) (((mode)&S_IFMT) == S_IFDIR) -#endif - static ZEND_INI_MH(OnUpdateFileCache) { if (new_value) { diff --git a/ext/phar/func_interceptors.c b/ext/phar/func_interceptors.c index 8cadeb5a4a..c4912649db 100644 --- a/ext/phar/func_interceptors.c +++ b/ext/phar/func_interceptors.c @@ -429,18 +429,6 @@ skip_phar: } /* }}} */ -#ifndef S_ISDIR -#define S_ISDIR(mode) (((mode)&S_IFMT) == S_IFDIR) -#endif -#ifndef S_ISREG -#define S_ISREG(mode) (((mode)&S_IFMT) == S_IFREG) -#endif -#ifndef S_ISLNK -#define S_ISLNK(mode) (((mode)&S_IFMT) == S_IFLNK) -#endif - -#define S_IXROOT ( S_IXUSR | S_IXGRP | S_IXOTH ) - #define IS_LINK_OPERATION(__t) ((__t) == FS_TYPE || (__t) == FS_IS_LINK || (__t) == FS_LSTAT) #define IS_EXISTS_CHECK(__t) ((__t) == FS_EXISTS || (__t) == FS_IS_W || (__t) == FS_IS_R || (__t) == FS_IS_X || (__t) == FS_IS_FILE || (__t) == FS_IS_DIR || (__t) == FS_IS_LINK) #define IS_ABLE_CHECK(__t) ((__t) == FS_IS_R || (__t) == FS_IS_W || (__t) == FS_IS_X) diff --git a/ext/phar/tar.c b/ext/phar/tar.c index 81b08de36a..52df81971b 100644 --- a/ext/phar/tar.c +++ b/ext/phar/tar.c @@ -460,9 +460,7 @@ bail: entry.flags = phar_tar_number(hdr->mode, sizeof(hdr->mode)) & PHAR_ENT_PERM_MASK; entry.timestamp = phar_tar_number(hdr->mtime, sizeof(hdr->mtime)); entry.is_persistent = myphar->is_persistent; -#ifndef S_ISDIR -#define S_ISDIR(mode) (((mode)&S_IFMT) == S_IFDIR) -#endif + if (old && entry.tar_type == TAR_FILE && S_ISDIR(entry.flags)) { entry.tar_type = TAR_DIR; } diff --git a/ext/standard/file.c b/ext/standard/file.c index 01c043f0ad..1755dab81b 100644 --- a/ext/standard/file.c +++ b/ext/standard/file.c @@ -122,9 +122,6 @@ php_file_globals file_globals; # include <wchar.h> #endif -#ifndef S_ISDIR -# define S_ISDIR(mode) (((mode)&S_IFMT) == S_IFDIR) -#endif /* }}} */ #define PHP_STREAM_TO_ZVAL(stream, arg) \ diff --git a/ext/standard/filestat.c b/ext/standard/filestat.c index ffcba3598d..764b490b9a 100644 --- a/ext/standard/filestat.c +++ b/ext/standard/filestat.c @@ -85,18 +85,6 @@ #include "basic_functions.h" #include "php_filestat.h" -#ifndef S_ISDIR -#define S_ISDIR(mode) (((mode)&S_IFMT) == S_IFDIR) -#endif -#ifndef S_ISREG -#define S_ISREG(mode) (((mode)&S_IFMT) == S_IFREG) -#endif -#ifndef S_ISLNK -#define S_ISLNK(mode) (((mode)&S_IFMT) == S_IFLNK) -#endif - -#define S_IXROOT ( S_IXUSR | S_IXGRP | S_IXOTH ) - PHP_RINIT_FUNCTION(filestat) /* {{{ */ { BG(CurrentStatFile)=NULL; diff --git a/ext/standard/string.c b/ext/standard/string.c index 3162533186..8d95290ca2 100644 --- a/ext/standard/string.c +++ b/ext/standard/string.c @@ -1200,69 +1200,79 @@ PHP_FUNCTION(explode) */ PHPAPI void php_implode(const zend_string *delim, zval *arr, zval *return_value) { - zval *tmp; - smart_str implstr = {0}; - int numelems, i = 0; - zend_string *str; + zval *tmp; + int numelems; + zend_string *str; + char *cptr; + size_t len = 0; + zend_string **strings, **strptr; numelems = zend_hash_num_elements(Z_ARRVAL_P(arr)); if (numelems == 0) { RETURN_EMPTY_STRING(); + } else if (numelems == 1) { + /* loop to search the first not undefined element... */ + ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(arr), tmp) { + RETURN_STR(zval_get_string(tmp)); + } ZEND_HASH_FOREACH_END(); } - ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(arr), tmp) { -again: - switch (Z_TYPE_P(tmp)) { - case IS_STRING: - smart_str_append(&implstr, Z_STR_P(tmp)); - break; - - case IS_LONG: - smart_str_append_long(&implstr, Z_LVAL_P(tmp)); - break; - - case IS_TRUE: - smart_str_appendl(&implstr, "1", sizeof("1")-1); - break; - - case IS_NULL: - case IS_FALSE: - break; + strings = emalloc((sizeof(zend_long) + sizeof(zend_string *)) * numelems); + strptr = strings - 1; - case IS_DOUBLE: { - char *stmp; - size_t str_len = spprintf(&stmp, 0, "%.*G", (int) EG(precision), Z_DVAL_P(tmp)); - smart_str_appendl(&implstr, stmp, str_len); - efree(stmp); - break; + ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(arr), tmp) { + if (Z_TYPE_P(tmp) == IS_LONG) { + double val = Z_LVAL_P(tmp); + *++strptr = NULL; + ((zend_long *) (strings + numelems))[strptr - strings] = Z_LVAL_P(tmp); + if (val < 0) { + val = -10 * val; } - - case IS_REFERENCE: - tmp = Z_REFVAL_P(tmp); - goto again; - - default: - str = zval_get_string(tmp); - smart_str_append(&implstr, str); - zend_string_release(str); - break; - + if (val < 10) { + len++; + } else { + len += (int) log10(10 * (double) val); + } + } else { + *++strptr = zval_get_string(tmp); + len += (*strptr)->len; } + } ZEND_HASH_FOREACH_END(); + + str = zend_string_alloc(len + (numelems - 1) * delim->len, 0); + cptr = str->val + str->len; + *cptr = 0; - if (++i != numelems) { - smart_str_append(&implstr, delim); + do { + if (*strptr) { + cptr -= (*strptr)->len; + memcpy(cptr, (*strptr)->val, (*strptr)->len); + zend_string_release(*strptr); + } else { + char *oldPtr = cptr; + char oldVal = *cptr; + zend_long val = ((zend_long *) (strings + numelems))[strptr - strings]; + cptr = zend_print_long_to_buf(cptr, val); + *oldPtr = oldVal; } - } ZEND_HASH_FOREACH_END(); - smart_str_0(&implstr); + cptr -= delim->len; + memcpy(cptr, delim->val, delim->len); + } while (--strptr > strings); - if (implstr.s) { - RETURN_NEW_STR(implstr.s); + if (*strptr) { + memcpy(str->val, (*strptr)->val, (*strptr)->len); + zend_string_release(*strptr); } else { - smart_str_free(&implstr); - RETURN_EMPTY_STRING(); + char *oldPtr = cptr; + char oldVal = *cptr; + zend_print_long_to_buf(cptr, ((zend_long *) (strings + numelems))[strptr - strings]); + *oldPtr = oldVal; } + + efree(strings); + RETURN_NEW_STR(str); } /* }}} */ diff --git a/ext/tokenizer/tests/bug67395.phpt b/ext/tokenizer/tests/bug67395.phpt index c9b7f3012f..8101c81edb 100644 --- a/ext/tokenizer/tests/bug67395.phpt +++ b/ext/tokenizer/tests/bug67395.phpt @@ -1,5 +1,7 @@ --TEST-- Bug 67395: token_name() does not return name for T_POW and T_POW_EQUAL token +--SKIPIF-- +<?php if (!extension_loaded("tokenizer")) print "skip"; ?> --FILE-- <?php diff --git a/ext/tokenizer/tests/token_get_all_TOKEN_PARSE_000.phpt b/ext/tokenizer/tests/token_get_all_TOKEN_PARSE_000.phpt new file mode 100644 index 0000000000..03b991b1a5 --- /dev/null +++ b/ext/tokenizer/tests/token_get_all_TOKEN_PARSE_000.phpt @@ -0,0 +1,19 @@ +--TEST-- +Parse errors during token_get_all() with TOKEN_PARSE flag +--SKIPIF-- +<?php if (!extension_loaded("tokenizer")) print "skip"; ?> +--FILE-- +<?php + +try { + token_get_all('<?php invalid code;', TOKEN_PARSE); +} catch (ParseException $e) { + echo $e->getMessage(), PHP_EOL; +} + +echo "Done"; + +?> +--EXPECT-- +syntax error, unexpected 'code' (T_STRING) +Done diff --git a/ext/tokenizer/tests/token_get_all_TOKEN_PARSE_001.phpt b/ext/tokenizer/tests/token_get_all_TOKEN_PARSE_001.phpt new file mode 100644 index 0000000000..eb0e300964 --- /dev/null +++ b/ext/tokenizer/tests/token_get_all_TOKEN_PARSE_001.phpt @@ -0,0 +1,81 @@ +--TEST-- +Semi reserved words support: member access +--SKIPIF-- +<?php if (!extension_loaded("tokenizer")) print "skip"; ?> +--FILE-- +<?php +$tokens = token_get_all('<?php +X::continue; +X::$continue; +$x->$continue; +X::continue(); +$x->continue(); +X::class; + +class X { + const CONTINUE = 1; + public $x = self::CONTINUE + 1; +} +', TOKEN_PARSE); + +array_walk($tokens, function($tk) { + if(is_array($tk)) { + if(($t = token_name($tk[0])) == 'T_WHITESPACE') return; + echo "L{$tk[2]}: ".$t." {$tk[1]}", PHP_EOL; + } + else echo $tk, PHP_EOL; +}); + +echo "Done"; + +?> +--EXPECTF-- +L1: T_OPEN_TAG <?php + +L2: T_STRING X +L2: T_DOUBLE_COLON :: +L2: T_STRING continue +; +L3: T_STRING X +L3: T_DOUBLE_COLON :: +L3: T_VARIABLE $continue +; +L4: T_VARIABLE $x +L4: T_OBJECT_OPERATOR -> +L4: T_VARIABLE $continue +; +L5: T_STRING X +L5: T_DOUBLE_COLON :: +L5: T_STRING continue +( +) +; +L6: T_VARIABLE $x +L6: T_OBJECT_OPERATOR -> +L6: T_STRING continue +( +) +; +L7: T_STRING X +L7: T_DOUBLE_COLON :: +L7: T_STRING class +; +L9: T_CLASS class +L9: T_STRING X +{ +L10: T_CONST const +L10: T_STRING CONTINUE += +L10: T_LNUMBER 1 +; +L11: T_PUBLIC public +L11: T_VARIABLE $x += +L11: T_STRING self +L11: T_DOUBLE_COLON :: +L11: T_STRING CONTINUE ++ +L11: T_LNUMBER 1 +; +} +Done diff --git a/ext/tokenizer/tests/token_get_all_TOKEN_PARSE_002.phpt b/ext/tokenizer/tests/token_get_all_TOKEN_PARSE_002.phpt new file mode 100644 index 0000000000..3dd8e14d84 --- /dev/null +++ b/ext/tokenizer/tests/token_get_all_TOKEN_PARSE_002.phpt @@ -0,0 +1,68 @@ +--TEST-- +Semi reserved words support: class const +--SKIPIF-- +<?php if (!extension_loaded("tokenizer")) print "skip"; ?> +--FILE-- +<?php +$tokens = token_get_all('<?php + class SomeClass { + const CONST = 1; + const CONTINUE = (self::CONST + 1); + const ARRAY = [1, self::CONTINUE => [3, 4], 5]; + } +', TOKEN_PARSE); + +array_walk($tokens, function($tk) { + if(is_array($tk)) { + if(($t = token_name($tk[0])) == 'T_WHITESPACE') return; + echo "L{$tk[2]}: ".$t." {$tk[1]}", PHP_EOL; + } + else echo $tk, PHP_EOL; +}); + +echo "Done"; + +?> +--EXPECTF-- +L1: T_OPEN_TAG <?php + +L2: T_CLASS class +L2: T_STRING SomeClass +{ +L3: T_CONST const +L3: T_STRING CONST += +L3: T_LNUMBER 1 +; +L4: T_CONST const +L4: T_STRING CONTINUE += +( +L4: T_STRING self +L4: T_DOUBLE_COLON :: +L4: T_STRING CONST ++ +L4: T_LNUMBER 1 +) +; +L5: T_CONST const +L5: T_STRING ARRAY += +[ +L5: T_LNUMBER 1 +, +L5: T_STRING self +L5: T_DOUBLE_COLON :: +L5: T_STRING CONTINUE +L5: T_DOUBLE_ARROW => +[ +L5: T_LNUMBER 3 +, +L5: T_LNUMBER 4 +] +, +L5: T_LNUMBER 5 +] +; +} +Done diff --git a/ext/tokenizer/tests/token_get_all_error.phpt b/ext/tokenizer/tests/token_get_all_error.phpt index 29e97c38c4..9ded0a1774 100644 --- a/ext/tokenizer/tests/token_get_all_error.phpt +++ b/ext/tokenizer/tests/token_get_all_error.phpt @@ -19,7 +19,7 @@ var_dump( token_get_all()); echo "-- Testing token_get_all() function with more than expected no. of arguments --\n"; $source = '<?php ?>'; $extra_arg = 10; -var_dump( token_get_all($source, $extra_arg)); +var_dump( token_get_all($source, true, $extra_arg)); echo "Done" ?> @@ -28,10 +28,10 @@ echo "Done" -- Testing token_get_all() function with zero arguments -- -Warning: token_get_all() expects exactly 1 parameter, 0 given in %s on line %d +Warning: token_get_all() expects at least 1 parameter, 0 given in %s on line 11 NULL -- Testing token_get_all() function with more than expected no. of arguments -- -Warning: token_get_all() expects exactly 1 parameter, 2 given in %s on line %d +Warning: token_get_all() expects at most 2 parameters, 3 given in %s on line 17 NULL -Done +Done
\ No newline at end of file diff --git a/ext/tokenizer/tokenizer.c b/ext/tokenizer/tokenizer.c index c011894441..2a4fa90ca2 100644 --- a/ext/tokenizer/tokenizer.c +++ b/ext/tokenizer/tokenizer.c @@ -37,6 +37,12 @@ #define zendcursor LANG_SCNG(yy_cursor) #define zendlimit LANG_SCNG(yy_limit) +#define TOKEN_PARSE 1 + +void tokenizer_token_get_all_register_constants(INIT_FUNC_ARGS) { + REGISTER_LONG_CONSTANT("TOKEN_PARSE", TOKEN_PARSE, CONST_CS|CONST_PERSISTENT); +} + /* {{{ arginfo */ ZEND_BEGIN_ARG_INFO_EX(arginfo_token_get_all, 0, 0, 1) ZEND_ARG_INFO(0, source) @@ -83,6 +89,7 @@ ZEND_GET_MODULE(tokenizer) PHP_MINIT_FUNCTION(tokenizer) { tokenizer_register_constants(INIT_FUNC_ARGS_PASSTHRU); + tokenizer_token_get_all_register_constants(INIT_FUNC_ARGS_PASSTHRU); return SUCCESS; } /* }}} */ @@ -97,19 +104,33 @@ PHP_MINFO_FUNCTION(tokenizer) } /* }}} */ -static void tokenize(zval *return_value) +static zend_bool tokenize(zval *return_value, zend_string *source) { + zval source_zval; + zend_lex_state original_lex_state; zval token; zval keyword; int token_type; zend_bool destroy; int token_line = 1; - int need_tokens = -1; // for __halt_compiler lexing. -1 = disabled + int need_tokens = -1; /* for __halt_compiler lexing. -1 = disabled */ + + ZVAL_STR_COPY(&source_zval, source); + zend_save_lexical_state(&original_lex_state); + if (zend_prepare_string_for_scanning(&source_zval, "") == FAILURE) { + zend_restore_lexical_state(&original_lex_state); + return 0; + } + + LANG_SCNG(yy_state) = yycINITIAL; array_init(return_value); ZVAL_NULL(&token); while ((token_type = lex_scan(&token))) { + + if(token_type == T_ERROR) break; + destroy = 1; switch (token_type) { case T_CLOSE_TAG: @@ -123,8 +144,6 @@ static void tokenize(zval *return_value) case T_DOC_COMMENT: destroy = 0; break; - case T_ERROR: - return; } if (token_type >= 256) { @@ -147,13 +166,13 @@ static void tokenize(zval *return_value) } ZVAL_NULL(&token); - // after T_HALT_COMPILER collect the next three non-dropped tokens + /* after T_HALT_COMPILER collect the next three non-dropped tokens */ if (need_tokens != -1) { if (token_type != T_WHITESPACE && token_type != T_OPEN_TAG - && token_type != T_COMMENT && token_type != T_DOC_COMMENT - && --need_tokens == 0 + && token_type != T_COMMENT && token_type != T_DOC_COMMENT + && --need_tokens == 0 ) { - // fetch the rest into a T_INLINE_HTML + /* fetch the rest into a T_INLINE_HTML */ if (zendcursor != zendlimit) { array_init(&keyword); add_next_index_long(&keyword, T_INLINE_HTML); @@ -169,34 +188,113 @@ static void tokenize(zval *return_value) token_line = CG(zend_lineno); } + + zval_dtor(&source_zval); + zend_restore_lexical_state(&original_lex_state); + + return 1; } -/* {{{ proto array token_get_all(string source) - */ -PHP_FUNCTION(token_get_all) +zval token_stream; + +void on_event(zend_php_scanner_event event, int token, int line) { - zend_string *source; - zval source_zval; - zend_lex_state original_lex_state; + zval keyword; + HashTable *tokens_ht; + zval *token_zv; - if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &source) == FAILURE) { - return; + switch(event) { + case ON_TOKEN: + if (token == T_ERROR || token == END) break; + if (token >= 256) { + array_init(&keyword); + add_next_index_long(&keyword, token); + add_next_index_stringl(&keyword, (char *)LANG_SCNG(yy_text), LANG_SCNG(yy_leng)); + add_next_index_long(&keyword, line); + add_next_index_zval(&token_stream, &keyword); + } else { + add_next_index_stringl(&token_stream, (char *)LANG_SCNG(yy_text), LANG_SCNG(yy_leng)); + } + break; + case ON_FEEDBACK: + tokens_ht = Z_ARRVAL(token_stream); + token_zv = zend_hash_index_find(tokens_ht, zend_hash_num_elements(tokens_ht) - 1); + if (token_zv && Z_TYPE_P(token_zv) == IS_ARRAY) { + ZVAL_LONG(zend_hash_index_find(Z_ARRVAL_P(token_zv), 0), token); + } + break; + case ON_STOP: + if (LANG_SCNG(yy_cursor) != LANG_SCNG(yy_limit)) { + array_init(&keyword); + add_next_index_long(&keyword, T_INLINE_HTML); + add_next_index_stringl(&keyword, + (char *)LANG_SCNG(yy_cursor), LANG_SCNG(yy_limit) - LANG_SCNG(yy_cursor)); + add_next_index_long(&keyword, CG(zend_lineno)); + add_next_index_zval(&token_stream, &keyword); + } + break; } +} + +static zend_bool tokenize_parse(zval *return_value, zend_string *source) +{ + zval source_zval; + zend_lex_state original_lex_state; + zend_bool original_in_compilation; + zend_bool success; ZVAL_STR_COPY(&source_zval, source); + + original_in_compilation = CG(in_compilation); + CG(in_compilation) = 1; zend_save_lexical_state(&original_lex_state); - if (zend_prepare_string_for_scanning(&source_zval, "") == FAILURE) { - zend_restore_lexical_state(&original_lex_state); - RETURN_FALSE; - } + if ((success = (zend_prepare_string_for_scanning(&source_zval, "") == SUCCESS))) { + CG(ast) = NULL; + CG(ast_arena) = zend_arena_create(1024 * 32); + LANG_SCNG(yy_state) = yycINITIAL; + LANG_SCNG(on_event) = on_event; - LANG_SCNG(yy_state) = yycINITIAL; + array_init(&token_stream); + if((success = (zendparse() == SUCCESS))) { + ZVAL_ZVAL(return_value, &token_stream, 1, 0); + } + zval_dtor(&token_stream); - tokenize(return_value); + zend_ast_destroy(CG(ast)); + zend_arena_destroy(CG(ast_arena)); + } + /* restore compiler and scanner global states */ zend_restore_lexical_state(&original_lex_state); + CG(in_compilation) = original_in_compilation; + zval_dtor(&source_zval); + + return success; +} + +/* }}} */ + +/* {{{ proto array token_get_all(string source) + */ +PHP_FUNCTION(token_get_all) +{ + zend_string *source; + zend_long flags = 0; + zend_bool success; + + if (zend_parse_parameters(ZEND_NUM_ARGS(), "S|l", &source, &flags) == FAILURE) { + return; + } + + if (flags & TOKEN_PARSE) { + success = tokenize_parse(return_value, source); + } else { + success = tokenize(return_value, source); + } + + if (!success) RETURN_FALSE; } /* }}} */ diff --git a/main/fopen_wrappers.c b/main/fopen_wrappers.c index 85127c3379..a4c6e4a6db 100644 --- a/main/fopen_wrappers.c +++ b/main/fopen_wrappers.c @@ -53,10 +53,6 @@ #include <sys/socket.h> #endif -#ifndef S_ISREG -#define S_ISREG(mode) (((mode) & S_IFMT) == S_IFREG) -#endif - #ifdef PHP_WIN32 #include <winsock2.h> #elif defined(NETWARE) && defined(USE_WINSOCK) diff --git a/main/main.c b/main/main.c index ebaaa2a8e4..2d58b9c99c 100644 --- a/main/main.c +++ b/main/main.c @@ -114,10 +114,6 @@ #endif /* }}} */ -#ifndef S_ISREG -#define S_ISREG(mode) (((mode) & S_IFMT) == S_IFREG) -#endif - PHPAPI int (*php_register_internal_extensions_func)(void) = php_register_internal_extensions; #ifndef ZTS diff --git a/main/php_ini.c b/main/php_ini.c index 80d34848f8..99919ca56e 100644 --- a/main/php_ini.c +++ b/main/php_ini.c @@ -37,10 +37,6 @@ #include <dirent.h> #endif -#ifndef S_ISREG -#define S_ISREG(mode) (((mode) & S_IFMT) == S_IFREG) -#endif - #ifdef PHP_WIN32 #define TRANSLATE_SLASHES_LOWER(path) \ { \ diff --git a/main/php_variables.c b/main/php_variables.c index cf70c8eed5..d800a2d3c4 100644 --- a/main/php_variables.c +++ b/main/php_variables.c @@ -245,7 +245,6 @@ static zend_bool add_post_var(zval *arr, post_var_data_t *var, zend_bool eof) { char *ksep, *vsep, *val; size_t klen, vlen; - /* FIXME: string-size_t */ size_t new_vlen; if (var->ptr >= var->end) { diff --git a/main/streams/php_streams_int.h b/main/streams/php_streams_int.h index c47c666178..0188202c91 100644 --- a/main/streams/php_streams_int.h +++ b/main/streams/php_streams_int.h @@ -55,10 +55,6 @@ # define EWOULDBLOCK WSAEWOULDBLOCK #endif -#ifndef S_ISREG -#define S_ISREG(mode) (((mode)&S_IFMT) == S_IFREG) -#endif - /* This functions transforms the first char to 'w' if it's not 'r', 'a' or 'w' * and strips any subsequent chars except '+' and 'b'. * Use this to sanitize stream->mode if you call e.g. fdopen, fopencookie or diff --git a/main/win95nt.h b/main/win95nt.h index adf9f61e34..12356eeccd 100644 --- a/main/win95nt.h +++ b/main/win95nt.h @@ -40,9 +40,6 @@ typedef char * caddr_t; #define S_IFIFO _IFIFO #define S_IFBLK _IFBLK #define S_IFLNK _IFLNK -#ifndef S_ISREG -#define S_ISREG(m) (((m) & S_IFMT) == S_IFREG) -#endif #define chdir(path) _chdir(path) #define mkdir(a, b) _mkdir(a) #define rmdir(a) _rmdir(a) diff --git a/sapi/cli/php_cli_server.c b/sapi/cli/php_cli_server.c index 568fc9f2d1..b07d6858da 100644 --- a/sapi/cli/php_cli_server.c +++ b/sapi/cli/php_cli_server.c @@ -91,10 +91,6 @@ # define SOCK_EADDRINUSE WSAEADDRINUSE #endif -#ifndef S_ISDIR -#define S_ISDIR(mode) (((mode)&S_IFMT) == S_IFDIR) -#endif - #include "ext/standard/file.h" /* for php_set_sock_blocking() :-( */ #include "zend_smart_str.h" #include "ext/standard/html.h" diff --git a/sapi/phpdbg/phpdbg_opcode.c b/sapi/phpdbg/phpdbg_opcode.c index 7dadc3f4b9..0935e748e5 100644 --- a/sapi/phpdbg/phpdbg_opcode.c +++ b/sapi/phpdbg/phpdbg_opcode.c @@ -106,8 +106,7 @@ static inline char *phpdbg_decode_op(zend_op_array *ops, znode_op *op, uint32_t } break; case IS_UNUSED: - asprintf(&decode, "<unused>"); - break; + return NULL; } return decode; } /* }}} */ @@ -116,43 +115,72 @@ char *phpdbg_decode_opline(zend_op_array *ops, zend_op *op, HashTable *vars) /*{ { char *decode[4] = {NULL, NULL, NULL, NULL}; + /* OP1 */ switch (op->opcode) { case ZEND_JMP: case ZEND_GOTO: case ZEND_FAST_CALL: asprintf(&decode[1], "J%ld", OP_JMP_ADDR(op, op->op1) - ops->opcodes); - goto format; + break; - case ZEND_JMPZNZ: + case ZEND_INIT_FCALL: + case ZEND_RECV: + case ZEND_RECV_INIT: + case ZEND_RECV_VARIADIC: + asprintf(&decode[1], "%" PRIu32, op->op1.num); + break; + + default: decode[1] = phpdbg_decode_op(ops, &op->op1, op->op1_type, vars); + break; + } + + /* OP2 */ + switch (op->opcode) { + /* TODO: ZEND_FAST_CALL, ZEND_FAST_RET op2 */ + case ZEND_JMPZNZ: asprintf(&decode[2], "J%u or J%" PRIu32, op->op2.opline_num, op->extended_value); - goto result; + break; case ZEND_JMPZ: case ZEND_JMPNZ: case ZEND_JMPZ_EX: case ZEND_JMPNZ_EX: case ZEND_JMP_SET: - decode[1] = phpdbg_decode_op(ops, &op->op1, op->op1_type, vars); asprintf(&decode[2], "J%ld", OP_JMP_ADDR(op, op->op2) - ops->opcodes); - goto result; + break; - case ZEND_RECV_INIT: - goto result; + case ZEND_SEND_VAL: + case ZEND_SEND_VAL_EX: + case ZEND_SEND_VAR: + case ZEND_SEND_VAR_NO_REF: + case ZEND_SEND_REF: + case ZEND_SEND_VAR_EX: + case ZEND_SEND_USER: + asprintf(&decode[2], "%" PRIu32, op->op2.num); + break; default: - decode[1] = phpdbg_decode_op(ops, &op->op1, op->op1_type, vars); decode[2] = phpdbg_decode_op(ops, &op->op2, op->op2_type, vars); -result: + break; + } + + /* RESULT */ + switch (op->opcode) { + case ZEND_CATCH: + asprintf(&decode[2], "%" PRIu32, op->result.num); + break; + default: decode[3] = phpdbg_decode_op(ops, &op->result, op->result_type, vars); -format: - asprintf(&decode[0], - "%-20s %-20s %-20s", - decode[1] ? decode[1] : "", - decode[2] ? decode[2] : "", - decode[3] ? decode[3] : ""); + break; } + asprintf(&decode[0], + "%-20s %-20s %-20s", + decode[1] ? decode[1] : "", + decode[2] ? decode[2] : "", + decode[3] ? decode[3] : ""); + if (decode[1]) free(decode[1]); if (decode[2]) diff --git a/sapi/phpdbg/tests/commands/0102_print.test b/sapi/phpdbg/tests/commands/0102_print.test index 6ca60dbbad..7078b13ea2 100644 --- a/sapi/phpdbg/tests/commands/0102_print.test +++ b/sapi/phpdbg/tests/commands/0102_print.test @@ -6,14 +6,14 @@ ################################################# #[User Class: test (3 methods)] #L%d-%d test::testMethod() %s - 0x%s + 1 ops -# L%d #0 RETURN null <unused> <unused> +# L%d #0 RETURN null #L%d-%d test::testPrivateMethod() %s - 0x%s + 1 ops -# L%d #0 RETURN null <unused> <unused> +# L%d #0 RETURN null #L%d-%d test::testProtectedMethod() %s - 0x%s + 1 ops -# L%d #0 RETURN null <unused> <unused> +# L%d #0 RETURN null #[User Method testMethod (1 ops)] #L%d-%d test::testMethod() %s - 0x%s + 1 ops -# L%d #0 RETURN null <unused> <unused> +# L%d #0 RETURN null ################################################# <: class test { diff --git a/tests/basic/bug51709_1.phpt b/tests/basic/bug51709_1.phpt deleted file mode 100644 index 3f2d544e54..0000000000 --- a/tests/basic/bug51709_1.phpt +++ /dev/null @@ -1,16 +0,0 @@ ---TEST-- -Bug #51709 (Can't use keywords as method names) ---FILE-- -<?php - -class foo { - static function for() { - echo "1"; - } -} - -?> -===DONE=== -<?php exit(0); ?> ---EXPECTF-- -Parse error: syntax error, unexpected %s, expecting %s in %sbug51709_1.php on line %d diff --git a/tests/basic/bug51709_2.phpt b/tests/basic/bug51709_2.phpt deleted file mode 100644 index bb1f91cc4c..0000000000 --- a/tests/basic/bug51709_2.phpt +++ /dev/null @@ -1,16 +0,0 @@ ---TEST-- -Bug #51709 (Can't use keywords as method names) ---FILE-- -<?php - -class foo { - static function goto() { - echo "1"; - } -} - -?> -===DONE=== -<?php exit(0); ?> ---EXPECTF-- -Parse error: syntax error, unexpected %s, expecting %s in %sbug51709_2.php on line %d diff --git a/win32/build/mkdist.php b/win32/build/mkdist.php index 9e4422addc..7b4c057530 100644 --- a/win32/build/mkdist.php +++ b/win32/build/mkdist.php @@ -342,6 +342,22 @@ foreach ($ENCHANT_DLLS as $dll) { } } +$SASL_DLLS = $php_build_dir . "/bin/sasl2/sasl*.dll"; +$fls = glob($SASL_DLLS); +if (!empty($fls)) { + $sasl_dest_dir = "$dist_dir/sasl2"; + if (!file_exists($sasl_dest_dir) || !is_dir($sasl_dest_dir)) { + if (!mkdir("$sasl_dest_dir", 0777, true)) { + echo "WARNING: couldn't create '$sasl_dest_dir' for SASL2 auth plugins "; + } + } + foreach ($fls as $fl) { + if (!copy($fl, "$sasl_dest_dir/" . basename($fl))) { + echo "WARNING: couldn't copy $fl into the $sasl_dest_dir"; + } + } +} + /* and those for pecl */ foreach ($pecl_dll_deps as $dll) { if (in_array($dll, $extra_dll_deps)) { diff --git a/win32/glob.c b/win32/glob.c index 1d4f235277..8a40f7f506 100644 --- a/win32/glob.c +++ b/win32/glob.c @@ -71,12 +71,6 @@ # define ARG_MAX 14500 # endif #endif -#ifndef S_ISDIR -#define S_ISDIR(m) (((m) & _S_IFDIR) == _S_IFDIR) -#endif -#ifndef S_ISLNK -#define S_ISLNK(m) (0) -#endif #endif #include "php.h" |