konpeito 0.2.2 → 0.2.3

data/tools/konpeito-asm/src/konpeito/runtime/RubyDispatch.java

@@ -102,18 +102,88 @@ public class RubyDispatch {
         Object[] methodArgs = new Object[args.length - 1];
         System.arraycopy(args, 1, methodArgs, 0, methodArgs.length);
 
-        // Handle nil (null) receiver — Ruby's NilClass methods
+        // Handle nil (null) receiver — Ruby's NilClass methods and Kernel methods
         if (receiver == null) {
             Object nilResult = tryNilDispatch(methodName, methodArgs);
             if (nilResult != SENTINEL) {
                 return nilResult;
             }
+            // Kernel methods (top-level functions with null receiver)
+            if (methodName.equals("Integer") && methodArgs.length >= 1) {
+                Object arg = methodArgs[0];
+                if (arg instanceof Long) return arg;
+                if (arg instanceof Double) return Long.valueOf(((Double) arg).longValue());
+                if (arg instanceof String) {
+                    String s = ((String) arg).strip();
+                    if (s.startsWith("0x") || s.startsWith("0X")) {
+                        return Long.parseLong(s.substring(2), 16);
+                    }
+                    return Long.parseLong(s);
+                }
+                throw new IllegalArgumentException("invalid value for Integer(): \"" + arg + "\"");
+            }
+            if (methodName.equals("Float") && methodArgs.length >= 1) {
+                Object arg = methodArgs[0];
+                if (arg instanceof Double) return arg;
+                if (arg instanceof Long) return Double.valueOf(((Long) arg).doubleValue());
+                if (arg instanceof String) {
+                    String s = ((String) arg).strip();
+                    return Double.parseDouble(s);
+                }
+                throw new IllegalArgumentException("invalid value for Float(): \"" + arg + "\"");
+            }
+            // Kernel#sleep
+            if (methodName.equals("sleep") && methodArgs.length >= 1) {
+                double seconds;
+                if (methodArgs[0] instanceof Long) {
+                    seconds = ((Long) methodArgs[0]).doubleValue();
+                } else if (methodArgs[0] instanceof Double) {
+                    seconds = (Double) methodArgs[0];
+                } else if (methodArgs[0] instanceof Number) {
+                    seconds = ((Number) methodArgs[0]).doubleValue();
+                } else {
+                    seconds = 0;
+                }
+                try {
+                    Thread.sleep((long) (seconds * 1000));
+                } catch (InterruptedException e) {
+                    Thread.currentThread().interrupt();
+                }
+                return Long.valueOf((long) seconds);
+            }
+            // Kernel#rand
+            if (methodName.equals("rand")) {
+                if (methodArgs.length == 0) {
+                    return Math.random();
+                } else if (methodArgs[0] instanceof Long) {
+                    return Long.valueOf((long)(Math.random() * (Long) methodArgs[0]));
+                }
+                return Math.random();
+            }
             throw new NullPointerException("Method '" + methodName + "' called on null receiver");
         }
 
         Class<?> clazz = receiver.getClass();
 
         // Handle Ruby exception methods on Java Throwable/Exception objects
+        if (receiver instanceof KRubyException) {
+            KRubyException kexc = (KRubyException) receiver;
+            switch (methodName) {
+                case "message":
+                    String kmsg = kexc.getMessage();
+                    return kmsg != null ? kmsg : "";
+                case "to_s":
+                    String kts = kexc.getMessage();
+                    return kts != null ? kts : kexc.getRubyClassName();
+                case "k_class":
+                    return kexc.getRubyClassName();
+                case "inspect":
+                    String kim = kexc.getMessage();
+                    return "#<" + kexc.getRubyClassName() + ": " + (kim != null ? kim : "") + ">";
+                case "backtrace":
+                    return null;
+            }
+        }
         if (receiver instanceof Throwable) {
             Throwable throwable = (Throwable) receiver;
             switch (methodName) {
@@ -221,6 +291,29 @@ public class RubyDispatch {
             return arr[idx];
         }
 
+        // Comparable methods: between?, clamp — delegate to <=> if available
+        if (methodName.equals("between_q") && methodArgs.length == 2) {
+            Method spaceship = findMethod(clazz, "op_cmp", 1);
+            if (spaceship != null) {
+                spaceship.setAccessible(true);
+                long cmpLo = ((Number) spaceship.invoke(receiver, methodArgs[0])).longValue();
+                long cmpHi = ((Number) spaceship.invoke(receiver, methodArgs[1])).longValue();
+                return Boolean.valueOf(cmpLo >= 0 && cmpHi <= 0);
+            }
+        }
+
+        if (methodName.equals("clamp") && methodArgs.length == 2) {
+            Method spaceship = findMethod(clazz, "op_cmp", 1);
+            if (spaceship != null) {
+                spaceship.setAccessible(true);
+                long cmpLo = ((Number) spaceship.invoke(receiver, methodArgs[0])).longValue();
+                if (cmpLo < 0) return methodArgs[0]; // below min → return min
+                long cmpHi = ((Number) spaceship.invoke(receiver, methodArgs[1])).longValue();
+                if (cmpHi > 0) return methodArgs[1]; // above max → return max
+                return receiver; // in range → return self
+            }
+        }
+
         throw new NoSuchMethodError(
             clazz.getName() + "." + methodName + " (arity " + methodArgs.length + ")");
     }
@@ -334,6 +427,7 @@ public class RubyDispatch {
                     case "op_xor": return Long.valueOf(lv ^ rv);
                     case "op_lshift": return Long.valueOf(lv << rv);
                     case "op_rshift": return Long.valueOf(lv >> rv);
+                    case "op_aref": return Long.valueOf((lv >> rv) & 1);
                     case "op_eq": return Boolean.valueOf(lv == rv);
                     case "op_neq": return Boolean.valueOf(lv != rv);
                     case "op_lt": return Boolean.valueOf(lv < rv);
@@ -369,6 +463,17 @@ public class RubyDispatch {
                     case "integer_q": return Boolean.TRUE;
                     case "op_uminus": return Long.valueOf(-lv);
                     case "op_uplus": return receiver;
+                    case "digits": {
+                        // Integer#digits — returns array of digits in reverse order (base 10)
+                        KArray<Object> result = new KArray<>();
+                        long val = Math.abs(lv);
+                        if (val == 0) { result.add(0L); return result; }
+                        while (val > 0) {
+                            result.add(Long.valueOf(val % 10));
+                            val /= 10;
+                        }
+                        return result;
+                    }
                 }
             }
         }
@@ -603,6 +708,16 @@ public class RubyDispatch {
                 }
             }
 
