erlix 0.5.0a

data/src/erlix_connection.h

@@ -0,0 +1,47 @@
+/*
+ * project : erlix
+ * author : kdr2
+ *
+ */
+
+#ifndef ERLIX_CONNECTION_H_
+#define ERLIX_CONNECTION_H_
+
+#include "ruby.h"
+
+#include "ei.h"
+#include "erl_interface.h"
+
+#include "erlix_term.h"
+#include "erlix_node.h"
+
+#define ERLIX_CONNECTION_ALIVE(cp) ((cp->status&0x01)==0x01)
+#define ERLIX_CONNECTION_DEAD(cp)  (cp->status&=0xfe)
+#define ERLIX_CONNECTION_BORN(cp)  (cp->status|=0x01)
+
+typedef struct _erlix_connection{
+  unsigned char status;
+  VALUE peer_node;
+  int sock_fd;
+}ErlixConnection;
+
+
+ErlixConnection* new_erlix_connection();
+void free_erlix_connection(void *econ);
+
+static VALUE erlix_connection_alloc(VALUE klass);
+static VALUE erlix_connection_init(VALUE self,VALUE pnode);
+static VALUE erlix_connection_init_copy(VALUE copy,VALUE orig);
+static VALUE erlix_connection_to_str(VALUE self);
+static VALUE erlix_connection_peer(VALUE self);
+static VALUE erlix_connection_etype(VALUE self);
+static VALUE erlix_connection_mkpid(VALUE self);
+static VALUE erlix_connection_send(VALUE self,VALUE pid,VALUE term);
+static VALUE erlix_connection_recv(VALUE self);
+static VALUE erlix_connection_rpc(VALUE self,VALUE module,VALUE func,VALUE args);
+static VALUE erlix_connection_close(VALUE self);
+
+
+void init_erlix_connection();
+
+#endif /* ERLIX_CONNECTION_H_ */

data/src/erlix_float.c

@@ -0,0 +1,65 @@
+/*
+ * project : erlix
+ * author : kdr2
+ *
+ */
+
+#include <stdio.h>
+#include <string.h>
+
+#include "erlix_term.h"
+
+VALUE erlix_cErlixFloat;
+
+VALUE erlix_float_alloc(VALUE klass){
+    ErlixTerm* efloat;
+    VALUE obj;
+    efloat=new_erlix_term();
+    efloat->type=TYPE_FLOAT;
+    obj=Data_Wrap_Struct(klass,0,free_erlix_term,efloat);
+    return obj;
+}
+
+static VALUE erlix_float_init(VALUE self,VALUE fix){
+    ErlixTerm* efloat;
+    double i=NUM2DBL(fix);
+    Data_Get_Struct(self,ErlixTerm,efloat);
+    efloat->term=erl_mk_float(i);
+    return self;
+}
+
+
+static VALUE erlix_float_to_fix(VALUE self){
+    ErlixTerm *efloat;
+    double l;
+    Data_Get_Struct(self,ErlixTerm,efloat);
+    l=ERL_FLOAT_VALUE(efloat->term);
+    return rb_float_new(l);
+}
+
+static VALUE erlix_float_inspect(VALUE self){
+    VALUE ret=rb_str_new2("#<Erlix::Float:");
+    ID concat=rb_intern("concat");
+    rb_funcall(ret,concat,1,rb_funcall(self,rb_intern("to_s"),0));
+    rb_funcall(ret,concat,1,rb_str_new2(">"));
+    return ret;
+}
+
+static VALUE erlix_float_etype(VALUE self){
+    return rb_str_new2("float");
+}
+
+void init_erlix_float(VALUE erlix){
+    erlix_cErlixFloat=rb_define_class_under(erlix,"Float",rb_cObject);
+
+    rb_define_alloc_func(erlix_cErlixFloat,erlix_float_alloc);
+    rb_define_method(erlix_cErlixFloat,"initialize",erlix_float_init,1);
+    rb_define_method(erlix_cErlixFloat,"to_i",erlix_float_to_fix,0);
+    rb_define_method(erlix_cErlixFloat,"inspect",erlix_float_inspect,0);
+    rb_define_method(erlix_cErlixFloat,"etype",erlix_float_etype,0);
+
+    rb_include_module(erlix_cErlixFloat,erlix_mErlixTerm);
+}
+
+
+

