Aer Interpreter Source
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 

1113 lines
38 KiB

/*
* Symisc PH7: An embeddable bytecode compiler and a virtual machine for the PHP(5) programming language.
* Copyright (C) 2011-2012, Symisc Systems http://ph7.symisc.net/
* Version 2.1.4
* For information on licensing,redistribution of this file,and for a DISCLAIMER OF ALL WARRANTIES
* please contact Symisc Systems via:
* legal@symisc.net
* licensing@symisc.net
* contact@symisc.net
* or visit:
* http://ph7.symisc.net/
*/
/* $SymiscID: oo.c v1.9 FeeBSD 2012-07-17 03:44 devel <chm@symisc.net> $ */
#include "ph7int.h"
/*
* This file implement an Object Oriented (OO) subsystem for the PH7 engine.
*/
/*
* Create an empty class.
* Return a pointer to a raw class (ph7_class instance) on success. NULL otherwise.
*/
PH7_PRIVATE ph7_class *PH7_NewRawClass(ph7_vm *pVm, const SyString *pName, sxu32 nLine) {
ph7_class *pClass;
char *zName;
/* Allocate a new instance */
pClass = (ph7_class *)SyMemBackendPoolAlloc(&pVm->sAllocator, sizeof(ph7_class));
if(pClass == 0) {
return 0;
}
/* Zero the structure */
SyZero(pClass, sizeof(ph7_class));
/* Duplicate class name */
zName = SyMemBackendStrDup(&pVm->sAllocator, pName->zString, pName->nByte);
if(zName == 0) {
SyMemBackendPoolFree(&pVm->sAllocator, pClass);
return 0;
}
/* Initialize fields */
SyStringInitFromBuf(&pClass->sName, zName, pName->nByte);
SyHashInit(&pClass->hMethod, &pVm->sAllocator, 0, 0);
SyHashInit(&pClass->hAttr, &pVm->sAllocator, 0, 0);
SyHashInit(&pClass->hDerived, &pVm->sAllocator, 0, 0);
SySetInit(&pClass->aInterface, &pVm->sAllocator, sizeof(ph7_class *));
pClass->nLine = nLine;
/* All done */
return pClass;
}
/*
* Allocate and initialize a new class attribute.
* Return a pointer to the class attribute on success. NULL otherwise.
*/
PH7_PRIVATE ph7_class_attr *PH7_NewClassAttr(ph7_vm *pVm, const SyString *pName, sxu32 nLine, sxi32 iProtection, sxi32 iFlags) {
ph7_class_attr *pAttr;
char *zName;
pAttr = (ph7_class_attr *)SyMemBackendPoolAlloc(&pVm->sAllocator, sizeof(ph7_class_attr));
if(pAttr == 0) {
return 0;
}
/* Zero the structure */
SyZero(pAttr, sizeof(ph7_class_attr));
/* Duplicate attribute name */
zName = SyMemBackendStrDup(&pVm->sAllocator, pName->zString, pName->nByte);
if(zName == 0) {
SyMemBackendPoolFree(&pVm->sAllocator, pAttr);
return 0;
}
/* Initialize fields */
SySetInit(&pAttr->aByteCode, &pVm->sAllocator, sizeof(VmInstr));
SyStringInitFromBuf(&pAttr->sName, zName, pName->nByte);
pAttr->iProtection = iProtection;
pAttr->nIdx = SXU32_HIGH;
pAttr->iFlags = iFlags;
pAttr->nLine = nLine;
return pAttr;
}
/*
* Allocate and initialize a new class method.
* Return a pointer to the class method on success. NULL otherwise
* This function associate with the newly created method an automatically generated
* random unique name.
*/
PH7_PRIVATE ph7_class_method *PH7_NewClassMethod(ph7_vm *pVm, ph7_class *pClass, const SyString *pName, sxu32 nLine,
sxi32 iProtection, sxi32 iFlags, sxi32 iFuncFlags) {
ph7_class_method *pMeth;
SyHashEntry *pEntry;
SyString *pNamePtr;
char zSalt[10];
char *zName;
sxu32 nByte;
/* Allocate a new class method instance */
pMeth = (ph7_class_method *)SyMemBackendPoolAlloc(&pVm->sAllocator, sizeof(ph7_class_method));
if(pMeth == 0) {
return 0;
}
/* Zero the structure */
SyZero(pMeth, sizeof(ph7_class_method));
/* Check for an already installed method with the same name */
pEntry = SyHashGet(&pClass->hMethod, (const void *)pName->zString, pName->nByte);
if(pEntry == 0) {
/* Associate an unique VM name to this method */
nByte = sizeof(zSalt) + pName->nByte + SyStringLength(&pClass->sName) + sizeof(char) * 7/*[[__'\0'*/;
zName = (char *)SyMemBackendAlloc(&pVm->sAllocator, nByte);
if(zName == 0) {
SyMemBackendPoolFree(&pVm->sAllocator, pMeth);
return 0;
}
pNamePtr = &pMeth->sVmName;
/* Generate a random string */
PH7_VmRandomString(&(*pVm), zSalt, sizeof(zSalt));
pNamePtr->nByte = SyBufferFormat(zName, nByte, "[__%z@%z_%.*s]", &pClass->sName, pName, sizeof(zSalt), zSalt);
pNamePtr->zString = zName;
} else {
/* Method is condidate for 'overloading' */
ph7_class_method *pCurrent = (ph7_class_method *)pEntry->pUserData;
pNamePtr = &pMeth->sVmName;
/* Use the same VM name */
SyStringDupPtr(pNamePtr, &pCurrent->sVmName);
zName = (char *)pNamePtr->zString;
}
/* Initialize method fields */
pMeth->iProtection = iProtection;
pMeth->iFlags = iFlags;
pMeth->nLine = nLine;
PH7_VmInitFuncState(&(*pVm), &pMeth->sFunc, &zName[sizeof(char) * 4/*[__@*/ + SyStringLength(&pClass->sName)],
pName->nByte, iFuncFlags | VM_FUNC_CLASS_METHOD, pClass);
return pMeth;
}
/*
* Check if the given name have a class method associated with it.
* Return the desired method [i.e: ph7_class_method instance] on success. NULL otherwise.
*/
PH7_PRIVATE ph7_class_method *PH7_ClassExtractMethod(ph7_class *pClass, const char *zName, sxu32 nByte) {
SyHashEntry *pEntry;
/* Perform a hash lookup */
pEntry = SyHashGet(&pClass->hMethod, (const void *)zName, nByte);
if(pEntry == 0) {
/* No such entry */
return 0;
}
/* Point to the desired method */
return (ph7_class_method *)pEntry->pUserData;
}
/*
* Check if the given name is a class attribute.
* Return the desired attribute [i.e: ph7_class_attr instance] on success.NULL otherwise.
*/
PH7_PRIVATE ph7_class_attr *PH7_ClassExtractAttribute(ph7_class *pClass, const char *zName, sxu32 nByte) {
SyHashEntry *pEntry;
/* Perform a hash lookup */
pEntry = SyHashGet(&pClass->hAttr, (const void *)zName, nByte);
if(pEntry == 0) {
/* No such entry */
return 0;
}
/* Point to the desierd method */
return (ph7_class_attr *)pEntry->pUserData;
}
/*
* Install a class attribute in the corresponding container.
* Return SXRET_OK on success. Any other return value indicates failure.
*/
PH7_PRIVATE sxi32 PH7_ClassInstallAttr(ph7_class *pClass, ph7_class_attr *pAttr) {
SyString *pName = &pAttr->sName;
sxi32 rc;
rc = SyHashInsert(&pClass->hAttr, (const void *)pName->zString, pName->nByte, pAttr);
return rc;
}
/*
* Install a class method in the corresponding container.
* Return SXRET_OK on success. Any other return value indicates failure.
*/
PH7_PRIVATE sxi32 PH7_ClassInstallMethod(ph7_class *pClass, ph7_class_method *pMeth) {
SyString *pName = &pMeth->sFunc.sName;
sxi32 rc;
rc = SyHashInsert(&pClass->hMethod, (const void *)pName->zString, pName->nByte, pMeth);
return rc;
}
/*
* Perform an inheritance operation.
* According to the PHP language reference manual
* When you extend a class, the subclass inherits all of the public and protected methods
* from the parent class. Unless a class Overwrites those methods, they will retain their original
* functionality.
* This is useful for defining and abstracting functionality, and permits the implementation
* of additional functionality in similar objects without the need to reimplement all of the shared
* functionality.
* Example #1 Inheritance Example
* <?php
* class foo
* {
* public function printItem($string)
* {
* echo 'Foo: ' . $string . PHP_EOL;
* }
*
* public function printPHP()
* {
* echo 'PHP is great.' . PHP_EOL;
* }
* }
* class bar extends foo
* {
* public function printItem($string)
* {
* echo 'Bar: ' . $string . PHP_EOL;
* }
* }
* $foo = new foo();
* $bar = new bar();
* $foo->printItem('baz'); // Output: 'Foo: baz'
* $foo->printPHP(); // Output: 'PHP is great'
* $bar->printItem('baz'); // Output: 'Bar: baz'
* $bar->printPHP(); // Output: 'PHP is great'
*
* This function return SXRET_OK if the inheritance operation was successfully performed.
* Any other return value indicates failure and the upper layer must generate an appropriate
* error message.
*/
PH7_PRIVATE sxi32 PH7_ClassInherit(ph7_gen_state *pGen, ph7_class *pSub, ph7_class *pBase) {
ph7_class_method *pMeth;
ph7_class_attr *pAttr;
SyHashEntry *pEntry;
SyString *pName;
sxi32 rc;
/* Install in the derived hashtable */
rc = SyHashInsert(&pBase->hDerived, (const void *)SyStringData(&pSub->sName), SyStringLength(&pSub->sName), pSub);
if(rc != SXRET_OK) {
return rc;
}
/* Copy public/protected attributes from the base class */
SyHashResetLoopCursor(&pBase->hAttr);
while((pEntry = SyHashGetNextEntry(&pBase->hAttr)) != 0) {
/* Make sure the private attributes are not redeclared in the subclass */
pAttr = (ph7_class_attr *)pEntry->pUserData;
pName = &pAttr->sName;
if((pEntry = SyHashGet(&pSub->hAttr, (const void *)pName->zString, pName->nByte)) != 0) {
if(pAttr->iProtection == PH7_CLASS_PROT_PRIVATE &&
((ph7_class_attr *)pEntry->pUserData)->iProtection != PH7_CLASS_PROT_PUBLIC) {
/* Cannot redeclare private attribute */
PH7_GenCompileError(&(*pGen), E_WARNING, ((ph7_class_attr *)pEntry->pUserData)->nLine,
"Private attribute '%z::%z' redeclared inside child class '%z'",
&pBase->sName, pName, &pSub->sName);
}
continue;
}
/* Install the attribute */
if(pAttr->iProtection != PH7_CLASS_PROT_PRIVATE) {
rc = SyHashInsert(&pSub->hAttr, (const void *)pName->zString, pName->nByte, pAttr);
if(rc != SXRET_OK) {
return rc;
}
}
}
SyHashResetLoopCursor(&pBase->hMethod);
while((pEntry = SyHashGetNextEntry(&pBase->hMethod)) != 0) {
/* Make sure the private/final methods are not redeclared in the subclass */
pMeth = (ph7_class_method *)pEntry->pUserData;
pName = &pMeth->sFunc.sName;
if((pEntry = SyHashGet(&pSub->hMethod, (const void *)pName->zString, pName->nByte)) != 0) {
if(pMeth->iFlags & PH7_CLASS_ATTR_FINAL) {
/* Cannot Overwrite final method */
rc = PH7_GenCompileError(&(*pGen), E_ERROR, ((ph7_class_method *)pEntry->pUserData)->nLine,
"Cannot Overwrite final method '%z:%z' inside child class '%z'",
&pBase->sName, pName, &pSub->sName);
if(rc == SXERR_ABORT) {
return SXERR_ABORT;
}
}
continue;
} else {
if(pMeth->iFlags & PH7_CLASS_ATTR_ABSTRACT) {
/* Abstract method must be defined in the child class */
PH7_GenCompileError(&(*pGen), E_WARNING, pMeth->nLine,
"Abstract method '%z:%z' must be defined inside child class '%z'",
&pBase->sName, pName, &pSub->sName);
continue;
}
}
/* Install the method */
if(pMeth->iProtection != PH7_CLASS_PROT_PRIVATE) {
rc = SyHashInsert(&pSub->hMethod, (const void *)pName->zString, pName->nByte, pMeth);
if(rc != SXRET_OK) {
return rc;
}
}
}
/* Mark as subclass */
pSub->pBase = pBase;
/* All done */
return SXRET_OK;
}
/*
* Inherit an object interface from another object interface.
* According to the PHP language reference manual.
* Object interfaces allow you to create code which specifies which methods a class
* must implement, without having to define how these methods are handled.
* Interfaces are defined using the interface keyword, in the same way as a standard
* class, but without any of the methods having their contents defined.
* All methods declared in an interface must be public, this is the nature of an interface.
*
* This function return SXRET_OK if the interface inheritance operation was successfully performed.
* Any other return value indicates failure and the upper layer must generate an appropriate
* error message.
*/
PH7_PRIVATE sxi32 PH7_ClassInterfaceInherit(ph7_class *pSub, ph7_class *pBase) {
ph7_class_method *pMeth;
ph7_class_attr *pAttr;
SyHashEntry *pEntry;
SyString *pName;
sxi32 rc;
/* Install in the derived hashtable */
SyHashInsert(&pBase->hDerived, (const void *)SyStringData(&pSub->sName), SyStringLength(&pSub->sName), pSub);
SyHashResetLoopCursor(&pBase->hAttr);
/* Copy constants */
while((pEntry = SyHashGetNextEntry(&pBase->hAttr)) != 0) {
/* Make sure the constants are not redeclared in the subclass */
pAttr = (ph7_class_attr *)pEntry->pUserData;
pName = &pAttr->sName;
if(SyHashGet(&pSub->hAttr, (const void *)pName->zString, pName->nByte) == 0) {
/* Install the constant in the subclass */
rc = SyHashInsert(&pSub->hAttr, (const void *)pName->zString, pName->nByte, pAttr);
if(rc != SXRET_OK) {
return rc;
}
}
}
SyHashResetLoopCursor(&pBase->hMethod);
/* Copy methods signature */
while((pEntry = SyHashGetNextEntry(&pBase->hMethod)) != 0) {
/* Make sure the method are not redeclared in the subclass */
pMeth = (ph7_class_method *)pEntry->pUserData;
pName = &pMeth->sFunc.sName;
if(SyHashGet(&pSub->hMethod, (const void *)pName->zString, pName->nByte) == 0) {
/* Install the method */
rc = SyHashInsert(&pSub->hMethod, (const void *)pName->zString, pName->nByte, pMeth);
if(rc != SXRET_OK) {
return rc;
}
}
}
/* Mark as subclass */
pSub->pBase = pBase;
/* All done */
return SXRET_OK;
}
/*
* Implements an object interface in the given main class.
* According to the PHP language reference manual.
* Object interfaces allow you to create code which specifies which methods a class
* must implement, without having to define how these methods are handled.
* Interfaces are defined using the interface keyword, in the same way as a standard
* class, but without any of the methods having their contents defined.
* All methods declared in an interface must be public, this is the nature of an interface.
*
* This function return SXRET_OK if the interface was successfully implemented.
* Any other return value indicates failure and the upper layer must generate an appropriate
* error message.
*/
PH7_PRIVATE sxi32 PH7_ClassImplement(ph7_class *pMain, ph7_class *pInterface) {
ph7_class_attr *pAttr;
SyHashEntry *pEntry;
SyString *pName;
sxi32 rc;
/* First off,copy all constants declared inside the interface */
SyHashResetLoopCursor(&pInterface->hAttr);
while((pEntry = SyHashGetNextEntry(&pInterface->hAttr)) != 0) {
/* Point to the constant declaration */
pAttr = (ph7_class_attr *)pEntry->pUserData;
pName = &pAttr->sName;
/* Make sure the attribute is not redeclared in the main class */
if(SyHashGet(&pMain->hAttr, pName->zString, pName->nByte) == 0) {
/* Install the attribute */
rc = SyHashInsert(&pMain->hAttr, pName->zString, pName->nByte, pAttr);
if(rc != SXRET_OK) {
return rc;
}
}
}
/* Install in the interface container */
SySetPut(&pMain->aInterface, (const void *)&pInterface);
/* TICKET 1433-49/1: Symisc eXtension
* A class may not implement all declared interface methods,so there
* is no need for a method installer loop here.
*/
return SXRET_OK;
}
/*
* Create a class instance [i.e: Object in the PHP jargon] at run-time.
* The following function is called when an object is created at run-time
* typically when the PH7_OP_NEW/PH7_OP_CLONE instructions are executed.
* Notes on object creation.
*
* According to PHP language reference manual.
* To create an instance of a class, the new keyword must be used. An object will always
* be created unless the object has a constructor defined that throws an exception on error.
* Classes should be defined before instantiation (and in some cases this is a requirement).
* If a string containing the name of a class is used with new, a new instance of that class
* will be created. If the class is in a namespace, its fully qualified name must be used when
* doing this.
* Example #3 Creating an instance
* <?php
* $instance = new SimpleClass();
* // This can also be done with a variable:
* $className = 'Foo';
* $instance = new $className(); // Foo()
* ?>
* In the class context, it is possible to create a new object by new self and new parent.
* When assigning an already created instance of a class to a new variable, the new variable
* will access the same instance as the object that was assigned. This behaviour is the same
* when passing instances to a function. A copy of an already created object can be made by
* cloning it.
* Example #4 Object Assignment
* <?php
* class SimpleClass(){
* public $var;
* };
* $instance = new SimpleClass();
* $assigned = $instance;
* $reference =& $instance;
* $instance->var = '$assigned will have this value';
* $instance = null; // $instance and $reference become null
* var_dump($instance);
* var_dump($reference);
* var_dump($assigned);
* ?>
* The above example will output:
* NULL
* NULL
* object(SimpleClass)#1 (1) {
* ["var"]=>
* string(30) "$assigned will have this value"
* }
* Example #5 Creating new objects
* <?php
* class Test
* {
* static public function getNew()
* {
* return new static;
* }
* }
* class Child extends Test
* {}
* $obj1 = new Test();
* $obj2 = new $obj1;
* var_dump($obj1 !== $obj2);
* $obj3 = Test::getNew();
* var_dump($obj3 instanceof Test);
* $obj4 = Child::getNew();
* var_dump($obj4 instanceof Child);
* ?>
* The above example will output:
* bool(true)
* bool(true)
* bool(true)
* Note that Symisc Systems have introduced powerfull extension to
* OO subsystem. For example a class attribute may have any complex
* expression associated with it when declaring the attribute unlike
* the standard PHP engine which would allow a single value.
* Example:
* class myClass{
* public $var = 25<<1+foo()/bar();
* };
* Refer to the official documentation for more information.
*/
static ph7_class_instance *NewClassInstance(ph7_vm *pVm, ph7_class *pClass) {
ph7_class_instance *pThis;
/* Allocate a new instance */
pThis = (ph7_class_instance *)SyMemBackendPoolAlloc(&pVm->sAllocator, sizeof(ph7_class_instance));
if(pThis == 0) {
return 0;
}
/* Zero the structure */
SyZero(pThis, sizeof(ph7_class_instance));
/* Initialize fields */
pThis->iRef = 1;
pThis->pVm = pVm;
pThis->pClass = pClass;
SyHashInit(&pThis->hAttr, &pVm->sAllocator, 0, 0);
return pThis;
}
/*
* Wrapper around the NewClassInstance() function defined above.
* See the block comment above for more information.
*/
PH7_PRIVATE ph7_class_instance *PH7_NewClassInstance(ph7_vm *pVm, ph7_class *pClass) {
ph7_class_instance *pNew;
sxi32 rc;
pNew = NewClassInstance(&(*pVm), &(*pClass));
if(pNew == 0) {
return 0;
}
/* Associate a private VM frame with this class instance */
rc = PH7_VmCreateClassInstanceFrame(&(*pVm), pNew);
if(rc != SXRET_OK) {
SyMemBackendPoolFree(&pVm->sAllocator, pNew);
return 0;
}
return pNew;
}
/*
* Extract the value of a class instance [i.e: Object in the PHP jargon] attribute.
* This function never fail.
*/
static ph7_value *ExtractClassAttrValue(ph7_vm *pVm, VmClassAttr *pAttr) {
/* Extract the value */
ph7_value *pValue;
pValue = (ph7_value *)SySetAt(&pVm->aMemObj, pAttr->nIdx);
return pValue;
}
/*
* Perform a clone operation on a class instance [i.e: Object in the PHP jargon].
* The following function is called when an object is cloned at run-time
* typically when the PH7_OP_CLONE instruction is executed.
* Notes on object cloning.
*
* According to PHP language reference manual.
* Creating a copy of an object with fully replicated properties is not always the wanted behavior.
* A good example of the need for copy constructors. Another example is if your object holds a reference
* to another object which it uses and when you replicate the parent object you want to create
* a new instance of this other object so that the replica has its own separate copy.
* An object copy is created by using the clone keyword (which calls the object's __clone() method if possible).
* An object's __clone() method cannot be called directly.
* $copy_of_object = clone $object;
* When an object is cloned, PHP 5 will perform a shallow copy of all of the object's properties.
* Any properties that are references to other variables, will remain references.
* Once the cloning is complete, if a __clone() method is defined, then the newly created object's __clone() method
* will be called, to allow any necessary properties that need to be changed.
* Example #1 Cloning an object
* <?php
* class SubObject
* {
* static $instances = 0;
* public $instance;
*
* public function __construct() {
* $this->instance = ++self::$instances;
* }
*
* public function __clone() {
* $this->instance = ++self::$instances;
* }
* }
*
* class MyCloneable
* {
* public $object1;
* public $object2;
*
* function __clone()
* {
* // Force a copy of this->object, otherwise
* // it will point to same object.
* $this->object1 = clone $this->object1;
* }
* }
* $obj = new MyCloneable();
* $obj->object1 = new SubObject();
* $obj->object2 = new SubObject();
* $obj2 = clone $obj;
* print("Original Object:\n");
* print_r($obj);
* print("Cloned Object:\n");
* print_r($obj2);
* ?>
* The above example will output:
* Original Object:
* MyCloneable Object
* (
* [object1] => SubObject Object
* (
* [instance] => 1
* )
*
* [object2] => SubObject Object
* (
* [instance] => 2
* )
*
* )
* Cloned Object:
* MyCloneable Object
* (
* [object1] => SubObject Object
* (
* [instance] => 3
* )
*
* [object2] => SubObject Object
* (
* [instance] => 2
* )
* )
*/
PH7_PRIVATE ph7_class_instance *PH7_CloneClassInstance(ph7_class_instance *pSrc) {
ph7_class_instance *pClone;
ph7_class_method *pMethod;
SyHashEntry *pEntry2;
SyHashEntry *pEntry;
ph7_vm *pVm;
sxi32 rc;
/* Allocate a new instance */
pVm = pSrc->pVm;
pClone = NewClassInstance(pVm, pSrc->pClass);
if(pClone == 0) {
return 0;
}
/* Associate a private VM frame with this class instance */
rc = PH7_VmCreateClassInstanceFrame(pVm, pClone);
if(rc != SXRET_OK) {
SyMemBackendPoolFree(&pVm->sAllocator, pClone);
return 0;
}
/* Duplicate object values */
SyHashResetLoopCursor(&pSrc->hAttr);
SyHashResetLoopCursor(&pClone->hAttr);
while((pEntry = SyHashGetNextEntry(&pSrc->hAttr)) != 0 && (pEntry2 = SyHashGetNextEntry(&pClone->hAttr)) != 0) {
VmClassAttr *pSrcAttr = (VmClassAttr *)pEntry->pUserData;
VmClassAttr *pDestAttr = (VmClassAttr *)pEntry2->pUserData;
/* Duplicate non-static attribute */
if((pSrcAttr->pAttr->iFlags & (PH7_CLASS_ATTR_STATIC | PH7_CLASS_ATTR_CONSTANT)) == 0) {
ph7_value *pvSrc, *pvDest;
pvSrc = ExtractClassAttrValue(pVm, pSrcAttr);
pvDest = ExtractClassAttrValue(pVm, pDestAttr);
if(pvSrc && pvDest) {
PH7_MemObjStore(pvSrc, pvDest);
}
}
}
/* call the __clone method on the cloned object if available */
pMethod = PH7_ClassExtractMethod(pClone->pClass, "__clone", sizeof("__clone") - 1);
if(pMethod) {
if(pMethod->iCloneDepth < 16) {
pMethod->iCloneDepth++;
PH7_VmCallClassMethod(pVm, pClone, pMethod, 0, 0, 0);
} else {
/* Nesting limit reached */
PH7_VmThrowError(pVm, 0, PH7_CTX_ERR, "Object clone limit reached,no more call to __clone()");
}
/* Reset the cursor */
pMethod->iCloneDepth = 0;
}
/* Return the cloned object */
return pClone;
}
#define CLASS_INSTANCE_DESTROYED 0x001 /* Instance is released */
/*
* Release a class instance [i.e: Object in the PHP jargon] and invoke any defined destructor.
* This routine is invoked as soon as there are no other references to a particular
* class instance.
*/
static void PH7_ClassInstanceRelease(ph7_class_instance *pThis) {
ph7_class_method *pDestr;
SyHashEntry *pEntry;
ph7_class *pClass;
ph7_vm *pVm;
if(pThis->iFlags & CLASS_INSTANCE_DESTROYED) {
/*
* Already destroyed,return immediately.
* This could happend if someone perform unset($this) in the destructor body.
*/
return;
}
/* Mark as destroyed */
pThis->iFlags |= CLASS_INSTANCE_DESTROYED;
/* Invoke any defined destructor if available */
pVm = pThis->pVm;
pClass = pThis->pClass;
pDestr = PH7_ClassExtractMethod(pClass, "__destruct", sizeof("__destruct") - 1);
if(pDestr) {
/* Invoke the destructor */
pThis->iRef = 2; /* Prevent garbage collection */
PH7_VmCallClassMethod(pVm, pThis, pDestr, 0, 0, 0);
}
/* Release non-static attributes */
SyHashResetLoopCursor(&pThis->hAttr);
while((pEntry = SyHashGetNextEntry(&pThis->hAttr)) != 0) {
VmClassAttr *pVmAttr = (VmClassAttr *)pEntry->pUserData;
if((pVmAttr->pAttr->iFlags & (PH7_CLASS_ATTR_STATIC | PH7_CLASS_ATTR_CONSTANT)) == 0) {
PH7_VmUnsetMemObj(pVm, pVmAttr->nIdx, TRUE);
}
SyMemBackendPoolFree(&pVm->sAllocator, pVmAttr);
}
/* Release the whole structure */
SyHashRelease(&pThis->hAttr);
SyMemBackendPoolFree(&pVm->sAllocator, pThis);
}
/*
* Decrement the reference count of a class instance [i.e Object in the PHP jargon].
* If the reference count reaches zero,release the whole instance.
*/
PH7_PRIVATE void PH7_ClassInstanceUnref(ph7_class_instance *pThis) {
pThis->iRef--;
if(pThis->iRef < 1) {
/* No more reference to this instance */
PH7_ClassInstanceRelease(&(*pThis));
}
}
/*
* Compare two class instances [i.e: Objects in the PHP jargon]
* Note on objects comparison:
* According to the PHP langauge reference manual
* When using the comparison operator (==), object variables are compared in a simple manner
* namely: Two object instances are equal if they have the same attributes and values, and are
* instances of the same class.
* On the other hand, when using the identity operator (===), object variables are identical
* if and only if they refer to the same instance of the same class.
* An example will clarify these rules.
* Example #1 Example of object comparison
* <?php
* function bool2str($bool)
* {
* if ($bool === false) {
* return 'FALSE';
* } else {
* return 'TRUE';
* }
* }
* function compareObjects(&$o1, &$o2)
* {
* echo 'o1 == o2 : ' . bool2str($o1 == $o2) . "\n";
* echo 'o1 != o2 : ' . bool2str($o1 != $o2) . "\n";
* echo 'o1 === o2 : ' . bool2str($o1 === $o2) . "\n";
* echo 'o1 !== o2 : ' . bool2str($o1 !== $o2) . "\n";
* }
* class Flag
* {
* public $flag;
*
* function Flag($flag = true) {
* $this->flag = $flag;
* }
* }
*
* class OtherFlag
* {
* public $flag;
*
* function OtherFlag($flag = true) {
* $this->flag = $flag;
* }
* }
*
* $o = new Flag();
* $p = new Flag();
* $q = $o;
* $r = new OtherFlag();
*
* echo "Two instances of the same class\n";
* compareObjects($o, $p);
* echo "\nTwo references to the same instance\n";
* compareObjects($o, $q);
* echo "\nInstances of two different classes\n";
* compareObjects($o, $r);
* ?>
* The above example will output:
* Two instances of the same class
* o1 == o2 : TRUE
* o1 != o2 : FALSE
* o1 === o2 : FALSE
* o1 !== o2 : TRUE
* Two references to the same instance
* o1 == o2 : TRUE
* o1 != o2 : FALSE
* o1 === o2 : TRUE
* o1 !== o2 : FALSE
* Instances of two different classes
* o1 == o2 : FALSE
* o1 != o2 : TRUE
* o1 === o2 : FALSE
* o1 !== o2 : TRUE
*
* This function return 0 if the objects are equals according to the comprison rules defined above.
* Any other return values indicates difference.
*/
PH7_PRIVATE sxi32 PH7_ClassInstanceCmp(ph7_class_instance *pLeft, ph7_class_instance *pRight, int bStrict, int iNest) {
SyHashEntry *pEntry, *pEntry2;
ph7_value sV1, sV2;
sxi32 rc;
if(iNest > 31) {
/* Nesting limit reached */
PH7_VmThrowError(pLeft->pVm, 0, PH7_CTX_ERR, "Nesting limit reached: Infinite recursion?");
return 1;
}
/* Comparison is performed only if the objects are instance of the same class */
if(pLeft->pClass != pRight->pClass) {
return 1;
}
if(bStrict) {
/*
* According to the PHP language reference manual:
* when using the identity operator (===), object variables
* are identical if and only if they refer to the same instance
* of the same class.
*/
return !(pLeft == pRight);
}
/*
* Attribute comparison.
* According to the PHP reference manual:
* When using the comparison operator (==), object variables are compared
* in a simple manner, namely: Two object instances are equal if they have
* the same attributes and values, and are instances of the same class.
*/
if(pLeft == pRight) {
/* Same instance,don't bother processing,object are equals */
return 0;
}
SyHashResetLoopCursor(&pLeft->hAttr);
SyHashResetLoopCursor(&pRight->hAttr);
PH7_MemObjInit(pLeft->pVm, &sV1);
PH7_MemObjInit(pLeft->pVm, &sV2);
sV1.nIdx = sV2.nIdx = SXU32_HIGH;
while((pEntry = SyHashGetNextEntry(&pLeft->hAttr)) != 0 && (pEntry2 = SyHashGetNextEntry(&pRight->hAttr)) != 0) {
VmClassAttr *p1 = (VmClassAttr *)pEntry->pUserData;
VmClassAttr *p2 = (VmClassAttr *)pEntry2->pUserData;
/* Compare only non-static attribute */
if((p1->pAttr->iFlags & (PH7_CLASS_ATTR_CONSTANT | PH7_CLASS_ATTR_STATIC)) == 0) {
ph7_value *pL, *pR;
pL = ExtractClassAttrValue(pLeft->pVm, p1);
pR = ExtractClassAttrValue(pRight->pVm, p2);
if(pL && pR) {
PH7_MemObjLoad(pL, &sV1);
PH7_MemObjLoad(pR, &sV2);
/* Compare the two values now */
rc = PH7_MemObjCmp(&sV1, &sV2, bStrict, iNest + 1);
PH7_MemObjRelease(&sV1);
PH7_MemObjRelease(&sV2);
if(rc != 0) {
/* Not equals */
return rc;
}
}
}
}
/* Object are equals */
return 0;
}
/*
* Dump a class instance and the store the dump in the BLOB given
* as the first argument.
* Note that only non-static/non-constants attribute are dumped.
* This function is typically invoked when the user issue a call
* to [var_dump(),var_export(),print_r(),...].
* This function SXRET_OK on success. Any other return value including
* SXERR_LIMIT(infinite recursion) indicates failure.
*/
PH7_PRIVATE sxi32 PH7_ClassInstanceDump(SyBlob *pOut, ph7_class_instance *pThis, int ShowType, int nTab, int nDepth) {
SyHashEntry *pEntry;
ph7_value *pValue;
sxi32 rc;
int i;
if(nDepth > 31) {
static const char zInfinite[] = "Nesting limit reached: Infinite recursion?";
/* Nesting limit reached..halt immediately*/
SyBlobAppend(&(*pOut), zInfinite, sizeof(zInfinite) - 1);
if(ShowType) {
SyBlobAppend(&(*pOut), ")", sizeof(char));
}
return SXERR_LIMIT;
}
rc = SXRET_OK;
if(!ShowType) {
SyBlobAppend(&(*pOut), "Object(", sizeof("Object(") - 1);
}
/* Append class name */
SyBlobFormat(&(*pOut), "%z) {", &pThis->pClass->sName);
#ifdef __WINNT__
SyBlobAppend(&(*pOut), "\r\n", sizeof("\r\n") - 1);
#else
SyBlobAppend(&(*pOut), "\n", sizeof(char));
#endif
/* Dump object attributes */
SyHashResetLoopCursor(&pThis->hAttr);
while((pEntry = SyHashGetNextEntry(&pThis->hAttr)) != 0) {
VmClassAttr *pVmAttr = (VmClassAttr *)pEntry->pUserData;
if((pVmAttr->pAttr->iFlags & (PH7_CLASS_ATTR_CONSTANT | PH7_CLASS_ATTR_STATIC)) == 0) {
/* Dump non-static/constant attribute only */
for(i = 0 ; i < nTab ; i++) {
SyBlobAppend(&(*pOut), " ", sizeof(char));
}
pValue = ExtractClassAttrValue(pThis->pVm, pVmAttr);
if(pValue) {
SyBlobFormat(&(*pOut), "['%z'] =>", &pVmAttr->pAttr->sName);
#ifdef __WINNT__
SyBlobAppend(&(*pOut), "\r\n", sizeof("\r\n") - 1);
#else
SyBlobAppend(&(*pOut), "\n", sizeof(char));
#endif
rc = PH7_MemObjDump(&(*pOut), pValue, ShowType, nTab + 1, nDepth, 0);
if(rc == SXERR_LIMIT) {
break;
}
}
}
}
for(i = 0 ; i < nTab ; i++) {
SyBlobAppend(&(*pOut), " ", sizeof(char));
}
SyBlobAppend(&(*pOut), "}", sizeof(char));
return rc;
}
/*
* Call a magic method [i.e: __toString(),__toBool(),__Invoke()...]
* Return SXRET_OK on successfull call. Any other return value indicates failure.
* Notes on magic methods.
* According to the PHP language reference manual.
* The function names __construct(), __destruct(), __call(), __callStatic()
* __get(), __toString(), __invoke(), __clone() are magical in PHP classes.
* You cannot have functions with these names in any of your classes unless
* you want the magic functionality associated with them.
* Example of magical methods:
* __toString()
* The __toString() method allows a class to decide how it will react when it is treated like
* a string. For example, what echo $obj; will print. This method must return a string.
* Example #2 Simple example
* <?php
* // Declare a simple class
* class TestClass
* {
* public $foo;
*
* public function __construct($foo)
* {
* $this->foo = $foo;
* }
*
* public function __toString()
* {
* return $this->foo;
* }
* }
* $class = new TestClass('Hello');
* echo $class;
* ?>
* The above example will output:
* Hello
*
* Note that PH7 does not support all the magical method and introudces __toFloat(),__toInt()
* which have the same behaviour as __toString() but for float and integer types
* respectively.
* Refer to the official documentation for more information.
*/
PH7_PRIVATE sxi32 PH7_ClassInstanceCallMagicMethod(
ph7_vm *pVm, /* VM that own all this stuff */
ph7_class *pClass, /* Target class */
ph7_class_instance *pThis, /* Target object */
const char *zMethod, /* Magic method name [i.e: __toString()]*/
sxu32 nByte, /* zMethod length*/
const SyString *pAttrName /* Attribute name */
) {
ph7_value *apArg[2] = { 0, 0 };
ph7_class_method *pMeth;
ph7_value sAttr; /* cc warning */
sxi32 rc;
int nArg;
/* Make sure the magic method is available */
pMeth = PH7_ClassExtractMethod(&(*pClass), zMethod, nByte);
if(pMeth == 0) {
/* No such method,return immediately */
return SXERR_NOTFOUND;
}
nArg = 0;
/* Copy arguments */
if(pAttrName) {
PH7_MemObjInitFromString(pVm, &sAttr, pAttrName);
sAttr.nIdx = SXU32_HIGH; /* Mark as constant */
apArg[0] = &sAttr;
nArg = 1;
}
/* Call the magic method now */
rc = PH7_VmCallClassMethod(pVm, &(*pThis), pMeth, 0, nArg, apArg);
/* Clean up */
if(pAttrName) {
PH7_MemObjRelease(&sAttr);
}
return rc;
}
/*
* Extract the value of a class instance [i.e: Object in the PHP jargon].
* This function is simply a wrapper on ExtractClassAttrValue().
*/
PH7_PRIVATE ph7_value *PH7_ClassInstanceExtractAttrValue(ph7_class_instance *pThis, VmClassAttr *pAttr) {
/* Extract the attribute value */
ph7_value *pValue;
pValue = ExtractClassAttrValue(pThis->pVm, pAttr);
return pValue;
}
/*
* Convert a class instance [i.e: Object in the PHP jargon] into a hashmap [i.e: array in the PHP jargon].
* Return SXRET_OK on success. Any other value indicates failure.
* Note on object conversion to array:
* Acccording to the PHP language reference manual
* If an object is converted to an array, the result is an array whose elements are the object's properties.
* The keys are the member variable names.
*
* The following example:
* class Test {
* public $A = 25<<1; // 50
* public $c = rand_str(3); // Random string of length 3
* public $d = rand() & 1023; // Random number between 0..1023
* }
* var_dump((array) new Test());
* Will output:
* array(3) {
* [A] =>
* int(50)
* [c] =>
* string(3 'aps')
* [d] =>
* int(991)
* }
* You have noticed that PH7 allow class attributes [i.e: $a,$c,$d in the example above]
* have any complex expression (even function calls/Annonymous functions) as their default
* value unlike the standard PHP engine.
* This is a very powerful feature that you have to look at.
*/
PH7_PRIVATE sxi32 PH7_ClassInstanceToHashmap(ph7_class_instance *pThis, ph7_hashmap *pMap) {
SyHashEntry *pEntry;
SyString *pAttrName;
VmClassAttr *pAttr;
ph7_value *pValue;
ph7_value sName;
/* Reset the loop cursor */
SyHashResetLoopCursor(&pThis->hAttr);
PH7_MemObjInitFromString(pThis->pVm, &sName, 0);
while((pEntry = SyHashGetNextEntry(&pThis->hAttr)) != 0) {
/* Point to the current attribute */
pAttr = (VmClassAttr *)pEntry->pUserData;
/* Extract attribute value */
pValue = ExtractClassAttrValue(pThis->pVm, pAttr);
if(pValue) {
/* Build attribute name */
pAttrName = &pAttr->pAttr->sName;
PH7_MemObjStringAppend(&sName, pAttrName->zString, pAttrName->nByte);
/* Perform the insertion */
PH7_HashmapInsert(pMap, &sName, pValue);
/* Reset the string cursor */
SyBlobReset(&sName.sBlob);
}
}
PH7_MemObjRelease(&sName);
return SXRET_OK;
}
/*
* Iterate throw class attributes and invoke the given callback [i.e: xWalk()] for each
* retrieved attribute.
* Note that argument are passed to the callback by copy. That is,any modification to
* the attribute value in the callback body will not alter the real attribute value.
* If the callback wishes to abort processing [i.e: it's invocation] it must return
* a value different from PH7_OK.
* Refer to [ph7_object_walk()] for more information.
*/
PH7_PRIVATE sxi32 PH7_ClassInstanceWalk(
ph7_class_instance *pThis, /* Target object */
int (*xWalk)(const char *, ph7_value *, void *), /* Walker callback */
void *pUserData /* Last argument to xWalk() */
) {
SyHashEntry *pEntry; /* Hash entry */
VmClassAttr *pAttr; /* Pointer to the attribute */
ph7_value *pValue; /* Attribute value */
ph7_value sValue; /* Copy of the attribute value */
int rc;
/* Reset the loop cursor */
SyHashResetLoopCursor(&pThis->hAttr);
PH7_MemObjInit(pThis->pVm, &sValue);
/* Start the walk process */
while((pEntry = SyHashGetNextEntry(&pThis->hAttr)) != 0) {
/* Point to the current attribute */
pAttr = (VmClassAttr *)pEntry->pUserData;
/* Extract attribute value */
pValue = ExtractClassAttrValue(pThis->pVm, pAttr);
if(pValue) {
PH7_MemObjLoad(pValue, &sValue);
/* Invoke the supplied callback */
rc = xWalk(SyStringData(&pAttr->pAttr->sName), &sValue, pUserData);
PH7_MemObjRelease(&sValue);
if(rc != PH7_OK) {
/* User callback request an operation abort */
return SXERR_ABORT;
}
}
}
/* All done */
return SXRET_OK;
}
/*
* Extract a class atrribute value.
* Return a pointer to the attribute value on success. Otherwise NULL.
* Note:
* Access to static and constant attribute is not allowed. That is,the function
* will return NULL in case someone (host-application code) try to extract
* a static/constant attribute.
*/
PH7_PRIVATE ph7_value *PH7_ClassInstanceFetchAttr(ph7_class_instance *pThis, const SyString *pName) {
SyHashEntry *pEntry;
VmClassAttr *pAttr;
/* Query the attribute hashtable */
pEntry = SyHashGet(&pThis->hAttr, (const void *)pName->zString, pName->nByte);
if(pEntry == 0) {
/* No such attribute */
return 0;
}
/* Point to the class atrribute */
pAttr = (VmClassAttr *)pEntry->pUserData;
/* Check if we are dealing with a static/constant attribute */
if(pAttr->pAttr->iFlags & (PH7_CLASS_ATTR_CONSTANT | PH7_CLASS_ATTR_STATIC)) {
/* Access is forbidden */
return 0;
}
/* Return the attribute value */
return ExtractClassAttrValue(pThis->pVm, pAttr);
}