diff --git a/Zend/tests/bug43343.phpt b/Zend/tests/bug43343.phpt
index 79b3e5a24ad38..f0df976a9f47e 100644
--- a/Zend/tests/bug43343.phpt
+++ b/Zend/tests/bug43343.phpt
@@ -8,4 +8,4 @@ $foo = 'bar';
 var_dump(new namespace::$foo);
 ?>
 --EXPECTF--
-Parse error: %s error%sexpecting%sT_NS_SEPARATOR%sin %sbug43343.php on line 5
+Fatal error: Class 'Foo\namespace' not found in %s on line %d
diff --git a/Zend/tests/identifier_or_keyword.phpt b/Zend/tests/identifier_or_keyword.phpt
new file mode 100644
index 0000000000000..6042d6b0c942c
--- /dev/null
+++ b/Zend/tests/identifier_or_keyword.phpt
@@ -0,0 +1,59 @@
+--TEST--
+Basic keyword support
+--FILE--
+<?php
+
+class return {
+	const finally = 1;
+
+	public $catch = 1;
+}
+
+class yield {
+	public function __toString() {
+		return 1;
+	}
+
+	public static function default () {
+	}
+
+	public function namespace () {
+	}
+}
+
+yield::default();
+
+switch (return::finally) {
+	case (new return)->catch:
+	case new yield:
+		echo "O";
+	default:
+		goto try;
+}
+echo "goto T_TRY failed";
+try:
+
+(new yield)->namespace();
+
+interface global {}
+
+class abstract extends namespace\yield implements \global {
+	public function __construct (array $array, callable $call) {
+	}
+}
+
+if (new abstract(["array_arg"], function () {})) {
+	echo "k";
+
+	// Test if it doesn't throw a parse error. fatal error is normal.
+	// inner_keyword
+	interface function extends const, break, continue, goto, echo, throw, if, do, for, foreach, declare, instanceof, as, switch, print, class, interface, while, trait, extends, implements, new, clone, var, eval, include, require, use, insteadof, isset, empty, abstract, final, private, protected, public, unset, list, array, callable, or, and, xor {}
+
+	// keyword
+	$obj->elseif->endif->else->endwhile->endfor->endforeach->enddeclare->endswitch->case->exit;
+}
+
+?>
+--EXPECTF--
+Ok
+Fatal error: %s in %s on line %d
diff --git a/Zend/tests/lsb_006.phpt b/Zend/tests/lsb_006.phpt
index 84cd22a99572d..9be6934f90f72 100644
--- a/Zend/tests/lsb_006.phpt
+++ b/Zend/tests/lsb_006.phpt
@@ -9,5 +9,5 @@ class Foo extends static {
 ?>
 ==DONE==
 --EXPECTF--
-Parse error: %s error,%sexpecting %s in %s on line %d
+Fatal error: Cannot use 'static' as class name as it is reserved in %s on line %d
 
diff --git a/Zend/tests/lsb_007.phpt b/Zend/tests/lsb_007.phpt
index 607f8efeb4398..5fdc1fe55ec99 100644
--- a/Zend/tests/lsb_007.phpt
+++ b/Zend/tests/lsb_007.phpt
@@ -9,5 +9,5 @@ class Foo implements static {
 ?>
 ==DONE==
 --EXPECTF--
-Parse error: %s error,%sexpecting %s in %s on line %d
+Fatal error: Cannot use 'static' as interface name as it is reserved in %s on line %d
 
diff --git a/Zend/tests/lsb_008.phpt b/Zend/tests/lsb_008.phpt
index b700e2df94359..0374bce66225c 100644
--- a/Zend/tests/lsb_008.phpt
+++ b/Zend/tests/lsb_008.phpt
@@ -4,6 +4,7 @@ ZE2 Late Static Binding class name "static"
 <?php
 class static {
 }
+?>
 --EXPECTF--
-Parse error: %s error,%sexpecting %s in %s on line %d
+Fatal error: Cannot use 'static' as class name as it is reserved in %s on line %d
 
diff --git a/Zend/tests/lsb_009.phpt b/Zend/tests/lsb_009.phpt
index d8d41817c8b82..26458848ed6ea 100644
--- a/Zend/tests/lsb_009.phpt
+++ b/Zend/tests/lsb_009.phpt
@@ -4,6 +4,7 @@ ZE2 Late Static Binding interface name "static"
 <?php
 interface static {
 }
+?>
 --EXPECTF--
-Parse error: %s error,%sexpecting %s in %s on line %d
+Fatal error: Cannot use 'static' as interface name as it is reserved in %s on line %d
 
diff --git a/Zend/tests/traits/error_013.phpt b/Zend/tests/traits/error_013.phpt
deleted file mode 100644
index d9fda2d0056ff..0000000000000
--- a/Zend/tests/traits/error_013.phpt
+++ /dev/null
@@ -1,19 +0,0 @@
---TEST--
-Trying to use static as method modifier
---FILE--
-<?php
-
-trait foo {
-	public function test() { return 3; }
-}
-
-class bar {
-	use foo { test as static; }
-}
-
-$x = new bar;
-var_dump($x->test());
-
-?>
---EXPECTF--
-Fatal error: Cannot use 'static' as method modifier in %s on line %d
diff --git a/Zend/tests/traits/language018.phpt b/Zend/tests/traits/language018.phpt
deleted file mode 100644
index 169cb50c6b07c..0000000000000
--- a/Zend/tests/traits/language018.phpt
+++ /dev/null
@@ -1,15 +0,0 @@
---TEST--
-abstract alias
---FILE--
-<?php
-trait T1 {
-	function foo() {}
-}
-class C1 {
-	use T1 {
-		T1::foo as abstract;
-	}
-}
-?>
---EXPECTF--
-Fatal error: Cannot use 'abstract' as method modifier in %s on line %d
diff --git a/Zend/tests/traits/language019.phpt b/Zend/tests/traits/language019.phpt
deleted file mode 100644
index 83318c58a2e73..0000000000000
--- a/Zend/tests/traits/language019.phpt
+++ /dev/null
@@ -1,15 +0,0 @@
---TEST--
-final alias
---FILE--
-<?php
-trait T1 {
-	function foo() {}
-}
-class C1 {
-	use T1 {
-		T1::foo as final;
-	}
-}
-?>
---EXPECTF--
-Fatal error: Cannot use 'final' as method modifier in %s on line %d
diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
index 672f62b7eefa3..90fb399b7b37f 100644
--- a/Zend/zend_compile.c
+++ b/Zend/zend_compile.c
@@ -201,6 +201,12 @@ void zend_init_compiler_data_structures(TSRMLS_D) /* {{{ */
 	zend_stack_init(&CG(context_stack));
 
 	CG(encoding_declared) = 0;
+	CG(tokenbufptr) = -1;
+	CG(tokenbufsize) = ZEND_INIT_TOKEN_BUF_SIZE;
+	CG(tokenbuffer) = emalloc(sizeof(token_buf) * (CG(tokenbufsize) + 1));
+	CG(tokenbuffer)++->token = 0;
+	CG(tokenbuf_in_class) = -1;
+	CG(tokenbuf_fn_decl) = -1;
 }
 /* }}} */
 
@@ -236,6 +242,7 @@ void shutdown_compiler(TSRMLS_D) /* {{{ */
 	zend_hash_destroy(&CG(filenames_table));
 	zend_llist_destroy(&CG(open_files));
 	zend_stack_destroy(&CG(context_stack));
+	efree(--CG(tokenbuffer));
 }
 /* }}} */
 
@@ -1516,6 +1523,25 @@ int zend_do_verify_access_types(const znode *current_access_type, const znode *n
 }
 /* }}} */
 