data/src/erlix_int.c

@@ -0,0 +1,64 @@
+/*
+ * project : erlix
+ * author : kdr2
+ *
+ */
+
+#include <stdio.h>
+#include <string.h>
+
+#include "erlix_term.h"
+
+VALUE erlix_cErlixInt;
+
+VALUE erlix_int_alloc(VALUE klass){
+    ErlixTerm* eint;
+    VALUE obj;
+    eint=new_erlix_term();
+    eint->type=TYPE_INT;
+    obj=Data_Wrap_Struct(klass,0,free_erlix_term,eint);
+    return obj;
+}
+
+static VALUE erlix_int_init(VALUE self,VALUE fix){
+    ErlixTerm* eint;
+    int i=FIX2INT(fix);
+    Data_Get_Struct(self,ErlixTerm,eint);
+    eint->term=erl_mk_int(i);
+    return self;
+}
+
+
+static VALUE erlix_int_to_fix(VALUE self){
+    ErlixTerm *eint;
+    int l;
+    Data_Get_Struct(self,ErlixTerm,eint);
+    l=ERL_INT_VALUE(eint->term);
+    return INT2FIX(l);
+}
+
+static VALUE erlix_int_inspect(VALUE self){
+    VALUE ret=rb_str_new2("#<Erlix::Int:");
+    ID concat=rb_intern("concat");
+    rb_funcall(ret,concat,1,rb_funcall(self,rb_intern("to_s"),0));
+    rb_funcall(ret,concat,1,rb_str_new2(">"));
+    return ret;
+}
+
+static VALUE erlix_int_etype(VALUE self){
+    return rb_str_new2("int");
+}
+
+void init_erlix_int(VALUE erlix){
+    erlix_cErlixInt=rb_define_class_under(erlix,"Int",rb_cObject);
+
+    rb_define_alloc_func(erlix_cErlixInt,erlix_int_alloc);
+    rb_define_method(erlix_cErlixInt,"initialize",erlix_int_init,1);
+    rb_define_method(erlix_cErlixInt,"to_i",erlix_int_to_fix,0);
+    rb_define_method(erlix_cErlixInt,"inspect",erlix_int_inspect,0);
+    rb_define_method(erlix_cErlixInt,"etype",erlix_int_etype,0);
+
+    rb_include_module(erlix_cErlixInt,erlix_mErlixTerm);
+}
+
+

data/src/erlix_list.c

