jyapayne/swig
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

[PHP] Add support for PHP7.

Browse source 
PHP5's C extension API has changed substantially so you need to use
-php7 to specify you want PHP7 compatible wrappers.
Fixes https://github.com/swig/swig/issues/571
This commit is contained in:
Olly Betts 2016-11-30 13:05:59 +13:00
commit 1169874f59
202 changed files with 11575 additions and 719 deletions
Download patch file Download diff file Expand all files Collapse all files

13
Lib/php/const.i
View file

@ -33,18 +33,13 @@
SWIGTYPE &,
SWIGTYPE &&,
SWIGTYPE [] {
zval *z_var;
zend_constant c;
size_t len = sizeof("$symname") - 1;
MAKE_STD_ZVAL(z_var);
SWIG_SetPointerZval(z_var, (void*)$value, $1_descriptor, 0);
c.value = *z_var;
SWIG_SetPointerZval(&c.value, (void*)$value, $1_descriptor, 0);
zval_copy_ctor(&c.value);
c.name = zend_strndup("$symname", len);
c.name_len = len+1;
c.flags = CONST_CS | CONST_PERSISTENT;
c.name = zend_string_init("$symname", sizeof("$symname") - 1, 0);
c.flags = CONST_CS;
c.module_number = module_number;
zend_register_constant( &c TSRMLS_CC );
zend_register_constant(&c);
}
/* Handled as a global variable. */

68
Lib/php/director.swg
View file

