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 <pike/global.h>
15#include <pike/module.h>
16#include <pike/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>
321