You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
298 lines
8.1 KiB
298 lines
8.1 KiB
/* ----------------------------------------------------------------------------- |
|
* See the LICENSE file for information on copyright, usage and redistribution |
|
* of SWIG, and the README file for authors - http://www.swig.org/release.html. |
|
* |
|
* php4.swg |
|
* |
|
* PHP4 configuration file |
|
* ----------------------------------------------------------------------------- */ |
|
|
|
%runtime "swigrun.swg" // Common C API type-checking code |
|
%runtime "php4run.swg" // Php4 runtime functions |
|
|
|
%include <php4init.swg> // Php4 initialization routine. |
|
|
|
%include <globalvar.i> // Global variables. |
|
%include <const.i> |
|
|
|
// use %init %{ "/*code goes here*/ " %} |
|
// or %minit %{ "/* code goes here*/ " %} to |
|
// insert code in the PHP_MINIT_FUNCTION |
|
#define %minit %insert("init") |
|
|
|
// use %rinit %{ "/* code goes here*/ " %} to |
|
// insert code in the PHP_RINIT_FUNCTION |
|
#define %rinit %insert("rinit") |
|
|
|
// use %shutdown %{ " /*code goes here*/ " %} to |
|
// insert code in the PHP_MSHUTDOWN_FUNCTION |
|
#define %shutdown %insert("shutdown") |
|
#define %mshutdown %insert("shutdown") |
|
|
|
// use %rshutdown %{ " /*code goes here*/" %} to |
|
// insert code in the PHP_RSHUTDOWN_FUNCTION |
|
#define %rshutdown %insert("rshutdown") |
|
|
|
/* Typemaps for input parameters by value */ |
|
|
|
%include <utils.i> |
|
|
|
%pass_by_val(bool,CONVERT_BOOL_IN); |
|
|
|
%pass_by_val(size_t, CONVERT_INT_IN); |
|
|
|
%pass_by_val(enum SWIGTYPE, CONVERT_INT_IN); |
|
|
|
%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 |
|
%typemap(in) char[ANY] |
|
{ |
|
convert_to_string_ex($input); |
|
$1 = ($1_ltype) Z_STRVAL_PP($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) { |
|
SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $&1_descriptor"); |
|
} |
|
$1 = *tmp; |
|
} |
|
|
|
%typemap(in) SWIGTYPE *, |
|
SWIGTYPE [] |
|
{ |
|
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) { |
|
SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $1_descriptor"); |
|
} |
|
} |
|
|
|
%typemap(in) SWIGTYPE *DISOWN |
|
{ |
|
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 [], |
|
SWIGTYPE&; |
|
|
|
%typemap(in) void * |
|
{ |
|
if(SWIG_ConvertPtr(*$input, (void **) &$1, 0, 0) < 0) { |
|
/* Allow NULL from php for void* */ |
|
if ((*$input)->type==IS_NULL) $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 */ |
|
%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) < 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))) { |
|
/* wasn't a pre/ref/thing, OR anything like an int thing */ |
|
SWIG_PHP_Error(E_ERROR, "Type error in argument $arg of $symname."); |
|
} |
|
} |
|
force=0; |
|
if (arg1==NULL) { |
|
#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; |
|
} |
|
} |
|
%typemap(argout) void **, |
|
void *& |
|
{ |
|
if (force$argnum) { |
|
SWIG_SetPointerZval( *$input, (void*) ptr$argnum, $*1_descriptor, 1); |
|
} |
|
} |
|
|
|
/* Typemap for output values */ |
|
|
|
%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 |
|
{ |
|
ZVAL_BOOL(return_value,($1)?1:0); |
|
} |
|
|
|
%typemap(out) float, |
|
double |
|
{ |
|
ZVAL_DOUBLE(return_value,$1); |
|
} |
|
|
|
%typemap(out) char |
|
{ |
|
ZVAL_STRINGL(return_value,&$1, 1, 1); |
|
} |
|
|
|
%typemap(out) char *, |
|
char [] |
|
{ |
|
if(!$1) { |
|
ZVAL_NULL(return_value); |
|
} else { |
|
ZVAL_STRING(return_value,$1, 1); |
|
} |
|
} |
|
|
|
%typemap(out) SWIGTYPE *, |
|
SWIGTYPE [], |
|
SWIGTYPE & |
|
{ |
|
SWIG_SetPointerZval(return_value, (void *)$1, $1_descriptor, $owner); |
|
} |
|
|
|
%typemap(out) SWIGTYPE *DYNAMIC, |
|
SWIGTYPE &DYNAMIC |
|
{ |
|
swig_type_info *ty = SWIG_TypeDynamicCast($1_descriptor, (void **) &$1); |
|
SWIG_SetPointerZval(return_value, (void *)$1, ty, $owner); |
|
} |
|
|
|
%typemap(out) SWIGTYPE |
|
#ifdef __cplusplus |
|
{ |
|
$&1_ltype resultobj = new $1_ltype(($1_ltype &) $1); |
|
SWIG_SetPointerZval(return_value, (void *)resultobj, $&1_descriptor, 1); |
|
} |
|
#else |
|
{ |
|
$&1_ltype resultobj = ($&1_ltype) emalloc(sizeof($1_type)); |
|
memmove(resultobj, &$1, sizeof($1_type)); |
|
SWIG_SetPointerZval(return_value, (void *)resultobj, $&1_descriptor, 1); |
|
} |
|
#endif |
|
|
|
%typemap(out) void ""; |
|
|
|
%typemap(out) char [ANY] |
|
{ |
|
RETVAL_STRINGL($1,$1_dim0,1); |
|
} |
|
|
|
// This typecheck does hard checking for proper argument type. If you want |
|
// an argument to be converted from a different PHP type, you must convert |
|
// it yourself before passing it (e.g. (string)4.7 or (int)"6"). |
|
%define %php_typecheck(_type,_prec,is) |
|
%typemap(typecheck,precedence=_prec) _type |
|
" $1 = (Z_TYPE_PP($input) == is); " |
|
%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 & |
|
{ |
|
void *tmp; |
|
_v = (SWIG_ConvertPtr( *$input, (void**)&tmp, $1_descriptor, 0) >= 0); |
|
} |
|
|
|
%typecheck(SWIG_TYPECHECK_VOIDPTR) void * |
|
" /* typecheck void * */ " |
|
|
|
|
|
/* Exception handling */ |
|
|
|
%typemap(throws) int, |
|
long, |
|
short, |
|
unsigned int, |
|
unsigned long, |
|
unsigned short { |
|
char error_msg[256]; |
|
sprintf(error_msg, "C++ $1_type exception thrown, value: %d", $1); |
|
SWIG_PHP_Error(E_ERROR, error_msg); |
|
} |
|
|
|
%typemap(throws) SWIGTYPE, SWIGTYPE &, SWIGTYPE *, SWIGTYPE [], SWIGTYPE [ANY] %{ |
|
(void)$1; |
|
SWIG_PHP_Error(E_ERROR, "C++ $1_type exception thrown"); |
|
%} |
|
|
|
%typemap(throws) char * %{ |
|
SWIG_PHP_Error(E_ERROR, (char *)$1); |
|
%} |
|
|
|
|
|
/* php keywords */ |
|
%include <php4kw.swg>
|
|
|