import/use last call

> Stanislav Malyshev wrote: > >> Hold off for a bit - I may have a simple solution that solves the > >> problem for class names, method names and functions, have to code the > >> patch tonight first to prove it works. > > > > OK, please send it as soon as you have it :) > Hi, > > The attached patch is for PHP 5.3, if it is acceptable, I will port it > to PHP 6, which is not difficult, although it does involve a lot of > cut/pasting. > > The patch does these things: > > 1) fixes an unrelated bug I found in implementation of LSB - "static" is > not checked for in zend_do_import()/zend_do_namespace() and other places > that we check for "self" and "parent" > 2) fixes a rather serious error in the fix for Bug #42859 - missing > parens in zend_do_import() > 3) adds "import" and "namespace" as valid function/class names > 4) allows any string for method names, just as we allow any string for > variable names > 5) fixes a bug in logic for $class->list where $class-> list (note the > whitespace between -> and list) returns a T_LIST instead of T_STRING > 6) It allows "import ::Classname as Blah" which is currently a parse error > 7) class constants are unchanged - reserved words still error out. > > Note that the zend_compile.c fixes can all be committed directly as they > are all bugfixes and not related to the import/namespace/reserved words fix. > > To implement this, I added several states to the lexer in order to > return T_STRING whenever possible, which is after T_NEW, T_INTERFACE, > T_CLASS, T_EXTENDS and in the T_IMPLEMENTS list. In addition, after > T_FUNCTION outside of a class, it returns T_STRING for "import" and > "namespace" but no other reserved words. After T_FUNCTION inside of a > class (method declaration), it returns T_STRING for all possible > strings. After :: or -> T_STRING is always returned. Also, rather than > take the approach LSB does with T_STATIC, I have the lexer initialize > the string value of T_IMPORT and T_NAMESPACE so we can preserve case for > autoloading needs. The parser frees the unused char * when normal > import/namespace declarations are called. > > In the parser, I use fully_qualified_class_name instead of > namespace_name for both import syntaxes. This introduces a minor issue > in that this is no longer a parse error: > > import static::oops as Classname; > > However, if "Classname" is used, this will simply result in "Fatal > error: Class 'static::oops' not found in..." and shouldn't be too big of > a deal. Also in the parser, I inserted T_IMPORT and T_NAMESPACE as > aliases to T_STRING in global situations to allow for static method > calls, class constants, and fully-qualified namespace calls. > > Basically this script is now possible with the patch: > > <?php > namespace import; > import ::Exception as Test; > function import() {echo 'import function';} > interface import {} > interface fooey {} > class Exception extends ::Exception implements fooey, import {} > class namespace { > const HI = 3; > function list() {echo __METHOD__;} > } > import(); > var_dump(namespace::HI); > namespace::list(); > ?> > > and results in this output: > > cellog@lot-49:~/workspace/php5$ sapi/cli/php -n testme.php > import functionint(3) > import::namespace::list > > I have not performed profiling on the patch, instead focusing on > correctness for now. > > The patch looks complicated because of the additional states, but is > really not that complicated, honest. > > :) > Greg > > ? Zend/tests/zend_function_name.phpt > Index: Zend/zend_compile.c > =================================================================== > RCS file: /repository/ZendEngine2/zend_compile.c,v > retrieving revision 1.647.2.27.2.41.2.10 > diff -u -r1.647.2.27.2.41.2.10 zend_compile.c > --- Zend/zend_compile.c 17 Oct 2007 10:01:21 -0000 1.647.2.27.2.41.2.10 > +++ Zend/zend_compile.c 23 Oct 2007 03:15:41 -0000 > @@ -2975,7 +2975,7 @@ > > lcname = zend_str_tolower_dup(class_name->u.constant.value.str.val, class_name->u.constant.value.str.len); > > - 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", class_name->u.constant.value.str.val); > } > @@ -4582,7 +4582,9 @@ > if (((Z_STRLEN(name->u.constant) == sizeof("self")-1) && > !memcmp(lcname, "self", sizeof("self")-1)) || > ((Z_STRLEN(name->u.constant) == sizeof("parent")-1) && > - !memcmp(lcname, "parent", sizeof("parent")-1))) { > + !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); > @@ -4596,7 +4598,7 @@ > { > char *lcname; > zval *name, *ns, tmp; > - zend_bool warn = 0; > + zend_bool warn = 0, shorthand = 0; > > if (!CG(current_import)) { > CG(current_import) = emalloc(sizeof(HashTable)); > @@ -4611,11 +4613,12 @@ > char *p; > > /* The form "import A::B" is eqivalent to "import A::B as B". > - So we extract the last part of compound name ti use as a new_name */ > + So we extract the last part of compound name to use as a new_name */ > name = &tmp; > p = zend_memrchr(Z_STRVAL_P(ns), ':', Z_STRLEN_P(ns)); > if (p) { > ZVAL_STRING(name, p+1, 1); > + shorthand = 1; > } else { > *name = *ns; > zval_copy_ctor(name); > @@ -4627,6 +4630,8 @@ > > if (((Z_STRLEN_P(name) == sizeof("self")-1) && > !memcmp(lcname, "self", sizeof("self")-1)) || > + ((Z_STRLEN_P(name) == sizeof("static")-1) && > + !memcmp(lcname, "static", sizeof("static")-1)) || > ((Z_STRLEN_P(name) == sizeof("parent")-1) && > !memcmp(lcname, "parent", sizeof("parent")-1))) { > zend_error(E_COMPILE_ERROR, "Cannot use '%s' as import name", Z_STRVAL_P(name)); > @@ -4640,7 +4645,8 @@ > ns_name[Z_STRLEN_P(CG(current_namespace))] = ':'; > ns_name[Z_STRLEN_P(CG(current_namespace))+1] = ':'; > memcpy(ns_name+Z_STRLEN_P(CG(current_namespace))+2, lcname, Z_STRLEN_P(name)+1); > - if (zend_hash_exists(CG(class_table), ns_name, Z_STRLEN_P(CG(current_namespace)) + 2 + Z_STRLEN_P(name)+1)) { > + /* if our new import name is simply the shorthand, skip this check */ > + if ((!shorthand || !memcmp(ns_name, Z_STRVAL_P(ns), Z_STRLEN_P(ns) + 1)) && zend_hash_exists(CG(class_table), ns_name, Z_STRLEN_P(CG(current_namespace)) + 2 + Z_STRLEN_P(name)+1)) { > zend_error(E_COMPILE_ERROR, "Import name '%s' conflicts with defined class", Z_STRVAL_P(name)); > } > efree(ns_name); > Index: Zend/zend_language_parser.y > =================================================================== > RCS file: /repository/ZendEngine2/zend_language_parser.y,v > retrieving revision 1.160.2.4.2.8.2.4 > diff -u -r1.160.2.4.2.8.2.4 zend_language_parser.y > --- Zend/zend_language_parser.y 1 Oct 2007 10:37:13 -0000 1.160.2.4.2.8.2.4 > +++ Zend/zend_language_parser.y 23 Oct 2007 03:15:41 -0000 > @@ -47,7 +47,7 @@ > %} > > %pure_parser > -%expect 2 > +%expect 3 > > %left T_INCLUDE T_INCLUDE_ONCE T_EVAL T_REQUIRE T_REQUIRE_ONCE > %left ',' > @@ -142,7 +142,7 @@ > %token T_END_HEREDOC > %token T_DOLLAR_OPEN_CURLY_BRACES > %token T_CURLY_OPEN > -%token T_PAAMAYIM_NEKUDOTAYIM > +%left T_PAAMAYIM_NEKUDOTAYIM > %token T_NAMESPACE > %token T_IMPORT > %token T_NS_C > @@ -160,6 +160,8 @@ > > namespace_name: > T_STRING { $$ = $1; } > + | T_IMPORT { $$ = $1; } > + | T_NAMESPACE { $$ = $1; } > | namespace_name T_PAAMAYIM_NEKUDOTAYIM T_STRING { zend_do_build_namespace_name(&$$, &$1, &$3 TSRMLS_CC); } > ; > > @@ -168,9 +170,9 @@ > | function_declaration_statement { zend_do_early_binding(TSRMLS_C); } > | class_declaration_statement { zend_do_early_binding(TSRMLS_C); } > | T_HALT_COMPILER '(' ')' ';' { zend_do_halt_compiler_register(TSRMLS_C); YYACCEPT; } > - | T_NAMESPACE namespace_name ';' { zend_do_namespace(&$2 TSRMLS_CC); } > - | T_IMPORT namespace_name ';' { zend_do_import(&$2, NULL TSRMLS_CC); } > - | T_IMPORT namespace_name T_AS T_STRING ';' { zend_do_import(&$2, &$4 TSRMLS_CC); } > + | T_NAMESPACE namespace_name ';' { efree($1.u.constant.value.str.val);zend_do_namespace(&$2 TSRMLS_CC); } > + | T_IMPORT fully_qualified_class_name ';' { efree($1.u.constant.value.str.val);zend_do_import(&$2, NULL TSRMLS_CC); } > + | T_IMPORT fully_qualified_class_name T_AS function_name_token ';' { efree($1.u.constant.value.str.val);zend_do_import(&$2, &$4 TSRMLS_CC); } > | constant_declaration ';' > ; > > @@ -298,6 +300,12 @@ > '(' parameter_list ')' '{' inner_statement_list '}' { zend_do_end_function_declaration(&$1 TSRMLS_CC); } > ; > > +function_name_token: > + T_STRING { $$ = $1; } > + | T_NAMESPACE { $$ = $1; } > + | T_IMPORT { $$ = $1; } > +; > + > unticked_class_declaration_statement: > class_entry_type T_STRING extends_from > { zend_do_begin_class_declaration(&$1, &$2, &$3 TSRMLS_CC); } > @@ -636,7 +644,7 @@ > ; > > function_call: > - T_STRING '(' { $2.u.opline_num = zend_do_begin_function_call(&$1, 1 TSRMLS_CC); } > + function_name_token '(' { $2.u.opline_num = zend_do_begin_function_call(&$1, 1 TSRMLS_CC); } > function_call_parameter_list > ')' { zend_do_end_function_call(&$1, &$$, &$4, 0, $2.u.opline_num TSRMLS_CC); zend_do_extended_fcall_end(TSRMLS_C); } > | T_PAAMAYIM_NEKUDOTAYIM T_STRING '(' { $3.u.opline_num = zend_do_begin_function_call(&$2, 0 TSRMLS_CC); } > @@ -661,6 +669,8 @@ > > fully_qualified_class_name: > T_STRING { $$ = $1; } > + | T_IMPORT { $$ = $1; } > + | T_NAMESPACE { $$ = $1; } > | T_STATIC { $$.op_type = IS_CONST; ZVAL_STRINGL(&$$.u.constant, "static", sizeof("static")-1, 1);} > | T_PAAMAYIM_NEKUDOTAYIM T_STRING { zend_do_build_namespace_name(&$$, NULL, &$2 TSRMLS_CC); } > | fully_qualified_class_name T_PAAMAYIM_NEKUDOTAYIM T_STRING { zend_do_build_namespace_name(&$$, &$1, &$3 TSRMLS_CC); } > Index: Zend/zend_language_scanner.l > =================================================================== > RCS file: /repository/ZendEngine2/zend_language_scanner.l,v > retrieving revision 1.131.2.11.2.13.2.2 > diff -u -r1.131.2.11.2.13.2.2 zend_language_scanner.l > --- Zend/zend_language_scanner.l 7 Oct 2007 05:22:03 -0000 1.131.2.11.2.13.2.2 > +++ Zend/zend_language_scanner.l 23 Oct 2007 03:15:42 -0000 > @@ -45,6 +45,11 @@ > %x ST_COMMENT > %x ST_DOC_COMMENT > %x ST_ONE_LINE_COMMENT > +%x ST_LOOKING_FOR_CLASSNAME > +%x ST_LOOKING_FOR_EXTENDS > +%x ST_LOOKING_FOR_IMPLEMENTS > +%x ST_LOOKING_FOR_FUNCTION_NAME > +%x ST_LOOKING_FOR_METHOD_NAME > %option stack > > %{ > @@ -969,143 +974,172 @@ > %option noyywrap > %% > > -<ST_IN_SCRIPTING>"exit" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"exit" { > return T_EXIT; > } > > -<ST_IN_SCRIPTING>"die" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"die" { > return T_EXIT; > } > > <ST_IN_SCRIPTING>"function" { > + if (CG(active_class_entry)) { > + yy_push_state(ST_LOOKING_FOR_METHOD_NAME TSRMLS_CC); > + } else { > + yy_push_state(ST_LOOKING_FOR_FUNCTION_NAME TSRMLS_CC); > + } > + return T_FUNCTION; > +} > + > +<ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"function" { > return T_FUNCTION; > } > > -<ST_IN_SCRIPTING>"const" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"const" { > return T_CONST; > } > > -<ST_IN_SCRIPTING>"return" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"return" { > return T_RETURN; > } > > -<ST_IN_SCRIPTING>"try" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"try" { > return T_TRY; > } > > -<ST_IN_SCRIPTING>"catch" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"catch" { > return T_CATCH; > } > > -<ST_IN_SCRIPTING>"throw" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"throw" { > return T_THROW; > } > > -<ST_IN_SCRIPTING>"if" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"if" { > return T_IF; > } > > -<ST_IN_SCRIPTING>"elseif" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"elseif" { > return T_ELSEIF; > } > > -<ST_IN_SCRIPTING>"endif" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"endif" { > return T_ENDIF; > } > > -<ST_IN_SCRIPTING>"else" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"else" { > return T_ELSE; > } > > -<ST_IN_SCRIPTING>"while" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"while" { > return T_WHILE; > } > > -<ST_IN_SCRIPTING>"endwhile" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"endwhile" { > return T_ENDWHILE; > } > > -<ST_IN_SCRIPTING>"do" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"do" { > return T_DO; > } > > -<ST_IN_SCRIPTING>"for" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"for" { > return T_FOR; > } > > -<ST_IN_SCRIPTING>"endfor" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"endfor" { > return T_ENDFOR; > } > > -<ST_IN_SCRIPTING>"foreach" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"foreach" { > return T_FOREACH; > } > > -<ST_IN_SCRIPTING>"endforeach" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"endforeach" { > return T_ENDFOREACH; > } > > -<ST_IN_SCRIPTING>"declare" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"declare" { > return T_DECLARE; > } > > -<ST_IN_SCRIPTING>"enddeclare" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"enddeclare" { > return T_ENDDECLARE; > } > > -<ST_IN_SCRIPTING>"instanceof" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"instanceof" { > return T_INSTANCEOF; > } > > -<ST_IN_SCRIPTING>"as" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"as" { > return T_AS; > } > > -<ST_IN_SCRIPTING>"switch" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"switch" { > return T_SWITCH; > } > > -<ST_IN_SCRIPTING>"endswitch" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"endswitch" { > return T_ENDSWITCH; > } > > -<ST_IN_SCRIPTING>"case" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"case" { > return T_CASE; > } > > -<ST_IN_SCRIPTING>"default" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"default" { > return T_DEFAULT; > } > > -<ST_IN_SCRIPTING>"break" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"break" { > return T_BREAK; > } > > -<ST_IN_SCRIPTING>"continue" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"continue" { > return T_CONTINUE; > } > > -<ST_IN_SCRIPTING>"echo" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"echo" { > return T_ECHO; > } > > -<ST_IN_SCRIPTING>"print" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"print" { > return T_PRINT; > } > > <ST_IN_SCRIPTING>"class" { > + yy_push_state(ST_LOOKING_FOR_CLASSNAME TSRMLS_CC); > + return T_CLASS; > +} > + > +<ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"class" { > return T_CLASS; > } > > <ST_IN_SCRIPTING>"interface" { > + yy_push_state(ST_LOOKING_FOR_CLASSNAME TSRMLS_CC); > + return T_INTERFACE; > +} > + > +<ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"interface" { > return T_INTERFACE; > } > > <ST_IN_SCRIPTING>"extends" { > + yy_push_state(ST_LOOKING_FOR_EXTENDS TSRMLS_CC); > + return T_EXTENDS; > +} > + > +<ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"extends" { > return T_EXTENDS; > } > > <ST_IN_SCRIPTING>"implements" { > + yy_push_state(ST_LOOKING_FOR_IMPLEMENTS TSRMLS_CC); > + return T_IMPLEMENTS; > +} > + > +<ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"implements" { > return T_IMPLEMENTS; > } > > @@ -1118,31 +1152,47 @@ > return T_OBJECT_OPERATOR; > } > > -<ST_LOOKING_FOR_PROPERTY>{LABEL} { > +<ST_LOOKING_FOR_METHOD_NAME>'&' { > + return '&'; > +} > + > +<ST_LOOKING_FOR_PROPERTY,ST_LOOKING_FOR_METHOD_NAME>{WHITESPACE} { > + zendlval->value.str.val = yytext; /* no copying - intentional */ > + zendlval->value.str.len = yyleng; > + zendlval->type = IS_STRING; > + HANDLE_NEWLINES(yytext, yyleng); > + return T_WHITESPACE; > +} > + > +<ST_LOOKING_FOR_PROPERTY,ST_LOOKING_FOR_METHOD_NAME>{LABEL} { > yy_pop_state(TSRMLS_C); > zend_copy_value(zendlval, yytext, yyleng); > zendlval->type = IS_STRING; > return T_STRING; > } > > -<ST_LOOKING_FOR_PROPERTY>{ANY_CHAR} { > +<ST_LOOKING_FOR_PROPERTY,ST_LOOKING_FOR_METHOD_NAME>{ANY_CHAR} { > yyless(0); > yy_pop_state(TSRMLS_C); > } > > <ST_IN_SCRIPTING>"::" { > + yy_push_state(ST_LOOKING_FOR_PROPERTY TSRMLS_CC); > return T_PAAMAYIM_NEKUDOTAYIM; > } > > <ST_IN_SCRIPTING>"new" { > + yy_push_state(ST_LOOKING_FOR_PROPERTY TSRMLS_CC); > return T_NEW; > } > > -<ST_IN_SCRIPTING>"clone" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"clone" { > + zend_copy_value(zendlval, yytext, yyleng); > + zendlval->type = IS_STRING; > return T_CLONE; > } > > -<ST_IN_SCRIPTING>"var" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"var" { > return T_VAR; > } > > @@ -1178,79 +1228,83 @@ > return T_UNSET_CAST; > } > > -<ST_IN_SCRIPTING>"eval" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"eval" { > return T_EVAL; > } > > -<ST_IN_SCRIPTING>"include" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"include" { > return T_INCLUDE; > } > > -<ST_IN_SCRIPTING>"include_once" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"include_once" { > return T_INCLUDE_ONCE; > } > > -<ST_IN_SCRIPTING>"require" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"require" { > return T_REQUIRE; > } > > -<ST_IN_SCRIPTING>"require_once" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"require_once" { > return T_REQUIRE_ONCE; > } > > <ST_IN_SCRIPTING>"namespace" { > + zend_copy_value(zendlval, yytext, yyleng); > + zendlval->type = IS_STRING; > return T_NAMESPACE; > } > > <ST_IN_SCRIPTING>"import" { > + zend_copy_value(zendlval, yytext, yyleng); > + zendlval->type = IS_STRING; > return T_IMPORT; > } > > -<ST_IN_SCRIPTING>"use" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"use" { > return T_USE; > } > > -<ST_IN_SCRIPTING>"global" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"global" { > return T_GLOBAL; > } > > -<ST_IN_SCRIPTING>"isset" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"isset" { > return T_ISSET; > } > > -<ST_IN_SCRIPTING>"empty" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"empty" { > return T_EMPTY; > } > > -<ST_IN_SCRIPTING>"__halt_compiler" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"__halt_compiler" { > return T_HALT_COMPILER; > } > > -<ST_IN_SCRIPTING>"static" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"static" { > return T_STATIC; > } > > -<ST_IN_SCRIPTING>"abstract" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"abstract" { > return T_ABSTRACT; > } > > -<ST_IN_SCRIPTING>"final" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"final" { > return T_FINAL; > } > > -<ST_IN_SCRIPTING>"private" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"private" { > return T_PRIVATE; > } > > -<ST_IN_SCRIPTING>"protected" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"protected" { > return T_PROTECTED; > } > > -<ST_IN_SCRIPTING>"public" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"public" { > return T_PUBLIC; > } > > -<ST_IN_SCRIPTING>"unset" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"unset" { > return T_UNSET; > } > > @@ -1258,11 +1312,11 @@ > return T_DOUBLE_ARROW; > } > > -<ST_IN_SCRIPTING>"list" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"list" { > return T_LIST; > } > > -<ST_IN_SCRIPTING>"array" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"array" { > return T_ARRAY; > } > > @@ -1480,7 +1534,7 @@ > return T_DNUMBER; > } > > -<ST_IN_SCRIPTING>"__CLASS__" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"__CLASS__" { > char *class_name = NULL; > > if (CG(active_class_entry)) { > @@ -1496,7 +1550,7 @@ > return T_CLASS_C; > } > > -<ST_IN_SCRIPTING>"__FUNCTION__" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"__FUNCTION__" { > char *func_name = NULL; > > if (CG(active_op_array)) { > @@ -1512,7 +1566,7 @@ > return T_FUNC_C; > } > > -<ST_IN_SCRIPTING>"__METHOD__" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"__METHOD__" { > char *class_name = CG(active_class_entry) ? CG(active_class_entry)->name : NULL; > char *func_name = CG(active_op_array)? CG(active_op_array)->function_name : NULL; > size_t len = 0; > @@ -1533,13 +1587,13 @@ > return T_METHOD_C; > } > > -<ST_IN_SCRIPTING>"__LINE__" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"__LINE__" { > zendlval->value.lval = CG(zend_lineno); > zendlval->type = IS_LONG; > return T_LINE; > } > > -<ST_IN_SCRIPTING>"__FILE__" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"__FILE__" { > char *filename = zend_get_compiled_filename(TSRMLS_C); > > if (!filename) { > @@ -1551,7 +1605,7 @@ > return T_FILE; > } > > -<ST_IN_SCRIPTING>"__NAMESPACE__" { > +<ST_IN_SCRIPTING,ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>"__NAMESPACE__" { > if (CG(current_namespace)) { > *zendlval = *CG(current_namespace); > zval_copy_ctor(zendlval); > @@ -1561,6 +1615,38 @@ > return T_NS_C; > } > > +<ST_LOOKING_FOR_IMPLEMENTS>"," { > + return ','; > +} > + > +<ST_LOOKING_FOR_FUNCTION_NAME>"&" { > + return '&'; > +} > + > +<ST_LOOKING_FOR_IMPLEMENTS>"::" { > + return T_PAAMAYIM_NEKUDOTAYIM; > +} > + > +<ST_LOOKING_FOR_IMPLEMENTS,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME>{WHITESPACE} { > + zendlval->value.str.val = yytext; /* no copying - intentional */ > + zendlval->value.str.len = yyleng; > + zendlval->type = IS_STRING; > + HANDLE_NEWLINES(yytext, yyleng); > + return T_WHITESPACE; > +} > + > +<ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_FUNCTION_NAME,ST_LOOKING_FOR_IMPLEMENTS>{LABEL} { > + yy_pop_state(TSRMLS_C); > + zend_copy_value(zendlval, yytext, yyleng); > + zendlval->type = IS_STRING; > + return T_STRING; > +} > + > +<ST_LOOKING_FOR_FUNCTION_NAME,ST_LOOKING_FOR_CLASSNAME,ST_LOOKING_FOR_EXTENDS,ST_LOOKING_FOR_IMPLEMENTS>{ANY_CHAR} { > + yyless(0); > + yy_pop_state(TSRMLS_C); > +} > + > <INITIAL>(([^<]|"<"[^?%s<]){1,400})|"<s"|"<" { > #ifdef ZEND_MULTIBYTE > if (SCNG(output_filter)) { > @@ -1693,7 +1779,6 @@ > return T_STRING; > } > > - > <ST_IN_SCRIPTING>{WHITESPACE} { > zendlval->value.str.val = yytext; /* no copying - intentional */ > zendlval->value.str.len = yyleng; > > > -- > PHP Internals - PHP Runtime Development Mailing List > To unsubscribe, visit: http://www.php.net/unsub.php >