/*
 * php4.swg
 *
 * PHP 4 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) {
          SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $&1_descriptor");
	}
	$1 = *tmp;
}

%typemap(in) SWIGTYPE *,
             SWIGTYPE [],
             SWIGTYPE &
{
        /* typemap(in) SWIGTYPE * */
	if(SWIG_ConvertPtr(*$input, (void **) &$1, $1_descriptor, 0) < 0) {
            SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $1_descriptor");
	}
}
%typemap(in) SWIGTYPE *DISOWN
{
  /* 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)) {
#ifdef __cplusplus
      ptr=new $*1_ltype;
#else
      ptr=($*1_ltype) calloc(1,sizeof($*1_ltype));
#endif
      $1=&ptr;
      /* have to passback arg$arg too */
      force=1;
    } else {  /* wasn't a pre/ref/thing, OR anything like an int thing */
      force=0;
          SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $1_descriptor");
    }
  } else force=0;
}
%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
{
	// 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 would do hard checking for proper argument type.
//%define %php_typecheck(_type,_prec,is)
//%typemap(typecheck,precedence=_prec) _type
// " $1 = Z_TYPE_PP($input) == is ? 1 : 0; "
//%enddef

%define %php_typecheck(_type,_prec,is)
%typemap(typecheck,precedence=_prec) _type
 " $1 = (Z_TYPE_PP($input) == IS_LONG ||
         Z_TYPE_PP($input) == IS_DOUBLE ||
         Z_TYPE_PP($input) == IS_STRING) ? 1 : 0; "
%enddef

%php_typecheck(int,SWIG_TYPECHECK_INTEGER,IS_LONG)
%php_typecheck(unsigned int,SWIG_TYPECHECK_UINT32,IS_LONG)
%php_typecheck(short,SWIG_TYPECHECK_INT16,IS_LONG)
%php_typecheck(unsigned short,SWIG_TYPECHECK_UINT16,IS_LONG)
%php_typecheck(long,SWIG_TYPECHECK_INT64,IS_LONG)
%php_typecheck(unsigned long,SWIG_TYPECHECK_UINT64,IS_LONG)
%php_typecheck(signed char,SWIG_TYPECHECK_INT8,IS_LONG)
%php_typecheck(unsigned char,SWIG_TYPECHECK_UINT8,IS_LONG)
%php_typecheck(size_t,SWIG_TYPECHECK_INT16,IS_LONG)
%php_typecheck(enum SWIGTYPE,SWIG_TYPECHECK_INT8,IS_LONG)
%php_typecheck(bool,SWIG_TYPECHECK_BOOL,IS_BOOL)

%php_typecheck(char,SWIG_TYPECHECK_CHAR,IS_STRING)
%php_typecheck(char *,SWIG_TYPECHECK_STRING,IS_STRING)
%php_typecheck(char [],SWIG_TYPECHECK_STRING,IS_STRING)

%php_typecheck(float,SWIG_TYPECHECK_FLOAT,IS_DOUBLE)
%php_typecheck(double,SWIG_TYPECHECK_BOOL,IS_DOUBLE)

%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE
 " /* typecheck SWIGTYPE */ "

%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *,
             SWIGTYPE [],
             SWIGTYPE &
{
  /* typecheck SWIGTYPE * */
  void *tmp;
  _v = (SWIG_ConvertPtr( *$input, (void**)&tmp, $1_descriptor, 0) < 0)? 0:1;
}
	
%typecheck(SWIG_TYPECHECK_VOIDPTR) void *
 " /* tyepcheck 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>
