summaryrefslogtreecommitdiff
path: root/devtools/swigwin-1.3.34/Lib/php4
diff options
context:
space:
mode:
Diffstat (limited to 'devtools/swigwin-1.3.34/Lib/php4')
-rw-r--r--devtools/swigwin-1.3.34/Lib/php4/const.i53
-rw-r--r--devtools/swigwin-1.3.34/Lib/php4/globalvar.i332
-rw-r--r--devtools/swigwin-1.3.34/Lib/php4/php4.swg298
-rw-r--r--devtools/swigwin-1.3.34/Lib/php4/php4init.swg12
-rw-r--r--devtools/swigwin-1.3.34/Lib/php4/php4kw.swg461
-rw-r--r--devtools/swigwin-1.3.34/Lib/php4/php4run.swg222
-rw-r--r--devtools/swigwin-1.3.34/Lib/php4/phppointers.i42
-rw-r--r--devtools/swigwin-1.3.34/Lib/php4/std_common.i13
-rw-r--r--devtools/swigwin-1.3.34/Lib/php4/std_deque.i1
-rw-r--r--devtools/swigwin-1.3.34/Lib/php4/std_map.i175
-rw-r--r--devtools/swigwin-1.3.34/Lib/php4/std_pair.i37
-rw-r--r--devtools/swigwin-1.3.34/Lib/php4/std_string.i73
-rw-r--r--devtools/swigwin-1.3.34/Lib/php4/std_vector.i132
-rw-r--r--devtools/swigwin-1.3.34/Lib/php4/stl.i15
-rw-r--r--devtools/swigwin-1.3.34/Lib/php4/typemaps.i171
-rw-r--r--devtools/swigwin-1.3.34/Lib/php4/utils.i59
16 files changed, 2096 insertions, 0 deletions
diff --git a/devtools/swigwin-1.3.34/Lib/php4/const.i b/devtools/swigwin-1.3.34/Lib/php4/const.i
new file mode 100644
index 0000000..6ddd403
--- /dev/null
+++ b/devtools/swigwin-1.3.34/Lib/php4/const.i
@@ -0,0 +1,53 @@
+/* -----------------------------------------------------------------------------
+ * See the LICENSE file for information on copyright, usage and redistribution
+ * of SWIG, and the README file for authors - http://www.swig.org/release.html.
+ *
+ * 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, $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 [] {
+ /* This actually registers it as a global variable and constant. I don't
+ * like it, but I can't figure out the zend_constant code... */
+ zval *z_var;
+ MAKE_STD_ZVAL(z_var);
+ SWIG_SetPointerZval(z_var, (void*)$value, $1_descriptor, 0);
+ /* zend_hash_add(&EG(symbol_table), "$1", sizeof("$1"), (void *)&z_var,sizeof(zval *), NULL); */
+ zend_constant c;
+ c.value = *z_var;
+ zval_copy_ctor(&c.value);
+ size_t len = sizeof("$1") - 1;
+ c.name = zend_strndup("$1", len);
+ c.name_len = len+1;
+ c.flags = CONST_CS | CONST_PERSISTENT;
+ c.module_number = module_number;
+ zend_register_constant( &c TSRMLS_CC );
+}
diff --git a/devtools/swigwin-1.3.34/Lib/php4/globalvar.i b/devtools/swigwin-1.3.34/Lib/php4/globalvar.i
new file mode 100644
index 0000000..3162de2
--- /dev/null
+++ b/devtools/swigwin-1.3.34/Lib/php4/globalvar.i
@@ -0,0 +1,332 @@
+/* -----------------------------------------------------------------------------
+ * See the LICENSE file for information on copyright, usage and redistribution
+ * of SWIG, and the README file for authors - http://www.swig.org/release.html.
+ *
+ * globalvar.i
+ *
+ * Global variables - add the variable to PHP
+ * ----------------------------------------------------------------------------- */
+
+%typemap(varinit) char *,
+ char []
+{
+ zval *z_var;
+ MAKE_STD_ZVAL(z_var);
+ z_var->type = IS_STRING;
+ if($1) {
+ z_var->value.str.val = estrdup($1);
+ z_var->value.str.len = strlen($1);
+ } else {
+ z_var->value.str.val = 0;
+ z_var->value.str.len = 0;
+ }
+ zend_hash_add(&EG(symbol_table), (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 = $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 &
+{
+ $&1_ltype argp;
+ zval *z_var;
+
+ MAKE_STD_ZVAL(z_var);
+ SWIG_SetPointerZval(z_var, (void*)&$1, $&1_descriptor, 0);
+ zend_hash_add(&EG(symbol_table), (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;
+ if ($1) {
+ // varinit char [ANY]
+ 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(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) || zend_binary_strcmp(s1, strlen(s1), $1, strlen($1))) {
+ if (s1)
+ $1 = estrdup(s1);
+ else
+ $1 = NULL;
+ }
+}
+
+
+%typemap(varin) SWIGTYPE []
+{
+ zval **z_var;
+
+ zend_hash_find(&EG(symbol_table), (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) || zend_binary_strcmp(s1, strlen(s1), $1, strlen($1))) {
+ if(s1)
+ strncpy($1, s1, $1_dim0);
+ }
+}
+
+%typemap(varin) SWIGTYPE
+{
+ zval **z_var;
+ $&1_ltype _temp;
+
+ zend_hash_find(&EG(symbol_table), (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 &
+{
+ 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(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) || zend_binary_strcmp(s1, strlen(s1), $1, strlen($1) )) {
+ if(s1)
+ efree(s1);
+ if($1) {
+ (*z_var)->value.str.val = estrdup($1);
+ (*z_var)->value.str.len = strlen($1) +1;
+ } else {
+ (*z_var)->value.str.val = 0;
+ (*z_var)->value.str.len = 0;
+ }
+ }
+}
+
+%typemap(varout) SWIGTYPE
+{
+ zval **z_var;
+
+ zend_hash_find(&EG(symbol_table), (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) || zend_binary_strcmp(s1, strlen(s1), $1, strlen($1))) {
+ if($1) {
+ (*z_var)->value.str.val = estrdup($1);
+ (*z_var)->value.str.len = strlen($1)+1;
+ } else {
+ (*z_var)->value.str.val = 0;
+ (*z_var)->value.str.len = 0;
+ }
+ }
+}
+
+%typemap(varout) SWIGTYPE *, SWIGTYPE &
+{
+ zval **z_var;
+
+ zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
+ SWIG_SetPointerZval(*z_var, (void*)$1, $1_descriptor, 0);
+}
+
+
diff --git a/devtools/swigwin-1.3.34/Lib/php4/php4.swg b/devtools/swigwin-1.3.34/Lib/php4/php4.swg
new file mode 100644
index 0000000..c8dded2
--- /dev/null
+++ b/devtools/swigwin-1.3.34/Lib/php4/php4.swg
@@ -0,0 +1,298 @@
+/* -----------------------------------------------------------------------------
+ * See the LICENSE file for information on copyright, usage and redistribution
+ * of SWIG, and the README file for authors - http://www.swig.org/release.html.
+ *
+ * php4.swg
+ *
+ * PHP4 configuration file
+ * ----------------------------------------------------------------------------- */
+
+%runtime "swigrun.swg" // Common C API type-checking code
+%runtime "php4run.swg" // Php4 runtime functions
+
+%include <php4init.swg> // Php4 initialization routine.
+
+%include <globalvar.i> // Global variables.
+%include <const.i>
+
+// use %init %{ "/*code goes here*/ " %}
+// or %minit %{ "/* code goes here*/ " %} to
+// insert code in the PHP_MINIT_FUNCTION
+#define %minit %insert("init")
+
+// use %rinit %{ "/* code goes here*/ " %} to
+// insert code in the PHP_RINIT_FUNCTION
+#define %rinit %insert("rinit")
+
+// use %shutdown %{ " /*code goes here*/ " %} to
+// insert code in the PHP_MSHUTDOWN_FUNCTION
+#define %shutdown %insert("shutdown")
+#define %mshutdown %insert("shutdown")
+
+// use %rshutdown %{ " /*code goes here*/" %} to
+// insert code in the PHP_RSHUTDOWN_FUNCTION
+#define %rshutdown %insert("rshutdown")
+
+/* Typemaps for input parameters by value */
+
+%include <utils.i>
+
+%pass_by_val(bool,CONVERT_BOOL_IN);
+
+%pass_by_val(size_t, CONVERT_INT_IN);
+
+%pass_by_val(enum SWIGTYPE, CONVERT_INT_IN);
+
+%pass_by_val(signed int, CONVERT_INT_IN);
+%pass_by_val(int,CONVERT_INT_IN);
+%pass_by_val(unsigned int,CONVERT_INT_IN);
+
+%pass_by_val(signed short, CONVERT_INT_IN);
+%pass_by_val(short,CONVERT_INT_IN);
+%pass_by_val(unsigned short, CONVERT_INT_IN);
+
+%pass_by_val(signed long, CONVERT_INT_IN);
+%pass_by_val(long, CONVERT_INT_IN);
+%pass_by_val(unsigned long, CONVERT_INT_IN);
+
+%pass_by_val(signed char, CONVERT_INT_IN);
+%pass_by_val(char, CONVERT_CHAR_IN);
+%pass_by_val(unsigned char, CONVERT_INT_IN);
+
+%pass_by_val(float, CONVERT_FLOAT_IN);
+
+%pass_by_val(double, CONVERT_FLOAT_IN);
+
+%pass_by_val(char *, CONVERT_STRING_IN);
+
+// char array can be in/out, though the passed string may not be big enough...
+// so we have to size it
+%typemap(in) char[ANY]
+{
+ convert_to_string_ex($input);
+ $1 = ($1_ltype) Z_STRVAL_PP($input);
+}
+
+/* Object passed by value. Convert to a pointer */
+%typemap(in) SWIGTYPE ($&1_ltype tmp)
+{
+ if(SWIG_ConvertPtr(*$input, (void **) &tmp, $&1_descriptor, 0) < 0 || tmp == NULL) {
+ SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $&1_descriptor");
+ }
+ $1 = *tmp;
+}
+
+%typemap(in) SWIGTYPE *,
+ SWIGTYPE []
+{
+ if(SWIG_ConvertPtr(*$input, (void **) &$1, $1_descriptor, 0) < 0) {
+ SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $1_descriptor");
+ }
+}
+
+%typemap(in) SWIGTYPE &
+{
+ if(SWIG_ConvertPtr(*$input, (void **) &$1, $1_descriptor, 0) < 0 || $1 == NULL) {
+ SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $1_descriptor");
+ }
+}
+
+%typemap(in) SWIGTYPE *DISOWN
+{
+ if(SWIG_ConvertPtr(*$input, (void **) &$1, $1_descriptor, SWIG_POINTER_DISOWN ) < 0) {
+ SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $&1_descriptor");
+ }
+}
+%typemap(argout) SWIGTYPE *,
+ SWIGTYPE [],
+ SWIGTYPE&;
+
+%typemap(in) void *
+{
+ if(SWIG_ConvertPtr(*$input, (void **) &$1, 0, 0) < 0) {
+ /* Allow NULL from php for void* */
+ if ((*$input)->type==IS_NULL) $1=0;
+ else
+ SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $&1_descriptor");
+ }
+}
+
+/* Special case when void* is passed by reference so it can be made to point
+ to opaque api structs */
+%typemap(in) void ** ($*1_ltype ptr, int force),
+ void *& ($*1_ltype ptr, int force)
+{
+ /* If they pass NULL by reference, make it into a void*
+ This bit should go in arginit if arginit support init-ing scripting args */
+ if(SWIG_ConvertPtr(*$input, (void **) &$1, $1_descriptor, 0) < 0) {
+ /* So... we didn't get a ref or ptr, but we'll accept NULL by reference */
+ if (!((*$input)->type==IS_NULL && PZVAL_IS_REF(*$input))) {
+ /* wasn't a pre/ref/thing, OR anything like an int thing */
+ SWIG_PHP_Error(E_ERROR, "Type error in argument $arg of $symname.");
+ }
+ }
+ force=0;
+ if (arg1==NULL) {
+#ifdef __cplusplus
+ ptr=new $*1_ltype;
+#else
+ ptr=($*1_ltype) calloc(1,sizeof($*1_ltype));
+#endif
+ $1=&ptr;
+ /* have to passback arg$arg too */
+ force=1;
+ }
+}
+%typemap(argout) void **,
+ void *&
+{
+ if (force$argnum) {
+ SWIG_SetPointerZval( *$input, (void*) ptr$argnum, $*1_descriptor, 1);
+ }
+}
+
+/* Typemap for output values */
+
+%typemap(out) int,
+ unsigned int,
+ short,
+ unsigned short,
+ long,
+ unsigned long,
+ signed char,
+ unsigned char,
+ bool,
+ size_t,
+ enum SWIGTYPE
+{
+ ZVAL_LONG(return_value,$1);
+}
+
+%typemap(out) bool
+{
+ ZVAL_BOOL(return_value,($1)?1:0);
+}
+
+%typemap(out) float,
+ double
+{
+ ZVAL_DOUBLE(return_value,$1);
+}
+
+%typemap(out) char
+{
+ ZVAL_STRINGL(return_value,&$1, 1, 1);
+}
+
+%typemap(out) char *,
+ char []
+{
+ if(!$1) {
+ ZVAL_NULL(return_value);
+ } else {
+ ZVAL_STRING(return_value,$1, 1);
+ }
+}
+
+%typemap(out) SWIGTYPE *,
+ SWIGTYPE [],
+ SWIGTYPE &
+{
+ SWIG_SetPointerZval(return_value, (void *)$1, $1_descriptor, $owner);
+}
+
+%typemap(out) SWIGTYPE *DYNAMIC,
+ SWIGTYPE &DYNAMIC
+{
+ swig_type_info *ty = SWIG_TypeDynamicCast($1_descriptor, (void **) &$1);
+ SWIG_SetPointerZval(return_value, (void *)$1, ty, $owner);
+}
+
+%typemap(out) SWIGTYPE
+#ifdef __cplusplus
+{
+ $&1_ltype resultobj = new $1_ltype(($1_ltype &) $1);
+ SWIG_SetPointerZval(return_value, (void *)resultobj, $&1_descriptor, 1);
+}
+#else
+{
+ $&1_ltype resultobj = ($&1_ltype) emalloc(sizeof($1_type));
+ memmove(resultobj, &$1, sizeof($1_type));
+ SWIG_SetPointerZval(return_value, (void *)resultobj, $&1_descriptor, 1);
+}
+#endif
+
+%typemap(out) void "";
+
+%typemap(out) char [ANY]
+{
+ RETVAL_STRINGL($1,$1_dim0,1);
+}
+
+// This typecheck does hard checking for proper argument type. If you want
+// an argument to be converted from a different PHP type, you must convert
+// it yourself before passing it (e.g. (string)4.7 or (int)"6").
+%define %php_typecheck(_type,_prec,is)
+%typemap(typecheck,precedence=_prec) _type
+ " $1 = (Z_TYPE_PP($input) == is); "
+%enddef
+
+%php_typecheck(int,SWIG_TYPECHECK_INTEGER,IS_LONG)
+%php_typecheck(unsigned int,SWIG_TYPECHECK_UINT32,IS_LONG)
+%php_typecheck(short,SWIG_TYPECHECK_INT16,IS_LONG)
+%php_typecheck(unsigned short,SWIG_TYPECHECK_UINT16,IS_LONG)
+%php_typecheck(long,SWIG_TYPECHECK_INT64,IS_LONG)
+%php_typecheck(unsigned long,SWIG_TYPECHECK_UINT64,IS_LONG)
+%php_typecheck(signed char,SWIG_TYPECHECK_INT8,IS_LONG)
+%php_typecheck(unsigned char,SWIG_TYPECHECK_UINT8,IS_LONG)
+%php_typecheck(size_t,SWIG_TYPECHECK_INT16,IS_LONG)
+%php_typecheck(enum SWIGTYPE,SWIG_TYPECHECK_INT8,IS_LONG)
+%php_typecheck(bool,SWIG_TYPECHECK_BOOL,IS_BOOL)
+
+%php_typecheck(char,SWIG_TYPECHECK_CHAR,IS_STRING)
+%php_typecheck(char *,SWIG_TYPECHECK_STRING,IS_STRING)
+%php_typecheck(char [],SWIG_TYPECHECK_STRING,IS_STRING)
+
+%php_typecheck(float,SWIG_TYPECHECK_FLOAT,IS_DOUBLE)
+%php_typecheck(double,SWIG_TYPECHECK_BOOL,IS_DOUBLE)
+
+%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE
+ " /* typecheck SWIGTYPE */ "
+
+%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *,
+ SWIGTYPE [],
+ SWIGTYPE &
+{
+ void *tmp;
+ _v = (SWIG_ConvertPtr( *$input, (void**)&tmp, $1_descriptor, 0) >= 0);
+}
+
+%typecheck(SWIG_TYPECHECK_VOIDPTR) void *
+ " /* typecheck void * */ "
+
+
+/* Exception handling */
+
+%typemap(throws) int,
+ long,
+ short,
+ unsigned int,
+ unsigned long,
+ unsigned short {
+ char error_msg[256];
+ sprintf(error_msg, "C++ $1_type exception thrown, value: %d", $1);
+ SWIG_PHP_Error(E_ERROR, error_msg);
+}
+
+%typemap(throws) SWIGTYPE, SWIGTYPE &, SWIGTYPE *, SWIGTYPE [], SWIGTYPE [ANY] %{
+ (void)$1;
+ SWIG_PHP_Error(E_ERROR, "C++ $1_type exception thrown");
+%}
+
+%typemap(throws) char * %{
+ SWIG_PHP_Error(E_ERROR, (char *)$1);
+%}
+
+
+/* php keywords */
+%include <php4kw.swg>
diff --git a/devtools/swigwin-1.3.34/Lib/php4/php4init.swg b/devtools/swigwin-1.3.34/Lib/php4/php4init.swg
new file mode 100644
index 0000000..b7a0fc9
--- /dev/null
+++ b/devtools/swigwin-1.3.34/Lib/php4/php4init.swg
@@ -0,0 +1,12 @@
+
+/* ------------------------------------------------------------
+ * The start of the PHP initialization function
+ * ------------------------------------------------------------ */
+
+%insert(init) "swiginit.swg"
+
+%init %{
+ SWIG_php_minit {
+ SWIG_InitializeModule(0);
+%}
+
diff --git a/devtools/swigwin-1.3.34/Lib/php4/php4kw.swg b/devtools/swigwin-1.3.34/Lib/php4/php4kw.swg
new file mode 100644
index 0000000..0d28994
--- /dev/null
+++ b/devtools/swigwin-1.3.34/Lib/php4/php4kw.swg
@@ -0,0 +1,461 @@
+/* -----------------------------------------------------------------------------
+ * See the LICENSE file for information on copyright, usage and redistribution
+ * of SWIG, and the README file for authors - http://www.swig.org/release.html.
+ *
+ * php4kw.swg
+ *
+ * The 'keywords' in PHP are global, ie, the following names are fine
+ * when used as class methods.
+ * ----------------------------------------------------------------------------- */
+
+#define PHPKW(x) %keywordwarn(`x` " is a php keyword, renamed as c_"`x`,sourcefmt="%(lower)s", rename="c_%s",fullname=1) `x`
+
+%define PHPCN(x)
+%keywordwarn(`x` " is a php reserved class name, class renamed as c_"`x`,%$isclass,rename="c_%s") `x`;
+%keywordwarn(`x` " is a php reserved class name, constructor renamed as c_"`x`,%$isconstructor,rename="c_%s") `x`;
+%enddef
+
+#define PHPBN1(x) %builtinwarn(`x` " conflicts with a built-in name in php",sourcefmt="%(lower)s",fullname=1) `x`
+#define PHPBN2(x) %builtinwarn(`x` " conflicts with a built-in name in php") "::" `x`
+
+
+/*
+ From
+
+ http://aspn.activestate.com/ASPN/docs/PHP/reserved.html
+
+ and reviewed by Olly Betts.
+
+ Further updates from the PHP manual on php.net.
+*/
+
+/* We classify these as kw since PHP will not run if used globally. */
+/* case insensitive */
+PHPKW(and);
+PHPKW(array);
+PHPKW(as);
+PHPKW(break);
+PHPKW(case);
+PHPKW(cfunction); /* No longer reserved in PHP5 */
+PHPKW(class);
+PHPKW(const);
+PHPKW(continue);
+PHPKW(declare);
+PHPKW(default);
+PHPKW(die);
+PHPKW(do);
+PHPKW(echo);
+PHPKW(else);
+PHPKW(elseif);
+PHPKW(empty);
+PHPKW(enddeclare);
+PHPKW(endfor);
+PHPKW(endforeach);
+PHPKW(endif);
+PHPKW(endswitch);
+PHPKW(endwhile);
+PHPKW(eval);
+PHPKW(exit);
+PHPKW(extends);
+PHPKW(for);
+PHPKW(foreach);
+PHPKW(function);
+PHPKW(global);
+PHPKW(if);
+PHPKW(include);
+PHPKW(include_once);
+PHPKW(isset);
+PHPKW(list);
+PHPKW(new);
+PHPKW(old_function); /* No longer reserved in PHP5 */
+PHPKW(or);
+PHPKW(print);
+PHPKW(require);
+PHPKW(require_once);
+PHPKW(return);
+PHPKW(static);
+PHPKW(switch);
+PHPKW(unset);
+PHPKW(use);
+PHPKW(var);
+PHPKW(while);
+PHPKW(xor);
+PHPKW(__FILE__);
+PHPKW(__LINE__);
+PHPKW(__FUNCTION__);
+PHPKW(__CLASS__);
+
+/* Added in PHP5 */
+PHPKW(__halt_compiler);
+PHPKW(abstract);
+PHPKW(catch);
+PHPKW(clone);
+PHPKW(final);
+PHPKW(implements);
+PHPKW(instanceof);
+PHPKW(interface);
+PHPKW(private);
+PHPKW(protected);
+PHPKW(public);
+PHPKW(throw);
+PHPKW(try);
+PHPKW(__METHOD__);
+
+/* We classify these as built-in names since they conflict, but PHP still runs */
+
+/* Type 1: case insensitive */
+PHPBN1(__sleep);
+PHPBN1(__wakeup);
+PHPBN1(not);
+PHPBN1(parent);
+PHPBN1(virtual);
+PHPBN1(NULL);
+PHPBN1(TRUE);
+PHPBN1(FALSE);
+
+/* Type 2: case sensitive */
+/* "Core Predefined Constants" from http://uk2.php.net/manual/en/reserved.constants.php */
+PHPBN2(E_ALL);
+PHPBN2(E_ERROR);
+PHPBN2(E_PARSE);
+PHPBN2(E_WARNING);
+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(PHP_OS);
+PHPBN2(PHP_VERSION);
+PHPBN2(PHP_SAPI);
+PHPBN2(PHP_EOL);
+PHPBN2(PHP_INT_MAX);
+PHPBN2(PHP_INT_SIZE);
+PHPBN2(DEFAULT_INCLUDE_PATH);
+PHPBN2(PEAR_INSTALL_DIR);
+PHPBN2(PEAR_EXTENSION_DIR);
+PHPBN2(PHP_EXTENSION_DIR);
+PHPBN2(PHP_PREFIX);
+PHPBN2(PHP_BINDIR);
+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(PHP_OUTPUT_HANDLER_START);
+PHPBN2(PHP_OUTPUT_HANDLER_CONT);
+PHPBN2(PHP_OUTPUT_HANDLER_END);
+/* "Standard Predefined Constants" from http://uk2.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(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(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(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 PHP5 */
+PHPBN2(E_STRICT);
+PHPBN2(__COMPILER_HALT_OFFSET__);
+
+/* Class names reserved by PHP */
+PHPCN(stdClass);
+PHPCN(__PHP_Incomplete_Class);
+PHPCN(Directory);
+
+/* Added in PHP5 (this list apparently depends which extensions you load by default). */
+PHPCN(parent);
+PHPCN(self);
+PHPCN(Exception);
+PHPCN(php_user_filter);
+PHPCN(ErrorException);
+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);
+
+#undef PHPKW
+#undef PHPBN1
+#undef PHPBN2
+#undef PHPCN
diff --git a/devtools/swigwin-1.3.34/Lib/php4/php4run.swg b/devtools/swigwin-1.3.34/Lib/php4/php4run.swg
new file mode 100644
index 0000000..d384527
--- /dev/null
+++ b/devtools/swigwin-1.3.34/Lib/php4/php4run.swg
@@ -0,0 +1,222 @@
+/* -----------------------------------------------------------------------------
+ * See the LICENSE file for information on copyright, usage and redistribution
+ * of SWIG, and the README file for authors - http://www.swig.org/release.html.
+ *
+ * php4run.swg
+ *
+ * PHP4 runtime library
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include "zend.h"
+#include "zend_API.h"
+#include "php.h"
+
+#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
+
+#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), 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_Php4_GetModule()
+#define SWIG_SetModule(clientdata, pointer) SWIG_Php4_SetModule(pointer)
+
+/* used to wrap returned objects in so we know whether they are newobject
+ and need freeing, or not */
+typedef struct _swig_object_wrapper {
+ void * ptr;
+ int newobject;
+} swig_object_wrapper;
+
+/* empty zend destructor for types without one */
+static ZEND_RSRC_DTOR_FUNC(SWIG_landfill) { (void)rsrc; }
+
+#define SWIG_SetPointerZval(a,b,c,d) SWIG_ZTS_SetPointerZval(a,b,c,d TSRMLS_CC)
+
+static void
+SWIG_ZTS_SetPointerZval(zval *z, void *ptr, swig_type_info *type, int newobject TSRMLS_DC) {
+ swig_object_wrapper *value=NULL;
+ /*
+ * First test for Null pointers. Return those as PHP native NULL
+ */
+ if (!ptr ) {
+ ZVAL_NULL(z);
+ return;
+ }
+ if (type->clientdata) {
+ if (! (*(int *)(type->clientdata)))
+ zend_error(E_ERROR, "Type: %s failed to register with zend",type->name);
+ value=(swig_object_wrapper *)emalloc(sizeof(swig_object_wrapper));
+ value->ptr=ptr;
+ value->newobject=newobject;
+ ZEND_REGISTER_RESOURCE(z, value, *(int *)(type->clientdata));
+ 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;
+ char *type_name;
+
+ value = (swig_object_wrapper *) zend_list_find(z->value.lval, &type);
+ if ( flags && SWIG_POINTER_DISOWN ) {
+ value->newobject = 0;
+ }
+ p = value->ptr;
+ if (type==-1) return NULL;
+
+ 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_Php4_GetModule() {
+ zval *pointer;
+ swig_module_info *ret = 0;
+
+ MAKE_STD_ZVAL(pointer);
+
+ TSRMLS_FETCH();
+
+ if (zend_get_constant(const_name, sizeof(const_name), pointer TSRMLS_CC)) {
+ if (pointer->type == IS_LONG) {
+ ret = (swig_module_info *) pointer->value.lval;
+ }
+ }
+ FREE_ZVAL(pointer);
+ return ret;
+}
+
+static void SWIG_Php4_SetModule(swig_module_info *pointer) {
+ TSRMLS_FETCH();
+ REGISTER_MAIN_LONG_CONSTANT(const_name, (long) pointer, 0);
+}
diff --git a/devtools/swigwin-1.3.34/Lib/php4/phppointers.i b/devtools/swigwin-1.3.34/Lib/php4/phppointers.i
new file mode 100644
index 0000000..91b2c6d
--- /dev/null
+++ b/devtools/swigwin-1.3.34/Lib/php4/phppointers.i
@@ -0,0 +1,42 @@
+%define %pass_by_ref( TYPE, CONVERT_IN, CONVERT_OUT )
+%typemap(in) 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 );
diff --git a/devtools/swigwin-1.3.34/Lib/php4/std_common.i b/devtools/swigwin-1.3.34/Lib/php4/std_common.i
new file mode 100644
index 0000000..a779649
--- /dev/null
+++ b/devtools/swigwin-1.3.34/Lib/php4/std_common.i
@@ -0,0 +1,13 @@
+/* -----------------------------------------------------------------------------
+ * See the LICENSE file for information on copyright, usage and redistribution
+ * of SWIG, and the README file for authors - http://www.swig.org/release.html.
+ *
+ * std_common.i
+ *
+ * SWIG typemaps for STL - common utilities
+ * ----------------------------------------------------------------------------- */
+
+%include <std/std_except.i>
+
+%apply size_t { std::size_t };
+
diff --git a/devtools/swigwin-1.3.34/Lib/php4/std_deque.i b/devtools/swigwin-1.3.34/Lib/php4/std_deque.i
new file mode 100644
index 0000000..cb98f6c
--- /dev/null
+++ b/devtools/swigwin-1.3.34/Lib/php4/std_deque.i
@@ -0,0 +1 @@
+%include <std/_std_deque.i>
diff --git a/devtools/swigwin-1.3.34/Lib/php4/std_map.i b/devtools/swigwin-1.3.34/Lib/php4/std_map.i
new file mode 100644
index 0000000..c35f21d
--- /dev/null
+++ b/devtools/swigwin-1.3.34/Lib/php4/std_map.i
@@ -0,0 +1,175 @@
+/* -----------------------------------------------------------------------------
+ * See the LICENSE file for information on copyright, usage and redistribution
+ * of SWIG, and the README file for authors - http://www.swig.org/release.html.
+ *
+ * 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:
+ map();
+ map(const map<K,T> &);
+
+ unsigned int size() const;
+ bool empty() const;
+ void clear();
+ %extend {
+ 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();
+ }
+ }
+ };
+
+
+ // specializations for built-ins
+
+ %define specialize_std_map_on_key(K,CHECK,CONVERT_FROM,CONVERT_TO)
+
+ template<class T> class map<K,T> {
+ // add typemaps here
+ public:
+ map();
+ map(const map<K,T> &);
+
+ unsigned int size() const;
+ bool empty() const;
+ void clear();
+ %extend {
+ T& get(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(K key, const T& x) {
+ (*self)[key] = x;
+ }
+ void del(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(K key) {
+ std::map<K,T >::iterator i = self->find(key);
+ return i != self->end();
+ }
+ }
+ };
+ %enddef
+
+ %define specialize_std_map_on_value(T,CHECK,CONVERT_FROM,CONVERT_TO)
+ template<class K> class map<K,T> {
+ // add typemaps here
+ public:
+ map();
+ map(const map<K,T> &);
+
+ unsigned int size() const;
+ bool empty() const;
+ void clear();
+ %extend {
+ 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, 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();
+ }
+ }
+ };
+ %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)
+ template<> class map<K,T> {
+ // add typemaps here
+ public:
+ map();
+ map(const map<K,T> &);
+
+ unsigned int size() const;
+ bool empty() const;
+ void clear();
+ %extend {
+ T get(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(K key, T x) {
+ (*self)[key] = x;
+ }
+ void del(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(K key) {
+ std::map<K,T >::iterator i = self->find(key);
+ return i != self->end();
+ }
+ }
+ };
+ %enddef
+
+ // add specializations here
+
+}
diff --git a/devtools/swigwin-1.3.34/Lib/php4/std_pair.i b/devtools/swigwin-1.3.34/Lib/php4/std_pair.i
new file mode 100644
index 0000000..dc0604d
--- /dev/null
+++ b/devtools/swigwin-1.3.34/Lib/php4/std_pair.i
@@ -0,0 +1,37 @@
+/* -----------------------------------------------------------------------------
+ * See the LICENSE file for information on copyright, usage and redistribution
+ * of SWIG, and the README file for authors - http://www.swig.org/release.html.
+ *
+ * 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
+
+}
diff --git a/devtools/swigwin-1.3.34/Lib/php4/std_string.i b/devtools/swigwin-1.3.34/Lib/php4/std_string.i
new file mode 100644
index 0000000..08a7cda
--- /dev/null
+++ b/devtools/swigwin-1.3.34/Lib/php4/std_string.i
@@ -0,0 +1,73 @@
+/* -----------------------------------------------------------------------------
+ * See the LICENSE file for information on copyright, usage and redistribution
+ * of SWIG, and the README file for authors - http://www.swig.org/release.html.
+ *
+ * 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 %{
+ $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(typecheck,precedence=SWIG_TYPECHECK_STRING) const string& %{
+ $1 = ( Z_TYPE_PP($input) == IS_STRING ) ? 1 : 0;
+ %}
+
+ %typemap(out) string %{
+ ZVAL_STRINGL($result, 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 %{
+ SWIG_PHP_Error(E_ERROR, (char *)$1.c_str());
+ %}
+
+ %typemap(throws) const string& %{
+ SWIG_PHP_Error(E_ERROR, (char *)$1.c_str());
+ %}
+
+ /* These next two handle a function which takes a non-const reference to
+ * a std::string and modifies the string. */
+ %typemap(in) string & (std::string temp) %{
+ convert_to_string_ex($input);
+ temp.assign(Z_STRVAL_PP($input), Z_STRLEN_PP($input));
+ $1 = &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 & "";
+}
diff --git a/devtools/swigwin-1.3.34/Lib/php4/std_vector.i b/devtools/swigwin-1.3.34/Lib/php4/std_vector.i
new file mode 100644
index 0000000..fe084ac
--- /dev/null
+++ b/devtools/swigwin-1.3.34/Lib/php4/std_vector.i
@@ -0,0 +1,132 @@
+/* -----------------------------------------------------------------------------
+ * See the LICENSE file for information on copyright, usage and redistribution
+ * of SWIG, and the README file for authors - http://www.swig.org/release.html.
+ *
+ * std_vector.i
+ *
+ * SWIG typemaps for std::vector types
+ * ----------------------------------------------------------------------------- */
+
+%include <std_common.i>
+
+// ------------------------------------------------------------------------
+// std::vector
+//
+// The aim of all that follows would be to integrate std::vector with
+// PHP as much as possible, namely, to allow the user to pass and
+// be returned PHP lists.
+// const declarations are used to guess the intent of the function being
+// exported; therefore, the following rationale is applied:
+//
+// -- f(std::vector<T>), f(const std::vector<T>&), f(const std::vector<T>*):
+// the parameter being read-only, either a PHP sequence or a
+// previously wrapped std::vector<T> can be passed.
+// -- f(std::vector<T>&), f(std::vector<T>*):
+// the parameter must be modified; therefore, only a wrapped std::vector
+// can be passed.
+// -- std::vector<T> f():
+// the vector is returned by copy; therefore, a PHP sequence of T:s
+// is returned which is most easily used in other PHP functions
+// -- std::vector<T>& f(), std::vector<T>* f(), const std::vector<T>& f(),
+// const std::vector<T>* f():
+// the vector is returned by reference; therefore, a wrapped std::vector
+// is returned
+// ------------------------------------------------------------------------
+
+%{
+#include <vector>
+#include <algorithm>
+#include <stdexcept>
+%}
+
+// exported class
+
+namespace std {
+
+ template<class T> class vector {
+ // add generic typemaps here
+ public:
+ vector(unsigned int size = 0);
+ unsigned int size() const;
+ bool empty() const;
+ void clear();
+ %rename(push) push_back;
+ void push_back(const T& x);
+ %extend {
+ 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;
+ }
+ T& 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 T& x) throw (std::out_of_range) {
+ int size = int(self->size());
+ if (i>=0 && i<size)
+ (*self)[i] = x;
+ else
+ throw std::out_of_range("vector index out of range");
+ }
+ }
+ };
+
+
+ // specializations for built-ins
+
+ %define specialize_std_vector(T)
+ template<> class vector<T> {
+ // add specialized typemaps here
+ public:
+ vector(unsigned int size = 0);
+ unsigned int size() const;
+ bool empty() const;
+ void clear();
+ %rename(push) push_back;
+ void push_back(T x);
+ %extend {
+ 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;
+ }
+ T 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, T x) throw (std::out_of_range) {
+ int size = int(self->size());
+ if (i>=0 && i<size)
+ (*self)[i] = x;
+ else
+ throw std::out_of_range("vector index out of range");
+ }
+ }
+ };
+ %enddef
+
+ specialize_std_vector(bool);
+ specialize_std_vector(char);
+ specialize_std_vector(int);
+ specialize_std_vector(short);
+ specialize_std_vector(long);
+ specialize_std_vector(unsigned char);
+ specialize_std_vector(unsigned int);
+ specialize_std_vector(unsigned short);
+ specialize_std_vector(unsigned long);
+ specialize_std_vector(float);
+ specialize_std_vector(double);
+
+}
+
diff --git a/devtools/swigwin-1.3.34/Lib/php4/stl.i b/devtools/swigwin-1.3.34/Lib/php4/stl.i
new file mode 100644
index 0000000..66b72e0
--- /dev/null
+++ b/devtools/swigwin-1.3.34/Lib/php4/stl.i
@@ -0,0 +1,15 @@
+/* -----------------------------------------------------------------------------
+ * See the LICENSE file for information on copyright, usage and redistribution
+ * of SWIG, and the README file for authors - http://www.swig.org/release.html.
+ *
+ * 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>
+
diff --git a/devtools/swigwin-1.3.34/Lib/php4/typemaps.i b/devtools/swigwin-1.3.34/Lib/php4/typemaps.i
new file mode 100644
index 0000000..c388fdf
--- /dev/null
+++ b/devtools/swigwin-1.3.34/Lib/php4/typemaps.i
@@ -0,0 +1,171 @@
+/* -----------------------------------------------------------------------------
+ * See the LICENSE file for information on copyright, usage and redistribution
+ * of SWIG, and the README file for authors - http://www.swig.org/release.html.
+ *
+ * typemaps.i.
+ *
+ * SWIG Typemap library for PHP4.
+ *
+ * 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 double_typemap(TYPE)
+%typemap(in) TYPE *INPUT(TYPE temp)
+%{
+ convert_to_double_ex($input);
+ temp = (TYPE) Z_DVAL_PP($input);
+ $1 = &temp;
+%}
+%typemap(argout) TYPE *INPUT "";
+%typemap(in,numinputs=0) TYPE *OUTPUT(TYPE temp) "$1 = &temp;";
+%typemap(argout,fragment="t_output_helper") TYPE *OUTPUT
+{
+ zval *o;
+ MAKE_STD_ZVAL(o);
+ ZVAL_DOUBLE(o,temp$argnum);
+ t_output_helper( &$result, o );
+}
+%typemap(in) TYPE *REFERENCE (TYPE dvalue)
+%{
+ convert_to_double_ex($input);
+ dvalue = (TYPE) (*$input)->value.dval;
+ $1 = &dvalue;
+%}
+%typemap(argout) TYPE *REFERENCE
+%{
+ $1->value.dval = (double)(lvalue$argnum);
+ $1->type = IS_DOUBLE;
+%}
+%enddef
+
+%define int_typemap(TYPE)
+%typemap(in) TYPE *INPUT(TYPE temp)
+%{
+ convert_to_long_ex($input);
+ temp = (TYPE) Z_LVAL_PP($input);
+ $1 = &temp;
+%}
+%typemap(argout) TYPE *INPUT "";
+%typemap(in,numinputs=0) TYPE *OUTPUT(TYPE temp) "$1 = &temp;";
+%typemap(argout,fragment="t_output_helper") TYPE *OUTPUT
+{
+ zval *o;
+ MAKE_STD_ZVAL(o);
+ ZVAL_LONG(o,temp$argnum);
+ t_output_helper( &$result, o );
+}
+%typemap(in) TYPE *REFERENCE (TYPE lvalue)
+%{
+ convert_to_long_ex($input);
+ lvalue = (TYPE) (*$input)->value.lval;
+ $1 = &lvalue;
+%}
+%typemap(argout) TYPE *REFERENCE
+%{
+ (*$arg)->value.lval = (long)(lvalue$argnum);
+ (*$arg)->type = IS_LONG;
+%}
+%enddef
+
+double_typemap(float);
+double_typemap(double);
+
+int_typemap(int);
+int_typemap(short);
+int_typemap(long);
+int_typemap(unsigned int);
+int_typemap(unsigned short);
+int_typemap(unsigned long);
+int_typemap(unsigned char);
+
+%typemap(in) float *INOUT = float *INPUT;
+%typemap(in) double *INOUT = double *INPUT;
+
+%typemap(in) int *INOUT = int *INPUT;
+%typemap(in) short *INOUT = short *INPUT;
+%typemap(in) long *INOUT = 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(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) unsigned short *INOUT= unsigned short *OUTPUT;
+%typemap(argout) unsigned long *INOUT = unsigned long *OUTPUT;
+%typemap(argout) unsigned char *INOUT = unsigned char *OUTPUT;
+
+%typemap(in) char INPUT[ANY] ( char temp[$1_dim0] )
+%{
+ convert_to_string_ex($input);
+ strncpy(temp,Z_LVAL_PP($input),$1_dim0);
+ $1 = temp;
+%}
+%typemap(in,numinputs=0) char OUTPUT[ANY] ( char temp[$1_dim0] )
+ "$1 = temp;";
+%typemap(argout) char OUTPUT[ANY]
+{
+ zval *o;
+ MAKE_STD_ZVAL(o);
+ ZVAL_STRINGL(o,temp$argnum,$1_dim0);
+ t_output_helper( &$result, o );
+}
+
+%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);
+ }
+ }
+%}
diff --git a/devtools/swigwin-1.3.34/Lib/php4/utils.i b/devtools/swigwin-1.3.34/Lib/php4/utils.i
new file mode 100644
index 0000000..f724118
--- /dev/null
+++ b/devtools/swigwin-1.3.34/Lib/php4/utils.i
@@ -0,0 +1,59 @@
+
+%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_INT_OUT(lvar,invar)
+ lvar = (t) Z_LVAL_PP(invar);
+%enddef
+
+%define CONVERT_FLOAT_IN(lvar,t,invar)
+ convert_to_double_ex(invar);
+ lvar = (t) Z_DVAL_PP(invar);
+%enddef
+
+%define CONVERT_CHAR_IN(lvar,t,invar)
+ convert_to_string_ex(invar);
+ lvar = (t) *Z_STRVAL_PP(invar);
+%enddef
+
+%define CONVERT_STRING_IN(lvar,t,invar)
+ convert_to_string_ex(invar);
+ lvar = (t) Z_STRVAL_PP(invar);
+%enddef
+
+%define %pass_by_val( TYPE, CONVERT_IN )
+%typemap(in) TYPE
+%{
+ CONVERT_IN($1,$1_ltype,$input);
+%}
+%enddef
+
+%fragment("t_output_helper","header") %{
+void
+t_output_helper( zval **target, zval *o) {
+ if ( (*target)->type == IS_ARRAY ) {
+ /* it's already an array, just append */
+ add_next_index_zval( *target, o );
+ return;
+ }
+ if ( (*target)->type == IS_NULL ) {
+ REPLACE_ZVAL_VALUE(target,o,1);
+ return;
+ }
+ zval *tmp;
+ 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);
+
+}
+%}
generated by cgit v1.2.3 (git 2.25.1) at 2026-06-06 21:46:52 +0000