candle 0.0.1

data/lib/candle/generators/lua/wax/lib/wax_gc.h

@@ -0,0 +1,20 @@
+//
+//  wax_garbage_collection.h
+//  WaxTests
+//
+//  Created by Corey Johnson on 2/23/10.
+//  Copyright 2010 Probably Interactive. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+
+@interface wax_gc : NSObject {
+
+}
+
++ (void)start;
++ (void)stop;
++ (void)cleanupUnusedObject;
+
+@end

data/lib/candle/generators/lua/wax/lib/wax_gc.m

@@ -0,0 +1,56 @@
+//
+//  wax_garbage_collection.m
+//  WaxTests
+//
+//  Created by Corey Johnson on 2/23/10.
+//  Copyright 2010 Probably Interactive. All rights reserved.
+//
+
+#import "wax_gc.h"
+
+#import "lua.h"
+#import "lauxlib.h"
+
+#import "wax.h"
+#import "wax_instance.h"
+#import "wax_helpers.h"
+
+#define WAX_GC_TIMEOUT 1
+
+@implementation wax_gc
+
+static NSTimer* timer = nil;
+
++ (void)start {
+    [timer invalidate];
+    timer = [NSTimer scheduledTimerWithTimeInterval:WAX_GC_TIMEOUT target:self selector:@selector(cleanupUnusedObject) userInfo:nil repeats:YES];
+}
+
++ (void)stop {
+    [timer invalidate];
+    timer = nil;
+}
+
++ (void)cleanupUnusedObject {   
+    lua_State *L = wax_currentLuaState();
+    BEGIN_STACK_MODIFY(L)
+    
+    wax_instance_pushStrongUserdataTable(L);
+
+    lua_pushnil(L);  // first key
+    while (lua_next(L, -2)) {
+        wax_instance_userdata *instanceUserdata = (wax_instance_userdata *)luaL_checkudata(L, -1, WAX_INSTANCE_METATABLE_NAME);
+        lua_pop(L, 1); // pops the value, keeps the key
+            
+        if (!instanceUserdata->isClass && !instanceUserdata->isSuper && [instanceUserdata->instance retainCount] <= 1) {
+            lua_pushvalue(L, -1);
+            lua_pushnil(L);
+            lua_rawset(L, -4); // Clear it!
+        }        
+    }
+
+        
+    END_STACK_MODIFY(L, 0);
+}
+
+@end

data/lib/candle/generators/lua/wax/lib/wax_helpers.h

