konpeito 0.1.0

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

@@ -0,0 +1,390 @@
+package konpeito.runtime;
+
+import java.util.*;
+
+/**
+ * KArray - Ruby Array implementation for JVM backend.
+ *
+ * Implements java.util.List<T> via composition (wrapping ArrayList<T>),
+ * providing both Java collection interop and Ruby-specific methods.
+ *
+ * @param <T> Element type
+ */
+public class KArray<T> implements List<T> {
+    private final ArrayList<T> data;
+
+    // ========================================================================
+    // Constructors
+    // ========================================================================
+
+    public KArray() {
+        this.data = new ArrayList<>();
+    }
+
+    public KArray(int capacity) {
+        this.data = new ArrayList<>(capacity);
+    }
+
+    public KArray(Collection<? extends T> c) {
+        this.data = new ArrayList<>(c);
+    }
+
+    // ========================================================================
+    // Ruby-specific methods
+    // ========================================================================
+
+    /** Ruby: arr.first */
+    public T first() {
+        return data.isEmpty() ? null : data.get(0);
+    }
+
+    /** Ruby: arr.last */
+    public T last() {
+        return data.isEmpty() ? null : data.get(data.size() - 1);
+    }
+
+    /** Ruby: arr.push(elem) / arr << elem — returns self for chaining */
+    public KArray<T> push(T elem) {
+        data.add(elem);
+        return this;
+    }
+
+    /** Ruby: arr.pop */
+    public T pop() {
+        return data.isEmpty() ? null : data.remove(data.size() - 1);
+    }
+
+    /** Ruby: arr.length / arr.size — returns long (Ruby Integer) */
+    public long length() {
+        return data.size();
+    }
+
+    /** Ruby: arr.empty? */
+    public boolean isEmpty_() {
+        return data.isEmpty();
+    }
+
+    /** Ruby: arr.include?(elem) */
+    public boolean includes(T elem) {
+        return data.contains(elem);
+    }
+
+    /** Ruby: arr.flatten (single-level) */
+    @SuppressWarnings("unchecked")
+    public KArray<Object> flatten() {
+        KArray<Object> result = new KArray<>();
+        for (T elem : data) {
+            if (elem instanceof KArray) {
+                result.data.addAll(((KArray<Object>) elem).flatten().data);
+            } else {
+                result.data.add(elem);
+            }
+        }
+        return result;
+    }
+
+    /** Ruby: arr.deconstruct — returns self (for pattern matching) */
+    public KArray<T> deconstruct() {
+        return this;
+    }
+
+    /** Ruby: arr.compact — removes nil (null) elements */
+    public KArray<T> compact() {
+        KArray<T> result = new KArray<>();
+        for (T elem : data) {
+            if (elem != null) {
+                result.data.add(elem);
+            }
+        }
+        return result;
+    }
+
+    /** Ruby: arr.uniq */
+    public KArray<T> uniq() {
+        KArray<T> result = new KArray<>();
+        Set<T> seen = new LinkedHashSet<>();
+        for (T elem : data) {
+            if (seen.add(elem)) {
+                result.data.add(elem);
+            }
+        }
+        return result;
+    }
+
+    /** Ruby: arr.reverse */
+    public KArray<T> reverse() {
+        KArray<T> result = new KArray<>(data);
+        Collections.reverse(result.data);
+        return result;
+    }
+
+    /** Ruby: arr.sort (natural ordering) */
+    @SuppressWarnings("unchecked")
+    public KArray<T> sort() {
+        KArray<T> result = new KArray<>(data);
+        result.data.sort((a, b) -> ((Comparable<T>) a).compareTo(b));
+        return result;
+    }
+
+    /** Ruby: arr.min */
+    @SuppressWarnings("unchecked")
+    public T min() {
+        if (data.isEmpty()) return null;
+        T result = data.get(0);
+        for (int i = 1; i < data.size(); i++) {
+            if (((Comparable<T>) data.get(i)).compareTo(result) < 0) {
+                result = data.get(i);
+            }
+        }
+        return result;
+    }
+
+    /** Ruby: arr.max */
+    @SuppressWarnings("unchecked")
+    public T max() {
+        if (data.isEmpty()) return null;
+        T result = data.get(0);
+        for (int i = 1; i < data.size(); i++) {
+            if (((Comparable<T>) data.get(i)).compareTo(result) > 0) {
+                result = data.get(i);
+            }
+        }
+        return result;
+    }
+
+    /** Ruby: arr.count (without block, same as length) */
+    public long count() {
+        return data.size();
+    }
+
+    /** Ruby: arr.shift — remove and return first element */
+    public T shift() {
+        return data.isEmpty() ? null : data.remove(0);
+    }
+
+    /** Ruby: arr.unshift(elem) / arr.prepend(elem) — add to front, return self */
+    public KArray<T> unshift(T elem) {
+        data.add(0, elem);
+        return this;
+    }
+
+    /** Ruby: arr.delete_at(index) — remove and return element at index */
+    public T deleteAt(int index) {
+        int idx = index < 0 ? data.size() + index : index;
+        if (idx < 0 || idx >= data.size()) return null;
+        return data.remove(idx);
+    }
+
+    /** Ruby: arr.delete(value) — remove all occurrences, return last removed or nil */
+    public T deleteValue(T value) {
+        boolean found = data.remove(value);
+        return found ? value : null;
+    }
+
+    /** Ruby: arr.sum — sum all elements (for numeric arrays) */
+    @SuppressWarnings("unchecked")
+    public long sumLong() {
+        long total = 0;
+        for (T elem : data) {
+            if (elem instanceof Long) total += (Long) elem;
+            else if (elem instanceof Integer) total += (Integer) elem;
+        }
+        return total;
+    }
+
+    /** Ruby: arr.sum for double arrays */
+    public double sumDouble() {
+        double total = 0.0;
+        for (T elem : data) {
+            if (elem instanceof Double) total += (Double) elem;
+            else if (elem instanceof Float) total += (Float) elem;
+            else if (elem instanceof Long) total += (Long) elem;
+        }
+        return total;
+    }
+
+    /** Ruby: arr.find_index(value) — returns index or -1 */
+    public long findIndex(T value) {
+        int idx = data.indexOf(value);
+        return idx;
+    }
+
+    /** Ruby: arr.join(sep) */
+    public String join(String separator) {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < data.size(); i++) {
+            if (i > 0) sb.append(separator);
+            sb.append(data.get(i));
+        }
+        return sb.toString();
+    }
+
+    /** Ruby: arr.join (no separator) */
+    public String join() {
+        return join("");
+    }
+
+    // ========================================================================
+    // Negative index support (Ruby semantics)
+    // ========================================================================
+
+    private int adjustIndex(int index) {
+        return index < 0 ? data.size() + index : index;
+    }
+
+    // ========================================================================
+    // List<T> interface delegation with negative index support
+    // ========================================================================
+
+    @Override
+    public int size() {
+        return data.size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return data.isEmpty();
+    }
+
+    @Override
+    public boolean contains(Object o) {
+        return data.contains(o);
+    }
+
+    @Override
+    public Iterator<T> iterator() {
+        return data.iterator();
+    }
+
+    @Override
+    public Object[] toArray() {
+        return data.toArray();
+    }
+
+    @Override
+    public <U> U[] toArray(U[] a) {
+        return data.toArray(a);
+    }
+
+    @Override
+    public boolean add(T t) {
+        return data.add(t);
+    }
+
+    @Override
+    public boolean remove(Object o) {
+        return data.remove(o);
+    }
+
+    @Override
+    public boolean containsAll(Collection<?> c) {
+        return data.containsAll(c);
+    }
+
+    @Override
+    public boolean addAll(Collection<? extends T> c) {
+        return data.addAll(c);
+    }
+
+    @Override
+    public boolean addAll(int index, Collection<? extends T> c) {
+        return data.addAll(adjustIndex(index), c);
+    }
+
+    @Override
+    public boolean removeAll(Collection<?> c) {
+        return data.removeAll(c);
+    }
+
+    @Override
+    public boolean retainAll(Collection<?> c) {
+        return data.retainAll(c);
+    }
+
+    @Override
+    public void clear() {
+        data.clear();
+    }
+
+    @Override
+    public T get(int index) {
+        return data.get(adjustIndex(index));
+    }
+
+    @Override
+    public T set(int index, T element) {
+        return data.set(adjustIndex(index), element);
+    }
+
+    @Override
+    public void add(int index, T element) {
+        data.add(adjustIndex(index), element);
+    }
+
+    @Override
+    public T remove(int index) {
+        return data.remove(adjustIndex(index));
+    }
+
+    @Override
+    public int indexOf(Object o) {
+        return data.indexOf(o);
+    }
+
+    @Override
+    public int lastIndexOf(Object o) {
+        return data.lastIndexOf(o);
+    }
+
+    @Override
+    public ListIterator<T> listIterator() {
+        return data.listIterator();
+    }
+
+    @Override
+    public ListIterator<T> listIterator(int index) {
+        return data.listIterator(adjustIndex(index));
+    }
+
+    @Override
+    public List<T> subList(int fromIndex, int toIndex) {
+        return data.subList(adjustIndex(fromIndex), adjustIndex(toIndex));
+    }
+
+    // ========================================================================
+    // Ruby-compatible toString: [1, 2, 3]
+    // ========================================================================
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder("[");
+        for (int i = 0; i < data.size(); i++) {
+            if (i > 0) sb.append(", ");
+            T elem = data.get(i);
+            if (elem instanceof String) {
+                sb.append("\"").append(elem).append("\"");
+            } else {
+                sb.append(elem);
+            }
+        }
+        sb.append("]");
+        return sb.toString();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o instanceof KArray) {
+            return data.equals(((KArray<?>) o).data);
+        }
+        if (o instanceof List) {
+            return data.equals(o);
+        }
+        return false;
+    }
+
+    @Override
+    public int hashCode() {
+        return data.hashCode();
+    }
+}

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

