merged changes

EmielBruijntjes · EmielBruijntjes · commit 94003aa2fe92 · 2016-10-02T18:36:54.000+02:00
diff --git a/.clang_complete b/.clang_complete
diff --git a/Makefile b/Makefile
@@ -17,8 +17,8 @@
 #   installed in the default directory, you can change that here.
 #
 
-PHP_CONFIG				=	php-config
-
+PHP_CONFIG			=	php-config
+UNAME 				:= 	$(shell uname)
 
 #
 #   Installation directory
@@ -30,9 +30,16 @@ PHP_CONFIG				=	php-config
 #   and /usr/local/lib. You can of course change it to whatever suits you best
 #
 
-INSTALL_PREFIX			=	/usr
+# Since OSX 10.10 Yosemite, /usr/include gives problem
+# So, let's switch to /usr/local as default instead.
+ifeq ($(UNAME), Darwin)
+  INSTALL_PREFIX		=	/usr/local
+else
+  INSTALL_PREFIX		=	/usr
+endif
+
 INSTALL_HEADERS			=	${INSTALL_PREFIX}/include
-INSTALL_LIB				=	${INSTALL_PREFIX}/lib
+INSTALL_LIB			=	${INSTALL_PREFIX}/lib
 
 
 #
@@ -204,6 +211,7 @@ ${PHP_STATIC_OBJECTS}:
 
 install:
 	${MKDIR} ${INSTALL_HEADERS}/phpcpp
+	${MKDIR} ${INSTALL_LIB}
 	${CP} phpcpp.h ${INSTALL_HEADERS}
 	${CP} include/*.h ${INSTALL_HEADERS}/phpcpp
 	if [ -e ${PHP_SHARED_LIBRARY} ]; then \
@@ -218,3 +226,7 @@ install:
 		sudo ldconfig; \
 	fi
 
+uninstall:
+	${RM} ${INSTALL_HEADERS}/phpcpp*
+	${RM} ${INSTALL_LIB}/libphpcpp.*
+
diff --git a/common/modifiers.cpp b/common/modifiers.cpp
@@ -30,7 +30,7 @@ const int Const     =   0;
 /**
  *  Modifiers that are supported for methods and properties
  */
-const int MethodModifiers           =   Final | Public | Protected | Private;
+const int MethodModifiers           =   Final | Public | Protected | Private | Static;
 const int PropertyModifiers         =   Final | Public | Protected | Private | Const | Static;
 
 /**
diff --git a/documentation/classes-and-objects.html b/documentation/classes-and-objects.html
@@ -118,7 +118,7 @@ <h1>Classes and objects</h1>
 <p>
     To make the class accessible from PHP, you must add it to the extension
     object inside the get_module() function. The Php::Class template class should be 
-    be used for that. The template parameter should be your 
+    used for that. The template parameter should be your 
     implementation class, so that the Php::Class object internally knows which 
     class to instantiate the moment the "new" operator is used inside a PHP script.
 </p>
diff --git a/documentation/lambda-functions.html b/documentation/lambda-functions.html
@@ -209,7 +209,7 @@ <h2>Calling anonymous PHP functions from C++</h2>
     object: you can assign it to other Php::Value objects, and you
     can use it as a parameter when you call user space PHP functions.
     In the above example we do exactly that: we call the user space
-    my_iterate() function with our own 'multiply_by_two' C++ function.
+    my_array_map() function with our own 'multiply_by_two' C++ function.
 </p>
 <h2>Signature of the C++ function</h2>
 <p>
diff --git a/include/class.h b/include/class.h
@@ -109,14 +109,14 @@ class PHPCPP_EXPORT Class : private ClassBase
      *  @param  args        Argument descriptions
      *  @return Class       Same object to allow chaining
      */
