cpyte 4.3.2__tar.gz → 4.4.0__tar.gz

{cpyte-4.3.2/source/cpyte.egg-info → cpyte-4.4.0}/PKG-INFO

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

{cpyte-4.3.2 → cpyte-4.4.0}/source/cpyte/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "4.3.2"
+__version__ = "4.4.0"
 
 # ---------------------------------------------------------------------------
 # Public library API.

{cpyte-4.3.2 → cpyte-4.4.0}/source/cpyte/bytecoding.py

@@ -261,6 +261,12 @@ class LLVM:
             # i32 fallthrough) lets `(size_t)ptr`/`(ptr)(size_t)` round-trips
             # preserve the full address instead of truncating to 32 bits.
             result = ir.IntType(64)
+        elif t in ("uint8", "char"):
+            result = ir.IntType(8)
+        elif t == "uint16":
+            result = ir.IntType(16)
+        elif t in ("uint32", "unsigned"):
+            result = ir.IntType(32)
         elif t == "bool":
             result = ir.IntType(1)
         elif t in ("float", "double"):
@@ -269,8 +275,6 @@ class LLVM:
             result = ir.VoidType()
         elif t == "str":
             result = ir.PointerType(ir.IntType(8))
-        elif t == "char":
-            result = ir.IntType(8)
         elif t == "void*" or t == "big" or t == "ubig":
             result = ir.PointerType(ir.IntType(8))
         elif t == "dynamic":
@@ -674,9 +678,11 @@ class LLVM:
         debug_instrument=False,
         debug_nids=None,
         debug_step_ids=None,
+        scorpion=False,
     ):
         self.module = ir.Module("main")
         self.no_gc = no_gc
+        self.scorpion = scorpion
         self.use_native_eh = use_native_eh
         # --- cpdb debug instrumentation (opt-in, off by default) -------------
         # When enabled, the emitter emits one `cpdbd_t_<nid>` tracer per step
@@ -813,6 +819,9 @@ class LLVM:
             input_str_fn = ir.Function(self.module, input_str_ty, "input_str")
             self.functions["input_str"] = input_str_fn
 
+        if self.scorpion:
+            self._declare_scorpion_abi()
+
         # BigNum runtime functions
         bignum_fns = [
             ("bigint_new", _i8ptr, []),
@@ -986,6 +995,38 @@ class LLVM:
         )
         self._code_skip.initializer = ir.Constant(ir.IntType(1), 0)  # type: ignore[attr-defined]
 