+            // String#split(separator, limit) — split with limit
+            if (methodName.equals("split") && args.length == 2 && args[0] instanceof String && args[1] instanceof Number) {
+                String pattern = (String) args[0];
+                int limit = ((Number) args[1]).intValue();
+                String[] parts = sv.split(java.util.regex.Pattern.quote(pattern), limit);
+                KArray<Object> splitArr = new KArray<>();
+                for (String part : parts) splitArr.push(part);
+                return splitArr;
+            }
+
             // String#tr(from, to) — 2 string args
             if (methodName.equals("tr") && args.length == 2 && args[0] instanceof String && args[1] instanceof String) {
                 return stringTr(sv, (String) args[0], (String) args[1]);
@@ -865,7 +980,7 @@ public class RubyDispatch {
                     case "clone": return sv;
                     case "k_class": return "String";
                     case "nil_q": return Boolean.FALSE;
-                    case "frozen_q": return Boolean.TRUE;
+                    case "frozen_q": return Boolean.FALSE; // Strings are not frozen by default in Ruby
                     case "to_a": {
                         // Range#to_a — ranges are stored as strings "start..end" or "start...end"
                         return rangeToArray(sv);
@@ -1355,6 +1470,86 @@ public class RubyDispatch {
                     }
                     break;
                 }
+                case "group_by": {
+                    if (args.length == 1) {
+                        KHash<Object, Object> result = new KHash<>();
+                        for (Object elem : arr) {
+                            Object key = invokeBlock(args[0], elem);
+                            result.groupByAdd(key, elem);
+                        }
+                        return result;
+                    }
+                    break;
+                }
+                case "each_with_object": {
+                    if (args.length == 2) {
+                        // args[0] = memo object, args[1] = block
+                        Object memo = args[0];
+                        Object block = args[1];
+                        for (Object elem : arr) {
+                            invokeBlock(block, elem, memo);
+                        }
+                        return memo;
+                    }
+                    break;
+                }
+                case "take_while": {
+                    if (args.length == 1) {
+                        KArray<Object> result = new KArray<>();
+                        for (Object elem : arr) {
+                            if (!isTruthy(invokeBlock(args[0], elem))) break;
+                            result.push(elem);
+                        }
+                        return result;
+                    }
+                    break;
+                }
+                case "drop_while": {
+                    if (args.length == 1) {
+                        KArray<Object> result = new KArray<>();
+                        boolean dropping = true;
+                        for (Object elem : arr) {
+                            if (dropping && isTruthy(invokeBlock(args[0], elem))) continue;
+                            dropping = false;
+                            result.push(elem);
+                        }
+                        return result;
+                    }
+                    break;
+                }
+                case "partition": {
+                    if (args.length == 1) {
+                        KArray<Object> trueArr = new KArray<>();
+                        KArray<Object> falseArr = new KArray<>();
+                        for (Object elem : arr) {
+                            if (isTruthy(invokeBlock(args[0], elem))) {
+                                trueArr.push(elem);
+                            } else {
+                                falseArr.push(elem);
+                            }
+                        }
+                        KArray<Object> result = new KArray<>();
+                        result.push(trueArr);
+                        result.push(falseArr);
+                        return result;
+                    }
+                    break;
+                }
+                case "tally": {
+                    if (args.length == 0) {
+                        KHash<Object, Object> result = new KHash<>();
+                        for (Object elem : arr) {
+                            Object count = result.get(elem);
+                            if (count instanceof Long) {
+                                result.put(elem, (Long) count + 1L);
+                            } else {
+                                result.put(elem, 1L);
+                            }
+                        }
+                        return result;
+                    }
+                    break;
+                }
                 case "sum": {
                     if (args.length == 0) return arr.sumLong();
                     break;
@@ -1369,8 +1564,8 @@ public class RubyDispatch {
                     }
                     return Long.valueOf(arr.size());
                 }
-                case "frozen_q": return Boolean.FALSE;
-                case "freeze": return arr;
+                case "frozen_q": return Boolean.valueOf(arr.isFrozen());
+                case "freeze": { arr.freeze(); return arr; }
             }
         }
 
