Keyword argument implemented.

4 files changed, 230 insertions, 62 deletions

diff --git a/src/codedump.c b/src/codedump.c
index 22cbc59eb..dc0e0e548 100644
--- a/src/codedump.c
+++ b/src/codedump.c
@@ -78,6 +78,16 @@ codedump(mrb_state *mrb, mrb_irep *irep)
   printf("irep %p nregs=%d nlocals=%d pools=%d syms=%d reps=%d\n", (void*)irep,
          irep->nregs, irep->nlocals, (int)irep->plen, (int)irep->slen, (int)irep->rlen);
 
+  if (irep->lv) {
+    int i;
+
+    printf("local variable names:\n");
+    for (i = 1; i < irep->nlocals; ++i) {
+      char const *n = mrb_sym2name(mrb, irep->lv[i - 1].name);
+      printf("  R%d:%s\n", irep->lv[i - 1].r, n? n : "");
+    }
+  }
+
   pc = irep->iseq;
   pcend = pc + irep->ilen;
   while (pc < pcend) {
@@ -246,10 +256,11 @@ codedump(mrb_state *mrb, mrb_irep *irep)
       printf("OP_SUPER\tR%d\t%d\n", a, b);
       break;
     CASE(OP_ARGARY, BS):
-      printf("OP_ARGARY\tR%d\t%d:%d:%d:%d", a,
-             (b>>10)&0x3f,
-             (b>>9)&0x1,
-             (b>>4)&0x1f,
+      printf("OP_ARGARY\tR%d\t%d:%d:%d:%d (%d)", a,
+             (b>>11)&0x3f,
+             (b>>10)&0x1,
+             (b>>5)&0x1f,
+             (b>>4)&0x1,
              (b>>0)&0xf);
       print_lv_a(mrb, irep, a);
       break;
@@ -263,32 +274,39 @@ codedump(mrb_state *mrb, mrb_irep *irep)
              (a>>1)&0x1,
              a & 0x1);
       break;
-    CASE(OP_KARG, BB):
-      printf("OP_KARG\tR(%d)\tK(%d)\n", a, b);
+    CASE(OP_KEY_P, BB):
+      printf("OP_KEY_P\tR%d\t:%s\t", a, mrb_sym2name(mrb, irep->syms[b]));
+      print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_KARG2, BB):
-      printf("OP_KARG2\tR(%d)\tK(%d)\n", a, b);
+    CASE(OP_KEYEND, Z):
+      printf("OP_KEYEND\n");
+      break;
+    CASE(OP_KARG, BB):
+      printf("OP_KARG\tR%d\t:%s\t", a, mrb_sym2name(mrb, irep->syms[b]));
+      print_lv_a(mrb, irep, a);
       break;
     CASE(OP_KDICT, B):
-      printf("OP_KDICt\tR(%d)\n", a);
+      printf("OP_KDICT\tR%d\t\t", a);
+      print_lv_a(mrb, irep, a);
       break;
     CASE(OP_RETURN, B):
-      printf("OP_RETURN\tR%d", a);
+      printf("OP_RETURN\tR%d\t\t", a);
       print_lv_a(mrb, irep, a);
       break;
     CASE(OP_RETURN_BLK, B):
-      printf("OP_RETURN_BLK\tR%d", a);
+      printf("OP_RETURN_BLK\tR%d\t\t", a);
       print_lv_a(mrb, irep, a);
       break;
     CASE(OP_BREAK, B):
-      printf("OP_BREAK\tR%d", a);
+      printf("OP_BREAK\tR%d\t\t", a);
       print_lv_a(mrb, irep, a);
       break;
     CASE(OP_BLKPUSH, BS):
-      printf("OP_BLKPUSH\tR%d\t%d:%d:%d:%d", a,
-             (b>>10)&0x3f,
-             (b>>9)&0x1,
-             (b>>4)&0x1f,
+      printf("OP_BLKPUSH\tR%d\t%d:%d:%d:%d (%d)", a,
+             (b>>11)&0x3f,
+             (b>>10)&0x1,
+             (b>>5)&0x1f,
+             (b>>4)&0x1,
              (b>>0)&0xf);
       print_lv_a(mrb, irep, a);
       break;
diff --git a/src/hash.c b/src/hash.c
index db9d1d9c8..0dce81677 100644
--- a/src/hash.c
+++ b/src/hash.c
@@ -208,6 +208,54 @@ mrb_hash_init_copy(mrb_state *mrb, mrb_value self)
   return vret;
 }
 