+    def _declare_scorpion_abi(self):
+        """Declare the Scorpion ABI wrappers and register `ScorpionLibInfo`.
+
+        Enabled by the `#scorpion` source directive. Each wrapper is an extern
+        resolved by `runtime_scorpion.c`, which ships the same `ecall`
+        encoding the Xtensa-only inline wrappers in `abi/scorpion.h` use (the
+        `a0`-`a7` register names are the RISC-V argument registers too, so the
+        ABI is identical on both architectures).
+
+        `ScorpionLibInfo` is materialized here rather than as a parsed
+        StructDef because it has no node in the AST: the kernel writes the
+        exact 32-byte layout through `scorpion_lib_info()`, so the `uint16`
+        tail must really be i16 (seven i32 + two i16, no padding).
+        """
+        from . import scorpion_abi
+
+        st = self.module.context.get_identified_type(
+            f"struct.{scorpion_abi.LIB_INFO_NAME}"
+        )
+        if st.is_opaque:
+            st.set_body(*[self.llvm_type(t) for _, t in scorpion_abi.LIB_INFO_FIELDS])
+        self.structs[scorpion_abi.LIB_INFO_NAME] = st
+        self.struct_fields[scorpion_abi.LIB_INFO_NAME] = scorpion_abi.lib_info_fields()
+
+        for name, (ret_type, params, vararg) in scorpion_abi.FUNCTIONS.items():
+            fnty = ir.FunctionType(
+                self.llvm_type(ret_type),
+                [self.llvm_type(t) for _, t in params],
+                var_arg=vararg,
+            )
+            self.functions[name] = ir.Function(self.module, fnty, name)
+
     # CRITICAL CONSTANT FOLDING BUG
     def _isolate_const_prop_branch(self, body):
         """Run one control-flow branch with isolated constant propagation.
@@ -1451,8 +1492,17 @@ class LLVM:
 
         if os.environ.get("CPYTE_JIT_DEBUG"):
             import sys as _sys
-            print("[bytecoding] runtime hooks:", [h.name for h in self._hook_registry.get(HookStage.RUNTIME)], file=_sys.stderr)
-            print("[bytecoding] import_src_files:", self.import_src_files, file=_sys.stderr)
+
+            print(
+                "[bytecoding] runtime hooks:",
+                [h.name for h in self._hook_registry.get(HookStage.RUNTIME)],
+                file=_sys.stderr,
+            )
+            print(
+                "[bytecoding] import_src_files:",
+                self.import_src_files,
+                file=_sys.stderr,
+            )
 
         for node in structs:
             if isinstance(node, ClassDef):
@@ -1638,25 +1688,20 @@ class LLVM:
             name = target.name
             if name in self.locals:
                 ptr = self.locals[name]
-                if not isinstance(
-                    getattr(ptr.type, "pointee", None), ir.PointerType
-                ):
-                    self.builder.store(
-                        ir.Constant(ptr.type.pointee, None), ptr
-                    )
+                if not isinstance(getattr(ptr.type, "pointee", None), ir.PointerType):
+                    self.builder.store(ir.Constant(ptr.type.pointee, None), ptr)
             for table in (self.locals, self.local_types, self.ssa_values):
                 table.pop(name, None)
             self.const_vars.pop(name, None)
             return
         if kind == "dynamic":
             name = target.name
-            if name in self.locals and getattr(
-                self.locals[name].type, "pointee", None
-            ) == _DynValue:
+            if (
+                name in self.locals
+                and getattr(self.locals[name].type, "pointee", None) == _DynValue
+            ):
                 zero = ir.Constant(_DynValue, ir.Undefined)
-                zero = self.builder.insert_value(
-                    zero, ir.Constant(_i32, _DYN_NONE), 0
-                )
+                zero = self.builder.insert_value(zero, ir.Constant(_i32, _DYN_NONE), 0)
                 zero = self.builder.insert_value(zero, ir.Constant(_i64, 0), 1)
                 self.builder.store(zero, self.locals[name])
             else:
@@ -2075,18 +2120,14 @@ class LLVM:
             index_fields = [Field("@vptr", "void*", token=node._token)] + all_fields
         field_tys = [self.llvm_type(f.type_expr) for f in index_fields]
         llvm_struct = self.structs.get(node.name)
-        if llvm_struct is None or not isinstance(
-            llvm_struct, ir.IdentifiedStructType
-        ):
+        if llvm_struct is None or not isinstance(llvm_struct, ir.IdentifiedStructType):
             # Pre-register an opaque identified struct BEFORE resolving field
             # types so self-referential fields resolve to a pointer to this
             # type instead of silently degrading to `i32`. get_identified_type
             # registers into the module's context so the definition is
             # serialized into the IR. Fieldless sealed classes still register
             # (as an empty struct) so `new T` can allocate them.
-            llvm_struct = self.module.context.get_identified_type(
-                f"class.{node.name}"
-            )
+            llvm_struct = self.module.context.get_identified_type(f"class.{node.name}")
             self.structs[node.name] = llvm_struct
         if field_tys or index_fields:
             if llvm_struct.is_opaque:
@@ -2141,9 +2182,7 @@ class LLVM:
                             wb.ret(ret)
                         self.functions[child_name] = wrapper
 
-    def _declare_class_method(
-        self, class_node: ClassDef, method: FuncDef
-    ):
+    def _declare_class_method(self, class_node: ClassDef, method: FuncDef):
         """Create the `Class.method` header function if it doesn't exist yet."""
         class_ty = self.structs.get(class_node.name)
         if class_ty is None:
