rua 0.1.3 → 0.1.4

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.
Files changed (4) hide show
  1. data/README.txt +21 -0
  2. data/ext/rua.c +89 -7
  3. data/ext/rua.h +12 -0
  4. metadata +2 -2
data/README.txt CHANGED
@@ -45,3 +45,24 @@ Rua is a library for using Lua under Ruby.
45
45
 
46
46
  rua.f.call
47
47
  p rua.eval('return 1, 2, 3')
48
+
49
+ co = rua.eval(<<-EOS)
50
+ function foo (a)
51
+ print('foo', a)
52
+ return coroutine.yield(2 * a)
53
+ end
54
+
55
+ return coroutine.create(function (a, b)
56
+ print('co-body', a, b)
57
+ local r = foo(a + 1)
58
+ print('co-body', r)
59
+ local r, s = coroutine.yield(a + b, a - b)
60
+ print('co-body', r, s)
61
+ return b, 'end'
62
+ end)
63
+ EOS
64
+
65
+ p co.resume(1, 10)
66
+ p co.resume('r')
67
+ p co.resume('x', 'y')
68
+ p co.resume('x', 'y')
data/ext/rua.c CHANGED
@@ -71,16 +71,17 @@ static const char *insecure_methods[] = {
71
71
  };
72
72
 
73
73
  static const int insecure_method_num = sizeof(insecure_methods) / sizeof(char*);
74
- static VALUE Rua, RuaFunc, RuaError;
74
+ static VALUE Rua, RuaFunc, RuaThread, RuaError;
75
75
  static VALUE s_all, s_base, s_package, s_string, s_table, s_math, s_io, s_debug;
76
76
 