+void
+mrb_hash_check_kdict(mrb_state *mrb, mrb_value self)
+{
+  khash_t(ht) *orig_h;
+  khiter_t k;
+  int nosym = FALSE;
+
+  orig_h = RHASH_TBL(self);
+  if (!orig_h || kh_size(orig_h) == 0) return;
+  for (k = kh_begin(orig_h); k != kh_end(orig_h); k++) {
+    if (kh_exist(orig_h, k)) {
+        mrb_value key = kh_key(orig_h, k);
+
+        if (!mrb_symbol_p(key)) nosym = TRUE;
+    }
+  }
+  if (nosym) {
+    mrb_raise(mrb, E_ARGUMENT_ERROR, "keyword argument hash with non symbol keys");
+  }
+}
+
+MRB_API mrb_value
+mrb_hash_dup(mrb_state *mrb, mrb_value self)
+{
+  struct RHash* copy;
+  khash_t(ht) *orig_h;
+
+  orig_h = RHASH_TBL(self);
+  copy = (struct RHash*)mrb_obj_alloc(mrb, MRB_TT_HASH, mrb->hash_class);
+  copy->ht = kh_init(ht, mrb);
+
+  if (orig_h && kh_size(orig_h) > 0) {
+    int ai = mrb_gc_arena_save(mrb);
+    khash_t(ht) *copy_h = copy->ht;
+    khiter_t k, copy_k;
+
+    for (k = kh_begin(orig_h); k != kh_end(orig_h); k++) {
+      if (kh_exist(orig_h, k)) {
+        copy_k = kh_put(ht, mrb, copy_h, KEY(kh_key(orig_h, k)));
+        mrb_gc_arena_restore(mrb, ai);
+        kh_val(copy_h, copy_k).v = kh_val(orig_h, k).v;
+        kh_val(copy_h, copy_k).n = kh_size(copy_h)-1;
+      }
+    }
+  }
+  return mrb_obj_value(copy);
+}
+
 MRB_API mrb_value
 mrb_hash_get(mrb_state *mrb, mrb_value hash, mrb_value key)
 {
@@ -716,13 +764,21 @@ mrb_hash_size_m(mrb_state *mrb, mrb_value self)
  *     {}.empty?   #=> true
  *
  */
-MRB_API mrb_value
+MRB_API mrb_bool
 mrb_hash_empty_p(mrb_state *mrb, mrb_value self)
 {
   khash_t(ht) *h = RHASH_TBL(self);
 
-  if (h) return mrb_bool_value(kh_size(h) == 0);
-  return mrb_true_value();
+  if (h) return kh_size(h) == 0;
+  return TRUE;
+}
+
+static mrb_value
+mrb_hash_empty_m(mrb_state *mrb, mrb_value self)
+{
+  if (mrb_hash_empty_p(mrb, self))
+    return mrb_true_value();
+  return mrb_false_value();
 }
 
 /* 15.2.13.4.29 (x)*/
@@ -833,21 +889,29 @@ mrb_hash_values(mrb_state *mrb, mrb_value hash)
  *
  */
 
-static mrb_value
-mrb_hash_has_key(mrb_state *mrb, mrb_value hash)
+MRB_API mrb_bool
+mrb_hash_key_p(mrb_state *mrb, mrb_value hash, mrb_value key)
 {
-  mrb_value key;
   khash_t(ht) *h;
   khiter_t k;
 
-  mrb_get_args(mrb, "o", &key);
-
   h = RHASH_TBL(hash);
   if (h) {
     k = kh_get(ht, mrb, h, key);
-    return mrb_bool_value(k != kh_end(h));
+    return k != kh_end(h);
   }
-  return mrb_false_value();
+  return FALSE;
+}
+
+static mrb_value
+mrb_hash_has_key(mrb_state *mrb, mrb_value hash)
+{
+  mrb_value key;
+  mrb_bool key_p;
+
+  mrb_get_args(mrb, "o", &key);
+  key_p = mrb_hash_key_p(mrb, hash, key);
+  return mrb_bool_value(key_p);
 }
 
 /* 15.2.13.4.14 */
@@ -904,7 +968,7 @@ mrb_init_hash(mrb_state *mrb)
   mrb_define_method(mrb, h, "default_proc",    mrb_hash_default_proc,MRB_ARGS_NONE()); /* 15.2.13.4.7  */
   mrb_define_method(mrb, h, "default_proc=",   mrb_hash_set_default_proc,MRB_ARGS_REQ(1)); /* 15.2.13.4.7  */
   mrb_define_method(mrb, h, "__delete",        mrb_hash_delete,      MRB_ARGS_REQ(1)); /* core of 15.2.13.4.8  */
-  mrb_define_method(mrb, h, "empty?",          mrb_hash_empty_p,     MRB_ARGS_NONE()); /* 15.2.13.4.12 */
+  mrb_define_method(mrb, h, "empty?",          mrb_hash_empty_m,     MRB_ARGS_NONE()); /* 15.2.13.4.12 */
   mrb_define_method(mrb, h, "has_key?",        mrb_hash_has_key,     MRB_ARGS_REQ(1)); /* 15.2.13.4.13 */
   mrb_define_method(mrb, h, "has_value?",      mrb_hash_has_value,   MRB_ARGS_REQ(1)); /* 15.2.13.4.14 */
   mrb_define_method(mrb, h, "include?",        mrb_hash_has_key,     MRB_ARGS_REQ(1)); /* 15.2.13.4.15 */
diff --git a/src/kernel.c b/src/kernel.c
index 155868eaa..42e9ca6a4 100644
--- a/src/kernel.c
+++ b/src/kernel.c
@@ -1194,7 +1194,15 @@ mrb_local_variables(mrb_state *mrb, mrb_value self)
     if (!irep->lv) break;
     for (i = 0; i + 1 < irep->nlocals; ++i) {
       if (irep->lv[i].name) {
-        mrb_hash_set(mrb, vars, mrb_symbol_value(irep->lv[i].name), mrb_true_value());
+        mrb_sym sym = irep->lv[i].name;
+        const char *name = mrb_sym2name(mrb, sym);
+        switch (name[0]) {
+        case '*': case '&':
+          break;
+        default:
+          mrb_hash_set(mrb, vars, mrb_symbol_value(sym), mrb_true_value());
+          break;
+        }
       }
     }
     if (!MRB_PROC_ENV_P(proc)) break;
diff --git a/src/vm.c b/src/vm.c
index b50f1ee9f..8aeb68fc2 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -969,6 +969,8 @@ check_target_class(mrb_state *mrb)
   return TRUE;
 }
 
