GVSDS/TransPyC
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

snapshot before regression test

Browse Source
This commit is contained in:
t
2026-07-18 19:25:40 +08:00
commit 796222a300
2295 changed files with 206453 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

38
Test/SysLibTest/App/main.py Normal file
View File

@@ -0,0 +1,38 @@
from stdint import *
import w32.win32console
import t, c
from t import CInt, CExport
import memhub
import stdlib
import sys
import os
import os._win32
import os._posix
import os.path
import shutil
import subprocess
import syslibtest_impl
# MBuddy arena 大小：1MB
ARENA_SIZE: t.CDefine = 1048576
def main() -> CInt | CExport:
w32.win32console.SetConsoleCP(65001)
w32.win32console.SetConsoleOutputCP(65001)
# 初始化全局 MBuddy 内存分配器
arena: bytes = stdlib.malloc(ARENA_SIZE)
mbuddy_obj: memhub.MemBuddy | t.CPtr = memhub.MemBuddy(arena, ARENA_SIZE)
# 将 MBuddy 对象赋值给所有需要内存分配的模块
sys._mbuddy = mbuddy_obj
os._mbuddy = mbuddy_obj
os._win32._mbuddy = mbuddy_obj
os._posix._mbuddy = mbuddy_obj
os.path._mbuddy = mbuddy_obj
shutil._mbuddy = mbuddy_obj
subprocess._mbuddy = mbuddy_obj
return syslibtest_impl.run()

39
Test/SysLibTest/App/os_backend.py Normal file
View File

@@ -0,0 +1,39 @@
import t, c
from stdint import *
import platmacro
import os._win32
import os._posix
# =============================================================================
# Workaround: TransPyC 无法正确解析 os.xxx() 包级函数调用
# (os.path.xxx() 子模块调用正常，但 os.xxx() 包级调用解析为本地模块)
# 此文件单独导入 os._win32 / os._posix 子模块，避免污染调用方的 os.rmdir() 等解析。
# =============================================================================
def os_exists(path: str) -> bool:
"""检查文件/目录是否存在（跨平台）"""
if platmacro.IS_WINDOWS:
return os._win32.exists(path)
return os._posix.exists(path)
def os_remove(path: str) -> int:
"""删除文件（跨平台）。成功返回 0，失败返回 -1。"""
if platmacro.IS_WINDOWS:
return os._win32.remove(path)
return os._posix.remove(path)
def os_isdir(path: str) -> bool:
"""检查路径是否为目录（跨平台）"""
if platmacro.IS_WINDOWS:
return os._win32.isdir(path)
return os._posix.isdir(path)
def os_getsize(path: str) -> t.CInt64T:
"""返回文件大小（字节，跨平台）。失败返回 -1。"""
if platmacro.IS_WINDOWS:
return os._win32.getsize(path)
return os._posix.getsize(path)

307
Test/SysLibTest/App/syslibtest_impl.py Normal file
View File

@@ -0,0 +1,307 @@
import t, c
from stdint import *
from t import CInt, CPtr, CUInt8T, CSizeT
import testcheck
import viperlib
import stdlib
import memhub
import platmacro
import os
import os.path
import os_backend
import shutil
import sys
import subprocess
import string
import w32.fileio
import w32.win32base
import w32.win32process
# 测试用临时文件/目录名前缀
TEST_DIR: t.CDefine = "__sylibtest_dir__"
TEST_FILE: t.CDefine = "__sylibtest_file.txt"
TEST_COPY: t.CDefine = "__sylibtest_copy.txt"
TEST_TREE: t.CDefine = "__sylibtest_tree__"
TEST_MOVE: t.CDefine = "__sylibtest_moved.txt"
# =============================================================================
# Workaround: TransPyC 无法正确解析 os.xxx() 包级函数调用
# (os.path.xxx() 子模块调用正常，但 os.xxx() 包级调用解析为本地模块)
# 通过 os_backend 模块（单独导入 os._win32 / os._posix）绕过此问题
# =============================================================================
def _cleanup():
"""清理可能残留的测试文件/目录"""
testcheck.info("DBG: cleanup start")
if os_backend.os_exists(TEST_DIR):
testcheck.info("DBG: cleanup rmdir TEST_DIR")
os.rmdir(TEST_DIR)
testcheck.info("DBG: cleanup after TEST_DIR")
if os_backend.os_exists(TEST_FILE):
os_backend.os_remove(TEST_FILE)
testcheck.info("DBG: cleanup after TEST_FILE")
if os_backend.os_exists(TEST_COPY):
os_backend.os_remove(TEST_COPY)
testcheck.info("DBG: cleanup after TEST_COPY")
if os_backend.os_exists(TEST_MOVE):
os_backend.os_remove(TEST_MOVE)
testcheck.info("DBG: cleanup after TEST_MOVE")
if os_backend.os_exists(TEST_TREE):
testcheck.info("DBG: cleanup rmtree TEST_TREE")
shutil.rmtree(TEST_TREE)
testcheck.info("DBG: cleanup done")
def run() -> CInt:
buf: bytes = stdlib.malloc(512)
testcheck.begin("SysLibTest: 系统兼容层库测试")
testcheck.info("DBG: after begin")
# 清理残留
_cleanup()
testcheck.info("DBG: after cleanup")
# =============================================================================
# 全局 MBuddy 初始化验证（在 main 中已初始化）
# =============================================================================
testcheck.section("全局 MBuddy 初始化验证")
testcheck.info("DBG: after section")
testcheck.check(os._mbuddy != None, "os._mbuddy initialized OK", "os._mbuddy NOT initialized")
testcheck.check(sys._mbuddy != None, "sys._mbuddy initialized OK", "sys._mbuddy NOT initialized")
testcheck.check(shutil._mbuddy != None, "shutil._mbuddy initialized OK", "shutil._mbuddy NOT initialized")
testcheck.check(subprocess._mbuddy != None, "subprocess._mbuddy initialized OK", "subprocess._mbuddy NOT initialized")
# 所有模块应共享同一个 MBuddy 对象
testcheck.check(os._mbuddy == sys._mbuddy, "os==sys same MBuddy OK", "os!=sys different MBuddy")
testcheck.check(shutil._mbuddy == os._mbuddy, "shutil==os same MBuddy OK", "shutil!=os different MBuddy")
# =============================================================================
# MBuddy alloc/free/calloc/realloc（通过 os._mbuddy 测试）
# =============================================================================
testcheck.section("MBuddy alloc/free")
p1: bytes = os._mbuddy.alloc(64)
p2: bytes = os._mbuddy.alloc(128)
testcheck.check(p1 != None and p2 != None, "alloc OK", "alloc FAILED")
p1_c: CUInt8T | CPtr = CPtr(p1)
p1_c[0] = CUInt8T(0xAB)
p1_c[1] = CUInt8T(0xCD)
testcheck.check(p1_c[0] == CUInt8T(0xAB) and p1_c[1] == CUInt8T(0xCD),
"alloc write/read OK", "alloc write/read FAILED")
os._mbuddy.free(p1)
os._mbuddy.free(p2)
testcheck.ok("free OK")
# calloc 清零测试
testcheck.section("MBuddy calloc/realloc")
cp: bytes = os._mbuddy.calloc(4, 16)
if cp != None:
cp_c: CUInt8T | CPtr = CPtr(cp)
all_zero: CInt = 1
i: CInt
for i in range(64):
if cp_c[i] != 0:
all_zero = 0
break
testcheck.check(all_zero == 1, "calloc zeroed OK", "calloc NOT zeroed")
os._mbuddy.free(cp)
else:
testcheck.fail("calloc FAILED")
# realloc 数据保留测试
rp: bytes = os._mbuddy.alloc(32)
rp_c: CUInt8T | CPtr = CPtr(rp)
for i in range(32):
rp_c[i] = CUInt8T(i + 1)
rp2: bytes = os._mbuddy.realloc(rp, 128)
if rp2 != None:
rp2_c: CUInt8T | CPtr = CPtr(rp2)
ok: CInt = 1
for i in range(32):
if rp2_c[i] != CUInt8T(i + 1):
ok = 0
break
testcheck.check(ok == 1, "realloc data preserved OK", "realloc data LOST")
os._mbuddy.free(rp2)
else:
testcheck.fail("realloc FAILED")
# =============================================================================
# os.path 路径操作
# =============================================================================
testcheck.section("os.path 路径操作")
# sep
sep_char: t.CChar = os.path.sep()
viperlib.snprintf(buf, 512, "sep = %c", sep_char)
testcheck.info(buf)
# join
joined: str = os.path.join("parent", "child")
testcheck.check(joined != None, "join(parent, child) OK", "join FAILED")
testcheck.info(joined)
# basename
base: str = os.path.basename("/usr/local/bin/test")
testcheck.check(base != None, "basename OK", "basename FAILED")
testcheck.info(base)
# dirname
dirn: str = os.path.dirname("/usr/local/bin/test")
testcheck.check(dirn != None, "dirname OK", "dirname FAILED")
testcheck.info(dirn)
# isabs
testcheck.check(os.path.isabs("/usr/local"), "isabs(/usr/local) OK", "isabs FAILED")
testcheck.check(not os.path.isabs("relative/path"), "isabs(relative)=False OK", "isabs(relative) should be False")
# =============================================================================
# os 文件/目录操作
# =============================================================================
testcheck.section("os 文件/目录操作")
# getcwd
cwd: str = os.getcwd()
testcheck.check(cwd != None, "getcwd OK", "getcwd FAILED")
testcheck.info(cwd)
# exists
testcheck.check(os_backend.os_exists("."), "exists(.) OK", "exists(.) FAILED")
testcheck.check(not os_backend.os_exists("__totally_nonexistent__"), "exists(nonexistent)=False OK", "exists(nonexistent) should be False")
# isdir / isfile
testcheck.check(os_backend.os_isdir("."), "isdir(.) OK", "isdir(.) FAILED")
# mkdir + rmdir
testcheck.check(os.mkdir(TEST_DIR) == 0, "mkdir OK", "mkdir FAILED")
testcheck.check(os_backend.os_exists(TEST_DIR), "mkdir: exists OK", "mkdir: not exists")
testcheck.check(os_backend.os_isdir(TEST_DIR), "mkdir: isdir OK", "mkdir: not isdir")
testcheck.check(os.rmdir(TEST_DIR) == 0, "rmdir OK", "rmdir FAILED")
testcheck.check(not os_backend.os_exists(TEST_DIR), "rmdir: gone OK", "rmdir: still exists")
# rename
testcheck.check(os.mkdir(TEST_DIR) == 0, "mkdir for rename OK", "mkdir for rename FAILED")
testcheck.check(os.rename(TEST_DIR, TEST_TREE) == 0, "rename OK", "rename FAILED")
testcheck.check(os_backend.os_exists(TEST_TREE) and not os_backend.os_exists(TEST_DIR), "rename: swapped OK", "rename: swap FAILED")
testcheck.check(os.rmdir(TEST_TREE) == 0, "rmdir renamed OK", "rmdir renamed FAILED")
# =============================================================================
# shutil 高级文件操作
# =============================================================================
testcheck.section("shutil 高级文件操作")
# 创建测试文件
f: w32.fileio.File | CPtr = w32.fileio.File(TEST_FILE, w32.fileio.MODE.W)
testcheck.check(not f.closed, "create test file OK", "create test file FAILED")
f.write_str("hello shutil")
f.close()
testcheck.check(os_backend.os_exists(TEST_FILE), "test file exists OK", "test file not exists")
# copyfile
testcheck.check(shutil.copyfile(TEST_FILE, TEST_COPY) == 0, "copyfile OK", "copyfile FAILED")
testcheck.check(os_backend.os_exists(TEST_COPY), "copyfile: dst exists OK", "copyfile: dst not exists")
# 验证拷贝内容一致（检查文件大小）
src_size: t.CInt64T = os_backend.os_getsize(TEST_FILE)
dst_size: t.CInt64T = os_backend.os_getsize(TEST_COPY)
viperlib.snprintf(buf, 512, "src_size=%lld dst_size=%lld", src_size, dst_size)
testcheck.info(buf)
testcheck.check(src_size == dst_size, "copyfile: same size OK", "copyfile: size mismatch")
# move
testcheck.check(shutil.move(TEST_COPY, TEST_MOVE) == 0, "move OK", "move FAILED")
testcheck.check(os_backend.os_exists(TEST_MOVE), "move: dst exists OK", "move: dst not exists")
os_backend.os_remove(TEST_MOVE)
# rmtree（递归删除目录树）
testcheck.check(os.mkdir(TEST_TREE) == 0, "mkdir tree OK", "mkdir tree FAILED")
# 在树中创建子目录
subdir: str = os.path.join(TEST_TREE, "sub")
testcheck.check(os.mkdir(subdir) == 0, "mkdir subdir OK", "mkdir subdir FAILED")
# 在子目录中创建文件
subfile: str = os.path.join(subdir, "leaf.txt")
sf: w32.fileio.File | CPtr = w32.fileio.File(subfile, w32.fileio.MODE.W)
sf.write_str("leaf")
sf.close()
testcheck.check(os_backend.os_exists(subfile), "create subfile OK", "create subfile FAILED")
# rmtree
testcheck.check(shutil.rmtree(TEST_TREE) == 0, "rmtree OK", "rmtree FAILED")
testcheck.check(not os_backend.os_exists(TEST_TREE), "rmtree: gone OK", "rmtree: still exists")
# 清理剩余文件
if os_backend.os_exists(TEST_FILE):
os_backend.os_remove(TEST_FILE)
if os_backend.os_exists(TEST_COPY):
os_backend.os_remove(TEST_COPY)
# =============================================================================
# sys 系统信息
# =============================================================================
testcheck.section("sys 系统信息")
# platform
plat: str = sys.platform()
testcheck.check(plat != None, "platform() OK", "platform() FAILED")
testcheck.info(plat)
# getpid
pid: CInt = sys.get_pid()
viperlib.snprintf(buf, 512, "pid = %d", pid)
testcheck.info(buf)
testcheck.check(pid > 0, "getpid > 0 OK", "getpid FAILED")
# maxsize
viperlib.snprintf(buf, 512, "maxsize = %lld", sys.maxsize)
testcheck.info(buf)
testcheck.check(sys.maxsize > 0, "maxsize > 0 OK", "maxsize FAILED")
# argv
argc: CInt = sys.argc()
viperlib.snprintf(buf, 512, "argc = %d", argc)
testcheck.info(buf)
testcheck.check(argc > 0, "argc > 0 OK", "argc FAILED")
argv0: str = sys.argv(0)
testcheck.check(argv0 != None, "argv(0) OK", "argv(0) FAILED")
testcheck.info(argv0)
# 越界访问
testcheck.check(sys.argv(9999) == None, "argv(out-of-range)=None OK", "argv(out-of-range) should be None")
# =============================================================================
# subprocess 子进程
# =============================================================================
testcheck.section("subprocess 子进程")
# Windows: cmd /c echo hello
result: subprocess.CompletedProcess | CPtr = subprocess.run("cmd /c echo hello", True, True)
testcheck.check(result != None, "run OK", "run FAILED")
if result != None:
viperlib.snprintf(buf, 512, "returncode = %d", result.returncode)
testcheck.info(buf)
testcheck.check(result.returncode == 0, "returncode == 0 OK", "returncode != 0")
if result.stdout != None:
testcheck.info(result.stdout)
# 验证输出包含 "hello"
testcheck.check(string.strstr(result.stdout, "hello") != None,
"stdout contains 'hello' OK", "stdout missing 'hello'")
else:
testcheck.fail("stdout is None")
else:
testcheck.fail("run returned None")
# =============================================================================
# 清理
# =============================================================================
_cleanup()
stdlib.free(buf)
return testcheck.end()

