cpyte 4.2.2__tar.gz → 4.2.3__tar.gz

{cpyte-4.2.2/source/cpyte.egg-info → cpyte-4.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cpyte
-Version: 4.2.2
+Version: 4.2.3
 Summary: The Cpyte programming language compiler
 Author: Hoang Duy Tung
 License: MIT

cpyte-4.2.3/source/cpyte/__init__.py

@@ -0,0 +1,143 @@
+__version__ = "4.2.3"
+
+# ---------------------------------------------------------------------------
+# Public library API.
+#
+# Consumers should import ONLY the ``cpyte`` package and use these entry
+# points (``import cpyte; cpyte.parse_and_analyze(...)``) instead of reaching
+# into ``cpyte.astparse`` / ``cpyte.lexar`` / ``cpyte.semantic_analasis`` /
+# ``cpyte.bytecoding`` / ``cpyte.compiling`` internals.  Everything here is an
+# additive re-export or thin wrapper: compiler behavior is unchanged.
+# ---------------------------------------------------------------------------
+
+from . import astparse, bytecoding, compiling, lexar, mainpie, semantic_analasis, ui
+
+
+class CpyteCompileError(Exception):
+    """Raised by the high-level library entry points on parse / analyze /
+    codegen failure (library calls never ``sys.exit``)."""
+
+
+def parse_and_analyze(
+    source,
+    *,
+    tab_size=4,
+    strict=False,
+    enable_extensions=True,
+    no_gc=False,
+    filepath=None,
+    workspace_root=None,
+):
+    """Lex + parse + semantically analyze ``source``.
+
+    Returns ``(parsed, generic_instantiations, warnings_txt)`` or raises
+    :class:`CpyteCompileError`.  Loads workspace package manifests when
+    extensions are enabled (same behavior as ``cpy build``).
+    """
+    if workspace_root is None:
+        workspace_root = mainpie._find_workspace_root(filepath)
+    if enable_extensions:
+        mainpie._load_package_manifests_from_source(workspace_root)
+    lex = lexar.Lexer(source, tab_size=tab_size, enable_extensions=enable_extensions)
+    tokens = lex.get_tokens()
+    try:
+        parsed, _ = astparse.parse_file(tokens, enable_extensions=enable_extensions)
+    except (lexar.LexerError, astparse.ParseError) as e:
+        raise CpyteCompileError(f"parse error: {e}") from e
+    result, warnings_txt, generic_instantiations = semantic_analasis.analyze(
+        source,
+        parsed,
+        strict=strict,
+        workspace_root=workspace_root,
+        filepath=filepath,
+        enable_extensions=enable_extensions,
+        no_gc=no_gc,
+    )
+    if result:
+        raise CpyteCompileError(str(result).rstrip())
+    return parsed, generic_instantiations, warnings_txt
+
+
+def emit_program(
+    parsed,
+    *,
+    generic_instantiations=None,
+    no_userspace=False,
+    enable_extensions=True,
+    no_gc=False,
+    use_native_eh=False,
+    debug_instrument=False,
+    debug_nids=None,
+    debug_step_ids=None,
+):
+    """Emit LLVM IR for a parsed module.
+
+    Returns ``(module, src_files, emitter)``; the emitter carries the
+    ``_dbg_*`` debug metadata (tracer symbols, box slots/types) when
+    ``debug_instrument`` is enabled.  Raises :class:`CpyteCompileError` on
+    codegen failure.
+    """
+    c = bytecoding.LLVM(
+        no_userspace=no_userspace,
+        enable_extensions=enable_extensions,
+        no_gc=no_gc,
+        use_native_eh=use_native_eh,
+        debug_instrument=debug_instrument,
+        debug_nids=debug_nids,
+        debug_step_ids=debug_step_ids,
+    )
+    c.generic_instantiations = generic_instantiations or {}
+    try:
+        prog, src_files = c.emit_program(parsed)
+    except Exception as e:
+        raise CpyteCompileError(f"codegen error: {type(e).__name__}: {e}") from e
+    return prog, src_files, c
+
+
+# -- low-level re-exports (the whole compiler usable from one package) ------
+from .astparse import (  # noqa: F401
+    Assert,
+    Assign,
+    Break,
+    Call,
+    ClassDef,
+    Continue,
+    DeferStmt,
+    DelStmt,
+    EnumDef,
+    ExprStmt,
+    FuncDef,
+    If,
+    Import,
+    ParseError,
+    Print,
+    Raise,
+    Return,
+    StructDef,
+    Switch,
+    Try,
+    TypeAlias,
+    VarDecl,
+    While,
+    parse_file,
+)
+from .bytecoding import LLVM  # noqa: F401
+from .compiling import (  # noqa: F401
+    Linker,
+    LinkerNotFoundError,
+    host_target,
+    run_aot,
+    run_jit,
+)
+from .compiling import _host_default_pic as host_default_pic
+from .lexar import Lexer, LexerError  # noqa: F401
+from .mainpie import (  # noqa: F401
+    _collect_frameworks as collect_frameworks,
+)
+from .mainpie import (
+    _detect_nogc as detect_nogc,
+)
+from .mainpie import (
+    _find_workspace_root as find_workspace_root,
+)
+from .semantic_analasis import analyze  # noqa: F401

{cpyte-4.2.2 → cpyte-4.2.3}/source/cpyte/_bignum_bc.py

@@ -1,6 +1,7 @@
-import base64, zlib
-from llvmlite import binding
+import base64
+import zlib
 
+from llvmlite import binding
 
 _B64 = (
     "eJztvQ1YE1f6N3wmk8wMISQDggZJcIJo8ZMIqOFDOyGo6NrdiLZLW1sSBMUWNXyoaNnuJAGClrbRsl26"

{cpyte-4.2.2 → cpyte-4.2.3}/source/cpyte/_runtime_bc.py

@@ -1,6 +1,7 @@
-import base64, zlib
-from llvmlite import binding
+import base64
+import zlib
 
+from llvmlite import binding
 
 _B64 = (
     "eJzsvX9AVGX2P/7cuTP3XoZh5gIDDjLAHQQb8deAv0CQ7syAobk2KpWZ5YBgWGojoiLr1p0f/BDJHY2M"

{cpyte-4.2.2 → cpyte-4.2.3}/source/cpyte/astparse.py

@@ -142,7 +142,14 @@ class ListLit(Node):
 
 
 class Call(Node):
-    __slots__ = ("_token", "args", "callee", "inferred_type", "param_types")
+    __slots__ = (
+        "_token",
+        "args",
+        "callee",
+        "inferred_type",
+        "param_types",
+        "meta",
+    )
 
     def __init__(self, callee, args: list, token=None):
         self.callee = callee
@@ -150,6 +157,7 @@ class Call(Node):
         self._token = token
         self.inferred_type = None
         self.param_types = None
+        self.meta = None
 
     def __repr__(self):
         return f"Call({self.callee}, {self.args})"
@@ -1185,6 +1193,8 @@ def _parse_standard_statement(tokens: list[Token], pos: int):
         node, pos = parse_break(tokens, pos)
     elif tok.type == TokenType.KEYWORD and tok.value == "continue":
         node, pos = parse_continue(tokens, pos)
+    elif tok.type == TokenType.KEYWORD and tok.value == "del":
+        node, pos = parse_del(tokens, pos)
     elif tok.type == TokenType.KEYWORD and tok.value == "assert":
         node, pos = parse_assert(tokens, pos)
     elif tok.type == TokenType.KEYWORD and tok.value == "asm":
@@ -1987,6 +1997,26 @@ class DeferStmt(Node):
         return f"DeferStmt({self.body!r})"
 
 
+class DelStmt(Node):
+    """`del <target>` — unbind a variable or clear a runtime slot.
+
+    Static locals are removed from the compiler scope (later uses become
+    compile errors); dynamic/arena variables are marked deleted at runtime
+    (kind DYN_NONE); heap pointers from `new`/`malloc` are freed; and
+    `del obj.field` / `del arr[i]` / `del *p` clear the addressed slot.
+    """
+
+    __slots__ = ("_token", "target", "del_kind")
+
+    def __init__(self, target, token=None):
+        self.target = target
+        self._token = token
+        self.del_kind = None  # "static" | "dynamic" | "heap" | "slot", set by semantic
+
+    def __repr__(self):
+        return f"DelStmt({self.target!r})"
+
+
 class StructDef(Node):
     __slots__ = ("_token", "fields", "generic_params", "name")
 
@@ -2502,12 +2532,25 @@ def parse_defer(tokens: list[Token], pos: int):
     return DeferStmt(stmt, token=tok), pos
 
 
+def parse_del(tokens: list[Token], pos: int):
+    tok = tokens[pos]  # 'del'
+    pos += 1
+    if pos >= len(tokens):
+        raise ParseError("Expected an expression after `del`", tok)
+    target, pos = parse_expression(tokens, pos)
+    _expect_newline(tokens, pos, tok)
+    return DelStmt(target, token=tok), pos
+
+
 def parse_statement(tokens: list[Token], pos: int):
     if pos >= len(tokens):
         return None, pos
 
     tok = tokens[pos]
 
+    if tok.type == TokenType.KEYWORD and tok.value == "del":
+        return parse_del(tokens, pos)
+
     if tok.type == TokenType.KEYWORD and tok.value == "return":
         return parse_return(tokens, pos)