ffi 0.3.5 → 0.4.0

data/ext/ffi_c/Pointer.c

@@ -11,26 +11,25 @@ typedef struct Pointer {
     VALUE parent;
 } Pointer;
 
-#define POINTER(obj) rb_FFI_AbstractMemory_cast((obj), rb_FFI_Pointer_class)
+#define POINTER(obj) rbffi_AbstractMemory_Cast((obj), rbffi_PointerClass)
 
-VALUE rb_FFI_Pointer_class;
-static VALUE classPointer = Qnil;
+VALUE rbffi_PointerClass;
 static void ptr_mark(Pointer* ptr);
 
 VALUE
-rb_FFI_Pointer_new(void* addr)
+rbffi_Pointer_NewInstance(void* addr)
 {
     Pointer* p;
     VALUE obj;
 
     if (addr == NULL) {
-        return rb_FFI_NullPointer_singleton;
+        return rbffi_NullPointerSingleton;
     }
 
-    obj = Data_Make_Struct(classPointer, Pointer, NULL, -1, p);
+    obj = Data_Make_Struct(rbffi_PointerClass, Pointer, NULL, -1, p);
     p->memory.address = addr;
     p->memory.size = LONG_MAX;
-    p->memory.ops = &rb_FFI_AbstractMemory_ops;
+    p->memory.ops = &rbffi_AbstractMemoryOps;
     p->parent = Qnil;
 
     return obj;
@@ -42,12 +41,43 @@ ptr_allocate(VALUE klass)
     Pointer* p;
     VALUE obj;
 
-    obj = Data_Make_Struct(classPointer, Pointer, NULL, -1, p);
+    obj = Data_Make_Struct(rbffi_PointerClass, Pointer, NULL, -1, p);
     p->parent = Qnil;
+    p->memory.ops = &rbffi_AbstractMemoryOps;
 
     return obj;
 }
 
+static VALUE
+ptr_initialize(int argc, VALUE* argv, VALUE self)
+{
+    Pointer* p;
+    VALUE type, address;
+
+    Data_Get_Struct(self, Pointer, p);
+
+    switch (rb_scan_args(argc, argv, "11", &type, &address)) {
+        case 1:
+            p->memory.address = (void*)(uintptr_t) NUM2LL(type);
+            // FIXME set type_size to 1
+            break;
+        case 2:
+            p->memory.address = (void*)(uintptr_t) NUM2LL(address);
+            // FIXME set type_size to rbffi_type_size(type)
+            break;
+        default:
+            rb_raise(rb_eArgError, "Invalid arguments");
+    }
+    if (p->memory.address == NULL) {
+        p->memory.ops = &rbffi_NullPointerOps;
+    }
+
+    p->memory.size = LONG_MAX;
+    
+    return self;
+}
+
+
 static VALUE
 ptr_plus(VALUE self, VALUE offset)
 {
@@ -59,11 +89,11 @@ ptr_plus(VALUE self, VALUE offset)
     Data_Get_Struct(self, AbstractMemory, ptr);
     checkBounds(ptr, off, 1);
 
-    retval = Data_Make_Struct(classPointer, Pointer, ptr_mark, -1, p);
+    retval = Data_Make_Struct(rbffi_PointerClass, Pointer, ptr_mark, -1, p);
 
     p->memory.address = ptr->address + off;
     p->memory.size = ptr->size == LONG_MAX ? LONG_MAX : ptr->size - off;
-    p->memory.ops = &rb_FFI_AbstractMemory_ops;
+    p->memory.ops = &rbffi_AbstractMemoryOps;
     p->parent = self;
 
     return retval;
@@ -118,16 +148,17 @@ ptr_mark(Pointer* ptr)
 }
 
 void
