[OpenSPARC-T2-SAM] / sam-t2 / devtools / amd64 / share / swig / 1.3.26 / pike / pike.swg

/* -----------------------------------------------------------------------------
 * pike.swg
 *
 * Pike configuration module.
 * ----------------------------------------------------------------------------- */

%insert(runtime) "swigrun.swg";            // Common C API type-checking code
%insert(runtime) "pikerun.swg";         // Pike run-time code

%insert(runtime) %{
#ifdef __cplusplus
extern "C" {
#endif
#include "global.h"
#include "module.h"
#include "interpret.h"
#ifdef __cplusplus
}
#endif
%}

/* -----------------------------------------------------------------------------
 *                          standard typemaps
 * ----------------------------------------------------------------------------- */

/* --- Input arguments --- */

/* Primitive datatypes. */

%typemap(in, pikedesc="tInt")
    int, unsigned int, short, unsigned short,
    long, unsigned long, char, signed char, unsigned char,
    bool, enum SWIGTYPE, long long, unsigned long long
{
    if ($input.type != T_INT)
        Pike_error("Bad argument: Expected an integer.\n");
    $1 = ($1_ltype) $input.u.integer;
}

%typemap(in, pikedesc="tFloat") float, double {
    if ($input.type != T_FLOAT)
        Pike_error("Bad argument: Expected a float.\n");
    $1 = ($1_ltype) $input.u.float_number;
}

%typemap(in, pikedesc="tStr") char *, char [ANY] {
    if ($input.type != T_STRING)
        Pike_error("Bad argument: Expected a string.\n");
    $1 = ($1_ltype) STR0($input.u.string);
}

/* Pointers, references and arrays */

%typemap(in) SWIGTYPE *,
             SWIGTYPE &,
             SWIGTYPE []
	"SWIG_ConvertPtr($input.u.object, (void **) &$1, $1_descriptor, 1);"
	
/* Void pointer.  Accepts any kind of pointer */
%typemap(in) void * "/* FIXME */";

/* Object passed by value. Convert to a pointer */
%typemap(in) SWIGTYPE ($&1_ltype argp) "/* FIXME */";

/* Pointer to a class member */
%typemap(in) SWIGTYPE (CLASS::*) "/* FIXME */";

/* Const primitive references.  Passed by value */

%typemap(in, pikedesc="tInt") const int & (int temp),
	     const short & (short temp),
             const long  & (long temp),
             const unsigned int & (unsigned int temp),
             const unsigned short & (unsigned short temp),
             const unsigned long & (unsigned long temp),
	     const char & (char temp),
             const signed char & (signed char temp),
             const unsigned char & (unsigned char temp),
             const bool & (bool temp),
	     const long long & ($*1_ltype temp),
	     const unsigned long long & ($*1_ltype temp),
             const enum SWIGTYPE & ($*1_ltype temp)
{
  if ($input.type != T_INT)
    Pike_error("Bad argument: Expected an integer.\n");
    temp = ($*1_ltype) $input.u.integer;
    $1 = &temp;
}

%typemap(in, pikedesc="tFloat") const float & (float temp),
	     const double & (double temp)
{
  if ($input.type != T_FLOAT)
    Pike_error("Bad argument: Expected a float.\n");
    temp = ($*1_ltype) $input.u.float_number;
    $1 = &temp;
}

/************************ Output Typemaps *****************************/

%typemap(out, pikedesc="tInt")
    int, unsigned int,
    short, unsigned short,
    long, unsigned long,
    char, signed char, unsigned char, 
    bool, enum SWIGTYPE
	"push_int($1);";

%typemap(out, pikedesc="tInt") long long	"push_int64($1);";
%typemap(out, pikedesc="tInt") unsigned long long	"push_int64($1);";
%typemap(out, pikedesc="tFloat") float, double	"push_float($1);";
%typemap(out, pikedesc="tStr") char *		"push_text($1);";

/* Pointers, references, and arrays */
%typemap(out, pikedesc="tObj") SWIGTYPE*, SWIGTYPE &, SWIGTYPE [] "push_object(SWIG_NewPointerObj((void *) $1, $1_descriptor, $owner));";

/* Void return value; don't push anything */
%typemap(out, pikedesc="tVoid") void		"";

/* Dynamic casts */

