ffi 0.4.0-x86-mswin32

data/ext/ffi_c/Platform.c

@@ -0,0 +1,59 @@
+#include <sys/param.h>
+#include <sys/types.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <ruby.h>
+#include <ctype.h>
+#include "endian.h"
+#include "Platform.h"
+
+static VALUE PlatformModule = Qnil;
+
+/*
+ * Determine the cpu type at compile time - useful for MacOSX where the the
+ * system installed ruby incorrectly reports 'host_cpu' as 'powerpc' when running
+ * on intel.
+ */
+#ifdef __i386__
+#define CPU "i386"
+#elif defined(__ppc__) || defined(__powerpc__)
+#define CPU "powerpc"
+#elif defined(__x86_64__)
+#define CPU "x86_64"
+#elif defined(__sparc__)
+#define CPU "sparc"
+#elif defined(__sparcv9__)
+#define CPU "sparcv9"
+#else
+#error "Unknown cpu type"
+#endif
+
+static void
+export_primitive_types(VALUE module)
+{
+#define S(name, T) do { \
+    typedef struct { char c; T v; } s; \
+    rb_define_const(module, #name "_ALIGN", INT2NUM((sizeof(s) - sizeof(T)) * 8)); \
+    rb_define_const(module, #name "_SIZE", INT2NUM(sizeof(T)* 8)); \
+} while(0)
+    S(INT8, char);
+    S(INT16, short);
+    S(INT32, int);
+    S(INT64, long long);
+    S(LONG, long);
+    S(FLOAT, float);
+    S(DOUBLE, double);
+    S(ADDRESS, void*);
+#undef S
+}
+
+void
+rbffi_Platform_Init(VALUE moduleFFI)
+{
+    PlatformModule = rb_define_module_under(moduleFFI, "Platform");
+    rb_define_const(PlatformModule, "BYTE_ORDER", INT2FIX(BYTE_ORDER));
+    rb_define_const(PlatformModule, "LITTLE_ENDIAN", INT2FIX(LITTLE_ENDIAN));
+    rb_define_const(PlatformModule, "BIG_ENDIAN", INT2FIX(BIG_ENDIAN));
+    rb_define_const(PlatformModule, "CPU", rb_str_new2(CPU));
+    export_primitive_types(PlatformModule);
+}

data/ext/ffi_c/Platform.h

@@ -0,0 +1,16 @@
+#ifndef _PLATFORM_H
+#define	_PLATFORM_H
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+    extern void rbffi_Platform_Init(VALUE moduleFFI);
+
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _PLATFORM_H */
+

data/ext/ffi_c/Pointer.c

@@ -0,0 +1,164 @@
+#include <stdbool.h>
+#include <stdint.h>
+#include <limits.h>
+#include <ruby.h>
+#include "rbffi.h"
+#include "AbstractMemory.h"
+#include "Pointer.h"
+
+typedef struct Pointer {
+    AbstractMemory memory;
+    VALUE parent;
+} Pointer;
+
+#define POINTER(obj) rbffi_AbstractMemory_Cast((obj), rbffi_PointerClass)
+
+VALUE rbffi_PointerClass;
+static void ptr_mark(Pointer* ptr);
+
+VALUE
+rbffi_Pointer_NewInstance(void* addr)
+{
+    Pointer* p;
+    VALUE obj;
+
+    if (addr == NULL) {
+        return rbffi_NullPointerSingleton;
+    }
+
+    obj = Data_Make_Struct(rbffi_PointerClass, Pointer, NULL, -1, p);
+    p->memory.address = addr;
+    p->memory.size = LONG_MAX;
+    p->memory.ops = &rbffi_AbstractMemoryOps;
+    p->parent = Qnil;
+
+    return obj;
+}
+
+static VALUE
+ptr_allocate(VALUE klass)
+{
+    Pointer* p;
+    VALUE obj;
+
+    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)
+{
+    AbstractMemory* ptr;
+    Pointer* p;
+    VALUE retval;
+    long off = NUM2LONG(offset);
+
+    Data_Get_Struct(self, AbstractMemory, ptr);
+    checkBounds(ptr, off, 1);
+
+    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 = &rbffi_AbstractMemoryOps;
+    p->parent = self;
+
+    return retval;
+}
+
+static VALUE
+ptr_inspect(VALUE self)
+{
+    Pointer* ptr;
+    char tmp[100];
+
+    Data_Get_Struct(self, Pointer, ptr);
+    snprintf(tmp, sizeof(tmp), "#<Native Pointer address=%p>", ptr->memory.address);
+
+    return rb_str_new2(tmp);
+}
+
+static VALUE
+ptr_null_p(VALUE self)
+{
+    Pointer* ptr;
+
+    Data_Get_Struct(self, Pointer, ptr);
+
+    return ptr->memory.address == NULL ? Qtrue : Qfalse;
+}
+
+static VALUE
+ptr_equals(VALUE self, VALUE other)
+{
+    Pointer* ptr;
+    
+    Data_Get_Struct(self, Pointer, ptr);
+
+    return ptr->memory.address == POINTER(other)->address ? Qtrue : Qfalse;
+}
+
+static VALUE
+ptr_address(VALUE self)
+{
+    Pointer* ptr;
+    
+    Data_Get_Struct(self, Pointer, ptr);
+
+    return ULL2NUM((uintptr_t) ptr->memory.address);
+}
+
+static void
+ptr_mark(Pointer* ptr)
+{
+    rb_gc_mark(ptr->parent);
+}
+
+void
+rbffi_Pointer_Init(VALUE moduleFFI)
+{
+    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

@@ -0,0 +1,25 @@
+
+#ifndef _POINTER_H
+#define	_POINTER_H
+
+#ifdef	__cplusplus
+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;
+
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _POINTER_H */
+

data/ext/ffi_c/Struct.c

@@ -0,0 +1,477 @@
+#include <sys/types.h>
+#include <sys/param.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <ruby.h>
+#include "rbffi.h"
+#include "compat.h"
+#include "AbstractMemory.h"
+#include "Pointer.h"
+#include "MemoryPointer.h"
+#include "Types.h"
+#include "Struct.h"
+
+typedef struct StructField {
+    unsigned int type;
+    unsigned int offset;
+    unsigned int size;
+    unsigned int align;
+} StructField;
+
+typedef struct StructLayout {
+    VALUE rbFields;
+    unsigned int fieldCount;
+    int size;
+    int align;
+} StructLayout;
+
+typedef struct StructLayoutBuilder {
+    unsigned int offset;
+} StructLayoutBuilder;
+
+static void struct_mark(Struct *);
+static void struct_layout_mark(StructLayout *);
+static inline MemoryOp* ptr_get_op(AbstractMemory* ptr, int type);
+
+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)
+{
+    StructField* field;
+    return Data_Make_Struct(klass, StructField, NULL, -1, field);
+}
+
+static VALUE
+struct_field_initialize(int argc, VALUE* argv, VALUE self)
+{
+    VALUE offset = Qnil, info = Qnil;
+    StructField* field;
+    int nargs;
+
+    Data_Get_Struct(self, StructField, field);
+
+    nargs = rb_scan_args(argc, argv, "11", &offset, &info);
+    
+    field->offset = NUM2UINT(offset);
+    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, SIZE_ID));
+    field->align = NUM2UINT(rb_const_get(klass, ALIGN_ID));
+#endif
+    rb_iv_set(self, "@off", offset);
+    rb_iv_set(self, "@info", info);
+
+    return self;
+}
+
+static VALUE
+struct_field_offset(VALUE self)
+{
+    StructField* field;
+    Data_Get_Struct(self, StructField, field);
+    return UINT2NUM(field->offset);
+}
+
+static VALUE
+struct_field_get(VALUE self, VALUE pointer)
+{
+    StructField* f;
+    MemoryOp* op;
+    AbstractMemory* memory = MEMORY(pointer);
+
+    Data_Get_Struct(self, StructField, f);
+    op = ptr_get_op(memory, f->type);
+    if (op == NULL) {
+        VALUE name = rb_class_name(CLASS_OF(self));
+        rb_raise(rb_eArgError, "get not supported for %s", StringValueCStr(name));
+        return Qnil;
+    }
+
+    return (*op->get)(memory, f->offset);
+}
+
+static VALUE
+struct_field_put(VALUE self, VALUE pointer, VALUE value)
+{
+    StructField* f;
+    MemoryOp* op;
+    AbstractMemory* memory = MEMORY(pointer);
+
+    Data_Get_Struct(self, StructField, f);
+    op = ptr_get_op(memory, f->type);
+    if (op == NULL) {
+        VALUE name = rb_class_name(CLASS_OF(self));
+        rb_raise(rb_eArgError, "put not supported for %s", StringValueCStr(name));
+        return self;
+    }
+    
+    (*op->put)(memory, f->offset, value);
+
+    return self;
+}
+
+static inline char*
+memory_address(VALUE self)
+{
+    return ((AbstractMemory *)DATA_PTR((self)))->address;
+}
+
+static VALUE
+struct_allocate(VALUE klass)
+{
+    Struct* s;
+    VALUE obj = Data_Make_Struct(klass, Struct, struct_mark, -1, s);
+    
+    s->rbPointer = Qnil;
+    s->rbLayout = Qnil;
+
+    return obj;
+}
+
+static VALUE
+struct_initialize(int argc, VALUE* argv, VALUE self)
+{
+    Struct* s;
+    VALUE rbPointer = Qnil, rest = Qnil, klass = CLASS_OF(self);
+    int nargs;
+
+    Data_Get_Struct(self, Struct, s);
+    
+    nargs = rb_scan_args(argc, argv, "01*", &rbPointer, &rest);
+
+    /* Call up into ruby code to adjust the layout */
+    if (nargs > 1) {
+        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, StructLayoutClass)) {
+        rb_raise(rb_eRuntimeError, "Invalid Struct layout");
+    }
+
+    Data_Get_Struct(s->rbLayout, StructLayout, s->layout);
+    
+    if (rbPointer != Qnil) {
+        s->pointer = MEMORY(rbPointer);
+        s->rbPointer = rbPointer;
+    } else {
+        s->rbPointer = rbffi_MemoryPointer_NewInstance(s->layout->size, 1, true);
+        s->pointer = (AbstractMemory *) DATA_PTR(s->rbPointer);
+    }
+
+    if (s->pointer->ops == NULL) {
+        VALUE name = rb_class_name(CLASS_OF(s->rbPointer));
+        rb_raise(rb_eRuntimeError, "No memory ops set for %s", StringValueCStr(name));
+    }
+
+    return self;
+}
+
+static void
+struct_mark(Struct *s)
+{
+    rb_gc_mark(s->rbPointer);
+    rb_gc_mark(s->rbLayout);
+}
+
+static VALUE
+struct_field(Struct* s, VALUE fieldName)
+{
+    StructLayout* layout = s->layout;
+    VALUE rbField;
+    if (layout == NULL) {
+        rb_raise(rb_eRuntimeError, "layout not set for Struct");
+    }
+
+    rbField = rb_hash_aref(layout->rbFields, fieldName);
+    if (rbField == Qnil) {
+        VALUE str = rb_funcall2(fieldName, to_s, 0, NULL);
+        rb_raise(rb_eArgError, "No such field '%s'", StringValuePtr(str));
+    }
+
+    return rbField;
+}
+
+static inline MemoryOp*
+ptr_get_op(AbstractMemory* ptr, int type)
+{
+    if (ptr == NULL || ptr->ops == NULL) {
+        return NULL;
+    }
+    switch (type) {
+        case NATIVE_INT8:
+            return ptr->ops->int8;
+        case NATIVE_UINT8:
+            return ptr->ops->uint8;
+        case NATIVE_INT16:
+            return ptr->ops->int16;
+        case NATIVE_UINT16:
+            return ptr->ops->uint16;
+        case NATIVE_INT32:
+            return ptr->ops->int32;
+        case NATIVE_UINT32:
+            return ptr->ops->uint32;
+        case NATIVE_INT64:
+            return ptr->ops->int64;
+        case NATIVE_UINT64:
+            return ptr->ops->uint64;
+        case NATIVE_FLOAT32:
+            return ptr->ops->float32;
+        case NATIVE_FLOAT64:
+            return ptr->ops->float64;
+        case NATIVE_POINTER:
+            return ptr->ops->pointer;
+        case NATIVE_STRING:
+            return ptr->ops->strptr;
+        default:
+            return NULL;
+    }
+}
+
+static VALUE
+struct_get_field(VALUE self, VALUE fieldName)
+{
+    Struct* s;
+    VALUE rbField;
+    StructField* f;
+    MemoryOp* op;
+
+    Data_Get_Struct(self, Struct, s);
+    rbField = struct_field(s, fieldName);
+    f = (StructField *) DATA_PTR(rbField);
+
+    op = ptr_get_op(s->pointer, f->type);
+    if (op != NULL) {
+        return (*op->get)(s->pointer, f->offset);
+    }
+    
+    /* call up to the ruby code to fetch the value */
+    return rb_funcall2(rbField, get_id, 1, &s->rbPointer);
+}
+
+static VALUE
+struct_put_field(VALUE self, VALUE fieldName, VALUE value)
+{
+    Struct* s;
+    VALUE rbField;
+    StructField* f;
+    MemoryOp* op;
+    VALUE argv[2];
+
+    Data_Get_Struct(self, Struct, s);
+    rbField = struct_field(s, fieldName);
+    f = (StructField *) DATA_PTR(rbField);
+
+    op = ptr_get_op(s->pointer, f->type);
+    if (op != NULL) {
+        (*op->put)(s->pointer, f->offset, value);
+        return self;
+    }
+    
+    /* call up to the ruby code to set the value */
+    argv[0] = s->rbPointer;
+    argv[1] = value;
+    rb_funcall2(rbField, put_id, 2, argv);
+    
+    return self;
+}
+
+static VALUE
+struct_set_pointer(VALUE self, VALUE pointer)
+{
+    Struct* s;
+
+    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, pointer_var_id, pointer);
+
+    return self;
+}
+
+static VALUE
+struct_get_pointer(VALUE self)
+{
+    Struct* s;
+
+    Data_Get_Struct(self, Struct, s);
+
+    return s->rbPointer;
+}
+
+static VALUE
+struct_set_layout(VALUE self, VALUE layout)
+{
+    Struct* s;
+    Data_Get_Struct(self, Struct, s);
+
+    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, layout_var_id, layout);
+
+    return self;
+}
+
+static VALUE
+struct_get_layout(VALUE self)
+{
+    Struct* s;
+
+    Data_Get_Struct(self, Struct, s);
+
+    return s->rbLayout;
+}
+
+static VALUE
+struct_layout_allocate(VALUE klass)
+{
+    StructLayout* layout;
+    VALUE obj;
+    
+    obj = Data_Make_Struct(klass, StructLayout, struct_layout_mark, -1, layout);
+    layout->rbFields = Qnil;
+
+    return obj;
+}
+
+static VALUE
+struct_layout_initialize(VALUE self, VALUE field_names, VALUE fields, VALUE size, VALUE align)
+{
+    StructLayout* layout;
+    int i;
+
+    Data_Get_Struct(self, StructLayout, layout);
+    layout->rbFields = rb_hash_new();
+    layout->size = NUM2INT(size);
+    layout->align = NUM2INT(align);
+    
+    rb_iv_set(self, "@field_names", field_names);
+    rb_iv_set(self, "@fields", fields);
+    rb_iv_set(self, "@size", size);
+    rb_iv_set(self, "@align", align);
+
+    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, StructFieldClass)) {
+            rb_raise(rb_eArgError, "Invalid field");
+        }
+        rb_hash_aset(layout->rbFields, name, field);
+    }
+    return self;
+}
+
+static VALUE
+struct_layout_aref(VALUE self, VALUE field)
+{
+    StructLayout* layout;
+
+    Data_Get_Struct(self, StructLayout, layout);
+
+    return rb_hash_aref(layout->rbFields, field);
+}
+
+
+static void
+struct_layout_mark(StructLayout *layout)
+{
+    rb_gc_mark(layout->rbFields);
+}
+
+void
+rbffi_Struct_Init(VALUE moduleFFI)
+{
+    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(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(StructClass, "pointer", struct_get_pointer, 0);
+    rb_define_private_method(StructClass, "pointer=", struct_set_pointer, 1);
+
+    rb_define_method(StructClass, "layout", struct_get_layout, 0);
+    rb_define_private_method(StructClass, "layout=", struct_set_layout, 1);
+
+    rb_define_method(StructClass, "[]", struct_get_field, 1);
+    rb_define_method(StructClass, "[]=", struct_put_field, 2);
+    
+    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(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)
+    
+    FIELD(Signed8, int8, NATIVE_INT8, char);
+    FIELD(Unsigned8, uint8, NATIVE_UINT8, unsigned char);
+    FIELD(Signed16, int16, NATIVE_INT16, short);
+    FIELD(Unsigned16, uint16, NATIVE_UINT16, unsigned short);
+    FIELD(Signed32, int32, NATIVE_INT32, int);
+    FIELD(Unsigned32, uint32, NATIVE_UINT32, unsigned int);
+    FIELD(Signed64, int64, NATIVE_INT64, long long);
+    FIELD(Unsigned64, uint64, NATIVE_UINT64, unsigned long long);
+    FIELD(FloatField, float32, NATIVE_FLOAT32, float);
+    FIELD(DoubleField, float64, NATIVE_FLOAT64, double);
+    FIELD(PointerField, pointer, NATIVE_POINTER, char *);
+    FIELD(StringField, string, NATIVE_STRING, char *);
+}