webruby 0.1.2 → 0.2.1

data/modules/mruby/src/class.c

@@ -55,7 +55,7 @@ mrb_name_class(mrb_state *mrb, struct RClass *c, mrb_sym name)
   mrb_obj_iv_set(mrb, (struct RObject*)c,
                  mrb_intern2(mrb, "__classid__", 11), mrb_symbol_value(name));
 }
-                                
+
 #define make_metaclass(mrb, c) prepare_singleton_class((mrb), (struct RBasic*)(c))
 
 static void
@@ -311,6 +311,7 @@ mrb_define_method_id(mrb_state *mrb, struct RClass *c, mrb_sym mid, mrb_func_t f
   int ai = mrb_gc_arena_save(mrb);
 
   p = mrb_proc_new_cfunc(mrb, func);
+  p->target_class = c;
   mrb_define_method_raw(mrb, c, mid, p);
   mrb_gc_arena_restore(mrb, ai);
 }
@@ -489,14 +490,19 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
         mrb_value ss;
         struct RString *s;
         char **ps;
+        mrb_int len;
 
         ps = va_arg(ap, char**);
         if (i < argc) {
           ss = to_str(mrb, *sp++);
           s = mrb_str_ptr(ss);
-          if ((mrb_int)strlen(s->ptr) < s->len) {
+          len = (mrb_int)strlen(s->ptr);
+          if (len < s->len) {
             mrb_raise(mrb, E_ARGUMENT_ERROR, "String contains NUL");
           }
+          else if (len > s->len) {
+            mrb_str_modify(mrb, s);
+          }
           *ps = s->ptr;
           i++;
         }
@@ -927,7 +933,7 @@ mrb_singleton_class(mrb_state *mrb, mrb_value v)
     return mrb_obj_value(mrb->false_class);
   case MRB_TT_TRUE:
     return mrb_obj_value(mrb->true_class);
-  case MRB_TT_VOIDP:
+  case MRB_TT_CPTR:
     return mrb_obj_value(mrb->object_class);
   case MRB_TT_SYMBOL:
   case MRB_TT_FIXNUM:
@@ -1003,10 +1009,19 @@ mrb_method_search(mrb_state *mrb, struct RClass* c, mrb_sym mid)
   return m;
 }
 
-void
-mrb_obj_call_init(mrb_state *mrb, mrb_value obj, int argc, mrb_value *argv)
+static mrb_value
+mrb_instance_alloc(mrb_state *mrb, mrb_value cv)
 {
-  mrb_funcall_argv(mrb, obj, mrb->init_sym, argc, argv);
+  struct RClass *c = mrb_class_ptr(cv);
+  struct RObject *o;
+  enum mrb_vtype ttype = MRB_INSTANCE_TT(c);
+
+  if (c->tt == MRB_TT_SCLASS)
+    mrb_raise(mrb, E_TYPE_ERROR, "can't create instance of singleton class");
+
+  if (ttype == 0) ttype = MRB_TT_OBJECT;
+  o = (struct RObject*)mrb_obj_alloc(mrb, ttype, c);
+  return mrb_obj_value(o);
 }
 
 /*
@@ -1020,59 +1035,33 @@ mrb_obj_call_init(mrb_state *mrb, mrb_value obj, int argc, mrb_value *argv)
  *  an object is constructed using .new.
  *
  */
-mrb_value
-mrb_class_new_instance(mrb_state *mrb, int argc, mrb_value *argv, struct RClass * klass)
-{
-  mrb_value obj;
-  struct RClass * c = (struct RClass*)mrb_obj_alloc(mrb, klass->tt, klass);
-  c->super = klass;
-  obj = mrb_obj_value(c);
-  mrb_obj_call_init(mrb, obj, argc, argv);
-  return obj;
-}
 
 mrb_value