@@ -0,0 +1,262 @@
+/*
+ * project : erlix
+ * author : kdr2
+ *
+ */
+
+#include "erlix_term.h"
+
+VALUE erlix_cErlixList;
+
+VALUE erlix_list_alloc(VALUE klass){
+    ErlixTerm *list;
+    VALUE obj;
+
+    list=new_erlix_term();
+    list->type=TYPE_LIST;
+    obj=Data_Wrap_Struct(klass,0,free_erlix_term,list);
+    return obj;
+}
+
+static VALUE erlix_list_init(VALUE self,VALUE ary){
+    ErlixTerm *list;
+    ETERM **les;
+    VALUE e;
+    ErlixTerm *ep;
+    int i;
+    Data_Get_Struct(self,ErlixTerm,list);
+
+    if(NIL_P(ary)){
+        //empty list
+        list->term=erl_mk_empty_list();
+        return self;
+    }
+    if(TYPE(ary)==T_ARRAY){
+        if(RARRAY_LEN(ary)==0){
+            //empty list
+            list->term=erl_mk_empty_list();
+        }else{
+            //check: all elements' must be ErlixTerm or auto-convertable Type
+            for(i=0;i<RARRAY_LEN(ary);i++){
+                e=RARRAY_PTR(ary)[i];
+                if(!IS_ETERM(e) && !CAN_AUTO_CONV(e)){
+                    rb_raise(rb_eTypeError,"all list's elements must be ErlixTerm or Auto-Convertable-Type!");
+                }
+            }
+            les=(ETERM**)malloc(sizeof(ETERM*)*(RARRAY_LEN(ary)));
+            for(i=0;i<RARRAY_LEN(ary);i++){
+                e=RARRAY_PTR(ary)[i];
+                if(IS_ETERM(e)){
+                    Data_Get_Struct(e,ErlixTerm,ep);
+                    *(les+i)=erl_copy_term(ep->term);
+                }else{
+                    *(les+i)=erlix_auto_conv(e);
+                }
+            }
+            list->term=erl_mk_list(les,RARRAY_LEN(ary));
+            //for(i=0;i<RARRAY(ary)->len;i++){
+            //  erl_free_term(*(les+i));
+            //}
+            free(les);
+        }
+    }else if(TYPE(ary)==T_STRING){
+        list->term=erl_mk_estring(RSTRING_PTR(ary), RSTRING_LEN(ary));
+    }
+    return self;
+}
+
+
+static VALUE erlix_list_init2(int argc, VALUE* argv,VALUE self){
+    ErlixTerm *list;
+    ETERM **les;
+    VALUE e;
+    ErlixTerm *ep;
+    int i;
+    Data_Get_Struct(self,ErlixTerm,list);
+
+    if(argc==0){
+        //empty list
+        list->term=erl_mk_empty_list();
+        return self;
+    }
+
+    if(argc==1 && (ARRAY_P(*argv)||STRING_P(*argv))){
+        return erlix_list_init(self, *argv);
+    }
+
+    //check: all elements' must be ErlixTerm or auto-convertable Type
+    for(i=0;i<argc;i++){
+        e=*(argv+i);
+        if(!IS_ETERM(e) && !CAN_AUTO_CONV(e)){
+            rb_raise(rb_eTypeError,"all list's elements must be ErlixTerm or Auto-Convertable-Type!");
+        }
+    }
+    les=(ETERM**)malloc(sizeof(ETERM*)*argc);
+    for(i=0;i<argc;i++){
+        e=*(argv+i);
+        if(IS_ETERM(e)){
+            Data_Get_Struct(e,ErlixTerm,ep);
+            *(les+i)=erl_copy_term(ep->term);
+        }else{
+            *(les+i)=erlix_auto_conv(e);
+        }
+    }
+    list->term=erl_mk_list(les,argc);
+    //for(i=0;i<RARRAY(ary)->len;i++){
+    //  erl_free_term(*(les+i));
+    //}
+    free(les);
+    return self;
+}
+
+
+static VALUE erlix_list_create(int argc,VALUE *argv,VALUE klass){
+    ETERM *rterm;
+    ETERM **les;
+    ErlixTerm *ep;
+    VALUE e;
+    int i;
+    
+    if(argc==0){
+        //empty list
+        rterm=erl_mk_empty_list();
+    }else{
+        //check: all elements' must be ErlixTerm or auto-convertable Type
+        for(i=0;i<argc;i++){
+            e=argv[i];
+            if(!IS_ETERM(e) && !CAN_AUTO_CONV(argv[i])){
+                rb_raise(rb_eTypeError,"all list's elements must be ErlixTerm or Auto-Convertable-Type!");
+            }
+        }
+        les=(ETERM**)malloc(sizeof(ETERM*)*argc);
+        for(i=0;i<argc;i++){
+            e=argv[i];
+            if(IS_ETERM(e)){
+                Data_Get_Struct(e,ErlixTerm,ep);
+                *(les+i)=erl_copy_term(ep->term);
+            }else{
+                *(les+i)=erlix_auto_conv(e);
+            }
+        }
+        rterm=erl_mk_list(les,argc);
+        //for(i=0;i<argc;i++){
+        //  erl_free_term(*(les+i));
+        //}
+        free(les);
+    }
+    return erlix_term(rterm);
+}
+
+static VALUE erlix_list_to_ary(VALUE self){
+    ErlixTerm *list;
+    ETERM *hd,*tmp,*ep;
+    VALUE ret;
+    int len, i;
+    
+    Data_Get_Struct(self,ErlixTerm,list);
+    len=erl_length(list->term);
+    ret=rb_ary_new2(len);
+    ep=list->term;
+    i=1;
+    while(!ERL_IS_EMPTY_LIST(ep)){
+        hd=erl_hd(ep);
+        rb_ary_store(ret,i,erlix_term(erl_copy_term(hd)));
+        tmp=erl_tl(ep);
+        //if(ep!=list->term)erl_free_term(ep);
+        ep=tmp;
+        //if(ERL_IS_EMPTY_LIST(ep)){
+        //  erl_free_term(ep);
+        //}
+        ++i;
+    }
+    return ret;
+}
+
+static VALUE erlix_list_head(VALUE self){
+    ErlixTerm *list;
+    ETERM *ep;
+    Data_Get_Struct(self,ErlixTerm,list);
+    if(ERL_IS_EMPTY_LIST(list->term)){
+        return Qnil;
+    }
+    ep=erl_hd(list->term);
+    return erlix_term(erl_copy_term(ep));
+}
+
+static VALUE erlix_list_tail(VALUE self){
+    ErlixTerm *list;
+    ETERM *ep;
+    
+    Data_Get_Struct(self,ErlixTerm,list);
+    if(ERL_IS_EMPTY_LIST(list->term)){
+        return Qnil;
+    }
+    ep=erl_tl(list->term);
+    return erlix_term(erl_copy_term(ep));
+}
+
+static VALUE erlix_list_cons(VALUE self,VALUE head){
+    ErlixTerm *list;
+    ETERM *ep;
+    ErlixTerm *hd;
+    VALUE ret;
+    
+    if(!IS_ETERM(head) && !CAN_AUTO_CONV(head)){
+        rb_raise(rb_eTypeError,"the head must be ErlixTerm or Auto-Convertable-Type!");
+        return Qnil;
+    }
+    
+    Data_Get_Struct(self,ErlixTerm,list);
+    if(IS_ETERM(head)){
+        Data_Get_Struct(head,ErlixTerm,hd);
+        ep=erl_cons(hd->term,list->term);
+    }else{
+        ep=erl_cons(erlix_auto_conv(head),list->term);
+    }
+    ret = erlix_term(erl_copy_term(ep));
+    erl_free_term(ep);
+    return ret;
+}
+
+static VALUE erlix_list_size(VALUE self){
+    ErlixTerm *list;
+    int len;
+    Data_Get_Struct(self,ErlixTerm,list);
+    len=erl_length(list->term);
+    return INT2FIX(len);
+}
+
+static VALUE erlix_list_inspect(VALUE self){
+    VALUE ret;
+    ID concat;
+    
+    ret=rb_str_new2("#<Erlix::List:");
+    concat=rb_intern("concat");
+    rb_funcall(ret,concat,1,rb_funcall(self,rb_intern("to_s"),0));
+    rb_funcall(ret,concat,1,rb_str_new2(">"));
+    return ret;
+}
+
+static VALUE erlix_list_etype(VALUE self){
+    return rb_str_new2("list");
+}
+
+void init_erlix_list(VALUE erlix){
+    erlix_cErlixList=rb_define_class_under(erlix,"List",rb_cObject);
+
+    rb_define_alloc_func(erlix_cErlixList,erlix_list_alloc);
+    rb_define_method(erlix_cErlixList,"initialize",erlix_list_init2,-1);
+    rb_define_method(erlix_cErlixList,"head",erlix_list_head,0);
+    rb_define_method(erlix_cErlixList,"tail",erlix_list_tail,0);
+    rb_define_method(erlix_cErlixList,"cons",erlix_list_cons,1);
+    rb_define_method(erlix_cErlixList,"to_a",erlix_list_to_ary,0);
+    rb_define_method(erlix_cErlixList,"size",erlix_list_size,0);
+    rb_define_method(erlix_cErlixList,"inspect",erlix_list_inspect,0);
+    rb_define_method(erlix_cErlixList,"etype",erlix_list_etype,0);
+
+    rb_define_singleton_method(erlix_cErlixList,"[]",erlix_list_create,-1);
+
+    rb_include_module(erlix_cErlixList,erlix_mErlixTerm);
+}
+
+