-rb_FFI_Pointer_Init()
+rbffi_Pointer_Init(VALUE moduleFFI)
 {
-    VALUE moduleFFI = rb_define_module("FFI");
-    rb_FFI_Pointer_class = classPointer = rb_define_class_under(moduleFFI, "Pointer", rb_FFI_AbstractMemory_class);
-    rb_global_variable(&rb_FFI_Pointer_class);
-
-    rb_define_alloc_func(classPointer, ptr_allocate);
-    rb_define_method(classPointer, "inspect", ptr_inspect, 0);
-    rb_define_method(classPointer, "+", ptr_plus, 1);
-    rb_define_method(classPointer, "null?", ptr_null_p, 0);
-    rb_define_method(classPointer, "address", ptr_address, 0);
-    rb_define_method(classPointer, "==", ptr_equals, 1);
+    rbffi_PointerClass = rb_define_class_under(moduleFFI, "Pointer", rbffi_AbstractMemoryClass);
+    rb_global_variable(&rbffi_PointerClass);
+
+    rb_define_alloc_func(rbffi_PointerClass, ptr_allocate);
+    rb_define_method(rbffi_PointerClass, "initialize", ptr_initialize, -1);
+    rb_define_method(rbffi_PointerClass, "inspect", ptr_inspect, 0);
+    rb_define_method(rbffi_PointerClass, "+", ptr_plus, 1);
+    rb_define_method(rbffi_PointerClass, "null?", ptr_null_p, 0);
+    rb_define_method(rbffi_PointerClass, "address", ptr_address, 0);
+    rb_define_alias(rbffi_PointerClass, "to_i", "address");
+    rb_define_method(rbffi_PointerClass, "==", ptr_equals, 1);
 }

data/ext/ffi_c/Pointer.h

@@ -6,14 +6,16 @@
 extern "C" {
 #endif
 
+#include "AbstractMemory.h"
 
+extern void rbffi_Pointer_Init(VALUE moduleFFI);
+extern void rbffi_NullPointer_Init(VALUE moduleFFI);
+extern VALUE rbffi_Pointer_NewInstance(void* addr);
+extern VALUE rbffi_PointerClass;
+extern VALUE rbffi_NullPointerClass;
+extern VALUE rbffi_NullPointerSingleton;
+extern MemoryOps rbffi_NullPointerOps;
 
-extern void rb_FFI_Pointer_Init(void);
-extern void rb_FFI_NullPointer_Init(void);
-extern VALUE rb_FFI_Pointer_new(void* addr);
-extern VALUE rb_FFI_Pointer_class;
-extern VALUE rb_FFI_NullPointer_class;
-extern VALUE rb_FFI_NullPointer_singleton;
 
 #ifdef	__cplusplus
 }

data/ext/ffi_c/Struct.c

@@ -33,11 +33,11 @@ static void struct_mark(Struct *);
 static void struct_layout_mark(StructLayout *);
 static inline MemoryOp* ptr_get_op(AbstractMemory* ptr, int type);
 
-VALUE rb_FFI_Struct_class = Qnil;
-static VALUE classStruct = Qnil, classStructLayout = Qnil;
-static VALUE classStructField = Qnil, classStructLayoutBuilder = Qnil;
-static ID pointerID = 0, layoutID = 0, SIZE_ID, ALIGN_ID;
-static ID getID = 0, putID = 0, to_ptr = 0;
+VALUE rbffi_StructClass = Qnil;
+static VALUE StructLayoutClass = Qnil;
+static VALUE StructFieldClass = Qnil, StructLayoutBuilderClass = Qnil;
+static ID pointer_var_id = 0, layout_var_id = 0, SIZE_ID, ALIGN_ID, TYPE_ID;
+static ID get_id = 0, put_id = 0, to_ptr = 0, to_s = 0, layout_id = 0;
 
 static VALUE
 struct_field_allocate(VALUE klass)
@@ -58,15 +58,15 @@ struct_field_initialize(int argc, VALUE* argv, VALUE self)
     nargs = rb_scan_args(argc, argv, "11", &offset, &info);
     
     field->offset = NUM2UINT(offset);
