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

Merge branch 'master' into directorargout_and_java_typemaps

Browse source
This commit is contained in:
Andrey Starodubtsev 2017-01-21 17:41:31 +03:00
commit 4ba9de370e
470 changed files with 15434 additions and 3110 deletions
Download patch file Download diff file Expand all files Collapse all files

1
Lib/allkw.swg
View file

@ -24,6 +24,7 @@
%include <lua/luakw.swg>
%include <ocaml/ocamlkw.swg>
%include <perl5/perlkw.swg>
%include <php5/phpkw.swg>
%include <php/phpkw.swg>
%include <pike/pikekw.swg>
%include <python/pythonkw.swg>

11
Lib/cdata.i
View file

@ -29,13 +29,20 @@ typedef struct SWIGCDATA {
}
%typemap(in) (const void *indata, int inlen) = (char *STRING, int LENGTH);
#elif SWIGPHP
#elif SWIGPHP5
%typemap(out) SWIGCDATA {
ZVAL_STRINGL($result, $1.data, $1.len, 1);
}
%typemap(in) (const void *indata, int inlen) = (char *STRING, int LENGTH);
#elif SWIGPHP7
%typemap(out) SWIGCDATA {
ZVAL_STRINGL($result, $1.data, $1.len);
}
%typemap(in) (const void *indata, int inlen) = (char *STRING, int LENGTH);
#elif SWIGJAVA
%apply (char *STRING, int LENGTH) { (const void *indata, int inlen) }
@ -64,8 +71,6 @@ static jbyteArray SWIG_JavaArrayOutCDATA(JNIEnv *jenv, char *result, jsize sz) {
return $jnicall;
}
#else
%echo "cdata.i module not supported."
#endif

1
Lib/csharp/csharp.swg
View file

@ -995,6 +995,7 @@ SWIG_CSBODY_TYPEWRAPPER(internal, protected, internal, SWIGTYPE)
#define %csmethodmodifiers %feature("cs:methodmodifiers")
#define %csnothrowexception %feature("except")
#define %csattributes %feature("cs:attributes")
#define %proxycode %insert("proxycode")
%pragma(csharp) imclassclassmodifiers="class"
%pragma(csharp) moduleclassmodifiers="public class"

2
Lib/csharp/std_array.i
View file

@ -17,7 +17,7 @@
%define SWIG_STD_ARRAY_INTERNAL(T, N)
%typemap(csinterfaces) std::array< T, N > "global::System.IDisposable, global::System.Collections.IEnumerable\n , global::System.Collections.Generic.IEnumerable<$typemap(cstype, T)>\n";
%typemap(cscode) std::array< T, N > %{
%proxycode %{
public $csclassname(global::System.Collections.ICollection c) : this() {
if (c == null)
throw new global::System.ArgumentNullException("c");

2
Lib/csharp/std_map.i
View file

@ -27,7 +27,7 @@
%define SWIG_STD_MAP_INTERNAL(K, T, C)
%typemap(csinterfaces) std::map< K, T, C > "global::System.IDisposable \n , global::System.Collections.Generic.IDictionary<$typemap(cstype, K), $typemap(cstype, T)>\n";
%typemap(cscode) std::map<K, T, C > %{
%proxycode %{
public $typemap(cstype, T) this[$typemap(cstype, K) key] {
get {

2
Lib/csharp/std_vector.i
View file

@ -25,7 +25,7 @@
// MACRO for use within the std::vector class body
%define SWIG_STD_VECTOR_MINIMUM_INTERNAL(CSINTERFACE, CONST_REFERENCE, CTYPE...)
%typemap(csinterfaces) std::vector< CTYPE > "global::System.IDisposable, global::System.Collections.IEnumerable\n , global::System.Collections.Generic.CSINTERFACE<$typemap(cstype, CTYPE)>\n";
%typemap(cscode) std::vector< CTYPE > %{
%proxycode %{
public $csclassname(global::System.Collections.ICollection c) : this() {
if (c == null)
throw new global::System.ArgumentNullException("c");

1
Lib/d/ddirectives.swg
View file

@ -8,3 +8,4 @@
#define %dconstvalue(value) %feature("d:constvalue",value)
#define %dmethodmodifiers %feature("d:methodmodifiers")
#define %dnothrowexception %feature("except")
#define %proxycode %insert("proxycode")

4
Lib/d/std_vector.i
View file

@ -24,7 +24,7 @@
%define SWIG_STD_VECTOR_MINIMUM_INTERNAL(CONST_REFERENCE, CTYPE...)
#if (SWIG_D_VERSION == 1)
%typemap(dimports) std::vector< CTYPE > "static import tango.core.Exception;"
%typemap(dcode) std::vector< CTYPE > %{
%proxycode %{
public this($typemap(dtype, CTYPE)[] values) {
this();
append(values);
@ -185,7 +185,7 @@ static import std.exception;
static import std.range;
static import std.traits;
%}
%typemap(dcode) std::vector< CTYPE > %{
%proxycode %{
alias size_t KeyType;
alias $typemap(dtype, CTYPE) ValueType;

9
Lib/exception.i
View file

@ -12,13 +12,20 @@
%insert("runtime") "swigerrors.swg"
#ifdef SWIGPHP
#ifdef SWIGPHP5
%{
#include "zend_exceptions.h"
#define SWIG_exception(code, msg) do { zend_throw_exception(NULL, (char*)msg, code TSRMLS_CC); goto thrown; } while (0)
%}
#endif
#ifdef SWIGPHP7
%{
#include "zend_exceptions.h"
#define SWIG_exception(code, msg) do { zend_throw_exception(NULL, (char*)msg, code); goto thrown; } while (0)
%}
#endif
#ifdef SWIGGUILE
%{
SWIGINTERN void SWIG_exception_ (int code, const char *msg,

3
Lib/guile/guile_scm_run.swg
View file

@ -176,6 +176,9 @@ SWIG_Guile_ConvertPtr(SCM s, void **result, swig_type_info *type, int flags)
if (SCM_NULLP(smob)) {
*result = NULL;
return SWIG_OK;
} else if (SCM_POINTER_P(s)) {
*result = SCM_POINTER_VALUE(s);
return SWIG_OK;
} else if (SCM_SMOB_PREDICATE(swig_tag, smob) || SCM_SMOB_PREDICATE(swig_collectable_tag, smob)) {
/* we do not accept smobs representing destroyed pointers */
from = (swig_type_info *) SCM_CELL_WORD_2(smob);

3
Lib/guile/std_common.i
View file

@ -14,7 +14,8 @@
%{
#include <string>
inline std::string SWIG_scm2string(SCM x) {
SWIGINTERNINLINE
std::string SWIG_scm2string(SCM x) {
char* temp;
temp = SWIG_scm2str(x);
std::string s(temp);

4
Lib/java/arrays_java.i
View file

@ -337,7 +337,8 @@ JAVA_ARRAYS_TYPEMAPS(double, double, jdouble, Double, "[D") /* double[ANY] *
/* Add some code to the proxy class of the array type for converting between type used in
* JNI class (long[]) and type used in proxy class ( ARRAYSOFCLASSES[] ) */
%typemap(javacode) ARRAYSOFCLASSES %{
%extend ARRAYSOFCLASSES {
%proxycode %{
protected static long[] cArrayUnwrap($javaclassname[] arrayWrapper) {
long[] cArray = new long[arrayWrapper.length];
for (int i=0; i<arrayWrapper.length; i++)
@ -352,6 +353,7 @@ JAVA_ARRAYS_TYPEMAPS(double, double, jdouble, Double, "[D") /* double[ANY] *
return arrayWrapper;
}
%}
}
%enddef /* JAVA_ARRAYSOFCLASSES */

8
Lib/java/boost_intrusive_ptr.i
View file

@ -264,7 +264,7 @@
// Base proxy classes
%typemap(javabody) TYPE %{
private transient long swigCPtr;
private boolean swigCMemOwnBase;
private transient boolean swigCMemOwnBase;
PTRCTOR_VISIBILITY $javaclassname(long cPtr, boolean cMemoryOwn) {
swigCMemOwnBase = cMemoryOwn;
@ -279,7 +279,7 @@
// Derived proxy classes
%typemap(javabody_derived) TYPE %{
private transient long swigCPtr;
private boolean swigCMemOwnDerived;
private transient boolean swigCMemOwnDerived;
PTRCTOR_VISIBILITY $javaclassname(long cPtr, boolean cMemoryOwn) {
super($imclassname.$javaclazznameSWIGSmartPtrUpcast(cPtr), true);
@ -414,7 +414,7 @@
// Base proxy classes
%typemap(javabody) TYPE %{
private transient long swigCPtr;
private boolean swigCMemOwnBase;
private transient boolean swigCMemOwnBase;
PTRCTOR_VISIBILITY $javaclassname(long cPtr, boolean cMemoryOwn) {
swigCMemOwnBase = cMemoryOwn;
@ -429,7 +429,7 @@
// Derived proxy classes
%typemap(javabody_derived) TYPE %{
private transient long swigCPtr;
private boolean swigCMemOwnDerived;
private transient boolean swigCMemOwnDerived;
PTRCTOR_VISIBILITY $javaclassname(long cPtr, boolean cMemoryOwn) {
super($imclassname.$javaclazznameSWIGSmartPtrUpcast(cPtr), true);

2
Lib/java/boost_shared_ptr.i
View file

@ -161,7 +161,7 @@
// Derived proxy classes
%typemap(javabody_derived) TYPE %{
private transient long swigCPtr;
private boolean swigCMemOwnDerived;
private transient boolean swigCMemOwnDerived;
PTRCTOR_VISIBILITY $javaclassname(long cPtr, boolean cMemoryOwn) {
super($imclassname.$javaclazznameSWIGSmartPtrUpcast(cPtr), true);

3
Lib/java/java.swg
View file

@ -1211,7 +1211,7 @@ Swig::LocalRefGuard $1_refguard(jenv, $input); %}
%}
%typemap(javabody) TYPE (CLASS::*) %{
private String swigCMemberPtr;
private transient String swigCMemberPtr;
PTRCTOR_VISIBILITY $javaclassname(String cMemberPtr, @SuppressWarnings("unused") boolean futureUse) {
swigCMemberPtr = cMemberPtr;
@ -1322,6 +1322,7 @@ SWIG_PROXY_CONSTRUCTOR(true, true, SWIGTYPE)
#define %javaexception(exceptionclasses) %feature("except",throws=exceptionclasses)
#define %nojavaexception %feature("except","0",throws="")
#define %clearjavaexception %feature("except","",throws="")
#define %proxycode %insert("proxycode")
%pragma(java) jniclassclassmodifiers="public class"
%pragma(java) moduleclassmodifiers="public class"

7
Lib/mzscheme/std_common.i
View file

@ -11,10 +11,13 @@
%{
#include <string>
std::string swig_scm_to_string(Scheme_Object* x) {
SWIGINTERNINLINE
std::string swig_scm_to_string(Scheme_Object *x) {
return std::string(SCHEME_STR_VAL(x));
}
Scheme_Object* swig_make_string(const std::string& s) {
SWIGINTERNINLINE
Scheme_Object *swig_make_string(const std::string &s) {
return scheme_make_string(s.c_str());
}
%}

15
Lib/ocaml/std_common.i
View file

@ -10,10 +10,13 @@
%{
#include <string>
CAML_VALUE SwigString_FromString(const std::string& s) {
return caml_val_string((char *)s.c_str());
}
std::string SwigString_AsString(CAML_VALUE o) {
return std::string((char *)caml_ptr_val(o,0));
}
SWIGINTERNINLINE
CAML_VALUE SwigString_FromString(const std::string &s) {
return caml_val_string((char *)s.c_str());
}
SWIGINTERNINLINE
std::string SwigString_AsString(CAML_VALUE o) {
return std::string((char *)caml_ptr_val(o,0));
}
%}

2
Lib/octave/octcontainer.swg
View file

@ -68,7 +68,7 @@ namespace swig {
namespace std {
template <>
struct less <octave_value>: public binary_function<octave_value, octave_value, bool>
struct less <octave_value>
{
bool
operator()(const octave_value& v, const octave_value& w) const

8
Lib/octave/std_pair.i
View file

@ -69,12 +69,16 @@
value_type *vp = %new_instance(std::pair<T,U>);
T *pfirst = &(vp->first);
int res1 = swig::asval(first, pfirst);
if (!SWIG_IsOK(res1))
if (!SWIG_IsOK(res1)) {
%delete(vp);
return res1;
}
U *psecond = &(vp->second);
int res2 = swig::asval(second, psecond);
if (!SWIG_IsOK(res2))
if (!SWIG_IsOK(res2)) {
%delete(vp);
return res2;
}
*val = vp;
return SWIG_AddNewMask(res1 > res2 ? res1 : res2);
} else {

3
Lib/perl5/std_common.i
View file

@ -10,14 +10,17 @@
%fragment("<string>");
%{
SWIGINTERN
double SwigSvToNumber(SV* sv) {
return SvIOK(sv) ? double(SvIVX(sv)) : SvNVX(sv);
}
SWIGINTERN
std::string SwigSvToString(SV* sv) {
STRLEN len;
char *ptr = SvPV(sv, len);
return std::string(ptr, len);
}
SWIGINTERN
void SwigSvFromString(SV* sv, const std::string& s) {
sv_setpvn(sv,s.data(),s.size());
}

17
Lib/php/const.i
View file

@ -12,10 +12,12 @@
unsigned long,
unsigned char,
signed char,
bool,
enum SWIGTYPE
"SWIG_LONG_CONSTANT($symname, ($1_type)$value);";
%typemap(consttab) bool
"SWIG_BOOL_CONSTANT($symname, ($1_type)$value);";
%typemap(consttab) float,
double
"SWIG_DOUBLE_CONSTANT($symname, $value);";
@ -33,18 +35,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;
%}

16
Lib/php/phpinit.swg
View file

@ -6,20 +6,20 @@
%insert(init) "swiginit.swg"
%init %{
SWIG_php_minit {
SWIG_php_minit {
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 );

164
Lib/php/phprun.swg
View file

@ -11,65 +11,31 @@ extern "C" {
#include "zend_API.h"
#include "zend_exceptions.h"
#include "php.h"
#if PHP_MAJOR_VERSION != 7
# error These bindings need PHP7 - to generate PHP5 bindings use: swig -php5
#endif
#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_BOOL_CONSTANT(N, V) REGISTER_BOOL_CONSTANT(#N, V, CONST_CS | CONST_PERSISTENT)
#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 +59,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 +79,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 +100,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 +136,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 +167,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 +225,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);
REGISTER_MAIN_LONG_CONSTANT(const_name, (long) pointer, CONST_PERSISTENT | CONST_CS);
}

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);
}
%}

51
Lib/php5/const.i Normal file
View file

@ -0,0 +1,51 @@
/* -----------------------------------------------------------------------------
* const.i
*
* Typemaps for constants
* ----------------------------------------------------------------------------- */
%typemap(consttab) int,
unsigned int,
short,
unsigned short,
long,
unsigned long,
unsigned char,
signed char,
bool,
enum SWIGTYPE
"SWIG_LONG_CONSTANT($symname, ($1_type)$value);";
%typemap(consttab) float,
double
"SWIG_DOUBLE_CONSTANT($symname, $value);";
%typemap(consttab) char
"SWIG_CHAR_CONSTANT($symname, $value);";
%typemap(consttab) char *,
const char *,
char [],
const char []
"SWIG_STRING_CONSTANT($symname, $value);";
%typemap(consttab) SWIGTYPE *,
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;
zval_copy_ctor(&c.value);
c.name = zend_strndup("$symname", len);
c.name_len = len+1;
c.flags = CONST_CS | CONST_PERSISTENT;
c.module_number = module_number;
zend_register_constant( &c TSRMLS_CC );
}
/* Handled as a global variable. */
%typemap(consttab) SWIGTYPE (CLASS::*) "";

170
Lib/php5/director.swg Normal file
View file

@ -0,0 +1,170 @@
/* -----------------------------------------------------------------------------
* director.swg
*
* This file contains support for director classes so that PHP proxy
* methods can be called from C++.
* ----------------------------------------------------------------------------- */
#ifndef SWIG_DIRECTOR_PHP_HEADER_
#define SWIG_DIRECTOR_PHP_HEADER_
#include <string>
#include <exception>
#include <map>
namespace Swig {
/* memory handler */
struct GCItem {
virtual ~GCItem() {
}
virtual int get_own() const {
return 0;
}
};
struct GCItem_var {
GCItem_var(GCItem *item = 0) : _item(item) {
}
GCItem_var& operator=(GCItem *item) {
GCItem *tmp = _item;
_item = item;
delete tmp;
return *this;
}
~GCItem_var() {
delete _item;
}
GCItem * operator->() const {
return _item;
}
private:
GCItem *_item;
};
struct GCItem_Object : GCItem {
GCItem_Object(int own) : _own(own) {
}
virtual ~GCItem_Object() {
}
int get_own() const {
return _own;
}
private:
int _own;
};
template <typename Type>
struct GCItem_T : GCItem {
GCItem_T(Type *ptr) : _ptr(ptr) {
}
virtual ~GCItem_T() {
delete _ptr;
}
private:
Type *_ptr;
};
class Director {
protected:
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);
}
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;
}
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);
}
template <typename Type>
void swig_acquire_ownership(Type *vptr) const {
if (vptr) {
swig_owner[vptr] = new GCItem_T<Type>(vptr);
}
}
};
/* base class for director exceptions */
class DirectorException : public std::exception {
protected:
std::string swig_msg;
public:
DirectorException(int code, const char *hdr, const char *msg TSRMLS_DC) : swig_msg(hdr) {
if (msg[0]) {
swig_msg += " ";
swig_msg += msg;
}
SWIG_ErrorCode() = code;
SWIG_ErrorMsg() = swig_msg.c_str();
}
virtual ~DirectorException() throw() {
}
const char *what() const throw() {
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);
}
};
/* 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) {
}
static void raise(const char *msg TSRMLS_DC) {
throw DirectorPureVirtualException(msg TSRMLS_CC);
}
};
/* any php exception that occurs during a director method call */
class DirectorMethodException : public DirectorException
{
public:
DirectorMethodException(const char *msg TSRMLS_DC)
: DirectorException(E_ERROR, "SWIG director method error", msg TSRMLS_CC) {
}
static void raise(const char *msg TSRMLS_DC) {
throw DirectorMethodException(msg TSRMLS_CC);
}
};
}
// 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

109
Lib/php5/factory.i Normal file
View file

@ -0,0 +1,109 @@
/*
Implement a more natural wrap for factory methods, for example, if
you have:
---- geometry.h --------
struct Geometry {
enum GeomType{
POINT,
CIRCLE
};
virtual ~Geometry() {}
virtual int draw() = 0;
//
// Factory method for all the Geometry objects
//
static Geometry *create(GeomType i);
};
struct Point : Geometry {
int draw() { return 1; }
double width() { return 1.0; }
};
struct Circle : Geometry {
int draw() { return 2; }
double radius() { return 1.5; }
};
//
// Factory method for all the Geometry objects
//
Geometry *Geometry::create(GeomType type) {
switch (type) {
case POINT: return new Point();
case CIRCLE: return new Circle();
default: return 0;
}
}
---- geometry.h --------
You can use the %factory with the Geometry::create method as follows:
%newobject Geometry::create;
%factory(Geometry *Geometry::create, Point, Circle);
%include "geometry.h"
and Geometry::create will return a 'Point' or 'Circle' instance
instead of the plain 'Geometry' type. For example, in python:
circle = Geometry.create(Geometry.CIRCLE)
r = circle.radius()
where circle is a Circle proxy instance.
NOTES: remember to fully qualify all the type names and don't
use %factory inside a namespace declaration, ie, instead of
namespace Foo {
%factory(Geometry *Geometry::create, Point, Circle);
}
use
%factory(Foo::Geometry *Foo::Geometry::create, Foo::Point, Foo::Circle);
*/
/* for loop for macro with one argument */
%define %_formacro_1(macro, arg1,...)macro(arg1)
#if #__VA_ARGS__ != "__fordone__"
%_formacro_1(macro, __VA_ARGS__)
#endif
%enddef
/* for loop for macro with one argument */
%define %formacro_1(macro,...)%_formacro_1(macro,__VA_ARGS__,__fordone__)%enddef
%define %formacro(macro,...)%_formacro_1(macro,__VA_ARGS__,__fordone__)%enddef
/* for loop for macro with two arguments */
%define %_formacro_2(macro, arg1, arg2, ...)macro(arg1, arg2)
#if #__VA_ARGS__ != "__fordone__"
%_formacro_2(macro, __VA_ARGS__)
#endif
%enddef
/* for loop for macro with two arguments */
%define %formacro_2(macro,...)%_formacro_2(macro, __VA_ARGS__, __fordone__)%enddef
%define %_factory_dispatch(Type)
if (!dcast) {
Type *dobj = dynamic_cast<Type *>($1);
if (dobj) {
dcast = 1;
SWIG_SetPointerZval(return_value, SWIG_as_voidptr(dobj),$descriptor(Type *), $owner);
}
}%enddef
%define %factory(Method,Types...)
%typemap(out) Method {
int dcast = 0;
%formacro(%_factory_dispatch, Types)
if (!dcast) {
SWIG_SetPointerZval(return_value, SWIG_as_voidptr($1),$descriptor, $owner);
}
}%enddef

361
Lib/php5/globalvar.i Normal file
View file

@ -0,0 +1,361 @@
/* -----------------------------------------------------------------------------
* globalvar.i
*
* Global variables - add the variable to PHP
* ----------------------------------------------------------------------------- */
%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);
} else {
z_var->value.str.val = 0;
z_var->value.str.len = 0;
}
zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void *)&z_var, sizeof(zval *), NULL);
}
%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);
}
%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 = (long)$1;
zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$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), (char*)"$1", sizeof("$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), (char*)"$1", sizeof("$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 = 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);
}
%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);
}
%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);
}
%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);
}
%typemap(varinit, fragment="swig_php_init_member_ptr") SWIGTYPE (CLASS::*)
{
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);
}
%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);
}
}
%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);
}
}
%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);
}
}
%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);
}
}
%typemap(varin) char *
{
zval **z_var;
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);
if ((s1 == NULL) || ($1 == NULL) || strcmp(s1, $1)) {
if (s1)
$1 = estrdup(s1);
else
$1 = NULL;
}
}
%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);
}
}
%typemap(varin) char [ANY]
{
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)
strncpy($1, s1, $1_dim0);
}
}
%typemap(varin) SWIGTYPE
{
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) {
SWIG_PHP_Error(E_ERROR,"Type error in value of $symname. Expected $&1_descriptor");
}
$1 = *($&1_ltype)_temp;
}
%typemap(varin) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&
{
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) {
SWIG_PHP_Error(E_ERROR,"Type error in value of $symname. Expected $&1_descriptor");
}
$1 = ($1_ltype)_temp;
}
%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);
memcpy(&$1, p, sizeof($1));
}
%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), (char*)"$1", sizeof("$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), (char*)"$1", sizeof("$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), (char*)"$1", sizeof("$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), (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);
}
}
%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)
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), (char*)"$1", sizeof("$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), (char*)"$1", sizeof("$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), (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;
} else {
(*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);
}
%typemap(varout, fragment="swig_php_init_member_ptr") SWIGTYPE (CLASS::*)
{
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);
}

