Implement handling of optional and rest in rb_get_kwargs.

Author: aardvark179

src/main/c/cext/ruby.c

@@ -1662,6 +1662,10 @@ VALUE rb_hash_set_ifnone(VALUE hash, VALUE if_none) {
   return RUBY_CEXT_INVOKE("rb_hash_set_ifnone", hash, if_none);
 }
 
+VALUE rb_hash_keys(VALUE hash) {
+  return RUBY_INVOKE(hash, "keys");
+}
+
 VALUE rb_hash_key_str(VALUE hash) {
   rb_tr_error("rb_hash_key_str not yet implemented");
 }
@@ -4678,24 +4682,93 @@ VALUE rb_current_receiver(void) {
   rb_tr_error("rb_current_receiver not implemented");
 }
 
-int rb_get_kwargs(VALUE keyword_hash, const ID *table, int required, int optional, VALUE *values) {
-  if (optional == -1) {
-    rb_tr_error("rb_get_kwargs with rest not implemented");
+static VALUE rb_keyword_error_new(const char *error, VALUE keys) {
+  long i = 0, len = RARRAY_LEN(keys);
+  VALUE error_message = rb_sprintf("%s keyword%.*s", error, len > 1, "s");
+
+  if (len > 0) {
+    rb_str_append(error_message, rb_str_new_cstr(": "));
+    while (1) {
+      const VALUE k = RARRAY_AREF(keys, i);
+      Check_Type(k, T_SYMBOL); /* wrong hash is given to rb_get_kwargs */
+      rb_str_append(error_message, rb_sym2str(k));
+      if (++i >= len) break;
+      rb_str_append(error_message, rb_str_new_cstr(", "));
+    }
   }
 
-  if (optional > 0) {
-    rb_tr_error("rb_get_kwargs with optional not implemented");
+  return rb_exc_new_str(rb_eArgError, error_message);
+}
+
+NORETURN(static void rb_keyword_error(const char *error, VALUE keys)) {
+  rb_exc_raise(rb_keyword_error_new(error, keys));
+}
+
+NORETURN(static void unknown_keyword_error(VALUE hash, const ID *table, int keywords)) {
+  int i;
+  for (i = 0; i < keywords; i++) {
+    VALUE key = table[i];
+    rb_hash_delete(hash, key);
   }
+  rb_keyword_error("unknown", rb_hash_keys(hash));
+}
+
+ static VALUE rb_tr_extract_keyword(VALUE keyword_hash, ID key, VALUE *values) {
+   VALUE val = rb_hash_lookup2(keyword_hash, key, Qundef);
+   if (values) {
+     rb_hash_delete(keyword_hash, key);
+   }
+   return val;
+}
+
+int rb_get_kwargs(VALUE keyword_hash, const ID *table, int required, int optional, VALUE *values) {
+  int rest = 0;
+  int extracted = 0;
+  VALUE missing = Qnil;
 
   if (optional < 0) {
-    rb_tr_error("rb_get_kwargs with rest and optional not implemented");
+	rest = 1;
+	optional = -1-optional;
   }
 
   for (int n = 0; n < required; n++) {
-    values[n] = rb_hash_fetch(keyword_hash, table[n]);
+    VALUE val = rb_tr_extract_keyword(keyword_hash, table[n], values);
+    if (values) {
+      values[n] = val;
+    }
+    if (val == Qundef) {
+      if (NIL_P(missing)) {
+        missing = rb_ary_new();
+      }
+      rb_ary_push(missing, table[n]);
+      rb_keyword_error("missing", missing);
+    }
+    extracted++;
+  }
+
+  if (optional && !NIL_P(keyword_hash)) {
+    for (int m = required; m < required + optional; m++) {
+      VALUE val = rb_tr_extract_keyword(keyword_hash, table[m], values);
+      if (values) {
+        values[m] = val;
+      }
+      if (val != Qundef) {
+        extracted++;
+      }
+    }
+  }
+
+  if (!rest && !NIL_P(keyword_hash)) {
+	if (RHASH_SIZE(keyword_hash) > (unsigned int)(values ? 0 : extracted)) {
+	    unknown_keyword_error(keyword_hash, table, required + optional);
+	}
+  }
+
+  for (int i = extracted; i < required + optional; i++) {
+    values[i] = Qundef;
   }
 
-  return required;
+  return extracted;
 }
 
 VALUE rb_extract_keywords(VALUE *orighash) {