1
Test/SysLibTest/output/59e00d50660b941e.deps.json Normal file
View File

@@ -0,0 +1 @@
{"w32.fileio": "0035c95a18d4f8e8", "fileio": "0035c95a18d4f8e8", "w32.win32process": "067c78e9f121dce3", "win32process": "067c78e9f121dce3", "w32.win32sync": "06f53cc594b4ac6c", "win32sync": "06f53cc594b4ac6c", "os.path": "13110effbb0bb06c", "path": "13110effbb0bb06c", "atom": "271ea3decb810db2", "subprocess": "2da636c61863c815", "posix": "6503c97dde0c79c4", "stdio": "6f62fe05c5ea1ceb", "stdarg": "71e0a3ffcb3ebfad", "os.__init__": "76dd6c275aa72b3b", "__init__": "76dd6c275aa72b3b", "os": "76dd6c275aa72b3b", "w32.win32base": "7e529fe7a078cfef", "win32base": "7e529fe7a078cfef", "stdlib": "90c53dd6db8d41cf", "platmacro": "93c1d18e35d188d6", "syslibtest_impl": "a03139660029514f", "os._win32": "a68b70f233541a7f", "_win32": "a68b70f233541a7f", "string": "ab6e54ba9a669f76", "shutil": "abbcbd92436cc16a", "sys": "b5a965302cded36b", "w32.win32console": "bbdf3bbd4c3bc28c", "win32console": "bbdf3bbd4c3bc28c", "viperlib": "c3b259b4059f8668", "main": "c70684ccfe48a5a9", "viperio": "c9f4be41ca1cc2b4", "os._posix": "d152115b49e50218", "_posix": "d152115b49e50218", "testcheck": "dd3002730623424b", "memhub": "ee084e9fc6ee413a", "stdint": "f5522571bcce7bcb", "w32.win32file": "f6b51804a0ba8ff0", "win32file": "f6b51804a0ba8ff0"}

1
Test/SysLibTest/output/a03139660029514f.deps.json Normal file
View File

@@ -0,0 +1 @@
{"w32.fileio": "0035c95a18d4f8e8", "fileio": "0035c95a18d4f8e8", "w32.win32process": "067c78e9f121dce3", "win32process": "067c78e9f121dce3", "w32.win32sync": "06f53cc594b4ac6c", "win32sync": "06f53cc594b4ac6c", "os.path": "13110effbb0bb06c", "path": "13110effbb0bb06c", "atom": "271ea3decb810db2", "subprocess": "2da636c61863c815", "os_backend": "59e00d50660b941e", "posix": "6503c97dde0c79c4", "stdio": "6f62fe05c5ea1ceb", "stdarg": "71e0a3ffcb3ebfad", "os.__init__": "76dd6c275aa72b3b", "__init__": "76dd6c275aa72b3b", "os": "76dd6c275aa72b3b", "w32.win32base": "7e529fe7a078cfef", "win32base": "7e529fe7a078cfef", "stdlib": "90c53dd6db8d41cf", "platmacro": "93c1d18e35d188d6", "os._win32": "a68b70f233541a7f", "_win32": "a68b70f233541a7f", "string": "ab6e54ba9a669f76", "shutil": "abbcbd92436cc16a", "sys": "b5a965302cded36b", "w32.win32console": "bbdf3bbd4c3bc28c", "win32console": "bbdf3bbd4c3bc28c", "viperlib": "c3b259b4059f8668", "main": "c70684ccfe48a5a9", "viperio": "c9f4be41ca1cc2b4", "os._posix": "d152115b49e50218", "_posix": "d152115b49e50218", "testcheck": "dd3002730623424b", "memhub": "ee084e9fc6ee413a", "stdint": "f5522571bcce7bcb", "w32.win32file": "f6b51804a0ba8ff0", "win32file": "f6b51804a0ba8ff0"}

1
Test/SysLibTest/output/c70684ccfe48a5a9.deps.json Normal file
View File

@@ -0,0 +1 @@
{"w32.fileio": "0035c95a18d4f8e8", "fileio": "0035c95a18d4f8e8", "w32.win32process": "067c78e9f121dce3", "win32process": "067c78e9f121dce3", "w32.win32sync": "06f53cc594b4ac6c", "win32sync": "06f53cc594b4ac6c", "os.path": "13110effbb0bb06c", "path": "13110effbb0bb06c", "atom": "271ea3decb810db2", "subprocess": "2da636c61863c815", "os_backend": "59e00d50660b941e", "posix": "6503c97dde0c79c4", "stdio": "6f62fe05c5ea1ceb", "stdarg": "71e0a3ffcb3ebfad", "os.__init__": "76dd6c275aa72b3b", "__init__": "76dd6c275aa72b3b", "os": "76dd6c275aa72b3b", "w32.win32base": "7e529fe7a078cfef", "win32base": "7e529fe7a078cfef", "stdlib": "90c53dd6db8d41cf", "platmacro": "93c1d18e35d188d6", "syslibtest_impl": "a03139660029514f", "os._win32": "a68b70f233541a7f", "_win32": "a68b70f233541a7f", "string": "ab6e54ba9a669f76", "shutil": "abbcbd92436cc16a", "sys": "b5a965302cded36b", "w32.win32console": "bbdf3bbd4c3bc28c", "win32console": "bbdf3bbd4c3bc28c", "viperlib": "c3b259b4059f8668", "viperio": "c9f4be41ca1cc2b4", "os._posix": "d152115b49e50218", "_posix": "d152115b49e50218", "testcheck": "dd3002730623424b", "memhub": "ee084e9fc6ee413a", "stdint": "f5522571bcce7bcb", "w32.win32file": "f6b51804a0ba8ff0", "win32file": "f6b51804a0ba8ff0"}

29
Test/SysLibTest/project.json Normal file
View File

@@ -0,0 +1,29 @@
{
"$schema": "https://raw.githubusercontent.com/TermiNexus/TransPyC/main/schemas/project-schema.json",
"name": "SysLibTest",
"version": "1.0.0",
"source_dir": "./App",
"temp_dir": "./temp",
"output_dir": "./output",
"compiler": {
"cmd": "llc",
"flags": ["-filetype=obj", "-relocation-model=pic"]
},
"linker": {
"cmd": "clang++",
"flags": ["-lmsvcrt", "-lucrt", "-lpthread", "-lmingwex", "-lkernel32", "-Wl,--allow-multiple-definition"],
"output": "SysLibTest.exe"
},
"includes": [
"./includes"
],
"target": {
"triple": "x86_64-pc-windows-gnu",
"datalayout": "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
},
"options": {
"slice_level": 3,
"target": "llvm",
"strict_mode": true
}
}

81
Test/SysLibTest/temp/0035c95a18d4f8e8.pyi Normal file
View File

@@ -0,0 +1,81 @@
"""
Auto-generated Python stub file from w32.fileio.py
Module: w32.fileio
"""
import t, c
from stdint import *
import stdio
import w32.win32base
import w32.win32file
class MODE(t.CEnum):
R = 0
W = 1
A = 2
RP = 3
WP = 4
AP = 5
X = 6
XP = 7
class FRESULT(t.CEnum):
OK = 0
ERR = -1
ERR_CLOSED = -2
ERR_PERM = -3
ERR_IO = -4
ERR_NOTFOUND = -5
SEEK_SET: t.CDefine = 0
SEEK_CUR: t.CDefine = 1
SEEK_END: t.CDefine = 2
INVALID_SET_FILE_POINTER: t.CDefine = -1
SHARE_READ: t.CDefine = 0x00000001
SHARE_WRITE: t.CDefine = 0x00000002
SHARE_DELETE: t.CDefine = 0x00000004
class File:
handle: w32.win32base.HANDLE
closed: bool
can_read: bool
can_write: bool
is_append: bool
_share_mode: ULONG
def __init__(self: File, filename: str, mode: ULONG, share: ULONG) -> t.CInt: pass
def __enter__(self: File) -> 'File' | t.CPtr: pass
def __exit__(self: File) -> t.CInt: pass
def read(self: File, buf: bytes, count: ULONG) -> LONG: pass
def write(self: File, buf: bytes, count: ULONG) -> LONG: pass
def write_str(self: File, s: str) -> LONG: pass
def seek(self: File, offset: LONG, origin: ULONG) -> LONG: pass
def tell(self: File) -> LONG: pass
def close(self: File) -> LONG: pass
def flush(self: File) -> LONG: pass
def size(self: File) -> LONGLONG: pass
def readline(self: File, buf: bytes, max_count: ULONG) -> LONG: pass
def read_all(self: File, buf: bytes, max_count: ULONG) -> LONG: pass
class FileW:
handle: w32.win32base.HANDLE
closed: bool
can_read: bool
can_write: bool
is_append: bool
_share_mode: ULONG
def __init__(self: FileW, filename: w32.win32base.LPCWSTR, mode: ULONG, share: ULONG) -> t.CInt: pass
def __enter__(self: FileW) -> 'FileW' | t.CPtr: pass
def __exit__(self: FileW) -> t.CInt: pass
def read(self: FileW, buf: bytes, count: ULONG) -> LONG: pass
def write(self: FileW, buf: bytes, count: ULONG) -> LONG: pass
def write_str(self: FileW, s: str) -> LONG: pass
def seek(self: FileW, offset: LONG, origin: ULONG) -> LONG: pass
def tell(self: FileW) -> LONG: pass
def close(self: FileW) -> LONG: pass
def flush(self: FileW) -> LONG: pass
def size(self: FileW) -> LONGLONG: pass
def readline(self: FileW, buf: bytes, max_count: ULONG) -> LONG: pass
def read_all(self: FileW, buf: bytes, max_count: ULONG) -> LONG: pass
def open(filename: str, mode: ULONG, share: ULONG) -> File | t.CPtr: pass
def openw(filename: LPCWSTR, mode: ULONG, share: ULONG) -> FileW | t.CPtr: pass

136
Test/SysLibTest/temp/067c78e9f121dce3.pyi Normal file
View File