529
Lib/php5/php.swg Normal file
View file

@ -0,0 +1,529 @@
/* -----------------------------------------------------------------------------
* php.swg
*
* PHP configuration file
* ----------------------------------------------------------------------------- */
%runtime "swigrun.swg" // Common C API type-checking code
%runtime "phprun.swg" // PHP runtime functions
%include <phpinit.swg> // PHP 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 long long, CONVERT_LONG_LONG_IN);
%pass_by_val(long long, CONVERT_LONG_LONG_IN);
%pass_by_val(unsigned long long, CONVERT_UNSIGNED_LONG_LONG_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);
%typemap(in) char *& = const char *&;
%typemap(directorout) char *& = const char *&;
// 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);
}
%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);
}
/* 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(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)
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) {
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 &&
{
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) {
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) {
SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $&1_descriptor");
}
}
%typemap(argout) SWIGTYPE *,
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
{
ZVAL_LONG(return_value,$1);
}
%typemap(out) enum SWIGTYPE
{
ZVAL_LONG(return_value, (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;
} else {
char temp[256];
sprintf(temp, "%lld", (long long)$1);
ZVAL_STRING(return_value, temp, 1);
}
%}
%typemap(out) unsigned long long
%{
if ($1 <= (unsigned long long)LONG_MAX) {
return_value->value.lval = (long)($1);
return_value->type = IS_LONG;
} else {
char temp[256];
sprintf(temp, "%llu", (unsigned long long)$1);
ZVAL_STRING(return_value, temp, 1);
}
%}
%typemap(out) const int &,
const unsigned int &,
const short &,
const unsigned short &,
const long &,
const unsigned long &,
const signed char &,
const unsigned char &,
const bool &,
const size_t &
{
ZVAL_LONG(return_value,*$1);
}
%typemap(out) const enum SWIGTYPE &
{
ZVAL_LONG(return_value, (long)*$1);
}
%typemap(out) const enum SWIGTYPE &&
{
ZVAL_LONG(return_value, (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;
} else {
char temp[256];
sprintf(temp, "%lld", (long long)(*$1));
ZVAL_STRING(return_value, temp, 1);
}
%}
%typemap(out) const unsigned long long &
%{
if (*$1 <= (unsigned long long)LONG_MAX) {
return_value->value.lval = (long)(*$1);
return_value->type = IS_LONG;
} else {
char temp[256];
sprintf(temp, "%llu", (unsigned long long)(*$1));
ZVAL_STRING(return_value, temp, 1);
}
%}
%typemap(directorin) int,
unsigned int,
short,
unsigned short,
long,
unsigned long,
signed char,
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);
}
}
%typemap(out) bool
{
ZVAL_BOOL(return_value,($1)?1:0);
}
%typemap(out) const bool &
{
ZVAL_BOOL(return_value,(*$1)?1:0);
}
%typemap(directorin) bool
{
ZVAL_BOOL($input,($1)?1:0);
}
%typemap(out) float,
double
{
ZVAL_DOUBLE(return_value,$1);
}
%typemap(out) const float &,
const double &
{
ZVAL_DOUBLE(return_value,*$1);
}
%typemap(directorin) float,
double
{
ZVAL_DOUBLE($input,$1);
}
%typemap(out) char
{
ZVAL_STRINGL(return_value,&$1, 1, 1);
}
%typemap(out) const char &
{
ZVAL_STRINGL(return_value,&*$1, 1, 1);
}
%typemap(out) char *,
char []
{
if(!$1) {
ZVAL_NULL(return_value);
} else {
ZVAL_STRING(return_value, (char *)$1, 1);
}
}
%typemap(out) char *&
{
if(!*$1) {
ZVAL_NULL(return_value);
} else {
ZVAL_STRING(return_value, (char *)*$1, 1);
}
}
%typemap(out) SWIGTYPE *,
SWIGTYPE [],
SWIGTYPE &,
SWIGTYPE &&
%{
SWIG_SetPointerZval(return_value, (void *)$1, $1_descriptor, $owner);
%}
%typemap(out) SWIGTYPE *const&
%{
SWIG_SetPointerZval(return_value, (void *)*$1, $*1_descriptor, $owner);
%}
%typemap(directorin) SWIGTYPE *,
SWIGTYPE [],
SWIGTYPE &,
SWIGTYPE &&
%{
SWIG_SetPointerZval($input, (void *)&$1, $1_descriptor, ($owner)|2);
%}
%typemap(out, fragment="swig_php_init_member_ptr") SWIGTYPE (CLASS::*)
{
void * p = emalloc(sizeof($1));
memcpy(p, &$1, sizeof($1));
ZEND_REGISTER_RESOURCE(return_value, 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);
memcpy(&$1, p, sizeof($1));
}
%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((const $1_ltype &) $1);
SWIG_SetPointerZval(return_value, (void *)resultobj, $&1_descriptor, 1);
}
#else
{
$&1_ltype resultobj = ($&1_ltype) emalloc(sizeof($1_type));
memcpy(resultobj, &$1, sizeof($1_type));
SWIG_SetPointerZval(return_value, (void *)resultobj, $&1_descriptor, 1);
}
#endif
%typemap(directorin) SWIGTYPE
{
SWIG_SetPointerZval($input, SWIG_as_voidptr(new $1_ltype((const $1_ltype &)$1)), $&1_descriptor, 1|2);
}
%typemap(out) void "";
%typemap(out) char [ANY]
{
int len = 0;
while (len < $1_dim0 && $1[len]) ++len;
RETVAL_STRINGL($1, len, 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, const _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_INT32,IS_LONG)
%php_typecheck(unsigned long,SWIG_TYPECHECK_UINT32,IS_LONG)
%php_typecheck(long long,SWIG_TYPECHECK_INT64,IS_LONG)
%php_typecheck(unsigned long 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_SIZE,IS_LONG)
%php_typecheck(enum SWIGTYPE,SWIG_TYPECHECK_INTEGER,IS_LONG)
%php_typecheck(bool,SWIG_TYPECHECK_BOOL,IS_BOOL)
%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); "
%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE
{
void *tmp;
_v = (SWIG_ConvertPtr(*$input, (void **)&tmp, $&1_descriptor, 0) >= 0);
}
%typecheck(SWIG_TYPECHECK_POINTER)
SWIGTYPE *,
SWIGTYPE [],
SWIGTYPE &,
SWIGTYPE &&,
SWIGTYPE *const&
{
void *tmp;
_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);
}
%typecheck(SWIG_TYPECHECK_VOIDPTR) void *
{
void *tmp;
_v = (SWIG_ConvertPtr(*$input, (void**)&tmp, 0, 0) >= 0);
}
/* Exception handling */
%typemap(throws) int,
long,
short,
unsigned int,
unsigned long,
unsigned short {
zend_throw_exception(NULL, const_cast<char*>("C++ $1_type exception thrown"), $1 TSRMLS_CC);
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);
return;
%}
%typemap(throws) char * %{
zend_throw_exception(NULL, const_cast<char*>($1), 0 TSRMLS_CC);
return;
%}
/* Array reference typemaps */
%apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) }
%apply SWIGTYPE && { SWIGTYPE ((&&)[ANY]) }
/* const pointers */
%apply SWIGTYPE * { SWIGTYPE *const }
/* php keywords */
%include <phpkw.swg>

