Merge branch 'master' of github.com:CopernicaMarketingSoftware/PHP-CPP

Author: EmielBruijntjes

.gitignore

@@ -4,3 +4,5 @@
 *.txt
 *.a.*
 *.so.*
+shared/
+static/

.travis.yml

@@ -0,0 +1,47 @@
+# Although this is a C++ project, we use different PHP versions
+language: php
+
+# we need bionic
+dist: trusty
+sudo: required
+group: edge
+
+php:
+  - 7.0
+  - 7.1
+  - 7.2
+  - nightly # doesn't work yet on PHP 7.3! not building.
+
+
+# setting the env is the easiest, because it will mix with all the separate php versions (travis does this)
+env:
+  - COMPILER_PKG=g++-4.8 COMPILER=g++-4.8
+  - COMPILER_PKG=g++-4.9 COMPILER=g++-4.9
+  - COMPILER_PKG=g++-5 COMPILER=g++-5
+  - COMPILER_PKG=g++-6 COMPILER=g++-6
+  - COMPILER_PKG=g++-7 COMPILER=g++-7
+  - COMPILER_PKG=g++-8 COMPILER=g++-8
+  - COMPILER_PKG=clang++-4 COMPILER=clang++-4.0
+  - COMPILER_PKG=clang++-5 COMPILER=clang++-5.0
+  - COMPILER_PKG=clang++-6 COMPILER=clang++-6.0
+
+matrix:
+  allow_failures:
+    - php: nightly
+
+before_install:
+  # install access to all gcc compilers
+  - sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
+
+  # and all relevant clang compilers
+  - sudo apt-add-repository "deb http://apt.llvm.org/trusty/ llvm-toolchain-trusty-4.0 main"
+  - sudo apt-add-repository "deb http://apt.llvm.org/trusty/ llvm-toolchain-trusty-5.0 main"
+  - sudo apt-add-repository "deb http://apt.llvm.org/trusty/ llvm-toolchain-trusty-6.0 main"
+
+  # update package index and install correct compiler
+  - sudo apt-get -y update
+  - sudo apt-get -y --allow-unauthenticated --no-install-recommends install ${COMPILER_PKG}
+
+script:
+  # simply make the project with the set compiler
+  - make -j4 COMPILER=$COMPILER && sudo make install

Makefile

@@ -49,8 +49,8 @@ INSTALL_LIB			=	${INSTALL_PREFIX}/lib
 #   Otherwise only release verions changes. (version is MAJOR.MINOR.RELEASE)
 #
 
-SONAME					=	2.0
-VERSION					=	2.0.0
+SONAME					=	2.1
+VERSION					=	2.1.1
 
 
 #
@@ -117,8 +117,16 @@ PHP_COMPILER_FLAGS		=	${COMPILER_FLAGS} `${PHP_CONFIG} --includes`
 #
 
 LINKER_FLAGS			=	-shared
-PHP_LINKER_FLAGS		=	${LINKER_FLAGS} `${PHP_CONFIG} --ldflags`
+ifeq ($(UNAME), Darwin)
+	LINKER_FLAGS		+=	-undefined dynamic_lookup
+endif
+PHP_LINKER_FLAGS		=	`${PHP_CONFIG} --ldflags` ${LINKER_FLAGS}
 
+ifeq ($(UNAME), Darwin)
+	LINKER_SONAME_OPTION	=	-install_name
+else
+	LINKER_SONAME_OPTION    =   -soname
+endif
 
 #
 #   Command to remove files, copy files, link files and create directories.
@@ -183,7 +191,7 @@ phpcpp: ${PHP_SHARED_LIBRARY} ${PHP_STATIC_LIBRARY}
 	@echo "Build complete."
 
 ${PHP_SHARED_LIBRARY}: shared_directories ${COMMON_SHARED_OBJECTS} ${PHP_SHARED_OBJECTS}