@ -77,30 +77,30 @@ namespace Swig {
class Director {
protected:
zval *swig_self;
// "mutable" so we can get a non-const pointer to it in const methods.
mutable zval swig_self;
typedef std::map<void *, GCItem_var> swig_ownership_map;
mutable swig_ownership_map swig_owner;
#ifdef ZTS
// Store the ZTS context so it's available when C++ calls back to PHP.
void *** swig_zts_ctx;
#endif
public:
Director(zval *self TSRMLS_DC) : swig_self(self) {
TSRMLS_SET_CTX(swig_zts_ctx);
Director(zval *self) {
ZVAL_COPY_VALUE(&swig_self, self);
}
static bool swig_is_overridden_method(char *cname, char *lc_fname TSRMLS_DC) {
zend_class_entry **ce;
zend_function *mptr;
if (zend_lookup_class(cname, strlen(cname), &ce TSRMLS_CC) != SUCCESS) {
return false;
static bool swig_is_overridden_method(const char *cname, const char *lc_fname) {
bool result = false;
zend_string * cname_str = zend_string_init(cname, strlen(cname), 0);
zend_class_entry *ce = zend_lookup_class(cname_str);
if (ce) {
zval * mptr = zend_hash_str_find(&ce->function_table, lc_fname, strlen(lc_fname));
if (mptr) {
// common.scope points to zend_class_entry for the declaring class,
// and there's only one of those per class, so we can just use a
// pointer compare here.
result = Z_FUNC_P(mptr)->common.scope != ce;
}
}
if (zend_hash_find(&(*ce)->function_table, lc_fname, strlen(lc_fname) + 1, (void **) &mptr) != SUCCESS) {
return false;
}
// common.scope points to the declaring class
return strcmp(mptr->common.scope->name, cname);
zend_string_release(cname_str);
return result;
}
template <typename Type>
@ -116,8 +116,8 @@ namespace Swig {
protected:
std::string swig_msg;
public:
DirectorException(int code, const char *hdr, const char *msg TSRMLS_DC) : swig_msg(hdr) {
if (msg[0]) {
DirectorException(int code, const char *hdr, const char *msg) : swig_msg(hdr) {
if (msg && msg[0]) {
swig_msg += " ";
swig_msg += msg;
}
@ -132,20 +132,20 @@ namespace Swig {
return swig_msg.c_str();
}
static void raise(int code, const char *hdr, const char *msg TSRMLS_DC) {
throw DirectorException(code, hdr, msg TSRMLS_CC);
static void raise(int code, const char *hdr, const char *msg) {
throw DirectorException(code, hdr, msg);
}
};
/* attempt to call a pure virtual method via a director method */
class DirectorPureVirtualException : public DirectorException {
public:
DirectorPureVirtualException(const char *msg TSRMLS_DC)
: DirectorException(E_ERROR, "SWIG director pure virtual method called", msg TSRMLS_CC) {
DirectorPureVirtualException(const char *msg)
: DirectorException(E_ERROR, "SWIG director pure virtual method called", msg) {
}
static void raise(const char *msg TSRMLS_DC) {
throw DirectorPureVirtualException(msg TSRMLS_CC);
static void raise(const char *msg) {
throw DirectorPureVirtualException(msg);
}
};
@ -153,18 +153,18 @@ namespace Swig {
class DirectorMethodException : public DirectorException
{
public:
DirectorMethodException(const char *msg TSRMLS_DC)
: DirectorException(E_ERROR, "SWIG director method error", msg TSRMLS_CC) {
DirectorMethodException()
: DirectorException(E_ERROR, "SWIG director method error", NULL) {
}
static void raise(const char *msg TSRMLS_DC) {
throw DirectorMethodException(msg TSRMLS_CC);
DirectorMethodException(const char *msg)
: DirectorException(E_ERROR, "SWIG director method error", msg) {
}
static void raise(const char *msg) {
throw DirectorMethodException(msg);
}
};
}
// DirectorMethodException() is documented to be callable with no parameters
// so use a macro to insert TSRMLS_CC so any ZTS context gets passed.
#define DirectorMethodException() DirectorMethodException("" TSRMLS_CC)
#endif

269
Lib/php/globalvar.i
View file

@ -6,27 +6,20 @@
%typemap(varinit) char *
{
zval *z_var;
MAKE_STD_ZVAL(z_var);
z_var->type = IS_STRING;
if($1) {
z_var->value.str.val = estrdup($1);
z_var->value.str.len = strlen($1);
zval z_var;
if ($1) {
ZVAL_STRING(&z_var, $1);
} else {
z_var->value.str.val = 0;
z_var->value.str.len = 0;
ZVAL_STR(&z_var, ZSTR_EMPTY_ALLOC());
}
zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void *)&z_var, sizeof(zval *), NULL);
zend_hash_str_add(&EG(symbol_table), "$1", sizeof("$1") - 1, &z_var);
}
%typemap(varinit) char []
{
zval *z_var;
MAKE_STD_ZVAL(z_var);
z_var->type = IS_STRING;
z_var->value.str.val = estrdup($1);
z_var->value.str.len = strlen($1);
zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void *)&z_var, sizeof(zval *), NULL);
zval z_var;
ZVAL_STRING(&z_var, $1);
zend_hash_str_add(&EG(symbol_table), "$1", sizeof("$1") - 1, &z_var);
}
%typemap(varinit) int,
@ -40,136 +33,98 @@
unsigned char,
enum SWIGTYPE
{
zval *z_var;
MAKE_STD_ZVAL(z_var);
z_var->type = IS_LONG;
z_var->value.lval = (long)$1;
zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void *)&z_var, sizeof(zval *), NULL);
zval z_var;
ZVAL_LONG(&z_var, (long)$1);
zend_hash_str_add(&EG(symbol_table), "$1", sizeof("$1") - 1, &z_var);
}
%typemap(varinit) bool
{
zval *z_var;
MAKE_STD_ZVAL(z_var);
z_var->type = IS_BOOL;
z_var->value.lval = ($1)?1:0;
zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void *)&z_var, sizeof(zval *), NULL);
zval z_var;
ZVAL_BOOL(&z_var, ($1)?1:0);
zend_hash_str_add(&EG(symbol_table), "$1", sizeof("$1") - 1, &z_var);
}
%typemap(varinit) float, double
{
zval *z_var;
MAKE_STD_ZVAL(z_var);
z_var->type = IS_DOUBLE;
z_var->value.dval = $1;
zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void *)&z_var,
sizeof(zval *), NULL);
zval z_var;
ZVAL_DOUBLE(&z_var, (double)$1);
zend_hash_str_add(&EG(symbol_table), "$1", sizeof("$1") - 1, &z_var);
}
%typemap(varinit) char
{
zval *z_var;
char c[2];
MAKE_STD_ZVAL(z_var);
c[0] = $1;
c[1] = 0;
z_var->type = IS_STRING;
z_var->value.str.val = estrndup(c, 1);
z_var->value.str.len = 1;
zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void *)&z_var,
sizeof(zval *), NULL);
zval z_var;
char c = $1;
ZVAL_STRINGL(&z_var, &c, 1);
zend_hash_str_add(&EG(symbol_table), "$1", sizeof("$1") - 1, &z_var);
}
%typemap(varinit) SWIGTYPE *, SWIGTYPE []
{
zval *z_var;
MAKE_STD_ZVAL(z_var);
SWIG_SetPointerZval(z_var, (void*)$1, $1_descriptor, 0);
zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void *)&z_var,
sizeof(zval *), NULL);
zval z_var;
SWIG_SetPointerZval(&z_var, (void*)$1, $1_descriptor, 0);
zend_hash_str_add(&EG(symbol_table), "$1", sizeof("$1") - 1, &z_var);
}
%typemap(varinit) SWIGTYPE, SWIGTYPE &, SWIGTYPE &&
{
zval *z_var;
MAKE_STD_ZVAL(z_var);
SWIG_SetPointerZval(z_var, (void*)&$1, $&1_descriptor, 0);
zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void*)&z_var,
sizeof(zval *), NULL);
zval z_var;
SWIG_SetPointerZval(&z_var, (void*)&$1, $&1_descriptor, 0);
zend_hash_str_add(&EG(symbol_table), "$1", sizeof("$1") - 1, &z_var);
}
%typemap(varinit) char [ANY]
{
zval *z_var;
MAKE_STD_ZVAL(z_var);
z_var->type = IS_STRING;
ZVAL_STRINGL(z_var,(char*)$1, $1_dim0, 1);
zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void*)&z_var, sizeof(zval *), NULL);
zval z_var;
/* varinit char [ANY] */
ZVAL_STRINGL(&z_var, $1, $1_dim0);
zend_hash_str_add(&EG(symbol_table), "$1", sizeof("$1") - 1, &z_var);
}
%typemap(varinit, fragment="swig_php_init_member_ptr") SWIGTYPE (CLASS::*)
{
zval resource;
void * p = emalloc(sizeof($1));
memcpy(p, &$1, sizeof($1));
zval * resource;
MAKE_STD_ZVAL(resource);
ZEND_REGISTER_RESOURCE(resource, p, swig_member_ptr);
zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void*)&resource, sizeof(zval *), NULL);
ZVAL_RES(&resource, zend_register_resource(p, swig_member_ptr));
zend_hash_str_add(&EG(symbol_table), "$1", sizeof("$1") - 1, &resource);
}
%typemap(varin) int, unsigned int, short, unsigned short, long, unsigned long, signed char, unsigned char, enum SWIGTYPE
{
zval **z_var;
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
convert_to_long_ex(z_var);
if ($1 != ($1_ltype)((*z_var)->value.lval)) {
$1 = Z_LVAL_PP(z_var);
}
zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
$1 = zval_get_long(z_var);
}
%typemap(varin) bool
{
zval **z_var;
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
convert_to_boolean_ex(z_var);
if ($1 != ($1_ltype)((*z_var)->value.lval)) {
$1 = Z_LVAL_PP(z_var);
}
zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
convert_to_boolean(z_var);
$1 = (Z_TYPE_P(z_var) == IS_TRUE);
}
%typemap(varin) double,float
{
zval **z_var;
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
convert_to_double_ex(z_var);
if ($1 != ($1_ltype)((*z_var)->value.dval)) {
$1 = Z_DVAL_PP(z_var);
}
zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
$1 = zval_get_double(z_var);
}
%typemap(varin) char
{
zval **z_var;
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
convert_to_string_ex(z_var);
if ($1 != *((*z_var)->value.str.val)) {
$1 = *((*z_var)->value.str.val);
zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
convert_to_string(z_var);
if ($1 != Z_STRVAL_P(z_var)[0]) {
$1 = Z_STRVAL_P(z_var)[0];
}
}
%typemap(varin) char *
{
zval **z_var;
zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
char *s1;
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
convert_to_string_ex(z_var);
s1 = Z_STRVAL_PP(z_var);
convert_to_string(z_var);
s1 = Z_STRVAL_P(z_var);
if ((s1 == NULL) || ($1 == NULL) || strcmp(s1, $1)) {
if (s1)
$1 = estrdup(s1);
@ -181,11 +136,9 @@
%typemap(varin) SWIGTYPE []
{
zval **z_var;
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
if($1) {
SWIG_SetPointerZval(*z_var, (void*)$1, $1_descriptor, $owner);
zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
SWIG_SetPointerZval(z_var, (void*)$1, $1_descriptor, $owner);
}
}
@ -194,8 +147,8 @@
zval **z_var;
char *s1;
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
s1 = Z_STRVAL_PP(z_var);
zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1, (void**)&z_var);
s1 = Z_STRVAL_P(z_var);
if ((s1 == NULL) || ($1 == NULL) || strcmp(s1, $1)) {
if (s1)
strncpy($1, s1, $1_dim0);
@ -204,11 +157,11 @@
%typemap(varin) SWIGTYPE
{
zval **z_var;
zval *z_var;
$&1_ltype _temp;
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
if (SWIG_ConvertPtr(*z_var, (void**)&_temp, $&1_descriptor, 0) < 0) {
z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
if (SWIG_ConvertPtr(z_var, (void**)&_temp, $&1_descriptor, 0) < 0) {
SWIG_PHP_Error(E_ERROR,"Type error in value of $symname. Expected $&1_descriptor");
}
@ -218,11 +171,11 @@
%typemap(varin) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&
{
zval **z_var;
zval *z_var;
$1_ltype _temp;
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
if (SWIG_ConvertPtr(*z_var, (void **)&_temp, $1_descriptor, 0) < 0) {
z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
if (SWIG_ConvertPtr(z_var, (void **)&_temp, $1_descriptor, 0) < 0) {
SWIG_PHP_Error(E_ERROR,"Type error in value of $symname. Expected $&1_descriptor");
}
@ -231,10 +184,8 @@
%typemap(varin, fragment="swig_php_init_member_ptr") SWIGTYPE (CLASS::*)
{
zval **z_var;
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
void * p = (void*)zend_fetch_resource(*z_var TSRMLS_CC, -1, SWIG_MEMBER_PTR, NULL, 1, swig_member_ptr);
zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
void * p = (void*)zend_fetch_resource_ex(z_var, SWIG_MEMBER_PTR, swig_member_ptr);
memcpy(&$1, p, sizeof($1));
}
@ -248,114 +199,96 @@
unsigned char,
enum SWIGTYPE
{
zval **z_var;
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
if($1 != ($1_ltype)((*z_var)->value.lval)) {
(*z_var)->value.lval = (long)$1;
zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
if ($1 != ($1_ltype)Z_LVAL_P(z_var)) {
z_var->value.lval = (long)$1;
}
}
//SAMFIX need to cast zval->type, what if zend-hash_find fails? etc?
%typemap(varout) bool
{
zval **z_var;
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
if($1 != ($1_ltype)((*z_var)->value.lval)) {
(*z_var)->value.lval = (long)$1;
zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
if ($1 != ($1_ltype)Z_LVAL_P(z_var)) {
z_var->value.lval = (long)$1;
}
}
%typemap(varout) double, float
{
zval **z_var;
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
if($1 != ($1_ltype)((*z_var)->value.dval)) {
(*z_var)->value.dval = (double)$1;
zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
if ($1 != ($1_ltype)Z_DVAL_P(z_var)) {
z_var->value.dval = (double)$1;
}
}
%typemap(varout) char
{
zval **z_var;
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
if($1 != *((*z_var)->value.str.val)) {
char c[2];
efree((*z_var)->value.str.val);
c[0] = $1;
c[1] = 0;
(*z_var)->value.str.val = estrdup(c);
zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
char c = $1;
if ($1 != Z_STRVAL_P(z_val)[0]) {
ZVAL_STRING(z_var, &c);
}
}
%typemap(varout) char *
{
zval **z_var;
char *s1;
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
s1 = Z_STRVAL_PP(z_var);
if((s1 == NULL) || ($1 == NULL) || strcmp(s1, $1)) {
if(s1)
zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
const char *s1 = Z_STRVAL_P(z_var);
if ((s1 == NULL) || ($1 == NULL) || strcmp(s1, $1)) {
if (s1)
efree(s1);
if($1) {
(*z_var)->value.str.val = estrdup($1);
(*z_var)->value.str.len = strlen($1) + 1;
if ($1) {
(z_var)->value.str.val = estrdup($1);
(z_var)->value.str.len = strlen($1) + 1;
} else {
(*z_var)->value.str.val = 0;
(*z_var)->value.str.len = 0;
(z_var)->value.str.val = 0;
(z_var)->value.str.len = 0;
}
}
}
%typemap(varout) SWIGTYPE
{
zval **z_var;
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
SWIG_SetPointerZval(*z_var, (void*)&$1, $&1_descriptor, 0);
zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
SWIG_SetPointerZval(z_var, (void*)&$1, $&1_descriptor, 0);
}
%typemap(varout) SWIGTYPE []
{
zval **z_var;
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
if($1)
SWIG_SetPointerZval(*z_var, (void*)$1, $1_descriptor, 0);
if($1) {
zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
SWIG_SetPointerZval(z_var, (void*)$1, $1_descriptor, 0);
}
}
%typemap(varout) char [ANY]
{
zval **z_var;
char *s1;
zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
const char *s1 = Z_STRVAL_P(z_var);
deliberate error cos this code looks bogus to me
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
s1 = Z_STRVAL_PP(z_var);
if((s1 == NULL) || strcmp(s1, $1)) {
if($1) {
(*z_var)->value.str.val = estrdup($1);
(*z_var)->value.str.len = strlen($1) + 1;
if ((s1 == NULL) || strcmp(s1, $1)) {
if ($1) {
(z_var)->value.str.val = estrdup($1);
(z_var)->value.str.len = strlen($1) + 1;
} else {
(*z_var)->value.str.val = 0;
(*z_var)->value.str.len = 0;
(z_var)->value.str.val = 0;
(z_var)->value.str.len = 0;
}
}
}
%typemap(varout) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&
{
zval **z_var;
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
SWIG_SetPointerZval(*z_var, (void*)$1, $1_descriptor, 0);
zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
SWIG_SetPointerZval(z_var, (void*)$1, $1_descriptor, 0);
}
%typemap(varout, fragment="swig_php_init_member_ptr") SWIGTYPE (CLASS::*)
{
zval resource;
void * p = emalloc(sizeof($1));
memcpy(p, &$1, sizeof($1));
zval * resource;
MAKE_STD_ZVAL(resource);
ZEND_REGISTER_RESOURCE(resource, p, swig_member_ptr);
zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void*)&resource, sizeof(zval *), NULL);
ZVAL_RES(&resource, zend_register_resource(p, swig_member_ptr));
zend_hash_str_add(&EG(symbol_table), "$1", sizeof("$1") - 1, &resource);
}

258
Lib/php/php.swg
View file

@ -71,72 +71,72 @@
// char array can be in/out, though the passed string may not be big enough...
// so we have to size it
%typemap(in) char[ANY]
{
convert_to_string_ex($input);
$1 = ($1_ltype) Z_STRVAL_PP($input);
}
%{
convert_to_string(&$input);
$1 = ($1_ltype) Z_STRVAL($input);
%}
%typemap(in) (char *STRING, int LENGTH), (char *STRING, size_t LENGTH) {
convert_to_string_ex($input);
$1 = ($1_ltype) Z_STRVAL_PP($input);
$2 = ($2_ltype) Z_STRLEN_PP($input);
}
%typemap(in) (char *STRING, int LENGTH), (char *STRING, size_t LENGTH) %{
convert_to_string(&$input);
$1 = ($1_ltype) Z_STRVAL($input);
$2 = ($2_ltype) Z_STRLEN($input);
%}
/* Object passed by value. Convert to a pointer */
%typemap(in) SWIGTYPE ($&1_ltype tmp)
{
if(SWIG_ConvertPtr(*$input, (void **) &tmp, $&1_descriptor, 0) < 0 || tmp == NULL) {
%{
if (SWIG_ConvertPtr(&$input, (void **) &tmp, $&1_descriptor, 0) < 0 || tmp == NULL) {
SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $&1_descriptor");
}
$1 = *tmp;
}
%}
%typemap(directorout) SWIGTYPE ($&1_ltype tmp)
{
%{
/* If exit was via exception, PHP NULL is returned so skip the conversion. */
if (!EG(exception)) {
if(SWIG_ConvertPtr($input, (void **) &tmp, $&1_descriptor, 0) < 0 || tmp == NULL)
if (SWIG_ConvertPtr($input, (void **) &tmp, $&1_descriptor, 0) < 0 || tmp == NULL)
SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $&1_descriptor");
$result = *tmp;
}
}
%}
%typemap(in) SWIGTYPE *,
SWIGTYPE []
{
if(SWIG_ConvertPtr(*$input, (void **) &$1, $1_descriptor, 0) < 0) {
%{
if (SWIG_ConvertPtr(&$input, (void **) &$1, $1_descriptor, 0) < 0) {
SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $1_descriptor");
}
}
%}
%typemap(in) SWIGTYPE &
{
if(SWIG_ConvertPtr(*$input, (void **) &$1, $1_descriptor, 0) < 0 || $1 == NULL) {
%{
if (SWIG_ConvertPtr(&$input, (void **) &$1, $1_descriptor, 0) < 0 || $1 == NULL) {
SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $1_descriptor");
}
}
%}
%typemap(in) SWIGTYPE &&
{
if(SWIG_ConvertPtr(*$input, (void **) &$1, $1_descriptor, 0) < 0 || $1 == NULL) {
%{
if (SWIG_ConvertPtr(&$input, (void **) &$1, $1_descriptor, 0) < 0 || $1 == NULL) {
SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $1_descriptor");
}
}
%}
%typemap(in) SWIGTYPE *const& ($*ltype temp)
{
if(SWIG_ConvertPtr(*$input, (void **) &temp, $*1_descriptor, 0) < 0) {
%{
if (SWIG_ConvertPtr(&$input, (void **) &temp, $*1_descriptor, 0) < 0) {
SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $*1_descriptor");
}
$1 = ($1_ltype)&temp;
}
%}
%typemap(in) SWIGTYPE *DISOWN
{
if(SWIG_ConvertPtr(*$input, (void **) &$1, $1_descriptor, SWIG_POINTER_DISOWN ) < 0) {
%{
if (SWIG_ConvertPtr(&$input, (void **) &$1, $1_descriptor, SWIG_POINTER_DISOWN ) < 0) {
SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $&1_descriptor");
}
}
%}
%typemap(argout) SWIGTYPE *,
SWIGTYPE [],
@ -144,14 +144,14 @@
SWIGTYPE &&;
%typemap(in) void *
{
if(SWIG_ConvertPtr(*$input, (void **) &$1, 0, 0) < 0) {
%{
if (SWIG_ConvertPtr(&$input, (void **) &$1, 0, 0) < 0) {
/* Allow NULL from php for void* */
if ((*$input)->type==IS_NULL) $1=0;
if (Z_ISNULL($input)) $1=0;
else
SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $&1_descriptor");
}
}
%}
/* Special case when void* is passed by reference so it can be made to point
to opaque api structs */
@ -160,9 +160,9 @@
{
/* If they pass NULL by reference, make it into a void*
This bit should go in arginit if arginit support init-ing scripting args */
if(SWIG_ConvertPtr(*$input, (void **) &$1, $1_descriptor, 0) < 0) {
if (SWIG_ConvertPtr(&$input, (void **) &$1, $1_descriptor, 0) < 0) {
/* So... we didn't get a ref or ptr, but we'll accept NULL by reference */
if (!((*$input)->type==IS_NULL && PZVAL_IS_REF(*$input))) {
if (!(Z_ISREF($input) && Z_ISNULL_P(Z_REFVAL($input)))) {
/* wasn't a pre/ref/thing, OR anything like an int thing */
SWIG_PHP_Error(E_ERROR, "Type error in argument $arg of $symname.");
}
@ -181,11 +181,11 @@
}
%typemap(argout) void **,
void *&
{
%{
if (force$argnum) {
SWIG_SetPointerZval( *$input, (void*) ptr$argnum, $*1_descriptor, 1);
SWIG_SetPointerZval(&$input, (void*) ptr$argnum, $*1_descriptor, 1);
}
}
%}
/* Typemap for output values */
@ -199,35 +199,33 @@
unsigned char,
bool,
size_t
{
ZVAL_LONG(return_value,$1);
}
%{
RETVAL_LONG($1);
%}
%typemap(out) enum SWIGTYPE
{
ZVAL_LONG(return_value, (long)$1);
}
%{
RETVAL_LONG((long)$1);
%}
%typemap(out) long long
%{
if ((long long)LONG_MIN <= $1 && $1 <= (long long)LONG_MAX) {
return_value->value.lval = (long)($1);
return_value->type = IS_LONG;
RETVAL_LONG((long)($1));
} else {
char temp[256];
sprintf(temp, "%lld", (long long)$1);
ZVAL_STRING(return_value, temp, 1);
RETVAL_STRING(temp);
}
%}
%typemap(out) unsigned long long
%{
if ($1 <= (unsigned long long)LONG_MAX) {
return_value->value.lval = (long)($1);
return_value->type = IS_LONG;
RETVAL_LONG((long)($1));
} else {
char temp[256];
sprintf(temp, "%llu", (unsigned long long)$1);
ZVAL_STRING(return_value, temp, 1);
RETVAL_STRING(temp);
}
%}
@ -241,40 +239,38 @@
const unsigned char &,
const bool &,
const size_t &
{
ZVAL_LONG(return_value,*$1);
}
%{
RETVAL_LONG(*$1);
%}
%typemap(out) const enum SWIGTYPE &
{
ZVAL_LONG(return_value, (long)*$1);
}
%{
RETVAL_LONG((long)*$1);
%}
%typemap(out) const enum SWIGTYPE &&
{
ZVAL_LONG(return_value, (long)*$1);
}
%{
RETVAL_LONG((long)*$1);
%}
%typemap(out) const long long &
%{
if ((long long)LONG_MIN <= *$1 && *$1 <= (long long)LONG_MAX) {
return_value->value.lval = (long)(*$1);
return_value->type = IS_LONG;
RETVAL_LONG((long)(*$1));
} else {
char temp[256];
sprintf(temp, "%lld", (long long)(*$1));
ZVAL_STRING(return_value, temp, 1);
RETVAL_STRING(temp);
}
%}
%typemap(out) const unsigned long long &
%{
if (*$1 <= (unsigned long long)LONG_MAX) {
return_value->value.lval = (long)(*$1);
return_value->type = IS_LONG;
RETVAL_LONG((long)(*$1));
} else {
char temp[256];
sprintf(temp, "%llu", (unsigned long long)(*$1));
ZVAL_STRING(return_value, temp, 1);
RETVAL_STRING(temp);
}
%}
@ -288,85 +284,85 @@
unsigned char,
size_t,
enum SWIGTYPE
{
%{
ZVAL_LONG($input,$1);
}
%}
%typemap(directorin) enum SWIGTYPE
{
%{
ZVAL_LONG($input, (long)$1_name);
}
%}
%typemap(directorin) char *, char []
{
%{
if(!$1) {
ZVAL_NULL($input);
} else {
ZVAL_STRING($input, (char *)$1, 1);
ZVAL_STRING($input, (const char*)$1);
}
}
%}
%typemap(out) bool
{
ZVAL_BOOL(return_value,($1)?1:0);
}
%{
RETVAL_BOOL(($1) ? 1 : 0);
%}
%typemap(out) const bool &
{
ZVAL_BOOL(return_value,(*$1)?1:0);
}
%{
RETVAL_BOOL((*$1) ? 1 : 0);
%}
%typemap(directorin) bool
{
ZVAL_BOOL($input,($1)?1:0);
}
%{
ZVAL_BOOL($input, ($1) ? 1 : 0);
%}
%typemap(out) float,
double
{
ZVAL_DOUBLE(return_value,$1);
}
%{
RETVAL_DOUBLE($1);
%}
%typemap(out) const float &,
const double &
{
ZVAL_DOUBLE(return_value,*$1);
}
%{
RETVAL_DOUBLE(*$1);
%}
%typemap(directorin) float,
double
{
ZVAL_DOUBLE($input,$1);
}
%{
ZVAL_DOUBLE($input, $1);
%}
%typemap(out) char
{
ZVAL_STRINGL(return_value,&$1, 1, 1);
}
%{
RETVAL_STRINGL(&$1, 1);
%}
%typemap(out) const char &
{
ZVAL_STRINGL(return_value,&*$1, 1, 1);
}
%{
RETVAL_STRINGL(&*$1, 1);
%}
%typemap(out) char *,
char []
{
if(!$1) {
ZVAL_NULL(return_value);
} else {
ZVAL_STRING(return_value, (char *)$1, 1);
}
}
%{
if (!$1) {
RETVAL_NULL();
} else {
RETVAL_STRING((const char *)$1);
}
%}
%typemap(out) char *&
{
if(!*$1) {
ZVAL_NULL(return_value);
} else {
ZVAL_STRING(return_value, (char *)*$1, 1);
}
}
%{
if (!*$1) {
RETVAL_NULL();
} else {
RETVAL_STRING((const char *)*$1);
}
%}
%typemap(out) SWIGTYPE *,
SWIGTYPE [],
@ -393,12 +389,12 @@
{
void * p = emalloc(sizeof($1));
memcpy(p, &$1, sizeof($1));
ZEND_REGISTER_RESOURCE(return_value, p, swig_member_ptr);
RETVAL_RES(zend_register_resource(p, swig_member_ptr));
}
%typemap(in, fragment="swig_php_init_member_ptr") SWIGTYPE (CLASS::*)
{
void * p = (void*)zend_fetch_resource($input TSRMLS_CC, -1, SWIG_MEMBER_PTR, NULL, 1, swig_member_ptr);
void * p = (void*)zend_fetch_resource_ex(&$input, SWIG_MEMBER_PTR, swig_member_ptr);
memcpy(&$1, p, sizeof($1));
}
@ -424,9 +420,9 @@
#endif
%typemap(directorin) SWIGTYPE
{
%{
SWIG_SetPointerZval($input, SWIG_as_voidptr(new $1_ltype((const $1_ltype &)$1)), $&1_descriptor, 1|2);
}
%}
%typemap(out) void "";
@ -434,7 +430,7 @@
{
int len = 0;
while (len < $1_dim0 && $1[len]) ++len;
RETVAL_STRINGL($1, len, 1);
RETVAL_STRINGL($1, len);
}
// This typecheck does hard checking for proper argument type. If you want
@ -442,7 +438,13 @@
// it yourself before passing it (e.g. (string)4.7 or (int)"6").
%define %php_typecheck(_type,_prec,is)
%typemap(typecheck,precedence=_prec) _type, const _type &
" $1 = (Z_TYPE_PP($input) == is); "
" $1 = (Z_TYPE($input) == is);"
%enddef
// Like %php_typecheck but allows either of two values.
%define %php_typecheck2(_type,_prec,is1,is2)
%typemap(typecheck,precedence=_prec) _type, const _type &
" $1 = (Z_TYPE($input) == is1 || Z_TYPE($input) == is2);"
%enddef
%php_typecheck(int,SWIG_TYPECHECK_INTEGER,IS_LONG)
@ -457,18 +459,18 @@
%php_typecheck(unsigned char,SWIG_TYPECHECK_UINT8,IS_LONG)
%php_typecheck(size_t,SWIG_TYPECHECK_SIZE,IS_LONG)
%php_typecheck(enum SWIGTYPE,SWIG_TYPECHECK_INTEGER,IS_LONG)
%php_typecheck(bool,SWIG_TYPECHECK_BOOL,IS_BOOL)
%php_typecheck2(bool,SWIG_TYPECHECK_BOOL,IS_TRUE,IS_FALSE)
%php_typecheck(float,SWIG_TYPECHECK_FLOAT,IS_DOUBLE)
%php_typecheck(double,SWIG_TYPECHECK_DOUBLE,IS_DOUBLE)
%php_typecheck(char,SWIG_TYPECHECK_CHAR,IS_STRING)
%typemap(typecheck,precedence=SWIG_TYPECHECK_STRING) char *, char *&, char []
" $1 = (Z_TYPE_PP($input) == IS_STRING); "
" $1 = (Z_TYPE($input) == IS_STRING); "
%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE
{
void *tmp;
_v = (SWIG_ConvertPtr(*$input, (void **)&tmp, $&1_descriptor, 0) >= 0);
_v = (SWIG_ConvertPtr(&$input, (void **)&tmp, $&1_descriptor, 0) >= 0);
}
%typecheck(SWIG_TYPECHECK_POINTER)
@ -479,19 +481,19 @@
SWIGTYPE *const&
{
void *tmp;
_v = (SWIG_ConvertPtr(*$input, (void**)&tmp, $1_descriptor, 0) >= 0);
_v = (SWIG_ConvertPtr(&$input, (void**)&tmp, $1_descriptor, 0) >= 0);
}
%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *const&
{
void *tmp;
_v = (SWIG_ConvertPtr(*$input, (void**)&tmp, $*1_descriptor, 0) >= 0);
_v = (SWIG_ConvertPtr(&$input, (void**)&tmp, $*1_descriptor, 0) >= 0);
}
%typecheck(SWIG_TYPECHECK_VOIDPTR) void *
{
void *tmp;
_v = (SWIG_ConvertPtr(*$input, (void**)&tmp, 0, 0) >= 0);
_v = (SWIG_ConvertPtr(&$input, (void**)&tmp, 0, 0) >= 0);
}
/* Exception handling */
@ -501,19 +503,19 @@
short,
unsigned int,
unsigned long,
unsigned short {
zend_throw_exception(NULL, const_cast<char*>("C++ $1_type exception thrown"), $1 TSRMLS_CC);
unsigned short %{
zend_throw_exception(NULL, "C++ $1_type exception thrown", $1);
return;
}
%}
%typemap(throws) SWIGTYPE, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE *, SWIGTYPE [], SWIGTYPE [ANY] %{
(void)$1;
zend_throw_exception(NULL, const_cast<char*>("C++ $1_type exception thrown"), 0 TSRMLS_CC);
zend_throw_exception(NULL, "C++ $1_type exception thrown", 0);
return;
%}
%typemap(throws) char * %{
zend_throw_exception(NULL, const_cast<char*>($1), 0 TSRMLS_CC);
zend_throw_exception(NULL, $1, 0);
return;
%}

14
Lib/php/phpinit.swg
View file

@ -10,16 +10,16 @@
SWIG_InitializeModule(0);
%}
%fragment("swig_php_init_member_ptr2", "header") {
#define SWIG_MEMBER_PTR ((char*)"CLASS::*")
%fragment("swig_php_init_member_ptr2", "header") %{
#define SWIG_MEMBER_PTR "CLASS::*"
static void swig_member_ptr_dtor(zend_rsrc_list_entry *rsrc TSRMLS_DC) {
efree(rsrc->ptr);
static void swig_member_ptr_dtor(zend_resource *res) {
efree(res->ptr);
}
static int swig_member_ptr = 0;
}
%}
%fragment("swig_php_init_member_ptr", "init", fragment="swig_php_init_member_ptr2") {
%fragment("swig_php_init_member_ptr", "init", fragment="swig_php_init_member_ptr2") %{
swig_member_ptr = zend_register_list_destructors_ex(swig_member_ptr_dtor, NULL, SWIG_MEMBER_PTR, module_number);
}
%}

15
Lib/php/phpkw.swg
View file

@ -661,6 +661,21 @@ PHPCN(generator); // As of PHP 5.5
PHPCN(self);
PHPCN(static);
PHPCN(parent);
/* http://php.net/manual/en/migration70.incompatible.php#migration70.incompatible.other.classes */
PHPCN(bool); // As of PHP 7.0
PHPCN(int); // As of PHP 7.0
PHPCN(float); // As of PHP 7.0
PHPCN(string); // As of PHP 7.0
PHPCN(NULL); // As of PHP 7.0
PHPCN(TRUE); // As of PHP 7.0
PHPCN(FALSE); // As of PHP 7.0
PHPCN(resource); // As of PHP 7.0 (currently works but reserved)
PHPCN(object); // As of PHP 7.0 (currently works but reserved)
PHPCN(mixed); // As of PHP 7.0 (currently works but reserved)
PHPCN(numeric); // As of PHP 7.0 (currently works but reserved)
/* http://php.net/manual/en/migration71.incompatible.php#migration71.incompatible.invalid-class-names */
PHPCN(iterable); // As of PHP 7.1
PHPCN(void); // As of PHP 7.1
/* From extensions (which of these are actually predefined depends which
* extensions are loaded by default). */
PHPCN(xmlwriter);

14
Lib/php/phppointers.i
View file

@ -3,19 +3,23 @@
TYPE &REF ($*1_ltype tmp)
%{
/* First Check for SWIG wrapped type */
if ( ZVAL_IS_NULL( *$input ) ) {
if (Z_ISNULL($input)) {
$1 = 0;
} else if ( PZVAL_IS_REF( *$input ) ) {
} else if (Z_ISREF($input)) {
/* Not swig wrapped type, so we check if it's a PHP reference type */
CONVERT_IN( tmp, $*1_ltype, $input );
CONVERT_IN(tmp, $*1_ltype, $input);
$1 = &tmp;
} else {
SWIG_PHP_Error( E_ERROR, SWIG_PHP_Arg_Error_Msg($argnum, Expected a reference) );
SWIG_PHP_Error(E_ERROR, SWIG_PHP_Arg_Error_Msg($argnum, Expected a reference));
}
%}
%typemap(argout) TYPE *REF,
TYPE &REF
"CONVERT_OUT(*$input, tmp$argnum );";
%{
if (Z_ISREF($input)) {
CONVERT_OUT(Z_REFVAL($input), tmp$argnum);
}
%}
%enddef
%pass_by_ref( size_t, CONVERT_INT_IN, ZVAL_LONG );

156
Lib/php/phprun.swg
View file

@ -14,62 +14,22 @@ extern "C" {
#include "ext/standard/php_string.h"
#include <stdlib.h> /* for abort(), used in generated code. */
#ifdef ZEND_RAW_FENTRY
/* ZEND_RAW_FENTRY was added somewhere between 5.2.0 and 5.2.3 */
# define SWIG_ZEND_NAMED_FE(ZN, N, A) ZEND_RAW_FENTRY((char*)#ZN, N, A, 0)
#else
/* This causes warnings from GCC >= 4.2 (assigning a string literal to char*).
* But this seems to be unavoidable without directly assuming knowledge of
* the structure, which changed between PHP4 and PHP5. */
# define SWIG_ZEND_NAMED_FE(ZN, N, A) ZEND_NAMED_FE(ZN, N, A)
#endif
/* This indirection is to work around const correctness issues in older PHP.
* FIXME: Remove for PHP7? Or might user code be using it? */
#define SWIG_ZEND_NAMED_FE(ZN, N, A) ZEND_NAMED_FE(ZN, N, A)
#ifndef ZEND_FE_END
# define ZEND_FE_END { NULL, NULL, NULL }
#endif
#ifndef Z_SET_ISREF_P
/* For PHP < 5.3 */
# define Z_SET_ISREF_P(z) (z)->is_ref = 1
#endif
#ifndef Z_SET_REFCOUNT_P
/* For PHP < 5.3 */
# define Z_SET_REFCOUNT_P(z, rc) (z)->refcount = (rc)
#endif
#define SWIG_LONG_CONSTANT(N, V) zend_register_long_constant((char*)#N, sizeof(#N), V, CONST_CS | CONST_PERSISTENT, module_number TSRMLS_CC)
#define SWIG_DOUBLE_CONSTANT(N, V) zend_register_double_constant((char*)#N, sizeof(#N), V, CONST_CS | CONST_PERSISTENT, module_number TSRMLS_CC)
#define SWIG_STRING_CONSTANT(N, V) zend_register_stringl_constant((char*)#N, sizeof(#N), (char*)(V), strlen(V), CONST_CS | CONST_PERSISTENT, module_number TSRMLS_CC)
#define SWIG_LONG_CONSTANT(N, V) REGISTER_LONG_CONSTANT(#N, V, CONST_CS | CONST_PERSISTENT)
#define SWIG_DOUBLE_CONSTANT(N, V) REGISTER_DOUBLE_CONSTANT(#N, V, CONST_CS | CONST_PERSISTENT)
#define SWIG_STRING_CONSTANT(N, V) REGISTER_STRING_CONSTANT(#N, (char*)V, CONST_CS | CONST_PERSISTENT)
#define SWIG_CHAR_CONSTANT(N, V) do {\
static char swig_char = (V);\
zend_register_stringl_constant((char*)#N, sizeof(#N), &swig_char, 1, CONST_CS | CONST_PERSISTENT, module_number TSRMLS_CC);\
char swig_char = (V);\
REGISTER_STRINGL_CONSTANT(#N, &swig_char, 1, CONST_CS | CONST_PERSISTENT);\
} while (0)
/* These TSRMLS_ stuff should already be defined now, but with older php under
redhat are not... */
#ifndef TSRMLS_D
#define TSRMLS_D
#endif
#ifndef TSRMLS_DC
#define TSRMLS_DC
#endif
#ifndef TSRMLS_C
#define TSRMLS_C
#endif
#ifndef TSRMLS_CC
#define TSRMLS_CC
#endif
#ifdef __cplusplus
}
#endif
/* But in fact SWIG_ConvertPtr is the native interface for getting typed
pointer values out of zvals. We need the TSRMLS_ macros for when we
make PHP type calls later as we handle php resources */
#define SWIG_ConvertPtr(obj,pp,type,flags) SWIG_ZTS_ConvertPtr(obj,pp,type,flags TSRMLS_CC)
#define SWIG_fail goto fail
static const char *default_error_msg = "Unknown error occurred";
@ -93,11 +53,10 @@ typedef struct {
int newobject;
} swig_object_wrapper;
#define SWIG_SetPointerZval(a,b,c,d) SWIG_ZTS_SetPointerZval(a,b,c,d TSRMLS_CC)
#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
static void
SWIG_ZTS_SetPointerZval(zval *z, void *ptr, swig_type_info *type, int newobject TSRMLS_DC) {
SWIG_SetPointerZval(zval *z, void *ptr, swig_type_info *type, int newobject) {
/*
* First test for Null pointers. Return those as PHP native NULL
*/
@ -114,19 +73,19 @@ SWIG_ZTS_SetPointerZval(zval *z, void *ptr, swig_type_info *type, int newobject
value->newobject=(newobject & 1);
if ((newobject & 2) == 0) {
/* Just register the pointer as a resource. */
ZEND_REGISTER_RESOURCE(z, value, *(int *)(type->clientdata));
ZVAL_RES(z, zend_register_resource(value, *(int *)(type->clientdata)));
} else {
/*
* Wrap the resource in an object, the resource will be accessible
* via the "_cPtr" member. This is currently only used by
* directorin typemaps.
*/
zval *resource;
zend_class_entry **ce = NULL;
zval resource;
zend_class_entry *ce = NULL;
const char *type_name = type->name+3; /* +3 so: _p_Foo -> Foo */
size_t type_name_len;
int result;
const char * p;
HashTable * ht;
/* Namespace__Foo -> Foo */
/* FIXME: ugly and goes wrong for classes with __ in their names. */
@ -135,26 +94,27 @@ SWIG_ZTS_SetPointerZval(zval *z, void *ptr, swig_type_info *type, int newobject
}
type_name_len = strlen(type_name);
MAKE_STD_ZVAL(resource);
ZEND_REGISTER_RESOURCE(resource, value, *(int *)(type->clientdata));
ZVAL_RES(&resource, zend_register_resource(value, *(int *)(type->clientdata)));
if (SWIG_PREFIX_LEN > 0) {
char * classname = (char*)emalloc(SWIG_PREFIX_LEN + type_name_len + 1);
strcpy(classname, SWIG_PREFIX);
strcpy(classname + SWIG_PREFIX_LEN, type_name);
result = zend_lookup_class(classname, SWIG_PREFIX_LEN + type_name_len, &ce TSRMLS_CC);
efree(classname);
zend_string * classname = zend_string_alloc(SWIG_PREFIX_LEN + type_name_len, 0);
memcpy(classname->val, SWIG_PREFIX, SWIG_PREFIX_LEN);
memcpy(classname->val + SWIG_PREFIX_LEN, type_name, type_name_len);
ce = zend_lookup_class(classname);
zend_string_release(classname);
} else {
result = zend_lookup_class((char *)type_name, type_name_len, &ce TSRMLS_CC);
zend_string * classname = zend_string_init(type_name, type_name_len, 0);
ce = zend_lookup_class(classname);
zend_string_release(classname);
}
if (result != SUCCESS) {
if (ce == NULL) {
/* class does not exist */
object_init(z);
} else {
object_init_ex(z, *ce);
ce = zend_standard_class_def;
}
Z_SET_REFCOUNT_P(z, 1);
Z_SET_ISREF_P(z);
zend_hash_update(HASH_OF(z), (char*)"_cPtr", sizeof("_cPtr"), (void*)&resource, sizeof(zval*), NULL);
ALLOC_HASHTABLE(ht);
zend_hash_init(ht, 1, NULL, NULL, 0);
zend_hash_str_update(ht, "_cPtr", sizeof("_cPtr") - 1, &resource);
object_and_properties_init(z, ce, ht);
}
return;
}
@ -170,11 +130,11 @@ SWIG_ZTS_SetPointerZval(zval *z, void *ptr, swig_type_info *type, int newobject
instance of a resource of the type id, so we have to pass type_name as well.
The two functions which might call this are:
SWIG_ZTS_ConvertResourcePtr which gets the type name from the resource
SWIG_ConvertResourcePtr which gets the type name from the resource
and the registered zend destructors for which we have one per type each
with the type name hard wired in. */
static void *
SWIG_ZTS_ConvertResourceData(void * p, const char *type_name, swig_type_info *ty TSRMLS_DC) {
SWIG_ConvertResourceData(void * p, const char *type_name, swig_type_info *ty) {
swig_cast_info *tc;
void *result = 0;
@ -201,48 +161,53 @@ SWIG_ZTS_ConvertResourceData(void * p, const char *type_name, swig_type_info *ty
/* This function returns a pointer of type ty by extracting the pointer
and type info from the resource in z. z must be a resource.
If it fails, NULL is returned.
It uses SWIG_ZTS_ConvertResourceData to do the real work. */
It uses SWIG_ConvertResourceData to do the real work. */
static void *
SWIG_ZTS_ConvertResourcePtr(zval *z, swig_type_info *ty, int flags TSRMLS_DC) {
SWIG_ConvertResourcePtr(zval *z, swig_type_info *ty, int flags) {
swig_object_wrapper *value;
void *p;
int type;
const char *type_name;
value = (swig_object_wrapper *) zend_list_find(z->value.lval, &type);
if (type==-1) return NULL;
if (Z_RES_TYPE_P(z) == -1) return NULL;
value = (swig_object_wrapper *) Z_RES_VAL_P(z);
if (flags & SWIG_POINTER_DISOWN) {
value->newobject = 0;
}
p = value->ptr;
type_name=zend_rsrc_list_get_rsrc_type(z->value.lval TSRMLS_CC);
type_name=zend_rsrc_list_get_rsrc_type(Z_RES_P(z));
return SWIG_ZTS_ConvertResourceData(p, type_name, ty TSRMLS_CC);
return SWIG_ConvertResourceData(p, type_name, ty);
}
/* We allow passing of a RESOURCE pointing to the object or an OBJECT whose
_cPtr is a resource pointing to the object */
static int
SWIG_ZTS_ConvertPtr(zval *z, void **ptr, swig_type_info *ty, int flags TSRMLS_DC) {
SWIG_ConvertPtr(zval *z, void **ptr, swig_type_info *ty, int flags) {
if (z == NULL) {
*ptr = 0;
return 0;
}
switch (z->type) {
switch (Z_TYPE_P(z)) {
case IS_OBJECT: {
zval ** _cPtr;
if (zend_hash_find(HASH_OF(z),(char*)"_cPtr",sizeof("_cPtr"),(void**)&_cPtr)==SUCCESS) {
if ((*_cPtr)->type==IS_RESOURCE) {
*ptr = SWIG_ZTS_ConvertResourcePtr(*_cPtr, ty, flags TSRMLS_CC);
return (*ptr == NULL ? -1 : 0);
}
HashTable * ht = Z_OBJ_HT_P(z)->get_properties(z);
if (ht) {
zval * _cPtr = zend_hash_str_find(ht, "_cPtr", sizeof("_cPtr") - 1);
if (_cPtr) {
if (Z_TYPE_P(_cPtr) == IS_INDIRECT) {
_cPtr = Z_INDIRECT_P(_cPtr);
}
if (Z_TYPE_P(_cPtr) == IS_RESOURCE) {
*ptr = SWIG_ConvertResourcePtr(_cPtr, ty, flags);
return (*ptr == NULL ? -1 : 0);
}
}
}
break;
}
case IS_RESOURCE:
*ptr = SWIG_ZTS_ConvertResourcePtr(z, ty, flags TSRMLS_CC);
*ptr = SWIG_ConvertResourcePtr(z, ty, flags);
return (*ptr == NULL ? -1 : 0);
case IS_NULL:
*ptr = 0;
@ -254,22 +219,15 @@ SWIG_ZTS_ConvertPtr(zval *z, void **ptr, swig_type_info *ty, int flags TSRMLS_DC
static char const_name[] = "swig_runtime_data_type_pointer";
static swig_module_info *SWIG_Php_GetModule() {
zval *pointer;
swig_module_info *ret = 0;
TSRMLS_FETCH();
MAKE_STD_ZVAL(pointer);
if (zend_get_constant(const_name, sizeof(const_name) - 1, pointer TSRMLS_CC)) {
if (pointer->type == IS_LONG) {
ret = (swig_module_info *) pointer->value.lval;
zval *pointer = zend_get_constant_str(const_name, sizeof(const_name) - 1);
if (pointer) {
if (Z_TYPE_P(pointer) == IS_LONG) {
return (swig_module_info *) pointer->value.lval;
}
}
FREE_ZVAL(pointer);
return ret;
return NULL;
}
static void SWIG_Php_SetModule(swig_module_info *pointer) {
TSRMLS_FETCH();
REGISTER_MAIN_LONG_CONSTANT(const_name, (long) pointer, 0);
}

43
Lib/php/std_string.i
View file

@ -24,53 +24,68 @@ namespace std {
class string;
%typemap(typecheck,precedence=SWIG_TYPECHECK_STRING) string, const string& %{
$1 = ( Z_TYPE_PP($input) == IS_STRING ) ? 1 : 0;
$1 = (Z_TYPE($input) == IS_STRING) ? 1 : 0;
%}
%typemap(in) string %{
convert_to_string_ex($input);
$1.assign(Z_STRVAL_PP($input), Z_STRLEN_PP($input));
convert_to_string(&$input);
$1.assign(Z_STRVAL($input), Z_STRLEN($input));
%}
%typemap(directorout) string %{
convert_to_string_ex(&$input);
if (!EG(exception)) {
convert_to_string($input);
$result.assign(Z_STRVAL_P($input), Z_STRLEN_P($input));
}
%}
%typemap(out) string %{
ZVAL_STRINGL($result, const_cast<char*>($1.data()), $1.size(), 1);
ZVAL_STRINGL($result, $1.data(), $1.size());
%}
%typemap(directorin) string, const string& %{
ZVAL_STRINGL($input, const_cast<char*>($1.data()), $1.size(), 1);
ZVAL_STRINGL($input, $1.data(), $1.size());
%}
%typemap(out) const string & %{
ZVAL_STRINGL($result, const_cast<char*>($1->data()), $1->size(), 1);
ZVAL_STRINGL($result, $1->data(), $1->size());
%}
%typemap(throws) string, const string& %{
zend_throw_exception(NULL, const_cast<char*>($1.c_str()), 0 TSRMLS_CC);
zend_throw_exception(NULL, $1.c_str(), 0);
return;
%}
%typemap(in) const string & ($*1_ltype temp) %{
convert_to_string(&$input);
temp.assign(Z_STRVAL($input), Z_STRLEN($input));
$1 = &temp;
%}
/* These next two handle a function which takes a non-const reference to
* a std::string and modifies the string. */
%typemap(in) string & ($*1_ltype temp) %{
convert_to_string_ex($input);
temp.assign(Z_STRVAL_PP($input), Z_STRLEN_PP($input));
$1 = &temp;
%typemap(in,byref=1) string & ($*1_ltype temp) %{
{
zval * p = Z_ISREF($input) ? Z_REFVAL($input) : &$input;
convert_to_string(p);
temp.assign(Z_STRVAL_P(p), Z_STRLEN_P(p));
$1 = &temp;
}
%}
%typemap(directorout) string & ($*1_ltype *temp) %{
convert_to_string_ex(&$input);
if (!EG(exception)) {
convert_to_string($input);
temp = new $*1_ltype(Z_STRVAL_P($input), Z_STRLEN_P($input));
swig_acquire_ownership(temp);
$result = temp;
}
%}
%typemap(argout) string & %{
ZVAL_STRINGL(*($input), const_cast<char*>($1->data()), $1->size(), 1);
if (Z_ISREF($input)) {
ZVAL_STRINGL(Z_REFVAL($input), $1->data(), $1->size());
}
%}
/* SWIG will apply the non-const typemap above to const string& without

105
Lib/php/typemaps.i
View file

@ -27,87 +27,77 @@
%define BOOL_TYPEMAP(TYPE)
%typemap(in) TYPE *INPUT(TYPE temp), TYPE &INPUT(TYPE temp)
%{
convert_to_boolean_ex($input);
temp = Z_LVAL_PP($input) ? true : false;
convert_to_boolean(&$input);
temp = (Z_TYPE($input) == IS_TRUE);
$1 = &temp;
%}
%typemap(argout) TYPE *INPUT, TYPE &INPUT "";
%typemap(in,numinputs=0) TYPE *OUTPUT(TYPE temp), TYPE &OUTPUT(TYPE temp) "$1 = &temp;";
%typemap(argout,fragment="t_output_helper") TYPE *OUTPUT, TYPE &OUTPUT
{
zval *o;
MAKE_STD_ZVAL(o);
ZVAL_BOOL(o,temp$argnum);
t_output_helper( &$result, o TSRMLS_CC );
zval o;
ZVAL_BOOL(&o, temp$argnum);
t_output_helper($result, &o);
}
%typemap(in) TYPE *REFERENCE (TYPE lvalue), TYPE &REFERENCE (TYPE lvalue)
%{
convert_to_boolean_ex($input);
lvalue = (*$input)->value.lval ? true : false;
convert_to_boolean($input);
lvalue = (Z_TYPE_P($input) == IS_TRUE);
$1 = &lvalue;
%}
%typemap(argout) TYPE *REFERENCE, TYPE &REFERENCE
%{
(*$arg)->value.lval = lvalue$argnum ? true : false;
(*$arg)->type = IS_BOOL;
ZVAL_BOOL(&$arg, lvalue$argnum ? true : false);
%}
%enddef
%define DOUBLE_TYPEMAP(TYPE)
%typemap(in) TYPE *INPUT(TYPE temp), TYPE &INPUT(TYPE temp)
%{
convert_to_double_ex($input);
temp = (TYPE) Z_DVAL_PP($input);
temp = (TYPE) zval_get_double(&$input);
$1 = &temp;
%}
%typemap(argout) TYPE *INPUT, TYPE &INPUT "";
%typemap(in,numinputs=0) TYPE *OUTPUT(TYPE temp), TYPE &OUTPUT(TYPE temp) "$1 = &temp;";
%typemap(argout,fragment="t_output_helper") TYPE *OUTPUT, TYPE &OUTPUT
{
zval *o;
MAKE_STD_ZVAL(o);
ZVAL_DOUBLE(o,temp$argnum);
t_output_helper( &$result, o TSRMLS_CC );
zval o;
ZVAL_DOUBLE(&o, temp$argnum);
t_output_helper($result, &o);
}
%typemap(in) TYPE *REFERENCE (TYPE dvalue), TYPE &REFERENCE (TYPE dvalue)
%{
convert_to_double_ex($input);
dvalue = (TYPE) (*$input)->value.dval;
dvalue = (TYPE) zval_get_double(&$input);
$1 = &dvalue;
%}
%typemap(argout) TYPE *REFERENCE, TYPE &REFERENCE
%{
$1->value.dval = (double)(lvalue$argnum);
$1->type = IS_DOUBLE;
ZVAL_DOUBLE(&$arg, (double)(lvalue$argnum));
%}
%enddef
%define INT_TYPEMAP(TYPE)
%typemap(in) TYPE *INPUT(TYPE temp), TYPE &INPUT(TYPE temp)
%{
convert_to_long_ex($input);
temp = (TYPE) Z_LVAL_PP($input);
temp = (TYPE) zval_get_long(&$input);
$1 = &temp;
%}
%typemap(argout) TYPE *INPUT, TYPE &INPUT "";
%typemap(in,numinputs=0) TYPE *OUTPUT(TYPE temp), TYPE &OUTPUT(TYPE temp) "$1 = &temp;";
%typemap(argout,fragment="t_output_helper") TYPE *OUTPUT, TYPE &OUTPUT
{
zval *o;
MAKE_STD_ZVAL(o);
ZVAL_LONG(o,temp$argnum);
t_output_helper( &$result, o TSRMLS_CC );
zval o;
ZVAL_LONG(&o, temp$argnum);
t_output_helper($result, &o);
}
%typemap(in) TYPE *REFERENCE (TYPE lvalue), TYPE &REFERENCE (TYPE lvalue)
%{
convert_to_long_ex($input);
lvalue = (TYPE) (*$input)->value.lval;
lvalue = (TYPE) zval_get_long(&$input);
$1 = &lvalue;
%}
%typemap(argout) TYPE *REFERENCE, TYPE &REFERENCE
%{
(*$arg)->value.lval = (long)(lvalue$argnum);
(*$arg)->type = IS_LONG;
ZVAL_LONG(&$arg, (long)(lvalue$argnum));
%}
%enddef
@ -128,16 +118,15 @@ INT_TYPEMAP(signed char);
INT_TYPEMAP(long long);
%typemap(argout,fragment="t_output_helper") long long *OUTPUT
{
zval *o;
MAKE_STD_ZVAL(o);
zval o;
if ((long long)LONG_MIN <= temp$argnum && temp$argnum <= (long long)LONG_MAX) {
ZVAL_LONG(o, temp$argnum);
ZVAL_LONG(&o, (long)temp$argnum);
} else {
char temp[256];
sprintf(temp, "%lld", (long long)temp$argnum);
ZVAL_STRING(o, temp, 1);
ZVAL_STRING(&o, temp);
}
t_output_helper( &$result, o TSRMLS_CC );
t_output_helper($result, &o);
}
%typemap(in) TYPE *REFERENCE (long long lvalue)
%{
@ -147,38 +136,35 @@ INT_TYPEMAP(long long);
%typemap(argout) long long *REFERENCE
%{
if ((long long)LONG_MIN <= lvalue$argnum && lvalue$argnum <= (long long)LONG_MAX) {
(*$arg)->value.lval = (long)(lvalue$argnum);
(*$arg)->type = IS_LONG;
ZVAL_LONG(&$arg, (long)temp$argnum);
} else {
char temp[256];
sprintf(temp, "%lld", (long long)lvalue$argnum);
ZVAL_STRING((*$arg), temp, 1);
ZVAL_STRING(&$arg, temp);
}
%}
%typemap(argout) long long &OUTPUT
%{
if ((long long)LONG_MIN <= *arg$argnum && *arg$argnum <= (long long)LONG_MAX) {
($result)->value.lval = (long)(*arg$argnum);
($result)->type = IS_LONG;
ZVAL_LONG($result, (long)(*arg$argnum));
} else {
char temp[256];
sprintf(temp, "%lld", (long long)(*arg$argnum));
ZVAL_STRING($result, temp, 1);
ZVAL_STRING($result, temp);
}
%}
INT_TYPEMAP(unsigned long long);
%typemap(argout,fragment="t_output_helper") unsigned long long *OUTPUT
{
zval *o;
MAKE_STD_ZVAL(o);
zval o;
if (temp$argnum <= (unsigned long long)LONG_MAX) {
ZVAL_LONG(o, temp$argnum);
ZVAL_LONG(&o, temp$argnum);
} else {
char temp[256];
sprintf(temp, "%llu", (unsigned long long)temp$argnum);
ZVAL_STRING(o, temp, 1);
ZVAL_STRING(&o, temp);
}
t_output_helper( &$result, o TSRMLS_CC );
t_output_helper($result, &o);
}
%typemap(in) TYPE *REFERENCE (unsigned long long lvalue)
%{
@ -188,23 +174,21 @@ INT_TYPEMAP(unsigned long long);
%typemap(argout) unsigned long long *REFERENCE
%{
if (lvalue$argnum <= (unsigned long long)LONG_MAX) {
(*$arg)->value.lval = (long)(lvalue$argnum);
(*$arg)->type = IS_LONG;
ZVAL_LONG($arg, (long)(lvalue$argnum));
} else {
char temp[256];
sprintf(temp, "%llu", (unsigned long long)lvalue$argnum);
ZVAL_STRING((*$arg), temp, 1);
ZVAL_STRING((*$arg), temp);
}
%}
%typemap(argout) unsigned long long &OUTPUT
%{
if (*arg$argnum <= (unsigned long long)LONG_MAX) {
($result)->value.lval = (long)(*arg$argnum);
($result)->type = IS_LONG;
ZVAL_LONG($result, (long)(*arg$argnum));
} else {
char temp[256];
sprintf(temp, "%llu", (unsigned long long)(*arg$argnum));
ZVAL_STRING($result, temp, 1);
ZVAL_STRING($result, temp);
}
%}
@ -270,18 +254,17 @@ INT_TYPEMAP(unsigned long long);
%typemap(in) char INPUT[ANY] ( char temp[$1_dim0] )
%{
convert_to_string_ex($input);
strncpy(temp,Z_STRVAL_PP($input),$1_dim0);
convert_to_string(&$input);
strncpy(temp, Z_STRVAL($input), $1_dim0);
$1 = temp;
%}
%typemap(in,numinputs=0) char OUTPUT[ANY] ( char temp[$1_dim0] )
"$1 = temp;";
%typemap(argout,fragment="t_output_helper") char OUTPUT[ANY]
{
zval *o;
MAKE_STD_ZVAL(o);
ZVAL_STRINGL(o,temp$argnum,$1_dim0);
t_output_helper( &$result, o TSRMLS_CC );
zval o;
ZVAL_STRINGL(&o, temp$argnum, $1_dim0);
t_output_helper($result, &o);
}
%typemap(in,numinputs=0) void **OUTPUT (int force),
@ -289,9 +272,9 @@ INT_TYPEMAP(unsigned long long);
%{
/* If they pass NULL by reference, make it into a void*
This bit should go in arginit if arginit support init-ing scripting args */
if(SWIG_ConvertPtr(*$input, (void **) &$1, $1_descriptor, 0) < 0) {
if (SWIG_ConvertPtr(&$input, (void **) &$1, $1_descriptor, 0) < 0) {
/* So... we didn't get a ref or ptr, but we'll accept NULL by reference */
if (!((*$input)->type==IS_NULL && PZVAL_IS_REF(*$input))) {
if (!(Z_ISREF($input) && Z_ISNULL_P(Z_REFVAL($input)))) {
/* wasn't a pre/ref/thing, OR anything like an int thing */
SWIG_PHP_Error(E_ERROR, "Type error in argument $arg of $symname.");
}
@ -313,7 +296,7 @@ INT_TYPEMAP(unsigned long long);
void *&OUTPUT
%{
if (force$argnum) { /* pass back arg$argnum through params ($arg) if we can */
if (!PZVAL_IS_REF(*$arg)) {
if (!Z_ISREF($arg)) {
SWIG_PHP_Error(E_WARNING, "Parameter $argnum of $symname wasn't passed by reference");
} else {
SWIG_SetPointerZval(*$arg, (void *) ptr$argnum, $*1_descriptor, 1);

78
Lib/php/utils.i
View file

@ -1,70 +1,65 @@
%define CONVERT_BOOL_IN(lvar,t,invar)
convert_to_boolean_ex(invar);
lvar = (t) Z_LVAL_PP(invar);
lvar = (t) zval_is_true(&invar);
%enddef
%define CONVERT_INT_IN(lvar,t,invar)
convert_to_long_ex(invar);
lvar = (t) Z_LVAL_PP(invar);
lvar = (t) zval_get_long(&invar);
%enddef
%define CONVERT_LONG_LONG_IN(lvar,t,invar)
switch ((*(invar))->type) {
switch (Z_TYPE(invar)) {
case IS_DOUBLE:
lvar = (t) (*(invar))->value.dval;
lvar = (t) Z_DVAL(invar);
break;
case IS_STRING: {
char * endptr;
errno = 0;
lvar = (t) strtoll((*(invar))->value.str.val, &endptr, 10);
lvar = (t) strtoll(Z_STRVAL(invar), &endptr, 10);
if (*endptr && !errno) break;
/* FALL THRU */
}
default:
convert_to_long_ex(invar);
lvar = (t) (*(invar))->value.lval;
lvar = (t) zval_get_long(&invar);
}
%enddef
%define CONVERT_UNSIGNED_LONG_LONG_IN(lvar,t,invar)
switch ((*(invar))->type) {
switch (Z_TYPE(invar)) {
case IS_DOUBLE:
lvar = (t) (*(invar))->value.dval;
lvar = (t) Z_DVAL(invar);
break;
case IS_STRING: {
char * endptr;
errno = 0;
lvar = (t) strtoull((*(invar))->value.str.val, &endptr, 10);
lvar = (t) strtoull(Z_STRVAL(invar), &endptr, 10);
if (*endptr && !errno) break;
/* FALL THRU */
}
default:
convert_to_long_ex(invar);
lvar = (t) (*(invar))->value.lval;
lvar = (t) zval_get_long(&invar);
}
%enddef
%define CONVERT_INT_OUT(lvar,invar)
lvar = (t) Z_LVAL_PP(invar);
lvar = (t) zval_get_long(&invar);
%enddef
%define CONVERT_FLOAT_IN(lvar,t,invar)
convert_to_double_ex(invar);
lvar = (t) Z_DVAL_PP(invar);
lvar = (t) zval_get_double(&invar);
%enddef
%define CONVERT_CHAR_IN(lvar,t,invar)
convert_to_string_ex(invar);
lvar = (t) *Z_STRVAL_PP(invar);
convert_to_string(&invar);
lvar = (t) Z_STRVAL(invar)[0];
%enddef
%define CONVERT_STRING_IN(lvar,t,invar)
if ((*invar)->type==IS_NULL) {
if (Z_ISNULL(invar)) {
lvar = (t) 0;
} else {
convert_to_string_ex(invar);
lvar = (t) Z_STRVAL_PP(invar);
convert_to_string(&invar);
lvar = (t) Z_STRVAL(invar);
}
%enddef
@ -80,35 +75,42 @@
%}
%typemap(directorout) TYPE
%{
CONVERT_IN($result,$1_ltype,&$input);
if (!EG(exception)) {
CONVERT_IN($result, $1_ltype, *$input);
} else {
typedef $1_ltype swig_result_typedef;
$result = swig_result_typedef();
}
%}
%typemap(directorout) const TYPE & ($*1_ltype temp)
%{
CONVERT_IN(temp,$*1_ltype,&$input);
if (!EG(exception)) {
CONVERT_IN(temp, $*1_ltype, *$input);
} else {
typedef $*1_ltype swig_result_typedef;
temp = swig_result_typedef();
}
$result = &temp;
%}
%enddef
%fragment("t_output_helper","header") %{
static void
t_output_helper(zval **target, zval *o TSRMLS_DC) {
zval *tmp;
if ( (*target)->type == IS_ARRAY ) {
t_output_helper(zval *target, zval *o) {
zval tmp;
if (Z_TYPE_P(target) == IS_ARRAY) {
/* it's already an array, just append */
add_next_index_zval( *target, o );
add_next_index_zval(target, o);
return;
}
if ( (*target)->type == IS_NULL ) {
REPLACE_ZVAL_VALUE(target,o,1);
FREE_ZVAL(o);
if (Z_TYPE_P(target) == IS_NULL) {
/* NULL isn't refcounted */
ZVAL_COPY_VALUE(target, o);
return;
}
ALLOC_INIT_ZVAL(tmp);
*tmp = **target;
zval_copy_ctor(tmp);
array_init(*target);
add_next_index_zval( *target, tmp);
add_next_index_zval( *target, o);
ZVAL_DUP(&tmp, target);
array_init(target);
add_next_index_zval(target, &tmp);
add_next_index_zval(target, o);
}
%}