data/src/erlix_message.c

@@ -0,0 +1,122 @@
+/*
+ * project : erlix
+ * author : kdr2
+ *
+ */
+
+#include <stdlib.h>
+
+#include "erlix_term.h"
+#include "erlix_node.h"
+
+VALUE erlix_cErlixMessage;
+
+static ErlMessage* new_erlix_message(){
+    ErlMessage *ret=(ErlMessage*)malloc(sizeof(ErlMessage));
+    return ret;
+}
+
+static void free_erlix_message(void *omsg){
+    ErlMessage *msg=omsg;
+    erl_free_term(msg->msg);
+    erl_free_term(msg->from);
+    erl_free_term(msg->to);
+    free(msg);
+}
+
+VALUE erlix_message_alloc(VALUE klass){
+    ErlMessage *msg=new_erlix_message();
+    VALUE obj;
+    obj=Data_Wrap_Struct(klass,0,free_erlix_message,msg);
+    return obj;
+}
+
+static VALUE erlix_message_init_copy(VALUE copy,VALUE orig){
+    ErlMessage *tcopy,*tsrc;
+    if(copy==orig)return copy;
+    if(TYPE(orig)!=T_DATA || RDATA(orig)->dfree==(RUBY_DATA_FUNC)free_erlix_message){
+        rb_raise(rb_eTypeError,"wrong argument type!");
+    }
+    Data_Get_Struct(copy,ErlMessage,tcopy);
+    Data_Get_Struct(orig,ErlMessage,tsrc);
+    tcopy->type=tsrc->type;
+    tcopy->msg=erl_copy_term(tsrc->msg);
+    tcopy->from=erl_copy_term(tsrc->from);
+    tcopy->to=erl_copy_term(tsrc->to);
+    memcpy(tcopy->to_name,tsrc->to_name,MAXREGLEN);
+    return copy;
+}
+
+static VALUE erlix_message_etype(VALUE self){
+    return rb_str_new2("ErlMessage");
+}
+
+static VALUE erlix_message_mtype(VALUE self){
+    //ERL_SEND, ERL_REG_SEND, ERL_LINK, ERL_UNLINK and ERL_EXIT
+    ErlMessage *msg;
+    Data_Get_Struct(self,ErlMessage,msg);
+    switch(msg->type){
+    case ERL_SEND:
+        return rb_str_new2("ERL_SEND");
+        break;
+    case ERL_REG_SEND:
+        return rb_str_new2("ERL_REG_SEND");
+        break;
+    case ERL_LINK:
+        return rb_str_new2("ERL_LINK");
+        break;
+    case ERL_UNLINK:
+        return rb_str_new2("ERL_UNLINK");
+        break;
+    case ERL_EXIT:
+        return rb_str_new2("ERL_EXIT");
+        break;
+    default:
+        return rb_str_new2("UNKOWN");
+    }
+}
+
+static VALUE erlix_message_message(VALUE self){
+    ErlMessage *msg;
+    Data_Get_Struct(self,ErlMessage,msg);
+    if(msg->type==ERL_LINK || msg->type==ERL_UNLINK){
+        return Qnil;
+    }
+    return erlix_term(erl_copy_term(msg->msg));
+}
+
+static VALUE erlix_message_from(VALUE self){
+    ErlMessage *msg;
+    Data_Get_Struct(self,ErlMessage,msg);
+
+    if(msg->type==ERL_SEND){
+        return Qnil;
+    }
+
+    return erlix_term(erl_copy_term(msg->from));
+}
+
+static VALUE erlix_message_to(VALUE self){
+    ErlMessage *msg;
+    Data_Get_Struct(self,ErlMessage,msg);
+    if(msg->type==ERL_REG_SEND){
+        return Qnil;
+    }
+    return erlix_term(erl_copy_term(msg->to));
+}
+
+
+
+void init_erlix_message(VALUE erlix){
+    erlix_cErlixMessage=rb_define_class_under(erlix,"Message",rb_cObject);
+
+    rb_define_alloc_func(erlix_cErlixMessage,erlix_message_alloc);
+    rb_define_method(erlix_cErlixMessage,"initialize_copy",erlix_message_init_copy,1);
+    rb_define_method(erlix_cErlixMessage,"mtype",erlix_message_mtype,0);
+    rb_define_method(erlix_cErlixMessage,"etype",erlix_message_etype,0);
+    rb_define_method(erlix_cErlixMessage,"message",erlix_message_message,0);
+    rb_define_method(erlix_cErlixMessage,"from",erlix_message_from,0);
+    rb_define_method(erlix_cErlixMessage,"to",erlix_message_to,0);
+}
+
+