origin-or 1.7.9__tar.gz

origin_or-1.7.9/MANIFEST.in

@@ -0,0 +1,4 @@
+include origin/lib/*.or
+include origin/lib/*.py
+include origin/bc/JavaImplement/*.java
+include README.md

origin_or-1.7.9/PKG-INFO

@@ -0,0 +1,203 @@
+Metadata-Version: 2.4
+Name: origin-or
+Version: 1.7.9
+Summary: The Origin programming language — compiled bytecode VM for Raspberry Pi
+Author: Nikhil Mahankali
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: Software Development :: Interpreters
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: MacOS
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Provides-Extra: pi
+Requires-Dist: RPi.GPIO; extra == "pi"
+Requires-Dist: adafruit-circuitpython-servokit; extra == "pi"
+Requires-Dist: smbus2; extra == "pi"
+Provides-Extra: build
+Requires-Dist: pyinstaller; extra == "build"
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: provides-extra
+Dynamic: requires-python
+Dynamic: summary
+
+# Origin Programming Language · v1.7.9
+
+[![Status](https://img.shields.io/badge/Status-Stable-success?style=flat-square)](https://docs-origin.onrender.com)
+[![Version](https://img.shields.io/badge/Version-v1.7.9-blue?style=flat-square)](https://docs-origin.onrender.com)
+[![Platform](https://img.shields.io/badge/Platform-Windows-blue?style=flat-square)](https://docs-origin.onrender.com)
+
+**Origin** is a Python-based programming language with a syntax designed to be expressive, English-like, and hardware-first. It enables AI models and developers to produce scalable code with high readability while retaining the full power of the Python ecosystem.
+
+> **Visit the official documentation:** [docs-origin.onrender.com](https://docs-origin.onrender.com)
+
+> **June 2026 re-issue:** The standalone `origin.exe` has been rebuilt from the v1.7.5 reference sources with the flat-layout imports normalized, and `secure_install.ps1` now hard-codes the SHA-256 of the new binary. The language surface is unchanged from the prior v1.7.9 release. The bytecode VM migration continues on the [`origin-dev`](https://github.com/boblio-max/origin-dev) branch and will ship as v1.8.
+
+---
+
+## Key Features
+
+*   **English-Like Syntax**: Write code that reads like natural language.
+*   **Built-in Library System**: Import `.or` library files with `import calc`, including a math library (`calc.or`) and graph plotting library (`graph.or`).
+*   **Hardware Primitives**: Native, intuitive commands for Raspberry Pi GPIO and ServoKit (PCA9685).
+*   **Strict Typing**: Mandatory type annotations (`let x: int = 10`) for predictable state and AI-native safety.
+*   **Safe Hardware I/O**: Automatic angle clamping (0-180 degrees) for servos to prevent physical damage.
+*   **Formal Module System**: Professional namespacing and module support (`import math as m`, `from lib import x`).
+*   **Binary Builder**: Compile your Origin scripts into standalone, zero-dependency `.exe` files.
+*   **Modern Logic**: Support for Object-Oriented Programming (classes), `try/except/else`, `parallel` thread blocks, and robust scope management.
+
+---
+
+## Installation
+
+### Standalone (Recommended)
+You can now download Origin as a standalone installer for Windows. This is the fastest way to get started.
+
+1. **Download**: [Origin v1.7.9 Stable](https://docs-origin.onrender.com/download.html)
+2. **Install**: Run `secure_install.ps1` with PowerShell.
+3. **Usage**: Open a new terminal and type `origin`.
+
+### Developer / Source
+1. **Clone the repository**:
+   ```powershell
+   git clone https://github.com/boblio-max/origin.git
+   ```
+
+2. **Install Dependencies**:
+   ```powershell
+   pip install -r requirements.txt
+   ```
+
+---
+
+## Language Reference
+
+### 1. Variables & Types
+Origin uses `let` for variables and `const` for immutable references. Types are mandatory.
+
+```origin
+let   x: int    = 10          # Scalar integer
+let   name: str = "Origin"    # String literal
+let   flag: bool = true       # Boolean (lowercase)
+const pi: float = 3.14159     # Immutable constant
+let   data: none = none       # None literal
+```
+
+### 2. Built-in Libraries
+Origin includes a standard library system under `lib/`. Use `import` to load them:
+
+```origin
+import calc
+import graph
+
+# Math utilities
+calc = calc()
+print calc.sqrt(25)
+print calc.pi
+
+# Graph plotting
+graph "My Plot" with {
+    X: color(1,0,0) as "Line A",
+}
+```
+
+### 3. Hardware Control
+Control hardware directly with the `set` namespace and native protocol primitives.
+
+```origin
+# Set Servo 1 to 90 degrees (clamped 0-180)
+set servo.angle 1, 90
+
+# Drive BCM Pin 12 HIGH
+set pin 12, 1
+
+# Parentheseless I2C, SPI, and UART calls
+i2c.read 0x40, 4
+spi.write 0x01
+```
+
+### 4. Data Structures
+```origin
+# Lists
+let tools: list = ["Servo", "GPIO", "I2C"]
+print tools[0]
+
+# Dictionaries (Access via { })
+let config: dict = {"speed": 100, "active": true}
+print config{"speed"}
+
+# Tuples
+let coord: tuple = (10, 20)
+```
+
+### 5. Raw Python Blocks
+Seamlessly bridge the gap between Origin and Python.
+
+```origin
+py {
+    import math
+    import os
+    print("Python process ID:", os.getpid())
+    print("Sine of 90 degrees:", math.sin(math.pi/2))
+}
+```
+
+### 6. Module System
+Origin supports a formal module system for clean namespacing.
+
+```origin
+import math_utils as mu        # Import with alias
+from robotics import drive     # Selective import
+
+print mu.square(10)
+drive(1.0)
+```
+
+### 7. Object-Oriented Programming
+Define classes with fields and methods natively for structured development.
+
+```origin
+class Sensor (pin type) {
+    def read() {
+        return pin
+    }
+}
+```
+
+---
+
+Origin scripts use the `.or` extension.
+
+### Running a script:
+```powershell
+origin main.or
+```
+
+### Building a standalone binary:
+```powershell
+origin build main.or
+```
+
+---
+
+## Roadmap
+
+The following features are currently in development:
+- [ ] **Pattern Matching**: `match` and `case` constructs.
+- [ ] **Advanced Structures**: `struct` and `enum` types.
+- [ ] **Asynchronous I/O**: Native `async` and `await` support.
+- [ ] **Metaprogramming**: `macro` and `inline` definitions.
+- [ ] **Unified IDE**: A dedicated cross-platform IDE for Origin development.
+
+---
+
+## License & Contact
+
+Distributed under the **MIT License**.
+**Author**: Nikhil Mahankali
+**Contact**: [nikhilmahankali56@gmail.com](mailto:nikhilmahankali56@gmail.com)

origin_or-1.7.9/README.md

@@ -0,0 +1,175 @@
+# Origin Programming Language · v1.7.9
+
+[![Status](https://img.shields.io/badge/Status-Stable-success?style=flat-square)](https://docs-origin.onrender.com)
+[![Version](https://img.shields.io/badge/Version-v1.7.9-blue?style=flat-square)](https://docs-origin.onrender.com)
+[![Platform](https://img.shields.io/badge/Platform-Windows-blue?style=flat-square)](https://docs-origin.onrender.com)
+
+**Origin** is a Python-based programming language with a syntax designed to be expressive, English-like, and hardware-first. It enables AI models and developers to produce scalable code with high readability while retaining the full power of the Python ecosystem.
+
+> **Visit the official documentation:** [docs-origin.onrender.com](https://docs-origin.onrender.com)
+
+> **June 2026 re-issue:** The standalone `origin.exe` has been rebuilt from the v1.7.5 reference sources with the flat-layout imports normalized, and `secure_install.ps1` now hard-codes the SHA-256 of the new binary. The language surface is unchanged from the prior v1.7.9 release. The bytecode VM migration continues on the [`origin-dev`](https://github.com/boblio-max/origin-dev) branch and will ship as v1.8.
+
+---
+
+## Key Features
+
+*   **English-Like Syntax**: Write code that reads like natural language.
+*   **Built-in Library System**: Import `.or` library files with `import calc`, including a math library (`calc.or`) and graph plotting library (`graph.or`).
+*   **Hardware Primitives**: Native, intuitive commands for Raspberry Pi GPIO and ServoKit (PCA9685).
+*   **Strict Typing**: Mandatory type annotations (`let x: int = 10`) for predictable state and AI-native safety.
+*   **Safe Hardware I/O**: Automatic angle clamping (0-180 degrees) for servos to prevent physical damage.
+*   **Formal Module System**: Professional namespacing and module support (`import math as m`, `from lib import x`).
+*   **Binary Builder**: Compile your Origin scripts into standalone, zero-dependency `.exe` files.
+*   **Modern Logic**: Support for Object-Oriented Programming (classes), `try/except/else`, `parallel` thread blocks, and robust scope management.
+
+---
+
+## Installation
+
+### Standalone (Recommended)
+You can now download Origin as a standalone installer for Windows. This is the fastest way to get started.
+
+1. **Download**: [Origin v1.7.9 Stable](https://docs-origin.onrender.com/download.html)
+2. **Install**: Run `secure_install.ps1` with PowerShell.
+3. **Usage**: Open a new terminal and type `origin`.
+
+### Developer / Source
+1. **Clone the repository**:
+   ```powershell
+   git clone https://github.com/boblio-max/origin.git
+   ```
+
+2. **Install Dependencies**:
+   ```powershell
+   pip install -r requirements.txt
+   ```
+
+---
+
+## Language Reference
+
+### 1. Variables & Types
+Origin uses `let` for variables and `const` for immutable references. Types are mandatory.
+
+```origin
+let   x: int    = 10          # Scalar integer
+let   name: str = "Origin"    # String literal
+let   flag: bool = true       # Boolean (lowercase)
+const pi: float = 3.14159     # Immutable constant
+let   data: none = none       # None literal
+```
+
+### 2. Built-in Libraries
+Origin includes a standard library system under `lib/`. Use `import` to load them:
+
+```origin
+import calc
+import graph
+
+# Math utilities
+calc = calc()
+print calc.sqrt(25)
+print calc.pi
+
+# Graph plotting
+graph "My Plot" with {
+    X: color(1,0,0) as "Line A",
+}
+```
+
+### 3. Hardware Control
+Control hardware directly with the `set` namespace and native protocol primitives.
+
+```origin
+# Set Servo 1 to 90 degrees (clamped 0-180)
+set servo.angle 1, 90
+
+# Drive BCM Pin 12 HIGH
+set pin 12, 1
+
+# Parentheseless I2C, SPI, and UART calls
+i2c.read 0x40, 4
+spi.write 0x01
+```
+
+### 4. Data Structures
+```origin
+# Lists
+let tools: list = ["Servo", "GPIO", "I2C"]
+print tools[0]
+
+# Dictionaries (Access via { })
+let config: dict = {"speed": 100, "active": true}
+print config{"speed"}
+
+# Tuples
+let coord: tuple = (10, 20)
+```
+
+### 5. Raw Python Blocks
+Seamlessly bridge the gap between Origin and Python.
+
+```origin
+py {
+    import math
+    import os
+    print("Python process ID:", os.getpid())
+    print("Sine of 90 degrees:", math.sin(math.pi/2))
+}
+```
+
+### 6. Module System
+Origin supports a formal module system for clean namespacing.
+
+```origin
+import math_utils as mu        # Import with alias
+from robotics import drive     # Selective import
+
+print mu.square(10)
+drive(1.0)
+```
+
+### 7. Object-Oriented Programming
+Define classes with fields and methods natively for structured development.
+
+```origin
+class Sensor (pin type) {
+    def read() {
+        return pin
+    }
+}
+```
+
+---
+
+Origin scripts use the `.or` extension.
+
+### Running a script:
+```powershell
+origin main.or
+```
+
+### Building a standalone binary:
+```powershell
+origin build main.or
+```
+
+---
+
+## Roadmap
+
+The following features are currently in development:
+- [ ] **Pattern Matching**: `match` and `case` constructs.
+- [ ] **Advanced Structures**: `struct` and `enum` types.
+- [ ] **Asynchronous I/O**: Native `async` and `await` support.
+- [ ] **Metaprogramming**: `macro` and `inline` definitions.
+- [ ] **Unified IDE**: A dedicated cross-platform IDE for Origin development.
+
+---
+
+## License & Contact
+
+Distributed under the **MIT License**.
+**Author**: Nikhil Mahankali
+**Contact**: [nikhilmahankali56@gmail.com](mailto:nikhilmahankali56@gmail.com)

origin_or-1.7.9/origin/__init__.py

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

origin_or-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_or-1.7.9/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_or-1.7.9/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");
+    }
+}