@@ -2197,17 +2236,13 @@ class LLVM:
         slots = self._class_slot_list(cls)
         vt_ty = ir.LiteralStructType(
             [_i64]
-            + [
-                self.functions[f"{d}.{n}"].function_type.as_pointer()
-                for n, d in slots
-            ]
+            + [self.functions[f"{d}.{n}"].function_type.as_pointer() for n, d in slots]
         )
         cid = self._class_ids.setdefault(cls, len(self._class_ids))
         cv = ir.GlobalVariable(self.module, vt_ty, name=f"vt.{cls}")
         cv.initializer = ir.Constant(
             vt_ty,
-            [ir.Constant(_i64, cid)]
-            + [self.functions[f"{d}.{n}"] for n, d in slots],
+            [ir.Constant(_i64, cid)] + [self.functions[f"{d}.{n}"] for n, d in slots],
         )
         self._vt_types[cls] = vt_ty
         self._vt_globals[cls] = cv
@@ -2356,7 +2391,9 @@ class LLVM:
                 for i, arg in enumerate(node.args or []):
                     init_args.append(
                         self._coerce_call_arg(
-                            self.emit(arg), ptypes[i + 1], getattr(arg, "inferred_type", None)
+                            self.emit(arg),
+                            ptypes[i + 1],
+                            getattr(arg, "inferred_type", None),
                         )
                     )
                 self.builder.call(init_fn, init_args)
@@ -2694,7 +2731,9 @@ class LLVM:
             obj_decl = obj_decl or getattr(node.obj, "inferred_type", None)
             if not (obj_decl and str(obj_decl).endswith("[]")):
                 call = Call(
-                    Attr(node.obj, "__getitem__", token=getattr(node.obj, "_token", None)),
+                    Attr(
+                        node.obj, "__getitem__", token=getattr(node.obj, "_token", None)
+                    ),
                     [node.index],
                     token=node._token,
                 )
@@ -4629,7 +4668,9 @@ class LLVM:
         typed class pointers and integer/fp literals."""
         if isinstance(expected, ir.PointerType):
             if isinstance(val.type, ir.PointerType):
-                return self.builder.bitcast(val, expected) if val.type != expected else val
+                return (
+                    self.builder.bitcast(val, expected) if val.type != expected else val
+                )
             if isinstance(val.type, ir.IntType):
                 return self.builder.inttoptr(val, expected)
             return val
@@ -4640,7 +4681,9 @@ class LLVM:
                         return self.builder.sext(val, expected)
                     return self.builder.trunc(val, expected)
                 return val
-            if isinstance(val.type, ir.DoubleType) or isinstance(val.type, ir.FloatType):
+            if isinstance(val.type, ir.DoubleType) or isinstance(
+                val.type, ir.FloatType
+            ):
                 return self.builder.fptosi(val, expected)
             if isinstance(val.type, ir.PointerType) and expected.width >= 32:
                 return self.builder.ptrtoint(val, expected)
@@ -5731,7 +5774,8 @@ class LLVM:
                     for arg in node.args:
                         arg_val = self.emit(arg)
                         arg_val = self._coerce_call_arg(
-                            arg_val, slot_fnty.args[len(args)],
+                            arg_val,
+                            slot_fnty.args[len(args)],
                             getattr(arg, "inferred_type", None),
                         )
                         args.append(arg_val)
@@ -5760,7 +5804,8 @@ class LLVM:
                     for arg in node.args:
                         arg_val = self.emit(arg)
                         arg_val = self._coerce_call_arg(
-                            arg_val, func.function_type.args[len(args)],
+                            arg_val,
+                            func.function_type.args[len(args)],
                             getattr(arg, "inferred_type", None),
                         )
                         args.append(arg_val)
@@ -5859,10 +5904,7 @@ class LLVM:
             dunder_cls = node.callee._dunder_via
             if dunder_cls is None:
                 dunder_cls = self._static_obj_class(node.callee)
-            if (
-                dunder_cls
-                and self._dunder_fn_name(dunder_cls, "__call__") is not None
-            ):
+            if dunder_cls and self._dunder_fn_name(dunder_cls, "__call__") is not None:
                 call = Call(
                     Attr(node.callee, "__call__", token=node.callee._token),
                     node.args,
@@ -6238,9 +6280,7 @@ class LLVM:
             for f in fields:
                 fname = self._string_const(f.name)
                 cmp_res = self.builder.call(self._strcmp_fn, [name_val, fname])
-                match = self.builder.icmp_signed(
-                    "==", cmp_res, ir.Constant(_i32, 0)
-                )
+                match = self.builder.icmp_signed("==", cmp_res, ir.Constant(_i32, 0))
                 result = self.builder.or_(result, match)
             return result
         if kind == "get_attr_lit":
@@ -6259,12 +6299,8 @@ class LLVM:
             for i, f in enumerate(fields):
                 fname = self._string_const(f.name)
                 cmp_res = self.builder.call(self._strcmp_fn, [name_val, fname])
-                match = self.builder.icmp_signed(
-                    "==", cmp_res, ir.Constant(_i32, 0)
-                )
-                idx = self.builder.select(
-                    match, ir.Constant(_i32, i), idx
-                )
+                match = self.builder.icmp_signed("==", cmp_res, ir.Constant(_i32, 0))
+                idx = self.builder.select(match, ir.Constant(_i32, i), idx)
             struct_start = self.builder.gep(
                 obj_ptr,
                 [ir.Constant(_i32, 0), ir.Constant(_i32, 0)],
@@ -6289,9 +6325,7 @@ class LLVM:
         if getattr(self, "_ancestor_grid_emitted", False):
             return
         self._ancestor_grid_emitted = True
-        classes = [
-            c for c, n in self._struct_nodes.items() if isinstance(n, ClassDef)
-        ]
+        classes = [c for c, n in self._struct_nodes.items() if isinstance(n, ClassDef)]
         chains = {}
         for c in classes:
             cur = self._struct_nodes.get(c)
@@ -6359,13 +6393,9 @@ class LLVM:
             self.builder.mul(rcid, ir.Constant(_i64, stride)),
             ir.Constant(_i64, depth_t),
         )
-        row = self.builder.gep(
-            grid, [ir.Constant(_i32, 0), off], inbounds=True
-        )
+        row = self.builder.gep(grid, [ir.Constant(_i32, 0), off], inbounds=True)
         anc = self.builder.load(row)
-        return self.builder.icmp_signed(
-            "==", anc, ir.Constant(_i64, id_t)
-        )
+        return self.builder.icmp_signed("==", anc, ir.Constant(_i64, id_t))
 
     def _emit_builtin_append(self, node):
         """append(arr, x) — grow a registered array by one element.