25
Lib/php5/phpinit.swg Normal file
View file

@ -0,0 +1,25 @@
/* ------------------------------------------------------------
* The start of the PHP initialization function
* ------------------------------------------------------------ */
%insert(init) "swiginit.swg"
%init %{
SWIG_php_minit {
SWIG_InitializeModule(0);
%}
%fragment("swig_php_init_member_ptr2", "header") {
#define SWIG_MEMBER_PTR ((char*)"CLASS::*")
static void swig_member_ptr_dtor(zend_rsrc_list_entry *rsrc TSRMLS_DC) {
efree(rsrc->ptr);
}
static int swig_member_ptr = 0;
}
%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);
}

866
Lib/php5/phpkw.swg Normal file
View file

@ -0,0 +1,866 @@
/* -----------------------------------------------------------------------------
* phpkw.swg
* ----------------------------------------------------------------------------- */
/* Keyword (case insensitive) */
#define PHPKW(x) %keywordwarn("'" `x` "' is a PHP keyword, renaming to 'c_" `x` "'",sourcefmt="%(lower)s",rename="c_%s") `x`
/* Class (case insensitive) */
#define PHPCN(x) %keywordwarn("'" `x` "' is a PHP reserved class name, renaming to 'c_" `x` "'",%$isclass,sourcefmt="%(lower)s",rename="c_%s") `x`
/* Constant (case insensitive) */
#define PHPBN1a(x) %namewarn(%warningmsg(SWIGWARN_PARSE_BUILTIN_NAME, "enum conflicts with a built-in constant '"`x`"' in PHP"),%$isenumitem,sourcefmt="%(lower)s") `x`
#define PHPBN1b(x) %namewarn(%warningmsg(SWIGWARN_PARSE_BUILTIN_NAME, "constant conflicts with a built-in constant '"`x`"' in PHP"),%$isconstant,sourcefmt="%(lower)s") `x`
%define PHPBN1(X)
PHPBN1a(X); PHPBN1b(X)
%enddef
/* Constant (case sensitive) */
#define PHPBN2a(x) %namewarn(%warningmsg(SWIGWARN_PARSE_BUILTIN_NAME, "enum conflicts with a built-in constant '"`x`"' in PHP"),%$isenumitem) `x`
#define PHPBN2b(x) %namewarn(%warningmsg(SWIGWARN_PARSE_BUILTIN_NAME, "constant conflicts with a built-in constant '"`x`"' in PHP"),%$isconstant) `x`
%define PHPBN2(X)
PHPBN2a(X); PHPBN2b(X)
%enddef
#define PHPFN(x) %keywordwarn("'" `x` "' is a PHP built-in function, renaming to 'c_" `x` "'",sourcefmt="%(lower)s",%$isfunction,%$not %$ismember,rename="c_%s") `x`
/* From: http://php.net/manual/en/reserved.keywords.php
* "You cannot use any of the following words as constants, class names,
* function or method names. Using them as variable names is generally OK, but
* could lead to confusion."
*/
/* Check is case insensitive - these *MUST* be listed in lower case here */
PHPKW(__halt_compiler);
PHPKW(abstract);
PHPKW(and);
PHPKW(array);
PHPKW(as);
PHPKW(break);
PHPKW(callable); // As of PHP 5.4
PHPKW(case);
PHPKW(catch);
PHPKW(class);
PHPKW(clone);
PHPKW(const);
PHPKW(continue);
PHPKW(declare);
PHPKW(default);
PHPKW(die); // "Language construct"
PHPKW(do);
PHPKW(echo); // "Language construct"
PHPKW(else);
PHPKW(elseif);
PHPKW(empty); // "Language construct"
PHPKW(enddeclare);
PHPKW(endfor);
PHPKW(endforeach);
PHPKW(endif);
PHPKW(endswitch);
PHPKW(endwhile);
PHPKW(eval); // "Language construct"
PHPKW(exit); // "Language construct"
PHPKW(extends);
PHPKW(final);
PHPKW(finally); // As of PHP 5.5
PHPKW(for);
PHPKW(foreach);
PHPKW(function);
PHPKW(global);
PHPKW(goto); // As of PHP 5.3
PHPKW(if);
PHPKW(implements);
PHPKW(include); // "Language construct"
PHPKW(include_once); // "Language construct"
PHPKW(instanceof);
PHPKW(insteadof); // As of PHP 5.4
PHPKW(interface);
PHPKW(isset); // "Language construct"
PHPKW(list); // "Language construct"
PHPKW(namespace); // As of PHP 5.3
PHPKW(new);
PHPKW(or);
PHPKW(print); // "Language construct"
PHPKW(private);
PHPKW(protected);
PHPKW(public);
PHPKW(require); // "Language construct"
PHPKW(require_once); // "Language construct"
PHPKW(return); // "Language construct"
PHPKW(static);
PHPKW(switch);
PHPKW(throw);
PHPKW(trait); // As of PHP 5.4
PHPKW(try);
PHPKW(unset); // "Language construct"
PHPKW(use);
PHPKW(var);
PHPKW(while);
PHPKW(xor);
PHPKW(yield); // As of PHP 5.5
// Compile-time "magic" constants
// From: http://php.net/manual/en/reserved.keywords.php
// also at: http://php.net/manual/en/language.constants.predefined.php
/* These *MUST* be listed in lower case here */
PHPKW(__class__);
PHPKW(__dir__); // As of PHP 5.3
PHPKW(__file__);
PHPKW(__function__);
PHPKW(__line__);
PHPKW(__method__);
PHPKW(__namespace__); // As of PHP 5.3
PHPKW(__trait__); // As of PHP 5.4
/* We classify these as built-in names since they conflict, but PHP still runs */
/* Predefined case-insensitive constants */
/* These *MUST* be listed in lower case here */
PHPBN1(null);
PHPBN1(true);
PHPBN1(false);
/* "Core Predefined Constants" from http://php.net/manual/en/reserved.constants.php */
/* These are case sensitive */
PHPBN2(PHP_VERSION);
PHPBN2(PHP_MAJOR_VERSION); // As of PHP 5.2.7
PHPBN2(PHP_MINOR_VERSION); // As of PHP 5.2.7
PHPBN2(PHP_RELEASE_VERSION); // As of PHP 5.2.7
PHPBN2(PHP_VERSION_ID); // As of PHP 5.2.7
PHPBN2(PHP_EXTRA_VERSION); // As of PHP 5.2.7
PHPBN2(PHP_ZTS); // As of PHP 5.2.7
PHPBN2(PHP_DEBUG); // As of PHP 5.2.7
PHPBN2(PHP_MAXPATHLEN); // As of PHP 5.3.0
PHPBN2(PHP_OS);
PHPBN2(PHP_SAPI);
PHPBN2(PHP_EOL); // As of PHP 5.0.2
PHPBN2(PHP_INT_MAX); // As of PHP 5.0.5
PHPBN2(PHP_INT_SIZE); // As of PHP 5.0.5
PHPBN2(DEFAULT_INCLUDE_PATH);
PHPBN2(PEAR_INSTALL_DIR);
PHPBN2(PEAR_EXTENSION_DIR);
PHPBN2(PHP_EXTENSION_DIR);
PHPBN2(PHP_PREFIX);
PHPBN2(PHP_BINDIR);
PHPBN2(PHP_BINARY); // As of PHP 5.4
PHPBN2(PHP_MANDIR); // As of PHP 5.3.7
PHPBN2(PHP_LIBDIR);
PHPBN2(PHP_DATADIR);
PHPBN2(PHP_SYSCONFDIR);
PHPBN2(PHP_LOCALSTATEDIR);
PHPBN2(PHP_CONFIG_FILE_PATH);
PHPBN2(PHP_CONFIG_FILE_SCAN_DIR);
PHPBN2(PHP_SHLIB_SUFFIX);
PHPBN2(E_ERROR);
PHPBN2(E_WARNING);
PHPBN2(E_PARSE);
PHPBN2(E_NOTICE);
PHPBN2(E_CORE_ERROR);
PHPBN2(E_CORE_WARNING);
PHPBN2(E_COMPILE_ERROR);
PHPBN2(E_COMPILE_WARNING);
PHPBN2(E_USER_ERROR);
PHPBN2(E_USER_WARNING);
PHPBN2(E_USER_NOTICE);
PHPBN2(E_DEPRECATED); // As of PHP 5.3.0
PHPBN2(E_USER_DEPRECATED); // As of PHP 5.3.0
PHPBN2(E_ALL);
PHPBN2(E_STRICT);
PHPBN2(__COMPILER_HALT_OFFSET__); // As of PHP 5.1.0
// TRUE, FALSE, NULL are listed on the same page, but are actually
// case-insensitive, whereas all the other constants listed there seem to be
// case-sensitive, so we handle TRUE, FALSE, NULL in PHPBN1.
PHPBN2(PHP_OUTPUT_HANDLER_START);
PHPBN2(PHP_OUTPUT_HANDLER_CONT);
PHPBN2(PHP_OUTPUT_HANDLER_END);
/* These don't actually seem to be set (tested on Linux, I guess they're
* Windows only?) */
PHPBN2(PHP_WINDOWS_NT_DOMAIN_CONTROLLER); // As of PHP 5.3
PHPBN2(PHP_WINDOWS_NT_SERVER); // As of PHP 5.3
PHPBN2(PHP_WINDOWS_NT_WORKSTATION); // As of PHP 5.3
PHPBN2(PHP_WINDOWS_VERSION_BUILD); // As of PHP 5.3
PHPBN2(PHP_WINDOWS_VERSION_MAJOR); // As of PHP 5.3
PHPBN2(PHP_WINDOWS_VERSION_MINOR); // As of PHP 5.3
PHPBN2(PHP_WINDOWS_VERSION_PLATFORM); // As of PHP 5.3
PHPBN2(PHP_WINDOWS_VERSION_PRODUCTTYPE); // As of PHP 5.3
PHPBN2(PHP_WINDOWS_VERSION_SP_MAJOR); // As of PHP 5.3
PHPBN2(PHP_WINDOWS_VERSION_SP_MINOR); // As of PHP 5.3
PHPBN2(PHP_WINDOWS_VERSION_SUITEMASK); // As of PHP 5.3
/* "Standard Predefined Constants" from http://php.net/manual/en/reserved.constants.php */
PHPBN2(EXTR_OVERWRITE);
PHPBN2(EXTR_SKIP);
PHPBN2(EXTR_PREFIX_SAME);
PHPBN2(EXTR_PREFIX_ALL);
PHPBN2(EXTR_PREFIX_INVALID);
PHPBN2(EXTR_PREFIX_IF_EXISTS);
PHPBN2(EXTR_IF_EXISTS);
PHPBN2(SORT_ASC);
PHPBN2(SORT_DESC);
PHPBN2(SORT_REGULAR);
PHPBN2(SORT_NUMERIC);
PHPBN2(SORT_STRING);
PHPBN2(CASE_LOWER);
PHPBN2(CASE_UPPER);
PHPBN2(COUNT_NORMAL);
PHPBN2(COUNT_RECURSIVE);
PHPBN2(ASSERT_ACTIVE);
PHPBN2(ASSERT_CALLBACK);
PHPBN2(ASSERT_BAIL);
PHPBN2(ASSERT_WARNING);
PHPBN2(ASSERT_QUIET_EVAL);
PHPBN2(CONNECTION_ABORTED);
PHPBN2(CONNECTION_NORMAL);
PHPBN2(CONNECTION_TIMEOUT);
PHPBN2(INI_USER);
PHPBN2(INI_PERDIR);
PHPBN2(INI_SYSTEM);
PHPBN2(INI_ALL);
PHPBN2(INI_SCANNER_NORMAL); // As of PHP 5.3
PHPBN2(INI_SCANNER_RAW); // As of PHP 5.3
PHPBN2(M_E);
PHPBN2(M_LOG2E);
PHPBN2(M_LOG10E);
PHPBN2(M_LN2);
PHPBN2(M_LN10);
PHPBN2(M_PI);
PHPBN2(M_PI_2);
PHPBN2(M_PI_4);
PHPBN2(M_1_PI);
PHPBN2(M_2_PI);
PHPBN2(M_2_SQRTPI);
PHPBN2(M_SQRT2);
PHPBN2(M_SQRT1_2);
PHPBN2(M_EULER); // As of PHP 5.2
PHPBN2(M_LNPI); // As of PHP 5.2
PHPBN2(M_SQRT3); // As of PHP 5.2
PHPBN2(M_SQRTPI); // As of PHP 5.2
PHPBN2(CRYPT_SALT_LENGTH);
PHPBN2(CRYPT_STD_DES);
PHPBN2(CRYPT_EXT_DES);
PHPBN2(CRYPT_MD5);
PHPBN2(CRYPT_BLOWFISH);
PHPBN2(DIRECTORY_SEPARATOR);
PHPBN2(SEEK_SET);
PHPBN2(SEEK_CUR);
PHPBN2(SEEK_END);
PHPBN2(LOCK_SH);
PHPBN2(LOCK_EX);
PHPBN2(LOCK_UN);
PHPBN2(LOCK_NB);
PHPBN2(HTML_SPECIALCHARS);
PHPBN2(HTML_ENTITIES);
PHPBN2(ENT_COMPAT);
PHPBN2(ENT_QUOTES);
PHPBN2(ENT_NOQUOTES);
PHPBN2(INFO_GENERAL);
PHPBN2(INFO_CREDITS);
PHPBN2(INFO_CONFIGURATION);
PHPBN2(INFO_MODULES);
PHPBN2(INFO_ENVIRONMENT);
PHPBN2(INFO_VARIABLES);
PHPBN2(INFO_LICENSE);
PHPBN2(INFO_ALL);
PHPBN2(CREDITS_GROUP);
PHPBN2(CREDITS_GENERAL);
PHPBN2(CREDITS_SAPI);
PHPBN2(CREDITS_MODULES);
PHPBN2(CREDITS_DOCS);
PHPBN2(CREDITS_FULLPAGE);
PHPBN2(CREDITS_QA);
PHPBN2(CREDITS_ALL);
PHPBN2(STR_PAD_LEFT);
PHPBN2(STR_PAD_RIGHT);
PHPBN2(STR_PAD_BOTH);
PHPBN2(PATHINFO_DIRNAME);
PHPBN2(PATHINFO_BASENAME);
PHPBN2(PATHINFO_EXTENSION);
PHPBN2(PATHINFO_FILENAME); // As of PHP 5.2
PHPBN2(PATH_SEPARATOR);
PHPBN2(CHAR_MAX);
PHPBN2(LC_CTYPE);
PHPBN2(LC_NUMERIC);
PHPBN2(LC_TIME);
PHPBN2(LC_COLLATE);
PHPBN2(LC_MONETARY);
PHPBN2(LC_ALL);
PHPBN2(LC_MESSAGES);
PHPBN2(ABDAY_1);
PHPBN2(ABDAY_2);
PHPBN2(ABDAY_3);
PHPBN2(ABDAY_4);
PHPBN2(ABDAY_5);
PHPBN2(ABDAY_6);
PHPBN2(ABDAY_7);
PHPBN2(DAY_1);
PHPBN2(DAY_2);
PHPBN2(DAY_3);
PHPBN2(DAY_4);
PHPBN2(DAY_5);
PHPBN2(DAY_6);
PHPBN2(DAY_7);
PHPBN2(ABMON_1);
PHPBN2(ABMON_2);
PHPBN2(ABMON_3);
PHPBN2(ABMON_4);
PHPBN2(ABMON_5);
PHPBN2(ABMON_6);
PHPBN2(ABMON_7);
PHPBN2(ABMON_8);
PHPBN2(ABMON_9);
PHPBN2(ABMON_10);
PHPBN2(ABMON_11);
PHPBN2(ABMON_12);
PHPBN2(MON_1);
PHPBN2(MON_2);
PHPBN2(MON_3);
PHPBN2(MON_4);
PHPBN2(MON_5);
PHPBN2(MON_6);
PHPBN2(MON_7);
PHPBN2(MON_8);
PHPBN2(MON_9);
PHPBN2(MON_10);
PHPBN2(MON_11);
PHPBN2(MON_12);
PHPBN2(AM_STR);
PHPBN2(PM_STR);
PHPBN2(D_T_FMT);
PHPBN2(D_FMT);
PHPBN2(T_FMT);
PHPBN2(T_FMT_AMPM);
PHPBN2(ERA);
PHPBN2(ERA_YEAR);
PHPBN2(ERA_D_T_FMT);
PHPBN2(ERA_D_FMT);
PHPBN2(ERA_T_FMT);
PHPBN2(ALT_DIGITS);
PHPBN2(INT_CURR_SYMBOL);
PHPBN2(CURRENCY_SYMBOL);
PHPBN2(CRNCYSTR);
PHPBN2(MON_DECIMAL_POINT);
PHPBN2(MON_THOUSANDS_SEP);
PHPBN2(MON_GROUPING);
PHPBN2(POSITIVE_SIGN);
PHPBN2(NEGATIVE_SIGN);
PHPBN2(INT_FRAC_DIGITS);
PHPBN2(FRAC_DIGITS);
PHPBN2(P_CS_PRECEDES);
PHPBN2(P_SEP_BY_SPACE);
PHPBN2(N_CS_PRECEDES);
PHPBN2(N_SEP_BY_SPACE);
PHPBN2(P_SIGN_POSN);
PHPBN2(N_SIGN_POSN);
PHPBN2(DECIMAL_POINT);
PHPBN2(RADIXCHAR);
PHPBN2(THOUSANDS_SEP);
PHPBN2(THOUSEP);
PHPBN2(GROUPING);
PHPBN2(YESEXPR);
PHPBN2(NOEXPR);
PHPBN2(YESSTR);
PHPBN2(NOSTR);
PHPBN2(CODESET);
PHPBN2(LOG_EMERG);
PHPBN2(LOG_ALERT);
PHPBN2(LOG_CRIT);
PHPBN2(LOG_ERR);
PHPBN2(LOG_WARNING);
PHPBN2(LOG_NOTICE);
PHPBN2(LOG_INFO);
PHPBN2(LOG_DEBUG);
PHPBN2(LOG_KERN);
PHPBN2(LOG_USER);
PHPBN2(LOG_MAIL);
PHPBN2(LOG_DAEMON);
PHPBN2(LOG_AUTH);
PHPBN2(LOG_SYSLOG);
PHPBN2(LOG_LPR);
PHPBN2(LOG_NEWS);
PHPBN2(LOG_UUCP);
PHPBN2(LOG_CRON);
PHPBN2(LOG_AUTHPRIV);
PHPBN2(LOG_LOCAL0);
PHPBN2(LOG_LOCAL1);
PHPBN2(LOG_LOCAL2);
PHPBN2(LOG_LOCAL3);
PHPBN2(LOG_LOCAL4);
PHPBN2(LOG_LOCAL5);
PHPBN2(LOG_LOCAL6);
PHPBN2(LOG_LOCAL7);
PHPBN2(LOG_PID);
PHPBN2(LOG_CONS);
PHPBN2(LOG_ODELAY);
PHPBN2(LOG_NDELAY);
PHPBN2(LOG_NOWAIT);
PHPBN2(LOG_PERROR);
/* Added in PHP 5.2 */
PHPBN2(PREG_BACKTRACK_LIMIT_ERROR);
PHPBN2(PREG_BAD_UTF8_ERROR);
PHPBN2(PREG_INTERNAL_ERROR);
PHPBN2(PREG_NO_ERROR);
PHPBN2(PREG_RECURSION_LIMIT_ERROR);
PHPBN2(UPLOAD_ERR_EXTENSION);
PHPBN2(STREAM_SHUT_RD);
PHPBN2(STREAM_SHUT_WR);
PHPBN2(STREAM_SHUT_RDWR);
PHPBN2(CURLE_FILESIZE_EXCEEDED);
PHPBN2(CURLE_FTP_SSL_FAILED);
PHPBN2(CURLE_LDAP_INVALID_URL);
PHPBN2(CURLFTPAUTH_DEFAULT);
PHPBN2(CURLFTPAUTH_SSL);
PHPBN2(CURLFTPAUTH_TLS);
PHPBN2(CURLFTPSSL_ALL);
PHPBN2(CURLFTPSSL_CONTROL);
PHPBN2(CURLFTPSSL_NONE);
PHPBN2(CURLFTPSSL_TRY);
PHPBN2(CURLOPT_FTP_SSL);
PHPBN2(CURLOPT_FTPSSLAUTH);
PHPBN2(CURLOPT_TCP_NODELAY); // Added in PHP 5.2.1
PHPBN2(CURLOPT_TIMEOUT_MS); // Added in PHP 5.2.3
PHPBN2(CURLOPT_CONNECTTIMEOUT_MS); // Added in PHP 5.2.3
PHPBN2(GMP_VERSION); // Added in PHP 5.2.2
PHPBN2(SWFTEXTFIELD_USEFONT);
PHPBN2(SWFTEXTFIELD_AUTOSIZE);
PHPBN2(SWF_SOUND_NOT_COMPRESSED);
PHPBN2(SWF_SOUND_ADPCM_COMPRESSED);
PHPBN2(SWF_SOUND_MP3_COMPRESSED);
PHPBN2(SWF_SOUND_NOT_COMPRESSED_LE);
PHPBN2(SWF_SOUND_NELLY_COMPRESSED);
PHPBN2(SWF_SOUND_5KHZ);
PHPBN2(SWF_SOUND_11KHZ);
PHPBN2(SWF_SOUND_22KHZ);
PHPBN2(SWF_SOUND_44KHZ);
PHPBN2(SWF_SOUND_8BITS);
PHPBN2(SWF_SOUND_16BITS);
PHPBN2(SWF_SOUND_MONO);
PHPBN2(SWF_SOUND_STEREO);
PHPBN2(OPENSSL_VERSION_NUMBER);
PHPBN2(SNMP_OID_OUTPUT_FULL);
PHPBN2(SNMP_OID_OUTPUT_NUMERIC);
PHPBN2(MSG_EAGAIN);
PHPBN2(MSG_ENOMSG);
/* Added in PHP 5.3 */
PHPBN2(CURLOPT_PROGRESSFUNCTION);
PHPBN2(IMG_FILTER_PIXELATE);
PHPBN2(JSON_ERROR_CTRL_CHAR);
PHPBN2(JSON_ERROR_DEPTH);
PHPBN2(JSON_ERROR_NONE);
PHPBN2(JSON_ERROR_STATE_MISMATCH);
PHPBN2(JSON_ERROR_SYNTAX);
PHPBN2(JSON_FORCE_OBJECT);
PHPBN2(JSON_HEX_TAG);
PHPBN2(JSON_HEX_AMP);
PHPBN2(JSON_HEX_APOS);
PHPBN2(JSON_HEX_QUOT);
PHPBN2(LDAP_OPT_NETWORK_TIMEOUT);
PHPBN2(LIBXML_LOADED_VERSION);
PHPBN2(PREG_BAD_UTF8_OFFSET_ERROR);
PHPBN2(BUS_ADRALN);
PHPBN2(BUS_ADRERR);
PHPBN2(BUS_OBJERR);
PHPBN2(CLD_CONTIUNED);
PHPBN2(CLD_DUMPED);
PHPBN2(CLD_EXITED);
PHPBN2(CLD_KILLED);
PHPBN2(CLD_STOPPED);
PHPBN2(CLD_TRAPPED);
PHPBN2(FPE_FLTDIV);
PHPBN2(FPE_FLTINV);
PHPBN2(FPE_FLTOVF);
PHPBN2(FPE_FLTRES);
PHPBN2(FPE_FLTSUB);
PHPBN2(FPE_FLTUND);
PHPBN2(FPE_INTDIV);
PHPBN2(FPE_INTOVF);
PHPBN2(ILL_BADSTK);
PHPBN2(ILL_COPROC);
PHPBN2(ILL_ILLADR);
PHPBN2(ILL_ILLOPC);
PHPBN2(ILL_ILLOPN);
PHPBN2(ILL_ILLTRP);
PHPBN2(ILL_PRVOPC);
PHPBN2(ILL_PRVREG);
PHPBN2(POLL_ERR);
PHPBN2(POLL_HUP);
PHPBN2(POLL_IN);
PHPBN2(POLL_MSG);
PHPBN2(POLL_OUT);
PHPBN2(POLL_PRI);
PHPBN2(SEGV_ACCERR);
PHPBN2(SEGV_MAPERR);
PHPBN2(SI_ASYNCIO);
PHPBN2(SI_KERNEL);
PHPBN2(SI_MESGQ);
PHPBN2(SI_NOINFO);
PHPBN2(SI_QUEUE);
PHPBN2(SI_SIGIO);
PHPBN2(SI_TIMER);
PHPBN2(SI_TKILL);
PHPBN2(SI_USER);
PHPBN2(SIG_BLOCK);
PHPBN2(SIG_SETMASK);
PHPBN2(SIG_UNBLOCK);
PHPBN2(TRAP_BRKPT);
PHPBN2(TRAP_TRACE);
/* Added in PHP 5.4 */
PHPBN2(ENT_DISALLOWED);
PHPBN2(ENT_HTML401);
PHPBN2(ENT_HTML5);
PHPBN2(ENT_SUBSTITUTE);
PHPBN2(ENT_XML1);
PHPBN2(ENT_XHTML);
PHPBN2(IPPROTO_IP);
PHPBN2(IPPROTO_IPV6);
PHPBN2(IPV6_MULTICAST_HOPS);
PHPBN2(IPV6_MULTICAST_IF);
PHPBN2(IPV6_MULTICAST_LOOP);
PHPBN2(IP_MULTICAST_IF);
PHPBN2(IP_MULTICAST_LOOP);
PHPBN2(IP_MULTICAST_TTL);
PHPBN2(MCAST_JOIN_GROUP);
PHPBN2(MCAST_LEAVE_GROUP);
PHPBN2(MCAST_BLOCK_SOURCE);
PHPBN2(MCAST_UNBLOCK_SOURCE);
PHPBN2(MCAST_JOIN_SOURCE_GROUP);
PHPBN2(MCAST_LEAVE_SOURCE_GROUP);
PHPBN2(CURLOPT_MAX_RECV_SPEED_LARGE);
PHPBN2(CURLOPT_MAX_SEND_SPEED_LARGE);
PHPBN2(LIBXML_HTML_NODEFDTD);
PHPBN2(LIBXML_HTML_NOIMPLIED);
PHPBN2(LIBXML_PEDANTIC);
PHPBN2(OPENSSL_CIPHER_AES_128_CBC);
PHPBN2(OPENSSL_CIPHER_AES_192_CBC);
PHPBN2(OPENSSL_CIPHER_AES_256_CBC);
PHPBN2(OPENSSL_RAW_DATA);
PHPBN2(OPENSSL_ZERO_PADDING);
PHPBN2(PHP_OUTPUT_HANDLER_CLEAN);
PHPBN2(PHP_OUTPUT_HANDLER_CLEANABLE);
PHPBN2(PHP_OUTPUT_HANDLER_DISABLED);
PHPBN2(PHP_OUTPUT_HANDLER_FINAL);
PHPBN2(PHP_OUTPUT_HANDLER_FLUSH);
PHPBN2(PHP_OUTPUT_HANDLER_FLUSHABLE);
PHPBN2(PHP_OUTPUT_HANDLER_REMOVABLE);
PHPBN2(PHP_OUTPUT_HANDLER_STARTED);
PHPBN2(PHP_OUTPUT_HANDLER_STDFLAGS);
PHPBN2(PHP_OUTPUT_HANDLER_WRITE);
PHPBN2(PHP_SESSION_ACTIVE);
PHPBN2(PHP_SESSION_DISABLED);
PHPBN2(PHP_SESSION_NONE);
PHPBN2(STREAM_META_ACCESS);
PHPBN2(STREAM_META_GROUP);
PHPBN2(STREAM_META_GROUP_NAME);
PHPBN2(STREAM_META_OWNER);
PHPBN2(STREAM_META_OWNER_NAME);
PHPBN2(STREAM_META_TOUCH);
PHPBN2(ZLIB_ENCODING_DEFLATE);
PHPBN2(ZLIB_ENCODING_GZIP);
PHPBN2(ZLIB_ENCODING_RAW);
PHPBN2(U_IDNA_DOMAIN_NAME_TOO_LONG_ERROR);
PHPBN2(IDNA_CHECK_BIDI);
PHPBN2(IDNA_CHECK_CONTEXTJ);
PHPBN2(IDNA_NONTRANSITIONAL_TO_ASCII);
PHPBN2(IDNA_NONTRANSITIONAL_TO_UNICODE);
PHPBN2(INTL_IDNA_VARIANT_2003);
PHPBN2(INTL_IDNA_VARIANT_UTS46);
PHPBN2(IDNA_ERROR_EMPTY_LABEL);
PHPBN2(IDNA_ERROR_LABEL_TOO_LONG);
PHPBN2(IDNA_ERROR_DOMAIN_NAME_TOO_LONG);
PHPBN2(IDNA_ERROR_LEADING_HYPHEN);
PHPBN2(IDNA_ERROR_TRAILING_HYPHEN);
PHPBN2(IDNA_ERROR_HYPHEN_3_4);
PHPBN2(IDNA_ERROR_LEADING_COMBINING_MARK);
PHPBN2(IDNA_ERROR_DISALLOWED);
PHPBN2(IDNA_ERROR_PUNYCODE);
PHPBN2(IDNA_ERROR_LABEL_HAS_DOT);
PHPBN2(IDNA_ERROR_INVALID_ACE_LABEL);
PHPBN2(IDNA_ERROR_BIDI);
PHPBN2(IDNA_ERROR_CONTEXTJ);
PHPBN2(JSON_PRETTY_PRINT);
PHPBN2(JSON_UNESCAPED_SLASHES);
PHPBN2(JSON_NUMERIC_CHECK);
PHPBN2(JSON_UNESCAPED_UNICODE);
PHPBN2(JSON_BIGINT_AS_STRING);
/* Added in PHP 5.5 */
PHPBN2(IMG_AFFINE_TRANSLATE);
PHPBN2(IMG_AFFINE_SCALE);
PHPBN2(IMG_AFFINE_ROTATE);
PHPBN2(IMG_AFFINE_SHEAR_HORIZONTAL);
PHPBN2(IMG_AFFINE_SHEAR_VERTICAL);
PHPBN2(IMG_CROP_DEFAULT);
PHPBN2(IMG_CROP_TRANSPARENT);
PHPBN2(IMG_CROP_BLACK);
PHPBN2(IMG_CROP_WHITE);
PHPBN2(IMG_CROP_SIDES);
PHPBN2(IMG_FLIP_BOTH);
PHPBN2(IMG_FLIP_HORIZONTAL);
PHPBN2(IMG_FLIP_VERTICAL);
PHPBN2(IMG_BELL);
PHPBN2(IMG_BESSEL);
PHPBN2(IMG_BICUBIC);
PHPBN2(IMG_BICUBIC_FIXED);
PHPBN2(IMG_BLACKMAN);
PHPBN2(IMG_BOX);
PHPBN2(IMG_BSPLINE);
PHPBN2(IMG_CATMULLROM);
PHPBN2(IMG_GAUSSIAN);
PHPBN2(IMG_GENERALIZED_CUBIC);
PHPBN2(IMG_HERMITE);
PHPBN2(IMG_HAMMING);
PHPBN2(IMG_HANNING);
PHPBN2(IMG_MITCHELL);
PHPBN2(IMG_POWER);
PHPBN2(IMG_QUADRATIC);
PHPBN2(IMG_SINC);
PHPBN2(IMG_NEAREST_NEIGHBOUR);
PHPBN2(IMG_WEIGHTED4);
PHPBN2(IMG_TRIANGLE);
PHPBN2(JSON_ERROR_RECURSION);
PHPBN2(JSON_ERROR_INF_OR_NAN);
PHPBN2(JSON_ERROR_UNSUPPORTED_TYPE);
PHPBN2(MYSQLI_SERVER_PUBLIC_KEY);
/* Added in PHP 5.6 */
PHPBN2(LDAP_ESCAPE_DN);
PHPBN2(LDAP_ESCAPE_FILTER);
PHPBN2(OPENSSL_DEFAULT_STREAM_CIPHERS);
PHPBN2(STREAM_CRYPTO_METHOD_ANY_CLIENT);
PHPBN2(STREAM_CRYPTO_METHOD_ANY_SERVER);
PHPBN2(STREAM_CRYPTO_METHOD_TLSv1_0_CLIENT);
PHPBN2(STREAM_CRYPTO_METHOD_TLSv1_0_SERVER);
PHPBN2(STREAM_CRYPTO_METHOD_TLSv1_1_CLIENT);
PHPBN2(STREAM_CRYPTO_METHOD_TLSv1_1_SERVER);
PHPBN2(STREAM_CRYPTO_METHOD_TLSv1_2_CLIENT);
PHPBN2(STREAM_CRYPTO_METHOD_TLSv1_2_SERVER);
PHPBN2(PGSQL_CONNECT_ASYNC);
PHPBN2(PGSQL_CONNECTION_AUTH_OK);
PHPBN2(PGSQL_CONNECTION_AWAITING_RESPONSE);
PHPBN2(PGSQL_CONNECTION_MADE);
PHPBN2(PGSQL_CONNECTION_SETENV);
PHPBN2(PGSQL_CONNECTION_SSL_STARTUP);
PHPBN2(PGSQL_CONNECTION_STARTED);
PHPBN2(PGSQL_DML_ESCAPE);
PHPBN2(PGSQL_POLLING_ACTIVE);
PHPBN2(PGSQL_POLLING_FAILED);
PHPBN2(PGSQL_POLLING_OK);
PHPBN2(PGSQL_POLLING_READING);
PHPBN2(PGSQL_POLLING_WRITING);
/* Class names reserved by PHP (case insensitive) */
PHPCN(directory);
PHPCN(stdclass);
PHPCN(__php_incomplete_class);
/* Added in PHP5. */
PHPCN(exception);
PHPCN(errorexception); // As of PHP 5.1
PHPCN(php_user_filter);
PHPCN(closure); // As of PHP 5.3
PHPCN(generator); // As of PHP 5.5
PHPCN(self);
PHPCN(static);
PHPCN(parent);
/* From extensions (which of these are actually predefined depends which
* extensions are loaded by default). */
PHPCN(xmlwriter);
PHPCN(libxmlerror);
PHPCN(simplexmlelement);
PHPCN(soapclient);
PHPCN(soapvar);
PHPCN(soapserver);
PHPCN(soapfault);
PHPCN(soapparam);
PHPCN(soapheader);
PHPCN(recursiveiteratoriterator);
PHPCN(filteriterator);
PHPCN(recursivefilteriterator);
PHPCN(parentiterator);
PHPCN(limititerator);
PHPCN(cachingiterator);
PHPCN(recursivecachingiterator);
PHPCN(iteratoriterator);
PHPCN(norewinditerator);
PHPCN(appenditerator);
PHPCN(infiniteiterator);
PHPCN(emptyiterator);
PHPCN(arrayobject);
PHPCN(arrayiterator);
PHPCN(recursivearrayiterator);
PHPCN(splfileinfo);
PHPCN(directoryiterator);
PHPCN(recursivedirectoryiterator);
PHPCN(splfileobject);
PHPCN(spltempfileobject);
PHPCN(simplexmliterator);
PHPCN(logicexception);
PHPCN(badfunctioncallexception);
PHPCN(badmethodcallexception);
PHPCN(domainexception);
PHPCN(invalidargumentexception);
PHPCN(lengthexception);
PHPCN(outofrangeexception);
PHPCN(runtimeexception);
PHPCN(outofboundsexception);
PHPCN(overflowexception);
PHPCN(rangeexception);
PHPCN(underflowexception);
PHPCN(unexpectedvalueexception);
PHPCN(splobjectstorage);
PHPCN(reflectionexception);
PHPCN(reflection);
PHPCN(reflectionfunction);
PHPCN(reflectionparameter);
PHPCN(reflectionmethod);
PHPCN(reflectionclass);
PHPCN(reflectionobject);
PHPCN(reflectionproperty);
PHPCN(reflectionextension);
PHPCN(domexception);
PHPCN(domstringlist);
PHPCN(domnamelist);
PHPCN(domimplementationlist);
PHPCN(domimplementationsource);
PHPCN(domimplementation);
PHPCN(domnode);
PHPCN(domnamespacenode);
PHPCN(domdocumentfragment);
PHPCN(domdocument);
PHPCN(domnodelist);
PHPCN(domnamednodemap);
PHPCN(domcharacterdata);
PHPCN(domattr);
PHPCN(domelement);
PHPCN(domtext);
PHPCN(domcomment);
PHPCN(domtypeinfo);
PHPCN(domuserdatahandler);
PHPCN(domdomerror);
PHPCN(domerrorhandler);
PHPCN(domlocator);
PHPCN(domconfiguration);
PHPCN(domcdatasection);
PHPCN(domdocumenttype);
PHPCN(domnotation);
PHPCN(domentity);
PHPCN(domentityreference);
PHPCN(domprocessinginstruction);
PHPCN(domstringextend);
PHPCN(domxpath);
PHPCN(xmlreader);
PHPCN(sqlitedatabase);
PHPCN(sqliteresult);
PHPCN(sqliteunbuffered);
PHPCN(sqliteexception);
PHPCN(datetime);
/* Built-in PHP functions (incomplete). */
/* Includes Array Functions - http://php.net/manual/en/ref.array.php */
/* Check is case insensitive - these *MUST* be listed in lower case here */
PHPFN(acos);
PHPFN(array_change_key_case);
PHPFN(array_chunk);
PHPFN(array_column);
PHPFN(array_combine);
PHPFN(array_count_values);
PHPFN(array_diff);
PHPFN(array_diff_assoc);
PHPFN(array_diff_key);
PHPFN(array_diff_uassoc);
PHPFN(array_diff_ukey);
PHPFN(array_fill);
PHPFN(array_fill_keys);
PHPFN(array_filter);
PHPFN(array_flip);
PHPFN(array_intersect);
PHPFN(array_intersect_assoc);
PHPFN(array_intersect_key);
PHPFN(array_intersect_uassoc);
PHPFN(array_intersect_ukey);
PHPFN(array_key_exists);
PHPFN(array_keys);
PHPFN(array_map);
PHPFN(array_merge);
PHPFN(array_merge_recursive);
PHPFN(array_multisort);
PHPFN(array_pad);
PHPFN(array_pop);
PHPFN(array_product);
PHPFN(array_push);
PHPFN(array_rand);
PHPFN(array_reduce);
PHPFN(array_replace);
PHPFN(array_replace_recursive);
PHPFN(array_reverse);
PHPFN(array_search);
PHPFN(array_shift);
PHPFN(array_slice);
PHPFN(array_splice);
PHPFN(array_sum);
PHPFN(array_udiff);
PHPFN(array_udiff_assoc);
PHPFN(array_udiff_uassoc);
PHPFN(array_uintersect);
PHPFN(array_uintersect_assoc);
PHPFN(array_uintersect_uassoc);
PHPFN(array_unique);
PHPFN(array_unshift);
PHPFN(array_values);
PHPFN(array_walk);
PHPFN(array_walk_recursive);
PHPFN(arsort);
PHPFN(asin);
PHPFN(asort);
PHPFN(atan);
PHPFN(atan2);
PHPFN(ceil);
PHPFN(compact);
PHPFN(cos);
PHPFN(cosh);
PHPFN(count);
PHPFN(current);
PHPFN(each);
PHPFN(end);
PHPFN(exp);
PHPFN(extract);
PHPFN(floor);
PHPFN(fmod);
PHPFN(in_array);
PHPFN(key);
PHPFN(key_exists);
PHPFN(krsort);
PHPFN(ksort);
PHPFN(log);
PHPFN(log10);
PHPFN(max);
PHPFN(min);
PHPFN(natcasesort);
PHPFN(natsort);
PHPFN(next);
PHPFN(pos);
PHPFN(pow);
PHPFN(prev);
PHPFN(range);
PHPFN(reset);
PHPFN(rsort);
PHPFN(shuffle);
PHPFN(sin);
PHPFN(sinh);
PHPFN(sizeof);
PHPFN(sort);
PHPFN(sqrt);
PHPFN(tan);
PHPFN(tanh);
PHPFN(uasort);
PHPFN(uksort);
PHPFN(usort);
#undef PHPKW
#undef PHPBN1a
#undef PHPBN1b
#undef PHPBN1
#undef PHPBN2a
#undef PHPBN2b
#undef PHPBN2
#undef PHPCN
#undef PHPFN