-    if (rb_const_defined(CLASS_OF(self), rb_intern("TYPE"))) {
-        field->type = NUM2UINT(rb_const_get(CLASS_OF(self), rb_intern("TYPE")));
+    if (rb_const_defined(CLASS_OF(self), TYPE_ID)) {
+        field->type = NUM2UINT(rb_const_get(CLASS_OF(self), TYPE_ID));
     } else {
         field->type = ~0;
     }
 
 #ifdef notyet
-    field->size = NUM2UINT(rb_const_get(klass, rb_intern("SIZE")));
-    field->align = NUM2UINT(rb_const_get(klass, rb_intern("ALIGN")));
+    field->size = NUM2UINT(rb_const_get(klass, SIZE_ID));
+    field->align = NUM2UINT(rb_const_get(klass, ALIGN_ID));
 #endif
     rb_iv_set(self, "@off", offset);
     rb_iv_set(self, "@info", info);
@@ -151,14 +151,14 @@ struct_initialize(int argc, VALUE* argv, VALUE self)
 
     /* Call up into ruby code to adjust the layout */
     if (nargs > 1) {
-        s->rbLayout = rb_funcall2(CLASS_OF(self), rb_intern("layout"), RARRAY_LEN(rest), RARRAY_PTR(rest));
-    } else if (rb_cvar_defined(klass, layoutID)) {
-        s->rbLayout = rb_cvar_get(klass, layoutID);
+        s->rbLayout = rb_funcall2(CLASS_OF(self), layout_id, RARRAY_LEN(rest), RARRAY_PTR(rest));
+    } else if (rb_cvar_defined(klass, layout_var_id)) {
+        s->rbLayout = rb_cvar_get(klass, layout_var_id);
     } else {
         rb_raise(rb_eRuntimeError, "No Struct layout configured");
     }
 
-    if (!rb_obj_is_kind_of(s->rbLayout, classStructLayout)) {
+    if (!rb_obj_is_kind_of(s->rbLayout, StructLayoutClass)) {
         rb_raise(rb_eRuntimeError, "Invalid Struct layout");
     }
 
@@ -168,7 +168,7 @@ struct_initialize(int argc, VALUE* argv, VALUE self)
         s->pointer = MEMORY(rbPointer);
         s->rbPointer = rbPointer;
     } else {
-        s->rbPointer = rb_FFI_MemoryPointer_new(s->layout->size, 1, true);
+        s->rbPointer = rbffi_MemoryPointer_NewInstance(s->layout->size, 1, true);
         s->pointer = (AbstractMemory *) DATA_PTR(s->rbPointer);
     }
 
@@ -198,7 +198,7 @@ struct_field(Struct* s, VALUE fieldName)
 
     rbField = rb_hash_aref(layout->rbFields, fieldName);
     if (rbField == Qnil) {
-        VALUE str = rb_funcall2(fieldName, rb_intern("to_s"), 0, NULL);
+        VALUE str = rb_funcall2(fieldName, to_s, 0, NULL);
         rb_raise(rb_eArgError, "No such field '%s'", StringValuePtr(str));
     }
 
@@ -259,7 +259,7 @@ struct_get_field(VALUE self, VALUE fieldName)
     }
     
     /* call up to the ruby code to fetch the value */
-    return rb_funcall2(rbField, getID, 1, &s->rbPointer);
+    return rb_funcall2(rbField, get_id, 1, &s->rbPointer);
 }
 
 static VALUE
@@ -284,7 +284,7 @@ struct_put_field(VALUE self, VALUE fieldName, VALUE value)
     /* call up to the ruby code to set the value */
     argv[0] = s->rbPointer;
     argv[1] = value;
-    rb_funcall2(rbField, putID, 2, argv);
+    rb_funcall2(rbField, put_id, 2, argv);
     
     return self;
 }