@@ -0,0 +1,102 @@
+//
+//  wax_helpers.h
+//  Lua
+//
+//  Created by ProbablyInteractive on 5/18/09.
+//  Copyright 2009 Probably Interactive. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import <objc/runtime.h>
+#import <objc/message.h>
+
+#import "wax_instance.h"
+
+#import "lua.h"
+
+//#define _C_ATOM     '%'
+//#define _C_VECTOR   '!'
+//#define _C_CONST    'r'
+
+// ENCODINGS CAN BE FOUND AT http://developer.apple.com/documentation/Cocoa/Conceptual/ObjCRuntimeGuide/Articles/ocrtTypeEncodings.html
+#define WAX_TYPE_CHAR _C_CHR
+#define WAX_TYPE_INT _C_INT
+#define WAX_TYPE_SHORT _C_SHT
+#define WAX_TYPE_UNSIGNED_CHAR _C_UCHR
+#define WAX_TYPE_UNSIGNED_INT _C_UINT
+#define WAX_TYPE_UNSIGNED_SHORT _C_USHT
+
+#define WAX_TYPE_LONG _C_LNG
+#define WAX_TYPE_LONG_LONG _C_LNG_LNG
+#define WAX_TYPE_UNSIGNED_LONG _C_ULNG
+#define WAX_TYPE_UNSIGNED_LONG_LONG _C_ULNG_LNG
+#define WAX_TYPE_FLOAT _C_FLT
+#define WAX_TYPE_DOUBLE _C_DBL
+
+#define WAX_TYPE_C99_BOOL _C_BOOL
+
+#define WAX_TYPE_STRING _C_CHARPTR
+#define WAX_TYPE_VOID _C_VOID
+#define WAX_TYPE_ARRAY _C_ARY_B
+#define WAX_TYPE_ARRAY_END _C_ARY_E
+#define WAX_TYPE_BITFIELD _C_BFLD
+#define WAX_TYPE_ID _C_ID
+#define WAX_TYPE_CLASS _C_CLASS
+#define WAX_TYPE_SELECTOR _C_SEL
+#define WAX_TYPE_STRUCT _C_STRUCT_B
+#define WAX_TYPE_STRUCT_END _C_STRUCT_E
+#define WAX_TYPE_UNION _C_UNION_B
+#define WAX_TYPE_UNION_END _C_UNION_E
+#define WAX_TYPE_POINTER _C_PTR
+#define WAX_TYPE_UNKNOWN _C_UNDEF
+
+#define WAX_PROTOCOL_TYPE_CONST 'r'
+#define WAX_PROTOCOL_TYPE_IN 'n'
+#define WAX_PROTOCOL_TYPE_INOUT 'N'
+#define WAX_PROTOCOL_TYPE_OUT 'o'
+#define WAX_PROTOCOL_TYPE_BYCOPY 'O'
+#define WAX_PROTOCOL_TYPE_BYREF 'R'
+#define WAX_PROTOCOL_TYPE_ONEWAY 'V'
+
+#define BEGIN_STACK_MODIFY(L) int __startStackIndex = lua_gettop((L));
+
+#define END_STACK_MODIFY(L, i) while(lua_gettop((L)) > (__startStackIndex + (i))) lua_remove((L), __startStackIndex + 1);
+
+#ifndef LOG_FLAGS
+    #define LOG_FLAGS (LOG_FATAL | LOG_ERROR | LOG_DEBUG)
+#endif
+
+#define LOG_DEBUG	1 << 0
+#define LOG_ERROR	1 << 1
+#define LOG_FATAL	1 << 2
+
+#define LOG_GC		1 << 5
+#define LOG_NETWORK	1 << 6
+
+// Debug Helpers
+void wax_printStack(lua_State *L);
+void wax_printStackAt(lua_State *L, int i);
+void wax_printTable(lua_State *L, int t);
+void wax_log(int flag, NSString *format, ...);
+int wax_getStackTrace(lua_State *L);
+
+// Convertion Helpers
+int wax_fromObjc(lua_State *L, const char *typeDescription, void *buffer);
+void wax_fromInstance(lua_State *L, id instance);
+void wax_fromStruct(lua_State *L, const char *typeDescription, void *buffer);
+    
+void *wax_copyToObjc(lua_State *L, const char *typeDescription, int stackIndex, int *outsize);
+
+// Misc Helpers
+void wax_selectorsForName(const char *methodName, SEL selectors[2]);
+BOOL wax_selectorForInstance(wax_instance_userdata *instanceUserdata, SEL* foundSelectors, const char *methodName, BOOL forceInstanceCheck);
+void wax_pushMethodNameFromSelector(lua_State *L, SEL selector);
+BOOL wax_isInitMethod(const char *methodName);
+
+const char *wax_removeProtocolEncodings(const char *type_descriptions);
+
+int wax_sizeOfTypeDescription(const char *full_type_description);
+int wax_simplifyTypeDescription(const char *in, char *out);
+
+int wax_errorFunction(lua_State *L);
+int wax_pcall(lua_State *L, int argumentCount, int returnCount);

data/lib/candle/generators/lua/wax/lib/wax_helpers.m