@@ -1613,10 +1808,9 @@ public class RubyDispatch {
                             entries.push(pair);
                         }
                         entries.sort((a, b) -> {
-                            KArray<?> pa = (KArray<?>) a;
-                            KArray<?> pb = (KArray<?>) b;
-                            Object ka = invokeBlock(args[0], pa.get(0), pa.get(1));
-                            Object kb = invokeBlock(args[0], pb.get(0), pb.get(1));
+                            // Pass pair as single arg (Ruby Hash#sort_by yields [k,v] pair)
+                            Object ka = invokeBlock(args[0], a);
+                            Object kb = invokeBlock(args[0], b);
                             if (ka instanceof Comparable && kb instanceof Comparable) {
                                 return ((Comparable) ka).compareTo(kb);
                             }
@@ -1690,17 +1884,32 @@ public class RubyDispatch {
         // General respond_to?
         if (methodName.equals("respond_to_q") && args.length == 1) {
             String checkName = String.valueOf(args[0]);
-            Method found2 = findMethod(receiver.getClass(), checkName, 0);
-            if (found2 == null) {
+            // Try multiple arities (0, 1, 2) since Ruby methods have various arities
+            for (int arity = 0; arity <= 2; arity++) {
+                Method found2 = findMethod(receiver.getClass(), checkName, arity);
+                if (found2 != null) return Boolean.TRUE;
                 String[] aliases2 = RUBY_NAME_ALIASES.get(checkName);
                 if (aliases2 != null) {
                     for (String alias : aliases2) {
-                        found2 = findMethod(receiver.getClass(), alias, 0);
-                        if (found2 != null) break;
+                        found2 = findMethod(receiver.getClass(), alias, arity);
+                        if (found2 != null) return Boolean.TRUE;
                     }
                 }
             }
-            return Boolean.valueOf(found2 != null);
+            // Check well-known built-in methods handled in tryBuiltinOperator
+            if (receiver instanceof KArray) {
+                switch (checkName) {
+                    case "push": case "pop": case "shift": case "unshift": case "first":
+                    case "last": case "length": case "size": case "empty_q": case "include_q":
+                    case "sort": case "reverse": case "flatten": case "compact": case "uniq":
+                    case "each": case "map": case "select": case "reject": case "reduce":
+                    case "find": case "any_q": case "all_q": case "none_q": case "join":
+                    case "min": case "max": case "count": case "delete": case "index":
+                    case "freeze": case "frozen_q":
+                        return Boolean.TRUE;
+                }
+            }
+            return Boolean.FALSE;
         }
 
         return SENTINEL;
@@ -1728,6 +1937,9 @@ public class RubyDispatch {
         if (obj instanceof KArray) return "Array";
         if (obj instanceof KHash) return "Hash";
         if (obj instanceof java.util.regex.Pattern) return "Regexp";
+        if (obj instanceof KFiber) return "Fiber";
+        if (obj instanceof KThread) return "Thread";
+        if (obj instanceof java.util.concurrent.locks.ReentrantLock) return "Mutex";
         // User-defined class: use simple name
         String name = obj.getClass().getSimpleName();
         return name;
@@ -2083,16 +2295,35 @@ public class RubyDispatch {
     private static Object invokeBlock(Object block, Object... blockArgs) {
         if (block == null) return null;
         try {
-            // Find the `call` method on the block's class
+            // Collect all `call` methods (both from getMethods and getDeclaredMethods)
+            java.util.List<Method> callMethods = new java.util.ArrayList<>();
             for (Method m : block.getClass().getMethods()) {
-                if (m.getName().equals("call") && m.getParameterCount() == blockArgs.length) {
+                if (m.getName().equals("call")) callMethods.add(m);
+            }
+            for (Method m : block.getClass().getDeclaredMethods()) {
+                if (m.getName().equals("call")) {
+                    boolean duplicate = false;
+                    for (Method existing : callMethods) {
+                        if (java.util.Arrays.equals(existing.getParameterTypes(), m.getParameterTypes())) {
+                            duplicate = true;
+                            break;
+                        }
+                    }
+                    if (!duplicate) callMethods.add(m);
+                }
+            }
+
+            // First pass: exact arity match
+            for (Method m : callMethods) {
+                if (m.getParameterCount() == blockArgs.length) {
                     m.setAccessible(true);
                     return m.invoke(block, blockArgs);
                 }
             }
-            // Try with adapted arg count - some blocks may take fewer args
-            for (Method m : block.getClass().getMethods()) {
-                if (m.getName().equals("call") && !m.isBridge()) {
+
+            // Second pass: adapted arity (fewer params than args, or more params with null padding)
+            for (Method m : callMethods) {
+                if (!m.isBridge()) {
                     m.setAccessible(true);
                     int paramCount = m.getParameterCount();
                     Object[] adapted = new Object[paramCount];
@@ -2102,6 +2333,17 @@ public class RubyDispatch {
                     return m.invoke(block, adapted);
                 }
             }
+
+            // Third pass: use any call method (even bridge) as last resort
+            for (Method m : callMethods) {
+                m.setAccessible(true);
+                int paramCount = m.getParameterCount();
+                Object[] adapted = new Object[paramCount];
+                for (int i = 0; i < paramCount; i++) {
+                    adapted[i] = i < blockArgs.length ? blockArgs[i] : null;
+                }
+                return m.invoke(block, adapted);
+            }
         } catch (Exception e) {
             throw new RuntimeException("Failed to invoke block: " + e.getMessage(), e);
         }
@@ -2111,7 +2353,7 @@ public class RubyDispatch {
     /**
      * Ruby truthiness check: everything is truthy except null (nil) and false.
      */
-    private static boolean isTruthy(Object value) {
+    public static boolean isTruthy(Object value) {
         if (value == null) return false;
         if (value instanceof Boolean) return (Boolean) value;
         return true;
@@ -2231,4 +2473,28 @@ public class RubyDispatch {
             return parts[1];
         }
     }
+
+    /**
+     * Null-safe unboxing: Object → long. Returns 0L if null.
+     */
+    public static long unboxLong(Object o) {
+        if (o == null) return 0L;
+        return ((Number) o).longValue();
+    }
+
+    /**
+     * Null-safe unboxing: Object → double. Returns 0.0 if null.
+     */
+    public static double unboxDouble(Object o) {
+        if (o == null) return 0.0;
+        return ((Number) o).doubleValue();
+    }
+
+    /**
+     * Null-safe unboxing: Object → boolean. Returns false if null.
+     */
+    public static boolean unboxBoolean(Object o) {
+        if (o == null) return false;
+        return ((Boolean) o).booleanValue();
+    }
 }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: konpeito
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors:
 - Yasushi Itoh
@@ -213,14 +213,17 @@ files:
 - tools/konpeito-asm/runtime-classes/konpeito/runtime/KCompression.class
 - tools/konpeito-asm/runtime-classes/konpeito/runtime/KConditionVariable.class
 - tools/konpeito-asm/runtime-classes/konpeito/runtime/KCrypto.class
+- tools/konpeito-asm/runtime-classes/konpeito/runtime/KFiber.class
 - tools/konpeito-asm/runtime-classes/konpeito/runtime/KFile.class
 - tools/konpeito-asm/runtime-classes/konpeito/runtime/KHTTP.class
 - tools/konpeito-asm/runtime-classes/konpeito/runtime/KHash.class
 - tools/konpeito-asm/runtime-classes/konpeito/runtime/KJSON$Parser.class
 - tools/konpeito-asm/runtime-classes/konpeito/runtime/KJSON.class
+- tools/konpeito-asm/runtime-classes/konpeito/runtime/KMatchData.class
 - tools/konpeito-asm/runtime-classes/konpeito/runtime/KMath.class
 - tools/konpeito-asm/runtime-classes/konpeito/runtime/KRactor.class
 - tools/konpeito-asm/runtime-classes/konpeito/runtime/KRactorPort.class
+- tools/konpeito-asm/runtime-classes/konpeito/runtime/KRubyException.class
 - tools/konpeito-asm/runtime-classes/konpeito/runtime/KSizedQueue.class
 - tools/konpeito-asm/runtime-classes/konpeito/runtime/KThread.class
 - tools/konpeito-asm/runtime-classes/konpeito/runtime/KTime.class
@@ -231,13 +234,16 @@ files:
 - tools/konpeito-asm/src/konpeito/runtime/KCompression.java
 - tools/konpeito-asm/src/konpeito/runtime/KConditionVariable.java
 - tools/konpeito-asm/src/konpeito/runtime/KCrypto.java
+- tools/konpeito-asm/src/konpeito/runtime/KFiber.java
 - tools/konpeito-asm/src/konpeito/runtime/KFile.java
 - tools/konpeito-asm/src/konpeito/runtime/KHTTP.java
 - tools/konpeito-asm/src/konpeito/runtime/KHash.java
 - tools/konpeito-asm/src/konpeito/runtime/KJSON.java
+- tools/konpeito-asm/src/konpeito/runtime/KMatchData.java
 - tools/konpeito-asm/src/konpeito/runtime/KMath.java
 - tools/konpeito-asm/src/konpeito/runtime/KRactor.java
 - tools/konpeito-asm/src/konpeito/runtime/KRactorPort.java
+- tools/konpeito-asm/src/konpeito/runtime/KRubyException.java
 - tools/konpeito-asm/src/konpeito/runtime/KSizedQueue.java
 - tools/konpeito-asm/src/konpeito/runtime/KThread.java
 - tools/konpeito-asm/src/konpeito/runtime/KTime.java