@@ -294,14 +294,14 @@ struct_set_pointer(VALUE self, VALUE pointer)
 {
     Struct* s;
 
-    if (!rb_obj_is_kind_of(pointer, rb_FFI_AbstractMemory_class)) {
+    if (!rb_obj_is_kind_of(pointer, rbffi_AbstractMemoryClass)) {
         rb_raise(rb_eArgError, "Invalid pointer");
     }
 
     Data_Get_Struct(self, Struct, s);
     s->pointer = MEMORY(pointer);
     s->rbPointer = pointer;
-    rb_ivar_set(self, pointerID, pointer);
+    rb_ivar_set(self, pointer_var_id, pointer);
 
     return self;
 }
@@ -322,12 +322,12 @@ struct_set_layout(VALUE self, VALUE layout)
     Struct* s;
     Data_Get_Struct(self, Struct, s);
 
-    if (!rb_obj_is_kind_of(layout, classStructLayout)) {
+    if (!rb_obj_is_kind_of(layout, StructLayoutClass)) {
         rb_raise(rb_eArgError, "Invalid Struct layout");
     }
 
     Data_Get_Struct(layout, StructLayout, s->layout);
-    rb_ivar_set(self, layoutID, layout);
+    rb_ivar_set(self, layout_var_id, layout);
 
     return self;
 }
@@ -373,7 +373,7 @@ struct_layout_initialize(VALUE self, VALUE field_names, VALUE fields, VALUE size
     for (i = 0; i < RARRAY_LEN(field_names); ++i) {
         VALUE name = RARRAY_PTR(field_names)[i];
         VALUE field = rb_hash_aref(fields, name);
-        if (TYPE(field) != T_DATA || !rb_obj_is_kind_of(field, classStructField)) {
+        if (TYPE(field) != T_DATA || !rb_obj_is_kind_of(field, StructFieldClass)) {
             rb_raise(rb_eArgError, "Invalid field");
         }
         rb_hash_aset(layout->rbFields, name, field);
@@ -399,57 +399,66 @@ struct_layout_mark(StructLayout *layout)
 }
 
 void
-rb_FFI_Struct_Init()
+rbffi_Struct_Init(VALUE moduleFFI)
 {
-    VALUE moduleFFI = rb_define_module("FFI");
-    VALUE klass;
-    rb_FFI_Struct_class = classStruct = rb_define_class_under(moduleFFI, "Struct", rb_cObject);
-    classStructLayout = rb_define_class_under(moduleFFI, "StructLayout", rb_cObject);
-    classStructLayoutBuilder = rb_define_class_under(moduleFFI, "StructLayoutBuilder", rb_cObject);
-    classStructField = rb_define_class_under(classStructLayoutBuilder, "Field", rb_cObject);
-
-    rb_define_alloc_func(classStruct, struct_allocate);
-    rb_define_method(classStruct, "initialize", struct_initialize, -1);
+    VALUE klass, StructClass;
+    rbffi_StructClass = StructClass = rb_define_class_under(moduleFFI, "Struct", rb_cObject);
+    rb_global_variable(&rbffi_StructClass);
+
+    StructLayoutClass = rb_define_class_under(moduleFFI, "StructLayout", rb_cObject);
+    rb_global_variable(&StructLayoutClass);
+
+    StructLayoutBuilderClass = rb_define_class_under(moduleFFI, "StructLayoutBuilder", rb_cObject);
+    rb_global_variable(&StructLayoutBuilderClass);
+
+    StructFieldClass = rb_define_class_under(StructLayoutBuilderClass, "Field", rb_cObject);
+    rb_global_variable(&StructFieldClass);
+
+    rb_define_alloc_func(StructClass, struct_allocate);
+    rb_define_method(StructClass, "initialize", struct_initialize, -1);
     
-    rb_define_alias(rb_singleton_class(classStruct), "alloc_in", "new");
-    rb_define_alias(rb_singleton_class(classStruct), "alloc_out", "new");
-    rb_define_alias(rb_singleton_class(classStruct), "alloc_inout", "new");
-    rb_define_alias(rb_singleton_class(classStruct), "new_in", "new");
-    rb_define_alias(rb_singleton_class(classStruct), "new_out", "new");
-    rb_define_alias(rb_singleton_class(classStruct), "new_inout", "new");
+    rb_define_alias(rb_singleton_class(StructClass), "alloc_in", "new");
+    rb_define_alias(rb_singleton_class(StructClass), "alloc_out", "new");
+    rb_define_alias(rb_singleton_class(StructClass), "alloc_inout", "new");
+    rb_define_alias(rb_singleton_class(StructClass), "new_in", "new");
+    rb_define_alias(rb_singleton_class(StructClass), "new_out", "new");
+    rb_define_alias(rb_singleton_class(StructClass), "new_inout", "new");
 
-    rb_define_method(classStruct, "pointer", struct_get_pointer, 0);
-    rb_define_private_method(classStruct, "pointer=", struct_set_pointer, 1);
+    rb_define_method(StructClass, "pointer", struct_get_pointer, 0);
+    rb_define_private_method(StructClass, "pointer=", struct_set_pointer, 1);
 
-    rb_define_method(classStruct, "layout", struct_get_layout, 0);
-    rb_define_private_method(classStruct, "layout=", struct_set_layout, 1);
+    rb_define_method(StructClass, "layout", struct_get_layout, 0);
+    rb_define_private_method(StructClass, "layout=", struct_set_layout, 1);
 
-    rb_define_method(classStruct, "[]", struct_get_field, 1);
-    rb_define_method(classStruct, "[]=", struct_put_field, 2);
+    rb_define_method(StructClass, "[]", struct_get_field, 1);
+    rb_define_method(StructClass, "[]=", struct_put_field, 2);
     
-    rb_define_alloc_func(classStructField, struct_field_allocate);
-    rb_define_method(classStructField, "initialize", struct_field_initialize, -1);
-    rb_define_method(classStructField, "offset", struct_field_offset, 0);
-    rb_define_method(classStructField, "put", struct_field_put, 2);
-    rb_define_method(classStructField, "get", struct_field_get, 1);
-
-    rb_define_alloc_func(classStructLayout, struct_layout_allocate);
-    rb_define_method(classStructLayout, "initialize", struct_layout_initialize, 4);
-    rb_define_method(classStructLayout, "[]", struct_layout_aref, 1);
-
-    pointerID = rb_intern("@pointer");
-    layoutID = rb_intern("@layout");
-    getID = rb_intern("get");
-    putID = rb_intern("put");
+    rb_define_alloc_func(StructFieldClass, struct_field_allocate);
+    rb_define_method(StructFieldClass, "initialize", struct_field_initialize, -1);
+    rb_define_method(StructFieldClass, "offset", struct_field_offset, 0);
+    rb_define_method(StructFieldClass, "put", struct_field_put, 2);
+    rb_define_method(StructFieldClass, "get", struct_field_get, 1);
+
+    rb_define_alloc_func(StructLayoutClass, struct_layout_allocate);
+    rb_define_method(StructLayoutClass, "initialize", struct_layout_initialize, 4);
+    rb_define_method(StructLayoutClass, "[]", struct_layout_aref, 1);
+
+    pointer_var_id = rb_intern("@pointer");
+    layout_var_id = rb_intern("@layout");
+    layout_id = rb_intern("layout");
+    get_id = rb_intern("get");
+    put_id = rb_intern("put");
     to_ptr = rb_intern("to_ptr");
+    to_s = rb_intern("to_s");
     SIZE_ID = rb_intern("SIZE");
     ALIGN_ID = rb_intern("ALIGN");
+    TYPE_ID = rb_intern("TYPE");
 #undef FIELD
 #define FIELD(name, typeName, nativeType, T) do { \
     typedef struct { char c; T v; } s; \
-        klass = rb_define_class_under(classStructLayoutBuilder, #name, classStructField); \
-        rb_define_const(klass, "ALIGN", INT2NUM((sizeof(s) - sizeof(T)) * 8)); \
-        rb_define_const(klass, "SIZE", INT2NUM(sizeof(T)* 8)); \
+        klass = rb_define_class_under(StructLayoutBuilderClass, #name, StructFieldClass); \
+        rb_define_const(klass, "ALIGN", INT2NUM((sizeof(s) - sizeof(T)))); \
+        rb_define_const(klass, "SIZE", INT2NUM(sizeof(T))); \
         rb_define_const(klass, "TYPE", INT2NUM(nativeType)); \
     } while(0)
     

data/ext/ffi_c/Struct.h

@@ -7,7 +7,7 @@
 extern "C" {
 #endif
 
-    extern void rb_FFI_Struct_Init(void);
+    extern void rbffi_Struct_Init(VALUE ffiModule);
 
     struct StructLayout;
     typedef struct Struct {
@@ -17,7 +17,7 @@ extern "C" {
         VALUE rbPointer;
     } Struct;
 
-    extern VALUE rb_FFI_Struct_class;
+    extern VALUE rbffi_StructClass;
 #ifdef	__cplusplus
 }
 #endif

data/ext/ffi_c/Type.c

@@ -0,0 +1,230 @@
+#include <sys/param.h>
+#include <sys/types.h>
+#include <ruby.h>
+#include <ffi.h>
+#include "rbffi.h"
+#include "compat.h"
+#include "Types.h"
+#include "Type.h"
+
+
+typedef struct BuiltinType_ {
+    Type type;
+    char* name;
+} BuiltinType;
+
+static void builtin_type_free(BuiltinType *);
+
+VALUE rbffi_TypeClass = Qnil;
+
+static VALUE classBuiltinType = Qnil;
+
+static VALUE
+type_allocate(VALUE klass)
+{
+    Type* type;
+    VALUE obj = Data_Make_Struct(klass, Type, NULL, -1, type);
+
+    type->nativeType = -1;
+    type->size = 0;
+    type->alignment = 1;
+
+    return obj;
+}
+
+static VALUE
+type_initialize(VALUE self, VALUE value)
+{
+    Type* type;
+    Type* other;
+
+    Data_Get_Struct(self, Type, type);
+
+    if (FIXNUM_P(value)) {
+        type->nativeType = FIX2INT(value);
+    } else if (rb_obj_is_kind_of(value, rbffi_TypeClass)) {
+        Data_Get_Struct(value, Type, other);
+        type->nativeType = other->nativeType;
+        type->size = other->size;
+        type->alignment = other->alignment;
+    } else {
+        rb_raise(rb_eArgError, "wrong type");
+    }
+    
+    return self;
+}
+
+static VALUE
+type_size(VALUE self)
+{
+    Type *type;
+
+    Data_Get_Struct(self, Type, type);
+
+    return INT2FIX(type->size);
+}
+
+static VALUE
+type_alignment(VALUE self)
+{
+    Type *type;
+
+    Data_Get_Struct(self, Type, type);
+
+    return INT2FIX(type->alignment);
+}
+
+static VALUE
+type_inspect(VALUE self)
+{
+    char buf[256];
+    Type *type;
+
+    Data_Get_Struct(self, Type, type);
+    snprintf(buf, sizeof(buf), "#<FFI::Type:%p size=%d alignment=%d>", 
+            type, type->size, type->alignment);
+
+    return rb_str_new2(buf);
+}
+
+static VALUE
+enum_allocate(VALUE klass)
+{
+    Type* type;
+    VALUE obj;
+
+    obj = Data_Make_Struct(klass, Type, NULL, -1, type);
+    type->nativeType = NATIVE_ENUM;
+    type->ffiType = &ffi_type_sint;
+    type->size = ffi_type_sint.size;
+    type->alignment = ffi_type_sint.alignment;
+
+    return obj;
+}
+
+int
+rbffi_Type_GetIntValue(VALUE type)
+{
+    if (rb_obj_is_kind_of(type, rbffi_TypeClass)) {
+        Type* t;
+        Data_Get_Struct(type, Type, t);
+        return t->nativeType;
+    } else {
+        rb_raise(rb_eArgError, "Invalid type argument");
+    }
+}
+
+static VALUE
+builtin_type_new(VALUE klass, int nativeType, ffi_type* ffiType, const char* name)
+{
+    BuiltinType* type;
+    VALUE obj = Data_Make_Struct(klass, BuiltinType, NULL, builtin_type_free, type);
+    
+    type->name = strdup(name);
+    type->type.nativeType = nativeType;
+    type->type.ffiType = ffiType;
+    type->type.size = ffiType->size;
+    type->type.alignment = ffiType->alignment;
+
+    return obj;
+}
+
+static void
+builtin_type_free(BuiltinType *type)
+{
+    free(type->name);
+    xfree(type);
+}
+
+static VALUE
+builtin_type_inspect(VALUE self)
+{
+    char buf[256];
+    BuiltinType *type;
+
+    Data_Get_Struct(self, BuiltinType, type);
+    snprintf(buf, sizeof(buf), "#<FFI::Type::Builtin:%ssize=%d alignment=%d>",
+            type->name, type->type.size, type->type.alignment);
+
+    return rb_str_new2(buf);
+}
+
+void
+rbffi_Type_Init(VALUE moduleFFI)
+{
+    VALUE moduleNativeType;
+    VALUE classType = rbffi_TypeClass = rb_define_class_under(moduleFFI, "Type", rb_cObject);
+    VALUE classEnum =  rb_define_class_under(moduleFFI, "Enum", classType);
+    classBuiltinType = rb_define_class_under(rbffi_TypeClass, "Builtin", rbffi_TypeClass);
+    moduleNativeType = rb_define_module_under(moduleFFI, "NativeType");
+
+    rb_global_variable(&rbffi_TypeClass);
+    rb_global_variable(&classBuiltinType);
+    rb_global_variable(&moduleNativeType);
+
+    rb_define_alloc_func(classType, type_allocate);
+    rb_define_method(classType, "initialize", type_initialize, 1);
+    rb_define_method(classType, "size", type_size, 0);
+    rb_define_method(classType, "alignment", type_alignment, 0);
+    rb_define_method(classBuiltinType, "inspect", type_inspect, 0);
+
+    // Make Type::Builtin non-allocatable
+    rb_undef_method(CLASS_OF(classBuiltinType), "new");
+    rb_define_method(classBuiltinType, "inspect", builtin_type_inspect, 0);
+
+    rb_define_alloc_func(classEnum, enum_allocate);
+
+    rb_global_variable(&rbffi_TypeClass);
+    rb_global_variable(&classBuiltinType);
+
+    // Define all the builtin types
+    #define T(x, ffiType) do { \
+        VALUE t = Qnil; \
+        rb_define_const(classType, #x, t = builtin_type_new(classBuiltinType, NATIVE_##x, ffiType, #x)); \
+        rb_define_const(moduleNativeType, #x, t); \
+        rb_define_const(moduleFFI, "TYPE_" #x, t); \
+    } while(0)
+
+    T(VOID, &ffi_type_void);
+    T(INT8, &ffi_type_sint8);
+    T(UINT8, &ffi_type_uint8);
+    T(INT16, &ffi_type_sint16);
+    T(UINT16, &ffi_type_uint16);
+    T(INT32, &ffi_type_sint32);
+    T(UINT32, &ffi_type_uint32);
+    T(INT64, &ffi_type_sint64);
+    T(UINT64, &ffi_type_uint64);
+    T(FLOAT32, &ffi_type_float);
+    T(FLOAT64, &ffi_type_double);
+    T(POINTER, &ffi_type_pointer);
+    T(STRING, &ffi_type_pointer);
+    T(RBXSTRING, &ffi_type_pointer);
+    T(BUFFER_IN, &ffi_type_pointer);
+    T(BUFFER_OUT, &ffi_type_pointer);
+    T(BUFFER_INOUT, &ffi_type_pointer);
+    T(ENUM, &ffi_type_sint);
+    T(BOOL, &ffi_type_sint);
+
+
+    T(CHAR_ARRAY, &ffi_type_void);
+    T(VARARGS, &ffi_type_void);
+    
+
+    if (sizeof(long) == 4) {
+        VALUE t = Qnil;
+        rb_define_const(classType, "LONG", t = builtin_type_new(classBuiltinType, NATIVE_INT32, &ffi_type_slong, "LONG"));
+        rb_define_const(moduleNativeType, "LONG", t);
+        rb_define_const(moduleFFI, "TYPE_LONG", t);
+        rb_define_const(classType, "ULONG", t = builtin_type_new(classBuiltinType, NATIVE_UINT32, &ffi_type_slong, "ULONG"));
+        rb_define_const(moduleNativeType, "ULONG", t);
+        rb_define_const(moduleFFI, "TYPE_ULONG", t);
+    } else {
+        VALUE t = Qnil;
+        rb_define_const(classType, "LONG", t = builtin_type_new(classBuiltinType, NATIVE_INT64, &ffi_type_slong, "LONG"));
+        rb_define_const(moduleNativeType, "LONG", t);
+        rb_define_const(moduleFFI, "TYPE_LONG", t);
+        rb_define_const(classType, "ULONG", t = builtin_type_new(classBuiltinType, NATIVE_UINT64, &ffi_type_slong, "ULONG"));
+        rb_define_const(moduleNativeType, "ULONG", t);
+        rb_define_const(moduleFFI, "TYPE_ULONG", t);
+    }
+}