@@ -0,0 +1,136 @@
"""
Auto-generated Python stub file from w32.win32process.py
Module: w32.win32process
"""
import c
import t
from stdint import *
from w32.win32base import *
PROCESS_TERMINATE: t.CDefine = 0x0001
PROCESS_CREATE_THREAD: t.CDefine = 0x0002
PROCESS_VM_OPERATION: t.CDefine = 0x0008
PROCESS_VM_READ: t.CDefine = 0x0010
PROCESS_VM_WRITE: t.CDefine = 0x0020
PROCESS_QUERY_INFORMATION: t.CDefine = 0x0400
PROCESS_ALL_ACCESS: t.CDefine = 0x001FFFFF
THREAD_TERMINATE: t.CDefine = 0x0001
THREAD_SUSPEND_RESUME: t.CDefine = 0x0002
THREAD_GET_CONTEXT: t.CDefine = 0x0008
THREAD_SET_CONTEXT: t.CDefine = 0x0010
THREAD_QUERY_INFORMATION: t.CDefine = 0x0040
THREAD_ALL_ACCESS: t.CDefine = 0x001FFFFF
CREATE_SUSPENDED: t.CDefine = 0x00000004
CREATE_NEW_CONSOLE: t.CDefine = 0x00000010
CREATE_NEW_PROCESS_GROUP: t.CDefine = 0x00000200
CREATE_NO_WINDOW: t.CDefine = 0x08000000
DETACHED_PROCESS: t.CDefine = 0x00000008
STARTF_USESHOWWINDOW: t.CDefine = 0x00000001
STARTF_USESTDHANDLES: t.CDefine = 0x00000100
SW_HIDE: t.CDefine = 0
SW_SHOW: t.CDefine = 5
SW_MINIMIZE: t.CDefine = 6
NORMAL_PRIORITY_CLASS: t.CDefine = 0x00000020
IDLE_PRIORITY_CLASS: t.CDefine = 0x00000040
HIGH_PRIORITY_CLASS: t.CDefine = 0x00000080
REALTIME_PRIORITY_CLASS: t.CDefine = 0x00000100
BELOW_NORMAL_PRIORITY_CLASS: t.CDefine = 0x00004000
ABOVE_NORMAL_PRIORITY_CLASS: t.CDefine = 0x00008000
STILL_ACTIVE: t.CDefine = 259
class STARTUPINFOA:
cb: ULONG
lpReserved: CHARPTR
lpDesktop: CHARPTR
lpTitle: CHARPTR
dwX: ULONG
dwY: ULONG
dwXSize: ULONG
dwYSize: ULONG
dwXCountChars: ULONG
dwYCountChars: ULONG
dwFillAttribute: ULONG
dwFlags: ULONG
wShowWindow: WORD
cbReserved2: WORD
lpReserved2: VOIDPTR
hStdInput: HANDLE
hStdOutput: HANDLE
hStdError: HANDLE
class STARTUPINFOW:
cb: ULONG
lpReserved: WCHARPTR
lpDesktop: WCHARPTR
lpTitle: WCHARPTR
dwX: ULONG
dwY: ULONG
dwXSize: ULONG
dwYSize: ULONG
dwXCountChars: ULONG
dwYCountChars: ULONG
dwFillAttribute: ULONG
dwFlags: ULONG
wShowWindow: WORD
cbReserved2: WORD
lpReserved2: VOIDPTR
hStdInput: HANDLE
hStdOutput: HANDLE
hStdError: HANDLE
class PROCESS_INFORMATION:
hProcess: HANDLE
hThread: HANDLE
dwProcessId: ULONG
dwThreadId: ULONG
def CreateProcessA(lpApplicationName: LPCSTR, lpCommandLine: CHARPTR, lpProcessAttributes: SECURITY_ATTRIBUTES | t.CPtr, lpThreadAttributes: SECURITY_ATTRIBUTES | t.CPtr, bInheritHandles: BOOL, dwCreationFlags: ULONG, lpEnvironment: VOIDPTR, lpCurrentDirectory: LPCSTR, lpStartupInfo: STARTUPINFOA | t.CPtr, lpProcessInformation: PROCESS_INFORMATION | t.CPtr) -> BOOL | t.State: pass
def CreateProcessW(lpApplicationName: LPCWSTR, lpCommandLine: WCHARPTR, lpProcessAttributes: SECURITY_ATTRIBUTES | t.CPtr, lpThreadAttributes: SECURITY_ATTRIBUTES | t.CPtr, bInheritHandles: BOOL, dwCreationFlags: ULONG, lpEnvironment: VOIDPTR, lpCurrentDirectory: LPCWSTR, lpStartupInfo: STARTUPINFOW | t.CPtr, lpProcessInformation: PROCESS_INFORMATION | t.CPtr) -> BOOL | t.State: pass
def TerminateProcess(hProcess: HANDLE, uExitCode: UINT) -> BOOL | t.State: pass
def GetExitCodeProcess(hProcess: HANDLE, lpExitCode: ULONG | t.CPtr) -> BOOL | t.State: pass
def GetExitCodeThread(hThread: HANDLE, lpExitCode: ULONG | t.CPtr) -> BOOL | t.State: pass
def OpenProcess(dwDesiredAccess: ULONG, bInheritHandle: BOOL, dwProcessId: ULONG) -> HANDLE | t.State: pass
def GetCurrentProcess() -> HANDLE | t.State: pass
def GetCurrentProcessId() -> ULONG | t.State: pass
def CreateThread(lpThreadAttributes: SECURITY_ATTRIBUTES | t.CPtr, dwStackSize: t.CSizeT, lpStartAddress: VOIDPTR, lpParameter: VOIDPTR, dwCreationFlags: ULONG, lpThreadId: ULONG | t.CPtr) -> HANDLE | t.State: pass
def OpenThread(dwDesiredAccess: ULONG, bInheritHandle: BOOL, dwThreadId: ULONG) -> HANDLE | t.State: pass
def SuspendThread(hThread: HANDLE) -> ULONG | t.State: pass
def ResumeThread(hThread: HANDLE) -> ULONG | t.State: pass
def TerminateThread(hThread: HANDLE, dwExitCode: ULONG) -> BOOL | t.State: pass
def GetCurrentThread() -> HANDLE | t.State: pass
def GetCurrentThreadId() -> ULONG | t.State: pass
def GetThreadId(hThread: HANDLE) -> ULONG | t.State: pass
def GetProcessId(hProcess: HANDLE) -> ULONG | t.State: pass
def SetThreadPriority(hThread: HANDLE, nPriority: INT) -> BOOL | t.State: pass
def GetThreadPriority(hThread: HANDLE) -> INT | t.State: pass
def ExitProcess(uExitCode: UINT) -> VOID | t.State: pass
def ExitThread(dwExitCode: ULONG) -> VOID | t.State: pass
def TlsAlloc() -> ULONG | t.State: pass
def TlsFree(dwTlsIndex: ULONG) -> BOOL | t.State: pass
def TlsGetValue(dwTlsIndex: ULONG) -> VOIDPTR | t.State: pass
def TlsSetValue(dwTlsIndex: ULONG, lpTlsValue: VOIDPTR) -> BOOL | t.State: pass

109
Test/SysLibTest/temp/06f53cc594b4ac6c.pyi Normal file
View File

@@ -0,0 +1,109 @@
"""
Auto-generated Python stub file from w32.win32sync.py
Module: w32.win32sync
"""
import c
import t
from stdint import *
from w32.win32base import *
class CRITICAL_SECTION:
DebugInfo: VOIDPTR
LockCount: LONG
RecursionCount: LONG
OwningThread: HANDLE
LockSemaphore: HANDLE
SpinCount: QWORD
def InitializeCriticalSection(lpCriticalSection: CRITICAL_SECTION | t.CPtr) -> VOID | t.State: pass
def EnterCriticalSection(lpCriticalSection: CRITICAL_SECTION | t.CPtr) -> VOID | t.State: pass
def LeaveCriticalSection(lpCriticalSection: CRITICAL_SECTION | t.CPtr) -> VOID | t.State: pass
def DeleteCriticalSection(lpCriticalSection: CRITICAL_SECTION | t.CPtr) -> VOID | t.State: pass
def TryEnterCriticalSection(lpCriticalSection: CRITICAL_SECTION | t.CPtr) -> BOOL | t.State: pass
def SetCriticalSectionSpinCount(lpCriticalSection: CRITICAL_SECTION | t.CPtr, dwSpinCount: ULONG) -> ULONG | t.State: pass
def InitializeCriticalSectionAndSpinCount(lpCriticalSection: CRITICAL_SECTION | t.CPtr, dwSpinCount: ULONG) -> BOOL | t.State: pass
def CreateMutexA(lpMutexAttributes: SECURITY_ATTRIBUTES | t.CPtr, bInitialOwner: BOOL, lpName: LPCSTR) -> HANDLE | t.State: pass
def CreateMutexW(lpMutexAttributes: SECURITY_ATTRIBUTES | t.CPtr, bInitialOwner: BOOL, lpName: LPCWSTR) -> HANDLE | t.State: pass
def OpenMutexA(dwDesiredAccess: ULONG, bInheritHandle: BOOL, lpName: LPCSTR) -> HANDLE | t.State: pass
def OpenMutexW(dwDesiredAccess: ULONG, bInheritHandle: BOOL, lpName: LPCWSTR) -> HANDLE | t.State: pass
def ReleaseMutex(hMutex: HANDLE) -> BOOL | t.State: pass
def CreateEventA(lpEventAttributes: SECURITY_ATTRIBUTES | t.CPtr, bManualReset: BOOL, bInitialState: BOOL, lpName: LPCSTR) -> HANDLE | t.State: pass
def CreateEventW(lpEventAttributes: SECURITY_ATTRIBUTES | t.CPtr, bManualReset: BOOL, bInitialState: BOOL, lpName: LPCWSTR) -> HANDLE | t.State: pass
def OpenEventA(dwDesiredAccess: ULONG, bInheritHandle: BOOL, lpName: LPCSTR) -> HANDLE | t.State: pass
def OpenEventW(dwDesiredAccess: ULONG, bInheritHandle: BOOL, lpName: LPCWSTR) -> HANDLE | t.State: pass
def SetEvent(hEvent: HANDLE) -> BOOL | t.State: pass
def ResetEvent(hEvent: HANDLE) -> BOOL | t.State: pass
def PulseEvent(hEvent: HANDLE) -> BOOL | t.State: pass
def CreateSemaphoreA(lpSemaphoreAttributes: SECURITY_ATTRIBUTES | t.CPtr, lInitialCount: LONG, lMaximumCount: LONG, lpName: LPCSTR) -> HANDLE | t.State: pass
def CreateSemaphoreW(lpSemaphoreAttributes: SECURITY_ATTRIBUTES | t.CPtr, lInitialCount: LONG, lMaximumCount: LONG, lpName: LPCWSTR) -> HANDLE | t.State: pass
def OpenSemaphoreA(dwDesiredAccess: ULONG, bInheritHandle: BOOL, lpName: LPCSTR) -> HANDLE | t.State: pass
def OpenSemaphoreW(dwDesiredAccess: ULONG, bInheritHandle: BOOL, lpName: LPCWSTR) -> HANDLE | t.State: pass
def ReleaseSemaphore(hSemaphore: HANDLE, lReleaseCount: LONG, lpPreviousCount: LONG | t.CPtr) -> BOOL | t.State: pass
def WaitForSingleObject(hHandle: HANDLE, dwMilliseconds: ULONG) -> ULONG | t.State: pass
def WaitForSingleObjectEx(hHandle: HANDLE, dwMilliseconds: ULONG, bAlertable: BOOL) -> ULONG | t.State: pass
def WaitForMultipleObjects(nCount: ULONG, lpHandles: VOIDPTR, bWaitAll: BOOL, dwMilliseconds: ULONG) -> ULONG | t.State: pass
def WaitForMultipleObjectsEx(nCount: ULONG, lpHandles: VOIDPTR, bWaitAll: BOOL, dwMilliseconds: ULONG, bAlertable: BOOL) -> ULONG | t.State: pass
def InitializeSRWLock(SRWLock: VOIDPTR) -> VOID | t.State: pass
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_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
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

35
Test/SysLibTest/temp/13110effbb0bb06c.pyi Normal file
View File

@@ -0,0 +1,35 @@
"""
Auto-generated Python stub file from os.path.py
Module: os.path
"""
import t, c
from stdint import *
import string
import memhub
import platmacro
_mbuddy: t.CExtern | memhub.MemBuddy | t.CPtr
def sep() -> t.CChar: pass
def _is_sep(ch: t.CChar) -> bool: pass
def _dup_str(s: str) -> str: pass
def _substr(s: str, start: t.CSizeT, end: t.CSizeT) -> str: pass
def isabs(path: str) -> bool: pass
def join(path1: str, path2: str) -> str: pass
def basename(path: str) -> str: pass
def dirname(path: str) -> str: pass
def splitext_name(path: str) -> str: pass
def splitext_ext(path: str) -> str: pass
def normpath(path: str) -> str: pass

26
Test/SysLibTest/temp/271ea3decb810db2.pyi Normal file
View File

@@ -0,0 +1,26 @@
"""
Auto-generated Python stub file from atom.py
Module: atom
"""
import t, c
ATOMIC_RELAXED: t.CDefine = 0
ATOMIC_CONSUME: t.CDefine = 1
ATOMIC_ACQUIRE: t.CDefine = 2
ATOMIC_RELEASE: t.CDefine = 3
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: pass
def __atomic_clear(ptr: t.CUInt64T | t.CPtr, order: t.CInt) -> t.CVoid: pass
def __atomic_thread_fence(order: t.CInt) -> t.CVoid: pass
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: pass
def __atomic_is_lock_free(size: t.CSizeT, ptr: t.CVoid | t.CPtr) -> t.CBool: pass

33
Test/SysLibTest/temp/2da636c61863c815.pyi Normal file
View File

@@ -0,0 +1,33 @@
"""
Auto-generated Python stub file from subprocess.py
Module: subprocess
"""
import t, c
from stdint import *
import platmacro
import memhub
import string
import w32.win32base
import w32.win32file
import w32.win32process
import w32.win32sync
import posix
OUTPUT_BUF_SIZE: t.CDefine = 65536
_mbuddy: t.CExtern | memhub.MemBuddy | t.CPtr
class CompletedProcess:
args: str
returncode: int
stdout: str
stderr: str
def __new__(self: CompletedProcess, args: str, returncode: int, stdout: str, stderr: str) -> t.CPtr: pass
def __init__(self: CompletedProcess, args: str, returncode: int, stdout: str, stderr: str) -> t.CInt: pass
def run(args: str, capture_output: bool, text: bool) -> CompletedProcess | t.CPtr: pass
def _run_win32(args: str, capture_output: bool, text: bool) -> CompletedProcess | t.CPtr: pass
def _run_posix(args: str, capture_output: bool, text: bool) -> CompletedProcess | t.CPtr: pass

1
Test/SysLibTest/temp/59e00d50660b941e.doc.json Normal file
View File

@@ -0,0 +1 @@
{"os_exists": "检查文件/目录是否存在（跨平台）", "os_remove": "删除文件（跨平台）。成功返回 0，失败返回 -1。", "os_isdir": "检查路径是否为目录（跨平台）", "os_getsize": "返回文件大小（字节，跨平台）。失败返回 -1。"}

19
Test/SysLibTest/temp/59e00d50660b941e.pyi Normal file
View File

@@ -0,0 +1,19 @@
"""
Auto-generated Python stub file from os_backend.py
Module: os_backend
"""
import t, c
from stdint import *
import platmacro
import os._win32
import os._posix
def os_exists(path: str) -> bool: pass
def os_remove(path: str) -> int: pass
def os_isdir(path: str) -> bool: pass
def os_getsize(path: str) -> t.CInt64T: pass

86
Test/SysLibTest/temp/6446627d4f07a1b5.pyi Normal file
View File

@@ -0,0 +1,86 @@
"""
Auto-generated Python stub file from w32.winsock2.py
Module: w32.winsock2
"""
import t, c
from stdint import *
from w32.win32base import *
WINSOCK_VERSION: t.CDefine = 0x0202 # 2.2
AF_INET: t.CDefine = 2
AF_INET6: t.CDefine = 23
SOCK_STREAM: t.CDefine = 1 # TCP
SOCK_DGRAM: t.CDefine = 2 # UDP
SOCK_RAW: t.CDefine = 3 # 原始套接字
IPPROTO_TCP: t.CDefine = 6
IPPROTO_UDP: t.CDefine = 17
SOL_SOCKET: t.CDefine = 0xFFFF # WinSock2 值
SO_RCVTIMEO: t.CDefine = 0x1006 # WinSock2 值
SO_SNDTIMEO: t.CDefine = 0x1005 # WinSock2 值
SO_REUSEADDR: t.CDefine = 0x0004 # WinSock2 值
INADDR_ANY: t.CDefine = 0
SOCKET_ERROR: t.CDefine = -1
INVALID_SOCKET: t.CDefine = 0xFFFFFFFF # WinSock2: ~0
MSG_NOSIGNAL: t.CDefine = 0 # Windows 不支持，设为 0
SD_SEND: t.CDefine = 1
SD_RECV: t.CDefine = 0
SD_BOTH: t.CDefine = 2
class WSASocketAddr:
family: u16
port: u16
addr: u32
zero: u64
class WSAData:
wVersion: WORD
wHighVersion: WORD
szDescription: BYTE
szSystemStatus: BYTE
iMaxSockets: u16
iMaxUdpDg: u16
lpVendorInfo: CHARPTR
class WSAHostEnt:
h_name: CHARPTR
h_aliases: CHARPTR
h_addrtype: SHORT
h_length: SHORT
h_addr_list: CHARPTR
class WinTimeVal:
tv_sec: LONG
tv_usec: LONG
def WSAStartup(wVersionRequested: WORD, lpWSAData: WSAData | t.CPtr) -> INT | t.State: pass
def WSACleanup() -> INT | t.State: pass
def WSAGetLastError() -> INT | t.State: pass
def socket(family: INT, type: INT, protocol: INT) -> u64 | t.State: pass
def closesocket(s: u64) -> INT | t.State: pass
def connect(s: u64, name: WSASocketAddr | t.CPtr, namelen: INT) -> INT | t.State: pass
def send(s: u64, buf: t.CVoid | t.CPtr, len: INT, flags: INT) -> INT | t.State: pass
def recv(s: u64, buf: t.CVoid | t.CPtr, len: INT, flags: INT) -> INT | t.State: pass
def bind(s: u64, name: WSASocketAddr | t.CPtr, namelen: INT) -> INT | t.State: pass
def listen(s: u64, backlog: INT) -> INT | t.State: pass
def accept(s: u64, addr: WSASocketAddr | t.CPtr, addrlen: INT | t.CPtr) -> u64 | t.State: pass
def setsockopt(s: u64, level: INT, optname: INT, optval: t.CVoid | t.CPtr, optlen: INT) -> INT | t.State: pass
def shutdown(s: u64, how: INT) -> INT | t.State: pass
def gethostbyname(name: t.CChar | t.CConst | t.CPtr) -> WSAHostEnt | t.CPtr | t.State: pass
def ntohs(netshort: u16) -> u16 | t.State: pass
def htons(hostshort: u16) -> u16 | t.State: pass
def inet_addr(cp: t.CChar | t.CConst | t.CPtr) -> u32 | t.State: pass