+void mrb_hash_check_kdict(mrb_state *mrb, mrb_value self);
+
 MRB_API mrb_value
 mrb_vm_exec(mrb_state *mrb, struct RProc *proc, mrb_code *pc)
 {
@@ -1639,9 +1641,10 @@ RETRY_TRY_BLOCK:
     }
 
     CASE(OP_ARGARY, BS) {
-      int m1 = (b>>10)&0x3f;
-      int r  = (b>>9)&0x1;
-      int m2 = (b>>4)&0x1f;
+      int m1 = (b>>11)&0x3f;
+      int r  = (b>>10)&0x1;
+      int m2 = (b>>5)&0x1f;
+      int kd = (b>>4)&0x1;
       int lv = (b>>0)&0xf;
       mrb_value *stack;
 
@@ -1657,12 +1660,12 @@ RETRY_TRY_BLOCK:
       else {
         struct REnv *e = uvenv(mrb, lv-1);
         if (!e) goto L_NOSUPER;
-        if (MRB_ENV_STACK_LEN(e) <= m1+r+m2+1)
+        if (MRB_ENV_STACK_LEN(e) <= m1+r+m2+kd+1)
           goto L_NOSUPER;
         stack = e->stack + 1;
       }
       if (r == 0) {
-        regs[a] = mrb_ary_new_from_values(mrb, m1+m2, stack);
+        regs[a] = mrb_ary_new_from_values(mrb, m1+m2+kd, stack);
       }
       else {
         mrb_value *pp = NULL;
@@ -1675,7 +1678,7 @@ RETRY_TRY_BLOCK:
           pp = ARY_PTR(ary);
           len = (int)ARY_LEN(ary);
         }
-        regs[a] = mrb_ary_new_capa(mrb, m1+len+m2);
+        regs[a] = mrb_ary_new_capa(mrb, m1+len+m2+kd);
         rest = mrb_ary_ptr(regs[a]);
         if (m1 > 0) {
           stack_copy(ARY_PTR(rest), stack, m1);
@@ -1686,7 +1689,10 @@ RETRY_TRY_BLOCK:
         if (m2 > 0) {
           stack_copy(ARY_PTR(rest)+m1+len, stack+m1+1, m2);
         }
-        ARY_SET_LEN(rest, m1+len+m2);
+        if (kd) {
+          stack_copy(ARY_PTR(rest)+m1+len+m2, stack+m1+m2+1, kd);
+        }
+        ARY_SET_LEN(rest, m1+len+m2+kd);
       }
       regs[a+1] = stack[m1+r+m2];
       mrb_gc_arena_restore(mrb, ai);
@@ -1698,74 +1704,114 @@ RETRY_TRY_BLOCK:
       int o  = MRB_ASPEC_OPT(a);
       int r  = MRB_ASPEC_REST(a);
       int m2 = MRB_ASPEC_POST(a);
+      int kd = (MRB_ASPEC_KEY(a) > 0 || MRB_ASPEC_KDICT(a))? 1 : 0;
       /* unused
-      int k  = MRB_ASPEC_KEY(a);
-      int kd = MRB_ASPEC_KDICT(a);
       int b  = MRB_ASPEC_BLOCK(a);
       */
       int argc = mrb->c->ci->argc;
       mrb_value *argv = regs+1;
-      mrb_value *argv0 = argv;
-      int len = m1 + o + r + m2;
+      mrb_value * const argv0 = argv;
+      int const len = m1 + o + r + m2;
+      int const blk_pos = len + kd + 1;
       mrb_value *blk = &argv[argc < 0 ? 1 : argc];
+      mrb_value kdict;
+      int kargs = kd;
 
+      /* arguments is passed with Array */
       if (argc < 0) {
         struct RArray *ary = mrb_ary_ptr(regs[1]);
         argv = ARY_PTR(ary);
         argc = (int)ARY_LEN(ary);
         mrb_gc_protect(mrb, regs[1]);
       }
+
+      /* strict argument check */
       if (mrb->c->ci->proc && MRB_PROC_STRICT_P(mrb->c->ci->proc)) {
-        if (argc >= 0) {
-          if (argc < m1 + m2 || (r == 0 && argc > len)) {
+        if (argc >= 0 && !(argc <= 1 && kd)) {
+          if (argc < m1 + m2 + kd || (r == 0 && argc > len + kd)) {
             argnum_error(mrb, m1+m2);
             goto L_RAISE;
           }
         }
       }
+      /* extract first argument array to arguments */
       else if (len > 1 && argc == 1 && mrb_array_p(argv[0])) {
         mrb_gc_protect(mrb, argv[0]);
         argc = (int)RARRAY_LEN(argv[0]);
         argv = RARRAY_PTR(argv[0]);
       }
+
+      if (kd) {
+        /* check last arguments is hash if method takes keyword arguments */
+        if (argc == m1+m2) {
+          kdict = mrb_hash_new(mrb);
+          kargs = 0;
+        }
+        else {
+          if (!mrb_hash_p(argv[argc - 1])) {
+            if (r) {
+              kdict = mrb_hash_new(mrb);
+              kargs = 0;
+            }
+            else {
+              mrb_value str = mrb_str_new_lit(mrb, "Excepcted `Hash` as last argument for keyword arguments");
+              mrb_exc_set(mrb, mrb_exc_new_str(mrb, E_ARGUMENT_ERROR, str));
+              goto L_RAISE;
+            }
+          }
+          else {
+            kdict = argv[argc-1];
+          }
+          mrb_hash_check_kdict(mrb, kdict);
+          if (MRB_ASPEC_KEY(a) > 0) {
+            kdict = mrb_hash_dup(mrb, kdict);
+          }
+        }
+      }
+
+      /* no rest arguments */
       if (argc < len) {
         int mlen = m2;
         if (argc < m1+m2) {
-          if (m1 < argc)
-            mlen = argc - m1;
-          else
-            mlen = 0;
+          mlen = m1 < argc ? argc - m1 : 0;
         }
-        regs[len+1] = *blk; /* move block */
+        regs[blk_pos] = *blk; /* move block */
+        if (kd) regs[len + 1] = kdict;
+ 
         SET_NIL_VALUE(regs[argc+1]);
+        /* copy mandatory and optional arguments */
         if (argv0 != argv) {
           value_move(&regs[1], argv, argc-mlen); /* m1 + o */
         }
         if (argc < m1) {
           stack_clear(&regs[argc+1], m1-argc);
         }
+        /* copy post mandatory arguments */
         if (mlen) {
           value_move(&regs[len-m2+1], &argv[argc-mlen], mlen);
         }
         if (mlen < m2) {
           stack_clear(&regs[len-m2+mlen+1], m2-mlen);
         }
+        /* initalize rest arguments with empty Array */
         if (r) {
           regs[m1+o+1] = mrb_ary_new_capa(mrb, 0);
         }
-        if (o > 0 && argc >= m1+m2)
-          pc += (argc - m1 - m2)*3;
+        /* skip initailizer of passed arguments */
+        if (o > 0 && argc-kargs >= m1+m2)
+          pc += (argc - kargs - m1 - m2)*3;
       }
       else {
         int rnum = 0;
         if (argv0 != argv) {
-          regs[len+1] = *blk; /* move block */
+          regs[blk_pos] = *blk; /* move block */
+          if (kd) regs[len + 1] = kdict;
           value_move(&regs[1], argv, m1+o);
         }
         if (r) {
           mrb_value ary;
 
-          rnum = argc-m1-o-m2;
+          rnum = argc-m1-o-m2-kargs;
           ary = mrb_ary_new_from_values(mrb, rnum, argv+m1+o);
           regs[m1+o+1] = ary;
         }
@@ -1775,29 +1821,60 @@ RETRY_TRY_BLOCK:
           }
         }
         if (argv0 == argv) {
-          regs[len+1] = *blk; /* move block */
+          regs[blk_pos] = *blk; /* move block */
+          if (kd) regs[len + 1] = kdict;
         }
         pc += o*3;
       }
-      mrb->c->ci->argc = len;
+
+      /* format arguments for generated code */
+      mrb->c->ci->argc = len + kd;
+
       /* clear local (but non-argument) variables */
-      if (irep->nlocals-len-2 > 0) {
-        stack_clear(&regs[len+2], irep->nlocals-len-2);
+      if (irep->nlocals-blk_pos-1 > 0) {
+        stack_clear(&regs[blk_pos+1], irep->nlocals-blk_pos-1);
       }
       JUMP;
     }
 
     CASE(OP_KARG, BB) {
-      /* not implemented yet */
+      mrb_value k = mrb_symbol_value(syms[b]);
+      mrb_value kdict = regs[mrb->c->ci->argc];
+
+      if (!mrb_hash_key_p(mrb, kdict, k)) {
+        mrb_value str = mrb_format(mrb, "missing keyword: %S", k);
+        mrb_exc_set(mrb, mrb_exc_new_str(mrb, E_ARGUMENT_ERROR, str));
+        goto L_RAISE;
+      }
+      regs[a] = mrb_hash_get(mrb, kdict, k);
+      mrb_hash_delete_key(mrb, kdict, k);
       NEXT;
     }
-    CASE(OP_KARG2, BB) {
-      /* not implemented yet */
+
+    CASE(OP_KEY_P, BB) {
+      mrb_value k = mrb_symbol_value(syms[b]);
+      mrb_value kdict = regs[mrb->c->ci->argc];
+      mrb_bool key_p = mrb_hash_key_p(mrb, kdict, k);
+
+      regs[a] = mrb_bool_value(key_p);
+      NEXT;
+    }
+
+    CASE(OP_KEYEND, Z) {
+      mrb_value kdict = regs[mrb->c->ci->argc];
+
+      if (mrb_hash_p(kdict) && !mrb_hash_empty_p(mrb, kdict)) {
+        mrb_value keys = mrb_hash_keys(mrb, kdict);
+        mrb_value key1 = RARRAY_PTR(keys)[0];
+        mrb_value str = mrb_format(mrb, "unknown keyword: %S", key1);
+        mrb_exc_set(mrb, mrb_exc_new_str(mrb, E_ARGUMENT_ERROR, str));
+        goto L_RAISE;
+      }
       NEXT;
     }
 
     CASE(OP_KDICT, B) {
-      /* not implemented yet */
+      regs[a] = regs[mrb->c->ci->argc];
       NEXT;
     }
 
@@ -2064,9 +2141,10 @@ RETRY_TRY_BLOCK:
     }
 
     CASE(OP_BLKPUSH, BS) {
-      int m1 = (b>>10)&0x3f;
-      int r  = (b>>9)&0x1;
-      int m2 = (b>>4)&0x1f;
+      int m1 = (b>>11)&0x3f;
+      int r  = (b>>10)&0x1;
+      int m2 = (b>>5)&0x1f;
+      int kd = (b>>4)&0x1;
       int lv = (b>>0)&0xf;
       mrb_value *stack;
 
@@ -2084,7 +2162,7 @@ RETRY_TRY_BLOCK:
         localjump_error(mrb, LOCALJUMP_ERROR_YIELD);
         goto L_RAISE;
       }
-      regs[a] = stack[m1+r+m2];
+      regs[a] = stack[m1+r+m2+kd];
       NEXT;
     }