Lib/lua/lua.swg

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