189
Test/SysLibTest/temp/6503c97dde0c79c4.pyi Normal file
View File

@@ -0,0 +1,189 @@
"""
Auto-generated Python stub file from posix.py
Module: posix
"""
import t, c
from stdint import *
DIR: t.CTypedef = t.CVoid | t.CPtr
mode_t: t.CTypedef = t.CUInt32T
pid_t: t.CTypedef = t.CInt32T
off_t: t.CTypedef = t.CInt64T
dev_t: t.CTypedef = t.CUInt64T
ino_t: t.CTypedef = t.CUInt64T
nlink_t: t.CTypedef = t.CUInt64T
uid_t: t.CTypedef = t.CUInt32T
gid_t: t.CTypedef = t.CUInt32T
blksize_t: t.CTypedef = t.CInt64T
blkcnt_t: t.CTypedef = t.CInt64T
time_t: t.CTypedef = t.CInt64T
O_RDONLY: t.CDefine = 0
O_WRONLY: t.CDefine = 1
O_RDWR: t.CDefine = 2
O_CREAT: t.CDefine = 0o100
O_EXCL: t.CDefine = 0o200
O_TRUNC: t.CDefine = 0o1000
O_APPEND: t.CDefine = 0o2000
O_NONBLOCK: t.CDefine = 0o4000
O_CLOEXEC: t.CDefine = 0o2000000
F_OK: t.CDefine = 0 # 文件存在
R_OK: t.CDefine = 4 # 可读
W_OK: t.CDefine = 2 # 可写
X_OK: t.CDefine = 1 # 可执行
S_IFMT: t.CDefine = 0o170000 # 类型掩码
S_IFSOCK: t.CDefine = 0o140000 # 套接字
S_IFLNK: t.CDefine = 0o120000 # 符号链接
S_IFREG: t.CDefine = 0o100000 # 普通文件
S_IFBLK: t.CDefine = 0o060000 # 块设备
S_IFDIR: t.CDefine = 0o040000 # 目录
S_IFCHR: t.CDefine = 0o020000 # 字符设备
S_IFIFO: t.CDefine = 0o010000 # FIFO/管道
S_ISUID: t.CDefine = 0o4000 # set-user-ID
S_ISGID: t.CDefine = 0o2000 # set-group-ID
S_ISVTX: t.CDefine = 0o1000 # sticky 位
S_IRWXU: t.CDefine = 0o700 # 用户读写执行
S_IRUSR: t.CDefine = 0o400 # 用户读
S_IWUSR: t.CDefine = 0o200 # 用户写
S_IXUSR: t.CDefine = 0o100 # 用户执行
S_IRWXG: t.CDefine = 0o070 # 组读写执行
S_IRGRP: t.CDefine = 0o040 # 组读
S_IWGRP: t.CDefine = 0o020 # 组写
S_IXGRP: t.CDefine = 0o010 # 组执行
S_IRWXO: t.CDefine = 0o007 # 其他读写执行
S_IROTH: t.CDefine = 0o004 # 其他读
S_IWOTH: t.CDefine = 0o002 # 其他写
S_IXOTH: t.CDefine = 0o001 # 其他执行
SEEK_SET: t.CDefine = 0
SEEK_CUR: t.CDefine = 1
SEEK_END: t.CDefine = 2
PATH_MAX: t.CDefine = 4096
NAME_MAX: t.CDefine = 255
_SC_NPROCESSORS_ONLN: t.CDefine = 84
_SC_PAGESIZE: t.CDefine = 30
_SC_CLK_TCK: t.CDefine = 2
DT_UNKNOWN: t.CDefine = 0
DT_FIFO: t.CDefine = 1
DT_CHR: t.CDefine = 2
DT_DIR: t.CDefine = 4
DT_BLK: t.CDefine = 6
DT_REG: t.CDefine = 8
DT_LNK: t.CDefine = 10
DT_SOCK: t.CDefine = 12
DT_WHT: t.CDefine = 14
WNOHANG: t.CDefine = 1
WUNTRACED: t.CDefine = 2
WCONTINUED: t.CDefine = 8
class Stat:
st_dev: dev_t
st_ino: ino_t
st_nlink: nlink_t
st_mode: mode_t
st_uid: uid_t
st_gid: gid_t
__pad0: INT
st_rdev: dev_t
st_size: off_t
st_blksize: blksize_t
st_blocks: blkcnt_t
st_atim_sec: time_t
st_atim_nsec: LONGLONG
st_mtim_sec: time_t
st_mtim_nsec: LONGLONG
st_ctim_sec: time_t
st_ctim_nsec: LONGLONG
__unused0: LONGLONG
__unused1: LONGLONG
__unused2: LONGLONG
class Dirent:
d_ino: ino_t
d_off: off_t
d_reclen: USHORT
d_type: BYTE
d_name: CHARPTR
def open(path: t.CConst | str, oflag: INT, *args) -> INT | t.State: pass
def close(fd: INT) -> INT | t.State: pass
def read(fd: INT, buf: bytes, count: t.CSizeT) -> ssize_t | t.State: pass
def write(fd: INT, buf: t.CConst | bytes, count: t.CSizeT) -> ssize_t | t.State: pass
def lseek(fd: INT, offset: off_t, whence: INT) -> off_t | t.State: pass
def unlink(path: t.CConst | str) -> INT | t.State: pass
def access(path: t.CConst | str, amode: INT) -> INT | t.State: pass
def realpath(path: t.CConst | str, resolved: CHARPTR) -> CHARPTR | t.State: pass
def rename(oldpath: t.CConst | str, newpath: t.CConst | str) -> INT | t.State: pass
def chmod(path: t.CConst | str, mode: mode_t) -> INT | t.State: pass
def stat(path: t.CConst | str, buf: Stat | t.CPtr) -> INT | t.State: pass
def fstat(fd: INT, buf: Stat | t.CPtr) -> INT | t.State: pass
def opendir(name: t.CConst | str) -> DIR | t.CPtr | t.State: pass
def readdir(dirp: DIR | t.CPtr) -> Dirent | t.CPtr | t.State: pass
def closedir(dirp: DIR | t.CPtr) -> INT | t.State: pass
def mkdir(path: t.CConst | str, mode: mode_t) -> INT | t.State: pass
def rmdir(path: t.CConst | str) -> INT | t.State: pass
def getcwd(buf: CHARPTR, size: t.CSizeT) -> CHARPTR | t.State: pass
def chdir(path: t.CConst | str) -> INT | t.State: pass
def fork() -> pid_t | t.State: pass
def execvp(file: t.CConst | str, argv: CHARPTR | t.CPtr) -> INT | t.State: pass
def execv(path: t.CConst | str, argv: CHARPTR | t.CPtr) -> INT | t.State: pass
def waitpid(pid: pid_t, status: INT | t.CPtr, options: INT) -> pid_t | t.State: pass
def pipe(fds: INT | t.CPtr) -> INT | t.State: pass
def dup2(oldfd: INT, newfd: INT) -> INT | t.State: pass
def _exit(status: INT) -> t.CVoid | t.State: pass
def getpid() -> pid_t | t.State: pass
def getenv(name: t.CConst | str) -> CHARPTR | t.State: pass
def setenv(name: t.CConst | str, value: t.CConst | str, overwrite: INT) -> INT | t.State: pass
def sysconf(name: INT) -> LONG | t.State: pass
def isatty(fd: INT) -> INT | t.State: pass
def S_ISREG(mode: mode_t) -> bool: pass
def S_ISDIR(mode: mode_t) -> bool: pass
def S_ISLNK(mode: mode_t) -> bool: pass
def S_ISCHR(mode: mode_t) -> bool: pass
def S_ISBLK(mode: mode_t) -> bool: pass
def S_ISFIFO(mode: mode_t) -> bool: pass
def S_ISSOCK(mode: mode_t) -> bool: pass
def WIFEXITED(status: INT) -> bool: pass
def WEXITSTATUS(status: INT) -> INT: pass
def WIFSIGNALED(status: INT) -> bool: pass
def WTERMSIG(status: INT) -> INT: pass

28
Test/SysLibTest/temp/6f62fe05c5ea1ceb.pyi Normal file
View File

@@ -0,0 +1,28 @@
"""
Auto-generated Python stub file from stdio.py
Module: stdio
"""
import t, c
def printf(fmt: t.CConst | str, *args) -> t.CInt | t.State: pass
def fprintf(stream: bytes, fmt: t.CConst | str, *args) -> t.CInt | t.State: pass
def sprintf(buf: bytes, fmt: t.CConst | str, *args) -> t.CInt | t.State: pass
def snprintf(buf: bytes, size: t.CSizeT, fmt: t.CConst | str, *args) -> t.CInt | t.State: pass
def puts(s: t.CConst | str) -> t.CInt | t.State: pass
def fputs(s: t.CConst | str, stream: bytes) -> t.CInt | t.State: pass
def fgets(buf: bytes, size: t.CInt, stream: bytes) -> bytes | t.State: pass
def fflush(stream: bytes) -> t.CInt | t.State: pass
stdin: t.CExtern | bytes
stdout: t.CExtern | bytes
stderr: t.CExtern | bytes

20
Test/SysLibTest/temp/71e0a3ffcb3ebfad.pyi Normal file
View File

@@ -0,0 +1,20 @@
"""
Auto-generated Python stub file from stdarg.py
Module: stdarg
"""
import c
import t
def va_start(args: t.CPtr, last_arg: t.CPtr) -> t.State: pass
def va_arg(args: t.CPtr, type: t.CPtr) -> t.CPtr | t.State: pass
def va_end(args: t.CPtr) -> t.State | t.State: pass
va_list: t.CTypedef = t.CUnsignedChar | t.CPtr
def arg(type: t.CType) -> t.State: pass

91
Test/SysLibTest/temp/72e2d5ccb7cedcf1.pyi Normal file
View File

@@ -0,0 +1,91 @@
"""
Auto-generated Python stub file from w32.win32memory.py
Module: w32.win32memory
"""
import c
import t
from stdint import *
from w32.win32base import *
MEM_COMMIT: t.CDefine = 0x00001000
MEM_RESERVE: t.CDefine = 0x00002000
MEM_DECOMMIT: t.CDefine = 0x00004000
MEM_RELEASE: t.CDefine = 0x00008000
MEM_FREE: t.CDefine = 0x00010000
MEM_RESET: t.CDefine = 0x00080000
MEM_TOP_DOWN: t.CDefine = 0x00100000
MEM_WRITE_WATCH: t.CDefine = 0x00200000
MEM_PHYSICAL: t.CDefine = 0x00400000
MEM_LARGE_PAGES: t.CDefine = 0x20000000
PAGE_NOACCESS: t.CDefine = 0x01
PAGE_READONLY: t.CDefine = 0x02
PAGE_READWRITE: t.CDefine = 0x04
PAGE_WRITECOPY: t.CDefine = 0x08
PAGE_EXECUTE: t.CDefine = 0x10
PAGE_EXECUTE_READ: t.CDefine = 0x20
PAGE_EXECUTE_READWRITE: t.CDefine = 0x40
PAGE_EXECUTE_WRITECOPY: t.CDefine = 0x80
PAGE_GUARD: t.CDefine = 0x100
PAGE_NOCACHE: t.CDefine = 0x200
PAGE_WRITECOMBINE: t.CDefine = 0x400
HEAP_NO_SERIALIZE: t.CDefine = 0x00000001
HEAP_GROWABLE: t.CDefine = 0x00000002
HEAP_GENERATE_EXCEPTIONS: t.CDefine = 0x00000004
HEAP_ZERO_MEMORY: t.CDefine = 0x00000008
HEAP_REALLOC_IN_PLACE_ONLY: t.CDefine = 0x00000010
class MEMORY_BASIC_INFORMATION:
BaseAddress: VOIDPTR
AllocationBase: VOIDPTR
AllocationProtect: ULONG
RegionSize: t.CSizeT
State: ULONG
Protect: ULONG
Type: ULONG
def VirtualAlloc(lpAddress: VOIDPTR, dwSize: t.CSizeT, flAllocationType: ULONG, flProtect: ULONG) -> VOIDPTR | t.State: pass
def VirtualFree(lpAddress: VOIDPTR, dwSize: t.CSizeT, dwFreeType: ULONG) -> BOOL | t.State: pass
def VirtualProtect(lpAddress: VOIDPTR, dwSize: t.CSizeT, flNewProtect: ULONG, lpflOldProtect: ULONG | t.CPtr) -> BOOL | t.State: pass
def VirtualQuery(lpAddress: t.CConst | VOIDPTR, lpBuffer: MEMORY_BASIC_INFORMATION | t.CPtr, dwLength: t.CSizeT) -> t.CSizeT | t.State: pass
def VirtualLock(lpAddress: VOIDPTR, dwSize: t.CSizeT) -> BOOL | t.State: pass
def VirtualUnlock(lpAddress: VOIDPTR, dwSize: t.CSizeT) -> BOOL | t.State: pass
def GetProcessHeap() -> HANDLE | t.State: pass
def HeapCreate(flOptions: ULONG, dwInitialSize: t.CSizeT, dwMaximumSize: t.CSizeT) -> HANDLE | t.State: pass
def HeapDestroy(hHeap: HANDLE) -> BOOL | t.State: pass
def HeapAlloc(hHeap: HANDLE, dwFlags: ULONG, dwBytes: t.CSizeT) -> VOIDPTR | t.State: pass
def HeapReAlloc(hHeap: HANDLE, dwFlags: ULONG, lpMem: VOIDPTR, dwBytes: t.CSizeT) -> VOIDPTR | t.State: pass
def HeapFree(hHeap: HANDLE, dwFlags: ULONG, lpMem: VOIDPTR) -> BOOL | t.State: pass
def HeapSize(hHeap: HANDLE, dwFlags: ULONG, lpMem: t.CConst | VOIDPTR) -> t.CSizeT | t.State: pass
def HeapValidate(hHeap: HANDLE, dwFlags: ULONG, lpMem: t.CConst | VOIDPTR) -> BOOL | t.State: pass
def HeapCompact(hHeap: HANDLE, dwFlags: ULONG) -> t.CSizeT | t.State: pass
def GlobalAlloc(uFlags: UINT, dwBytes: t.CSizeT) -> VOIDPTR | t.State: pass
def GlobalFree(hMem: VOIDPTR) -> VOIDPTR | t.State: pass
def GlobalLock(hMem: VOIDPTR) -> VOIDPTR | t.State: pass
def GlobalUnlock(hMem: VOIDPTR) -> BOOL | t.State: pass
def GlobalSize(hMem: VOIDPTR) -> t.CSizeT | t.State: pass
def LocalAlloc(uFlags: UINT, dwBytes: t.CSizeT) -> VOIDPTR | t.State: pass
def LocalFree(hMem: VOIDPTR) -> VOIDPTR | t.State: pass

