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

Fairly major update to php code generation and type library. Brief summary:

Browse source 
- Revised simplified makefile generation using -make switch.
 - Proper support of in, out, argout, ret typemaps.
 - Function overloading with typecheck typemap support.
 - Fragment inclusion in typemaps.
 - Proper handling of object destructors relying on PHP's reference counting.
 - Constants using consttab and varinit typemaps.
 - Global variables using varinit typemaps.
 - Can generate C++ bindings using either objects or no objects (-noproxy).
 - Special phppointer.i typemaps for using php references for pointer passing.


git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk@7392 626c5289-ae23-0410-ae9c-e8d60b6d4f22
This commit is contained in:
Kevin Ruland 2005-08-24 17:10:11 +00:00
commit 6c87325b91
9 changed files with 1605 additions and 1731 deletions
Download patch file Download diff file Expand all files Collapse all files

46
SWIG/Lib/php4/const.i Normal file
View file

@ -0,0 +1,46 @@
/* Typemaps for constants */
%typemap(consttab) int,
unsigned int,
short,
unsigned short,
long,
unsigned long,
unsigned char,
signed char,
bool,
enum SWIGTYPE
"REGISTER_LONG_CONSTANT( \"$symname\", $value, CONST_CS | CONST_PERSISTENT);";
%typemap(consttab) float,
double
"REGISTER_DOUBLE_CONSTANT(\"$symname\", $value, CONST_CS | CONST_PERSISTENT);";
%typemap(consttab) char
"REGISTER_STRING_CONSTANT(\"$symname\", \"$value\", CONST_CS | CONST_PERSISTENT );";
%typemap(consttab) char *,
const char *,
char [],
const char []
"REGISTER_STRING_CONSTANT(\"$symname\", $value, CONST_CS | CONST_PERSISTENT);";
%typemap(consttab) SWIGTYPE *,
SWIGTYPE &,
SWIGTYPE [] {
// This actually registers it as a global variable and constant. I don't like it, but I can't figure out
// the zend_constant code...
zval *z_var;
MAKE_STD_ZVAL(z_var);
SWIG_SetPointerZval(z_var, (void*)$value, $1_descriptor, 0);
//zend_hash_add(&EG(symbol_table), "$1", strlen("$1")+1, (void *)&z_var,sizeof(zval *), NULL);
zend_constant c;
c.value = *z_var;
zval_copy_ctor(&c.value);
size_t len = strlen("$1");
c.name = zend_strndup( "$1", len );
c.name_len = len+1;
c.flags = CONST_CS | CONST_PERSISTENT;
c.module_number = module_number;
zend_register_constant( &c TSRMLS_CC );
}

327
SWIG/Lib/php4/globalvar.i Normal file
View file

@ -0,0 +1,327 @@
/* Global variables - add the variable to PHP */
%typemap(varinit) char *,
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);
} else {
z_var->value.str.val = 0;
z_var->value.str.len = 0;
}
zend_hash_add(&EG(symbol_table), "$1", strlen("$1")+1, (void *)&z_var, sizeof(zval *), NULL);
}
%typemap(varinit) int,
unsigned int,
unsigned short,
short,
unsigned short,
long,
unsigned long,
signed char,
unsigned char,
enum SWIGTYPE
{
zval *z_var;
MAKE_STD_ZVAL(z_var);
z_var->type = IS_LONG;
z_var->value.lval = $1;
zend_hash_add(&EG(symbol_table), "$1", strlen("$1")+1, (void *)&z_var, sizeof(zval *), NULL);
}
%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), "$1", strlen("$1")+1, (void *)&z_var, sizeof(zval *), NULL);
}
%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), "$1", strlen("$1")+1, (void *)&z_var,
sizeof(zval *), NULL);
}
%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 = estrdup(c);
z_var->value.str.len = 2;
zend_hash_add(&EG(symbol_table), "$1", strlen("$1")+1, (void *)&z_var,
sizeof(zval *), NULL);
}
%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), "$1", strlen("$1")+1, (void *)&z_var,
sizeof(zval *), NULL);
}
%typemap(varinit) SWIGTYPE, SWIGTYPE &
{
$&1_ltype argp;
zval *z_var;
MAKE_STD_ZVAL(z_var);
SWIG_SetPointerZval(z_var, (void*)&$1, $&1_descriptor, 0);
zend_hash_add(&EG(symbol_table), "$1", strlen("$1")+1, (void*)&z_var,
sizeof(zval *), NULL);
}
%typemap(varinit) char [ANY]
{
zval *z_var;
MAKE_STD_ZVAL(z_var);
z_var->type = IS_STRING;
if($1) {
// varinit char [ANY]
ZVAL_STRINGL(z_var,(char*)$1, $1_dim0, 1);
}
zend_hash_add(&EG(symbol_table), "$1", strlen("$1")+1, (void*)&z_var,
sizeof(zval *), NULL);
}
%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), "$1",strlen("$1")+1, (void**)&z_var);
convert_to_long_ex(z_var);
if($1 != ($1_ltype)((*z_var)->value.lval)) {
$1 = Z_LVAL_PP(z_var);
}
}
%typemap(varin) bool
{
zval **z_var;
zend_hash_find(&EG(symbol_table), "$1",strlen("$1")+1, (void**)&z_var);
convert_to_boolean_ex(z_var);
if($1 != ($1_ltype)((*z_var)->value.lval)) {
$1 = Z_LVAL_PP(z_var);
}
}
%typemap(varin) double,float
{
zval **z_var;
zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var);
convert_to_double_ex(z_var);
if($1 != ($1_ltype)((*z_var)->value.dval)) {
$1 = Z_DVAL_PP(z_var);
}
}
%typemap(varin) char
{
zval **z_var;
zend_hash_find(&EG(symbol_table), "$1",strlen("$1")+1, (void**)&z_var);
convert_to_string_ex(z_var);
if($1 != *((*z_var)->value.str.val)) {
$1 = *((*z_var)->value.str.val);
}
}
%typemap(varin) char *
{
zval **z_var;
char *s1;
zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var);
convert_to_string_ex(z_var);
s1 = Z_STRVAL_PP(z_var);
if((s1 == NULL) || ($1 == NULL) || zend_binary_strcmp(s1, strlen(s1), $1, strlen($1))) {
if(s1)
$1 = estrdup(s1);
else
$1 = NULL;
}
}
%typemap(varin) SWIGTYPE []
{
zval **z_var;
zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var);
if($1) {
SWIG_SetPointerZval(*z_var, (void*)$1, $1_descriptor, $owner);
}
}
%typemap(varin) char [ANY]
{
zval **z_var;
char *s1;
zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var);
s1 = Z_STRVAL_PP(z_var);
if((s1 == NULL) || ($1 == NULL) || zend_binary_strcmp(s1, strlen(s1), $1, strlen($1))) {
if(s1)
strncpy($1, s1, $1_dim0);
}
}
%typemap(varin) SWIGTYPE
{
zval **z_var;
$&1_ltype _temp;
zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var);
if (SWIG_ConvertPtr(*z_var, (void**)&_temp, $&1_descriptor) < 0) {
SWIG_PHP_Error(E_ERROR,"Type error in value of $symname. Expected $&1_descriptor");
}
$1 = *($&1_ltype)_temp;
}
%typemap(varin) SWIGTYPE *, SWIGTYPE &
{
zval **z_var;
$1_ltype _temp;
zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var);
if (SWIG_ConvertPtr(*z_var, (void **)&_temp, $1_descriptor) < 0) {
SWIG_PHP_Error(E_ERROR,"Type error in value of $symname. Expected $&1_descriptor");
}
$1 = ($1_ltype)_temp;
}
%typemap(varout) int,
unsigned int,
unsigned short,
short,
long,
unsigned long,
signed char,
unsigned char,
enum SWIGTYPE
{
zval **z_var;
zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var);
if($1 != ($1_ltype)((*z_var)->value.lval)) {
(*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), "$1", strlen("$1")+1, (void**)&z_var);
if($1 != ($1_ltype)((*z_var)->value.lval)) {
(*z_var)->value.lval = (long)$1;
}
}
%typemap(varout) double, float
{
zval **z_var;
zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var);
if($1 != ($1_ltype)((*z_var)->value.dval)) {
(*z_var)->value.dval = (double)$1;
}
}
%typemap(varout) char
{
zval **z_var;
zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+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);
}
}
%typemap(varout) char *
{
zval **z_var;
char *s1;
zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var);
s1 = Z_STRVAL_PP(z_var);
if((s1 == NULL) || ($1 == NULL) || zend_binary_strcmp(s1, strlen(s1), $1, strlen($1) )) {
if(s1)
efree(s1);
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;
}
}
}
%typemap(varout) SWIGTYPE
{
zval **z_var;
zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var);
SWIG_SetPointerZval(*z_var, (void*)&$1, $&1_descriptor, 0);
}
%typemap(varout) SWIGTYPE []
{
zval **z_var;
zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var);
if($1)
SWIG_SetPointerZval(*z_var, (void*)$1, $1_descriptor, 0);
}
%typemap(varout) char [ANY]
{
zval **z_var;
char *s1;
deliberate error cos this code looks bogus to me
zend_hash_find(&EG(symbol_table), "$1" ,strlen("$1")+1, (void**)&z_var);
s1 = Z_STRVAL_PP(z_var);
if((s1 == NULL) || zend_binary_strcmp(s1, strlen(s1), $1, strlen($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;
}
}
}
%typemap(varout) SWIGTYPE *, SWIGTYPE &
{
zval **z_var;
zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var);
SWIG_SetPointerZval(*z_var, (void*)$1, $1_descriptor, 0);
}

