origin-or 1.7.9__py3-none-any.whl

origin/__init__.py

@@ -0,0 +1,3 @@
+"""Origin programming language."""
+
+__version__ = "1.7.9"

origin/__main__.py

@@ -0,0 +1,16 @@
+"""Entry point for `python -m origin` and the `origin` CLI command."""
+
+import sys
+from .runner import run_origin
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("Origin Programming Language v1.7.9")
+        print("Usage: origin <file.or>")
+        sys.exit(1)
+    run_origin(sys.argv[1])
+
+
+if __name__ == "__main__":
+    main()

origin/bc/JavaImplement/BoundMethod.java

@@ -0,0 +1,11 @@
+package ORIGIN_CODE.bc.JavaImplement;
+
+public final class BoundMethod {
+    public final OriginInstance instance;
+    public final int funcPc;
+
+    public BoundMethod(OriginInstance instance, int funcPc) {
+        this.instance = instance;
+        this.funcPc = funcPc;
+    }
+}

origin/bc/JavaImplement/Builtins.java

@@ -0,0 +1,224 @@
+package ORIGIN_CODE.bc.JavaImplement;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Scanner;
+import java.util.concurrent.ThreadLocalRandom;
+
+/**
+ * Registry of built-in callables that the VM exposes to bytecode via CALL.
+ * Mirrors the {open, read, write, append, range, ...} dictionary in
+ * to_byte.py:18 plus the implicit built-ins handled by the Python branch
+ * of CALL at svm.py:333-339.
+ */
+public final class Builtins {
+
+    @FunctionalInterface
+    public interface BuiltinFn {
+        Object call(List<Object> args);
+    }
+
+    private final Map<String, BuiltinFn> registry;
+
+    public Builtins() {
+        this.registry = new HashMap<>();
+        registerDefaults();
+    }
+
+    public BuiltinFn get(String name) {
+        return registry.get(name);
+    }
+
+    public boolean contains(String name) {
+        return registry.containsKey(name);
+    }
+
+    private void registerDefaults() {
+        // Compiler builtins (to_byte.py:18-24)
+        registry.put("open", args -> new OpenFile(asStr(args, 0), "r"));
+        registry.put("read", args -> {
+            OpenFile f = asOpenFile(args, 0);
+            return f.readAll();
+        });
+        registry.put("write", args -> {
+            Object pathOrFile = args.get(0);
+            Object content = args.get(1);
+            String contentStr = String.valueOf(content);
+            if (pathOrFile instanceof OpenFile) {
+                ((OpenFile) pathOrFile).writeAll(contentStr);
+                return null;
+            }
+            try (java.io.FileWriter w = new java.io.FileWriter(asStr(args, 0))) {
+                w.write(contentStr);
+            } catch (java.io.IOException e) {
+                throw new RuntimeException(e);
+            }
+            return null;
+        });
+        registry.put("append", args -> {
+            Object pathOrFile = args.get(0);
+            Object content = args.get(1);
+            String contentStr = String.valueOf(content);
+            if (pathOrFile instanceof OpenFile) {
+                ((OpenFile) pathOrFile).appendAll(contentStr);
+                return null;
+            }
+            try (java.io.FileWriter w = new java.io.FileWriter(asStr(args, 0), true)) {
+                w.write(contentStr);
+            } catch (java.io.IOException e) {
+                throw new RuntimeException(e);
+            }
+            return null;
+        });
+        registry.put("range", args -> {
+            int n = args.size();
+            int start, end;
+            if (n == 1) { start = 0; end = asInt(args, 0); }
+            else { start = asInt(args, 0); end = asInt(args, 1); }
+            List<Object> out = new ArrayList<>();
+            for (int i = start; i < end; i++) out.add((long) i);
+            return out;
+        });
+
+        // Implied built-ins called from bytecode (svm.py CALL branch)
+        registry.put("str",  args -> toStr(args.isEmpty() ? null : args.get(0)));
+        registry.put("int",  args -> {
+            if (args.isEmpty()) return 0L;
+            Object v = args.get(0);
+            if (v instanceof Long) return v;
+            if (v instanceof Double) return ((Double) v).longValue();
+            if (v instanceof Boolean) return ((Boolean) v) ? 1L : 0L;
+            return Long.parseLong(String.valueOf(v));
+        });
+        registry.put("float", args -> {
+            if (args.isEmpty()) return 0.0;
+            Object v = args.get(0);
+            if (v instanceof Double) return v;
+            if (v instanceof Long) return ((Long) v).doubleValue();
+            return Double.parseDouble(String.valueOf(v));
+        });
+        registry.put("bool", args -> toBool(args.isEmpty() ? null : args.get(0)));
+        registry.put("len", args -> (long) lengthOf(args.get(0)));
+        registry.put("input", args -> {
+            if (args.isEmpty()) return new Scanner(System.in).nextLine();
+            System.out.print(args.get(0));
+            return new Scanner(System.in).nextLine();
+        });
+        registry.put("random", args -> {
+            // Placeholder; VM handles RAND_NUM directly via ThreadLocalRandom.
+            return null;
+        });
+        registry.put("math", args -> null);  // VM handles SQRT directly
+        registry.put("print", args -> {
+            StringBuilder sb = new StringBuilder();
+            for (Object a : args) sb.append(toStr(a));
+            System.out.println(sb.toString());
+            return null;
+        });
+        registry.put("list", args -> {
+            if (args.isEmpty()) return new ArrayList<>();
+            Object v = args.get(0);
+            if (v instanceof List) return new ArrayList<>((List<?>) v);
+            if (v instanceof String) {
+                List<Object> out = new ArrayList<>();
+                String s = (String) v;
+                for (int i = 0; i < s.length(); i++) out.add(String.valueOf(s.charAt(i)));
+                return out;
+            }
+            throw new RuntimeException("object is not iterable");
+        });
+        registry.put("dict", args -> new HashMap<>());
+        registry.put("tuple", args -> new ArrayList<>(args));
+    }
+
+    // --- helpers used by Builtins and by VM opcode handlers ---
+
+    public static String toStr(Object v) {
+        if (v == null) return "null";
+        if (v instanceof OriginInstance) return v.toString();
+        return String.valueOf(v);
+    }
+
+    public static boolean toBool(Object v) {
+        if (v == null) return false;
+        if (v instanceof Boolean) return (Boolean) v;
+        if (v instanceof Long) return ((Long) v) != 0;
+        if (v instanceof Double) return ((Double) v) != 0.0;
+        if (v instanceof String) return !((String) v).isEmpty();
+        if (v instanceof List) return !((List<?>) v).isEmpty();
+        if (v instanceof Map) return !((Map<?, ?>) v).isEmpty();
+        return true;
+    }
+
+    public static int asInt(List<Object> args, int i) {
+        Object v = args.get(i);
+        if (v instanceof Long) return ((Long) v).intValue();
+        if (v instanceof Double) return ((Double) v).intValue();
+        if (v instanceof Boolean) return ((Boolean) v) ? 1 : 0;
+        return Integer.parseInt(String.valueOf(v));
+    }
+
+    public static String asStr(List<Object> args, int i) {
+        Object v = args.get(i);
+        if (v == null) return "null";
+        return String.valueOf(v);
+    }
+
+    public static long asLong(Object v) {
+        if (v instanceof Long) return (Long) v;
+        if (v instanceof Double) return ((Double) v).longValue();
+        if (v instanceof Boolean) return ((Boolean) v) ? 1L : 0L;
+        return Long.parseLong(String.valueOf(v));
+    }
+
+    public static double asDouble(Object v) {
+        if (v instanceof Double) return (Double) v;
+        if (v instanceof Long) return ((Long) v).doubleValue();
+        if (v instanceof Boolean) return ((Boolean) v) ? 1.0 : 0.0;
+        return Double.parseDouble(String.valueOf(v));
+    }
+
+    public static long lengthOf(Object v) {
+        if (v instanceof String) return ((String) v).length();
+        if (v instanceof List) return ((List<?>) v).size();
+        if (v instanceof Map) return ((Map<?, ?>) v).size();
+        throw new RuntimeException("object has no len(): " + (v == null ? "null" : v.getClass().getName()));
+    }
+
+    public static int randInt(long start, long end) {
+        return ThreadLocalRandom.current().nextInt((int) start, (int) end + 1);
+    }
+
+    /** Wrapper for a file handle returned by built-in open(). */
+    public static final class OpenFile {
+        public final String path;
+        public final String mode;
+        public OpenFile(String path, String mode) { this.path = path; this.mode = mode; }
+        public String readAll() {
+            try {
+                return new String(java.nio.file.Files.readAllBytes(java.nio.file.Paths.get(path)));
+            } catch (java.io.IOException e) {
+                throw new RuntimeException(e);
+            }
+        }
+        public void writeAll(String content) {
+            try (java.io.FileWriter w = new java.io.FileWriter(path)) {
+                w.write(content);
+            } catch (java.io.IOException e) { throw new RuntimeException(e); }
+        }
+        public void appendAll(String content) {
+            try (java.io.FileWriter w = new java.io.FileWriter(path, true)) {
+                w.write(content);
+            } catch (java.io.IOException e) { throw new RuntimeException(e); }
+        }
+        @Override public String toString() { return "<open file '" + path + "' mode='" + mode + "'>"; }
+    }
+
+    private static OpenFile asOpenFile(List<Object> args, int i) {
+        Object v = args.get(i);
+        if (v instanceof OpenFile) return (OpenFile) v;
+        return new OpenFile(asStr(args, i), "r");
+    }
+}

