--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/lib/swig/swigwin-2.0.11/Lib/lua/lua.swg	Mon Oct 21 10:42:27 2013 +0200
@@ -0,0 +1,232 @@
+/* -----------------------------------------------------------------------------
+ * lua.swg
+ *
+ * SWIG Configuration File for Lua.
+ * This file is parsed by SWIG before reading any other interface file.
+ * ----------------------------------------------------------------------------- */
+
+/* -----------------------------------------------------------------------------
+ *                          includes
+ * ----------------------------------------------------------------------------- */
+
+%include <luatypemaps.swg>          /* The typemaps */
+%include <luaruntime.swg>          /* The runtime stuff */
+
+//%include <typemaps/swigmacros.swg>
+/* -----------------------------------------------------------------------------
+ *                          constants typemaps
+ * ----------------------------------------------------------------------------- */
+// this basically adds to a table of constants
+%typemap(consttab) int, unsigned int, short, unsigned short, long, unsigned long, unsigned char, signed char, bool, enum SWIGTYPE
+       {SWIG_LUA_CONSTTAB_INT("$symname", $value)}
+
+%typemap(consttab) float, double
+       {SWIG_LUA_CONSTTAB_FLOAT("$symname", $value)}
+
+%typemap(consttab) long long, unsigned long long, signed long long
+       {SWIG_LUA_CONSTTAB_FLOAT("$symname", $value)}
+
+%typemap(consttab) const long long&, const unsigned long long&, const signed long long&
+       {SWIG_LUA_CONSTTAB_FLOAT("$symname", *$value)}
+
+%typemap(consttab) char *, const char *, char [], const char []
+       {SWIG_LUA_CONSTTAB_STRING("$symname", $value)}
+
+// note: char is treated as a seperate special type
+// signed char & unsigned char are numbers
+%typemap(consttab) char
+       {SWIG_LUA_CONSTTAB_CHAR("$symname", $value)}
+
+%typemap(consttab) long long, unsigned long long
+       {SWIG_LUA_CONSTTAB_STRING("$symname", "$value")}
+
+%typemap(consttab) SWIGTYPE *, SWIGTYPE *const, SWIGTYPE &, SWIGTYPE []
+       { SWIG_LUA_POINTER, (char *)"$symname", 0, 0, (void *)$value, &$1_descriptor}
+
+// member function pointers
+%typemap(consttab) SWIGTYPE (CLASS::*)
+       { SWIG_LUA_BINARY,  (char *)"$symname", sizeof($type), 0, (void *)&$value, &$1_descriptor}
+
+
+/* -----------------------------------------------------------------------------
+ *                          Overloaded operator support
+ * ----------------------------------------------------------------------------- */
+// lua calls the + operator '__add'
+// python likes to call it '__add__'
+// Assuming most SWIGers will probably use the __add__ if they extend their classes
+// we have two sets of renames
+// one to rename the operator+() to __add()
+//	(this lets SWIG rename the operator overloads)
+// another is to rename __add__() to __add()
+//	(this means that people who wrote SWIG code to do that add will also work)
+
+#ifdef __cplusplus
+// this is extra renaming for lua
+// not all operators are supported, so only those that are, are listed
+%rename(__add)			*::operator+;
+%rename(__sub)			*::operator-;
+%rename(__mul)			*::operator*;
+%rename(__div)			*::operator/;
+%rename(__unm)      *::operator-();
+%rename(__unm)      *::operator-() const;
+
+%rename(__eq)			*::operator==;	
+%ignore *::operator!=;      // note: Lua does not have a notequal operator
+						// it just uses 'not (a==b)'
+%rename(__lt)			*::operator<;
+%ignore *::operator>;   	// ditto less than vs greater than
+%rename(__le)			*::operator<=;	
+%ignore *::operator>=;  // ditto less than vs greater than
+%ignore *::operator!;  // does not support not
+
+%rename(__call)			*::operator();	// the fn call operator
+
+// lua does not support overloading of:
+// 	logical/bitwise operators
+// 	assign operator
+// 	+=,-=,*=, etc
+// therefore ignoring them for now
+// it also doesn't support non class operators
+// eg friends or XX operator+(XX,XX)
+// also ignoring
+// note: some of these might be better to rename, but not doing that for now
+%ignore *::operator&&;	%ignore operator&&;
+%ignore *::operator||;	%ignore operator||;
+%ignore *::operator+=;
+%ignore *::operator-=;
+%ignore *::operator*=;
+%ignore *::operator/=;
+%ignore *::operator%=;
+%ignore *::operator++;	%ignore *::operator--;
+
+%ignore *::operator=;	// note: this might be better to rename to assign() or similar
+
+%ignore operator+;
+%ignore operator-;
+%ignore operator*;
+%ignore operator/;
+%ignore operator%;
+%ignore operator[];
+%ignore operator>;	%ignore operator>=;	
+%ignore operator<;	%ignore operator<=;
+%ignore operator==;	%ignore operator!=;
+
+
+// renaming the python operators to be compatible with lua
+// this means that if a developer has written a fn __add__()
+// it will be used for the lua +
+%rename(__add)			*::__add__;
+%rename(__sub)			*::__sub__;
+%rename(__mul)			*::__mul__;
+%rename(__div)			*::__div__;
+%rename(__unm)			*::__neg__;		// lua calls unary minus,'unm' not 'neg'
+%rename(__tostring)		*::__str__;		// both map to __tostring
+%rename(__tostring)		*::__repr__;	// both map to __tostring
+
+
+%rename(__pow)			*::__pow__;		// lua power '^' operator
+%rename(__concat)		*::__concat__;  // lua concat '..' operator
+%rename(__eq)			*::__eq__;
+%rename(__lt)			*::__lt__;
+%rename(__le)			*::__le__;
+%rename(__call)			*::__call__;	// the fn call operator()
+
+// the [] operator has two parts, the get & the set
+%rename(__getitem)			*::__getitem__;	// the v=X[i] (get operator)
+%rename(__setitem)			*::__setitem__;	// the X[i]=v (set operator)
+
+
+#endif
+
+
+/* ------------------------------------------------------------
+ *                              Exceptions
+ * ------------------------------------------------------------ */
+/* Confession: I don't really like C++ exceptions
+The python/lua ones are great, but C++ ones I don't like
+(mainly because I cannot get the stack trace out of it)
+Therefore I have not bothered to try doing much in this
+
+Therefore currently its just enough to get a few test cases running ok
+
+note: if you wish to throw anything related to std::exception
+use %include <std_except.i> instead
+*/
+
+// number as number+error
+%typemap(throws) int,unsigned int,signed int,
+				long,unsigned long,signed long,
+				short,unsigned short,signed short,
+				float,double,
+				long long,unsigned long long,
+				unsigned char, signed char,
+                int&,unsigned int&,signed int&,
+				long&,unsigned long&,signed long&,
+				short&,unsigned short&,signed short&,
+				float&,double&,
+				long long&,unsigned long long&,
+				unsigned char&, signed char&
+%{lua_pushnumber(L,(lua_Number)$1);SWIG_fail; %}
+
+%typemap(throws) bool,bool& 
+%{lua_pushboolean(L,(int)($1==true));SWIG_fail; %}
+
+// enum as number+error
+%typemap(throws) enum SWIGTYPE
+%{lua_pushnumber(L,(lua_Number)(int)$1);SWIG_fail; %}
+
+// strings are just sent as errors
+%typemap(throws) char *, const char *
+%{lua_pushstring(L,$1);SWIG_fail;%}
+
+// char is changed to a string
+%typemap(throws) char
+%{lua_pushfstring(L,"%c",$1);SWIG_fail;%}
+
+/*
+Throwing object is a serious problem:
+Assuming some code throws a 'FooBar'
+There are a few options:
+- return a pointer to it: but its unclear how long this will last for.
+- return a copy of it: but not all objects are copyable
+	(see exception_partial_info in the test suite for a case where you cannot do this)
+- convert to a string & throw that
+	it's not so useful, but it works (this is more lua like).
+The third option (though not nice) is used
+For a more useful solution: see std_except for more details
+*/
+
+// basic typemap for structs, classes, pointers & references
+// convert to string and error
+%typemap(throws) SWIGTYPE
+%{(void)$1; /* ignore it */
+lua_pushfstring(L,"object exception:%s",SWIG_TypePrettyName($1_descriptor));
+SWIG_fail;%}
+
+// code to make a copy of the object and return this
+// if you have a function which throws a FooBar & you want SWIG to return a copy of the object as its error
+// then use one of the below
+//	%apply SWIGTYPE EXCEPTION_BY_VAL {FooBar};
+//	%apply SWIGTYPE& EXCEPTION_BY_VAL {FooBar&}; // note: need & twice
+%typemap(throws) SWIGTYPE EXCEPTION_BY_VAL
+%{SWIG_NewPointerObj(L,(void *)new $1_ltype(($1_ltype &) $1),$&1_descriptor,1);
+SWIG_fail;%}
+
+// similar for object reference
+// note: swig typemaps seem a little confused around here, therefore we use $basetype
+%typemap(throws) SWIGTYPE& EXCEPTION_BY_VAL
+%{SWIG_NewPointerObj(L,(void *)new $basetype($1),$1_descriptor,1);
+SWIG_fail;%}
+
+
+// note: no support for object pointers
+// its not clear how long the pointer is valid for, therefore not supporting it
+
+/* -----------------------------------------------------------------------------
+ *                          extras
+ * ----------------------------------------------------------------------------- */
+// this %define is to allow insertion of lua source code into the wrapper file
+#define %luacode  %insert("luacode")
+
+
+/* ------------------------------ end lua.swg  ------------------------------ */