|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
?? ??? 20??, PHP 5.3.0
- Added support for namespaces. (Dmitry, Stas)
+- Added support for Late Static Binding. (Dmitry, Etienne Kneuss)
- Added support for dynamic access of static members using $foo::myFunc().
(Etienne Kneuss)
--- /dev/null
+--TEST--
+ZE2 Late Static Binding in a static function
+--FILE--
+<?php
+
+class TestClass {
+ protected static $staticVar = 'TestClassStatic';
+ const CLASS_CONST = 'TestClassConst';
+
+ protected static function staticFunction() {
+ return 'TestClassFunction';
+ }
+
+ public static function testStaticVar() {
+ return static::$staticVar;
+ }
+
+ public static function testClassConst() {
+ return static::CLASS_CONST;
+ }
+
+ public static function testStaticFunction() {
+ return static::staticFunction();
+ }
+}
+
+class ChildClass1 extends TestClass {
+ protected static $staticVar = 'ChildClassStatic';
+ const CLASS_CONST = 'ChildClassConst';
+
+ protected static function staticFunction() {
+ return 'ChildClassFunction';
+ }
+}
+
+class ChildClass2 extends TestClass {}
+
+echo TestClass::testStaticVar() . "\n";
+echo TestClass::testClassConst() . "\n";
+echo TestClass::testStaticFunction() . "\n";
+
+echo ChildClass1::testStaticVar() . "\n";
+echo ChildClass1::testClassConst() . "\n";
+echo ChildClass1::testStaticFunction() . "\n";
+
+echo ChildClass2::testStaticVar() . "\n";
+echo ChildClass2::testClassConst() . "\n";
+echo ChildClass2::testStaticFunction() . "\n";
+?>
+==DONE==
+--EXPECTF--
+TestClassStatic
+TestClassConst
+TestClassFunction
+ChildClassStatic
+ChildClassConst
+ChildClassFunction
+TestClassStatic
+TestClassConst
+TestClassFunction
+==DONE==
--- /dev/null
+--TEST--
+ZE2 Late Static Binding in an instance function
+--FILE--
+<?php
+
+class TestClass {
+ protected static $staticVar = 'TestClassStatic';
+ const CLASS_CONST = 'TestClassConst';
+
+ protected static function staticFunction() {
+ return 'TestClassFunction';
+ }
+
+ public function testStaticVar() {
+ return static::$staticVar;
+ }
+
+ public function testClassConst() {
+ return static::CLASS_CONST;
+ }
+
+ public function testStaticFunction() {
+ return static::staticFunction();
+ }
+}
+
+class ChildClass1 extends TestClass {
+ protected static $staticVar = 'ChildClassStatic';
+ const CLASS_CONST = 'ChildClassConst';
+
+ protected static function staticFunction() {
+ return 'ChildClassFunction';
+ }
+}
+
+class ChildClass2 extends TestClass {}
+
+$testClass = new TestClass();
+$childClass1 = new ChildClass1();
+$childClass2 = new ChildClass2();
+
+
+echo $testClass->testStaticVar() . "\n";
+echo $testClass->testClassConst() . "\n";
+echo $testClass->testStaticFunction() . "\n";
+
+echo $childClass1->testStaticVar() . "\n";
+echo $childClass1->testClassConst() . "\n";
+echo $childClass1->testStaticFunction() . "\n";
+
+echo $childClass2->testStaticVar() . "\n";
+echo $childClass2->testClassConst() . "\n";
+echo $childClass2->testStaticFunction() . "\n";
+?>
+==DONE==
+--EXPECTF--
+TestClassStatic
+TestClassConst
+TestClassFunction
+ChildClassStatic
+ChildClassConst
+ChildClassFunction
+TestClassStatic
+TestClassConst
+TestClassFunction
+==DONE==
--- /dev/null
+--TEST--
+ZE2 Late Static Binding creating a new class with 'static'
+--FILE--
+<?php
+
+class TestClass {
+ public static function createInstance() {
+ return new static();
+ }
+}
+
+class ChildClass extends TestClass {}
+
+$testClass = TestClass::createInstance();
+$childClass = ChildClass::createInstance();
+
+echo get_class($testClass) . "\n";
+echo get_class($childClass) . "\n";
+?>
+==DONE==
+--EXPECTF--
+TestClass
+ChildClass
+==DONE==
--- /dev/null
+--TEST--
+ZE2 Late Static Binding testing get_called_class()
+--FILE--
+<?php
+
+class TestClass {
+ public static function getClassName() {
+ return get_called_class();
+ }
+}
+
+class ChildClass extends TestClass {}
+
+echo TestClass::getClassName() . "\n";
+echo ChildClass::getClassName() . "\n";
+?>
+==DONE==
+--EXPECTF--
+TestClass
+ChildClass
+==DONE==
--- /dev/null
+--TEST--
+ZE2 Late Static Binding stacking static calleds
+--FILE--
+<?php
+
+class TestA {
+ public static function test() {
+ echo get_class(new static()) . "\n";
+ TestB::test();
+ echo get_class(new static()) . "\n";
+ TestC::test();
+ echo get_class(new static()) . "\n";
+ TestBB::test();
+ echo get_class(new static()) . "\n";
+ }
+}
+
+class TestB {
+ public static function test() {
+ echo get_class(new static()) . "\n";
+ TestC::test();
+ echo get_class(new static()) . "\n";
+ }
+}
+
+class TestC {
+ public static function test() {
+ echo get_class(new static()) . "\n";
+ }
+}
+
+class TestBB extends TestB {
+}
+
+TestA::test();
+
+?>
+==DONE==
+--EXPECTF--
+TestA
+TestB
+TestC
+TestB
+TestA
+TestC
+TestA
+TestBB
+TestC
+TestBB
+TestA
+==DONE==
--- /dev/null
+--TEST--
+ZE2 Late Static Binding ensuring extending 'static' is not allowed
+--FILE--
+<?php
+
+class Foo extends static {
+}
+
+?>
+==DONE==
+--EXPECTF--
+Fatal error: Cannot use 'static' as class name as it is reserved in %s on line %d
--- /dev/null
+--TEST--
+ZE2 Late Static Binding ensuring implementing 'static' is not allowed
+--FILE--
+<?php
+
+class Foo implements static {
+}
+
+?>
+==DONE==
+--EXPECTF--
+Fatal error: Cannot use 'static' as interface name as it is reserved in %s on line %d
--- /dev/null
+--TEST--
+ZE2 Late Static Binding class name "static"
+--FILE--
+<?php
+class static {
+}
+--EXPECTF--
+Parse error: syntax error, unexpected T_STATIC, expecting T_STRING in %slsb_008.php on line 2
--- /dev/null
+--TEST--
+ZE2 Late Static Binding interface name "static"
+--FILE--
+<?php
+interface static {
+}
+--EXPECTF--
+Parse error: syntax error, unexpected T_STATIC, expecting T_STRING in %slsb_009.php on line 2
--- /dev/null
+--TEST--
+ZE2 Late Static Binding using static:: in functions called by non execute() calls and constructors.
+--FILE--
+<?php
+
+class Foo {
+ protected static $className = 'Foo';
+ public static function bar() {
+ echo static::$className . "::bar\n";
+ }
+ public function __construct() {
+ echo static::$className . "::__construct\n";
+ }
+ public function __destruct() {
+ echo static::$className . "::__destruct\n";
+ }
+}
+
+class FooChild extends Foo {
+ protected static $className = 'FooChild';
+}
+
+register_shutdown_function(array('Foo', 'bar'));
+register_shutdown_function(array('FooChild', 'bar'));
+
+$foo = new Foo();
+$fooChild = new FooChild();
+unset($foo);
+unset($fooChild);
+
+?>
+--EXPECTF--
+Foo::__construct
+FooChild::__construct
+Foo::__destruct
+FooChild::__destruct
+Foo::bar
+FooChild::bar
--- /dev/null
+--TEST--
+ZE2 Late Static Binding call to static::method() from internal function (array)
+--FILE--
+<?php
+
+class Test1 {
+ static function ok() {
+ echo "bug";
+ }
+ static function test() {
+ call_user_func(array("static","ok"));
+ }
+}
+
+class Test2 extends Test1 {
+ static function ok() {
+ echo "ok";
+ }
+}
+Test2::test();
+?>
+--EXPECT--
+ok
--- /dev/null
+--TEST--
+ZE2 Late Static Binding call to static::method() from internal function (string)
+--FILE--
+<?php
+
+class Test1 {
+ static function ok() {
+ echo "bug";
+ }
+ static function test() {
+ call_user_func("static::ok");
+ }
+}
+
+class Test2 extends Test1 {
+ static function ok() {
+ echo "ok";
+ }
+}
+Test2::test();
+?>
+--EXPECT--
+ok
--- /dev/null
+--TEST--
+ZE2 Late Static Binding is_callable() and static::method()
+--FILE--
+<?php
+
+class Test1 {
+ static function test() {
+ var_dump(is_callable("static::ok"));
+ var_dump(is_callable(array("static","ok")));
+ }
+}
+
+class Test2 extends Test1 {
+ static function ok() {
+ }
+}
+Test1::test();
+Test2::test();
+?>
+--EXPECT--
+bool(false)
+bool(false)
+bool(true)
+bool(true)
--- /dev/null
+--TEST--
+ZE2 Late Static Binding access to static::const through defined() anf get_constant()
+--FILE--
+<?php
+
+class Test1 {
+ static function test() {
+ var_dump(defined("static::ok"));
+ if (defined("static::ok")) {
+ echo constant("static::ok");
+ }
+ }
+}
+
+class Test2 extends Test1 {
+ const ok = "ok";
+}
+Test1::test();
+Test2::test();
+?>
+--EXPECT--
+bool(false)
+bool(true)
+ok
--- /dev/null
+--TEST--
+ZE2 Late Static Binding with exceptions
+--FILE--
+<?php
+function foo() {
+ B::throwException();
+}
+class C {
+ public static function bla() {
+ B::throwException();
+ }
+ public static function getException() {
+ return new Exception();
+
+ }
+}
+class A {
+
+ public static function throwException_after() {
+ C::bla();
+ }
+ public static function throwException() {
+ throw C::getException();
+ }
+ public static function test() {
+ static::who();
+ }
+ public static function who() {
+ echo "A\n";
+ }
+
+ public static function mycatch() {
+ try {
+ static::who();
+ B::throwException_after();
+ } catch(Exception $e) {
+ static::who();
+ A::test();
+ static::who();
+ B::test();
+ static::who();
+
+ self::simpleCatch();
+ static::who();
+ }
+ }
+
+ public static function simpleCatch() {
+ try {
+ static::who();
+ throw new Exception();
+ } catch (Exception $e) {
+ static::who();
+ }
+ }
+}
+
+class B extends A {
+ public static function who() {
+ echo "B\n";
+ }
+
+}
+
+echo "via A:\n";
+A::myCatch();
+echo "via B:\n";
+B::myCatch();
+?>
+==DONE==
+--EXPECTF--
+via A:
+A
+A
+A
+A
+B
+A
+A
+A
+A
+via B:
+B
+B
+A
+B
+B
+B
+A
+A
+B
+==DONE==
--- /dev/null
+--TEST--
+ZE2 Late Static Binding within hooks/magic methods
+--FILE--
+<?php
+
+class TestChild extends TestParent {
+
+ public static function who() {
+ echo __CLASS__."\n";
+ }
+}
+
+class TestParent {
+
+ public function __get($var) {
+ static::who();
+ }
+
+ public function __set($var, $val) {
+ static::who();
+ }
+
+ public function __call($name, $args) {
+ static::who();
+ }
+
+ public static function who() {
+ echo __CLASS__."\n";
+ }
+}
+$o = new TestChild;
+$o->test();
+$o->a = "b";
+echo $o->a;
+?>
+==DONE==
+--EXPECTF--
+TestChild
+TestChild
+TestChild
+==DONE==
--- /dev/null
+--TEST--
+ZE2 Late Static Binding nested calls
+--FILE--
+<?php
+class A {
+ public static function test($x=null) {
+ if (!is_null($x)) {
+ echo "$x\n";
+ }
+ return get_called_class();
+ }
+}
+
+class B extends A {
+}
+class C extends A {
+}
+class D extends A {
+}
+
+echo A::test(B::test(C::test(D::test())))."\n";
+?>
+==DONE==
+--EXPECT--
+D
+C
+B
+A
+==DONE==
}
lcname = zend_str_tolower_dup(Z_STRVAL_PP(obj), Z_STRLEN_PP(obj));
- if (Z_STRLEN_PP(obj) == sizeof("self") - 1 && memcmp(lcname, "self", sizeof("self")) == 0 && EG(active_op_array)) {
+ if (Z_STRLEN_PP(obj) == sizeof("self") - 1 && memcmp(lcname, "self", sizeof("self")-1) == 0 && EG(active_op_array)) {
ce = EG(active_op_array)->scope;
- } else if (Z_STRLEN_PP(obj) == sizeof("parent") - 1 && memcmp(lcname, "parent", sizeof("parent")) == 0 && EG(active_op_array) && EG(active_op_array)->scope) {
+ } else if (Z_STRLEN_PP(obj) == sizeof("parent") - 1 && memcmp(lcname, "parent", sizeof("parent")-1) == 0 && EG(active_op_array) && EG(active_op_array)->scope) {
ce = EG(active_op_array)->scope->parent;
+ } else if (Z_STRLEN_PP(obj) == sizeof("static")-1 &&
+ !memcmp(lcname, "static", sizeof("static")-1)) {
+ ce = EG(called_scope);
} else if (zend_lookup_class(Z_STRVAL_PP(obj), Z_STRLEN_PP(obj), &pce TSRMLS_CC) == SUCCESS) {
ce = *pce;
}
static ZEND_FUNCTION(define);
static ZEND_FUNCTION(defined);
static ZEND_FUNCTION(get_class);
+static ZEND_FUNCTION(get_called_class);
static ZEND_FUNCTION(get_parent_class);
static ZEND_FUNCTION(method_exists);
static ZEND_FUNCTION(property_exists);
ZEND_FE(define, NULL)
ZEND_FE(defined, NULL)
ZEND_FE(get_class, NULL)
+ ZEND_FE(get_called_class, NULL)
ZEND_FE(get_parent_class, NULL)
ZEND_FE(method_exists, NULL)
ZEND_FE(property_exists, NULL)
/* }}} */
+/* {{{ proto string get_called_class()
+ Retrieves the "Late Static Binding" class name */
+ZEND_FUNCTION(get_called_class)
+{
+ if (!ZEND_NUM_ARGS()) {
+ if (EG(called_scope)) {
+ RETURN_STRINGL(EG(called_scope)->name, EG(called_scope)->name_length, 1);
+ } else {
+ zend_error(E_WARNING, "get_called_class() called from outside a class");
+ RETURN_FALSE;
+ }
+ } else {
+ ZEND_WRONG_PARAM_COUNT();
+ RETURN_FALSE;
+ }
+}
+/* }}} */
+
+
/* {{{ proto string get_parent_class([mixed object])
Retrieves the parent class name for object or class or current scope. */
ZEND_FUNCTION(get_parent_class)
switch (fetch_type) {
case ZEND_FETCH_CLASS_SELF:
case ZEND_FETCH_CLASS_PARENT:
+ case ZEND_FETCH_CLASS_STATIC:
SET_UNUSED(opline->op2);
opline->extended_value = fetch_type;
zval_dtor(&class_name->u.constant);
case ZEND_FETCH_CLASS_PARENT:
zend_error(E_COMPILE_ERROR, "Cannot use 'parent' as class name as it is reserved");
break;
+ case ZEND_FETCH_CLASS_STATIC:
+ zend_error(E_COMPILE_ERROR, "Cannot use 'static' as class name as it is reserved");
+ break;
default:
break;
}
case ZEND_FETCH_CLASS_PARENT:
zend_error(E_COMPILE_ERROR, "Cannot use 'parent' as interface name as it is reserved");
break;
+ case ZEND_FETCH_CLASS_STATIC:
+ zend_error(E_COMPILE_ERROR, "Cannot use 'static' as interface name as it is reserved");
+ break;
default:
if (CG(active_op_array)->last > 0) {
opline = &CG(active_op_array)->opcodes[CG(active_op_array)->last-1];
} else if ((class_name_len == sizeof("parent")-1) &&
!memcmp(class_name, "parent", sizeof("parent")-1)) {
return ZEND_FETCH_CLASS_PARENT;
+ } else if ((class_name_len == sizeof("static")-1) &&
+ !memcmp(class_name, "static", sizeof("static")-1)) {
+ return ZEND_FETCH_CLASS_STATIC;
} else {
return ZEND_FETCH_CLASS_DEFAULT;
}
typedef struct _zend_function_state {
- HashTable *function_symbol_table;
zend_function *function;
- void *reserved[ZEND_MAX_RESERVED_RESOURCES];
} zend_function_state;
struct _zend_op *opline;
zend_function_state function_state;
zend_function *fbc; /* Function Being Called */
+ zend_class_entry *called_scope;
zend_op_array *op_array;
zval *object;
union _temp_variable *Ts;
#define ZEND_FETCH_CLASS_GLOBAL 4
#define ZEND_FETCH_CLASS_AUTO 5
#define ZEND_FETCH_CLASS_INTERFACE 6
+#define ZEND_FETCH_CLASS_STATIC 7
#define ZEND_FETCH_CLASS_RT_NS_CHECK 0x20
#define ZEND_FETCH_CLASS_RT_NS_NAME 0x40
#define ZEND_FETCH_CLASS_NO_AUTOLOAD 0x80
ce = scope->parent;
}
efree(lcname);
+ } else if (class_name_len == sizeof("static")-1 &&
+ !memcmp(lcname, "static", sizeof("static")-1)) {
+ if (EG(called_scope)) {
+ ce = EG(called_scope);
+ } else {
+ zend_error(E_ERROR, "Cannot access static:: when no class scope is active");
+ }
+ efree(lcname);
} else {
/* Check for namespace constant */
char *nsname;
#define CV_OF(i) (EG(current_execute_data)->CVs[i])
#define CV_DEF_OF(i) (EG(active_op_array)->vars[i])
+#define CTOR_CALL_BIT 0x1
+#define CTOR_USED_BIT 0x2
+
+#define IS_CTOR_CALL(ce) (((zend_uintptr_t)(ce)) & CTOR_CALL_BIT)
+#define IS_CTOR_USED(ce) (((zend_uintptr_t)(ce)) & CTOR_USED_BIT)
+
+#define ENCODE_CTOR(ce, used) \
+ ((zend_class_entry*)(((zend_uintptr_t)(ce)) | CTOR_CALL_BIT | ((used) ? CTOR_USED_BIT : 0)))
+#define DECODE_CTOR(ce) \
+ ((zend_class_entry*)(((zend_uintptr_t)(ce)) & ~(CTOR_CALL_BIT|CTOR_USED_BIT)))
+
ZEND_API zval** zend_get_compiled_variable_value(zend_execute_data *execute_data_ptr, zend_uint var)
{
return execute_data_ptr->CVs[var];
EG(exception) = NULL;
EG(scope) = NULL;
+ EG(called_scope) = NULL;
EG(This) = NULL;
zend_op_array *original_op_array;
zend_op **original_opline_ptr;
zend_class_entry *current_scope;
+ zend_class_entry *current_called_scope;
zend_class_entry *calling_scope = NULL;
zend_class_entry *check_scope_or_static = NULL;
zval *current_this;
found = (*ce != NULL?SUCCESS:FAILURE);
fci->object_pp = EG(This)?&EG(This):NULL;
EX(object) = EG(This);
+ } else if (Z_STRLEN_PP(fci->object_pp) == sizeof("static")-1 &&
+ !memcmp(Z_STRVAL_PP(fci->object_pp), "static", sizeof("static")-1)) {
+ if (!EG(called_scope)) {
+ zend_error(E_ERROR, "Cannot access static:: when no class scope is active");
+ }
+ ce = &(EG(called_scope));
+ found = (*ce != NULL?SUCCESS:FAILURE);
+ fci->object_pp = EG(This)?&EG(This):NULL;
+ EX(object) = EG(This);
} else {
zend_class_entry *scope;
scope = EG(active_op_array) ? EG(active_op_array)->scope : NULL;
zend_hash_find(fci->function_table, lcname, fname_len+1, (void**)&EX(function_state).function) == SUCCESS) {
efree(lcname);
} else {
- efree(lcname);
if ((colon = zend_memrchr(fname, ':', fname_len)) != NULL &&
colon > fname &&
*(colon-1) == ':') {
int clen = colon - fname - 1;
int mlen = fname_len - clen - 2;
-
zend_class_entry **pce, *ce_child = NULL;
- if (zend_lookup_class(fname, clen, &pce TSRMLS_CC) == SUCCESS) {
+
+ if (calling_scope && clen == sizeof("self") - 1 && memcmp(lcname, "self", sizeof("self") - 1) == 0) {
+ ce_child = EG(active_op_array) ? EG(active_op_array)->scope : NULL;
+ } else if (calling_scope && clen == sizeof("parent") - 1 && memcmp(lcname, "parent", sizeof("parent") - 1) == 0 && EG(active_op_array)->scope) {
+ ce_child = EG(active_op_array) && EG(active_op_array)->scope ? EG(scope)->parent : NULL;
+ } else if (clen == sizeof("static") - 1 &&
+ !memcmp(lcname, "static", sizeof("static")-1)) {
+ ce_child = EG(called_scope);
+ } else if (zend_lookup_class(fname, clen, &pce TSRMLS_CC) == SUCCESS) {
ce_child = *pce;
- } else {
- char *lcname = zend_str_tolower_dup(fname, clen);
- /* caution: lcname is not '\0' terminated */
- if (calling_scope) {
- if (clen == sizeof("self") - 1 && memcmp(lcname, "self", sizeof("self") - 1) == 0) {
- ce_child = EG(active_op_array) ? EG(active_op_array)->scope : NULL;
- } else if (clen == sizeof("parent") - 1 && memcmp(lcname, "parent", sizeof("parent") - 1) == 0 && EG(active_op_array)->scope) {
- ce_child = EG(active_op_array) && EG(active_op_array)->scope ? EG(scope)->parent : NULL;
- }
- }
- efree(lcname);
}
+
if (!ce_child) {
zend_error(E_ERROR, "Cannot call method %s() or method does not exist", fname);
return FAILURE;
fname = fname + clen + 2;
fname_len = mlen;
}
+ efree(lcname);
if (fci->object_pp) {
if (Z_OBJ_HT_PP(fci->object_pp)->get_method == NULL) {
current_this = EG(This);
+ current_called_scope = EG(called_scope);
+ if (calling_scope) {
+ EG(called_scope) = calling_scope;
+ } else if (EX(function_state).function->type != ZEND_INTERNAL_FUNCTION) {
+ EG(called_scope) = NULL;
+ }
+
if (fci->object_pp) {
if ((EX(function_state).function->common.fn_flags & ZEND_ACC_STATIC)) {
EG(This) = NULL;
if (EG(This)) {
zval_ptr_dtor(&EG(This));
}
+ EG(called_scope) = current_called_scope;
EG(scope) = current_scope;
EG(This) = current_this;
EG(current_execute_data) = EX(prev_execute_data);
zend_error(E_ERROR, "Cannot access parent:: when current class scope has no parent");
}
return EG(scope)->parent;
+ case ZEND_FETCH_CLASS_STATIC:
+ if (!EG(called_scope)) {
+ zend_error(E_ERROR, "Cannot access static:: when no class scope is active");
+ }
+ return EG(called_scope);
case ZEND_FETCH_CLASS_AUTO: {
fetch_type = zend_get_class_fetch_type(class_name, class_name_len);
if (fetch_type!=ZEND_FETCH_CLASS_DEFAULT) {
HashTable *zend_constants; /* constants table */
zend_class_entry *scope;
+ zend_class_entry *called_scope; /* Scope of the calling class */
zval *This;
fully_qualified_class_name:
T_STRING { $$ = $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); }
;
int function_name_strlen;
zend_free_op free_op1, free_op2;
- zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
+ zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
function_name = GET_OP2_ZVAL_PTR(BP_VAR_R);
zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
}
+ EX(called_scope) = Z_OBJCE_P(EX(object));
+
if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
EX(object) = NULL;
} else {
zval *function_name;
zend_class_entry *ce;
- zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
+ zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
if (OP1_TYPE == IS_CONST && OP2_TYPE == IS_CONST) {
/* try a function in namespace */
EX(fbc) = ce->constructor;
}
+ EX(called_scope) = ce;
+
if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
EX(object) = NULL;
} else {
}
if ((EX(object) = EG(This))) {
EX(object)->refcount++;
+ EX(called_scope) = Z_OBJCE_P(EX(object));
}
}
int function_name_strlen;
zend_free_op free_op2;
- zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
+ zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
if (OP2_TYPE == IS_CONST) {
function_name_strval = opline->op2.u.constant.value.str.val;
{
zend_op *opline = EX(opline);
zval **original_return_value;
- zend_class_entry *current_scope = NULL;
- zval *current_this = NULL;
+ zend_class_entry *current_scope;
+ zend_class_entry *current_called_scope;
+ zval *current_this;
int return_value_used = RETURN_VALUE_USED(opline);
zend_bool should_change_scope;
- zend_op *ctor_opline;
+ zval *ex_object;
if (EX(function_state).function->common.fn_flags & (ZEND_ACC_ABSTRACT|ZEND_ACC_DEPRECATED)) {
if (EX(function_state).function->common.fn_flags & ZEND_ACC_ABSTRACT) {
EX(function_state).function->common.function_name);
}
}
+ if (EX(function_state).function->common.scope &&
+ !(EX(function_state).function->common.fn_flags & ZEND_ACC_STATIC) &&
+ !EX(object)) {
+
+ if (EX(function_state).function->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
+ /* FIXME: output identifiers properly */
+ zend_error(E_STRICT, "Non-static method %s::%s() should not be called statically", EX(function_state).function->common.scope->name, EX(function_state).function->common.function_name);
+ } else {
+ /* FIXME: output identifiers properly */
+ zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically", EX(function_state).function->common.scope->name, EX(function_state).function->common.function_name);
+ }
+ }
- zend_ptr_stack_2_push(&EG(argument_stack), (void *)(zend_uintptr_t)opline->extended_value, NULL);
-
- EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
-
- if (EX(function_state).function->type == ZEND_USER_FUNCTION
- || EX(function_state).function->common.scope) {
+ if (EX(function_state).function->type == ZEND_USER_FUNCTION ||
+ EX(function_state).function->common.scope) {
should_change_scope = 1;
current_this = EG(This);
- EG(This) = EX(object);
current_scope = EG(scope);
+ current_called_scope = EG(called_scope);
+ EG(This) = EX(object);
EG(scope) = (EX(function_state).function->type == ZEND_USER_FUNCTION || !EX(object)) ? EX(function_state).function->common.scope : NULL;
+ EG(called_scope) = EX(called_scope);
} else {
should_change_scope = 0;
}
- EX_T(opline->result.u.var).var.fcall_returned_reference = 0;
+ zend_ptr_stack_3_pop(&EG(arg_types_stack), (void*)&EX(called_scope), (void**)&ex_object, (void**)&EX(fbc));
+ zend_ptr_stack_2_push(&EG(argument_stack), (void *)(zend_uintptr_t)opline->extended_value, NULL);
+
+ EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
+// EX_T(opline->result.u.var).var.fcall_returned_reference = 0;
- if (EX(function_state).function->common.scope) {
- if (!EG(This) && !(EX(function_state).function->common.fn_flags & ZEND_ACC_STATIC)) {
- int severity;
- char *severity_word;
- if (EX(function_state).function->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
- severity = E_STRICT;
- severity_word = "should not";
- } else {
- severity = E_ERROR;
- severity_word = "cannot";
- }
- zend_error(severity, "Non-static method %s::%s() %s be called statically", EX(function_state).function->common.scope->name, EX(function_state).function->common.function_name, severity_word);
- }
- }
if (EX(function_state).function->type == ZEND_INTERNAL_FUNCTION) {
- unsigned char return_reference = EX(function_state).function->common.return_reference;
-
ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
INIT_ZVAL(*(EX_T(opline->result.u.var).var.ptr));
if (!return_value_used) {
zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
} else {
- EX_T(opline->result.u.var).var.fcall_returned_reference = return_reference;
+ EX_T(opline->result.u.var).var.fcall_returned_reference = EX(function_state).function->common.return_reference;
}
} else if (EX(function_state).function->type == ZEND_USER_FUNCTION) {
+ HashTable *function_symbol_table;
+
EX_T(opline->result.u.var).var.ptr = NULL;
if (EG(symtable_cache_ptr)>=EG(symtable_cache)) {
/*printf("Cache hit! Reusing %x\n", symtable_cache[symtable_cache_ptr]);*/
- EX(function_state).function_symbol_table = *(EG(symtable_cache_ptr)--);
+ function_symbol_table = *(EG(symtable_cache_ptr)--);
} else {
- ALLOC_HASHTABLE(EX(function_state).function_symbol_table);
- zend_hash_init(EX(function_state).function_symbol_table, 0, NULL, ZVAL_PTR_DTOR, 0);
- /*printf("Cache miss! Initialized %x\n", function_state.function_symbol_table);*/
+ ALLOC_HASHTABLE(function_symbol_table);
+ zend_hash_init(function_symbol_table, 0, NULL, ZVAL_PTR_DTOR, 0);
+ /*printf("Cache miss! Initialized %x\n", function_symbol_table);*/
}
- EG(active_symbol_table) = EX(function_state).function_symbol_table;
+ EG(active_symbol_table) = function_symbol_table;
original_return_value = EG(return_value_ptr_ptr);
- EG(return_value_ptr_ptr) = EX_T(opline->result.u.var).var.ptr_ptr;
+ EG(return_value_ptr_ptr) = &EX_T(opline->result.u.var).var.ptr;
EG(active_op_array) = (zend_op_array *) EX(function_state).function;
zend_execute(EG(active_op_array) TSRMLS_CC);
EG(active_op_array) = EX(op_array);
EG(return_value_ptr_ptr)=original_return_value;
if (EG(symtable_cache_ptr)>=EG(symtable_cache_limit)) {
- zend_hash_destroy(EX(function_state).function_symbol_table);
- FREE_HASHTABLE(EX(function_state).function_symbol_table);
+ zend_hash_destroy(function_symbol_table);
+ FREE_HASHTABLE(function_symbol_table);
} else {
/* clean before putting into the cache, since clean
could call dtors, which could use cached hash */
- zend_hash_clean(EX(function_state).function_symbol_table);
- *(++EG(symtable_cache_ptr)) = EX(function_state).function_symbol_table;
+ zend_hash_clean(function_symbol_table);
+ *(++EG(symtable_cache_ptr)) = function_symbol_table;
}
EG(active_symbol_table) = EX(symbol_table);
} else { /* ZEND_OVERLOADED_FUNCTION */
/* Not sure what should be done here if it's a static method */
if (EX(object)) {
- Z_OBJ_HT_P(EX(object))->call_method(EX(fbc)->common.function_name, opline->extended_value, EX_T(opline->result.u.var).var.ptr, &EX_T(opline->result.u.var).var.ptr, EX(object), return_value_used TSRMLS_CC);
+ Z_OBJ_HT_P(EX(object))->call_method(EX(function_state).function->common.function_name, opline->extended_value, EX_T(opline->result.u.var).var.ptr, &EX_T(opline->result.u.var).var.ptr, EX(object), return_value_used TSRMLS_CC);
} else {
zend_error_noreturn(E_ERROR, "Cannot call overloaded function for non-object");
}
if (EX(function_state).function->type == ZEND_OVERLOADED_FUNCTION_TEMPORARY) {
efree(EX(function_state).function->common.function_name);
}
- efree(EX(fbc));
+ efree(EX(function_state).function);
if (!return_value_used) {
zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
} else {
EX_T(opline->result.u.var).var.ptr->is_ref = 0;
EX_T(opline->result.u.var).var.ptr->refcount = 1;
+ EX_T(opline->result.u.var).var.fcall_returned_reference = 0;
}
}
- ctor_opline = (zend_op*)zend_ptr_stack_pop(&EG(arg_types_stack));
-
if (EG(This)) {
- if (EG(exception) && ctor_opline) {
- if (RETURN_VALUE_USED(ctor_opline)) {
+ if (EG(exception) && IS_CTOR_CALL(EX(called_scope))) {
+ if (IS_CTOR_USED(EX(called_scope))) {
EG(This)->refcount--;
}
if (EG(This)->refcount == 1) {
}
}
+ EX(object) = ex_object;
+ EX(called_scope) = DECODE_CTOR(EX(called_scope));
+
if (should_change_scope) {
EG(This) = current_this;
EG(scope) = current_scope;
+ EG(called_scope) = current_called_scope;
}
- zend_ptr_stack_2_pop(&EG(arg_types_stack), (void**)&EX(object), (void**)&EX(fbc));
EX(function_state).function = (zend_function *) EX(op_array);
EG(function_state_ptr) = &EX(function_state);
zend_free_op free_op1;
zval *fname = GET_OP1_ZVAL_PTR(BP_VAR_R);
- zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
+ zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
if (zend_hash_find(EG(function_table), fname->value.str.val, fname->value.str.len+1, (void **) &EX(function_state).function)==FAILURE) {
zend_error_noreturn(E_ERROR, "Call to undefined function %s()", fname->value.str.val);
EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
EX_T(opline->result.u.var).var.ptr = object_zval;
- zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), opline);
+ zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), ENCODE_CTOR(EX(called_scope), RETURN_VALUE_USED(opline)));
/* We are not handling overloaded classes right now */
EX(object) = object_zval;
EX(fbc) = constructor;
+ EX(called_scope) = EX_T(opline->op1.u.var).class_entry;
ZEND_VM_NEXT_OPCODE();
}
}
while (EX(fbc)) {
- zend_op *ctor_opline = (zend_op*)zend_ptr_stack_pop(&EG(arg_types_stack));
-
+ EX(called_scope) = (zend_class_entry*)zend_ptr_stack_pop(&EG(arg_types_stack));
if (EX(object)) {
- if (ctor_opline && RETURN_VALUE_USED(ctor_opline)) {
+ if (IS_CTOR_USED(EX(called_scope))) {
EX(object)->refcount--;
}
zval_ptr_dtor(&EX(object));
}
+ EX(called_scope) = DECODE_CTOR(EX(called_scope));
zend_ptr_stack_2_pop(&EG(arg_types_stack), (void**)&EX(object), (void**)&EX(fbc));
}
/* Initialize execute_data */
EX(fbc) = NULL;
+ EX(called_scope) = NULL;
EX(object) = NULL;
EX(old_error_reporting) = NULL;
if (op_array->T < TEMP_VAR_STACK_LIMIT) {
EX(function_state).function = (zend_function *) op_array;
EG(function_state_ptr) = &EX(function_state);
-#if ZEND_DEBUG
- /* function_state.function_symbol_table is saved as-is to a stack,
- * which is an intentional UMR. Shut it up if we're in DEBUG.
- */
- EX(function_state).function_symbol_table = NULL;
-#endif
while (1) {
#ifdef ZEND_WIN32
{
zend_op *opline = EX(opline);
zval **original_return_value;
- zend_class_entry *current_scope = NULL;
- zval *current_this = NULL;
+ zend_class_entry *current_scope;
+ zend_class_entry *current_called_scope;
+ zval *current_this;
int return_value_used = RETURN_VALUE_USED(opline);
zend_bool should_change_scope;
- zend_op *ctor_opline;
+ zval *ex_object;
if (EX(function_state).function->common.fn_flags & (ZEND_ACC_ABSTRACT|ZEND_ACC_DEPRECATED)) {
if (EX(function_state).function->common.fn_flags & ZEND_ACC_ABSTRACT) {
EX(function_state).function->common.function_name);
}
}
+ if (EX(function_state).function->common.scope &&
+ !(EX(function_state).function->common.fn_flags & ZEND_ACC_STATIC) &&
+ !EX(object)) {
- zend_ptr_stack_2_push(&EG(argument_stack), (void *)(zend_uintptr_t)opline->extended_value, NULL);
-
- EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
+ if (EX(function_state).function->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
+ /* FIXME: output identifiers properly */
+ zend_error(E_STRICT, "Non-static method %s::%s() should not be called statically", EX(function_state).function->common.scope->name, EX(function_state).function->common.function_name);
+ } else {
+ /* FIXME: output identifiers properly */
+ zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically", EX(function_state).function->common.scope->name, EX(function_state).function->common.function_name);
+ }
+ }
- if (EX(function_state).function->type == ZEND_USER_FUNCTION
- || EX(function_state).function->common.scope) {
+ if (EX(function_state).function->type == ZEND_USER_FUNCTION ||
+ EX(function_state).function->common.scope) {
should_change_scope = 1;
current_this = EG(This);
- EG(This) = EX(object);
current_scope = EG(scope);
+ current_called_scope = EG(called_scope);
+ EG(This) = EX(object);
EG(scope) = (EX(function_state).function->type == ZEND_USER_FUNCTION || !EX(object)) ? EX(function_state).function->common.scope : NULL;
+ EG(called_scope) = EX(called_scope);
} else {
should_change_scope = 0;
}
- EX_T(opline->result.u.var).var.fcall_returned_reference = 0;
+ zend_ptr_stack_3_pop(&EG(arg_types_stack), (void*)&EX(called_scope), (void**)&ex_object, (void**)&EX(fbc));
+ zend_ptr_stack_2_push(&EG(argument_stack), (void *)(zend_uintptr_t)opline->extended_value, NULL);
- if (EX(function_state).function->common.scope) {
- if (!EG(This) && !(EX(function_state).function->common.fn_flags & ZEND_ACC_STATIC)) {
- int severity;
- char *severity_word;
- if (EX(function_state).function->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
- severity = E_STRICT;
- severity_word = "should not";
- } else {
- severity = E_ERROR;
- severity_word = "cannot";
- }
- zend_error(severity, "Non-static method %s::%s() %s be called statically", EX(function_state).function->common.scope->name, EX(function_state).function->common.function_name, severity_word);
- }
- }
- if (EX(function_state).function->type == ZEND_INTERNAL_FUNCTION) {
- unsigned char return_reference = EX(function_state).function->common.return_reference;
+ EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
+// EX_T(opline->result.u.var).var.fcall_returned_reference = 0;
+ if (EX(function_state).function->type == ZEND_INTERNAL_FUNCTION) {
ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
INIT_ZVAL(*(EX_T(opline->result.u.var).var.ptr));
if (!return_value_used) {
zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
} else {
- EX_T(opline->result.u.var).var.fcall_returned_reference = return_reference;
+ EX_T(opline->result.u.var).var.fcall_returned_reference = EX(function_state).function->common.return_reference;
}
} else if (EX(function_state).function->type == ZEND_USER_FUNCTION) {
+ HashTable *function_symbol_table;
+
EX_T(opline->result.u.var).var.ptr = NULL;
if (EG(symtable_cache_ptr)>=EG(symtable_cache)) {
/*printf("Cache hit! Reusing %x\n", symtable_cache[symtable_cache_ptr]);*/
- EX(function_state).function_symbol_table = *(EG(symtable_cache_ptr)--);
+ function_symbol_table = *(EG(symtable_cache_ptr)--);
} else {
- ALLOC_HASHTABLE(EX(function_state).function_symbol_table);
- zend_hash_init(EX(function_state).function_symbol_table, 0, NULL, ZVAL_PTR_DTOR, 0);
- /*printf("Cache miss! Initialized %x\n", function_state.function_symbol_table);*/
+ ALLOC_HASHTABLE(function_symbol_table);
+ zend_hash_init(function_symbol_table, 0, NULL, ZVAL_PTR_DTOR, 0);
+ /*printf("Cache miss! Initialized %x\n", function_symbol_table);*/
}
- EG(active_symbol_table) = EX(function_state).function_symbol_table;
+ EG(active_symbol_table) = function_symbol_table;
original_return_value = EG(return_value_ptr_ptr);
- EG(return_value_ptr_ptr) = EX_T(opline->result.u.var).var.ptr_ptr;
+ EG(return_value_ptr_ptr) = &EX_T(opline->result.u.var).var.ptr;
EG(active_op_array) = (zend_op_array *) EX(function_state).function;
zend_execute(EG(active_op_array) TSRMLS_CC);
EG(active_op_array) = EX(op_array);
EG(return_value_ptr_ptr)=original_return_value;
if (EG(symtable_cache_ptr)>=EG(symtable_cache_limit)) {
- zend_hash_destroy(EX(function_state).function_symbol_table);
- FREE_HASHTABLE(EX(function_state).function_symbol_table);
+ zend_hash_destroy(function_symbol_table);
+ FREE_HASHTABLE(function_symbol_table);
} else {
/* clean before putting into the cache, since clean
could call dtors, which could use cached hash */
- zend_hash_clean(EX(function_state).function_symbol_table);
- *(++EG(symtable_cache_ptr)) = EX(function_state).function_symbol_table;
+ zend_hash_clean(function_symbol_table);
+ *(++EG(symtable_cache_ptr)) = function_symbol_table;
}
EG(active_symbol_table) = EX(symbol_table);
} else { /* ZEND_OVERLOADED_FUNCTION */
/* Not sure what should be done here if it's a static method */
if (EX(object)) {
- Z_OBJ_HT_P(EX(object))->call_method(EX(fbc)->common.function_name, opline->extended_value, EX_T(opline->result.u.var).var.ptr, &EX_T(opline->result.u.var).var.ptr, EX(object), return_value_used TSRMLS_CC);
+ Z_OBJ_HT_P(EX(object))->call_method(EX(function_state).function->common.function_name, opline->extended_value, EX_T(opline->result.u.var).var.ptr, &EX_T(opline->result.u.var).var.ptr, EX(object), return_value_used TSRMLS_CC);
} else {
zend_error_noreturn(E_ERROR, "Cannot call overloaded function for non-object");
}
if (EX(function_state).function->type == ZEND_OVERLOADED_FUNCTION_TEMPORARY) {
efree(EX(function_state).function->common.function_name);
}
- efree(EX(fbc));
+ efree(EX(function_state).function);
if (!return_value_used) {
zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
} else {
EX_T(opline->result.u.var).var.ptr->is_ref = 0;
EX_T(opline->result.u.var).var.ptr->refcount = 1;
+ EX_T(opline->result.u.var).var.fcall_returned_reference = 0;
}
}
- ctor_opline = (zend_op*)zend_ptr_stack_pop(&EG(arg_types_stack));
-
if (EG(This)) {
- if (EG(exception) && ctor_opline) {
- if (RETURN_VALUE_USED(ctor_opline)) {
+ if (EG(exception) && IS_CTOR_CALL(EX(called_scope))) {
+ if (IS_CTOR_USED(EX(called_scope))) {
EG(This)->refcount--;
}
if (EG(This)->refcount == 1) {
}
}
+ EX(object) = ex_object;
+ EX(called_scope) = DECODE_CTOR(EX(called_scope));
+
if (should_change_scope) {
EG(This) = current_this;
EG(scope) = current_scope;
+ EG(called_scope) = current_called_scope;
}
- zend_ptr_stack_2_pop(&EG(arg_types_stack), (void**)&EX(object), (void**)&EX(fbc));
EX(function_state).function = (zend_function *) EX(op_array);
EG(function_state_ptr) = &EX(function_state);
EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
EX_T(opline->result.u.var).var.ptr = object_zval;
- zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), opline);
+ zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), ENCODE_CTOR(EX(called_scope), RETURN_VALUE_USED(opline)));
/* We are not handling overloaded classes right now */
EX(object) = object_zval;
EX(fbc) = constructor;
+ EX(called_scope) = EX_T(opline->op1.u.var).class_entry;
ZEND_VM_NEXT_OPCODE();
}
}
while (EX(fbc)) {
- zend_op *ctor_opline = (zend_op*)zend_ptr_stack_pop(&EG(arg_types_stack));
-
+ EX(called_scope) = (zend_class_entry*)zend_ptr_stack_pop(&EG(arg_types_stack));
if (EX(object)) {
- if (ctor_opline && RETURN_VALUE_USED(ctor_opline)) {
+ if (IS_CTOR_USED(EX(called_scope))) {
EX(object)->refcount--;
}
zval_ptr_dtor(&EX(object));
}
+ EX(called_scope) = DECODE_CTOR(EX(called_scope));
zend_ptr_stack_2_pop(&EG(arg_types_stack), (void**)&EX(object), (void**)&EX(fbc));
}
int function_name_strlen;
- zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
+ zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
if (IS_CONST == IS_CONST) {
function_name_strval = opline->op2.u.constant.value.str.val;
int function_name_strlen;
zend_free_op free_op2;
- zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
+ zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
if (IS_TMP_VAR == IS_CONST) {
function_name_strval = opline->op2.u.constant.value.str.val;
int function_name_strlen;
zend_free_op free_op2;
- zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
+ zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
if (IS_VAR == IS_CONST) {
function_name_strval = opline->op2.u.constant.value.str.val;
int function_name_strlen;
- zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
+ zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
if (IS_CV == IS_CONST) {
function_name_strval = opline->op2.u.constant.value.str.val;
zval *fname = &opline->op1.u.constant;
- zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
+ zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
if (zend_hash_find(EG(function_table), fname->value.str.val, fname->value.str.len+1, (void **) &EX(function_state).function)==FAILURE) {
zend_error_noreturn(E_ERROR, "Call to undefined function %s()", fname->value.str.val);
zval *function_name;
zend_class_entry *ce;
- zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
+ zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
if (IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
/* try a function in namespace */
EX(fbc) = ce->constructor;
}
+ EX(called_scope) = ce;
+
if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
EX(object) = NULL;
} else {
}
if ((EX(object) = EG(This))) {
EX(object)->refcount++;
+ EX(called_scope) = Z_OBJCE_P(EX(object));
}
}
zval *function_name;
zend_class_entry *ce;
- zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
+ zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
if (IS_CONST == IS_CONST && IS_TMP_VAR == IS_CONST) {
/* try a function in namespace */
EX(fbc) = ce->constructor;
}
+ EX(called_scope) = ce;
+
if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
EX(object) = NULL;
} else {
}
if ((EX(object) = EG(This))) {
EX(object)->refcount++;
+ EX(called_scope) = Z_OBJCE_P(EX(object));
}
}
zval *function_name;
zend_class_entry *ce;
- zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
+ zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
if (IS_CONST == IS_CONST && IS_VAR == IS_CONST) {
/* try a function in namespace */
EX(fbc) = ce->constructor;
}
+ EX(called_scope) = ce;
+
if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
EX(object) = NULL;
} else {
}
if ((EX(object) = EG(This))) {
EX(object)->refcount++;
+ EX(called_scope) = Z_OBJCE_P(EX(object));
}
}
zval *function_name;
zend_class_entry *ce;
- zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
+ zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
if (IS_CONST == IS_CONST && IS_UNUSED == IS_CONST) {
/* try a function in namespace */
EX(fbc) = ce->constructor;
}
+ EX(called_scope) = ce;
+
if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
EX(object) = NULL;
} else {
}
if ((EX(object) = EG(This))) {
EX(object)->refcount++;
+ EX(called_scope) = Z_OBJCE_P(EX(object));
}
}
zval *function_name;
zend_class_entry *ce;
- zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
+ zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
if (IS_CONST == IS_CONST && IS_CV == IS_CONST) {
/* try a function in namespace */
EX(fbc) = ce->constructor;
}
+ EX(called_scope) = ce;
+
if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
EX(object) = NULL;
} else {
}
if ((EX(object) = EG(This))) {
EX(object)->refcount++;
+ EX(called_scope) = Z_OBJCE_P(EX(object));
}
}
int function_name_strlen;
zend_free_op free_op1;
- zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
+ zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
function_name = &opline->op2.u.constant;
zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
}
+ EX(called_scope) = Z_OBJCE_P(EX(object));
+
if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
EX(object) = NULL;
} else {
int function_name_strlen;
zend_free_op free_op1, free_op2;
- zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
+ zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
function_name = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
}
+ EX(called_scope) = Z_OBJCE_P(EX(object));
+
if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
EX(object) = NULL;
} else {
int function_name_strlen;
zend_free_op free_op1, free_op2;
- zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
+ zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
function_name = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
}
+ EX(called_scope) = Z_OBJCE_P(EX(object));
+
if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
EX(object) = NULL;
} else {
int function_name_strlen;
zend_free_op free_op1;
- zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
+ zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
function_name = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
}
+ EX(called_scope) = Z_OBJCE_P(EX(object));
+
if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
EX(object) = NULL;
} else {
int function_name_strlen;
zend_free_op free_op1;
- zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
+ zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
function_name = &opline->op2.u.constant;
zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
}
+ EX(called_scope) = Z_OBJCE_P(EX(object));
+
if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
EX(object) = NULL;
} else {
zval *function_name;
zend_class_entry *ce;
- zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
+ zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
if (IS_VAR == IS_CONST && IS_CONST == IS_CONST) {
/* try a function in namespace */
EX(fbc) = ce->constructor;
}
+ EX(called_scope) = ce;
+
if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
EX(object) = NULL;
} else {
}
if ((EX(object) = EG(This))) {
EX(object)->refcount++;
+ EX(called_scope) = Z_OBJCE_P(EX(object));
}
}
int function_name_strlen;
zend_free_op free_op1, free_op2;
- zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
+ zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
function_name = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
}
+ EX(called_scope) = Z_OBJCE_P(EX(object));
+
if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
EX(object) = NULL;
} else {
zval *function_name;
zend_class_entry *ce;
- zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
+ zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
if (IS_VAR == IS_CONST && IS_TMP_VAR == IS_CONST) {
/* try a function in namespace */
EX(fbc) = ce->constructor;
}
+ EX(called_scope) = ce;
+
if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
EX(object) = NULL;
} else {
}
if ((EX(object) = EG(This))) {
EX(object)->refcount++;
+ EX(called_scope) = Z_OBJCE_P(EX(object));
}
}
int function_name_strlen;
zend_free_op free_op1, free_op2;
- zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
+ zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
function_name = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
}
+ EX(called_scope) = Z_OBJCE_P(EX(object));
+
if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
EX(object) = NULL;
} else {
zval *function_name;
zend_class_entry *ce;
- zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
+ zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
if (IS_VAR == IS_CONST && IS_VAR == IS_CONST) {
/* try a function in namespace */
EX(fbc) = ce->constructor;
}
+ EX(called_scope) = ce;
+
if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
EX(object) = NULL;
} else {
}
if ((EX(object) = EG(This))) {
EX(object)->refcount++;
+ EX(called_scope) = Z_OBJCE_P(EX(object));
}
}
zval *function_name;
zend_class_entry *ce;
- zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
+ zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
if (IS_VAR == IS_CONST && IS_UNUSED == IS_CONST) {
/* try a function in namespace */
EX(fbc) = ce->constructor;
}
+ EX(called_scope) = ce;
+
if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
EX(object) = NULL;
} else {
}
if ((EX(object) = EG(This))) {
EX(object)->refcount++;
+ EX(called_scope) = Z_OBJCE_P(EX(object));
}
}
int function_name_strlen;
zend_free_op free_op1;
- zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
+ zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
function_name = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
}
+ EX(called_scope) = Z_OBJCE_P(EX(object));
+
if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
EX(object) = NULL;
} else {
zval *function_name;
zend_class_entry *ce;
- zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
+ zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
if (IS_VAR == IS_CONST && IS_CV == IS_CONST) {
/* try a function in namespace */
EX(fbc) = ce->constructor;
}
+ EX(called_scope) = ce;
+
if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
EX(object) = NULL;
} else {
}
if ((EX(object) = EG(This))) {
EX(object)->refcount++;
+ EX(called_scope) = Z_OBJCE_P(EX(object));
}
}
int function_name_strlen;
- zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
+ zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
function_name = &opline->op2.u.constant;
zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
}
+ EX(called_scope) = Z_OBJCE_P(EX(object));
+
if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
EX(object) = NULL;
} else {
int function_name_strlen;
zend_free_op free_op2;
- zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
+ zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
function_name = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
}
+ EX(called_scope) = Z_OBJCE_P(EX(object));
+
if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
EX(object) = NULL;
} else {
int function_name_strlen;
zend_free_op free_op2;
- zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
+ zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
function_name = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
}
+ EX(called_scope) = Z_OBJCE_P(EX(object));
+
if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
EX(object) = NULL;
} else {
int function_name_strlen;
- zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
+ zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
function_name = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
}
+ EX(called_scope) = Z_OBJCE_P(EX(object));
+
if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
EX(object) = NULL;
} else {
int function_name_strlen;
- zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
+ zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
function_name = &opline->op2.u.constant;
zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
}
+ EX(called_scope) = Z_OBJCE_P(EX(object));
+
if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
EX(object) = NULL;
} else {
int function_name_strlen;
zend_free_op free_op2;
- zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
+ zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
function_name = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
}
+ EX(called_scope) = Z_OBJCE_P(EX(object));
+
if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
EX(object) = NULL;
} else {
int function_name_strlen;
zend_free_op free_op2;
- zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
+ zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
function_name = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
}
+ EX(called_scope) = Z_OBJCE_P(EX(object));
+
if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
EX(object) = NULL;
} else {
int function_name_strlen;
- zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
+ zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
function_name = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
}
+ EX(called_scope) = Z_OBJCE_P(EX(object));
+
if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
EX(object) = NULL;
} else {
/* Initialize execute_data */
EX(fbc) = NULL;
+ EX(called_scope) = NULL;
EX(object) = NULL;
EX(old_error_reporting) = NULL;
if (op_array->T < TEMP_VAR_STACK_LIMIT) {
EX(function_state).function = (zend_function *) op_array;
EG(function_state_ptr) = &EX(function_state);
-#if ZEND_DEBUG
- /* function_state.function_symbol_table is saved as-is to a stack,
- * which is an intentional UMR. Shut it up if we're in DEBUG.
- */
- EX(function_state).function_symbol_table = NULL;
-#endif
while (1) {
{%ZEND_VM_CONTINUE_LABEL%}
projects / php / commitdiff