-mrb_class_new_instance_m(mrb_state *mrb, mrb_value klass)
+mrb_instance_new(mrb_state *mrb, mrb_value cv)
 {
+  mrb_value obj, blk;
   mrb_value *argv;
-  mrb_value blk;
-  struct RClass *k = mrb_class_ptr(klass);
-  struct RClass *c;
   int argc;
-  mrb_value obj;
 
+  obj = mrb_instance_alloc(mrb, cv);
   mrb_get_args(mrb, "*&", &argv, &argc, &blk);
-  c = (struct RClass*)mrb_obj_alloc(mrb, k->tt, k);
-  c->super = k;
-  obj = mrb_obj_value(c);
-  mrb_funcall_with_block(mrb, obj, mrb->init_sym, argc, argv, blk);
+  mrb_funcall_with_block(mrb, obj, mrb_intern2(mrb, "initialize", 10), argc, argv, blk);
 
   return obj;
 }
 
 mrb_value
-mrb_instance_new(mrb_state *mrb, mrb_value cv)
+mrb_obj_new(mrb_state *mrb, struct RClass *c, int argc, mrb_value *argv)
 {
-  struct RClass *c = mrb_class_ptr(cv);
-  struct RObject *o;
-  enum mrb_vtype ttype = MRB_INSTANCE_TT(c);
-  mrb_value obj, blk;
-  mrb_value *argv;
-  int argc;
+  mrb_value obj;
 
-  if (c->tt == MRB_TT_SCLASS)
-    mrb_raise(mrb, E_TYPE_ERROR, "can't create instance of singleton class");
-
-  if (ttype == 0) ttype = MRB_TT_OBJECT;
-  o = (struct RObject*)mrb_obj_alloc(mrb, ttype, c);
-  obj = mrb_obj_value(o);
-  mrb_get_args(mrb, "*&", &argv, &argc, &blk);
-  mrb_funcall_with_block(mrb, obj, mrb->init_sym, argc, argv, blk);
+  obj = mrb_instance_alloc(mrb, mrb_obj_value(c));
+  mrb_funcall_argv(mrb, obj, mrb_intern2(mrb, "initialize", 10), argc, argv);
 
   return obj;
 }
 
-mrb_value
+static mrb_value
 mrb_class_new_class(mrb_state *mrb, mrb_value cv)
 {
   mrb_value super;
@@ -1844,6 +1833,18 @@ mrb_mod_remove_const(mrb_state *mrb, mrb_value mod)
   return val;
 }
 