@@ -0,0 +1,870 @@
+//
+//  wax_helpers.m
+//  Lua
+//
+//  Created by ProbablyInteractive on 5/18/09.
+//  Copyright 2009 Probably Interactive. All rights reserved.
+//
+
+#import "wax_helpers.h"
+#import "wax_instance.h"
+#import "wax_struct.h"
+#import "lauxlib.h"
+
+@interface WaxFunction : NSObject {}
+@end
+
+@implementation WaxFunction // Used to pass lua fuctions around
+@end
+
+void wax_printStack(lua_State *L) {
+    int i;
+    int top = lua_gettop(L);
+    
+    for (i = 1; i <= top; i++) {        
+        printf("%d: ", i);
+        wax_printStackAt(L, i);
+        printf("\n");
+    }
+    
+    printf("\n");
+}
+
+void wax_printStackAt(lua_State *L, int i) {
+    int t = lua_type(L, i);
+    printf("(%s) ", lua_typename(L, t));
+    
+    switch (t) {
+        case LUA_TSTRING:
+            printf("'%s'", lua_tostring(L, i));
+            break;
+        case LUA_TBOOLEAN:
+            printf(lua_toboolean(L, i) ? "true" : "false");
+            break;
+        case LUA_TNUMBER:
+            printf("'%g'", lua_tonumber(L, i));
+            break;
+        default:
+            printf("%p", lua_topointer(L, i));
+            break;
+    }
+}
+
+void wax_printTable(lua_State *L, int t) {
+    // table is in the stack at index 't'
+    
+    if (t < 0) t = lua_gettop(L) + t + 1; // if t is negative, we need to normalize
+	if (t <= 0 || t > lua_gettop(L)) {
+		printf("%d is not within stack boundries.\n", t);
+		return;
+	}
+	else if (!lua_istable(L, t)) {
+		printf("Object at stack index %d is not a table.\n", t);
+		return;
+	}
+
+	lua_pushnil(L);  // first key
+    while (lua_next(L, t) != 0) {
+        wax_printStackAt(L, -2);
+        printf(" : ");
+        wax_printStackAt(L, -1);
+        printf("\n");
+
+        lua_pop(L, 1); // remove 'value'; keeps 'key' for next iteration
+    }
+}
+
+void wax_log(int flag, NSString *format, ...) {
+    if (flag & LOG_FLAGS) {
+        va_list args;
+        va_start(args, format);
+        NSString *output = [[[NSString alloc] initWithFormat:format arguments:args] autorelease];
+        printf("%s\n", [output UTF8String]);
+        va_end(args);
+    }
+}
+
+int wax_getStackTrace(lua_State *L) {
+    lua_getfield(L, LUA_GLOBALSINDEX, "debug");
+    if (!lua_istable(L, -1)) {
+        lua_pop(L, 1);
+        return 1;
+    }
+    
+    lua_getfield(L, -1, "traceback");
+    if (!lua_isfunction(L, -1)) {
+        lua_pop(L, 2);
+        return 1;
+    }    
+    lua_remove(L, -2); // Remove debug
+    
+    lua_call(L, 0, 1);    
+    return 1;
+}
+
+int wax_fromObjc(lua_State *L, const char *typeDescription, void *buffer) {
+    BEGIN_STACK_MODIFY(L)
+    
+    typeDescription = wax_removeProtocolEncodings(typeDescription);
+    
+    int size = wax_sizeOfTypeDescription(typeDescription);
+    
+    switch (typeDescription[0]) {
+        case WAX_TYPE_VOID:
+            lua_pushnil(L);
+            break;
+
+        case WAX_TYPE_POINTER:
+            lua_pushlightuserdata(L, *(void **)buffer);
+            break;                        
+            
+        case WAX_TYPE_CHAR: {
+            char c = *(char *)buffer;
+            if (c <= 1) lua_pushboolean(L, c); // If it's 1 or 0, then treat it like a bool
+            else lua_pushinteger(L, c);
+            break;
+        }
+            
+        case WAX_TYPE_SHORT:
+            lua_pushinteger(L, *(short *)buffer);            
+            break;
+            
+        case WAX_TYPE_INT:
+            lua_pushnumber(L, *(int *)buffer);
+            break;
+
+        case WAX_TYPE_UNSIGNED_CHAR:
+            lua_pushnumber(L, *(unsigned char *)buffer);
+            break;
+
+        case WAX_TYPE_UNSIGNED_INT:
+            lua_pushnumber(L, *(unsigned int *)buffer);
+            break;
+
+        case WAX_TYPE_UNSIGNED_SHORT:
+            lua_pushinteger(L, *(short *)buffer);
+            break;
+            
+        case WAX_TYPE_LONG:
+            lua_pushnumber(L, *(long *)buffer);
+            break;
+
+        case WAX_TYPE_LONG_LONG:
+            lua_pushnumber(L, *(long long *)buffer);
+            break;
+
+        case WAX_TYPE_UNSIGNED_LONG:
+            lua_pushnumber(L, *(unsigned long *)buffer);
+            break;
+
+        case WAX_TYPE_UNSIGNED_LONG_LONG:
+            lua_pushnumber(L, *(unsigned long long *)buffer);
+            break;
+
+        case WAX_TYPE_FLOAT:
+            lua_pushnumber(L, *(float *)buffer);
+            break;
+
+        case WAX_TYPE_DOUBLE:
+            lua_pushnumber(L, *(double *)buffer);
+            break;
+            
+        case WAX_TYPE_C99_BOOL:
+            lua_pushboolean(L, *(BOOL *)buffer);
+            break;
+            
+        case WAX_TYPE_STRING:
+            lua_pushstring(L, *(char **)buffer);
+            break;
+            
+        case WAX_TYPE_ID: {
+            id instance = *(id *)buffer;
+            wax_fromInstance(L, instance);
+            break;
+        }
+            
+        case WAX_TYPE_STRUCT: {
+            wax_fromStruct(L, typeDescription, buffer);
+            break;
+        }
+            
+        case WAX_TYPE_SELECTOR:
+            lua_pushstring(L, sel_getName(*(SEL *)buffer));
+            break;            
+
+        case WAX_TYPE_CLASS: {
+            id instance = *(id *)buffer;
+            wax_instance_create(L, instance, YES);
+            break;                        
+        }
+            
+        default:
+            luaL_error(L, "Unable to convert Obj-C type with type description '%s'", typeDescription);
+            break;
+    }
+    
+    END_STACK_MODIFY(L, 1)
+    
+    return size;
+}
+
+void wax_fromStruct(lua_State *L, const char *typeDescription, void *buffer) {
+    wax_struct_create(L, typeDescription, buffer);
+}
+
+void wax_fromInstance(lua_State *L, id instance) {
+    BEGIN_STACK_MODIFY(L)
+    
+    if (instance) {
+        if ([instance isKindOfClass:[NSString class]]) {    
+            lua_pushstring(L, [(NSString *)instance UTF8String]);
+        }
+        else if ([instance isKindOfClass:[NSNumber class]]) {
+            lua_pushnumber(L, [instance doubleValue]);
+        }
+        else if ([instance isKindOfClass:[NSArray class]]) {
+            lua_newtable(L);
+            for (id obj in instance) {
+                int i = lua_objlen(L, -1);
+                wax_fromInstance(L, obj);
+                lua_rawseti(L, -2, i + 1);
+            }
+        }
+        else if ([instance isKindOfClass:[NSDictionary class]]) {
+            lua_newtable(L);
+            for (id key in instance) {
+                wax_fromInstance(L, key);
+                wax_fromInstance(L, [instance objectForKey:key]);
+                lua_rawset(L, -3);
+            }
+        }                
+        else if ([instance isKindOfClass:[NSValue class]]) {
+            void *buffer = malloc(wax_sizeOfTypeDescription([instance objCType]));
+            [instance getValue:buffer];
+            wax_fromObjc(L, [instance objCType], buffer);
+            free(buffer);
+        }    
+		else if ([instance isKindOfClass:[WaxFunction class]]) {
+			wax_instance_pushUserdata(L, instance);
+			if (lua_isnil(L, -1)) {
+				luaL_error(L, "Could not get userdata associated with WaxFunction");
+			}
+			lua_getfield(L, -1, "function");
+		}
+        else {
+            wax_instance_create(L, instance, NO);
+        }
+    }
+    else {
+        lua_pushnil(L);
+    }
+    
+    END_STACK_MODIFY(L, 1)
+}
+
+#define WAX_TO_INTEGER(_type_) *outsize = sizeof(_type_); value = calloc(sizeof(_type_), 1); *((_type_ *)value) = (_type_)lua_tointeger(L, stackIndex);
+#define WAX_TO_NUMBER(_type_) *outsize = sizeof(_type_); value = calloc(sizeof(_type_), 1); *((_type_ *)value) = (_type_)lua_tonumber(L, stackIndex);
+#define WAX_TO_BOOL_OR_CHAR(_type_) *outsize = sizeof(_type_); value = calloc(sizeof(_type_), 1); *((_type_ *)value) = (_type_)(lua_isstring(L, stackIndex) ? lua_tostring(L, stackIndex)[0] : lua_toboolean(L, stackIndex));
+
+// MAKE SURE YOU RELEASE THE RETURN VALUE!
+void *wax_copyToObjc(lua_State *L, const char *typeDescription, int stackIndex, int *outsize) {
+    void *value = nil;
+
+    // Ignore method encodings
+    switch (typeDescription[0]) {
+        case WAX_PROTOCOL_TYPE_CONST:
+        case WAX_PROTOCOL_TYPE_IN:
+        case WAX_PROTOCOL_TYPE_INOUT:
+        case WAX_PROTOCOL_TYPE_OUT:
+        case WAX_PROTOCOL_TYPE_BYCOPY:
+        case WAX_PROTOCOL_TYPE_BYREF:
+        case  WAX_PROTOCOL_TYPE_ONEWAY:
+            typeDescription = typeDescription + 1; // Skip first
+            break;
+    }
+
+    
+    if (outsize == nil) outsize = alloca(sizeof(int)); // if no outsize address set, treat it as a junk var
+    
+    switch (typeDescription[0]) {
+        case WAX_TYPE_C99_BOOL:
+            WAX_TO_BOOL_OR_CHAR(BOOL)
+            break;            
+            
+        case WAX_TYPE_CHAR:
+            WAX_TO_BOOL_OR_CHAR(char)
+            break;
+            
+        case WAX_TYPE_INT:
+            WAX_TO_INTEGER(int)
+            break;            
+            
+        case WAX_TYPE_SHORT:
+            WAX_TO_INTEGER(short)
+            break;            
+            
+        case WAX_TYPE_UNSIGNED_CHAR:
+            WAX_TO_INTEGER(unsigned char)
+            break;            
+            
+        case WAX_TYPE_UNSIGNED_INT:
+            WAX_TO_INTEGER(unsigned int)
+            break;            
+            
+        case WAX_TYPE_UNSIGNED_SHORT:
+            WAX_TO_INTEGER(unsigned short)
+            break;
+            
+        case WAX_TYPE_LONG:
+            WAX_TO_NUMBER(long)
+            break;
+            
+        case WAX_TYPE_LONG_LONG:
+            WAX_TO_NUMBER(long long)
+            break;
+            
+        case WAX_TYPE_UNSIGNED_LONG:
+            WAX_TO_NUMBER(unsigned long)
+            break;
+            
+        case WAX_TYPE_UNSIGNED_LONG_LONG:
+            WAX_TO_NUMBER(unsigned long long);
+            break;            
+            
+        case WAX_TYPE_FLOAT:
+            WAX_TO_NUMBER(float);
+            break;
+            
+        case WAX_TYPE_DOUBLE:
+            WAX_TO_NUMBER(double);
+            break;
+            
+        case WAX_TYPE_SELECTOR:
+            if (lua_isnil(L, stackIndex)) { // If no slector is passed it, just use an empty string
+                lua_pushstring(L, "");
+                lua_replace(L, stackIndex);
+            }
+            
+            *outsize = sizeof(SEL);
+            value = calloc(sizeof(SEL), 1);
+            const char *selectorName = luaL_checkstring(L, stackIndex);
+            *((SEL *)value) = sel_getUid(selectorName);                
+
+            break;            
+
+        case WAX_TYPE_CLASS:
+            *outsize = sizeof(Class);
+            value = calloc(sizeof(Class), 1);
+            if (lua_isuserdata(L, stackIndex)) {
+                wax_instance_userdata *instanceUserdata = (wax_instance_userdata *)luaL_checkudata(L, stackIndex, WAX_INSTANCE_METATABLE_NAME);
+                *(id *)value = instanceUserdata->instance;   
+            }
+            else {
+                *((Class *)value) = objc_getClass(lua_tostring(L, stackIndex));
+            }
+            break;             
+            
+        case WAX_TYPE_STRING: {
+            const char *string = lua_tostring(L, stackIndex);
+            int length = strlen(string) + 1;
+            *outsize = length;
+            
+            value = calloc(sizeof(char *), length);
+            strcpy(value, string);
+            break;
+        }
+
+        case WAX_TYPE_POINTER:
+            *outsize = sizeof(void *);
+            
+            value = calloc(sizeof(void *), 1);            
+            void *pointer = nil;
+            
+            switch (typeDescription[1]) {
+                case WAX_TYPE_VOID:
+                case WAX_TYPE_ID: {
+                    switch (lua_type(L, stackIndex)) {
+                        case LUA_TNIL:
+                        case LUA_TNONE:
+                            break;
+                            
+                        case LUA_TUSERDATA: {
+                            wax_instance_userdata *instanceUserdata = (wax_instance_userdata *)luaL_checkudata(L, stackIndex, WAX_INSTANCE_METATABLE_NAME);
+							if (typeDescription[1] == WAX_TYPE_VOID) {
+								pointer = instanceUserdata->instance;
+							}
+							else {
+								pointer = &instanceUserdata->instance;
+							}
+
+                            break;                                  
+                        }
+                        default:
+                            luaL_error(L, "Can't convert %s to wax_instance_userdata.", luaL_typename(L, stackIndex));
+                            break;
+                    }    
+                    break;
+                }
+                default:
+                    if (lua_islightuserdata(L, stackIndex)) {
+                        pointer = lua_touserdata(L, stackIndex);
+                    }
+                    else {
+                        free(value);
+                        luaL_error(L, "Converstion from %s to Objective-c not implemented.", typeDescription);
+                    }
+            }
+            
+            if (pointer) {
+                memcpy(value, &pointer, *outsize);
+            }   
+            
+            break;
+            
+        case WAX_TYPE_ID: {
+            *outsize = sizeof(id);
+
+            value = calloc(sizeof(id), 1);            
+            // add number, string
+            
+            id instance = nil;
+
+            switch (lua_type(L, stackIndex)) {
+                case LUA_TNIL:
+                case LUA_TNONE:
+                    instance = nil;
+                    break;
+                    
+                case LUA_TBOOLEAN: {
+                    BOOL value = lua_toboolean(L, stackIndex);
+                    instance = [NSValue valueWithBytes:&value objCType:@encode(bool)];
+                    break;
+                }
+                case LUA_TNUMBER:
+                    instance = [NSNumber numberWithDouble:lua_tonumber(L, stackIndex)];                    
+                    break;
+                    
+                case LUA_TSTRING: 
+                    instance = [NSString stringWithUTF8String:lua_tostring(L, stackIndex)];  
+                    break;
+
+                case LUA_TTABLE: {
+                    BOOL dictionary = NO;
+                    
+                    lua_pushvalue(L, stackIndex); // Push the table reference on the top
+                    lua_pushnil(L);  /* first key */
+                    while (!dictionary && lua_next(L, -2)) {
+                        if (lua_type(L, -2) != LUA_TNUMBER) {
+                            dictionary = YES;                        
+                            lua_pop(L, 2); // pop key and value off the stack
+                        }
+                        else {
+                            lua_pop(L, 1);
+                        }
+                    }
+                                        
+                    if (dictionary) {
+                        instance = [NSMutableDictionary dictionary];
+                        
+                        lua_pushnil(L);  /* first key */
+                        while (lua_next(L, -2)) {
+                            id *key = wax_copyToObjc(L, "@", -2, nil);
+                            id *object = wax_copyToObjc(L, "@", -1, nil);
+                            [instance setObject:*object forKey:*key];
+                            lua_pop(L, 1); // Pop off the value
+                            free(key);
+                            free(object);
+                        }                        
+                    }
+                    else {
+                        instance = [NSMutableArray array];
+                        
+                        lua_pushnil(L);  /* first key */
+                        while (lua_next(L, -2)) {
+                            int index = lua_tonumber(L, -2) - 1;
+                            id *object = wax_copyToObjc(L, "@", -1, nil);
+                            [instance insertObject:*object atIndex:index];
+                            lua_pop(L, 1);
+                            free(object);
+                        }                                
+                    }
+                      
+                    lua_pop(L, 1); // Pop the table reference off 
+                    break;
+                }
+                                        
+                case LUA_TUSERDATA: {
+                    wax_instance_userdata *instanceUserdata = (wax_instance_userdata *)luaL_checkudata(L, stackIndex, WAX_INSTANCE_METATABLE_NAME);
+                    instance = instanceUserdata->instance;
+                    break;                                  
+                }
+                case LUA_TLIGHTUSERDATA: {
+                    instance = lua_touserdata(L, -1);
+                    break;
+                }
+				case LUA_TFUNCTION: {
+				    instance = [[[WaxFunction alloc] init] autorelease];
+				    wax_instance_create(L, instance, NO);
+				    lua_pushvalue(L, -2);
+				    lua_setfield(L, -2, "function"); // Stores function inside of this instance
+					lua_pop(L, 1);
+					
+					break;
+				}
+                default:
+                    luaL_error(L, "Can't convert %s to obj-c.", luaL_typename(L, stackIndex));
+                    break;
+            }
+            
+            if (instance) {
+                *(id *)value = instance;
+            }
+
+            
+            break;
+        }        
+            
+        case WAX_TYPE_STRUCT: {
+            if (lua_isuserdata(L, stackIndex)) {
+                wax_struct_userdata *structUserdata = (wax_struct_userdata *)luaL_checkudata(L, stackIndex, WAX_STRUCT_METATABLE_NAME);
+                value = malloc(structUserdata->size);
+                memcpy(value, structUserdata->data, structUserdata->size);
+            }
+            else {
+                void *data = (void *)lua_tostring(L, stackIndex);            
+                size_t length = lua_objlen(L, stackIndex);
+                *outsize = length;
+            
+                value = malloc(length);
+                memcpy(value, data, length);
+            }
+            break;
+        }
+            
+        default:
+            luaL_error(L, "Unable to get type for Obj-C method argument with type description '%s'", typeDescription);
+            break;
+    }
+    
+    return value;
+}
+
+// You can't tell if there are 0 or 1 arguments based on selector alone, so pass in an SEL[2] for possibleSelectors
+void wax_selectorsForName(const char *methodName, SEL possibleSelectors[2]) {
+    int strlength = strlen(methodName) + 2; // Add 2. One for trailing : and one for \0
+    char *objcMethodName = calloc(strlength, 1); 
+    
+    int argCount = 0;
+    strcpy(objcMethodName, methodName);
+    for(int i = 0; objcMethodName[i]; i++) {
+        if (objcMethodName[i] == '_') {
+            argCount++;
+            objcMethodName[i] = ':';
+        }
+    }
+    
+    objcMethodName[strlength - 2] = ':'; // Add final arg portion
+    possibleSelectors[0] = sel_getUid(objcMethodName);
+    
+    if (argCount == 0) {
+        objcMethodName[strlength - 2] = '\0';
+        possibleSelectors[1] = sel_getUid(objcMethodName);        
+    }
+    else {
+        possibleSelectors[1] = nil;
+    }
+
+
+    free(objcMethodName);
+}
+
+BOOL wax_selectorForInstance(wax_instance_userdata *instanceUserdata, SEL* foundSelectors, const char *methodName, BOOL forceInstanceCheck) {    
+    SEL possibleSelectors[2];
+    wax_selectorsForName(methodName, possibleSelectors);
+    
+    for (int i = 0; i < 2; i++) {
+        SEL selector = possibleSelectors[i];
+        if (!selector) continue; // There may be only one acceptable selector (i.e. methods with multiple keyword args)
+        
+        BOOL addSelector = NO;
+        if (instanceUserdata->isClass && (forceInstanceCheck || wax_isInitMethod(methodName))) {
+            if ([instanceUserdata->instance instanceMethodSignatureForSelector:selector]) addSelector = YES;
+        }
+        else {
+            if ([instanceUserdata->instance methodSignatureForSelector:selector]) addSelector = YES;
+        }    
+        
+        if (addSelector) {
+            if (!foundSelectors[0]) foundSelectors[0] = selector;
+            else foundSelectors[1] = selector;
+        }
+    }
+    
+    // True if it found any selectors
+    return foundSelectors[0] || foundSelectors[1];
+}
+
+void wax_pushMethodNameFromSelector(lua_State *L, SEL selector) {
+    BEGIN_STACK_MODIFY(L)
+    const char *methodName = [NSStringFromSelector(selector) UTF8String];
+    int length = strlen(methodName);
+    
+    luaL_Buffer b;
+    luaL_buffinit(L, &b);    
+    
+    int i = 0;
+    while(methodName[i]) {
+        if (methodName[i] == ':') {
+            if (i < length - 1) luaL_addchar(&b, '_');
+        }
+        else {
+            luaL_addchar(&b, methodName[i]);
+        }
+        i++;
+    }
+    
+    luaL_pushresult(&b);
+    
+    END_STACK_MODIFY(L, 1)
+}
+
+// Wax assumes anything that starts with init[A-Z0-9]? is an init method
+BOOL wax_isInitMethod(const char *methodName) {
+    if (strncmp(methodName, "init", 4) == 0) {
+        if (methodName[4] == '\0') return YES; // It's just an init
+        if (isupper(methodName[4]) || isdigit(methodName[4])) return YES; // It's init[A-Z0-9]
+    }
+    
+    return NO;
+}
+
+// I could get rid of this <- Then why don't you?
+const char *wax_removeProtocolEncodings(const char *type_descriptions) {
+    switch (type_descriptions[0]) {
+        case WAX_PROTOCOL_TYPE_CONST:
+        case WAX_PROTOCOL_TYPE_INOUT:
+        case WAX_PROTOCOL_TYPE_OUT:
+        case WAX_PROTOCOL_TYPE_BYCOPY:
+        case WAX_PROTOCOL_TYPE_BYREF:
+        case WAX_PROTOCOL_TYPE_ONEWAY:
+            return &type_descriptions[1];
+            break;
+        default:
+            return type_descriptions;
+            break;
+    }
+}
+
+int wax_sizeOfTypeDescription(const char *full_type_description) {
+    int index = 0;
+    int size = 0;
+    
+    size_t length = strlen(full_type_description) + 1;
+    char *type_description = alloca(length);
+    bzero(type_description, length);
+    wax_simplifyTypeDescription(full_type_description, type_description);
+    
+    while(type_description[index]) {
+        switch (type_description[index]) {
+            case WAX_TYPE_POINTER:
+                size += sizeof(void *);
+                
+            case WAX_TYPE_CHAR:
+                size += sizeof(char);
+                break;
+                
+            case WAX_TYPE_INT:
+                size += sizeof(int);
+                break;
+                
+            case WAX_TYPE_ARRAY:
+            case WAX_TYPE_ARRAY_END:
+                [NSException raise:@"Wax Error" format:@"C array's are not implemented yet."];
+                break;
+            
+            case WAX_TYPE_SHORT:
+                size += sizeof(short);
+                break;
+                
+            case WAX_TYPE_UNSIGNED_CHAR:
+                size += sizeof(unsigned char);
+                break;
+                
+            case WAX_TYPE_UNSIGNED_INT:
+                size += sizeof(unsigned int);
+                break;
+                
+            case WAX_TYPE_UNSIGNED_SHORT:
+                size += sizeof(unsigned short);
+                break;
+                
+            case WAX_TYPE_LONG:
+                size += sizeof(long);
+                break;
+                
+            case WAX_TYPE_LONG_LONG:
+                size += sizeof(long long);
+                break;
+                
+            case WAX_TYPE_UNSIGNED_LONG:
+                size += sizeof(unsigned long);
+                break;
+                
+            case WAX_TYPE_UNSIGNED_LONG_LONG:
+                size += sizeof(unsigned long long);
+                break;
+                
+            case WAX_TYPE_FLOAT:
+                size += sizeof(float);
+                break;
+                
+            case WAX_TYPE_DOUBLE:
+                size += sizeof(double);
+                break;
+                
+            case WAX_TYPE_C99_BOOL:
+                size += sizeof(_Bool);
+                break;
+                
+            case WAX_TYPE_STRING:
+                size += sizeof(char *);
+                break;
+                
+            case WAX_TYPE_VOID:
+                size += sizeof(char);
+                break;
+                
+            case WAX_TYPE_BITFIELD:
+                [NSException raise:@"Wax Error" format:@"Bitfields are not implemented yet"];
+                break;
+                
+            case WAX_TYPE_ID:
+                size += sizeof(id);
+                break;
+                
+            case WAX_TYPE_CLASS:
+                size += sizeof(Class);
+                break;
+                
+            case WAX_TYPE_SELECTOR:
+                size += sizeof(SEL);
+                break;
+                
+            case WAX_TYPE_STRUCT:
+            case WAX_TYPE_STRUCT_END:
+            case WAX_TYPE_UNION:
+            case WAX_TYPE_UNION_END:
+            case WAX_TYPE_UNKNOWN:                
+            case WAX_PROTOCOL_TYPE_CONST:                
+            case WAX_PROTOCOL_TYPE_IN:                
+            case WAX_PROTOCOL_TYPE_INOUT:
+            case WAX_PROTOCOL_TYPE_OUT:
+            case WAX_PROTOCOL_TYPE_BYCOPY:
+            case WAX_PROTOCOL_TYPE_BYREF:
+            case WAX_PROTOCOL_TYPE_ONEWAY:                    
+                // Weeeee! Just ignore this stuff I guess?
+                break;
+            default:
+                [NSException raise:@"Wax Error" format:@"Unknown type encoding %c", type_description[index]];
+                break;
+        }
+        
+        index++;
+    }
+    
+    return size;
+}
+
+int wax_simplifyTypeDescription(const char *in, char *out) {
+    int out_index = 0;
+    int in_index = 0;
+    
+    while(in[in_index]) {
+        switch (in[in_index]) {
+            case WAX_TYPE_STRUCT:
+            case WAX_TYPE_UNION:                
+                for (; in[in_index] != '='; in_index++); // Eat the name!
+                in_index++; // Eat the = sign 
+                break;
+                
+            case WAX_TYPE_ARRAY:            
+                do {
+                    out[out_index++] = in[in_index++];
+                } while(in[in_index] != WAX_TYPE_ARRAY_END);
+                break;
+                
+            case WAX_TYPE_POINTER: { //get rid of internal stucture parts
+                out[out_index++] = in[in_index++]; 
+                for (; in[in_index] == '^'; in_index++); // Eat all the pointers
+                
+                switch (in[in_index]) {
+                    case WAX_TYPE_UNION:
+                    case WAX_TYPE_STRUCT: {
+                        in_index++;
+                        int openCurlies = 1;
+                        
+                        for (; openCurlies > 1 || (in[in_index] != WAX_TYPE_UNION_END && in[in_index] != WAX_TYPE_STRUCT_END); in_index++) {
+                            if (in[in_index] == WAX_TYPE_UNION || in[in_index] == WAX_TYPE_STRUCT) openCurlies++;
+                            else if (in[in_index] == WAX_TYPE_UNION_END || in[in_index] == WAX_TYPE_STRUCT_END) openCurlies--;
+                        }
+                        break;
+                    }
+                }
+            }
+                
+            case WAX_TYPE_STRUCT_END:
+            case WAX_TYPE_UNION_END:
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':                
+                in_index++;
+                break;
+                
+            default:
+                out[out_index++] = in[in_index++];
+                break;
+        }
+    }
+    
+    out[out_index] = '\0';
+    
+    return out_index;
+}
+
+int wax_errorFunction(lua_State *L) {
+    lua_getfield(L, LUA_GLOBALSINDEX, "debug");
+    if (!lua_istable(L, -1)) {
+        lua_pop(L, 1);
+        return 1;
+    }
+    
+    lua_getfield(L, -1, "traceback");
+    if (!lua_isfunction(L, -1)) {
+        lua_pop(L, 2);
+        return 1;
+    }    
+    lua_remove(L, -2); // Remove debug
+    
+    lua_pushvalue(L, -2); // Grab the error string and place it on the stack
+    
+    lua_call(L, 1, 1);
+    lua_remove(L, -2); // Remove original error string
+    
+    return 1;
+}
+
+int wax_pcall(lua_State *L, int argumentCount, int returnCount) {
+    lua_pushcclosure(L, wax_errorFunction, 0);
+    int errorFuncStackIndex = lua_gettop(L) - (argumentCount + 1); // Insert error function before arguments
+    lua_insert(L, errorFuncStackIndex);
+    
+    return lua_pcall(L, argumentCount, returnCount, errorFuncStackIndex);
+}
+