1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
|
/**
* ObjectImpl.h
*
* Implementation class for Base objects that allow the objects to be stored
* in the Zend engine
*
* @author Emiel Bruijntjes <emiel.bruijntjes@copernica.com>
* @copyright 2014 Copernica BV
*/
/**
* Set up namespace
*/
namespace Php {
/**
* Class definition
*/
class ObjectImpl
{
private:
/**
* Structure with a first element which is a zend_object, so that
* it can be casted to a zend_object
* @var MixedObject
*/
struct MixedObject
{
/**
* The actual object is the first member, so that casting
* the MixedObject to a zend_object will also result in a valid pointer
* @var zend_object
*/
zend_object php;
/**
* Pointer to ourselves
* @var ObjectImpl
*/
ObjectImpl *self;
} *_mixed;
/**
* Pointer to the C++ implementation
* @var Base
*/
Base *_object;
/**
* The object handle in the Zend engine
* @var int
*/
int _handle;
public:
/**
* Constructor
*
* This will create a new object in the Zend engine.
*
* @param entry Zend class entry
* @param base C++ object that already exists
* @param refcount The initial refcount for the object
* @param tsrm_ls Optional threading data
*/
ObjectImpl(zend_class_entry *entry, Base *base, int refcount TSRMLS_DC)
{
// allocate a mixed object (for some reason this does not have to be deallocated)
_mixed = (MixedObject *)emalloc(sizeof(MixedObject));
// copy properties to the mixed object
_mixed->php.ce = entry;
_mixed->self = this;
// store the c++ object
_object = base;
// initialize the object
zend_object_std_init(&_mixed->php, entry TSRMLS_CC);
#if PHP_VERSION_ID < 50399
// tmp variable
zval *tmp;
// initialize the properties, php 5.3 way
zend_hash_copy(_mixed->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(&_mixed->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(php(), (zend_objects_store_dtor_t)destructMethod, (zend_objects_free_object_storage_t)freeMethod, NULL TSRMLS_CC);
// set the initial refcount (if it is different than one, because one is the default)
if (refcount != 1) EG(objects_store).object_buckets[_handle].bucket.obj.refcount = refcount;
// the object may remember that we are its implementation object
base->_impl = this;
}
/**
* Destructor
*/
virtual ~ObjectImpl()
{
// deallocate the cpp object
if (_object) delete _object;
}
/**
* Destruct the object
* @param tsrm_ls
*/
void destruct(TSRMLS_D)
{
// pass on to the default destructor
zend_objects_free_object_storage(php() TSRMLS_CC);
// destruct the object
delete this;
}
/**
* Find the object based on a zval
* @param val Zval object
* @param tsrm_ls Optional pointer to thread info
* @return ObjectImpl
*/
static ObjectImpl *find(zval *val TSRMLS_DC)
{
// retrieve the old object, which we are going to copy
MixedObject *object = (MixedObject *)zend_object_store_get_object(val TSRMLS_CC);
// done
return object->self;
}
/**
* Find the object based on a zend_object
* @param object Zend object pointer
* @return ObjectImpl
*/
static ObjectImpl *find(const zend_object *object)
{
// retrieve the old object, which we are going to copy
const MixedObject *mixed = (const MixedObject *)object;
// done
return mixed->self;
}
/**
* Retrieve the base class of the original C++ object
* @return Base
*/
Base *object() const
{
return _object;
}
/**
* Pointer to the PHP object
* @return zend_object
*/
zend_object *php() const
{
return &_mixed->php;
}
/**
* Retrieve the handle object
* @return int
*/
int handle() const
{
return _handle;
}
};
/**
* End of namespace
*/
}
|