42
Lib/php5/phppointers.i Normal file
View file

@ -0,0 +1,42 @@
%define %pass_by_ref( TYPE, CONVERT_IN, CONVERT_OUT )
%typemap(in, byref=1) TYPE *REF ($*1_ltype tmp),
TYPE &REF ($*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, Expected a reference) );
}
%}
%typemap(argout) TYPE *REF,
TYPE &REF
"CONVERT_OUT(*$input, tmp$argnum );";
%enddef
%pass_by_ref( size_t, CONVERT_INT_IN, ZVAL_LONG );
%pass_by_ref( signed int, CONVERT_INT_IN, ZVAL_LONG );
%pass_by_ref( int, CONVERT_INT_IN, ZVAL_LONG );
%pass_by_ref( unsigned int, CONVERT_INT_IN, ZVAL_LONG );
%pass_by_ref( signed short, CONVERT_INT_IN, ZVAL_LONG );
%pass_by_ref( short, CONVERT_INT_IN, ZVAL_LONG );
%pass_by_ref( unsigned short, CONVERT_INT_IN, ZVAL_LONG );
%pass_by_ref( signed long, CONVERT_INT_IN, ZVAL_LONG );
%pass_by_ref( long, CONVERT_INT_IN, ZVAL_LONG );
%pass_by_ref( unsigned long, CONVERT_INT_IN, ZVAL_LONG );
%pass_by_ref( signed char, CONVERT_INT_IN, ZVAL_LONG );
%pass_by_ref( char, CONVERT_CHAR_IN, ZVAL_STRING );
%pass_by_ref( unsigned char, CONVERT_INT_IN, ZVAL_LONG );
%pass_by_ref( float, CONVERT_FLOAT_IN, ZVAL_DOUBLE );
%pass_by_ref( double, CONVERT_FLOAT_IN, ZVAL_DOUBLE );
%pass_by_ref( char *, CONVERT_CHAR_IN, ZVAL_STRING );

