codecin 5.4.2__py3-none-any.whl

codecin/native/go.mod

@@ -0,0 +1,3 @@
+module codecin-native
+
+go 1.26

codecin/native/ir/ir.go

@@ -0,0 +1,48 @@
+// Package ir 定义 Code CIN 字节码中间表示 (IR)。
+//
+// 该 IR 与 Python codecin 侧 CINCompiler 产出的结构完全等价:
+//
+//	指令 = (opcode 名, 操作数列表); 操作数用 Kind 区分 (reg/imm/mem/label/cond/float/str)。
+//
+// 编译器 (compiler 包) 产出 *Program, engine 包将其编码为 UCBC 字节码后交由 VM 执行。
+package ir
+
+// Operand 表示一条指令的操作数。
+type Operand struct {
+	Kind string  // reg / imm / mem / label / cond / float / str / vec / veclane
+	V    int64   // reg 号 / imm 值 / mem base(-1=绝对地址) / str 地址 / vec 号
+	Off  int64   // mem 偏移 / veclane
+	Name string  // label 名 / cond 名
+	F    float64 // float 值
+}
+
+// Instr 是一条 IR 指令。
+type Instr struct {
+	Op   string
+	Args []Operand
+}
+
+// DataWrite 是一次数据段写入 (地址 + 字节)。
+type DataWrite struct {
+	Addr int
+	Data []byte
+}
+
+// Program 是编译产物: 指令流 + 标签 + 数据段写入。
+type Program struct {
+	Instructions []Instr
+	Labels       map[string]int
+	DataLabels   map[string]int
+	DataWrites   []DataWrite
+}
+
+// 操作数构造辅助 (与编译器共享书写习惯)。
+func Reg(n int) Operand   { return Operand{Kind: "reg", V: int64(n)} }
+func Imm(v int64) Operand { return Operand{Kind: "imm", V: v} }
+func Mem(base, off int) Operand {
+	return Operand{Kind: "mem", V: int64(base), Off: int64(off)}
+}
+func Label(name string) Operand { return Operand{Kind: "label", Name: name} }
+func Cond(name string) Operand  { return Operand{Kind: "cond", Name: name} }
+func Float(f float64) Operand   { return Operand{Kind: "float", F: f} }
+func Str(addr int) Operand      { return Operand{Kind: "str", V: int64(addr)} }

codecin/native/main.go