@@ -6941,7 +6971,6 @@ class LLVM:
         self._const_prop_f = saved_f
 
     def _emit_for_worker(self, node, var_name, iterable, body, iter_type, var_type):
-
         # ---- 3.  Bounded loop unrolling for constant-size list literals ----
         if (
             isinstance(iterable, ListLit)

{cpyte-4.3.2 → cpyte-4.4.0}/source/cpyte/compiling.py

@@ -1677,9 +1677,14 @@ def _map_process_libc(engine, mod):
                     pass
                 break
     if os.environ.get("CPYTE_JIT_DEBUG"):
-        unset = [f.name for f in mod.functions if f.is_declaration
-                 and not f.name.startswith("llvm.") and f.name not in mapped
-                 and f.name not in _explicit_mapped]
+        unset = [
+            f.name
+            for f in mod.functions
+            if f.is_declaration
+            and not f.name.startswith("llvm.")
+            and f.name not in mapped
+            and f.name not in _explicit_mapped
+        ]
         if unset:
             print("[jit] unresolved externs: %s" % sorted(unset), file=sys.stderr)
 
@@ -1817,7 +1822,9 @@ def _scorpion_tool(name):
     if os.path.isfile(bundled):
         return bundled
     sibling = os.path.join(
-        os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(_RUNTIME_SCORPION_C)))),
+        os.path.dirname(
+            os.path.dirname(os.path.dirname(os.path.dirname(_RUNTIME_SCORPION_C)))
+        ),
         "WEW-scorpion",
         "tools" if name == "elf2sef.py" else "user",
         name,