280
Lib/php5/phprun.swg Normal file
View file

@ -0,0 +1,280 @@
/* -----------------------------------------------------------------------------
* phprun.swg
*
* PHP runtime library
* ----------------------------------------------------------------------------- */
#ifdef __cplusplus
extern "C" {
#endif
#include "zend.h"
#include "zend_API.h"
#include "zend_exceptions.h"
#include "php.h"
#if PHP_MAJOR_VERSION != 5
# error These bindings need PHP5 - to generate PHP7 bindings use: swig -php7
#endif
#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
#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_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);\
} 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";
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) do { SWIG_ErrorCode() = code; SWIG_ErrorMsg() = msg; SWIG_fail; } while (0)
#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_Php_GetModule()
#define SWIG_SetModule(clientdata, pointer) SWIG_Php_SetModule(pointer)
/* used to wrap returned objects in so we know whether they are newobject
and need freeing, or not */
typedef struct {
void * ptr;
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) {
/*
* First test for Null pointers. Return those as PHP native NULL
*/
if (!ptr ) {
ZVAL_NULL(z);
return;
}
if (type->clientdata) {
swig_object_wrapper *value;
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 & 1);
if ((newobject & 2) == 0) {
/* Just register the pointer as a resource. */
ZEND_REGISTER_RESOURCE(z, 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;
const char *type_name = type->name+3; /* +3 so: _p_Foo -> Foo */
size_t type_name_len;
int result;
const char * p;
/* Namespace__Foo -> Foo */
/* FIXME: ugly and goes wrong for classes with __ in their names. */
while ((p = strstr(type_name, "__")) != NULL) {
type_name = p + 2;
}
type_name_len = strlen(type_name);
MAKE_STD_ZVAL(resource);
ZEND_REGISTER_RESOURCE(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);
} else {
result = zend_lookup_class((char *)type_name, type_name_len, &ce TSRMLS_CC);
}
if (result != SUCCESS) {
/* class does not exist */
object_init(z);
} else {
object_init_ex(z, *ce);
}
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);
}
return;
}
zend_error(E_ERROR, "Type: %s not registered with zend",type->name);
}
/* This pointer conversion routine takes the native pointer p (along with
its type name) and converts it by calling appropriate casting functions
according to ty. The resultant pointer is returned, or NULL is returned
if the pointer can't be cast.
Sadly PHP has no API to find a type name from a type id, only from an
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
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_cast_info *tc;
void *result = 0;
if (!ty) {
/* They don't care about the target type, so just pass on the pointer! */
return p;
}
if (! type_name) {
/* can't convert p to ptr type ty if we don't know what type p is */
return NULL;
}
/* convert and cast p from type_name to ptr as ty. */
tc = SWIG_TypeCheck(type_name, ty);
if (tc) {
int newmemory = 0;
result = SWIG_TypeCast(tc, p, &newmemory);
assert(!newmemory); /* newmemory handling not yet implemented */
}
return result;
}
/* 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. */
static void *
SWIG_ZTS_ConvertResourcePtr(zval *z, swig_type_info *ty, int flags TSRMLS_DC) {
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 (flags & SWIG_POINTER_DISOWN) {
value->newobject = 0;
}
p = value->ptr;
type_name=zend_rsrc_list_get_rsrc_type(z->value.lval TSRMLS_CC);
return SWIG_ZTS_ConvertResourceData(p, type_name, ty TSRMLS_CC);
}
/* 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) {
if (z == NULL) {
*ptr = 0;
return 0;
}
switch (z->type) {
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);
}
}
break;
}
case IS_RESOURCE:
*ptr = SWIG_ZTS_ConvertResourcePtr(z, ty, flags TSRMLS_CC);
return (*ptr == NULL ? -1 : 0);
case IS_NULL:
*ptr = 0;
return 0;
}
return -1;
}
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;
}
}
FREE_ZVAL(pointer);
return ret;
}
static void SWIG_Php_SetModule(swig_module_info *pointer) {
TSRMLS_FETCH();
REGISTER_MAIN_LONG_CONSTANT(const_name, (long) pointer, CONST_PERSISTENT | CONST_CS);
}

10
Lib/php5/std_common.i Normal file
View file

@ -0,0 +1,10 @@
/* -----------------------------------------------------------------------------
* std_common.i
*
* SWIG typemaps for STL - common utilities
* ----------------------------------------------------------------------------- */
%include <std/std_except.i>
%apply size_t { std::size_t };

