wrb 2.0.0

data/ext/rwin/rw_api.c

@@ -0,0 +1,2058 @@
+/*
+# Project WRB was forked from Project VisualuRuby(temp-name).
+# Author of this project: BANJO Koyu <banjokoyu at gmail.com>
+# The URL of this project: https://bitbucket.org/wrb/
+#
+# This is a ext-library part of WRB.
+*/
+
+#include "rwin.h"
+
+/* ##################### local structures ##################### */
+
+typedef struct {
+    AAtree *libs;
+} ApiFuncLibs;
+
+/* ####################### destructors ######################## */
+
+void
+aa_callback_libs(const AAnode *node, void *arg){
+	FreeLibrary((HMODULE)node->key);
+}
+
+void
+destruct_libs(ApiFuncLibs *libs){
+    if(libs->libs) {
+	aaForeach(libs->libs, aa_callback_libs, NULL);
+	freeAAtree(libs->libs);
+    }
+    free(libs);
+}
+
+/* ###################### global variables ##################### */
+VALUE mRwAPI;
+VALUE cRwAPIfunc;
+VALUE cRwAPIstruct;
+VALUE cRwAPIstructArrayPart;
+VALUE apifunc_class_libs;
+
+AAtree *apifunc_libs;
+
+static HMODULE current_hModule;
+
+int _id_cstruct_size;
+int _id_cstruct_template;
+int _id_cstruct_s_offsets;
+int _id_cstruct_s_classes;
+
+/* ##################### static prototypes ##################### */
+static VALUE cstruct_cast_(VALUE klass, VALUE parent, int offset, int len);
+static VALUE cstruct1_newptr(int argc, VALUE *argv, VALUE klass);
+static VALUE cstruct1_alloc_int(VALUE klass, VALUE arg);
+static VALUE cstruct1_alloc_int_ptr(VALUE klass, VALUE arg);
+static VALUE cstruct_set_idx_value__(int argc, VALUE *argv, VALUE self);
+
+/* ######################## CStruct type definition ######################## */
+const VALUE v_zero = INT2FIX(0);
+const VALUE v_one = INT2FIX(1);
+
+void cstructdata_mark(void *ptr){
+    if(ptr) {
+	CStructData *data = ptr;
+	if (data->dtparent) rb_gc_mark(data->dtparent);
+    }
+}
+
+void cstructdata_free(void *ptr){
+    if(ptr){
+	CStructData *data = ptr;
+	if (data->dtstr && !data->dtwrapped){ free(data->dtstr);}
+	free(data);
+    }
+}
+
+static size_t
+cstruct_memsize(const void *ptr){
+    return ptr ? sizeof(CStructData) : 0;
+}
+
+const rb_data_type_t cstruct_data_type = {
+    "Cstruct",
+    {NULL, cstructdata_free, cstruct_memsize}, NULL, NULL
+};
+
+static const rb_data_type_t cstruct_data_type_default_free = {
+    "Cstruct_df", 
+    {cstructdata_mark, RUBY_TYPED_DEFAULT_FREE, cstruct_memsize}, &cstruct_data_type, NULL
+};
+
+#define CStruct_Data_Make_Struct_Default_Free(obj, sval) \
+  TypedData_Make_Struct(obj, CStructData, &cstruct_data_type_default_free, sval)
+
+/* ######################## Callback Macros ######################## */
+
+#define DEFINE_CALLBACK_FUNC(m, n) \
+static LRESULT CALLBACK \
+ap_cb ##n##_0(LONG_PTR a0){\
+    VALUE r = rb_proc_call(rw_api_callback_procs[0*m+n], rb_ary_new());\
+    return NUM2LONG(r);\
+}\
+static LRESULT CALLBACK \
+ap_cb ##n##_1(LONG_PTR a0){\
+    VALUE r = rb_proc_call(rw_api_callback_procs[1*m+n], rb_ary_new3(1, LONG_PTR2NUM(a0)));\
+    return NUM2LONG_PTR(r);\
+}\
+static LRESULT CALLBACK \
+ap_cb ##n##_2(LONG_PTR a0,LONG_PTR a1){\
+    VALUE r = rb_proc_call(rw_api_callback_procs[2*m+n], rb_ary_new3(2, LONG_PTR2NUM(a0), LONG_PTR2NUM(a1)));\
+    return NUM2LONG_PTR(r);\
+}\
+static LRESULT CALLBACK \
+ap_cb ##n##_3(LONG_PTR a0,LONG_PTR a1,LONG_PTR a2){\
+    VALUE r = rb_proc_call(rw_api_callback_procs[3*m+n], rb_ary_new3(3, LONG_PTR2NUM(a0), LONG_PTR2NUM(a1), LONG_PTR2NUM(a2)));\
+    return NUM2LONG_PTR(r);\
+}\
+static LRESULT CALLBACK \
+ap_cb ##n##_4(LONG_PTR a0,LONG_PTR a1,LONG_PTR a2,LONG_PTR a3){\
+    VALUE r = rb_proc_call(rw_api_callback_procs[4*m+n], rb_ary_new3(4, LONG_PTR2NUM(a0), LONG_PTR2NUM(a1), LONG_PTR2NUM(a2), LONG_PTR2NUM(a3)));\
+    return NUM2LONG_PTR(r);\
+}\
+static LRESULT CALLBACK \
+ap_cb ##n##_5(LONG_PTR a0,LONG_PTR a1,LONG_PTR a2,LONG_PTR a3,LONG_PTR a4){\
+    VALUE r = rb_proc_call(rw_api_callback_procs[5*m+n], rb_ary_new3(5, LONG_PTR2NUM(a0), LONG_PTR2NUM(a1), LONG_PTR2NUM(a2), LONG_PTR2NUM(a3), LONG_PTR2NUM(a4)));\
+    return NUM2LONG_PTR(r);\
+}\
+static LRESULT CALLBACK \
+ap_cb ##n##_6(LONG_PTR a0,LONG_PTR a1,LONG_PTR a2,LONG_PTR a3,LONG_PTR a4,LONG_PTR a5){\
+    VALUE r = rb_proc_call(rw_api_callback_procs[6*m+n], rb_ary_new3(6, LONG_PTR2NUM(a0), LONG_PTR2NUM(a1), LONG_PTR2NUM(a2), LONG_PTR2NUM(a3), LONG_PTR2NUM(a4), LONG_PTR2NUM(a5)));\
+    return NUM2LONG_PTR(r);\
+}\
+static LRESULT CALLBACK \
+ap_cb ##n##_7(LONG_PTR a0,LONG_PTR a1,LONG_PTR a2,LONG_PTR a3,LONG_PTR a4,LONG_PTR a5,LONG_PTR a6){\
+    VALUE r = rb_proc_call(rw_api_callback_procs[7*m+n], rb_ary_new3(7, LONG_PTR2NUM(a0), LONG_PTR2NUM(a1), LONG_PTR2NUM(a2), LONG_PTR2NUM(a3), LONG_PTR2NUM(a4), LONG_PTR2NUM(a5), LONG_PTR2NUM(a6)));\
+    return NUM2LONG_PTR(r);\
+}\
+static LRESULT CALLBACK \
+ap_cb ##n##_8(LONG_PTR a0,LONG_PTR a1,LONG_PTR a2,LONG_PTR a3,LONG_PTR a4,LONG_PTR a5,LONG_PTR a6,LONG_PTR a7){\
+    VALUE r = rb_proc_call(rw_api_callback_procs[8*m+n], rb_ary_new3(8, LONG_PTR2NUM(a0), LONG_PTR2NUM(a1), LONG_PTR2NUM(a2), LONG_PTR2NUM(a3), LONG_PTR2NUM(a4), LONG_PTR2NUM(a5), LONG_PTR2NUM(a6), LONG_PTR2NUM(a7)));\
+    return NUM2LONG_PTR(r);\
+}
+
+#define MAX_CALLBACK_ARITY 9
+#define MAX_CALLBACK_ENTRY 10
+
+#define CREATE_CALLBACK_ENTRIES(n) \
+    rw_api_callback_funcs[MAX_CALLBACK_ENTRY*0 + n] = (ULONG_PTR)ap_cb ##n##_0;\
+    rw_api_callback_funcs[MAX_CALLBACK_ENTRY*1 + n] = (ULONG_PTR)ap_cb ##n##_1;\
+    rw_api_callback_funcs[MAX_CALLBACK_ENTRY*2 + n] = (ULONG_PTR)ap_cb ##n##_2;\
+    rw_api_callback_funcs[MAX_CALLBACK_ENTRY*3 + n] = (ULONG_PTR)ap_cb ##n##_3;\
+    rw_api_callback_funcs[MAX_CALLBACK_ENTRY*4 + n] = (ULONG_PTR)ap_cb ##n##_4;\
+    rw_api_callback_funcs[MAX_CALLBACK_ENTRY*5 + n] = (ULONG_PTR)ap_cb ##n##_5;\
+    rw_api_callback_funcs[MAX_CALLBACK_ENTRY*6 + n] = (ULONG_PTR)ap_cb ##n##_6;\
+    rw_api_callback_funcs[MAX_CALLBACK_ENTRY*7 + n] = (ULONG_PTR)ap_cb ##n##_7;\
+    rw_api_callback_funcs[MAX_CALLBACK_ENTRY*8 + n] = (ULONG_PTR)ap_cb ##n##_8;\
+
+ULONG_PTR rw_api_callback_funcs[MAX_CALLBACK_ENTRY * MAX_CALLBACK_ARITY];
+VALUE rw_api_callback_procs[MAX_CALLBACK_ENTRY * MAX_CALLBACK_ARITY];
+
+DEFINE_CALLBACK_FUNC(MAX_CALLBACK_ENTRY, 0);
+DEFINE_CALLBACK_FUNC(MAX_CALLBACK_ENTRY, 1);
+DEFINE_CALLBACK_FUNC(MAX_CALLBACK_ENTRY, 2);
+DEFINE_CALLBACK_FUNC(MAX_CALLBACK_ENTRY, 3);
+DEFINE_CALLBACK_FUNC(MAX_CALLBACK_ENTRY, 4);
+DEFINE_CALLBACK_FUNC(MAX_CALLBACK_ENTRY, 5);
+DEFINE_CALLBACK_FUNC(MAX_CALLBACK_ENTRY, 6);
+DEFINE_CALLBACK_FUNC(MAX_CALLBACK_ENTRY, 7);
+DEFINE_CALLBACK_FUNC(MAX_CALLBACK_ENTRY, 8);
+DEFINE_CALLBACK_FUNC(MAX_CALLBACK_ENTRY, 9);
+
+static void
+api_init_CallbackProcs(){
+    rb_define_const(cRwAPIfunc, "MaxCallbackFuncEntry", INT2FIX(MAX_CALLBACK_ENTRY));
+    rb_define_const(cRwAPIfunc, "MaxCallbackFuncArity", INT2FIX(MAX_CALLBACK_ARITY));
+    
+    CREATE_CALLBACK_ENTRIES(0);
+    CREATE_CALLBACK_ENTRIES(1);
+    CREATE_CALLBACK_ENTRIES(2);
+    CREATE_CALLBACK_ENTRIES(3);
+    CREATE_CALLBACK_ENTRIES(4);
+    CREATE_CALLBACK_ENTRIES(5);
+    CREATE_CALLBACK_ENTRIES(6);
+    CREATE_CALLBACK_ENTRIES(7);
+    CREATE_CALLBACK_ENTRIES(8);
+    CREATE_CALLBACK_ENTRIES(9);
+}
+
+/* ################ RWin::API::CFuncs ################ */
+
+static size_t
+cfunc_memsize(const void *ptr){
+    return ptr ? sizeof(CFuncData) : 0;
+}
+
+const rb_data_type_t cfunc_data_type = {
+    "CFunc", {NULL, NULL, cfunc_memsize}, NULL, NULL
+};
+
+static VALUE
+api_cfunc1_loadlib(VALUE klass, VALUE dllname){
+    HANDLE hdl;
+    VALUE hdll;
+    AAnode *node;
+    hdl = LoadLibraryA(RSTRING_PTR(dllname));
+    if (hdl==0) rb_raise( rb_eRuntimeError, "Can't load: %s\n", RSTRING_PTR(dllname));
+    hdll = ULONG_PTR2NUM((ULONG_PTR)hdl);
+    node = aaSearch(apifunc_libs, (ULONG_PTR)hdl);
+    if (node) {
+	FreeLibrary(hdl);
+    } else { //fprintf(stderr, "%s, %d\n", RSTRING_PTR(dllname), (ULONG_PTR)hdl);
+	aaInsert(apifunc_libs, (ULONG_PTR)hdl, 0);
+    }
+    current_hModule = hdl;
+    return hdll;
+}
+
+static VALUE
+cfunc_alloc(VALUE klass){
+    CFuncData *cf;
+    VALUE obj = CFunc_Data_Make_Struct(klass, cf);
+    return obj;
+}
+
+static void
+aa_callback_search_libs(const AAnode *node, void *arg){
+    if (node->key != (ULONG_PTR)current_hModule) {
+	VALUE pair = (VALUE)arg;
+	FARPROC hproc = GetProcAddress((HMODULE)node->key, RSTRING_PTR(rb_ary_entry(pair, 0)));
+	if (hproc){
+	    rb_ary_store(pair, 1, ULONG_PTR2NUM((ULONG_PTR)hproc));
+	}
+    }
+}
+
+static VALUE
+api_initialize(VALUE self, VALUE procname, VALUE nargs){
+    CFuncData *cf;
+    VALUE v_procaddress;
+    FARPROC hproc = NULL;
+    if(current_hModule) hproc = GetProcAddress(current_hModule, RSTRING_PTR(procname));
+    if (hproc){
+	cf = DATA_PTR(self);
+	cf->nargs = FIX2INT(nargs);
+	cf->procaddress = (ULONG_PTR)hproc;
+	v_procaddress = ULONG_PTR2NUM((ULONG_PTR)hproc);
+    } else {
+	VALUE pair = rb_ary_new3(2, procname, Qnil);
+	aaForeach(apifunc_libs, aa_callback_search_libs, (void*)pair);
+	v_procaddress = rb_ary_entry(pair, 1);
+	if (NIL_P(v_procaddress)) {
+	    rb_raise(rb_eRuntimeError,"Can't GetProcAddress: `%s'\r\n", RSTRING_PTR(procname));
+	}
+	cf = DATA_PTR(self);
+	cf->nargs = FIX2INT(nargs);
+	cf->procaddress = NUM2ULONG_PTR(v_procaddress);
+    }
+    return v_procaddress;
+}
+
+static VALUE
+api_cfunc1_getfunc(VALUE klass, VALUE procname, VALUE nargs){
+    VALUE obj;
+    CFuncData *cf;
+    FARPROC hproc = NULL;
+    if(current_hModule) hproc = GetProcAddress(current_hModule, RSTRING_PTR(procname));
+    if (hproc){
+	obj = CFunc_Data_Make_Struct(klass, cf);
+	cf->nargs = FIX2INT(nargs);
+	cf->procaddress = (ULONG_PTR)hproc;
+    } else {
+	VALUE v_procaddress;
+	VALUE pair = rb_ary_new3(2, procname, Qnil);
+	aaForeach(apifunc_libs, aa_callback_search_libs, (void*)pair);
+	v_procaddress = rb_ary_entry(pair, 1);
+	if (NIL_P(v_procaddress)) return Qnil;
+	obj = CFunc_Data_Make_Struct(klass, cf);
+	cf->nargs = FIX2INT(nargs);
+	cf->procaddress = NUM2ULONG_PTR(v_procaddress);
+    }
+    return obj;
+}
+
+//static long
+static ULONG_PTR
+api_bind_callback_proc_core(VALUE proc){
+    int n;
+    int nfree = MAX_CALLBACK_ENTRY;
+    int arity = rb_proc_arity(proc);
+    for(n=0; n<MAX_CALLBACK_ENTRY; n++){
+	int i = arity * MAX_CALLBACK_ENTRY + n;
+	VALUE obj = rw_api_callback_procs[i];
+	if(proc == obj) return rw_api_callback_funcs[i];
+	if(obj==0){
+	    if (n < nfree) nfree = n;
+	} else if(RBASIC(obj)->flags==0){
+	    rw_api_callback_procs[i] = 0;
+	    if (n < nfree) nfree = n;
+	}
+    }
+    if(nfree < MAX_CALLBACK_ENTRY){
+	int i = arity * MAX_CALLBACK_ENTRY + nfree;
+	rw_api_callback_procs[i] = proc;
+	return rw_api_callback_funcs[i];
+    }
+    rb_raise(rb_eRuntimeError,
+	     "Can't register callback proc any more (over %d)", MAX_CALLBACK_ENTRY);
+}
+
+static VALUE
+api_bind_callback_proc(VALUE klass, VALUE proc){
+    return ULONG_PTR2NUM(api_bind_callback_proc_core(proc));
+}
+
+static VALUE
+api_release_callback_proc(VALUE klass, VALUE proc){
+    int i;
+    int arity = rb_proc_arity(proc);
+    for(i=arity*MAX_CALLBACK_ARITY; i<(arity+1)*MAX_CALLBACK_ARITY; i++){
+	VALUE obj = rw_api_callback_procs[i];
+	if(proc == obj) {
+	    rw_api_callback_procs[i] = 0;
+	    return Qtrue;
+	}
+    }
+    return Qfalse;
+}
+
+static ULONG_PTR api_call_get_proc(VALUE self, int argc){
+    CFuncData *cf = DATA_PTR(self);
+    if(cf->nargs != argc){
+	rb_raise( rb_eRuntimeError,
+		  "Num of args is different : expected %d, but got %d\n", cf->nargs, argc);
+    }
+    return cf->procaddress;
+}
+
+static void
+api_call_set_args(VALUE self, int argc, VALUE *argv, ULONG_PTR *calldata){
+    int i;
+    VALUE arg;
+    CStructData *data;
+    for (i = 0; i < argc; i++){
+	arg = argv[i];
+	switch (TYPE(arg)){
+	  case T_DATA:
+	    if (rb_typeddata_is_kind_of(arg, &cstruct_data_type)){
+		CStruct_Data_Get_Struct(arg, data);
+		calldata[i+1] = (ULONG_PTR)(data->dtstr+data->dtoffset);
+	    } else if (rb_obj_is_proc(arg)) {
+		calldata[i+1] = api_bind_callback_proc_core(arg);
+	    } else {
+		rb_raise(rb_eRuntimeError, "Argument is neither a CStruct nor a Proc");
+	    }
+	    break;
+	  case T_STRING:
+	    calldata[i+1] = (ENCODING_IS_ASCII8BIT(arg)) ? (ULONG_PTR)RSTRING_PTR(arg) :
+	                                                   (ULONG_PTR)rw_str2tchar(arg);
+	    break;
+	  case T_NIL:
+	    calldata[i+1] = (ULONG_PTR)0;
+	    break;
+	  case T_FIXNUM:
+	  case T_BIGNUM:
+	    calldata[i+1] = NUM2ULONG_PTR(arg);
+	    break;
+	  default:
+	    rb_raise(rb_eRuntimeError, "Unrecognised type of argument");
+	}
+    }
+}
+
+static VALUE
+api_call(int argc, VALUE *argv, VALUE self){
+    ULONG_PTR proc_address = api_call_get_proc(self, argc);
+    ULONG_PTR *calldata = alloca((argc+2)*sizeof(ULONG_PTR));
+    calldata[0] = proc_address;
+    api_call_set_args(self, argc, argv, calldata);	
+    switch (argc){
+      case 0:
+	return ULONG_PTR2NUM(rw_call_std_func_0(calldata));
+      case 1:
+	return ULONG_PTR2NUM(rw_call_std_func_1(calldata));
+      case 2:
+	return ULONG_PTR2NUM(rw_call_std_func_2(calldata));
+      case 3:
+	return ULONG_PTR2NUM(rw_call_std_func_3(calldata));
+      case 4:
+	return ULONG_PTR2NUM(rw_call_std_func_4(calldata));
+      case 5:
+	return ULONG_PTR2NUM(rw_call_std_func_5(calldata));
+      case 6:
+	return ULONG_PTR2NUM(rw_call_std_func_6(calldata));
+      case 7:
+	return ULONG_PTR2NUM(rw_call_std_func_7(calldata));
+      case 8:
+	return ULONG_PTR2NUM(rw_call_std_func_8(calldata));
+      case 9:
+	return ULONG_PTR2NUM(rw_call_std_func_9(calldata));
+      case 10:
+	return ULONG_PTR2NUM(rw_call_std_func_10(calldata));
+      case 11:
+	return ULONG_PTR2NUM(rw_call_std_func_11(calldata));
+      case 12:
+	return ULONG_PTR2NUM(rw_call_std_func_12(calldata));
+      default:
+	rb_raise(rb_eArgError, "Too many args: %d > 12.", argc);
+	return Qnil;
+    }
+    return Qnil;
+}
+
+/*
+  DO NOT USE "call_ubf" easely, otherwise you'll get SEGV easely.
+  (only for function similar to SendMessage)
+*/
+
+static VALUE
+api_call_ubf(int argc, VALUE *argv, VALUE self){
+    ULONG_PTR proc_address = api_call_get_proc(self, argc);
+    ULONG_PTR *calldata = alloca((argc+1)*sizeof(ULONG));
+    //ULONG calldata[argc+1];
+    calldata[0] = proc_address;
+    api_call_set_args(self, argc, argv, calldata);	
+    switch (argc){
+      case 0:
+	return ULONG_PTR2NUM(CALL_NON_GVL_FUNC(rw_call_std_func_0, calldata));
+      case 1:
+	return ULONG_PTR2NUM(CALL_NON_GVL_FUNC(rw_call_std_func_1, calldata));
+      case 2:
+	return ULONG_PTR2NUM(CALL_NON_GVL_FUNC(rw_call_std_func_2, calldata));
+      case 3:
+	return ULONG_PTR2NUM(CALL_NON_GVL_FUNC(rw_call_std_func_3, calldata));
+      case 4:
+	return ULONG_PTR2NUM(CALL_NON_GVL_FUNC(rw_call_std_func_4, calldata));
+      case 5:
+	return ULONG_PTR2NUM(CALL_NON_GVL_FUNC(rw_call_std_func_5, calldata));
+      case 6:
+	return ULONG_PTR2NUM(CALL_NON_GVL_FUNC(rw_call_std_func_6, calldata));
+      case 7:
+	return ULONG_PTR2NUM(CALL_NON_GVL_FUNC(rw_call_std_func_7, calldata));
+      case 8:
+	return ULONG_PTR2NUM(CALL_NON_GVL_FUNC(rw_call_std_func_8, calldata));
+      case 9:
+	return ULONG_PTR2NUM(CALL_NON_GVL_FUNC(rw_call_std_func_9, calldata));
+      case 10:
+	return ULONG_PTR2NUM(CALL_NON_GVL_FUNC(rw_call_std_func_10, calldata));
+      case 11:
+	return ULONG_PTR2NUM(CALL_NON_GVL_FUNC(rw_call_std_func_11, calldata));
+      case 12:
+	return ULONG_PTR2NUM(CALL_NON_GVL_FUNC(rw_call_std_func_12, calldata));
+      default:
+	rb_raise(rb_eArgError, "Too many args: %d > 12.)", argc);
+	return Qnil;
+    }
+    return Qnil;
+}
+
+
+/* additional definition of API functions */
+
+static VALUE
+api_message_core(FARPROC msgproc, VALUE hwnd, VALUE umsg, VALUE wparam, VALUE lparam){
+    HWND hw = (HWND)NUM2ULONG_PTR(hwnd);
+    ULONG um = NUM2UINT(umsg);
+    WPARAM wp = NUM2ULONG_PTR(wparam);
+    LPARAM lp;
+    if (TYPE(lparam) == T_STRING){
+	lp = (ULONG_PTR)(ENCODING_IS_ASCII8BIT(lparam) ? RSTRING_PTR(lparam) :
+		                                     (char*)rw_str2tchar(lparam));
+    }else{
+	lp = NUM2ULONG_PTR(lparam);
+    }
+    return INT2NUM(rw_call_without_gvl_4(0, msgproc, (ULONG_PTR)hw, um, wp, lp));
+}
+
+static VALUE
+api_sendmessage(VALUE klass, VALUE hwnd, VALUE umsg, VALUE wparam, VALUE lparam){
+    return api_message_core((FARPROC)SendMessage, (ULONG_PTR)hwnd, umsg, wparam, lparam);
+}
+
+static VALUE
+api_postmessage(VALUE klass, VALUE hwnd, VALUE umsg, VALUE wparam, VALUE lparam){
+    return api_message_core((FARPROC)PostMessage, hwnd, umsg, wparam, lparam);
+}
+
+
+static VALUE
+api_g_alloc_str(VALUE klass,VALUE uFlags, VALUE text){
+    int len = RSTRING_LEN(text);
+    HGLOBAL hmem = GlobalAlloc(NUM2UINT(uFlags), len+1);
+    char* ptr = GlobalLock(hmem);
+    if (!ptr) rb_raise(rb_eRuntimeError, "Global Lock failed");
+    memcpy(ptr, RSTRING_PTR(text), len);
+    ptr[len+1] = 0; 
+    GlobalUnlock(hmem);
+    return ULONG_PTR2NUM((ULONG_PTR)hmem);
+}
+
+static VALUE
+api_g_get_str(VALUE klass, VALUE hMem){
+    VALUE val;
+    int len;
+    HGLOBAL hmem = (HGLOBAL)NUM2ULONG_PTR(hMem);
+    char* ptr = GlobalLock(hmem);
+    if (!ptr) rb_raise(rb_eRuntimeError, "Global Lock failed");
+    len = GlobalSize(hmem);
+    val = rb_str_new(ptr, len);
+    GlobalUnlock(hmem);
+    return val;
+}
+
+/* ################### RWin::API::CStruct ################## */
+/* enums */
+typedef enum{
+    dt_B=1, dt_C, dt_H, dt_W, dt_L, dt_U, dt_S,
+    dt_s, dt_l, dt_u, dt_i, dt_q, dt_I, dt_Q, dt_K, dt_P
+} CST_GET_FUNCS;
+
+/* structures */
+typedef struct {
+    WORD offset;
+    BYTE ifunc;
+    BYTE mblen;
+    WORD nth;
+    WORD klsidx;
+} RWOffsetData;
+
+typedef struct {
+    WORD size;
+    WORD realsize;
+    WORD cmembers;
+    BYTE maxmblen;
+    BYTE packed;
+} RWCSAttribute;
+
+/* inlines */
+static inline RWCSAttribute*
+cs_get_offset_attribute(VALUE klass){
+    char *ptr = RSTRING_PTR(rb_const_get(klass, _id_cstruct_s_offsets));
+    return (RWCSAttribute*)ptr;
+}
+
+static inline RWOffsetData*
+cs_get_offset_data(VALUE klass, int index){
+    char *ptr = RSTRING_PTR(rb_const_get(klass, _id_cstruct_s_offsets));
+    return (RWOffsetData*)(ptr+sizeof(RWCSAttribute)+index*sizeof(RWOffsetData));
+}
+
+static inline void
+rw_set_offdata(RWOffsetData *offdata, WORD offset, BYTE ifunc, BYTE mblen, WORD nth, WORD kidx){
+    offdata->offset = offset;
+    offdata->ifunc = ifunc;
+    offdata->mblen = mblen;
+    offdata->nth = nth;
+    offdata->klsidx = kidx;
+}
+
+static inline ULONG
+rw_num2ulong(VALUE x) {
+    if(FIXNUM_P(x)) return FIX2ULONG(x);
+    else if(RB_TYPE_P(x, T_BIGNUM)) return rb_big2ulong(x);
+    else rb_raise(rb_eTypeError, "%s is not an Integer", RSTRING_PTR(rb_inspect(x)));
+}
+
+static inline LONG
+rw_num2long(VALUE x) {
+    if(FIXNUM_P(x)) return FIX2LONG(x);
+    else if(RB_TYPE_P(x, T_BIGNUM)) return rb_big2long(x);
+    else rb_raise(rb_eTypeError, "%s is not an Integer", RSTRING_PTR(rb_inspect(x)));
+}
+
+static inline int
+cst_adjust_align(int offset, int sz){
+    return offset ? ((offset/sz) + ((offset%sz) ? 1 : 0)) * sz : 0;
+}
+
+/* common funcs */
+static int
+cs_get_count(VALUE self){
+    int n;
+    CStructData *cd = DATA_PTR(self);
+    if(cd->bifunc) { /* ArrayPart */
+	VALUE klass = rb_class_of(cd->dtparent ? cd->dtparent : self);
+	n = cd->dtlen / cs_get_offset_data(klass, cd->prindex)->mblen;
+    }else{
+	VALUE klass = rb_class_of(self);
+	n = cs_get_offset_attribute(klass)->cmembers;
+	if (n==1){
+	    n = cd->dtlen / cs_get_offset_data(klass, 0)->mblen;
+	}
+    }
+    return n;
+}
+
+/* ############## alloc functions ################ */
+
+static VALUE
+cstruct_alloc(VALUE klass){
+    CStructData *cd;
+    VALUE obj = CStruct_Data_Make_Struct(klass, cd);
+    if(cs_get_offset_attribute(klass)->cmembers==1){
+	cd->bifunc = cs_get_offset_data(klass, 0)->ifunc;
+    }
+    return obj;
+}
+
+/* for internal use */
+VALUE
+api_cstruct_new(VALUE klass){
+    char *data;
+    VALUE obj = cstruct_alloc(klass);
+    CStructData *cd = DATA_PTR(obj);
+    int len = FIX2INT(rb_const_get(klass, _id_cstruct_size));
+    RW_CALLOC(data, len);
+    cd->dtstr = data;
+    cd->dtlen = len;
+    return obj;
+}
+
+/* data manipulation functions */
+/* ############ gets ########## */
+
+static VALUE
+cst_get_a_dt_L(CStructData *cd, int offset){
+    char *ptr;
+    if(offset+sizeof(LONG) > cd->dtlen) rb_bug("Out of bounds.");
+    ptr = cd->dtstr + cd->dtoffset + offset;
+    return INT2NUM(*(int*)ptr);
+}
+
+static VALUE
+cst_get_a_dt_U(CStructData *cd, int offset){
+    char *ptr;
+    if(offset+sizeof(LONG) > cd->dtlen) rb_bug("Out of bounds.");
+    ptr = cd->dtstr + cd->dtoffset + offset;
+    return UINT2NUM(*(int*)ptr);
+}
+
+static VALUE
+cst_get_a_dt_H(CStructData *cd, int offset){
+    char *ptr;
+    if(offset+sizeof(short) > cd->dtlen) rb_bug("Out of bounds.");
+    ptr = cd->dtstr + cd->dtoffset + offset;
+    return UINT2NUM(*(short*)ptr & 0x0000ffff);
+}
+
+static VALUE
+cst_get_a_dt_C(CStructData *cd, int offset){
+    char *ptr;
+    if(offset+sizeof(char) > cd->dtlen) rb_bug("Out of bounds.");
+    ptr = cd->dtstr + cd->dtoffset + offset;
+    return UINT2NUM(*(char*)ptr & 0x000000ff);
+}
+
+static VALUE
+cst_get_a_dt_Q(CStructData *cd, int offset){
+    char *ptr;
+    if(offset+sizeof(LONG_PTR) > cd->dtlen) rb_bug("Out of bounds.");
+    ptr = cd->dtstr + cd->dtoffset + offset;
+    return ULONG_PTR2NUM(*(ULONG_PTR*)ptr);
+}
+
+static VALUE
+cst_get_a_dt_I(CStructData *cd, int offset){
+    char *ptr;
+    if(offset+sizeof(LONG_PTR) > cd->dtlen) rb_bug("Out of bounds.");
+    ptr = cd->dtstr + cd->dtoffset + offset;
+    return LONG_PTR2NUM(*(LONG_PTR*)ptr);
+}
+
+static VALUE
+cst_get_a_dt_S(CStructData *cd, int offset){
+    char *ptr; ULONG_PTR ptr2data;
+    if(offset+sizeof(void*) > cd->dtlen) rb_bug("Out of bounds.");
+    ptr = cd->dtstr + cd->dtoffset + offset;
+    ptr2data = *(long*)ptr;
+    return ptr2data ? rw_encode_external((TCHAR*)ptr2data) : Qnil;
+}
+
+static VALUE /* Get as un-encoded String */
+cst_get_a_dt_s(CStructData *cd, int offset){
+    char *ptr; ULONG_PTR ptr2data;
+    if(offset+sizeof(void*) > cd->dtlen) rb_bug("Out of bounds.");
+    ptr = cd->dtstr + cd->dtoffset + offset;
+    ptr2data =  *(long*)ptr;
+    return ptr2data ? rb_str_new2((char*)ptr2data) : Qnil;
+}
+
+static VALUE
+cst_get_a_dt_l(CStructData *cd, int offset){
+    char *ptr; ULONG_PTR ptr2data;
+    if(offset+sizeof(void*) > cd->dtlen) rb_bug("Out of bounds.");
+    ptr = cd->dtstr + cd->dtoffset + offset;
+    ptr2data = *(ULONG_PTR*)ptr;
+    if (!ptr2data) rb_raise(rb_eRuntimeError, "NULL pointer given");
+    return LONG2NUM(*(LONG*)ptr2data);
+}
+
+static VALUE
+cst_get_a_dt_u(CStructData *cd, int offset){
+    char *ptr; ULONG_PTR ptr2data;
+    if(offset+sizeof(void*) > cd->dtlen) rb_bug("Out of bounds.");
+    ptr = cd->dtstr + cd->dtoffset + offset;
+    ptr2data = *(ULONG_PTR*)ptr;
+    if (!ptr2data) rb_raise(rb_eRuntimeError, "NULL pointer given");
+    return ULONG2NUM(*(ULONG*)ptr2data);
+}
+
+static VALUE
+cst_get_a_dt_i(CStructData *cd, int offset){
+    char *ptr; ULONG_PTR ptr2data;
+    if(offset+sizeof(void*) > cd->dtlen) rb_bug("Out of bounds.");
+    ptr = cd->dtstr + cd->dtoffset + offset;
+    ptr2data = *(ULONG_PTR*)ptr;
+    if (!ptr2data) rb_raise(rb_eRuntimeError, "NULL pointer given");
+    return LONG_PTR2NUM(*(LONG_PTR*)ptr2data);
+}
+
+static VALUE
+cst_get_a_dt_q(CStructData *cd, int offset){
+    char *ptr; ULONG_PTR ptr2data;
+    if(offset+sizeof(void*) > cd->dtlen) rb_bug("Out of bounds.");
+    ptr = cd->dtstr + cd->dtoffset + offset;
+    ptr2data = *(ULONG_PTR*)ptr;
+    if (!ptr2data) rb_raise(rb_eRuntimeError, "NULL pointer given");
+    return ULONG_PTR2NUM(*(ULONG_PTR*)ptr2data);
+}
+
+static VALUE
+cst_get_a_dt_K(VALUE self, int offset, VALUE klass){
+    return cstruct_cast_(klass, self, offset, //cs_get_class_size_of(klass));
+			 FIX2INT(rb_const_get(klass, _id_cstruct_size)));
+}
+
+static VALUE
+cst_get_a_dt_P(CStructData *cd, int offset, VALUE klass, VALUE self){
+    char *ptr; ULONG_PTR ptr2data;
+    if(offset+sizeof(void*) > cd->dtlen) rb_bug("Out of bounds.");
+    ptr = cd->dtstr + cd->dtoffset + offset;
+    ptr2data = *(long*)ptr;
+    if(ptr2data) return cstruct_wrapptr(klass, (char*)ptr2data, self);
+    return Qnil;
+}
+
+/* Array of functions */
+static VALUE
+(* cst_get_funcs[15])(CStructData*, int) = {
+    NULL,
+    cst_get_a_dt_C,
+    cst_get_a_dt_C,
+    cst_get_a_dt_H,
+    cst_get_a_dt_H,
+    cst_get_a_dt_L,
+    cst_get_a_dt_U,
+    cst_get_a_dt_S,
+    cst_get_a_dt_s,
+    cst_get_a_dt_l,
+    cst_get_a_dt_u,
+    cst_get_a_dt_i,
+    cst_get_a_dt_q,
+    cst_get_a_dt_I,
+    cst_get_a_dt_Q,
+};
+
+/* ############### sets ############# */
+
+static VALUE
+cst_set_a_dt_C(CStructData *cd, int offset, VALUE arg){
+    char *ptr = cd->dtstr + cd->dtoffset + offset;
+    if(offset+sizeof(BYTE) > cd->dtlen) rb_raise(rb_eRangeError, "Out of bounds.");
+    *(BYTE*)ptr = (BYTE)rw_num2ulong(arg);
+    return arg;
+}
+
+static VALUE
+cst_set_a_dt_H(CStructData *cd, int offset, VALUE arg){
+    char *ptr = cd->dtstr + cd->dtoffset + offset;
+    if(offset+sizeof(WORD) > cd->dtlen) rb_raise(rb_eRangeError, "Out of bounds.");
+    *(WORD*)ptr = (WORD)rw_num2ulong(arg);
+    return arg;
+}
+
+static VALUE
+cst_set_a_dt_L(CStructData *cd, int offset, VALUE arg){
+    char *ptr = cd->dtstr + cd->dtoffset + offset;
+    if(offset+sizeof(DWORD) > cd->dtlen) rb_raise(rb_eRangeError, "Out of bounds.");
+    *(DWORD*)ptr = (DWORD)rw_num2long(arg);
+    return arg;
+}
+
+static VALUE
+cst_set_a_dt_U(CStructData *cd, int offset, VALUE arg){
+    char *ptr = cd->dtstr + cd->dtoffset + offset;
+    if(offset+sizeof(DWORD) > cd->dtlen) rb_raise(rb_eRangeError, "Out of bounds.");
+    *(DWORD*)ptr = (DWORD)rw_num2ulong(arg);
+    return arg;
+}
+
+static VALUE
+cst_set_a_dt_S(CStructData *cd, int offset, VALUE arg){
+    CStructData* ptr2arg; void * ptr2data;
+    char *ptr = cd->dtstr + cd->dtoffset + offset;
+    if(offset+sizeof(void*) > cd->dtlen) rb_raise(rb_eRangeError, "Out of bounds.");
+    if(rb_typeddata_is_kind_of(arg, &cstruct_data_type)){
+	CStruct_Data_Get_Struct(arg, ptr2arg); 
+	ptr2data = ptr2arg->dtstr + ptr2arg->dtoffset;
+    }else{
+	switch (TYPE(arg)){
+	  case T_STRING:
+	    if (!ENCODING_IS_ASCII8BIT(arg)){
+		VALUE text = rb_str_encode(arg, internal_encoding, 0, Qnil);
+		rb_str_shared_replace(arg, text); /* Replaces original object, so take care. */
+	    } 
+	    ptr2data = RSTRING_PTR(arg);
+	    break;
+	  case T_FIXNUM:
+	  case T_BIGNUM:
+	    ptr2data = (void*)NUM2ULONG_PTR(arg);
+	    break;
+	  default:
+	    rb_raise(rb_eArgError, "Pointer data must be a String or CStruct or address of it");
+	}
+    }
+    *(ULONG_PTR*)ptr = (ULONG_PTR)ptr2data;
+    return arg;
+}
+
+static VALUE
+cst_set_a_dt_u(CStructData *cd, int offset, VALUE arg){
+    CStructData* ptr2arg; void * ptr2data; VALUE obj;
+    char *ptr = cd->dtstr + cd->dtoffset + offset;
+    if(offset+sizeof(void*) > cd->dtlen) rb_raise(rb_eRangeError, "Out of bounds.");
+    
+    if(rb_typeddata_is_kind_of(arg, &cstruct_data_type)){
+	CStruct_Data_Get_Struct(arg, ptr2arg);
+	ptr2data = ptr2arg->dtstr + ptr2arg->dtoffset;
+    } else if (TYPE(arg) == T_STRING) {
+	ptr2data = StringValuePtr(arg);
+    } else if (TYPE(arg) == T_FIXNUM || TYPE(arg) == T_BIGNUM) {
+	obj = cstruct1_alloc_int(cRwAPIstruct, arg);
+	CStruct_Data_Get_Struct(obj, ptr2arg);
+	ptr2data = ptr2arg->dtstr + ptr2arg->dtoffset;
+    } else {
+	rb_raise(rb_eArgError, "Pointer data must be a String or CStruct");
+    }
+    *(ULONG_PTR*)ptr = (ULONG_PTR)ptr2data;
+    return arg;
+}
+
+static VALUE
+cst_set_a_dt_q(CStructData *cd, int offset, VALUE arg){
+    CStructData* ptr2arg; void * ptr2data; VALUE obj;
+    char *ptr = cd->dtstr + cd->dtoffset + offset;
+    if(offset+sizeof(void*) > cd->dtlen) rb_raise(rb_eRangeError, "Out of bounds.");
+    
+    if(rb_typeddata_is_kind_of(arg, &cstruct_data_type)){
+	CStruct_Data_Get_Struct(arg, ptr2arg);
+	ptr2data = ptr2arg->dtstr + ptr2arg->dtoffset;
+    } else if (TYPE(arg) == T_STRING) {
+	ptr2data = StringValuePtr(arg);
+    } else if (TYPE(arg) == T_FIXNUM || TYPE(arg) == T_BIGNUM) {
+	obj = cstruct1_alloc_int_ptr(cRwAPIstruct, arg);
+	CStruct_Data_Get_Struct(obj, ptr2arg);
+	ptr2data = ptr2arg->dtstr + ptr2arg->dtoffset;
+    } else {
+	rb_raise(rb_eArgError, "Pointer data must be a String or CStruct");
+    }
+    *(ULONG_PTR*)ptr = (ULONG_PTR)ptr2data;
+    return arg;
+}
+
+static VALUE
+cst_set_a_dt_Q(CStructData *cd, int offset, VALUE arg){
+    char *ptr = cd->dtstr + cd->dtoffset + offset;
+    if(offset+sizeof(void*) > cd->dtlen) rb_raise(rb_eRangeError, "Out of bounds.");
+    *(ULONG_PTR*)ptr = (ULONG_PTR)NUM2ULONG_PTR(arg);
+    return arg;
+}
+
+static VALUE
+cst_set_a_dt_K(CStructData *cd, int offset, VALUE klass, VALUE arg){
+    char *ptr = cd->dtstr + cd->dtoffset + offset;
+    if(rb_class_of(arg)==klass){
+	CStructData* ptr2arg;
+	CStruct_Data_Get_Struct(arg, ptr2arg);
+	memcpy(ptr, ptr2arg->dtstr + ptr2arg->dtoffset, ptr2arg->dtlen);
+    }else{
+	rb_raise(rb_eRuntimeError, "Struct type is differnt: expected %s, but got %s",
+		 rb_class2name(klass), rb_obj_classname(arg));
+    }
+    return arg;
+}
+
+ // not work
+static VALUE
+cst_set_a_dt_P(CStructData *cd, int offset, VALUE klass, VALUE arg){
+    CStructData* ptr2arg;
+    char *ptr = cd->dtstr + cd->dtoffset + offset;
+    if(offset+sizeof(void*) > cd->dtlen) rb_raise(rb_eRangeError, "Out of bounds.");
+    if(klass!=rb_class_of(arg)) {
+	rb_raise(rb_eArgError, "Arg type is differnt: expected %s, but got %s",
+		 rb_class2name(klass), rb_obj_classname(arg));
+    }
+    CStruct_Data_Get_Struct(arg, ptr2arg);
+    *(long*)ptr = (ULONG_PTR)(ptr2arg->dtstr + ptr2arg->dtoffset);
+    return arg;
+}
+
+static VALUE
+(* cst_set_funcs[15])(CStructData*, int, VALUE) = {
+    NULL,
+    cst_set_a_dt_C,
+    cst_set_a_dt_C,
+    cst_set_a_dt_H,
+    cst_set_a_dt_H,
+    cst_set_a_dt_L,
+    cst_set_a_dt_U,
+    cst_set_a_dt_S,
+    cst_set_a_dt_S,
+    cst_set_a_dt_u,
+    cst_set_a_dt_u,
+    cst_set_a_dt_q,
+    cst_set_a_dt_q,
+    cst_set_a_dt_Q,
+    cst_set_a_dt_Q,
+};
+
+/********************** Array ***********************/
+static void
+cst_str_copy_src_to_dest(CStructData *pd, VALUE arg, int offset2){
+    if (rb_typeddata_is_kind_of(arg, &cstruct_data_type)){
+	CStructData *sd;
+	size_t slen;
+	CStruct_Data_Get_Struct(arg, sd);
+	slen = sd->dtlen;
+	if(pd->dtlen+offset2 < slen) rb_raise(rb_eRangeError, "Reached the end of data");
+	memcpy(pd->dtstr, sd->dtstr+offset2, slen);
+    }else
+      rb_raise(rb_eArgError, "Argument must be a String or a CStruct");
+}
+
+static VALUE
+cst_set_ary_dt_W(CStructData *cd, int offset, VALUE arg){
+    VALUE apistr;
+    wchar_t *buff;
+    size_t slen;
+    int offset2 = offset + cd->dtoffset;
+    char *ptr = cd->dtstr + offset2;
+    switch (TYPE(arg)){
+      case T_STRING:
+	apistr = rb_str_encode(arg, wchar_encoding, 0, Qnil);
+	buff = (wchar_t*)RSTRING_PTR(apistr);
+	slen = RSTRING_LEN(apistr);
+	if(slen+offset2 > cd->dtlen) rb_raise(rb_eRangeError, "Reached the end of data");
+	memcpy(ptr, buff, slen);
+	break;
+      case T_DATA:
+	cst_str_copy_src_to_dest(cd, arg, offset2);
+	break;
+      default:
+	rb_raise(rb_eArgError, "Argument must be a String or a CStruct");
+    }
+    return arg;
+}
+
+static VALUE
+cst_set_ary_dt_C(CStructData *cd, int offset, VALUE arg){
+    size_t slen;
+    int offset2 = offset + cd->dtoffset;
+    char *ptr = cd->dtstr + offset2;
+    switch (TYPE(arg)){
+      case T_STRING:
+	slen = RSTRING_LEN(arg);
+	if(slen+offset2 > cd->dtlen) rb_raise(rb_eRangeError, "Reached the end of data");
+	memcpy(ptr, RSTRING_PTR(arg), slen);
+	break;
+      case T_DATA:
+	cst_str_copy_src_to_dest(cd, arg, offset2);
+	break;
+      default:
+	rb_raise(rb_eArgError, "Argument must be a String or a CStruct");
+    }
+    return arg;
+}
+
+/* ############## instance methods ################ */
+
+static void
+cstruct_set_args_(int argc, VALUE* argv, VALUE klass, VALUE self) { // set args
+    int i;
+    int len = cs_get_count(self);
+    if (len < argc)
+      rb_raise(rb_eRangeError, "Too many arguments, expected %d, but got %d", len, argc);
+    for (i=0; i<argc; i++){
+	if(NIL_P(argv[i])) {
+	    continue;
+	} else {
+	    VALUE v_arg[2];
+	    v_arg[0] = INT2FIX(i);
+	    v_arg[1] = argv[i];
+	    cstruct_set_idx_value__(2, v_arg, self);
+	}
+    }
+}
+
+static VALUE cstruct_initialize_default(int argc, VALUE* argv, VALUE self){
+    VALUE klass;
+    int len;
+    char* ptr;
+    CStructData* cd = DATA_PTR(self);
+    
+    /* create by default */
+    klass = rb_class_of(self);
+    len = FIX2INT(rb_const_get(klass, _id_cstruct_size));
+    if (!len) rb_raise(rb_eRuntimeError, "Use 'CStruct.alloc' instead.");
+    RW_CALLOC(ptr, len);
+    cd->dtstr = ptr;
+    cd->dtlen = len;
+    if(argc > 0) cstruct_set_args_(argc, argv, klass, self);
+    return Qnil;
+}
+
+static VALUE
+cstruct_to_bstr(VALUE self){
+    CStructData* cd = DATA_PTR(self);
+    return rb_str_new(cd->dtstr + cd->dtoffset, cd->dtlen);
+}
+
+static VALUE
+cstruct_to_str(VALUE self){
+    int l;
+    VALUE str;
+    CStructData* cd = DATA_PTR(self);
+    VALUE klass = rb_class_of(self);
+    int ifunc = 0; 
+    if(!cd->bifunc){
+	ifunc = cs_get_offset_data(klass, 0)->ifunc;
+    }
+    if(cd->bifunc==dt_C || ifunc==dt_C){ /* CHAR[] */
+	char *strptr = cd->dtstr + cd->dtoffset;
+	for(l=cd->dtlen-1; l>0; l--){if(strptr[l]>0) break;}
+	return rb_enc_str_new(strptr, strptr[0] ? l+1 : 0, rw_external_enc);
+    } else if(cd->bifunc==dt_W || ifunc==dt_W){ /* WCHAR[] */
+	wchar_t *strptr = (wchar_t*)(cd->dtstr + cd->dtoffset);
+	for(l=cd->dtlen/2-1; l>0; l--){if(strptr[l]>0) break;}
+	str = rb_enc_str_new((char*)strptr, strptr[0] ? (l+1)*2 : 0, rw_wchar_enc);
+	return rb_str_encode(str, external_encoding, 0, Qnil);
+    } else {
+	return rb_str_new(cd->dtstr + cd->dtoffset, cd->dtlen);
+    }
+}
+
+static VALUE
+cstruct_to_int(VALUE self){
+    CStructData* cd = DATA_PTR(self);
+    return INT2NUM((int)*(cd->dtstr + cd->dtoffset));
+}
+
+static VALUE
+cstruct_to_uint(VALUE self){
+    CStructData* cd = DATA_PTR(self);
+    return UINT2NUM((UINT)*(cd->dtstr + cd->dtoffset));
+}
+
+static VALUE
+cstruct_size(VALUE self){
+    CStructData* cd = DATA_PTR(self);
+    return INT2FIX(cd->dtlen);
+}
+
+static VALUE
+cstruct_count(VALUE self){
+    return INT2FIX(cs_get_count(self));
+}
+
+static VALUE
+cstruct_pointer(VALUE self){
+    CStructData* cd = DATA_PTR(self);
+    return ULONG_PTR2NUM((ULONG_PTR)cd->dtstr + cd->dtoffset);
+}
+
+static VALUE
+cstruct1_newstr(int argc, VALUE *argv, VALUE klass){
+    CStructData* cd;
+    VALUE str; VALUE offset;
+    char *target; char *ptr;
+    int ofst;
+    size_t strlen, len;
+    
+    VALUE obj = CStruct_Data_Make_Struct(klass, cd);
+    len = FIX2INT(rb_const_get(klass, _id_cstruct_size));
+    rb_scan_args(argc, argv, "11", &str, &offset);
+    ofst = NIL_P(offset) ? 0 : FIX2INT(offset);
+    strlen = RSTRING_LEN(str);
+    if(len + ofst > strlen) rb_raise(rb_eRuntimeError,"Too short sting");
+    target = (char*)(RSTRING_PTR(str) + ofst);
+    RW_CALLOC(ptr, len);
+    memcpy(ptr, target, len);
+    cd->dtstr = ptr;
+    cd->dtlen = len;
+    return obj;
+}
+
+static VALUE
+cstruct1_newptr(int argc, VALUE *argv, VALUE klass){
+    CStructData* cd;
+    VALUE pointer; VALUE len;
+    size_t ln;
+    char *target; char *ptr;
+    VALUE obj = CStruct_Data_Make_Struct(klass, cd);
+    
+    rb_scan_args(argc, argv, "11", &pointer, &len);
+    ln = FIX2INT(NIL_P(len) ? rb_const_get(klass, _id_cstruct_size) : len);
+    target = (char*)NUM2ULONG_PTR(pointer);
+    RW_CALLOC(ptr, ln);
+    memcpy(ptr, target, ln);
+    cd->dtstr = ptr;
+    cd->dtlen = ln;
+    return obj;
+}
+
+VALUE
+cstruct_wrapptr(VALUE klass, char* pointer, VALUE v_parent){
+    CStructData* cd;
+    VALUE obj = CStruct_Data_Make_Struct(klass, cd);
+    int len = FIX2INT(rb_const_get(klass, _id_cstruct_size));
+    cd->dtstr = pointer;
+    cd->dtlen = len;
+    cd->dtparent = v_parent;
+    cd->dtwrapped = 1;
+    return obj;
+}
+
+static VALUE
+cstruct1_wrapptr(VALUE klass, VALUE v_pointer){
+    return cstruct_wrapptr(klass, (char*)NUM2ULONG_PTR(v_pointer), 0);
+}
+
+static VALUE
+cstruct1_wrapstr(VALUE klass, VALUE str){
+    CStructData* cd;
+    VALUE obj = CStruct_Data_Make_Struct_Default_Free(klass, cd);
+    int len = FIX2INT(rb_const_get(klass, _id_cstruct_size));
+    if (RSTRING_LEN(str) != len){
+	rb_raise(rb_eRuntimeError,
+		 "Struct size mismatch: expected %d, but got %d", len, (int)RSTRING_LEN(str));
+    }
+    cd->dtstr = (char*)RSTRING_PTR(str);
+    cd->dtlen = len;
+    cd->dtwrapped = 1;
+    return obj;
+}
+
+static VALUE
+cstruct1_alloc(VALUE klass, VALUE arg){
+    char *ptr;
+    size_t len;
+    VALUE obj = cstruct_alloc(klass);
+    CStructData* sdtptr = DATA_PTR(obj);
+   
+    if (FIXNUM_P(arg)){ /* initialize memory to 0 */
+	len =  FIX2INT(arg);
+	RW_CALLOC(ptr, len);
+    }else if(TYPE(arg) == T_STRING){ /* copy string data to memory */
+	StringValue(arg);
+	len = RSTRING_LEN(arg);
+	RW_CALLOC(ptr, len);
+	memcpy(ptr, RSTRING_PTR(arg), len);
+    }else if (rb_typeddata_is_kind_of(arg, &cstruct_data_type)){/*copy cstruct data to memory */
+	CStructData *src;
+	CStruct_Data_Get_Struct(arg, src);
+	len = src->dtlen;
+	RW_CALLOC(ptr, len);
+	memcpy(ptr, src->dtstr, len);
+    }else{
+	rb_raise(rb_eArgError, "Argument must be a Integer or String or Cstruct.");
+    }
+    sdtptr->dtstr = ptr;
+    sdtptr->dtlen = len;
+    return obj;
+}
+
+static VALUE
+cstruct1_alloc_int(VALUE klass, VALUE arg){
+    CStructData* sdtptr;
+    char *ptr;
+    size_t len = sizeof(LONG);
+    VALUE obj = CStruct_Data_Make_Struct(klass, sdtptr);
+    RW_CALLOC(ptr, len);
+    *(LONG*)ptr = NUM2ULONG(arg);
+    sdtptr->dtstr = ptr;
+    sdtptr->dtlen = len;
+    sdtptr->dtparent = 8;
+    return obj;
+}
+
+static VALUE
+cstruct1_alloc_int_ptr(VALUE klass, VALUE arg){
+    CStructData* sdtptr;
+    char *ptr;
+    size_t len = sizeof(LONG_PTR);
+    VALUE obj = CStruct_Data_Make_Struct(klass, sdtptr);
+    RW_CALLOC(ptr, len);
+    *(LONG_PTR*)ptr = NUM2LONG_PTR(arg);
+    sdtptr->dtstr = ptr;
+    sdtptr->dtlen = len;
+    sdtptr->dtparent = 8;
+    return obj;
+}
+
+static VALUE
+cstruct_cast_(VALUE klass, VALUE parent, int offset, int len){
+    CStructData* sdtptr;
+    CStructData* srcptr;
+    VALUE obj = CStruct_Data_Make_Struct_Default_Free(klass, sdtptr); 
+    CStruct_Data_Get_Struct(parent, srcptr);
+    sdtptr->dtstr = srcptr->dtstr;
+    sdtptr->dtoffset = srcptr->dtoffset + offset;
+    sdtptr->dtlen = len;
+    sdtptr->dtparent = parent;
+    sdtptr->dtwrapped = 1;
+    return obj;
+}
+
+static VALUE
+cstruct1_cast(VALUE klass, VALUE parent, VALUE v_offset, VALUE v_len){
+    return cstruct_cast_(klass, parent, FIX2INT(v_offset), FIX2INT(v_len));
+}
+
+static VALUE
+cstruct_clear(int argc, VALUE* argv, VALUE self){ //[args...]
+    CStructData* cd = DATA_PTR(self);
+    memset(cd->dtstr, 0, cd->dtlen);
+    if(argc > 0) cstruct_set_args_(argc, argv, rb_obj_class(self), self);
+    return self;
+}
+
+static VALUE
+cstruct_get_array_part(VALUE self, CStructData* cd, int idx, int nth){// Data is an ArrayPart
+    VALUE v_apart;
+    int ub, len;
+    VALUE kls = Qnil;
+    int offset = 0;
+    int ifunc = cd->bifunc;
+    VALUE klass = rb_class_of(cd->dtparent ? cd->dtparent : self);
+    RWOffsetData *od = cs_get_offset_data(klass, cd->prindex);
+    if (ifunc==dt_K || ifunc==dt_P) {
+	kls = rb_ary_entry(rb_const_get(klass, _id_cstruct_s_classes), od->klsidx);
+    }
+    len = od->mblen;
+    ub = cd->dtlen / len;
+    if (idx+nth>ub || nth<0){
+      rb_raise(rb_eRangeError, "@%d: Out of index: [%d, %d]", __LINE__, idx, nth);
+    }
+    offset += idx*len;
+    if(nth==1) {
+	if(ifunc<dt_K) return cst_get_funcs[ifunc](cd, offset);
+	else if (ifunc==dt_K) return cst_get_a_dt_K(self, offset, kls);
+	else if (ifunc==dt_P) return cst_get_a_dt_P(cd, offset, kls, self);
+	else rb_bug("@%d: ifunc:%d is not allowed.", __LINE__, ifunc);
+    } else {
+	int i;
+	VALUE r;
+	v_apart = rb_ary_new2(nth);
+	for(i=0; i<nth; i++){
+	    if(ifunc<dt_K) r = cst_get_funcs[ifunc](cd, offset);
+	    else if(ifunc==dt_K) r = cst_get_a_dt_K(self, offset, kls);
+	    else if (ifunc==dt_P) r = cst_get_a_dt_P(cd, offset, kls, self);
+	    else rb_bug("@%d: ifunc:%d is not allowed.", __LINE__, ifunc);
+	    rb_ary_store(v_apart, i, r);
+	    offset += len;
+	}
+	return v_apart;
+    }
+}
+
+static VALUE
+cstruct_get_idx_value__(int argc, VALUE *argv, VALUE self){
+    CStructData* cd = DATA_PTR(self);
+    if(cd->bifunc){ // data is array part
+	int idx, nth;
+	switch (argc){
+	  case 1:
+	    idx = FIX2INT(argv[0]);
+	    nth = 1;
+	    break;
+	  case 2:
+	    idx = FIX2INT(argv[0]);
+	    nth = FIX2INT(argv[1]);
+	    break;
+	  default :
+	    rb_raise(rb_eArgError, "Num of arguemnts must br 1 or 2 but %d", argc);
+	}
+	return cstruct_get_array_part(self, cd, idx, nth);
+    } else {
+	int ub, idx, ifunc, nth, offset;
+	VALUE kls, klass, s_offsets;
+	char *ods;
+	RWCSAttribute *attr;
+	RWOffsetData *od;
+	if (argc!=1) rb_raise(rb_eArgError, "Num of arguemnts must be 1 but %d", argc);
+	klass=rb_class_of(self);
+	s_offsets = rb_const_get(klass, _id_cstruct_s_offsets);
+	ods = RSTRING_PTR(s_offsets);
+	attr = (RWCSAttribute*)ods;
+	idx = FIX2INT(argv[0]);
+	od = cs_get_offset_data(klass, idx);
+	ub =  attr->cmembers;
+	if (idx>ub-1)rb_raise(rb_eRangeError, "Out of index: %d > %d", idx, ub-1);
+	offset = od->offset;
+	ifunc = od->ifunc;
+	nth = od->nth;
+	kls = (ifunc==dt_K || ifunc==dt_P) ?
+	  rb_ary_entry(rb_const_get(klass, _id_cstruct_s_classes), od->klsidx) : Qnil;
+
+	if(nth){
+	    VALUE v_apart;
+	    CStructData *ap;
+	    int dtlen;
+	    if (idx==ub-1) dtlen = cd->dtlen - offset; /* variable length termination */
+	    else dtlen = od->mblen * nth;
+	    v_apart = cstruct_cast_(cRwAPIstructArrayPart, self, offset, dtlen);
+	    ap = DATA_PTR(v_apart);
+	    ap->bifunc = ifunc;
+	    ap->prindex = idx;
+	    return v_apart;
+	}else{
+	    if(ifunc<dt_K) return cst_get_funcs[ifunc](cd, offset);
+	    else if (ifunc==dt_K) return cst_get_a_dt_K(self, offset, kls);
+	    else if (ifunc==dt_P) return cst_get_a_dt_P(cd, offset, kls, self);
+	    else rb_bug("@%d: ifunc:%d is not allowed.", __LINE__, ifunc);
+	}
+    }
+}
+
+static VALUE
+cstruct_set_array_part(VALUE self, CStructData* cd, int idx, int nth, VALUE v_val){
+    int len, offset, ub;
+    VALUE klass;
+    RWOffsetData *od;
+    VALUE kls = 0;
+    int ifunc = cd->bifunc;
+    offset = 0;
+    if (RB_TYPE_P(v_val, T_STRING)) {
+	switch(ifunc){
+	  case dt_C:
+	    return cst_set_ary_dt_C(cd, offset, v_val);
+	  case dt_W:
+	    return cst_set_ary_dt_W(cd, offset, v_val);
+	  default:
+	    rb_raise(rb_eTypeError, "ifunc: %d is not allowed for String.", ifunc);
+	}
+    }
+    
+    klass = rb_class_of(cd->dtparent ? cd->dtparent : self);
+    od = cs_get_offset_data(klass, cd->prindex);
+    if (ifunc==dt_K || ifunc==dt_P) {
+	kls = rb_ary_entry(rb_const_get(klass, _id_cstruct_s_classes), od->klsidx);
+    }
+    len = od->mblen;
+    ub = cd->dtlen / len;
+    if (idx+nth>ub || nth<0){
+      rb_raise(rb_eRangeError, "@%d: Out of index: [%d, %d]", __LINE__, idx, nth);
+    }
+    
+    offset += idx*len;
+    if(RB_TYPE_P(v_val, T_ARRAY)) {
+	int i;
+	int alen = RARRAY_LEN(v_val);
+	if (len*(idx+alen)>(int)cd->dtlen || len*(idx+nth)>(int)cd->dtlen){
+	    rb_raise(rb_eRangeError, "@%d: Reached the end of data.", __LINE__);
+	} else if (nth>alen){
+	    rb_raise(rb_eRangeError, "@%d: Too few arguments: %d, expected %d or more.",
+		     __LINE__, alen, nth);
+	}
+	if(ifunc<dt_K) {
+	    for(i=0; i<nth; i++){
+		cst_set_funcs[ifunc](cd, offset, rb_ary_entry(v_val, i));
+		offset += len;
+	    }
+	} else if(ifunc==dt_K) {
+	    for(i=0; i<nth; i++){
+		cst_set_a_dt_K(cd, offset, kls, rb_ary_entry(v_val, i));
+		offset += len;
+	    }
+	} else rb_raise(rb_eTypeError, "ifunc: %d is not allowed for Array.", ifunc);
+	return v_val;
+    } else {
+	if (nth > 1){
+	    rb_raise(rb_eRangeError, "@%d: Too few arguments: 1, expected %d or more.",
+		     __LINE__, nth);
+	}
+	if(ifunc<dt_K) {
+	    return cst_set_funcs[ifunc](cd, offset, v_val);
+	} else if(ifunc==dt_K) {
+	    return cst_set_a_dt_K(cd, offset, kls, v_val);
+	} else if(ifunc==dt_P) {
+	    return cst_set_a_dt_P(cd, offset, kls, v_val);
+	} else rb_raise(rb_eTypeError, "ifunc:%d is not allowed.", ifunc);	
+    }
+    return v_val;
+}
+
+static VALUE
+cstruct_set_idx_value__(int argc, VALUE *argv, VALUE self){
+    VALUE v_val;
+    int ub, offset, ifunc, len, nth, idx;
+    CStructData* cd = DATA_PTR(self);
+    VALUE klass = rb_class_of(self);
+    VALUE kls = 0;
+    if(ifunc=cd->bifunc){// Data is an ArrayPart
+	switch (argc){
+	  case 2:
+	    idx = FIX2INT(argv[0]);
+	    nth = 1;
+	    v_val = argv[1];
+	    break;
+	  case 3:
+	    idx = FIX2INT(argv[0]);
+	    nth = FIX2INT(argv[1]);
+	    v_val = argv[2];
+	    break;
+	  default :
+	    rb_raise(rb_eArgError, "Num of arguemnts must br 2 or 3 but %d", argc);
+	}
+	return cstruct_set_array_part(self, cd, idx, nth, v_val);
+    } else {
+	RWOffsetData *od;
+	if (argc!=2) rb_raise(rb_eArgError, "Num of arguemnts must be 2 but %d", argc);
+	idx = FIX2INT(argv[0]);
+	v_val = argv[1];
+	klass = rb_class_of(self);
+	od = cs_get_offset_data(klass, idx);
+	ub =  cs_get_offset_attribute(klass)->cmembers;
+	if (idx>ub-1)rb_raise(rb_eRangeError, "Out of index: %d > %d", idx, ub-1);
+	offset = od->offset;
+	ifunc = od->ifunc; 
+	nth = od->nth;
+	// fprintf(stderr, "@%d: offset=%d, ifunc=%d, nth=%d, mblen=%d\n", __LINE__, od->offset, od->ifunc, od->nth, od->mblen);
+	kls = (ifunc==dt_K || ifunc==dt_P) ?
+	  rb_ary_entry(rb_const_get(klass, _id_cstruct_s_classes), od->klsidx) : Qnil;
+	len = od->mblen;
+    } 
+    if(!nth){
+	if(offset+len>(int)cd->dtlen){
+	    rb_raise(rb_eRangeError, "@%d: Out of index: %d",__LINE__, idx);
+	}
+	if(ifunc<dt_K) {
+	    return cst_set_funcs[ifunc](cd, offset, v_val);
+	} else if(ifunc==dt_K) {
+	    return cst_set_a_dt_K(cd, offset, kls, v_val);
+	} else if(ifunc==dt_P) {
+	    return cst_set_a_dt_P(cd, offset, kls, v_val);
+	} else {
+	    rb_raise(rb_eTypeError, "ifunc:%d is not allowed.", ifunc);
+	}
+    } else {
+	int i, n;
+	if(offset+len*nth>(int)cd->dtlen){
+	    rb_raise(rb_eRangeError, "@%d: Out of index: %d",__LINE__, idx);
+	}
+	if(RB_TYPE_P(v_val, T_STRING)){
+	    switch(ifunc){
+	      case dt_C:
+		return cst_set_ary_dt_C(cd, offset, v_val);
+	      case dt_W:
+		return cst_set_ary_dt_W(cd, offset, v_val);
+	      default:
+		rb_raise(rb_eTypeError, "Argument must be an String.");
+	    }
+	}
+	if(!RB_TYPE_P(v_val, T_ARRAY)){
+	    rb_raise(rb_eTypeError, "Argument must be Array.");
+	}
+	n = RARRAY_LEN(v_val);
+	if(ifunc<dt_K) {
+	    for (i=0;i<n;i++){
+		cst_set_funcs[ifunc](cd, offset, rb_ary_entry(v_val, i));
+		offset += len;
+	    }
+	} else if(ifunc==dt_K) {
+	    for (i=0;i<n;i++){
+		cst_set_a_dt_K(cd, offset, kls, rb_ary_entry(v_val, i));
+		offset += len;
+	    }
+	} else if(ifunc==dt_P) {
+	    for (i=0;i<n;i++){
+		cst_set_a_dt_P(cd, offset, kls, rb_ary_entry(v_val, i));
+		offset += len;
+	    }
+	} else{
+	    rb_raise(rb_eTypeError, "ifunc:%d is not allowed.", ifunc);
+	}
+	return v_val;
+    }
+}
+
+static VALUE
+cstruct_getvalue(VALUE self){
+    CStructData *cd = DATA_PTR(self);
+    if (cs_get_offset_attribute(rb_class_of(self))->cmembers!=1)
+	rb_raise(rb_eRangeError, "Not a single member");
+    else {
+	int ifunc = cs_get_offset_data(rb_class_of(self), 0)->ifunc;
+	VALUE v_arpart = cstruct_cast_(cRwAPIstructArrayPart, self, 0, cd->dtlen); /* entire data */
+	CStructData *sl = DATA_PTR(v_arpart);
+	sl->bifunc = ifunc;
+	sl->prindex = 0;
+	return v_arpart;
+    }
+}
+
+
+static VALUE
+cstruct_setvalue(VALUE self, VALUE v_val){
+    VALUE args[3];
+    args[0] = v_zero;
+    args[1] = RB_TYPE_P(v_val, T_ARRAY) ? INT2FIX(RARRAY_LEN(v_val)) : v_one;
+    args[2] = v_val;
+    return cstruct_set_idx_value__(3, args, self);
+}
+
+static VALUE
+cstruct1_new2(int argc, VALUE* argv, VALUE klass){ //[args...]
+    CStructData* cd;
+    char *ptr;
+    size_t len;
+    VALUE obj = CStruct_Data_Make_Struct(klass, cd);
+    len = FIX2INT(rb_const_get(klass, _id_cstruct_size));
+    RW_CALLOC(ptr, len);
+    cd->dtstr = ptr;
+    cd->dtlen = len;
+    cd->dtparent = 9;
+    if(argc > 0) cstruct_set_args_(argc, argv, klass, obj);
+    return obj;
+}
+
+static VALUE
+cstruct_each(VALUE self){
+    int i;
+    int len = cs_get_count(self);
+    for (i=0; i < len; i++){
+	VALUE v_idx = INT2FIX(i);
+	VALUE x = cstruct_get_idx_value__(1, &v_idx, self);
+	rb_yield(x);
+    }
+    return self;
+}
+
+static VALUE
+cs_to_ary_core(VALUE self, VALUE rflag){
+    int i;
+    VALUE ret;
+    int len = cs_get_count(self);
+    ret = rb_ary_new2(len);
+    for (i=0; i < len; i++){
+	VALUE v_idx = INT2FIX(i);
+	VALUE r = cstruct_get_idx_value__(1, &v_idx, self);
+	if(rflag==Qtrue && rb_typeddata_is_kind_of(r, &cstruct_data_type)){
+	    r = cs_to_ary_core(r, rflag);
+	}
+	rb_ary_store(ret, i, r);
+    }
+    return ret;
+}
+
+static VALUE
+cstruct_to_ary(int argc, VALUE* argv, VALUE self){
+    VALUE rflag;
+    rb_scan_args(argc, argv, "01", &rflag);
+    return cs_to_ary_core(self, rflag);
+}
+
+/* !!!DANGER!!! Do not use easily. */
+static VALUE
+cstruct_slice(VALUE self, VALUE v_offset, VALUE v_len){
+    CStructData *cd;
+    char *ptr;
+    CStructData *cdsrc = DATA_PTR(self);
+    
+    VALUE obj = CStruct_Data_Make_Struct(cRwAPIstruct, cd); 
+    int offset = FIX2INT(v_offset);
+    int len = FIX2INT(v_len);
+    
+    if (offset + len > (int)cdsrc->dtlen)
+      rb_raise(rb_eRuntimeError, "Reached the end of data");
+    ptr = malloc(len);
+    if(!ptr) rb_raise(rb_eRuntimeError,"Failed to allocate memory");
+    memcpy(ptr, cdsrc->dtstr + offset, len);
+    cd->dtoffset = 0;
+    cd -> dtlen = len;
+    cd->dtstr = ptr;
+    cd->dtreferences = 0;
+    cd->dtwrapped = 0;
+    return obj;
+}
+
+/* !!!DANGER!!! Do not use easily. */
+static VALUE
+cstruct_subst(VALUE self, VALUE roffset, VALUE rlen, VALUE robj){
+    CStructData* pdata;
+    CStructData* psrc;
+    unsigned usrc;
+    int len = 0;
+    int offset = FIX2INT(roffset);
+    int length = FIX2INT(rlen);
+    CStruct_Data_Get_Struct(self, pdata);
+    
+    switch (TYPE(robj)){
+      case T_BIGNUM:
+      case T_FIXNUM:
+	if (offset + length > (int)pdata->dtlen)
+	    rb_raise(rb_eRuntimeError, "Reached the end of data");
+	usrc = NUM2INT(robj);
+	switch (length){
+	  case 1:
+	    *(char*)(pdata->dtstr + pdata->dtoffset + offset) = usrc;
+	    break;
+	  case 2:
+	    *(short*)(pdata->dtstr + pdata->dtoffset + offset) = usrc;
+	    break;
+	  case 4:
+	    *(long*)(pdata->dtstr + pdata->dtoffset + offset) = usrc;
+	    break;
+	  default:
+	    rb_raise(rb_eArgError,"Length of numeric data must be 1(byte), 2(short) or 4(long)");
+	}
+	break;
+      case T_STRING:
+	len = RSTRING_LEN(robj);
+	if (offset + length > (int)pdata->dtlen)
+	  rb_raise(rb_eRuntimeError, "Reached the end of data");
+	if (length < len) len = length;
+	memcpy(pdata->dtstr + pdata->dtoffset + offset, RSTRING_PTR(robj), len);
+	break;
+      default:
+	if(!rb_typeddata_is_kind_of(robj, &cstruct_data_type))
+	    rb_raise(rb_eTypeError, "Illegal type");
+	CStruct_Data_Get_Struct(robj, psrc);
+	len = psrc->dtlen;
+	if (offset + length > (int)pdata->dtlen)
+	    rb_raise(rb_eRuntimeError, "Reached the end of data");
+	if (length < len) len = length;
+	memcpy(pdata->dtstr + pdata->dtoffset + offset, psrc->dtstr+psrc->dtoffset, len);
+	break;
+    }
+    return self;
+}
+
+static VALUE
+api_getvalueptr(VALUE klass, VALUE obj){
+    return INT2NUM((int)obj);
+}
+
+static VALUE
+api_getptrvalue(VALUE klass, VALUE num){
+    return (VALUE)NUM2INT(num);
+}
+
+static VALUE
+api_ptr2str(VALUE klass, VALUE v_ptr, VALUE v_len){
+    char* ptr = (char*)NUM2ULONG_PTR(v_ptr);
+    if(!ptr) rb_raise(rb_eArgError, "NULL pointer given.");
+    return rb_str_new(ptr, FIX2INT(v_len));
+}
+
+static VALUE
+api_getlasterrmsg(VALUE klass){
+    TCHAR buff[1024];
+    int err = GetLastError();
+    FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, 0, err, 0, buff, sizeof(buff), NULL);
+    return rw_encode_external(buff); 
+}
+
+static VALUE
+cstruct1_deftemplate(int argc, VALUE *argv, VALUE klass){
+    VALUE v_template, ar_classes, v_packed;
+    char* template;
+    int i, j, sz, maxsz, maxsz_k, nth, to, offset;
+    CST_GET_FUNCS ifunc;
+    char tp, c;
+    BOOL packed;
+    RWCSAttribute *csattr;
+    VALUE s_offsets = rb_str_new_literal("\0\0\0\0\0\0\0\0");
+    VALUE s_klasses = rb_ary_new();
+    
+    rb_scan_args(argc, argv, "12", &v_template, &ar_classes, &v_packed);
+    if (TYPE(v_template)!=T_STRING) rb_raise(rb_eArgError, "1st argument must be a String");
+    switch (TYPE(ar_classes)){
+      case T_NIL:
+	ar_classes = rb_ary_new();
+      case T_ARRAY:
+	break;
+      default:
+	rb_raise(rb_eArgError, "2nd argument must be an Array");
+    }
+    rb_define_const(klass, "Packed", v_packed);
+    packed = v_packed==Qtrue ? TRUE : FALSE;
+    template = RSTRING_PTR(v_template);
+    offset = 0;
+    sz = 0;
+    maxsz = 1;
+    nth = 0;
+    ifunc = 0;
+    i = 0;
+    j = 0;
+    while(tp=template[0]){
+	VALUE kls;
+	RWOffsetData offdata;
+	nth = 0;
+	to = 0;
+	while(isdigit(c=template[++to])){nth = nth*10+(c-'0');}
+	template += to;
+	
+	if (!nth) { /* Single v_member */
+	    switch(tp){
+	      case 'L':
+		ifunc = dt_L;
+		sz = sizeof(ULONG);
+		if (!packed)offset = cst_adjust_align(offset, sz);
+		break;
+	      case 'U':
+		ifunc = dt_U;
+		sz = sizeof(ULONG);
+		if (!packed)offset = cst_adjust_align(offset, sz);
+		break;
+	      case 'H':
+		ifunc = dt_H;
+		sz = sizeof(SHORT);
+		if (!packed) offset = cst_adjust_align(offset, sz);
+		break;
+	      case 'W':
+		ifunc = dt_W;
+		sz = sizeof(SHORT);
+		if (!packed) offset = cst_adjust_align(offset, sz);
+		break;
+	      case 'C':
+		ifunc = dt_C;
+		sz = sizeof(char);
+		break;
+	      case 'B':
+		ifunc = dt_B;
+		sz = sizeof(char);
+		break;
+	      case 'Q':
+		ifunc = dt_Q;
+		sz = sizeof(ULONG_PTR);
+		if (!packed) offset = cst_adjust_align(offset, sz);
+		break;
+	      case 'I':
+		ifunc = dt_I;
+		sz = sizeof(ULONG_PTR);
+		if (!packed) offset = cst_adjust_align(offset, sz);
+		break;
+	      case 'S':
+		ifunc = dt_S;
+		sz = sizeof(ULONG_PTR);
+		if (!packed) offset = cst_adjust_align(offset, sz);
+		break;
+	      case 'l':
+		ifunc = dt_l;
+		sz = sizeof(ULONG_PTR);
+		if (!packed) offset = cst_adjust_align(offset, sz);
+		break;
+	      case 'u':
+		ifunc = dt_u;
+		sz = sizeof(ULONG_PTR);
+		if (!packed) offset = cst_adjust_align(offset, sz);
+		break;
+	      case 'q':
+		ifunc = dt_q;
+		sz = sizeof(ULONG_PTR);
+		if (!packed) offset = cst_adjust_align(offset, sz);
+		break;
+	      case 'i':
+		ifunc = dt_i;
+		sz = sizeof(ULONG_PTR);
+		if (!packed) offset = cst_adjust_align(offset, sz);
+		break;
+	      case 's':
+		ifunc = dt_s;
+		sz = sizeof(ULONG_PTR);
+		if (!packed) offset = cst_adjust_align(offset, sz);
+		break;
+	      case 'P':
+		kls = rb_ary_shift(ar_classes);
+		ifunc = dt_P;
+		if(NIL_P(kls)) rb_raise(rb_eArgError, "No class given for template `P'");
+		sz = sizeof(ULONG_PTR);
+		if (!packed) offset = cst_adjust_align(offset, sz);
+		rw_set_offdata(&offdata, offset, ifunc, sz, 0, j++);
+		rb_str_cat(s_offsets, (char*)&offdata, sizeof(RWOffsetData));
+		if (maxsz < sz) maxsz = sz;
+		offset += sz;
+		rb_ary_push(s_klasses, kls);
+		i++;
+		continue;
+	      case 'K': /* modify maxsz */
+		kls = rb_ary_shift(ar_classes);
+		ifunc = dt_K; 
+		if (NIL_P(kls)) rb_raise(rb_eArgError, "No class given for template `K'");
+		maxsz_k = cs_get_offset_attribute(kls)->maxmblen;
+		sz = FIX2INT(rb_const_get(kls, _id_cstruct_size));
+		if (!packed) offset = cst_adjust_align(offset, maxsz_k);
+		rw_set_offdata(&offdata, offset, ifunc, sz, 0, j++);
+		rb_str_cat(s_offsets, (char*)&offdata, sizeof(RWOffsetData));
+		offset += sz;
+		rb_ary_push(s_klasses, kls);
+		if (maxsz < maxsz_k) maxsz = maxsz_k;
+		i++;
+		continue;
+	      case 'X':
+		offset += 1; /* for padding */
+		continue;
+	      default:
+		rb_raise(rb_eArgError, "Unknown template: `%c' for v_member", tp);
+	    }
+	    rw_set_offdata(&offdata, offset, ifunc, sz, 0, 0);
+	    rb_str_cat(s_offsets, (char*)&offdata, sizeof(RWOffsetData));
+	    if (maxsz < sz) maxsz = sz;
+	    offset += sz;
+	} else { /* Array */
+	    switch(tp){
+	      case 'L':
+		ifunc = dt_L;
+		sz = sizeof(ULONG);
+		if(!packed) offset = cst_adjust_align(offset, sz);
+		break;
+	      case 'U':
+		ifunc = dt_U;
+		sz = sizeof(ULONG);
+		if(!packed) offset = cst_adjust_align(offset, sz);
+		break;
+	      case 'H':
+		ifunc = dt_H;
+		sz = sizeof(SHORT);
+		if(!packed) offset = cst_adjust_align(offset, sz);
+		break;
+	      case 'W':
+		ifunc = dt_W;
+		sz = sizeof(SHORT);
+		if(!packed) offset = cst_adjust_align(offset, sz);
+		break;
+	      case 'C':
+		ifunc = dt_C;
+		sz = sizeof(char);
+		break;
+	      case 'B':
+		ifunc = dt_B;
+		sz = sizeof(char);
+		break;
+	      case 'K': /* modify maxsz */
+		kls = rb_ary_shift(ar_classes);
+		if(NIL_P(kls)) rb_raise(rb_eArgError, "No class given for template `K'");
+		ifunc = dt_K;
+		maxsz_k = cs_get_offset_attribute(kls)->maxmblen;
+		if (!packed) offset = cst_adjust_align(offset, maxsz_k);
+		sz = FIX2INT(rb_const_get(kls, _id_cstruct_size));
+		rw_set_offdata(&offdata, offset, ifunc, sz, nth, j++);
+		rb_str_cat(s_offsets, (char*)&offdata, sizeof(RWOffsetData));
+		offset += sz*nth;
+		rb_ary_push(s_klasses, kls);
+		if (maxsz < maxsz_k) maxsz = maxsz_k;
+		i++;
+		continue;
+	      case 'X':
+		offset += 1*nth; /* for padding */
+		continue;
+	      default:
+		rb_raise(rb_eArgError, "Unknown template: `%c%d' for array v_member.", tp, nth);
+	    }
+	    rw_set_offdata(&offdata, offset, ifunc, sz, nth, 0);
+	    rb_str_cat(s_offsets, (char*)&offdata, sizeof(RWOffsetData));
+	    if (maxsz < sz) maxsz = sz;
+	    offset += sz*nth;
+	}
+	i++;
+    }
+    if (i==1){
+	rb_define_method(klass, "value", cstruct_getvalue, 0);
+	rb_define_method(klass, "value=", cstruct_setvalue, 1);
+    }
+    csattr = (RWCSAttribute*)RSTRING_PTR(s_offsets);
+    csattr->realsize = (WORD)offset;
+    if(!packed && !nth && maxsz>1) offset = cst_adjust_align(offset, maxsz);
+    rb_define_const(klass, "Size", INT2FIX(offset));
+    csattr->size = (WORD)offset;
+    rb_define_const(klass, "Template", v_template);
+    rb_obj_freeze(v_template);
+    rb_define_const(klass, "SOffsets", s_offsets);
+    rb_obj_freeze(s_offsets);
+    rb_define_const(klass, "SClasses", s_klasses);
+    csattr->cmembers = i;
+    csattr->maxmblen = maxsz;
+    csattr->packed = packed;
+    return klass;
+}
+
+VALUE ccsCHAR, ccsWCHAR, ccsTCHAR, ccsBYTE, ccsWORD, ccsDWORD, ccsPOINT, ccsSIZE, ccsRECT;
+VALUE ccsLOGBRUSH, ccsLOGFONT, ccsLOGPEN, ccsIMAGEINFO, ccsBITMAPINFO, ccsMENUITEMINFO;
+VALUE ccsDEVMODE;
+
+VALUE
+cs_deftemplate_intern(VALUE *klass, const char* cname, const char *template){
+    VALUE v_template;
+    VALUE v_args[1];
+    *klass = rb_define_class_under(mRwAPI, cname, cRwAPIstruct);
+    v_template = rb_str_new2(template);
+    v_args[0] = v_template;
+    return cstruct1_deftemplate(1, v_args, *klass);
+}
+
+void
+create_pre_defined_class(){
+    cs_deftemplate_intern(&ccsCHAR, "CHAR", "C1");
+    cs_deftemplate_intern(&ccsWCHAR, "WCHAR", "W1");
+    cs_deftemplate_intern(&ccsBYTE, "BYTE", "B1");
+    cs_deftemplate_intern(&ccsWORD, "WORD", "H1");
+    cs_deftemplate_intern(&ccsDWORD, "DWORD", "L1");
+    cs_deftemplate_intern(&ccsPOINT, "POINT", "LL");
+    cs_deftemplate_intern(&ccsSIZE, "SIZE", "LL");
+    cs_deftemplate_intern(&ccsRECT, "RECT", "LLLL");
+    cs_deftemplate_intern(&ccsLOGBRUSH, "LOGBRUSH", "UUU");
+    cs_deftemplate_intern(&ccsLOGPEN, "LOGPEN", "ULX4U");
+    cs_deftemplate_intern(&ccsBITMAPINFO, "BITMAPINFO", "LLLHHLLLLLLL1");
+    cs_deftemplate_intern(&ccsIMAGEINFO, "IMAGEINFO", "LLX8LLLL");
+    cs_deftemplate_intern(&ccsMENUITEMINFO, "MENUITEMINFO", "UUUUUQQQQSUQ");
+#ifdef UNICODE
+    cs_deftemplate_intern(&ccsTCHAR, "TCHAR", "W1");
+    cs_deftemplate_intern(&ccsLOGFONT, "LOGFONT", "LLLLLBBBBBBBBW32");
+    cs_deftemplate_intern(&ccsDEVMODE, "DEVMODE", "W32HHHHUHHHHHHHHHHHHHW32HUUUUUUUUUUUUU");
+#else
+    cs_deftemplate_intern(&ccsTCHAR, "TCHAR", "C1");
+    cs_deftemplate_intern(&ccsLOGFONT, "LOGFONT", "LLLLLBBBBBBBBC32");
+    cs_deftemplate_intern(&ccsDEVMODE, "DEVMODE", "C32HHHHUHHHHHHHHHHHHHW32HUUUUUUUUUUUUU");
+#endif
+}
+
+/* // offset test
+//#include <comdlg32.h>
+static VALUE
+cstruct1_offset_test(){
+//    return UINT2NUM(offsetof(CHARFORMAT2, sSpacing));
+    return rb_ary_new3(2, UINT2NUM(offsetof(PRINTDLG, hInstance)), UINT2NUM(sizeof(PRINTDLG)));
+}
+ */
+
+/* ######################  End of RWin::API::CStruct  ####################### */
+
+/* initialization */
+static void
+rw_init_CStruct(){ /* CStruct */
+    cRwAPIstruct = rb_define_class_under(mRwAPI, "CStruct", rb_cData);
+    cRwAPIstructArrayPart = rb_define_class_under(cRwAPIstruct, "ArrayPart", cRwAPIstruct);
+    
+    rb_define_alloc_func(cRwAPIstruct, cstruct_alloc);
+    
+    rb_define_singleton_method(cRwAPIstruct, "alloc", cstruct1_alloc, 1);
+    rb_define_singleton_method(cRwAPIstruct, "alloc_int", cstruct1_alloc_int, 1);
+    rb_define_singleton_method(cRwAPIstruct, "alloc_uint", cstruct1_alloc_int, 1);
+    rb_define_singleton_method(cRwAPIstruct, "alloc_int_ptr", cstruct1_alloc_int_ptr, 1);
+    rb_define_singleton_method(cRwAPIstruct, "alloc_uint_ptr", cstruct1_alloc_int_ptr, 1);
+    rb_define_singleton_method(cRwAPIstruct, "[]", cstruct1_new2, -1);
+    rb_define_singleton_method(cRwAPIstruct, "__new_and_set_args__", cstruct1_new2, -1);
+    rb_define_singleton_method(cRwAPIstruct, "cast", cstruct1_cast, 3);
+    rb_define_singleton_method(cRwAPIstruct, "new_from_string", cstruct1_newstr, -1);
+    rb_define_singleton_method(cRwAPIstruct, "new_from_pointer", cstruct1_newptr, -1);
+    rb_define_singleton_method(cRwAPIstruct, "wrap_pointer", cstruct1_wrapptr, 1);
+    rb_define_singleton_method(cRwAPIstruct, "wrap_string", cstruct1_wrapstr, 1);
+    rb_define_singleton_method(cRwAPIstruct, "deftemplate", cstruct1_deftemplate, -1);
+
+    rb_define_method(cRwAPIstruct, "initialize", cstruct_initialize_default, -1);
+    rb_define_method(cRwAPIstruct, "to_bstr", cstruct_to_bstr, 0);
+    rb_define_method(cRwAPIstruct, "to_b", cstruct_to_bstr, 0);
+    rb_define_method(cRwAPIstruct, "to_str", cstruct_to_str, 0);
+    rb_define_method(cRwAPIstruct, "to_s", cstruct_to_str, 0);
+    rb_define_method(cRwAPIstruct, "to_int", cstruct_to_int, 0);
+    rb_define_method(cRwAPIstruct, "to_i", cstruct_to_int, 0);
+    rb_define_method(cRwAPIstruct, "to_uint", cstruct_to_uint, 0);
+    rb_define_method(cRwAPIstruct, "to_u", cstruct_to_uint, 0);
+    rb_define_method(cRwAPIstruct, "each", cstruct_each, 0);
+    rb_define_method(cRwAPIstruct, "to_ary", cstruct_to_ary, -1);
+    rb_define_method(cRwAPIstruct, "to_a", cstruct_to_ary, -1);
+    
+    rb_define_method(cRwAPIstruct, "size", cstruct_size, 0);
+    rb_define_method(cRwAPIstruct, "bytesize", cstruct_size, 0);
+    rb_define_method(cRwAPIstruct, "count", cstruct_count, 0);
+    rb_define_method(cRwAPIstruct, "pointer", cstruct_pointer, 0);
+    rb_define_method(cRwAPIstruct, "slice", cstruct_slice, 2);
+    rb_define_method(cRwAPIstruct, "subst", cstruct_subst, 3);
+    rb_define_method(cRwAPIstruct, "clear", cstruct_clear, -1);
+    rb_define_method(cRwAPIstruct, "[]", cstruct_get_idx_value__, -1);
+    rb_define_method(cRwAPIstruct, "[]=", cstruct_set_idx_value__, -1);
+    
+    /* internal name definition */
+    _id_cstruct_size       = rb_intern("Size");
+    _id_cstruct_template = rb_intern("Template");
+    _id_cstruct_s_classes  = rb_intern("SClasses");
+    _id_cstruct_s_offsets  = rb_intern("SOffsets");
+    
+    /* create pre-defined CStruct class */
+    create_pre_defined_class();
+}
+
+
+static VALUE
+api_test_func(int argc, VALUE* argv, VALUE klass){
+//    fprintf(stderr, "NMHDR=%d, LOGFONT=%d, NONCLIENTMETRICS=%d\n", (int)sizeof(NMHDR), (int)sizeof(LOGFONT), (int)sizeof(NONCLIENTMETRICS));
+    return INT2FIX(sizeof(NMTREEVIEW));
+}
+
+static void
+rw_init_CFunc(){ /* CFunc */
+    ApiFuncLibs *libs;
+    apifunc_class_libs = Data_Make_Struct(rb_cObject, ApiFuncLibs, 0, destruct_libs, libs);
+    rb_global_variable(&apifunc_class_libs);
+    apifunc_libs = newAAtree(NULL); /* destructor is not needed, by same reason as rwin. */
+    libs->libs = apifunc_libs;
+    
+    current_hModule = NULL;
+    
+    cRwAPIfunc = rb_define_class_under(mRwAPI, "CFunc", rb_cData);
+    rb_define_alloc_func(cRwAPIfunc, cfunc_alloc);
+
+    rb_define_singleton_method(cRwAPIfunc,"loadLibrary", api_cfunc1_loadlib, 1);
+    rb_define_singleton_method(cRwAPIfunc,"getfunc", api_cfunc1_getfunc, 2);
+    
+    rb_define_method(cRwAPIfunc, "initialize", api_initialize, 2);
+    rb_define_method(cRwAPIfunc, "call", api_call, -1);
+    rb_define_method(cRwAPIfunc, "call_ubf", api_call_ubf, -1);
+    
+    /* additional definition of API-like module functions */
+    rb_define_module_function(mRwAPI, "SendMessage", api_sendmessage, 4);
+    rb_define_module_function(mRwAPI, "PostMessage", api_postmessage, 4);
+    rb_define_module_function(mRwAPI, "GlobalAllocStr", api_g_alloc_str, 2);
+    rb_define_module_function(mRwAPI, "GlobalGetStr", api_g_get_str, 1);
+    rb_define_module_function(mRwAPI, "Obj2Ptr", api_getvalueptr, 1);
+    rb_define_module_function(mRwAPI, "Ptr2Obj", api_getptrvalue, 1); /* DANGER function */
+    rb_define_module_function(mRwAPI, "GetLastErrorMsg", api_getlasterrmsg, 0); /* not API */
+    rb_define_module_function(mRwAPI, "Ptr2Str", api_ptr2str, 2); /* Not API; DANGER */
+    /* for testing */
+    rb_define_module_function(mRwAPI, "__test__", api_test_func, -1); 
+    
+}
+
+static void
+rw_init_Callback(){ /* Callback */
+    api_init_CallbackProcs();
+    rb_define_singleton_method(mRwAPI,"bindCallbackProc", api_bind_callback_proc, 1);
+    rb_define_singleton_method(mRwAPI,"releaseCallbackProc", api_release_callback_proc, 1);
+}
+
+void
+Init_rw_api(){
+    mRwAPI = rb_define_module_under(mRwin, "API");
+    rw_init_CStruct();
+    rw_init_CFunc();
+    rw_init_Callback(); /* Callback procs must be defined at last */
+}