%typemap(out) SWIGTYPE *DYNAMIC, SWIGTYPE &DYNAMIC "/* FIXME */";

/* Member pointer */
%typemap(out) SWIGTYPE (CLASS::*) "/* FIXME */";

/* Special typemap for character array return values */
%typemap(out, pikedesc="tStr") char [ANY], const char [ANY] "push_text($1);";

/* Primitive types--return by value */
%typemap(out, "tObj") SWIGTYPE 
#ifdef __cplusplus
{
  $&1_ltype resultptr;
  resultptr = new $1_ltype(($1_ltype &) $1);
  push_object(SWIG_NewPointerObj((void *) resultptr, $&1_descriptor, 1));
}
#else
{
  $&1_ltype resultptr;
  resultptr = ($&1_ltype) malloc(sizeof($1_type));
  memmove(resultptr, &$1, sizeof($1_type));
  push_object(SWIG_NewPointerObj((void *) resultptr, $&1_descriptor, 1));
}
#endif

/* References to primitive types.  Return by value */

%typemap(out, pikedesc="tInt") const int &, const unsigned int &,
              const short &, const unsigned short &,
              const long &, const unsigned long &,
              const char &, const signed char &, const unsigned char &,
              const bool &,
	      const long long &, const unsigned long long &,
              const enum SWIGTYPE & ($*1_ltype temp)
      "push_int(*($1));";

%typemap(out, pikedesc="tFloat") const float &, const double &  "push_float(*($1));";

/************************ Constant Typemaps *****************************/

%typemap(constant)
    int, unsigned int,
    short, unsigned short,
    long, unsigned long,
    signed char, unsigned char, 
    bool, enum SWIGTYPE,
    long long, unsigned long long
    	"add_integer_constant(\"$symname\", $1, 0);";

%typemap(constant) char
	"add_integer_constant(\"$symname\", '$1', 0);";

%typemap(constant) long long, unsigned long long
	"add_integer_constant(\"$symname\", $1, 0);";

%typemap(constant) float, double
	"add_float_constant(\"$symname\", $1, 0);";

%typemap(constant) char *
	"add_string_constant(\"$symname\", \"$1\", 0);";

/* ------------------------------------------------------------
 * String & length
 * ------------------------------------------------------------ */

%typemap(in, pikedesc="tStr") (char *STRING, int LENGTH) {
    if ($input.type != T_STRING)
        Pike_error("Bad argument: Expected a string.\n");
    $1 = ($1_ltype) STR0($input.u.string);
    $2 = ($2_ltype) $input.u.string->length;
}

/* ------------------------------------------------------------
 * ANSI C typemaps
 * ------------------------------------------------------------ */

%typemap(in, pikedesc="tInt") size_t {
    if ($input.type != T_INT)
        Pike_error("Bad argument: Expected an integer.\n");
    $1 = ($1_ltype) $input.u.integer;
}

%typemap(out)      size_t = long;

/* ------------------------------------------------------------
 * Typechecking rules
 * ------------------------------------------------------------ */

%typecheck(SWIG_TYPECHECK_INTEGER)
	 int, short, long,
 	 unsigned int, unsigned short, unsigned long,
	 signed char, unsigned char,
	 long long, unsigned long long,
	 const int &, const short &, const long &,
 	 const unsigned int &, const unsigned short &, const unsigned long &,
	 const long long &, const unsigned long long &,
	 enum SWIGTYPE, enum SWIGTYPE &,
         bool, const bool & 
{
  $1 = ($input.type == T_INT) ? 1 : 0;
}

%typecheck(SWIG_TYPECHECK_DOUBLE)
	float, double,
	const float &, const double &
{
  $1 = (($input.type == T_FLOAT) || ($input.type == T_INT)) ? 1 : 0;
}

%typecheck(SWIG_TYPECHECK_CHAR) char {
  $1 = ($input.type == T_INT) ? 1 : 0;
}

%typecheck(SWIG_TYPECHECK_STRING) char * {
  $1 = ($input.type == T_STRING) ? 1 : 0;
}

%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *, SWIGTYPE &, SWIGTYPE [] {
  void *ptr;
  if (SWIG_ConvertPtr($input.u.object, (void **) &ptr, $1_descriptor, 0) == -1) {
    $1 = 0;
  } else {
    $1 = 1;
  }
}