1
Lib/php5/std_deque.i Normal file
View file

@ -0,0 +1 @@
%include <std/_std_deque.i>

76
Lib/php5/std_map.i Normal file
View file

@ -0,0 +1,76 @@
/* -----------------------------------------------------------------------------
* std_map.i
*
* SWIG typemaps for std::map
* ----------------------------------------------------------------------------- */
%include <std_common.i>
// ------------------------------------------------------------------------
// std::map
// ------------------------------------------------------------------------
%{
#include <map>
#include <algorithm>
#include <stdexcept>
%}
// exported class
namespace std {
template<class K, class T> class map {
// add typemaps here
public:
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef K key_type;
typedef T mapped_type;
map();
map(const map<K,T> &);
unsigned int size() const;
void clear();
%extend {
const T& get(const K& key) throw (std::out_of_range) {
std::map<K,T >::iterator i = self->find(key);
if (i != self->end())
return i->second;
else
throw std::out_of_range("key not found");
}
void set(const K& key, const T& x) {
(*self)[key] = x;
}
void del(const K& key) throw (std::out_of_range) {
std::map<K,T >::iterator i = self->find(key);
if (i != self->end())
self->erase(i);
else
throw std::out_of_range("key not found");
}
bool has_key(const K& key) {
std::map<K,T >::iterator i = self->find(key);
return i != self->end();
}
bool is_empty() const {
return self->empty();
}
}
};
// Legacy macros (deprecated)
%define specialize_std_map_on_key(K,CHECK,CONVERT_FROM,CONVERT_TO)
#warning "specialize_std_map_on_key ignored - macro is deprecated and no longer necessary"
%enddef
%define specialize_std_map_on_value(T,CHECK,CONVERT_FROM,CONVERT_TO)
#warning "specialize_std_map_on_value ignored - macro is deprecated and no longer necessary"
%enddef
%define specialize_std_map_on_both(K,CHECK_K,CONVERT_K_FROM,CONVERT_K_TO, T,CHECK_T,CONVERT_T_FROM,CONVERT_T_TO)
#warning "specialize_std_map_on_both ignored - macro is deprecated and no longer necessary"
%enddef
}

34
Lib/php5/std_pair.i Normal file
View file

@ -0,0 +1,34 @@
/* -----------------------------------------------------------------------------
* std_pair.i
*
* SWIG typemaps for std::pair
* ----------------------------------------------------------------------------- */
%include <std_common.i>
%include <exception.i>
// ------------------------------------------------------------------------
// std::pair
// ------------------------------------------------------------------------
%{
#include <utility>
%}
namespace std {
template<class T, class U> struct pair {
pair();
pair(T first, U second);
pair(const pair& p);
template <class U1, class U2> pair(const pair<U1, U2> &p);
T first;
U second;
};
// add specializations here
}

79
Lib/php5/std_string.i Normal file
View file

@ -0,0 +1,79 @@
/* -----------------------------------------------------------------------------
* std_string.i
*
* SWIG typemaps for std::string types
* ----------------------------------------------------------------------------- */
// ------------------------------------------------------------------------
// std::string is typemapped by value
// This can prevent exporting methods which return a string
// in order for the user to modify it.
// However, I think I'll wait until someone asks for it...
// ------------------------------------------------------------------------
%include <exception.i>
%{
#include <string>
%}
namespace std {
%naturalvar string;
class string;
%typemap(typecheck,precedence=SWIG_TYPECHECK_STRING) string, const string& %{
$1 = ( Z_TYPE_PP($input) == IS_STRING ) ? 1 : 0;
%}
%typemap(in) string %{
convert_to_string_ex($input);
$1.assign(Z_STRVAL_PP($input), Z_STRLEN_PP($input));
%}
%typemap(directorout) string %{
convert_to_string_ex(&$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);
%}
%typemap(directorin) string, const string& %{
ZVAL_STRINGL($input, const_cast<char*>($1.data()), $1.size(), 1);
%}
%typemap(out) const string & %{
ZVAL_STRINGL($result, const_cast<char*>($1->data()), $1->size(), 1);
%}
%typemap(throws) string, const string& %{
zend_throw_exception(NULL, const_cast<char*>($1.c_str()), 0 TSRMLS_CC);
return;
%}
/* 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(directorout) string & ($*1_ltype *temp) %{
convert_to_string_ex(&$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);
%}
/* SWIG will apply the non-const typemap above to const string& without
* this more specific typemap. */
%typemap(argout) const string & "";
}

102
Lib/php5/std_vector.i Normal file
View file

@ -0,0 +1,102 @@
/* -----------------------------------------------------------------------------
* std_vector.i
* ----------------------------------------------------------------------------- */
%include <std_common.i>
%{
#include <vector>
#include <stdexcept>
%}
namespace std {
template<class T> class vector {
public:
typedef size_t size_type;
typedef T value_type;
typedef const value_type& const_reference;
vector();
vector(size_type n);
size_type size() const;
size_type capacity() const;
void reserve(size_type n);
void clear();
%rename(push) push_back;
void push_back(const value_type& x);
%extend {
bool is_empty() const {
return $self->empty();
}
T pop() throw (std::out_of_range) {
if (self->size() == 0)
throw std::out_of_range("pop from empty vector");
T x = self->back();
self->pop_back();
return x;
}
const_reference get(int i) throw (std::out_of_range) {
int size = int(self->size());
if (i>=0 && i<size)
return (*self)[i];
else
throw std::out_of_range("vector index out of range");
}
void set(int i, const value_type& val) throw (std::out_of_range) {
int size = int(self->size());
if (i>=0 && i<size)
(*self)[i] = val;
else
throw std::out_of_range("vector index out of range");
}
}
};
// bool specialization
template<> class vector<bool> {
public:
typedef size_t size_type;
typedef bool value_type;
typedef bool const_reference;
vector();
vector(size_type n);
size_type size() const;
size_type capacity() const;
void reserve(size_type n);
void clear();
%rename(push) push_back;
void push_back(const value_type& x);
%extend {
bool is_empty() const {
return $self->empty();
}
bool pop() throw (std::out_of_range) {
if (self->size() == 0)
throw std::out_of_range("pop from empty vector");
bool x = self->back();
self->pop_back();
return x;
}
bool get(int i) throw (std::out_of_range) {
int size = int(self->size());
if (i>=0 && i<size)
return (*self)[i];
else
throw std::out_of_range("vector index out of range");
}
void set(int i, const value_type& val) throw (std::out_of_range) {
int size = int(self->size());
if (i>=0 && i<size)
(*self)[i] = val;
else
throw std::out_of_range("vector index out of range");
}
}
};
}
%define specialize_std_vector(T)
#warning "specialize_std_vector - specialization for type T no longer needed"
%enddef

12
Lib/php5/stl.i Normal file
View file

@ -0,0 +1,12 @@
/* -----------------------------------------------------------------------------
* stl.i
*
* Initial STL definition. extended as needed in each language
* ----------------------------------------------------------------------------- */
%include <std_common.i>
%include <std_string.i>
%include <std_vector.i>
%include <std_map.i>
%include <std_pair.i>

322
Lib/php5/typemaps.i Normal file
View file

@ -0,0 +1,322 @@
/* -----------------------------------------------------------------------------
* typemaps.i.
*
* SWIG Typemap library for PHP.
*
* This library provides standard typemaps for modifying SWIG's behavior.
* With enough entries in this file, I hope that very few people actually
* ever need to write a typemap.
*
* Define macros to define the following typemaps:
*
* TYPE *INPUT. Argument is passed in as native variable by value.
* TYPE *OUTPUT. Argument is returned as an array from the function call.
* TYPE *INOUT. Argument is passed in by value, and out as part of returned list
* TYPE *REFERENCE. Argument is passed in as native variable with value
* semantics. Variable value is changed with result.
* Use like this:
* int foo(int *REFERENCE);
*
* $a = 0;
* $rc = foo($a);
*
* Even though $a looks like it's passed by value,
* its value can be changed by foo().
* ----------------------------------------------------------------------------- */
%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;
$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 );
}
%typemap(in) TYPE *REFERENCE (TYPE lvalue), TYPE &REFERENCE (TYPE lvalue)
%{
convert_to_boolean_ex($input);
lvalue = (*$input)->value.lval ? true : false;
$1 = &lvalue;
%}
%typemap(argout) TYPE *REFERENCE, TYPE &REFERENCE
%{
(*$arg)->value.lval = lvalue$argnum ? true : false;
(*$arg)->type = IS_BOOL;
%}
%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);
$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 );
}
%typemap(in) TYPE *REFERENCE (TYPE dvalue), TYPE &REFERENCE (TYPE dvalue)
%{
convert_to_double_ex($input);
dvalue = (TYPE) (*$input)->value.dval;
$1 = &dvalue;
%}
%typemap(argout) TYPE *REFERENCE, TYPE &REFERENCE
%{
$1->value.dval = (double)(lvalue$argnum);
$1->type = IS_DOUBLE;
%}
%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);
$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 );
}
%typemap(in) TYPE *REFERENCE (TYPE lvalue), TYPE &REFERENCE (TYPE lvalue)
%{
convert_to_long_ex($input);
lvalue = (TYPE) (*$input)->value.lval;
$1 = &lvalue;
%}
%typemap(argout) TYPE *REFERENCE, TYPE &REFERENCE
%{
(*$arg)->value.lval = (long)(lvalue$argnum);
(*$arg)->type = IS_LONG;
%}
%enddef
BOOL_TYPEMAP(bool);
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);
INT_TYPEMAP(signed char);
INT_TYPEMAP(long long);
%typemap(argout,fragment="t_output_helper") long long *OUTPUT
{
zval *o;
MAKE_STD_ZVAL(o);
if ((long long)LONG_MIN <= temp$argnum && temp$argnum <= (long long)LONG_MAX) {
ZVAL_LONG(o, temp$argnum);
} else {
char temp[256];
sprintf(temp, "%lld", (long long)temp$argnum);
ZVAL_STRING(o, temp, 1);
}
t_output_helper( &$result, o TSRMLS_CC );
}
%typemap(in) TYPE *REFERENCE (long long lvalue)
%{
CONVERT_LONG_LONG_IN(lvalue, long long, $input)
$1 = &lvalue;
%}
%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;
} else {
char temp[256];
sprintf(temp, "%lld", (long long)lvalue$argnum);
ZVAL_STRING((*$arg), temp, 1);
}
%}
%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;
} else {
char temp[256];
sprintf(temp, "%lld", (long long)(*arg$argnum));
ZVAL_STRING($result, temp, 1);
}
%}
INT_TYPEMAP(unsigned long long);
%typemap(argout,fragment="t_output_helper") unsigned long long *OUTPUT
{
zval *o;
MAKE_STD_ZVAL(o);
if (temp$argnum <= (unsigned long long)LONG_MAX) {
ZVAL_LONG(o, temp$argnum);
} else {
char temp[256];
sprintf(temp, "%llu", (unsigned long long)temp$argnum);
ZVAL_STRING(o, temp, 1);
}
t_output_helper( &$result, o TSRMLS_CC );
}
%typemap(in) TYPE *REFERENCE (unsigned long long lvalue)
%{
CONVERT_UNSIGNED_LONG_LONG_IN(lvalue, unsigned long long, $input)
$1 = &lvalue;
%}
%typemap(argout) unsigned long long *REFERENCE
%{
if (lvalue$argnum <= (unsigned long long)LONG_MAX) {
(*$arg)->value.lval = (long)(lvalue$argnum);
(*$arg)->type = IS_LONG;
} else {
char temp[256];
sprintf(temp, "%llu", (unsigned long long)lvalue$argnum);
ZVAL_STRING((*$arg), temp, 1);
}
%}
%typemap(argout) unsigned long long &OUTPUT
%{
if (*arg$argnum <= (unsigned long long)LONG_MAX) {
($result)->value.lval = (long)(*arg$argnum);
($result)->type = IS_LONG;
} else {
char temp[256];
sprintf(temp, "%llu", (unsigned long long)(*arg$argnum));
ZVAL_STRING($result, temp, 1);
}
%}
%typemap(in) bool *INOUT = bool *INPUT;
%typemap(in) float *INOUT = float *INPUT;
%typemap(in) double *INOUT = double *INPUT;
%typemap(in) int *INOUT = int *INPUT;
%typemap(in) short *INOUT = short *INPUT;
%typemap(in) long *INOUT = long *INPUT;
%typemap(in) long long *INOUT = long long *INPUT;
%typemap(in) unsigned *INOUT = unsigned *INPUT;
%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) unsigned long long *INOUT = unsigned long long *INPUT;
%typemap(in) signed char *INOUT = signed char *INPUT;
%typemap(in) bool &INOUT = bool *INPUT;
%typemap(in) float &INOUT = float *INPUT;
%typemap(in) double &INOUT = double *INPUT;
%typemap(in) int &INOUT = int *INPUT;
%typemap(in) short &INOUT = short *INPUT;
%typemap(in) long &INOUT = long *INPUT;
%typemap(in) long long &INOUT = long long *INPUT;
%typemap(in) long long &INPUT = long long *INPUT;
%typemap(in) unsigned &INOUT = unsigned *INPUT;
%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) unsigned long long &INOUT = unsigned long long *INPUT;
%typemap(in) unsigned long long &INPUT = unsigned long long *INPUT;
%typemap(in) signed char &INOUT = signed char *INPUT;
%typemap(argout) bool *INOUT = bool *OUTPUT;
%typemap(argout) float *INOUT = float *OUTPUT;
%typemap(argout) double *INOUT= double *OUTPUT;
%typemap(argout) int *INOUT = int *OUTPUT;
%typemap(argout) short *INOUT = short *OUTPUT;
%typemap(argout) long *INOUT= long *OUTPUT;
%typemap(argout) long long *INOUT= long long *OUTPUT;
%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) unsigned long long *INOUT = unsigned long long *OUTPUT;
%typemap(argout) signed char *INOUT = signed char *OUTPUT;
%typemap(argout) bool &INOUT = bool *OUTPUT;
%typemap(argout) float &INOUT = float *OUTPUT;
%typemap(argout) double &INOUT= double *OUTPUT;
%typemap(argout) int &INOUT = int *OUTPUT;
%typemap(argout) short &INOUT = short *OUTPUT;
%typemap(argout) long &INOUT= long *OUTPUT;
%typemap(argout) long long &INOUT= long long *OUTPUT;
%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) unsigned long long &INOUT = unsigned long long *OUTPUT;
%typemap(argout) signed char &INOUT = signed char *OUTPUT;
%typemap(in) char INPUT[ANY] ( char temp[$1_dim0] )
%{
convert_to_string_ex($input);
strncpy(temp,Z_STRVAL_PP($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 );
}
%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) < 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 **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);
}
}
%}