41
Test/SysLibTest/temp/76dd6c275aa72b3b.pyi Normal file
View File

@@ -0,0 +1,41 @@
"""
Auto-generated Python stub file from os.__init__.py
Module: os.__init__
"""
import t, c
from stdint import *
import platmacro
import memhub
import os.path
import os._win32
import os._posix
_mbuddy: t.CExtern | memhub.MemBuddy | t.CPtr
def exists(path: str) -> bool: pass
def isdir(path: str) -> bool: pass
def isfile(path: str) -> bool: pass
def getsize(path: str) -> t.CInt64T: pass
def getcwd() -> str: pass
def chdir(path: str) -> int: pass
def mkdir(path: str) -> int: pass
def remove(path: str) -> int: pass
def rmdir(path: str) -> int: pass
def rename(old_path: str, new_path: str) -> int: pass
def chmod(path: str, mode: int) -> int: pass
def listdir(path: str, out_names: str, max_count: ULONG) -> ULONG: pass
def system(cmd: str) -> int: pass

100
Test/SysLibTest/temp/7e529fe7a078cfef.pyi Normal file
View File

@@ -0,0 +1,100 @@
"""
Auto-generated Python stub file from w32.win32base.py
Module: w32.win32base
"""
import c
import t
from stdint import *
HANDLE: t.CTypedef = VOIDPTR
LPCSTR: t.CTypedef = t.CConst | t.CChar | t.CPtr
LPCWSTR: t.CTypedef = t.CConst | t.CUnsignedShort | t.CPtr
INVALID_HANDLE_VALUE: t.CDefine = t.CVoid(-1)
NULL: t.CDefine = 0
TRUE: t.CDefine = 1
FALSE: t.CDefine = 0
INFINITE: t.CDefine = 0xFFFFFFFF
WAIT_FAILED: t.CDefine = 0xFFFFFFFF
WAIT_OBJECT_0: t.CDefine = 0
WAIT_TIMEOUT: t.CDefine = 258
WAIT_ABANDONED: t.CDefine = 0x80
MAX_PATH: t.CDefine = 260
ERROR_SUCCESS: t.CDefine = 0
ERROR_FILE_NOT_FOUND: t.CDefine = 2
ERROR_ACCESS_DENIED: t.CDefine = 5
ERROR_INSUFFICIENT_BUFFER: t.CDefine = 122
class SECURITY_ATTRIBUTES:
nLength: ULONG
lpSecurityDescriptor: VOIDPTR
bInheritHandle: BOOL
class OVERLAPPED:
Internal: ULONGLONG
InternalHigh: ULONGLONG
Offset: ULONG
OffsetHigh: ULONG
hEvent: HANDLE
class FILETIME:
dwLowDateTime: DWORD
dwHighDateTime: DWORD
class SYSTEMTIME:
wYear: WORD
wMonth: WORD
wDayOfWeek: WORD
wDay: WORD
wHour: WORD
wMinute: WORD
wSecond: WORD
wMilliseconds: WORD
class GUID:
Data1: DWORD
Data2: WORD
Data3: WORD
Data4: BYTEPTR
class LARGE_INTEGER:
QuadPart: LONGLONG
class ULARGE_INTEGER:
QuadPart: ULONGLONG
def GetLastError() -> ULONG | t.State: pass
def SetLastError(dwErrCode: ULONG) -> t.State: pass
def CloseHandle(hObject: HANDLE) -> BOOL | t.State: pass
def GetProcAddress(hModule: HANDLE, lpProcName: LPCSTR) -> VOIDPTR | t.State: pass
def GetModuleHandleA(lpModuleName: LPCSTR) -> HANDLE | t.State: pass
def GetModuleHandleW(lpModuleName: LPCWSTR) -> HANDLE | t.State: pass
def LoadLibraryA(lpLibFileName: LPCSTR) -> HANDLE | t.State: pass
def LoadLibraryW(lpLibFileName: LPCWSTR) -> HANDLE | t.State: pass
def FreeLibrary(hLibModule: HANDLE) -> BOOL | t.State: pass
def GetSystemTime(lpSystemTime: SYSTEMTIME | t.CPtr) -> t.State: pass
def GetLocalTime(lpSystemTime: SYSTEMTIME | t.CPtr) -> t.State: pass
def FileTimeToSystemTime(lpFileTime: FILETIME | t.CPtr, lpSystemTime: SYSTEMTIME | t.CPtr) -> BOOL | t.State: pass
def SystemTimeToFileTime(lpSystemTime: SYSTEMTIME | t.CPtr, lpFileTime: FILETIME | t.CPtr) -> BOOL | t.State: pass
def QueryPerformanceCounter(lpPerformanceCount: LARGE_INTEGER | t.CPtr) -> BOOL | t.State: pass
def QueryPerformanceFrequency(lpFrequency: LARGE_INTEGER | t.CPtr) -> BOOL | t.State: pass
def Sleep(dwMilliseconds: ULONG) -> t.State: pass
def SleepEx(dwMilliseconds: ULONG, bAlertable: BOOL) -> ULONG | t.State: pass
def GetTickCount() -> ULONG | t.State: pass
def GetTickCount64() -> ULONGLONG | t.State: pass
def GetCommandLineA() -> CHARPTR | t.State: pass

20
Test/SysLibTest/temp/90c53dd6db8d41cf.pyi Normal file
View File

@@ -0,0 +1,20 @@
"""
Auto-generated Python stub file from stdlib.py
Module: stdlib
"""
import c
from stdint import *
import t
def malloc(size: t.CSizeT) -> t.CVoid | t.CPtr | t.State: pass
def calloc(nmemb: t.CSizeT, size: t.CSizeT) -> t.CVoid | t.CPtr | t.State: pass
def realloc(p: t.CVoid | t.CPtr, size: t.CSizeT) -> t.CVoid | t.CPtr | t.State: pass
def free(p: t.CVoid | t.CPtr) -> t.State: pass
def system(cmd: t.CConst | t.CChar | t.CPtr) -> INT | t.State: pass

53
Test/SysLibTest/temp/93c1d18e35d188d6.pyi Normal file
View File

@@ -0,0 +1,53 @@
"""
Auto-generated Python stub file from platmacro.py
Module: platmacro
"""
import t, c
IS_WINDOWS: t.CDefine = 1
IS_WIN64: t.CDefine = 1
IS_X86_64: t.CDefine = 1
IS_LP64: t.CDefine = 1
IS_LITTLE_ENDIAN: t.CDefine = 1
IS_LINUX: t.CDefine = 0
IS_MACOS: t.CDefine = 0
IS_ARM64: t.CDefine = 0
IS_BIG_ENDIAN: t.CDefine = 0
IS_ILP32: t.CDefine = 0
PTR_SIZE: t.CDefine = t.CSizeT().Size
INT_SIZE: t.CDefine = 4
LONG_SIZE: t.CDefine = t.CLong().Size
WORD_SIZE: t.CDefine = t.CSizeT().Size
CACHE_LINE_SIZE: t.CDefine = 64
PAGE_SIZE: t.CDefine = 4096
STACK_ALIGN: t.CDefine = 16
MAX_PATH_LEN: t.CDefine = 260
PLATFORM_NAME: t.CDefine = 1
ARCH_NAME: t.CDefine = 1
WINVER: t.CDefine = 0x0A00
_WIN32_WINNT: t.CDefine = 0x0A00
NTDDI_VERSION: t.CDefine = 0x0A000006
HAS_SSE2: t.CDefine = 1
HAS_AVX: t.CDefine = 1
HAS_AVX2: t.CDefine = 1
HAS_FMA: t.CDefine = 1
HAS_NEON: t.CDefine = 0
ALIGNOF_INT: t.CDefine = 4
ALIGNOF_LONG: t.CDefine = t.CLong().Size // 8
ALIGNOF_PTR: t.CDefine = t.CSizeT().Size // 8
ALIGNOF_DOUBLE: t.CDefine = 8
ALIGNOF_LONG_DOUBLE: t.CDefine = 16
SIZEOF_SHORT: t.CDefine = 2
SIZEOF_INT: t.CDefine = 4
SIZEOF_LONG: t.CDefine = t.CLong().Size // 8
SIZEOF_LONG_LONG: t.CDefine = 8
SIZEOF_FLOAT: t.CDefine = 4
SIZEOF_DOUBLE: t.CDefine = 8
SIZEOF_LONG_DOUBLE: t.CDefine = 16
SIZEOF_POINTER: t.CDefine = t.CSizeT().Size // 8
SIZEOF_SIZE_T: t.CDefine = t.CSizeT().Size // 8
SIZEOF_PTRDIFF_T: t.CDefine = t.CPtrDiffT().Size // 8
BYTE_ORDER_LE: t.CDefine = 1
BYTE_ORDER_BE: t.CDefine = 0

1
Test/SysLibTest/temp/_phase1_manifest.json Normal file
View File

