PageRenderTime 9ms CodeModel.GetById 1ms app.highlight 3ms RepoModel.GetById 1ms app.codeStats 0ms

/trunk/Lib/pike/pike.swg

#
Unknown | 320 lines | 262 code | 58 blank | 0 comment | 0 complexity | 2498203f3b38c552b2ae357aae40af53 MD5 | raw file
  1/* -----------------------------------------------------------------------------
  2 * pike.swg
  3 *
  4 * Pike configuration module.
  5 * ----------------------------------------------------------------------------- */
  6
  7%insert(runtime) "swigrun.swg";            // Common C API type-checking code
  8%insert(runtime) "pikerun.swg";         // Pike run-time code
  9
 10%insert(runtime) %{
 11#ifdef __cplusplus
 12extern "C" {
 13#endif
 14#include <global.h>
 15#include <module.h>
 16#include <interpret.h>
 17#ifdef __cplusplus
 18}
 19#endif
 20%}
 21
 22/* -----------------------------------------------------------------------------
 23 *                          standard typemaps
 24 * ----------------------------------------------------------------------------- */
 25
 26/* --- Input arguments --- */
 27
 28/* Primitive datatypes. */
 29
 30%typemap(in, pikedesc="tInt")
 31    int, unsigned int, short, unsigned short,
 32    long, unsigned long, char, signed char, unsigned char,
 33    bool, enum SWIGTYPE, long long, unsigned long long
 34{
 35    if ($input.type != T_INT)
 36        Pike_error("Bad argument: Expected an integer.\n");
 37    $1 = ($1_ltype) $input.u.integer;
 38}
 39
 40%typemap(in, pikedesc="tFloat") float, double {
 41    if ($input.type != T_FLOAT)
 42        Pike_error("Bad argument: Expected a float.\n");
 43    $1 = ($1_ltype) $input.u.float_number;
 44}
 45
 46%typemap(in, pikedesc="tStr") char *, char [ANY] {
 47    if ($input.type != T_STRING)
 48        Pike_error("Bad argument: Expected a string.\n");
 49    $1 = ($1_ltype) STR0($input.u.string);
 50}
 51
 52/* Pointers, references and arrays */
 53
 54%typemap(in) SWIGTYPE *,
 55             SWIGTYPE &,
 56             SWIGTYPE []
 57	"SWIG_ConvertPtr($input.u.object, (void **) &$1, $1_descriptor, 1);"
 58	
 59/* Void pointer.  Accepts any kind of pointer */
 60%typemap(in) void * "/* FIXME */";
 61
 62/* Object passed by value. Convert to a pointer */
 63%typemap(in) SWIGTYPE ($&1_ltype argp) "/* FIXME */";
 64
 65/* Pointer to a class member */
 66%typemap(in) SWIGTYPE (CLASS::*) "/* FIXME */";
 67
 68/* Const primitive references.  Passed by value */
 69
 70%typemap(in, pikedesc="tInt") const int & (int temp),
 71	     const short & (short temp),
 72             const long  & (long temp),
 73             const unsigned int & (unsigned int temp),
 74             const unsigned short & (unsigned short temp),
 75             const unsigned long & (unsigned long temp),
 76	     const char & (char temp),
 77             const signed char & (signed char temp),
 78             const unsigned char & (unsigned char temp),
 79             const bool & (bool temp),
 80	     const long long & ($*1_ltype temp),
 81	     const unsigned long long & ($*1_ltype temp),
 82             const enum SWIGTYPE & ($*1_ltype temp)
 83{
 84  if ($input.type != T_INT)
 85    Pike_error("Bad argument: Expected an integer.\n");
 86    temp = ($*1_ltype) $input.u.integer;
 87    $1 = &temp;
 88}
 89
 90%typemap(in, pikedesc="tFloat") const float & (float temp),
 91	     const double & (double temp)
 92{
 93  if ($input.type != T_FLOAT)
 94    Pike_error("Bad argument: Expected a float.\n");
 95    temp = ($*1_ltype) $input.u.float_number;
 96    $1 = &temp;
 97}
 98
 99/* -----------------------------------------------------------------------------
100 * Output Typemaps
101 * ----------------------------------------------------------------------------- */
102%typemap(out, pikedesc="tInt")
103    int, unsigned int,
104    short, unsigned short,
105    long, unsigned long,
106    char, signed char, unsigned char, 
107    bool, enum SWIGTYPE
108	"push_int($1);";
109
110%typemap(out, pikedesc="tInt") long long	"push_int64($1);";
111%typemap(out, pikedesc="tInt") unsigned long long	"push_int64($1);";
112%typemap(out, pikedesc="tFloat") float, double	"push_float($1);";
113%typemap(out, pikedesc="tStr") char *		"push_text($1);";
114
115/* Pointers, references, and arrays */
116%typemap(out, pikedesc="tObj") SWIGTYPE*, SWIGTYPE &, SWIGTYPE [] "push_object(SWIG_NewPointerObj((void *) $1, $1_descriptor, $owner));";
117
118/* Void return value; don't push anything */
119%typemap(out, pikedesc="tVoid") void		"";
120
121/* Dynamic casts */
122
123%typemap(out) SWIGTYPE *DYNAMIC, SWIGTYPE &DYNAMIC "/* FIXME */";
124
125/* Member pointer */
126%typemap(out) SWIGTYPE (CLASS::*) "/* FIXME */";
127
128/* Special typemap for character array return values */
129%typemap(out, pikedesc="tStr") char [ANY], const char [ANY] "push_text($1);";
130
131/* Primitive types--return by value */
132%typemap(out, pikedesc="tObj") SWIGTYPE 
133#ifdef __cplusplus
134{
135  $&1_ltype resultptr;
136  resultptr = new $1_ltype((const $1_ltype &) $1);
137  push_object(SWIG_NewPointerObj((void *) resultptr, $&1_descriptor, 1));
138}
139#else
140{
141  $&1_ltype resultptr;
142  resultptr = ($&1_ltype) malloc(sizeof($1_type));
143  memmove(resultptr, &$1, sizeof($1_type));
144  push_object(SWIG_NewPointerObj((void *) resultptr, $&1_descriptor, 1));
145}
146#endif
147
148/* References to primitive types.  Return by value */
149
150%typemap(out, pikedesc="tInt") const int &, const unsigned int &,
151              const short &, const unsigned short &,
152              const long &, const unsigned long &,
153              const char &, const signed char &, const unsigned char &,
154              const bool &,
155	      const long long &, const unsigned long long &,
156              const enum SWIGTYPE & ($*1_ltype temp)
157      "push_int(*($1));";
158
159%typemap(out, pikedesc="tFloat") const float &, const double &  "push_float(*($1));";
160
161/************************ Constant Typemaps *****************************/
162
163%typemap(constant)
164    int, unsigned int,
165    short, unsigned short,
166    long, unsigned long,
167    signed char, unsigned char, 
168    bool, enum SWIGTYPE,
169    long long, unsigned long long
170    	"add_integer_constant(\"$symname\", $1, 0);";
171
172%typemap(constant) char
173	"add_integer_constant(\"$symname\", '$1', 0);";
174
175%typemap(constant) long long, unsigned long long
176	"add_integer_constant(\"$symname\", $1, 0);";
177
178%typemap(constant) float, double
179	"add_float_constant(\"$symname\", $1, 0);";
180
181%typemap(constant) char *
182	"add_string_constant(\"$symname\", \"$1\", 0);";
183
184/* ------------------------------------------------------------
185 * String & length
186 * ------------------------------------------------------------ */
187
188%typemap(in) (char *STRING, int LENGTH), (char *STRING, size_t LENGTH) {
189    if ($input.type != T_STRING)
190        Pike_error("Bad argument: Expected a string.\n");
191    $1 = ($1_ltype) STR0($input.u.string);
192    $2 = ($2_ltype) $input.u.string->length;
193}
194
195/* ------------------------------------------------------------
196 * ANSI C typemaps
197 * ------------------------------------------------------------ */
198
199%typemap(in, pikedesc="tInt") size_t {
200    if ($input.type != T_INT)
201        Pike_error("Bad argument: Expected an integer.\n");
202    $1 = ($1_ltype) $input.u.integer;
203}
204
205%typemap(out)      size_t = long;
206
207/* ------------------------------------------------------------
208 * Typechecking rules
209 * ------------------------------------------------------------ */
210
211%typecheck(SWIG_TYPECHECK_INTEGER)
212	 int, short, long,
213 	 unsigned int, unsigned short, unsigned long,
214	 signed char, unsigned char,
215	 long long, unsigned long long,
216	 const int &, const short &, const long &,
217 	 const unsigned int &, const unsigned short &, const unsigned long &,
218	 const long long &, const unsigned long long &,
219	 enum SWIGTYPE, enum SWIGTYPE &,
220         bool, const bool & 
221{
222  $1 = ($input.type == T_INT) ? 1 : 0;
223}
224
225%typecheck(SWIG_TYPECHECK_DOUBLE)
226	float, double,
227	const float &, const double &
228{
229  $1 = (($input.type == T_FLOAT) || ($input.type == T_INT)) ? 1 : 0;
230}
231
232%typecheck(SWIG_TYPECHECK_CHAR) char {
233  $1 = ($input.type == T_INT) ? 1 : 0;
234}
235
236%typecheck(SWIG_TYPECHECK_STRING) char * {
237  $1 = ($input.type == T_STRING) ? 1 : 0;
238}
239
240%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *, SWIGTYPE &, SWIGTYPE [] {
241  void *ptr;
242  if (SWIG_ConvertPtr($input.u.object, (void **) &ptr, $1_descriptor, 0) == -1) {
243    $1 = 0;
244  } else {
245    $1 = 1;
246  }
247}
248
249%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE {
250  void *ptr;
251  if (SWIG_ConvertPtr($input.u.object, (void **) &ptr, $&1_descriptor, 0) == -1) {
252    $1 = 0;
253  } else {
254    $1 = 1;
255  }
256}
257
258%typecheck(SWIG_TYPECHECK_VOIDPTR) void * {
259  void *ptr;
260  if (SWIG_ConvertPtr($input.u.object, (void **) &ptr, 0, 0) == -1) {
261    $1 = 0;
262  } else {
263    $1 = 1;
264  }
265}
266
267/* Array reference typemaps */
268%apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) }
269
270/* const pointers */
271%apply SWIGTYPE * { SWIGTYPE *const }
272
273/* ------------------------------------------------------------
274 * Overloaded operator support
275 * ------------------------------------------------------------ */
276
277#ifdef __cplusplus
278%rename("`+")      *::operator+;
279%rename("`-")      *::operator-;
280%rename("`*")      *::operator*;
281%rename("`/")      *::operator/;
282%rename("`%")      *::operator%;
283%rename("`<<")     *::operator<<;
284%rename("`>>")     *::operator>>;
285%rename("`&")      *::operator&;
286%rename("`|")      *::operator|;
287%rename("`^")      *::operator^;
288%rename("`~")      *::operator~;
289%rename("`<")      *::operator<;
290%rename("`>")      *::operator>;
291%rename("`==")     *::operator==;
292
293/* Special cases */
294%rename("`()")     *::operator();
295
296#endif
297
298/* ------------------------------------------------------------
299 * The start of the Pike initialization function
300 * ------------------------------------------------------------ */
301
302%init "swiginit.swg"
303
304%init %{
305#ifdef __cplusplus
306extern "C"
307#endif
308PIKE_MODULE_EXIT {}
309
310#ifdef __cplusplus
311extern "C"
312#endif
313PIKE_MODULE_INIT
314{
315    struct program *pr;
316    SWIG_InitializeModule(0);
317%}
318
319/* pike keywords */
320%include <pikekw.swg>