erlix 0.5.0a

data/src/erlix_node.c

@@ -0,0 +1,83 @@
+/*
+ * project : erlix
+ * author : kdr2
+ *
+ */
+
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "erlix_node.h"
+
+
+ErlixNode *erlix_node=NULL;
+
+VALUE erlix_mErlixNode;
+
+VALUE erlix_node_init(VALUE self,VALUE sname,VALUE cookie){
+    VALUE str_name;
+    int creation;
+    struct in_addr self_addr;
+    char host[64];
+    int nn_len;
+    char *nname;
+    if(erlix_node!=NULL){
+        rb_raise(rb_eException,"Erlix::Node has been inited already!");
+        return Qnil;
+    }
+    str_name=StringValue(sname);
+    creation=rand()%100;
+    self_addr.s_addr=htonl(INADDR_ANY);
+    memset(host,0,64);
+    if(gethostname(host,64)!=0){
+        rb_raise(rb_eException,"gethostname error!");
+        return Qnil;
+    }
+    nn_len=strlen(host)+RSTRING_LEN(str_name)+2;
+    nname=(char*)malloc(nn_len);
+    memset(nname,0,nn_len);
+    sprintf(nname,"%s@%s",RSTRING_PTR(str_name),host);
+    if(!erl_connect_xinit(host,
+                          RSTRING_PTR(str_name),
+                          nname,
+                          &self_addr,
+                          NIL_P(cookie)?NULL:RSTRING_PTR(cookie),
+                          creation)){
+        free(nname);
+        rb_raise(rb_eException,"erl_connect_xinit error!");
+        return Qnil;
+    }
+    free(nname);
+    erlix_node=(ErlixNode*)malloc(sizeof(ErlixNode));
+    return self;
+}
+
+VALUE erlix_node_inited(VALUE self){
+    if(erlix_node==NULL)return Qfalse;
+    return Qtrue;
+}
+
+VALUE erlix_node_name(VALUE self){
+    if(erlix_node==NULL)return Qnil;
+    return rb_str_new2(erl_thisnodename());
+}
+
+VALUE erlix_node_creation(VALUE self){
+    if(erlix_node==NULL)return Qnil;
+    return INT2FIX(erl_thiscreation());
+}
+
+//TODO
+VALUE erlix_node_publish(VALUE self);
+
+//TODO
+VALUE erlix_node_accept(VALUE self);
+
+void init_erlix_node(VALUE erlix){
+    erlix_mErlixNode=rb_define_module_under(erlix,ERLIX_NODE_MOD);
+    rb_define_module_function(erlix_mErlixNode,"init",erlix_node_init,2);
+    rb_define_module_function(erlix_mErlixNode,"init?",erlix_node_inited,0);
+    rb_define_module_function(erlix_mErlixNode,"name",erlix_node_name,0);
+    rb_define_module_function(erlix_mErlixNode,"creation",erlix_node_creation,0);
+}

data/src/erlix_node.h

@@ -0,0 +1,39 @@
+/*
+ * project : erlix
+ * author : kdr2
+ *
+ */
+
+#ifndef ERLIX_NODE_H_
+#define ERLIX_NODE_H_
+
+#include "ruby.h"
+
+#include "ei.h"
+#include "erl_interface.h"
+
+#include "erlix_term.h"
+
+#define ERLIX_NODE_MOD "Node"
+
+extern const char *erl_thisnodename(void);
+extern short erl_thiscreation(void);
+
+typedef struct _erlix_node{
+  unsigned long status;
+  int listen_fd;
+}ErlixNode;
+
+
+VALUE erlix_node_init(VALUE self,VALUE sname,VALUE cookie);
+VALUE erlix_node_inited(VALUE self);
+VALUE erlix_node_name(VALUE self);
+VALUE erlix_node_creation(VALUE self);
+
+VALUE erlix_node_publish(VALUE self);
+
+VALUE erlix_node_accept(VALUE self);
+
+void init_erlix_node();
+
+#endif /* ERLIX_CONNECTION_H_ */