114
Lib/php5/utils.i Normal file
View file

@ -0,0 +1,114 @@
%define CONVERT_BOOL_IN(lvar,t,invar)
convert_to_boolean_ex(invar);
lvar = (t) Z_LVAL_PP(invar);
%enddef
%define CONVERT_INT_IN(lvar,t,invar)
convert_to_long_ex(invar);
lvar = (t) Z_LVAL_PP(invar);
%enddef
%define CONVERT_LONG_LONG_IN(lvar,t,invar)
switch ((*(invar))->type) {
case IS_DOUBLE:
lvar = (t) (*(invar))->value.dval;
break;
case IS_STRING: {
char * endptr;
errno = 0;
lvar = (t) strtoll((*(invar))->value.str.val, &endptr, 10);
if (*endptr && !errno) break;
/* FALL THRU */
}
default:
convert_to_long_ex(invar);
lvar = (t) (*(invar))->value.lval;
}
%enddef
%define CONVERT_UNSIGNED_LONG_LONG_IN(lvar,t,invar)
switch ((*(invar))->type) {
case IS_DOUBLE:
lvar = (t) (*(invar))->value.dval;
break;
case IS_STRING: {
char * endptr;
errno = 0;
lvar = (t) strtoull((*(invar))->value.str.val, &endptr, 10);
if (*endptr && !errno) break;
/* FALL THRU */
}
default:
convert_to_long_ex(invar);
lvar = (t) (*(invar))->value.lval;
}
%enddef
%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)
if ((*invar)->type==IS_NULL) {
lvar = (t) 0;
} else {
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);
%}
%typemap(in) const TYPE & ($*1_ltype temp)
%{
CONVERT_IN(temp,$*1_ltype,$input);
$1 = &temp;
%}
%typemap(directorout) TYPE
%{
CONVERT_IN($result,$1_ltype,&$input);
%}
%typemap(directorout) const TYPE & ($*1_ltype temp)
%{
CONVERT_IN(temp,$*1_ltype,&$input);
$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 ) {
/* it's already an array, just append */
add_next_index_zval( *target, o );
return;
}
if ( (*target)->type == IS_NULL ) {
REPLACE_ZVAL_VALUE(target,o,1);
FREE_ZVAL(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);
}
%}

7
Lib/python/builtin.swg
View file

