修复了大量存在的问题，增加了假鸭子类型等等机制
This commit is contained in:
425
includes/__builtin.py
Normal file
425
includes/__builtin.py
Normal file
@@ -0,0 +1,425 @@
|
||||
# GCC/Clang 内建函数声明
|
||||
# 所有函数均为仅声明（t.State 等价于 CExtern | CExport），由编译器/运行时提供实现
|
||||
import t
|
||||
|
||||
|
||||
# ============================================================
|
||||
# 随机数生成 (RDRAND / RDSEED)
|
||||
# ============================================================
|
||||
|
||||
def __builtin_ia32_rdrand16_step(p: t.CUInt16T | t.CPtr) -> t.CInt | t.State: pass
|
||||
def __builtin_ia32_rdrand32_step(p: t.CUInt32T | t.CPtr) -> t.CInt | t.State: pass
|
||||
def __builtin_ia32_rdrand64_step(p: t.CUInt64T | t.CPtr) -> t.CInt | t.State: pass
|
||||
def __builtin_ia32_rdseed16_step(p: t.CUInt16T | t.CPtr) -> t.CInt | t.State: pass
|
||||
def __builtin_ia32_rdseed32_step(p: t.CUInt32T | t.CPtr) -> t.CInt | t.State: pass
|
||||
def __builtin_ia32_rdseed64_step(p: t.CUInt64T | t.CPtr) -> t.CInt | t.State: pass
|
||||
|
||||
|
||||
# ============================================================
|
||||
# 时间戳计数器 (RDTSC / RDTSCP)
|
||||
# ============================================================
|
||||
|
||||
def __builtin_ia32_rdtsc() -> t.CUInt64T | t.State: pass
|
||||
def __builtin_ia32_rdtscp(p: t.CUInt32T | t.CPtr) -> t.CUInt64T | t.State: pass
|
||||
def __builtin_ia32_rdpmc(counter: t.CUInt32T) -> t.CUInt64T | t.State: pass
|
||||
|
||||
|
||||
# ============================================================
|
||||
# CPUID
|
||||
# ============================================================
|
||||
|
||||
def __builtin_ia32_cpuid(level: t.CUInt32T, a: t.CUInt32T | t.CPtr, b: t.CUInt32T | t.CPtr, c: t.CUInt32T | t.CPtr, d: t.CUInt32T | t.CPtr) -> t.CUInt32T | t.State: pass
|
||||
def __builtin_ia32_cpuid_count(level: t.CUInt32T, count: t.CUInt32T, a: t.CUInt32T | t.CPtr, b: t.CUInt32T | t.CPtr, c: t.CUInt32T | t.CPtr, d: t.CUInt32T | t.CPtr) -> t.CUInt32T | t.State: pass
|
||||
|
||||
|
||||
# ============================================================
|
||||
# 内存屏障 (Fence)
|
||||
# ============================================================
|
||||
|
||||
def __builtin_ia32_lfence() -> t.State: pass
|
||||
def __builtin_ia32_mfence() -> t.State: pass
|
||||
def __builtin_ia32_sfence() -> t.State: pass
|
||||
def __builtin_ia32_pause() -> t.State: pass
|
||||
|
||||
|
||||
# ============================================================
|
||||
# 位操作 (POPCNT / BSF / BSR / TZCNT / LZCNT / BEXTR / PDEP / PEXT / ANDN)
|
||||
# ============================================================
|
||||
|
||||
def __builtin_ia32_popcntsi(x: t.CUInt32T) -> t.CInt | t.State: pass
|
||||
def __builtin_ia32_popcntdi(x: t.CUInt64T) -> t.CInt | t.State: pass
|
||||
def __builtin_ia32_popcntqi(x: t.CUInt64T) -> t.CInt | t.State: pass
|
||||
|
||||
def __builtin_ia32_bsfsi(src: t.CUInt32T, dst: t.CUInt32T | t.CPtr) -> t.CInt | t.State: pass
|
||||
def __builtin_ia32_bsrsi(src: t.CUInt32T, dst: t.CUInt32T | t.CPtr) -> t.CInt | t.State: pass
|
||||
def __builtin_ia32_bsfqi(src: t.CUInt64T, dst: t.CUInt64T | t.CPtr) -> t.CInt | t.State: pass
|
||||
def __builtin_ia32_bsrqi(src: t.CUInt64T, dst: t.CUInt64T | t.CPtr) -> t.CInt | t.State: pass
|
||||
|
||||
def __builtin_ia32_tzcntsi(x: t.CUInt32T) -> t.CUInt32T | t.State: pass
|
||||
def __builtin_ia32_tzcntdi(x: t.CUInt64T) -> t.CUInt64T | t.State: pass
|
||||
def __builtin_ia32_lzcntsi(x: t.CUInt32T) -> t.CUInt32T | t.State: pass
|
||||
def __builtin_ia32_lzcntdi(x: t.CUInt64T) -> t.CUInt64T | t.State: pass
|
||||
|
||||
def __builtin_ia32_bextrsi(src: t.CUInt32T, start: t.CUInt32T, len: t.CUInt32T) -> t.CUInt32T | t.State: pass
|
||||
def __builtin_ia32_bextrdi(src: t.CUInt64T, start: t.CUInt32T, len: t.CUInt32T) -> t.CUInt64T | t.State: pass
|
||||
|
||||
def __builtin_ia32_pdep_si(src: t.CUInt32T, mask: t.CUInt32T) -> t.CUInt32T | t.State: pass
|
||||
def __builtin_ia32_pext_si(src: t.CUInt32T, mask: t.CUInt32T) -> t.CUInt32T | t.State: pass
|
||||
def __builtin_ia32_pdep_di(src: t.CUInt64T, mask: t.CUInt64T) -> t.CUInt64T | t.State: pass
|
||||
def __builtin_ia32_pext_di(src: t.CUInt64T, mask: t.CUInt64T) -> t.CUInt64T | t.State: pass
|
||||
|
||||
def __builtin_ia32_andn_si(a: t.CUInt32T, b: t.CUInt32T) -> t.CUInt32T | t.State: pass
|
||||
def __builtin_ia32_andn_di(a: t.CUInt64T, b: t.CUInt64T) -> t.CUInt64T | t.State: pass
|
||||
|
||||
|
||||
# ============================================================
|
||||
# 字节序交换 (BSWAP)
|
||||
# ============================================================
|
||||
|
||||
def __builtin_bswap16(x: t.CUInt16T) -> t.CUInt16T | t.State: pass
|
||||
def __builtin_bswap32(x: t.CUInt32T) -> t.CUInt32T | t.State: pass
|
||||
def __builtin_bswap64(x: t.CUInt64T) -> t.CUInt64T | t.State: pass
|
||||
|
||||
|
||||
# ============================================================
|
||||
# 缓存操作 (Cache)
|
||||
# ============================================================
|
||||
|
||||
def __builtin_ia32_clflush(p: t.CVoid | t.CConst | t.CPtr) -> t.State: pass
|
||||
def __builtin_ia32_clflushopt(p: t.CVoid | t.CConst | t.CPtr) -> t.State: pass
|
||||
def __builtin_ia32_clwb(p: t.CVoid | t.CConst | t.CPtr) -> t.State: pass
|
||||
def __builtin_ia32_clzero() -> t.State: pass
|
||||
|
||||
|
||||
# ============================================================
|
||||
# 预取 (Prefetch)
|
||||
# ============================================================
|
||||
|
||||
def __builtin_prefetch(addr: t.CVoid | t.CConst | t.CPtr, rw: t.CInt = 0, locality: t.CInt = 3) -> t.State: pass
|
||||
def __builtin_ia32_prefetch0(p: t.CChar | t.CConst | t.CPtr) -> t.State: pass
|
||||
def __builtin_ia32_prefetch1(p: t.CChar | t.CConst | t.CPtr) -> t.State: pass
|
||||
def __builtin_ia32_prefetch2(p: t.CChar | t.CConst | t.CPtr) -> t.State: pass
|
||||
def __builtin_ia32_prefetchnta(p: t.CChar | t.CConst | t.CPtr) -> t.State: pass
|
||||
|
||||
|
||||
# ============================================================
|
||||
# 非临时存储 (Non-Temporal Store)
|
||||
# ============================================================
|
||||
|
||||
def __builtin_ia32_movnti(p: t.CUInt32T | t.CPtr, val: t.CUInt32T) -> t.State: pass
|
||||
def __builtin_ia32_movnti64(p: t.CUInt64T | t.CPtr, val: t.CUInt64T) -> t.State: pass
|
||||
def __builtin_ia32_movntdq(p: t.CVoid | t.CPtr, val: t.CVoid | t.CPtr) -> t.State: pass
|
||||
def __builtin_ia32_movntps(p: t.CFloat | t.CPtr, val: t.CFloat) -> t.State: pass
|
||||
def __builtin_ia32_movntpd(p: t.CDouble | t.CPtr, val: t.CDouble) -> t.State: pass
|
||||
|
||||
|
||||
# ============================================================
|
||||
# I/O 端口操作 (Port I/O)
|
||||
# ============================================================
|
||||
|
||||
def __builtin_ia32_inb(port: t.CUInt16T) -> t.CUInt8T | t.State: pass
|
||||
def __builtin_ia32_inw(port: t.CUInt16T) -> t.CUInt16T | t.State: pass
|
||||
def __builtin_ia32_inl(port: t.CUInt16T) -> t.CUInt32T | t.State: pass
|
||||
def __builtin_ia32_outb(val: t.CUInt8T, port: t.CUInt16T) -> t.State: pass
|
||||
def __builtin_ia32_outw(val: t.CUInt16T, port: t.CUInt16T) -> t.State: pass
|
||||
def __builtin_ia32_outl(val: t.CUInt32T, port: t.CUInt16T) -> t.State: pass
|
||||
|
||||
|
||||
# ============================================================
|
||||
# 模型特定寄存器 (MSR)
|
||||
# ============================================================
|
||||
|
||||
def __builtin_ia32_rdmsr(msr: t.CUInt32T, val: t.CUInt64T | t.CPtr) -> t.State: pass
|
||||
def __builtin_ia32_wrmsr(msr: t.CUInt32T, val: t.CUInt64T) -> t.State: pass
|
||||
|
||||
|
||||
# ============================================================
|
||||
# 系统指令 (System)
|
||||
# ============================================================
|
||||
|
||||
def __builtin_ia32_hlt() -> t.State: pass
|
||||
def __builtin_ia32_invd() -> t.State: pass
|
||||
def __builtin_ia32_wbinvd() -> t.State: pass
|
||||
def __builtin_ia32_invlpg(p: t.CVoid | t.CPtr) -> t.State: pass
|
||||
def __builtin_ia32_clts() -> t.State: pass
|
||||
def __builtin_ia32_cli() -> t.State: pass
|
||||
def __builtin_ia32_sti() -> t.State: pass
|
||||
def __builtin_ia32_int3() -> t.State: pass
|
||||
def __builtin_ia32_int(n: t.CUInt8T) -> t.State: pass
|
||||
def __builtin_ia32_ud2() -> t.State: pass
|
||||
|
||||
|
||||
# ============================================================
|
||||
# 描述符表 (GDT / IDT / LDT / TR)
|
||||
# ============================================================
|
||||
|
||||
def __builtin_ia32_lgdt(p: t.CVoid | t.CPtr) -> t.State: pass
|
||||
def __builtin_ia32_sgdt(p: t.CVoid | t.CPtr) -> t.State: pass
|
||||
def __builtin_ia32_lidt(p: t.CVoid | t.CPtr) -> t.State: pass
|
||||
def __builtin_ia32_sidt(p: t.CVoid | t.CPtr) -> t.State: pass
|
||||
def __builtin_ia32_lldt(sel: t.CUInt32T) -> t.State: pass
|
||||
def __builtin_ia32_sldt(p: t.CVoid | t.CPtr) -> t.State: pass
|
||||
def __builtin_ia32_ltr(sel: t.CUInt32T) -> t.State: pass
|
||||
def __builtin_ia32_str(p: t.CVoid | t.CPtr) -> t.State: pass
|
||||
|
||||
|
||||
# ============================================================
|
||||
# 控制寄存器 (CR / MSW)
|
||||
# ============================================================
|
||||
|
||||
def __builtin_ia32_lmsw(val: t.CUInt32T) -> t.State: pass
|
||||
def __builtin_ia32_smsw(p: t.CVoid | t.CPtr) -> t.State: pass
|
||||
|
||||
|
||||
# ============================================================
|
||||
# 监控等待 (MONITOR / MWAIT)
|
||||
# ============================================================
|
||||
|
||||
def __builtin_ia32_monitor(p: t.CVoid | t.CPtr, extensions: t.CUInt32T, hints: t.CUInt32T) -> t.State: pass
|
||||
def __builtin_ia32_mwait(extensions: t.CUInt32T, hints: t.CUInt32T) -> t.State: pass
|
||||
|
||||
|
||||
# ============================================================
|
||||
# XSAVE 状态操作
|
||||
# ============================================================
|
||||
|
||||
def __builtin_ia32_xsave(p: t.CVoid | t.CPtr, mask: t.CUInt64T) -> t.State: pass
|
||||
def __builtin_ia32_xrstor(p: t.CVoid | t.CConst | t.CPtr, mask: t.CUInt64T) -> t.State: pass
|
||||
def __builtin_ia32_xsaveopt(p: t.CVoid | t.CPtr, mask: t.CUInt64T) -> t.State: pass
|
||||
def __builtin_ia32_xsavec(p: t.CVoid | t.CPtr, mask: t.CUInt64T) -> t.State: pass
|
||||
def __builtin_ia32_xrstors(p: t.CVoid | t.CConst | t.CPtr, mask: t.CUInt64T) -> t.State: pass
|
||||
def __builtin_ia32_xsaves(p: t.CVoid | t.CPtr, mask: t.CUInt64T) -> t.State: pass
|
||||
|
||||
|
||||
# ============================================================
|
||||
# 通用内建函数 (Generic Builtins)
|
||||
# ============================================================
|
||||
|
||||
def __builtin_expect(exp: t.CLong, c: t.CLong) -> t.CLong | t.State: pass
|
||||
def __builtin_unreachable() -> t.State: pass
|
||||
def __builtin_trap() -> t.State: pass
|
||||
def __builtin_abort() -> t.State: pass
|
||||
def __builtin_assume_aligned(addr: t.CVoid | t.CConst | t.CPtr, align: t.CSizeT, *args) -> t.CVoid | t.CPtr | t.State: pass
|
||||
def __builtin_constant_p(expr: t.CVoid) -> t.CInt | t.State: pass
|
||||
def __builtin_types_compatible_p(t1: t.CVoid, t2: t.CVoid) -> t.CInt | t.State: pass
|
||||
def __builtin_choose_expr(const_exp: t.CUInt32T, exp1: t.CVoid, exp2: t.CVoid) -> t.CVoid | t.CPtr | t.State: pass
|
||||
def __builtin_offsetof(typ: t.CVoid, member: t.CVoid) -> t.CSizeT | t.State: pass
|
||||
def __builtin_function_start(func: t.CVoid | t.CPtr) -> t.CVoid | t.CPtr | t.State: pass
|
||||
|
||||
|
||||
# ============================================================
|
||||
# 可变参数 (VaList)
|
||||
# ============================================================
|
||||
|
||||
def __builtin_va_start(va: t.CVoid | t.CPtr, *args) -> t.State: pass
|
||||
def __builtin_va_end(va: t.CVoid | t.CPtr) -> t.State: pass
|
||||
def __builtin_va_arg(va: t.CVoid | t.CPtr, typ: t.CVoid) -> t.State: pass
|
||||
def __builtin_va_copy(dst: t.CVoid | t.CPtr, src: t.CVoid | t.CConst | t.CPtr) -> t.State: pass
|
||||
|
||||
|
||||
# ============================================================
|
||||
# 栈与调用信息 (Stack / Frame)
|
||||
# ============================================================
|
||||
|
||||
def __builtin_return_address(level: t.CUInt32T) -> t.CVoid | t.CPtr | t.State: pass
|
||||
def __builtin_frame_address(level: t.CUInt32T) -> t.CVoid | t.CPtr | t.State: pass
|
||||
def __builtin_alloca(size: t.CSizeT) -> t.CVoid | t.CPtr | t.State: pass
|
||||
def __builtin_alloca_with_align(size: t.CSizeT, alignment: t.CSizeT) -> t.CVoid | t.CPtr | t.State: pass
|
||||
|
||||
|
||||
# ============================================================
|
||||
# 内存操作 (Memory)
|
||||
# ============================================================
|
||||
|
||||
def __builtin_memcpy(dst: t.CVoid | t.CPtr, src: t.CVoid | t.CConst | t.CPtr, n: t.CSizeT) -> t.CVoid | t.CPtr | t.State: pass
|
||||
def __builtin_memset(s: t.CVoid | t.CPtr, c: t.CInt, n: t.CSizeT) -> t.CVoid | t.CPtr | t.State: pass
|
||||
def __builtin_memmove(dst: t.CVoid | t.CPtr, src: t.CVoid | t.CConst | t.CPtr, n: t.CSizeT) -> t.CVoid | t.CPtr | t.State: pass
|
||||
def __builtin_memcmp(s1: t.CVoid | t.CConst | t.CPtr, s2: t.CVoid | t.CConst | t.CPtr, n: t.CSizeT) -> t.CInt | t.State: pass
|
||||
def __builtin_mempcpy(dst: t.CVoid | t.CPtr, src: t.CVoid | t.CConst | t.CPtr, n: t.CSizeT) -> t.CVoid | t.CPtr | t.State: pass
|
||||
def __builtin_memchr(s: t.CVoid | t.CConst | t.CPtr, c: t.CInt, n: t.CSizeT) -> t.CVoid | t.CPtr | t.State: pass
|
||||
|
||||
|
||||
# ============================================================
|
||||
# 字符串操作 (String)
|
||||
# ============================================================
|
||||
|
||||
def __builtin_strcpy(dst: t.CChar | t.CPtr, src: t.CChar | t.CConst | t.CPtr) -> t.CChar | t.CPtr | t.State: pass
|
||||
def __builtin_strncpy(dst: t.CChar | t.CPtr, src: t.CChar | t.CConst | t.CPtr, n: t.CSizeT) -> t.CChar | t.CPtr | t.State: pass
|
||||
def __builtin_strcat(dst: t.CChar | t.CPtr, src: t.CChar | t.CConst | t.CPtr) -> t.CChar | t.CPtr | t.State: pass
|
||||
def __builtin_strncat(dst: t.CChar | t.CPtr, src: t.CChar | t.CConst | t.CPtr, n: t.CSizeT) -> t.CChar | t.CPtr | t.State: pass
|
||||
def __builtin_strlen(s: t.CChar | t.CConst | t.CPtr) -> t.CSizeT | t.State: pass
|
||||
def __builtin_strcmp(s1: t.CChar | t.CConst | t.CPtr, s2: t.CChar | t.CConst | t.CPtr) -> t.CInt | t.State: pass
|
||||
def __builtin_strncmp(s1: t.CChar | t.CConst | t.CPtr, s2: t.CChar | t.CConst | t.CPtr, n: t.CSizeT) -> t.CInt | t.State: pass
|
||||
def __builtin_strchr(s: t.CChar | t.CConst | t.CPtr, c: t.CInt) -> t.CChar | t.CPtr | t.State: pass
|
||||
def __builtin_strrchr(s: t.CChar | t.CConst | t.CPtr, c: t.CInt) -> t.CChar | t.CPtr | t.State: pass
|
||||
def __builtin_strstr(haystack: t.CChar | t.CConst | t.CPtr, needle: t.CChar | t.CConst | t.CPtr) -> t.CChar | t.CPtr | t.State: pass
|
||||
|
||||
|
||||
# ============================================================
|
||||
# 数学内建函数 (Math)
|
||||
# ============================================================
|
||||
|
||||
def __builtin_sqrt(x: t.CDouble) -> t.CDouble | t.State: pass
|
||||
def __builtin_sqrtf(x: t.CFloat) -> t.CFloat | t.State: pass
|
||||
def __builtin_sqrtl(x: t.CDouble) -> t.CDouble | t.State: pass
|
||||
def __builtin_pow(x: t.CDouble, y: t.CDouble) -> t.CDouble | t.State: pass
|
||||
def __builtin_powf(x: t.CFloat, y: t.CFloat) -> t.CFloat | t.State: pass
|
||||
def __builtin_sin(x: t.CDouble) -> t.CDouble | t.State: pass
|
||||
def __builtin_sinf(x: t.CFloat) -> t.CFloat | t.State: pass
|
||||
def __builtin_cos(x: t.CDouble) -> t.CDouble | t.State: pass
|
||||
def __builtin_cosf(x: t.CFloat) -> t.CFloat | t.State: pass
|
||||
def __builtin_tan(x: t.CDouble) -> t.CDouble | t.State: pass
|
||||
def __builtin_tanf(x: t.CFloat) -> t.CFloat | t.State: pass
|
||||
def __builtin_atan(x: t.CDouble) -> t.CDouble | t.State: pass
|
||||
def __builtin_atan2(y: t.CDouble, x: t.CDouble) -> t.CDouble | t.State: pass
|
||||
def __builtin_exp(x: t.CDouble) -> t.CDouble | t.State: pass
|
||||
def __builtin_log(x: t.CDouble) -> t.CDouble | t.State: pass
|
||||
def __builtin_log2(x: t.CDouble) -> t.CDouble | t.State: pass
|
||||
def __builtin_log10(x: t.CDouble) -> t.CDouble | t.State: pass
|
||||
def __builtin_fabs(x: t.CDouble) -> t.CDouble | t.State: pass
|
||||
def __builtin_fabsf(x: t.CFloat) -> t.CFloat | t.State: pass
|
||||
def __builtin_abs(x: t.CInt) -> t.CInt | t.State: pass
|
||||
def __builtin_labs(x: t.CLong) -> t.CLong | t.State: pass
|
||||
def __builtin_llabs(x: t.CInt64T) -> t.CInt64T | t.State: pass
|
||||
def __builtin_fma(x: t.CDouble, y: t.CDouble, z: t.CDouble) -> t.CDouble | t.State: pass
|
||||
def __builtin_fmod(x: t.CDouble, y: t.CDouble) -> t.CDouble | t.State: pass
|
||||
def __builtin_floor(x: t.CDouble) -> t.CDouble | t.State: pass
|
||||
def __builtin_ceil(x: t.CDouble) -> t.CDouble | t.State: pass
|
||||
def __builtin_trunc(x: t.CDouble) -> t.CDouble | t.State: pass
|
||||
def __builtin_round(x: t.CDouble) -> t.CDouble | t.State: pass
|
||||
def __builtin_nearbyint(x: t.CDouble) -> t.CDouble | t.State: pass
|
||||
def __builtin_rint(x: t.CDouble) -> t.CDouble | t.State: pass
|
||||
|
||||
|
||||
# ============================================================
|
||||
# 位计数内建函数 (Bit Counting)
|
||||
# ============================================================
|
||||
|
||||
def __builtin_ffs(x: t.CUInt32T) -> t.CInt | t.State: pass
|
||||
def __builtin_clz(x: t.CUInt32T) -> t.CInt | t.State: pass
|
||||
def __builtin_ctz(x: t.CUInt32T) -> t.CInt | t.State: pass
|
||||
def __builtin_popcount(x: t.CUInt32T) -> t.CInt | t.State: pass
|
||||
def __builtin_parity(x: t.CUInt32T) -> t.CInt | t.State: pass
|
||||
|
||||
def __builtin_ffsl(x: t.CULong) -> t.CInt | t.State: pass
|
||||
def __builtin_clzl(x: t.CULong) -> t.CInt | t.State: pass
|
||||
def __builtin_ctzl(x: t.CULong) -> t.CInt | t.State: pass
|
||||
def __builtin_popcountl(x: t.CULong) -> t.CInt | t.State: pass
|
||||
def __builtin_parityl(x: t.CULong) -> t.CInt | t.State: pass
|
||||
|
||||
def __builtin_ffsll(x: t.CUInt64T) -> t.CInt | t.State: pass
|
||||
def __builtin_clzll(x: t.CUInt64T) -> t.CInt | t.State: pass
|
||||
def __builtin_ctzll(x: t.CUInt64T) -> t.CInt | t.State: pass
|
||||
def __builtin_popcountll(x: t.CUInt64T) -> t.CInt | t.State: pass
|
||||
def __builtin_parityll(x: t.CUInt64T) -> t.CInt | t.State: pass
|
||||
|
||||
|
||||
# ============================================================
|
||||
# 对象大小检查 (Object size check)
|
||||
# ============================================================
|
||||
|
||||
def __builtin_object_size(ptr: t.CVoid | t.CConst | t.CPtr, typ: t.CInt) -> t.CSizeT | t.State: pass
|
||||
def __builtin_dynamic_object_size(ptr: t.CVoid | t.CConst | t.CPtr, typ: t.CInt) -> t.CSizeT | t.State: pass
|
||||
|
||||
def __builtin___memcpy_chk(dst: t.CVoid | t.CPtr, src: t.CVoid | t.CConst | t.CPtr, n: t.CSizeT, objsize: t.CSizeT) -> t.CVoid | t.CPtr | t.State: pass
|
||||
def __builtin___memmove_chk(dst: t.CVoid | t.CPtr, src: t.CVoid | t.CConst | t.CPtr, n: t.CSizeT, objsize: t.CSizeT) -> t.CVoid | t.CPtr | t.State: pass
|
||||
def __builtin___memset_chk(s: t.CVoid | t.CPtr, c: t.CInt, n: t.CSizeT, objsize: t.CSizeT) -> t.CVoid | t.CPtr | t.State: pass
|
||||
def __builtin___mempcpy_chk(dst: t.CVoid | t.CPtr, src: t.CVoid | t.CConst | t.CPtr, n: t.CSizeT, objsize: t.CSizeT) -> t.CVoid | t.CPtr | t.State: pass
|
||||
def __builtin___strcpy_chk(dst: t.CChar | t.CPtr, src: t.CChar | t.CConst | t.CPtr, objsize: t.CSizeT) -> t.CChar | t.CPtr | t.State: pass
|
||||
def __builtin___strncpy_chk(dst: t.CChar | t.CPtr, src: t.CChar | t.CConst | t.CPtr, n: t.CSizeT, objsize: t.CSizeT) -> t.CChar | t.CPtr | t.State: pass
|
||||
def __builtin___strcat_chk(dst: t.CChar | t.CPtr, src: t.CChar | t.CConst | t.CPtr, objsize: t.CSizeT) -> t.CChar | t.CPtr | t.State: pass
|
||||
def __builtin___strncat_chk(dst: t.CChar | t.CPtr, src: t.CChar | t.CConst | t.CPtr, n: t.CSizeT, objsize: t.CSizeT) -> t.CChar | t.CPtr | t.State: pass
|
||||
def __builtin___snprintf_chk(s: t.CChar | t.CPtr, maxlen: t.CSizeT, flag: t.CInt, slen: t.CSizeT, fmt: t.CChar | t.CConst | t.CPtr, *args) -> t.CInt | t.State: pass
|
||||
def __builtin___sprintf_chk(s: t.CChar | t.CPtr, flag: t.CInt, slen: t.CSizeT, fmt: t.CChar | t.CConst | t.CPtr, *args) -> t.CInt | t.State: pass
|
||||
|
||||
|
||||
# ============================================================
|
||||
# 浮点分类 (FP Classification)
|
||||
# ============================================================
|
||||
|
||||
def __builtin_isnan(x: t.CDouble) -> t.CInt | t.State: pass
|
||||
def __builtin_isinf(x: t.CDouble) -> t.CInt | t.State: pass
|
||||
def __builtin_isinf_sign(x: t.CDouble) -> t.CInt | t.State: pass
|
||||
def __builtin_isfinite(x: t.CDouble) -> t.CInt | t.State: pass
|
||||
def __builtin_isnormal(x: t.CDouble) -> t.CInt | t.State: pass
|
||||
def __builtin_signbit(x: t.CDouble) -> t.CInt | t.State: pass
|
||||
def __builtin_isgreater(x: t.CDouble, y: t.CDouble) -> t.CInt | t.State: pass
|
||||
def __builtin_isgreaterequal(x: t.CDouble, y: t.CDouble) -> t.CInt | t.State: pass
|
||||
def __builtin_isless(x: t.CDouble, y: t.CDouble) -> t.CInt | t.State: pass
|
||||
def __builtin_islessequal(x: t.CDouble, y: t.CDouble) -> t.CInt | t.State: pass
|
||||
def __builtin_islessgreater(x: t.CDouble, y: t.CDouble) -> t.CInt | t.State: pass
|
||||
def __builtin_isunordered(x: t.CDouble, y: t.CDouble) -> t.CInt | t.State: pass
|
||||
|
||||
|
||||
# ============================================================
|
||||
# 特殊值 (Special Values)
|
||||
# ============================================================
|
||||
|
||||
def __builtin_nan(s: t.CChar | t.CConst | t.CPtr) -> t.CDouble | t.State: pass
|
||||
def __builtin_nanf(s: t.CChar | t.CConst | t.CPtr) -> t.CFloat | t.State: pass
|
||||
def __builtin_nanl(s: t.CChar | t.CConst | t.CPtr) -> t.CDouble | t.State: pass
|
||||
def __builtin_nans(s: t.CChar | t.CConst | t.CPtr) -> t.CDouble | t.State: pass
|
||||
def __builtin_nansf(s: t.CChar | t.CConst | t.CPtr) -> t.CFloat | t.State: pass
|
||||
def __builtin_inf() -> t.CDouble | t.State: pass
|
||||
def __builtin_inff() -> t.CFloat | t.State: pass
|
||||
def __builtin_infl() -> t.CDouble | t.State: pass
|
||||
def __builtin_huge_val() -> t.CDouble | t.State: pass
|
||||
def __builtin_huge_valf() -> t.CFloat | t.State: pass
|
||||
def __builtin_huge_vall() -> t.CDouble | t.State: pass
|
||||
def __builtin_inf_sign() -> t.CInt | t.State: pass
|
||||
|
||||
|
||||
# ============================================================
|
||||
# 类型转换与溢出检查 (Overflow)
|
||||
# ============================================================
|
||||
|
||||
def __builtin_add_overflow(a: t.CUInt64T, b: t.CUInt64T, res: t.CUInt64T | t.CPtr) -> t.CBool | t.State: pass
|
||||
def __builtin_sub_overflow(a: t.CUInt64T, b: t.CUInt64T, res: t.CUInt64T | t.CPtr) -> t.CBool | t.State: pass
|
||||
def __builtin_mul_overflow(a: t.CUInt64T, b: t.CUInt64T, res: t.CUInt64T | t.CPtr) -> t.CBool | t.State: pass
|
||||
def __builtin_sadd_overflow(a: t.CInt64T, b: t.CInt64T, res: t.CInt64T | t.CPtr) -> t.CBool | t.State: pass
|
||||
def __builtin_ssub_overflow(a: t.CInt64T, b: t.CInt64T, res: t.CInt64T | t.CPtr) -> t.CBool | t.State: pass
|
||||
def __builtin_smul_overflow(a: t.CInt64T, b: t.CInt64T, res: t.CInt64T | t.CPtr) -> t.CBool | t.State: pass
|
||||
def __builtin_uadd_overflow(a: t.CUInt64T, b: t.CUInt64T, res: t.CUInt64T | t.CPtr) -> t.CBool | t.State: pass
|
||||
def __builtin_usub_overflow(a: t.CUInt64T, b: t.CUInt64T, res: t.CUInt64T | t.CPtr) -> t.CBool | t.State: pass
|
||||
def __builtin_umul_overflow(a: t.CUInt64T, b: t.CUInt64T, res: t.CUInt64T | t.CPtr) -> t.CBool | t.State: pass
|
||||
|
||||
|
||||
# ============================================================
|
||||
# MMX / SSE 状态
|
||||
# ============================================================
|
||||
|
||||
def __builtin_ia32_emms() -> t.State: pass
|
||||
def __builtin_ia32_femms() -> t.State: pass
|
||||
|
||||
|
||||
# ============================================================
|
||||
# 排队指令 (ENQCMD)
|
||||
# ============================================================
|
||||
|
||||
def __builtin_ia32_enqcmd(dst: t.CVoid | t.CPtr, src: t.CVoid | t.CConst | t.CPtr) -> t.CBool | t.State: pass
|
||||
def __builtin_ia32_enqcmds(dst: t.CVoid | t.CPtr, src: t.CVoid | t.CConst | t.CPtr) -> t.CBool | t.State: pass
|
||||
|
||||
|
||||
# ============================================================
|
||||
# 用户级等待 (UMWAIT / UMONITOR / TPAUSE)
|
||||
# ============================================================
|
||||
|
||||
def __builtin_ia32_umonitor(p: t.CVoid | t.CPtr) -> t.State: pass
|
||||
def __builtin_ia32_umwait(extensions: t.CUInt32T, counter: t.CUInt64T) -> t.CUInt8T | t.State: pass
|
||||
def __builtin_ia32_tpause(extensions: t.CUInt32T, counter: t.CUInt64T) -> t.CUInt8T | t.State: pass
|
||||
|
||||
|
||||
# ============================================================
|
||||
# 访问控制 (CLAC / STAC)
|
||||
# ============================================================
|
||||
|
||||
def __builtin_ia32_clac() -> t.State: pass
|
||||
def __builtin_ia32_stac() -> t.State: pass
|
||||
|
||||
|
||||
# ============================================================
|
||||
# TLB 无效化 (INVLPG 变体)
|
||||
# ============================================================
|
||||
|
||||
def __builtin_ia32_invlpgb(aux: t.CUInt64T, pcid: t.CUInt64T) -> t.State: pass
|
||||
def __builtin_ia32_tlbsync() -> t.State: pass
|
||||
283
includes/_dict.py
Normal file
283
includes/_dict.py
Normal file
@@ -0,0 +1,283 @@
|
||||
import t, c
|
||||
import mbuddy
|
||||
import string
|
||||
import json
|
||||
import mpool
|
||||
from stdint import *
|
||||
|
||||
# Variant 类型标签 (与 _variant.py 保持一致)
|
||||
VARIANT_NONE: t.CDefine = 0 # 无类型/空值
|
||||
VARIANT_INT: t.CDefine = 1 # int (i64)
|
||||
VARIANT_FLOAT: t.CDefine = 2 # float (f32)
|
||||
VARIANT_DOUBLE: t.CDefine = 3 # double (f64)
|
||||
VARIANT_STR: t.CDefine = 4 # str (i8*)
|
||||
VARIANT_DICT: t.CDefine = 5 # dict*
|
||||
VARIANT_LIST: t.CDefine = 6 # list*
|
||||
VARIANT_BOOL: t.CDefine = 7 # bool (i1/i32)
|
||||
VARIANT_PTR: t.CDefine = 8 # 自定义指针类型
|
||||
|
||||
# Variant 结构体大小: vtype(i32, 4 bytes) + padding(4 bytes) + ptr(i8*, 8 bytes) = 16 bytes
|
||||
_VARIANT_SIZE: t.CDefine = 16
|
||||
|
||||
|
||||
class dict:
|
||||
"""堆上动态字典容器，基于 mbuddy 分配器。
|
||||
键类型固定为 str (i8*)，值使用 Variant 存储 (类型标签 + 无类型指针)。
|
||||
支持嵌套 dict/list 和 JSON 序列化。
|
||||
|
||||
用法:
|
||||
mb: mbuddy.MBuddy = mbuddy.MBuddy(arena, arena_size)
|
||||
d: dict = dict(mb)
|
||||
d.set_int("x", 42)
|
||||
p: t.CPtr = d["x"]
|
||||
v: int = c.Deref(p)
|
||||
|
||||
# 嵌套 dict
|
||||
inner: dict = dict(mb)
|
||||
inner.set_int("a", 1)
|
||||
d.set_dict("sub", inner)
|
||||
sub: dict = c.Deref(d["sub"])
|
||||
av: int = c.Deref(sub["a"])
|
||||
"""
|
||||
__keys__: t.CVoid | t.CPtr
|
||||
__values__: t.CVoid | t.CPtr
|
||||
__count__: t.CSizeT
|
||||
__capacity__: t.CSizeT
|
||||
__mbuddy__: mbuddy.MBuddy | t.CPtr
|
||||
__iter_index__: t.CSizeT
|
||||
|
||||
def __new__(self, mb: mbuddy.MBuddy | t.CPtr) -> t.CPtr:
|
||||
# 堆分配 dict 对象 (6 字段 × 8 字节 = 48 字节)
|
||||
buf: t.CVoid | t.CPtr = mb.alloc(48)
|
||||
return buf
|
||||
|
||||
def __init__(self, mb: mbuddy.MBuddy | t.CPtr):
|
||||
self.__mbuddy__ = mb
|
||||
self.__count__ = 0
|
||||
self.__capacity__ = 8
|
||||
self.__keys__ = mb.alloc(self.__capacity__ * 8)
|
||||
self.__values__ = mb.alloc(self.__capacity__ * _VARIANT_SIZE)
|
||||
self.__iter_index__ = 0
|
||||
|
||||
def __len__(self) -> t.CSizeT:
|
||||
return self.__count__
|
||||
|
||||
def _find(self, key: str) -> t.CSizeT:
|
||||
"""查找 key 的索引，找不到返回 __count__"""
|
||||
i: t.CSizeT = 0
|
||||
while i < self.__count__:
|
||||
key_ptr: str | t.CPtr = t.CVoid(t.CUInt64T(self.__keys__) + i * 8, t.CPtr)
|
||||
if string.strcmp(key_ptr[0], key) == 0:
|
||||
return i
|
||||
i += 1
|
||||
return self.__count__
|
||||
|
||||
def __getitem__(self, key: str) -> t.CPtr:
|
||||
"""返回值的无类型指针。用户用 c.Deref 解引用获取实际值。
|
||||
例: p: t.CPtr = d["x"]; v: int = c.Deref(p)"""
|
||||
idx: t.CSizeT = self._find(key)
|
||||
if idx >= self.__count__:
|
||||
return None
|
||||
# Variant.ptr 在 Variant 结构体偏移 8 处
|
||||
val_ptr: str | t.CPtr = t.CVoid(t.CUInt64T(self.__values__) + idx * _VARIANT_SIZE + 8, t.CPtr)
|
||||
return val_ptr[0]
|
||||
|
||||
def __setitem__(self, key: str, val: t.CNeedPtr):
|
||||
"""存储值为 VARIANT_PTR。val 自动取地址 (t.CNeedPtr)。
|
||||
注意: val 指向的值生命周期由调用者管理。
|
||||
如需持久存储，请使用 set_int / set_str 等类型化方法。"""
|
||||
self._set_variant_raw(key, VARIANT_PTR, val)
|
||||
|
||||
def _set_variant_raw(self, key: str, vtype: t.CInt, ptr: t.CPtr):
|
||||
"""内部方法: 存储 Variant (vtype + ptr)。不自动取地址。"""
|
||||
idx: t.CSizeT = self._find(key)
|
||||
if idx < self.__count__:
|
||||
# 更新已有键
|
||||
vtype_ptr: t.CInt | t.CPtr = t.CVoid(t.CUInt64T(self.__values__) + idx * _VARIANT_SIZE, t.CPtr)
|
||||
vtype_ptr[0] = vtype
|
||||
val_ptr: str | t.CPtr = t.CVoid(t.CUInt64T(self.__values__) + idx * _VARIANT_SIZE + 8, t.CPtr)
|
||||
val_ptr[0] = ptr
|
||||
return
|
||||
if self.__count__ >= self.__capacity__:
|
||||
new_cap: t.CSizeT = self.__capacity__ * 2
|
||||
new_keys: t.CVoid | t.CPtr = self.__mbuddy__.alloc(new_cap * 8)
|
||||
new_values: t.CVoid | t.CPtr = self.__mbuddy__.alloc(new_cap * _VARIANT_SIZE)
|
||||
if new_keys == None:
|
||||
return
|
||||
if new_values == None:
|
||||
return
|
||||
string.memcpy(new_keys, self.__keys__, self.__count__ * 8)
|
||||
string.memcpy(new_values, self.__values__, self.__count__ * _VARIANT_SIZE)
|
||||
self.__keys__ = new_keys
|
||||
self.__values__ = new_values
|
||||
self.__capacity__ = new_cap
|
||||
key_ptr: str | t.CPtr = t.CVoid(t.CUInt64T(self.__keys__) + self.__count__ * 8, t.CPtr)
|
||||
key_ptr[0] = key
|
||||
vtype_ptr: t.CInt | t.CPtr = t.CVoid(t.CUInt64T(self.__values__) + self.__count__ * _VARIANT_SIZE, t.CPtr)
|
||||
vtype_ptr[0] = vtype
|
||||
val_ptr: str | t.CPtr = t.CVoid(t.CUInt64T(self.__values__) + self.__count__ * _VARIANT_SIZE + 8, t.CPtr)
|
||||
val_ptr[0] = ptr
|
||||
self.__count__ += 1
|
||||
|
||||
# ============================================================
|
||||
# 类型化 setter — 在 __mbuddy__ 中分配持久存储
|
||||
# ============================================================
|
||||
|
||||
def set_int(self, key: str, val: int):
|
||||
"""存储 int 值 (VARIANT_INT)。值复制到 __mbuddy__ 持久存储。"""
|
||||
storage: t.CVoid | t.CPtr = self.__mbuddy__.alloc(8)
|
||||
int_ptr: int | t.CPtr = t.CVoid(t.CUInt64T(storage), t.CPtr)
|
||||
int_ptr[0] = val
|
||||
self._set_variant_raw(key, VARIANT_INT, storage)
|
||||
|
||||
def set_str(self, key: str, val: str):
|
||||
"""存储 str 值 (VARIANT_STR)。直接存储字符串指针。"""
|
||||
self._set_variant_raw(key, VARIANT_STR, val)
|
||||
|
||||
def set_float(self, key: str, val: float):
|
||||
"""存储 float 值 (VARIANT_FLOAT)。值复制到 __mbuddy__ 持久存储。"""
|
||||
storage: t.CVoid | t.CPtr = self.__mbuddy__.alloc(8)
|
||||
float_ptr: float | t.CPtr = t.CVoid(t.CUInt64T(storage), t.CPtr)
|
||||
float_ptr[0] = val
|
||||
self._set_variant_raw(key, VARIANT_FLOAT, storage)
|
||||
|
||||
def set_double(self, key: str, val: t.CDouble):
|
||||
"""存储 double 值 (VARIANT_DOUBLE)。值复制到 __mbuddy__ 持久存储。"""
|
||||
storage: t.CVoid | t.CPtr = self.__mbuddy__.alloc(8)
|
||||
dbl_ptr: t.CDouble | t.CPtr = t.CVoid(t.CUInt64T(storage), t.CPtr)
|
||||
dbl_ptr[0] = val
|
||||
self._set_variant_raw(key, VARIANT_DOUBLE, storage)
|
||||
|
||||
def set_dict(self, key: str, val: dict | t.CPtr):
|
||||
"""存储嵌套 dict 指针 (VARIANT_DICT)。"""
|
||||
self._set_variant_raw(key, VARIANT_DICT, val)
|
||||
|
||||
def set_list(self, key: str, val: t.CPtr):
|
||||
"""存储嵌套 list 指针 (VARIANT_LIST)。"""
|
||||
self._set_variant_raw(key, VARIANT_LIST, val)
|
||||
|
||||
def set_bool(self, key: str, val: t.CInt):
|
||||
"""存储 bool 值 (VARIANT_BOOL)。值复制到 __mbuddy__ 持久存储。"""
|
||||
storage: t.CVoid | t.CPtr = self.__mbuddy__.alloc(8)
|
||||
bool_ptr: t.CInt | t.CPtr = t.CVoid(t.CUInt64T(storage), t.CPtr)
|
||||
bool_ptr[0] = val
|
||||
self._set_variant_raw(key, VARIANT_BOOL, storage)
|
||||
|
||||
# ============================================================
|
||||
# 查询方法
|
||||
# ============================================================
|
||||
|
||||
def get_vtype(self, key: str) -> t.CInt:
|
||||
"""返回 key 对应值的 Variant 类型标签。"""
|
||||
idx: t.CSizeT = self._find(key)
|
||||
if idx >= self.__count__:
|
||||
return VARIANT_NONE
|
||||
vtype_ptr: t.CInt | t.CPtr = t.CVoid(t.CUInt64T(self.__values__) + idx * _VARIANT_SIZE, t.CPtr)
|
||||
return vtype_ptr[0]
|
||||
|
||||
def get(self, key: str, default: t.CPtr) -> t.CPtr:
|
||||
"""返回值指针，不存在则返回 default。"""
|
||||
idx: t.CSizeT = self._find(key)
|
||||
if idx >= self.__count__:
|
||||
return default
|
||||
val_ptr: str | t.CPtr = t.CVoid(t.CUInt64T(self.__values__) + idx * _VARIANT_SIZE + 8, t.CPtr)
|
||||
return val_ptr[0]
|
||||
|
||||
def contains(self, key: str) -> t.CInt:
|
||||
"""检查 key 是否存在。"""
|
||||
idx: t.CSizeT = self._find(key)
|
||||
if idx < self.__count__:
|
||||
return 1
|
||||
return 0
|
||||
|
||||
def __iter__(self) -> dict | t.CPtr:
|
||||
self.__iter_index__ = 0
|
||||
return self
|
||||
|
||||
def __next__(self) -> str:
|
||||
if self.__iter_index__ >= self.__count__:
|
||||
raise StopIteration
|
||||
idx: t.CSizeT = self.__iter_index__
|
||||
self.__iter_index__ = idx + 1
|
||||
key_ptr: str | t.CPtr = t.CVoid(t.CUInt64T(self.__keys__) + idx * 8, t.CPtr)
|
||||
return key_ptr[0]
|
||||
|
||||
# ============================================================
|
||||
# JSON 处理：利用 includes/json 库实现序列化/反序列化
|
||||
# ============================================================
|
||||
|
||||
def to_json(self, pool: mpool.MPool | t.CPtr) -> json.JsonValue | t.CPtr:
|
||||
"""将 dict 转换为 JsonValue 对象 (JSON_OBJECT)。
|
||||
根据 Variant 类型标签自动选择合适的 JSON 值类型。"""
|
||||
obj: json.JsonValue | t.CPtr = json.object(pool)
|
||||
i: t.CSizeT = 0
|
||||
while i < self.__count__:
|
||||
key_ptr: str | t.CPtr = t.CVoid(t.CUInt64T(self.__keys__) + i * 8, t.CPtr)
|
||||
vtype_ptr: t.CInt | t.CPtr = t.CVoid(t.CUInt64T(self.__values__) + i * _VARIANT_SIZE, t.CPtr)
|
||||
val_ptr: str | t.CPtr = t.CVoid(t.CUInt64T(self.__values__) + i * _VARIANT_SIZE + 8, t.CPtr)
|
||||
vt: t.CInt = vtype_ptr[0]
|
||||
vp: t.CPtr = val_ptr[0]
|
||||
jv: json.JsonValue | t.CPtr = json.null(pool)
|
||||
if jv != None:
|
||||
if vt == VARIANT_INT:
|
||||
jv.vtype = 2 # JSON_INT
|
||||
ip: int | t.CPtr = t.CVoid(t.CUInt64T(vp), t.CPtr)
|
||||
jv.int_val = ip[0]
|
||||
elif vt == VARIANT_STR:
|
||||
jv.vtype = 4 # JSON_STRING
|
||||
jv.str_val = vp
|
||||
elif vt == VARIANT_BOOL:
|
||||
jv.vtype = 1 # JSON_BOOL
|
||||
bp: t.CInt | t.CPtr = t.CVoid(t.CUInt64T(vp), t.CPtr)
|
||||
jv.bool_val = bp[0]
|
||||
elif vt == VARIANT_FLOAT:
|
||||
jv.vtype = 3 # JSON_FLOAT
|
||||
fp: float | t.CPtr = t.CVoid(t.CUInt64T(vp), t.CPtr)
|
||||
jv.float_val = fp[0]
|
||||
elif vt == VARIANT_PTR:
|
||||
# 默认: 将 PTR 作为整数处理
|
||||
jv.vtype = 2 # JSON_INT
|
||||
ip: int | t.CPtr = t.CVoid(t.CUInt64T(vp), t.CPtr)
|
||||
jv.int_val = ip[0]
|
||||
json.object_set(pool, obj, key_ptr[0], jv)
|
||||
i += 1
|
||||
return obj
|
||||
|
||||
def from_json(self, pool: mpool.MPool | t.CPtr, root: json.JsonValue | t.CPtr):
|
||||
"""从 JsonValue 对象填充 dict。
|
||||
根据 JSON 值类型自动提取并存储为对应 Variant 类型。"""
|
||||
if root == None:
|
||||
return
|
||||
if root.vtype != 6: # JSON_OBJECT
|
||||
return
|
||||
cur: json.JsonValue | t.CPtr = root.child
|
||||
while cur != None:
|
||||
if cur.key != None:
|
||||
if cur.vtype == 2: # JSON_INT
|
||||
storage: t.CVoid | t.CPtr = self.__mbuddy__.alloc(8)
|
||||
ip: int | t.CPtr = t.CVoid(t.CUInt64T(storage), t.CPtr)
|
||||
ip[0] = cur.int_val
|
||||
self._set_variant_raw(cur.key, VARIANT_INT, storage)
|
||||
elif cur.vtype == 4: # JSON_STRING
|
||||
self._set_variant_raw(cur.key, VARIANT_STR, cur.str_val)
|
||||
elif cur.vtype == 1: # JSON_BOOL
|
||||
storage: t.CVoid | t.CPtr = self.__mbuddy__.alloc(8)
|
||||
bp: t.CInt | t.CPtr = t.CVoid(t.CUInt64T(storage), t.CPtr)
|
||||
bp[0] = cur.bool_val
|
||||
self._set_variant_raw(cur.key, VARIANT_BOOL, storage)
|
||||
elif cur.vtype == 3: # JSON_FLOAT
|
||||
storage: t.CVoid | t.CPtr = self.__mbuddy__.alloc(8)
|
||||
fp: float | t.CPtr = t.CVoid(t.CUInt64T(storage), t.CPtr)
|
||||
fp[0] = cur.float_val
|
||||
self._set_variant_raw(cur.key, VARIANT_FLOAT, storage)
|
||||
cur = cur.next
|
||||
|
||||
def dumps(self, pool: mpool.MPool | t.CPtr) -> str:
|
||||
"""将 dict 序列化为 JSON 字符串。"""
|
||||
obj: json.JsonValue | t.CPtr = self.to_json(pool)
|
||||
return json.write(pool, obj, False)
|
||||
|
||||
def loads(self, pool: mpool.MPool | t.CPtr, json_str: str):
|
||||
"""从 JSON 字符串解析并填充 dict。"""
|
||||
root: json.JsonValue | t.CPtr = json.parse(pool, json_str)
|
||||
self.from_json(pool, root)
|
||||
325
includes/_fakeduck.py
Normal file
325
includes/_fakeduck.py
Normal file
@@ -0,0 +1,325 @@
|
||||
import t
|
||||
import mbuddy
|
||||
import string
|
||||
|
||||
|
||||
class _Type:
|
||||
def type_id(self) -> int:
|
||||
return 99
|
||||
|
||||
|
||||
class _str:
|
||||
# 编译期元数据：声明此类希望从 with 上下文获取 __mbuddy__ 字段（非必要，找不到不报错）
|
||||
__requires__: list[str] = ['__mbuddy__']
|
||||
__data__: str
|
||||
__mbuddy__: mbuddy.MBuddy | t.CPtr
|
||||
|
||||
def b(self) -> int:
|
||||
return 42
|
||||
|
||||
def SELF(self) -> str:
|
||||
return self.__data__
|
||||
|
||||
def upper(self) -> str:
|
||||
src: str = self.__data__
|
||||
length: t.CSizeT = len(src)
|
||||
buf: bytes = self.__mbuddy__.alloc(length + 1)
|
||||
if buf == None: return self.__data__
|
||||
for i, ch in enumerate(src):
|
||||
if ch >= 97:
|
||||
if ch <= 122:
|
||||
buf[i] = ch - 32
|
||||
else:
|
||||
buf[i] = ch
|
||||
else:
|
||||
buf[i] = ch
|
||||
buf[length] = 0
|
||||
return str(buf)
|
||||
|
||||
def lower(self) -> str:
|
||||
src: str = self.__data__
|
||||
length: t.CSizeT = len(src)
|
||||
buf: bytes = self.__mbuddy__.alloc(length + 1)
|
||||
if buf == None: return self.__data__
|
||||
for i, ch in enumerate(src):
|
||||
if ch >= 65:
|
||||
if ch <= 90:
|
||||
buf[i] = ch + 32
|
||||
else:
|
||||
buf[i] = ch
|
||||
else:
|
||||
buf[i] = ch
|
||||
buf[length] = 0
|
||||
return str(buf)
|
||||
|
||||
def capitalize(self) -> str:
|
||||
src: str = self.__data__
|
||||
length: t.CSizeT = len(src)
|
||||
buf: bytes = self.__mbuddy__.alloc(length + 1)
|
||||
if buf == None: return self.__data__
|
||||
first: bool = True
|
||||
for i, ch in enumerate(src):
|
||||
if first:
|
||||
first = False
|
||||
if ch >= 97:
|
||||
if ch <= 122:
|
||||
buf[i] = ch - 32
|
||||
else:
|
||||
buf[i] = ch
|
||||
else:
|
||||
buf[i] = ch
|
||||
else:
|
||||
if ch >= 65:
|
||||
if ch <= 90:
|
||||
buf[i] = ch + 32
|
||||
else:
|
||||
buf[i] = ch
|
||||
else:
|
||||
buf[i] = ch
|
||||
buf[length] = 0
|
||||
return str(buf)
|
||||
|
||||
def swapcase(self) -> str:
|
||||
src: str = self.__data__
|
||||
length: t.CSizeT = len(src)
|
||||
buf: bytes = self.__mbuddy__.alloc(length + 1)
|
||||
if buf == None: return self.__data__
|
||||
for i, ch in enumerate(src):
|
||||
if ch >= 97:
|
||||
if ch <= 122:
|
||||
buf[i] = ch - 32
|
||||
else:
|
||||
buf[i] = ch
|
||||
else:
|
||||
if ch >= 65:
|
||||
if ch <= 90:
|
||||
buf[i] = ch + 32
|
||||
else:
|
||||
buf[i] = ch
|
||||
else:
|
||||
buf[i] = ch
|
||||
buf[length] = 0
|
||||
return str(buf)
|
||||
|
||||
def title(self) -> str:
|
||||
src: str = self.__data__
|
||||
length: t.CSizeT = len(src)
|
||||
buf: bytes = self.__mbuddy__.alloc(length + 1)
|
||||
if buf == None: return self.__data__
|
||||
prev_alpha: bool = False
|
||||
for i, ch in enumerate(src):
|
||||
cur_alpha: bool = False
|
||||
if ch >= 65:
|
||||
if ch <= 90:
|
||||
cur_alpha = True
|
||||
else:
|
||||
if ch >= 97:
|
||||
if ch <= 122:
|
||||
cur_alpha = True
|
||||
if cur_alpha:
|
||||
if prev_alpha:
|
||||
if ch >= 65:
|
||||
if ch <= 90:
|
||||
buf[i] = ch + 32
|
||||
else:
|
||||
buf[i] = ch
|
||||
else:
|
||||
buf[i] = ch
|
||||
else:
|
||||
if ch >= 97:
|
||||
if ch <= 122:
|
||||
buf[i] = ch - 32
|
||||
else:
|
||||
buf[i] = ch
|
||||
else:
|
||||
buf[i] = ch
|
||||
else:
|
||||
buf[i] = ch
|
||||
prev_alpha = cur_alpha
|
||||
buf[length] = 0
|
||||
return str(buf)
|
||||
|
||||
def casefold(self) -> str:
|
||||
src: str = self.__data__
|
||||
length: t.CSizeT = len(src)
|
||||
buf: bytes = self.__mbuddy__.alloc(length + 1)
|
||||
if buf == None: return self.__data__
|
||||
for i, ch in enumerate(src):
|
||||
if ch >= 65:
|
||||
if ch <= 90:
|
||||
buf[i] = ch + 32
|
||||
else:
|
||||
buf[i] = ch
|
||||
else:
|
||||
buf[i] = ch
|
||||
buf[length] = 0
|
||||
return str(buf)
|
||||
|
||||
def isupper(self) -> bool:
|
||||
src: str = self.__data__
|
||||
has_alpha: bool = False
|
||||
for ch in src:
|
||||
if ch >= 65:
|
||||
if ch <= 90:
|
||||
has_alpha = True
|
||||
else:
|
||||
if ch >= 97:
|
||||
if ch <= 122:
|
||||
return False
|
||||
return has_alpha
|
||||
|
||||
def islower(self) -> bool:
|
||||
src: str = self.__data__
|
||||
has_alpha: bool = False
|
||||
for ch in src:
|
||||
if ch >= 97:
|
||||
if ch <= 122:
|
||||
has_alpha = True
|
||||
if ch >= 65:
|
||||
if ch <= 90:
|
||||
return False
|
||||
return has_alpha
|
||||
|
||||
def isalpha(self) -> bool:
|
||||
src: str = self.__data__
|
||||
has_char: bool = False
|
||||
for ch in src:
|
||||
has_char = True
|
||||
cur_alpha: bool = False
|
||||
if ch >= 65:
|
||||
if ch <= 90:
|
||||
cur_alpha = True
|
||||
else:
|
||||
if ch >= 97:
|
||||
if ch <= 122:
|
||||
cur_alpha = True
|
||||
if not cur_alpha:
|
||||
return False
|
||||
return has_char
|
||||
|
||||
def isdigit(self) -> bool:
|
||||
src: str = self.__data__
|
||||
has_char: bool = False
|
||||
for ch in src:
|
||||
has_char = True
|
||||
if ch >= 48:
|
||||
if ch > 57:
|
||||
return False
|
||||
else:
|
||||
return False
|
||||
return has_char
|
||||
|
||||
def isalnum(self) -> bool:
|
||||
src: str = self.__data__
|
||||
has_char: bool = False
|
||||
for ch in src:
|
||||
has_char = True
|
||||
ok: bool = False
|
||||
if ch >= 48:
|
||||
if ch <= 57:
|
||||
ok = True
|
||||
if not ok:
|
||||
if ch >= 65:
|
||||
if ch <= 90:
|
||||
ok = True
|
||||
else:
|
||||
if ch >= 97:
|
||||
if ch <= 122:
|
||||
ok = True
|
||||
if not ok:
|
||||
return False
|
||||
return has_char
|
||||
|
||||
def isspace(self) -> bool:
|
||||
src: str = self.__data__
|
||||
has_char: bool = False
|
||||
for ch in src:
|
||||
has_char = True
|
||||
is_space: bool = False
|
||||
if ch == 32 or ch == 9 or ch == 10 or ch == 13 or ch == 11 or ch == 12:
|
||||
is_space = True
|
||||
if not is_space:
|
||||
return False
|
||||
return has_char
|
||||
|
||||
def isascii(self) -> bool:
|
||||
src: str = self.__data__
|
||||
has_char: bool = False
|
||||
for ch in src:
|
||||
has_char = True
|
||||
if ch > 127: return False
|
||||
return has_char
|
||||
|
||||
def istitle(self) -> bool:
|
||||
src: str = self.__data__
|
||||
has_char: bool = False
|
||||
prev_alpha: bool = False
|
||||
for ch in src:
|
||||
has_char = True
|
||||
cur_alpha: bool = False
|
||||
if ch >= 65:
|
||||
if ch <= 90:
|
||||
cur_alpha = True
|
||||
else:
|
||||
if ch >= 97:
|
||||
if ch <= 122:
|
||||
cur_alpha = True
|
||||
if cur_alpha:
|
||||
if not prev_alpha:
|
||||
if ch >= 97:
|
||||
if ch <= 122:
|
||||
return False
|
||||
else:
|
||||
if ch >= 65:
|
||||
if ch <= 90:
|
||||
return False
|
||||
prev_alpha = cur_alpha
|
||||
return has_char
|
||||
|
||||
def split(self, delimiter: str) -> list[str]:
|
||||
result = list[str](self.__mbuddy__)
|
||||
src: str = self.__data__
|
||||
length: t.CSizeT = len(src)
|
||||
delim_len: t.CSizeT = string.strlen(delimiter)
|
||||
start: t.CSizeT = 0
|
||||
i: t.CSizeT = 0
|
||||
cur: str = src
|
||||
sub_len: t.CSizeT = 0
|
||||
sub: bytes = None
|
||||
src_off: bytes = None
|
||||
term: bytes = None
|
||||
if delim_len == 0:
|
||||
sub_len = length
|
||||
sub = self.__mbuddy__.alloc(sub_len + 1)
|
||||
if sub != None:
|
||||
src_off = bytes(t.CUInt64T(src) + start)
|
||||
string.memcpy(sub, src_off, sub_len)
|
||||
term = sub
|
||||
term[sub_len] = 0
|
||||
result.append(str(sub))
|
||||
return result
|
||||
while i + delim_len <= length:
|
||||
if string.strncmp(cur, delimiter, delim_len) == 0:
|
||||
sub_len = i - start
|
||||
sub = self.__mbuddy__.alloc(sub_len + 1)
|
||||
if sub != None:
|
||||
src_off = bytes(t.CUInt64T(src) + start)
|
||||
string.memcpy(sub, src_off, sub_len)
|
||||
term = sub
|
||||
term[sub_len] = 0
|
||||
result.append(str(sub))
|
||||
start = i + delim_len
|
||||
cur += delim_len
|
||||
i += delim_len
|
||||
else:
|
||||
cur += 1
|
||||
i += 1
|
||||
sub_len = length - start
|
||||
sub = self.__mbuddy__.alloc(sub_len + 1)
|
||||
if sub != None:
|
||||
src_off = bytes(t.CUInt64T(src) + start)
|
||||
string.memcpy(sub, src_off, sub_len)
|
||||
term = sub
|
||||
term[sub_len] = 0
|
||||
result.append(str(sub))
|
||||
return result
|
||||
85
includes/_list.py
Normal file
85
includes/_list.py
Normal file
@@ -0,0 +1,85 @@
|
||||
import t, c
|
||||
import mbuddy
|
||||
import string
|
||||
from stdint import *
|
||||
|
||||
|
||||
class list[T]:
|
||||
"""堆上动态列表容器，基于 mbuddy 分配器。
|
||||
|
||||
用法:
|
||||
mb: mbuddy.MBuddy = mbuddy.MBuddy(arena, arena_size)
|
||||
nums: list[int] = list[int](mb)
|
||||
nums.append(42)
|
||||
x: int = nums.get(0)
|
||||
"""
|
||||
__data__: t.CVoid | t.CPtr
|
||||
__count__: t.CSizeT
|
||||
__capacity__: t.CSizeT
|
||||
__mbuddy__: mbuddy.MBuddy | t.CPtr
|
||||
__iter_index__: t.CSizeT
|
||||
|
||||
def __new__(self, mb: mbuddy.MBuddy | t.CPtr):
|
||||
# 堆分配 list[T] 对象 (5 字段 × 8 字节 = 40 字节)
|
||||
# 避免栈上分配导致返回后 use-after-free
|
||||
buf: t.CVoid | t.CPtr = mb.alloc(40)
|
||||
return buf
|
||||
|
||||
def __init__(self, mb: mbuddy.MBuddy | t.CPtr):
|
||||
self.__mbuddy__ = mb
|
||||
self.__count__ = 0
|
||||
self.__capacity__ = 8
|
||||
self.__data__ = mb.alloc(self.__capacity__ * T.__sizeof__())
|
||||
self.__iter_index__ = 0
|
||||
|
||||
def __len__(self) -> t.CSizeT:
|
||||
return self.__count__
|
||||
|
||||
def append(self, item: T):
|
||||
if self.__count__ >= self.__capacity__:
|
||||
new_cap: t.CSizeT = self.__capacity__ * 2
|
||||
new_data: t.CVoid | t.CPtr = self.__mbuddy__.alloc(new_cap * T.__sizeof__())
|
||||
if new_data == None:
|
||||
return
|
||||
string.memcpy(new_data, self.__data__, self.__count__ * T.__sizeof__())
|
||||
self.__data__ = new_data
|
||||
self.__capacity__ = new_cap
|
||||
elem_ptr: T | t.CPtr = t.CVoid(t.CUInt64T(self.__data__) + self.__count__ * T.__sizeof__(), t.CPtr)
|
||||
elem_ptr[0] = item
|
||||
self.__count__ += 1
|
||||
|
||||
def get(self, index: t.CSizeT) -> T:
|
||||
elem_ptr: T | t.CPtr = t.CVoid(t.CUInt64T(self.__data__) + index * T.__sizeof__(), t.CPtr)
|
||||
return elem_ptr[0]
|
||||
|
||||
def __getitem__(self, index: t.CSizeT) -> T:
|
||||
elem_ptr: T | t.CPtr = t.CVoid(t.CUInt64T(self.__data__) + index * T.__sizeof__(), t.CPtr)
|
||||
return elem_ptr[0]
|
||||
|
||||
def set(self, index: t.CSizeT, value: T):
|
||||
elem_ptr: T | t.CPtr = t.CVoid(t.CUInt64T(self.__data__) + index * T.__sizeof__(), t.CPtr)
|
||||
elem_ptr[0] = value
|
||||
|
||||
def __setitem__(self, index: t.CSizeT, value: T):
|
||||
elem_ptr: T | t.CPtr = t.CVoid(t.CUInt64T(self.__data__) + index * T.__sizeof__(), t.CPtr)
|
||||
elem_ptr[0] = value
|
||||
|
||||
def pop(self) -> T:
|
||||
self.__count__ -= 1
|
||||
elem_ptr: T | t.CPtr = t.CVoid(t.CUInt64T(self.__data__) + self.__count__ * T.__sizeof__(), t.CPtr)
|
||||
return elem_ptr[0]
|
||||
|
||||
def clear(self):
|
||||
self.__count__ = 0
|
||||
|
||||
def __iter__(self):
|
||||
self.__iter_index__ = 0
|
||||
return self
|
||||
|
||||
def __next__(self) -> T:
|
||||
if self.__iter_index__ >= self.__count__:
|
||||
raise StopIteration
|
||||
idx: t.CSizeT = self.__iter_index__
|
||||
self.__iter_index__ = idx + 1
|
||||
elem_ptr: T | t.CPtr = t.CVoid(t.CUInt64T(self.__data__) + idx * T.__sizeof__(), t.CPtr)
|
||||
return elem_ptr[0]
|
||||
64
includes/_variant.py
Normal file
64
includes/_variant.py
Normal file
@@ -0,0 +1,64 @@
|
||||
import t, c
|
||||
from stdint import *
|
||||
|
||||
# Variant 类型标签 (固定枚举 + 自定义 PTR)
|
||||
VARIANT_NONE: t.CDefine = 0 # 无类型/空值
|
||||
VARIANT_INT: t.CDefine = 1 # int (i64)
|
||||
VARIANT_FLOAT: t.CDefine = 2 # float (f32)
|
||||
VARIANT_DOUBLE: t.CDefine = 3 # double (f64)
|
||||
VARIANT_STR: t.CDefine = 4 # str (i8*)
|
||||
VARIANT_DICT: t.CDefine = 5 # dict*
|
||||
VARIANT_LIST: t.CDefine = 6 # list*
|
||||
VARIANT_BOOL: t.CDefine = 7 # bool (i1/i32)
|
||||
VARIANT_PTR: t.CDefine = 8 # 自定义指针类型
|
||||
|
||||
|
||||
class Variant:
|
||||
"""通用变体类型，存储类型标签 + 无类型指针。
|
||||
用于 dict/list 的万能对象存储，支持嵌套和 JSON 序列化。
|
||||
|
||||
用法:
|
||||
v: Variant = Variant(VARIANT_INT, t.CNeedPtr(42))
|
||||
v2: Variant = Variant(VARIANT_STR, t.CNeedPtr("hello"))
|
||||
|
||||
# 获取值
|
||||
ptr: t.CPtr = v.ptr
|
||||
i: int = c.Deref(ptr)
|
||||
"""
|
||||
vtype: t.CInt
|
||||
ptr: t.CPtr
|
||||
|
||||
def __init__(self, vtype: t.CInt, val: t.CNeedPtr):
|
||||
"""构造 Variant。
|
||||
val 使用 t.CNeedPtr 自动取地址（非指针值自动 alloca+store）。
|
||||
注意: val 的生命周期由调用者管理，Variant 仅存储指针。
|
||||
"""
|
||||
self.vtype = vtype
|
||||
self.ptr = val
|
||||
|
||||
def is_none(self) -> t.CInt:
|
||||
return self.vtype == VARIANT_NONE
|
||||
|
||||
def is_int(self) -> t.CInt:
|
||||
return self.vtype == VARIANT_INT
|
||||
|
||||
def is_float(self) -> t.CInt:
|
||||
return self.vtype == VARIANT_FLOAT
|
||||
|
||||
def is_double(self) -> t.CInt:
|
||||
return self.vtype == VARIANT_DOUBLE
|
||||
|
||||
def is_str(self) -> t.CInt:
|
||||
return self.vtype == VARIANT_STR
|
||||
|
||||
def is_dict(self) -> t.CInt:
|
||||
return self.vtype == VARIANT_DICT
|
||||
|
||||
def is_list(self) -> t.CInt:
|
||||
return self.vtype == VARIANT_LIST
|
||||
|
||||
def is_bool(self) -> t.CInt:
|
||||
return self.vtype == VARIANT_BOOL
|
||||
|
||||
def is_ptr(self) -> t.CInt:
|
||||
return self.vtype == VARIANT_PTR
|
||||
69
includes/_withcontent.py
Normal file
69
includes/_withcontent.py
Normal file
@@ -0,0 +1,69 @@
|
||||
import t, c
|
||||
from stdint import *
|
||||
from w32.win32process import TlsAlloc, TlsGetValue, TlsSetValue
|
||||
import stdlib
|
||||
import stdio
|
||||
import string
|
||||
|
||||
|
||||
# 最大提供者栈深度（编译器会检查是否够用，不够再往上提）
|
||||
_MAX_PROVIDER_DEPTH: t.CDefine = 32
|
||||
|
||||
|
||||
@t.Object
|
||||
class _ProviderStack:
|
||||
"""提供者栈，存储字段名和指针对。"""
|
||||
names: t.CArray[VOIDPTR, 32]
|
||||
ptrs: t.CArray[VOIDPTR, 32]
|
||||
top: UINT64
|
||||
|
||||
|
||||
# TLS 索引（全局，所有线程共享同一个索引）
|
||||
_tls_index: ULONG = 0
|
||||
|
||||
|
||||
@t.TLS
|
||||
def _init_tls():
|
||||
"""初始化 TLS 索引（一次性执行，后续调用跳过）。"""
|
||||
global _tls_index
|
||||
_tls_index = TlsAlloc()
|
||||
|
||||
|
||||
def _get_stack() -> _ProviderStack | t.CPtr:
|
||||
"""获取当前线程的提供者栈，不存在则分配。"""
|
||||
_init_tls()
|
||||
stack: _ProviderStack | t.CPtr = TlsGetValue(_tls_index)
|
||||
if stack == None:
|
||||
stack = stdlib.malloc(_ProviderStack.__sizeof__())
|
||||
string.memset(stack, 0, _ProviderStack.__sizeof__())
|
||||
TlsSetValue(_tls_index, stack)
|
||||
return stack
|
||||
|
||||
|
||||
def _push_provider(field_name: str, ptr: t.CPtr):
|
||||
"""压入提供者 (field_name, ptr) 到栈中。"""
|
||||
stack: _ProviderStack | t.CPtr = _get_stack()
|
||||
if stack.top >= _MAX_PROVIDER_DEPTH:
|
||||
stdio.printf("[with] ERROR: provider stack overflow (depth=%lu, max=%d), field '%s' not injected\n", stack.top, _MAX_PROVIDER_DEPTH, field_name)
|
||||
return
|
||||
stack.names[stack.top] = field_name
|
||||
stack.ptrs[stack.top] = ptr
|
||||
stack.top = stack.top + 1
|
||||
|
||||
|
||||
def _pop_provider():
|
||||
"""弹出栈顶提供者。"""
|
||||
stack: _ProviderStack | t.CPtr = _get_stack()
|
||||
if stack.top > 0:
|
||||
stack.top = stack.top - 1
|
||||
|
||||
|
||||
def _find_provider(field_name: str) -> t.CPtr:
|
||||
"""从栈顶向下查找匹配 field_name 的提供者，返回对应的指针。找不到返回 NULL。"""
|
||||
stack: _ProviderStack | t.CPtr = _get_stack()
|
||||
i: UINT64 = stack.top
|
||||
while i > 0:
|
||||
i = i - 1
|
||||
if string.strcmp(stack.names[i], field_name) == 0:
|
||||
return stack.ptrs[i]
|
||||
return None
|
||||
@@ -9,7 +9,7 @@ ATOMIC_ACQ_REL: t.CDefine = 4
|
||||
ATOMIC_SEQ_CST: t.CDefine = 5
|
||||
|
||||
|
||||
def __atomic_test_and_set(ptr: t.CUInt64T | t.CPtr, order: t.CInt) -> t.CBool | t.State:
|
||||
def __atomic_test_and_set(ptr: t.CUInt64T | t.CPtr, order: t.CInt) -> t.CBool:
|
||||
result: t.CUInt8T = 1
|
||||
c.Asm(f"""mov al, 1
|
||||
xchg byte ptr [{c.AsmInp(ptr, t.ASM_DESCR.REG_ANY)}], al
|
||||
@@ -20,23 +20,23 @@ def __atomic_test_and_set(ptr: t.CUInt64T | t.CPtr, order: t.CInt) -> t.CBool |
|
||||
return t.CBool(result)
|
||||
|
||||
|
||||
def __atomic_clear(ptr: t.CUInt64T | t.CPtr, order: t.CInt) -> t.CVoid | t.State:
|
||||
def __atomic_clear(ptr: t.CUInt64T | t.CPtr, order: t.CInt) -> t.CVoid:
|
||||
c.Asm(f"""mov byte ptr [{c.AsmInp(ptr, t.ASM_DESCR.REG_ANY)}], 0""",
|
||||
inp = [c.AsmInp(ptr, t.ASM_DESCR.REG_ANY)],
|
||||
op = [t.ASM_DESCR.CLOBBER_MEMORY])
|
||||
|
||||
|
||||
def __atomic_thread_fence(order: t.CInt) -> t.CVoid | t.State:
|
||||
def __atomic_thread_fence(order: t.CInt) -> t.CVoid:
|
||||
c.Asm("mfence", op=[t.ASM_DESCR.CLOBBER_MEMORY])
|
||||
|
||||
|
||||
def __atomic_signal_fence(order: t.CInt) -> t.CVoid | t.State:
|
||||
def __atomic_signal_fence(order: t.CInt) -> t.CVoid:
|
||||
pass
|
||||
|
||||
|
||||
def __atomic_always_lock_free(size: t.CSizeT, ptr: t.CVoid | t.CPtr) -> t.CBool | t.State:
|
||||
def __atomic_always_lock_free(size: t.CSizeT, ptr: t.CVoid | t.CPtr) -> t.CBool:
|
||||
return t.CBool(1)
|
||||
|
||||
|
||||
def __atomic_is_lock_free(size: t.CSizeT, ptr: t.CVoid | t.CPtr) -> t.CBool | t.State:
|
||||
def __atomic_is_lock_free(size: t.CSizeT, ptr: t.CVoid | t.CPtr) -> t.CBool:
|
||||
return t.CBool(1)
|
||||
|
||||
@@ -5,10 +5,10 @@ import t, c
|
||||
# Base64 编解码 纯裸实现
|
||||
# ==============================================
|
||||
# Base64 编码对照表
|
||||
b64_tab: list[t.CChar, None] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
|
||||
b64_tab: t.CArray[t.CChar, None] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
|
||||
|
||||
# Base64 反向解码表，映射字符到索引值
|
||||
b64_dec_tab: list[t.CInt8T, 80] = [
|
||||
b64_dec_tab: t.CArray[t.CInt8T, 80] = [
|
||||
62, -1, -1, -1, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
|
||||
-1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
|
||||
10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
|
||||
|
||||
@@ -1,13 +1,13 @@
|
||||
import t, c
|
||||
|
||||
|
||||
HEX_CHARS: list[t.CChar, None] = "0123456789abcdef"
|
||||
HEX_VALS: list[t.CInt, 256]
|
||||
HEX_CHARS: t.CArray[t.CChar, None] = "0123456789abcdef"
|
||||
HEX_VALS: t.CArray[t.CInt, 256]
|
||||
|
||||
B64_CHARS: list[t.CChar, None] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
|
||||
B64_VALS: list[t.CInt, 256]
|
||||
B64_CHARS: t.CArray[t.CChar, None] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
|
||||
B64_VALS: t.CArray[t.CInt, 256]
|
||||
|
||||
HQX_CHARS: list[t.CChar, 64] = [
|
||||
HQX_CHARS: t.CArray[t.CChar, 64] = [
|
||||
' ', '!', chr(34), '#', '$', '%', '&', "'", '(', ')', '*', '+', ',', '-', '.', '/',
|
||||
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
|
||||
'@',
|
||||
@@ -16,11 +16,11 @@ HQX_CHARS: list[t.CChar, 64] = [
|
||||
'[', chr(92), '`',
|
||||
'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm'
|
||||
]
|
||||
HQX_VALS: list[t.CInt, 256]
|
||||
HQX_VALS: t.CArray[t.CInt, 256]
|
||||
|
||||
UU_CHARS: list[t.CChar, None] = " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_"
|
||||
UU_CHARS: t.CArray[t.CChar, None] = " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_"
|
||||
|
||||
CRC32_TABLE: list[t.CUnsignedInt, 256] = [
|
||||
CRC32_TABLE: t.CArray[t.CUnsignedInt, 256] = [
|
||||
0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3,
|
||||
0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91,
|
||||
0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,
|
||||
@@ -55,7 +55,7 @@ CRC32_TABLE: list[t.CUnsignedInt, 256] = [
|
||||
0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
|
||||
]
|
||||
|
||||
CRC_HQX_TABLE: list[t.CUnsignedShort, 256] = [
|
||||
CRC_HQX_TABLE: t.CArray[t.CUnsignedShort, 256] = [
|
||||
0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
|
||||
0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
|
||||
0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
|
||||
|
||||
53
includes/condition.py
Normal file
53
includes/condition.py
Normal file
@@ -0,0 +1,53 @@
|
||||
import t, c
|
||||
from stdint import *
|
||||
from w32.win32base import *
|
||||
from w32.win32sync import (
|
||||
CRITICAL_SECTION,
|
||||
InitializeCriticalSection, EnterCriticalSection, LeaveCriticalSection, DeleteCriticalSection,
|
||||
InitializeConditionVariable, SleepConditionVariableCS,
|
||||
WakeConditionVariable, WakeAllConditionVariable
|
||||
)
|
||||
|
||||
|
||||
@t.Object
|
||||
class Condition:
|
||||
"""基于 Windows 条件变量的条件变量，内部包含 CRITICAL_SECTION。
|
||||
|
||||
用法:
|
||||
cond: Condition = Condition()
|
||||
with cond:
|
||||
while not ready:
|
||||
cond.wait()
|
||||
cond.notify()
|
||||
"""
|
||||
cond_var: VOIDPTR
|
||||
cs: CRITICAL_SECTION
|
||||
|
||||
def __init__(self):
|
||||
InitializeCriticalSection(c.Addr(self.cs))
|
||||
InitializeConditionVariable(c.Addr(self.cond_var))
|
||||
|
||||
def wait(self, timeout_ms: ULONG = INFINITE) -> BOOL:
|
||||
return SleepConditionVariableCS(c.Addr(self.cond_var), c.Addr(self.cs), timeout_ms)
|
||||
|
||||
def notify(self):
|
||||
WakeConditionVariable(c.Addr(self.cond_var))
|
||||
|
||||
def notify_all(self):
|
||||
WakeAllConditionVariable(c.Addr(self.cond_var))
|
||||
|
||||
def acquire(self):
|
||||
EnterCriticalSection(c.Addr(self.cs))
|
||||
|
||||
def release(self):
|
||||
LeaveCriticalSection(c.Addr(self.cs))
|
||||
|
||||
def __enter__(self) -> 'Condition' | t.CPtr:
|
||||
self.acquire()
|
||||
return self
|
||||
|
||||
def __exit__(self):
|
||||
self.release()
|
||||
|
||||
def delete(self):
|
||||
DeleteCriticalSection(c.Addr(self.cs))
|
||||
20
includes/ctraits.pyi
Normal file
20
includes/ctraits.pyi
Normal file
@@ -0,0 +1,20 @@
|
||||
"""ctraits — 编译时类型特征库
|
||||
|
||||
提供编译时类型判断函数，不纳入运行时编译。
|
||||
所有函数仅在编译时求值，可与 c.CIf 等编译时条件配合使用。
|
||||
"""
|
||||
import t
|
||||
|
||||
|
||||
def isptr(x: t.CType) -> bool:
|
||||
"""编译时判断 x 的类型是否为指针类型。
|
||||
|
||||
返回 True 如果 x 是指针（ptr_count > 0），否则返回 False。
|
||||
可与 c.CIf 配合使用实现条件编译。
|
||||
|
||||
示例:
|
||||
if c.CIf(ctraits.isptr(my_var)):
|
||||
# 仅当 my_var 是指针类型时编译此分支
|
||||
...
|
||||
"""
|
||||
pass
|
||||
36
includes/event.py
Normal file
36
includes/event.py
Normal file
@@ -0,0 +1,36 @@
|
||||
import t, c
|
||||
from stdint import *
|
||||
from w32.win32base import *
|
||||
from w32.win32sync import CreateEventA, SetEvent, ResetEvent, WaitForSingleObject
|
||||
|
||||
|
||||
@t.Object
|
||||
class Event:
|
||||
"""基于 Windows Event 的事件对象，支持手动/自动重置。
|
||||
|
||||
用法:
|
||||
evt: Event = Event(FALSE, FALSE)
|
||||
evt.set()
|
||||
evt.wait()
|
||||
"""
|
||||
handle: HANDLE
|
||||
manual_reset: BOOL
|
||||
|
||||
def __init__(self, manual_reset: BOOL = FALSE, initial_state: BOOL = FALSE):
|
||||
self.manual_reset = manual_reset
|
||||
self.handle = CreateEventA(NULL, manual_reset, initial_state, NULL)
|
||||
|
||||
def set(self):
|
||||
SetEvent(self.handle)
|
||||
|
||||
def clear(self):
|
||||
ResetEvent(self.handle)
|
||||
|
||||
def is_set(self) -> BOOL:
|
||||
return WaitForSingleObject(self.handle, 0) == WAIT_OBJECT_0
|
||||
|
||||
def wait(self, timeout_ms: ULONG = INFINITE) -> BOOL:
|
||||
return WaitForSingleObject(self.handle, timeout_ms) == WAIT_OBJECT_0
|
||||
|
||||
def close(self):
|
||||
CloseHandle(self.handle)
|
||||
@@ -16,7 +16,7 @@ def md5_I(x: t.CUInt32T, y: t.CUInt32T, z: t.CUInt32T) -> t.CUInt32T: return y ^
|
||||
def md5_rotl(x: t.CUInt32T, n: t.CInt) -> t.CUInt32T: return (x << n) | (x >> (32 - n))
|
||||
|
||||
# MD5 常量表、移位表
|
||||
md5_T: list[t.CUInt32T, 64] = [
|
||||
md5_T: t.CArray[t.CUInt32T, 64] = [
|
||||
0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee, 0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
|
||||
0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be, 0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,
|
||||
0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa, 0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8,
|
||||
@@ -27,7 +27,7 @@ md5_T: list[t.CUInt32T, 64] = [
|
||||
0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1, 0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391
|
||||
]
|
||||
|
||||
md5_S: list[t.CInt, 64] = [
|
||||
md5_S: t.CArray[t.CInt, 64] = [
|
||||
7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22,
|
||||
5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20,
|
||||
4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23,
|
||||
@@ -37,9 +37,9 @@ md5_S: list[t.CInt, 64] = [
|
||||
# MD5 上下文结构体
|
||||
@t.Object
|
||||
class md5:
|
||||
state: list[t.CUInt32T, 4] # 4个32位状态寄存器
|
||||
state: t.CArray[t.CUInt32T, 4] # 4个32位状态寄存器
|
||||
count: t.CUInt64T # 已处理比特数
|
||||
buf: list[t.CUInt8T, MD5_BLOCK_LEN] # 分组缓冲区
|
||||
buf: t.CArray[t.CUInt8T, MD5_BLOCK_LEN] # 分组缓冲区
|
||||
# 初始化MD5上下文
|
||||
def __init__(self):
|
||||
memset(self.buf, 0, MD5_BLOCK_LEN)
|
||||
@@ -54,7 +54,7 @@ class md5:
|
||||
b: t.CUInt32T = self.state[1]
|
||||
c: t.CUInt32T = self.state[2]
|
||||
d: t.CUInt32T = self.state[3]
|
||||
w: list[t.CUInt32T, 16]
|
||||
w: t.CArray[t.CUInt32T, 16]
|
||||
# 字节序转32位字
|
||||
for i in range(16):
|
||||
w[i] = ((t.CUInt32T(block[i * 4 + 0]) << 0) |
|
||||
@@ -105,7 +105,7 @@ class md5:
|
||||
if length > 0:
|
||||
memcpy(self.buf + idx, data, length)
|
||||
# 结束计算，输出16字节摘要
|
||||
def final(self, out: list[t.CUInt8T, MD5_DIGEST_LEN]):
|
||||
def final(self, out: t.CArray[t.CUInt8T, MD5_DIGEST_LEN]):
|
||||
idx: t.CSizeT = self.count % MD5_BLOCK_LEN
|
||||
# 填充0x80结尾
|
||||
self.buf[idx] = 0x80
|
||||
|
||||
@@ -17,9 +17,9 @@ def sha1_f3(b: t.CUInt32T, c: t.CUInt32T, d: t.CUInt32T) -> t.CUInt32T: return (
|
||||
# SHA1 上下文
|
||||
@t.Object
|
||||
class sha1:
|
||||
state: list[t.CUInt32T, 5]
|
||||
state: t.CArray[t.CUInt32T, 5]
|
||||
count: t.CUInt64T
|
||||
buf: list[t.CUInt8T, SHA1_BLOCK_LEN]
|
||||
buf: t.CArray[t.CUInt8T, SHA1_BLOCK_LEN]
|
||||
def __init__(self):
|
||||
memset(self.buf, 0, SHA1_BLOCK_LEN)
|
||||
self.state[0] = 0x67452301
|
||||
@@ -30,7 +30,7 @@ class sha1:
|
||||
self.count = 0
|
||||
# 单分组压缩
|
||||
def transform(self, block: t.CUInt8T | t.CPtr):
|
||||
w: list[t.CUInt32T, 80]
|
||||
w: t.CArray[t.CUInt32T, 80]
|
||||
data: t.CUInt8T | t.CPtr = block
|
||||
# 前16个字
|
||||
for i in range(16):
|
||||
@@ -97,7 +97,7 @@ class sha1:
|
||||
length -= SHA1_BLOCK_LEN
|
||||
if length > 0:
|
||||
memcpy(self.buf + idx, data, length)
|
||||
def final(self, out: list[t.CUInt8T, SHA1_DIGEST_LEN]):
|
||||
def final(self, out: t.CArray[t.CUInt8T, SHA1_DIGEST_LEN]):
|
||||
idx: t.CSizeT = self.count % SHA1_BLOCK_LEN
|
||||
self.buf[idx] = 0x80
|
||||
idx += 1
|
||||
|
||||
@@ -8,7 +8,7 @@ SHA256_BLOCK_LEN: t.CDefine = 64
|
||||
SHA256_DIGEST_LEN: t.CDefine = 32
|
||||
|
||||
# SHA256 常量K
|
||||
sha256_K: list[t.CUInt32T, 64] = [
|
||||
sha256_K: t.CArray[t.CUInt32T, 64] = [
|
||||
0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
|
||||
0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
|
||||
0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
|
||||
@@ -30,9 +30,9 @@ def Maj(x: t.CUInt32T, y: t.CUInt32T, z: t.CUInt32T) -> t.CUInt32T: return (x &
|
||||
# SHA256 上下文
|
||||
@t.Object
|
||||
class sha256:
|
||||
state: list[t.CUInt32T, 8]
|
||||
state: t.CArray[t.CUInt32T, 8]
|
||||
count: t.CUInt64T
|
||||
buf: list[t.CUInt8T, SHA256_BLOCK_LEN]
|
||||
buf: t.CArray[t.CUInt8T, SHA256_BLOCK_LEN]
|
||||
def __init__(self):
|
||||
memset(self, 0, sha256.__sizeof__())
|
||||
self.state[0] = 0x6a09e667
|
||||
@@ -47,7 +47,7 @@ class sha256:
|
||||
# memset(self.buf, 0, SHA256_BLOCK_LEN)
|
||||
# 单分组压缩
|
||||
def transform(self, block: t.CUInt8T | t.CPtr):
|
||||
w: list[t.CUInt32T, 64]
|
||||
w: t.CArray[t.CUInt32T, 64]
|
||||
for i in range(16):
|
||||
w[i] = ((t.CUInt32T(block[i * 4 + 0]) << 24) |
|
||||
(t.CUInt32T(block[i * 4 + 1]) << 16) |
|
||||
@@ -102,7 +102,7 @@ class sha256:
|
||||
length -= SHA256_BLOCK_LEN
|
||||
if length > 0:
|
||||
memcpy(self.buf + idx, data, length)
|
||||
def final(self, out: list[t.CUInt8T, SHA256_DIGEST_LEN]):
|
||||
def final(self, out: t.CArray[t.CUInt8T, SHA256_DIGEST_LEN]):
|
||||
idx: t.CSizeT = self.count % SHA256_BLOCK_LEN
|
||||
self.buf[idx] = 0x80
|
||||
idx += 1
|
||||
|
||||
@@ -16,7 +16,7 @@ def sha512_BigSigma1(x: t.CUInt64T) -> t.CUInt64T: return sha512_ror(x, 14) ^ sh
|
||||
def sha512_Sigma0(x: t.CUInt64T) -> t.CUInt64T: return sha512_ror(x, 1) ^ sha512_ror(x, 8) ^ sha512_shr(x, 7)
|
||||
def sha512_Sigma1(x: t.CUInt64T) -> t.CUInt64T: return sha512_ror(x, 19) ^ sha512_ror(x, 61) ^ sha512_shr(x, 6)
|
||||
|
||||
sha512_K: list[t.CUInt64T, 80] = [
|
||||
sha512_K: t.CArray[t.CUInt64T, 80] = [
|
||||
0x428a2f98d728ae22, 0x7137449123ef65cd, 0xb5c0fbcfec4d3b2f, 0xe9b5dba58189dbbc,
|
||||
0x3956c25bf348b538, 0x59f111f1b605d019, 0x923f82a4af194f9b, 0xab1c5ed5da6d8118,
|
||||
0xd807aa98a3030242, 0x12835b0145706fbe, 0x243185be4ee4b28c, 0x550c7dc3d5ffb4e2,
|
||||
@@ -41,9 +41,9 @@ sha512_K: list[t.CUInt64T, 80] = [
|
||||
|
||||
@t.Object
|
||||
class sha512:
|
||||
state: list[t.CUInt64T, 8]
|
||||
count: list[t.CUInt64T, 2]
|
||||
buf: list[t.CUInt8T, SHA512_BLOCK_LEN]
|
||||
state: t.CArray[t.CUInt64T, 8]
|
||||
count: t.CArray[t.CUInt64T, 2]
|
||||
buf: t.CArray[t.CUInt8T, SHA512_BLOCK_LEN]
|
||||
def __init__(self):
|
||||
memset(self, 0, sha512.__sizeof__())
|
||||
self.state[0] = 0x6a09e667f3bcc908
|
||||
@@ -54,8 +54,8 @@ class sha512:
|
||||
self.state[5] = 0x9b05688c2b3e6c1f
|
||||
self.state[6] = 0x1f83d9abfb41bd6b
|
||||
self.state[7] = 0x5be0cd19137e2179
|
||||
def transform(self, block: list[t.CUInt8T, SHA512_BLOCK_LEN]):
|
||||
w: list[t.CUInt64T, 80]
|
||||
def transform(self, block: t.CArray[t.CUInt8T, SHA512_BLOCK_LEN]):
|
||||
w: t.CArray[t.CUInt64T, 80]
|
||||
a: t.CUInt64T
|
||||
b: t.CUInt64T
|
||||
c: t.CUInt64T
|
||||
@@ -121,7 +121,7 @@ class sha512:
|
||||
length -= SHA512_BLOCK_LEN
|
||||
if length > 0:
|
||||
memcpy(self.buf + idx, data, length)
|
||||
def final(self, out: list[t.CUInt8T, SHA512_DIGEST_LEN]):
|
||||
def final(self, out: t.CArray[t.CUInt8T, SHA512_DIGEST_LEN]):
|
||||
bits_lo: t.CUInt64T = self.count[0] << 3
|
||||
bits_hi: t.CUInt64T = (self.count[1] << 3) | (self.count[0] >> 61)
|
||||
idx: t.CUInt32T = t.CUInt32T(self.count[0] % SHA512_BLOCK_LEN)
|
||||
|
||||
39
includes/lock.py
Normal file
39
includes/lock.py
Normal file
@@ -0,0 +1,39 @@
|
||||
import t, c
|
||||
from stdint import *
|
||||
from w32.win32base import *
|
||||
from w32.win32sync import CRITICAL_SECTION, InitializeCriticalSection, EnterCriticalSection, LeaveCriticalSection, DeleteCriticalSection, TryEnterCriticalSection
|
||||
|
||||
|
||||
@t.Object
|
||||
class Lock:
|
||||
"""基于 CRITICAL_SECTION 的互斥锁，支持递归加锁。
|
||||
|
||||
用法:
|
||||
lock: Lock = Lock()
|
||||
with lock:
|
||||
# 临界区
|
||||
pass
|
||||
"""
|
||||
cs: CRITICAL_SECTION
|
||||
|
||||
def __init__(self):
|
||||
InitializeCriticalSection(c.Addr(self.cs))
|
||||
|
||||
def acquire(self):
|
||||
EnterCriticalSection(c.Addr(self.cs))
|
||||
|
||||
def release(self):
|
||||
LeaveCriticalSection(c.Addr(self.cs))
|
||||
|
||||
def try_acquire(self) -> BOOL:
|
||||
return TryEnterCriticalSection(c.Addr(self.cs))
|
||||
|
||||
def __enter__(self) -> 'Lock' | t.CPtr:
|
||||
self.acquire()
|
||||
return self
|
||||
|
||||
def __exit__(self):
|
||||
self.release()
|
||||
|
||||
def delete(self):
|
||||
DeleteCriticalSection(c.Addr(self.cs))
|
||||
374
includes/mbuddy.py
Normal file
374
includes/mbuddy.py
Normal file
@@ -0,0 +1,374 @@
|
||||
import t, c
|
||||
from stdint import *
|
||||
import string
|
||||
import atom
|
||||
|
||||
# 伙伴系统内存分配器
|
||||
# 支持可变大小分配 (malloc/free/calloc/realloc)
|
||||
# 通过二分块 (buddy splitting) 和合并 (coalescing) 管理内存
|
||||
# 使用 atom 库的原子操作实现自旋锁 (线程安全)
|
||||
|
||||
MBUDDY_MIN_BLOCK: t.CDefine = 32 # 最小块大小 (字节)，需 >= 16 以容纳链表指针
|
||||
MBUDDY_MAX_ORDERS: t.CDefine = 32 # 最大阶数数量
|
||||
MBUDDY_HEADER_SIZE: t.CDefine = 8 # 块头大小 (存储阶数)
|
||||
|
||||
|
||||
def _largest_pow2_le(val: t.CSizeT) -> t.CSizeT:
|
||||
"""返回 <= val 的最大 2 的幂"""
|
||||
if val == 0: return 0
|
||||
p: t.CSizeT = 1
|
||||
while p * 2 <= val:
|
||||
p = p * 2
|
||||
return p
|
||||
|
||||
|
||||
def _block_size_at_order(order: t.CInt) -> t.CSizeT:
|
||||
"""返回指定阶数的块大小"""
|
||||
bs: t.CSizeT = MBUDDY_MIN_BLOCK
|
||||
i: t.CInt
|
||||
for i in range(order):
|
||||
bs = bs << 1
|
||||
return bs
|
||||
|
||||
|
||||
class MBuddy:
|
||||
# 编译期元数据：声明此类在 with 上下文中提供 __mbuddy__ 字段
|
||||
__provides__: list[str] = ['__mbuddy__']
|
||||
mem: t.CVoid | t.CPtr # 可用内存基址
|
||||
mem_size: t.CSizeT # 可用内存大小 (2 的幂)
|
||||
max_order: t.CInt # 最大阶数
|
||||
free_lists: t.CUInt64T | t.CPtr # 空闲链头数组 (存储在 arena 开头)
|
||||
lock_val: t.CVolatile | t.CInt # 自旋锁标志 (0=未锁, 1=已锁)
|
||||
|
||||
def __init__(self, arena: t.CVoid | t.CPtr, arena_size: t.CSizeT):
|
||||
# 初始化自旋锁
|
||||
self.lock_val = 0
|
||||
# 空闲链数组放在 arena 开头
|
||||
fl_bytes: t.CSizeT = (MBUDDY_MAX_ORDERS + 1) * 8
|
||||
self.free_lists = arena
|
||||
|
||||
# 初始化所有空闲链头为 0 (NULL)
|
||||
i: t.CInt
|
||||
for i in range(MBUDDY_MAX_ORDERS + 1):
|
||||
self.free_lists[i] = 0
|
||||
|
||||
# 计算可用区域
|
||||
if arena_size <= fl_bytes:
|
||||
self.mem = None
|
||||
self.mem_size = 0
|
||||
self.max_order = 0
|
||||
return
|
||||
|
||||
remaining: t.CSizeT = arena_size - fl_bytes
|
||||
usable: t.CSizeT = _largest_pow2_le(remaining)
|
||||
|
||||
if usable < MBUDDY_MIN_BLOCK:
|
||||
self.mem = None
|
||||
self.mem_size = 0
|
||||
self.max_order = 0
|
||||
return
|
||||
|
||||
self.mem = t.CVoid(t.CUInt64T(arena) + fl_bytes, t.CPtr)
|
||||
self.mem_size = usable
|
||||
|
||||
# 计算 max_order: log2(usable / MIN_BLOCK)
|
||||
self.max_order = 0
|
||||
bs: t.CSizeT = MBUDDY_MIN_BLOCK
|
||||
while bs < usable:
|
||||
bs = bs << 1
|
||||
self.max_order += 1
|
||||
|
||||
# 将整个可用区域作为一个 max_order 阶的空闲块加入空闲链
|
||||
self._fl_push(self.max_order, self.mem)
|
||||
|
||||
def __enter__(self) -> 'MBuddy' | t.CPtr:
|
||||
return self
|
||||
|
||||
def __exit__(self):
|
||||
self.reset()
|
||||
|
||||
def reset(self):
|
||||
"""重置分配器: 清空所有空闲链，将整个可用区域作为单个大块归还"""
|
||||
if self.mem == None:
|
||||
return
|
||||
# 清空所有空闲链头
|
||||
i: t.CInt
|
||||
for i in range(MBUDDY_MAX_ORDERS + 1):
|
||||
self.free_lists[i] = 0
|
||||
# 将整个可用区域作为单个 max_order 阶块加入
|
||||
self._fl_push(self.max_order, self.mem)
|
||||
|
||||
# === 空闲链操作 ===
|
||||
|
||||
def _fl_push(self, order: t.CInt, block: t.CVoid | t.CPtr):
|
||||
"""将块压入指定阶数的空闲链头部"""
|
||||
old_head: t.CUInt64T = self.free_lists[order]
|
||||
c.DerefAs(block, t.CVoid(old_head, t.CPtr))
|
||||
self.free_lists[order] = t.CUInt64T(block)
|
||||
|
||||
def _fl_pop(self, order: t.CInt) -> t.CVoid | t.CPtr:
|
||||
"""从指定阶数的空闲链头部弹出块"""
|
||||
head_val: t.CUInt64T = self.free_lists[order]
|
||||
if head_val == 0:
|
||||
return None
|
||||
block: t.CVoid | t.CPtr = t.CVoid(head_val, t.CPtr)
|
||||
next_ptr: t.CVoid | t.CPtr = t.CVoid(c.Deref(t.CUInt64T(block, t.CPtr)), t.CPtr)
|
||||
self.free_lists[order] = t.CUInt64T(next_ptr)
|
||||
return block
|
||||
|
||||
def _fl_find_and_remove(self, order: t.CInt, target: t.CVoid | t.CPtr) -> t.CInt:
|
||||
"""在指定阶数的空闲链中查找并移除 target 块。返回 1=找到, 0=未找到"""
|
||||
head_val: t.CUInt64T = self.free_lists[order]
|
||||
if head_val == 0:
|
||||
return 0
|
||||
|
||||
head: t.CVoid | t.CPtr = t.CVoid(head_val, t.CPtr)
|
||||
if t.CUInt64T(head) == t.CUInt64T(target):
|
||||
next_ptr: t.CVoid | t.CPtr = t.CVoid(c.Deref(t.CUInt64T(head, t.CPtr)), t.CPtr)
|
||||
self.free_lists[order] = t.CUInt64T(next_ptr)
|
||||
return 1
|
||||
|
||||
prev: t.CVoid | t.CPtr = head
|
||||
cur: t.CVoid | t.CPtr = t.CVoid(c.Deref(t.CUInt64T(head, t.CPtr)), t.CPtr)
|
||||
while cur != None:
|
||||
if t.CUInt64T(cur) == t.CUInt64T(target):
|
||||
next_ptr: t.CVoid | t.CPtr = t.CVoid(c.Deref(t.CUInt64T(cur, t.CPtr)), t.CPtr)
|
||||
c.DerefAs(prev, next_ptr)
|
||||
return 1
|
||||
prev = cur
|
||||
cur = t.CVoid(c.Deref(t.CUInt64T(cur, t.CPtr)), t.CPtr)
|
||||
|
||||
return 0
|
||||
|
||||
# === 伙伴系统核心操作 ===
|
||||
|
||||
def _buddy_of(self, block: t.CVoid | t.CPtr, order: t.CInt) -> t.CVoid | t.CPtr:
|
||||
"""计算指定块的伙伴块地址"""
|
||||
offset: t.CSizeT = t.CUInt64T(block) - t.CUInt64T(self.mem)
|
||||
bs: t.CSizeT = _block_size_at_order(order)
|
||||
buddy_offset: t.CSizeT = offset ^ bs
|
||||
return t.CVoid(t.CUInt64T(self.mem) + buddy_offset, t.CPtr)
|
||||
|
||||
def _order_for_size(self, size: t.CSizeT) -> t.CInt:
|
||||
"""返回使 MIN_BLOCK << order >= size 的最小阶数"""
|
||||
order: t.CInt = 0
|
||||
bs: t.CSizeT = MBUDDY_MIN_BLOCK
|
||||
while bs < size:
|
||||
bs = bs << 1
|
||||
order += 1
|
||||
return order
|
||||
|
||||
def _split_to_order(self, to_order: t.CInt) -> t.CVoid | t.CPtr:
|
||||
"""找到可用块并分裂到目标阶数。返回块指针或 None"""
|
||||
# 寻找第一个有空闲块的阶数 >= to_order
|
||||
found_order: t.CInt = to_order
|
||||
while found_order <= self.max_order:
|
||||
if self.free_lists[found_order] != 0:
|
||||
break
|
||||
found_order += 1
|
||||
|
||||
if found_order > self.max_order:
|
||||
return None
|
||||
|
||||
# 弹出块
|
||||
block: t.CVoid | t.CPtr = self._fl_pop(found_order)
|
||||
|
||||
# 逐级分裂到 to_order
|
||||
while found_order > to_order:
|
||||
found_order -= 1
|
||||
bs: t.CSizeT = _block_size_at_order(found_order)
|
||||
buddy: t.CVoid | t.CPtr = t.CVoid(t.CUInt64T(block) + bs, t.CPtr)
|
||||
self._fl_push(found_order, buddy)
|
||||
|
||||
return block
|
||||
|
||||
def _coalesce(self, block: t.CVoid | t.CPtr, order: t.CInt):
|
||||
"""尝试与伙伴合并，递归直到无法合并"""
|
||||
while order < self.max_order:
|
||||
buddy: t.CVoid | t.CPtr = self._buddy_of(block, order)
|
||||
found: t.CInt = self._fl_find_and_remove(order, buddy)
|
||||
if found == 0:
|
||||
break
|
||||
# 使用地址较低的一半作为合并后的块
|
||||
if t.CUInt64T(buddy) < t.CUInt64T(block):
|
||||
block = buddy
|
||||
order += 1
|
||||
|
||||
self._fl_push(order, block)
|
||||
|
||||
def _is_valid_ptr(self, ptr: t.CVoid | t.CPtr) -> t.CInt:
|
||||
"""验证指针是否为有效的已分配块指针。返回 1=有效, 0=无效"""
|
||||
if ptr == None:
|
||||
return 0
|
||||
if self.mem == None:
|
||||
return 0
|
||||
block: t.CVoid | t.CPtr = t.CVoid(t.CUInt64T(ptr) - MBUDDY_HEADER_SIZE, t.CPtr)
|
||||
# 检查范围
|
||||
if t.CUInt64T(block) < t.CUInt64T(self.mem):
|
||||
return 0
|
||||
if t.CUInt64T(block) >= t.CUInt64T(self.mem) + self.mem_size:
|
||||
return 0
|
||||
# 检查对齐 (所有块都 MIN_BLOCK 对齐)
|
||||
offset: t.CSizeT = t.CUInt64T(block) - t.CUInt64T(self.mem)
|
||||
if offset % MBUDDY_MIN_BLOCK != 0:
|
||||
return 0
|
||||
# 读取头部编码值: (order << 1) | allocated_flag
|
||||
stored: t.CVoid | t.CPtr = t.CVoid(c.Deref(t.CUInt64T(block, t.CPtr)), t.CPtr)
|
||||
stored_val: t.CUInt64T = t.CUInt64T(stored)
|
||||
# 检查 allocated 标志位 (bit 0 = 1 表示已分配)
|
||||
if (stored_val & 1) == 0:
|
||||
return 0 # 未分配或已释放 (双重 free 检测)
|
||||
# 提取阶数
|
||||
order: t.CInt = t.CInt(stored_val >> 1)
|
||||
if order < 0:
|
||||
return 0
|
||||
if order > self.max_order:
|
||||
return 0
|
||||
return 1
|
||||
|
||||
def _fl_count(self, order: t.CInt) -> t.CSizeT:
|
||||
"""统计指定阶数空闲链中的块数"""
|
||||
count: t.CSizeT = 0
|
||||
cur_val: t.CUInt64T = self.free_lists[order]
|
||||
while cur_val != 0:
|
||||
count += 1
|
||||
cur: t.CVoid | t.CPtr = t.CVoid(cur_val, t.CPtr)
|
||||
cur_val = t.CUInt64T(t.CVoid(c.Deref(t.CUInt64T(cur, t.CPtr)), t.CPtr))
|
||||
return count
|
||||
|
||||
# === 公共 API ===
|
||||
|
||||
def _lock(self):
|
||||
"""自旋锁: 原子测试并设置 lock_val，旧值为 1 时自旋等待"""
|
||||
while atom.__atomic_test_and_set(c.Addr(self.lock_val), atom.ATOMIC_ACQUIRE):
|
||||
pass
|
||||
|
||||
def _unlock(self):
|
||||
"""解锁: 原子清除 lock_val"""
|
||||
atom.__atomic_clear(c.Addr(self.lock_val), atom.ATOMIC_RELEASE)
|
||||
|
||||
def alloc(self, size: t.CSizeT) -> t.CVoid | t.CPtr:
|
||||
"""分配至少 size 字节的内存。返回用户数据指针或 None (线程安全)"""
|
||||
self._lock()
|
||||
result: t.CVoid | t.CPtr = None
|
||||
if self.mem != None:
|
||||
if size != 0:
|
||||
needed: t.CSizeT = size + MBUDDY_HEADER_SIZE
|
||||
order: t.CInt = self._order_for_size(needed)
|
||||
if order <= self.max_order:
|
||||
block: t.CVoid | t.CPtr = self._split_to_order(order)
|
||||
if block != None:
|
||||
c.DerefAs(block, t.CVoid(t.CUInt64T((order << 1) | 1), t.CPtr))
|
||||
result = t.CVoid(t.CUInt64T(block) + MBUDDY_HEADER_SIZE, t.CPtr)
|
||||
self._unlock()
|
||||
return result
|
||||
|
||||
def free(self, ptr: t.CVoid | t.CPtr):
|
||||
"""释放之前分配的内存。非法指针将被忽略 (线程安全)"""
|
||||
self._lock()
|
||||
if ptr != None:
|
||||
if self._is_valid_ptr(ptr) != 0:
|
||||
# 从头部读取阶数 (编码: (order << 1) | 1)
|
||||
block: t.CVoid | t.CPtr = t.CVoid(t.CUInt64T(ptr) - MBUDDY_HEADER_SIZE, t.CPtr)
|
||||
stored: t.CVoid | t.CPtr = t.CVoid(c.Deref(t.CUInt64T(block, t.CPtr)), t.CPtr)
|
||||
stored_val: t.CUInt64T = t.CUInt64T(stored)
|
||||
order: t.CInt = t.CInt(stored_val >> 1)
|
||||
# 清除 allocated 标志，防止双重 free
|
||||
c.DerefAs(block, t.CVoid(0, t.CPtr))
|
||||
# 合并并加入空闲链
|
||||
self._coalesce(block, order)
|
||||
self._unlock()
|
||||
|
||||
def calloc(self, count: t.CSizeT, size: t.CSizeT) -> t.CVoid | t.CPtr:
|
||||
"""分配 count*size 字节并清零"""
|
||||
total: t.CSizeT = count * size
|
||||
ptr: t.CVoid | t.CPtr = self.alloc(total)
|
||||
if ptr != None:
|
||||
string.memset(ptr, 0, total)
|
||||
return ptr
|
||||
|
||||
def realloc(self, ptr: t.CVoid | t.CPtr, new_size: t.CSizeT) -> t.CVoid | t.CPtr:
|
||||
"""重新分配内存大小"""
|
||||
if ptr == None:
|
||||
return self.alloc(new_size)
|
||||
if new_size == 0:
|
||||
self.free(ptr)
|
||||
return None
|
||||
if self._is_valid_ptr(ptr) == 0:
|
||||
return None # 非法指针
|
||||
|
||||
# 读取旧阶数 (编码: (order << 1) | 1)
|
||||
block: t.CVoid | t.CPtr = t.CVoid(t.CUInt64T(ptr) - MBUDDY_HEADER_SIZE, t.CPtr)
|
||||
stored: t.CVoid | t.CPtr = t.CVoid(c.Deref(t.CUInt64T(block, t.CPtr)), t.CPtr)
|
||||
stored_val: t.CUInt64T = t.CUInt64T(stored)
|
||||
old_order: t.CInt = t.CInt(stored_val >> 1)
|
||||
|
||||
# 计算新阶数
|
||||
needed: t.CSizeT = new_size + MBUDDY_HEADER_SIZE
|
||||
new_order: t.CInt = self._order_for_size(needed)
|
||||
|
||||
# 如果新阶数 <= 旧阶数，无需重新分配
|
||||
if new_order <= old_order:
|
||||
return ptr
|
||||
|
||||
# 分配新块
|
||||
new_ptr: t.CVoid | t.CPtr = self.alloc(new_size)
|
||||
if new_ptr == None:
|
||||
return ptr # 保留旧块
|
||||
|
||||
# 复制旧数据
|
||||
old_block_size: t.CSizeT = _block_size_at_order(old_order)
|
||||
old_data_size: t.CSizeT = old_block_size - MBUDDY_HEADER_SIZE
|
||||
string.memcpy(new_ptr, ptr, old_data_size)
|
||||
|
||||
# 释放旧块
|
||||
self.free(ptr)
|
||||
return new_ptr
|
||||
|
||||
def stats(self) -> t.CSizeT:
|
||||
"""返回总可用内存大小"""
|
||||
return self.mem_size
|
||||
|
||||
def free_count(self) -> t.CSizeT:
|
||||
"""统计所有空闲链中的总块数"""
|
||||
total: t.CSizeT = 0
|
||||
i: t.CInt
|
||||
for i in range(self.max_order + 1):
|
||||
total += self._fl_count(i)
|
||||
return total
|
||||
|
||||
def self_check(self) -> t.CInt:
|
||||
"""自检: 遍历所有空闲链，验证块的范围、对齐和阶数一致性。返回错误数 (0=正常)"""
|
||||
if self.mem == None:
|
||||
return 0
|
||||
errors: t.CInt = 0
|
||||
order: t.CInt
|
||||
for order in range(self.max_order + 1):
|
||||
bs: t.CSizeT = _block_size_at_order(order)
|
||||
max_in_order: t.CSizeT = self.mem_size / bs + 1
|
||||
seen: t.CSizeT = 0
|
||||
cur_val: t.CUInt64T = self.free_lists[order]
|
||||
while cur_val != 0:
|
||||
seen += 1
|
||||
if seen > max_in_order:
|
||||
errors += 1
|
||||
break
|
||||
cur: t.CVoid | t.CPtr = t.CVoid(cur_val, t.CPtr)
|
||||
# 检查范围
|
||||
if t.CUInt64T(cur) < t.CUInt64T(self.mem):
|
||||
errors += 1
|
||||
break
|
||||
if t.CUInt64T(cur) >= t.CUInt64T(self.mem) + self.mem_size:
|
||||
errors += 1
|
||||
break
|
||||
# 检查对齐
|
||||
offset: t.CSizeT = t.CUInt64T(cur) - t.CUInt64T(self.mem)
|
||||
if offset % MBUDDY_MIN_BLOCK != 0:
|
||||
errors += 1
|
||||
break
|
||||
# 检查阶数一致性: 块偏移应是其块大小的倍数
|
||||
if offset % bs != 0:
|
||||
errors += 1
|
||||
break
|
||||
cur_val = t.CUInt64T(t.CVoid(c.Deref(t.CUInt64T(cur, t.CPtr)), t.CPtr))
|
||||
return errors
|
||||
@@ -5,7 +5,7 @@ import string
|
||||
|
||||
MPOOL_ALIGN: t.CDefine = 8
|
||||
MPOOL_TYPE_SLAB: t.CDefine = 0
|
||||
MPOOL_TYPE_BUMP: t.CDefine = 2
|
||||
MPOOL_TYPE_BUMP: t.CDefine = 1
|
||||
|
||||
|
||||
def _align_up(val: t.CSizeT, align: t.CSizeT) -> t.CSizeT:
|
||||
@@ -39,7 +39,6 @@ class MPool:
|
||||
self.alloc_map = None
|
||||
self.alloc_map_size = 0
|
||||
|
||||
if mem == None: return
|
||||
if block_size > 0:
|
||||
self._init_slab(mem, mem_size, block_size)
|
||||
else:
|
||||
@@ -113,9 +112,7 @@ class MPool:
|
||||
def alloc(self, size: t.CSizeT) -> t.CVoid | t.CPtr:
|
||||
if self.mtype == MPOOL_TYPE_SLAB:
|
||||
return self._slab_alloc()
|
||||
if self.mtype == MPOOL_TYPE_BUMP:
|
||||
return self._bump_alloc(size)
|
||||
return None
|
||||
return self._bump_alloc(size)
|
||||
|
||||
def alloc_buf(self, capacity: t.CSizeT) -> viperio.Buf | t.CPtr:
|
||||
ptr: t.CVoid | t.CPtr = self.alloc(capacity)
|
||||
|
||||
@@ -27,8 +27,8 @@ e: t.CDefine = 2.71828182845904523536
|
||||
@t.Object
|
||||
class ndarray:
|
||||
data: t.CDouble | t.CPtr
|
||||
shape: list[t.CSizeT, MAX_NDIM]
|
||||
strides: list[t.CSizeT, MAX_NDIM]
|
||||
shape: t.CArray[t.CSizeT, MAX_NDIM]
|
||||
strides: t.CArray[t.CSizeT, MAX_NDIM]
|
||||
ndim: t.CInt
|
||||
size: t.CSizeT
|
||||
owns_data: t.CInt
|
||||
|
||||
46
includes/rwlock.py
Normal file
46
includes/rwlock.py
Normal file
@@ -0,0 +1,46 @@
|
||||
import t, c
|
||||
from stdint import *
|
||||
from w32.win32base import *
|
||||
from w32.win32sync import (
|
||||
InitializeSRWLock,
|
||||
AcquireSRWLockExclusive, ReleaseSRWLockExclusive,
|
||||
AcquireSRWLockShared, ReleaseSRWLockShared
|
||||
)
|
||||
|
||||
|
||||
@t.Object
|
||||
class RWLock:
|
||||
"""基于 SRWLock 的读写锁，支持多读单写，不支持递归。
|
||||
|
||||
用法:
|
||||
rwlock: RWLock = RWLock()
|
||||
rwlock.acquire_read()
|
||||
# ... 读取共享数据
|
||||
rwlock.release_read()
|
||||
rwlock.acquire_write()
|
||||
# ... 修改共享数据
|
||||
rwlock.release_write()
|
||||
"""
|
||||
lock: VOIDPTR
|
||||
|
||||
def __init__(self):
|
||||
InitializeSRWLock(c.Addr(self.lock))
|
||||
|
||||
def acquire_read(self):
|
||||
AcquireSRWLockShared(c.Addr(self.lock))
|
||||
|
||||
def release_read(self):
|
||||
ReleaseSRWLockShared(c.Addr(self.lock))
|
||||
|
||||
def acquire_write(self):
|
||||
AcquireSRWLockExclusive(c.Addr(self.lock))
|
||||
|
||||
def release_write(self):
|
||||
ReleaseSRWLockExclusive(c.Addr(self.lock))
|
||||
|
||||
def __enter__(self) -> 'RWLock' | t.CPtr:
|
||||
self.acquire_write()
|
||||
return self
|
||||
|
||||
def __exit__(self):
|
||||
self.release_write()
|
||||
@@ -5,7 +5,7 @@ import atom
|
||||
@t.Object
|
||||
class _spinlock:
|
||||
locked: t.CVolatile | t.CInt
|
||||
name: list[t.CChar, 32]
|
||||
name: t.CArray[t.CChar, 32]
|
||||
|
||||
def __init__(self):
|
||||
self.locked = 0
|
||||
|
||||
@@ -70,3 +70,13 @@ CHAR32: t.CTypedef = t.CChar32T
|
||||
CHAR8PTR: t.CTypedef = t.CChar8T | t.CPtr
|
||||
CHAR16PTR: t.CTypedef = t.CChar16T | t.CPtr
|
||||
CHAR32PTR: t.CTypedef = t.CChar32T | t.CPtr
|
||||
|
||||
i8: t.CTypedef = t.CInt8T
|
||||
i16: t.CTypedef = t.CInt16T
|
||||
i32: t.CTypedef = t.CInt32T
|
||||
i64: t.CTypedef = t.CInt64T
|
||||
|
||||
u8: t.CTypedef = t.CUInt8T
|
||||
u16: t.CTypedef = t.CUInt16T
|
||||
u32: t.CTypedef = t.CUInt32T
|
||||
u64: t.CTypedef = t.CUInt64T
|
||||
|
||||
@@ -289,7 +289,7 @@ def atof(src: str) -> t.CDouble:
|
||||
exp += 1
|
||||
return result
|
||||
|
||||
def split(s: str, delim: str, result: list[str]) -> int:
|
||||
def split(s: str, delim: str, result: t.CArray[str]) -> int:
|
||||
count: int = 0
|
||||
start: str = s
|
||||
if not s or not delim or not result:
|
||||
|
||||
54
includes/testcheck.py
Normal file
54
includes/testcheck.py
Normal file
@@ -0,0 +1,54 @@
|
||||
# testcheck - 回归测试格式化输出库
|
||||
# 提供 PASS/FAIL 计数、分节标题、汇总报告
|
||||
import t, c
|
||||
import stdio
|
||||
|
||||
_pass_count: t.CInt = 0
|
||||
_fail_count: t.CInt = 0
|
||||
|
||||
|
||||
def begin(name: str):
|
||||
"""开始测试套件，打印头部并重置计数器"""
|
||||
global _pass_count, _fail_count
|
||||
_pass_count = 0
|
||||
_fail_count = 0
|
||||
stdio.printf("=== %s ===\n\n", name)
|
||||
|
||||
|
||||
def section(name: str):
|
||||
"""打印分节标题"""
|
||||
stdio.printf("--- %s ---\n", name)
|
||||
|
||||
|
||||
def ok(msg: str):
|
||||
"""打印 PASS 并计数"""
|
||||
global _pass_count
|
||||
_pass_count += 1
|
||||
stdio.printf("PASS: %s\n", msg)
|
||||
|
||||
|
||||
def fail(msg: str):
|
||||
"""打印 FAIL 并计数"""
|
||||
global _fail_count
|
||||
_fail_count += 1
|
||||
stdio.printf("FAIL: %s\n", msg)
|
||||
|
||||
|
||||
def check(cond: t.CInt, ok_msg: str, fail_msg: str):
|
||||
"""条件检查，自动选择 PASS/FAIL"""
|
||||
if cond:
|
||||
ok(ok_msg)
|
||||
else:
|
||||
fail(fail_msg)
|
||||
|
||||
|
||||
def info(msg: str):
|
||||
"""打印信息消息（不计入 PASS/FAIL）"""
|
||||
stdio.printf("%s\n", msg)
|
||||
|
||||
|
||||
def end() -> t.CInt:
|
||||
"""打印汇总，返回失败数"""
|
||||
stdio.printf("\n--- Summary ---\n")
|
||||
stdio.printf("PASS: %d, FAIL: %d\n", _pass_count, _fail_count)
|
||||
return _fail_count
|
||||
@@ -24,7 +24,7 @@ def snprintf(buf: t.CChar | t.CPtr, size: t.CSizeT, fmt: str, *args) -> t.CInt |
|
||||
if buf == None or fmt == None or size == 0: return 0
|
||||
ptr: t.CChar | t.CPtr = buf
|
||||
write_count: t.CInt = 0
|
||||
temp: list[t.CChar, 24]
|
||||
temp: t.CArray[t.CChar, 24]
|
||||
temp[0] = '\t'
|
||||
while c.Deref(fmt) != 0 and write_count < size - 1:
|
||||
if c.Deref(fmt) != 37:
|
||||
|
||||
379
includes/vrandom.py
Normal file
379
includes/vrandom.py
Normal file
@@ -0,0 +1,379 @@
|
||||
# vrandom - 硬件随机数生成库
|
||||
# 基于 x86 RDRAND / RDSEED 指令，使用内嵌汇编实现
|
||||
import t, c
|
||||
import vipermath
|
||||
|
||||
|
||||
# 重试次数限制（RDRAND 通常不需要重试，RDSEED 可能需要）
|
||||
RDRAND_RETRY_LIMIT: t.CDefine = 10
|
||||
RDSEED_RETRY_LIMIT: t.CDefine = 100
|
||||
|
||||
|
||||
# ============================================================
|
||||
# RDRAND - 硬件随机数（伪随机数发生器输出）
|
||||
# ============================================================
|
||||
|
||||
def rdrand16() -> t.CUInt16T:
|
||||
val: t.CUInt32T = 0
|
||||
c.Asm(f"rdrand {c.AsmOut(val, t.ASM_DESCR.OUTPUT_REG)}",
|
||||
out=[c.AsmOut(val, t.ASM_DESCR.OUTPUT_REG)],
|
||||
op=[t.ASM_DESCR.CLOBBER_CC])
|
||||
return t.CUInt16T(val)
|
||||
|
||||
|
||||
def rdrand32() -> t.CUInt32T:
|
||||
val: t.CUInt32T = 0
|
||||
c.Asm(f"rdrand {c.AsmOut(val, t.ASM_DESCR.OUTPUT_REG)}",
|
||||
out=[c.AsmOut(val, t.ASM_DESCR.OUTPUT_REG)],
|
||||
op=[t.ASM_DESCR.CLOBBER_CC])
|
||||
return val
|
||||
|
||||
|
||||
def rdrand64() -> t.CUInt64T:
|
||||
val: t.CUInt64T = 0
|
||||
c.Asm(f"rdrand {c.AsmOut(val, t.ASM_DESCR.OUTPUT_REG)}",
|
||||
out=[c.AsmOut(val, t.ASM_DESCR.OUTPUT_REG)],
|
||||
op=[t.ASM_DESCR.CLOBBER_CC])
|
||||
return val
|
||||
|
||||
|
||||
# ============================================================
|
||||
# RDSEED - 硬件随机种子（熵源直接输出）
|
||||
# ============================================================
|
||||
|
||||
def rdseed16() -> t.CUInt16T:
|
||||
val: t.CUInt32T = 0
|
||||
c.Asm(f"rdseed {c.AsmOut(val, t.ASM_DESCR.OUTPUT_REG)}",
|
||||
out=[c.AsmOut(val, t.ASM_DESCR.OUTPUT_REG)],
|
||||
op=[t.ASM_DESCR.CLOBBER_CC])
|
||||
return t.CUInt16T(val)
|
||||
|
||||
|
||||
def rdseed32() -> t.CUInt32T:
|
||||
val: t.CUInt32T = 0
|
||||
c.Asm(f"rdseed {c.AsmOut(val, t.ASM_DESCR.OUTPUT_REG)}",
|
||||
out=[c.AsmOut(val, t.ASM_DESCR.OUTPUT_REG)],
|
||||
op=[t.ASM_DESCR.CLOBBER_CC])
|
||||
return val
|
||||
|
||||
|
||||
def rdseed64() -> t.CUInt64T:
|
||||
val: t.CUInt64T = 0
|
||||
c.Asm(f"rdseed {c.AsmOut(val, t.ASM_DESCR.OUTPUT_REG)}",
|
||||
out=[c.AsmOut(val, t.ASM_DESCR.OUTPUT_REG)],
|
||||
op=[t.ASM_DESCR.CLOBBER_CC])
|
||||
return val
|
||||
|
||||
|
||||
# ============================================================
|
||||
# Step 版本（带成功标志，匹配 GCC builtin 接口）
|
||||
# 返回 1 表示成功，0 表示失败；随机值写入 *p
|
||||
# ============================================================
|
||||
|
||||
def rdrand16_step(p: t.CUInt16T | t.CPtr) -> t.CInt:
|
||||
val: t.CUInt32T = 0
|
||||
ok: t.CUInt32T = 0
|
||||
c.Asm(f"""rdrand {c.AsmOut(val, t.ASM_DESCR.OUTPUT_REG)}
|
||||
setc al
|
||||
movzx {c.AsmOut(ok, t.ASM_DESCR.OUTPUT_REG)}, al""",
|
||||
out=[c.AsmOut(val, t.ASM_DESCR.OUTPUT_REG), c.AsmOut(ok, t.ASM_DESCR.OUTPUT_REG)],
|
||||
op=[t.ASM_DESCR.CLOBBER_CC, t.ASM_DESCR.CLOBBER_AL])
|
||||
p[0] = t.CUInt16T(val)
|
||||
return t.CInt(ok)
|
||||
|
||||
|
||||
def rdrand32_step(p: t.CUInt32T | t.CPtr) -> t.CInt:
|
||||
val: t.CUInt32T = 0
|
||||
ok: t.CUInt32T = 0
|
||||
c.Asm(f"""rdrand {c.AsmOut(val, t.ASM_DESCR.OUTPUT_REG)}
|
||||
setc al
|
||||
movzx {c.AsmOut(ok, t.ASM_DESCR.OUTPUT_REG)}, al""",
|
||||
out=[c.AsmOut(val, t.ASM_DESCR.OUTPUT_REG), c.AsmOut(ok, t.ASM_DESCR.OUTPUT_REG)],
|
||||
op=[t.ASM_DESCR.CLOBBER_CC, t.ASM_DESCR.CLOBBER_AL])
|
||||
p[0] = val
|
||||
return t.CInt(ok)
|
||||
|
||||
|
||||
def rdrand64_step(p: t.CUInt64T | t.CPtr) -> t.CInt:
|
||||
val: t.CUInt64T = 0
|
||||
ok: t.CUInt32T = 0
|
||||
c.Asm(f"""rdrand {c.AsmOut(val, t.ASM_DESCR.OUTPUT_REG)}
|
||||
setc al
|
||||
movzx {c.AsmOut(ok, t.ASM_DESCR.OUTPUT_REG)}, al""",
|
||||
out=[c.AsmOut(val, t.ASM_DESCR.OUTPUT_REG), c.AsmOut(ok, t.ASM_DESCR.OUTPUT_REG)],
|
||||
op=[t.ASM_DESCR.CLOBBER_CC, t.ASM_DESCR.CLOBBER_AL])
|
||||
p[0] = val
|
||||
return t.CInt(ok)
|
||||
|
||||
|
||||
def rdseed16_step(p: t.CUInt16T | t.CPtr) -> t.CInt:
|
||||
val: t.CUInt32T = 0
|
||||
ok: t.CUInt32T = 0
|
||||
c.Asm(f"""rdseed {c.AsmOut(val, t.ASM_DESCR.OUTPUT_REG)}
|
||||
setc al
|
||||
movzx {c.AsmOut(ok, t.ASM_DESCR.OUTPUT_REG)}, al""",
|
||||
out=[c.AsmOut(val, t.ASM_DESCR.OUTPUT_REG), c.AsmOut(ok, t.ASM_DESCR.OUTPUT_REG)],
|
||||
op=[t.ASM_DESCR.CLOBBER_CC, t.ASM_DESCR.CLOBBER_AL])
|
||||
p[0] = t.CUInt16T(val)
|
||||
return t.CInt(ok)
|
||||
|
||||
|
||||
def rdseed32_step(p: t.CUInt32T | t.CPtr) -> t.CInt:
|
||||
val: t.CUInt32T = 0
|
||||
ok: t.CUInt32T = 0
|
||||
c.Asm(f"""rdseed {c.AsmOut(val, t.ASM_DESCR.OUTPUT_REG)}
|
||||
setc al
|
||||
movzx {c.AsmOut(ok, t.ASM_DESCR.OUTPUT_REG)}, al""",
|
||||
out=[c.AsmOut(val, t.ASM_DESCR.OUTPUT_REG), c.AsmOut(ok, t.ASM_DESCR.OUTPUT_REG)],
|
||||
op=[t.ASM_DESCR.CLOBBER_CC, t.ASM_DESCR.CLOBBER_AL])
|
||||
p[0] = val
|
||||
return t.CInt(ok)
|
||||
|
||||
|
||||
def rdseed64_step(p: t.CUInt64T | t.CPtr) -> t.CInt:
|
||||
val: t.CUInt64T = 0
|
||||
ok: t.CUInt32T = 0
|
||||
c.Asm(f"""rdseed {c.AsmOut(val, t.ASM_DESCR.OUTPUT_REG)}
|
||||
setc al
|
||||
movzx {c.AsmOut(ok, t.ASM_DESCR.OUTPUT_REG)}, al""",
|
||||
out=[c.AsmOut(val, t.ASM_DESCR.OUTPUT_REG), c.AsmOut(ok, t.ASM_DESCR.OUTPUT_REG)],
|
||||
op=[t.ASM_DESCR.CLOBBER_CC, t.ASM_DESCR.CLOBBER_AL])
|
||||
p[0] = val
|
||||
return t.CInt(ok)
|
||||
|
||||
|
||||
# ============================================================
|
||||
# 带重试的便捷接口（自动重试直到成功或达到上限）
|
||||
# ============================================================
|
||||
|
||||
def random_u16() -> t.CUInt16T:
|
||||
r: t.CUInt16T = 0
|
||||
i: t.CInt = 0
|
||||
while i < RDRAND_RETRY_LIMIT:
|
||||
if rdrand16_step(c.Addr(r)) == 1:
|
||||
return r
|
||||
i += 1
|
||||
return 0
|
||||
|
||||
|
||||
def random_u32() -> t.CUInt32T:
|
||||
r: t.CUInt32T = 0
|
||||
i: t.CInt = 0
|
||||
while i < RDRAND_RETRY_LIMIT:
|
||||
if rdrand32_step(c.Addr(r)) == 1:
|
||||
return r
|
||||
i += 1
|
||||
return 0
|
||||
|
||||
|
||||
def random_u64() -> t.CUInt64T:
|
||||
r: t.CUInt64T = 0
|
||||
i: t.CInt = 0
|
||||
while i < RDRAND_RETRY_LIMIT:
|
||||
if rdrand64_step(c.Addr(r)) == 1:
|
||||
return r
|
||||
i += 1
|
||||
return 0
|
||||
|
||||
|
||||
def seed_u16() -> t.CUInt16T:
|
||||
r: t.CUInt16T = 0
|
||||
i: t.CInt = 0
|
||||
while i < RDSEED_RETRY_LIMIT:
|
||||
if rdseed16_step(c.Addr(r)) == 1:
|
||||
return r
|
||||
i += 1
|
||||
return 0
|
||||
|
||||
|
||||
def seed_u32() -> t.CUInt32T:
|
||||
r: t.CUInt32T = 0
|
||||
i: t.CInt = 0
|
||||
while i < RDSEED_RETRY_LIMIT:
|
||||
if rdseed32_step(c.Addr(r)) == 1:
|
||||
return r
|
||||
i += 1
|
||||
return 0
|
||||
|
||||
|
||||
def seed_u64() -> t.CUInt64T:
|
||||
r: t.CUInt64T = 0
|
||||
i: t.CInt = 0
|
||||
while i < RDSEED_RETRY_LIMIT:
|
||||
if rdseed64_step(c.Addr(r)) == 1:
|
||||
return r
|
||||
i += 1
|
||||
return 0
|
||||
|
||||
|
||||
# ============================================================
|
||||
# Python random 标准库函数实现
|
||||
# 默认类型：t.CUInt64T (u64), t.CDouble (f64), t.CInt (i32)
|
||||
# ============================================================
|
||||
|
||||
# ---------- 一、随机整数 ----------
|
||||
|
||||
def randint(a: t.CInt, b: t.CInt) -> t.CInt:
|
||||
return t.CInt(a + t.CInt(random_u64() % t.CUInt64T(b - a + 1)))
|
||||
|
||||
|
||||
def randrange(start: t.CInt, stop: t.CInt, step: t.CInt = 1) -> t.CInt:
|
||||
width: t.CInt = 0
|
||||
if step > 0:
|
||||
width = (stop - start + step - 1) // step
|
||||
else:
|
||||
width = (start - stop - step - 1) // (-step)
|
||||
return t.CInt(start + t.CInt(random_u64() % t.CUInt64T(width)) * step)
|
||||
|
||||
|
||||
def getrandbits(k: t.CInt) -> t.CUInt64T:
|
||||
r: t.CUInt64T = rdrand64()
|
||||
if k >= 64:
|
||||
return r
|
||||
mask: t.CUInt64T = (t.CUInt64T(1) << k) - t.CUInt64T(1)
|
||||
return r & mask
|
||||
|
||||
|
||||
# ---------- 二、随机浮点数 ----------
|
||||
|
||||
def random() -> t.CDouble:
|
||||
return t.CDouble(rdrand64() >> 11) * (t.CDouble(1.0) / t.CDouble(9007199254740992.0))
|
||||
|
||||
|
||||
def uniform(a: t.CDouble, b: t.CDouble) -> t.CDouble:
|
||||
return a + (b - a) * random()
|
||||
|
||||
|
||||
def triangular(low: t.CDouble, high: t.CDouble, mode: t.CDouble) -> t.CDouble:
|
||||
u: t.CDouble = random()
|
||||
c: t.CDouble = (mode - low) / (high - low)
|
||||
if u > c:
|
||||
u = t.CDouble(1.0) - u
|
||||
c = t.CDouble(1.0) - c
|
||||
tmp: t.CDouble = low
|
||||
low = high
|
||||
high = tmp
|
||||
return low + (high - low) * vipermath.sqrt(u * c)
|
||||
|
||||
|
||||
def betavariate(alpha: t.CDouble, beta: t.CDouble) -> t.CDouble:
|
||||
y: t.CDouble = gammavariate(alpha, t.CDouble(1.0))
|
||||
if y != t.CDouble(0.0):
|
||||
return y / (y + gammavariate(beta, t.CDouble(1.0)))
|
||||
return t.CDouble(0.0)
|
||||
|
||||
|
||||
def expovariate(lambd: t.CDouble) -> t.CDouble:
|
||||
u: t.CDouble = random()
|
||||
if u < t.CDouble(1e-300):
|
||||
u = t.CDouble(1e-300)
|
||||
return -vipermath.log(t.CDouble(1.0) - u) / lambd
|
||||
|
||||
|
||||
def gammavariate(alpha: t.CDouble, beta: t.CDouble) -> t.CDouble:
|
||||
u: t.CDouble = t.CDouble(0.0)
|
||||
d: t.CDouble = t.CDouble(0.0)
|
||||
c: t.CDouble = t.CDouble(0.0)
|
||||
x: t.CDouble = t.CDouble(0.0)
|
||||
v: t.CDouble = t.CDouble(0.0)
|
||||
if alpha <= t.CDouble(0.0) or beta <= t.CDouble(0.0):
|
||||
return t.CDouble(0.0)
|
||||
if alpha < t.CDouble(1.0):
|
||||
u = random()
|
||||
if u < t.CDouble(1e-300):
|
||||
u = t.CDouble(1e-300)
|
||||
return gammavariate(alpha + t.CDouble(1.0), beta) * vipermath.pow(u, t.CDouble(1.0) / alpha)
|
||||
d = alpha - t.CDouble(1.0) / t.CDouble(3.0)
|
||||
c = t.CDouble(1.0) / vipermath.sqrt(t.CDouble(9.0) * d)
|
||||
while 1:
|
||||
x = gauss(t.CDouble(0.0), t.CDouble(1.0))
|
||||
v = t.CDouble(1.0) + c * x
|
||||
if v > t.CDouble(0.0):
|
||||
v = v * v * v
|
||||
u = random()
|
||||
if u < t.CDouble(1.0) - t.CDouble(0.0331) * x * x * x * x:
|
||||
return d * v * beta
|
||||
if vipermath.log(u) < t.CDouble(0.5) * x * x + d * (t.CDouble(1.0) - v + vipermath.log(v)):
|
||||
return d * v * beta
|
||||
|
||||
|
||||
def gauss(mu: t.CDouble, sigma: t.CDouble) -> t.CDouble:
|
||||
u1: t.CDouble = random()
|
||||
u2: t.CDouble = random()
|
||||
if u1 < t.CDouble(1e-300):
|
||||
u1 = t.CDouble(1e-300)
|
||||
z0: t.CDouble = vipermath.sqrt(t.CDouble(-2.0) * vipermath.log(u1)) * vipermath.cos(t.CDouble(2.0) * vipermath.U_M_PI * u2)
|
||||
return mu + sigma * z0
|
||||
|
||||
|
||||
def normalvariate(mu: t.CDouble, sigma: t.CDouble) -> t.CDouble:
|
||||
NV_MAGICCONST: t.CDouble = t.CDouble(1.7155277699214135)
|
||||
u1: t.CDouble = t.CDouble(0.0)
|
||||
u2: t.CDouble = t.CDouble(0.0)
|
||||
z: t.CDouble = t.CDouble(0.0)
|
||||
zz: t.CDouble = t.CDouble(0.0)
|
||||
while 1:
|
||||
u1 = random()
|
||||
u2 = random()
|
||||
if u2 < t.CDouble(1e-300):
|
||||
continue
|
||||
z = NV_MAGICCONST * (u1 - t.CDouble(0.5)) / u2
|
||||
zz = z * z / t.CDouble(4.0)
|
||||
if zz <= t.CDouble(0.0) - vipermath.log(u2):
|
||||
break
|
||||
return mu + z * sigma
|
||||
|
||||
|
||||
def lognormvariate(mu: t.CDouble, sigma: t.CDouble) -> t.CDouble:
|
||||
return vipermath.exp(gauss(mu, sigma))
|
||||
|
||||
|
||||
def vonmisesvariate(mu: t.CDouble, kappa: t.CDouble) -> t.CDouble:
|
||||
if kappa <= t.CDouble(1e-6):
|
||||
return vipermath.U_M_PI * t.CDouble(2.0) * random()
|
||||
s: t.CDouble = t.CDouble(0.5) / kappa
|
||||
r: t.CDouble = s + vipermath.sqrt(t.CDouble(1.0) + s * s)
|
||||
u1: t.CDouble = t.CDouble(0.0)
|
||||
u2: t.CDouble = t.CDouble(0.0)
|
||||
u3: t.CDouble = t.CDouble(0.0)
|
||||
z: t.CDouble = t.CDouble(0.0)
|
||||
d: t.CDouble = t.CDouble(0.0)
|
||||
q: t.CDouble = t.CDouble(0.0)
|
||||
f: t.CDouble = t.CDouble(0.0)
|
||||
theta: t.CDouble = t.CDouble(0.0)
|
||||
two_pi: t.CDouble = vipermath.U_M_PI * t.CDouble(2.0)
|
||||
while 1:
|
||||
u1 = random()
|
||||
z = vipermath.cos(vipermath.U_M_PI * u1)
|
||||
d = t.CDouble(1.0) / (r + z)
|
||||
u2 = random()
|
||||
if u2 < t.CDouble(1.0) - d * d:
|
||||
break
|
||||
if u2 < (t.CDouble(1.0) - z) * vipermath.exp(kappa * (z - t.CDouble(1.0)) - d * kappa * r):
|
||||
break
|
||||
q = t.CDouble(1.0) / r
|
||||
f = (q + z) / (t.CDouble(1.0) + q * z)
|
||||
u3 = random()
|
||||
if u3 > t.CDouble(0.5):
|
||||
theta = mu + vipermath.acos(f)
|
||||
else:
|
||||
theta = mu - vipermath.acos(f)
|
||||
while theta < t.CDouble(0.0):
|
||||
theta += two_pi
|
||||
while theta >= two_pi:
|
||||
theta -= two_pi
|
||||
return theta
|
||||
|
||||
|
||||
def paretovariate(alpha: t.CDouble) -> t.CDouble:
|
||||
u: t.CDouble = random()
|
||||
if u < t.CDouble(1e-300):
|
||||
u = t.CDouble(1e-300)
|
||||
return t.CDouble(1.0) / vipermath.pow(t.CDouble(1.0) - u, t.CDouble(1.0) / alpha)
|
||||
|
||||
|
||||
def weibullvariate(alpha: t.CDouble, beta: t.CDouble) -> t.CDouble:
|
||||
u: t.CDouble = random()
|
||||
if u < t.CDouble(1e-300):
|
||||
u = t.CDouble(1e-300)
|
||||
return alpha * vipermath.pow(t.CDouble(-1.0) * vipermath.log(t.CDouble(1.0) - u), t.CDouble(1.0) / beta)
|
||||
104
includes/vthreading.py
Normal file
104
includes/vthreading.py
Normal file
@@ -0,0 +1,104 @@
|
||||
import t, c
|
||||
from stdint import *
|
||||
from w32.win32base import *
|
||||
from w32.win32process import CreateThread, GetExitCodeThread, GetCurrentThreadId, TlsAlloc, TlsFree, TlsGetValue, TlsSetValue
|
||||
from w32.win32sync import WaitForSingleObject
|
||||
|
||||
# 全部导入锁类，用户也可按需导入
|
||||
from lock import Lock
|
||||
from event import Event
|
||||
from condition import Condition
|
||||
from rwlock import RWLock
|
||||
|
||||
|
||||
@t.Object
|
||||
class Thread:
|
||||
"""线程类，封装 Windows CreateThread。
|
||||
|
||||
线程回调签名: def thread_func(arg: t.CPtr) -> t.CPtr
|
||||
注意: Windows API 限制返回值为 DWORD(32位)，64位指针会被截断。
|
||||
如需返回 64 位结果，请通过 arg 参数结构体传递。
|
||||
|
||||
用法:
|
||||
def worker(arg: t.CPtr) -> t.CPtr:
|
||||
# 线程逻辑
|
||||
return NULL
|
||||
|
||||
t: Thread = Thread(worker, arg_ptr)
|
||||
t.start()
|
||||
t.join()
|
||||
"""
|
||||
handle: HANDLE
|
||||
thread_id: ULONG
|
||||
target: VOIDPTR
|
||||
arg: VOIDPTR
|
||||
started: BOOL
|
||||
|
||||
def __init__(self, target: VOIDPTR, arg: VOIDPTR = NULL):
|
||||
self.handle = NULL
|
||||
self.thread_id = 0
|
||||
self.target = target
|
||||
self.arg = arg
|
||||
self.started = FALSE
|
||||
|
||||
def start(self):
|
||||
if self.started:
|
||||
return
|
||||
self.handle = CreateThread(NULL, 0, self.target, self.arg, 0, c.Addr(self.thread_id))
|
||||
self.started = TRUE
|
||||
|
||||
def join(self, timeout_ms: ULONG = INFINITE) -> BOOL:
|
||||
if not self.started:
|
||||
return FALSE
|
||||
result: ULONG = WaitForSingleObject(self.handle, timeout_ms)
|
||||
return result == WAIT_OBJECT_0
|
||||
|
||||
def is_alive(self) -> BOOL:
|
||||
if not self.started:
|
||||
return FALSE
|
||||
result: ULONG = WaitForSingleObject(self.handle, 0)
|
||||
return result == WAIT_TIMEOUT
|
||||
|
||||
def get_exit_code(self) -> ULONG:
|
||||
code: ULONG = 0
|
||||
GetExitCodeThread(self.handle, c.Addr(code))
|
||||
return code
|
||||
|
||||
def close(self):
|
||||
if self.handle != NULL:
|
||||
CloseHandle(self.handle)
|
||||
self.handle = NULL
|
||||
|
||||
|
||||
@t.Object
|
||||
class local:
|
||||
"""TLS (Thread Local Storage) 封装。
|
||||
|
||||
用法:
|
||||
tls: local = local()
|
||||
tls.set(value_ptr)
|
||||
val: t.CPtr = tls.get()
|
||||
"""
|
||||
index: ULONG
|
||||
|
||||
def __init__(self):
|
||||
self.index = TlsAlloc()
|
||||
|
||||
def get(self) -> VOIDPTR:
|
||||
return TlsGetValue(self.index)
|
||||
|
||||
def set(self, value: VOIDPTR) -> BOOL:
|
||||
return TlsSetValue(self.index, value)
|
||||
|
||||
def free(self) -> BOOL:
|
||||
return TlsFree(self.index)
|
||||
|
||||
|
||||
def get_current_thread_id() -> ULONG:
|
||||
"""获取当前线程 ID"""
|
||||
return GetCurrentThreadId()
|
||||
|
||||
|
||||
def sleep_ms(ms: ULONG):
|
||||
"""让当前线程休眠指定毫秒数"""
|
||||
Sleep(ms)
|
||||
@@ -43,3 +43,23 @@ def AcquireSRWLockExclusive(SRWLock: VOIDPTR) -> VOID | t.State: pass
|
||||
def AcquireSRWLockShared(SRWLock: VOIDPTR) -> VOID | t.State: pass
|
||||
def ReleaseSRWLockExclusive(SRWLock: VOIDPTR) -> VOID | t.State: pass
|
||||
def ReleaseSRWLockShared(SRWLock: VOIDPTR) -> VOID | t.State: pass
|
||||
|
||||
# 条件变量 (Condition Variables) - Vista+
|
||||
CONDITION_VARIABLE_LOCKMODE_SHARED: t.CDefine = 0x1
|
||||
|
||||
def InitializeConditionVariable(ConditionVariable: VOIDPTR) -> VOID | t.State: pass
|
||||
def SleepConditionVariableCS(ConditionVariable: VOIDPTR, CriticalSection: CRITICAL_SECTION | t.CPtr, dwMilliseconds: ULONG) -> BOOL | t.State: pass
|
||||
def SleepConditionVariableSRW(ConditionVariable: VOIDPTR, SRWLock: VOIDPTR, dwMilliseconds: ULONG, Flags: ULONG) -> BOOL | t.State: pass
|
||||
def WakeConditionVariable(ConditionVariable: VOIDPTR) -> VOID | t.State: pass
|
||||
def WakeAllConditionVariable(ConditionVariable: VOIDPTR) -> VOID | t.State: pass
|
||||
|
||||
# 一次性初始化 (One-Time Initialization) - Vista+
|
||||
INIT_ONCE_STATIC_INIT: t.CDefine = 0x00000001
|
||||
INIT_ONCE_CHECK_ONLY: t.CDefine = 0x00000002
|
||||
INIT_ONCE_ASYNC: t.CDefine = 0x00000004
|
||||
INIT_ONCE_INIT_FAILED: t.CDefine = 0x00000008
|
||||
|
||||
class INIT_ONCE:
|
||||
Ptr: t.CPtr
|
||||
|
||||
def InitOnceExecuteOnce(InitOnce: INIT_ONCE | t.CPtr, InitFn: VOIDPTR, Parameter: VOIDPTR, Context: VOIDPTR | t.CPtr) -> BOOL | t.State: pass
|
||||
|
||||
@@ -59,7 +59,7 @@ DEF_MEM_LEVEL: t.CDefine = 8
|
||||
# Version
|
||||
ZLIB_VERSION: t.CDefine = "1.3.2"
|
||||
|
||||
pyzlib_error_msg: list[t.CChar, 512] = ""
|
||||
pyzlib_error_msg: t.CArray[t.CChar, 512] = ""
|
||||
pyzlib_error_code_val: t.CInt = 0
|
||||
|
||||
# ============================================================
|
||||
@@ -552,7 +552,9 @@ def compress(pool: mpool.MPool | t.CPtr, data: BYTEPTR, data_len: t.CSizeT,
|
||||
actual_wbits: t.CInt = wbits
|
||||
if wbits > MAX_WBITS:
|
||||
actual_wbits = -MAX_WBITS
|
||||
stdio.printf("[DEBUG] compress: calling zdeflate_one_shot, pool=%p, data=%p, len=%zu, level=%d, wbits=%d\n", pool, data, data_len, level, actual_wbits)
|
||||
raw_result: UINT8PTR = zdeflate.zdeflate_one_shot(pool, data, data_len, level, actual_wbits, out_len)
|
||||
stdio.printf("[DEBUG] compress: zdeflate_one_shot returned %p\n", raw_result)
|
||||
if not raw_result:
|
||||
set_error(Z_DATA_ERROR, "compression failed")
|
||||
return None
|
||||
|
||||
@@ -13,7 +13,7 @@ def zchecksum_adler32(data: UINT8PTR, length: t.CSizeT, init: UINT32) -> t.CUInt
|
||||
b = (b + a) % 65521
|
||||
return (b << 16) | a
|
||||
|
||||
crc32_table: list[t.CUInt32T, 256] = [
|
||||
crc32_table: t.CArray[t.CUInt32T, 256] = [
|
||||
0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA,
|
||||
0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3,
|
||||
0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988,
|
||||
|
||||
@@ -34,7 +34,7 @@ ZDEFLATE_END_OF_BLOCK: t.CDefine = 256
|
||||
# ============================================================
|
||||
# Length / Distance extra bits tables (RFC 1951)
|
||||
# ============================================================
|
||||
zdeflate_len_extra_bits: list[t.CInt, 29] = [
|
||||
zdeflate_len_extra_bits: t.CArray[t.CInt, 29] = [
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
1, 1, 1, 1,
|
||||
2, 2, 2, 2,
|
||||
@@ -44,7 +44,7 @@ zdeflate_len_extra_bits: list[t.CInt, 29] = [
|
||||
0
|
||||
]
|
||||
|
||||
zdeflate_len_base: list[t.CInt, 29] = [
|
||||
zdeflate_len_base: t.CArray[t.CInt, 29] = [
|
||||
3, 4, 5, 6, 7, 8, 9, 10,
|
||||
11, 13, 15, 17,
|
||||
19, 23, 27, 31,
|
||||
@@ -54,7 +54,7 @@ zdeflate_len_base: list[t.CInt, 29] = [
|
||||
258
|
||||
]
|
||||
|
||||
zdeflate_dist_extra_bits: list[t.CInt, 30] = [
|
||||
zdeflate_dist_extra_bits: t.CArray[t.CInt, 30] = [
|
||||
0, 0, 0, 0,
|
||||
1, 1,
|
||||
2, 2,
|
||||
@@ -71,7 +71,7 @@ zdeflate_dist_extra_bits: list[t.CInt, 30] = [
|
||||
13, 13
|
||||
]
|
||||
|
||||
zdeflate_dist_base: list[t.CInt, 30] = [
|
||||
zdeflate_dist_base: t.CArray[t.CInt, 30] = [
|
||||
1, 2, 3, 4,
|
||||
5, 7,
|
||||
9, 13,
|
||||
@@ -88,7 +88,7 @@ zdeflate_dist_base: list[t.CInt, 30] = [
|
||||
16385, 24577
|
||||
]
|
||||
|
||||
zdeflate_codelen_order: list[int, 19] = [
|
||||
zdeflate_codelen_order: t.CArray[int, 19] = [
|
||||
16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
|
||||
]
|
||||
|
||||
|
||||
@@ -122,8 +122,8 @@ class zdeflate_stream:
|
||||
|
||||
|
||||
def write_dynamic_block(self, data: UINT8PTR, length: t.CSizeT, final: t.CInt):
|
||||
lit_freqs: list[t.CInt, 288]
|
||||
dist_freqs: list[t.CInt, 32]
|
||||
lit_freqs: t.CArray[t.CInt, 288]
|
||||
dist_freqs: t.CArray[t.CInt, 32]
|
||||
zdeflate_count_freqs(lit_freqs, dist_freqs, self, data, length)
|
||||
hlit: t.CInt = 286
|
||||
while hlit > 257 and lit_freqs[hlit - 1] == 0: hlit -= 1
|
||||
@@ -133,11 +133,11 @@ class zdeflate_stream:
|
||||
dist_tree = zhuff.zhuff_tree()
|
||||
lit_tree.build_codes(lit_freqs, hlit, zdef.ZDEFLATE_MAX_BITS)
|
||||
dist_tree.build_codes(dist_freqs, hdist, zdef.ZDEFLATE_MAX_BITS)
|
||||
all_lengths: list[t.CInt, 288 + 32]
|
||||
all_lengths: t.CArray[t.CInt, 288 + 32]
|
||||
for i in range(hlit): all_lengths[i] = lit_tree.codes[i].bits
|
||||
for i in range(hdist): all_lengths[hlit + i] = dist_tree.codes[i].bits
|
||||
total_lengths: t.CInt = hlit + hdist
|
||||
cl_freqs: list[t.CInt, 19]
|
||||
cl_freqs: t.CArray[t.CInt, 19]
|
||||
zdeflate_count_cl_freqs(all_lengths, total_lengths, cl_freqs)
|
||||
cl_tree = zhuff.zhuff_tree()
|
||||
cl_tree.build_codes(cl_freqs, 19, 7)
|
||||
@@ -373,14 +373,28 @@ def zdeflate_write_cl_encoded(all_lengths: INTPTR, total: t.CInt,
|
||||
|
||||
|
||||
def zdeflate_create(pool: mpool.MPool | t.CPtr, level: t.CInt, wbits: t.CInt, mem_level: t.CInt, strategy: t.CInt) -> zdeflate_stream | t.CPtr:
|
||||
s: zdeflate_stream | t.CPtr = zdef.zdef_alloc(pool, zdeflate_stream.__sizeof__())
|
||||
stdio.printf("[DEBUG] zdeflate_create: pool=%p, level=%d, wbits=%d\n", pool, level, wbits)
|
||||
n: t.CSizeT = zdeflate_stream.__sizeof__()
|
||||
stdio.printf("[DEBUG] zdeflate_create: sizeof(zdeflate_stream)=%zu\n", n)
|
||||
s: zdeflate_stream | t.CPtr = zdef.zdef_alloc(pool, n)
|
||||
stdio.printf("[DEBUG] zdeflate_create: allocated stream=%p\n", s)
|
||||
if not s: return None
|
||||
stdio.printf("[DEBUG] zdeflate_create: memset(s, 0)\n")
|
||||
memset(s, 0, zdeflate_stream.__sizeof__())
|
||||
stdio.printf("[DEBUG] zdeflate_create: s.pool = pool\n")
|
||||
s.pool = pool
|
||||
stdio.printf("[DEBUG] zdeflate_create: creating zbit_writer\n")
|
||||
s.writer = zdef.zbit_writer(pool)
|
||||
stdio.printf("[DEBUG] zdeflate_create: zbit_writer created, writer.buf=%p\n", s.writer.buf)
|
||||
stdio.printf("[DEBUG] zdeflate_create: allocating window\n")
|
||||
s.window = BYTEPTR(zdef.zdef_alloc(pool, zdef.ZDEFLATE_WINDOW_SIZE))
|
||||
stdio.printf("[DEBUG] zdeflate_create: window=%p\n", s.window)
|
||||
stdio.printf("[DEBUG] zdeflate_create: allocating hash_head\n")
|
||||
s.hash_head = INTPTR(zdef.zdef_alloc(pool, zdef.ZDEFLATE_HASH_SIZE * int.__sizeof__()))
|
||||
stdio.printf("[DEBUG] zdeflate_create: hash_head=%p\n", s.hash_head)
|
||||
stdio.printf("[DEBUG] zdeflate_create: allocating hash_prev\n")
|
||||
s.hash_prev = INTPTR(zdef.zdef_alloc(pool, zdef.ZDEFLATE_WINDOW_SIZE * int.__sizeof__()))
|
||||
stdio.printf("[DEBUG] zdeflate_create: hash_prev=%p\n", s.hash_prev)
|
||||
if not s.window or not s.hash_head or not s.hash_prev:
|
||||
s.destroy()
|
||||
return None
|
||||
@@ -400,7 +414,9 @@ def zdeflate_create(pool: mpool.MPool | t.CPtr, level: t.CInt, wbits: t.CInt, me
|
||||
|
||||
def zdeflate_one_shot(pool: mpool.MPool | t.CPtr, data: UINT8PTR, length: t.CSizeT,
|
||||
level: t.CInt, wbits: t.CInt, out_len: t.CSizeT | t.CPtr) -> t.CUInt8T | t.CPtr:
|
||||
stdio.printf("[DEBUG] zdeflate_one_shot: pool=%p, data=%p, length=%zu, level=%d, wbits=%d\n", pool, data, length, level, wbits)
|
||||
s: zdeflate_stream | t.CPtr = zdeflate_create(pool, level, wbits, 8, 0)
|
||||
stdio.printf("[DEBUG] zdeflate_one_shot: stream created=%p\n", s)
|
||||
if not s: return None
|
||||
|
||||
memset(s.hash_head, -1, zdef.ZDEFLATE_HASH_SIZE * int.__sizeof__())
|
||||
|
||||
@@ -15,17 +15,17 @@ class zhuff_code:
|
||||
@t.Object
|
||||
class zhuff_tree:
|
||||
pool: mpool.MPool | t.CPtr
|
||||
codes: list[zhuff_code, ZHUFF_MAX_CODES]
|
||||
codes: t.CArray[zhuff_code, ZHUFF_MAX_CODES]
|
||||
count: t.CInt
|
||||
max_bits: t.CInt
|
||||
|
||||
def __init__(self):
|
||||
pass
|
||||
self.pool = None
|
||||
|
||||
def build_codes(self, freqs: INTPTR, count: t.CInt, max_bits: t.CInt):
|
||||
lengths: list[t.CInt, ZHUFF_MAX_CODES]
|
||||
bl_count: list[t.CInt, ZHUFF_MAX_BITS + 1]
|
||||
next_code: list[UINT, ZHUFF_MAX_BITS + 1]
|
||||
lengths: t.CArray[t.CInt, ZHUFF_MAX_CODES]
|
||||
bl_count: t.CArray[t.CInt, ZHUFF_MAX_BITS + 1]
|
||||
next_code: t.CArray[UINT, ZHUFF_MAX_BITS + 1]
|
||||
self.count = count
|
||||
self.max_bits = max_bits
|
||||
self.build_code_lengths(lengths, freqs, count, max_bits)
|
||||
@@ -47,9 +47,9 @@ class zhuff_tree:
|
||||
self.codes[i].code = 0
|
||||
|
||||
def build_fixed_lit_tree(self):
|
||||
lengths: list[t.CInt, 288]
|
||||
bl_count: list[t.CInt, 16]
|
||||
next_code: list[t.CUnsignedInt, 16]
|
||||
lengths: t.CArray[t.CInt, 288]
|
||||
bl_count: t.CArray[t.CInt, 16]
|
||||
next_code: t.CArray[t.CUnsignedInt, 16]
|
||||
self.get_fixed_lit_lengths(lengths)
|
||||
memset(bl_count, 0, bl_count.__sizeof__())
|
||||
for i in range(288):
|
||||
@@ -71,9 +71,9 @@ class zhuff_tree:
|
||||
self.codes[i].code = 0
|
||||
|
||||
def build_fixed_dist_tree(self):
|
||||
lengths: list[t.CInt, 32]
|
||||
bl_count: list[t.CInt, 16]
|
||||
next_code: list[t.CUnsignedInt, 16]
|
||||
lengths: t.CArray[t.CInt, 32]
|
||||
bl_count: t.CArray[t.CInt, 16]
|
||||
next_code: t.CArray[t.CUnsignedInt, 16]
|
||||
self.get_fixed_dist_lengths(lengths)
|
||||
memset(bl_count, 0, bl_count.__sizeof__())
|
||||
for i in range(32):
|
||||
@@ -103,7 +103,7 @@ class zhuff_tree:
|
||||
|
||||
|
||||
def build_code_lengths(self, lengths: t.CInt | t.CPtr, freqs: t.CInt | t.CPtr, count: t.CInt, max_bits: t.CInt):
|
||||
bl_count: list[t.CInt, ZHUFF_MAX_BITS + 2]
|
||||
bl_count: t.CArray[t.CInt, ZHUFF_MAX_BITS + 2]
|
||||
sort_count: t.CInt = 0
|
||||
memset(bl_count, 0, bl_count.__sizeof__())
|
||||
memset(lengths, 0, int.__sizeof__() * count)
|
||||
@@ -272,8 +272,8 @@ class zhuff_tree:
|
||||
lengths[i] = 5
|
||||
|
||||
def build_tree_from_lengths(self, lengths: INTPTR, count: t.CInt, max_bits: t.CInt):
|
||||
bl_count: list[t.CInt, 16]
|
||||
next_code: list[t.CUnsignedInt, 16]
|
||||
bl_count: t.CArray[t.CInt, 16]
|
||||
next_code: t.CArray[t.CUnsignedInt, 16]
|
||||
|
||||
memset(bl_count, 0, bl_count.__sizeof__())
|
||||
for i in range(count):
|
||||
@@ -298,19 +298,19 @@ class zhuff_tree:
|
||||
|
||||
|
||||
class zhuff_decode_node:
|
||||
children: list[t.CInt, 2]
|
||||
children: t.CArray[t.CInt, 2]
|
||||
symbol: t.CInt
|
||||
|
||||
|
||||
@t.Object
|
||||
class zhuff_decode_tree:
|
||||
pool: mpool.MPool | t.CPtr
|
||||
nodes: list[zhuff_decode_node, 2 * ZHUFF_MAX_CODES]
|
||||
nodes: t.CArray[zhuff_decode_node, 2 * ZHUFF_MAX_CODES]
|
||||
node_count: t.CInt
|
||||
root: t.CInt
|
||||
|
||||
def __init__(self):
|
||||
pass
|
||||
self.pool = None
|
||||
|
||||
def build_decode_tree(self, ht: zhuff_tree | t.CPtr):
|
||||
self.node_count = 1
|
||||
|
||||
@@ -213,7 +213,7 @@ class zinflate_stream:
|
||||
hdist: t.CInt = t.CInt(hdist_val) + 1
|
||||
hclen: t.CInt = t.CInt(hclen_val) + 4
|
||||
|
||||
cl_lengths: list[t.CInt, 19]
|
||||
cl_lengths: t.CArray[t.CInt, 19]
|
||||
memset(cl_lengths, 0, cl_lengths.__sizeof__())
|
||||
for i in range(hclen):
|
||||
len_val: UINT
|
||||
@@ -283,13 +283,13 @@ class zinflate_stream:
|
||||
lit_tree = zhuff.zhuff_tree()
|
||||
dist_tree = zhuff.zhuff_tree()
|
||||
|
||||
lit_lengths: list[t.CInt, 288]
|
||||
lit_lengths: t.CArray[t.CInt, 288]
|
||||
memset(lit_lengths, 0, lit_lengths.__sizeof__())
|
||||
for i in range(hlit):
|
||||
lit_lengths[i] = all_lengths[i]
|
||||
lit_tree.build_tree_from_lengths(lit_lengths, hlit, zdef.ZDEFLATE_MAX_BITS)
|
||||
|
||||
dist_lengths: list[t.CInt, 32]
|
||||
dist_lengths: t.CArray[t.CInt, 32]
|
||||
memset(dist_lengths, 0, dist_lengths.__sizeof__())
|
||||
for i in range(hdist):
|
||||
dist_lengths[i] = all_lengths[hlit + i]
|
||||
|
||||
Reference in New Issue
Block a user