jsharp 0.1.0__tar.gz

jsharp-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 J# Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

jsharp-0.1.0/PKG-INFO

@@ -0,0 +1,149 @@
+Metadata-Version: 2.4
+Name: jsharp
+Version: 0.1.0
+Summary: J# language: lexer -> parser -> AST -> bytecode -> VM
+Author: J# Contributors
+License: MIT
+Project-URL: Homepage, https://github.com/jsharp-lang/jsharp
+Project-URL: Repository, https://github.com/jsharp-lang/jsharp
+Project-URL: Issues, https://github.com/jsharp-lang/jsharp/issues
+Keywords: programming-language,bytecode,vm,compiler,education
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Compilers
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Dynamic: license-file
+
+# J# (J-sharp)
+
+J# is a language project with a real execution pipeline:
+
+`source (.jsh) -> lexer -> parser -> AST -> bytecode -> VM`
+
+J# programs are not executed with Python `eval`/`exec`, and the runtime does not transpile J# source to Python/JS for execution.
+
+## Install
+
+```bash
+cd jsharp
+python -m pip install -e .
+```
+
+If install is not available in your environment:
+
+```bash
+python jsh.py run examples/hello.jsh
+```
+
+## Quick Start
+
+### Hello
+
+```bash
+python jsh.py run examples/hello.jsh
+```
+
+### Web demo
+
+```bash
+python jsh.py run examples/web.jsh
+```
+
+Then open [http://localhost:8080](http://localhost:8080).
+
+### Dump and debug
+
+```bash
+python jsh.py dump examples/hello.jsh
+python jsh.py run --debug examples/hello.jsh
+```
+
+## CLI
+
+- `python jsh.py run <file.jsh>`
+- `python jsh.py run --debug <file.jsh>`
+- `python jsh.py run --native <file.jsh>`
+- `python jsh.py dump <file.jsh>`
+- `python jsh.py build <file.jsh> -o out.jbc`
+
+If installed as a package, `jsh` is available as a console script.
+
+## Architecture (text diagram)
+
+```text
+.jsh source
+   |
+   v
+ Lexer  -> token stream
+   |
+   v
+ Parser -> AST
+   |
+   v
+ Compiler -> bytecode chunks (per function)
+   |
+   v
+ VM (stack + frames + globals)
+```
+
+## Current Feature Set (v0.1)
+
+- Function declarations and function literals
+- `let`, assignment, `if/else`, `while`, `break`, `continue`, `return`
+- Numbers, strings, bools, none
+- Lists (`[1,2,3]`), indexing (`a[i]`), indexed assignment (`a[i] = x`)
+- Calls, attribute access, short-circuit `&&` / `||`
+- Stdlib objects: `http`, `io`, `fs`, `json`
+- Builtins: `print`, `len`, `div`
+
+## Competitive Programming
+
+Use the `io` module for fast buffered input/output.
+
+- `examples/cp_sum.jsh`
+- `examples/cp_minmax.jsh`
+- `examples/cp_prefix_sum.jsh`
+- Full guide: `docs/cp-guide.md`
+
+## Native Runtime Path
+
+- `python jsh.py build file.jsh -o file.jbc` emits serialized bytecode.
+- `python jsh.py run --native file.jsh` compiles to temp `.jbc` and executes `jsh-native` when available.
+- If `jsh-native` is unavailable, CLI prints guidance and falls back to Python VM execution.
+- Bytecode format spec: `docs/bytecode-spec.md`
+
+## Roadmap Summary
+
+Near-term goals:
+- expand stdlib and diagnostics,
+- strengthen Python/native runtime compatibility tests,
+- keep web demo smooth in Python VM path,
+- improve performance with targeted compiler/VM optimizations.
+
+Detailed plans: `docs/roadmap.md`.
+
+## Project Docs
+
+- `LANGUAGE_REFERENCE.md`
+- `docs/getting-started.md`
+- `docs/standard-library.md`
+- `docs/internals.md`
+- `docs/cp-guide.md`
+- `docs/bytecode-spec.md`
+- `docs/roadmap.md`
+
+## Limitations (current)
+
+- Closures/captures are intentionally disabled in v0.1 function literals.
+- Native VM path is focused on CP/runtime core; Python VM remains the primary path for full web demo behavior.

jsharp-0.1.0/README.md

@@ -0,0 +1,122 @@
+# J# (J-sharp)
+
+J# is a language project with a real execution pipeline:
+
+`source (.jsh) -> lexer -> parser -> AST -> bytecode -> VM`
+
+J# programs are not executed with Python `eval`/`exec`, and the runtime does not transpile J# source to Python/JS for execution.
+
+## Install
+
+```bash
+cd jsharp
+python -m pip install -e .
+```
+
+If install is not available in your environment:
+
+```bash
+python jsh.py run examples/hello.jsh
+```
+
+## Quick Start
+
+### Hello
+
+```bash
+python jsh.py run examples/hello.jsh
+```
+
+### Web demo
+
+```bash
+python jsh.py run examples/web.jsh
+```
+
+Then open [http://localhost:8080](http://localhost:8080).
+
+### Dump and debug
+
+```bash
+python jsh.py dump examples/hello.jsh
+python jsh.py run --debug examples/hello.jsh
+```
+
+## CLI
+
+- `python jsh.py run <file.jsh>`
+- `python jsh.py run --debug <file.jsh>`
+- `python jsh.py run --native <file.jsh>`
+- `python jsh.py dump <file.jsh>`
+- `python jsh.py build <file.jsh> -o out.jbc`
+
+If installed as a package, `jsh` is available as a console script.
+
+## Architecture (text diagram)
+
+```text
+.jsh source
+   |
+   v
+ Lexer  -> token stream
+   |
+   v
+ Parser -> AST
+   |
+   v
+ Compiler -> bytecode chunks (per function)
+   |
+   v
+ VM (stack + frames + globals)
+```
+
+## Current Feature Set (v0.1)
+
+- Function declarations and function literals
+- `let`, assignment, `if/else`, `while`, `break`, `continue`, `return`
+- Numbers, strings, bools, none
+- Lists (`[1,2,3]`), indexing (`a[i]`), indexed assignment (`a[i] = x`)
+- Calls, attribute access, short-circuit `&&` / `||`
+- Stdlib objects: `http`, `io`, `fs`, `json`
+- Builtins: `print`, `len`, `div`
+
+## Competitive Programming
+
+Use the `io` module for fast buffered input/output.
+
+- `examples/cp_sum.jsh`
+- `examples/cp_minmax.jsh`
+- `examples/cp_prefix_sum.jsh`
+- Full guide: `docs/cp-guide.md`
+
+## Native Runtime Path
+
+- `python jsh.py build file.jsh -o file.jbc` emits serialized bytecode.
+- `python jsh.py run --native file.jsh` compiles to temp `.jbc` and executes `jsh-native` when available.
+- If `jsh-native` is unavailable, CLI prints guidance and falls back to Python VM execution.
+- Bytecode format spec: `docs/bytecode-spec.md`
+
+## Roadmap Summary
+
+Near-term goals:
+- expand stdlib and diagnostics,
+- strengthen Python/native runtime compatibility tests,
+- keep web demo smooth in Python VM path,
+- improve performance with targeted compiler/VM optimizations.
+
+Detailed plans: `docs/roadmap.md`.
+
+## Project Docs
+
+- `LANGUAGE_REFERENCE.md`
+- `docs/getting-started.md`
+- `docs/standard-library.md`
+- `docs/internals.md`
+- `docs/cp-guide.md`
+- `docs/bytecode-spec.md`
+- `docs/roadmap.md`
+
+## Limitations (current)
+
+- Closures/captures are intentionally disabled in v0.1 function literals.
+- Native VM path is focused on CP/runtime core; Python VM remains the primary path for full web demo behavior.

jsharp-0.1.0/pyproject.toml

@@ -0,0 +1,44 @@
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "jsharp"
+version = "0.1.0"
+description = "J# language: lexer -> parser -> AST -> bytecode -> VM"
+readme = "README.md"
+requires-python = ">=3.11"
+license = { text = "MIT" }
+authors = [{ name = "J# Contributors" }]
+keywords = ["programming-language", "bytecode", "vm", "compiler", "education"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Topic :: Software Development :: Compilers",
+]
+dependencies = []
+
+[project.optional-dependencies]
+dev = ["pytest", "ruff", "build"]
+
+[project.scripts]
+jsh = "jsharp.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/jsharp-lang/jsharp"
+Repository = "https://github.com/jsharp-lang/jsharp"
+Issues = "https://github.com/jsharp-lang/jsharp/issues"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]

jsharp-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

jsharp-0.1.0/src/jsharp/__init__.py

@@ -0,0 +1,4 @@
+"""J# language implementation package."""
+
+__all__ = ["__version__"]
+__version__ = "0.1.0"

jsharp-0.1.0/src/jsharp/ast_nodes.py

@@ -0,0 +1,173 @@
+"""AST dataclasses for J#. Keep this file simple and beginner-readable."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class Program:
+    functions: list["FnDecl"]
+
+
+@dataclass
+class FnDecl:
+    name: str
+    params: list[str]
+    body: list["Stmt"]
+    line: int
+    col: int
+
+
+class Stmt:
+    pass
+
+
+@dataclass
+class LetStmt(Stmt):
+    name: str
+    expr: "Expr"
+    line: int
+    col: int
+
+
+@dataclass
+class AssignStmt(Stmt):
+    name: str
+    expr: "Expr"
+    line: int
+    col: int
+
+
+@dataclass
+class IndexSetStmt(Stmt):
+    obj: "Expr"
+    index: "Expr"
+    value: "Expr"
+    line: int
+    col: int
+
+
+@dataclass
+class ExprStmt(Stmt):
+    expr: "Expr"
+    line: int
+    col: int
+
+
+@dataclass
+class IfStmt(Stmt):
+    cond: "Expr"
+    then_body: list[Stmt]
+    else_body: Optional[list[Stmt]]
+    line: int
+    col: int
+
+
+@dataclass
+class WhileStmt(Stmt):
+    cond: "Expr"
+    body: list[Stmt]
+    line: int
+    col: int
+
+
+@dataclass
+class BreakStmt(Stmt):
+    line: int
+    col: int
+
+
+@dataclass
+class ContinueStmt(Stmt):
+    line: int
+    col: int
+
+
+@dataclass
+class ReturnStmt(Stmt):
+    value: Optional["Expr"]
+    line: int
+    col: int
+
+
+class Expr:
+    pass
+
+
+@dataclass
+class LiteralExpr(Expr):
+    value: object
+    line: int
+    col: int
+
+
+@dataclass
+class ListLitExpr(Expr):
+    items: list["Expr"]
+    line: int
+    col: int
+
+
+@dataclass
+class VarExpr(Expr):
+    name: str
+    line: int
+    col: int
+
+
+@dataclass
+class UnaryExpr(Expr):
+    op: str
+    right: Expr
+    line: int
+    col: int
+
+
+@dataclass
+class BinaryExpr(Expr):
+    left: Expr
+    op: str
+    right: Expr
+    line: int
+    col: int
+
+
+@dataclass
+class CallExpr(Expr):
+    callee: Expr
+    args: list[Expr]
+    line: int
+    col: int
+
+
+@dataclass
+class GetAttrExpr(Expr):
+    obj: Expr
+    name: str
+    line: int
+    col: int
+
+
+@dataclass
+class IndexGetExpr(Expr):
+    obj: Expr
+    index: Expr
+    line: int
+    col: int
+
+
+@dataclass
+class GroupExpr(Expr):
+    expr: Expr
+    line: int
+    col: int
+
+
+@dataclass
+class FnLitExpr(Expr):
+    params: list[str]
+    body: list[Stmt]
+    line: int
+    col: int

jsharp-0.1.0/src/jsharp/builtins.py

@@ -0,0 +1,59 @@
+"""Builtin/native symbols registered in VM.globals."""
+
+from __future__ import annotations
+
+from jsharp.stdlib import fs, http, io, jsonlib
+from jsharp.stdlib.io import IOState
+from jsharp.values import NativeFn
+
+
+def _native_print(vm, *args):
+    print(*args)
+    return None
+
+
+def _native_len(vm, value):
+    try:
+        return len(value)
+    except TypeError as exc:
+        raise RuntimeError(f"len() not supported for type {type(value).__name__}") from exc
+
+
+def _native_div(vm, a, b):
+    if isinstance(a, bool) or isinstance(b, bool) or not isinstance(a, int) or not isinstance(b, int):
+        raise RuntimeError("div(a,b) expects integer arguments")
+    if b == 0:
+        raise RuntimeError("division by zero")
+    # Truncate toward zero for C-like competitive-programming semantics.
+    return int(a / b)
+
+
+def make_builtins(vm):
+    if not hasattr(vm, "_io_state"):
+        vm._io_state = IOState()
+
+    return {
+        "print": NativeFn("print", _native_print),
+        "len": NativeFn("len", _native_len),
+        "div": NativeFn("div", _native_div),
+        "http": {
+            "serve": NativeFn("http.serve", http.serve),
+        },
+        "fs": {
+            "read_text": NativeFn("fs.read_text", fs.read_text),
+            "write_text": NativeFn("fs.write_text", fs.write_text),
+        },
+        "json": {
+            "parse": NativeFn("json.parse", jsonlib.parse),
+            "stringify": NativeFn("json.stringify", jsonlib.stringify),
+        },
+        "io": {
+            "read_all": NativeFn("io.read_all", io.read_all),
+            "read_line": NativeFn("io.read_line", io.read_line),
+            "read_int": NativeFn("io.read_int", io.read_int),
+            "read_str": NativeFn("io.read_str", io.read_str),
+            "write": NativeFn("io.write", io.write),
+            "writeln": NativeFn("io.writeln", io.writeln),
+            "flush": NativeFn("io.flush", io.flush),
+        },
+    }

jsharp-0.1.0/src/jsharp/bytecode.py

@@ -0,0 +1,55 @@
+"""Bytecode container and disassembler for J# VM."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class Instruction:
+    op: str
+    arg: Any = None
+    line: int = 0
+
+
+class Chunk:
+    def __init__(self) -> None:
+        self.code: list[Instruction] = []
+        self.consts: list[Any] = []
+
+    def add_const(self, value: Any) -> int:
+        self.consts.append(value)
+        return len(self.consts) - 1
+
+    def emit(self, op: str, arg: Any = None, line: int = 0) -> int:
+        self.code.append(Instruction(op=op, arg=arg, line=line))
+        return len(self.code) - 1
+
+    def patch(self, index: int, arg: Any) -> None:
+        self.code[index].arg = arg
+
+    def disassemble(self, fn_name: str = "<fn>") -> str:
+        def fmt_const(value: Any) -> str:
+            # Keep disassembly stable even for function object constants.
+            if hasattr(value, "name") and hasattr(value, "chunk"):
+                return f"<fn {getattr(value, 'name', '?')}>"
+            return repr(value)
+
+        lines = [f"== Function {fn_name} ==", "Constants:"]
+        if not self.consts:
+            lines.append("  <none>")
+        else:
+            for i, c in enumerate(self.consts):
+                lines.append(f"  [{i}] {fmt_const(c)}")
+
+        lines.append("Code:")
+        for i, ins in enumerate(self.code):
+            if ins.arg is None:
+                lines.append(f"  {i:04d} {ins.op}")
+            elif ins.op == "CONST" and isinstance(ins.arg, int) and 0 <= ins.arg < len(self.consts):
+                lines.append(f"  {i:04d} {ins.op} {ins.arg}    ; {fmt_const(self.consts[ins.arg])}")
+            else:
+                lines.append(f"  {i:04d} {ins.op} {ins.arg}")
+
+        return "\n".join(lines)