origin/bc/JavaImplement/HardwareSim.java

@@ -0,0 +1,93 @@
+package ORIGIN_CODE.bc.JavaImplement;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Hardware-backed operations for SET_PIN, HARDWARE_CALL, SET_SERVO.
+ * Mirrors the try-import-then-fallback pattern in svm.py:14-46.
+ *
+ * The Real backend is intentionally absent — Pi GPIO / smbus2 / adafruit_servokit
+ * are not available on the JVM, and adding the JNI/pi4j dependencies is out of
+ * scope for this port. Any call to setBackend(Backend.REAL) without the
+ * corresponding JNI bridge installed will fall through to simulation.
+ */
+public final class HardwareSim {
+
+    public enum Backend { SIM, REAL }
+
+    private static Backend backend = Backend.SIM;
+
+    public static void setBackend(Backend b) { backend = b; }
+    public static Backend getBackend() { return backend; }
+
+    public static void setPin(long pin, long state) {
+        // svm.py:14-21 — only the simulation branch is reachable from the JVM.
+        System.out.println("[SIM] Pin " + pin + " set to " + state);
+    }
+
+    public static Object i2cRead(long addr, long reg, long size) {
+        // svm.py:23-29
+        return 0L;
+    }
+
+    public static void i2cWrite(long addr, long reg, Object data) {
+        // svm.py:31-38
+        // no-op in simulation
+    }
+
+    public static void spiWrite(Object data) {
+        // svm.py:40-41
+        System.out.println("[SIM] SPI write: " + data);
+    }
+
+    public static Object spiRead(long count) {
+        // svm.py:43-45
+        System.out.println("[SIM] SPI read: " + count);
+        return 0L;
+    }
+
+    /** SET_SERVO dispatcher (svm.py:427-438). Caches the kit globally. */
+    public static void setServo(long channel, double angle) {
+        // svm.py:432-438 — without adafruit_servokit available on the JVM,
+        // we always take the simulation branch.
+        System.out.println("[SIM] Servo " + channel + " angle set to " + angle);
+    }
+
+    /** HARDWARE_CALL dispatcher (svm.py:407-425). */
+    public static Object hardwareCall(String namespace, String method, List<Object> args) {
+        if ("i2c".equals(namespace) && "read".equals(method)) {
+            long addr = Builtins.asLong(args.get(0));
+            long reg  = Builtins.asLong(args.get(1));
+            long size = args.size() > 2 ? Builtins.asLong(args.get(2)) : 1L;
+            return i2cRead(addr, reg, size);
+        }
+        if ("i2c".equals(namespace) && "write".equals(method)) {
+            long addr = Builtins.asLong(args.get(0));
+            long reg  = Builtins.asLong(args.get(1));
+            i2cWrite(addr, reg, args.get(2));
+            return null;
+        }
+        if ("spi".equals(namespace) && "write".equals(method)) {
+            spiWrite(args.get(0));
+            return null;
+        }
+        if ("spi".equals(namespace) && "read".equals(method)) {
+            return spiRead(Builtins.asLong(args.get(0)));
+        }
+        // svm.py:425 — unknown hardware call gets a generic SIM line
+        StringBuilder sb = new StringBuilder("[SIM] ").append(namespace).append(".").append(method).append("(");
+        for (int i = 0; i < args.size(); i++) {
+            if (i > 0) sb.append(", ");
+            sb.append(Builtins.toStr(args.get(i)));
+        }
+        sb.append(")");
+        System.out.println(sb);
+        return null;
+    }
+
+    /** EXEC_PY dispatcher (svm.py:461-463). Simulation: print only. */
+    public static void execPy(Object code) {
+        System.out.println("[SIM] exec(" + Builtins.toStr(code) + ")");
+    }
+}

