Mercurial > mm7

comparison lib/swig/swigwin-2.0.11/Lib/lua/lua.swg @ 1899:b3009adc0e2f

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Adding swig, gitignore, hgignore
author Nomad
date Mon, 21 Oct 2013 10:42:27 +0200
parents
children
comparison
equal deleted inserted replaced
1867:eb580660bbbb 1899:b3009adc0e2f
1 /* -----------------------------------------------------------------------------
2 * lua.swg
3 *
4 * SWIG Configuration File for Lua.
5 * This file is parsed by SWIG before reading any other interface file.
6 * ----------------------------------------------------------------------------- */
7
8 /* -----------------------------------------------------------------------------
9 * includes
10 * ----------------------------------------------------------------------------- */
11
12 %include <luatypemaps.swg> /* The typemaps */
13 %include <luaruntime.swg> /* The runtime stuff */
14
15 //%include <typemaps/swigmacros.swg>
16 /* -----------------------------------------------------------------------------
17 * constants typemaps
18 * ----------------------------------------------------------------------------- */
19 // this basically adds to a table of constants
20 %typemap(consttab) int, unsigned int, short, unsigned short, long, unsigned long, unsigned char, signed char, bool, enum SWIGTYPE
21 {SWIG_LUA_CONSTTAB_INT("$symname", $value)}
22
23 %typemap(consttab) float, double
24 {SWIG_LUA_CONSTTAB_FLOAT("$symname", $value)}
25
26 %typemap(consttab) long long, unsigned long long, signed long long
27 {SWIG_LUA_CONSTTAB_FLOAT("$symname", $value)}
28
29 %typemap(consttab) const long long&, const unsigned long long&, const signed long long&
30 {SWIG_LUA_CONSTTAB_FLOAT("$symname", *$value)}
31
32 %typemap(consttab) char *, const char *, char [], const char []
33 {SWIG_LUA_CONSTTAB_STRING("$symname", $value)}
34
35 // note: char is treated as a seperate special type
36 // signed char & unsigned char are numbers
37 %typemap(consttab) char
38 {SWIG_LUA_CONSTTAB_CHAR("$symname", $value)}
39
40 %typemap(consttab) long long, unsigned long long
41 {SWIG_LUA_CONSTTAB_STRING("$symname", "$value")}
42
43 %typemap(consttab) SWIGTYPE *, SWIGTYPE *const, SWIGTYPE &, SWIGTYPE []
44 { SWIG_LUA_POINTER, (char *)"$symname", 0, 0, (void *)$value, &$1_descriptor}
45
46 // member function pointers
47 %typemap(consttab) SWIGTYPE (CLASS::*)
48 { SWIG_LUA_BINARY, (char *)"$symname", sizeof($type), 0, (void *)&$value, &$1_descriptor}
49
50
51 /* -----------------------------------------------------------------------------
52 * Overloaded operator support
53 * ----------------------------------------------------------------------------- */
54 // lua calls the + operator '__add'
55 // python likes to call it '__add__'
56 // Assuming most SWIGers will probably use the __add__ if they extend their classes
57 // we have two sets of renames
58 // one to rename the operator+() to __add()
59 // (this lets SWIG rename the operator overloads)
60 // another is to rename __add__() to __add()
61 // (this means that people who wrote SWIG code to do that add will also work)
62
63 #ifdef __cplusplus
64 // this is extra renaming for lua
65 // not all operators are supported, so only those that are, are listed
66 %rename(__add) *::operator+;
67 %rename(__sub) *::operator-;
68 %rename(__mul) *::operator*;
69 %rename(__div) *::operator/;
70 %rename(__unm) *::operator-();
71 %rename(__unm) *::operator-() const;
72
73 %rename(__eq) *::operator==;
74 %ignore *::operator!=; // note: Lua does not have a notequal operator
75 // it just uses 'not (a==b)'
76 %rename(__lt) *::operator<;
77 %ignore *::operator>; // ditto less than vs greater than
78 %rename(__le) *::operator<=;
79 %ignore *::operator>=; // ditto less than vs greater than
80 %ignore *::operator!; // does not support not
81
82 %rename(__call) *::operator(); // the fn call operator
83
84 // lua does not support overloading of:
85 // logical/bitwise operators
86 // assign operator
87 // +=,-=,*=, etc
88 // therefore ignoring them for now
89 // it also doesn't support non class operators
90 // eg friends or XX operator+(XX,XX)
91 // also ignoring
92 // note: some of these might be better to rename, but not doing that for now
93 %ignore *::operator&&; %ignore operator&&;
94 %ignore *::operator||; %ignore operator||;
95 %ignore *::operator+=;
96 %ignore *::operator-=;
97 %ignore *::operator*=;
98 %ignore *::operator/=;
99 %ignore *::operator%=;
100 %ignore *::operator++; %ignore *::operator--;
101
102 %ignore *::operator=; // note: this might be better to rename to assign() or similar
103
104 %ignore operator+;
105 %ignore operator-;
106 %ignore operator*;
107 %ignore operator/;
108 %ignore operator%;
109 %ignore operator[];
110 %ignore operator>; %ignore operator>=;
111 %ignore operator<; %ignore operator<=;
112 %ignore operator==; %ignore operator!=;
113
114
115 // renaming the python operators to be compatible with lua
116 // this means that if a developer has written a fn __add__()
117 // it will be used for the lua +
118 %rename(__add) *::__add__;
119 %rename(__sub) *::__sub__;
120 %rename(__mul) *::__mul__;
121 %rename(__div) *::__div__;
122 %rename(__unm) *::__neg__; // lua calls unary minus,'unm' not 'neg'
123 %rename(__tostring) *::__str__; // both map to __tostring
124 %rename(__tostring) *::__repr__; // both map to __tostring
125
126
127 %rename(__pow) *::__pow__; // lua power '^' operator
128 %rename(__concat) *::__concat__; // lua concat '..' operator
129 %rename(__eq) *::__eq__;
130 %rename(__lt) *::__lt__;
131 %rename(__le) *::__le__;
132 %rename(__call) *::__call__; // the fn call operator()
133
134 // the [] operator has two parts, the get & the set
135 %rename(__getitem) *::__getitem__; // the v=X[i] (get operator)
136 %rename(__setitem) *::__setitem__; // the X[i]=v (set operator)
137
138
139 #endif
140
141
142 /* ------------------------------------------------------------
143 * Exceptions
144 * ------------------------------------------------------------ */
145 /* Confession: I don't really like C++ exceptions
146 The python/lua ones are great, but C++ ones I don't like
147 (mainly because I cannot get the stack trace out of it)
148 Therefore I have not bothered to try doing much in this
149
150 Therefore currently its just enough to get a few test cases running ok
151
152 note: if you wish to throw anything related to std::exception
153 use %include <std_except.i> instead
154 */
155
156 // number as number+error
157 %typemap(throws) int,unsigned int,signed int,
158 long,unsigned long,signed long,
159 short,unsigned short,signed short,
160 float,double,
161 long long,unsigned long long,
162 unsigned char, signed char,
163 int&,unsigned int&,signed int&,
164 long&,unsigned long&,signed long&,
165 short&,unsigned short&,signed short&,
166 float&,double&,
167 long long&,unsigned long long&,
168 unsigned char&, signed char&
169 %{lua_pushnumber(L,(lua_Number)$1);SWIG_fail; %}
170
171 %typemap(throws) bool,bool&
172 %{lua_pushboolean(L,(int)($1==true));SWIG_fail; %}
173
174 // enum as number+error
175 %typemap(throws) enum SWIGTYPE
176 %{lua_pushnumber(L,(lua_Number)(int)$1);SWIG_fail; %}
177
178 // strings are just sent as errors
179 %typemap(throws) char *, const char *
180 %{lua_pushstring(L,$1);SWIG_fail;%}
181
182 // char is changed to a string
183 %typemap(throws) char
184 %{lua_pushfstring(L,"%c",$1);SWIG_fail;%}
185
186 /*
187 Throwing object is a serious problem:
188 Assuming some code throws a 'FooBar'
189 There are a few options:
190 - return a pointer to it: but its unclear how long this will last for.
191 - return a copy of it: but not all objects are copyable
192 (see exception_partial_info in the test suite for a case where you cannot do this)
193 - convert to a string & throw that
194 it's not so useful, but it works (this is more lua like).
195 The third option (though not nice) is used
196 For a more useful solution: see std_except for more details
197 */
198
199 // basic typemap for structs, classes, pointers & references
200 // convert to string and error
201 %typemap(throws) SWIGTYPE
202 %{(void)$1; /* ignore it */
203 lua_pushfstring(L,"object exception:%s",SWIG_TypePrettyName($1_descriptor));
204 SWIG_fail;%}
205
206 // code to make a copy of the object and return this
207 // if you have a function which throws a FooBar & you want SWIG to return a copy of the object as its error
208 // then use one of the below
209 // %apply SWIGTYPE EXCEPTION_BY_VAL {FooBar};
210 // %apply SWIGTYPE& EXCEPTION_BY_VAL {FooBar&}; // note: need & twice
211 %typemap(throws) SWIGTYPE EXCEPTION_BY_VAL
212 %{SWIG_NewPointerObj(L,(void *)new $1_ltype(($1_ltype &) $1),$&1_descriptor,1);
213 SWIG_fail;%}
214
215 // similar for object reference
216 // note: swig typemaps seem a little confused around here, therefore we use $basetype
217 %typemap(throws) SWIGTYPE& EXCEPTION_BY_VAL
218 %{SWIG_NewPointerObj(L,(void *)new $basetype($1),$1_descriptor,1);
219 SWIG_fail;%}
220
221
222 // note: no support for object pointers
223 // its not clear how long the pointer is valid for, therefore not supporting it
224
225 /* -----------------------------------------------------------------------------
226 * extras
227 * ----------------------------------------------------------------------------- */
228 // this %define is to allow insertion of lua source code into the wrapper file
229 #define %luacode %insert("luacode")
230
231
232 /* ------------------------------ end lua.swg ------------------------------ */