data/src/erlix_pid.c

@@ -0,0 +1,68 @@
+/*
+ * project : erlix
+ * author : kdr2
+ *
+ */
+#include <stdlib.h>
+#include <string.h>
+
+#include "erlix_term.h"
+#include "erlix_node.h"
+#include "erlix_connection.h"
+
+VALUE erlix_cErlixPid;
+
+extern const char *erl_thisnodename(void);
+extern short erl_thiscreation(void);
+extern ErlixNode *erlix_node;
+
+VALUE erlix_pid_alloc(VALUE klass){
+    ErlixTerm* pid;
+    VALUE obj;
+    pid=new_erlix_term();
+    pid->type=TYPE_PID;
+    obj=Data_Wrap_Struct(klass,0,free_erlix_term,pid);
+    return obj;
+}
+
+static VALUE erlix_pid_init(VALUE self,VALUE econn){
+    ErlixTerm* pid;
+    ErlixConnection* conn;
+    if(erlix_node==NULL){
+        rb_raise(rb_eException,"call Erlix::Node.init(name,cookie) first please!");
+        return Qnil;
+    }
+
+    if((TYPE(econn)!=T_DATA || RDATA(econn)->dfree!=(RUBY_DATA_FUNC)free_erlix_connection)){
+        rb_raise(rb_eTypeError,"the argument is not an Erlix::Connection");
+    }
+    Data_Get_Struct(self,ErlixTerm,pid);
+    Data_Get_Struct(econn,ErlixConnection,conn);
+    pid->term=erl_mk_pid(erl_thisnodename(),conn->sock_fd,rand()%16,erl_thiscreation());
+    return self;
+}
+
+static VALUE erlix_pid_inspect(VALUE self){
+    VALUE ret=rb_str_new2("#<Erlix::Pid:");
+    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_pid_etype(VALUE self){
+    return rb_str_new2("pid");
+}
+
+void init_erlix_pid(VALUE erlix){
+    erlix_cErlixPid=rb_define_class_under(erlix,"Pid",rb_cObject);
+
+    rb_define_alloc_func(erlix_cErlixPid,erlix_pid_alloc);
+    rb_define_method(erlix_cErlixPid,"initialize",erlix_pid_init,1);
+    rb_define_method(erlix_cErlixPid,"inspect",erlix_pid_inspect,0);
+    rb_define_method(erlix_cErlixPid,"etype",erlix_pid_etype,0);
+
+    rb_include_module(erlix_cErlixPid,erlix_mErlixTerm);
+}
+
+

data/src/erlix_ref.c

@@ -0,0 +1,59 @@
+/*
+ * project : erlix
+ * author : kdr2
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#include "erlix_term.h"
+
+VALUE erlix_cErlixRef;
+extern const char *erl_thisnodename(void);
+extern short erl_thiscreation(void);
+
+VALUE erlix_ref_alloc(VALUE klass){
+    ErlixTerm* eref;
+    VALUE obj;
+    eref=new_erlix_term();
+    eref->type=TYPE_REF;
+    obj=Data_Wrap_Struct(klass,0,free_erlix_term,eref);
+    return obj;
+}
+
+static VALUE erlix_ref_init(VALUE self){
+    ErlixTerm* eref;
+    Data_Get_Struct(self,ErlixTerm,eref);
+    //TODO
+    eref->term=erl_mk_long_ref(erl_thisnodename(),rand(),rand(),time(NULL),erl_thiscreation());
+    return self;
+}
+
+static VALUE erlix_ref_inspect(VALUE self){
+    VALUE ret=rb_str_new2("#<Erlix::Ref:");
+    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_ref_etype(VALUE self){
+    return rb_str_new2("ref");
+}
+
+void init_erlix_ref(VALUE erlix){
+    erlix_cErlixRef=rb_define_class_under(erlix,"Ref",rb_cObject);
+
+    rb_define_alloc_func(erlix_cErlixRef,erlix_ref_alloc);
+    rb_define_method(erlix_cErlixRef,"initialize",erlix_ref_init,0);
+    rb_define_method(erlix_cErlixRef,"inspect",erlix_ref_inspect,0);
+    rb_define_method(erlix_cErlixRef,"etype",erlix_ref_etype,0);
+
+    rb_include_module(erlix_cErlixRef,erlix_mErlixTerm);
+}
+
+
+

data/src/erlix_term.c

@@ -0,0 +1,362 @@
+/*
+ * project : erlix
+ * author : kdr2
+ *
+ */
+
+#include <ctype.h>
+#include <stdlib.h>
+
+#include "erlix_term.h"
+
+VALUE erlix_mErlixTerm;
+
+ErlixTerm* new_erlix_term(){
+    ErlixTerm* ret=(ErlixTerm*)malloc(sizeof(ErlixTerm));
+    memset(ret, 0, sizeof(ErlixTerm));
+    return ret;
+}
+
+void free_erlix_term(void* ptr){
+    ErlixTerm* eterm=ptr;
+    //TODO
+    //flags
+    //erl_free_term(eterm->term);
+    if(eterm && eterm->term){
+        erl_free_compound(eterm->term);
+        free(eterm);
+    }
+}
+
+//initialize_copy
+static VALUE erlix_term_init_copy(VALUE copy,VALUE orig){
+    ErlixTerm *tcopy,*tsrc;
+    if(copy==orig)return copy;
+    if(!IS_ETERM(orig)){
+        rb_raise(rb_eTypeError,"wrong argument type!");
+    }
+    Data_Get_Struct(copy,ErlixTerm,tcopy);
+    Data_Get_Struct(orig,ErlixTerm,tsrc);
+    tcopy->flags=tsrc->flags;
+    tcopy->type=tsrc->type;
+    tcopy->term=erl_copy_term(tsrc->term);
+
+    return copy;
+}
+
+
+//obj.to_s
+static void fill_string(VALUE *str,ETERM *ep);
+VALUE erlix_term_to_str(VALUE self){
+    ErlixTerm *eterm;
+    ETERM *ep;
+    VALUE ret;
+    Data_Get_Struct(self,ErlixTerm,eterm);
+    ep=eterm->term;
+    ret=rb_str_new2("");
+    fill_string(&ret,ep);
+    return ret;
+}
+
+static int is_printable_list(const ETERM* term)
+{
+    ETERM* head;
+    while (ERL_TYPE(term) == ERL_LIST) {
+        head = (ETERM*)(ERL_CONS_HEAD(term));
+        if (ERL_INT_VALUE(head)<0 || ERL_INT_VALUE(head)>255) {
+            return 0;
+        }
+        if (ERL_INT_VALUE(head) < ' ') {
+            switch (ERL_INT_VALUE(head)) {
+            case '\n':
+            case '\r':
+            case '\t':
+            case '\v':
+            case '\b':
+            case '\f':
+                break;
+            default:
+                return 0;
+            }
+        }
+        term = (ETERM*)(ERL_CONS_TAIL(term));
+    }
+    return ERL_IS_EMPTY_LIST(term);
+}
+
+static void fill_printable_list(VALUE *str, const ETERM* ep){
+    int c;
+    char tmp_buf[9];
+    ID concat=rb_intern("concat");
+    rb_funcall(*str,concat,1,rb_str_new2("\""));
+    while (ERL_IS_CONS(ep)) {
+        c = ERL_INT_VALUE((ETERM*)ERL_CONS_HEAD(ep));
+        if (c >= ' ') {
+            memset(tmp_buf,0,9);
+            tmp_buf[0]=c;
+            tmp_buf[1]=0;
+            rb_funcall(*str,concat,1,rb_str_new2(tmp_buf));
+        }
+        else {
+            if(c=='\n'){
+                rb_funcall(*str,concat,1,rb_str_new2("\\n"));
+            }else if(c=='\r'){
+                rb_funcall(*str,concat,1,rb_str_new2("\\r"));
+            }else if(c=='\t'){
+                rb_funcall(*str,concat,1,rb_str_new2("\\t"));
+            }else if(c=='\v'){
+                rb_funcall(*str,concat,1,rb_str_new2("\\v"));
+            }else if(c=='\b'){
+                rb_funcall(*str,concat,1,rb_str_new2("\\b"));
+            }else if(c=='\f'){
+                rb_funcall(*str,concat,1,rb_str_new2("\\f"));
+            }else{
+                memset(tmp_buf,0,9);
+                sprintf(tmp_buf,"\\%o",c);
+                rb_funcall(*str,concat,1,rb_str_new2(tmp_buf));
+            }
+        }
+        ep = (ETERM*)ERL_CONS_TAIL(ep);
+    }
+    rb_funcall(*str,concat,1,rb_str_new2("\""));
+}
+
+
+static void fill_string(VALUE *str,ETERM *ep){
+    ID concat=rb_intern("concat");
+
+    int j,i,doquote;
+    
+    if (!ep) return;
+
+    j = i = doquote = 0;
+
+    if(ERL_IS_ATOM(ep)){
+        /* FIXME: what if some weird locale is in use? */
+        if (!islower((int)ERL_ATOM_PTR(ep)[0]))
+            doquote = 1;
+        for (i = 0; !doquote && i < ERL_ATOM_SIZE(ep); i++){
+            doquote = !(isalnum((int)ERL_ATOM_PTR(ep)[i])
+                        || (ERL_ATOM_PTR(ep)[i] == '_'));
+        }
+        if (doquote) {
+            rb_funcall(*str,concat,1,rb_str_new2("\'"));
+        }
+        rb_funcall(*str,concat,1,rb_str_new2(ERL_ATOM_PTR(ep)));
+        if(doquote){
+            rb_funcall(*str,concat,1,rb_str_new2("\'"));
+        }
+    }else if(ERL_IS_PID(ep)){
+        char tmp_buf_pid[24];
+        memset(tmp_buf_pid,0,24);
+        sprintf(tmp_buf_pid,"<%d.%d.%d>",ERL_PID_NUMBER(ep), ERL_PID_SERIAL(ep),ERL_PID_CREATION(ep));
+        rb_funcall(*str,concat,1,rb_str_new2(tmp_buf_pid));
+    }else if(ERL_IS_PORT(ep)){
+        rb_funcall(*str,concat,1,rb_str_new2("#Port"));
+    }else if(ERL_IS_REF(ep)){
+        rb_funcall(*str,concat,1,rb_str_new2("#Ref"));
+    }else if(ERL_IS_EMPTY_LIST(ep)){
+        rb_funcall(*str,concat,1,rb_str_new2("[]"));
+    }else if(ERL_IS_LIST(ep)){
+        if (is_printable_list(ep)) {
+            fill_printable_list(str,ep);
+        } else {
+            rb_funcall(*str,concat,1,rb_str_new2("["));
+            ETERM *tl=ep,*hd,*tmp;
+            while (ERL_IS_CONS(tl)){
+                hd=erl_hd(tl);
+                fill_string(str,hd);
+                //erl_free_term(hd);
+                tmp = erl_tl(tl);
+                //if(tl!=ep)erl_free_term(tl);
+                tl=tmp;
+                if (ERL_IS_CONS(tl)) {
+                    rb_funcall(*str,concat,1,rb_str_new2(","));
+                }
+            }
+            if (!ERL_IS_EMPTY_LIST(tl)) {
+                rb_funcall(*str,concat,1,rb_str_new2("|"));
+                fill_string(str, tl);
+            }else{
+                //erl_free_term(tl);
+            }
+            rb_funcall(*str,concat,1,rb_str_new2("]"));
+        }
+    }else if(ERL_IS_TUPLE(ep)){
+        rb_funcall(*str,concat,1,rb_str_new2("{"));
+        for (i=0; i < ERL_TUPLE_SIZE(ep); i++) {
+            ETERM *e=erl_element(i+1,ep);
+            fill_string(str,e);
+            //erl_free_term(e);
+            if (i != ERL_TUPLE_SIZE(ep)-1) {
+                rb_funcall(*str,concat,1,rb_str_new2(","));
+            }
+        }
+        rb_funcall(*str,concat,1,rb_str_new2("}"));
+    }else if(ERL_IS_BINARY(ep)){
+        rb_funcall(*str,concat,1,rb_str_new2("#Bin"));
+    }else if(ERL_IS_INTEGER(ep)){
+        char tmp_buf_num[24];
+        memset(tmp_buf_num,0,24);
+        sprintf(tmp_buf_num,"%d", ERL_INT_VALUE(ep));
+        rb_funcall(*str,concat,1,rb_str_new2(tmp_buf_num));
+    }else if(ERL_IS_UNSIGNED_INTEGER(ep)){
+        char tmp_buf_unum[24];
+        memset(tmp_buf_unum,0,24);
+        sprintf(tmp_buf_unum,"%u", ERL_INT_UVALUE(ep));
+        rb_funcall(*str,concat,1,rb_str_new2(tmp_buf_unum));
+    }else if(ERL_IS_FLOAT(ep)){
+        char tmp_buf_float[24];
+        memset(tmp_buf_float,0,24);
+        sprintf(tmp_buf_float,"%f", ERL_FLOAT_VALUE(ep));
+        rb_funcall(*str,concat,1,rb_str_new2(tmp_buf_float));
+    }else{
+        rb_funcall(*str,concat,1,rb_str_new2("*Unknow*"));
+        //rb_raise(rb_eException,"ErlixTerm.to_s: Bad type of term !");
+    }
+}
+
+static VALUE erlix_term_eql(VALUE left,VALUE right){
+    ErlixTerm *el,*er;
+    Data_Get_Struct(left,ErlixTerm,el);
+    Data_Get_Struct(right,ErlixTerm,er);
+    if(erl_match(el->term, er->term)){
+        return Qtrue;
+    }
+    return Qfalse;
+}
+
+static VALUE erlix_term_match(VALUE self,VALUE string){
+    VALUE ret;
+    VALUE pattern=StringValue(string);
+    ErlixTerm *et;
+    Data_Get_Struct(self,ErlixTerm,et);
+    ETERM *epattern = erl_format(RSTRING_PTR(pattern));
+    if(erl_match(epattern,et->term)){
+        ret=Qtrue;
+    }else{
+        ret=Qfalse;
+    }
+    erl_free_term(epattern);
+    return ret;
+}
+
+static VALUE erlix_term_mget(VALUE self,VALUE string,VALUE e){
+    VALUE ret;
+    VALUE pattern=StringValue(string);
+    VALUE t=StringValue(e);
+    ErlixTerm *et;
+    Data_Get_Struct(self,ErlixTerm,et);
+    ETERM *epattern = erl_format(RSTRING_PTR(pattern));
+    if(erl_match(epattern,et->term)){
+        ETERM *ep = erl_var_content(epattern,RSTRING_PTR(e));
+        if(ep==NULL){
+            ret=Qnil;
+        }else{
+            ret=erlix_term(ep);
+        }
+    }else{
+        ret=Qnil;
+    }
+    erl_free_term(epattern);
+    return ret;
+}
+
+ETERM *erlix_auto_conv(VALUE v){
+    if(SYMBOL_P(v)){
+        return erl_mk_atom(rb_id2name(SYM2ID(v)));
+    }else if(FIXNUM_P(v)){
+        return erl_mk_int(FIX2INT(v));
+    }else if(TYPE(v)==T_FLOAT){
+        return erl_mk_float(NUM2DBL(v));
+    }else if(TYPE(v)==T_STRING){
+        return erl_mk_estring(RSTRING_PTR(v),RSTRING_LEN(v));
+    }
+    return NULL;
+}
+
+unsigned long erlix_term_type(ETERM *t){
+    if(ERL_IS_INTEGER(t))return TYPE_INT;
+    if(ERL_IS_UNSIGNED_INTEGER(t))return TYPE_UINT;
+    if(ERL_IS_FLOAT(t))return TYPE_FLOAT;
+    if(ERL_IS_ATOM(t))return TYPE_ATOM;
+    if(ERL_IS_PID(t))return TYPE_PID;
+    if(ERL_IS_PORT(t))return TYPE_PORT;
+    if(ERL_IS_REF(t))return TYPE_REF;
+    if(ERL_IS_TUPLE(t))return TYPE_TUPLE;
+    if(ERL_IS_BINARY(t))return TYPE_BINARY;
+    if(ERL_IS_LIST(t))return TYPE_LIST;
+    if(ERL_IS_EMPTY_LIST(t))return TYPE_EMPTY_LIST;
+    if(ERL_IS_CONS(t))return TYPE_CONS;
+    return 0;
+}
+
+VALUE erlix_term(ETERM *term){
+    unsigned long type=erlix_term_type(term);
+    VALUE ret;
+    ErlixTerm *eterm;
+    if(type==TYPE_INT){
+        ret=erlix_int_alloc(erlix_cErlixInt);
+        Data_Get_Struct(ret,ErlixTerm,eterm);
+        eterm->term=term;
+        return ret;
+    }else if(type==TYPE_UINT){
+        ret=erlix_uint_alloc(erlix_cErlixUInt);
+        Data_Get_Struct(ret,ErlixTerm,eterm);
+        eterm->term=term;
+        return ret;
+    }else if(type==TYPE_FLOAT){
+        ret=erlix_float_alloc(erlix_cErlixFloat);
+        Data_Get_Struct(ret,ErlixTerm,eterm);
+        eterm->term=term;
+        return ret;
+    }else if(type==TYPE_PID){
+        ret=erlix_pid_alloc(erlix_cErlixPid);
+        Data_Get_Struct(ret,ErlixTerm,eterm);
+        eterm->term=term;
+        return ret;
+    }else if(type==TYPE_REF){
+        ret=erlix_ref_alloc(erlix_cErlixRef);
+        Data_Get_Struct(ret,ErlixTerm,eterm);
+        eterm->term=term;
+        return ret;
+    }else if(type==TYPE_ATOM){
+        ret=erlix_atom_alloc(erlix_cErlixAtom);
+        Data_Get_Struct(ret,ErlixTerm,eterm);
+        eterm->term=term;
+        return ret;
+    }else if(type==TYPE_LIST){
+        ret=erlix_list_alloc(erlix_cErlixList);
+        Data_Get_Struct(ret,ErlixTerm,eterm);
+        eterm->term=term;
+        return ret;
+    }else if(type==TYPE_TUPLE){
+        ret=erlix_tuple_alloc(erlix_cErlixTuple);
+        Data_Get_Struct(ret,ErlixTerm,eterm);
+        eterm->term=term;
+        return ret;
+    }else if(type==TYPE_BINARY){
+        ret=erlix_binary_alloc(erlix_cErlixBinary);
+        Data_Get_Struct(ret,ErlixTerm,eterm);
+        eterm->term=term;
+        return ret;
+    }else{
+        rb_raise(rb_eException,"Unknow Erlang Type!");
+        //TODO OTHER TYPE!!!
+        return Qnil;
+    }
+}
+
+
+void init_erlix_term(VALUE erlix){
+    erlix_mErlixTerm=rb_define_module_under(erlix, "Term");
+    rb_define_method(erlix_mErlixTerm,"initialize_copy",erlix_term_init_copy,1);
+    rb_define_method(erlix_mErlixTerm,"eql?",erlix_term_eql,1);
+    rb_define_method(erlix_mErlixTerm,"to_s",erlix_term_to_str,0);
+    rb_define_method(erlix_mErlixTerm,"match",erlix_term_match,1);
+    rb_define_method(erlix_mErlixTerm,"mget",erlix_term_mget,2);
+    rb_define_method(erlix_mErlixTerm,"==",erlix_term_eql,1);
+}
+
+
+