+mrb_value
+mrb_mod_const_missing(mrb_state *mrb, mrb_value mod)
+{
+  mrb_sym sym;
+
+  mrb_get_args(mrb, "n", &sym);
+  mrb_name_error(mrb, sym, "uninitialized constant %S",
+                 mrb_sym2str(mrb, sym));
+  /* not reached */
+  return mrb_nil_value();
+}
+
 static mrb_value
 mrb_mod_s_constants(mrb_state *mrb, mrb_value mod)
 {
@@ -1937,6 +1938,7 @@ mrb_init_class(mrb_state *mrb)
   mrb_define_method(mrb, mod, "const_set",               mrb_mod_const_set,        MRB_ARGS_REQ(2)); /* 15.2.2.4.23 */
   mrb_define_method(mrb, mod, "constants",               mrb_mod_constants,        MRB_ARGS_NONE()); /* 15.2.2.4.24 */
   mrb_define_method(mrb, mod, "remove_const",            mrb_mod_remove_const,     MRB_ARGS_REQ(1)); /* 15.2.2.4.40 */
+  mrb_define_method(mrb, mod, "const_missing",           mrb_mod_const_missing,    MRB_ARGS_REQ(1));
   mrb_define_method(mrb, mod, "define_method",           mod_define_method,        MRB_ARGS_REQ(1));
   mrb_define_method(mrb, mod, "class_variables",         mrb_mod_class_variables,  MRB_ARGS_NONE()); /* 15.2.2.4.19 */
   mrb_define_method(mrb, mod, "===",                     mrb_mod_eqq,              MRB_ARGS_REQ(1));

data/modules/mruby/src/codegen.c

@@ -12,6 +12,7 @@
 #include "mruby/irep.h"
 #include "mruby/numeric.h"
 #include "mruby/string.h"
+#include "mruby/debug.h"
 #include "node.h"
 #include "opcode.h"
 #include "re.h"
@@ -51,11 +52,11 @@ typedef struct scope {
 
   struct loopinfo *loop;
   int ensure_level;
-  char *filename;
-  short lineno;
+  char const *filename;
+  uint16_t lineno;
 
   mrb_code *iseq;
-  short *lines;
+  uint16_t *lines;
   int icapa;
 
   mrb_irep *irep;
@@ -67,6 +68,10 @@ typedef struct scope {
   int ai;
 
   int idx;
+
+  int debug_start_pos;
+  uint16_t filename_index;
+  parser_state* parser;
 } codegen_scope;
 
 static codegen_scope* scope_new(mrb_state *mrb, codegen_scope *prev, node *lv);
@@ -141,7 +146,8 @@ genop(codegen_scope *s, mrb_code i)
     s->icapa *= 2;
     s->iseq = (mrb_code *)codegen_realloc(s, s->iseq, sizeof(mrb_code)*s->icapa);
     if (s->lines) {
-      s->lines = (short*)codegen_realloc(s, s->lines, sizeof(short)*s->icapa);
+      s->lines = (uint16_t*)codegen_realloc(s, s->lines, sizeof(short)*s->icapa);
+      s->irep->lines = s->lines;
     }
   }
   s->iseq[s->pc] = i;
@@ -271,18 +277,6 @@ genop_peep(codegen_scope *s, mrb_code i, int val)
       case OP_MOVE:
         s->iseq[s->pc-1] = MKOP_AB(OP_RETURN, GETARG_B(i0), OP_R_NORMAL);
         return;
-      case OP_LOADI:
-        s->iseq[s->pc-1] = MKOP_AsBx(OP_LOADI, 0, GETARG_sBx(i0));
-        genop(s, MKOP_AB(OP_RETURN, 0, OP_R_NORMAL));
-        return;
-      case OP_ARRAY:
-      case OP_HASH:
-      case OP_RANGE:
-      case OP_AREF:
-      case OP_GETUPVAR:
-        s->iseq[s->pc-1] = MKOP_ABC(c0, 0, GETARG_B(i0), GETARG_C(i0));
-        genop(s, MKOP_AB(OP_RETURN, 0, OP_R_NORMAL));
-        return;
       case OP_SETIV:
       case OP_SETCV:
       case OP_SETCONST:
@@ -294,29 +288,6 @@ genop_peep(codegen_scope *s, mrb_code i, int val)
         i0 = s->iseq[s->pc-1];
         genop(s, MKOP_AB(OP_RETURN, GETARG_A(i0), OP_R_NORMAL));
         return;
-      case OP_LOADSYM:
-      case OP_GETGLOBAL:
-      case OP_GETIV:
-      case OP_GETCV:
-      case OP_GETCONST:
-      case OP_GETSPECIAL:
-      case OP_LOADL:
-      case OP_STRING:
-        s->iseq[s->pc-1] = MKOP_ABx(c0, 0, GETARG_Bx(i0));
-        genop(s, MKOP_AB(OP_RETURN, 0, OP_R_NORMAL));
-        return;
-      case OP_SCLASS:
-        s->iseq[s->pc-1] = MKOP_AB(c0, GETARG_A(i), GETARG_B(i0));
-        genop(s, MKOP_AB(OP_RETURN, 0, OP_R_NORMAL));
-        return;
-      case OP_LOADNIL:
-      case OP_LOADSELF:
-      case OP_LOADT:
-      case OP_LOADF:
-      case OP_OCLASS:
-        s->iseq[s->pc-1] = MKOP_A(c0, 0);
-        genop(s, MKOP_AB(OP_RETURN, 0, OP_R_NORMAL));
-        return;
 #if 0
       case OP_SEND:
         if (GETARG_B(i) == OP_R_NORMAL && GETARG_A(i) == GETARG_A(i0)) {
@@ -713,16 +684,23 @@ static int
 gen_values(codegen_scope *s, node *t, int val)
 {
   int n = 0;
+  int is_splat;
 
   while (t) {
-    if (n >= 127 || (intptr_t)t->car->car == NODE_SPLAT) { // splat mode
+    is_splat = (intptr_t)t->car->car == NODE_SPLAT; // splat mode
+    if (n >= 127 || is_splat) {
       if (val) {
         pop_n(n);
         genop(s, MKOP_ABC(OP_ARRAY, cursp(), cursp(), n));
         push();
         codegen(s, t->car, VAL);
         pop(); pop();
-        genop(s, MKOP_AB(OP_ARYCAT, cursp(), cursp()+1));
+        if (is_splat) {
+            genop(s, MKOP_AB(OP_ARYCAT, cursp(), cursp()+1));
+        }
+        else {
+            genop(s, MKOP_AB(OP_ARYPUSH, cursp(), cursp()+1));
+        }
         t = t->cdr;
         while (t) {
           push();
@@ -959,6 +937,9 @@ gen_vmassignment(codegen_scope *s, node *tree, int rhs, int val)
       }
     }
   }
+  else {
+    pop();
+  }
 }
 
 static void
@@ -1104,6 +1085,15 @@ codegen(codegen_scope *s, node *tree, int val)
   int nt;
 
   if (!tree) return;
+
+  if (s->irep && s->pc > 0 && s->filename_index != tree->filename_index) {
+    s->irep->filename = mrb_parser_get_filename(s->parser, s->filename_index);
+    mrb_debug_info_append_file(s->mrb, s->irep, s->debug_start_pos, s->pc);
+    s->debug_start_pos = s->pc;
+    s->filename_index = tree->filename_index;
+    s->filename = mrb_parser_get_filename(s->parser, tree->filename_index);
+  }
+
   nt = (intptr_t)tree->car;
   s->lineno = tree->lineno;
   tree = tree->cdr;
@@ -2389,9 +2379,23 @@ scope_new(mrb_state *mrb, codegen_scope *prev, node *lv)
 
   p->filename = prev->filename;
   if (p->filename) {
-    p->lines = (short*)mrb_malloc(mrb, sizeof(short)*p->icapa);
+    p->lines = (uint16_t*)mrb_malloc(mrb, sizeof(short)*p->icapa);
   }
   p->lineno = prev->lineno;
+
+  // debug setting
+  p->debug_start_pos = 0;
+  if(p->filename) {
+    mrb_debug_info_alloc(mrb, p->irep);
+    p->irep->filename = p->filename;
+    p->irep->lines = p->lines;
+  }
+  else {
+    p->irep->debug_info = NULL;
+  }
+  p->parser = prev->parser;
+  p->filename_index = prev->filename_index;
+
   return p;
 }
 
@@ -2417,6 +2421,9 @@ scope_finish(codegen_scope *s)
   irep->pool = (mrb_value *)codegen_realloc(s, irep->pool, sizeof(mrb_value)*irep->plen);
   irep->syms = (mrb_sym *)codegen_realloc(s, irep->syms, sizeof(mrb_sym)*irep->slen);
   if (s->filename) {
+    s->irep->filename = mrb_parser_get_filename(s->parser, s->filename_index);
+    mrb_debug_info_append_file(mrb, s->irep, s->debug_start_pos, s->pc);
+
     fname_len = strlen(s->filename);
     fname = codegen_malloc(s, fname_len + 1);
     memcpy(fname, s->filename, fname_len);
@@ -2828,7 +2835,6 @@ codedump_all(mrb_state *mrb, int start)
     codedump(mrb, i);
   }
 }
-
 static int
 codegen_start(mrb_state *mrb, parser_state *p)
 {
@@ -2838,9 +2844,9 @@ codegen_start(mrb_state *mrb, parser_state *p)
     return -1;
   }
   scope->mrb = mrb;
-  if (p->filename) {
-    scope->filename = p->filename;
-  }
+  scope->parser = p;
+  scope->filename = p->filename;
+  scope->filename_index = p->current_filename_index;
   if (setjmp(scope->jmp) == 0) {
     // prepare irep
     codegen(scope, p->tree, NOVAL);

data/modules/mruby/src/debug.c

@@ -0,0 +1,214 @@
+#include <string.h>
+#include "mruby.h"
+#include "mruby/irep.h"
+#include "mruby/debug.h"
+
+static mrb_irep_debug_info_file *
+get_file(mrb_irep_debug_info *info, uint32_t pc)
+{
+  mrb_irep_debug_info_file **ret;
+  int32_t count;
+
+  if(pc >= info->pc_count) { return NULL; }
+  // get upper bound
+  ret = info->files;
+  count =  info->flen;
+  while (count > 0) {
+    int32_t step = count / 2;
+    mrb_irep_debug_info_file **it = ret + step;
+    if (!(pc < (*it)->start_pos)) {
+      ret = it + 1;
+      count -= step + 1;
+    } else { count = step; }
+  }
+
+  --ret;
+
+  // check returning file exists inside debug info
+  mrb_assert(info->files <= ret && ret < (info->files + info->flen));
+  // check pc is within the range of returning file
+  mrb_assert((*ret)->start_pos <= pc &&
+             pc < (((ret + 1 - info->files) < info->flen)
+                   ? (*(ret+1))->start_pos : info->pc_count));
+
+  return *ret;
+}
+
+static mrb_debug_line_type
+select_line_type(const uint16_t *lines, size_t lines_len)
+{
+  size_t line_count = 0;
+  int prev_line = -1;
+  size_t i;
+  for (i = 0; i < lines_len; ++i) {
+    if (lines[i] != prev_line) {
+      ++line_count;
+    }
+  }
+  return (sizeof(uint16_t) * lines_len) <= (sizeof(mrb_irep_debug_info_line) * line_count)
+      ? mrb_debug_line_ary : mrb_debug_line_flat_map;
+}
+
+char const*
+mrb_debug_get_filename(mrb_irep *irep, uint32_t pc)
+{
+  if (irep && pc < irep->ilen) {
+    mrb_irep_debug_info_file* f = NULL;
+    if (!irep->debug_info) { return irep->filename; }
+    else if ((f = get_file(irep->debug_info, pc))) {
+      return f->filename;
+    }
+  }
+  return NULL;
+}
+
+int32_t
+mrb_debug_get_line(mrb_irep *irep, uint32_t pc)
+{
+  if (irep && pc < irep->ilen) {
+    mrb_irep_debug_info_file* f = NULL;
+    if (!irep->debug_info) {
+      return irep->lines? irep->lines[pc] : -1;
+    }
+    else if ((f = get_file(irep->debug_info, pc))) {
+      switch(f->line_type) {
+        case mrb_debug_line_ary:
+          mrb_assert(f->start_pos <= pc && pc < (f->start_pos + f->line_entry_count));
+          return f->line_ary[pc - f->start_pos];
+
+        case mrb_debug_line_flat_map: {
+          // get upper bound
+          mrb_irep_debug_info_line *ret = f->line_flat_map;
+          uint32_t count = f->line_entry_count;
+          while (count > 0) {
+            int32_t step = count / 2;
+            mrb_irep_debug_info_line *it = ret + step;
+            if (!(pc < it->start_pos)) {
+              ret = it + 1;
+              count -= step + 1;
+            } else { count = step; }
+          }
+
+          --ret;
+
+          // check line entry pointer range
+          mrb_assert(f->line_flat_map <= ret && ret < (f->line_flat_map + f->line_entry_count));
+          // check pc range
+          mrb_assert(ret->start_pos <= pc &&
+                     pc < (((ret + 1 - f->line_flat_map) < f->line_entry_count)
+                           ? (ret+1)->start_pos : irep->debug_info->pc_count));
+
+          return ret->line;
+        }
+      }
+    }
+  }
+  return -1;
+}
+
+mrb_irep_debug_info *
+mrb_debug_info_alloc(mrb_state *mrb, mrb_irep *irep)
+{
+  static const mrb_irep_debug_info initial = { 0, 0, NULL };
+  mrb_irep_debug_info *ret;
+
+  mrb_assert(!irep->debug_info);
+  ret = (mrb_irep_debug_info *)mrb_malloc(mrb, sizeof(*ret));
+  *ret = initial;
+  irep->debug_info = ret;
+  return ret;
+}
+
+mrb_irep_debug_info_file *
+mrb_debug_info_append_file(mrb_state *mrb, mrb_irep *irep,
+                           uint32_t start_pos, uint32_t end_pos)
+{
+  mrb_irep_debug_info *info;
+  mrb_irep_debug_info_file *ret;
+  uint32_t file_pc_count;
+  size_t fn_len;
+  size_t len;
+  uint32_t i;
+
+  if (!irep->debug_info) { return NULL; }
+
+  mrb_assert(irep->filename);
+  mrb_assert(irep->lines);
+
+  info = irep->debug_info;
+
+  if (info->flen > 0 && strcmp(irep->filename, info->files[info->flen - 1]->filename) == 0) {
+    return NULL;
+  }
+
+  ret = (mrb_irep_debug_info_file *)mrb_malloc(mrb, sizeof(*ret));
+  info->files =
+      (mrb_irep_debug_info_file*)info->files
+      ? mrb_realloc(mrb, info->files, sizeof(mrb_irep_debug_info_file*) * (info->flen + 1))
+      : mrb_malloc(mrb, sizeof(mrb_irep_debug_info_file*));
+  info->files[info->flen++] = ret;
+
+  file_pc_count = end_pos - start_pos;
+
+  ret->start_pos = start_pos;
+  info->pc_count = end_pos;
+
+  fn_len = strlen(irep->filename);
+  ret->filename_sym = mrb_intern2(mrb, irep->filename, fn_len);
+  len = 0;
+  ret->filename = mrb_sym2name_len(mrb, ret->filename_sym, &len);
+
+  ret->line_type = select_line_type(irep->lines + start_pos, end_pos - start_pos);
+  ret->line_ptr = NULL;
+
+  switch(ret->line_type) {
+    case mrb_debug_line_ary:
+      ret->line_entry_count = file_pc_count;
+      ret->line_ary = mrb_malloc(mrb, sizeof(uint16_t) * file_pc_count);
+      for(i = 0; i < file_pc_count; ++i) {
+        ret->line_ary[i] = irep->lines[start_pos + i];
+      }
+      break;
+
+    case mrb_debug_line_flat_map: {
+      uint16_t prev_line = 0;
+      mrb_irep_debug_info_line m;
+      ret->line_flat_map = mrb_malloc(mrb, sizeof(mrb_irep_debug_info_line) * 1);
+      ret->line_entry_count = 0;
+      for(i = 0; i < file_pc_count; ++i) {
+        if(irep->lines[start_pos + i] == prev_line) { continue; }
+
+        ret->line_flat_map = mrb_realloc(
+            mrb, ret->line_flat_map,
+            sizeof(mrb_irep_debug_info_line) * (ret->line_entry_count + 1));
+        m.start_pos = start_pos + i;
+        m.line = irep->lines[start_pos + i];
+        ret->line_flat_map[ret->line_entry_count] = m;
+
+        // update
+        ++ret->line_entry_count;
+        prev_line = irep->lines[start_pos + i];
+      }
+    } break;
+
+    default: mrb_assert(0); break;
+  }
+
+  return ret;
+}
+
+void
+mrb_debug_info_free(mrb_state *mrb, mrb_irep_debug_info *d)
+{
+  uint32_t i;
+
+  if(!d) { return; }
+
+  for(i = 0; i < d->flen; ++i) {
+    mrb_assert(d->files[i]);
+    mrb_free(mrb, d->files[i]->line_ptr);
+    mrb_free(mrb, d->files[i]);
+  }
+  mrb_free(mrb, d->files);
+  mrb_free(mrb, d);
+}