@@ -0,0 +1,225 @@
+package main
+
+/*
+#include <stdlib.h>
+*/
+import "C"
+
+import (
+	"encoding/binary"
+	"fmt"
+	"sync"
+	"unsafe"
+
+	"codecin-native/engine"
+)
+
+// 结果结构布局 (与 codecin/native.py _parse_result 严格一致):
+//   status u8 + 3B pad
+//   pc u64  sp u64  heap_ptr u64  steps u64
+//   regs 33×u64
+//   vec  32×4×f64
+//   mem_len u64 | mem ...
+//   out_len u64 | out ...
+//   err_len u16 | err ...
+
+// buildVersion 由构建时注入: -ldflags "-X main.buildVersion=<版本>"
+// (install.sh / install.ps1 / build.ps1 会传入 codecin 包版本)。
+var buildVersion = "dev"
+
+// marshalResult 把执行结果序列化为 ABI 缓冲。
+// mem 为执行后的内存镜像; panic 降级路径传 nil (调用方按 mem_len=0 处理)。
+func marshalResult(res *engine.Result, mem []byte,
+	sp0, heap0 int64) unsafe.Pointer {
+
+	const regBytes = 33 * 8
+	const vecBytes = 32 * 4 * 8
+
+	status := engine.StatusError
+	pc := 0
+	sp := uint64(sp0)
+	heap := uint64(heap0)
+	var steps uint64
+	var regs [33]uint64
+	out := []byte{}
+	errb := []byte{}
+	if res != nil {
+		status = res.Status
+		pc = res.Pc
+		sp = res.Sp
+		heap = res.HeapPtr
+		steps = res.Steps
+		regs = res.Regs
+		out = []byte(res.Output)
+		errb = []byte(res.ErrMsg)
+	}
+
+	total := 36 + regBytes + vecBytes + 8 + len(mem) + 8 + len(out) + 2 + len(errb)
+	buf := make([]byte, total)
+
+	buf[0] = byte(status)
+	pos := 4
+	binary.LittleEndian.PutUint64(buf[pos:], uint64(pc))
+	binary.LittleEndian.PutUint64(buf[pos+8:], sp)
+	binary.LittleEndian.PutUint64(buf[pos+16:], heap)
+	binary.LittleEndian.PutUint64(buf[pos+24:], steps)
+	pos = 36 // 状态头 36 字节: status+pad(4) + 4×u64(32)
+	for i := 0; i < 33; i++ {
+		binary.LittleEndian.PutUint64(buf[pos+i*8:], regs[i])
+	}
+	pos += regBytes
+	pos += vecBytes // 向量区保持 0
+	binary.LittleEndian.PutUint64(buf[pos:], uint64(len(mem)))
+	pos += 8
+	copy(buf[pos:], mem)
+	pos += len(mem)
+	binary.LittleEndian.PutUint64(buf[pos:], uint64(len(out)))
+	pos += 8
+	copy(buf[pos:], out)
+	pos += len(out)
+	binary.LittleEndian.PutUint16(buf[pos:], uint16(len(errb)))
+	pos += 2
+	copy(buf[pos:], errb)
+
+	cbuf := C.malloc(C.size_t(total))
+	if cbuf == nil {
+		return nil
+	}
+	copy(unsafe.Slice((*byte)(cbuf), total), buf)
+	return cbuf
+}
+
+// errResult 是 panic / 参数非法时的降级结果 (仍返回合法缓冲, 供 Python 解析)。
+func errResult(msg string, sp0, heap0 int64) unsafe.Pointer {
+	return marshalResult(&engine.Result{
+		Status:  engine.StatusError,
+		ErrMsg:  msg,
+		Sp:      uint64(sp0),
+		HeapPtr: uint64(heap0),
+	}, nil, sp0, heap0)
+}
+
+//export codecin_run
+func codecin_run(bcPtr unsafe.Pointer, bcLen C.int,
+	memPtr unsafe.Pointer, memLen C.int,
+	entry C.longlong, sp C.longlong, heapBase C.longlong,
+	inPtr unsafe.Pointer, inLen C.int,
+	maxSteps C.longlong) (ret unsafe.Pointer) {
+
+	// panic 不得跨越 CGO 边界: Go 运行时会把未捕获 panic 当作致命错误直接
+	// 终止宿主进程 (Python 无法拦截)。这里降级为"一次调用返回错误结果"。
+	defer func() {
+		if r := recover(); r != nil {
+			ret = errResult(fmt.Sprintf("native panic: %v", r),
+				int64(sp), int64(heapBase))
+		}
+	}()
+
+	if bcLen < 0 || memLen < 0 || inLen < 0 {
+		return errResult("native: negative buffer length",
+			int64(sp), int64(heapBase))
+	}
+
+	var bc, mem []byte
+	if bcPtr != nil && bcLen > 0 {
+		bc = C.GoBytes(bcPtr, bcLen)
+	}
+	if memPtr != nil && memLen > 0 {
+		mem = C.GoBytes(memPtr, memLen)
+	}
+	in := []byte{}
+	if inPtr != nil && inLen > 0 {
+		in = C.GoBytes(inPtr, inLen)
+	}
+
+	res := engine.Run(bc, mem, int64(entry), int64(sp), int64(heapBase),
+		in, int64(maxSteps))
+	return marshalResult(res, mem, int64(sp), int64(heapBase))
+}
+
+//export codecin_free
+func codecin_free(ptr unsafe.Pointer) {
+	if ptr != nil {
+		C.free(ptr)
+	}
+}
+
+//export codecin_crom_pack
+func codecin_crom_pack(dataPtr unsafe.Pointer, dataLen C.int, compress C.int,
+	outLen *C.int) (ret unsafe.Pointer) {
+	defer func() {
+		if r := recover(); r != nil {
+			ret = nil
+		}
+	}()
+	if outLen == nil || dataLen < 0 || dataPtr == nil {
+		return nil
+	}
+	data := C.GoBytes(dataPtr, dataLen)
+	packed := engine.CromPack(data, compress != 0)
+	if packed == nil {
+		return nil
+	}
+	cbuf := C.malloc(C.size_t(len(packed)))
+	if cbuf == nil {
+		return nil
+	}
+	copy(unsafe.Slice((*byte)(cbuf), len(packed)), packed)
+	*outLen = C.int(len(packed))
+	return cbuf
+}
+
+//export codecin_crom_unpack
+func codecin_crom_unpack(dataPtr unsafe.Pointer, dataLen C.int,
+	memLen *C.int, flags *C.int) (ret unsafe.Pointer) {
+	defer func() {
+		if r := recover(); r != nil {
+			ret = nil
+		}
+	}()
+	if memLen == nil || flags == nil || dataLen < 0 || dataPtr == nil {
+		return nil
+	}
+	data := C.GoBytes(dataPtr, dataLen)
+	raw, flg, ok := engine.CromUnpack(data)
+	if !ok {
+		return nil
+	}
+	cbuf := C.malloc(C.size_t(len(raw)))
+	if cbuf == nil {
+		return nil
+	}
+	copy(unsafe.Slice((*byte)(cbuf), len(raw)), raw)
+	*memLen = C.int(len(raw))
+	*flags = C.int(flg)
+	return cbuf
+}
+
+// buildVersion 为空时使用生成器注入的 engine.BuildVersion
+// (单一事实来源: codecin/__init__.py 的 __version__)。
+func versionString() string {
+	v := buildVersion
+	if v == "" || v == "dev" {
+		v = engine.BuildVersion
+	}
+	return "codecin-native " + v + " (Go)"
+}
+
+var (
+	versionOnce sync.Once
+	versionCStr *C.char
+)
+
+// codecin_version 返回静态版本字符串。
+// 旧实现每次调用都 C.CString, 而 Python 侧以 c_char_p 取走后永不 free → 每次调用泄漏。
+// 返回的指针为进程级常量, 调用方不要 free。
+//
+//export codecin_version
+func codecin_version() *C.char {
+	versionOnce.Do(func() {
+		versionCStr = C.CString(versionString())
+	})
+	return versionCStr
+}
+
+func main() {}