%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE {
  void *ptr;
  if (SWIG_ConvertPtr($input.u.object, (void **) &ptr, $&1_descriptor, 0) == -1) {
    $1 = 0;
  } else {
    $1 = 1;
  }
}

%typecheck(SWIG_TYPECHECK_VOIDPTR) void * {
  void *ptr;
  if (SWIG_ConvertPtr($input.u.object, (void **) &ptr, 0, 0) == -1) {
    $1 = 0;
  } else {
    $1 = 1;
  }
}

/* ------------------------------------------------------------
 * Overloaded operator support
 * ------------------------------------------------------------ */

#ifdef __cplusplus
%rename("`+")      *::operator+;
%rename("`-")      *::operator-;
%rename("`*")      *::operator*;
%rename("`/")      *::operator/;
%rename("`%")      *::operator%;
%rename("`<<")     *::operator<<;
%rename("`>>")     *::operator>>;
%rename("`&")      *::operator&;
%rename("`|")      *::operator|;
%rename("`^")      *::operator^;
%rename("`~")      *::operator~;
%rename("`<")      *::operator<;
%rename("`>")      *::operator>;
%rename("`==")     *::operator==;

/* Special cases */
%rename("`()")     *::operator();

/* Ignored operators */
%ignorewarn("362:operator= ignored") operator=;
%ignorewarn("365:operator+= ignored") operator+=;
%ignorewarn("366:operator-= ignored") operator-=;
%ignorewarn("367:operator*= ignored") operator*=;
%ignorewarn("368:operator/= ignored") operator/=;
%ignorewarn("369:operator%= ignored") operator%=;
%ignorewarn("370:operator^= ignored") operator^=;
%ignorewarn("371:operator&= ignored") operator&=;
%ignorewarn("372:operator|= ignored") operator|=;
%ignorewarn("375:operator<<= ignored") operator<<=;
%ignorewarn("376:operator>>= ignored") operator>>=;
%ignorewarn("378:operator!= ignored") operator!=;
%ignorewarn("379:operator<= ignored") operator<=;
%ignorewarn("380:operator>= ignored") operator>=;
%ignorewarn("381:operator&& ignored") operator&&;
%ignorewarn("382:operator|| ignored") operator||;
%ignorewarn("383:operator++ ignored") operator++;
%ignorewarn("384:operator-- ignored") operator--;
%ignorewarn("386:operator->* ignored") operator->*;
%ignorewarn("389:operator[] ignored (consider using %extend)") operator[];
%ignorewarn("390:operator+() ignored") operator+();
%ignorewarn("390:operator+() const ignored") operator+() const;
%ignorewarn("391:operator-() ignored") operator-();
%ignorewarn("391:operator-() const ignored") operator-() const;

#endif

/* ------------------------------------------------------------
 * The start of the Pike initialization function
 * ------------------------------------------------------------ */

%init "swiginit.swg"