@@ -0,0 +1 @@
{"D:\\Users\\TermiNexus\\Desktop\\TransPyC\\Test\\SysLibTest\\App\\main.py": {"sha1": "c70684ccfe48a5a9", "mtime": 1782828223.3150382, "size": 918}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\Test\\SysLibTest\\App\\os_backend.py": {"sha1": "59e00d50660b941e", "mtime": 1782491896.4070306, "size": 1323}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\Test\\SysLibTest\\App\\syslibtest_impl.py": {"sha1": "a03139660029514f", "mtime": 1782828233.2147534, "size": 12395}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\atom.py": {"sha1": "271ea3decb810db2", "mtime": 1782226548.693161, "size": 1290}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\memhub.py": {"sha1": "ee084e9fc6ee413a", "mtime": 1784214242.4485993, "size": 17765}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\os\\__init__.py": {"sha1": "76dd6c275aa72b3b", "mtime": 1782826646.8940291, "size": 4395}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\os\\_posix.py": {"sha1": "d152115b49e50218", "mtime": 1782826648.538678, "size": 5665}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\os\\_win32.py": {"sha1": "a68b70f233541a7f", "mtime": 1782826646.872196, "size": 7601}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\os\\path.py": {"sha1": "13110effbb0bb06c", "mtime": 1782826648.9189062, "size": 9499}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\platmacro.py": {"sha1": "93c1d18e35d188d6", "mtime": 1781237231.03366, "size": 1422}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\posix.py": {"sha1": "6503c97dde0c79c4", "mtime": 1783064077.6376991, "size": 10386}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\shutil.py": {"sha1": "abbcbd92436cc16a", "mtime": 1782826619.0231705, "size": 9131}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\stdarg.py": {"sha1": "71e0a3ffcb3ebfad", "mtime": 1781258888.113146, "size": 277}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\stdint.py": {"sha1": "f5522571bcce7bcb", "mtime": 1782383975.8824987, "size": 4356}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\stdio.py": {"sha1": "6f62fe05c5ea1ceb", "mtime": 1783239556.0959673, "size": 714}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\stdlib.py": {"sha1": "90c53dd6db8d41cf", "mtime": 1783874975.3597875, "size": 375}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\string.py": {"sha1": "ab6e54ba9a669f76", "mtime": 1783933178.7264287, "size": 9922}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\subprocess.py": {"sha1": "2da636c61863c815", "mtime": 1783847277.4569364, "size": 7627}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\sys.py": {"sha1": "b5a965302cded36b", "mtime": 1783569641.07535, "size": 5509}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\testcheck.py": {"sha1": "dd3002730623424b", "mtime": 1783927513.1159866, "size": 1818}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\viperio.py": {"sha1": "c9f4be41ca1cc2b4", "mtime": 1782812279.506002, "size": 1556}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\viperlib.py": {"sha1": "c3b259b4059f8668", "mtime": 1782821991.979496, "size": 56772}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\w32\\fileio.py": {"sha1": "0035c95a18d4f8e8", "mtime": 1783747022.686592, "size": 14147}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\w32\\win32base.py": {"sha1": "7e529fe7a078cfef", "mtime": 1782488356.7736557, "size": 2662}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\w32\\win32console.py": {"sha1": "bbdf3bbd4c3bc28c", "mtime": 1781200703.5338137, "size": 5604}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\w32\\win32file.py": {"sha1": "f6b51804a0ba8ff0", "mtime": 1782531158.744144, "size": 8424}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\w32\\win32process.py": {"sha1": "067c78e9f121dce3", "mtime": 1781200703.5409546, "size": 4802}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\w32\\win32sync.py": {"sha1": "06f53cc594b4ac6c", "mtime": 1782297500.2581685, "size": 4726}}

28
Test/SysLibTest/temp/_sha1_map.txt Normal file
View File

@@ -0,0 +1,28 @@
0035c95a18d4f8e8:includes/w32\fileio.py
067c78e9f121dce3:includes/w32\win32process.py
06f53cc594b4ac6c:includes/w32\win32sync.py
13110effbb0bb06c:includes/os\path.py
271ea3decb810db2:includes/atom.py
2da636c61863c815:includes/subprocess.py
59e00d50660b941e:os_backend.py
6503c97dde0c79c4:includes/posix.py
6f62fe05c5ea1ceb:includes/stdio.py
71e0a3ffcb3ebfad:includes/stdarg.py
76dd6c275aa72b3b:includes/os\__init__.py
7e529fe7a078cfef:includes/w32\win32base.py
90c53dd6db8d41cf:includes/stdlib.py
93c1d18e35d188d6:includes/platmacro.py
a03139660029514f:syslibtest_impl.py
a68b70f233541a7f:includes/os\_win32.py
ab6e54ba9a669f76:includes/string.py
abbcbd92436cc16a:includes/shutil.py
b5a965302cded36b:includes/sys.py
bbdf3bbd4c3bc28c:includes/w32\win32console.py
c3b259b4059f8668:includes/viperlib.py
c70684ccfe48a5a9:main.py
c9f4be41ca1cc2b4:includes/viperio.py
d152115b49e50218:includes/os\_posix.py
dd3002730623424b:includes/testcheck.py
ee084e9fc6ee413a:includes/memhub.py
f5522571bcce7bcb:includes/stdint.py
f6b51804a0ba8ff0:includes/w32\win32file.py

BIN
Test/SysLibTest/temp/_shared_sym.json Normal file
View File

Binary file not shown.

1
Test/SysLibTest/temp/a03139660029514f.doc.json Normal file
View File

@@ -0,0 +1 @@
{"_cleanup": "清理可能残留的测试文件/目录"}

34
Test/SysLibTest/temp/a03139660029514f.pyi Normal file
View File

@@ -0,0 +1,34 @@
"""
Auto-generated Python stub file from syslibtest_impl.py
Module: syslibtest_impl
"""
import t, c
from stdint import *
from t import CInt, CPtr, CUInt8T, CSizeT
import testcheck
import viperlib
import stdlib
import memhub
import platmacro
import os
import os.path
import os_backend
import shutil
import sys
import subprocess
import string
import w32.fileio
import w32.win32base
import w32.win32process
TEST_DIR: t.CDefine = "__sylibtest_dir__"
TEST_FILE: t.CDefine = "__sylibtest_file.txt"
TEST_COPY: t.CDefine = "__sylibtest_copy.txt"
TEST_TREE: t.CDefine = "__sylibtest_tree__"
TEST_MOVE: t.CDefine = "__sylibtest_moved.txt"
def _cleanup() -> t.CInt: pass
def run() -> CInt: pass

44
Test/SysLibTest/temp/a68b70f233541a7f.pyi Normal file
View File

@@ -0,0 +1,44 @@
"""
Auto-generated Python stub file from os._win32.py
Module: os._win32
"""
import t, c
from stdint import *
import w32.win32base
import w32.win32file
import memhub
import stdlib
MAX_PATH_LEN: t.CDefine = 260
INVALID_FILE_ATTRIBUTES: t.CDefine = 0xFFFFFFFF
_mbuddy: t.CExtern | memhub.MemBuddy | t.CPtr
def _get_attrs(path: str) -> ULONG: pass
def exists(path: str) -> bool: pass
def isdir(path: str) -> bool: pass
def isfile(path: str) -> bool: pass
def getsize(path: str) -> t.CInt64T: pass
def getcwd() -> str: pass
def chdir(path: str) -> int: pass
def mkdir(path: str) -> int: pass
def remove(path: str) -> int: pass
def rmdir(path: str) -> int: pass
def rename(old_path: str, new_path: str) -> int: pass
def chmod(path: str, mode: int) -> int: pass
def listdir(path: str, out_names: str, max_count: ULONG) -> ULONG: pass
def system(cmd: str) -> int: pass

48
Test/SysLibTest/temp/ab6e54ba9a669f76.pyi Normal file
View File

@@ -0,0 +1,48 @@
"""
Auto-generated Python stub file from string.py
Module: string
"""
from stdint import *
import t, c
def strcpy(dest: str, src: str) -> str: pass
def strcat(dest: str, src: str) -> str: pass
def strncpy(dest: str, src: str, n: t.CSizeT) -> str: pass
def strlen(src: str) -> t.CSizeT | t.CExport: pass
def strcmp(str1: str, str2: str) -> t.CInt: pass
def samestr(str1: str, str2: str) -> bool: pass
def strncmp(str1: str, str2: str, n: t.CSizeT) -> t.CInt: pass
def memcmp(ptr1: t.CVoid | t.CPtr, ptr2: t.CVoid | t.CPtr, n: t.CSizeT) -> t.CInt: pass
def strchr(s: str, cr: t.CInt) -> str: pass
def strrchr(s: str, cr: t.CInt) -> str: pass
def strstr(s: str, needle: str) -> str: pass
def strspn(s: str, skip: str) -> int: pass
def memset(ptr: t.CVoid | t.CPtr, value: t.CInt, num: t.CSizeT) -> t.CVoid | t.CPtr | t.CExport: pass
def memset32(ptr: t.CVoid | t.CPtr, value: t.CUInt32T, count: t.CSizeT) -> t.CVoid | t.CPtr: pass
def memcpy(dest: t.CVoid | t.CPtr, src: t.CVoid | t.CPtr, num: t.CSizeT) -> t.CVoid | t.CPtr | t.CExport: pass
def memmove(dest: t.CVoid | t.CPtr, src: t.CVoid | t.CPtr, num: t.CSizeT) -> t.CVoid | t.CPtr: pass
def atoi(src: str) -> t.CInt: pass
def atoll(src: str) -> t.CInt64T: pass
def atof(src: str) -> t.CDouble: pass
def split(s: str, delim: str, result: t.CArray[str]) -> int: pass

41
Test/SysLibTest/temp/abbcbd92436cc16a.pyi Normal file
View File

@@ -0,0 +1,41 @@
"""
Auto-generated Python stub file from shutil.py
Module: shutil
"""
import t, c
from stdint import *
import platmacro
import memhub
import string
import w32.win32base
import w32.win32file
import posix
COPY_BUF_SIZE: t.CDefine = 65536
_mbuddy: t.CExtern | memhub.MemBuddy | t.CPtr
def copyfile(src: str, dst: str) -> int: pass
def _copyfile_win32(src: str, dst: str) -> int: pass
def _copyfile_posix(src: str, dst: str) -> int: pass
def copy(src: str, dst: str) -> int: pass
def _copy_win32(src: str, dst: str) -> int: pass
def _copy_posix(src: str, dst: str) -> int: pass
def rmtree(path: str) -> int: pass
def _rmtree_win32(path: str) -> int: pass
def _rmtree_posix(path: str) -> int: pass
def move(src: str, dst: str) -> int: pass
def _move_win32(src: str, dst: str) -> int: pass
def _move_posix(src: str, dst: str) -> int: pass

44
Test/SysLibTest/temp/b5a965302cded36b.pyi Normal file
View File

@@ -0,0 +1,44 @@
"""
Auto-generated Python stub file from sys.py
Module: sys
"""
import t, c
from stdint import *
import platmacro
import memhub
import string
import stdio
import w32.win32base
import w32.win32process
import posix
_mbuddy: t.CExtern | memhub.MemBuddy | t.CPtr
def fgets(buf: t.CChar | t.CPtr, size: t.CInt, stream: t.CVoid | t.CPtr) -> t.CChar | t.CPtr | t.CExtern | t.CExport: pass
def fflush(stream: t.CVoid | t.CPtr) -> t.CInt | t.CExtern | t.CExport: pass
def exit(status: INT) -> VOID | t.CExtern | t.CExport: pass
maxsize: t.CDefine = 9223372036854775807
def platform() -> str: pass
def get_pid() -> int: pass
_argc: t.CExtern | INT
_argv: t.CExtern | str | t.CPtr
def _init_argv() -> t.CInt: pass
def _init_argv_win32() -> t.CInt: pass
def _init_argv_posix() -> t.CInt: pass
def argc() -> int: pass
def argv(index: int) -> str: pass

138
Test/SysLibTest/temp/bbdf3bbd4c3bc28c.pyi Normal file
View File

@@ -0,0 +1,138 @@
"""
Auto-generated Python stub file from w32.win32console.py
Module: w32.win32console
"""
import c
import t
from stdint import *
from w32.win32base import *
ENABLE_PROCESSED_INPUT: t.CDefine = 0x0001
ENABLE_LINE_INPUT: t.CDefine = 0x0002
ENABLE_ECHO_INPUT: t.CDefine = 0x0004
ENABLE_WINDOW_INPUT: t.CDefine = 0x0008
ENABLE_MOUSE_INPUT: t.CDefine = 0x0010
ENABLE_INSERT_MODE: t.CDefine = 0x0020
ENABLE_QUICK_EDIT_MODE: t.CDefine = 0x0040
ENABLE_EXTENDED_FLAGS: t.CDefine = 0x0080
ENABLE_PROCESSED_OUTPUT: t.CDefine = 0x0001
ENABLE_WRAP_AT_EOL_OUTPUT: t.CDefine = 0x0002
ENABLE_VIRTUAL_TERMINAL_PROCESSING: t.CDefine = 0x0004
DISABLE_NEWLINE_AUTO_RETURN: t.CDefine = 0x0008
ENABLE_LVB_GRID_WORLDWIDE: t.CDefine = 0x0010
FOREGROUND_BLUE: t.CDefine = 0x0001
FOREGROUND_GREEN: t.CDefine = 0x0002
FOREGROUND_RED: t.CDefine = 0x0004
FOREGROUND_INTENSITY: t.CDefine = 0x0008
BACKGROUND_BLUE: t.CDefine = 0x0010
BACKGROUND_GREEN: t.CDefine = 0x0020
BACKGROUND_RED: t.CDefine = 0x0040
BACKGROUND_INTENSITY: t.CDefine = 0x0080
KEY_EVENT: t.CDefine = 0x0001
MOUSE_EVENT: t.CDefine = 0x0002
WINDOW_BUFFER_SIZE_EVENT: t.CDefine = 0x0004
MENU_EVENT: t.CDefine = 0x0008
FOCUS_EVENT: t.CDefine = 0x0010
class COORD:
X: SHORT
Y: SHORT
class SMALL_RECT:
Left: SHORT
Top: SHORT
Right: SHORT
Bottom: SHORT
class CONSOLE_SCREEN_BUFFER_INFO:
dwSize: COORD
dwCursorPosition: COORD
wAttributes: WORD
srWindow: SMALL_RECT
dwMaximumWindowSize: COORD
class CONSOLE_CURSOR_INFO:
dwSize: ULONG
bVisible: BOOL
class CHAR_INFO:
UnicodeChar: WCHAR
Attributes: WORD
class KEY_EVENT_RECORD:
bKeyDown: BOOL
wRepeatCount: WORD
wVirtualKeyCode: WORD
wVirtualScanCode: WORD
uChar: WCHAR
dwControlKeyState: ULONG
class MOUSE_EVENT_RECORD:
dwMousePosition: COORD
dwButtonState: ULONG
dwControlKeyState: ULONG
dwEventFlags: ULONG
class WINDOW_BUFFER_SIZE_RECORD:
dwSize: COORD
class INPUT_RECORD:
EventType: WORD
Event: KEY_EVENT_RECORD
def SetConsoleOutputCP(codepage: UINT) -> BOOL | t.State: pass
def SetConsoleCP(codepage: UINT) -> BOOL | t.State: pass
def GetConsoleCP() -> UINT | t.State: pass
def GetConsoleOutputCP() -> UINT | t.State: pass
def GetConsoleScreenBufferInfo(hConsoleOutput: HANDLE, lpConsoleScreenBufferInfo: CONSOLE_SCREEN_BUFFER_INFO | t.CPtr) -> BOOL | t.State: pass
def SetConsoleScreenBufferSize(hConsoleOutput: HANDLE, dwSize: COORD) -> BOOL | t.State: pass
def SetConsoleCursorPosition(hConsoleOutput: HANDLE, dwCursorPosition: COORD) -> BOOL | t.State: pass
def GetConsoleCursorInfo(hConsoleOutput: HANDLE, lpConsoleCursorInfo: CONSOLE_CURSOR_INFO | t.CPtr) -> BOOL | t.State: pass
def SetConsoleCursorInfo(hConsoleOutput: HANDLE, lpConsoleCursorInfo: CONSOLE_CURSOR_INFO | t.CPtr) -> BOOL | t.State: pass
def SetConsoleTextAttribute(hConsoleOutput: HANDLE, wAttributes: WORD) -> BOOL | t.State: pass
def FillConsoleOutputCharacterA(hConsoleOutput: HANDLE, cCharacter: t.CChar, nLength: ULONG, dwWriteCoord: COORD, lpNumberOfCharsWritten: ULONG | t.CPtr) -> BOOL | t.State: pass
def FillConsoleOutputCharacterW(hConsoleOutput: HANDLE, cCharacter: WCHAR, nLength: ULONG, dwWriteCoord: COORD, lpNumberOfCharsWritten: ULONG | t.CPtr) -> BOOL | t.State: pass
def FillConsoleOutputAttribute(hConsoleOutput: HANDLE, wAttribute: WORD, nLength: ULONG, dwWriteCoord: COORD, lpNumberOfAttrsWritten: ULONG | t.CPtr) -> BOOL | t.State: pass
def WriteConsoleA(hConsoleOutput: HANDLE, lpBuffer: t.CConst | VOIDPTR, nNumberOfCharsToWrite: ULONG, lpNumberOfCharsWritten: ULONG | t.CPtr, lpReserved: VOIDPTR) -> BOOL | t.State: pass
def WriteConsoleW(hConsoleOutput: HANDLE, lpBuffer: t.CConst | VOIDPTR, nNumberOfCharsToWrite: ULONG, lpNumberOfCharsWritten: ULONG | t.CPtr, lpReserved: VOIDPTR) -> BOOL | t.State: pass
def ReadConsoleA(hConsoleInput: HANDLE, lpBuffer: VOIDPTR, nNumberOfCharsToRead: ULONG, lpNumberOfCharsRead: ULONG | t.CPtr, pInputControl: VOIDPTR) -> BOOL | t.State: pass
def ReadConsoleW(hConsoleInput: HANDLE, lpBuffer: VOIDPTR, nNumberOfCharsToRead: ULONG, lpNumberOfCharsRead: ULONG | t.CPtr, pInputControl: VOIDPTR) -> BOOL | t.State: pass
def GetConsoleMode(hConsoleHandle: HANDLE, lpMode: ULONG | t.CPtr) -> BOOL | t.State: pass
def SetConsoleMode(hConsoleHandle: HANDLE, dwMode: ULONG) -> BOOL | t.State: pass
def ReadConsoleInputA(hConsoleInput: HANDLE, lpBuffer: INPUT_RECORD | t.CPtr, nLength: ULONG, lpNumberOfEventsRead: ULONG | t.CPtr) -> BOOL | t.State: pass
def ReadConsoleInputW(hConsoleInput: HANDLE, lpBuffer: INPUT_RECORD | t.CPtr, nLength: ULONG, lpNumberOfEventsRead: ULONG | t.CPtr) -> BOOL | t.State: pass
def GetNumberOfConsoleInputEvents(hConsoleInput: HANDLE, lpNumberOfEvents: ULONG | t.CPtr) -> BOOL | t.State: pass
def FlushConsoleInputBuffer(hConsoleInput: HANDLE) -> BOOL | t.State: pass
def SetConsoleTitleA(lpConsoleTitle: LPCSTR) -> BOOL | t.State: pass
def SetConsoleTitleW(lpConsoleTitle: LPCWSTR) -> BOOL | t.State: pass
def GetConsoleTitleA(lpConsoleTitle: CHARPTR, nSize: ULONG) -> ULONG | t.State: pass
def GetConsoleTitleW(lpConsoleTitle: WCHARPTR, nSize: ULONG) -> ULONG | t.State: pass
def AllocConsole() -> BOOL | t.State: pass
def FreeConsole() -> BOOL | t.State: pass
def SetConsoleWindowInfo(hConsoleOutput: HANDLE, bAbsolute: BOOL, lpConsoleWindow: SMALL_RECT | t.CPtr) -> BOOL | t.State: pass
def ScrollConsoleScreenBufferA(hConsoleOutput: HANDLE, lpScrollRectangle: SMALL_RECT | t.CPtr, lpClipRectangle: SMALL_RECT | t.CPtr, dwDestinationOrigin: COORD, lpFill: CHAR_INFO | t.CPtr) -> BOOL | t.State: pass

23
Test/SysLibTest/temp/c3b259b4059f8668.pyi Normal file
View File

@@ -0,0 +1,23 @@
"""
Auto-generated Python stub file from viperlib.py
Module: viperlib
"""
import t, c
import viperio
from stdarg import arg, va_arg
TEMP_BUF_SIZE: t.CDefine = 68
def get_digit_count(num: t.CUnsignedInt, base: t.CInt) -> t.CStatic | t.CInt: pass
def sprintf(buf: t.CChar | t.CPtr, rule: str, *args) -> t.CVoid | t.CExport: pass
def vsprintf(buf: t.CChar | t.CPtr, rule: str, *args) -> t.CInt: pass
def snprintf(buf: t.CChar | t.CPtr, size: t.CSizeT, fmt: str, *args) -> t.CInt | t.CExport: pass
def _check_special_float(fv: t.CDouble) -> t.CInt: pass
def vsnprintf(buf: t.CChar | t.CPtr, size: t.CSizeT, fmt: str, ap: t.CChar | t.CPtr) -> t.CInt | t.CExport: pass

1
Test/SysLibTest/temp/c70684ccfe48a5a9.doc.json Normal file
View File

@@ -0,0 +1 @@
{}

24
Test/SysLibTest/temp/c70684ccfe48a5a9.pyi Normal file
View File

@@ -0,0 +1,24 @@
"""
Auto-generated Python stub file from main.py
Module: main
"""
from stdint import *
import w32.win32console
import t, c
from t import CInt, CExport
import memhub
import stdlib
import sys
import os
import os._win32
import os._posix
import os.path
import shutil
import subprocess
import syslibtest_impl
ARENA_SIZE: t.CDefine = 1048576
def main() -> CInt | CExport: pass

22
Test/SysLibTest/temp/c9f4be41ca1cc2b4.pyi Normal file
View File

@@ -0,0 +1,22 @@
"""
Auto-generated Python stub file from viperio.py
Module: viperio
"""
import t, c
from stdint import *
class Buf:
data: t.CChar | t.CPtr
length: t.CSizeT
capacity: t.CSizeT
owned: bool
def __init__(self: Buf, data: t.CChar | t.CPtr, capacity: t.CSizeT, length: t.CSizeT, owned: bool) -> t.CInt: pass
def clear(self: Buf) -> t.CInt: pass
def write(self: Buf, src: t.CChar | t.CPtr, count: t.CSizeT) -> t.CSizeT: pass
def cstr(self: Buf) -> t.CChar | t.CPtr: pass
def reset(self: Buf) -> t.CInt: pass
def __enter__(self: Buf) -> 'Buf' | t.CPtr: pass
def __exit__(self: Buf) -> t.CInt: pass
def free(self: Buf) -> t.CInt: pass

42
Test/SysLibTest/temp/d152115b49e50218.pyi Normal file
View File

@@ -0,0 +1,42 @@
"""
Auto-generated Python stub file from os._posix.py
Module: os._posix
"""
import t, c
from stdint import *
import posix
import memhub
import stdlib
MAX_PATH_LEN: t.CDefine = 4096
_mbuddy: t.CExtern | memhub.MemBuddy | t.CPtr
def _stat(path: str) -> posix.Stat | t.CPtr: pass
def exists(path: str) -> bool: pass
def isdir(path: str) -> bool: pass
def isfile(path: str) -> bool: pass
def getsize(path: str) -> t.CInt64T: pass
def getcwd_impl() -> str: pass
def chdir_impl(path: str) -> int: pass
def mkdir_impl(path: str) -> int: pass
def remove(path: str) -> int: pass
def rmdir_impl(path: str) -> int: pass
def rename_impl(old_path: str, new_path: str) -> int: pass
def chmod_impl(path: str, mode: int) -> int: pass
def listdir(path: str, out_names: str, max_count: ULONG) -> ULONG: pass
def system_impl(cmd: str) -> int: pass

31
Test/SysLibTest/temp/dd3002730623424b.pyi Normal file
View File

@@ -0,0 +1,31 @@
"""
Auto-generated Python stub file from testcheck.py
Module: testcheck
"""
import t, c
import stdio
from w32.win32console import SetConsoleOutputCP, SetConsoleCP
CP_UTF8: t.CDefine = 65001
_pass_count: t.CExtern | t.CInt
_fail_count: t.CExtern | t.CInt
_total_pass: t.CExtern | t.CInt
_total_fail: t.CExtern | t.CInt
def begin(name: str) -> t.CInt: pass
def section(name: str) -> t.CInt: pass
def ok(msg: str) -> t.CInt: pass
def fail(msg: str) -> t.CInt: pass
def check(cond: t.CInt, ok_msg: str, fail_msg: str) -> t.CInt: pass
def info(msg: str) -> t.CInt: pass
def end() -> t.CInt: pass
def summary() -> t.CInt: pass

81
Test/SysLibTest/temp/ee084e9fc6ee413a.pyi Normal file
View File

@@ -0,0 +1,81 @@
"""
Auto-generated Python stub file from memhub.py
Module: memhub
"""
import t, c
from stdint import *
import string
import atom
import viperio
MEMHUB_ALIGN: t.CDefine = 8
MEMSLAB_MIN_BLOCK: t.CDefine = 16
MEMSLAB_BITMAP_BYTES: t.CDefine = 256
MEMBUDDY_MIN_BLOCK: t.CDefine = 32
MEMBUDDY_MAX_ORDERS: t.CDefine = 32
MEMBUDDY_HEADER_SIZE: t.CDefine = 8
def _align_up(val: t.CSizeT, align: t.CSizeT) -> t.CSizeT: pass
def _largest_pow2_le(val: t.CSizeT) -> t.CSizeT: pass
def _block_size_at_order(order: t.CInt) -> t.CSizeT: pass
@t.CVTable
class MemManager:
__provides__: list[str] = ['__memmgr__']
base: t.CVoid | t.CPtr
size: t.CSizeT
def __init__(self: MemManager, base: t.CVoid | t.CPtr, size: t.CSizeT) -> t.CInt: pass
def alloc(self: MemManager, size: t.CSizeT) -> t.CVoid | t.CPtr: pass
def free(self: MemManager, ptr: t.CVoid | t.CPtr) -> t.CInt: pass
def reset(self: MemManager) -> t.CInt: pass
def calloc(self: MemManager, count: t.CSizeT, size: t.CSizeT) -> t.CVoid | t.CPtr: pass
def realloc(self: MemManager, ptr: t.CVoid | t.CPtr, old_size: t.CSizeT, new_size: t.CSizeT) -> t.CVoid | t.CPtr: pass
def __enter__(self: MemManager) -> 'MemManager' | t.CPtr: pass
def __exit__(self: MemManager) -> t.CInt: pass
def alloc_buf(self: MemManager, capacity: t.CSizeT) -> viperio.Buf | t.CPtr: pass
class MemPool(MemManager):
offset: t.CSizeT
high_water: t.CSizeT
def __init__(self: MemPool, base: t.CVoid | t.CPtr, size: t.CSizeT) -> t.CInt: pass
def alloc(self: MemPool, size: t.CSizeT) -> t.CVoid | t.CPtr: pass
def free(self: MemPool, ptr: t.CVoid | t.CPtr) -> t.CInt: pass
def reset(self: MemPool) -> t.CInt: pass
class MemSlab(MemManager):
block_size: t.CSizeT
block_count: t.CSizeT
used_count: t.CSizeT
free_list: t.CVoid | t.CPtr
alloc_map: t.CUInt8T | t.CPtr
alloc_map_size: t.CSizeT
usable: t.CVoid | t.CPtr
usable_size: t.CSizeT
def __init__(self: MemSlab, base: t.CVoid | t.CPtr, size: t.CSizeT, block_size: t.CSizeT) -> t.CInt: pass
def alloc(self: MemSlab, size: t.CSizeT) -> t.CVoid | t.CPtr: pass
def free(self: MemSlab, ptr: t.CVoid | t.CPtr) -> t.CInt: pass
def reset(self: MemSlab) -> t.CInt: pass
class MemBuddy(MemManager):
max_order: t.CInt
free_lists: t.CUInt64T | t.CPtr
lock_val: t.CVolatile | t.CInt
usable: t.CVoid | t.CPtr
usable_size: t.CSizeT
def __init__(self: MemBuddy, base: t.CVoid | t.CPtr, size: t.CSizeT) -> t.CInt: pass
def _fl_push(self: MemBuddy, order: t.CInt, block: t.CVoid | t.CPtr) -> t.CInt: pass
def _fl_pop(self: MemBuddy, order: t.CInt) -> t.CVoid | t.CPtr: pass
def _fl_find_and_remove(self: MemBuddy, order: t.CInt, target: t.CVoid | t.CPtr) -> t.CInt: pass
def _buddy_of(self: MemBuddy, block: t.CVoid | t.CPtr, order: t.CInt) -> t.CVoid | t.CPtr: pass
def _order_for_size(self: MemBuddy, size: t.CSizeT) -> t.CInt: pass
def _split_to_order(self: MemBuddy, to_order: t.CInt) -> t.CVoid | t.CPtr: pass
def _coalesce(self: MemBuddy, block: t.CVoid | t.CPtr, order: t.CInt) -> t.CInt: pass
def _is_valid_ptr(self: MemBuddy, ptr: t.CVoid | t.CPtr) -> t.CInt: pass
def _lock(self: MemBuddy) -> t.CInt: pass
def _unlock(self: MemBuddy) -> t.CInt: pass
def alloc(self: MemBuddy, size: t.CSizeT) -> t.CVoid | t.CPtr: pass
def free(self: MemBuddy, ptr: t.CVoid | t.CPtr) -> t.CInt: pass
def reset(self: MemBuddy) -> t.CInt: pass
def realloc(self: MemBuddy, ptr: t.CVoid | t.CPtr, old_size: t.CSizeT, new_size: t.CSizeT) -> t.CVoid | t.CPtr: pass

100
Test/SysLibTest/temp/f5522571bcce7bcb.pyi Normal file
View File

@@ -0,0 +1,100 @@
"""
Auto-generated Python stub file from stdint.py
Module: stdint
"""
import c
import t
INT: t.CTypedef = t.CInt
INTPTR: t.CTypedef = t.CInt | t.CPtr
BOOL: t.CTypedef = t.CInt
UINT: t.CTypedef = t.CUnsignedInt
UINTPTR: t.CTypedef = UINT | t.CPtr
BYTE: t.CTypedef = t.CUnsignedChar
BYTEPTR: t.CTypedef = BYTE | t.CPtr
WORD: t.CTypedef = t.CUInt16T
DWORD: t.CTypedef = t.CUInt32T
QWORD: t.CTypedef = t.CUInt64T
TCHAR: t.CTypedef = t.CChar
CHARLIST: t.CTypedef = str | t.CPtr
VOID: t.CTypedef = t.CVoid
SHORT: t.CTypedef = t.CShort
SHORTPTR: t.CTypedef = t.CShort | t.CPtr
USHORT: t.CTypedef = t.CUnsignedShort
USHORTPTR: t.CTypedef = t.CUnsignedShort | t.CPtr
LONGLONG: t.CTypedef = t.CLongLong
ULONGLONG: t.CTypedef = t.CUnsignedLongLong
LONG: t.CTypedef = t.CLong
ULONG: t.CTypedef = t.CUnsignedLong
WCHAR: t.CTypedef = WORD
WCHARPTR: t.CTypedef = WORD | t.CPtr
CHARPTR: t.CTypedef = t.CChar | t.CPtr
FSIZE_t: t.CTypedef = DWORD
LBA_t: t.CTypedef = DWORD
VOIDPTR: t.CTypedef = t.CVoid | t.CPtr
FLOAT: t.CTypedef = t.CFloat
DOUBLE: t.CTypedef = t.CDouble
FLOAT8: t.CTypedef = t.CFloat8T
FLOAT16: t.CTypedef = t.CFloat16T
FLOAT32: t.CTypedef = t.CFloat32T
FLOAT64: t.CTypedef = t.CFloat64T
FLOAT128: t.CTypedef = t.CFloat128T
INT8: t.CTypedef = t.CInt8T
INT16: t.CTypedef = t.CInt16T
INT32: t.CTypedef = t.CInt32T
INT64: t.CTypedef = t.CInt64T
UINT8: t.CTypedef = t.CUInt8T
UINT16: t.CTypedef = t.CUInt16T
UINT32: t.CTypedef = t.CUInt32T
UINT64: t.CTypedef = t.CUInt64T
INT8PTR: t.CTypedef = t.CInt8T | t.CPtr
INT16PTR: t.CTypedef = t.CInt16T | t.CPtr
INT32PTR: t.CTypedef = t.CInt32T | t.CPtr
INT64PTR: t.CTypedef = t.CInt64T | t.CPtr
UINT8PTR: t.CTypedef = t.CUInt8T | t.CPtr
UINT16PTR: t.CTypedef = t.CUInt16T | t.CPtr
UINT32PTR: t.CTypedef = t.CUInt32T | t.CPtr
UINT64PTR: t.CTypedef = t.CUInt64T | t.CPtr
CHAR8: t.CTypedef = t.CChar8T
CHAR16: t.CTypedef = t.CChar16T
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
SIZE_T: t.CTypedef = t.CSizeT
SSIZE_T: t.CTypedef = t.CPtrDiffT
PTRDIFF_T: t.CTypedef = t.CPtrDiffT
int8_t: t.CTypedef = t.CInt8T
int16_t: t.CTypedef = t.CInt16T
int32_t: t.CTypedef = t.CInt32T
int64_t: t.CTypedef = t.CInt64T
uint8_t: t.CTypedef = t.CUInt8T
uint16_t: t.CTypedef = t.CUInt16T
uint32_t: t.CTypedef = t.CUInt32T
uint64_t: t.CTypedef = t.CUInt64T
size_t: t.CTypedef = t.CSizeT
ssize_t: t.CTypedef = t.CPtrDiffT
ptrdiff_t: t.CTypedef = t.CPtrDiffT
intptr_t: t.CTypedef = t.CIntPtrT
uintptr_t: t.CTypedef = t.CUIntPtrT
wchar_t: t.CTypedef = t.CWCharT
char8_t: t.CTypedef = t.CChar8T
char16_t: t.CTypedef = t.CChar16T
char32_t: t.CTypedef = t.CChar32T
float8_t: t.CTypedef = t.CFloat8T
float16_t: t.CTypedef = t.CFloat16T
float32_t: t.CTypedef = t.CFloat32T
float64_t: t.CTypedef = t.CFloat64T
float128_t: t.CTypedef = t.CFloat128T
_Bool: t.CTypedef = t.CBool

192
Test/SysLibTest/temp/f6b51804a0ba8ff0.pyi Normal file
View File

@@ -0,0 +1,192 @@
"""
Auto-generated Python stub file from w32.win32file.py
Module: w32.win32file
"""
import c
import t
from stdint import *
from w32.win32base import *
GENERIC_READ: t.CDefine = 0x80000000
GENERIC_WRITE: t.CDefine = 0x40000000
GENERIC_EXECUTE: t.CDefine = 0x20000000
GENERIC_ALL: t.CDefine = 0x10000000
FILE_SHARE_READ: t.CDefine = 0x00000001
FILE_SHARE_WRITE: t.CDefine = 0x00000002
FILE_SHARE_DELETE: t.CDefine = 0x00000004
CREATE_NEW: t.CDefine = 1
CREATE_ALWAYS: t.CDefine = 2
OPEN_EXISTING: t.CDefine = 3
OPEN_ALWAYS: t.CDefine = 4
TRUNCATE_EXISTING: t.CDefine = 5
FILE_ATTRIBUTE_READONLY: t.CDefine = 0x00000001
FILE_ATTRIBUTE_HIDDEN: t.CDefine = 0x00000002
FILE_ATTRIBUTE_SYSTEM: t.CDefine = 0x00000004
FILE_ATTRIBUTE_DIRECTORY: t.CDefine = 0x00000010
FILE_ATTRIBUTE_ARCHIVE: t.CDefine = 0x00000020
FILE_ATTRIBUTE_NORMAL: t.CDefine = 0x00000080
FILE_ATTRIBUTE_TEMPORARY: t.CDefine = 0x00000100
FILE_ATTRIBUTE_COMPRESSED: t.CDefine = 0x00000800
FILE_ATTRIBUTE_OFFLINE: t.CDefine = 0x00001000
FILE_ATTRIBUTE_ENCRYPTED: t.CDefine = 0x00004000
FILE_FLAG_WRITE_THROUGH: t.CDefine = 0x80000000
FILE_FLAG_OVERLAPPED: t.CDefine = 0x40000000
FILE_FLAG_NO_BUFFERING: t.CDefine = 0x20000000
FILE_FLAG_RANDOM_ACCESS: t.CDefine = 0x10000000
FILE_FLAG_SEQUENTIAL_SCAN: t.CDefine = 0x08000000
FILE_FLAG_DELETE_ON_CLOSE: t.CDefine = 0x04000000
FILE_FLAG_BACKUP_SEMANTICS: t.CDefine = 0x02000000
FILE_FLAG_POSIX_SEMANTICS: t.CDefine = 0x01000000
FILE_BEGIN: t.CDefine = 0
FILE_CURRENT: t.CDefine = 1
FILE_END: t.CDefine = 2
STD_INPUT_HANDLE: t.CDefine = t.CUnsignedLong(-10)
STD_OUTPUT_HANDLE: t.CDefine = t.CUnsignedLong(-11)
STD_ERROR_HANDLE: t.CDefine = t.CUnsignedLong(-12)
MOVEFILE_REPLACE_EXISTING: t.CDefine = 0x00000001
MOVEFILE_COPY_ALLOWED: t.CDefine = 0x00000002
MOVEFILE_WRITE_THROUGH: t.CDefine = 0x00000008
class BY_HANDLE_FILE_INFORMATION:
dwFileAttributes: ULONG
ftCreationTime: FILETIME
ftLastAccessTime: FILETIME
ftLastWriteTime: FILETIME
dwVolumeSerialNumber: ULONG
nFileSizeHigh: ULONG
nFileSizeLow: ULONG
nNumberOfLinks: ULONG
nFileIndexHigh: ULONG
nFileIndexLow: ULONG
class WIN32_FIND_DATAA:
dwFileAttributes: ULONG
ftCreationTime: FILETIME
ftLastAccessTime: FILETIME
ftLastWriteTime: FILETIME
nFileSizeHigh: ULONG
nFileSizeLow: ULONG
dwReserved0: ULONG
dwReserved1: ULONG
cFileName: t.CArray[t.CChar, 260]
cAlternateFileName: t.CArray[t.CChar, 14]
class WIN32_FIND_DATAW:
dwFileAttributes: ULONG
ftCreationTime: FILETIME
ftLastAccessTime: FILETIME
ftLastWriteTime: FILETIME
nFileSizeHigh: ULONG
nFileSizeLow: ULONG
dwReserved0: ULONG
dwReserved1: ULONG
cFileName: t.CArray[t.CUInt16T, 260]
cAlternateFileName: t.CArray[t.CUInt16T, 14]
def CreateFileA(lpFileName: LPCSTR, dwDesiredAccess: ULONG, dwShareMode: ULONG, lpSecurityAttributes: SECURITY_ATTRIBUTES | t.CPtr, dwCreationDisposition: ULONG, dwFlagsAndAttributes: ULONG, hTemplateFile: HANDLE) -> HANDLE | t.State: pass
def CreateFileW(lpFileName: LPCWSTR, dwDesiredAccess: ULONG, dwShareMode: ULONG, lpSecurityAttributes: SECURITY_ATTRIBUTES | t.CPtr, dwCreationDisposition: ULONG, dwFlagsAndAttributes: ULONG, hTemplateFile: HANDLE) -> HANDLE | t.State: pass
def ReadFile(hFile: HANDLE, lpBuffer: VOIDPTR, nNumberOfBytesToRead: ULONG, lpNumberOfBytesRead: ULONG | t.CPtr, lpOverlapped: OVERLAPPED | t.CPtr) -> BOOL | t.State: pass
def WriteFile(hFile: HANDLE, lpBuffer: t.CConst | VOIDPTR, nNumberOfBytesToWrite: ULONG, lpNumberOfBytesWritten: ULONG | t.CPtr, lpOverlapped: OVERLAPPED | t.CPtr) -> BOOL | t.State: pass
def SetFilePointer(hFile: HANDLE, lDistanceToMove: LONG, lpDistanceToMoveHigh: LONG | t.CPtr, dwMoveMethod: ULONG) -> LONG | t.State: pass
def SetFilePointerEx(hFile: HANDLE, liDistanceToMove: LARGE_INTEGER | t.CPtr, lpNewFilePointer: LARGE_INTEGER | t.CPtr, dwMoveMethod: ULONG) -> BOOL | t.State: pass
def GetFileSize(hFile: HANDLE, lpFileSizeHigh: ULONG | t.CPtr) -> ULONG | t.State: pass
def GetFileSizeEx(hFile: HANDLE, lpFileSize: LARGE_INTEGER | t.CPtr) -> BOOL | t.State: pass
def SetEndOfFile(hFile: HANDLE) -> BOOL | t.State: pass
def FlushFileBuffers(hFile: HANDLE) -> BOOL | t.State: pass
def GetFileType(hFile: HANDLE) -> ULONG | t.State: pass
def GetFileAttributesA(lpFileName: LPCSTR) -> ULONG | t.State: pass
def GetFileAttributesW(lpFileName: LPCWSTR) -> ULONG | t.State: pass
def SetFileAttributesA(lpFileName: LPCSTR, dwFileAttributes: ULONG) -> BOOL | t.State: pass
def SetFileAttributesW(lpFileName: LPCWSTR, dwFileAttributes: ULONG) -> BOOL | t.State: pass
def DeleteFileA(lpFileName: LPCSTR) -> BOOL | t.State: pass
def DeleteFileW(lpFileName: LPCWSTR) -> BOOL | t.State: pass
def MoveFileA(lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR) -> BOOL | t.State: pass
def MoveFileW(lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR) -> BOOL | t.State: pass
def MoveFileExA(lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, dwFlags: ULONG) -> BOOL | t.State: pass
def MoveFileExW(lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, dwFlags: ULONG) -> BOOL | t.State: pass
def CopyFileA(lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, bFailIfExists: BOOL) -> BOOL | t.State: pass
def CopyFileW(lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, bFailIfExists: BOOL) -> BOOL | t.State: pass
def CreateDirectoryA(lpPathName: LPCSTR, lpSecurityAttributes: SECURITY_ATTRIBUTES | t.CPtr) -> BOOL | t.State: pass
def CreateDirectoryW(lpPathName: LPCWSTR, lpSecurityAttributes: SECURITY_ATTRIBUTES | t.CPtr) -> BOOL | t.State: pass
def RemoveDirectoryA(lpPathName: LPCSTR) -> BOOL | t.State: pass
def RemoveDirectoryW(lpPathName: LPCWSTR) -> BOOL | t.State: pass
def FindFirstFileA(lpFileName: LPCSTR, lpFindFileData: WIN32_FIND_DATAA | t.CPtr) -> HANDLE | t.State: pass
def FindFirstFileW(lpFileName: LPCWSTR, lpFindFileData: WIN32_FIND_DATAW | t.CPtr) -> HANDLE | t.State: pass
def FindNextFileA(hFindFile: HANDLE, lpFindFileData: WIN32_FIND_DATAA | t.CPtr) -> BOOL | t.State: pass
def FindNextFileW(hFindFile: HANDLE, lpFindFileData: WIN32_FIND_DATAW | t.CPtr) -> BOOL | t.State: pass
def FindClose(hFindFile: HANDLE) -> BOOL | t.State: pass
def GetStdHandle(nStdHandle: ULONG) -> HANDLE | t.State: pass
def SetStdHandle(nStdHandle: ULONG, hHandle: HANDLE) -> BOOL | t.State: pass
def GetFileInformationByHandle(hFile: HANDLE, lpFileInformation: BY_HANDLE_FILE_INFORMATION | t.CPtr) -> BOOL | t.State: pass
def LockFile(hFile: HANDLE, dwFileOffsetLow: ULONG, dwFileOffsetHigh: ULONG, nNumberOfBytesToLockLow: ULONG, nNumberOfBytesToLockHigh: ULONG) -> BOOL | t.State: pass
def UnlockFile(hFile: HANDLE, dwFileOffsetLow: ULONG, dwFileOffsetHigh: ULONG, nNumberOfBytesToUnlockLow: ULONG, nNumberOfBytesToUnlockHigh: ULONG) -> BOOL | t.State: pass
def GetTempPathA(nBufferLength: ULONG, lpBuffer: CHARPTR) -> ULONG | t.State: pass
def GetTempPathW(nBufferLength: ULONG, lpBuffer: WCHARPTR) -> ULONG | t.State: pass
def GetTempFileNameA(lpPathName: LPCSTR, lpPrefixString: LPCSTR, uUnique: UINT, lpTempFileName: CHARPTR) -> UINT | t.State: pass
def GetTempFileNameW(lpPathName: LPCWSTR, lpPrefixString: LPCWSTR, uUnique: UINT, lpTempFileName: WCHARPTR) -> UINT | t.State: pass
def GetCurrentDirectoryA(nBufferLength: ULONG, lpBuffer: CHARPTR) -> ULONG | t.State: pass
def GetCurrentDirectoryW(nBufferLength: ULONG, lpBuffer: WCHARPTR) -> ULONG | t.State: pass
def SetCurrentDirectoryA(lpPathName: LPCSTR) -> BOOL | t.State: pass
def SetCurrentDirectoryW(lpPathName: LPCWSTR) -> BOOL | t.State: pass
def GetModuleFileNameA(hModule: HANDLE, lpFilename: CHARPTR, nSize: ULONG) -> ULONG | t.State: pass
def GetModuleFileNameW(hModule: HANDLE, lpFilename: WCHARPTR, nSize: ULONG) -> ULONG | t.State: pass
HANDLE_FLAG_INHERIT: t.CDefine = 0x00000001
HANDLE_FLAG_PROTECT_FROM_CLOSE: t.CDefine = 0x00000002
def CreatePipe(hReadPipe: HANDLE | t.CPtr, hWritePipe: HANDLE | t.CPtr, lpPipeAttributes: SECURITY_ATTRIBUTES | t.CPtr, nSize: ULONG) -> BOOL | t.State: pass
def SetHandleInformation(hObject: HANDLE, dwMask: ULONG, dwFlags: ULONG) -> BOOL | t.State: pass
def DuplicateHandle(hSourceProcessHandle: HANDLE, hSourceHandle: HANDLE, hTargetProcessHandle: HANDLE, lpTargetHandle: HANDLE | t.CPtr, dwDesiredAccess: ULONG, bInheritHandle: BOOL, dwOptions: ULONG) -> BOOL | t.State: pass
DUPLICATE_SAME_ACCESS: t.CDefine = 0x00000002