+void zend_prepare_typehint(const znode *token, znode *result) /* {{{ */
+{
+	if ((Z_STRLEN(token->u.constant) == 5 && !strncasecmp(Z_STRVAL(token->u.constant), "array", 5)) || (Z_STRLEN(token->u.constant) == 8 && !strncasecmp(Z_STRVAL(token->u.constant), "callable", 8))) {
+		result->op_type = IS_CONST;
+		efree(Z_STRVAL(token->u.constant));
+		switch (Z_STRLEN(token->u.constant)) {
+			case 5:
+				Z_TYPE(result->u.constant) = IS_ARRAY;
+				break;
+			case 8:
+				Z_TYPE(result->u.constant) = IS_CALLABLE;
+				break;
+		}
+	} else {
+		*result = *token;
+	}
+}
+/* }}} */
+
 void zend_do_begin_function_declaration(znode *function_token, znode *function_name, int is_method, int return_reference, znode *fn_flags_znode TSRMLS_DC) /* {{{ */
 {
 	zend_op_array op_array;
@@ -4943,9 +4969,13 @@ void zend_do_begin_class_declaration(const znode *class_token, znode *class_name
 
 	lcname = zend_str_tolower_dup(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant));
 
-	if (!(strcmp(lcname, "self") && strcmp(lcname, "parent"))) {
+	if (!(strcmp(lcname, "self") && strcmp(lcname, "parent") && strcmp(lcname, "static"))) {
 		efree(lcname);
-		zend_error(E_COMPILE_ERROR, "Cannot use '%s' as class name as it is reserved", Z_STRVAL(class_name->u.constant));
+		if (parent_class_name) {
+			zend_error(E_COMPILE_ERROR, "Cannot use '%s' as class name as it is reserved", Z_STRVAL(class_name->u.constant));
+		} else {
+			zend_error(E_COMPILE_ERROR, "Cannot use '%s' as interface name as it is reserved", Z_STRVAL(class_name->u.constant));
+		}
 	}
 
 	/* Class name must not conflict with import names */
@@ -6735,7 +6765,6 @@ int zendlex(znode *zendlval TSRMLS_DC) /* {{{ */
 	}
 
 again:
-	Z_TYPE(zendlval->u.constant) = IS_LONG;
 	retval = lex_scan(&zendlval->u.constant TSRMLS_CC);
 	switch (retval) {
 		case T_COMMENT:
@@ -6932,9 +6961,11 @@ void zend_do_begin_namespace(const znode *name, zend_bool with_bracket TSRMLS_DC
 	if (name) {
 		lcname = zend_str_tolower_dup(Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant));
 		if (((Z_STRLEN(name->u.constant) == sizeof("self")-1) &&
-		      !memcmp(lcname, "self", sizeof("self")-1)) ||
+		     !memcmp(lcname, "self", sizeof("self")-1)) ||
 		    ((Z_STRLEN(name->u.constant) == sizeof("parent")-1) &&
-	          !memcmp(lcname, "parent", sizeof("parent")-1))) {
+		     !memcmp(lcname, "parent", sizeof("parent")-1)) ||
+		    ((Z_STRLEN(name->u.constant) == sizeof("static")-1) &&
+		     !memcmp(lcname, "static", sizeof("static")-1))) {
 			zend_error(E_COMPILE_ERROR, "Cannot use '%s' as namespace name", Z_STRVAL(name->u.constant));
 		}
 		efree(lcname);
@@ -7002,9 +7033,11 @@ void zend_do_use(znode *ns_name, znode *new_name, int is_global TSRMLS_DC) /* {{
 	lcname = zend_str_tolower_dup(Z_STRVAL_P(name), Z_STRLEN_P(name));
 
 	if (((Z_STRLEN_P(name) == sizeof("self")-1) &&
-				!memcmp(lcname, "self", sizeof("self")-1)) ||
-			((Z_STRLEN_P(name) == sizeof("parent")-1) &&
-	   !memcmp(lcname, "parent", sizeof("parent")-1))) {
+	     !memcmp(lcname, "self", sizeof("self")-1)) ||
+	    ((Z_STRLEN_P(name) == sizeof("parent")-1) &&
+	     !memcmp(lcname, "parent", sizeof("parent")-1)) ||
+	    ((Z_STRLEN_P(name) == sizeof("static")-1) &&
+	     !memcmp(lcname, "static", sizeof("static")-1))) {
 		zend_error(E_COMPILE_ERROR, "Cannot use %s as %s because '%s' is a special class name", Z_STRVAL_P(ns), Z_STRVAL_P(name), Z_STRVAL_P(name));
 	}
 
diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h
index 61d11427a1e49..91c0bedcb47f0 100644
--- a/Zend/zend_compile.h
+++ b/Zend/zend_compile.h
@@ -65,6 +65,18 @@ typedef struct _zend_compiler_context {
 	HashTable *labels;
 } zend_compiler_context;
 
+typedef struct _token_buf {
+	zval zv;
+	int token;
+	unsigned char *text;
+	unsigned int len;
+	unsigned char *start;
+	unsigned char *end;
+	char *doc_comment;
+	zend_uint doc_comment_len;
+	uint lineno;
+} token_buf;
+
 typedef struct _zend_literal {
 	zval       constant;
 	zend_ulong hash_value;
diff --git a/Zend/zend_globals.h b/Zend/zend_globals.h
index b9a5b39914a6c..7a9e0b8fb49e9 100644
--- a/Zend/zend_globals.h
+++ b/Zend/zend_globals.h
@@ -68,7 +68,6 @@ typedef struct _zend_declarables {
 typedef struct _zend_vm_stack *zend_vm_stack;
 typedef struct _zend_ini_entry zend_ini_entry;
 
-
 struct _zend_compiler_globals {
 	zend_stack bp_stack;
 	zend_stack switch_cond_stack;
@@ -155,6 +154,13 @@ struct _zend_compiler_globals {
 	zval ***static_members_table;
 	int last_static_member;
 #endif
+
+	token_buf *tokenbuffer;
+	int tokenbufptr;
+	int tokenbufsize;
+	int tokenbuf_in_class;
+	int tokenbuf_fn_decl;
+	zend_uchar tokenbuf_mode;
 };
 
 
@@ -293,7 +299,7 @@ struct _zend_php_scanner_globals {
 	int yy_state;
 	zend_stack state_stack;
 	zend_ptr_stack heredoc_label_stack;
-	
+
 	/* original (unfiltered) script */
 	unsigned char *script_org;
 	size_t script_org_size;
@@ -306,6 +312,10 @@ struct _zend_php_scanner_globals {
 	zend_encoding_filter input_filter;
 	zend_encoding_filter output_filter;
 	const zend_encoding *script_encoding;
+
+	/* doc comments */
+	char *doc_comment;
+	zend_uint doc_comment_len;
 };
 
 #endif /* ZEND_GLOBALS_H */
diff --git a/Zend/zend_highlight.c b/Zend/zend_highlight.c
index c789cb719a01b..bfa904a1e3905 100644
--- a/Zend/zend_highlight.c
+++ b/Zend/zend_highlight.c
@@ -25,6 +25,8 @@
 #include "zend_highlight.h"
 #include "zend_ptr_stack.h"
 #include "zend_globals.h"
+#include <zend_language_scanner.h>
+
 
 ZEND_API void zend_html_putc(char c)
 {
@@ -104,10 +106,9 @@ ZEND_API void zend_highlight(zend_syntax_highlighter_ini *syntax_highlighter_ini
 				break;
 			case T_OPEN_TAG:
 			case T_OPEN_TAG_WITH_ECHO:
-				next_color = syntax_highlighter_ini->highlight_default;
-				break;
 			case T_CLOSE_TAG:
 				next_color = syntax_highlighter_ini->highlight_default;
+				Z_TYPE(token) = 0;
 				break;
 			case '"':
 			case T_ENCAPSED_AND_WHITESPACE:
@@ -116,11 +117,11 @@ ZEND_API void zend_highlight(zend_syntax_highlighter_ini *syntax_highlighter_ini
 				break;
 			case T_WHITESPACE:
 				zend_html_puts((char*)LANG_SCNG(yy_text), LANG_SCNG(yy_leng) TSRMLS_CC);  /* no color needed */
-				token.type = 0;
+				Z_TYPE(token) = 0;
 				continue;
 				break;
 			default:
-				if (token.type == 0) {
+				if (Z_TYPE(token) == 0) {
 					next_color = syntax_highlighter_ini->highlight_keyword;
 				} else {
 					next_color = syntax_highlighter_ini->highlight_default;
@@ -140,21 +141,15 @@ ZEND_API void zend_highlight(zend_syntax_highlighter_ini *syntax_highlighter_ini
 
 		zend_html_puts((char*)LANG_SCNG(yy_text), LANG_SCNG(yy_leng) TSRMLS_CC);
 
-		if (token.type == IS_STRING) {
+		if (Z_TYPE(token) == IS_STRING) {
 			switch (token_type) {
-				case T_OPEN_TAG:
-				case T_OPEN_TAG_WITH_ECHO:
-				case T_CLOSE_TAG:
-				case T_WHITESPACE:
-				case T_COMMENT:
-				case T_DOC_COMMENT:
+				PARSER_IGNORED_TOKEN_CASES
 					break;
 				default:
-					efree(token.value.str.val);
-					break;
+					efree(Z_STRVAL(token));
 			}
 		}
-		token.type = 0;
+		Z_TYPE(token) = 0;
 	}
 
 	if (last_color != syntax_highlighter_ini->highlight_html) {
@@ -183,7 +178,7 @@ ZEND_API void zend_strip(TSRMLS_D)
 			case T_DOC_COMMENT:
 				token.type = 0;
 				continue;
-			
+
 			case T_END_HEREDOC:
 				zend_write((char*)LANG_SCNG(yy_text), LANG_SCNG(yy_leng));
 				/* read the following character, either newline or ; */
@@ -202,17 +197,10 @@ ZEND_API void zend_strip(TSRMLS_D)
 
 		if (token.type == IS_STRING) {
 			switch (token_type) {
-				case T_OPEN_TAG:
-				case T_OPEN_TAG_WITH_ECHO:
-				case T_CLOSE_TAG:
-				case T_WHITESPACE:
-				case T_COMMENT:
-				case T_DOC_COMMENT:
+				PARSER_IGNORED_TOKEN_CASES
 					break;
-
 				default:
-					efree(token.value.str.val);
-					break;
+					efree(Z_STRVAL(token));
 			}
 		}
 		prev_space = token.type = 0;
diff --git a/Zend/zend_language_parser.y b/Zend/zend_language_parser.y
index 403146e16486e..0c16c28f46603 100644
--- a/Zend/zend_language_parser.y
+++ b/Zend/zend_language_parser.y
@@ -249,10 +249,10 @@ use_declarations:
 ;
 
 use_declaration:
-		namespace_name 			{ zend_do_use(&$1, NULL, 0 TSRMLS_CC); }
-	|	namespace_name T_AS T_STRING	{ zend_do_use(&$1, &$3, 0 TSRMLS_CC); }
-	|	T_NS_SEPARATOR namespace_name { zend_do_use(&$2, NULL, 1 TSRMLS_CC); }
-	|	T_NS_SEPARATOR namespace_name T_AS T_STRING { zend_do_use(&$2, &$4, 1 TSRMLS_CC); }
+		namespace_name							{ zend_do_use(&$1, NULL, 0 TSRMLS_CC); }
+	|	namespace_name T_AS T_STRING			{ zend_do_use(&$1, &$3, 0 TSRMLS_CC); }
+	|	T_NS_SEPARATOR namespace_name						{ zend_do_use(&$2, NULL, 1 TSRMLS_CC); }
+	|	T_NS_SEPARATOR namespace_name T_AS T_STRING	{ zend_do_use(&$2, &$4, 1 TSRMLS_CC); }
 ;
 
 constant_declaration:
@@ -327,15 +327,15 @@ unticked_statement:
 ;
 
 catch_statement:
-				/* empty */ { $$.op_type = IS_UNUSED; }
+		/* empty */ { $$.op_type = IS_UNUSED; }
 	|	T_CATCH '(' { zend_initialize_try_catch_element(&$1 TSRMLS_CC); } 
-		fully_qualified_class_name { zend_do_first_catch(&$2 TSRMLS_CC); }
+		class_name { zend_do_first_catch(&$2 TSRMLS_CC); }
 		T_VARIABLE ')' { zend_do_begin_catch(&$1, &$4, &$6, &$2 TSRMLS_CC); }
 		'{' inner_statement_list '}' { zend_do_end_catch(&$1 TSRMLS_CC); }
 		additional_catches { zend_do_mark_last_catch(&$2, &$13 TSRMLS_CC); $$ = $1;}
 
 finally_statement:
-					/* empty */ { $$.op_type = IS_UNUSED; }
+		/* empty */ { $$.op_type = IS_UNUSED; }
 	|	T_FINALLY { zend_do_finally(&$1 TSRMLS_CC); } '{' inner_statement_list '}' { $$ = $1; }
 ;
 
@@ -350,7 +350,7 @@ non_empty_additional_catches:
 ;
 
 additional_catch:
-	T_CATCH '(' fully_qualified_class_name { $$.u.op.opline_num = get_next_op_number(CG(active_op_array)); } T_VARIABLE ')' { zend_do_begin_catch(&$1, &$3, &$5, NULL TSRMLS_CC); } '{' inner_statement_list '}' { zend_do_end_catch(&$1 TSRMLS_CC); }
+	T_CATCH '(' class_name { $$.u.op.opline_num = get_next_op_number(CG(active_op_array)); } T_VARIABLE ')' { zend_do_begin_catch(&$1, &$3, &$5, NULL TSRMLS_CC); } '{' inner_statement_list '}' { zend_do_end_catch(&$1 TSRMLS_CC); }
 ;
 
 unset_variables:
@@ -407,7 +407,7 @@ class_entry_type:
 
 extends_from:
 		/* empty */					{ $$.op_type = IS_UNUSED; }
-	|	T_EXTENDS fully_qualified_class_name	{ zend_do_fetch_class(&$$, &$2 TSRMLS_CC); }
+	|	T_EXTENDS class_name	{ zend_do_fetch_class(&$$, &$2 TSRMLS_CC); }
 ;
 
 interface_entry:
@@ -425,8 +425,8 @@ implements_list:
 ;
 
 interface_list:
-		fully_qualified_class_name			{ zend_do_implements_interface(&$1 TSRMLS_CC); }
-	|	interface_list ',' fully_qualified_class_name { zend_do_implements_interface(&$3 TSRMLS_CC); }
+		class_name			{ zend_do_implements_interface(&$1 TSRMLS_CC); }
+	|	interface_list ',' class_name { zend_do_implements_interface(&$3 TSRMLS_CC); }
 ;
 
 foreach_optional_arg:
@@ -491,7 +491,6 @@ while_statement:
 ;
 
 
-
 elseif_list:
 		/* empty */
 	|	elseif_list T_ELSEIF parenthesis_expr { zend_do_if_cond(&$3, &$2 TSRMLS_CC); } statement { zend_do_if_after_statement(&$2, 0 TSRMLS_CC); }
@@ -536,9 +535,7 @@ non_empty_parameter_list:
 
 optional_class_type:
 		/* empty */					{ $$.op_type = IS_UNUSED; }
-	|	T_ARRAY						{ $$.op_type = IS_CONST; Z_TYPE($$.u.constant)=IS_ARRAY; }
-	|	T_CALLABLE					{ $$.op_type = IS_CONST; Z_TYPE($$.u.constant)=IS_CALLABLE; }
-	|	fully_qualified_class_name			{ $$ = $1; }
+	|	class_name			{ zend_prepare_typehint(&$1, &$$); }
 ;
 
 
@@ -600,8 +597,8 @@ trait_use_statement:
 ;
 
 trait_list:
-		fully_qualified_class_name						{ zend_do_use_trait(&$1 TSRMLS_CC); }
-	|	trait_list ',' fully_qualified_class_name		{ zend_do_use_trait(&$3 TSRMLS_CC); }
+		class_name						{ zend_do_use_trait(&$1 TSRMLS_CC); }
+	|	trait_list ',' class_name		{ zend_do_use_trait(&$3 TSRMLS_CC); }
 ;
 
 trait_adaptations:
@@ -629,8 +626,8 @@ trait_precedence:
 ;
 
 trait_reference_list:
-		fully_qualified_class_name									{ zend_resolve_class_name(&$1 TSRMLS_CC); zend_init_list(&$$.u.op.ptr, Z_STRVAL($1.u.constant) TSRMLS_CC); }
-	|	trait_reference_list ',' fully_qualified_class_name			{ zend_resolve_class_name(&$3 TSRMLS_CC); zend_add_to_list(&$1.u.op.ptr, Z_STRVAL($3.u.constant) TSRMLS_CC); $$ = $1; }
+		class_name                                                                      { zend_resolve_class_name(&$1 TSRMLS_CC); zend_init_list(&$$.u.op.ptr, Z_STRVAL($1.u.constant) TSRMLS_CC); }
+	|	trait_reference_list ',' class_name                     { zend_resolve_class_name(&$3 TSRMLS_CC); zend_add_to_list(&$1.u.op.ptr, Z_STRVAL($3.u.constant) TSRMLS_CC); $$ = $1; }
 ;
 
 trait_method_reference:
@@ -639,7 +636,7 @@ trait_method_reference:
 ;
 
 trait_method_reference_fully_qualified:
-	fully_qualified_class_name T_PAAMAYIM_NEKUDOTAYIM T_STRING		{ zend_prepare_reference(&$$, &$1, &$3 TSRMLS_CC); }
+	class_name T_PAAMAYIM_NEKUDOTAYIM T_STRING		{ zend_prepare_reference(&$$, &$1, &$3 TSRMLS_CC); }
 ;
 
 trait_alias:
@@ -648,8 +645,8 @@ trait_alias:
 ;
 
 trait_modifiers:
-		/* empty */					{ Z_LVAL($$.u.constant) = 0x0; } /* No change of methods visibility */
-	|	member_modifier	{ $$ = $1; } /* REM: Keep in mind, there are not only visibility modifiers */
+		/* empty */ { Z_LVAL($$.u.constant) = 0x0; } /* No change of methods visibility */
+	|	member_modifier { $$ = $1; } /* REM: Keep in mind, there are not only visibility modifiers */
 ;
 
 method_body:
@@ -868,21 +865,17 @@ function_call:
 		function_call_parameter_list { zend_do_end_function_call(&$1, &$$, &$3, 0, 1 TSRMLS_CC); zend_do_extended_fcall_end(TSRMLS_C);}
 ;
 
-class_name:
-		T_STATIC { $$.op_type = IS_CONST; ZVAL_STRINGL(&$$.u.constant, "static", sizeof("static")-1, 1);}
-	|	namespace_name { $$ = $1; }
-	|	T_NAMESPACE T_NS_SEPARATOR namespace_name { $$.op_type = IS_CONST; ZVAL_EMPTY_STRING(&$$.u.constant);  zend_do_build_namespace_name(&$$, &$$, &$3 TSRMLS_CC); }
-	|	T_NS_SEPARATOR namespace_name { char *tmp = estrndup(Z_STRVAL($2.u.constant), Z_STRLEN($2.u.constant)+1); memcpy(&(tmp[1]), Z_STRVAL($2.u.constant), Z_STRLEN($2.u.constant)+1); tmp[0] = '\\'; efree(Z_STRVAL($2.u.constant)); Z_STRVAL($2.u.constant) = tmp; ++Z_STRLEN($2.u.constant); $$ = $2; }
+base_class_name:
+	namespace_name { $$ = $1; }
 ;
 
-fully_qualified_class_name:
-		namespace_name { $$ = $1; }
-	|	T_NAMESPACE T_NS_SEPARATOR namespace_name { $$.op_type = IS_CONST; ZVAL_EMPTY_STRING(&$$.u.constant);  zend_do_build_namespace_name(&$$, &$$, &$3 TSRMLS_CC); }
-	|	T_NS_SEPARATOR namespace_name { char *tmp = estrndup(Z_STRVAL($2.u.constant), Z_STRLEN($2.u.constant)+1); memcpy(&(tmp[1]), Z_STRVAL($2.u.constant), Z_STRLEN($2.u.constant)+1); tmp[0] = '\\'; efree(Z_STRVAL($2.u.constant)); Z_STRVAL($2.u.constant) = tmp; ++Z_STRLEN($2.u.constant); $$ = $2; }
+class_name:
+		base_class_name { $$ = $1; }
+	|	T_NAMESPACE T_NS_SEPARATOR base_class_name { $$.op_type = IS_CONST; ZVAL_EMPTY_STRING(&$$.u.constant);  zend_do_build_namespace_name(&$$, &$$, &$3 TSRMLS_CC); }
+	|	T_NS_SEPARATOR base_class_name { char *tmp = estrndup(Z_STRVAL($2.u.constant), Z_STRLEN($2.u.constant)+1); memcpy(&(tmp[1]), Z_STRVAL($2.u.constant), Z_STRLEN($2.u.constant)+1); tmp[0] = '\\'; efree(Z_STRVAL($2.u.constant)); Z_STRVAL($2.u.constant) = tmp; ++Z_STRLEN($2.u.constant); $$ = $2; }
 ;
 
 
-
 class_name_reference:
 		class_name						{ zend_do_fetch_class(&$$, &$1 TSRMLS_CC); }
 	|	dynamic_class_name_reference	{ zend_do_end_variable_parse(&$1, BP_VAR_R, 0 TSRMLS_CC); zend_do_fetch_class(&$$, &$1 TSRMLS_CC); }
@@ -944,8 +937,8 @@ common_scalar:
 
 static_scalar: /* compile-time evaluated scalars */
 		common_scalar		{ $$ = $1; }
-	|	static_class_name_scalar	{ $$ = $1; }
-	|	namespace_name 		{ zend_do_fetch_constant(&$$, NULL, &$1, ZEND_CT, 1 TSRMLS_CC); }
+	|	static_class_name_scalar { $$ = $1; }
+	|	namespace_name      { zend_do_fetch_constant(&$$, NULL, &$1, ZEND_CT, 1 TSRMLS_CC); }
 	|	T_NAMESPACE T_NS_SEPARATOR namespace_name { $$.op_type = IS_CONST; ZVAL_EMPTY_STRING(&$$.u.constant);  zend_do_build_namespace_name(&$$, &$$, &$3 TSRMLS_CC); $3 = $$; zend_do_fetch_constant(&$$, NULL, &$3, ZEND_CT, 0 TSRMLS_CC); }
 	|	T_NS_SEPARATOR namespace_name { char *tmp = estrndup(Z_STRVAL($2.u.constant), Z_STRLEN($2.u.constant)+1); memcpy(&(tmp[1]), Z_STRVAL($2.u.constant), Z_STRLEN($2.u.constant)+1); tmp[0] = '\\'; efree(Z_STRVAL($2.u.constant)); Z_STRVAL($2.u.constant) = tmp; ++Z_STRLEN($2.u.constant); zend_do_fetch_constant(&$$, NULL, &$2, ZEND_CT, 0 TSRMLS_CC); }
 	|	'+' static_scalar { ZVAL_LONG(&$1.u.constant, 0); add_function(&$2.u.constant, &$1.u.constant, &$2.u.constant TSRMLS_CC); $$ = $2; }
@@ -956,13 +949,15 @@ static_scalar: /* compile-time evaluated scalars */
 	|	T_CLASS_C			{ $$ = $1; }
 ;
 
+
+
 static_class_constant:
-		class_name T_PAAMAYIM_NEKUDOTAYIM T_STRING { zend_do_fetch_constant(&$$, &$1, &$3, ZEND_CT, 0 TSRMLS_CC); }
+		class_name T_PAAMAYIM_NEKUDOTAYIM T_STRING { if (Z_STRLEN($3.u.constant) == 5 && !strncasecmp("class", Z_STRVAL($3.u.constant), 5)) { efree(Z_STRVAL($3.u.constant)); zend_do_resolve_class_name(&$$, &$1, 1 TSRMLS_CC); } else { zend_do_fetch_constant(&$$, &$1, &$3, ZEND_CT, 0 TSRMLS_CC); } }
 ;
 
 scalar:
 		T_STRING_VARNAME		{ $$ = $1; }
-	|	class_name_scalar	{ $$ = $1; }
+	|	class_name_scalar		{ $$ = $1; }
 	|	class_constant		{ $$ = $1; }
 	|	namespace_name	{ zend_do_fetch_constant(&$$, NULL, &$1, ZEND_RT, 1 TSRMLS_CC); }
 	|	T_NAMESPACE T_NS_SEPARATOR namespace_name { $$.op_type = IS_CONST; ZVAL_EMPTY_STRING(&$$.u.constant);  zend_do_build_namespace_name(&$$, &$$, &$3 TSRMLS_CC); $3 = $$; zend_do_fetch_constant(&$$, NULL, &$3, ZEND_RT, 0 TSRMLS_CC); }
@@ -1006,7 +1001,6 @@ r_variable:
 	variable { zend_do_end_variable_parse(&$1, BP_VAR_R, 0 TSRMLS_CC); $$ = $1; }
 ;
 
-
 w_variable:
 	variable	{ zend_do_end_variable_parse(&$1, BP_VAR_W, 0 TSRMLS_CC); $$ = $1;
 				  zend_check_writable_variable(&$1); }
@@ -1077,7 +1071,6 @@ base_variable_with_function_calls:
 	|	function_call { zend_do_begin_variable_parse(TSRMLS_C); $$ = $1; $$.EA = ZEND_PARSED_FUNCTION_CALL; }
 ;
 
-
 base_variable:
 		reference_variable { $$ = $1; $$.EA = ZEND_PARSED_VARIABLE; }
 	|	simple_indirect_reference reference_variable { zend_do_indirect_references(&$$, &$1, &$2 TSRMLS_CC); $$.EA = ZEND_PARSED_VARIABLE; }
diff --git a/Zend/zend_language_scanner.c b/Zend/zend_language_scanner.c
index d5768d3345569..3b35c6df35688 100644
--- a/Zend/zend_language_scanner.c
+++ b/Zend/zend_language_scanner.c
@@ -114,15 +114,19 @@ do {																			\
 	} \
 }
 
-/* To save initial string length after scanning to first variable, CG(doc_comment_len) can be reused */
-#define SET_DOUBLE_QUOTES_SCANNED_LENGTH(len) CG(doc_comment_len) = (len)
-#define GET_DOUBLE_QUOTES_SCANNED_LENGTH()    CG(doc_comment_len)
+/* To save initial string length after scanning to first variable, SCNG(doc_comment_len) can be reused */
+#define SET_DOUBLE_QUOTES_SCANNED_LENGTH(len) SCNG(doc_comment_len) = (len)
+#define GET_DOUBLE_QUOTES_SCANNED_LENGTH()    SCNG(doc_comment_len)
 
 #define IS_LABEL_START(c) (((c) >= 'a' && (c) <= 'z') || ((c) >= 'A' && (c) <= 'Z') || (c) == '_' || (c) >= 0x7F)
 
 #define ZEND_IS_OCT(c)  ((c)>='0' && (c)<='7')
 #define ZEND_IS_HEX(c)  (((c)>='0' && (c)<='9') || ((c)>='a' && (c)<='f') || ((c)>='A' && (c)<='F'))
 
+static zend_bool lex_is_real_string_token_table[512];
+
+static zend_always_inline zend_bool lex_is_real_string_token(int token);
+
 BEGIN_EXTERN_C()
 
 static size_t encoding_filter_script_to_internal(unsigned char **to, size_t *to_length, const unsigned char *from, size_t from_length TSRMLS_DC)
@@ -179,6 +183,10 @@ static void yy_scan_buffer(char *str, unsigned int len TSRMLS_DC)
 
 void startup_scanner(TSRMLS_D)
 {
+	int i;
+	for (i = -1; ++i < 512;) {
+		lex_is_real_string_token_table[i] = lex_is_real_string_token(i);
+	}
 	CG(parse_error) = 0;
 	CG(doc_comment) = NULL;
 	CG(doc_comment_len) = 0;
@@ -988,8 +996,366 @@ static void zend_scan_escape_string(zval *zendlval, char *str, int len, char quo
 	}
 }
 
+int lex_scan_ex(zval *zendlval TSRMLS_DC);
+
+#define LEX_BUF_ADD_EX \
+	buf_tmp = CG(tokenbuffer) + (++CG(tokenbufptr)); \
+	buf_tmp->zv = *zendlval; \
+	buf_tmp->token = retval; \
+	buf_tmp->text = SCNG(yy_text); \
+	buf_tmp->len = SCNG(yy_leng); \
+	buf_tmp->start = SCNG(yy_cursor); \
+	buf_tmp->end = SCNG(yy_limit); \
+	if (retval == T_DOC_COMMENT) { \
+		buf_tmp->doc_comment = SCNG(doc_comment); \
+		buf_tmp->doc_comment_len = SCNG(doc_comment_len); \
+	} \
+	buf_tmp->lineno = CG(zend_lineno);
+
+#define LEX_BUF_ADD \
+	buf_two = buf_one; \
+	buf_two_token = buf_one_token; \
+	LEX_BUF_ADD_EX \
+	buf_one = buf_tmp; \
+	buf_one_token = retval; \
+	goto again;
+
+static zend_always_inline int lex_get_real_buf_offset(const int relpos) {
+	int effective_pos = CG(tokenbufptr) - relpos + 1;
+	int i = CG(tokenbufptr) + 1;
+	while (--i >= effective_pos) {
+		switch(CG(tokenbuffer)[i].token) {
+			PARSER_IGNORED_TOKEN_CASES
+				--effective_pos;
+		}
+	}
+	return effective_pos >= 0?effective_pos:-1;
+}
+
+#define LEX_REL_BUF(relpos) \
+	(CG(tokenbuffer)[lex_get_real_buf_offset(relpos)])
+
+static zend_always_inline zend_bool lex_is_real_string_token(int token) {
+	switch (token) {
+		PARSER_IGNORED_TOKEN_CASES
+		COPIED_STRING_TOKEN_CASES
+			return 1;
+	}
+	return token < 256;
+}
+
+#define LEX_IS_CUR_ALPH_TOKEN() \
+	(Z_TYPE_P(zendlval) == 255 && !lex_is_real_string_token_table[retval])
+
+#define LEX_IS_REL_ALPH_TOKEN(relpos) \
+	(Z_TYPE(LEX_REL_BUF(relpos).zv) == 255 && !lex_is_real_string_token_table[LEX_REL_BUF(relpos).token])
+
+#define LEX_IS_BUF_ALPH_TOKEN(buf) \
+	(Z_TYPE(buf->zv) == 255 && !lex_is_real_string_token_table[buf##_token])
+
+#define LEX_CONVERT_STRING(token, zval, text, len) \
+	token = T_STRING; \
+	Z_STRLEN(zval) = len; \
+	Z_STRVAL(zval) = estrndup(text, len); \
+	Z_TYPE(zval) = IS_STRING;
+
+#define LEX_CONVERT_CUR_STRING() LEX_CONVERT_STRING(retval, *zendlval, yytext, yyleng) goto leave;
+
+#define LEX_CONVERT_REL_STRING(relpos) LEX_CONVERT_STRING(LEX_REL_BUF(relpos).token, LEX_REL_BUF(relpos).zv, (char *)LEX_REL_BUF(relpos).text, LEX_REL_BUF(relpos).len)
+
+#define LEX_CONVERT_BUF_STRING(buf) LEX_CONVERT_STRING(buf##_token, buf->zv, (char *)buf->text, buf->len) buf->token = buf##_token;
+
+#define LEX_PREPARE_RETURN_FROM_BUF \
+	buf_tmp = CG(tokenbuffer) + CG(tokenbufptr)++; \
+	*zendlval = buf_tmp->zv; \
+	if (Z_TYPE_P(zendlval) == 255) { \
+		Z_TYPE_P(zendlval) = 0; \
+	} \
+	retval = buf_tmp->token; \
+	if (retval == '}' || retval == T_DOC_COMMENT) { \
+		RESET_DOC_COMMENT(); \
+	} \
+	SCNG(yy_text) = buf_tmp->text; \
+	SCNG(yy_leng) = buf_tmp->len; \
+	SCNG(yy_cursor) = buf_tmp->start; \
+	SCNG(yy_limit) = buf_tmp->end; \
+	if (retval == T_DOC_COMMENT) { \
+		CG(doc_comment) = buf_tmp->doc_comment; \
+		CG(doc_comment_len) = buf_tmp->doc_comment_len; \
+	} \
+	CG(zend_lineno) = buf_tmp->lineno;
+
+/* This function checks the cases where a token needs to be converted to some other token to simplify parsing */
+/* Also it shouldn't be done in parser, because it actually breaks applications relying on token_get_all output */
+/* Doing it in parser also would make highlight_string() etc. look ugly when tokens are used as other tokens */
+/* The real lexing step is done in lex_scan_ex */
+int lex_scan(zval *zendlval) {
+	int retval;
+	token_buf *buf_one, *buf_two, *buf_tmp;
+	int buf_one_token, buf_two_token;
+
+	if (CG(tokenbufptr) != -1) {
+		if (CG(tokenbuffer)[CG(tokenbufptr)].token != -1) {
+			LEX_PREPARE_RETURN_FROM_BUF
+			return retval;
+		}
+		CG(tokenbufptr) = -1;
+	}
+
+	buf_one = CG(tokenbuffer) - 1;
+	buf_one_token = buf_one->token;
+	buf_two = buf_one;
+	buf_two_token = buf_one_token;
+
+again:
+	Z_TYPE_P(zendlval) = 0;
+	retval = lex_scan_ex(zendlval);
+
+	switch (retval) {
+		COPIED_STRING_TOKEN_CASES
+			goto leave;
+	}
+	if (retval) {
+		if (CG(tokenbufptr) >= CG(tokenbufsize) - 4) {
+			CG(tokenbuffer) = erealloc(--CG(tokenbuffer), sizeof(token_buf) * ((CG(tokenbufsize) *= 2) + 1));
+			CG(tokenbuffer)++;
+			buf_one = CG(tokenbuffer) + lex_get_real_buf_offset(1);
+			buf_one_token = buf_one->token;
+			buf_two = CG(tokenbuffer) + lex_get_real_buf_offset(2);
+			buf_two_token = buf_two->token;
+		}
+
+		if (CG(tokenbufptr) != -1) {
+			switch (retval) {
+				PARSER_IGNORED_TOKEN_CASES
+					LEX_BUF_ADD_EX
+					goto again;
+			}
+
+			/* class access */
+			/* class name */
+			if (retval == T_PAAMAYIM_NEKUDOTAYIM && LEX_IS_BUF_ALPH_TOKEN(buf_one)) {
+				LEX_CONVERT_BUF_STRING(buf_one);
+			}
+			/* class const / method name */
+			if (buf_one_token == T_PAAMAYIM_NEKUDOTAYIM && LEX_IS_CUR_ALPH_TOKEN()) {
+				/* ::class is reserved */
+				if (retval == T_CLASS) {
+					goto leave;
+				}
+				LEX_CONVERT_CUR_STRING();
+			}
+
+			/* classes */
+			if (CG(tokenbuf_in_class) != -1 && LEX_IS_CUR_ALPH_TOKEN()) {
+				/* class name */
+				switch (buf_one_token) {
+					case T_CLASS:
+					case T_INTERFACE:
+					case T_TRAIT:
+						if (retval != T_NAMESPACE) {
+							LEX_CONVERT_CUR_STRING();
+						}
+				}
+				if (CG(tokenbuf_in_class) == 0 && retval != T_NAMESPACE && (((retval != T_IMPLEMENTS && retval != T_EXTENDS) || buf_one_token == ',' || buf_one_token == T_IMPLEMENTS) || (retval == T_IMPLEMENTS && buf_one_token == T_EXTENDS)) && LEX_IS_CUR_ALPH_TOKEN()) {
+					LEX_CONVERT_CUR_STRING();
+				}
+				/* method names */
+				if ((buf_one_token == T_FUNCTION || (buf_one_token == '&' && buf_two_token == T_FUNCTION)) && LEX_IS_CUR_ALPH_TOKEN()) {
+					LEX_CONVERT_CUR_STRING();
+				}
+				/* constant names */
+				if (buf_one_token == T_CONST && LEX_IS_CUR_ALPH_TOKEN()) {
+					LEX_CONVERT_CUR_STRING();
+				}
+				/* trait use aliasing */
+				if (CG(tokenbuf_mode) == LEX_USE_TOKEN_MODE) {
+					if (retval == ';' && LEX_IS_BUF_ALPH_TOKEN(buf_one)) {
+						switch (buf_one_token) {
+							case T_PUBLIC:
+							case T_PROTECTED:
+							case T_PRIVATE:
+								break;
+							default:
+								LEX_BUF_ADD
+						}
+					}
+					if (buf_one_token == T_INSTEADOF && LEX_IS_CUR_ALPH_TOKEN()) {
+						LEX_BUF_ADD
+					}
+				}
+			}
+
+			/* class name typehints */
+			if (CG(tokenbuf_fn_decl) == 0 && (buf_one_token == '(' || buf_one_token == ',') && retval != T_NAMESPACE && LEX_IS_CUR_ALPH_TOKEN()) {
+				LEX_CONVERT_CUR_STRING();
+			}
+
+			/* goto & labels */
+			if ((retval == ':' || (retval == ';' && buf_two_token == T_GOTO)) && LEX_IS_BUF_ALPH_TOKEN(buf_one)) {
+				/* disallow replacing of alternative syntax and default (in switch) */
+				switch (buf_one_token) {
+					case T_DEFAULT:
+					case T_ELSE:
+						break;
+					default:
+						LEX_CONVERT_BUF_STRING(buf_one);
+				}
+			}
+			if (buf_one_token == T_GOTO && LEX_IS_CUR_ALPH_TOKEN() && retval != T_DEFAULT) {
+				LEX_CONVERT_CUR_STRING();
+			}
+
+			/* namespaces */
+			/* Disallow T_NAMESPACE because of namespace\string syntax */
+			switch (buf_one_token) {
+				case T_USE:
+					if (CG(tokenbuf_in_class) != -1) {
+						break;
+					}
+				case T_NEW:
+				case T_NAMESPACE:
+					if (retval != T_NAMESPACE && LEX_IS_CUR_ALPH_TOKEN()) {
+						LEX_CONVERT_CUR_STRING();
+					}
+			}
+			if (buf_two_token == T_NS_SEPARATOR && LEX_IS_BUF_ALPH_TOKEN(buf_one) && (retval != T_NS_SEPARATOR || buf_one_token != T_NAMESPACE)) {
+				LEX_CONVERT_BUF_STRING(buf_one);
+			}
+
+			if (retval == T_NS_SEPARATOR) {
+				switch (buf_one_token) {
+					case T_NAMESPACE:
+						break;
+					case T_NEW:
+						if (buf_two_token == T_THROW || buf_two_token == T_RETURN || buf_two_token == ',') {
+							break;
+						}
+					case T_USE:
+					case T_ECHO:
+					case T_YIELD:
+						if (buf_two_token < 256 && buf_two_token != ',') {
+							break;
+						}
+					case T_IMPLEMENTS:
+						if (buf_one_token == T_IMPLEMENTS && buf_two_token != T_IMPLEMENTS && buf_two_token != T_EXTENDS && buf_two_token != ',') {
+							break;
+						}
+					case T_EXTENDS:
+						if (buf_one_token == T_EXTENDS && buf_two_token != T_EXTENDS && buf_two_token != ',') {
+							break;
+						}
+					default:
+						if (LEX_IS_BUF_ALPH_TOKEN(buf_one)) {
+							LEX_CONVERT_BUF_STRING(buf_one);
+						}
+				}
+			}
+			/* handling of multiple comma separated T_USE */
+			if (CG(tokenbuf_mode) == LEX_USE_TOKEN_MODE && LEX_IS_CUR_ALPH_TOKEN() && buf_one_token == ',') {
+				LEX_CONVERT_CUR_STRING();
+			}
+
+			/* Handling of T_HALT_COMPILER; might cause memory leaks if not handled */
+			if (
+				   (buf_one_token == T_HALT_COMPILER && retval == '(')
+				|| (buf_two_token == T_HALT_COMPILER && buf_one_token == '(' && retval == ')')
+			   ) {
+				LEX_BUF_ADD
+			}
+		}
+
+		switch (retval) {
+			case '{':
+				if (CG(tokenbuf_in_class) != -1) {
+					++CG(tokenbuf_in_class);
+				}
+				break;
+			case '}':
+				if (CG(tokenbuf_in_class) != -1 && --CG(tokenbuf_in_class) == 0) {
+					CG(tokenbuf_in_class) = -1;
+				}
+				break;
+			case T_CLASS:
+			case T_INTERFACE:
+			case T_TRAIT:
+				if (CG(tokenbuf_in_class) == -1) {
+					CG(tokenbuf_in_class) = 0;
+				}
+				break;
+			case ';':
+				if (CG(tokenbuf_mode) == LEX_USE_TOKEN_MODE) {
+					CG(tokenbuf_mode) = LEX_NO_TOKEN_MODE;
+				}
+				break;
+			case T_FUNCTION:
+				if (CG(tokenbuf_mode) == LEX_NO_TOKEN_MODE) {
+					CG(tokenbuf_mode) = LEX_FUNC_NAMING_TOKEN_MODE;
+				}
+				break;
+			case '(':
+				if (CG(tokenbuf_mode) == LEX_FUNC_NAMING_TOKEN_MODE) {
+					CG(tokenbuf_mode) = LEX_NO_TOKEN_MODE;
+					CG(tokenbuf_fn_decl) = 0;
+				} else if (CG(tokenbuf_fn_decl) != -1) {
+					++CG(tokenbuf_fn_decl);
+				}
+				break;
+			case ')':
+				if (CG(tokenbuf_fn_decl) != -1) {
+					--CG(tokenbuf_fn_decl);
+				}
+				break;
+			case T_USE:
+				if (CG(tokenbuf_mode) == LEX_NO_TOKEN_MODE) {
+					CG(tokenbuf_mode) = LEX_USE_TOKEN_MODE;
+				}
+				break;
+		}
+
+		if (LEX_IS_CUR_ALPH_TOKEN()) {
+			LEX_BUF_ADD
+		} else {
+			switch (retval) {
+				case ';':
+					if (buf_two_token == '(' && LEX_REL_BUF(3).token == T_HALT_COMPILER) {
+						break;
+					}
+				case '&':
+				case ',':
+				case '(':
+				case T_PAAMAYIM_NEKUDOTAYIM:
+				case T_NS_SEPARATOR:
+					LEX_BUF_ADD
+			}
+		}
+	}
+
+leave:
+
+	if (CG(tokenbufptr) != -1) {
+		LEX_BUF_ADD_EX
+		CG(tokenbuffer)[CG(tokenbufptr) + 1].token = -1;
+		CG(tokenbufptr) = 0;
+		LEX_PREPARE_RETURN_FROM_BUF
+	} else if (retval == '}' || retval == T_DOC_COMMENT) {
+		RESET_DOC_COMMENT();
+		if (retval == T_DOC_COMMENT) {
+			CG(doc_comment) = SCNG(doc_comment);
+			CG(doc_comment_len) = SCNG(doc_comment_len);
+		}
+	}
+
+	return retval;
+}
+
+/* Mark token as eventual T_STRING */
+#define RETURN_STRING_TOKEN(token) \
+	Z_TYPE_P(zendlval) = 255; /* mark keyword ready for eventual conversion to T_STRING in lex_scan function */ \
+	return token;
 
-int lex_scan(zval *zendlval TSRMLS_DC)
+/* "Real" lexer (see comments above to function lex_scan) */
+int lex_scan_ex(zval *zendlval TSRMLS_DC)
 {
 restart:
 	SCNG(yy_text) = YYCURSOR;
@@ -997,7 +1363,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 yymore_restart:
 
 
-#line 1001 "Zend/zend_language_scanner.c"
+#line 1367 "Zend/zend_language_scanner.c"
 {
 	YYCTYPE yych;
 	unsigned int yyaccept = 0;
@@ -1096,7 +1462,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 yy3:
 		YYDEBUG(3, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1738 "Zend/zend_language_scanner.l"
+#line 2103 "Zend/zend_language_scanner.l"
 		{
 	if (YYCURSOR > YYLIMIT) {
 		return 0;
@@ -1156,7 +1522,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 	HANDLE_NEWLINES(yytext, yyleng);
 	return T_INLINE_HTML;
 }
-#line 1160 "Zend/zend_language_scanner.c"
+#line 1526 "Zend/zend_language_scanner.c"
 yy4:
 		YYDEBUG(4, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -1174,7 +1540,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 yy6:
 		YYDEBUG(6, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1728 "Zend/zend_language_scanner.l"
+#line 2093 "Zend/zend_language_scanner.l"
 		{
 	if (CG(short_tags)) {
 		ZVAL_STRINGL(zendlval, yytext, yyleng, 0); /* no copying - intentional */
@@ -1184,14 +1550,14 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		goto inline_char_handler;
 	}
 }
-#line 1188 "Zend/zend_language_scanner.c"
+#line 1554 "Zend/zend_language_scanner.c"
 yy7:
 		YYDEBUG(7, *YYCURSOR);
 		++YYCURSOR;
 		if ((yych = *YYCURSOR) == '=') goto yy43;
 		YYDEBUG(8, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1709 "Zend/zend_language_scanner.l"
+#line 2074 "Zend/zend_language_scanner.l"
 		{
 	if (CG(asp_tags)) {
 		ZVAL_STRINGL(zendlval, yytext, yyleng, 0); /* no copying - intentional */
@@ -1201,7 +1567,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		goto inline_char_handler;
 	}
 }
-#line 1205 "Zend/zend_language_scanner.c"
+#line 1571 "Zend/zend_language_scanner.c"
 yy9:
 		YYDEBUG(9, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -1387,7 +1753,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		++YYCURSOR;
 		YYDEBUG(38, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1675 "Zend/zend_language_scanner.l"
+#line 2040 "Zend/zend_language_scanner.l"
 		{
 	YYCTYPE *bracket = (YYCTYPE*)zend_memrchr(yytext, '<', yyleng - (sizeof("script language=php>") - 1));
 
@@ -1402,7 +1768,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 	BEGIN(ST_IN_SCRIPTING);
 	return T_OPEN_TAG;
 }
-#line 1406 "Zend/zend_language_scanner.c"
+#line 1772 "Zend/zend_language_scanner.c"
 yy39:
 		YYDEBUG(39, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -1429,7 +1795,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		++YYCURSOR;
 		YYDEBUG(44, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1691 "Zend/zend_language_scanner.l"
+#line 2056 "Zend/zend_language_scanner.l"
 		{
 	if (CG(asp_tags)) {
 		ZVAL_STRINGL(zendlval, yytext, yyleng, 0); /* no copying - intentional */
@@ -1439,19 +1805,19 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		goto inline_char_handler;
 	}
 }
-#line 1443 "Zend/zend_language_scanner.c"
+#line 1809 "Zend/zend_language_scanner.c"
 yy45:
 		YYDEBUG(45, *YYCURSOR);
 		++YYCURSOR;
 		YYDEBUG(46, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1702 "Zend/zend_language_scanner.l"
+#line 2067 "Zend/zend_language_scanner.l"
 		{
 	ZVAL_STRINGL(zendlval, yytext, yyleng, 0); /* no copying - intentional */
 	BEGIN(ST_IN_SCRIPTING);
 	return T_OPEN_TAG_WITH_ECHO;
 }
-#line 1455 "Zend/zend_language_scanner.c"
+#line 1821 "Zend/zend_language_scanner.c"
 yy47:
 		YYDEBUG(47, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -1478,14 +1844,14 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 yy51:
 		YYDEBUG(51, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1720 "Zend/zend_language_scanner.l"
+#line 2085 "Zend/zend_language_scanner.l"
 		{
 	ZVAL_STRINGL(zendlval, yytext, yyleng, 0); /* no copying - intentional */
 	HANDLE_NEWLINE(yytext[yyleng-1]);
 	BEGIN(ST_IN_SCRIPTING);
 	return T_OPEN_TAG;
 }
-#line 1489 "Zend/zend_language_scanner.c"
+#line 1855 "Zend/zend_language_scanner.c"
 yy52:
 		YYDEBUG(52, *YYCURSOR);
 		++YYCURSOR;
@@ -1556,7 +1922,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 yy56:
 		YYDEBUG(56, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 2183 "Zend/zend_language_scanner.l"
+#line 2547 "Zend/zend_language_scanner.l"
 		{
 	if (YYCURSOR > YYLIMIT) {
 		return 0;
@@ -1597,7 +1963,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 	zend_scan_escape_string(zendlval, yytext, yyleng, '`' TSRMLS_CC);
 	return T_ENCAPSED_AND_WHITESPACE;
 }
-#line 1601 "Zend/zend_language_scanner.c"
+#line 1967 "Zend/zend_language_scanner.c"
 yy57:
 		YYDEBUG(57, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -1608,12 +1974,12 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		++YYCURSOR;
 		YYDEBUG(59, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 2127 "Zend/zend_language_scanner.l"
+#line 2491 "Zend/zend_language_scanner.l"
 		{
 	BEGIN(ST_IN_SCRIPTING);
 	return '`';
 }
-#line 1617 "Zend/zend_language_scanner.c"
+#line 1983 "Zend/zend_language_scanner.c"
 yy60:
 		YYDEBUG(60, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -1623,14 +1989,14 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		++YYCURSOR;
 		YYDEBUG(62, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 2114 "Zend/zend_language_scanner.l"
+#line 2478 "Zend/zend_language_scanner.l"
 		{
 	Z_LVAL_P(zendlval) = (long) '{';
 	yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
 	yyless(1);
 	return T_CURLY_OPEN;
 }
-#line 1634 "Zend/zend_language_scanner.c"
+#line 2000 "Zend/zend_language_scanner.c"
 yy63:
 		YYDEBUG(63, *YYCURSOR);
 		yyaccept = 0;
@@ -1646,24 +2012,24 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 yy65:
 		YYDEBUG(65, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1820 "Zend/zend_language_scanner.l"
+#line 2185 "Zend/zend_language_scanner.l"
 		{
 	zend_copy_value(zendlval, (yytext+1), (yyleng-1));
 	zendlval->type = IS_STRING;
 	return T_VARIABLE;
 }
-#line 1656 "Zend/zend_language_scanner.c"
+#line 2022 "Zend/zend_language_scanner.c"
 yy66:
 		YYDEBUG(66, *YYCURSOR);
 		++YYCURSOR;
 		YYDEBUG(67, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1454 "Zend/zend_language_scanner.l"
+#line 1820 "Zend/zend_language_scanner.l"
 		{
 	yy_push_state(ST_LOOKING_FOR_VARNAME TSRMLS_CC);
 	return T_DOLLAR_OPEN_CURLY_BRACES;
 }
-#line 1667 "Zend/zend_language_scanner.c"
+#line 2033 "Zend/zend_language_scanner.c"
 yy68:
 		YYDEBUG(68, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -1677,7 +2043,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		++YYCURSOR;
 		YYDEBUG(71, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1812 "Zend/zend_language_scanner.l"
+#line 2177 "Zend/zend_language_scanner.l"
 		{
 	yyless(yyleng - 1);
 	yy_push_state(ST_VAR_OFFSET TSRMLS_CC);
@@ -1685,7 +2051,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 	zendlval->type = IS_STRING;
 	return T_VARIABLE;
 }
-#line 1689 "Zend/zend_language_scanner.c"
+#line 2055 "Zend/zend_language_scanner.c"
 yy72:
 		YYDEBUG(72, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -1703,7 +2069,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		++YYCURSOR;
 		YYDEBUG(74, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1802 "Zend/zend_language_scanner.l"
+#line 2167 "Zend/zend_language_scanner.l"
 		{
 	yyless(yyleng - 3);
 	yy_push_state(ST_LOOKING_FOR_PROPERTY TSRMLS_CC);
@@ -1711,7 +2077,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 	zendlval->type = IS_STRING;
 	return T_VARIABLE;
 }
-#line 1715 "Zend/zend_language_scanner.c"
+#line 2081 "Zend/zend_language_scanner.c"
 	}
 /* *********************************** */
 yyc_ST_DOUBLE_QUOTES:
@@ -1779,7 +2145,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 yy78:
 		YYDEBUG(78, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 2133 "Zend/zend_language_scanner.l"
+#line 2497 "Zend/zend_language_scanner.l"
 		{
 	if (GET_DOUBLE_QUOTES_SCANNED_LENGTH()) {
 		YYCURSOR += GET_DOUBLE_QUOTES_SCANNED_LENGTH() - 1;
@@ -1828,7 +2194,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 	zend_scan_escape_string(zendlval, yytext, yyleng, '"' TSRMLS_CC);
 	return T_ENCAPSED_AND_WHITESPACE;
 }
-#line 1832 "Zend/zend_language_scanner.c"
+#line 2198 "Zend/zend_language_scanner.c"
 yy79:
 		YYDEBUG(79, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -1839,12 +2205,12 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		++YYCURSOR;
 		YYDEBUG(81, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 2122 "Zend/zend_language_scanner.l"
+#line 2486 "Zend/zend_language_scanner.l"
 		{
 	BEGIN(ST_IN_SCRIPTING);
 	return '"';
 }
-#line 1848 "Zend/zend_language_scanner.c"
+#line 2214 "Zend/zend_language_scanner.c"
 yy82:
 		YYDEBUG(82, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -1854,14 +2220,14 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		++YYCURSOR;
 		YYDEBUG(84, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 2114 "Zend/zend_language_scanner.l"
+#line 2478 "Zend/zend_language_scanner.l"
 		{
 	Z_LVAL_P(zendlval) = (long) '{';
 	yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
 	yyless(1);
 	return T_CURLY_OPEN;
 }
-#line 1865 "Zend/zend_language_scanner.c"
+#line 2231 "Zend/zend_language_scanner.c"
 yy85:
 		YYDEBUG(85, *YYCURSOR);
 		yyaccept = 0;
@@ -1877,24 +2243,24 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 yy87:
 		YYDEBUG(87, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1820 "Zend/zend_language_scanner.l"
+#line 2185 "Zend/zend_language_scanner.l"
 		{
 	zend_copy_value(zendlval, (yytext+1), (yyleng-1));
 	zendlval->type = IS_STRING;
 	return T_VARIABLE;
 }
-#line 1887 "Zend/zend_language_scanner.c"
+#line 2253 "Zend/zend_language_scanner.c"
 yy88:
 		YYDEBUG(88, *YYCURSOR);
 		++YYCURSOR;
 		YYDEBUG(89, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1454 "Zend/zend_language_scanner.l"
+#line 1820 "Zend/zend_language_scanner.l"
 		{
 	yy_push_state(ST_LOOKING_FOR_VARNAME TSRMLS_CC);
 	return T_DOLLAR_OPEN_CURLY_BRACES;
 }
-#line 1898 "Zend/zend_language_scanner.c"
+#line 2264 "Zend/zend_language_scanner.c"
 yy90:
 		YYDEBUG(90, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -1908,7 +2274,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		++YYCURSOR;
 		YYDEBUG(93, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1812 "Zend/zend_language_scanner.l"
+#line 2177 "Zend/zend_language_scanner.l"
 		{
 	yyless(yyleng - 1);
 	yy_push_state(ST_VAR_OFFSET TSRMLS_CC);
@@ -1916,7 +2282,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 	zendlval->type = IS_STRING;
 	return T_VARIABLE;
 }
-#line 1920 "Zend/zend_language_scanner.c"
+#line 2286 "Zend/zend_language_scanner.c"
 yy94:
 		YYDEBUG(94, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -1934,7 +2300,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		++YYCURSOR;
 		YYDEBUG(96, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1802 "Zend/zend_language_scanner.l"
+#line 2167 "Zend/zend_language_scanner.l"
 		{
 	yyless(yyleng - 3);
 	yy_push_state(ST_LOOKING_FOR_PROPERTY TSRMLS_CC);
@@ -1942,7 +2308,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 	zendlval->type = IS_STRING;
 	return T_VARIABLE;
 }
-#line 1946 "Zend/zend_language_scanner.c"
+#line 2312 "Zend/zend_language_scanner.c"
 	}
 /* *********************************** */
 yyc_ST_END_HEREDOC:
@@ -1953,7 +2319,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 	++YYCURSOR;
 	YYDEBUG(100, *YYCURSOR);
 	yyleng = YYCURSOR - SCNG(yy_text);
-#line 2100 "Zend/zend_language_scanner.l"
+#line 2464 "Zend/zend_language_scanner.l"
 	{
 	zend_heredoc_label *heredoc_label = zend_ptr_stack_pop(&SCNG(heredoc_label_stack));
 
@@ -1966,7 +2332,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 	BEGIN(ST_IN_SCRIPTING);
 	return T_END_HEREDOC;
 }
-#line 1970 "Zend/zend_language_scanner.c"
+#line 2336 "Zend/zend_language_scanner.c"
 /* *********************************** */
 yyc_ST_HEREDOC:
 	{
@@ -2028,7 +2394,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 yy104:
 		YYDEBUG(104, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 2225 "Zend/zend_language_scanner.l"
+#line 2589 "Zend/zend_language_scanner.l"
 		{
 	int newline = 0;
 
@@ -2101,7 +2467,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 	zend_scan_escape_string(zendlval, yytext, yyleng - newline, 0 TSRMLS_CC);
 	return T_ENCAPSED_AND_WHITESPACE;
 }
-#line 2105 "Zend/zend_language_scanner.c"
+#line 2471 "Zend/zend_language_scanner.c"
 yy105:
 		YYDEBUG(105, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -2116,14 +2482,14 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		++YYCURSOR;
 		YYDEBUG(108, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 2114 "Zend/zend_language_scanner.l"
+#line 2478 "Zend/zend_language_scanner.l"
 		{
 	Z_LVAL_P(zendlval) = (long) '{';
 	yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
 	yyless(1);
 	return T_CURLY_OPEN;
 }
-#line 2127 "Zend/zend_language_scanner.c"
+#line 2493 "Zend/zend_language_scanner.c"
 yy109:
 		YYDEBUG(109, *YYCURSOR);
 		yyaccept = 0;
@@ -2139,24 +2505,24 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 yy111:
 		YYDEBUG(111, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1820 "Zend/zend_language_scanner.l"
+#line 2185 "Zend/zend_language_scanner.l"
 		{
 	zend_copy_value(zendlval, (yytext+1), (yyleng-1));
 	zendlval->type = IS_STRING;
 	return T_VARIABLE;
 }
-#line 2149 "Zend/zend_language_scanner.c"
+#line 2515 "Zend/zend_language_scanner.c"
 yy112:
 		YYDEBUG(112, *YYCURSOR);
 		++YYCURSOR;
 		YYDEBUG(113, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1454 "Zend/zend_language_scanner.l"
+#line 1820 "Zend/zend_language_scanner.l"
 		{
 	yy_push_state(ST_LOOKING_FOR_VARNAME TSRMLS_CC);
 	return T_DOLLAR_OPEN_CURLY_BRACES;
 }
-#line 2160 "Zend/zend_language_scanner.c"
+#line 2526 "Zend/zend_language_scanner.c"
 yy114:
 		YYDEBUG(114, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -2170,7 +2536,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		++YYCURSOR;
 		YYDEBUG(117, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1812 "Zend/zend_language_scanner.l"
+#line 2177 "Zend/zend_language_scanner.l"
 		{
 	yyless(yyleng - 1);
 	yy_push_state(ST_VAR_OFFSET TSRMLS_CC);
@@ -2178,7 +2544,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 	zendlval->type = IS_STRING;
 	return T_VARIABLE;
 }
-#line 2182 "Zend/zend_language_scanner.c"
+#line 2548 "Zend/zend_language_scanner.c"
 yy118:
 		YYDEBUG(118, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -2196,7 +2562,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		++YYCURSOR;
 		YYDEBUG(120, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1802 "Zend/zend_language_scanner.l"
+#line 2167 "Zend/zend_language_scanner.l"
 		{
 	yyless(yyleng - 3);
 	yy_push_state(ST_LOOKING_FOR_PROPERTY TSRMLS_CC);
@@ -2204,7 +2570,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 	zendlval->type = IS_STRING;
 	return T_VARIABLE;
 }
-#line 2208 "Zend/zend_language_scanner.c"
+#line 2574 "Zend/zend_language_scanner.c"
 	}
 /* *********************************** */
 yyc_ST_IN_SCRIPTING:
@@ -2387,13 +2753,13 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 yy124:
 		YYDEBUG(124, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1843 "Zend/zend_language_scanner.l"
+#line 2208 "Zend/zend_language_scanner.l"
 		{
 	zend_copy_value(zendlval, yytext, yyleng);
 	zendlval->type = IS_STRING;
 	return T_STRING;
 }
-#line 2397 "Zend/zend_language_scanner.c"
+#line 2763 "Zend/zend_language_scanner.c"
 yy125:
 		YYDEBUG(125, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -2625,11 +2991,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 yy139:
 		YYDEBUG(139, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1443 "Zend/zend_language_scanner.l"
+#line 1809 "Zend/zend_language_scanner.l"
 		{
 	return yytext[0];
 }
-#line 2633 "Zend/zend_language_scanner.c"
+#line 2999 "Zend/zend_language_scanner.c"
 yy140:
 		YYDEBUG(140, *YYCURSOR);
 		++YYCURSOR;
@@ -2638,13 +3004,13 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 yy141:
 		YYDEBUG(141, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1176 "Zend/zend_language_scanner.l"
+#line 1542 "Zend/zend_language_scanner.l"
 		{
 	ZVAL_STRINGL(zendlval, yytext, yyleng, 0); /* no copying - intentional */
 	HANDLE_NEWLINES(yytext, yyleng);
 	return T_WHITESPACE;
 }
-#line 2648 "Zend/zend_language_scanner.c"
+#line 3014 "Zend/zend_language_scanner.c"
 yy142:
 		YYDEBUG(142, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -2655,11 +3021,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		++YYCURSOR;
 		YYDEBUG(144, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1203 "Zend/zend_language_scanner.l"
+#line 1569 "Zend/zend_language_scanner.l"
 		{
 	return T_NS_SEPARATOR;
 }
-#line 2663 "Zend/zend_language_scanner.c"
+#line 3029 "Zend/zend_language_scanner.c"
 yy145:
 		YYDEBUG(145, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -2887,26 +3253,25 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		++YYCURSOR;
 		YYDEBUG(169, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1448 "Zend/zend_language_scanner.l"
+#line 1814 "Zend/zend_language_scanner.l"
 		{
 	yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
 	return '{';
 }
-#line 2896 "Zend/zend_language_scanner.c"
+#line 3262 "Zend/zend_language_scanner.c"
 yy170:
 		YYDEBUG(170, *YYCURSOR);
 		++YYCURSOR;
 		YYDEBUG(171, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1460 "Zend/zend_language_scanner.l"
+#line 1826 "Zend/zend_language_scanner.l"
 		{
-	RESET_DOC_COMMENT();
 	if (!zend_stack_is_empty(&SCNG(state_stack))) {
 		yy_pop_state(TSRMLS_C);
 	}
 	return '}';
 }
-#line 2910 "Zend/zend_language_scanner.c"
+#line 3275 "Zend/zend_language_scanner.c"
 yy172:
 		YYDEBUG(172, *YYCURSOR);
 		yyaccept = 2;
@@ -2934,7 +3299,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 yy173:
 		YYDEBUG(173, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1510 "Zend/zend_language_scanner.l"
+#line 1875 "Zend/zend_language_scanner.l"
 		{
 	if (yyleng < MAX_LENGTH_OF_LONG - 1) { /* Won't overflow */
 		Z_LVAL_P(zendlval) = strtol(yytext, NULL, 0);
@@ -2955,7 +3320,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 	zendlval->type = IS_LONG;
 	return T_LNUMBER;
 }
-#line 2959 "Zend/zend_language_scanner.c"
+#line 3324 "Zend/zend_language_scanner.c"
 yy174:
 		YYDEBUG(174, *YYCURSOR);
 		yyaccept = 2;
@@ -2983,7 +3348,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 yy177:
 		YYDEBUG(177, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1850 "Zend/zend_language_scanner.l"
+#line 2215 "Zend/zend_language_scanner.l"
 		{
 	while (YYCURSOR < YYLIMIT) {
 		switch (*YYCURSOR++) {
@@ -3017,14 +3382,14 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 
 	return T_COMMENT;
 }
-#line 3021 "Zend/zend_language_scanner.c"
+#line 3386 "Zend/zend_language_scanner.c"
 yy178:
 		YYDEBUG(178, *YYCURSOR);
 		++YYCURSOR;
 yy179:
 		YYDEBUG(179, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1937 "Zend/zend_language_scanner.l"
+#line 2301 "Zend/zend_language_scanner.l"
 		{
 	register char *s, *t;
 	char *end;
@@ -3090,14 +3455,14 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 	}
 	return T_CONSTANT_ENCAPSED_STRING;
 }
-#line 3094 "Zend/zend_language_scanner.c"
+#line 3459 "Zend/zend_language_scanner.c"
 yy180:
 		YYDEBUG(180, *YYCURSOR);
 		++YYCURSOR;
 yy181:
 		YYDEBUG(181, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 2004 "Zend/zend_language_scanner.l"
+#line 2368 "Zend/zend_language_scanner.l"
 		{
 	int bprefix = (yytext[0] != '"') ? 1 : 0;
 
@@ -3138,24 +3503,24 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 	BEGIN(ST_DOUBLE_QUOTES);
 	return '"';
 }
-#line 3142 "Zend/zend_language_scanner.c"
+#line 3507 "Zend/zend_language_scanner.c"
 yy182:
 		YYDEBUG(182, *YYCURSOR);
 		++YYCURSOR;
 		YYDEBUG(183, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 2094 "Zend/zend_language_scanner.l"
+#line 2458 "Zend/zend_language_scanner.l"
 		{
 	BEGIN(ST_BACKQUOTE);
 	return '`';
 }
-#line 3153 "Zend/zend_language_scanner.c"
+#line 3518 "Zend/zend_language_scanner.c"
 yy184:
 		YYDEBUG(184, *YYCURSOR);
 		++YYCURSOR;
 		YYDEBUG(185, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 2357 "Zend/zend_language_scanner.l"
+#line 2721 "Zend/zend_language_scanner.l"
 		{
 	if (YYCURSOR > YYLIMIT) {
 		return 0;
@@ -3164,7 +3529,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 	zend_error(E_COMPILE_WARNING,"Unexpected character in input:  '%c' (ASCII=%d) state=%d", yytext[0], yytext[0], YYSTATE);
 	goto restart;
 }
-#line 3168 "Zend/zend_language_scanner.c"
+#line 3533 "Zend/zend_language_scanner.c"
 yy186:
 		YYDEBUG(186, *YYCURSOR);
 		++YYCURSOR;
@@ -3191,12 +3556,12 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 yy190:
 		YYDEBUG(190, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1569 "Zend/zend_language_scanner.l"
+#line 1934 "Zend/zend_language_scanner.l"
 		{
 	ZVAL_DOUBLE(zendlval, zend_strtod(yytext, NULL));
 	return T_DNUMBER;
 }
-#line 3200 "Zend/zend_language_scanner.c"
+#line 3565 "Zend/zend_language_scanner.c"
 yy191:
 		YYDEBUG(191, *YYCURSOR);
 		yyaccept = 2;
@@ -3288,7 +3653,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(202, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1486 "Zend/zend_language_scanner.l"
+#line 1851 "Zend/zend_language_scanner.l"
 		{
 	char *bin = yytext + 2; /* Skip "0b" */
 	int len = yyleng - 2;
@@ -3312,7 +3677,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		return T_DNUMBER;
 	}
 }
-#line 3316 "Zend/zend_language_scanner.c"
+#line 3681 "Zend/zend_language_scanner.c"
 yy203:
 		YYDEBUG(203, *YYCURSOR);
 		++YYCURSOR;
@@ -3324,7 +3689,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(205, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1531 "Zend/zend_language_scanner.l"
+#line 1896 "Zend/zend_language_scanner.l"
 		{
 	char *hex = yytext + 2; /* Skip "0x" */
 	int len = yyleng - 2;
@@ -3348,7 +3713,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		return T_DNUMBER;
 	}
 }
-#line 3352 "Zend/zend_language_scanner.c"
+#line 3717 "Zend/zend_language_scanner.c"
 yy206:
 		YYDEBUG(206, *YYCURSOR);
 		++YYCURSOR;
@@ -3357,13 +3722,13 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 yy207:
 		YYDEBUG(207, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1918 "Zend/zend_language_scanner.l"
+#line 2282 "Zend/zend_language_scanner.l"
 		{
 	ZVAL_STRINGL(zendlval, yytext, yyleng, 0); /* no copying - intentional */
 	BEGIN(INITIAL);
 	return T_CLOSE_TAG;  /* implicit ';' at php-end tag */
 }
-#line 3367 "Zend/zend_language_scanner.c"
+#line 3732 "Zend/zend_language_scanner.c"
 yy208:
 		YYDEBUG(208, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -3397,13 +3762,13 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 yy212:
 		YYDEBUG(212, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1820 "Zend/zend_language_scanner.l"
+#line 2185 "Zend/zend_language_scanner.l"
 		{
 	zend_copy_value(zendlval, (yytext+1), (yyleng-1));
 	zendlval->type = IS_STRING;
 	return T_VARIABLE;
 }
-#line 3407 "Zend/zend_language_scanner.c"
+#line 3772 "Zend/zend_language_scanner.c"
 yy213:
 		YYDEBUG(213, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -3417,11 +3782,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(215, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1431 "Zend/zend_language_scanner.l"
+#line 1797 "Zend/zend_language_scanner.l"
 		{
-	return T_LOGICAL_XOR;
+	RETURN_STRING_TOKEN(T_LOGICAL_XOR)
 }
-#line 3425 "Zend/zend_language_scanner.c"
+#line 3790 "Zend/zend_language_scanner.c"
 yy216:
 		YYDEBUG(216, *YYCURSOR);
 		++YYCURSOR;
@@ -3430,61 +3795,61 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(217, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1423 "Zend/zend_language_scanner.l"
+#line 1789 "Zend/zend_language_scanner.l"
 		{
-	return T_LOGICAL_OR;
+	RETURN_STRING_TOKEN(T_LOGICAL_OR)
 }
-#line 3438 "Zend/zend_language_scanner.c"
+#line 3803 "Zend/zend_language_scanner.c"
 yy218:
 		YYDEBUG(218, *YYCURSOR);
 		++YYCURSOR;
 		YYDEBUG(219, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1411 "Zend/zend_language_scanner.l"
+#line 1777 "Zend/zend_language_scanner.l"
 		{
 	return T_XOR_EQUAL;
 }
-#line 3448 "Zend/zend_language_scanner.c"
+#line 3813 "Zend/zend_language_scanner.c"
 yy220:
 		YYDEBUG(220, *YYCURSOR);
 		++YYCURSOR;
 		YYDEBUG(221, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1415 "Zend/zend_language_scanner.l"
+#line 1781 "Zend/zend_language_scanner.l"
 		{
 	return T_BOOLEAN_OR;
 }
-#line 3458 "Zend/zend_language_scanner.c"
+#line 3823 "Zend/zend_language_scanner.c"
 yy222:
 		YYDEBUG(222, *YYCURSOR);
 		++YYCURSOR;
 		YYDEBUG(223, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1407 "Zend/zend_language_scanner.l"
+#line 1773 "Zend/zend_language_scanner.l"
 		{
 	return T_OR_EQUAL;
 }
-#line 3468 "Zend/zend_language_scanner.c"
+#line 3833 "Zend/zend_language_scanner.c"
 yy224:
 		YYDEBUG(224, *YYCURSOR);
 		++YYCURSOR;
 		YYDEBUG(225, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1419 "Zend/zend_language_scanner.l"
+#line 1785 "Zend/zend_language_scanner.l"
 		{
-	return T_BOOLEAN_AND;
+	RETURN_STRING_TOKEN(T_BOOLEAN_AND)
 }
-#line 3478 "Zend/zend_language_scanner.c"
+#line 3843 "Zend/zend_language_scanner.c"
 yy226:
 		YYDEBUG(226, *YYCURSOR);
 		++YYCURSOR;
 		YYDEBUG(227, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1403 "Zend/zend_language_scanner.l"
+#line 1769 "Zend/zend_language_scanner.l"
 		{
 	return T_AND_EQUAL;
 }
-#line 3488 "Zend/zend_language_scanner.c"
+#line 3853 "Zend/zend_language_scanner.c"
 yy228:
 		YYDEBUG(228, *YYCURSOR);
 		++YYCURSOR;
@@ -3493,7 +3858,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 yy229:
 		YYDEBUG(229, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1925 "Zend/zend_language_scanner.l"
+#line 2289 "Zend/zend_language_scanner.l"
 		{
 	if (CG(asp_tags)) {
 		BEGIN(INITIAL);
@@ -3504,17 +3869,17 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		return yytext[0];
 	}
 }
-#line 3508 "Zend/zend_language_scanner.c"
+#line 3873 "Zend/zend_language_scanner.c"
 yy230:
 		YYDEBUG(230, *YYCURSOR);
 		++YYCURSOR;
 		YYDEBUG(231, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1391 "Zend/zend_language_scanner.l"
+#line 1757 "Zend/zend_language_scanner.l"
 		{
 	return T_MOD_EQUAL;
 }
-#line 3518 "Zend/zend_language_scanner.c"
+#line 3883 "Zend/zend_language_scanner.c"
 yy232:
 		YYDEBUG(232, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -3545,11 +3910,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		++YYCURSOR;
 		YYDEBUG(237, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1387 "Zend/zend_language_scanner.l"
+#line 1753 "Zend/zend_language_scanner.l"
 		{
 	return T_CONCAT_EQUAL;
 }
-#line 3553 "Zend/zend_language_scanner.c"
+#line 3918 "Zend/zend_language_scanner.c"
 yy238:
 		YYDEBUG(238, *YYCURSOR);
 		yyaccept = 4;
@@ -3558,13 +3923,12 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 yy239:
 		YYDEBUG(239, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1884 "Zend/zend_language_scanner.l"
+#line 2249 "Zend/zend_language_scanner.l"
 		{
 	int doc_com;
 
 	if (yyleng > 2) {
 		doc_com = 1;
-		RESET_DOC_COMMENT();
 	} else {
 		doc_com = 0;
 	}
@@ -3585,14 +3949,14 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 	HANDLE_NEWLINES(yytext, yyleng);
 
 	if (doc_com) {
-		CG(doc_comment) = estrndup(yytext, yyleng);
-		CG(doc_comment_len) = yyleng;
+		SCNG(doc_comment) = estrndup(yytext, yyleng);
+		SCNG(doc_comment_len) = yyleng;
 		return T_DOC_COMMENT;
 	}
 
 	return T_COMMENT;
 }
-#line 3596 "Zend/zend_language_scanner.c"
+#line 3960 "Zend/zend_language_scanner.c"
 yy240:
 		YYDEBUG(240, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -3602,11 +3966,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		++YYCURSOR;
 		YYDEBUG(242, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1383 "Zend/zend_language_scanner.l"
+#line 1749 "Zend/zend_language_scanner.l"
 		{
 	return T_DIV_EQUAL;
 }
-#line 3610 "Zend/zend_language_scanner.c"
+#line 3974 "Zend/zend_language_scanner.c"
 yy243:
 		YYDEBUG(243, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -3629,42 +3993,42 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		++YYCURSOR;
 		YYDEBUG(247, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1379 "Zend/zend_language_scanner.l"
+#line 1745 "Zend/zend_language_scanner.l"
 		{
 	return T_MUL_EQUAL;
 }
-#line 3637 "Zend/zend_language_scanner.c"
+#line 4001 "Zend/zend_language_scanner.c"
 yy248:
 		YYDEBUG(248, *YYCURSOR);
 		++YYCURSOR;
 		if ((yych = *YYCURSOR) == '=') goto yy252;
 		YYDEBUG(249, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1439 "Zend/zend_language_scanner.l"
+#line 1805 "Zend/zend_language_scanner.l"
 		{
 	return T_SR;
 }
-#line 3648 "Zend/zend_language_scanner.c"
+#line 4012 "Zend/zend_language_scanner.c"
 yy250:
 		YYDEBUG(250, *YYCURSOR);
 		++YYCURSOR;
 		YYDEBUG(251, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1367 "Zend/zend_language_scanner.l"
+#line 1733 "Zend/zend_language_scanner.l"
 		{
 	return T_IS_GREATER_OR_EQUAL;
 }
-#line 3658 "Zend/zend_language_scanner.c"
+#line 4022 "Zend/zend_language_scanner.c"
 yy252:
 		YYDEBUG(252, *YYCURSOR);
 		++YYCURSOR;
 		YYDEBUG(253, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1399 "Zend/zend_language_scanner.l"
+#line 1765 "Zend/zend_language_scanner.l"
 		{
 	return T_SR_EQUAL;
 }
-#line 3668 "Zend/zend_language_scanner.c"
+#line 4032 "Zend/zend_language_scanner.c"
 yy254:
 		YYDEBUG(254, *YYCURSOR);
 		yyaccept = 5;
@@ -3675,11 +4039,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 yy255:
 		YYDEBUG(255, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1435 "Zend/zend_language_scanner.l"
+#line 1801 "Zend/zend_language_scanner.l"
 		{
 	return T_SL;
 }
-#line 3683 "Zend/zend_language_scanner.c"
+#line 4047 "Zend/zend_language_scanner.c"
 yy256:
 		YYDEBUG(256, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -3691,22 +4055,22 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		++YYCURSOR;
 		YYDEBUG(258, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1363 "Zend/zend_language_scanner.l"
+#line 1729 "Zend/zend_language_scanner.l"
 		{
 	return T_IS_SMALLER_OR_EQUAL;
 }
-#line 3699 "Zend/zend_language_scanner.c"
+#line 4063 "Zend/zend_language_scanner.c"
 yy259:
 		YYDEBUG(259, *YYCURSOR);
 		++YYCURSOR;
 yy260:
 		YYDEBUG(260, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1359 "Zend/zend_language_scanner.l"
+#line 1725 "Zend/zend_language_scanner.l"
 		{
 	return T_IS_NOT_EQUAL;
 }
-#line 3710 "Zend/zend_language_scanner.c"
+#line 4074 "Zend/zend_language_scanner.c"
 yy261:
 		YYDEBUG(261, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -3757,11 +4121,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		++YYCURSOR;
 		YYDEBUG(269, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1395 "Zend/zend_language_scanner.l"
+#line 1761 "Zend/zend_language_scanner.l"
 		{
 	return T_SL_EQUAL;
 }
-#line 3765 "Zend/zend_language_scanner.c"
+#line 4129 "Zend/zend_language_scanner.c"
 yy270:
 		YYDEBUG(270, *YYCURSOR);
 		++YYCURSOR;
@@ -3866,7 +4230,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 yy280:
 		YYDEBUG(280, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 2046 "Zend/zend_language_scanner.l"
+#line 2410 "Zend/zend_language_scanner.l"
 		{
 	char *s;
 	int bprefix = (yytext[0] != '<') ? 1 : 0;
@@ -3913,7 +4277,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 
 	return T_START_HEREDOC;
 }
-#line 3917 "Zend/zend_language_scanner.c"
+#line 4281 "Zend/zend_language_scanner.c"
 yy281:
 		YYDEBUG(281, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -3953,31 +4317,31 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		++YYCURSOR;
 		YYDEBUG(286, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1351 "Zend/zend_language_scanner.l"
+#line 1717 "Zend/zend_language_scanner.l"
 		{
 	return T_IS_NOT_IDENTICAL;
 }
-#line 3961 "Zend/zend_language_scanner.c"
+#line 4325 "Zend/zend_language_scanner.c"
 yy287:
 		YYDEBUG(287, *YYCURSOR);
 		++YYCURSOR;
 		YYDEBUG(288, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1371 "Zend/zend_language_scanner.l"
+#line 1737 "Zend/zend_language_scanner.l"
 		{
 	return T_PLUS_EQUAL;
 }
-#line 3971 "Zend/zend_language_scanner.c"
+#line 4335 "Zend/zend_language_scanner.c"
 yy289:
 		YYDEBUG(289, *YYCURSOR);
 		++YYCURSOR;
 		YYDEBUG(290, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1339 "Zend/zend_language_scanner.l"
+#line 1705 "Zend/zend_language_scanner.l"
 		{
 	return T_INC;
 }
-#line 3981 "Zend/zend_language_scanner.c"
+#line 4345 "Zend/zend_language_scanner.c"
 yy291:
 		YYDEBUG(291, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -3996,42 +4360,42 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(294, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1327 "Zend/zend_language_scanner.l"
+#line 1693 "Zend/zend_language_scanner.l"
 		{
-	return T_LIST;
+	RETURN_STRING_TOKEN(T_LIST)
 }
-#line 4004 "Zend/zend_language_scanner.c"
+#line 4368 "Zend/zend_language_scanner.c"
 yy295:
 		YYDEBUG(295, *YYCURSOR);
 		++YYCURSOR;
 		if ((yych = *YYCURSOR) == '=') goto yy299;
 		YYDEBUG(296, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1355 "Zend/zend_language_scanner.l"
+#line 1721 "Zend/zend_language_scanner.l"
 		{
 	return T_IS_EQUAL;
 }
-#line 4015 "Zend/zend_language_scanner.c"
+#line 4379 "Zend/zend_language_scanner.c"
 yy297:
 		YYDEBUG(297, *YYCURSOR);
 		++YYCURSOR;
 		YYDEBUG(298, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1323 "Zend/zend_language_scanner.l"
+#line 1689 "Zend/zend_language_scanner.l"
 		{
 	return T_DOUBLE_ARROW;
 }
-#line 4025 "Zend/zend_language_scanner.c"
+#line 4389 "Zend/zend_language_scanner.c"
 yy299:
 		YYDEBUG(299, *YYCURSOR);
 		++YYCURSOR;
 		YYDEBUG(300, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1347 "Zend/zend_language_scanner.l"
+#line 1713 "Zend/zend_language_scanner.l"
 		{
 	return T_IS_IDENTICAL;
 }
-#line 4035 "Zend/zend_language_scanner.c"
+#line 4399 "Zend/zend_language_scanner.c"
 yy301:
 		YYDEBUG(301, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -4161,7 +4525,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(320, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1665 "Zend/zend_language_scanner.l"
+#line 2030 "Zend/zend_language_scanner.l"
 		{
 	if (CG(current_namespace)) {
 		*zendlval = *CG(current_namespace);
@@ -4171,7 +4535,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 	}
 	return T_NS_C;
 }
-#line 4175 "Zend/zend_language_scanner.c"
+#line 4539 "Zend/zend_language_scanner.c"
 yy321:
 		YYDEBUG(321, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -4191,7 +4555,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(325, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1640 "Zend/zend_language_scanner.l"
+#line 2005 "Zend/zend_language_scanner.l"
 		{
 	char *filename = zend_get_compiled_filename(TSRMLS_C);
 	const size_t filename_len = strlen(filename);
@@ -4216,7 +4580,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 	ZVAL_STRING(zendlval, dirname, 0);
 	return T_DIR;
 }
-#line 4220 "Zend/zend_language_scanner.c"
+#line 4584 "Zend/zend_language_scanner.c"
 yy326:
 		YYDEBUG(326, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -4241,12 +4605,12 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(331, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1625 "Zend/zend_language_scanner.l"
+#line 1990 "Zend/zend_language_scanner.l"
 		{
 	ZVAL_LONG(zendlval, CG(zend_lineno));
 	return T_LINE;
 }
-#line 4250 "Zend/zend_language_scanner.c"
+#line 4614 "Zend/zend_language_scanner.c"
 yy332:
 		YYDEBUG(332, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -4281,7 +4645,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(339, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1612 "Zend/zend_language_scanner.l"
+#line 1977 "Zend/zend_language_scanner.l"
 		{
 	const char *class_name = CG(active_class_entry) ? CG(active_class_entry)->name : NULL;
 	const char *func_name = CG(active_op_array)? CG(active_op_array)->function_name : NULL;
@@ -4294,7 +4658,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 	zendlval->type = IS_STRING;
 	return T_METHOD_C;
 }
-#line 4298 "Zend/zend_language_scanner.c"
+#line 4662 "Zend/zend_language_scanner.c"
 yy340:
 		YYDEBUG(340, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -4345,7 +4709,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(350, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1602 "Zend/zend_language_scanner.l"
+#line 1967 "Zend/zend_language_scanner.l"
 		{
 	zend_op_array *op_array = CG(active_op_array);
 	if (op_array && op_array->function_name) {
@@ -4355,7 +4719,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 	}
 	return T_FUNC_C;
 }
-#line 4359 "Zend/zend_language_scanner.c"
+#line 4723 "Zend/zend_language_scanner.c"
 yy351:
 		YYDEBUG(351, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -4375,7 +4739,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(355, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1630 "Zend/zend_language_scanner.l"
+#line 1995 "Zend/zend_language_scanner.l"
 		{
 	char *filename = zend_get_compiled_filename(TSRMLS_C);
 
@@ -4385,7 +4749,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 	ZVAL_STRING(zendlval, filename, 1);
 	return T_FILE;
 }
-#line 4389 "Zend/zend_language_scanner.c"
+#line 4753 "Zend/zend_language_scanner.c"
 yy356:
 		YYDEBUG(356, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -4415,7 +4779,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(362, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1592 "Zend/zend_language_scanner.l"
+#line 1957 "Zend/zend_language_scanner.l"
 		{
 	zend_class_entry *ce = CG(active_class_entry);
 	if (ce && ce->name && ZEND_ACC_TRAIT == (ce->ce_flags & ZEND_ACC_TRAIT)) {
@@ -4425,7 +4789,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 	}
 	return T_TRAIT_C;
 }
-#line 4429 "Zend/zend_language_scanner.c"
+#line 4793 "Zend/zend_language_scanner.c"
 yy363:
 		YYDEBUG(363, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -4455,7 +4819,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(369, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1574 "Zend/zend_language_scanner.l"
+#line 1939 "Zend/zend_language_scanner.l"
 		{
 	zend_class_entry *ce = CG(active_class_entry);
 	if (ce && ZEND_ACC_TRAIT == (ce->ce_flags & ZEND_ACC_TRAIT)) {
@@ -4473,7 +4837,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 	}
 	return T_CLASS_C;
 }
-#line 4477 "Zend/zend_language_scanner.c"
+#line 4841 "Zend/zend_language_scanner.c"
 yy370:
 		YYDEBUG(370, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -4535,11 +4899,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(382, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1291 "Zend/zend_language_scanner.l"
+#line 1657 "Zend/zend_language_scanner.l"
 		{
-	return T_HALT_COMPILER;
+	RETURN_STRING_TOKEN(T_HALT_COMPILER)
 }
-#line 4543 "Zend/zend_language_scanner.c"
+#line 4907 "Zend/zend_language_scanner.c"
 yy383:
 		YYDEBUG(383, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -4559,11 +4923,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(386, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1271 "Zend/zend_language_scanner.l"
+#line 1637 "Zend/zend_language_scanner.l"
 		{
-	return T_USE;
+	RETURN_STRING_TOKEN(T_USE)
 }
-#line 4567 "Zend/zend_language_scanner.c"
+#line 4931 "Zend/zend_language_scanner.c"
 yy387:
 		YYDEBUG(387, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -4582,11 +4946,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(390, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1319 "Zend/zend_language_scanner.l"
+#line 1685 "Zend/zend_language_scanner.l"
 		{
-	return T_UNSET;
+	RETURN_STRING_TOKEN(T_UNSET)
 }
-#line 4590 "Zend/zend_language_scanner.c"
+#line 4954 "Zend/zend_language_scanner.c"
 yy391:
 		YYDEBUG(391, *YYCURSOR);
 		++YYCURSOR;
@@ -4758,11 +5122,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		++YYCURSOR;
 		YYDEBUG(408, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1219 "Zend/zend_language_scanner.l"
+#line 1585 "Zend/zend_language_scanner.l"
 		{
 	return T_INT_CAST;
 }
-#line 4766 "Zend/zend_language_scanner.c"
+#line 5130 "Zend/zend_language_scanner.c"
 yy409:
 		YYDEBUG(409, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -4806,11 +5170,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		++YYCURSOR;
 		YYDEBUG(417, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1223 "Zend/zend_language_scanner.l"
+#line 1589 "Zend/zend_language_scanner.l"
 		{
 	return T_DOUBLE_CAST;
 }
-#line 4814 "Zend/zend_language_scanner.c"
+#line 5178 "Zend/zend_language_scanner.c"
 yy418:
 		YYDEBUG(418, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -4880,11 +5244,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		++YYCURSOR;
 		YYDEBUG(431, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1227 "Zend/zend_language_scanner.l"
+#line 1593 "Zend/zend_language_scanner.l"
 		{
 	return T_STRING_CAST;
 }
-#line 4888 "Zend/zend_language_scanner.c"
+#line 5252 "Zend/zend_language_scanner.c"
 yy432:
 		YYDEBUG(432, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -4917,11 +5281,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		++YYCURSOR;
 		YYDEBUG(438, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1231 "Zend/zend_language_scanner.l"
+#line 1597 "Zend/zend_language_scanner.l"
 		{
 	return T_ARRAY_CAST;
 }
-#line 4925 "Zend/zend_language_scanner.c"
+#line 5289 "Zend/zend_language_scanner.c"
 yy439:
 		YYDEBUG(439, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -4959,11 +5323,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		++YYCURSOR;
 		YYDEBUG(446, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1235 "Zend/zend_language_scanner.l"
+#line 1601 "Zend/zend_language_scanner.l"
 		{
 	return T_OBJECT_CAST;
 }
-#line 4967 "Zend/zend_language_scanner.c"
+#line 5331 "Zend/zend_language_scanner.c"
 yy447:
 		YYDEBUG(447, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -5004,11 +5368,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		++YYCURSOR;
 		YYDEBUG(454, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1239 "Zend/zend_language_scanner.l"
+#line 1605 "Zend/zend_language_scanner.l"
 		{
 	return T_BOOL_CAST;
 }
-#line 5012 "Zend/zend_language_scanner.c"
+#line 5376 "Zend/zend_language_scanner.c"
 yy455:
 		YYDEBUG(455, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -5068,11 +5432,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		++YYCURSOR;
 		YYDEBUG(466, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1243 "Zend/zend_language_scanner.l"
+#line 1609 "Zend/zend_language_scanner.l"
 		{
 	return T_UNSET_CAST;
 }
-#line 5076 "Zend/zend_language_scanner.c"
+#line 5440 "Zend/zend_language_scanner.c"
 yy467:
 		YYDEBUG(467, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -5086,11 +5450,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(469, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1215 "Zend/zend_language_scanner.l"
+#line 1581 "Zend/zend_language_scanner.l"
 		{
-	return T_VAR;
+	RETURN_STRING_TOKEN(T_VAR)
 }
-#line 5094 "Zend/zend_language_scanner.c"
+#line 5458 "Zend/zend_language_scanner.c"
 yy470:
 		YYDEBUG(470, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -5110,11 +5474,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(473, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1207 "Zend/zend_language_scanner.l"
+#line 1573 "Zend/zend_language_scanner.l"
 		{
-	return T_NEW;
+	RETURN_STRING_TOKEN(T_NEW)
 }
-#line 5118 "Zend/zend_language_scanner.c"
+#line 5482 "Zend/zend_language_scanner.c"
 yy474:
 		YYDEBUG(474, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -5153,21 +5517,21 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(481, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1267 "Zend/zend_language_scanner.l"
+#line 1633 "Zend/zend_language_scanner.l"
 		{
-	return T_NAMESPACE;
+	RETURN_STRING_TOKEN(T_NAMESPACE)
 }
-#line 5161 "Zend/zend_language_scanner.c"
+#line 5525 "Zend/zend_language_scanner.c"
 yy482:
 		YYDEBUG(482, *YYCURSOR);
 		++YYCURSOR;
 		YYDEBUG(483, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1199 "Zend/zend_language_scanner.l"
+#line 1565 "Zend/zend_language_scanner.l"
 		{
 	return T_PAAMAYIM_NEKUDOTAYIM;
 }
-#line 5171 "Zend/zend_language_scanner.c"
+#line 5535 "Zend/zend_language_scanner.c"
 yy484:
 		YYDEBUG(484, *YYCURSOR);
 		++YYCURSOR;
@@ -5189,32 +5553,32 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		++YYCURSOR;
 		YYDEBUG(487, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1375 "Zend/zend_language_scanner.l"
+#line 1741 "Zend/zend_language_scanner.l"
 		{
 	return T_MINUS_EQUAL;
 }
-#line 5197 "Zend/zend_language_scanner.c"
+#line 5561 "Zend/zend_language_scanner.c"
 yy488:
 		YYDEBUG(488, *YYCURSOR);
 		++YYCURSOR;
 		YYDEBUG(489, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1343 "Zend/zend_language_scanner.l"
+#line 1709 "Zend/zend_language_scanner.l"
 		{
 	return T_DEC;
 }
-#line 5207 "Zend/zend_language_scanner.c"
+#line 5571 "Zend/zend_language_scanner.c"
 yy490:
 		YYDEBUG(490, *YYCURSOR);
 		++YYCURSOR;
 		YYDEBUG(491, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1171 "Zend/zend_language_scanner.l"
+#line 1537 "Zend/zend_language_scanner.l"
 		{
 	yy_push_state(ST_LOOKING_FOR_PROPERTY TSRMLS_CC);
 	return T_OBJECT_OPERATOR;
 }
-#line 5218 "Zend/zend_language_scanner.c"
+#line 5582 "Zend/zend_language_scanner.c"
 yy492:
 		YYDEBUG(492, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -5259,11 +5623,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(498, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1315 "Zend/zend_language_scanner.l"
+#line 1681 "Zend/zend_language_scanner.l"
 		{
-	return T_PUBLIC;
+	RETURN_STRING_TOKEN(T_PUBLIC)
 }
-#line 5267 "Zend/zend_language_scanner.c"
+#line 5631 "Zend/zend_language_scanner.c"
 yy499:
 		YYDEBUG(499, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -5318,11 +5682,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(507, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1311 "Zend/zend_language_scanner.l"
+#line 1677 "Zend/zend_language_scanner.l"
 		{
-	return T_PROTECTED;
+	RETURN_STRING_TOKEN(T_PROTECTED)
 }
-#line 5326 "Zend/zend_language_scanner.c"
+#line 5690 "Zend/zend_language_scanner.c"
 yy508:
 		YYDEBUG(508, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -5352,11 +5716,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(513, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1307 "Zend/zend_language_scanner.l"
+#line 1673 "Zend/zend_language_scanner.l"
 		{
-	return T_PRIVATE;
+	RETURN_STRING_TOKEN(T_PRIVATE)
 }
-#line 5360 "Zend/zend_language_scanner.c"
+#line 5724 "Zend/zend_language_scanner.c"
 yy514:
 		YYDEBUG(514, *YYCURSOR);
 		++YYCURSOR;
@@ -5365,11 +5729,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(515, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1147 "Zend/zend_language_scanner.l"
+#line 1513 "Zend/zend_language_scanner.l"
 		{
-	return T_PRINT;
+	RETURN_STRING_TOKEN(T_PRINT)
 }
-#line 5373 "Zend/zend_language_scanner.c"
+#line 5737 "Zend/zend_language_scanner.c"
 yy516:
 		YYDEBUG(516, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -5394,11 +5758,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(520, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1139 "Zend/zend_language_scanner.l"
+#line 1505 "Zend/zend_language_scanner.l"
 		{
-	return T_GOTO;
+	RETURN_STRING_TOKEN(T_GOTO)
 }
-#line 5402 "Zend/zend_language_scanner.c"
+#line 5766 "Zend/zend_language_scanner.c"
 yy521:
 		YYDEBUG(521, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -5422,11 +5786,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(525, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1279 "Zend/zend_language_scanner.l"
+#line 1645 "Zend/zend_language_scanner.l"
 		{
-	return T_GLOBAL;
+	RETURN_STRING_TOKEN(T_GLOBAL)
 }
-#line 5430 "Zend/zend_language_scanner.c"
+#line 5794 "Zend/zend_language_scanner.c"
 yy526:
 		YYDEBUG(526, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -5463,11 +5827,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(533, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1131 "Zend/zend_language_scanner.l"
+#line 1497 "Zend/zend_language_scanner.l"
 		{
-	return T_BREAK;
+	RETURN_STRING_TOKEN(T_BREAK)
 }
-#line 5471 "Zend/zend_language_scanner.c"
+#line 5835 "Zend/zend_language_scanner.c"
 yy534:
 		YYDEBUG(534, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -5507,11 +5871,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(541, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1115 "Zend/zend_language_scanner.l"
+#line 1481 "Zend/zend_language_scanner.l"
 		{
-	return T_SWITCH;
+	RETURN_STRING_TOKEN(T_SWITCH)
 }
-#line 5515 "Zend/zend_language_scanner.c"
+#line 5879 "Zend/zend_language_scanner.c"
 yy542:
 		YYDEBUG(542, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -5535,11 +5899,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(546, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1295 "Zend/zend_language_scanner.l"
+#line 1661 "Zend/zend_language_scanner.l"
 		{
-	return T_STATIC;
+	RETURN_STRING_TOKEN(T_STATIC)
 }
-#line 5543 "Zend/zend_language_scanner.c"
+#line 5907 "Zend/zend_language_scanner.c"
 yy547:
 		YYDEBUG(547, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -5566,11 +5930,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(551, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1111 "Zend/zend_language_scanner.l"
+#line 1477 "Zend/zend_language_scanner.l"
 		{
-	return T_AS;
+	RETURN_STRING_TOKEN(T_AS)
 }
-#line 5574 "Zend/zend_language_scanner.c"
+#line 5938 "Zend/zend_language_scanner.c"
 yy552:
 		YYDEBUG(552, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -5589,11 +5953,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(555, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1331 "Zend/zend_language_scanner.l"
+#line 1697 "Zend/zend_language_scanner.l"
 		{
-	return T_ARRAY;
+	RETURN_STRING_TOKEN(T_ARRAY)
 }
-#line 5597 "Zend/zend_language_scanner.c"
+#line 5961 "Zend/zend_language_scanner.c"
 yy556:
 		YYDEBUG(556, *YYCURSOR);
 		++YYCURSOR;
@@ -5602,11 +5966,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(557, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1427 "Zend/zend_language_scanner.l"
+#line 1793 "Zend/zend_language_scanner.l"
 		{
-	return T_LOGICAL_AND;
+	RETURN_STRING_TOKEN(T_LOGICAL_AND)
 }
-#line 5610 "Zend/zend_language_scanner.c"
+#line 5974 "Zend/zend_language_scanner.c"
 yy558:
 		YYDEBUG(558, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -5640,11 +6004,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(564, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1299 "Zend/zend_language_scanner.l"
+#line 1665 "Zend/zend_language_scanner.l"
 		{
-	return T_ABSTRACT;
+	RETURN_STRING_TOKEN(T_ABSTRACT)
 }
-#line 5648 "Zend/zend_language_scanner.c"
+#line 6012 "Zend/zend_language_scanner.c"
 yy565:
 		YYDEBUG(565, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -5668,11 +6032,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(569, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1071 "Zend/zend_language_scanner.l"
+#line 1437 "Zend/zend_language_scanner.l"
 		{
-	return T_WHILE;
+	RETURN_STRING_TOKEN(T_WHILE)
 }
-#line 5676 "Zend/zend_language_scanner.c"
+#line 6040 "Zend/zend_language_scanner.c"
 yy570:
 		YYDEBUG(570, *YYCURSOR);
 		++YYCURSOR;
@@ -5681,11 +6045,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(571, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1055 "Zend/zend_language_scanner.l"
+#line 1421 "Zend/zend_language_scanner.l"
 		{
-	return T_IF;
+	RETURN_STRING_TOKEN(T_IF)
 }
-#line 5689 "Zend/zend_language_scanner.c"
+#line 6053 "Zend/zend_language_scanner.c"
 yy572:
 		YYDEBUG(572, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -5737,11 +6101,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(578, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1283 "Zend/zend_language_scanner.l"
+#line 1649 "Zend/zend_language_scanner.l"
 		{
-	return T_ISSET;
+	RETURN_STRING_TOKEN(T_ISSET)
 }
-#line 5745 "Zend/zend_language_scanner.c"
+#line 6109 "Zend/zend_language_scanner.c"
 yy579:
 		YYDEBUG(579, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -5795,11 +6159,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 yy586:
 		YYDEBUG(586, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1251 "Zend/zend_language_scanner.l"
+#line 1617 "Zend/zend_language_scanner.l"
 		{
-	return T_INCLUDE;
+	RETURN_STRING_TOKEN(T_INCLUDE)
 }
-#line 5803 "Zend/zend_language_scanner.c"
+#line 6167 "Zend/zend_language_scanner.c"
 yy587:
 		YYDEBUG(587, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -5828,11 +6192,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(592, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1255 "Zend/zend_language_scanner.l"
+#line 1621 "Zend/zend_language_scanner.l"
 		{
-	return T_INCLUDE_ONCE;
+	RETURN_STRING_TOKEN(T_INCLUDE_ONCE)
 }
-#line 5836 "Zend/zend_language_scanner.c"
+#line 6200 "Zend/zend_language_scanner.c"
 yy593:
 		YYDEBUG(593, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -5866,11 +6230,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(599, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1155 "Zend/zend_language_scanner.l"
+#line 1521 "Zend/zend_language_scanner.l"
 		{
-	return T_INTERFACE;
+	RETURN_STRING_TOKEN(T_INTERFACE)
 }
-#line 5874 "Zend/zend_language_scanner.c"
+#line 6238 "Zend/zend_language_scanner.c"
 yy600:
 		YYDEBUG(600, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -5920,11 +6284,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(607, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1275 "Zend/zend_language_scanner.l"
+#line 1641 "Zend/zend_language_scanner.l"
 		{
-        return T_INSTEADOF;
+	RETURN_STRING_TOKEN(T_INSTEADOF)
 }
-#line 5928 "Zend/zend_language_scanner.c"
+#line 6292 "Zend/zend_language_scanner.c"
 yy608:
 		YYDEBUG(608, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -5953,11 +6317,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(613, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1107 "Zend/zend_language_scanner.l"
+#line 1473 "Zend/zend_language_scanner.l"
 		{
-	return T_INSTANCEOF;
+	RETURN_STRING_TOKEN(T_INSTANCEOF)
 }
-#line 5961 "Zend/zend_language_scanner.c"
+#line 6325 "Zend/zend_language_scanner.c"
 yy614:
 		YYDEBUG(614, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -6001,11 +6365,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(622, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1167 "Zend/zend_language_scanner.l"
+#line 1533 "Zend/zend_language_scanner.l"
 		{
-	return T_IMPLEMENTS;
+	RETURN_STRING_TOKEN(T_IMPLEMENTS)
 }
-#line 6009 "Zend/zend_language_scanner.c"
+#line 6373 "Zend/zend_language_scanner.c"
 yy623:
 		YYDEBUG(623, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -6033,11 +6397,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(626, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1039 "Zend/zend_language_scanner.l"
+#line 1405 "Zend/zend_language_scanner.l"
 		{
-	return T_TRY;
+	RETURN_STRING_TOKEN(T_TRY)
 }
-#line 6041 "Zend/zend_language_scanner.c"
+#line 6405 "Zend/zend_language_scanner.c"
 yy627:
 		YYDEBUG(627, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -6056,11 +6420,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(630, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1159 "Zend/zend_language_scanner.l"
+#line 1525 "Zend/zend_language_scanner.l"
 		{
-	return T_TRAIT;
+	RETURN_STRING_TOKEN(T_TRAIT)
 }
-#line 6064 "Zend/zend_language_scanner.c"
+#line 6428 "Zend/zend_language_scanner.c"
 yy631:
 		YYDEBUG(631, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -6079,11 +6443,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(634, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1051 "Zend/zend_language_scanner.l"
+#line 1417 "Zend/zend_language_scanner.l"
 		{
-	return T_THROW;
+	RETURN_STRING_TOKEN(T_THROW)
 }
-#line 6087 "Zend/zend_language_scanner.c"
+#line 6451 "Zend/zend_language_scanner.c"
 yy635:
 		YYDEBUG(635, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -6107,11 +6471,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(639, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1035 "Zend/zend_language_scanner.l"
+#line 1401 "Zend/zend_language_scanner.l"
 		{
-	return T_YIELD;
+	RETURN_STRING_TOKEN(T_YIELD)
 }
-#line 6115 "Zend/zend_language_scanner.c"
+#line 6479 "Zend/zend_language_scanner.c"
 yy640:
 		YYDEBUG(640, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -6172,11 +6536,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 yy647:
 		YYDEBUG(647, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1259 "Zend/zend_language_scanner.l"
+#line 1625 "Zend/zend_language_scanner.l"
 		{
-	return T_REQUIRE;
+	RETURN_STRING_TOKEN(T_REQUIRE)
 }
-#line 6180 "Zend/zend_language_scanner.c"
+#line 6544 "Zend/zend_language_scanner.c"
 yy648:
 		YYDEBUG(648, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -6205,11 +6569,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(653, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1263 "Zend/zend_language_scanner.l"
+#line 1629 "Zend/zend_language_scanner.l"
 		{
-	return T_REQUIRE_ONCE;
+	RETURN_STRING_TOKEN(T_REQUIRE_ONCE)
 }
-#line 6213 "Zend/zend_language_scanner.c"
+#line 6577 "Zend/zend_language_scanner.c"
 yy654:
 		YYDEBUG(654, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -6228,11 +6592,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(657, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1031 "Zend/zend_language_scanner.l"
+#line 1397 "Zend/zend_language_scanner.l"
 		{
-	return T_RETURN;
+	RETURN_STRING_TOKEN(T_RETURN)
 }
-#line 6236 "Zend/zend_language_scanner.c"
+#line 6600 "Zend/zend_language_scanner.c"
 yy658:
 		YYDEBUG(658, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -6322,11 +6686,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(668, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1135 "Zend/zend_language_scanner.l"
+#line 1501 "Zend/zend_language_scanner.l"
 		{
-	return T_CONTINUE;
+	RETURN_STRING_TOKEN(T_CONTINUE)
 }
-#line 6330 "Zend/zend_language_scanner.c"
+#line 6694 "Zend/zend_language_scanner.c"
 yy669:
 		YYDEBUG(669, *YYCURSOR);
 		++YYCURSOR;
@@ -6335,11 +6699,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(670, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1027 "Zend/zend_language_scanner.l"
+#line 1393 "Zend/zend_language_scanner.l"
 		{
-	return T_CONST;
+	RETURN_STRING_TOKEN(T_CONST)
 }
-#line 6343 "Zend/zend_language_scanner.c"
+#line 6707 "Zend/zend_language_scanner.c"
 yy671:
 		YYDEBUG(671, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -6364,11 +6728,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(675, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1211 "Zend/zend_language_scanner.l"
+#line 1577 "Zend/zend_language_scanner.l"
 		{
-	return T_CLONE;
+	RETURN_STRING_TOKEN(T_CLONE)
 }
-#line 6372 "Zend/zend_language_scanner.c"
+#line 6736 "Zend/zend_language_scanner.c"
 yy676:
 		YYDEBUG(676, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -6382,11 +6746,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(678, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1151 "Zend/zend_language_scanner.l"
+#line 1517 "Zend/zend_language_scanner.l"
 		{
-	return T_CLASS;
+	RETURN_STRING_TOKEN(T_CLASS)
 }
-#line 6390 "Zend/zend_language_scanner.c"
+#line 6754 "Zend/zend_language_scanner.c"
 yy679:
 		YYDEBUG(679, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -6432,11 +6796,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(687, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1335 "Zend/zend_language_scanner.l"
+#line 1701 "Zend/zend_language_scanner.l"
 		{
- return T_CALLABLE;
+	RETURN_STRING_TOKEN(T_CALLABLE)
 }
-#line 6440 "Zend/zend_language_scanner.c"
+#line 6804 "Zend/zend_language_scanner.c"
 yy688:
 		YYDEBUG(688, *YYCURSOR);
 		++YYCURSOR;
@@ -6445,11 +6809,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(689, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1123 "Zend/zend_language_scanner.l"
+#line 1489 "Zend/zend_language_scanner.l"
 		{
-	return T_CASE;
+	RETURN_STRING_TOKEN(T_CASE)
 }
-#line 6453 "Zend/zend_language_scanner.c"
+#line 6817 "Zend/zend_language_scanner.c"
 yy690:
 		YYDEBUG(690, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -6463,11 +6827,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(692, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1043 "Zend/zend_language_scanner.l"
+#line 1409 "Zend/zend_language_scanner.l"
 		{
-	return T_CATCH;
+	RETURN_STRING_TOKEN(T_CATCH)
 }
-#line 6471 "Zend/zend_language_scanner.c"
+#line 6835 "Zend/zend_language_scanner.c"
 yy693:
 		YYDEBUG(693, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -6518,11 +6882,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(702, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1023 "Zend/zend_language_scanner.l"
+#line 1389 "Zend/zend_language_scanner.l"
 		{
-	return T_FUNCTION;
+	RETURN_STRING_TOKEN(T_FUNCTION)
 }
-#line 6526 "Zend/zend_language_scanner.c"
+#line 6890 "Zend/zend_language_scanner.c"
 yy703:
 		YYDEBUG(703, *YYCURSOR);
 		++YYCURSOR;
@@ -6546,11 +6910,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 yy704:
 		YYDEBUG(704, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1083 "Zend/zend_language_scanner.l"
+#line 1449 "Zend/zend_language_scanner.l"
 		{
-	return T_FOR;
+	RETURN_STRING_TOKEN(T_FOR)
 }
-#line 6554 "Zend/zend_language_scanner.c"
+#line 6918 "Zend/zend_language_scanner.c"
 yy705:
 		YYDEBUG(705, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -6574,11 +6938,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(709, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1091 "Zend/zend_language_scanner.l"
+#line 1457 "Zend/zend_language_scanner.l"
 		{
-	return T_FOREACH;
+	RETURN_STRING_TOKEN(T_FOREACH)
 }
-#line 6582 "Zend/zend_language_scanner.c"
+#line 6946 "Zend/zend_language_scanner.c"
 yy710:
 		YYDEBUG(710, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -6612,11 +6976,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 yy713:
 		YYDEBUG(713, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1303 "Zend/zend_language_scanner.l"
+#line 1669 "Zend/zend_language_scanner.l"
 		{
-	return T_FINAL;
+	RETURN_STRING_TOKEN(T_FINAL)
 }
-#line 6620 "Zend/zend_language_scanner.c"
+#line 6984 "Zend/zend_language_scanner.c"
 yy714:
 		YYDEBUG(714, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -6630,11 +6994,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(716, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1047 "Zend/zend_language_scanner.l"
+#line 1413 "Zend/zend_language_scanner.l"
 		{
-	return T_FINALLY;
+	RETURN_STRING_TOKEN(T_FINALLY)
 }
-#line 6638 "Zend/zend_language_scanner.c"
+#line 7002 "Zend/zend_language_scanner.c"
 yy717:
 		YYDEBUG(717, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -6665,11 +7029,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(720, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1079 "Zend/zend_language_scanner.l"
+#line 1445 "Zend/zend_language_scanner.l"
 		{
-	return T_DO;
+	RETURN_STRING_TOKEN(T_DO)
 }
-#line 6673 "Zend/zend_language_scanner.c"
+#line 7037 "Zend/zend_language_scanner.c"
 yy721:
 		YYDEBUG(721, *YYCURSOR);
 		++YYCURSOR;
@@ -6678,11 +7042,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(722, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1019 "Zend/zend_language_scanner.l"
+#line 1385 "Zend/zend_language_scanner.l"
 		{
-	return T_EXIT;
+	RETURN_STRING_TOKEN(T_EXIT)
 }
-#line 6686 "Zend/zend_language_scanner.c"
+#line 7050 "Zend/zend_language_scanner.c"
 yy723:
 		YYDEBUG(723, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -6717,11 +7081,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(729, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1127 "Zend/zend_language_scanner.l"
+#line 1493 "Zend/zend_language_scanner.l"
 		{
-	return T_DEFAULT;
+	RETURN_STRING_TOKEN(T_DEFAULT)
 }
-#line 6725 "Zend/zend_language_scanner.c"
+#line 7089 "Zend/zend_language_scanner.c"
 yy730:
 		YYDEBUG(730, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -6745,11 +7109,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(734, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1099 "Zend/zend_language_scanner.l"
+#line 1465 "Zend/zend_language_scanner.l"
 		{
-	return T_DECLARE;
+	RETURN_STRING_TOKEN(T_DECLARE)
 }
-#line 6753 "Zend/zend_language_scanner.c"
+#line 7117 "Zend/zend_language_scanner.c"
 yy735:
 		YYDEBUG(735, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -6829,11 +7193,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(747, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1163 "Zend/zend_language_scanner.l"
+#line 1529 "Zend/zend_language_scanner.l"
 		{
-	return T_EXTENDS;
+	RETURN_STRING_TOKEN(T_EXTENDS)
 }
-#line 6837 "Zend/zend_language_scanner.c"
+#line 7201 "Zend/zend_language_scanner.c"
 yy748:
 		YYDEBUG(748, *YYCURSOR);
 		++YYCURSOR;
@@ -6842,11 +7206,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(749, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1015 "Zend/zend_language_scanner.l"
+#line 1381 "Zend/zend_language_scanner.l"
 		{
-	return T_EXIT;
+	RETURN_STRING_TOKEN(T_EXIT)
 }
-#line 6850 "Zend/zend_language_scanner.c"
+#line 7214 "Zend/zend_language_scanner.c"
 yy750:
 		YYDEBUG(750, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -6860,11 +7224,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(752, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1247 "Zend/zend_language_scanner.l"
+#line 1613 "Zend/zend_language_scanner.l"
 		{
-	return T_EVAL;
+	RETURN_STRING_TOKEN(T_EVAL)
 }
-#line 6868 "Zend/zend_language_scanner.c"
+#line 7232 "Zend/zend_language_scanner.c"
 yy753:
 		YYDEBUG(753, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -6934,11 +7298,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(763, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1075 "Zend/zend_language_scanner.l"
+#line 1441 "Zend/zend_language_scanner.l"
 		{
-	return T_ENDWHILE;
+	RETURN_STRING_TOKEN(T_ENDWHILE)
 }
-#line 6942 "Zend/zend_language_scanner.c"
+#line 7306 "Zend/zend_language_scanner.c"
 yy764:
 		YYDEBUG(764, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -6967,11 +7331,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(769, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1119 "Zend/zend_language_scanner.l"
+#line 1485 "Zend/zend_language_scanner.l"
 		{
-	return T_ENDSWITCH;
+	RETURN_STRING_TOKEN(T_ENDSWITCH)
 }
-#line 6975 "Zend/zend_language_scanner.c"
+#line 7339 "Zend/zend_language_scanner.c"
 yy770:
 		YYDEBUG(770, *YYCURSOR);
 		++YYCURSOR;
@@ -6980,11 +7344,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(771, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1063 "Zend/zend_language_scanner.l"
+#line 1429 "Zend/zend_language_scanner.l"
 		{
-	return T_ENDIF;
+	RETURN_STRING_TOKEN(T_ENDIF)
 }
-#line 6988 "Zend/zend_language_scanner.c"
+#line 7352 "Zend/zend_language_scanner.c"
 yy772:
 		YYDEBUG(772, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -7013,11 +7377,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 yy774:
 		YYDEBUG(774, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1087 "Zend/zend_language_scanner.l"
+#line 1453 "Zend/zend_language_scanner.l"
 		{
-	return T_ENDFOR;
+	RETURN_STRING_TOKEN(T_ENDFOR)
 }
-#line 7021 "Zend/zend_language_scanner.c"
+#line 7385 "Zend/zend_language_scanner.c"
 yy775:
 		YYDEBUG(775, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -7041,11 +7405,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(779, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1095 "Zend/zend_language_scanner.l"
+#line 1461 "Zend/zend_language_scanner.l"
 		{
-	return T_ENDFOREACH;
+	RETURN_STRING_TOKEN(T_ENDFOREACH)
 }
-#line 7049 "Zend/zend_language_scanner.c"
+#line 7413 "Zend/zend_language_scanner.c"
 yy780:
 		YYDEBUG(780, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -7079,11 +7443,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(786, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1103 "Zend/zend_language_scanner.l"
+#line 1469 "Zend/zend_language_scanner.l"
 		{
-	return T_ENDDECLARE;
+	RETURN_STRING_TOKEN(T_ENDDECLARE)
 }
-#line 7087 "Zend/zend_language_scanner.c"
+#line 7451 "Zend/zend_language_scanner.c"
 yy787:
 		YYDEBUG(787, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -7102,11 +7466,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(790, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1287 "Zend/zend_language_scanner.l"
+#line 1653 "Zend/zend_language_scanner.l"
 		{
-	return T_EMPTY;
+	RETURN_STRING_TOKEN(T_EMPTY)
 }
-#line 7110 "Zend/zend_language_scanner.c"
+#line 7474 "Zend/zend_language_scanner.c"
 yy791:
 		YYDEBUG(791, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -7135,11 +7499,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 yy793:
 		YYDEBUG(793, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1067 "Zend/zend_language_scanner.l"
+#line 1433 "Zend/zend_language_scanner.l"
 		{
-	return T_ELSE;
+	RETURN_STRING_TOKEN(T_ELSE)
 }
-#line 7143 "Zend/zend_language_scanner.c"
+#line 7507 "Zend/zend_language_scanner.c"
 yy794:
 		YYDEBUG(794, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -7153,11 +7517,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(796, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1059 "Zend/zend_language_scanner.l"
+#line 1425 "Zend/zend_language_scanner.l"
 		{
-	return T_ELSEIF;
+	RETURN_STRING_TOKEN(T_ELSEIF)
 }
-#line 7161 "Zend/zend_language_scanner.c"
+#line 7525 "Zend/zend_language_scanner.c"
 yy797:
 		YYDEBUG(797, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -7171,11 +7535,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		}
 		YYDEBUG(799, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1143 "Zend/zend_language_scanner.l"
+#line 1509 "Zend/zend_language_scanner.l"
 		{
-	return T_ECHO;
+	RETURN_STRING_TOKEN(T_ECHO)
 }
-#line 7179 "Zend/zend_language_scanner.c"
+#line 7543 "Zend/zend_language_scanner.c"
 	}
 /* *********************************** */
 yyc_ST_LOOKING_FOR_PROPERTY:
@@ -7248,13 +7612,13 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 yy803:
 		YYDEBUG(803, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1176 "Zend/zend_language_scanner.l"
+#line 1542 "Zend/zend_language_scanner.l"
 		{
 	ZVAL_STRINGL(zendlval, yytext, yyleng, 0); /* no copying - intentional */
 	HANDLE_NEWLINES(yytext, yyleng);
 	return T_WHITESPACE;
 }
-#line 7258 "Zend/zend_language_scanner.c"
+#line 7622 "Zend/zend_language_scanner.c"
 yy804:
 		YYDEBUG(804, *YYCURSOR);
 		++YYCURSOR;
@@ -7262,13 +7626,13 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 yy805:
 		YYDEBUG(805, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1193 "Zend/zend_language_scanner.l"
+#line 1559 "Zend/zend_language_scanner.l"
 		{
 	yyless(0);
 	yy_pop_state(TSRMLS_C);
 	goto restart;
 }
-#line 7272 "Zend/zend_language_scanner.c"
+#line 7636 "Zend/zend_language_scanner.c"
 yy806:
 		YYDEBUG(806, *YYCURSOR);
 		++YYCURSOR;
@@ -7277,14 +7641,14 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 yy807:
 		YYDEBUG(807, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1186 "Zend/zend_language_scanner.l"
+#line 1552 "Zend/zend_language_scanner.l"
 		{
 	yy_pop_state(TSRMLS_C);
 	zend_copy_value(zendlval, yytext, yyleng);
 	zendlval->type = IS_STRING;
 	return T_STRING;
 }
-#line 7288 "Zend/zend_language_scanner.c"
+#line 7652 "Zend/zend_language_scanner.c"
 yy808:
 		YYDEBUG(808, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -7305,11 +7669,11 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		++YYCURSOR;
 		YYDEBUG(812, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1182 "Zend/zend_language_scanner.l"
+#line 1548 "Zend/zend_language_scanner.l"
 		{
 	return T_OBJECT_OPERATOR;
 }
-#line 7313 "Zend/zend_language_scanner.c"
+#line 7677 "Zend/zend_language_scanner.c"
 yy813:
 		YYDEBUG(813, *YYCURSOR);
 		++YYCURSOR;
@@ -7394,14 +7758,14 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 yy818:
 		YYDEBUG(818, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1479 "Zend/zend_language_scanner.l"
+#line 1844 "Zend/zend_language_scanner.l"
 		{
 	yyless(0);
 	yy_pop_state(TSRMLS_C);
 	yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
 	goto restart;
 }
-#line 7405 "Zend/zend_language_scanner.c"
+#line 7769 "Zend/zend_language_scanner.c"
 yy819:
 		YYDEBUG(819, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -7426,7 +7790,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		++YYCURSOR;
 		YYDEBUG(824, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1469 "Zend/zend_language_scanner.l"
+#line 1834 "Zend/zend_language_scanner.l"
 		{
 	yyless(yyleng - 1);
 	zend_copy_value(zendlval, yytext, yyleng);
@@ -7435,7 +7799,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 	yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
 	return T_STRING_VARNAME;
 }
-#line 7439 "Zend/zend_language_scanner.c"
+#line 7803 "Zend/zend_language_scanner.c"
 	}
 /* *********************************** */
 yyc_ST_NOWDOC:
@@ -7446,7 +7810,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 	++YYCURSOR;
 	YYDEBUG(828, *YYCURSOR);
 	yyleng = YYCURSOR - SCNG(yy_text);
-#line 2299 "Zend/zend_language_scanner.l"
+#line 2663 "Zend/zend_language_scanner.l"
 	{
 	int newline = 0;
 
@@ -7503,7 +7867,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 	HANDLE_NEWLINES(yytext, yyleng - newline);
 	return T_ENCAPSED_AND_WHITESPACE;
 }
-#line 7507 "Zend/zend_language_scanner.c"
+#line 7871 "Zend/zend_language_scanner.c"
 /* *********************************** */
 yyc_ST_VAR_OFFSET:
 	{
@@ -7610,7 +7974,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 yy832:
 		YYDEBUG(832, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1555 "Zend/zend_language_scanner.l"
+#line 1920 "Zend/zend_language_scanner.l"
 		{ /* Offset could be treated as a long */
 	if (yyleng < MAX_LENGTH_OF_LONG - 1 || (yyleng == MAX_LENGTH_OF_LONG - 1 && strcmp(yytext, long_min_digits) < 0)) {
 		ZVAL_LONG(zendlval, strtol(yytext, NULL, 10));
@@ -7619,7 +7983,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 	}
 	return T_NUM_STRING;
 }
-#line 7623 "Zend/zend_language_scanner.c"
+#line 7987 "Zend/zend_language_scanner.c"
 yy833:
 		YYDEBUG(833, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -7639,23 +8003,23 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 yy835:
 		YYDEBUG(835, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1831 "Zend/zend_language_scanner.l"
+#line 2196 "Zend/zend_language_scanner.l"
 		{
 	/* Only '[' can be valid, but returning other tokens will allow a more explicit parse error */
 	return yytext[0];
 }
-#line 7648 "Zend/zend_language_scanner.c"
+#line 8012 "Zend/zend_language_scanner.c"
 yy836:
 		YYDEBUG(836, *YYCURSOR);
 		++YYCURSOR;
 		YYDEBUG(837, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1826 "Zend/zend_language_scanner.l"
+#line 2191 "Zend/zend_language_scanner.l"
 		{
 	yy_pop_state(TSRMLS_C);
 	return ']';
 }
-#line 7659 "Zend/zend_language_scanner.c"
+#line 8023 "Zend/zend_language_scanner.c"
 yy838:
 		YYDEBUG(838, *YYCURSOR);
 		yych = *++YYCURSOR;
@@ -7665,14 +8029,14 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		++YYCURSOR;
 		YYDEBUG(840, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1836 "Zend/zend_language_scanner.l"
+#line 2201 "Zend/zend_language_scanner.l"
 		{
 	/* Invalid rule to return a more explicit parse error with proper line number */
 	yyless(0);
 	yy_pop_state(TSRMLS_C);
 	return T_ENCAPSED_AND_WHITESPACE;
 }
-#line 7676 "Zend/zend_language_scanner.c"
+#line 8040 "Zend/zend_language_scanner.c"
 yy841:
 		YYDEBUG(841, *YYCURSOR);
 		++YYCURSOR;
@@ -7681,19 +8045,19 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 yy842:
 		YYDEBUG(842, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1843 "Zend/zend_language_scanner.l"
+#line 2208 "Zend/zend_language_scanner.l"
 		{
 	zend_copy_value(zendlval, yytext, yyleng);
 	zendlval->type = IS_STRING;
 	return T_STRING;
 }
-#line 7691 "Zend/zend_language_scanner.c"
+#line 8055 "Zend/zend_language_scanner.c"
 yy843:
 		YYDEBUG(843, *YYCURSOR);
 		++YYCURSOR;
 		YYDEBUG(844, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 2357 "Zend/zend_language_scanner.l"
+#line 2721 "Zend/zend_language_scanner.l"
 		{
 	if (YYCURSOR > YYLIMIT) {
 		return 0;
@@ -7702,7 +8066,7 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 	zend_error(E_COMPILE_WARNING,"Unexpected character in input:  '%c' (ASCII=%d) state=%d", yytext[0], yytext[0], YYSTATE);
 	goto restart;
 }
-#line 7706 "Zend/zend_language_scanner.c"
+#line 8070 "Zend/zend_language_scanner.c"
 yy845:
 		YYDEBUG(845, *YYCURSOR);
 		++YYCURSOR;
@@ -7738,13 +8102,13 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 yy849:
 		YYDEBUG(849, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1820 "Zend/zend_language_scanner.l"
+#line 2185 "Zend/zend_language_scanner.l"
 		{
 	zend_copy_value(zendlval, (yytext+1), (yyleng-1));
 	zendlval->type = IS_STRING;
 	return T_VARIABLE;
 }
-#line 7748 "Zend/zend_language_scanner.c"
+#line 8112 "Zend/zend_language_scanner.c"
 yy850:
 		YYDEBUG(850, *YYCURSOR);
 		++YYCURSOR;
@@ -7784,12 +8148,12 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 yy857:
 		YYDEBUG(857, *YYCURSOR);
 		yyleng = YYCURSOR - SCNG(yy_text);
-#line 1564 "Zend/zend_language_scanner.l"
+#line 1929 "Zend/zend_language_scanner.l"
 		{ /* Offset must be treated as a string */
 	ZVAL_STRINGL(zendlval, yytext, yyleng, 1);
 	return T_NUM_STRING;
 }
-#line 7793 "Zend/zend_language_scanner.c"
+#line 8157 "Zend/zend_language_scanner.c"
 yy858:
 		YYDEBUG(858, *YYCURSOR);
 		++YYCURSOR;
@@ -7812,6 +8176,6 @@ int lex_scan(zval *zendlval TSRMLS_DC)
 		goto yy857;
 	}
 }
-#line 2366 "Zend/zend_language_scanner.l"
+#line 2730 "Zend/zend_language_scanner.l"
 
 }
diff --git a/Zend/zend_language_scanner.h b/Zend/zend_language_scanner.h
index 2e5914f1b20a0..783da79c05b6f 100644
--- a/Zend/zend_language_scanner.h
+++ b/Zend/zend_language_scanner.h
@@ -66,6 +66,37 @@ ZEND_API int zend_multibyte_set_filter(const zend_encoding *onetime_encoding TSR
 
 END_EXTERN_C()
 
+/* maximal lookahead token buffer array size */
+#define ZEND_INIT_TOKEN_BUF_SIZE	8
+
+#define LEX_NO_TOKEN_MODE	0
+#define LEX_USE_TOKEN_MODE	1
+#define LEX_FUNC_NAMING_TOKEN_MODE	2
+
+#define PARSER_IGNORED_TOKEN_CASES \
+	case T_COMMENT: \
+	case T_DOC_COMMENT: \
+	case T_OPEN_TAG: \
+	case T_WHITESPACE: \
+	case T_CLOSE_TAG: \
+	case T_OPEN_TAG_WITH_ECHO:
+
+#define COPIED_STRING_TOKEN_CASES \
+	case T_STRING: \
+	case T_STRING_VARNAME: \
+	case T_VARIABLE: \
+	case T_ENCAPSED_AND_WHITESPACE: \
+	case T_CONSTANT_ENCAPSED_STRING: \
+	case T_INLINE_HTML: \
+	case T_CLASS_C: \
+	case T_TRAIT_C: \
+	case T_FUNC_C: \
+	case T_METHOD_C: \
+	case T_LINE: \
+	case T_FILE: \
+	case T_DIR: \
+	case T_NS_C:
+
 #endif
 
 /*
diff --git a/Zend/zend_language_scanner.l b/Zend/zend_language_scanner.l
index f9c421fe8805a..08e14abd6739c 100644
--- a/Zend/zend_language_scanner.l
+++ b/Zend/zend_language_scanner.l
@@ -112,15 +112,19 @@ do {																			\
 	} \
 }
 
-/* To save initial string length after scanning to first variable, CG(doc_comment_len) can be reused */
-#define SET_DOUBLE_QUOTES_SCANNED_LENGTH(len) CG(doc_comment_len) = (len)
-#define GET_DOUBLE_QUOTES_SCANNED_LENGTH()    CG(doc_comment_len)
+/* To save initial string length after scanning to first variable, SCNG(doc_comment_len) can be reused */
+#define SET_DOUBLE_QUOTES_SCANNED_LENGTH(len) SCNG(doc_comment_len) = (len)
+#define GET_DOUBLE_QUOTES_SCANNED_LENGTH()    SCNG(doc_comment_len)
 
 #define IS_LABEL_START(c) (((c) >= 'a' && (c) <= 'z') || ((c) >= 'A' && (c) <= 'Z') || (c) == '_' || (c) >= 0x7F)
 
 #define ZEND_IS_OCT(c)  ((c)>='0' && (c)<='7')
 #define ZEND_IS_HEX(c)  (((c)>='0' && (c)<='9') || ((c)>='a' && (c)<='f') || ((c)>='A' && (c)<='F'))
 
+static zend_bool lex_is_real_string_token_table[512];
+
+static zend_always_inline zend_bool lex_is_real_string_token(int token);
+
 BEGIN_EXTERN_C()
 
 static size_t encoding_filter_script_to_internal(unsigned char **to, size_t *to_length, const unsigned char *from, size_t from_length TSRMLS_DC)
@@ -177,6 +181,10 @@ static void yy_scan_buffer(char *str, unsigned int len TSRMLS_DC)
 
 void startup_scanner(TSRMLS_D)
 {
+	int i;
+	for (i = -1; ++i < 512;) {
+		lex_is_real_string_token_table[i] = lex_is_real_string_token(i);
+	}
 	CG(parse_error) = 0;
 	CG(doc_comment) = NULL;
 	CG(doc_comment_len) = 0;
@@ -986,8 +994,366 @@ static void zend_scan_escape_string(zval *zendlval, char *str, int len, char quo
 	}
 }
 
+int lex_scan_ex(zval *zendlval TSRMLS_DC);
+
+#define LEX_BUF_ADD_EX \
+	buf_tmp = CG(tokenbuffer) + (++CG(tokenbufptr)); \
+	buf_tmp->zv = *zendlval; \
+	buf_tmp->token = retval; \
+	buf_tmp->text = SCNG(yy_text); \
+	buf_tmp->len = SCNG(yy_leng); \
+	buf_tmp->start = SCNG(yy_cursor); \
+	buf_tmp->end = SCNG(yy_limit); \
+	if (retval == T_DOC_COMMENT) { \
+		buf_tmp->doc_comment = SCNG(doc_comment); \
+		buf_tmp->doc_comment_len = SCNG(doc_comment_len); \
+	} \
+	buf_tmp->lineno = CG(zend_lineno);
+
+#define LEX_BUF_ADD \
+	buf_two = buf_one; \
+	buf_two_token = buf_one_token; \
+	LEX_BUF_ADD_EX \
+	buf_one = buf_tmp; \
+	buf_one_token = retval; \
+	goto again;
+
+static zend_always_inline int lex_get_real_buf_offset(const int relpos) {
+	int effective_pos = CG(tokenbufptr) - relpos + 1;
+	int i = CG(tokenbufptr) + 1;
+	while (--i >= effective_pos) {
+		switch(CG(tokenbuffer)[i].token) {
+			PARSER_IGNORED_TOKEN_CASES
+				--effective_pos;
+		}
+	}
+	return effective_pos >= 0?effective_pos:-1;
+}
+
+#define LEX_REL_BUF(relpos) \
+	(CG(tokenbuffer)[lex_get_real_buf_offset(relpos)])
+
+static zend_always_inline zend_bool lex_is_real_string_token(int token) {
+	switch (token) {
+		PARSER_IGNORED_TOKEN_CASES
+		COPIED_STRING_TOKEN_CASES
+			return 1;
+	}
+	return token < 256;
+}
+
+#define LEX_IS_CUR_ALPH_TOKEN() \
+	(Z_TYPE_P(zendlval) == 255 && !lex_is_real_string_token_table[retval])
+
+#define LEX_IS_REL_ALPH_TOKEN(relpos) \
+	(Z_TYPE(LEX_REL_BUF(relpos).zv) == 255 && !lex_is_real_string_token_table[LEX_REL_BUF(relpos).token])
+
+#define LEX_IS_BUF_ALPH_TOKEN(buf) \
+	(Z_TYPE(buf->zv) == 255 && !lex_is_real_string_token_table[buf##_token])
+
+#define LEX_CONVERT_STRING(token, zval, text, len) \
+	token = T_STRING; \
+	Z_STRLEN(zval) = len; \
+	Z_STRVAL(zval) = estrndup(text, len); \
+	Z_TYPE(zval) = IS_STRING;
+
+#define LEX_CONVERT_CUR_STRING() LEX_CONVERT_STRING(retval, *zendlval, yytext, yyleng) goto leave;
+
+#define LEX_CONVERT_REL_STRING(relpos) LEX_CONVERT_STRING(LEX_REL_BUF(relpos).token, LEX_REL_BUF(relpos).zv, (char *)LEX_REL_BUF(relpos).text, LEX_REL_BUF(relpos).len)
+
+#define LEX_CONVERT_BUF_STRING(buf) LEX_CONVERT_STRING(buf##_token, buf->zv, (char *)buf->text, buf->len) buf->token = buf##_token;
+
+#define LEX_PREPARE_RETURN_FROM_BUF \
+	buf_tmp = CG(tokenbuffer) + CG(tokenbufptr)++; \
+	*zendlval = buf_tmp->zv; \
+	if (Z_TYPE_P(zendlval) == 255) { \
+		Z_TYPE_P(zendlval) = 0; \
+	} \
+	retval = buf_tmp->token; \
+	if (retval == '}' || retval == T_DOC_COMMENT) { \
+		RESET_DOC_COMMENT(); \
+	} \
+	SCNG(yy_text) = buf_tmp->text; \
+	SCNG(yy_leng) = buf_tmp->len; \
+	SCNG(yy_cursor) = buf_tmp->start; \
+	SCNG(yy_limit) = buf_tmp->end; \
+	if (retval == T_DOC_COMMENT) { \
+		CG(doc_comment) = buf_tmp->doc_comment; \
+		CG(doc_comment_len) = buf_tmp->doc_comment_len; \
+	} \
+	CG(zend_lineno) = buf_tmp->lineno;
+
+/* This function checks the cases where a token needs to be converted to some other token to simplify parsing */
+/* Also it shouldn't be done in parser, because it actually breaks applications relying on token_get_all output */
+/* Doing it in parser also would make highlight_string() etc. look ugly when tokens are used as other tokens */
+/* The real lexing step is done in lex_scan_ex */
+int lex_scan(zval *zendlval) {
+	int retval;
+	token_buf *buf_one, *buf_two, *buf_tmp;
+	int buf_one_token, buf_two_token;
+
+	if (CG(tokenbufptr) != -1) {
+		if (CG(tokenbuffer)[CG(tokenbufptr)].token != -1) {
+			LEX_PREPARE_RETURN_FROM_BUF
+			return retval;
+		}
+		CG(tokenbufptr) = -1;
+	}
+
+	buf_one = CG(tokenbuffer) - 1;
+	buf_one_token = buf_one->token;
+	buf_two = buf_one;
+	buf_two_token = buf_one_token;
+
+again:
+	Z_TYPE_P(zendlval) = 0;
+	retval = lex_scan_ex(zendlval);
+
+	switch (retval) {
+		COPIED_STRING_TOKEN_CASES
+			goto leave;
+	}
+	if (retval) {
+		if (CG(tokenbufptr) >= CG(tokenbufsize) - 4) {
+			CG(tokenbuffer) = erealloc(--CG(tokenbuffer), sizeof(token_buf) * ((CG(tokenbufsize) *= 2) + 1));
+			CG(tokenbuffer)++;
+			buf_one = CG(tokenbuffer) + lex_get_real_buf_offset(1);
+			buf_one_token = buf_one->token;
+			buf_two = CG(tokenbuffer) + lex_get_real_buf_offset(2);
+			buf_two_token = buf_two->token;
+		}
+
+		if (CG(tokenbufptr) != -1) {
+			switch (retval) {
+				PARSER_IGNORED_TOKEN_CASES
+					LEX_BUF_ADD_EX
+					goto again;
+			}
+
+			/* class access */
+			/* class name */
+			if (retval == T_PAAMAYIM_NEKUDOTAYIM && LEX_IS_BUF_ALPH_TOKEN(buf_one)) {
+				LEX_CONVERT_BUF_STRING(buf_one);
+			}
+			/* class const / method name */
+			if (buf_one_token == T_PAAMAYIM_NEKUDOTAYIM && LEX_IS_CUR_ALPH_TOKEN()) {
+				/* ::class is reserved */
+				if (retval == T_CLASS) {
+					goto leave;
+				}
+				LEX_CONVERT_CUR_STRING();
+			}
+
+			/* classes */
+			if (CG(tokenbuf_in_class) != -1 && LEX_IS_CUR_ALPH_TOKEN()) {
+				/* class name */
+				switch (buf_one_token) {
+					case T_CLASS:
+					case T_INTERFACE:
+					case T_TRAIT:
+						if (retval != T_NAMESPACE) {
+							LEX_CONVERT_CUR_STRING();
+						}
+				}
+				if (CG(tokenbuf_in_class) == 0 && retval != T_NAMESPACE && (((retval != T_IMPLEMENTS && retval != T_EXTENDS) || buf_one_token == ',' || buf_one_token == T_IMPLEMENTS) || (retval == T_IMPLEMENTS && buf_one_token == T_EXTENDS)) && LEX_IS_CUR_ALPH_TOKEN()) {
+					LEX_CONVERT_CUR_STRING();
+				}
+				/* method names */
+				if ((buf_one_token == T_FUNCTION || (buf_one_token == '&' && buf_two_token == T_FUNCTION)) && LEX_IS_CUR_ALPH_TOKEN()) {
+					LEX_CONVERT_CUR_STRING();
+				}
+				/* constant names */
+				if (buf_one_token == T_CONST && LEX_IS_CUR_ALPH_TOKEN()) {
+					LEX_CONVERT_CUR_STRING();
+				}
+				/* trait use aliasing */
+				if (CG(tokenbuf_mode) == LEX_USE_TOKEN_MODE) {
+					if (retval == ';' && LEX_IS_BUF_ALPH_TOKEN(buf_one)) {
+						switch (buf_one_token) {
+							case T_PUBLIC:
+							case T_PROTECTED:
+							case T_PRIVATE:
+								break;
+							default:
+								LEX_BUF_ADD
+						}
+					}
+					if (buf_one_token == T_INSTEADOF && LEX_IS_CUR_ALPH_TOKEN()) {
+						LEX_BUF_ADD
+					}
+				}
+			}
+
+			/* class name typehints */
+			if (CG(tokenbuf_fn_decl) == 0 && (buf_one_token == '(' || buf_one_token == ',') && retval != T_NAMESPACE && LEX_IS_CUR_ALPH_TOKEN()) {
+				LEX_CONVERT_CUR_STRING();
+			}
 
-int lex_scan(zval *zendlval TSRMLS_DC)
+			/* goto & labels */
+			if ((retval == ':' || (retval == ';' && buf_two_token == T_GOTO)) && LEX_IS_BUF_ALPH_TOKEN(buf_one)) {
+				/* disallow replacing of alternative syntax and default (in switch) */
+				switch (buf_one_token) {
+					case T_DEFAULT:
+					case T_ELSE:
+						break;
+					default:
+						LEX_CONVERT_BUF_STRING(buf_one);
+				}
+			}
+			if (buf_one_token == T_GOTO && LEX_IS_CUR_ALPH_TOKEN() && retval != T_DEFAULT) {
+				LEX_CONVERT_CUR_STRING();
+			}
+
+			/* namespaces */
+			/* Disallow T_NAMESPACE because of namespace\string syntax */
+			switch (buf_one_token) {
+				case T_USE:
+					if (CG(tokenbuf_in_class) != -1) {
+						break;
+					}
+				case T_NEW:
+				case T_NAMESPACE:
+					if (retval != T_NAMESPACE && LEX_IS_CUR_ALPH_TOKEN()) {
+						LEX_CONVERT_CUR_STRING();
+					}
+			}
+			if (buf_two_token == T_NS_SEPARATOR && LEX_IS_BUF_ALPH_TOKEN(buf_one) && (retval != T_NS_SEPARATOR || buf_one_token != T_NAMESPACE)) {
+				LEX_CONVERT_BUF_STRING(buf_one);
+			}
+
+			if (retval == T_NS_SEPARATOR) {
+				switch (buf_one_token) {
+					case T_NAMESPACE:
+						break;
+					case T_NEW:
+						if (buf_two_token == T_THROW || buf_two_token == T_RETURN || buf_two_token == ',') {
+							break;
+						}
+					case T_USE:
+					case T_ECHO:
+					case T_YIELD:
+						if (buf_two_token < 256 && buf_two_token != ',') {
+							break;
+						}
+					case T_IMPLEMENTS:
+						if (buf_one_token == T_IMPLEMENTS && buf_two_token != T_IMPLEMENTS && buf_two_token != T_EXTENDS && buf_two_token != ',') {
+							break;
+						}
+					case T_EXTENDS:
+						if (buf_one_token == T_EXTENDS && buf_two_token != T_EXTENDS && buf_two_token != ',') {
+							break;
+						}
+					default:
+						if (LEX_IS_BUF_ALPH_TOKEN(buf_one)) {
+							LEX_CONVERT_BUF_STRING(buf_one);
+						}
+				}
+			}
+			/* handling of multiple comma separated T_USE */
+			if (CG(tokenbuf_mode) == LEX_USE_TOKEN_MODE && LEX_IS_CUR_ALPH_TOKEN() && buf_one_token == ',') {
+				LEX_CONVERT_CUR_STRING();
+			}
+
+			/* Handling of T_HALT_COMPILER; might cause memory leaks if not handled */
+			if (
+				   (buf_one_token == T_HALT_COMPILER && retval == '(')
+				|| (buf_two_token == T_HALT_COMPILER && buf_one_token == '(' && retval == ')')
+			   ) {
+				LEX_BUF_ADD
+			}
+		}
+
+		switch (retval) {
+			case '{':
+				if (CG(tokenbuf_in_class) != -1) {
+					++CG(tokenbuf_in_class);
+				}
+				break;
+			case '}':
+				if (CG(tokenbuf_in_class) != -1 && --CG(tokenbuf_in_class) == 0) {
+					CG(tokenbuf_in_class) = -1;
+				}
+				break;
+			case T_CLASS:
+			case T_INTERFACE:
+			case T_TRAIT:
+				if (CG(tokenbuf_in_class) == -1) {
+					CG(tokenbuf_in_class) = 0;
+				}
+				break;
+			case ';':
+				if (CG(tokenbuf_mode) == LEX_USE_TOKEN_MODE) {
+					CG(tokenbuf_mode) = LEX_NO_TOKEN_MODE;
+				}
+				break;
+			case T_FUNCTION:
+				if (CG(tokenbuf_mode) == LEX_NO_TOKEN_MODE) {
+					CG(tokenbuf_mode) = LEX_FUNC_NAMING_TOKEN_MODE;
+				}
+				break;
+			case '(':
+				if (CG(tokenbuf_mode) == LEX_FUNC_NAMING_TOKEN_MODE) {
+					CG(tokenbuf_mode) = LEX_NO_TOKEN_MODE;
+					CG(tokenbuf_fn_decl) = 0;
+				} else if (CG(tokenbuf_fn_decl) != -1) {
+					++CG(tokenbuf_fn_decl);
+				}
+				break;
+			case ')':
+				if (CG(tokenbuf_fn_decl) != -1) {
+					--CG(tokenbuf_fn_decl);
+				}
+				break;
+			case T_USE:
+				if (CG(tokenbuf_mode) == LEX_NO_TOKEN_MODE) {
+					CG(tokenbuf_mode) = LEX_USE_TOKEN_MODE;
+				}
+				break;
+		}
+
+		if (LEX_IS_CUR_ALPH_TOKEN()) {
+			LEX_BUF_ADD
+		} else {
+			switch (retval) {
+				case ';':
+					if (buf_two_token == '(' && LEX_REL_BUF(3).token == T_HALT_COMPILER) {
+						break;
+					}
+				case '&':
+				case ',':
+				case '(':
+				case T_PAAMAYIM_NEKUDOTAYIM:
+				case T_NS_SEPARATOR:
+					LEX_BUF_ADD
+			}
+		}
+	}
+
+leave:
+
+	if (CG(tokenbufptr) != -1) {
+		LEX_BUF_ADD_EX
+		CG(tokenbuffer)[CG(tokenbufptr) + 1].token = -1;
+		CG(tokenbufptr) = 0;
+		LEX_PREPARE_RETURN_FROM_BUF
+	} else if (retval == '}' || retval == T_DOC_COMMENT) {
+		RESET_DOC_COMMENT();
+		if (retval == T_DOC_COMMENT) {
+			CG(doc_comment) = SCNG(doc_comment);
+			CG(doc_comment_len) = SCNG(doc_comment_len);
+		}
+	}
+
+	return retval;
+}
+
+/* Mark token as eventual T_STRING */
+#define RETURN_STRING_TOKEN(token) \
+	Z_TYPE_P(zendlval) = 255; /* mark keyword ready for eventual conversion to T_STRING in lex_scan function */ \
+	return token;
+
+/* "Real" lexer (see comments above to function lex_scan) */
+int lex_scan_ex(zval *zendlval TSRMLS_DC)
 {
 restart:
 	SCNG(yy_text) = YYCURSOR;
@@ -1013,159 +1379,159 @@ NEWLINE ("\r"|"\n"|"\r\n")
 
 
 <ST_IN_SCRIPTING>"exit" {
-	return T_EXIT;
+	RETURN_STRING_TOKEN(T_EXIT)
 }
 
 <ST_IN_SCRIPTING>"die" {
-	return T_EXIT;
+	RETURN_STRING_TOKEN(T_EXIT)
 }
 
 <ST_IN_SCRIPTING>"function" {
-	return T_FUNCTION;
+	RETURN_STRING_TOKEN(T_FUNCTION)
 }
 
 <ST_IN_SCRIPTING>"const" {
-	return T_CONST;
+	RETURN_STRING_TOKEN(T_CONST)
 }
 
 <ST_IN_SCRIPTING>"return" {
-	return T_RETURN;
+	RETURN_STRING_TOKEN(T_RETURN)
 }
 
 <ST_IN_SCRIPTING>"yield" {
-	return T_YIELD;
+	RETURN_STRING_TOKEN(T_YIELD)
 }
 
 <ST_IN_SCRIPTING>"try" {
-	return T_TRY;
+	RETURN_STRING_TOKEN(T_TRY)
 }
 
 <ST_IN_SCRIPTING>"catch" {
-	return T_CATCH;
+	RETURN_STRING_TOKEN(T_CATCH)
 }
 
 <ST_IN_SCRIPTING>"finally" {
-	return T_FINALLY;
+	RETURN_STRING_TOKEN(T_FINALLY)
 }
 
 <ST_IN_SCRIPTING>"throw" {
-	return T_THROW;
+	RETURN_STRING_TOKEN(T_THROW)
 }
 
 <ST_IN_SCRIPTING>"if" {
-	return T_IF;
+	RETURN_STRING_TOKEN(T_IF)
 }
 
 <ST_IN_SCRIPTING>"elseif" {
-	return T_ELSEIF;
+	RETURN_STRING_TOKEN(T_ELSEIF)
 }
 
 <ST_IN_SCRIPTING>"endif" {
-	return T_ENDIF;
+	RETURN_STRING_TOKEN(T_ENDIF)
 }
 
 <ST_IN_SCRIPTING>"else" {
-	return T_ELSE;
+	RETURN_STRING_TOKEN(T_ELSE)
 }
 
 <ST_IN_SCRIPTING>"while" {
-	return T_WHILE;
+	RETURN_STRING_TOKEN(T_WHILE)
 }
 
 <ST_IN_SCRIPTING>"endwhile" {
-	return T_ENDWHILE;
+	RETURN_STRING_TOKEN(T_ENDWHILE)
 }
 
 <ST_IN_SCRIPTING>"do" {
-	return T_DO;
+	RETURN_STRING_TOKEN(T_DO)
 }
 
 <ST_IN_SCRIPTING>"for" {
-	return T_FOR;
+	RETURN_STRING_TOKEN(T_FOR)
 }
 
 <ST_IN_SCRIPTING>"endfor" {
-	return T_ENDFOR;
+	RETURN_STRING_TOKEN(T_ENDFOR)
 }
 
 <ST_IN_SCRIPTING>"foreach" {
-	return T_FOREACH;
+	RETURN_STRING_TOKEN(T_FOREACH)
 }
 
 <ST_IN_SCRIPTING>"endforeach" {
-	return T_ENDFOREACH;
+	RETURN_STRING_TOKEN(T_ENDFOREACH)
 }
 
 <ST_IN_SCRIPTING>"declare" {
-	return T_DECLARE;
+	RETURN_STRING_TOKEN(T_DECLARE)
 }
 
 <ST_IN_SCRIPTING>"enddeclare" {
-	return T_ENDDECLARE;
+	RETURN_STRING_TOKEN(T_ENDDECLARE)
 }
 
 <ST_IN_SCRIPTING>"instanceof" {
-	return T_INSTANCEOF;
+	RETURN_STRING_TOKEN(T_INSTANCEOF)
 }
 
 <ST_IN_SCRIPTING>"as" {
-	return T_AS;
+	RETURN_STRING_TOKEN(T_AS)
 }
 
 <ST_IN_SCRIPTING>"switch" {
-	return T_SWITCH;
+	RETURN_STRING_TOKEN(T_SWITCH)
 }
 
 <ST_IN_SCRIPTING>"endswitch" {
-	return T_ENDSWITCH;
+	RETURN_STRING_TOKEN(T_ENDSWITCH)
 }
 
 <ST_IN_SCRIPTING>"case" {
-	return T_CASE;
+	RETURN_STRING_TOKEN(T_CASE)
 }
 
 <ST_IN_SCRIPTING>"default" {
-	return T_DEFAULT;
+	RETURN_STRING_TOKEN(T_DEFAULT)
 }
 
 <ST_IN_SCRIPTING>"break" {
-	return T_BREAK;
+	RETURN_STRING_TOKEN(T_BREAK)
 }
 
 <ST_IN_SCRIPTING>"continue" {
-	return T_CONTINUE;
+	RETURN_STRING_TOKEN(T_CONTINUE)
 }
 
 <ST_IN_SCRIPTING>"goto" {
-	return T_GOTO;
+	RETURN_STRING_TOKEN(T_GOTO)
 }
 
 <ST_IN_SCRIPTING>"echo" {
-	return T_ECHO;
+	RETURN_STRING_TOKEN(T_ECHO)
 }
 
 <ST_IN_SCRIPTING>"print" {
-	return T_PRINT;
+	RETURN_STRING_TOKEN(T_PRINT)
 }
 
 <ST_IN_SCRIPTING>"class" {
-	return T_CLASS;
+	RETURN_STRING_TOKEN(T_CLASS)
 }
 
 <ST_IN_SCRIPTING>"interface" {
-	return T_INTERFACE;
+	RETURN_STRING_TOKEN(T_INTERFACE)
 }
 
 <ST_IN_SCRIPTING>"trait" {
-	return T_TRAIT;
+	RETURN_STRING_TOKEN(T_TRAIT)
 }
 
 <ST_IN_SCRIPTING>"extends" {
-	return T_EXTENDS;
+	RETURN_STRING_TOKEN(T_EXTENDS)
 }
 
 <ST_IN_SCRIPTING>"implements" {
-	return T_IMPLEMENTS;
+	RETURN_STRING_TOKEN(T_IMPLEMENTS)
 }
 
 <ST_IN_SCRIPTING>"->" {
@@ -1205,15 +1571,15 @@ NEWLINE ("\r"|"\n"|"\r\n")
 }
 
 <ST_IN_SCRIPTING>"new" {
-	return T_NEW;
+	RETURN_STRING_TOKEN(T_NEW)
 }
 
 <ST_IN_SCRIPTING>"clone" {
-	return T_CLONE;
+	RETURN_STRING_TOKEN(T_CLONE)
 }
 
 <ST_IN_SCRIPTING>"var" {
-	return T_VAR;
+	RETURN_STRING_TOKEN(T_VAR)
 }
 
 <ST_IN_SCRIPTING>"("{TABS_AND_SPACES}("int"|"integer"){TABS_AND_SPACES}")" {
@@ -1245,79 +1611,79 @@ NEWLINE ("\r"|"\n"|"\r\n")
 }
 
 <ST_IN_SCRIPTING>"eval" {
-	return T_EVAL;
+	RETURN_STRING_TOKEN(T_EVAL)
 }
 
 <ST_IN_SCRIPTING>"include" {
-	return T_INCLUDE;
+	RETURN_STRING_TOKEN(T_INCLUDE)
 }
 
 <ST_IN_SCRIPTING>"include_once" {
-	return T_INCLUDE_ONCE;
+	RETURN_STRING_TOKEN(T_INCLUDE_ONCE)
 }
 
 <ST_IN_SCRIPTING>"require" {
-	return T_REQUIRE;
+	RETURN_STRING_TOKEN(T_REQUIRE)
 }
 
 <ST_IN_SCRIPTING>"require_once" {
-	return T_REQUIRE_ONCE;
+	RETURN_STRING_TOKEN(T_REQUIRE_ONCE)
 }
 
 <ST_IN_SCRIPTING>"namespace" {
-	return T_NAMESPACE;
+	RETURN_STRING_TOKEN(T_NAMESPACE)
 }
 
 <ST_IN_SCRIPTING>"use" {
-	return T_USE;
+	RETURN_STRING_TOKEN(T_USE)
 }
 
 <ST_IN_SCRIPTING>"insteadof" {
-        return T_INSTEADOF;
+	RETURN_STRING_TOKEN(T_INSTEADOF)
 }
 
 <ST_IN_SCRIPTING>"global" {
-	return T_GLOBAL;
+	RETURN_STRING_TOKEN(T_GLOBAL)
 }
 
 <ST_IN_SCRIPTING>"isset" {
-	return T_ISSET;
+	RETURN_STRING_TOKEN(T_ISSET)
 }
 
 <ST_IN_SCRIPTING>"empty" {
-	return T_EMPTY;
+	RETURN_STRING_TOKEN(T_EMPTY)
 }
 
 <ST_IN_SCRIPTING>"__halt_compiler" {
-	return T_HALT_COMPILER;
+	RETURN_STRING_TOKEN(T_HALT_COMPILER)
 }
 
 <ST_IN_SCRIPTING>"static" {
-	return T_STATIC;
+	RETURN_STRING_TOKEN(T_STATIC)
 }
 
 <ST_IN_SCRIPTING>"abstract" {
-	return T_ABSTRACT;
+	RETURN_STRING_TOKEN(T_ABSTRACT)
 }
 
 <ST_IN_SCRIPTING>"final" {
-	return T_FINAL;
+	RETURN_STRING_TOKEN(T_FINAL)
 }
 
 <ST_IN_SCRIPTING>"private" {
-	return T_PRIVATE;
+	RETURN_STRING_TOKEN(T_PRIVATE)
 }
 
 <ST_IN_SCRIPTING>"protected" {
-	return T_PROTECTED;
+	RETURN_STRING_TOKEN(T_PROTECTED)
 }
 
 <ST_IN_SCRIPTING>"public" {
-	return T_PUBLIC;
+	RETURN_STRING_TOKEN(T_PUBLIC)
 }
 
 <ST_IN_SCRIPTING>"unset" {
-	return T_UNSET;
+	RETURN_STRING_TOKEN(T_UNSET)
 }
 
 <ST_IN_SCRIPTING>"=>" {
@@ -1325,15 +1691,15 @@ NEWLINE ("\r"|"\n"|"\r\n")
 }
 
 <ST_IN_SCRIPTING>"list" {
-	return T_LIST;
+	RETURN_STRING_TOKEN(T_LIST)
 }
 
 <ST_IN_SCRIPTING>"array" {
-	return T_ARRAY;
+	RETURN_STRING_TOKEN(T_ARRAY)
 }
 
 <ST_IN_SCRIPTING>"callable" {
- return T_CALLABLE;
+	RETURN_STRING_TOKEN(T_CALLABLE)
 }
 
 <ST_IN_SCRIPTING>"++" {
@@ -1417,19 +1783,19 @@ NEWLINE ("\r"|"\n"|"\r\n")
 }
 
 <ST_IN_SCRIPTING>"&&" {
-	return T_BOOLEAN_AND;
+	RETURN_STRING_TOKEN(T_BOOLEAN_AND)
 }
 
 <ST_IN_SCRIPTING>"OR" {
-	return T_LOGICAL_OR;
+	RETURN_STRING_TOKEN(T_LOGICAL_OR)
 }
 
 <ST_IN_SCRIPTING>"AND" {
-	return T_LOGICAL_AND;
+	RETURN_STRING_TOKEN(T_LOGICAL_AND)
 }
 
 <ST_IN_SCRIPTING>"XOR" {
-	return T_LOGICAL_XOR;
+	RETURN_STRING_TOKEN(T_LOGICAL_XOR)
 }
 
 <ST_IN_SCRIPTING>"<<" {
@@ -1458,7 +1824,6 @@ NEWLINE ("\r"|"\n"|"\r\n")
 
 
 <ST_IN_SCRIPTING>"}" {
-	RESET_DOC_COMMENT();
 	if (!zend_stack_is_empty(&SCNG(state_stack))) {
 		yy_pop_state(TSRMLS_C);
 	}
@@ -1886,7 +2251,6 @@ inline_html:
 
 	if (yyleng > 2) {
 		doc_com = 1;
-		RESET_DOC_COMMENT();
 	} else {
 		doc_com = 0;
 	}
@@ -1907,8 +2271,8 @@ inline_html:
 	HANDLE_NEWLINES(yytext, yyleng);
 
 	if (doc_com) {
-		CG(doc_comment) = estrndup(yytext, yyleng);
-		CG(doc_comment_len) = yyleng;
+		SCNG(doc_comment) = estrndup(yytext, yyleng);
+		SCNG(doc_comment_len) = yyleng;
 		return T_DOC_COMMENT;
 	}
 
diff --git a/ext/tokenizer/tokenizer.c b/ext/tokenizer/tokenizer.c
index ee96e2eaa11e1..602884d156b67 100644
--- a/ext/tokenizer/tokenizer.c
+++ b/ext/tokenizer/tokenizer.c
@@ -115,16 +115,13 @@ static void tokenize(zval *return_value TSRMLS_DC)
 	ZVAL_NULL(&token);
 	while ((token_type = lex_scan(&token TSRMLS_CC))) {
 		destroy = 1;
+		if (token_type == T_CLOSE_TAG && zendtext[zendleng - 1] != '>') {
+			CG(zend_lineno)++;
+		}
 		switch (token_type) {
-			case T_CLOSE_TAG:
-				if (zendtext[zendleng - 1] != '>') {
-					CG(zend_lineno)++;
-				}
-			case T_OPEN_TAG:
-			case T_OPEN_TAG_WITH_ECHO:
-			case T_WHITESPACE:
-			case T_COMMENT:
-			case T_DOC_COMMENT:
+			COPIED_STRING_TOKEN_CASES
+				break;
+			default:
 				destroy = 0;
 				break;
 		}
diff --git a/tests/basic/bug51709_1.phpt b/tests/basic/bug51709_1.phpt
index 3f2d544e54d5c..93d5774ed7ad1 100644
--- a/tests/basic/bug51709_1.phpt
+++ b/tests/basic/bug51709_1.phpt
@@ -1,16 +1,16 @@
 --TEST--
-Bug #51709 (Can't use keywords as method names)
+Bug #51709 (Use keywords as method or class names)
 --FILE--
 <?php
 
-class foo {
-        static function for() {
-                echo "1";
-        }
+class for {
+	static function foreach() {
+		echo "OK";
+	}
 }
 
+for::foreach();
+
 ?>
-===DONE===
-<?php exit(0); ?>
 --EXPECTF--
-Parse error: syntax error, unexpected %s, expecting %s in %sbug51709_1.php on line %d
+OK
diff --git a/tests/basic/bug51709_2.phpt b/tests/basic/bug51709_2.phpt
index bb1f91cc4c7e2..6112c416bf02c 100644
--- a/tests/basic/bug51709_2.phpt
+++ b/tests/basic/bug51709_2.phpt
@@ -1,16 +1,16 @@
 --TEST--
-Bug #51709 (Can't use keywords as method names)
+Bug #51709 (Use keywords as method or class names)
 --FILE--
 <?php
 
-class foo {
+class List {
         static function goto() {
-                echo "1";
+                echo "OK";
         }
 }
 
+List::goto();
+
 ?>
-===DONE===
-<?php exit(0); ?>
 --EXPECTF--
-Parse error: syntax error, unexpected %s, expecting %s in %sbug51709_2.php on line %d
+OK
diff --git a/tests/lang/bug21820.phpt b/tests/lang/bug21820.phpt
index cbf466eea7fc2..68a1856cbfb57 100644
--- a/tests/lang/bug21820.phpt
+++ b/tests/lang/bug21820.phpt
@@ -10,4 +10,4 @@ echo "$arr['foo']";
 
 ?>
 --EXPECTF--
-Parse error: %s error, %s(T_STRING)%s(T_VARIABLE)%s(T_NUM_STRING)%sin %sbug21820.php on line %d
+Parse error: %s error, %s(T_ENCAPSED_AND_WHITESPACE)%sin %sbug21820.php on line %d