@@ -0,0 +1,168 @@
+package konpeito.runtime;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.zip.Deflater;
+import java.util.zip.GZIPInputStream;
+import java.util.zip.GZIPOutputStream;
+import java.util.zip.Inflater;
+
+/**
+ * KCompression - Data compression for Konpeito JVM backend.
+ * Maps to KonpeitoCompression Ruby module.
+ * Uses java.util.zip.* (no external dependencies).
+ *
+ * Binary data is encoded as ISO-8859-1 strings for lossless round-tripping.
+ */
+public class KCompression {
+
+    public static final long BEST_SPEED = 1;
+    public static final long BEST_COMPRESSION = 9;
+    public static final long DEFAULT_COMPRESSION = -1;
+
+    // ========================================================================
+    // Gzip (RFC 1952)
+    // ========================================================================
+
+    /** KonpeitoCompression.gzip(data) -> String (binary) */
+    public static String gzip(String data) {
+        try {
+            byte[] input = data.getBytes(StandardCharsets.UTF_8);
+            ByteArrayOutputStream baos = new ByteArrayOutputStream();
+            try (GZIPOutputStream gzos = new GZIPOutputStream(baos)) {
+                gzos.write(input);
+            }
+            return new String(baos.toByteArray(), StandardCharsets.ISO_8859_1);
+        } catch (Exception e) {
+            throw new RuntimeException("gzip failed: " + e.getMessage(), e);
+        }
+    }
+
+    /** KonpeitoCompression.gunzip(data) -> String */
+    public static String gunzip(String data) {
+        try {
+            byte[] input = data.getBytes(StandardCharsets.ISO_8859_1);
+            ByteArrayInputStream bais = new ByteArrayInputStream(input);
+            try (GZIPInputStream gzis = new GZIPInputStream(bais)) {
+                ByteArrayOutputStream baos = new ByteArrayOutputStream();
+                byte[] buffer = new byte[4096];
+                int n;
+                while ((n = gzis.read(buffer)) != -1) {
+                    baos.write(buffer, 0, n);
+                }
+                return baos.toString(StandardCharsets.UTF_8);
+            }
+        } catch (Exception e) {
+            throw new RuntimeException("gunzip failed: " + e.getMessage(), e);
+        }
+    }
+
+    // ========================================================================
+    // Raw Deflate (RFC 1951)
+    // ========================================================================
+
+    /** KonpeitoCompression.deflate(data, level) -> String (binary) */
+    public static String deflate(String data, Object level) {
+        try {
+            int compressionLevel = Deflater.DEFAULT_COMPRESSION;
+            if (level instanceof Long) {
+                compressionLevel = ((Long) level).intValue();
+            } else if (level instanceof Integer) {
+                compressionLevel = (Integer) level;
+            }
+            byte[] input = data.getBytes(StandardCharsets.UTF_8);
+            Deflater deflater = new Deflater(compressionLevel, true); // true = raw deflate (no zlib header)
+            deflater.setInput(input);
+            deflater.finish();
+            ByteArrayOutputStream baos = new ByteArrayOutputStream();
+            byte[] buffer = new byte[4096];
+            while (!deflater.finished()) {
+                int count = deflater.deflate(buffer);
+                baos.write(buffer, 0, count);
+            }
+            deflater.end();
+            return new String(baos.toByteArray(), StandardCharsets.ISO_8859_1);
+        } catch (Exception e) {
+            throw new RuntimeException("deflate failed: " + e.getMessage(), e);
+        }
+    }
+
+    /** KonpeitoCompression.inflate(data) -> String */
+    public static String inflate(String data) {
+        try {
+            byte[] input = data.getBytes(StandardCharsets.ISO_8859_1);
+            Inflater inflater = new Inflater(true); // true = raw inflate (no zlib header)
+            inflater.setInput(input);
+            ByteArrayOutputStream baos = new ByteArrayOutputStream();
+            byte[] buffer = new byte[4096];
+            while (!inflater.finished()) {
+                int count = inflater.inflate(buffer);
+                if (count == 0 && inflater.needsInput()) break;
+                baos.write(buffer, 0, count);
+            }
+            inflater.end();
+            return baos.toString(StandardCharsets.UTF_8);
+        } catch (Exception e) {
+            throw new RuntimeException("inflate failed: " + e.getMessage(), e);
+        }
+    }
+
+    // ========================================================================
+    // Zlib (RFC 1950) - with zlib header
+    // ========================================================================
+
+    /** KonpeitoCompression.zlib_compress(data) -> String (binary) */
+    public static String zlibCompress(String data) {
+        try {
+            byte[] input = data.getBytes(StandardCharsets.UTF_8);
+            Deflater deflater = new Deflater(); // default: zlib format (with header)
+            deflater.setInput(input);
+            deflater.finish();
+            ByteArrayOutputStream baos = new ByteArrayOutputStream();
+            byte[] buffer = new byte[4096];
+            while (!deflater.finished()) {
+                int count = deflater.deflate(buffer);
+                baos.write(buffer, 0, count);
+            }
+            deflater.end();
+            return new String(baos.toByteArray(), StandardCharsets.ISO_8859_1);
+        } catch (Exception e) {
+            throw new RuntimeException("zlib_compress failed: " + e.getMessage(), e);
+        }
+    }
+
+    /** KonpeitoCompression.zlib_decompress(data, maxSize) -> String */
+    public static String zlibDecompress(String data, Object maxSize) {
+        try {
+            long maxBytes = 100 * 1024 * 1024; // 100MB default
+            if (maxSize instanceof Long) {
+                maxBytes = (Long) maxSize;
+            } else if (maxSize instanceof Integer) {
+                maxBytes = (Integer) maxSize;
+            }
+            byte[] input = data.getBytes(StandardCharsets.ISO_8859_1);
+            Inflater inflater = new Inflater(); // default: zlib format (with header)
+            inflater.setInput(input);
+            ByteArrayOutputStream baos = new ByteArrayOutputStream();
+            byte[] buffer = new byte[4096];
+            long totalBytes = 0;
+            while (!inflater.finished()) {
+                int count = inflater.inflate(buffer);
+                if (count == 0 && inflater.needsInput()) break;
+                totalBytes += count;
+                if (totalBytes > maxBytes) {
+                    inflater.end();
+                    throw new RuntimeException("Decompressed data exceeds max size: " + maxBytes);
+                }
+                baos.write(buffer, 0, count);
+            }
+            inflater.end();
+            return baos.toString(StandardCharsets.UTF_8);
+        } catch (RuntimeException e) {
+            throw e;
+        } catch (Exception e) {
+            throw new RuntimeException("zlib_decompress failed: " + e.getMessage(), e);
+        }
+    }
+}

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

@@ -0,0 +1,48 @@
+package konpeito.runtime;
+
+import java.util.concurrent.locks.Condition;
+import java.util.concurrent.locks.ReentrantLock;
+
+/**
+ * KConditionVariable - Ruby ConditionVariable implementation for JVM backend.
+ *
+ * Uses an internal ReentrantLock + Condition pair.
+ * Note: In Ruby, ConditionVariable can be used with any Mutex.
+ * This simplified implementation uses its own internal lock.
+ */
+public class KConditionVariable {
+    private final ReentrantLock lock = new ReentrantLock();
+    private final Condition condition = lock.newCondition();
+
+    /** Ruby: cv.wait(mutex) — waits for signal */
+    public void await() {
+        lock.lock();
+        try {
+            condition.await();
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    /** Ruby: cv.signal — wakes one waiting thread */
+    public void signal() {
+        lock.lock();
+        try {
+            condition.signal();
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    /** Ruby: cv.broadcast — wakes all waiting threads */
+    public void broadcast() {
+        lock.lock();
+        try {
+            condition.signalAll();
+        } finally {
+            lock.unlock();
+        }
+    }
+}