erlix 0.5.0a

data/src/erlix_term.h

@@ -0,0 +1,118 @@
+/*
+ * project : erlix
+ * author : kdr2
+ *
+ */
+
+#ifndef ERLIX_TERM_H_
+#define ERLIX_TERM_H_
+
+#include "ruby.h"
+
+#include "erl_interface.h"
+#include "ei.h"
+
+#ifndef RUBY_VERSION_MINOR
+#define RUBY_VERSION_MINOR 8
+#endif
+
+
+#ifndef RSTRING_LEN
+  #define RSTRING_LEN(x) (RSTRING(x)->len)
+  #define RSTRING_PTR(x) (RSTRING(x)->ptr)
+#endif
+
+#ifndef RARRAY_LEN
+  #define RARRAY_LEN(x) (RARRAY(x)->len)
+  #define RARRAY_PTR(x) (RARRAY(x)->ptr)
+#endif
+
+
+/*********** erlix_term  ***********/
+
+#define TYPE_ATOM        (1<<0)  //DONE
+#define TYPE_INT         (1<<1)  //DONE bug?
+#define TYPE_UINT        (1<<2)  //DONE bug?
+#define TYPE_FLOAT       (1<<3)  //DONE
+#define TYPE_PID         (1<<4)  //DONE
+#define TYPE_PORT        (1<<5)  //TODO now?
+#define TYPE_REF         (1<<6)  //DONE
+#define TYPE_TUPLE       (1<<7)  //DONE
+#define TYPE_BINARY      (1<<8)  //DONE
+#define TYPE_LIST        (1<<9)  //DONE
+#define TYPE_EMPTY_LIST  (1<<10) //NONE
+#define TYPE_CONS        (1<<11) //NONE
+
+typedef struct _erlix_term{
+  unsigned long flags;
+  unsigned long type;
+  ETERM *term;
+}ErlixTerm;
+
+
+extern VALUE erlix_cErlixInt;
+extern VALUE erlix_cErlixUInt;
+extern VALUE erlix_cErlixFloat;
+extern VALUE erlix_cErlixPid;
+extern VALUE erlix_cErlixRef;
+extern VALUE erlix_cErlixAtom;
+extern VALUE erlix_cErlixList;
+extern VALUE erlix_cErlixTuple;
+extern VALUE erlix_cErlixBinary;
+extern VALUE erlix_cErlixConnection;
+
+extern VALUE erlix_mErlixTerm;
+extern VALUE erlix_mErlixNode;
+
+/*
+ * Type Automatic Convert
+ *  Ruby-Type ->  Erlang-Type
+ *  FixNum    ->  ErlixInt
+ *  Float     ->  ErlixFloat
+ *  String    ->  ErlixList
+ *  Symbol    ->  ErlixAtom
+ *
+ */
+#define CAN_AUTO_CONV(v) ((FIXNUM_P(v)) || \
+                          (SYMBOL_P(v)) || \
+                          (TYPE(v)==T_FLOAT) || \
+                          (TYPE(v)==T_STRING))
+ETERM *erlix_auto_conv(VALUE v);
+
+#define STRING_P(s) (RB_TYPE_P((s), T_STRING) && CLASS_OF(s) == rb_cString)
+#define ARRAY_P(s) (RB_TYPE_P((s), T_ARRAY) && CLASS_OF(s) == rb_cArray)
+#define IS_ETERM(v) (TYPE(v)==T_DATA && RDATA(v)->dfree==(RUBY_DATA_FUNC)free_erlix_term)
+
+ErlixTerm* new_erlix_term();
+void free_erlix_term(void* ptr);
+VALUE erlix_term(ETERM *term);
+unsigned long erlix_term_type(ETERM *term);
+
+
+VALUE erlix_int_alloc(VALUE klass);
+VALUE erlix_uint_alloc(VALUE klass);
+VALUE erlix_float_alloc(VALUE klass);
+VALUE erlix_pid_alloc(VALUE klass);
+VALUE erlix_ref_alloc(VALUE klass);
+VALUE erlix_atom_alloc(VALUE klass);
+VALUE erlix_list_alloc(VALUE klass);
+VALUE erlix_tuple_alloc(VALUE klass);
+VALUE erlix_binary_alloc(VALUE klass);
+VALUE erlix_message_alloc(VALUE klass);
+
+
+void init_erlix_term(VALUE erlix);
+void init_erlix_int(VALUE erlix);
+void init_erlix_uint(VALUE erlix);
+void init_erlix_float(VALUE erlix);
+void init_erlix_pid(VALUE erlix);
+void init_erlix_ref(VALUE erlix);
+void init_erlix_atom(VALUE erlix);
+void init_erlix_list(VALUE erlix);
+void init_erlix_node(VALUE erlix);
+void init_erlix_tuple(VALUE erlix);
+void init_erlix_binary(VALUE erlix);
+void init_erlix_message(VALUE erlix);
+void init_erlix_connection(VALUE erlix);
+
+#endif /* ERLIX_TERM_H_ */