origin/bc/JavaImplement/Loader.java

@@ -0,0 +1,103 @@
+package ORIGIN_CODE.bc.JavaImplement;
+
+import java.io.DataInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Loads an .obc bytecode file into (bytecode, constants[]) for the VM.
+ *
+ * Format (all big-endian):
+ *   magic        : 4 bytes  "OBC1"
+ *   version      : 1 byte   (0x01)
+ *   const_count  : 4 bytes int32
+ *   constants    : repeated [typeTag(1) + payload]
+ *   code_len     : 4 bytes int32
+ *   bytecode     : code_len bytes
+ *
+ * Type tags:
+ *   0 = LONG       payload  = 8 bytes signed
+ *   1 = DOUBLE     payload  = 8 bytes IEEE-754
+ *   2 = BOOLEAN    payload  = 1 byte
+ *   3 = STRING     payload  = int32 len + utf8 bytes
+ *   4 = NULL       payload  = 0 bytes
+ *   5 = INT32      payload  = 4 bytes signed
+ *
+ * Origin's bytecode emitter emits integer addresses as ints and small
+ * constants as ints; everything else gets LONG. STRING carries names
+ * for LOAD_VAR / STORE_VAR and the (ns, method) pair for HARDWARE_CALL
+ * (encoded as STRING, STRING).
+ */
+public final class Loader {
+
+    public static final class Loaded {
+        public final byte[] bytecode;
+        public final Object[] constants;
+        public Loaded(byte[] bytecode, Object[] constants) {
+            this.bytecode = bytecode;
+            this.constants = constants;
+        }
+    }
+
+    public static Loaded load(InputStream in) throws IOException {
+        DataInputStream din = new DataInputStream(in);
+        byte[] magic = new byte[4];
+        din.readFully(magic);
+        if (!new String(magic, StandardCharsets.US_ASCII).equals("OBC1")) {
+            throw new IOException("bad magic: " + new String(magic, StandardCharsets.US_ASCII));
+        }
+        int version = din.readByte() & 0xFF;
+        if (version != 1) throw new IOException("unsupported version: " + version);
+
+        int constCount = din.readInt();
+        Object[] consts = new Object[constCount];
+        for (int i = 0; i < constCount; i++) {
+            consts[i] = readConst(din);
+        }
+
+        int codeLen = din.readInt();
+        byte[] code = new byte[codeLen];
+        din.readFully(code);
+        return new Loaded(code, consts);
+    }
+
+    private static Object readConst(DataInputStream din) throws IOException {
+        int tag = din.readByte() & 0xFF;
+        switch (tag) {
+            case 0: return din.readLong();
+            case 1: return din.readDouble();
+            case 2: return din.readByte() != 0;
+            case 3: {
+                int len = din.readInt();
+                byte[] b = new byte[len];
+                din.readFully(b);
+                return new String(b, StandardCharsets.UTF_8);
+            }
+            case 4: return null;
+            case 5: return (long) din.readInt();
+            case 6: {
+                // TUPLE — emitted by dump_obc.py for both tuple/list literals
+                // and for the flat [key, value, ...] representation of dicts
+                // used by MAKE_CLASS's methods table.
+                int n = din.readInt();
+                List<Object> tuple = new ArrayList<>(n);
+                for (int i = 0; i < n; i++) tuple.add(readConst(din));
+                return tuple;
+            }
+            default: throw new IOException("bad const tag: " + tag);
+        }
+    }
+
+    /** Convenience: load from a file path. */
+    public static Loaded loadFromFile(String path) throws IOException {
+        try (InputStream in = new java.io.FileInputStream(path)) {
+            return load(in);
+        }
+    }
+}

