@@ -8,6 +8,7 @@ h4. 20090430 update * features: ** Type auto-convert[1] ** [] singleton method for ErlixTuple and ErlixList[2] +** add ErlixTerm.to_s, remove ErlixTerm.puts h4. erlix-v0.3 changelog: @@ -80,40 +81,29 @@ irb(main):004:0> a2=ErlixAtom.new("atom2") irb(main):005:0> f=ErlixFloat.new(17.0) => 17.000000 irb(main):006:0> b=ErlixBinary.new("data\0data") -=> #Binary<<...>> -irb(main):007:0> i=ErlixInt.new(101) +=> #Bin +irb(main):007:0> b.data +=> "data\000data" +irb(main):008:0> i=ErlixInt.new(101) => 101 -irb(main):008:0> t=ErlixTuple.new([a1,f,b,a2,i]) -=> #<ErlixTuple:0xb7c37104> -irb(main):009:0> t.puts -{atom1,17.000000,#Bin,atom2,101} -=> nil +irb(main):009:0> t=ErlixTuple.new([a1,f,b,a2,i]) +=> {atom1,17.000000,#Bin,atom2,101} irb(main):010:0> list=ErlixList.new([a1,i,t]) -=> #<ErlixList:0xb7c26598> -irb(main):011:0> list.puts -[atom1,101,{atom1,17.000000,#Bin,atom2,101}] -=> nil -irb(main):012:0> t[2] +=> [atom1,101,{atom1,17.000000,#Bin,atom2,101}] +irb(main):011:0> t[2] => 17.000000 -irb(main):013:0> t[2].class +irb(main):012:0> t[2].class => ErlixFloat -irb(main):014:0> t[3].class +irb(main):013:0> t[3].class => ErlixBinary -irb(main):015:0> t.nth(3)==t[3] +irb(main):014:0> t.nth(3)==t[3] => true -irb(main):016:0> list.head +irb(main):015:0> list.head => atom1 -irb(main):017:0> list.tail.puts -[101,{atom1,17.000000,#Bin,atom2,101}] -=> nil -irb(main):018:0> list2=list.cons(b) -=> #<ErlixList:0xb7bfbed8> -irb(main):019:0> list2.puts -[#Bin,atom1,101,{atom1,17.000000,#Bin,atom2,101}] -=> nil -irb(main):020:0> -irb(main):021:0> b.data -=> "data\000data" +irb(main):016:0> list.tail +=>[101,{atom1,17.000000,#Bin,atom2,101}] +irb(main):017:0> list2=list.cons(b) +=> [#Bin,atom1,101,{atom1,17.000000,#Bin,atom2,101}] </code></pre> <a name="fn1">Some Ruby-Type var can be auto-convert to particular Erlang-Type:</a> @@ -133,11 +123,8 @@ See below <pre><code> irb(main):016:0> c=ErlixList.new(["string-to-list",1,:symbol_to_atom,1.00]) -=> #<ErlixList:0xb7bddb2c> -irb(main):017:0> c.puts -["string-to-list",1,symbol_to_atom,1.000000] -=> nil -irb(main):018:0> c.head.class +=> ["string-to-list",1,symbol_to_atom,1.000000] +irb(main):017:0> c.head.class => ErlixList irb(main):019:0> </code></pre> @@ -145,35 +132,30 @@ irb(main):019:0> <a name="fn2">Use singleton method [] to create ErlixTuple/ErlixList</a> <pre><code> irb(main):019:0> c=ErlixList["string-to-list",1,:symbol_to_atom,1.00] -=> #<ErlixList:0xb7bd5c38> +=> ["string-to-list",1,symbol_to_atom,1.000000] irb(main):020:0> t=ErlixTuple["string-to-list",1,:symbol_to_atom,1.00] -=> #<ErlixTuple:0xb7bd079c> +=> {"string-to-list",1,symbol_to_atom,1.000000} irb(main):021:0> t[1] -=> #<ErlixList:0xb7bcd308> +=> "string-to-list" irb(main):022:0> t[3] => symbol_to_atom +irb(main):023:0> sl=%w[abc def xyz] +=> ["abc", "def", "xyz"] +irb(main):024:0> ErlixTuple[*sl] +=> {"abc","def","xyz"} </code></pre> And we can use @match@ to test a ErlixTerm's format, use @mget@ to get a particular ErlixTerm inside a ErlixTerm: <pre><code> -irb(main):023:0> list2.puts -[#Bin,atom1,101,{atom1,17.000000,#Bin,atom2,101}] -=> nil +irb(main):023:0> list2 +=> [#Bin,atom1,101,{atom1,17.000000,#Bin,atom2,101}] irb(main):024:0> list2.match("[B,Atom,101,Tuple]") => true irb(main):025:0> list2.match("[nomatch,B,Atom,101,Tuple]") => false irb(main):027:0> t2=list2.mget("[B,Atom,101,Tuple]","Tuple") -=> #<ErlixTuple:0xb7bdd9b0> -irb(main):028:0> t2.puts -{atom1,17.000000,#Bin,atom2,101} -=> nil -irb(main):029:0> a=%w[abc def xyz] -=> ["abc", "def", "xyz"] -irb(main):039:0> t=ErlixTuple[*a] -=> #<ErlixTuple:0xb7c6b1ac> - +=> {atom1,17.000000,#Bin,atom2,101} </code></pre> h3. Play with the Real-Erlang-Node @@ -251,7 +233,7 @@ t=Thread.new{ #in erlix-v0.2,erecv make this thread block,v0.3 fixed this m=c.erecv puts m.mtype - m.message.puts + puts m.message puts m.class puts m.from puts m.to README.textile @@ -9,4 +9,4 @@ File.chmod(0755,findei) ei_dir=`#{findei}`.chomp src_dir=File.join(File.dirname(__FILE__),"src") mkmf=File.join(File.dirname(__FILE__),"extconf.rb") -puts `ruby #{mkmf} --with-ei-dir=#{ei_dir} --with-ldflags=\"-lei -lerl_interface\" --srcdir=#{src_dir}` +puts `ruby #{mkmf} --with-ei-dir=#{ei_dir} --with-ldflags=\"-lei -lerl_interface -lpthread\" --srcdir=#{src_dir}` configure.rb @@ -26,12 +26,6 @@ VALUE erlix_atom_init(VALUE self,VALUE string){ } -VALUE erlix_atom_to_str(VALUE self){ - ErlixTerm* atom; - Data_Get_Struct(self,ErlixTerm,atom); - return rb_str_new2(ERL_ATOM_PTR(atom->term)); -} - VALUE erlix_atom_size(VALUE self){ ErlixTerm *atom; Data_Get_Struct(self,ErlixTerm,atom); @@ -48,7 +42,6 @@ void init_erlix_atom(){ rb_define_alloc_func(erlix_cErlixAtom,erlix_atom_alloc); rb_define_method(erlix_cErlixAtom,"initialize",erlix_atom_init,1); - rb_define_method(erlix_cErlixAtom,"to_s",erlix_atom_to_str,0); rb_define_method(erlix_cErlixAtom,"size",erlix_atom_size,0); rb_define_method(erlix_cErlixAtom,"etype",erlix_atom_etype,0); src/erlix_atom.c @@ -14,7 +14,6 @@ VALUE erlix_atom_alloc(VALUE klass); VALUE erlix_atom_init(VALUE self,VALUE string); -VALUE erlix_atom_to_str(VALUE self); VALUE erlix_atom_size(VALUE self); VALUE erlix_atom_etype(VALUE self); src/erlix_atom.h @@ -26,10 +26,6 @@ VALUE erlix_binary_init(VALUE self,VALUE string){ } -VALUE erlix_binary_to_str(VALUE self){ - return rb_str_new2("#Binary<<...>>"); -} - VALUE erlix_binary_data(VALUE self){ ErlixTerm* binary; Data_Get_Struct(self,ErlixTerm,binary); @@ -52,7 +48,6 @@ void init_erlix_binary(){ rb_define_alloc_func(erlix_cErlixBinary,erlix_binary_alloc); rb_define_method(erlix_cErlixBinary,"initialize",erlix_binary_init,1); - rb_define_method(erlix_cErlixBinary,"to_s",erlix_binary_to_str,0); rb_define_method(erlix_cErlixBinary,"data",erlix_binary_data,0); rb_define_method(erlix_cErlixBinary,"size",erlix_binary_size,0); rb_define_method(erlix_cErlixBinary,"etype",erlix_binary_etype,0); src/erlix_binary.c @@ -14,7 +14,6 @@ VALUE erlix_binary_alloc(VALUE klass); VALUE erlix_binary_init(VALUE self,VALUE string); -VALUE erlix_binary_to_str(VALUE self); VALUE erlix_binary_data(VALUE self); VALUE erlix_binary_size(VALUE self); VALUE erlix_binary_etype(VALUE self); src/erlix_binary.h @@ -29,15 +29,6 @@ VALUE erlix_float_init(VALUE self,VALUE fix){ } -VALUE erlix_float_to_str(VALUE self){ - ErlixTerm* efloat; - Data_Get_Struct(self,ErlixTerm,efloat); - char buf[12]; - memset(buf,0,12); - sprintf(buf,"%f",ERL_FLOAT_VALUE(efloat->term)); - return rb_str_new2(buf); -} - VALUE erlix_float_to_fix(VALUE self){ ErlixTerm *efloat; Data_Get_Struct(self,ErlixTerm,efloat); @@ -54,7 +45,6 @@ void init_erlix_float(){ 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_s",erlix_float_to_str,0); rb_define_method(erlix_cErlixFloat,"to_i",erlix_float_to_fix,0); rb_define_method(erlix_cErlixFloat,"etype",erlix_float_etype,0); src/erlix_float.c @@ -14,7 +14,6 @@ VALUE erlix_float_alloc(VALUE klass); VALUE erlix_float_init(VALUE self,VALUE fixnum); -VALUE erlix_float_to_str(VALUE self); VALUE erlix_float_to_fix(VALUE self); VALUE erlix_float_size(VALUE self); VALUE erlix_float_etype(VALUE self); src/erlix_float.h @@ -29,15 +29,6 @@ VALUE erlix_int_init(VALUE self,VALUE fix){ } -VALUE erlix_int_to_str(VALUE self){ - ErlixTerm* eint; - Data_Get_Struct(self,ErlixTerm,eint); - char buf[12]; - memset(buf,0,12); - sprintf(buf,"%d",ERL_INT_VALUE(eint->term)); - return rb_str_new2(buf); -} - VALUE erlix_int_to_fix(VALUE self){ ErlixTerm *eint; Data_Get_Struct(self,ErlixTerm,eint); @@ -54,7 +45,6 @@ void init_erlix_int(){ 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_s",erlix_int_to_str,0); rb_define_method(erlix_cErlixInt,"to_i",erlix_int_to_fix,0); rb_define_method(erlix_cErlixInt,"etype",erlix_int_etype,0); src/erlix_int.c @@ -14,7 +14,6 @@ VALUE erlix_int_alloc(VALUE klass); VALUE erlix_int_init(VALUE self,VALUE fixnum); -VALUE erlix_int_to_str(VALUE self); VALUE erlix_int_to_fix(VALUE self); VALUE erlix_int_size(VALUE self); VALUE erlix_int_etype(VALUE self); src/erlix_int.h @@ -48,9 +48,9 @@ VALUE erlix_list_init(VALUE self,VALUE ary){ } } list->term=erl_mk_list(les,RARRAY(ary)->len); - for(i=0;i<RARRAY(ary)->len;i++){ - erl_free_term(*(les+i)); - } + //for(i=0;i<RARRAY(ary)->len;i++){ + // erl_free_term(*(les+i)); + //} free(les); } }else if(TYPE(ary)==T_STRING){ @@ -85,17 +85,14 @@ VALUE erlix_list_create(int argc,VALUE *argv,VALUE klass){ } } rterm=erl_mk_list(les,argc); - for(i=0;i<argc;i++){ - erl_free_term(*(les+i)); - } + //for(i=0;i<argc;i++){ + // erl_free_term(*(les+i)); + //} free(les); } return erlix_term(rterm); } -//TODO -VALUE erlix_list_to_str(VALUE self); -//TODO VALUE erlix_list_to_ary(VALUE self){ ErlixTerm *list; Data_Get_Struct(self,ErlixTerm,list); @@ -105,10 +102,13 @@ VALUE erlix_list_to_ary(VALUE self){ int i=0; while(!ERL_IS_EMPTY_LIST(ep)){ hd=erl_hd(ep); - rb_ary_store(ret,i,erlix_term(hd)); + rb_ary_store(ret,i,erlix_term(erl_copy_term(hd))); tmp=erl_tl(ep); - if(ep!=list->term)erl_free_term(ep); + //if(ep!=list->term)erl_free_term(ep); ep=tmp; + //if(ERL_IS_EMPTY_LIST(ep)){ + // erl_free_term(ep); + //} ++i; } return ret; @@ -117,28 +117,41 @@ VALUE erlix_list_to_ary(VALUE self){ VALUE erlix_list_head(VALUE self){ ErlixTerm *list; Data_Get_Struct(self,ErlixTerm,list); + if(ERL_IS_EMPTY_LIST(list->term)){ + return Qnil; + } ETERM *ep=erl_hd(list->term); - return erlix_term(ep); + return erlix_term(erl_copy_term(ep)); } VALUE erlix_list_tail(VALUE self){ ErlixTerm *list; Data_Get_Struct(self,ErlixTerm,list); - + if(ERL_IS_EMPTY_LIST(list->term)){ + return Qnil; + } ETERM *ep=erl_tl(list->term); - return erlix_term(ep); + return erlix_term(erl_copy_term(ep)); } VALUE erlix_list_cons(VALUE self,VALUE head){ - if(!IS_ETERM(head)){ - rb_raise(rb_eTypeError,"the head must be ErlixTerm!"); + if(!IS_ETERM(head) && !CAN_AUTO_CONV(head)){ + rb_raise(rb_eTypeError,"the head must be ErlixTerm or Auto-Convertable-Type!"); return Qnil; } - ErlixTerm *list,*hd; + ErlixTerm *list; + ETERM *ep; Data_Get_Struct(self,ErlixTerm,list); - Data_Get_Struct(head,ErlixTerm,hd); - ETERM *ep=erl_cons(hd->term,list->term); - return erlix_term(ep); + if(IS_ETERM(head)){ + ErlixTerm *hd; + Data_Get_Struct(head,ErlixTerm,hd); + ep=erl_cons(hd->term,list->term); + }else{ + ep=erl_cons(erlix_auto_conv(head),list->term); + } + VALUE ret= erlix_term(erl_copy_term(ep)); + erl_free_term(ep); + return ret; } VALUE erlix_list_size(VALUE self){ src/erlix_list.c @@ -18,7 +18,6 @@ VALUE erlix_list_create(int argc,VALUE *argv,VALUE klass); VALUE erlix_list_head(VALUE self); VALUE erlix_list_tail(VALUE self); VALUE erlix_list_cons(VALUE self,VALUE head); -VALUE erlix_list_to_str(VALUE self); VALUE erlix_list_size(VALUE self); VALUE erlix_list_etype(VALUE self); src/erlix_list.h @@ -42,17 +42,6 @@ VALUE erlix_pid_init(VALUE self,VALUE econn){ } -VALUE erlix_pid_to_str(VALUE self){ - ErlixTerm* pid; - Data_Get_Struct(self,ErlixTerm,pid); - char name[10]; - ETERM *p=pid->term; - memset(name,0,10); - sprintf(name,"<%d.%d.%d>",ERL_PID_NUMBER(p),ERL_PID_SERIAL(p),ERL_PID_CREATION(p)); - return rb_str_new2(name); -} - - VALUE erlix_pid_etype(VALUE self){ return rb_str_new2("pid"); } @@ -62,7 +51,6 @@ void init_erlix_pid(){ rb_define_alloc_func(erlix_cErlixPid,erlix_pid_alloc); rb_define_method(erlix_cErlixPid,"initialize",erlix_pid_init,1); - rb_define_method(erlix_cErlixPid,"to_s",erlix_pid_to_str,0); rb_define_method(erlix_cErlixPid,"etype",erlix_pid_etype,0); rb_include_module(erlix_cErlixPid,erlix_mErlixTerm); src/erlix_pid.c @@ -14,7 +14,6 @@ VALUE erlix_pid_alloc(VALUE klass); VALUE erlix_pid_init(VALUE self,VALUE econn); -VALUE erlix_pid_to_str(VALUE self); VALUE erlix_pid_size(VALUE self); VALUE erlix_pid_etype(VALUE self); src/erlix_pid.h @@ -32,16 +32,6 @@ VALUE erlix_ref_init(VALUE self){ } -VALUE erlix_ref_to_str(VALUE self){ - ErlixTerm* eref; - Data_Get_Struct(self,ErlixTerm,eref); - //char buf[64]; - //memset(buf,0,12); - //sprintf(buf,"#Ref<%d.%d.%d.%d>",ERL_REF_VALUE(eref->term)); - return rb_str_new2("#Ref<...>"); -} - - VALUE erlix_ref_etype(VALUE self){ return rb_str_new2("ref"); } @@ -51,7 +41,6 @@ void init_erlix_ref(){ rb_define_alloc_func(erlix_cErlixRef,erlix_ref_alloc); rb_define_method(erlix_cErlixRef,"initialize",erlix_ref_init,0); - rb_define_method(erlix_cErlixRef,"to_s",erlix_ref_to_str,0); rb_define_method(erlix_cErlixRef,"etype",erlix_ref_etype,0); rb_include_module(erlix_cErlixRef,erlix_mErlixTerm); src/erlix_ref.c @@ -14,7 +14,6 @@ VALUE erlix_REF_alloc(VALUE klass); VALUE erlix_REF_init(VALUE self); -VALUE erlix_REF_to_str(VALUE self); VALUE erlix_REF_etype(VALUE self); void init_erlix_REF(); src/erlix_ref.h @@ -43,13 +43,171 @@ VALUE erlix_term_init_copy(VALUE copy,VALUE orig){ return copy; } -//obj.puts -VALUE erlix_term_puts(VALUE self){ + +//obj.to_s +static void fill_string(VALUE *str,ETERM *ep); +VALUE erlix_term_to_str(VALUE self){ ErlixTerm *eterm; Data_Get_Struct(self,ErlixTerm,eterm); - erl_print_term(stdout,eterm->term); - printf("\n"); - return Qnil; + ETERM *ep=eterm->term; + VALUE ret=rb_str_new2(""); + fill_string(&ret,ep); + return ret; +} + +static int is_printable_list(const ETERM* term) +{ + while (ERL_TYPE(term) == ERL_LIST) { + ETERM* 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){ + ID concat=rb_intern("concat"); + rb_funcall(*str,concat,1,rb_str_new2("\"")); + while (ERL_IS_CONS(ep)) { + int c = ERL_INT_VALUE((ETERM*)ERL_CONS_HEAD(ep)); + if (c >= ' ') { + char tmp_buf[2]; + 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{ + char tmp_buf[8]; + memset(tmp_buf,0,8); + 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,"<%s.%d.%d>",ERL_PID_NODE(ep),ERL_PID_NUMBER(ep), ERL_PID_SERIAL(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 !"); + } } VALUE erlix_term_eql(VALUE left,VALUE right){ @@ -185,6 +343,7 @@ VALUE erlix_term(ETERM *term){ eterm->term=term; return ret; }else{ + rb_raise(rb_eException,"Unknow Erlang Type!"); //TODO OTHER TYPE!!! return Qnil; } @@ -195,8 +354,8 @@ void init_erlix_term(){ erlix_mErlixTerm=rb_define_module("ErlixTerm"); 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,"puts",erlix_term_puts,0); rb_define_method(erlix_mErlixTerm,"==",erlix_term_eql,1); } src/erlix_term.c @@ -70,7 +70,7 @@ void free_erlix_term(void* p); VALUE erlix_term(ETERM *term); VALUE erlix_term_init_copy(VALUE copy,VALUE orig); -VALUE erlix_term_puts(VALUE self); +VALUE erlix_term_to_str(VALUE self); VALUE erlix_term_eql(VALUE left,VALUE right); VALUE erlix_term_match(VALUE left,VALUE string); VALUE erlix_term_mget(VALUE left,VALUE string,VALUE e); src/erlix_term.h @@ -27,12 +27,11 @@ VALUE erlix_tuple_init(VALUE self,VALUE ary){ return self; } int i; - //check: all elements' must be ErlixTerm - //TODO: automatic conversions + //check: all elements' must be ErlixTerm or auto-convertable Type for(i=0;i<RARRAY(array)->len;i++){ VALUE e=RARRAY(array)->ptr[i]; if(!IS_ETERM(e) && !CAN_AUTO_CONV(e)){ - rb_raise(rb_eTypeError,"all tuple's elements must be ErlixTerm!"); + rb_raise(rb_eTypeError,"all tuple's elements must be ErlixTerm or Auto-Convertable-Type!"); } } ETERM **tes=(ETERM**)malloc(sizeof(ETERM*)*(RARRAY(array)->len)); @@ -47,9 +46,9 @@ VALUE erlix_tuple_init(VALUE self,VALUE ary){ } } tuple->term=erl_mk_tuple(tes,RARRAY(array)->len); - for(i=0;i<RARRAY(array)->len;i++){ - erl_free_term(*(tes+i)); - } + //for(i=0;i<RARRAY(array)->len;i++){ + // erl_free_term(*(tes+i)); + //} free(tes); return self; } @@ -62,7 +61,7 @@ VALUE erlix_tuple_create(int argc,VALUE *argv,VALUE klass){ }else if(argc>0){ int i; //check: all elements' must be ErlixTerm - //TODO: automatic conversions + //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 ErlixTerm!"); @@ -79,9 +78,9 @@ VALUE erlix_tuple_create(int argc,VALUE *argv,VALUE klass){ } } rterm=erl_mk_tuple(tes,argc); - for(i=0;i<argc;i++){ - erl_free_term(*(tes+i)); - } + //for(i=0;i<argc;i++){ + // erl_free_term(*(tes+i)); + //} free(tes); } return erlix_term(rterm); @@ -98,12 +97,9 @@ VALUE erlix_tuple_nth(VALUE self,VALUE index){ return Qnil; } ETERM *e=erl_element(FIX2INT(index),tuple->term); - return erlix_term(e); + return erlix_term(erl_copy_term(e)); } -//TODO -VALUE erlix_tuple_to_str(VALUE self); -//TODO VALUE erlix_tuple_to_ary(VALUE self){ ErlixTerm *tuple; Data_Get_Struct(self,ErlixTerm,tuple); @@ -112,7 +108,7 @@ VALUE erlix_tuple_to_ary(VALUE self){ int i=0; for(;i<len;i++){ ETERM *e=erl_element(i+1,tuple->term); - rb_ary_store(ret,i,erlix_term(e)); + rb_ary_store(ret,i,erlix_term(erl_copy_term(e))); } return ret; } src/erlix_tuple.c @@ -16,7 +16,6 @@ VALUE erlix_tuple_alloc(VALUE klass); VALUE erlix_tuple_init(VALUE self,VALUE ary); VALUE erlix_tuple_create(int argc,VALUE *argv,VALUE klass); VALUE erlix_tuple_nth(VALUE self,VALUE index); -VALUE erlix_tuple_to_str(VALUE self); VALUE erlix_tuple_to_ary(VALUE self); VALUE erlix_tuple_size(VALUE self); VALUE erlix_tuple_etype(VALUE self); src/erlix_tuple.h @@ -29,15 +29,6 @@ VALUE erlix_uint_init(VALUE self,VALUE fix){ } -VALUE erlix_uint_to_str(VALUE self){ - ErlixTerm* euint; - Data_Get_Struct(self,ErlixTerm,euint); - char buf[12]; - memset(buf,0,12); - sprintf(buf,"%u",ERL_INT_UVALUE(euint->term)); - return rb_str_new2(buf); -} - VALUE erlix_uint_to_fix(VALUE self){ ErlixTerm *euint; Data_Get_Struct(self,ErlixTerm,euint); @@ -54,7 +45,6 @@ void init_erlix_uint(){ 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_s",erlix_uint_to_str,0); rb_define_method(erlix_cErlixUInt,"to_i",erlix_uint_to_fix,0); rb_define_method(erlix_cErlixUInt,"etype",erlix_uint_etype,0); src/erlix_uint.c @@ -14,7 +14,6 @@ VALUE erlix_uint_alloc(VALUE klass); VALUE erlix_uint_init(VALUE self,VALUE fixnum); -VALUE erlix_uint_to_str(VALUE self); VALUE erlix_uint_to_fix(VALUE self); VALUE erlix_uint_size(VALUE self); VALUE erlix_uint_etype(VALUE self); src/erlix_uint.h 42d7d13105411d58a5430065233dfcea3c12f577 KDr2 kdr2@x-macro.com http://github.com/KDr2/erlix/commit/b9b8b1e545f66188d15509c39b8476d680ff05a9 b9b8b1e545f66188d15509c39b8476d680ff05a9 2009-04-30T18:34:31-07:00 2009-04-30T18:34:31-07:00 add ErlixTerm.to_s,remove ErlixTerm.puts,fix some bugs about erl-term 6e07f607db904e3fedee49d1b6f1f599a8a5ae20 KDr2 kdr2@x-macro.com