Changed default visibility for symbols in the PHP-CPP library to hidden and explicitly exported all symbols available from the public API. Moved the hiddenpointer to the zend implementation directory as it is not meant to be used publicly and not referenced anywhere from the API anyway

2 files changed, 184 insertions, 1 deletions

diff --git a/zend/hiddenpointer.h b/zend/hiddenpointer.h
new file mode 100644
index 0000000..d2636e3
--- /dev/null
+++ b/zend/hiddenpointer.h
@@ -0,0 +1,182 @@
+/**
+ *  HiddenPointer.h
+ *
+ *  Helper class that we use to hide a pointer in a string. We do this
+ *  by creating a string buffer that is a littlebit bigger, and put
+ *  the hidden pointer in front of the name
+ *
+ *  @author Emiel Bruijntjes <emiel.bruijntjes@copernica.com>
+ *  @copyright 2013 Copernica BV
+ */
+
+/**
+ *  Set up namespace
+ */
+namespace Php {
+
+/**
+ *  Class definition
+ */
+template <typename Type>
+class HiddenPointer
+{
+public:
+    /**
+     *  Constructor to hide the pointer in a buffer
+     *  @param  pointer     The pointer to hide
+     *  @param  text        The visible text
+     *  @param  size        Optional text size
+     */
+    HiddenPointer(Type *pointer, const char *text, int size=-1)
+    {
+        // calculate size of the text
+        if (size < 0) size = ::strlen(text);
+
+        // allocate data + trailing null + size of pointer
+        char *buffer = new char[size + 1 + sizeof(Type *)];
+
+        // copy pointer into the buffer
+        memcpy(buffer, &pointer, sizeof(Type *));
+        
+        // copy the name into the buffer
+        memcpy(buffer + sizeof(Type *), text, size + 1);
+        
+        // store in member
+        _buffer = buffer;
+    }
+    
+    /**
+     *  Hide pointer in buffer
+     *  @param  pointer
+     *  @param  text
+     */
+    HiddenPointer(Type *pointer, const std::string &text) : 
+        HiddenPointer(pointer, text.c_str(), text.size()) {}
+
+    /**
+     *  Constructor to retrieve the object given a buffer
+     *  @param  text        The visible text
+     */
+    HiddenPointer(const char *text) : 
+        _buffer(text - sizeof(Type *)), // the buffer starts before the actual text
+        _allocated(false) {}            // no memory was allocated
+    
+    /**
+     *  Copy constructor
+     *  @param  that
+     */
+    HiddenPointer(const HiddenPointer<Type> &that) : _allocated(that._allocated)
+    {
+        // is the other object allocated?
+        if (_allocated)
+        {
+            // allocate this object too, call other constructor
+            HiddenPointer(that, that);
+        }
+        else
+        {
+            // just copy the data
+            _buffer = that._buffer;
+        }
+    }
+    
+    /**
+     *  Move constructor
+     *  @param  that
+     */
+    HiddenPointer(HiddenPointer<Type> &&that) _NOEXCEPT : _allocated(that._allocated), _buffer(that._buffer)
+    {
+        // the other object is no longer allocated
+        that._allocated = false;
+    }
+    
+    /**
+     *  Destructor
+     */
+    virtual ~HiddenPointer() 
+    {
+        // destruct data
+        if (_allocated) delete[] _buffer;
+    }
+    
+    /**
+     *  Assignment operator
+     *  @param  that
+     *  @return HiddenPointer
+     */
+    HiddenPointer<Type> &operator=(const HiddenPointer &that)
+    {
+        // skip self assignmend
+        if (this == &that) return *this;
+        
+        // deallocate current object
+        if (_allocated) delete[] _buffer;
+        
+        // copy allocated setting
+        _allocated = that._allocated;
+        
+        // is the other object allocated?
+        if (_allocated)
+        {
+            // allocate this object too, call constructor
+            HiddenPointer(that, that);
+        }
+        else
+        {
+            // just copy the data
+            _buffer = that._buffer;
+        }
+        
+        // done
+        return *this;
+    }
+    
+    /**
+     *  Retrieve the pointer
+     *  @return Type*
+     */
+    operator Type * () const
+    {
+        // type is stored in front of the buffer
+        return *((Type **)_buffer);
+    }
+    
+    /**
+     *  Retrieve the text
+     *  @return const char *
+     */
+    operator const char * () const
+    {
+        // name starts a number of bytes further
+        return _buffer + sizeof(Type *);
+    }
+    
+    /**
+     *  Derefence the pointer
+     *  @return Type*
+     */
+    Type *operator->() const
+    {
+        // type is stored in front of the buffer
+        return *((Type **)_buffer);
+    }
+    
+private:
+    /**
+     *  Buffer that holds both the pointer and the text - the text starts
+     *  a number of bytes further up
+     *  @var buffer
+     */
+    const char *_buffer = nullptr;
+
+    /**
+     *  Was this allocated?
+     *  @var bool
+     */
+    bool _allocated = true;
+};
+
+/**
+ *  End of namespace
+ */
+}
diff --git a/zend/includes.h b/zend/includes.h
index c092a07..aed5ed0 100644
--- a/zend/includes.h
+++ b/zend/includes.h
@@ -47,6 +47,7 @@
 /**
  *  Include other files from this library
  */
+#include "../include/visibility.h"
 #include "../include/noexcept.h"
 #include "../include/platform.h"
 #include "../include/version.h"
@@ -61,7 +62,6 @@
 #include "../include/valueiterator.h"
 #include "../include/array.h"
 #include "../include/object.h"
-#include "../include/hiddenpointer.h"
 #include "../include/globals.h"
 #include "../include/argument.h"
 #include "../include/byval.h"
@@ -98,6 +98,7 @@
 /**
  *  Specific zend implementation  files for internal use only
  */
+#include "hiddenpointer.h"
 #include "init.h"
 #include "callable.h"
 #include "nativefunction.h"