564
SWIG/Lib/php4/php4.swg
View file

@ -5,61 +5,91 @@
*
*/
%runtime "swigrun.swg" // Common C API type-checking code
%runtime "php4run.swg" // Php4 runtime functions
%include "utils.i" // building blocks
%runtime "swigrun.swg" // Common C API type-checking code
%runtime "php4run.swg" // Php4 runtime functions
%init "swiginit.swg"
%include "php4init.swg" // Php4 initialization routine.
%include "globalvar.i" // Global variables.
%include "const.i"
/* Typemaps for input parameters by value */
%typemap(in) int, unsigned int, unsigned short, short, unsigned short, long, unsigned long, signed char, unsigned char, enum SWIGTYPE %{
convert_to_long_ex($input);
$1 = ($1_ltype) Z_LVAL_PP($input);
%}
%include "utils.i"
%typemap(in) bool %{
convert_to_boolean_ex($input);
$1 = ($1_ltype) Z_LVAL_PP($input);
%}
%pass_by_val(bool,CONVERT_BOOL_IN);
%typemap(in) char %{
convert_to_string_ex($input);
$1 = ($1_ltype) *Z_STRVAL_PP($input);
%}
%pass_by_val(size_t, CONVERT_INT_IN);
%typemap(in) float,double %{
convert_to_double_ex($input);
$1 = ($1_ltype) Z_DVAL_PP($input);
%}
%pass_by_val(enum SWIGTYPE, CONVERT_INT_IN);
// char * is input only normally
%typemap(in) char * %{
convert_to_string_ex($input);
$1 = ($1_ltype) Z_STRVAL_PP($input);
%}
%pass_by_val(signed int, CONVERT_INT_IN);
%pass_by_val(int,CONVERT_INT_IN);
%pass_by_val(unsigned int,CONVERT_INT_IN);
%pass_by_val(signed short, CONVERT_INT_IN);
%pass_by_val(short,CONVERT_INT_IN);
%pass_by_val(unsigned short, CONVERT_INT_IN);
%pass_by_val(signed long, CONVERT_INT_IN);
%pass_by_val(long, CONVERT_INT_IN);
%pass_by_val(unsigned long, CONVERT_INT_IN);
%pass_by_val(signed char, CONVERT_INT_IN);
%pass_by_val(char, CONVERT_CHAR_IN);
%pass_by_val(unsigned char, CONVERT_INT_IN);
%pass_by_val(float, CONVERT_FLOAT_IN);
%pass_by_val(double, CONVERT_FLOAT_IN);
%pass_by_val(char *, CONVERT_STRING_IN);
// char array can be in/out, though the passed string may not be big enough...
// so we have to size it
strarray_inout(char [ANY])
%typemap(in) char[ANY]
{
convert_to_string_ex($input);
$1 = ($1_ltype) Z_STRVAL_PP($input);
}
%typemap(in) SWIGTYPE *, SWIGTYPE [], SWIGTYPE & %{
if(SWIG_ConvertPtr(*$input, (void **) &$1, $1_descriptor) < 0) {
zend_error(E_ERROR, "Type error in argument %d of $symname. Expected %s", $argnum-argbase, $1_descriptor->name);
/* Object passed by value. Convert to a pointer */
%typemap(in) SWIGTYPE ($&1_ltype tmp)
{
if(SWIG_ConvertPtr(*$input, (void **) &tmp, $&1_descriptor) < 0) {
SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $&1_descriptor");
}
%}
$1 = *tmp;
}
%typemap(in) SWIGTYPE *,
SWIGTYPE [],
SWIGTYPE &
{
/* typemap(in) SWIGTYPE * */
if(SWIG_ConvertPtr(*$input, (void **) &$1, $1_descriptor) < 0) {
SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $&1_descriptor");
}
}
%typemap(argout) SWIGTYPE *,
SWIGTYPE [],
SWIGTYPE&;
%typemap(in) void * %{
%typemap(in) void *
{
if(SWIG_ConvertPtr(*$input, (void **) &$1, 0) < 0) {
/* Allow NULL from php for void* */
if ((*$input)->type==IS_NULL) $1=0;
else zend_error(E_ERROR, "Type error in argument %d of $symname. Expected %s", $argnum-argbase, $1_descriptor->name);
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 */
%typemap(in) void ** ($*1_ltype ptr, int force), void *& ($*1_ltype ptr, int force) %{
%typemap(in) void ** ($*1_ltype ptr, int force),
void *& ($*1_ltype ptr, int force)
{
/* 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) {
@ -75,62 +105,72 @@ strarray_inout(char [ANY])
force=1;
} else { /* wasn't a pre/ref/thing, OR anything like an int thing */
force=0;
zend_error(E_ERROR, "Type error in argument %d of $symname. Expected %s or %s or at least NULL passed by reference", $argnum-argbase, $1_descriptor->name,$*1_descriptor->name);
SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $1_descriptor");
}
} else force=0;
%}
%typemap(argout) void **, void *& %{
if (force$argnum) { /* pass back arg$argnum through params ($arg) if we can */
if(! PZVAL_IS_REF(*$arg)) {
zend_error(E_WARNING, "Parameter %d of $symname wasn't passed by reference: [argout void**, void*&]",$argnum-argbase);
} else {
SWIG_SetPointerZval(*$arg, (void *) ptr$argnum, $*1_descriptor, 1);
}
}
%typemap(argout) void **,
void *&
{
if (force$argnum) {
SWIG_SetPointerZval( *$input, (void*) ptr$argnum, $*1_descriptor, 1);
}
%}
/* Object passed by value. Convert to a pointer */
%typemap(in) SWIGTYPE {
$&1_ltype argp;
if(SWIG_ConvertPtr(*$input, (void **) &argp, $&1_descriptor) < 0) {
zend_error(E_ERROR, "Type error in argument %d of $symname. Expected %s", $argnum-argbase, $&1_descriptor->name);
}
$1 = *argp;
}
/* Typemap for output values */
%typemap(out) int, unsigned int, short, unsigned short, long, unsigned long, signed char, unsigned char, bool, enum SWIGTYPE %{
%typemap(out) int,
unsigned int,
short,
unsigned short,
long,
unsigned long,
signed char,
unsigned char,
bool,
size_t,
enum SWIGTYPE
{
ZVAL_LONG(return_value,$1);
%}
}
%typemap(out) bool %{
%typemap(out) bool
{
ZVAL_BOOL(return_value,($1)?1:0);
%}
}
%typemap(out) float, double %{
%typemap(out) float,
double
{
ZVAL_DOUBLE(return_value,$1);
%}
}
%typemap(out) char %{
%typemap(out) char
{
// out char
ZVAL_STRINGL(return_value,$1, 1, 1);
%}
ZVAL_STRINGL(return_value,&$1, 1, 1);
}
%typemap(out) char * %{
%typemap(out) char *,
char []
{
if(!$1) {
ZVAL_NULL(return_value);
} else {
ZVAL_STRING(return_value,$1, 1);
}
%}
}
%typemap(out) SWIGTYPE *, SWIGTYPE [], SWIGTYPE & %{
%typemap(out) SWIGTYPE *,
SWIGTYPE [],
SWIGTYPE &
{
SWIG_SetPointerZval(return_value, (void *)$1, $1_descriptor, $owner);
%}
}
%typemap(out) SWIGTYPE *DYNAMIC, SWIGTYPE &DYNAMIC {
%typemap(out) SWIGTYPE *DYNAMIC,
SWIGTYPE &DYNAMIC
{
swig_type_info *ty = SWIG_TypeDynamicCast($1_descriptor, (void **) &$1);
SWIG_SetPointerZval(return_value, (void *)$1, ty, $owner);
}
@ -151,362 +191,50 @@ strarray_inout(char [ANY])
%typemap(out) void "";
/* Typemap for character array returns */
%typemap(out) char [ANY] {
// out char any
ZVAL_STRINGL(return_value,$1, $1_dim0, 1);
}
/* Typemap for in/argout references
NOTE: we don't choose to use these for arrays yet, maybe later */
%typemap_inout_ord(bool,convert_to_boolean_ex,ZVAL_BOOL)
%typemap_inout_ord(int,convert_to_long_ex,ZVAL_LONG)
%typemap_inout_ord(unsigned int,convert_to_long_ex,ZVAL_LONG)
%typemap_inout_ord(short,convert_to_long_ex,ZVAL_LONG)
%typemap_inout_ord(unsigned short,convert_to_long_ex,ZVAL_LONG)
%typemap_inout_ord(long,convert_to_long_ex,ZVAL_LONG)
%typemap_inout_ord(unsigned long,convert_to_long_ex,ZVAL_LONG)
%typemap_inout_ord(signed char,convert_to_long_ex,ZVAL_LONG)
%typemap_inout_ord(unsigned char,convert_to_long_ex,ZVAL_LONG)
%typemap_inout_ord(enum SWIGTYPE,convert_to_long_ex,ZVAL_LONG)
/* Global variables - add the variable to PHP */
%typemap(varinit) char *
%typemap(out) char [ANY]
{
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);
} else {
z_var->value.str.val = 0;
z_var->value.str.len = 0;
}
zend_hash_add(&EG(symbol_table), "$1", strlen("$1")+1, (void *)&z_var, sizeof(zval *), NULL);
size_t len = strnlen($1,$1_dim0);
RETVAL_STRINGL($1,len,1);
}
%typemap(varinit) int, unsigned int, unsigned short, short, unsigned short, long, unsigned long, signed char, unsigned char, bool, enum SWIGTYPE
%define %php_typecheck(_type,_prec,is)
%typemap(typecheck,precedence=_prec) _type
" $1 = Z_TYPE_PP($input) == is ? 1 : 0; "
%enddef
%php_typecheck(int,SWIG_TYPECHECK_INTEGER,IS_LONG)
%php_typecheck(unsigned int,SWIG_TYPECHECK_UINT32,IS_LONG)
%php_typecheck(short,SWIG_TYPECHECK_INT16,IS_LONG)
%php_typecheck(unsigned short,SWIG_TYPECHECK_UINT16,IS_LONG)
%php_typecheck(long,SWIG_TYPECHECK_INT64,IS_LONG)
%php_typecheck(unsigned long,SWIG_TYPECHECK_UINT64,IS_LONG)
%php_typecheck(signed char,SWIG_TYPECHECK_INT8,IS_LONG)
%php_typecheck(unsigned char,SWIG_TYPECHECK_UINT8,IS_LONG)
%php_typecheck(size_t,SWIG_TYPECHECK_INT16,IS_LONG)
%php_typecheck(enum SWIGTYPE,SWIG_TYPECHECK_INT8,IS_LONG)
%php_typecheck(bool,SWIG_TYPECHECK_BOOL,IS_BOOL)
%php_typecheck(char,SWIG_TYPECHECK_CHAR,IS_STRING)
%php_typecheck(char *,SWIG_TYPECHECK_STRING,IS_STRING)
%php_typecheck(char [],SWIG_TYPECHECK_STRING,IS_STRING)
%php_typecheck(float,SWIG_TYPECHECK_FLOAT,IS_DOUBLE)
%php_typecheck(double,SWIG_TYPECHECK_BOOL,IS_DOUBLE)
%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE
" /* typecheck SWIGTYPE */ "
%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *,
SWIGTYPE [],
SWIGTYPE &
{
zval *z_var;
MAKE_STD_ZVAL(z_var);
z_var->type = IS_LONG;
z_var->value.lval = $1;
zend_hash_add(&EG(symbol_table), "$1", strlen("$1")+1, (void *)&z_var, sizeof(zval *), NULL);
/* typecheck SWIGTYPE * */
void *tmp;
_v = (SWIG_ConvertPtr( *$input, (void**)&tmp, $1_descriptor) < 0)? 0:1;
}
%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), "$1", strlen("$1")+1, (void *)&z_var, sizeof(zval *), NULL);
}
%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), "$1", strlen("$1")+1, (void *)&z_var,
sizeof(zval *), NULL);
}
%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 = estrdup(c);
z_var->value.str.len = 2;
zend_hash_add(&EG(symbol_table), "$1", strlen("$1")+1, (void *)&z_var,
sizeof(zval *), NULL);
}
%typemap(varinit) SWIGTYPE *, SWIGTYPE &, SWIGTYPE []
{
zval *z_var;
MAKE_STD_ZVAL(z_var);
SWIG_SetPointerZval(z_var, (void*)$1, $1_descriptor, $owner);
zend_hash_add(&EG(symbol_table), "$1", strlen("$1")+1, (void *)&z_var,
sizeof(zval *), NULL);
}
%typemap(varinit) SWIGTYPE
{
$&1_ltype argp;
zval *z_var;
MAKE_STD_ZVAL(z_var);
SWIG_SetPointerZval(z_var, (void*)&$1, $&1_descriptor, $owner);
zend_hash_add(&EG(symbol_table), "$1", strlen("$1")+1, (void*)&z_var,
sizeof(zval *), NULL);
}
%typemap(varinit) char [ANY]
{
zval *z_var;
MAKE_STD_ZVAL(z_var);
z_var->type = IS_STRING;
if($1) {
// varinit char [ANY]
ZVAL_STRINGL(z_var,$1, $1_dim0, 1);
}
zend_hash_add(&EG(symbol_table), "$1", strlen("$1")+1, (void*)&z_var,
sizeof(zval *), NULL);
}
%typemap(varin) int, unsigned int, unsigned short, short, unsigned short, long, unsigned long, signed char, unsigned char, enum SWIGTYPE
{
zval **z_var;
zend_hash_find(&EG(symbol_table), "$1",strlen("$1")+1, (void**)&z_var);
convert_to_long_ex(z_var);
if($1 != ($1_ltype)((*z_var)->value.lval)) {
$1 = Z_LVAL_PP(z_var);
}
}
%typemap(varin) bool
{
zval **z_var;
zend_hash_find(&EG(symbol_table), "$1",strlen("$1")+1, (void**)&z_var);
convert_to_boolean_ex(z_var);
if($1 != ($1_ltype)((*z_var)->value.lval)) {
$1 = Z_LVAL_PP(z_var);
}
}
%typemap(varin) double,float
{
zval **z_var;
zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var);
convert_to_double_ex(z_var);
if($1 != ($1_ltype)((*z_var)->value.dval)) {
$1 = Z_DVAL_PP(z_var);
}
}
%typemap(varin) char
{
zval **z_var;
zend_hash_find(&EG(symbol_table), "$1",strlen("$1")+1, (void**)&z_var);
convert_to_string_ex(z_var);
if($1 != *((*z_var)->value.str.val)) {
$1 = *((*z_var)->value.str.val);
}
}
%typemap(varin) char *
{
zval **z_var;
char *s1;
zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var);
convert_to_string_ex(z_var);
s1 = Z_STRVAL_PP(z_var);
if((s1 == NULL) || ($1 == NULL) || zend_binary_strcmp(s1, strlen(s1), $1, strlen($1))) {
if(s1)
$1 = estrdup(s1);
else
$1 = NULL;
}
}
%typemap(varin) SWIGTYPE []
{
zval **z_var;
zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var);
if($1) {
SWIG_SetPointerZval(*z_var, (void*)$1, $1_descriptor, $owner);
}
}
%typemap(varin) char [ANY]
{
zval **z_var;
char *s1;
zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var);
s1 = Z_STRVAL_PP(z_var);
if((s1 == NULL) || ($1 == NULL) || zend_binary_strcmp(s1, strlen(s1), $1, strlen($1))) {
if(s1)
strncpy($1, s1, $1_dim0);
}
}
%typemap(varin) SWIGTYPE
{
zval **z_var;
$&1_ltype _temp;
zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var);
if (SWIG_ConvertPtr(*z_var, (void**)&_temp, $&1_descriptor) < 0) {
zend_error(E_ERROR, "Type error in value of $symname. Expected %s", $&1_descriptor->name);
}
$1 = *($&1_ltype)_temp;
}
%typemap(varin) SWIGTYPE *, SWIGTYPE &
{
zval **z_var;
$1_ltype _temp;
zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var);
if (SWIG_ConvertPtr(*z_var, (void **)&_temp, $1_descriptor) < 0) {
zend_error(E_ERROR, "Type error in value of $symname. Expected %s", $1_descriptor->name);
}
$1 = ($1_ltype)_temp;
}
%typemap(varout) int, unsigned int, unsigned short, short, unsigned short, long, unsigned long, signed char, unsigned char, enum SWIGTYPE
{
zval **z_var;
zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var);
if($1 != ($1_ltype)((*z_var)->value.lval)) {
(*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), "$1", strlen("$1")+1, (void**)&z_var);
if($1 != ($1_ltype)((*z_var)->value.lval)) {
(*z_var)->value.lval = (long)$1;
}
}
%typemap(varout) double, float
{
zval **z_var;
zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var);
if($1 != ($1_ltype)((*z_var)->value.dval)) {
(*z_var)->value.dval = (double)$1;
}
}
%typemap(varout) char
{
zval **z_var;
zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+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);
}
}
%typemap(varout) char *
{
zval **z_var;
char *s1;
zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var);
s1 = Z_STRVAL_PP(z_var);
if((s1 == NULL) || ($1 == NULL) || zend_binary_strcmp(s1, strlen(s1), $1, strlen($1) )) {
if(s1)
efree(s1);
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;
}
}
}
%typemap(varout) SWIGTYPE
{
zval **z_var;
zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var);
SWIG_SetPointerZval(*z_var, (void*)&$1, $&1_descriptor, $owner);
}
%typemap(varout) SWIGTYPE []
{
zval **z_var;
zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var);
if($1)
SWIG_SetPointerZval(*z_var, (void*)$1, $1_descriptor, $owner);
}
%typemap(varout) char [ANY]
{
zval **z_var;
char *s1;
deliberate error cos this code looks bogus to me
zend_hash_find(&EG(symbol_table), "$1" ,strlen("$1")+1, (void**)&z_var);
s1 = Z_STRVAL_PP(z_var);
if((s1 == NULL) || zend_binary_strcmp(s1, strlen(s1), $1, strlen($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;
}
}
}
%typemap(varout) SWIGTYPE *, SWIGTYPE &
{
zval **z_var;
zend_hash_find(&EG(symbol_table), "$1", strlen("$1")+1, (void**)&z_var);
SWIG_SetPointerZval(*z_var, (void*)$1, $1_descriptor, $owner);
}
/* Typemaps for constants */
%typemap(consttab) int, unsigned int, short, unsigned short, long, unsigned long, unsigned char, signed char, bool, enum SWIGTYPE
"REGISTER_LONG_CONSTANT( \"$symname\", $value, CONST_CS | CONST_PERSISTENT);";
%typemap(consttab) float, double
"REGISTER_DOUBLE_CONSTANT(\"$symname\", $value, CONST_CS | CONST_PERSISTENT);";
%typemap(consttab) char, char *
"REGISTER_STRING_CONSTANT(\"$symname\", \"$value\", CONST_CS | CONST_PERSISTENT);";
%typemap(consttab) SWIGTYPE *, SWIGTYPE &, SWIGTYPE [] {
char *cp;
SWIG_SetPointerChar(&cp, (void*)$value, $1_descriptor);
REGISTER_STRING_CONSTANT("$symname", cp, CONST_CS | CONST_PERSISTENT);
}
/* Some ANSI C typemaps */
%apply unsigned long { size_t };
%init %{
SWIG_php_minit {
SWIG_InitializeModule(0);
%}
%typecheck(SWIG_TYPECHECK_VOIDPTR) void *
" /* tyepcheck void * */ "
/* php kewords */
/* please test and activate */

12
SWIG/Lib/php4/php4init.swg Normal file
View file

@ -0,0 +1,12 @@
/* ------------------------------------------------------------
* The start of the PHP initialization function
* ------------------------------------------------------------ */
%insert(init) "swiginit.swg"
%init %{
SWIG_php_minit {
SWIG_InitializeModule(0);
%}

62
SWIG/Lib/php4/php4run.swg
View file

@ -31,6 +31,18 @@ extern "C" {
}
#endif
#define SWIG_fail goto fail
static char *default_error_msg = "Unknown error occurred";
static int default_error_code = E_ERROR;
#define SWIG_PHP_Arg_Error_Msg(argnum,extramsg) "Error in argument " #argnum " "#extramsg
#define SWIG_PHP_Error(code,msg) ErrorCode() = code; ErrorMsg() = msg; SWIG_fail;
#define SWIG_contract_assert(expr,msg) \
if (!(expr) ) { zend_printf("Contract Assert Failed %s\n",msg ); } else
/* Standard SWIG API */
#define SWIG_GetModule(clientdata) SWIG_Php4_GetModule()
#define SWIG_SetModule(clientdata, pointer) SWIG_Php4_SetModule(pointer)
@ -42,56 +54,24 @@ typedef struct _swig_object_wrapper {
int newobject;
} swig_object_wrapper;
/* local scope self_constructors are set to 1 inside function wrappers
which are also class constructors, so that the php4.swg output typemaps
know whether or not to wrap returned objects in this_ptr or a new object */
int self_constructor=0;
/* empty zend destructor for types without one */
static ZEND_RSRC_DTOR_FUNC(SWIG_landfill) {};
/* This one makes old swig style string pointers but the php module doesn't
use these any more. This is just left here for old times sake and may go */
static void
SWIG_MakePtr(char *c, void *ptr, swig_type_info *ty) {
static char hex[17] = "0123456789abcdef";
unsigned long p, s;
char data[32], *r;
r = data;
p = (unsigned long) ptr;
if (p > 0) {
while (p > 0) {
s = p & 0xf;
*(r++) = hex[s];
p = p >> 4;
}
*r = '_';
while (r >= data) {
*(c++) = *(r--);
}
strcpy (c, ty->name);
} else {
strcpy (c, "NULL");
}
}
static void
SWIG_SetPointerChar(char **c, void *ptr, swig_type_info *type) {
char data[512];
SWIG_MakePtr(data, ptr, type);
*c = estrdup(data);
}
#define SWIG_SetPointerZval(a,b,c,d) SWIG_ZTS_SetPointerZval(a,b,c,d, SWIG_module_entry TSRMLS_CC)
static void
SWIG_ZTS_SetPointerZval(zval *z, void *ptr, swig_type_info *type, int newobject, zend_module_entry* module_entry TSRMLS_DC) {
swig_object_wrapper *value=NULL;
/* No need to call SWIG_MakePtr here! */
/*
* First test for Null pointers. Return those as PHP native NULL
*/
if (!ptr ) {
ZVAL_NULL(z);
return;
}
if (type->clientdata) {
if (! (*(int *)(type->clientdata))) zend_error(E_ERROR, "Type: %s failed to register with zend",type->name);
if (! (*(int *)(type->clientdata)))
zend_error(E_ERROR, "Type: %s failed to register with zend",type->name);
value=(swig_object_wrapper *)emalloc(sizeof(swig_object_wrapper));
value->ptr=ptr;
value->newobject=newobject;

23
SWIG/Lib/php4/phppointers.i Normal file
View file

@ -0,0 +1,23 @@
%define %pass_by_ref( TYPE, CONVERT_IN, CONVERT_OUT )
%typemap(in) TYPE * ($*1_ltype tmp),
TYPE & ($*1_ltype tmp)
{
/* First Check for SWIG wrapped type */
if ( ZVAL_IS_NULL( *$input ) ) {
$1 = 0;
} else if ( PZVAL_IS_REF( *$input ) ) {
/* Not swig wrapped type, so we check if it's a PHP reference type */
CONVERT_IN( tmp, $*1_ltype, $input );
$1 = &tmp;
} else {
SWIG_PHP_Error( E_ERROR, SWIG_PHP_Arg_Error_Msg($argnum, Excpeted a reference) );
}
}
%typemap(argout) TYPE *,
TYPE & {
CONVERT_OUT(*$input, tmp$argnum );
}
%enddef
%pass_by_ref( int, CONVERT_INT_IN, ZVAL_LONG );
%pass_by_ref( double, CONVERT_FLOAT_IN, ZVAL_DOUBLE );

327
SWIG/Lib/php4/typemaps.i
View file

@ -11,90 +11,100 @@
// ever need to write a typemap.
//
%typemap(in) double *INPUT(double temp)
//
// Define macros to define the following typemaps:
//
// INPUT arguments by Pointer
// OUTPUT arguments by Pointer
// INPUT arguments by Php reference
// OUTPUT arguments by Php reference
//
%define double_typemap(TYPE)
%typemap(in) TYPE *INPUT(TYPE temp)
{
temp = (double) Z_DVAL_PP($input);
$1 = &temp;
temp = (TYPE) Z_DVAL_PP($input);
$1 = &temp;
}
%typemap(in) float *INPUT(float temp)
{
temp = (float) Z_DVAL_PP($input);
$1 = &temp;
}
%typemap(in) int *INPUT(int temp)
{
temp = (int) Z_LVAL_PP($input);
$1 = &temp;
}
%typemap(in) short *INPUT(short temp)
{
temp = (short) Z_LVAL_PP($input);
$1 = &temp;
}
%typemap(in) long *INPUT(long temp)
{
temp = (long) Z_LVAL_PP($input);
$1 = &temp;
}
%typemap(in) unsigned int *INPUT(unsigned int temp)
{
temp = (unsigned int) Z_LVAL_PP($input);
$1 = &temp;
}
%typemap(in) unsigned short *INPUT(unsigned short temp)
{
temp = (unsigned short) Z_LVAL_PP($input);
$1 = &temp;
}
%typemap(in) unsigned long *INPUT(unsigned long temp)
{
temp = (unsigned long) Z_LVAL_PP($input);
$1 = &temp;
}
%typemap(in) unsigned char *INPUT(unsigned char temp)
{
temp = (unsigned char) Z_LVAL_PP($input);
$1 = &temp;
}
%typemap(in,numinputs=0) int *OUTPUT(int temp),
short *OUTPUT(short temp),
long *OUTPUT(long temp),
unsigned int *OUTPUT(unsigned int temp),
unsigned short *OUTPUT(unsigned short temp),
unsigned long *OUTPUT(unsigned long temp),
unsigned char *OUTPUT(unsigned char temp),
float *OUTPUT(float temp),
double *OUTPUT(double temp)
%typemap(argout) TYPE *INPUT "";
%typemap(in,numinputs=0) TYPE *OUTPUT(TYPE temp)
{
$1 = &temp;
}
%typemap(argout,fragment="t_output_helper") TYPE *OUTPUT
{
zval *o;
MAKE_STD_ZVAL(o);
ZVAL_DOUBLE(o,temp$argnum);
t_output_helper( &$result, o );
}
%typemap(in) TYPE *REFERENCE (TYPE dvalue)
{
if(!ParameterPassedByReference(ht, argvi))
{
SWIG_PHP_Error(E_WARNING, "Parameter wasn't passed by reference");
RETURN_NULL();
}
%typemap(argout) int *OUTPUT,
short *OUTPUT,
long *OUTPUT,
unsigned int *OUTPUT,
unsigned short *OUTPUT,
unsigned long *OUTPUT,
unsigned char *OUTPUT
dvalue = (TYPE) (*$input)->value.dval;
$1 = &dvalue;
}
%typemap(argout) TYPE *REFERENCE
{
$1->value.dval = (double)(*$arg);
$1->type = IS_DOUBLE;
}
%enddef
%define int_typemap(TYPE)
%typemap(in) TYPE *INPUT(TYPE temp)
{
temp = (TYPE) Z_LVAL_PP($input);
$1 = &temp;
}
%typemap(argout) TYPE *INPUT "";
%typemap(in,numinputs=0) TYPE *OUTPUT(TYPE temp)
{
$1 = &temp;
}
%typemap(argout,fragment="t_output_helper") TYPE *OUTPUT
{
zval *o;
MAKE_STD_ZVAL(o);
ZVAL_LONG(o,temp$argnum);
t_output_helper( &$result, o );
}
%typemap(in) TYPE *REFERENCE (TYPE lvalue)
{
if(!ParameterPassedByReference(ht, argvi))
{
SWIG_PHP_Error(E_WARNING, "Parameter wasn't passed by reference");
RETURN_NULL();
}
lvalue = (TYPE) (*$input)->value.lval;
$1 = &lvalue;
}
%typemap(argout) TYPE *REFERENCE
{
ZVAL_LONG($result,*($input));
(*$arg)->value.lval = (long)(*$input);
(*$arg)->type = IS_LONG;
}
%enddef
%typemap(argout) float *OUTPUT,
double *OUTPUT
{
ZVAL_DOUBLE($result,*($input));
}
double_typemap(float);
double_typemap(double);
int_typemap(int);
int_typemap(short);
int_typemap(long);
int_typemap(unsigned int);
int_typemap(unsigned short);
int_typemap(unsigned long);
int_typemap(unsigned char);
%typemap(in) float *INOUT = float *INPUT;
%typemap(in) double *INOUT = double *INPUT;
%typemap(in) int *INOUT = int *INPUT;
%typemap(in) short *INOUT = short *INPUT;
@ -103,8 +113,9 @@
%typemap(in) unsigned short *INOUT = unsigned short *INPUT;
%typemap(in) unsigned long *INOUT = unsigned long *INPUT;
%typemap(in) unsigned char *INOUT = unsigned char *INPUT;
%typemap(in) float *INOUT = float *INPUT;
%typemap(in) double *INOUT = double *INPUT;
%typemap(argout) float *INOUT = float *OUTPUT;
%typemap(argout) double *INOUT= double *OUTPUT;
%typemap(argout) int *INOUT = int *OUTPUT;
%typemap(argout) short *INOUT = short *OUTPUT;
@ -112,123 +123,55 @@
%typemap(argout) unsigned short *INOUT= unsigned short *OUTPUT;
%typemap(argout) unsigned long *INOUT = unsigned long *OUTPUT;
%typemap(argout) unsigned char *INOUT = unsigned char *OUTPUT;
%typemap(argout) float *INOUT = float *OUTPUT;
%typemap(argout) double *INOUT= double *OUTPUT;
// REFERENCE
// Accept Php references as pointers
%typemap(in) double *REFERENCE (double dvalue)
%typemap(in) char INPUT[ANY] ( char temp[$1_dim0] )
{
if(!ParameterPassedByReference(ht, argvi))
{
zend_error(E_WARNING, "Parameter wasn't passed by reference");
RETURN_NULL();
convert_to_string_ex($input);
char *val = Z_LVAL_PP($input);
strncpy(temp,val,$1_dim0);
$1 = temp;
}
%typemap(in,numinputs=0) char OUTPUT[ANY] ( char temp[$1_dim0] )
{
$1 = temp;
}
%typemap(argout) char OUTPUT[ANY]
{
size_t len = strnlen($1,$1_dim0);
RETURN_STRINGL( $1, len );
}
%typemap(in,numinputs=0) void **OUTPUT (int force),
void *&OUTPUT (int force)
{
/* 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) {
/* 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)) {
#ifdef __cplusplus
ptr=new $*1_ltype;
#else
ptr=($*1_ltype) calloc(1,sizeof($*1_ltype));
#endif
$1=&ptr;
/* have to passback arg$arg too */
force=1;
} else { /* wasn't a pre/ref/thing, OR anything like an int thing */
force=0;
SWIG_PHP_Error(E_ERROR, "Type error in argument $arg of $symname.");
}
} else force=0;
}
%typemap(argout) void **OUTPUT,
void *&OUTPUT
{
if (force$argnum) { /* pass back arg$argnum through params ($arg) if we can */
if(! PZVAL_IS_REF(*$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);
}
}
dvalue = (double) (*$input)->value.dval;
$1 = &dvalue;
}
%typemap(in) float *REFERENCE (float dvalue)
{
if(!ParameterPassedByReference(ht, argvi))
{
zend_error(E_WARNING, "Parameter wasn't passed by reference");
RETURN_NULL();
}
dvalue = (float) (*$input)->value.dval;
$1 = &dvalue;
}
%typemap(in) int *REFERENCE (int dvalue)
{
if(!ParameterPassedByReference(ht, argvi))
{
zend_error(E_WARNING, "Parameter wasn't passed by reference");
RETURN_NULL();
}
dvalue = (int) (*$input)->value.lval;
$1 = &dvalue;
}
%typemap(in) short *REFERENCE (short dvalue)
{
if(!ParameterPassedByReference(ht, argvi))
{
zend_error(E_WARNING, "Parameter wasn't passed by reference");
RETURN_NULL();
}
dvalue = (short) (*$input)->value.lval;
$1 = &dvalue;
}
%typemap(in) long *REFERENCE (long dvalue)
{
if(!ParameterPassedByReference(ht, argvi))
{
zend_error(E_WARNING, "Parameter wasn't passed by reference");
RETURN_NULL();
}
dvalue = (long) (*$input)->value.lval;
$1 = &dvalue;
}
%typemap(in) unsigned int *REFERENCE (unsigned int dvalue)
{
if(!ParameterPassedByReference(ht, argvi))
{
zend_error(E_WARNING, "Parameter wasn't passed by reference");
RETURN_NULL();
}
dvalue = (unsigned int) (*$input)->value.lval;
$1 = &dvalue;
}
%typemap(in) unsigned short *REFERENCE (unsigned short dvalue)
{
if(!ParameterPassedByReference(ht, argvi))
{
zend_error(E_WARNING, "Parameter wasn't passed by reference");
RETURN_NULL();
}
dvalue = (unsigned short) $input->value.lval;
$1 = &dvalue;
}
%typemap(in) unsigned long *REFERENCE (unsigned long dvalue)
{
if(!ParameterPassedByReference(ht, argvi))
{
zend_error(E_WARNING, "Parameter wasn't passed by reference");
RETURN_NULL();
}
dvalue = (unsigned long) $input->value.lval;
$1 = &dvalue;
}
%typemap(argout) double *REFERENCE,
float *REFERENCE
{
$1->value.dval = (double)(*$arg);
$1->type = IS_DOUBLE;
}
%typemap(argout) int *REFERENCE,
short *REFERENCE,
long *REFERENCE,
unsigned int *REFERENCE,
unsigned short *REFERENCE,
unsigned long *REFERENCE
{
(*$arg)->value.lval = (long)(*$input);
(*$arg)->type = IS_LONG;
}

191
SWIG/Lib/php4/utils.i
View file

@ -1,145 +1,58 @@
// Contains operations useful in php typemaps
// typemaps don't support "subroutine" typemaps where one typemap can
// include another, so we define useful bodies here to include inother places
// _strbuf_out is designed to be included as part of an argout typemap
// and _strbuf_in which should be part of the in typemap for the same argument
// They share knowledge of the "force" temporary variable.
// You probably don't want to make direct use of _strbuf_out or _strbuf_in but
// you may want strbufsize_inout which uses these
%define _strbuf_out(BUFFER,SIZE)
if (force$argnum) { /* pass back arg$argnum through params ($arg) if we can */
if(! PZVAL_IS_REF(*$arg)) {
zend_error(E_WARNING, "Parameter %d of $symname wasn't passed by reference [argout TYPES *, TYPES &]",$argnum-argbase);
} else {
#if SIZE
// SIZE
ZVAL_STRINGL(*$arg,BUFFER$argnum, SIZE, 1);
#else
// Measure length
ZVAL_STRING(*$arg,BUFFER$argnum, 1);
#endif
}
}
%define CONVERT_BOOL_IN(lvar,t,invar)
convert_to_boolean_ex(invar);
lvar = (t) Z_LVAL_PP(invar);
%enddef
%define
_strbuf_in(BUFFER)
// _strbuf_in
if(! SWIG_ConvertPtr(*$input, (void **) &$1, $1_descriptor) < 0) {
/* Using a _p_ SWIG pointer, so they will have to manage size themselves */
force=0;
} else if ((*$input)->type==IS_STRING ||
(*$input)->type==IS_LONG ||
/* Null passed by reference means we want a value back */
(*$input)->type==IS_NULL ||
(*$input)->type==IS_BOOL ||
(*$input)->type==IS_DOUBLE) {
// Only pass back if we can...
if (PZVAL_IS_REF(*$input)) force=1;
else force=0;
%define CONVERT_INT_IN(lvar,t,invar)
convert_to_long_ex(invar);
lvar = (t) Z_LVAL_PP(invar);
%enddef
convert_to_string_ex($input);
// Init temp buffer
strncpy((char *)temp,Z_STRVAL_PP($input),sizeof(BUFFER));
$1=temp;
} else {
force=0;
$1=NULL;
zend_error(E_ERROR, "Type error in argument %d of $symname. Expected %s or at least something looking vaguely like a string hopefully passed by reference", $argnum-argbase, $1_descriptor->name);
%define CONVERT_INT_OUT(lvar,invar)
lvar = (t) Z_LVAL_PP(invar);
%enddef
%define CONVERT_FLOAT_IN(lvar,t,invar)
convert_to_double_ex(invar);
lvar = (t) Z_DVAL_PP(invar);
%enddef
%define CONVERT_CHAR_IN(lvar,t,invar)
convert_to_string_ex(invar);
lvar = (t) *Z_STRVAL_PP(invar);
%enddef
%define CONVERT_STRING_IN(lvar,t,invar)
convert_to_string_ex(invar);
lvar = (t) Z_STRVAL_PP(invar);
%enddef
%define %pass_by_val( TYPE, CONVERT_IN )
%typemap(in) TYPE
{
CONVERT_IN($1,$1_ltype,$input);
}
%enddef
%fragment("t_output_helper","header") %{
void
t_output_helper( zval **target, zval *o) {
if ( (*target)->type == IS_ARRAY ) {
/* it's already an array, just append */
add_next_index_zval( *target, o );
return;
}
%enddef
// strbufsize_inout defines a typemap which
// Example: strbufsize_inout(UCHAR FAR * szErrorMsg, SWORD cbErrorMsgMax,1024)
// defines a typeemap for UCHAR FAR * szErrorMsg, SWORD cbErrorMsgMax with a
// max buffer size of 1024
%define strbufsize_inout(BUFFER,SIZE,MAXSIZE)
%typemap(in) (BUFFER, SIZE) ($*1_ltype temp[MAXSIZE], int force) {
_strbuf_in(temp)
$2=sizeof(temp);
}
%typemap(argout) (BUFFER, SIZE) {
_strbuf_out((char *)temp,strlen(temp))
}
%enddef
// char array can be in/out, though the passed string may not be big enough...
// so we have to size it
// e.g. Do: strarray_inout(char [ANY])
%define strarray_inout(TYPE)
%typemap(in) TYPE ($*1_ltype temp[$1_dim0], int force) %{
_strbuf_in(temp)
%}
%typemap(argout) TYPE %{
_strbuf_out((char *)temp,$1_dim0);
%}
%enddef
%define strarraysize_inout(TYPE,SIZE)
%typemap(in) TYPE ($*1_ltype temp[SIZE], int force) %{
_strbuf_in(temp)
%}
%typemap(argout) TYPE %{
_strbuf_out((char *)temp,SIZE);
%}
%enddef
%define strbuf_inout(BUFFER,MAXSIZE)
%typemap(in) (BUFFER) ($*1_ltype temp[MAXSIZE], int force) {
_strbuf_in(temp)
}
%typemap(argout) (BUFFER) {
_strbuf_out(temp,strlen(temp))
}
%enddef
/* Typemap for in/argout references
NOTE: we don't choose to use these for arrays yet, maybe later */
%define outLONG(ZVALARG,CARG)
ZVAL_LONG(*$arg,intr$argnum);
%enddef
// Defines an on/argout typemap for ordinal types
//Usage: %typemap_inout_ord(bool,convert_to_boolean_ex,ZVAL_BOOL)
%define %typemap_inout_ord(TYPES,TYPE_IN,TYPE_OUT)
%typemap(in) TYPES * ($*1_ltype intr, int force),
TYPES & ($*1_ltype intr, int force) %{
/* inout typemap for TYPES using TYPE_IN and TYPE_OUT */
if(SWIG_ConvertPtr(*$input, (void **) &$1, $1_descriptor) < 0) {
/* So... we didn't get a ref or ptr, but can it be reasonably
co-erced into what we were looking for a ref of or ptr to? */
if (!PZVAL_IS_REF(*$input) && (*$input)->type==IS_NULL) {
// null passed not by reference means pass NULL
$1 = NULL;
force=0;
} else if (PZVAL_IS_REF(*$input) &&
((*$input)->type==IS_STRING ||
(*$input)->type==IS_LONG ||
/* Null passed by reference means we want a value back */
(*$input)->type==IS_NULL ||
(*$input)->type==IS_BOOL ||
(*$input)->type==IS_DOUBLE)) {
TYPE_IN($input);
intr = ($*1_ltype) (*$input)->value.lval;
$1 = &intr;
/* have to passback arg$arg too */
force=1;
} else { /* wasn't a pre/ref/thing, OR anything like an int thing */
force=0;
zend_error(E_ERROR, "Type error in argument %d of $symname. Expected %s or at least something looking vaguely like a number hopefully passed by reference", $argnum-argbase, $1_descriptor->name);
}
} else force=0;
%}
%typemap(argout) TYPES *, TYPES & %{
if (force$argnum) { /* pass back arg$argnum through params ($arg) if we can */
if(! PZVAL_IS_REF(*$arg)) {
zend_error(E_WARNING, "Parameter %d of $symname wasn't passed by reference [argout TYPES *, TYPES &]",$argnum-argbase);
} else {
TYPE_OUT(*$arg,intr$argnum);
}
if ( (*target)->type == IS_NULL ) {
REPLACE_ZVAL_VALUE(target,o,1);
return;
}
%}
%enddef
zval *tmp;
tmp = *target;
zval_copy_ctor(tmp);
array_init(*target);
add_next_index_zval( *target, tmp);
add_next_index_zval( *target, o);
}
%}