1HEADmaster

1 files changed, 353 insertions, 0 deletions

diff --git a/devtools/swigwin-1.3.34/Lib/lua/luatypemaps.swg b/devtools/swigwin-1.3.34/Lib/lua/luatypemaps.swg
new file mode 100644
index 0000000..51f96b0
--- /dev/null
+++ b/devtools/swigwin-1.3.34/Lib/lua/luatypemaps.swg
@@ -0,0 +1,353 @@
+/* -----------------------------------------------------------------------------
+ * See the LICENSE file for information on copyright, usage and redistribution
+ * of SWIG, and the README file for authors - http://www.swig.org/release.html.
+ *
+ * luatypemaps.swg
+ *
+ * basic typemaps for Lua.
+ * ----------------------------------------------------------------------------- */
+
+/* -----------------------------------------------------------------------------
+ *                          standard typemaps
+ * ----------------------------------------------------------------------------- */
+/* NEW LANGUAGE NOTE:
+   the 'checkfn' param is something that I added for typemap(in)
+   it is an optional fn call to check the type of the lua object
+   the fn call must be of the form
+     int checkfn(lua_State *L, int index);
+   and return 1/0 depending upon if this is the correct type
+   For the typemap(out), an additional SWIG_arg parmeter must be incremented
+   to reflect the number of values returned (normally SWIG_arg++; will do)
+*/
+// numbers
+%typemap(in,checkfn="lua_isnumber") int,short,long,
+             unsigned int,unsigned short,unsigned long,
+             signed char,unsigned char,
+             float,double
+%{$1 = ($type)lua_tonumber(L, $input);%}
+
+%typemap(out) int,short,long,
+             unsigned int,unsigned short,unsigned long,
+             signed char,unsigned char,
+             float,double
+%{  lua_pushnumber(L, (lua_Number) $1); SWIG_arg++;%}
+
+// we must also provide typemaps for privitives by const reference:
+// given a function:
+//	int intbyref(const int& i);
+// SWIG assumes that this code will need a pointer to int to be passed in
+// (this might be ok for objects by const ref, but not for numeric primitives)
+// therefore we add a set of typemaps to fix this (for both in & out)
+%typemap(in,checkfn="lua_isnumber") const int&($basetype temp)
+%{ temp=($basetype)lua_tonumber(L,$input); $1=&temp;%}
+
+%typemap(out) const int&
+%{  lua_pushnumber(L, (lua_Number) *$1); SWIG_arg++;%}
+
+// for the other numbers we can just use an apply statement to cover them
+%apply const int & {const short&,const long&,
+             const unsigned int&,const unsigned short&,const unsigned long&,
+             const signed char&,const unsigned char&,
+             const float&,const double&};
+
+/* enums have to be handled slightly differently
+	VC++ .net will not allow a cast from lua_Number(double) to enum directly.
+*/
+%typemap(in,checkfn="lua_isnumber") enum SWIGTYPE
+%{$1 = ($type)(int)lua_tonumber(L, $input);%}
+
+%typemap(out) enum SWIGTYPE
+%{  lua_pushnumber(L, (lua_Number)(int)($1)); SWIG_arg++;%}
+
+// and const refs
+%typemap(in,checkfn="lua_isnumber") const enum SWIGTYPE &($basetype temp)
+%{ temp=($basetype)(int)lua_tonumber(L,$input); $1=&temp;%}
+%typemap(out) const enum SWIGTYPE &
+%{  lua_pushnumber(L, (lua_Number) *$1); SWIG_arg++;%}
+
+
+// boolean (which is a special type in lua)
+// note: lua_toboolean() returns 1 or 0
+// note: 1 & 0 are not booleans in lua, only true & false
+%typemap(in,checkfn="lua_isboolean") bool
+%{$1 = (lua_toboolean(L, $input)!=0);%}
+
+%typemap(out) bool
+%{  lua_pushboolean(L,(int)$1); SWIG_arg++;%}
+
+// for const bool&, SWIG treats this as a const bool* so we must dereference it
+%typemap(in,checkfn="lua_isboolean") const bool& (bool temp)
+%{temp=lua_toboolean(L, $input) ? true : false;
+  $1=&temp;%}
+
+%typemap(out) const bool&
+%{  lua_pushboolean(L,(int)*$1); SWIG_arg++;%}
+
+// strings (char* and char[])
+%typemap(in,checkfn="lua_isstring") const char*, char*
+%{$1 = ($ltype)lua_tostring(L, $input);%}
+
+%typemap(in,checkfn="lua_isstring") const char[ANY], char[ANY]
+%{$1 = ($ltype)lua_tostring(L, $input);%}
+
+%typemap(out) const char*, char*
+%{  lua_pushstring(L,(const char*)$1); SWIG_arg++;%}
+
+%typemap(out) const char[ANY], char[ANY]
+%{  lua_pushstring(L,(const char*)$1); SWIG_arg++;%}
+
+// char's
+// currently treating chars as small strings, not as numbers
+// (however signed & unsigned char's are numbers...)
+%typemap(in,checkfn="lua_isstring") char
+%{$1 = (lua_tostring(L, $input))[0];%}
+
+%typemap(out) char
+%{  lua_pushfstring(L,"%c",$1); SWIG_arg++;%}
+
+// by const ref
+%typemap(in,checkfn="lua_isstring") const char& (char temp)
+%{temp = (lua_tostring(L, $input))[0]; $1=&temp;%}
+
+%typemap(out) const char&
+%{  lua_pushfstring(L,"%c",*$1); SWIG_arg++;%}
+
+// pointers and references
+// under SWIG rules, it is ok, to have a pass in a lua nil,
+// it should be converted to a SWIG NULL.
+// This will only be allowed for pointers & arrays, not refs or by value
+// the checkfn lua_isuserdata will only work for userdata
+// the checkfn SWIG_isptrtype will work for both userdata and nil's
+%typemap(in,checkfn="SWIG_isptrtype") SWIGTYPE*,SWIGTYPE[]
+%{
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,$input,(void**)&$1,$descriptor,0))){
+    SWIG_fail_ptr("$symname",$argnum,$descriptor);
+  }
+%}
+
+%typemap(in,checkfn="lua_isuserdata") SWIGTYPE&
+%{
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,$input,(void**)&$1,$descriptor,0))){
+    SWIG_fail_ptr("$symname",$argnum,$descriptor);
+  }
+%}
+
+// out is simple
+%typemap(out) SWIGTYPE*,SWIGTYPE&
+%{SWIG_NewPointerObj(L,$1,$descriptor,$owner); SWIG_arg++; %}
+
+// dynamic casts
+// this uses the SWIG_TypeDynamicCast() which relies on RTTI to find out what the pointer really is
+// the we return it as the correct type
+%typemap(out) SWIGTYPE *DYNAMIC,
+              SWIGTYPE &DYNAMIC
+{
+  swig_type_info *ty = SWIG_TypeDynamicCast($1_descriptor, (void **) &$1);
+  SWIG_NewPointerObj(L,(void*)$1,ty,$owner); SWIG_arg++; 
+}
+
+
+// passing objects by value
+// SWIG_ConvertPtr wants an object pointer (the $&ltype argp)
+// then dereferences it to get the object
+%typemap(in,checkfn="lua_isuserdata") SWIGTYPE ($&ltype argp)
+%{
+   if (!SWIG_IsOK(SWIG_ConvertPtr(L,$input,(void**)&argp,$&descriptor,0))){
+     SWIG_fail_ptr("$symname",$argnum,$&descriptor);
+   }
+   $1 = *argp;
+%}
+
+// Also needed for object ptrs by const ref
+// eg const A* ref_pointer(A* const& a);
+// found in mixed_types.i
+%typemap(in,checkfn="lua_isuserdata") SWIGTYPE* const &($*ltype temp)
+%{temp=($*ltype)SWIG_MustGetPtr(L,$input,$*descriptor,0,$argnum,"$symname");
+$1=&temp;%}
+
+
+// Primitive types--return by value
+// must make a new object, copy the data & return the new object
+// Note: the brackets are {...} and not %{..%}, because we want them to be included in the wrapper
+// this is because typemap(out) does not support local variables, like in typemap(in) does
+// and we need the $&1_ltype resultptr; to be declared
+#ifdef __cplusplus
+%typemap(out) SWIGTYPE
+{
+  $&1_ltype resultptr = new $1_ltype(($1_ltype &) $1);
+  SWIG_NewPointerObj(L,(void *) resultptr,$&1_descriptor,1); SWIG_arg++;
+}
+#else
+%typemap(out) SWIGTYPE
+{
+  $&1_ltype resultptr;
+  resultptr = ($&1_ltype) malloc(sizeof($1_type));
+  memmove(resultptr, &$1, sizeof($1_type));
+  SWIG_NewPointerObj(L,(void *) resultptr,$&1_descriptor,1); SWIG_arg++;
+}
+#endif
+
+// member function pointer
+// a member fn ptr is not 4 bytes like a normal pointer, but 8 bytes (at least on mingw)
+// so the standard wrappering cannot be done
+// nor can you cast a member function pointer to a void* (obviously)
+// therefore a special wrappering functions SWIG_ConvertMember() & SWIG_NewMemberObj() were written
+#ifdef __cplusplus
+%typemap(in,checkfn="lua_isuserdata") SWIGTYPE (CLASS::*)
+%{
+  if (!SWIG_IsOK(SWIG_ConvertMember(L,$input,(void*)(&$1),sizeof($type),$descriptor)))
+    SWIG_fail_ptr("$symname",$argnum,$descriptor);
+%}
+
+%typemap(out) SWIGTYPE (CLASS::*)
+%{ 
+  SWIG_NewMemberObj(L,(void*)(&$1),sizeof($type),$descriptor); SWIG_arg++; 
+%}
+#endif
+
+
+// void (must be empty without the SWIG_arg++)
+%typemap(out) void "";
+
+/* void* is a special case
+A function void fn(void*) should take any kind of pointer as a parameter (just like C/C++ does)
+but if its an output, then it should be wrappered like any other SWIG object (using default typemap)
+*/
+%typemap(in,checkfn="SWIG_isptrtype") void*
+%{$1=($1_ltype)SWIG_MustGetPtr(L,$input,0,0,$argnum,"$symname");%}
+
+/* long long is another special case:
+as lua only supports one numeric type (lua_Number), we will just
+cast it to that & accept the loss of precision.
+An alternative solution would be a long long struct or class
+with the relevant operators.
+*/
+%apply long {long long, signed long long, unsigned long long};
+%apply const long& {const long long&, const signed long long&, const unsigned long long&};
+
+/* It is possible to also pass a lua_State* into a function, so
+void fn(int a, float b, lua_State* s) is wrappable as
+> fn(1,4.3) -- note: the state is implicitly passed in
+*/
+%typemap(in, numinputs=0) lua_State* 
+%{$1 = L;%}
+
+
+
+/* -----------------------------------------------------------------------------
+ *                          typecheck rules
+ * ----------------------------------------------------------------------------- */
+/* These are needed for the overloaded functions
+These define the detection routines which will spot what
+parmeters match which function
+*/
+
+// unfortunately lua only considers one type of number
+// so all numbers (int,float,double) match
+// you could add an advanced fn to get type & check if its integral
+%typecheck(SWIG_TYPECHECK_INTEGER)
+	 int, short, long,
+ 	 unsigned int, unsigned short, unsigned long,
+	 signed char, unsigned char,
+	 long long, unsigned long long, signed long long,
+	 const int &, const short &, const long &,
+ 	 const unsigned int &, const unsigned short &, const unsigned long &,
+	 const signed char&, const unsigned char&,
+	 const long long &, const unsigned long long &,
+	 enum SWIGTYPE,	const enum SWIGTYPE&,
+	 float, double, const float &, const double&
+{
+  $1 = lua_isnumber(L,$input);
+}
+
+%typecheck(SWIG_TYPECHECK_BOOL)
+    bool, const bool &
+{
+  $1 = lua_isboolean(L,$input);
+}
+
+// special check for a char (string of length 1)
+%typecheck(SWIG_TYPECHECK_CHAR) char, const char& {
+  $1 = lua_isstring(L,$input) && (lua_strlen(L,$input)==1);
+}
+
+%typecheck(SWIG_TYPECHECK_STRING) char *, char[] {
+  $1 = lua_isstring(L,$input);
+}
+
+%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *, SWIGTYPE [] {
+  void *ptr;
+  if (SWIG_isptrtype(L,$input)==0 || SWIG_ConvertPtr(L,$input, (void **) &ptr, $1_descriptor, 0)) {
+    $1 = 0;
+  } else {
+    $1 = 1;
+  }
+}
+
+%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE & {
+  void *ptr;
+  if (lua_isuserdata(L,$input)==0 || SWIG_ConvertPtr(L,$input, (void **) &ptr, $1_descriptor, 0)) {
+    $1 = 0;
+  } else {
+    $1 = 1;
+  }
+}
+
+%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE {
+  void *ptr;
+  if (lua_isuserdata(L,$input)==0 || SWIG_ConvertPtr(L,$input, (void **) &ptr, $&1_descriptor, 0)) {
+    $1 = 0;
+  } else {
+    $1 = 1;
+  }
+}
+
+%typecheck(SWIG_TYPECHECK_VOIDPTR) void * {
+  void *ptr;
+  if (SWIG_isptrtype(L,$input)==0 || SWIG_ConvertPtr(L,$input, (void **) &ptr, 0, 0)) {
+    $1 = 0;
+  } else {
+    $1 = 1;
+  }
+}
+
+// Also needed for object ptrs by const ref
+// eg const A* ref_pointer(A* const& a);
+// found in mixed_types.i
+%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE* const &
+{
+  void *ptr;
+  if (lua_isuserdata(L,$input)==0 || SWIG_ConvertPtr(L,$input, (void **) &ptr, $*descriptor, 0)) {
+    $1 = 0;
+  } else {
+    $1 = 1;
+  }
+}
+
+/* -----------------------------------------------------------------------------
+ *                          Others
+ * ----------------------------------------------------------------------------- */
+
+// size_t (which is just a unsigned long)
+%apply unsigned long { size_t };
+%apply const unsigned long & { const size_t & };
+
+
+/* -----------------------------------------------------------------------------
+ *                          Specials
+ * ----------------------------------------------------------------------------- */
+// swig::LANGUAGE_OBJ was added to allow containers of native objects
+// however its rather difficult to do this in lua, as you cannot hold pointers
+// to native objects (they are held in the interpreter)
+// therefore for now: just ignoring this feature
+#ifdef __cplusplus
+%ignore swig::LANGUAGE_OBJ;
+
+//%inline %{
+%{
+namespace swig {
+typedef struct{} LANGUAGE_OBJ;
+}
+%}
+
+#endif // __cplusplus