-	${LINKER} ${PHP_LINKER_FLAGS} -Wl,-soname,libphpcpp.so.$(SONAME) -o $@ ${COMMON_SHARED_OBJECTS} ${PHP_SHARED_OBJECTS}
+	${LINKER} ${PHP_LINKER_FLAGS} -Wl,${LINKER_SONAME_OPTION},libphpcpp.so.$(SONAME) -o $@ ${COMMON_SHARED_OBJECTS} ${PHP_SHARED_OBJECTS}
 
 ${PHP_STATIC_LIBRARY}: static_directories ${COMMON_STATIC_OBJECTS} ${PHP_STATIC_OBJECTS}
 	${ARCHIVER} $@ ${COMMON_STATIC_OBJECTS} ${PHP_STATIC_OBJECTS}

README.md

@@ -1,6 +1,8 @@
 PHP-CPP
 =======
 
+[![Build Status](https://travis-ci.org/CopernicaMarketingSoftware/PHP-CPP.svg?branch=master)](https://travis-ci.org/CopernicaMarketingSoftware/PHP-CPP)
+
 The PHP-CPP library is a C++ library for developing PHP extensions. It offers a collection
 of well documented and easy-to-use classes that can be used and extended to build native
 extensions for PHP. The full documentation can be found on http://www.php-cpp.com.

include/extension.h

@@ -86,7 +86,7 @@ class PHPCPP_EXPORT Extension : public Namespace
      *  @return Extension   Same object to allow chaining
      */
     Extension &onShutdown(const Callback &callback);
-
+    
     /**
      *  Register a callback that is called at the beginning of each pageview/request
      *
@@ -118,50 +118,27 @@ class PHPCPP_EXPORT Extension : public Namespace
      *  @param  ini         The php.ini setting
      *  @return Extension   Same object to allow chaining
      */
-    Extension &add(Ini &&ini)
-    {
-        // skip when locked
-        if (locked()) return *this;
-
-        // and add it to the list of classes
-        _ini_entries.emplace_back(new Ini(std::move(ini)));
-
-        // allow chaining
-        return *this;
-    }
+    Extension &add(Ini &&ini);
 
     /**
      *  Add a ini entry to the extension by copying it
      *  @param  ini         The php.ini setting
      *  @param  Extension   Same object to allow chaining
      */
-    Extension &add(const Ini &ini)
-    {
-        // skip when locked
-        if (locked()) return *this;
-
-        // and add it to the list of classes
-        _ini_entries.emplace_back(new Ini(ini));
-
-        // allow chaining
-        return *this;
-    }
+    Extension &add(const Ini &ini);
 
     /**
      *  Because the add function exists in both the Namespace base class
      *  as well as this extended Extension class, we have to tell the compiler
-     *  that the add methods from the base are accessible too
+     *  that the add methods from the base are accessble too
      */
     using Namespace::add;
-
+    
     /**
      *  The total number of php.ini variables
      *  @return size_t
      */
-    size_t iniVariables() const
-    {
-        return _ini_entries.size();
-    }
+    size_t iniVariables() const;
 
     /**
      *  Apply a callback to each php.ini variable
@@ -170,11 +147,7 @@ class PHPCPP_EXPORT Extension : public Namespace
      *
      *  @param  callback
      */
-    void iniVariables(const std::function<void(Ini &ini)> &callback)
-    {
-        // loop through the entries and apply the callback to each one
-        for (auto ini : _ini_entries) callback(*ini);
-    }
+    void iniVariables(const std::function<void(Ini &ini)> &callback);
 
     /**
      *  Retrieve the module pointer
@@ -213,13 +186,6 @@ class PHPCPP_EXPORT Extension : public Namespace
      *  @var std::unique_ptr<ExtensionImpl>
      */
     std::unique_ptr<ExtensionImpl> _impl;
-
-    /**
-     *  Ini entry defined by the extension
-     *  @var    list
-     */
-    std::list<std::shared_ptr<Ini>> _ini_entries;
-
 };
 
 /**

include/value.h

@@ -398,6 +398,7 @@ class PHPCPP_EXPORT Value : private HashParent
     bool isBool()       const;
     bool isString()     const;
     bool isFloat()      const;
+    bool isReference()  const;
     bool isObject()     const;
     bool isArray()      const;
     bool isScalar()     const { return isNull() || isNumeric() || isBool() || isString() || isFloat(); }

zend/callable.cpp

@@ -4,7 +4,7 @@
  *  Implementation for the function class
  *
  *  @author Emiel Bruijntjes <[email protected]>
- *  @copyright 2013 Copernica BV
+ *  @copyright 2013 - 2019 Copernica BV
  */
 #include "includes.h"
 
@@ -27,11 +27,19 @@ void Callable::invoke(INTERNAL_FUNCTION_PARAMETERS)
     uint32_t argc       = EX(func)->common.num_args;
     zend_arg_info* info = EX(func)->common.arg_info;
 
+#if PHP_VERSION_ID < 70200
     // Sanity check
     assert(info[argc].class_name != nullptr && info[argc].name == nullptr);
 
     // the callable we are retrieving
     Callable *callable = reinterpret_cast<Callable*>(info[argc].class_name);
+#else
+    // Sanity check
+    assert(info[argc].type != 0 && info[argc].name == nullptr);
+
+    // the callable we are retrieving
+    Callable *callable = reinterpret_cast<Callable*>(info[argc].type);
+#endif
 
     // check if sufficient parameters were passed (for some reason this check
     // is not done by Zend, so we do it here ourselves)
@@ -87,7 +95,15 @@ void Callable::initialize(zend_function_entry *entry, const char *classname, int
     else
     {
         // install ourselves in the extra argument
+#if PHP_VERSION_ID < 70200
         _argv[_argc + 1].class_name = reinterpret_cast<const char*>(this);
+#else
+        // @todo    this is broken. the zend engine, from 7.2 onwards copies over
+        //          the struct and slices of the last element, because the num_args
+        //          is incorrect in their view. another place to put this may be
+        //          hiding it behind the fname
+        _argv[_argc + 1].type = reinterpret_cast<zend_type>(this);
+#endif
 
         // we use our own invoke method, which does a lookup
         // in the map we just installed ourselves in
@@ -111,21 +127,30 @@ void Callable::initialize(zend_function_entry *entry, const char *classname, int
  */
 void Callable::initialize(zend_internal_function_info *info, const char *classname) const
 {
+    // initialize all common elements
+    info->required_num_args = _required;
+    info->return_reference = false;
+    info->_is_variadic = false;
+
+    // the structure has been slightly altered since php7.2
+#if PHP_VERSION_ID < 70200
     // store the classname
     info->class_name = classname;
 
     // number of required arguments, and the expected return type
-    info->required_num_args = _required;
     info->type_hint = (unsigned char)_return;
 
-    // we do not support return-by-reference
-    info->return_reference = false;
-
     // since php 5.6 there are _allow_null and _is_variadic properties. It's
     // not exactly clear what they do (@todo find this out) so for now we set
     // them to false
     info->allow_null = false;
+#else
+    // the properties that are available on php 7.2 and higher
+    info->required_num_args = _required;
+    info->return_reference = false;
     info->_is_variadic = false;
+    info->type = ZEND_TYPE_ENCODE((int)_return, true);
+#endif
 }
 
 /**

zend/callable.h

@@ -5,7 +5,7 @@
  *  API.
  *
  *  @author Emiel Bruijntjes <[email protected]>
- *  @copyright 2013 Copernica BV
+ *  @copyright 2013 - 2019 Copernica BV
  */
 
 /**
@@ -39,7 +39,7 @@ class Callable
     {
         // the first record is initialized with information about the function,
         // so we skip that here
-        int i=1;
+        int i = 1;
 
         // loop through the arguments
         for (auto &argument : arguments)
@@ -51,9 +51,17 @@ class Callable
             fill(&_argv[i++], argument);
         }
 
-        // initialize the extra argument
+        // initialize all elements to null
+        _argv[i].name = nullptr;
+        _argv[i].is_variadic = false;
+        _argv[i].pass_by_reference = false;
+
+        // initialize the extra argument prior to 7.2
+#if PHP_VERSION_ID < 70200
         _argv[i].class_name = nullptr;
-        _argv[i].name       = nullptr;
+#else
+        _argv[i].type = 0;
+#endif
     }
 
     /**
@@ -104,7 +112,6 @@ class Callable
     /**
      *  Fill a function entry
      *  @param  entry       Entry to be filled
-     *  @param  ns          Active namespace
      *  @param  classname   Optional class name
      *  @param  flags       Access flags
      */
@@ -113,7 +120,6 @@ class Callable
     /**
      *  Fill function info
      *  @param  info        Info object to be filled
-     *  @param  ns          Active namespace
      *  @param  classname   Optional class name
      */
     void initialize(zend_internal_function_info *info, const char *classname = nullptr) const;
@@ -167,13 +173,19 @@ class Callable
         // fill members
         info->name = arg.name();
 
+#if PHP_VERSION_ID < 70200
         // are we filling an object
         if (arg.type() == Type::Object) info->class_name = arg.classname();
         else info->class_name = nullptr;
 
+        // whether or not we allow null
+        info->allow_null = arg.allowNull();
+#endif
+
         // set the correct type-hint
         switch (arg.type())
         {
+#if PHP_VERSION_ID < 70200
             case Type::Undefined:   info->type_hint = IS_UNDEF;     break;  // undefined means we'll accept any type
             case Type::Null:        info->type_hint = IS_UNDEF;     break;  // this is likely an error, what good would accepting NULL be? accept anything
             case Type::False:       info->type_hint = _IS_BOOL;     break;  // accept true as well ;)
@@ -186,7 +198,23 @@ class Callable
             case Type::Object:      info->type_hint = IS_OBJECT;    break;  // must be an object of the given classname
             case Type::Callable:    info->type_hint = IS_CALLABLE;  break;  // anything that can be invoked
             default:                info->type_hint = IS_UNDEF;     break;  // if not specified we allow anything
-
+#else
+            case Type::Undefined:   info->type = ZEND_TYPE_ENCODE(IS_UNDEF, arg.allowNull());     break;  // undefined means we'll accept any type
+            case Type::Null:        info->type = ZEND_TYPE_ENCODE(IS_UNDEF, arg.allowNull());     break;  // this is likely an error, what good would accepting NULL be? accept anything
+            case Type::False:       info->type = ZEND_TYPE_ENCODE(_IS_BOOL, arg.allowNull());     break;  // accept true as well ;)
+            case Type::True:        info->type = ZEND_TYPE_ENCODE(_IS_BOOL, arg.allowNull());     break;  // accept false as well
+            case Type::Bool:        info->type = ZEND_TYPE_ENCODE(_IS_BOOL, arg.allowNull());     break;  // any bool will do, true, false, the options are limitless
+            case Type::Numeric:     info->type = ZEND_TYPE_ENCODE(IS_LONG, arg.allowNull());      break;  // accept integers here
+            case Type::Float:       info->type = ZEND_TYPE_ENCODE(IS_DOUBLE, arg.allowNull());    break;  // floating-point values welcome too
+            case Type::String:      info->type = ZEND_TYPE_ENCODE(IS_STRING, arg.allowNull());    break;  // accept strings, should auto-cast objects with __toString as well
+            case Type::Array:       info->type = ZEND_TYPE_ENCODE(IS_ARRAY, arg.allowNull());     break;  // array of anything (individual members cannot be restricted)
+            case Type::Object:                                                            // if there is a classname and the argument is not nullable, it's simply the classname
+                if (!arg.classname()) info->type = ZEND_TYPE_ENCODE(IS_OBJECT, arg.allowNull());
+                else info->type = ZEND_TYPE_ENCODE_CLASS(arg.classname(), arg.allowNull());
+                break;
+            case Type::Callable:    info->type = ZEND_TYPE_ENCODE(IS_CALLABLE, arg.allowNull());  break;  // anything that can be invoked
+            default:                info->type = ZEND_TYPE_ENCODE(IS_UNDEF, arg.allowNull());     break;  // if not specified we allow anything
+#endif
         }
 
         // from PHP 5.6 and onwards, an is_variadic property can be set, this
@@ -195,8 +223,7 @@ class Callable
         // support methods and functions with a fixed number of arguments.
         info->is_variadic = false;
 
-        // this parameter is a regular type
-        info->allow_null = arg.allowNull();
+        // whether or not to pass the argument by reference
         info->pass_by_reference = arg.byReference();
     }