-    template <void  (*callback)()                               >   Class<T> &method(const char *name, int flags,   const Arguments &args = {}) { ClassBase::method(name, &ZendCallable::invoke<callback>, flags,  args); return *this; }
-    template <Value (*callback)()                               >   Class<T> &method(const char *name, int flags,   const Arguments &args = {}) { ClassBase::method(name, &ZendCallable::invoke<callback>, flags,  args); return *this; }
-    template <void  (*callback)(Parameters &parameters)         >   Class<T> &method(const char *name, int flags,   const Arguments &args = {}) { ClassBase::method(name, &ZendCallable::invoke<callback>, flags,  args); return *this; }
-    template <Value (*callback)(Parameters &parameters)         >   Class<T> &method(const char *name, int flags,   const Arguments &args = {}) { ClassBase::method(name, &ZendCallable::invoke<callback>, flags,  args); return *this; }
-    template <void  (*callback)()                               >   Class<T> &method(const char *name,              const Arguments &args = {}) { ClassBase::method(name, &ZendCallable::invoke<callback>, Public, args); return *this; }
-    template <Value (*callback)()                               >   Class<T> &method(const char *name,              const Arguments &args = {}) { ClassBase::method(name, &ZendCallable::invoke<callback>, Public, args); return *this; }
-    template <void  (*callback)(Parameters &parameters)         >   Class<T> &method(const char *name,              const Arguments &args = {}) { ClassBase::method(name, &ZendCallable::invoke<callback>, Public, args); return *this; }
-    template <Value (*callback)(Parameters &parameters)         >   Class<T> &method(const char *name,              const Arguments &args = {}) { ClassBase::method(name, &ZendCallable::invoke<callback>, Public, args); return *this; }
+    template <void  (*callback)()                               >   Class<T> &method(const char *name, int flags,   const Arguments &args = {}) { ClassBase::method(name, &ZendCallable::invoke<callback>, Static | flags,  args); return *this; }
+    template <Value (*callback)()                               >   Class<T> &method(const char *name, int flags,   const Arguments &args = {}) { ClassBase::method(name, &ZendCallable::invoke<callback>, Static | flags,  args); return *this; }
+    template <void  (*callback)(Parameters &parameters)         >   Class<T> &method(const char *name, int flags,   const Arguments &args = {}) { ClassBase::method(name, &ZendCallable::invoke<callback>, Static | flags,  args); return *this; }
+    template <Value (*callback)(Parameters &parameters)         >   Class<T> &method(const char *name, int flags,   const Arguments &args = {}) { ClassBase::method(name, &ZendCallable::invoke<callback>, Static | flags,  args); return *this; }
+    template <void  (*callback)()                               >   Class<T> &method(const char *name,              const Arguments &args = {}) { ClassBase::method(name, &ZendCallable::invoke<callback>, Static | Public, args); return *this; }
+    template <Value (*callback)()                               >   Class<T> &method(const char *name,              const Arguments &args = {}) { ClassBase::method(name, &ZendCallable::invoke<callback>, Static | Public, args); return *this; }
+    template <void  (*callback)(Parameters &parameters)         >   Class<T> &method(const char *name,              const Arguments &args = {}) { ClassBase::method(name, &ZendCallable::invoke<callback>, Static | Public, args); return *this; }
+    template <Value (*callback)(Parameters &parameters)         >   Class<T> &method(const char *name,              const Arguments &args = {}) { ClassBase::method(name, &ZendCallable::invoke<callback>, Static | Public, args); return *this; }
 
     /**
      *  Add a regular method to the class
diff --git a/include/value.h b/include/value.h
@@ -380,13 +380,13 @@ class PHPCPP_EXPORT Value : private HashParent
      *  Check if the value is of a certain type
      *  @return bool
      */
-    bool isNull()       const { return type() == Type::Null; }
-    bool isNumeric()    const { return type() == Type::Numeric; }
-    bool isBool()       const { return type() == Type::False || type() == Type::True; }
-    bool isString()     const { return type() == Type::String; }
-    bool isFloat()      const { return type() == Type::Float; }
-    bool isObject()     const { return type() == Type::Object; }
-    bool isArray()      const { return type() == Type::Array; }
+    bool isNull()       const;
+    bool isNumeric()    const;
+    bool isBool()       const;
+    bool isString()     const;
+    bool isFloat()      const;
+    bool isObject()     const;
+    bool isArray()      const;
     bool isScalar()     const { return isNull() || isNumeric() || isBool() || isString() || isFloat(); }
     bool isCallable()   const;
 
diff --git a/include/zval.h b/include/zval.h
@@ -67,6 +67,13 @@ class Zval
         // reinterpret and dereference
         return *const_cast<struct _zval_struct*>(reinterpret_cast<const struct _zval_struct*>(&_buffer));
     }
+
+    /**
+     *  In case this is a reference, dereference it into a zval.. In case it isn't
+     *  the actual value is returned.
+     *  @return struct _zval_struct*
+     */
+    struct _zval_struct *dereference() const;
 };
 
 /**
diff --git a/zend/classimpl.cpp b/zend/classimpl.cpp
@@ -825,12 +825,6 @@ zval *ClassImpl::toZval(Value &&value, int type, zval *rv)
     // if the zval has a reference count we must decrease it
     Z_TRY_DELREF_P(result);
 
-    // the pointer from the value may now be destroyed
-    // (it was allocated by the value and detached)
-    // we do not actually "destroy" the value here,
-    // even if the refcount reaches 0 here!
-    delete result;
-
     // return the pointer to the value
     return rv;
 }
diff --git a/zend/inivalue.cpp b/zend/inivalue.cpp
@@ -18,7 +18,7 @@ namespace Php {
  */
 int64_t IniValue::numericValue() const
 {
-    return zend_ini_long(const_cast<char*>(_name.c_str()), _name.size()+1, _isorig);
+    return zend_ini_long(const_cast<char*>(_name.c_str()), _name.size(), _isorig);
 
 }
 