origin/bc/JavaImplement/Main.java

@@ -0,0 +1,34 @@
+package ORIGIN_CODE.bc.JavaImplement;
+
+import java.io.IOException;
+
+/**
+ * CLI entry point. Usage:
+ *   java -cp . ORIGIN_CODE.bc.Main program.obc
+ */
+public final class Main {
+
+    public static void main(String[] args) {
+        if (args.length < 1) {
+            System.err.println("usage: java -cp . ORIGIN_CODE.bc.Main <program.obc>");
+            System.exit(2);
+        }
+        String path = args[0];
+
+        if (args.length >= 2 && "--hw=real".equals(args[1])) {
+            HardwareSim.setBackend(HardwareSim.Backend.REAL);
+        }
+
+        try {
+            Loader.Loaded prog = Loader.loadFromFile(path);
+            svm vm = new svm(prog.bytecode, prog.constants);
+            vm.run();
+        } catch (IOException e) {
+            System.err.println("load error: " + e.getMessage());
+            System.exit(1);
+        } catch (RuntimeException e) {
+            System.err.println("runtime error: " + e.getMessage());
+            System.exit(1);
+        }
+    }
+}

origin/bc/JavaImplement/OpCode.java

@@ -0,0 +1,79 @@
+package ORIGIN_CODE.bc.JavaImplement;
+
+public final class OpCode {
+    public static final byte PUSH_CONST     = 0x01;
+    public static final byte LOAD_VAR       = 0x02;
+    public static final byte STORE_VAR      = 0x03;
+    public static final byte ADD            = 0x04;
+    public static final byte SUB            = 0x05;
+    public static final byte MUL            = 0x06;
+    public static final byte DIV            = 0x07;
+    public static final byte MOD            = 0x08;
+    public static final byte POW            = 0x09;
+    public static final byte NEGATE         = 0x0A;
+    public static final byte EQ             = 0x0B;
+    public static final byte NEQ            = 0x0C;
+    public static final byte LT             = 0x0D;
+    public static final byte GT             = 0x0E;
+    public static final byte LTE            = 0x0F;
+    public static final byte GTE            = 0x10;
+    public static final byte AND            = 0x11;
+    public static final byte OR             = 0x12;
+    public static final byte NOT            = 0x13;
+    public static final byte JMP            = 0x14;
+    public static final byte JMP_IF_FALSE   = 0x15;
+    public static final byte PRINT          = 0x16;
+    public static final byte INPUT          = 0x17;
+    public static final byte LEN            = 0x18;
+    public static final byte SQRT           = 0x19;
+    public static final byte RAND_NUM       = 0x1A;
+    public static final byte LIST_INIT      = 0x1B;
+    public static final byte DICT_INIT      = 0x1C;
+    public static final byte INDEX_LOAD     = 0x1D;
+    public static final byte INDEX_STORE    = 0x1E;
+    public static final byte HALT           = 0x1F;
+    public static final byte POP            = 0x20;
+    public static final byte DUP            = 0x21;
+    public static final byte CALL           = 0x22;
+    public static final byte RETURN         = 0x23;
+    public static final byte LOOP_START     = 0x24;
+    public static final byte LOOP_END       = 0x25;
+    public static final byte BREAK          = 0x26;
+    public static final byte CONTINUE       = 0x27;
+    public static final byte CAST_STR       = 0x28;
+    public static final byte CAST_INT       = 0x29;
+    public static final byte CAST_FLOAT     = 0x2A;
+    public static final byte GET_ITER       = 0x2B;
+    public static final byte FOR_ITER       = 0x2C;
+    public static final byte MAKE_CLASS     = 0x2D;
+    public static final byte LOAD_ATTR      = 0x2E;
+    public static final byte STORE_ATTR     = 0x2F;
+    public static final byte MAKE_CLOSURE   = 0x30;
+    public static final byte LOAD_UPVALUE   = 0x31;
+    public static final byte STORE_UPVALUE  = 0x32;
+    public static final byte SETUP_EXCEPT   = 0x33;
+    public static final byte POP_EXCEPT     = 0x34;
+    public static final byte THROW          = 0x35;
+    public static final byte IMPORT_NAME    = 0x36;
+    public static final byte IMPORT_FROM    = 0x37;
+    public static final byte BIT_AND        = 0x38;
+    public static final byte BIT_OR         = 0x39;
+    public static final byte BIT_XOR        = 0x3A;
+    public static final byte BIT_NOT        = 0x3B;
+    public static final byte LSHIFT         = 0x3C;
+    public static final byte RSHIFT         = 0x3D;
+    public static final byte UNPACK_SEQ     = 0x3E;
+    public static final byte FORMAT_VAL     = 0x3F;
+    public static final byte BUILD_STR      = 0x40;
+    public static final byte READ_FILE      = 0x41;
+    public static final byte WRITE_FILE     = 0x42;
+    public static final byte APPEND_FILE    = 0x43;
+    public static final byte HARDWARE_CALL  = 0x44;
+    public static final byte SET_SERVO      = 0x45;
+    public static final byte SET_PIN        = 0x46;
+    public static final byte PARALLEL_START = 0x47;
+    public static final byte PARALLEL_END   = 0x48;
+    public static final byte EXEC_PY        = 0x49;
+
+    private OpCode() {}
+}

origin/bc/JavaImplement/OriginClass.java

@@ -0,0 +1,16 @@
+package ORIGIN_CODE.bc.JavaImplement;
+
+import java.util.List;
+import java.util.Map;
+
+public final class OriginClass {
+    public final String name;
+    public final List<String> fields;
+    public final Map<String, Integer> methods;
+
+    public OriginClass(String name, List<String> fields, Map<String, Integer> methods) {
+        this.name = name;
+        this.fields = fields;
+        this.methods = methods;
+    }
+}

origin/bc/JavaImplement/OriginInstance.java

@@ -0,0 +1,19 @@
+package ORIGIN_CODE.bc.JavaImplement;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public final class OriginInstance {
+    public final OriginClass originClass;
+    public final Map<String, Object> attrs;
+
+    public OriginInstance(OriginClass originClass) {
+        this.originClass = originClass;
+        this.attrs = new HashMap<>();
+    }
+
+    @Override
+    public String toString() {
+        return "<" + originClass.name + " instance>";
+    }
+}