@ -13,6 +13,11 @@ SWIGINTERN Py_hash_t
SWIG_PyNumber_AsPyHash(PyObject *obj) {
Py_hash_t result = -1;
#if PY_VERSION_HEX < 0x03020000
#if PY_VERSION_HEX < 0x03000000
if (PyInt_Check(obj))
result = PyInt_AsLong(obj);
else
#endif
if (PyLong_Check(obj))
result = PyLong_AsLong(obj);
#else
@ -21,7 +26,7 @@ SWIG_PyNumber_AsPyHash(PyObject *obj) {
#endif
else
PyErr_Format(PyExc_TypeError, "Wrong type for hash function");
return result;
return PyErr_Occurred() ? -1 : result;
}
SWIGINTERN int

42
Lib/python/carrays.i
View file

@ -2,48 +2,8 @@
#if defined(SWIGPYTHON_BUILTIN)
%feature("python:slot", "sq_item", functype="ssizeargfunc") NAME::__getitem__;
%feature("python:slot", "sq_ass_item", functype="ssizeobjargproc") NAME::__setitem__;
%inline %{
typedef struct {
TYPE *el;
} NAME;
%}
%extend NAME {
NAME(size_t nelements) {
NAME *arr = %new_instance(NAME);
arr->el = %new_array(nelements, TYPE);
return arr;
}
~NAME() {
%delete_array(self->el);
%delete(self);
}
TYPE __getitem__(size_t index) {
return self->el[index];
}
void __setitem__(size_t index, TYPE value) {
self->el[index] = value;
}
TYPE * cast() {
return self->el;
}
static NAME *frompointer(TYPE *t) {
return %reinterpret_cast(t, NAME *);
}
};
%types(NAME = TYPE);
#else
%array_class_wrap(TYPE,NAME,__getitem__,__setitem__)
#endif
%array_class_wrap(TYPE,NAME,__getitem__,__setitem__)
%enddef
%include <typemaps/carrays.swg>

8
Lib/python/pycontainer.swg
View file

@ -108,7 +108,7 @@ namespace swig {
namespace std {
template <>
struct less <PyObject *>: public binary_function<PyObject *, PyObject *, bool>
struct less <PyObject *>
{
bool
operator()(PyObject * v, PyObject *w) const
@ -133,7 +133,7 @@ namespace std {
};
template <>
struct less <swig::SwigPtr_PyObject>: public binary_function<swig::SwigPtr_PyObject, swig::SwigPtr_PyObject, bool>
struct less <swig::SwigPtr_PyObject>
{
bool
operator()(const swig::SwigPtr_PyObject& v, const swig::SwigPtr_PyObject& w) const
@ -143,7 +143,7 @@ namespace std {
};
template <>
struct less <swig::SwigVar_PyObject>: public binary_function<swig::SwigVar_PyObject, swig::SwigVar_PyObject, bool>
struct less <swig::SwigVar_PyObject>
{
bool
operator()(const swig::SwigVar_PyObject& v, const swig::SwigVar_PyObject& w) const
@ -1012,7 +1012,7 @@ namespace swig {
%#ifdef SWIG_PYTHON_EXTRA_NATIVE_CONTAINERS
swig_type_info *desc = swig::type_info<sequence>();
if (desc && desc->clientdata) {
return SWIG_NewPointerObj(new sequence(seq), desc, SWIG_POINTER_OWN);
return SWIG_InternalNewPointerObj(new sequence(seq), desc, SWIG_POINTER_OWN);
}
%#endif
size_type size = seq.size();

32
Lib/python/pyopers.swg
View file

@ -108,11 +108,6 @@
%pybinoperator(__neg__, *::operator-(), unaryfunc, nb_negative);
%pybinoperator(__neg__, *::operator-() const, unaryfunc, nb_negative);
%pybinoperator(__mul__, *::operator*, binaryfunc, nb_multiply);
#if defined(SWIGPYTHON_PY3)
%pybinoperator(__truediv__, *::operator/, binaryfunc, nb_divide);
#else
%pybinoperator(__div__, *::operator/, binaryfunc, nb_divide);
#endif
%pybinoperator(__mod__, *::operator%, binaryfunc, nb_remainder);
%pybinoperator(__lshift__, *::operator<<, binaryfunc, nb_lshift);
%pybinoperator(__rshift__, *::operator>>, binaryfunc, nb_rshift);
@ -134,6 +129,7 @@
#if defined(SWIGPYTHON_BUILTIN)
%pybinoperator(__nonzero__, *::operator bool, inquiry, nb_nonzero);
%pybinoperator(__truediv__, *::operator/ , binaryfunc, nb_divide);
#else
%feature("shadow") *::operator bool %{
def __nonzero__(self):
@ -141,6 +137,13 @@ def __nonzero__(self):
__bool__ = __nonzero__
%};
%rename(__nonzero__) *::operator bool;
%feature("shadow") *::operator/ %{
def __truediv__(self, *args):
return $action(self, *args)
__div__ = __truediv__
%};
%rename(__truediv__) *::operator/;
%pythonmaybecall *::operator/;
#endif
/* Ignored operators */
@ -207,11 +210,6 @@ __bool__ = __nonzero__
%pyinplaceoper(__iadd__ , *::operator +=, binaryfunc, nb_inplace_add);
%pyinplaceoper(__isub__ , *::operator -=, binaryfunc, nb_inplace_subtract);
%pyinplaceoper(__imul__ , *::operator *=, binaryfunc, nb_inplace_multiply);
#if defined(SWIGPYTHON_PY3)
%pyinplaceoper(__itruediv__ , *::operator /=, binaryfunc, nb_inplace_divide);
#else
%pyinplaceoper(__idiv__ , *::operator /=, binaryfunc, nb_inplace_divide);
#endif
%pyinplaceoper(__imod__ , *::operator %=, binaryfunc, nb_inplace_remainder);
%pyinplaceoper(__iand__ , *::operator &=, binaryfunc, nb_inplace_and);
%pyinplaceoper(__ior__ , *::operator |=, binaryfunc, nb_inplace_or);
@ -219,6 +217,19 @@ __bool__ = __nonzero__
%pyinplaceoper(__ilshift__, *::operator <<=, binaryfunc, nb_inplace_lshift);
%pyinplaceoper(__irshift__, *::operator >>=, binaryfunc, nb_inplace_rshift);
/* Special cases */
#if defined(SWIGPYTHON_BUILTIN)
%pyinplaceoper(__itruediv__ , *::operator /=, binaryfunc, nb_inplace_divide);
#else
%delobject *::operator /=;
%newobject *::operator /=;
%feature("shadow") *::operator /= %{
def __itruediv__(self, *args):
return $action(self, *args)
__idiv__ = __itruediv__
%};
%rename(__itruediv__) *::operator /=;
#endif
/* Finally, in python we need to mark the binary operations to fail as
'maybecall' methods */
@ -233,6 +244,7 @@ __bool__ = __nonzero__
%pybinopermaybecall(neg);
%pybinopermaybecall(mul);
%pybinopermaybecall(div);
%pybinopermaybecall(truediv);
%pybinopermaybecall(mod);
%pybinopermaybecall(lshift);
%pybinopermaybecall(rshift);

8
Lib/python/std_array.i
View file

@ -45,11 +45,11 @@
Difference jj = 0;
swig::slice_adjust(i, j, step, size, ii, jj);
if (step == 1 && ii == 0 && jj == size) {
if (step == 1 && ii == 0 && static_cast<typename Sequence::size_type>(jj) == size) {
Sequence *sequence = new Sequence();
std::copy(self->begin(), self->end(), sequence->begin());
return sequence;
} else if (step == -1 && ii == (size - 1) && jj == -1) {
} else if (step == -1 && static_cast<typename Sequence::size_type>(ii) == (size - 1) && jj == -1) {
Sequence *sequence = new Sequence();
std::copy(self->rbegin(), self->rend(), sequence->begin());
return sequence;
@ -67,9 +67,9 @@
Difference jj = 0;
swig::slice_adjust(i, j, step, size, ii, jj, true);
if (step == 1 && ii == 0 && jj == size) {
if (step == 1 && ii == 0 && static_cast<typename Sequence::size_type>(jj) == size) {
std::copy(is.begin(), is.end(), self->begin());
} else if (step == -1 && ii == (size - 1) && jj == -1) {
} else if (step == -1 && static_cast<typename Sequence::size_type>(ii) == (size - 1) && jj == -1) {
std::copy(is.rbegin(), is.rend(), self->begin());
} else {
throw std::invalid_argument("std::array object only supports setting a slice that is the size of the array");

14
Lib/python/std_pair.i
View file

@ -31,7 +31,7 @@
int res2 = swig::asval((PyObject*)second, psecond);
if (!SWIG_IsOK(res2)) return res2;
return res1 > res2 ? res1 : res2;
}
}
}
static int asval(PyObject *obj, std::pair<T,U> *val) {
@ -68,10 +68,16 @@
value_type *vp = %new_instance(std::pair<T,U>);
T *pfirst = &(vp->first);
int res1 = swig::asval((PyObject*)first, pfirst);
if (!SWIG_IsOK(res1)) return res1;
if (!SWIG_IsOK(res1)) {
%delete(vp);
return res1;
}
U *psecond = &(vp->second);
int res2 = swig::asval((PyObject*)second, psecond);
if (!SWIG_IsOK(res2)) return res2;
if (!SWIG_IsOK(res2)) {
%delete(vp);
return res2;
}
*val = vp;
return SWIG_AddNewMask(res1 > res2 ? res1 : res2);
} else {
@ -82,7 +88,7 @@
int res2 = swig::asval((PyObject*)second, psecond);
if (!SWIG_IsOK(res2)) return res2;
return res1 > res2 ? res1 : res2;
}
}
}
static int asptr(PyObject *obj, std::pair<T,U> **val) {

38
Lib/r/ropers.swg
View file

@ -1,43 +1,5 @@
#ifdef __cplusplus
// These are auto-supported by the Perl-module
%rename(__plusplus__) *::operator++;
%rename(__minmin__) *::operator--;
%rename(__add__) *::operator+;
%rename(__sub__) *::operator-;
%rename(__neg__) *::operator-();
%rename(__neg__) *::operator-() const;
%rename(__mul__) *::operator*;
%rename(__div__) *::operator/;
%rename(__eq__) *::operator==;
%rename(__ne__) *::operator!=;
%rename(__mod__) *::operator%;
%rename(__gt__) *::operator>;
%rename(__lt__) *::operator<;
%rename(__not__) *::operator!;
// These are renamed, but no 'use overload...' is added
%rename(__lshift__) *::operator<<;
%rename(__rshift__) *::operator>>;
%rename(__and__) *::operator&;
%rename(__or__) *::operator|;
%rename(__xor__) *::operator^;
%rename(__invert__) *::operator~;
%rename(__le__) *::operator<=;
%rename(__ge__) *::operator>=;
%rename(__call__) *::operator();
%rename(__getitem__) *::operator[];
%rename(__seteq__) *::operator=;
%rename(__land__) operator&&;
%rename(__lor__) operator||;
%rename(__plusplus__) *::operator++;
%rename(__minusminus__) *::operator--;
%rename(__arrowstar__) *::operator->*;
%rename(__index__) *::operator[];
%rename(Equal) operator =;
%rename(PlusEqual) operator +=;
%rename(MinusEqual) operator -=;

1
Lib/r/rrun.swg
View file

@ -20,6 +20,7 @@ extern "C" {
#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_R_ConvertPtr(obj, pptr, type, flags)
#define SWIG_NewPointerObj(ptr, type, flags) SWIG_R_NewPointerObj(ptr, type, flags)
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

2
Lib/ruby/rubycontainer.swg
View file

@ -38,7 +38,7 @@
namespace swig {
template < class T >
struct yield : public std::unary_function< T, bool >
struct yield
{
bool
operator()( const T& v ) const

8
Lib/ruby/rubystdfunctors.swg
View file

@ -90,7 +90,7 @@ namespace swig {
static ID call_id = rb_intern("call");
template <class _T = GC_VALUE, class _DefaultFunc = std::less<GC_VALUE> >
struct BinaryPredicate : GC_VALUE, std::binary_function< _T, _T, bool >
struct BinaryPredicate : GC_VALUE
{
BinaryPredicate(VALUE obj = Qnil) : GC_VALUE(obj) { }
bool operator()(_T a, _T b) const
@ -109,7 +109,7 @@ namespace swig {
};
template <class _T = GC_VALUE, class _DefaultFunc = std::less< _T > >
struct BinaryFunction : GC_VALUE, std::binary_function< _T, _T, _T >
struct BinaryFunction : GC_VALUE
{
BinaryFunction(VALUE obj = Qnil) : GC_VALUE(obj) { }
_T operator()(_T a, _T b) const
@ -128,7 +128,7 @@ namespace swig {
};
template< class _T = GC_VALUE >
struct UnaryPredicate : GC_VALUE, std::unary_function< _T, bool >
struct UnaryPredicate : GC_VALUE
{
UnaryPredicate(VALUE obj = Qnil) : GC_VALUE(obj) { }
bool operator()(_T a) const
@ -142,7 +142,7 @@ namespace swig {
};
template< class _T = GC_VALUE >
struct UnaryFunction : GC_VALUE, std::unary_function< _T, _T >
struct UnaryFunction : GC_VALUE
{
UnaryFunction(VALUE obj = Qnil) : GC_VALUE(obj) { }
_T operator()(_T a) const

14
Lib/ruby/std_pair.i
View file

@ -31,7 +31,7 @@
int res2 = swig::asval((VALUE)second, psecond);
if (!SWIG_IsOK(res2)) return res2;
return res1 > res2 ? res1 : res2;
}
}
}
static int asval(VALUE obj, std::pair<T,U> *val) {
@ -63,10 +63,16 @@
value_type *vp = %new_instance(std::pair<T,U>);
T *pfirst = &(vp->first);
int res1 = swig::asval((VALUE)first, pfirst);
if (!SWIG_IsOK(res1)) return res1;
if (!SWIG_IsOK(res1)) {
%delete(vp);
return res1;
}
U *psecond = &(vp->second);
int res2 = swig::asval((VALUE)second, psecond);
if (!SWIG_IsOK(res2)) return res2;
if (!SWIG_IsOK(res2)) {
%delete(vp);
return res2;
}
*val = vp;
return SWIG_AddNewMask(res1 > res2 ? res1 : res2);
} else {
@ -77,7 +83,7 @@
int res2 = swig::asval((VALUE)second, psecond);
if (!SWIG_IsOK(res2)) return res2;
return res1 > res2 ? res1 : res2;
}
}
}
static int asptr(VALUE obj, std::pair<T,U> **val) {

47
Lib/scilab/scirun.swg
View file

@ -251,8 +251,7 @@ SwigScilabPtrToObject(void *pvApiCtx, int iVar, void **pvObj, swig_type_info *de
void *pvTypeinfo = NULL;
sciErr = getListItemNumber(pvApiCtx, piAddrVar, &iItemCount);
if (sciErr.iErr)
{
if (sciErr.iErr) {
printError(&sciErr, 0);
return SWIG_ERROR;
}
@ -335,7 +334,6 @@ SwigScilabPtrFromObject(void *pvApiCtx, int iVarOut, void *pvObj, swig_type_info
return SWIG_ERROR;
}
sciErr = createPointerInList(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + iVarOut, piMListAddr, 3, pvObj);
if (sciErr.iErr) {
printError(&sciErr, 0);
@ -448,27 +446,36 @@ int SWIG_this(SWIG_GatewayParameters) {
extern "C"
#endif
int SWIG_ptr(SWIG_GatewayParameters) {
void *ptrValue = NULL;
double dValue = 0;
int *piAddr;
SciErr sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
if(sciErr.iErr) {
printError(&sciErr, 0);
return SWIG_ERROR;
}
if (getScalarDouble(pvApiCtx, piAddr, &dValue) == 0) {
if (dValue != (uintptr_t)dValue) {
Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Incorrect value for input argument #%d: The double value cannot be converted to a pointer.\n"), fname, 1);
return SWIG_ValueError;
}
if ((dValue < 0) || (dValue > ULONG_MAX)) {
Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Overflow error for input argument #%d: The double value cannot be converted to a pointer.\n"), fname, 1);
return SWIG_OverflowError;
}
if (SwigScilabPtrToObject(pvApiCtx, 1, &ptrValue, NULL, 0, fname) == SWIG_OK) {
SWIG_Scilab_SetOutputPosition(1);
return SWIG_Scilab_SetOutput(pvApiCtx,
SwigScilabPtrFromObject(pvApiCtx, 1, (void *) (uintptr_t)dValue, NULL, 0, NULL));
SwigScilabPtrFromObject(pvApiCtx, 1, ptrValue, NULL, 0, NULL));
}
else {
return SWIG_ERROR;
int *piAddr;
SciErr sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
if(sciErr.iErr) {
printError(&sciErr, 0);
return SWIG_ERROR;
}
if (getScalarDouble(pvApiCtx, piAddr, &dValue) == 0) {
if (dValue != (uintptr_t)dValue) {
Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Incorrect value for input argument #%d: The double value cannot be converted to a pointer.\n"), fname, 1);
return SWIG_ValueError;
}
if ((dValue < 0) || (dValue > ULONG_MAX)) {
Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Overflow error for input argument #%d: The double value cannot be converted to a pointer.\n"), fname, 1);
return SWIG_OverflowError;
}
SWIG_Scilab_SetOutputPosition(1);
return SWIG_Scilab_SetOutput(pvApiCtx,
SwigScilabPtrFromObject(pvApiCtx, 1, (void *) (uintptr_t)dValue, NULL, 0, NULL));
}
else {
Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong type for input argument #%d: A pointer or a double expected.\n"), "SWIG_ptr", 1);
return SWIG_TypeError;
}
}
}

29
Lib/scilab/scitypemaps.swg
View file

@ -122,28 +122,37 @@
}
%enddef
/* Scilab equivalent for C integers can be sci_ints or sci_matrix */
%define %scilab_typecheck_integer(PRECEDENCE, INTTYPE, TYPE)
%typecheck(PRECEDENCE) TYPE {
%fragment("SWIG_Check_SciDoubleOrInt", "header") {
SWIGINTERN int
SWIG_Check_SciDoubleOrInt(void *pvApiCtx, SwigSciObject iVar, int iIntegerType) {
int *piAddrVar = NULL;
SciErr sciErr = getVarAddressFromPosition(pvApiCtx, $input, &piAddrVar);
int ret = 0;
SciErr sciErr = getVarAddressFromPosition(pvApiCtx, iVar, &piAddrVar);
if (sciErr.iErr) {
printError(&sciErr, 0);
return SWIG_ERROR;
return 0;
}
$1 = isIntegerType(pvApiCtx, piAddrVar);
if ($1 == 1) {
ret = isIntegerType(pvApiCtx, piAddrVar);
if (ret == 1) {
int iPrec = 0;
sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddrVar, &iPrec);
if (sciErr.iErr) {
printError(&sciErr, 0);
return SWIG_ERROR;
return 0;
}
$1 = (iPrec == INTTYPE) ? 1 : 0;
ret = (iPrec == iIntegerType) ? 1 : 0;
}
else {
$1 = isDoubleType(pvApiCtx, piAddrVar);
ret = isDoubleType(pvApiCtx, piAddrVar);
}
return ret;
}
}
/* Scilab equivalent for C integers can be sci_intXX or sci_matrix */
%define %scilab_typecheck_integer(PRECEDENCE, INTTYPE, TYPE)
%typecheck(PRECEDENCE, fragment="SWIG_Check_SciDoubleOrInt") TYPE {
$1 = SWIG_Check_SciDoubleOrInt(pvApiCtx, $input, INTTYPE);
}
%enddef

6
Lib/std/_std_deque.i
View file

@ -24,7 +24,7 @@
};
*/
%define %std_deque_methods_noempty(T)
%define %std_deque_methods_noempty(T...)
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef T value_type;
@ -116,7 +116,7 @@
%enddef
#ifdef SWIGPHP
%define %std_deque_methods(T)
%define %std_deque_methods(T...)
%extend {
bool is_empty() const {
return self->empty();
@ -125,7 +125,7 @@
%std_deque_methods_noempty(T)
%enddef
#else
%define %std_deque_methods(T)
%define %std_deque_methods(T...)
bool empty() const;
%std_deque_methods_noempty(T)
%enddef

2
Lib/std/std_deque.i
View file

@ -120,7 +120,7 @@ namespace std {
%swig_deque_methods_val(std::deque< _Tp*, _Alloc >);
#endif
%std_deque_methods_val(std::deque< _Tp*, _Alloc >);
%std_deque_methods_val(deque);
};
}

4
Lib/std/std_list.i
View file

@ -6,7 +6,7 @@
// List
%define %std_list_methods(list)
%define %std_list_methods(list...)
%std_sequence_methods(list)
void pop_front();
@ -17,7 +17,7 @@
%enddef
%define %std_list_methods_val(list)
%define %std_list_methods_val(list...)
%std_sequence_methods_val(list)
void pop_front();

2
Lib/std/std_queue.i
View file

@ -122,7 +122,7 @@ namespace std {
%swig_queue_methods_val(std::queue< _Tp*, _Sequence >);
#endif
%std_queue_methods_val(std::queue< _Tp*, _Sequence >);
%std_queue_methods_val(queue);
};
}

2
Lib/std/std_stack.i
View file

@ -121,7 +121,7 @@ namespace std {
%swig_stack_methods_val(std::stack< _Tp*, _Sequence >);
#endif
%std_stack_methods_val(std::stack< _Tp*, _Sequence >);
%std_stack_methods_val(stack);
};
}

11
Lib/tcl/tclrun.swg
View file

@ -225,15 +225,14 @@ SWIG_Tcl_ConvertPacked(Tcl_Interp *SWIGUNUSEDPARM(interp) , Tcl_Obj *obj, void *
/* Take a pointer and convert it to a string */
SWIGRUNTIME void
SWIG_Tcl_MakePtr(char *c, void *ptr, swig_type_info *ty, int flags) {
SWIG_Tcl_MakePtr(char *c, void *ptr, swig_type_info *ty, int SWIGUNUSEDPARM(flags)) {
if (ptr) {
*(c++) = '_';
c = SWIG_PackData(c,&ptr,sizeof(void *));
strcpy(c,ty->name);
} else {
strcpy(c,(char *)"NULL");
strcpy(c,"NULL");
}
flags = 0;
}
/* Create a new pointer object */
@ -287,14 +286,15 @@ SWIG_Tcl_SetModule(Tcl_Interp *interp, swig_module_info *module) {
}
/* -----------------------------------------------------------------------------*
* Object auxiliars
* Object auxiliaries
* -----------------------------------------------------------------------------*/
SWIGRUNTIME void
SWIG_Tcl_ObjectDelete(ClientData clientData) {
swig_instance *si = (swig_instance *) clientData;
if ((si) && (si->destroy) && (SWIG_Disown(si->thisvalue))) {
if (!si) return;
if (si->destroy && SWIG_Disown(si->thisvalue)) {
if (si->classptr->destructor) {
(si->classptr->destructor)(si->thisvalue);
}
@ -344,7 +344,6 @@ SWIG_Tcl_MethodCommand(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_
}
cls_stack[cls_stack_top] = inst->classptr;
cls_stack_bi[cls_stack_top] = -1;
cls = inst->classptr;
while (1) {
Tcl_HashEntry* hashentry;
bi = cls_stack_bi[cls_stack_top];

16
Lib/typemaps/fragments.swg
View file

@ -168,11 +168,23 @@
%fragment("SWIG_isfinite","header",fragment="<math.h>,<float.h>") %{
/* Getting isfinite working pre C99 across multiple platforms is non-trivial. Users can provide SWIG_isfinite on older platforms. */
#ifndef SWIG_isfinite
/* isfinite() is a macro for C99, but a function in namespace std for C++11. */
/* isfinite() is a macro for C99 */
# if defined(isfinite)
# define SWIG_isfinite(X) (isfinite(X))
# elif defined __cplusplus && __cplusplus >= 201103L
# define SWIG_isfinite(X) (std::isfinite(X))
/* Use a template so that this works whether isfinite() is std::isfinite() or
* in the global namespace. The reality seems to vary between compiler
* versions.
*
* Make sure namespace std exists to avoid compiler warnings.
*/
namespace std { }
template<typename T>
inline int SWIG_isfinite_func(T x) {
using namespace std;
return isfinite(x);
}
# define SWIG_isfinite(X) (SWIG_isfinite_func(X))
# elif defined(_MSC_VER)
# define SWIG_isfinite(X) (_finite(X))
# elif defined(__sun) && defined(__SVR4)

2
Lib/typemaps/string.swg
View file

@ -18,7 +18,7 @@ SWIG_pchar_descriptor(void)
}
%fragment("SWIG_strnlen","header",fragment="SWIG_FromCharPtrAndSize") {
size_t
SWIGINTERN size_t
SWIG_strnlen(const char* s, size_t maxlen)
{
const char *p;

14
Lib/typemaps/swigmacros.swg
View file

@ -43,7 +43,7 @@
%new_instance(Type) Allocate a new instance of given Type
%new_copy(value,Type) Allocate and initialize a new instance with 'value'
%new_array(size,Type) Allocate a new array with given size and Type
%new_array(size,Type) Allocate a new array with given size and Type and zero initialize
%new_copy_array(cptr,size,Type) Allocate and initialize a new array from 'cptr'
%delete(cptr) Delete an instance
%delete_array(cptr) Delete an array
@ -157,17 +157,17 @@ nocppval
* ----------------------------------------------------------------------------- */
#if defined(__cplusplus)
# define %new_instance(Type...) (new Type)
# define %new_instance(Type...) (new Type())
# define %new_copy(val,Type...) (new Type(%static_cast(val, const Type&)))
# define %new_array(size,Type...) (new Type[size])
# define %new_copy_array(ptr,size,Type...) %reinterpret_cast(memcpy(%new_array(size,Type), ptr, sizeof(Type)*(size)), Type*)
# define %new_array(size,Type...) (new Type[size]())
# define %new_copy_array(ptr,size,Type...) %reinterpret_cast(memcpy(new Type[size], ptr, sizeof(Type)*(size)), Type*)
# define %delete(cptr) delete cptr
# define %delete_array(cptr) delete[] cptr
#else /* C case */
# define %new_instance(Type...) (Type *)malloc(sizeof(Type))
# define %new_instance(Type...) (Type *)calloc(1,sizeof(Type))
# define %new_copy(val,Type...) (Type *)memcpy(%new_instance(Type),&val,sizeof(Type))
# define %new_array(size,Type...) (Type *)malloc((size)*sizeof(Type))
# define %new_copy_array(ptr,size,Type...) (Type *)memcpy(%new_array(size,Type), ptr, sizeof(Type)*(size))
# define %new_array(size,Type...) (Type *)calloc(size, sizeof(Type))
# define %new_copy_array(ptr,size,Type...) (Type *)memcpy(malloc((size)*sizeof(Type)), ptr, sizeof(Type)*(size))
# define %delete(cptr) free((char*)cptr)
# define %delete_array(cptr) free((char*)cptr)
#endif /* __cplusplus */

2
Lib/typemaps/wstring.swg
View file

@ -19,7 +19,7 @@ SWIG_pwchar_descriptor()
}
%fragment("SWIG_wcsnlen","header",fragment="SWIG_FromWCharPtrAndSize") {
size_t
SWIGINTERN size_t
SWIG_wcsnlen(const wchar_t* s, size_t maxlen)
{
const wchar_t *p;