data/src/erlix_tuple.c

@@ -0,0 +1,215 @@
+/*
+ * project : erlix
+ * author : kdr2
+ *
+ */
+
+#include "erlix_term.h"
+
+VALUE erlix_cErlixTuple;
+
+VALUE erlix_tuple_alloc(VALUE klass){
+    VALUE obj;    
+    ErlixTerm *tuple=new_erlix_term();
+    tuple->type=TYPE_TUPLE;
+    obj=Data_Wrap_Struct(klass,0,free_erlix_term,tuple);
+    return obj;
+}
+
+static VALUE erlix_tuple_init(VALUE self,VALUE ary){
+    ErlixTerm *tuple;
+    VALUE array, e;
+    int i;
+    ETERM **tes;
+    ErlixTerm *ep;
+    
+    Data_Get_Struct(self,ErlixTerm,tuple);
+
+    array=rb_check_array_type(ary);
+    if(NIL_P(array)||RARRAY_LEN(array)==0){
+        //empty tuple
+        tuple->term=erl_mk_tuple(NULL,0);
+        return self;
+    }
+    //check: all elements' must be Erlix::Term or auto-convertable Type
+    for(i=0;i<RARRAY_LEN(array);i++){
+        e=RARRAY_PTR(array)[i];
+        if(!IS_ETERM(e) && !CAN_AUTO_CONV(e)){
+            rb_raise(rb_eTypeError,"all tuple's elements must be Erlix::Term or Auto-Convertable-Type!");
+        }
+    }
+    tes=(ETERM**)malloc(sizeof(ETERM*)*(RARRAY_LEN(array)));
+    for(i=0;i<RARRAY_LEN(array);i++){
+        VALUE e=RARRAY_PTR(array)[i];
+        if(IS_ETERM(e)){
+            Data_Get_Struct(e,ErlixTerm,ep);
+            *(tes+i)=erl_copy_term(ep->term);
+        }else{
+            *(tes+i)=erlix_auto_conv(e);
+        }
+    }
+    //TODO
+    tuple->term=erl_mk_tuple(tes,(uint32_t)RARRAY_LEN(array));
+    //for(i=0;i<RARRAY(array)->len;i++){
+    //  erl_free_term(*(tes+i));
+    //}
+    free(tes);
+    return self;
+}
+
+
+static VALUE erlix_tuple_init2(int argc, VALUE *argv, VALUE self){
+    ErlixTerm *tuple;
+    VALUE array, e;
+    int i;
+    ETERM **tes;
+    ErlixTerm *ep;
+    
+    Data_Get_Struct(self,ErlixTerm,tuple);
+    
+    if(argc==1 && ARRAY_P(*argv)){
+        return erlix_tuple_init(self, *argv);
+    }
+    
+    if(argc==0){
+        //empty tuple
+        tuple->term=erl_mk_tuple(NULL,0);
+        return self;
+    }
+
+    
+    //check: all elements' must be Erlix::Term 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 tuple's elements must be Erlix::Term or Auto-Convertable-Type!");
+        }
+    }
+    tes=(ETERM**)malloc(sizeof(ETERM*)*argc);
+    for(i=0; i<argc; i++){
+        e=*(argv+i);
+        if(IS_ETERM(e)){
+            Data_Get_Struct(e,ErlixTerm,ep);
+            *(tes+i)=erl_copy_term(ep->term);
+        }else{
+            *(tes+i)=erlix_auto_conv(e);
+        }
+    }
+    //TODO
+    tuple->term=erl_mk_tuple(tes,(uint32_t)RARRAY_LEN(array));
+    //for(i=0;i<RARRAY(array)->len;i++){
+    //  erl_free_term(*(tes+i));
+    //}
+    free(tes);
+    return self;
+}
+
+static VALUE erlix_tuple_create(int argc,VALUE *argv,VALUE klass){
+    
+    ETERM *rterm=NULL;
+    ETERM **tes;
+    ErlixTerm *ep;
+    int i;
+    
+    if(argc==0){
+        //empty tuple
+        rterm=erl_mk_tuple(NULL,0);
+    }else if(argc>0){
+        //check: all elements' must be Erlix::Term
+        //or automatic conversions
+        for(i=0;i<argc;i++){
+            if(!IS_ETERM(argv[i]) && !CAN_AUTO_CONV(argv[i])){
+                rb_raise(rb_eTypeError,"all tuple's elements must be Erlix::Term!");
+            }
+        }
+        tes=(ETERM**)malloc(sizeof(ETERM*)*argc);
+        for(i=0;i<argc;i++){
+            if(IS_ETERM(argv[i])){
+                Data_Get_Struct(argv[i],ErlixTerm,ep);
+                *(tes+i)=erl_copy_term(ep->term);
+            }else{
+                *(tes+i)=erlix_auto_conv(argv[i]);
+            }
+        }
+        rterm=erl_mk_tuple(tes,argc);
+        //for(i=0;i<argc;i++){
+        //  erl_free_term(*(tes+i));
+        //}
+        free(tes);
+    }
+    return erlix_term(rterm);
+}
+
+static VALUE erlix_tuple_nth(VALUE self,VALUE index){
+    ErlixTerm *tuple;
+    ETERM *e;
+    
+    if(TYPE(index)!=T_FIXNUM){
+        rb_raise(rb_eTypeError,"index must be a fixnum(1..len)!");
+        return Qnil;
+    }
+    Data_Get_Struct(self,ErlixTerm,tuple);
+    if(ERL_TUPLE_SIZE(tuple->term)<FIX2INT(index)||FIX2INT(index)<=0){
+        return Qnil;
+    }
+    e=erl_element(FIX2INT(index),tuple->term);
+    return erlix_term(erl_copy_term(e));
+}
+
+static VALUE erlix_tuple_to_ary(VALUE self){
+    ErlixTerm *tuple;
+    int len, i;
+    ETERM *e;
+    VALUE ret;
+    
+    Data_Get_Struct(self,ErlixTerm,tuple);
+    len=ERL_TUPLE_SIZE(tuple->term);
+    ret=rb_ary_new2(len);
+    for(i=0;i<len;i++){
+        e=erl_element(i+1,tuple->term);
+        rb_ary_store(ret,i,erlix_term(erl_copy_term(e)));
+    }
+    return ret;
+}
+
+
+static VALUE erlix_tuple_size(VALUE self){
+    ErlixTerm *tuple;
+    int len;
+    
+    Data_Get_Struct(self,ErlixTerm,tuple);
+    len=ERL_TUPLE_SIZE(tuple->term);
+    return INT2FIX(len);
+}
+
+static VALUE erlix_tuple_inspect(VALUE self){
+    VALUE ret=rb_str_new2("#<Erlix::Tuple:");
+    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_tuple_etype(VALUE self){
+    return rb_str_new2("tuple");
+}
+
+void init_erlix_tuple(VALUE erlix){
+    erlix_cErlixTuple=rb_define_class_under(erlix,"Tuple",rb_cObject);
+
+    rb_define_alloc_func(erlix_cErlixTuple,erlix_tuple_alloc);
+    rb_define_method(erlix_cErlixTuple,"initialize",erlix_tuple_init2,-1);
+    rb_define_method(erlix_cErlixTuple,"nth",erlix_tuple_nth,1);
+    rb_define_method(erlix_cErlixTuple,"[]",erlix_tuple_nth,1);
+    rb_define_method(erlix_cErlixTuple,"to_a",erlix_tuple_to_ary,0);
+    rb_define_method(erlix_cErlixTuple,"size",erlix_tuple_size,0);
+    rb_define_method(erlix_cErlixTuple,"inspect",erlix_tuple_inspect,0);
+    rb_define_method(erlix_cErlixTuple,"etype",erlix_tuple_etype,0);
+
+    rb_define_singleton_method(erlix_cErlixTuple, "[]", erlix_tuple_create, -1);
+
+    rb_include_module(erlix_cErlixTuple,erlix_mErlixTerm);
+}
+
+
+

data/src/erlix_uint.c

@@ -0,0 +1,63 @@
+/*
+ * project : erlix
+ * author : kdr2
+ *
+ */
+
+#include <stdio.h>
+#include <string.h>
+
+#include "erlix_term.h"
+
+VALUE erlix_cErlixUInt;
+
+VALUE erlix_uint_alloc(VALUE klass){
+    ErlixTerm* euint;
+    VALUE obj;
+    euint=new_erlix_term();
+    euint->type=TYPE_UINT;
+    obj=Data_Wrap_Struct(klass,0,free_erlix_term,euint);
+    return obj;
+}
+
+static VALUE erlix_uint_init(VALUE self,VALUE fix){
+    ErlixTerm* euint;
+    unsigned int i=FIX2UINT(fix);
+    Data_Get_Struct(self,ErlixTerm,euint);
+    euint->term=erl_mk_uint(i);
+    return self;
+}
+
+
+static VALUE erlix_uint_to_fix(VALUE self){
+    ErlixTerm *euint;
+    unsigned int l;
+    Data_Get_Struct(self,ErlixTerm,euint);
+    l=ERL_INT_VALUE(euint->term);
+    return INT2FIX(l);
+}
+
+static VALUE erlix_uint_inspect(VALUE self){
+    VALUE ret=rb_str_new2("#<Erlix::UInt:");
+    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_uint_etype(VALUE self){
+    return rb_str_new2("unsigned int");
+}
+
+void init_erlix_uint(VALUE erlix){
+    erlix_cErlixUInt=rb_define_class_under(erlix,"UInt",rb_cObject);
+
+    rb_define_alloc_func(erlix_cErlixUInt,erlix_uint_alloc);
+    rb_define_method(erlix_cErlixUInt,"initialize",erlix_uint_init,1);
+    rb_define_method(erlix_cErlixUInt,"to_i",erlix_uint_to_fix,0);
+    rb_define_method(erlix_cErlixUInt,"inspect",erlix_uint_inspect,0);
+    rb_define_method(erlix_cErlixUInt,"etype",erlix_uint_etype,0);
+
+    rb_include_module(erlix_cErlixUInt,erlix_mErlixTerm);
+}
+

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: erlix
+version: !ruby/object:Gem::Version
+  version: 0.5.0a
+  prerelease: 5
+platform: ruby
+authors:
+- KDr2
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-25 00:00:00.000000000 Z
+dependencies: []
+description: Run ruby as an Erlang Node!
+email: killy.draw@gmail.com
+executables: []
+extensions:
+- _extconf.rb
+extra_rdoc_files: []
+files:
+- configure
+- _extconf.rb
+- extconf.rb
+- findei.erl
+- src/erlix.c
+- src/erlix_atom.c
+- src/erlix_binary.c
+- src/erlix_connection.c
+- src/erlix_float.c
+- src/erlix_int.c
+- src/erlix_list.c
+- src/erlix_message.c
+- src/erlix_node.c
+- src/erlix_pid.c
+- src/erlix_ref.c
+- src/erlix_term.c
+- src/erlix_tuple.c
+- src/erlix_uint.c
+- src/erlix_connection.h
+- src/erlix_node.h
+- src/erlix_term.h
+homepage: http://github.com/KDr2/erlix
+licenses: []
+post_install_message: Thanks for installing!
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Run ruby as an Erlang Node!
+test_files: []