Lib/chicken/typemaps.i

   1 /* -----------------------------------------------------------------------------
   2  * See the LICENSE file for information on copyright, usage and redistribution
   3  * of SWIG, and the README file for authors - http://www.swig.org/release.html.
   4  *
   5  * typemaps.i
   6  *
   7  * Pointer handling
   8  *
   9  * These mappings provide support for input/output arguments and
  10  * common uses for C/C++ pointers.  INOUT mappings allow for C/C++
  11  * pointer variables in addition to input/output arguments.
  12  * ----------------------------------------------------------------------------- */
  13
  14 // INPUT typemaps.
  15 // These remap a C pointer to be an "INPUT" value which is passed by value
  16 // instead of reference.
  17
  18 /*
  19 The following methods can be applied to turn a pointer into a simple
  20 "input" value.  That is, instead of passing a pointer to an object,
  21 you would use a real value instead.
  22
  23          int            *INPUT
  24          short          *INPUT
  25          long           *INPUT
  26          long long      *INPUT
  27          unsigned int   *INPUT
  28          unsigned short *INPUT
  29          unsigned long  *INPUT
  30          unsigned long long *INPUT
  31          unsigned char  *INPUT
  32          char           *INPUT
  33          bool           *INPUT
  34          float          *INPUT
  35          double         *INPUT
  36
  37 To use these, suppose you had a C function like this :
  38
  39         double fadd(double *a, double *b) {
  40                return *a+*b;
  41         }
  42
  43 You could wrap it with SWIG as follows :
  44
  45         %include <typemaps.i>
  46         double fadd(double *INPUT, double *INPUT);
  47
  48 or you can use the %apply directive :
  49
  50         %include <typemaps.i>
  51         %apply double *INPUT { double *a, double *b };
  52         double fadd(double *a, double *b);
  53
  54 */
  55
  56 // OUTPUT typemaps.   These typemaps are used for parameters that
  57 // are output only.   The output value is appended to the result as
  58 // a list element.
  59
  60 /*
  61 The following methods can be applied to turn a pointer into an "output"
  62 value.  When calling a function, no input value would be given for
  63 a parameter, but an output value would be returned.  In the case of
  64 multiple output values, they are returned in the form of a Scheme list.
  65
  66          int            *OUTPUT
  67          short          *OUTPUT
  68          long           *OUTPUT
  69          long long      *OUTPUT
  70          unsigned int   *OUTPUT
  71          unsigned short *OUTPUT
  72          unsigned long  *OUTPUT
  73          unsigned long long *OUTPUT
  74          unsigned char  *OUTPUT
  75          char           *OUTPUT
  76          bool           *OUTPUT
  77          float          *OUTPUT
  78          double         *OUTPUT
  79
  80 For example, suppose you were trying to wrap the modf() function in the
  81 C math library which splits x into integral and fractional parts (and
  82 returns the integer part in one of its parameters).K:
  83
  84         double modf(double x, double *ip);
  85
  86 You could wrap it with SWIG as follows :
  87
  88         %include <typemaps.i>
  89         double modf(double x, double *OUTPUT);
  90
  91 or you can use the %apply directive :
  92
  93         %include <typemaps.i>
  94         %apply double *OUTPUT { double *ip };
  95         double modf(double x, double *ip);
  96
  97 */
  98
  99 // These typemaps contributed by Robin Dunn
 100 //----------------------------------------------------------------------
 101 //
 102 // T_OUTPUT typemap (and helper function) to return multiple argouts as
 103 // a tuple instead of a list.
 104 //
 105 //----------------------------------------------------------------------
 106
 107 // Simple types
 108
 109 %define INOUT_TYPEMAP(type_, from_scheme, to_scheme, checker, convtype, storage_)
 110
 111 %typemap(in) type_ *INPUT($*1_ltype temp), type_ &INPUT($*1_ltype temp)
 112 %{  if (!checker ($input)) {
 113     swig_barf (SWIG_BARF1_BAD_ARGUMENT_TYPE, "Argument #$argnum is not of type 'type_'");
 114   }
 115   temp = ($*1_ltype) from_scheme ($input);
 116   $1 = &temp; %}
 117
 118 %typemap(typecheck) type_ *INPUT = type_;
 119 %typemap(typecheck) type_ &INPUT = type_;
 120
 121 %typemap(in, numinputs=0) type_ *OUTPUT($*1_ltype temp), type_ &OUTPUT($*1_ltype temp)
 122 "  $1 = &temp;"
 123
 124 #if "storage_" == "0"
 125
 126 %typemap(argout) type_ *OUTPUT, type_ &OUTPUT
 127 %{
 128   if ($1 == NULL) {
 129     swig_barf (SWIG_BARF1_ARGUMENT_NULL, "Argument #$argnum must be non-null");
 130   }
 131   SWIG_APPEND_VALUE(to_scheme (convtype (*$1)));
 132 %}
 133
 134 #else
 135
 136 %typemap(argout) type_ *OUTPUT, type_ &OUTPUT
 137 %{
 138   {
 139     C_word *known_space = C_alloc(storage_);
 140     if ($1 == NULL) {
 141       swig_barf (SWIG_BARF1_ARGUMENT_NULL, "Variable '$1' must be non-null");
 142     }
 143     SWIG_APPEND_VALUE(to_scheme (&known_space, convtype (*$1)));
 144   }
 145 %}
 146
 147 #endif
 148
 149 %enddef
 150
 151 INOUT_TYPEMAP(int, C_num_to_int, C_fix, C_swig_is_number, (int), 0);
 152 INOUT_TYPEMAP(enum SWIGTYPE, C_num_to_int, C_fix, C_swig_is_number, (int), 0);
 153 INOUT_TYPEMAP(short, C_num_to_int, C_fix, C_swig_is_number, (int), 0);
 154 INOUT_TYPEMAP(long, C_num_to_long, C_long_to_num, C_swig_is_long, (long), C_SIZEOF_FLONUM);
 155 INOUT_TYPEMAP(long long, C_num_to_long, C_long_to_num, C_swig_is_long, (long), C_SIZEOF_FLONUM);
 156 INOUT_TYPEMAP(unsigned int, C_num_to_unsigned_int, C_unsigned_int_to_num, C_swig_is_number, (int), C_SIZEOF_FLONUM);
 157 INOUT_TYPEMAP(unsigned short, C_num_to_unsigned_int, C_fix, C_swig_is_number, (unsigned int), 0);
 158 INOUT_TYPEMAP(unsigned long, C_num_to_unsigned_long, C_unsigned_long_to_num, C_swig_is_long, (unsigned long), C_SIZEOF_FLONUM);
 159 INOUT_TYPEMAP(unsigned long long, C_num_to_unsigned_long, C_unsigned_long_to_num, C_swig_is_long, (unsigned long), C_SIZEOF_FLONUM);
 160 INOUT_TYPEMAP(unsigned char, C_character_code, C_make_character, C_swig_is_char, (unsigned int), 0);
 161 INOUT_TYPEMAP(signed char, C_character_code, C_make_character, C_swig_is_char, (int), 0);
 162 INOUT_TYPEMAP(char, C_character_code, C_make_character, C_swig_is_char, (char), 0);
 163 INOUT_TYPEMAP(bool, C_truep, C_mk_bool, C_swig_is_bool, (bool), 0);
 164 INOUT_TYPEMAP(float, C_c_double, C_flonum, C_swig_is_number, (double), C_SIZEOF_FLONUM);
 165 INOUT_TYPEMAP(double, C_c_double, C_flonum, C_swig_is_number, (double), C_SIZEOF_FLONUM);
 166
 167 // INOUT
 168 // Mappings for an argument that is both an input and output
 169 // parameter
 170
 171 /*
 172 The following methods can be applied to make a function parameter both
 173 an input and output value.  This combines the behavior of both the
 174 "INPUT" and "OUTPUT" methods described earlier.  Output values are
 175 returned in the form of a CHICKEN tuple.
 176
 177          int            *INOUT
 178          short          *INOUT
 179          long           *INOUT
 180          long long      *INOUT
 181          unsigned int   *INOUT
 182          unsigned short *INOUT
 183          unsigned long  *INOUT
 184          unsigned long long *INOUT
 185          unsigned char  *INOUT
 186          char           *INOUT
 187          bool           *INOUT
 188          float          *INOUT
 189          double         *INOUT
 190
 191 For example, suppose you were trying to wrap the following function :
 192
 193         void neg(double *x) {
 194              *x = -(*x);
 195         }
 196
 197 You could wrap it with SWIG as follows :
 198
 199         %include <typemaps.i>
 200         void neg(double *INOUT);
 201
 202 or you can use the %apply directive :
 203
 204         %include <typemaps.i>
 205         %apply double *INOUT { double *x };
 206         void neg(double *x);
 207
 208 As well, you can wrap variables with :
 209
 210         %include <typemaps.i>
 211         %apply double *INOUT { double *y };
 212         extern double *y;
 213
 214 Unlike C, this mapping does not directly modify the input value (since
 215 this makes no sense in CHICKEN).  Rather, the modified input value shows
 216 up as the return value of the function.  Thus, to apply this function
 217 to a CHICKEN variable you might do this :
 218
 219        x = neg(x)
 220
 221 Note : previous versions of SWIG used the symbol 'BOTH' to mark
 222 input/output arguments.   This is still supported, but will be slowly
 223 phased out in future releases.
 224
 225 */
 226
 227 %typemap(in) int *INOUT = int *INPUT;
 228 %typemap(in) enum SWIGTYPE *INOUT = enum SWIGTYPE *INPUT;
 229 %typemap(in) short *INOUT = short *INPUT;
 230 %typemap(in) long *INOUT = long *INPUT;
 231 %typemap(in) long long *INOUT = long long *INPUT;
 232 %typemap(in) unsigned *INOUT = unsigned *INPUT;
 233 %typemap(in) unsigned short *INOUT = unsigned short *INPUT;
 234 %typemap(in) unsigned long *INOUT = unsigned long *INPUT;
 235 %typemap(in) unsigned long long *INOUT = unsigned long long *INPUT;
 236 %typemap(in) unsigned char *INOUT = unsigned char *INPUT;
 237 %typemap(in) char *INOUT = char *INPUT;
 238 %typemap(in) bool *INOUT = bool *INPUT;
 239 %typemap(in) float *INOUT = float *INPUT;
 240 %typemap(in) double *INOUT = double *INPUT;
 241
 242 %typemap(in) int &INOUT = int &INPUT;
 243 %typemap(in) enum SWIGTYPE &INOUT = enum SWIGTYPE &INPUT;
 244 %typemap(in) short &INOUT = short &INPUT;
 245 %typemap(in) long &INOUT = long &INPUT;
 246 %typemap(in) long long &INOUT = long long &INPUT;
 247 %typemap(in) unsigned &INOUT = unsigned &INPUT;
 248 %typemap(in) unsigned short &INOUT = unsigned short &INPUT;
 249 %typemap(in) unsigned long &INOUT = unsigned long &INPUT;
 250 %typemap(in) unsigned long long &INOUT = unsigned long long &INPUT;
 251 %typemap(in) unsigned char &INOUT = unsigned char &INPUT;
 252 %typemap(in) char &INOUT = char &INPUT;
 253 %typemap(in) bool &INOUT = bool &INPUT;
 254 %typemap(in) float &INOUT = float &INPUT;
 255 %typemap(in) double &INOUT = double &INPUT;
 256
 257 %typemap(argout) int *INOUT = int *OUTPUT;
 258 %typemap(argout) enum SWIGTYPE *INOUT = enum SWIGTYPE *OUTPUT;
 259 %typemap(argout) short *INOUT = short *OUTPUT;
 260 %typemap(argout) long *INOUT = long *OUTPUT;
 261 %typemap(argout) long long *INOUT = long long *OUTPUT;
 262 %typemap(argout) unsigned *INOUT = unsigned *OUTPUT;
 263 %typemap(argout) unsigned short *INOUT = unsigned short *OUTPUT;
 264 %typemap(argout) unsigned long *INOUT = unsigned long *OUTPUT;
 265 %typemap(argout) unsigned long long *INOUT = unsigned long long *OUTPUT;
 266 %typemap(argout) unsigned char *INOUT = unsigned char *OUTPUT;
 267 %typemap(argout) bool *INOUT = bool *OUTPUT;
 268 %typemap(argout) float *INOUT = float *OUTPUT;
 269 %typemap(argout) double *INOUT = double *OUTPUT;
 270
 271 %typemap(argout) int &INOUT = int &OUTPUT;
 272 %typemap(argout) enum SWIGTYPE &INOUT = enum SWIGTYPE &OUTPUT;
 273 %typemap(argout) short &INOUT = short &OUTPUT;
 274 %typemap(argout) long &INOUT = long &OUTPUT;
 275 %typemap(argout) long long &INOUT = long long &OUTPUT;
 276 %typemap(argout) unsigned &INOUT = unsigned &OUTPUT;
 277 %typemap(argout) unsigned short &INOUT = unsigned short &OUTPUT;
 278 %typemap(argout) unsigned long &INOUT = unsigned long &OUTPUT;
 279 %typemap(argout) unsigned long long &INOUT = unsigned long long &OUTPUT;
 280 %typemap(argout) unsigned char &INOUT = unsigned char &OUTPUT;
 281 %typemap(argout) char &INOUT = char &OUTPUT;
 282 %typemap(argout) bool &INOUT = bool &OUTPUT;
 283 %typemap(argout) float &INOUT = float &OUTPUT;
 284 %typemap(argout) double &INOUT = double &OUTPUT;
 285
 286 /* Overloading information */
 287
 288 %typemap(typecheck) double *INOUT = double;
 289 %typemap(typecheck) bool *INOUT = bool;
 290 %typemap(typecheck) char *INOUT = char;
 291 %typemap(typecheck) signed char *INOUT = signed char;
 292 %typemap(typecheck) unsigned char *INOUT = unsigned char;
 293 %typemap(typecheck) unsigned long *INOUT = unsigned long;
 294 %typemap(typecheck) unsigned long long *INOUT = unsigned long long;
 295 %typemap(typecheck) unsigned short *INOUT = unsigned short;
 296 %typemap(typecheck) unsigned int *INOUT = unsigned int;
 297 %typemap(typecheck) long *INOUT = long;
 298 %typemap(typecheck) long long *INOUT = long long;
 299 %typemap(typecheck) short *INOUT = short;
 300 %typemap(typecheck) int *INOUT = int;
 301 %typemap(typecheck) enum SWIGTYPE *INOUT = enum SWIGTYPE;
 302 %typemap(typecheck) float *INOUT = float;
 303
 304 %typemap(typecheck) double &INOUT = double;
 305 %typemap(typecheck) bool &INOUT = bool;
 306 %typemap(typecheck) char &INOUT = char;
 307 %typemap(typecheck) signed char &INOUT = signed char;
 308 %typemap(typecheck) unsigned char &INOUT = unsigned char;
 309 %typemap(typecheck) unsigned long &INOUT = unsigned long;
 310 %typemap(typecheck) unsigned long long &INOUT = unsigned long long;
 311 %typemap(typecheck) unsigned short &INOUT = unsigned short;
 312 %typemap(typecheck) unsigned int &INOUT = unsigned int;
 313 %typemap(typecheck) long &INOUT = long;
 314 %typemap(typecheck) long long &INOUT = long long;
 315 %typemap(typecheck) short &INOUT = short;
 316 %typemap(typecheck) int &INOUT = int;
 317 %typemap(typecheck) enum SWIGTYPE &INOUT = enum SWIGTYPE;
 318 %typemap(typecheck) float &INOUT = float;