77
77
  void Init_rua() {
78
78
  Rua = rb_define_class("Rua", rb_cObject);
79
79
  RuaFunc = rb_define_class("RuaFunc", rb_cObject);
80
+ RuaThread = rb_define_class("RuaThread", rb_cObject);
80
81
  RuaError = rb_define_class("RuaError", rb_eStandardError);
81
82
 
82
83
  rb_define_alloc_func(Rua, rua_alloc);
83
- rb_define_const(Rua, "VERSION", rb_str_new2("0.1.3"));
84
+ rb_define_const(Rua, "VERSION", rb_str_new2("0.1.4"));
84
85
  rb_define_private_method(Rua, "initialize", rua_initialize, -1);
85
86
  rb_define_method(Rua, "openlibs", rua_openlibs, -1);
86
87
  rb_define_method(Rua, "eval", rua_eval, 1);
@@ -94,6 +95,10 @@ void Init_rua() {
94
95
  rb_define_private_method(RuaFunc, "initialize", rua_func_initialize, 0);
95
96
  rb_define_method(RuaFunc, "call", rua_func_call, -1);
96
97
 
98
+ rb_define_alloc_func(RuaThread, rua_thread_alloc);
99
+ rb_define_private_method(RuaThread, "initialize", rua_thread_initialize, 0);
100
+ rb_define_method(RuaThread, "resume", rua_thread_resume, -1);
101
+
97
102
  s_all = ID2SYM(rb_intern("all"));
98
103
  s_base = ID2SYM(rb_intern("base"));
99
104
  s_package = ID2SYM(rb_intern("package"));
@@ -194,8 +199,8 @@ static VALUE rua_eval(VALUE self, VALUE str) {
194
199
  const char *errmsg;
195
200
  int pretop, nresults, i;
196
201
 
197
- Data_Get_Struct(self, struct rua, p);
198
202
  Check_Type(str, T_STRING);
203
+ Data_Get_Struct(self, struct rua, p);
199
204
  pretop = lua_gettop(p->L);
200
205
  luaL_loadstring(p->L, StringValuePtr(str));
201
206
 
@@ -350,6 +355,62 @@ static VALUE rua_func_call(int argc, VALUE *argv, VALUE self) {
350
355
 
351
356
  // ------------------------------------------------------------------
352
357
 
358
+ static VALUE rua_thread_alloc(VALUE klass) {
359
+ struct rua_thread *p = ALLOC(struct rua_thread);
360
+
361
+ return Data_Wrap_Struct(klass, 0, -1, p);
362
+ }
363
+
364
+ static VALUE rua_thread_initialize(VALUE self) {
365
+ return Qnil;
366
+ }
367
+
368
+ static VALUE rua_thread_resume(int argc, VALUE *argv, VALUE self) {
369
+ struct rua_thread *p;
370
+ VALUE retval;
371
+ int pretop, nresults, i;
372
+ const char *errmsg;
373
+
374
+ Data_Get_Struct(self, struct rua_thread , p);
375
+ lua_getglobal(p->L, "coroutine");
376
+ pretop = lua_gettop(p->L);
377
+ lua_pushstring(p->L, "resume");
378
+ lua_gettable(p->L, pretop);
379
+ lua_rawgeti(p->L, LUA_REGISTRYINDEX, p->ref);
380
+
381
+ for (i = 0; i < argc; i ++) {
382
+ rua_pushrbval(p->L, argv[i], p->error_handler, p->secure);
383
+ }
384
+
385
+ if (lua_pcall(p->L, argc + 1, LUA_MULTRET, 0) != 0) {
386
+ errmsg = lua_tostring(p->L, -1);
387
+ lua_pop(p->L, 2);
388
+ rb_raise(RuaError, "%s", errmsg);
389
+ }
390
+
391
+ nresults = lua_gettop(p->L) - pretop;
392
+
393
+ if (nresults == 0) {
394
+ lua_pop(p->L, 1);
395
+ return Qnil;
396
+ } else if (nresults == 1) {
397
+ retval = rua_torbval(p->L, -1, p->error_handler, p->secure);
398
+ lua_pop(p->L, 2);
399
+ return retval;
400
+ } else {
401
+ retval = rb_ary_new();
402
+
403
+ for (i = nresults; i > 0; i--) {
404
+ rb_ary_push(retval, rua_torbval(p->L, -i, p->error_handler, p->secure));
405
+ }
406
+
407
+ lua_pop(p->L, nresults + 1);
408
+ return retval;
409
+ }
410
+ }
411
+
412
+ // ------------------------------------------------------------------
413
+
353
414
  static VALUE rua_torbval(lua_State *L, int idx, VALUE error_handler, int secure) {
354
415
  VALUE rbval = Qnil;
355
416
 
@@ -374,6 +435,10 @@ static VALUE rua_torbval(lua_State *L, int idx, VALUE error_handler, int secure)
374
435
  rbval = rua_toruafunc(L, idx, error_handler, secure);
375
436
  break;
376
437
 
438
+ case LUA_TTHREAD:
439
+ rbval = rua_toruathread(L, idx, error_handler, secure);
440
+ break;
441
+
377
442
  case LUA_TLIGHTUSERDATA:
378
443
  rbval = (VALUE) lua_touserdata(L, idx);
379
444
  break;
@@ -403,7 +468,8 @@ static VALUE rua_tohash(lua_State *L, int idx, VALUE error_handler, int secure)
403
468
  }
404
469
 
405
470
  static void rua_pushrbval(lua_State *L, VALUE rbval, VALUE error_handler, int secure) {
406
- struct rua_func *p;
471
+ struct rua_func *pf;
472
+ struct rua_thread *pt;
407
473
 
408
474
  switch (TYPE(rbval)) {
409
475
  case T_NIL:
@@ -441,8 +507,11 @@ static void rua_pushrbval(lua_State *L, VALUE rbval, VALUE error_handler, int se
441
507
  fprintf(stderr, "warning: convert insecure value %s", rua_to_sptr(rbval));
442
508
  lua_pushnil(L);
443
509
  } else if (rb_obj_is_kind_of(rbval, RuaFunc)) {
444
- Data_Get_Struct(rbval, struct rua_func, p);
445
- lua_rawgeti(L, LUA_REGISTRYINDEX, p->ref);
510
+ Data_Get_Struct(rbval, struct rua_func, pf);
511
+ lua_rawgeti(L, LUA_REGISTRYINDEX, pf->ref);
512
+ } else if (rb_obj_is_kind_of(rbval, RuaThread)) {
513
+ Data_Get_Struct(rbval, struct rua_thread, pt);
514
+ lua_rawgeti(L, LUA_REGISTRYINDEX, pt->ref);
446
515
  } else if (rua_obj_is_executable(rbval)) {
447
516
  lua_pushlightuserdata(L, (void *) rbval);
448
517
  lua_pushlightuserdata(L, (void *) error_handler);
@@ -563,10 +632,23 @@ static VALUE rua_toruafunc(lua_State *L, int idx, VALUE error_handler, int secur
563
632
  p->secure = secure;
564
633
  lua_pushvalue(L, idx);
565
634
  p->ref = luaL_ref(L, LUA_REGISTRYINDEX);
566
- lua_pop(L, 1);
567
635
  return f;
568
636
  }
569
637
 
638
+ static VALUE rua_toruathread(lua_State *L, int idx, VALUE error_handler, int secure) {
639
+ struct rua_thread *p;
640
+ VALUE t;
641
+
642
+ t = rb_funcall(RuaThread, rb_intern("new"), 0);
643
+ Data_Get_Struct(t, struct rua_thread, p);
644
+ p->L = L;
645
+ p->error_handler = error_handler;
646
+ p->secure = secure;
647
+ lua_pushvalue(L, idx);
648
+ p->ref = luaL_ref(L, LUA_REGISTRYINDEX);
649
+ return t;
650
+ }
651
+
570
652
  static VALUE rua_obj_is_executable(VALUE obj) {
571
653
  return (rb_obj_is_kind_of(obj, rb_cProc) || rb_obj_is_kind_of(obj, rb_cMethod));
572
654
  }
data/ext/rua.h CHANGED
@@ -14,6 +14,13 @@ struct rua_func {
14
14
  int secure;
15
15
  };
16
16
 
17
+ struct rua_thread {
18
+ lua_State *L;
19
+ int ref;
20
+ VALUE error_handler;
21
+ int secure;
22
+ };
23
+
17
24
  void Init_rua();
18
25
  static VALUE rua_alloc(VALUE klass);
19
26
  static void rua_free(struct rua *p);
@@ -30,6 +37,10 @@ static VALUE rua_func_alloc(VALUE klass);
30
37
  static VALUE rua_func_initialize(VALUE self);
31
38
  static VALUE rua_func_call(int argc, VALUE *argv, VALUE self);
32
39
 
40
+ static VALUE rua_thread_alloc(VALUE klass);
41
+ static VALUE rua_thread_initialize(VALUE self);
42
+ static VALUE rua_thread_resume(int argc, VALUE *argv, VALUE self);
43
+
33
44
  static VALUE rua_torbval(lua_State *L, int idx, VALUE error_handler, int secure);
34
45
  static VALUE rua_tohash(lua_State *L, int idx, VALUE error_handler, int secure);
35
46
  static void rua_pushrbval(lua_State *L, VALUE rbval, VALUE error_handler, int secure);
@@ -39,6 +50,7 @@ static void rua_newtable_from_obj(lua_State *L, VALUE obj, VALUE error_handler,
39
50
  static int rua_proc_call(lua_State *L);
40
51
  static VALUE _rua_proc_call(VALUE args);
41
52
  static VALUE rua_toruafunc(lua_State *L, int idx, VALUE error_handler, int secure);
53
+ static VALUE rua_toruathread(lua_State *L, int idx, VALUE error_handler, int secure);
42
54
  static VALUE rua_obj_is_executable(VALUE obj);
43
55
  static int rua_name_is_insecure_method(const char *name);
44
56
  static VALUE rua_to_s(VALUE v);
metadata CHANGED
@@ -3,8 +3,8 @@ rubygems_version: 0.9.2
3
3
  specification_version: 1
4
4
  name: rua
5
5
  version: !ruby/object:Gem::Version
6
- version: 0.1.3
7
- date: 2007-11-14 00:00:00 +09:00
6
+ version: 0.1.4
7
+ date: 2007-11-15 00:00:00 +09:00
8
8
  summary: rua is a library for using Lua under Ruby.
9
9
  require_paths:
10
10
  - lib