%init %{
#ifdef __cplusplus
extern "C"
#endif
PIKE_MODULE_EXIT {}

#ifdef __cplusplus
extern "C"
#endif
PIKE_MODULE_INIT
{
    struct program *pr;
    SWIG_InitializeModule(0);
%}

/* pike keywords */
/* please test and activate */
//%include "pikekw.swg"
Commit	Line	Data
920dae64 AT	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
	12	extern "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	/********************** Output Typemaps ***************************/
100
101	%typemap(out, pikedesc="tInt")
102	int, unsigned int,
103	short, unsigned short,
104	long, unsigned long,
105	char, signed char, unsigned char,
106	bool, enum SWIGTYPE
107	"push_int($1);";
108
109	%typemap(out, pikedesc="tInt") long long "push_int64($1);";
110	%typemap(out, pikedesc="tInt") unsigned long long "push_int64($1);";
111	%typemap(out, pikedesc="tFloat") float, double "push_float($1);";
112	%typemap(out, pikedesc="tStr") char * "push_text($1);";
113
114	/* Pointers, references, and arrays */
115	%typemap(out, pikedesc="tObj") SWIGTYPE, SWIGTYPE &, SWIGTYPE [] "push_object(SWIG_NewPointerObj((void ) $1, $1_descriptor, $owner));";
116
117	/* Void return value; don't push anything */
118	%typemap(out, pikedesc="tVoid") void "";
119
120	/* Dynamic casts */
121
122	%typemap(out) SWIGTYPE DYNAMIC, SWIGTYPE &DYNAMIC "/ FIXME */";
123
124	/* Member pointer */
125	%typemap(out) SWIGTYPE (CLASS::) "/ FIXME */";
126
127	/* Special typemap for character array return values */
128	%typemap(out, pikedesc="tStr") char [ANY], const char [ANY] "push_text($1);";
129
130	/* Primitive types--return by value */
131	%typemap(out, "tObj") SWIGTYPE
132	#ifdef __cplusplus
133	{
134	$&1_ltype resultptr;
135	resultptr = new $1_ltype(($1_ltype &) $1);
136	push_object(SWIG_NewPointerObj((void *) resultptr, $&1_descriptor, 1));
137	}
138	#else
139	{
140	$&1_ltype resultptr;
141	resultptr = ($&1_ltype) malloc(sizeof($1_type));
142	memmove(resultptr, &$1, sizeof($1_type));
143	push_object(SWIG_NewPointerObj((void *) resultptr, $&1_descriptor, 1));
144	}
145	#endif
146
147	/* References to primitive types. Return by value */
148
149	%typemap(out, pikedesc="tInt") const int &, const unsigned int &,
150	const short &, const unsigned short &,
151	const long &, const unsigned long &,
152	const char &, const signed char &, const unsigned char &,
153	const bool &,
154	const long long &, const unsigned long long &,
155	const enum SWIGTYPE & ($*1_ltype temp)
156	"push_int(*($1));";
157
158	%typemap(out, pikedesc="tFloat") const float &, const double & "push_float(*($1));";
159
160	/********************** Constant Typemaps ***************************/
161
162	%typemap(constant)
163	int, unsigned int,
164	short, unsigned short,
165	long, unsigned long,
166	signed char, unsigned char,
167	bool, enum SWIGTYPE,
168	long long, unsigned long long
169	"add_integer_constant(\"$symname\", $1, 0);";
170
171	%typemap(constant) char
172	"add_integer_constant(\"$symname\", '$1', 0);";
173
174	%typemap(constant) long long, unsigned long long
175	"add_integer_constant(\"$symname\", $1, 0);";
176
177	%typemap(constant) float, double
178	"add_float_constant(\"$symname\", $1, 0);";
179
180	%typemap(constant) char *
181	"add_string_constant(\"$symname\", \"$1\", 0);";
182
183	/* ------------------------------------------------------------
184	* String & length
185	* ------------------------------------------------------------ */
186
187	%typemap(in, pikedesc="tStr") (char *STRING, int LENGTH) {
188	if ($input.type != T_STRING)
189	Pike_error("Bad argument: Expected a string.\n");
190	$1 = ($1_ltype) STR0($input.u.string);
191	$2 = ($2_ltype) $input.u.string->length;
192	}
193
194	/* ------------------------------------------------------------
195	* ANSI C typemaps
196	* ------------------------------------------------------------ */
197
198	%typemap(in, pikedesc="tInt") size_t {
199	if ($input.type != T_INT)
200	Pike_error("Bad argument: Expected an integer.\n");
201	$1 = ($1_ltype) $input.u.integer;
202	}
203
204	%typemap(out) size_t = long;
205
206	/* ------------------------------------------------------------
207	* Typechecking rules
208	* ------------------------------------------------------------ */
209
210	%typecheck(SWIG_TYPECHECK_INTEGER)
211	int, short, long,
212	unsigned int, unsigned short, unsigned long,
213	signed char, unsigned char,
214	long long, unsigned long long,
215	const int &, const short &, const long &,
216	const unsigned int &, const unsigned short &, const unsigned long &,
217	const long long &, const unsigned long long &,
218	enum SWIGTYPE, enum SWIGTYPE &,
219	bool, const bool &
220	{
221	$1 = ($input.type == T_INT) ? 1 : 0;
222	}
223
224	%typecheck(SWIG_TYPECHECK_DOUBLE)
225	float, double,
226	const float &, const double &
227	{
228	$1 = (($input.type == T_FLOAT) \|\| ($input.type == T_INT)) ? 1 : 0;
229	}
230
231	%typecheck(SWIG_TYPECHECK_CHAR) char {
232	$1 = ($input.type == T_INT) ? 1 : 0;
233	}
234
235	%typecheck(SWIG_TYPECHECK_STRING) char * {
236	$1 = ($input.type == T_STRING) ? 1 : 0;
237	}
238
239	%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *, SWIGTYPE &, SWIGTYPE [] {
240	void *ptr;
241	if (SWIG_ConvertPtr($input.u.object, (void **) &ptr, $1_descriptor, 0) == -1) {
242	$1 = 0;
243	} else {
244	$1 = 1;
245	}
246	}
247
248	%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE {
249	void *ptr;
250	if (SWIG_ConvertPtr($input.u.object, (void **) &ptr, $&1_descriptor, 0) == -1) {
251	$1 = 0;
252	} else {
253	$1 = 1;
254	}
255	}
256
257	%typecheck(SWIG_TYPECHECK_VOIDPTR) void * {
258	void *ptr;
259	if (SWIG_ConvertPtr($input.u.object, (void **) &ptr, 0, 0) == -1) {
260	$1 = 0;
261	} else {
262	$1 = 1;
263	}
264	}
265
266	/* ------------------------------------------------------------
267	* Overloaded operator support
268	* ------------------------------------------------------------ */
269
270	#ifdef __cplusplus
271	%rename("`+") *::operator+;
272	%rename("`-") *::operator-;
273	%rename("`") ::operator*;
274	%rename("`/") *::operator/;
275	%rename("`%") *::operator%;
276	%rename("`<<") *::operator<<;
277	%rename("`>>") *::operator>>;
278	%rename("`&") *::operator&;
279	%rename("`\|") *::operator\|;
280	%rename("`^") *::operator^;
281	%rename("`~") *::operator~;
282	%rename("`<") *::operator<;
283	%rename("`>") *::operator>;
284	%rename("`==") *::operator==;
285
286	/* Special cases */
287	%rename("`()") *::operator();
288
289	/* Ignored operators */
290	%ignorewarn("362:operator= ignored") operator=;
291	%ignorewarn("365:operator+= ignored") operator+=;
292	%ignorewarn("366:operator-= ignored") operator-=;
293	%ignorewarn("367:operator= ignored") operator=;
294	%ignorewarn("368:operator/= ignored") operator/=;
295	%ignorewarn("369:operator%= ignored") operator%=;
296	%ignorewarn("370:operator^= ignored") operator^=;
297	%ignorewarn("371:operator&= ignored") operator&=;
298	%ignorewarn("372:operator\|= ignored") operator\|=;
299	%ignorewarn("375:operator<<= ignored") operator<<=;
300	%ignorewarn("376:operator>>= ignored") operator>>=;
301	%ignorewarn("378:operator!= ignored") operator!=;
302	%ignorewarn("379:operator<= ignored") operator<=;
303	%ignorewarn("380:operator>= ignored") operator>=;
304	%ignorewarn("381:operator&& ignored") operator&&;
305	%ignorewarn("382:operator\|\| ignored") operator\|\|;
306	%ignorewarn("383:operator++ ignored") operator++;
307	%ignorewarn("384:operator-- ignored") operator--;
308	%ignorewarn("386:operator->* ignored") operator->*;
309	%ignorewarn("389:operator[] ignored (consider using %extend)") operator[];
310	%ignorewarn("390:operator+() ignored") operator+();
311	%ignorewarn("390:operator+() const ignored") operator+() const;
312	%ignorewarn("391:operator-() ignored") operator-();
313	%ignorewarn("391:operator-() const ignored") operator-() const;
314
315	#endif
316
317	/* ------------------------------------------------------------
318	* The start of the Pike initialization function
319	* ------------------------------------------------------------ */
320
321	%init "swiginit.swg"
322
323	%init %{
324	#ifdef __cplusplus
325	extern "C"
326	#endif
327	PIKE_MODULE_EXIT {}
328
329	#ifdef __cplusplus
330	extern "C"
331	#endif
332	PIKE_MODULE_INIT
333	{
334	struct program *pr;
335	SWIG_InitializeModule(0);
336	%}
337
338	/* pike keywords */
339	/* please test and activate */
340	//%include "pikekw.swg"