@@ -28,7 +28,7 @@ int64_t IniValue::numericValue() const
  */
 const char* IniValue::rawValue() const
 {
-    return zend_ini_string(const_cast<char*>(_name.c_str()), _name.size()+1, _isorig);
+    return zend_ini_string(const_cast<char*>(_name.c_str()), _name.size(), _isorig);
 }
 
 /**
@@ -37,7 +37,7 @@ const char* IniValue::rawValue() const
  */
 IniValue::operator double() const
 {
-    return zend_ini_double(const_cast<char*>(_name.c_str()), _name.size()+1, _isorig);
+    return zend_ini_double(const_cast<char*>(_name.c_str()), _name.size(), _isorig);
 }
 
 /**
diff --git a/zend/value.cpp b/zend/value.cpp
@@ -950,6 +950,100 @@ Type Value::type() const
     return (Type)Z_TYPE_P(_val);
 }
 
+/**
+ *  Are we null? This will also check if we're a reference to a null value
+ *  @return bool
+ */
+bool Value::isNull() const
+{
+    // if we're null we simply return true
+    if (type() == Type::Null) return true;
+
+    // derefence ourselves and check the type of that
+    return ((Type) Z_TYPE_P(_val.dereference())) == Type::Null;
+}
+
+/**
+ *  Are we a number? This will also check if we're a reference to a number
+ *  @return bool
+ */
+bool Value::isNumeric() const
+{
+    // if we're a number we simply return true
+    if (type() == Type::Numeric) return true;
+
+    // derefence ourselves and check the type of that
+    return ((Type) Z_TYPE_P(_val.dereference())) == Type::Numeric;
+}
+
+/**
+ *  Are we a boolean? This will also check if we're a reference to a boolean
+ *  @return bool
+ */
+bool Value::isBool() const
+{
+    // if we're a true or false type right away we just return true
+    if (type() == Type::False || type() == Type::True) return true;
+
+    // retrieve the type
+    auto type = ((Type) Z_TYPE_P(_val.dereference()));
+
+    // are we a true or false type?
+    return type == Type::True || type == Type::False;
+}
+
+/**
+ *  Are we a string? This will also check if we're a reference to a string
+ *  @return bool
+ */
+bool Value::isString() const
+{
+    // if we're a string we just return true right away
+    if (type() == Type::String) return true;
+
+    // derefence ourselves and check the type of that
+    return ((Type) Z_TYPE_P(_val.dereference())) == Type::String;
+}
+
+/**
+ *  Are we a float? This will also check if we're a reference to a float
+ *  @return bool
+ */
+bool Value::isFloat() const
+{
+    // if we're a float ourselves we just return true right away
+    if (type() == Type::Float) return true;
+
+    // derefence ourselves and check the type of that
+    return ((Type) Z_TYPE_P(_val.dereference())) == Type::Float;
+}
+
+/**
+ *  Are we an object? This will also check if we're a reference to an object
+ *  @return bool
+ */
+bool Value::isObject() const
+{
+    // if we're an object right away we just return true
+    if (type() == Type::Object) return true;
+
+    // derefence ourselves and check the type of that
+    return ((Type) Z_TYPE_P(_val.dereference())) == Type::Object;
+}
+
+/**
+ *  Are we an array? This will also check if we're a reference to an array
+ *  @return bool
+ */
+bool Value::isArray() const
+{
+    // if we're directly an array we just return true
+    if (type() == Type::Array) return true;
+
+    // check the type of the dereference
+    return ((Type) Z_TYPE_P(_val.dereference())) == Type::Array;
+}
+
 /**
  *  Change the internal type
  *  @param  type
@@ -1295,7 +1389,7 @@ std::map<std::string,Php::Value> Value::mapValue() const
 ValueIterator Value::createIterator(bool begin) const
 {
     // check type
-    if (isArray()) return ValueIterator(new HashIterator(Z_ARRVAL_P(_val), begin, true));
+    if (isArray()) return ValueIterator(new HashIterator(Z_ARRVAL_P(_val.dereference()), begin, true));
 
     // get access to the hash table
     if (isObject())
@@ -1372,7 +1466,7 @@ bool Value::contains(int index) const
     else if (!isArray()) return false;
 
     // check if this index is already in the array
-    return zend_hash_index_find(Z_ARRVAL_P(_val), index) != nullptr;
+    return zend_hash_index_find(Z_ARRVAL_P(_val.dereference()), index) != nullptr;
 }
 
 /**
@@ -1390,7 +1484,7 @@ bool Value::contains(const char *key, int size) const
     if (isArray())
     {
         // check if index is already in the array
-        return zend_hash_find(Z_ARRVAL_P(_val), String(key, size)) != nullptr;
+        return zend_hash_find(Z_ARRVAL_P(_val.dereference()), String(key, size)) != nullptr;
     }
     else if (isObject())
     {
@@ -1432,7 +1526,7 @@ Value Value::get(int index) const
     if (isArray())
     {
         // retrieve the value
-        auto *result = zend_hash_index_find(Z_ARRVAL_P(_val), index);
+        auto *result = zend_hash_index_find(Z_ARRVAL_P(_val.dereference()), index);
 
         // did the offset exist?
         if (!result) return Type::Undefined;
@@ -1463,8 +1557,11 @@ Value Value::get(const char *key, int size) const
     // are we in an object or an array?
     if (isArray())
     {
-        // find the result and wrap it in a value
-        return Value(zend_hash_find(Z_ARRVAL_P(_val), String(key, size)));
+        // find the result
+        auto val = zend_hash_find(Z_ARRVAL_P(_val.dereference()), String(key, size));
+
+        // wrap it in a value if it isn't null, otherwise return an empty value
+        return val ? Value(val) : Value();
     }
     else
     {
@@ -1516,7 +1613,7 @@ void Value::set(int index, const Value &value)
     zval *current;
 
     // check if this index is already in the array, otherwise we return NULL
-    if (isArray() && (current = zend_hash_index_find(Z_ARRVAL_P(_val), index)))
+    if (isArray() && (current = zend_hash_index_find(Z_ARRVAL_P(_val.dereference()), index)))
     {
         // skip if nothing is going to change
         if (value._val == current) return;
@@ -1558,7 +1655,7 @@ void Value::setRaw(const char *key, int size, const Value &value)
         SEPARATE_ZVAL_IF_NOT_REF(_val);
 
         // add the value (this will reduce the refcount of the current value)
-        add_assoc_zval_ex(_val, key, size+1, value._val);
+        add_assoc_zval_ex(_val, key, size, value._val);
 
         // the variable has one more reference (the array entry)
         Z_TRY_ADDREF_P(value._val);
@@ -1578,7 +1675,7 @@ void Value::set(const char *key, int size, const Value &value)
     zval *current;
 
     // check if this index is already in the array, otherwise we return NULL
-    if (isArray() && (current = zend_hash_find(Z_ARRVAL_P(_val), String(key, size))))
+    if (isArray() && (current = zend_hash_find(Z_ARRVAL_P(_val.dereference()), String(key, size))))
     {
         // skip if nothing is going to change
         if (value._val == current) return;
@@ -1604,7 +1701,7 @@ void Value::unset(int index)
     SEPARATE_ZVAL_IF_NOT_REF(_val);
 
     // remove the index
-    zend_hash_index_del(Z_ARRVAL_P(_val), index);
+    zend_hash_index_del(Z_ARRVAL_P(_val.dereference()), index);
 }
 
 /**
@@ -1632,7 +1729,7 @@ void Value::unset(const char *key, int size)
         SEPARATE_ZVAL_IF_NOT_REF(_val);
 
         // remove the index
-        zend_hash_del(Z_ARRVAL_P(_val), String(key, size));
+        zend_hash_del(Z_ARRVAL_P(_val.dereference()), String(key, size));
     }
 }
 
diff --git a/zend/zval.cpp b/zend/zval.cpp

Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ namespace Php {`
`18`	`18`	`*/`
`19`	`19`	`int64_t IniValue::numericValue() const`
`20`	`20`	`{`
`21`		`- return zend_ini_long(const_cast<char*>(_name.c_str()), _name.size()+1, _isorig);`
	`21`	`+ return zend_ini_long(const_cast<char*>(_name.c_str()), _name.size(), _isorig);`
`22`	`22`
`23`	`23`	`}`
`24`	`24`
`@@ -28,7 +28,7 @@ int64_t IniValue::numericValue() const`
`28`	`28`	`*/`
`29`	`29`	`const char* IniValue::rawValue() const`
`30`	`30`	`{`
`31`		`- return zend_ini_string(const_cast<char*>(_name.c_str()), _name.size()+1, _isorig);`
	`31`	`+ return zend_ini_string(const_cast<char*>(_name.c_str()), _name.size(), _isorig);`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`/**`
`@@ -37,7 +37,7 @@ const char* IniValue::rawValue() const`
`37`	`37`	`*/`
`38`	`38`	`IniValue::operator double() const`
`39`	`39`	`{`
`40`		`- return zend_ini_double(const_cast<char*>(_name.c_str()), _name.size()+1, _isorig);`
	`40`	`+ return zend_ini_double(const_cast<char*>(_name.c_str()), _name.size(), _isorig);`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`/**`