codecin/native.py

@@ -0,0 +1,336 @@
+"""Go 原生库桥接 (c-shared)。
+
+通过 ctypes 加载 Go 编译的共享库 (Windows: codecin_native.dll,
+Linux/Termux: libcodecin_native.so, macOS: libcodecin_native.dylib),
+提供:
+  1. 原生字节码 VM (codecin_run)  -- 整程序高速执行
+  2. CROM 压缩/解压 (codecin_crom_pack / codecin_crom_unpack)
+
+库不存在或加载失败时所有接口返回 None, 调用方自动回退纯 Python。
+
+字节码格式 (UCBC):
+  头部: magic[4]='UCBC' version u8 entry u32 instr_count u32
+  指令: opcode u8 argc u8
+  操作数: kind u8 value i64 extra i64 (小端)
+"""
+
+import ctypes
+import os
+import platform
+import struct
+import sys
+from typing import Any, Dict, List, Optional, Tuple
+
+from .isa import (
+    BC_MAGIC,
+    BC_VERSION,
+    KIND_COND,
+    KIND_FLOAT,
+    KIND_IMM,
+    KIND_MEM,
+    KIND_REG,
+    KIND_STR,
+    KIND_VEC,
+    KIND_VECLANE,
+    Cond,
+    Constants,
+    Opcode,
+)
+
+Operand = Tuple[Any, ...]
+Instruction = Tuple[str, List[Operand]]
+
+# ==================== 字节码编解码 ====================
+
+_KIND_MAP = {
+    'reg': KIND_REG, 'imm': KIND_IMM, 'vec': KIND_VEC,
+    'veclane': KIND_VECLANE, 'mem': KIND_MEM, 'cond': KIND_COND,
+    'float': KIND_FLOAT, 'str': KIND_STR,
+}
+
+
+def encode_operand(op: Operand) -> Tuple[int, int, int]:
+    kind = _KIND_MAP.get(op[0])
+    if kind is None:
+        if op[0] == 'label':
+            return KIND_IMM, 0, 0  # 未解析标签 (不应出现)
+        raise ValueError(f"Cannot encode operand: {op}")
+    if kind == KIND_REG:
+        return kind, int(op[1]), 0
+    if kind == KIND_IMM:
+        return kind, int(op[1]) & 0xFFFFFFFFFFFFFFFF, 0
+    if kind == KIND_VEC:
+        return kind, int(op[1]), 0
+    if kind == KIND_VECLANE:
+        return kind, int(op[1]), int(op[2])
+    if kind == KIND_MEM:
+        base = op[1] if len(op) > 1 else -1
+        off = op[2] if len(op) > 2 else 0
+        return kind, int(base), int(off) & 0xFFFFFFFFFFFFFFFF
+    if kind == KIND_COND:
+        return kind, Cond.code(op[1]), 0
+    if kind == KIND_FLOAT:
+        return kind, struct.unpack('<Q', struct.pack('<d', float(op[1])))[0], 0
+    if kind == KIND_STR:
+        return kind, int(op[1]), 0
+    raise ValueError(f"Cannot encode operand: {op}")
+
+
+def _i64(v: int) -> int:
+    v &= 0xFFFFFFFFFFFFFFFF
+    return v if v < (1 << 63) else v - (1 << 64)
+
+
+def decode_operand(kind: int, value: int, extra: int) -> Operand:
+    if kind == KIND_REG:
+        return ('reg', value)
+    if kind == KIND_IMM:
+        return ('imm', value)
+    if kind == KIND_VEC:
+        return ('vec', value)
+    if kind == KIND_VECLANE:
+        return ('veclane', value, extra)
+    if kind == KIND_MEM:
+        return ('mem', value, extra)
+    if kind == KIND_COND:
+        return ('cond', Cond.NAMES[value & 15])
+    if kind == KIND_FLOAT:
+        return ('float', struct.unpack('<d', struct.pack('<q', _i64(value)))[0])
+    if kind == KIND_STR:
+        return ('str', value)
+    raise ValueError(f"Unknown operand kind: {kind}")
+
+
+def encode_program(instructions: List[Instruction], entry: int = 0,
+                   labels: Optional[Dict[str, int]] = None) -> bytes:
+    """编码程序为字节码。labels 用于将 ('label', name) 操作数解析为立即数。"""
+    out = bytearray()
+    out += BC_MAGIC
+    out += struct.pack('<B', BC_VERSION)
+    out += struct.pack('<I', entry & 0xFFFFFFFF)
+    out += struct.pack('<I', len(instructions) & 0xFFFFFFFF)
+    labels = labels or {}
+    for opcode, args in instructions:
+        op_enum = Constants.OPCODE_NAME_TO_ENUM.get(opcode)
+        if op_enum is None:
+            raise ValueError(f"Unknown opcode: {opcode}")
+        out += struct.pack('<BB', op_enum.value, len(args))
+        for arg in args:
+            if arg[0] == 'label':
+                if arg[1] not in labels:
+                    raise ValueError(f"Undefined label: {arg[1]}")
+                arg = ('imm', labels[arg[1]])
+            kind, value, extra = encode_operand(arg)
+            out += struct.pack('<Bqq', kind, _i64(value), _i64(extra))
+    return bytes(out)
+
+
+def decode_program(data: bytes) -> Tuple[List[Instruction], int]:
+    if data[:4] != BC_MAGIC:
+        raise ValueError("Bad bytecode magic")
+    version = data[4]
+    if version != BC_VERSION:
+        raise ValueError(f"Unsupported bytecode version: {version}")
+    entry = struct.unpack('<I', data[5:9])[0]
+    count = struct.unpack('<I', data[9:13])[0]
+    pos = 13
+    instructions: List[Instruction] = []
+    for _ in range(count):
+        op_val, argc = struct.unpack('<BB', data[pos:pos + 2])
+        pos += 2
+        opcode = Opcode(op_val).name
+        args: List[Operand] = []
+        for _ in range(argc):
+            kind, value, extra = struct.unpack('<Bqq', data[pos:pos + 17])
+            pos += 17
+            args.append(decode_operand(kind, value, extra))
+        instructions.append((opcode, args))
+    return instructions, entry
+
+
+# ==================== 原生库加载 ====================
+
+_LIB_CACHE: Optional['NativeEngine'] = False  # type: ignore
+
+
+def _lib_candidates() -> List[str]:
+    here = os.path.dirname(os.path.abspath(__file__))
+    system = platform.system()
+    if system == 'Windows':
+        names = ['codecin_native.dll']
+    elif system == 'Darwin':
+        names = ['libcodecin_native.dylib', 'codecin_native.dylib']
+    else:
+        names = ['libcodecin_native.so', 'codecin_native.so']
+    candidates = [os.path.join(here, 'native', n) for n in names]
+    candidates += [os.path.join(here, n) for n in names]
+    env = os.environ.get('CODECIN_NATIVE_LIB')
+    if env:
+        candidates.insert(0, env)
+    if getattr(sys, 'frozen', False):
+        # PyInstaller 打包布局: 二进制位于 exe 目录或 _internal 下
+        exe_dir = os.path.dirname(os.path.abspath(sys.executable))
+        meipass = getattr(sys, '_MEIPASS', exe_dir)
+        candidates += [os.path.join(meipass, n) for n in names]
+        candidates += [os.path.join(exe_dir, n) for n in names]
+    return candidates
+
+
+class NativeEngine:
+    def __init__(self, lib: ctypes.CDLL):
+        self.lib = lib
+        self._configure()
+
+    def _configure(self) -> None:
+        lib = self.lib
+        lib.codecin_run.argtypes = [
+            ctypes.c_void_p, ctypes.c_int,       # bytecode, len
+            ctypes.c_void_p, ctypes.c_int,       # mem, len
+            ctypes.c_longlong, ctypes.c_longlong, ctypes.c_longlong,  # entry, sp, heap
+            ctypes.c_void_p, ctypes.c_int,       # input, len
+            ctypes.c_longlong,                   # max steps
+        ]
+        lib.codecin_run.restype = ctypes.c_void_p
+        lib.codecin_free.argtypes = [ctypes.c_void_p]
+        lib.codecin_free.restype = None
+        lib.codecin_crom_pack.argtypes = [
+            ctypes.c_void_p, ctypes.c_int, ctypes.c_int,
+            ctypes.POINTER(ctypes.c_int),
+        ]
+        lib.codecin_crom_pack.restype = ctypes.c_void_p
+        lib.codecin_crom_unpack.argtypes = [
+            ctypes.c_void_p, ctypes.c_int,
+            ctypes.POINTER(ctypes.c_int), ctypes.POINTER(ctypes.c_int),
+        ]
+        lib.codecin_crom_unpack.restype = ctypes.c_void_p
+        lib.codecin_version.argtypes = []
+        lib.codecin_version.restype = ctypes.c_char_p
+
+    def version(self) -> str:
+        try:
+            return self.lib.codecin_version().decode()
+        except Exception:
+            return "unknown"
+
+    # ---------------- 原生 VM ----------------
+
+    def run(self, bytecode: bytes, mem: bytes, entry: int, sp: int,
+            heap_base: int, input_data: bytes, max_steps: int) -> Optional[Dict[str, Any]]:
+        bc_buf = ctypes.create_string_buffer(bytecode)
+        mem_buf = ctypes.create_string_buffer(bytes(mem), len(mem))
+        in_buf = ctypes.create_string_buffer(input_data) if input_data else None
+
+        ptr = self.lib.codecin_run(
+            ctypes.cast(bc_buf, ctypes.c_void_p), len(bytecode),
+            ctypes.cast(mem_buf, ctypes.c_void_p), len(mem),
+            entry, sp, heap_base,
+            ctypes.cast(in_buf, ctypes.c_void_p) if in_buf else None,
+            len(input_data),
+            max_steps,
+        )
+        if not ptr:
+            return None
+        try:
+            return self._parse_result(ptr)
+        finally:
+            self.lib.codecin_free(ptr)
+
+    def _parse_result(self, ptr: int) -> Dict[str, Any]:
+        base = ptr
+        view = ctypes.string_at(base, 64)
+        status = view[0]
+        pc, sp, heap_ptr, steps = struct.unpack_from('<QQQQ', view, 4)
+        off = 4 + 32
+        regs_raw = ctypes.string_at(base + off, 33 * 8)
+        off += 33 * 8
+        vec_raw = ctypes.string_at(base + off, 32 * 4 * 8)
+        off += 32 * 4 * 8
+        mem_len = struct.unpack_from('<Q', ctypes.string_at(base + off, 8), 0)[0]
+        off += 8
+        mem_data = bytes(ctypes.string_at(base + off, mem_len)) if mem_len else b''
+        off += mem_len
+        out_len = struct.unpack_from('<Q', ctypes.string_at(base + off, 8), 0)[0]
+        off += 8
+        out_data = bytes(ctypes.string_at(base + off, out_len)) if out_len else b''
+        off += out_len
+        err_len = struct.unpack_from('<H', ctypes.string_at(base + off, 2), 0)[0]
+        off += 2
+        err_msg = ctypes.string_at(base + off, err_len).decode('utf-8', 'replace') if err_len else ''
+
+        regs = list(struct.unpack('<33Q', regs_raw))
+        vec_flat = struct.unpack(f'<{32 * 4}d', vec_raw)
+        vec_regs = [list(vec_flat[i * 4:(i + 1) * 4]) for i in range(32)]
+
+        error = None
+        if status == 2:
+            error = 'unsupported'
+        elif status == 3:
+            error = err_msg or 'runtime error'
+
+        return {
+            'status': status,
+            'halted': status == 0,
+            'pc': pc,
+            'sp': sp,
+            'heap_ptr': heap_ptr,
+            'steps': steps,
+            'regs': regs,
+            'vec_regs': vec_regs,
+            'mem': mem_data,
+            'output': out_data.decode('utf-8', 'replace'),
+            'error': error,
+        }
+
+    # ---------------- CROM ----------------
+
+    def crom_pack(self, mem: bytes, compress: bool) -> Optional[bytes]:
+        buf = ctypes.create_string_buffer(bytes(mem), len(mem))
+        out_len = ctypes.c_int(0)
+        ptr = self.lib.codecin_crom_pack(
+            ctypes.cast(buf, ctypes.c_void_p), len(mem),
+            1 if compress else 0, ctypes.byref(out_len))
+        if not ptr:
+            return None
+        try:
+            return bytes(ctypes.string_at(ptr, out_len.value))
+        finally:
+            self.lib.codecin_free(ptr)
+
+    def crom_unpack(self, data: bytes) -> Optional[bytes]:
+        buf = ctypes.create_string_buffer(data, len(data))
+        mem_len = ctypes.c_int(0)
+        flags = ctypes.c_int(0)
+        ptr = self.lib.codecin_crom_unpack(
+            ctypes.cast(buf, ctypes.c_void_p), len(data),
+            ctypes.byref(mem_len), ctypes.byref(flags))
+        if not ptr:
+            return None
+        try:
+            return bytes(ctypes.string_at(ptr, mem_len.value))
+        finally:
+            self.lib.codecin_free(ptr)
+
+
+def get_engine(logger=None) -> Optional[NativeEngine]:
+    """查找并加载原生库; 失败返回 None (纯 Python 回退)。"""
+    global _LIB_CACHE
+    if _LIB_CACHE is not False:
+        return _LIB_CACHE
+
+    engine = None
+    for path in _lib_candidates():
+        if not os.path.exists(path):
+            continue
+        try:
+            lib = ctypes.CDLL(path)
+            engine = NativeEngine(lib)
+            if logger:
+                logger.debug(f"Loaded native library: {path} ({engine.version()})")
+            break
+        except OSError as e:
+            if logger:
+                logger.debug(f"Failed to load native library {path}: {e}")
+            engine = None
+
+    _LIB_CACHE = engine
+    return engine