erlix 0.5.0a

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,118 @@
1
+ /*
2
+ * project : erlix
3
+ * author : kdr2
4
+ *
5
+ */
6
+
7
+ #ifndef ERLIX_TERM_H_
8
+ #define ERLIX_TERM_H_
9
+
10
+ #include "ruby.h"
11
+
12
+ #include "erl_interface.h"
13
+ #include "ei.h"
14
+
15
+ #ifndef RUBY_VERSION_MINOR
16
+ #define RUBY_VERSION_MINOR 8
17
+ #endif
18
+
19
+
20
+ #ifndef RSTRING_LEN
21
+ #define RSTRING_LEN(x) (RSTRING(x)->len)
22
+ #define RSTRING_PTR(x) (RSTRING(x)->ptr)
23
+ #endif
24
+
25
+ #ifndef RARRAY_LEN
26
+ #define RARRAY_LEN(x) (RARRAY(x)->len)
27
+ #define RARRAY_PTR(x) (RARRAY(x)->ptr)
28
+ #endif
29
+
30
+
31
+ /*********** erlix_term ***********/
32
+
33
+ #define TYPE_ATOM (1<<0) //DONE
34
+ #define TYPE_INT (1<<1) //DONE bug?
35
+ #define TYPE_UINT (1<<2) //DONE bug?
36
+ #define TYPE_FLOAT (1<<3) //DONE
37
+ #define TYPE_PID (1<<4) //DONE
38
+ #define TYPE_PORT (1<<5) //TODO now?
39
+ #define TYPE_REF (1<<6) //DONE
40
+ #define TYPE_TUPLE (1<<7) //DONE
41
+ #define TYPE_BINARY (1<<8) //DONE
42
+ #define TYPE_LIST (1<<9) //DONE
43
+ #define TYPE_EMPTY_LIST (1<<10) //NONE
44
+ #define TYPE_CONS (1<<11) //NONE
45
+
46
+ typedef struct _erlix_term{
47
+ unsigned long flags;
48
+ unsigned long type;
49
+ ETERM *term;
50
+ }ErlixTerm;
51
+
52
+
53
+ extern VALUE erlix_cErlixInt;
54
+ extern VALUE erlix_cErlixUInt;
55
+ extern VALUE erlix_cErlixFloat;
56
+ extern VALUE erlix_cErlixPid;
57
+ extern VALUE erlix_cErlixRef;
58
+ extern VALUE erlix_cErlixAtom;
59
+ extern VALUE erlix_cErlixList;
60
+ extern VALUE erlix_cErlixTuple;
61
+ extern VALUE erlix_cErlixBinary;
62
+ extern VALUE erlix_cErlixConnection;
63
+
64
+ extern VALUE erlix_mErlixTerm;
65
+ extern VALUE erlix_mErlixNode;
66
+
67
+ /*
68
+ * Type Automatic Convert
69
+ * Ruby-Type -> Erlang-Type
70
+ * FixNum -> ErlixInt
71
+ * Float -> ErlixFloat
72
+ * String -> ErlixList
73
+ * Symbol -> ErlixAtom
74
+ *
75
+ */
76
+ #define CAN_AUTO_CONV(v) ((FIXNUM_P(v)) || \
77
+ (SYMBOL_P(v)) || \
78
+ (TYPE(v)==T_FLOAT) || \
79
+ (TYPE(v)==T_STRING))
80
+ ETERM *erlix_auto_conv(VALUE v);
81
+
82
+ #define STRING_P(s) (RB_TYPE_P((s), T_STRING) && CLASS_OF(s) == rb_cString)
83
+ #define ARRAY_P(s) (RB_TYPE_P((s), T_ARRAY) && CLASS_OF(s) == rb_cArray)
84
+ #define IS_ETERM(v) (TYPE(v)==T_DATA && RDATA(v)->dfree==(RUBY_DATA_FUNC)free_erlix_term)
85
+
86
+ ErlixTerm* new_erlix_term();
87
+ void free_erlix_term(void* ptr);
88
+ VALUE erlix_term(ETERM *term);
89
+ unsigned long erlix_term_type(ETERM *term);
90
+
91
+
92
+ VALUE erlix_int_alloc(VALUE klass);
93
+ VALUE erlix_uint_alloc(VALUE klass);
94
+ VALUE erlix_float_alloc(VALUE klass);
95
+ VALUE erlix_pid_alloc(VALUE klass);
96
+ VALUE erlix_ref_alloc(VALUE klass);
97
+ VALUE erlix_atom_alloc(VALUE klass);
98
+ VALUE erlix_list_alloc(VALUE klass);
99
+ VALUE erlix_tuple_alloc(VALUE klass);
100
+ VALUE erlix_binary_alloc(VALUE klass);
101
+ VALUE erlix_message_alloc(VALUE klass);
102
+
103
+
104
+ void init_erlix_term(VALUE erlix);
105
+ void init_erlix_int(VALUE erlix);
106
+ void init_erlix_uint(VALUE erlix);
107
+ void init_erlix_float(VALUE erlix);
108
+ void init_erlix_pid(VALUE erlix);
109
+ void init_erlix_ref(VALUE erlix);
110
+ void init_erlix_atom(VALUE erlix);
111
+ void init_erlix_list(VALUE erlix);
112
+ void init_erlix_node(VALUE erlix);
113
+ void init_erlix_tuple(VALUE erlix);
114
+ void init_erlix_binary(VALUE erlix);
115
+ void init_erlix_message(VALUE erlix);
116
+ void init_erlix_connection(VALUE erlix);
117
+
118
+ #endif /* ERLIX_TERM_H_ */
@@ -0,0 +1,215 @@
1
+ /*
2
+ * project : erlix
3
+ * author : kdr2
4
+ *
5
+ */
6
+
7
+ #include "erlix_term.h"
8
+
9
+ VALUE erlix_cErlixTuple;
10
+
11
+ VALUE erlix_tuple_alloc(VALUE klass){
12
+ VALUE obj;
13
+ ErlixTerm *tuple=new_erlix_term();
14
+ tuple->type=TYPE_TUPLE;
15
+ obj=Data_Wrap_Struct(klass,0,free_erlix_term,tuple);
16
+ return obj;
17
+ }
18
+
19
+ static VALUE erlix_tuple_init(VALUE self,VALUE ary){
20
+ ErlixTerm *tuple;
21
+ VALUE array, e;
22
+ int i;
23
+ ETERM **tes;
24
+ ErlixTerm *ep;
25
+
26
+ Data_Get_Struct(self,ErlixTerm,tuple);
27
+
28
+ array=rb_check_array_type(ary);
29
+ if(NIL_P(array)||RARRAY_LEN(array)==0){
30
+ //empty tuple
31
+ tuple->term=erl_mk_tuple(NULL,0);
32
+ return self;
33
+ }
34
+ //check: all elements' must be Erlix::Term or auto-convertable Type
35
+ for(i=0;i<RARRAY_LEN(array);i++){
36
+ e=RARRAY_PTR(array)[i];
37
+ if(!IS_ETERM(e) && !CAN_AUTO_CONV(e)){
38
+ rb_raise(rb_eTypeError,"all tuple's elements must be Erlix::Term or Auto-Convertable-Type!");
39
+ }
40
+ }
41
+ tes=(ETERM**)malloc(sizeof(ETERM*)*(RARRAY_LEN(array)));
42
+ for(i=0;i<RARRAY_LEN(array);i++){
43
+ VALUE e=RARRAY_PTR(array)[i];
44
+ if(IS_ETERM(e)){
45
+ Data_Get_Struct(e,ErlixTerm,ep);
46
+ *(tes+i)=erl_copy_term(ep->term);
47
+ }else{
48
+ *(tes+i)=erlix_auto_conv(e);
49
+ }
50
+ }
51
+ //TODO
52
+ tuple->term=erl_mk_tuple(tes,(uint32_t)RARRAY_LEN(array));
53
+ //for(i=0;i<RARRAY(array)->len;i++){
54
+ // erl_free_term(*(tes+i));
55
+ //}
56
+ free(tes);
57
+ return self;
58
+ }
59
+
60
+
61
+ static VALUE erlix_tuple_init2(int argc, VALUE *argv, VALUE self){
62
+ ErlixTerm *tuple;
63
+ VALUE array, e;
64
+ int i;
65
+ ETERM **tes;
66
+ ErlixTerm *ep;
67
+
68
+ Data_Get_Struct(self,ErlixTerm,tuple);
69
+
70
+ if(argc==1 && ARRAY_P(*argv)){
71
+ return erlix_tuple_init(self, *argv);
72
+ }
73
+
74
+ if(argc==0){
75
+ //empty tuple
76
+ tuple->term=erl_mk_tuple(NULL,0);
77
+ return self;
78
+ }
79
+
80
+
81
+ //check: all elements' must be Erlix::Term or auto-convertable Type
82
+ for(i=0; i<argc; i++){
83
+ e=*(argv+i);
84
+ if(!IS_ETERM(e) && !CAN_AUTO_CONV(e)){
85
+ rb_raise(rb_eTypeError,"all tuple's elements must be Erlix::Term or Auto-Convertable-Type!");
86
+ }
87
+ }
88
+ tes=(ETERM**)malloc(sizeof(ETERM*)*argc);
89
+ for(i=0; i<argc; i++){
90
+ e=*(argv+i);
91
+ if(IS_ETERM(e)){
92
+ Data_Get_Struct(e,ErlixTerm,ep);
93
+ *(tes+i)=erl_copy_term(ep->term);
94
+ }else{
95
+ *(tes+i)=erlix_auto_conv(e);
96
+ }
97
+ }
98
+ //TODO
99
+ tuple->term=erl_mk_tuple(tes,(uint32_t)RARRAY_LEN(array));
100
+ //for(i=0;i<RARRAY(array)->len;i++){
101
+ // erl_free_term(*(tes+i));
102
+ //}
103
+ free(tes);
104
+ return self;
105
+ }
106
+
107
+ static VALUE erlix_tuple_create(int argc,VALUE *argv,VALUE klass){
108
+
109
+ ETERM *rterm=NULL;
110
+ ETERM **tes;
111
+ ErlixTerm *ep;
112
+ int i;
113
+
114
+ if(argc==0){
115
+ //empty tuple
116
+ rterm=erl_mk_tuple(NULL,0);
117
+ }else if(argc>0){
118
+ //check: all elements' must be Erlix::Term
119
+ //or automatic conversions
120
+ for(i=0;i<argc;i++){
121
+ if(!IS_ETERM(argv[i]) && !CAN_AUTO_CONV(argv[i])){
122
+ rb_raise(rb_eTypeError,"all tuple's elements must be Erlix::Term!");
123
+ }
124
+ }
125
+ tes=(ETERM**)malloc(sizeof(ETERM*)*argc);
126
+ for(i=0;i<argc;i++){
127
+ if(IS_ETERM(argv[i])){
128
+ Data_Get_Struct(argv[i],ErlixTerm,ep);
129
+ *(tes+i)=erl_copy_term(ep->term);
130
+ }else{
131
+ *(tes+i)=erlix_auto_conv(argv[i]);
132
+ }
133
+ }
134
+ rterm=erl_mk_tuple(tes,argc);
135
+ //for(i=0;i<argc;i++){
136
+ // erl_free_term(*(tes+i));
137
+ //}
138
+ free(tes);
139
+ }
140
+ return erlix_term(rterm);
141
+ }
142
+
143
+ static VALUE erlix_tuple_nth(VALUE self,VALUE index){
144
+ ErlixTerm *tuple;
145
+ ETERM *e;
146
+
147
+ if(TYPE(index)!=T_FIXNUM){
148
+ rb_raise(rb_eTypeError,"index must be a fixnum(1..len)!");
149
+ return Qnil;
150
+ }
151
+ Data_Get_Struct(self,ErlixTerm,tuple);
152
+ if(ERL_TUPLE_SIZE(tuple->term)<FIX2INT(index)||FIX2INT(index)<=0){
153
+ return Qnil;
154
+ }
155
+ e=erl_element(FIX2INT(index),tuple->term);
156
+ return erlix_term(erl_copy_term(e));
157
+ }
158
+
159
+ static VALUE erlix_tuple_to_ary(VALUE self){
160
+ ErlixTerm *tuple;
161
+ int len, i;
162
+ ETERM *e;
163
+ VALUE ret;
164
+
165
+ Data_Get_Struct(self,ErlixTerm,tuple);
166
+ len=ERL_TUPLE_SIZE(tuple->term);
167
+ ret=rb_ary_new2(len);
168
+ for(i=0;i<len;i++){
169
+ e=erl_element(i+1,tuple->term);
170
+ rb_ary_store(ret,i,erlix_term(erl_copy_term(e)));
171
+ }
172
+ return ret;
173
+ }
174
+
175
+
176
+ static VALUE erlix_tuple_size(VALUE self){
177
+ ErlixTerm *tuple;
178
+ int len;
179
+
180
+ Data_Get_Struct(self,ErlixTerm,tuple);
181
+ len=ERL_TUPLE_SIZE(tuple->term);
182
+ return INT2FIX(len);
183
+ }
184
+
185
+ static VALUE erlix_tuple_inspect(VALUE self){
186
+ VALUE ret=rb_str_new2("#<Erlix::Tuple:");
187
+ ID concat=rb_intern("concat");
188
+ rb_funcall(ret,concat,1,rb_funcall(self,rb_intern("to_s"),0));
189
+ rb_funcall(ret,concat,1,rb_str_new2(">"));
190
+ return ret;
191
+ }
192
+
193
+ static VALUE erlix_tuple_etype(VALUE self){
194
+ return rb_str_new2("tuple");
195
+ }
196
+
197
+ void init_erlix_tuple(VALUE erlix){
198
+ erlix_cErlixTuple=rb_define_class_under(erlix,"Tuple",rb_cObject);
199
+
200
+ rb_define_alloc_func(erlix_cErlixTuple,erlix_tuple_alloc);
201
+ rb_define_method(erlix_cErlixTuple,"initialize",erlix_tuple_init2,-1);
202
+ rb_define_method(erlix_cErlixTuple,"nth",erlix_tuple_nth,1);
203
+ rb_define_method(erlix_cErlixTuple,"[]",erlix_tuple_nth,1);
204
+ rb_define_method(erlix_cErlixTuple,"to_a",erlix_tuple_to_ary,0);
205
+ rb_define_method(erlix_cErlixTuple,"size",erlix_tuple_size,0);
206
+ rb_define_method(erlix_cErlixTuple,"inspect",erlix_tuple_inspect,0);
207
+ rb_define_method(erlix_cErlixTuple,"etype",erlix_tuple_etype,0);
208
+
209
+ rb_define_singleton_method(erlix_cErlixTuple, "[]", erlix_tuple_create, -1);
210
+
211
+ rb_include_module(erlix_cErlixTuple,erlix_mErlixTerm);
212
+ }
213
+
214
+
215
+
@@ -0,0 +1,63 @@
1
+ /*
2
+ * project : erlix
3
+ * author : kdr2
4
+ *
5
+ */
6
+
7
+ #include <stdio.h>
8
+ #include <string.h>
9
+
10
+ #include "erlix_term.h"
11
+
12
+ VALUE erlix_cErlixUInt;
13
+
14
+ VALUE erlix_uint_alloc(VALUE klass){
15
+ ErlixTerm* euint;
16
+ VALUE obj;
17
+ euint=new_erlix_term();
18
+ euint->type=TYPE_UINT;
19
+ obj=Data_Wrap_Struct(klass,0,free_erlix_term,euint);
20
+ return obj;
21
+ }
22
+
23
+ static VALUE erlix_uint_init(VALUE self,VALUE fix){
24
+ ErlixTerm* euint;
25
+ unsigned int i=FIX2UINT(fix);
26
+ Data_Get_Struct(self,ErlixTerm,euint);
27
+ euint->term=erl_mk_uint(i);
28
+ return self;
29
+ }
30
+
31
+
32
+ static VALUE erlix_uint_to_fix(VALUE self){
33
+ ErlixTerm *euint;
34
+ unsigned int l;
35
+ Data_Get_Struct(self,ErlixTerm,euint);
36
+ l=ERL_INT_VALUE(euint->term);
37
+ return INT2FIX(l);
38
+ }
39
+
40
+ static VALUE erlix_uint_inspect(VALUE self){
41
+ VALUE ret=rb_str_new2("#<Erlix::UInt:");
42
+ ID concat=rb_intern("concat");
43
+ rb_funcall(ret,concat,1,rb_funcall(self,rb_intern("to_s"),0));
44
+ rb_funcall(ret,concat,1,rb_str_new2(">"));
45
+ return ret;
46
+ }
47
+
48
+ static VALUE erlix_uint_etype(VALUE self){
49
+ return rb_str_new2("unsigned int");
50
+ }
51
+
52
+ void init_erlix_uint(VALUE erlix){
53
+ erlix_cErlixUInt=rb_define_class_under(erlix,"UInt",rb_cObject);
54
+
55
+ rb_define_alloc_func(erlix_cErlixUInt,erlix_uint_alloc);
56
+ rb_define_method(erlix_cErlixUInt,"initialize",erlix_uint_init,1);
57
+ rb_define_method(erlix_cErlixUInt,"to_i",erlix_uint_to_fix,0);
58
+ rb_define_method(erlix_cErlixUInt,"inspect",erlix_uint_inspect,0);
59
+ rb_define_method(erlix_cErlixUInt,"etype",erlix_uint_etype,0);
60
+
61
+ rb_include_module(erlix_cErlixUInt,erlix_mErlixTerm);
62
+ }
63
+
metadata ADDED
@@ -0,0 +1,66 @@
1
+ --- !ruby/object:Gem::Specification
2
+ name: erlix
3
+ version: !ruby/object:Gem::Version
4
+ version: 0.5.0a
5
+ prerelease: 5
6
+ platform: ruby
7
+ authors:
8
+ - KDr2
9
+ autorequire:
10
+ bindir: bin
11
+ cert_chain: []
12
+ date: 2012-07-25 00:00:00.000000000 Z
13
+ dependencies: []
14
+ description: Run ruby as an Erlang Node!
15
+ email: killy.draw@gmail.com
16
+ executables: []
17
+ extensions:
18
+ - _extconf.rb
19
+ extra_rdoc_files: []
20
+ files:
21
+ - configure
22
+ - _extconf.rb
23
+ - extconf.rb
24
+ - findei.erl
25
+ - src/erlix.c
26
+ - src/erlix_atom.c
27
+ - src/erlix_binary.c
28
+ - src/erlix_connection.c
29
+ - src/erlix_float.c
30
+ - src/erlix_int.c
31
+ - src/erlix_list.c
32
+ - src/erlix_message.c
33
+ - src/erlix_node.c
34
+ - src/erlix_pid.c
35
+ - src/erlix_ref.c
36
+ - src/erlix_term.c
37
+ - src/erlix_tuple.c
38
+ - src/erlix_uint.c
39
+ - src/erlix_connection.h
40
+ - src/erlix_node.h
41
+ - src/erlix_term.h
42
+ homepage: http://github.com/KDr2/erlix
43
+ licenses: []
44
+ post_install_message: Thanks for installing!
45
+ rdoc_options: []
46
+ require_paths:
47
+ - lib
48
+ required_ruby_version: !ruby/object:Gem::Requirement
49
+ none: false
50
+ requirements:
51
+ - - ! '>='
52
+ - !ruby/object:Gem::Version
53
+ version: 1.9.2
54
+ required_rubygems_version: !ruby/object:Gem::Requirement
55
+ none: false
56
+ requirements:
57
+ - - ! '>'
58
+ - !ruby/object:Gem::Version
59
+ version: 1.3.1
60
+ requirements: []
61
+ rubyforge_project:
62
+ rubygems_version: 1.8.24
63
+ signing_key:
64
+ specification_version: 3
65
+ summary: Run ruby as an Erlang Node!
66
+ test_files: []