renamed src directory to zend directory, disabled TSRM debug code

1 files changed, 287 insertions, 0 deletions

diff --git a/zend/base.cpp b/zend/base.cpp
new file mode 100644
index 0000000..5d15011
--- /dev/null
+++ b/zend/base.cpp
@@ -0,0 +1,287 @@
+/**
+ *  Base.cpp
+ *
+ *  Implementation file for the base of all classes
+ *
+ *  @copyright 2014 Copernica BV
+ */
+#include "includes.h"
+
+/**
+ *  Set up namespace
+ */
+namespace Php {
+
+/**
+ *  Store the object in the PHP object cache
+ *  @param  entry               Class entry
+ *  @param  tsrm_ls
+ *  @return MixedObject
+ */
+//MixedObject *Base::store(zend_class_entry *entry TSRMLS_DC)
+//{
+//    // allocate memory for the object
+//    MixedObject *result = (MixedObject *)emalloc(sizeof(MixedObject));
+//    
+//    // store the new c++ object
+//    result->cpp = this;
+//    
+//    // store the class entry in the newly created object
+//    result->php.ce = entry;
+//    
+//    // initialize the object
+//    zend_object_std_init(&result->php, entry TSRMLS_CC);
+//
+//#if PHP_VERSION_ID < 50399
+//
+//    // tmp variable
+//    zval *tmp;
+//    
+//    // initialize the properties, php 5.3 way
+//    zend_hash_copy(result->php.properties, &entry->default_properties, (copy_ctor_func_t) zval_property_ctor, &tmp, sizeof(zval*));
+//
+//#else
+//
+//    // version higher than 5.3 have an easier way to initialize
+//    object_properties_init(&result->php, entry);
+//
+//#endif    
+//
+//#ifdef ZTS
+//
+//    // when in thread safety mode, the destruct method and free method have
+//    // an extra parameter holding thread information
+//    using DestructType = void(zend_object*,unsigned int,void***);
+//    using FreeType = void(zend_object*,void***);
+//    
+//#else
+//
+//    // not in thread mode: no special parameter for the tsrm_ls variable
+//    using DestructType = void(zend_object*,unsigned int);
+//    using FreeType = void(zend_object*);
+//    
+//#endif
+//    
+//    // store the two destruct methods in temporary vars
+//    DestructType *destructMethod = &ClassImpl::destructObject;
+//    FreeType *freeMethod = &ClassImpl::freeObject;
+//
+//    // the destructor and clone handlers are set to NULL. I dont know why, but they do not
+//    // seem to be necessary...
+//    _handle = zend_objects_store_put(result, (zend_objects_store_dtor_t)destructMethod, (zend_objects_free_object_storage_t)freeMethod, NULL TSRMLS_CC);
+//    
+//    // done
+//    return result;
+//}
+
+/**
+ *  Overridable method that is called right before an object is destructed
+ */
+void Base::__destruct() const
+{
+    // throw exception, so that the PHP-CPP library will check if the user
+    // somehow registered an explicit __destruct method
+    throw NotImplemented();
+}
+
+/**
+ *  Overridable method that is called to check if a property is set
+ * 
+ *  The default implementation does nothing, and the script will fall back
+ *  to accessing the regular object properties
+ * 
+ *  @param  key
+ *  @return bool
+ */
+bool Base::__isset(const Php::Value &key) const
+{
+    // throw an exception that will be caught in the ClassBase class, 
+    // so that the default implementation of the unset function can be called
+    throw NotImplemented();
+}
+
+/**
+ *  Overridable method that is called to set a new property
+ * 
+ *  The default implementation does nothing, and the script will fall back
+ *  to accessing the regular object properties
+ * 
+ *  @param  key
+ *  @param  value
+ */
+void Base::__set(const Php::Value &key, const Php::Value &value) const
+{
+    // throw an exception that will be caught in the ClassBase class, 
+    // so that the default implementation of the unset function can be called
+    throw NotImplemented();
+}
+
+/**
+ *  Retrieve a property
+ * 
+ *  The default implementation does nothing, and the script will fall back
+ *  to accessing the regular object properties
+ * 
+ *  @param  key
+ *  @return value
+ */
+Php::Value Base::__get(const Php::Value &key) const
+{
+    // throw an exception that will be caught in the ClassBase class, 
+    // so that the default implementation of the function can be called
+    throw NotImplemented();
+    
+    // unreachable code
+    return nullptr;
+}
+
+/**
+ *  Remove a member
+ * 
+ *  The default implementation does nothing, and the script will fall back
+ *  to accessing the regular object properties
+ * 
+ *  @param key
+ */
+void Base::__unset(const Php::Value &key) const
+{
+    // throw an exception that will be caught in the ClassBase class, 
+    // so that the default implementation of the function can be called
+    throw NotImplemented();
+}
+
+/**
+ *  Call a method
+ * 
+ *  This method is called when a method is called from the PHP script that
+ *  was not explicitly defined. You can use this to catch variable method
+ *  names, or to support all thinkable method names.
+ * 
+ *  @param  method      Name of the method that was called
+ *  @param  params      The parameters that were passed to the function
+ *  @return Value       The return value
+ */
+Value Base::__call(const char *method, Parameters &params) const
+{
+    // throw an exception that will be caught in the ClassBase class, 
+    // so that the default implementation of the function can be called
+    throw NotImplemented();
+    
+    // unreachable code
+    return nullptr;
+}
+
+/**
+ *  Call the class as if it was a function
+ * 
+ *  This method is called when a an object is used with () operators:
+ *  $object(). You can override this method to make objects callable.
+ * 
+ *  @param  params      The parameters that were passed to the function
+ *  @return Value       The return value
+ */
+Value Base::__invoke(Parameters &params) const
+{
+    // throw an exception that will be caught in the ClassBase class, 
+    // so that the default implementation of the function can be called
+    throw NotImplemented();
+    
+    // unreachable code
+    return nullptr;
+}
+
+/**
+ *  Cast the object to a string
+ * 
+ *  This method is called when an object is casted to a string, or when
+ *  it is used in a string context
+ * 
+ *  @return Value       The object as a string
+ */
+Value Base::__toString() const
+{
+    // throw an exception that will be caught in the ClassBase class, 
+    // so that the default implementation of the function can be called
+    throw NotImplemented();
+    
+    // unreachable code
+    return nullptr;
+}    
+
+/**
+ *  Cast the object to an integer
+ * 
+ *  This method is called when an object is casted to an integer, or when
+ *  it is used in an integer context
+ * 
+ *  @return int         Integer value
+ */
+Value Base::__toInteger() const
+{
+    // throw an exception that will be caught in the ClassBase class, 
+    // so that the default implementation of the function can be called
+    throw NotImplemented();
+    
+    // unreachable code
+    return 0;
+}
+
+/**
+ *  Cast the object to a float
+ * 
+ *  This method is called when an object is casted to a float, or when it
+ *  is used in a float context
+ * 
+ *  @return double      Floating point value
+ */
+Value Base::__toFloat() const
+{
+    // throw an exception that will be caught in the ClassBase class, 
+    // so that the default implementation of the function can be called
+    throw NotImplemented();
+    
+    // unreachable code
+    return 0.0;
+}
+
+/**
+ *  Cast the object to a boolean
+ * 
+ *  This method is called when an object is casted to a bool, or when it
+ *  is used in a boolean context
+ * 
+ *  @return bool
+ */
+Value Base::__toBool() const
+{
+    // throw an exception that will be caught in the ClassBase class, 
+    // so that the default implementation of the function can be called
+    throw NotImplemented();
+    
+    // unreachable code
+    return false;
+}
+
+/**
+ *  Compare the object with a different object
+ *  
+ *  Check how a different object compares to this object
+ * 
+ *  @param  that        Object to compare with
+ *  @return int
+ */
+int Base::__compare(const Base &that) const
+{
+    // throw an exception that will be caught in the ClassBase class, 
+    // so that the default implementation of the function can be called
+    throw NotImplemented();
+    
+    // unreachable code
+    return 1;
+}
+
+/**
+ *  End namespace
+ */
+}
+