@@ -1833,6 +1840,11 @@ def run_scorpion(
     pic=False,
     exports=None,
     auto_exports=None,
+    requires=None,
+    scopes=None,
+    weaks=None,
+    lazy=None,
+    versym=None,
 ):
     """Compile a Cpyte module for Scorpion (RV32 bare-metal) producing a SEF file.
     Please use it good! :):)
@@ -1840,11 +1852,20 @@ def run_scorpion(
     With pic=True the module is compiled with -fPIC and the final ELF is linked
     with --emit-relocs so it can be converted to a dynamic (SEF v2) image via
     WEW-scorpion/tools/elf2sef.py. `exports` names the symbols to mark as
-    exported for dynamic linking (libraries). `auto_exports` are additional
-    candidates discovered automatically (top-level `public` functions); only
-    those that actually resolve to a defined symbol in the emitted module are
-    added (elf2sef refuses unknown names). Returns (elf_file, [final exports])
-    so callers can report exactly what was published.
+    exported for dynamic linking (libraries); an entry is either `NAME` or
+    elf2sef's `SYMBOL=WIRE_NAME` form to publish SYMBOL under a different wire
+    name. `auto_exports` are additional candidates discovered automatically
+    (top-level `public` functions); only those that actually resolve to a
+    defined symbol in the emitted module are added (elf2sef refuses unknown
+    names).
+
+    `requires` (`NAME=VER`), `scopes`, `weaks`, `lazy` and `versym` are the
+    remaining elf2sef dynamic-linking controls, forwarded verbatim; see
+    WEW-scorpion/docs/dynamic-linking.md. `lazy`/`versym` are tri-state (None
+    = leave elf2sef's default). They only apply to the pic path.
+
+    Returns (elf_file, [final exports]) so callers can report exactly what was
+    published.
     """
     from llvmlite import binding
 
@@ -1858,9 +1879,7 @@ def run_scorpion(
     optimize(mod, opt_level)
     mod.verify()
 
-    defined = {
-        f.name for f in mod.functions if not getattr(f, "is_declaration", True)
-    }
+    defined = {f.name for f in mod.functions if not getattr(f, "is_declaration", True)}
     final_exports = list(exports or [])
     seen = set(final_exports)
     if auto_exports:
@@ -1941,6 +1960,28 @@ def run_scorpion(
         if final_exports:
             for name in final_exports:
                 cmd += ["--export", name]
+        # elf2sef rejects --no-versym together with --lazy (a v2.0 import record
+        # has no plt field, so a lazy site would point into an unresolvable
+        # hole). Surface that here instead of as a subprocess error.
+        if versym is False and lazy:
+            print_err(
+                "error: --no-versym cannot be combined with --lazy "
+                "(a v2.0 import record has no plt field)"
+            )
+            raise SystemExit(1)
+        for req in requires or ():
+            cmd += ["--require", req]
+        for scope in scopes or ():
+            cmd += ["--scope", scope]
+        for weak in weaks or ():
+            cmd += ["--weak", weak]
+        if lazy is not None:
+            cmd.append("--lazy" if lazy else "--no-lazy")
+        # elf2sef has no `--versym`: wide (v2.1) records are the default and
+        # only the downgrade is selectable. So `--versym` is an explicit
+        # restatement of the default and forwards nothing.
+        if versym is False:
+            cmd.append("--no-versym")
         r = subprocess.run(cmd, capture_output=True, text=True)
         if r.returncode != 0:
             print_err(f"error converting to SEF: {format_cc_diag(r.stderr)}")

{cpyte-4.3.2 → cpyte-4.4.0}/source/cpyte/lsp_server.py

@@ -11,14 +11,12 @@ from pygls.cli import start_server
 from pygls.lsp.server import LanguageServer
 
 from .astparse import (
-    Assign,
     Call,
     ClassDef,
     EnumDef,
     FuncDef,
     If,
     Import,
-    NewExpr,
     ParseError,
     StructDef,
     Switch,
@@ -31,6 +29,7 @@ from .astparse import (
 from .formatter import format_source
 from .lexar import Lexer, LexerError, TokenType
 from .semantic_analasis import SemanticAnalyzer
+from . import scorpion_abi
 from .clib import _BUILTIN_LIB_HEADERS
 
 logging.basicConfig(level=logging.INFO, format="%(message)s")
@@ -282,7 +281,10 @@ def _analyze(source, filepath=None, workspace_root=None):
             return tokens, parsed, analyzer, error
         try:
             analyzer = SemanticAnalyzer(
-                source, filepath=filepath, workspace_root=workspace_root
+                source,
+                filepath=filepath,
+                workspace_root=workspace_root,
+                scorpion=scorpion_abi.detect(source)[1],
             )
             analyzer.analyze(parsed)
         except Exception as e: