From f5da836fbb82546ffe3689503316778a08698a0b Mon Sep 17 00:00:00 2001 From: TermiNexus Date: Mon, 5 Oct 2026 19:59:02 +0800 Subject: [PATCH] =?UTF-8?q?chore(test):=20=E8=BF=81=E7=A7=BB=E6=B5=8B?= =?UTF-8?q?=E8=AF=95=E5=A4=B9=E5=85=B7=E5=88=B0=E6=96=B0=E8=AF=AD=E6=B3=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 机械规则 R2/R3/R4/R6/R7/R8/R13 + R16 保守子集，共 86 文件 2127 行。R1（T | t.CPtr）与 R12（while 下标循环）未做，仍列为待办。全量 77/77 顺序回归通过。 --- ArgparseTest/App/main.vp | 28 +- AstTest/App/main.vp | 30 +- BuddyTest/App/mbuddytest.vp | 16 +- BuiltinDecoratorTest/App/main.vp | 72 +-- CPythonTest/App/cpython.vp | 484 +++++++++---------- CPythonTest/App/main.vp | 18 +- CharTest/App/main.vp | 2 +- ClassArrayTest/App/class_test.vp | 54 +-- ClassArrayTest/App/main.vp | 2 +- ClosureCallTest/App/main.vp | 2 +- ClosureTest/App/main.vp | 40 +- ClosureTest2/App/main.vp | 68 +-- CoroTest/App/main.vp | 8 +- DecoratorTest/App/main.vp | 76 +-- DefaultArgTest/App/main.vp | 20 +- DefaultArgTest/App/remote.vp | 4 +- DefineTest/App/main.vp | 30 +- DictTest/App/main.vp | 46 +- DocTest/App/main.vp | 4 +- DocTest/App/remote.vp | 2 +- EdgeCaseTest/App/main.vp | 52 +- EnumTest/App/enumtest.vp | 2 +- EnumTest/App/main.vp | 2 +- ExpandKeywordsTest/App/main.vp | 18 +- Extern2Test/App/main.vp | 6 +- FakeDuckTest/App/main.vp | 24 +- FileIoTest/App/fileiotest.vp | 16 +- FileIoTest/App/main.vp | 2 +- ForAndLoopTest/App/main.vp | 50 +- FormatStringTest/App/main.vp | 2 +- G3/App/main.vp | 8 +- G4/App/caller1.vp | 4 +- G4/App/caller2.vp | 4 +- G4/App/main.vp | 16 +- G4/includes/g4node.vp | 6 +- G5/App/main.vp | 18 +- G5/includes/g5container.vp | 16 +- G6/App/main.vp | 28 +- G7/App/main.vp | 8 +- G7/includes/conflict_node.vp | 6 +- GenericOopTest/App/main.vp | 6 +- GenericTest/App/main.vp | 34 +- GenericTest2/App/main.vp | 88 ++-- GenericTest3/App/main.vp | 14 +- GenericTest4/App/main.vp | 28 +- HashLibTest/App/main.vp | 28 +- HashTableTest/App/main.vp | 44 +- IterTest/App/main.vp | 20 +- JsonTest/App/main.vp | 22 +- ListTest/App/main.vp | 8 +- LogicFlowTest/App/config.vp | 38 +- LogicFlowTest/App/logic_test.vp | 162 +++---- LogicFlowTest/App/main.vp | 2 +- LoopMathTest/App/config.vp | 38 +- LoopMathTest/App/main.vp | 2 +- LoopMathTest/App/test.vp | 112 ++--- LoopTest/App/main.vp | 20 +- MemhubTest/App/main.vp | 22 +- MpoolOopTest/App/main.vp | 2 +- NewAstTest/App/main.vp | 50 +- NoVTableCrossMixinTest/App/main.vp | 18 +- NoVTableTest/App/main.vp | 32 +- NumpyTest/App/main.vp | 2 +- NumpyTest/App/test_numpy.vp | 706 ++++++++++++++-------------- PointerTest/App/main.vp | 76 +-- ProbeGen/App/main.vp | 12 +- RawArrayTest/App/main.vp | 4 +- SimdTest/App/main.vp | 404 ++++++++-------- SprintfTest/App/main.vp | 42 +- StringIterTest/App/inline_test.vp | 14 +- StringIterTest/App/main.vp | 108 ++--- StringTest/App/main.vp | 46 +- StructTest/App/main.vp | 20 +- SysLibTest/App/main.vp | 2 +- SysLibTest/App/os_backend.vp | 2 +- SysLibTest/App/syslibtest_impl.vp | 16 +- TestFBProject/App/main.vp | 18 +- ThreadingTest/App/main.vp | 74 +-- TypeCastTest/App/main.vp | 106 ++--- VRandomTest/App/main.vp | 12 +- VariadicTest/App/main.vp | 144 +++--- VectorGenericTest/App/main.vp | 2 +- VectorGenericTest/App/vectortest.vp | 2 +- ZlibDbg/App/main.vp | 74 +-- ZlibTest/App/main.vp | 2 +- ZlibTest/App/test_pyzlib.vp | 270 +++++------ 86 files changed, 2121 insertions(+), 2121 deletions(-) diff --git a/ArgparseTest/App/main.vp b/ArgparseTest/App/main.vp index c3d17a1..e9596d0 100644 --- a/ArgparseTest/App/main.vp +++ b/ArgparseTest/App/main.vp @@ -33,43 +33,43 @@ def main() -> int: # argv[0] = "myprog" s0: bytes = _mbuddy.alloc(16) string.strcpy(s0, "myprog") - argv0: str | t.CPtr = (str | t.CPtr)(t.CUInt64T(argv)) + argv0: str | t.CPtr = (str | t.CPtr)(uint64(argv)) argv0[0] = s0 # argv[1] = "--input" s1: bytes = _mbuddy.alloc(16) string.strcpy(s1, "--input") - argv1: str | t.CPtr = (str | t.CPtr)(t.CUInt64T(argv) + 8) + argv1: str | t.CPtr = (str | t.CPtr)(uint64(argv) + 8) argv1[0] = s1 # argv[2] = "test.txt" s2: bytes = _mbuddy.alloc(16) string.strcpy(s2, "test.txt") - argv2: str | t.CPtr = (str | t.CPtr)(t.CUInt64T(argv) + 16) + argv2: str | t.CPtr = (str | t.CPtr)(uint64(argv) + 16) argv2[0] = s2 # argv[3] = "-c" s3: bytes = _mbuddy.alloc(8) string.strcpy(s3, "-c") - argv3: str | t.CPtr = (str | t.CPtr)(t.CUInt64T(argv) + 24) + argv3: str | t.CPtr = (str | t.CPtr)(uint64(argv) + 24) argv3[0] = s3 # argv[4] = "42" s4: bytes = _mbuddy.alloc(8) string.strcpy(s4, "42") - argv4: str | t.CPtr = (str | t.CPtr)(t.CUInt64T(argv) + 32) + argv4: str | t.CPtr = (str | t.CPtr)(uint64(argv) + 32) argv4[0] = s4 # argv[5] = "--verbose" s5: bytes = _mbuddy.alloc(16) string.strcpy(s5, "--verbose") - argv5: str | t.CPtr = (str | t.CPtr)(t.CUInt64T(argv) + 40) + argv5: str | t.CPtr = (str | t.CPtr)(uint64(argv) + 40) argv5[0] = s5 # argv[6] = "output.dat" s6: bytes = _mbuddy.alloc(16) string.strcpy(s6, "output.dat") - argv6: str | t.CPtr = (str | t.CPtr)(t.CUInt64T(argv) + 48) + argv6: str | t.CPtr = (str | t.CPtr)(uint64(argv) + 48) argv6[0] = s6 argc: INT = 7 @@ -109,17 +109,17 @@ def main() -> int: a0: bytes = _mbuddy.alloc(16) string.strcpy(a0, "myprog") - a0_ptr: str | t.CPtr = (str | t.CPtr)(t.CUInt64T(argv2)) + a0_ptr: str | t.CPtr = (str | t.CPtr)(uint64(argv2)) a0_ptr[0] = a0 a1: bytes = _mbuddy.alloc(32) string.strcpy(a1, "--input=hello.txt") - a1_ptr: str | t.CPtr = (str | t.CPtr)(t.CUInt64T(argv2) + 8) + a1_ptr: str | t.CPtr = (str | t.CPtr)(uint64(argv2) + 8) a1_ptr[0] = a1 a2: bytes = _mbuddy.alloc(16) string.strcpy(a2, "output2.dat") - a2_ptr: str | t.CPtr = (str | t.CPtr)(t.CUInt64T(argv2) + 16) + a2_ptr: str | t.CPtr = (str | t.CPtr)(uint64(argv2) + 16) a2_ptr[0] = a2 args2 = parser.parse_args(3, argv2) if args2 is not None: @@ -144,22 +144,22 @@ def main() -> int: b0: bytes = _mbuddy.alloc(8) string.strcpy(b0, "myprog") - b0_ptr: str | t.CPtr = (str | t.CPtr)(t.CUInt64T(argv3_arr)) + b0_ptr: str | t.CPtr = (str | t.CPtr)(uint64(argv3_arr)) b0_ptr[0] = b0 b1: bytes = _mbuddy.alloc(8) string.strcpy(b1, "-v") - b1_ptr: str | t.CPtr = (str | t.CPtr)(t.CUInt64T(argv3_arr) + 8) + b1_ptr: str | t.CPtr = (str | t.CPtr)(uint64(argv3_arr) + 8) b1_ptr[0] = b1 b2: bytes = _mbuddy.alloc(8) string.strcpy(b2, "-v") - b2_ptr: str | t.CPtr = (str | t.CPtr)(t.CUInt64T(argv3_arr) + 16) + b2_ptr: str | t.CPtr = (str | t.CPtr)(uint64(argv3_arr) + 16) b2_ptr[0] = b2 b3: bytes = _mbuddy.alloc(16) string.strcpy(b3, "output3.dat") - b3_ptr: str | t.CPtr = (str | t.CPtr)(t.CUInt64T(argv3_arr) + 24) + b3_ptr: str | t.CPtr = (str | t.CPtr)(uint64(argv3_arr) + 24) b3_ptr[0] = b3 parser2 = argparse.ArgumentParser("myprog", "Count test", pool=_mbuddy) diff --git a/AstTest/App/main.vp b/AstTest/App/main.vp index 8fd4d29..47df708 100644 --- a/AstTest/App/main.vp +++ b/AstTest/App/main.vp @@ -11,25 +11,25 @@ import w32.win32console # MBuddy arena 大小：1MB -ARENA_SIZE: t.CDefine = 1048576 +define ARENA_SIZE = 1048576 # mpool 内存大小：512KB -POOL_SIZE: t.CDefine = 524288 +define POOL_SIZE = 524288 # dump 缓冲区大小：256KB -DUMP_SIZE: t.CDefine = 262144 +define DUMP_SIZE = 262144 -def classify_list(lst: list[ast.AST | t.CPtr] | t.CPtr, depth: t.CInt): +def classify_list(lst: list[ast.AST | t.CPtr] | t.CPtr, depth: int): """递归遍历 list[AST | t.CPtr] 容器，逐元素分类（orelse/args/comparators 等）""" if lst is None: return - n: t.CSizeT = lst.__len__() - i: t.CSizeT = 0 + n: sizet = lst.__len__() + i: sizet = 0 while i < n: classify_print(lst.get(i), depth + 1) i += 1 -def classify_print(node: ast.AST | t.CPtr, depth: t.CInt): +def classify_print(node: ast.AST | t.CPtr, depth: int): """递归遍历 parse 树，用 isinstance 运行时判定每个节点的类别并打印。 依赖 TPV isinstance 的 vtable 子类集合比较： @@ -40,7 +40,7 @@ def classify_print(node: ast.AST | t.CPtr, depth: t.CInt): """ if node is None: return - sp: t.CInt = 0 + sp: int = 0 while sp < depth: printf(" ") sp += 1 @@ -53,7 +53,7 @@ def classify_print(node: ast.AST | t.CPtr, depth: t.CInt): # 按 kind 遍历语句持有的表达式字段（语句 body 块均在 children）。 # 属性访问前先 cast 成具体节点类：node 静态类型是 ast.AST， # 直接访问 node.value 会在 AST 基类字段表 fast-fail（按需过滤原则）。 - k: t.CInt = node.kind() + k: int = node.kind() if k == ast.ASTKind.Assign: asg: ast.Assign | t.CPtr = (ast.Assign | t.CPtr)(node) classify_print(asg.value, depth + 1) @@ -98,8 +98,8 @@ def classify_print(node: ast.AST | t.CPtr, depth: t.CInt): pass # children（语句 body 块） if node.children is not None: - n: t.CSizeT = node.children.__len__() - i: t.CSizeT = 0 + n: sizet = node.children.__len__() + i: sizet = 0 while i < n: classify_print(node.children.get(i), depth + 1) i += 1 @@ -139,7 +139,7 @@ def main() -> CInt | CExport: if dump_mem == None: printf("FAIL: malloc for dump failed\n") return 1 - dump_buf: t.CChar | t.CPtr = t.CChar(dump_mem, t.CPtr) + dump_buf: char | t.CPtr = char(dump_mem, t.CPtr) # 综合测试源码：覆盖 CPython 主要语法 src: str = """x = 1 @@ -214,9 +214,9 @@ class Point: printf("PASS: Module is neither Stmt nor ExprNode\n") # 断言 2: 顶层 body 每条语句均为 Stmt - top_ok: t.CInt = 1 - top_n: t.CSizeT = tree.children.__len__() - i2: t.CSizeT = 0 + top_ok: int = 1 + top_n: sizet = tree.children.__len__() + i2: sizet = 0 while i2 < top_n: top_node: ast.AST | t.CPtr = tree.children.get(i2) if isinstance(top_node, ast.Stmt) == 0: diff --git a/BuddyTest/App/mbuddytest.vp b/BuddyTest/App/mbuddytest.vp index b27ad5a..64fc24c 100644 --- a/BuddyTest/App/mbuddytest.vp +++ b/BuddyTest/App/mbuddytest.vp @@ -12,7 +12,7 @@ import w32.win32base # 线程函数: 在共享 MBuddy 上执行 alloc/free (测试 spinlock 线程安全) -def _thread_alloc_free(param: t.CPtr) -> t.CUInt32T: +def _thread_alloc_free(param: t.CPtr) -> uint32: bd: memhub.MemBuddy | t.CPtr = (memhub.MemBuddy | t.CPtr)(param) i: CInt for i in range(100): @@ -191,7 +191,7 @@ def mbuddy_main() -> CInt: testcheck.check(valid != None, "alloc for illegal test OK", "alloc FAILED") # 1. free 随机地址 (地址 1) - bd5.free(t.CPtr(t.CUInt64T(1))) + bd5.free(t.CPtr(uint64(1))) testcheck.ok("free(addr=1) ignored") # 2. free NULL @@ -199,15 +199,15 @@ def mbuddy_main() -> CInt: testcheck.ok("free(NULL) ignored") # 3. free 越界指针 (arena 之前) - bd5.free(t.CPtr(t.CUInt64T(arena5))) + bd5.free(t.CPtr(uint64(arena5))) testcheck.ok("free(before arena) ignored") # 4. free 越界指针 (arena 之后) - bd5.free(t.CPtr(t.CUInt64T(arena5) + 99999)) + bd5.free(t.CPtr(uint64(arena5) + 99999)) testcheck.ok("free(after arena) ignored") # 5. free 未对齐指针 (arena + 1, 在 mem 区域内但不对齐) - bd5.free(t.CPtr(t.CUInt64T(bd5.base) + 1)) + bd5.free(t.CPtr(uint64(bd5.base) + 1)) testcheck.ok("free(misaligned) ignored") # 6. 验证合法 free 仍正常工作 (释放后应能再次分配) @@ -237,7 +237,7 @@ def mbuddy_main() -> CInt: p: bytes = bd6.alloc(32) if p == None: break - ptrs[alloc_count] = t.CUInt64T(p) + ptrs[alloc_count] = uint64(p) alloc_count += 1 viperlib.snprintf(buf, 256, "allocated %d blocks before OOM", alloc_count) @@ -388,7 +388,7 @@ def mbuddy_main() -> CInt: # 创建 4 个线程并发 alloc/free t_idx: CInt for t_idx in range(NUM_THREADS): - h: bytes = w32.win32process.CreateThread(None, 0, _thread_alloc_free, t.CPtr(bd_mt), 0, c.Addr(tid)) + h: bytes = w32.win32process.CreateThread(None, 0, _thread_alloc_free, t.CPtr(bd_mt), 0, &tid) handles[t_idx] = CUInt64T(h) # 等待所有线程完成 @@ -521,7 +521,7 @@ def mbuddy_main() -> CInt: fp: bytes = bd_fill.alloc(24) if fp == None: break - fill_ptrs[fill_count] = t.CUInt64T(fp) + fill_ptrs[fill_count] = uint64(fp) fill_count += 1 viperlib.snprintf(buf, 256, "fill: %d min blocks allocated", fill_count) diff --git a/BuiltinDecoratorTest/App/main.vp b/BuiltinDecoratorTest/App/main.vp index 56566d9..5b8f1f1 100644 --- a/BuiltinDecoratorTest/App/main.vp +++ b/BuiltinDecoratorTest/App/main.vp @@ -9,18 +9,18 @@ import testcheck # 测试 1：@property getter # ============================================================ class Rect: - width: t.CInt - height: t.CInt + width: int + height: int - def __new__(self, w: t.CInt, h: t.CInt) -> 'Rect' | t.CPtr: + def __new__(self, w: int, h: int) -> 'Rect' | t.CPtr: return t.CPtr(malloc(Rect.__sizeof__())) - def __init__(self, w: t.CInt, h: t.CInt): + def __init__(self, w: int, h: int): self.width = w self.height = h @property - def area(self) -> t.CInt: + def area(self) -> int: return self.width * self.height @property @@ -42,24 +42,24 @@ def test_property_getter(): # 测试 2：@property.setter # ============================================================ class Temperature: - _celsius: t.CDouble + _celsius: double - def __new__(self, celsius_val: t.CDouble) -> 'Temperature' | t.CPtr: + def __new__(self, celsius_val: double) -> 'Temperature' | t.CPtr: return t.CPtr(malloc(Temperature.__sizeof__())) - def __init__(self, celsius_val: t.CDouble): + def __init__(self, celsius_val: double): self._celsius = celsius_val @property - def celsius(self) -> t.CDouble: + def celsius(self) -> double: return self._celsius @celsius.setter - def celsius(self, val: t.CDouble): + def celsius(self, val: double): self._celsius = val @property - def fahrenheit(self) -> t.CDouble: + def fahrenheit(self) -> double: return self._celsius * 1.8 + 32.0 @@ -76,7 +76,7 @@ def test_property_setter(): # 测试 3：@property.getter（重新定义 getter） # ============================================================ class Counter: - _count: t.CInt + _count: int def __new__(self) -> 'Counter' | t.CPtr: return t.CPtr(malloc(Counter.__sizeof__())) @@ -85,11 +85,11 @@ class Counter: self._count = 0 @property - def value(self) -> t.CInt: + def value(self) -> int: return self._count @value.setter - def value(self, v: t.CInt): + def value(self, v: int): self._count = v @@ -105,22 +105,22 @@ def test_property_getter_redef(): # 测试 4：@property.deleter # ============================================================ class Config: - _value: t.CInt - _deleted: t.CInt + _value: int + _deleted: int - def __new__(self, v: t.CInt) -> 'Config' | t.CPtr: + def __new__(self, v: int) -> 'Config' | t.CPtr: return t.CPtr(malloc(Config.__sizeof__())) - def __init__(self, v: t.CInt): + def __init__(self, v: int): self._value = v self._deleted = 0 @property - def value(self) -> t.CInt: + def value(self) -> int: return self._value @value.setter - def value(self, v: t.CInt): + def value(self, v: int): self._value = v @value.deleter @@ -147,11 +147,11 @@ def test_property_deleter(): # ============================================================ class MathUtils: @staticmethod - def add(a: t.CInt, b: t.CInt) -> t.CInt: + def add(a: int, b: int) -> int: return a + b @staticmethod - def max_val(a: t.CInt, b: t.CInt) -> t.CInt: + def max_val(a: int, b: int) -> int: return a if a > b else b @@ -166,13 +166,13 @@ def test_staticmethod(): # 测试 6：@classmethod # ============================================================ class Point: - x: t.CDouble - y: t.CDouble + x: double + y: double - def __new__(self, x: t.CDouble, y: t.CDouble) -> 'Point' | t.CPtr: + def __new__(self, x: double, y: double) -> 'Point' | t.CPtr: return t.CPtr(malloc(Point.__sizeof__())) - def __init__(self, x: t.CDouble, y: t.CDouble): + def __init__(self, x: double, y: double): self.x = x self.y = y @@ -181,10 +181,10 @@ class Point: return Point(0.0, 0.0) @classmethod - def from_int(cls: Point, x: t.CInt, y: t.CInt) -> Point: + def from_int(cls: Point, x: int, y: int) -> Point: return Point(x * 1.0, y * 1.0) - def dist_sq(self) -> t.CDouble: + def dist_sq(self) -> double: return self.x * self.x + self.y * self.y @@ -206,28 +206,28 @@ def test_classmethod(): # 测试 7：综合测试 — @property + @staticmethod + @classmethod # ============================================================ class Circle: - _radius: t.CDouble + _radius: double - def __new__(self, r: t.CDouble) -> 'Circle' | t.CPtr: + def __new__(self, r: double) -> 'Circle' | t.CPtr: return t.CPtr(malloc(Circle.__sizeof__())) - def __init__(self, r: t.CDouble): + def __init__(self, r: double): self._radius = r @property - def radius(self) -> t.CDouble: + def radius(self) -> double: return self._radius @radius.setter - def radius(self, val: t.CDouble): + def radius(self, val: double): self._radius = val @property - def area(self) -> t.CDouble: + def area(self) -> double: return 3.14159265 * self._radius * self._radius @staticmethod - def is_unit(r: t.CDouble) -> bool: + def is_unit(r: double) -> bool: return r > 0.99 and r < 1.01 @classmethod @@ -254,7 +254,7 @@ def test_combined(): # ============================================================ # 主函数 # ============================================================ -def main() -> t.CInt | t.CExport: +def main() -> int | t.CExport: testcheck.begin("Builtin Decorator Test") test_property_getter() diff --git a/CPythonTest/App/cpython.vp b/CPythonTest/App/cpython.vp index 40e3aae..4ef5919 100644 --- a/CPythonTest/App/cpython.vp +++ b/CPythonTest/App/cpython.vp @@ -24,141 +24,141 @@ extern def Py_DecRef(op: PyObject | t.CPtr) # ============================================================ extern def Py_Initialize() extern def Py_Finalize() -extern def Py_InitializeEx(initsigs: t.CInt) -extern def Py_FinalizeEx() -> t.CInt -extern def Py_IsInitialized() -> t.CInt +extern def Py_InitializeEx(initsigs: int) +extern def Py_FinalizeEx() -> int +extern def Py_IsInitialized() -> int # ============================================================ # PyConfig # ============================================================ class PySTATUS: - func: t.CConst | str - err_msg: t.CConst | str - exitcode: t.CInt + func: const str + err_msg: const str + exitcode: int class PyPreConfig: - _config_version: t.CInt - _config_init: t.CInt - parse_argv: t.CInt - isolated: t.CInt - use_environment: t.CInt - utf8_mode: t.CInt - coerce_c_locale: t.CInt - C_locale_warnings: t.CInt - allocator: t.CInt - dev_mode: t.CInt + _config_version: int + _config_init: int + parse_argv: int + isolated: int + use_environment: int + utf8_mode: int + coerce_c_locale: int + C_locale_warnings: int + allocator: int + dev_mode: int class PyWideStringList: - length: t.CSizeT + length: sizet items: t.CPtr class PyConfig: - _config_version: t.CInt - _config_init: t.CInt - isolated: t.CInt - use_environment: t.CInt - dev_mode: t.CInt - install_signal_handlers: t.CInt - use_hash_seed: t.CInt + _config_version: int + _config_init: int + isolated: int + use_environment: int + dev_mode: int + install_signal_handlers: int + use_hash_seed: int hash_seed: t.CUnsignedLong - faulthandler: t.CInt - tracemalloc: t.CInt - import_time: t.CInt - show_ref_count: t.CInt - dump_refs: t.CInt - dump_refs_file: t.CConst | str - malloc_stats: t.CInt - filesystem_errors: t.CInt - pycache_prefix: t.CConst | str - parse_argv: t.CInt + faulthandler: int + tracemalloc: int + import_time: int + show_ref_count: int + dump_refs: int + dump_refs_file: const str + malloc_stats: int + filesystem_errors: int + pycache_prefix: const str + parse_argv: int argv: PyWideStringList - program_name: t.CConst | str + program_name: const str xoptions: PyWideStringList warnoptions: PyWideStringList - site_import: t.CInt - bytes_warning: t.CInt - warn_default_encoding: t.CInt - inspect: t.CInt - interactive: t.CInt - optimization_level: t.CInt - parser_debug: t.CInt - verbose: t.CInt - quiet: t.CInt - home: t.CConst | str - pythonpath_env: t.CConst | str + site_import: int + bytes_warning: int + warn_default_encoding: int + inspect: int + interactive: int + optimization_level: int + parser_debug: int + verbose: int + quiet: int + home: const str + pythonpath_env: const str module_search_paths: PyWideStringList - module_search_paths_set: t.CInt - executable: t.CConst | str - base_executable: t.CConst | str - prefix: t.CConst | str - base_prefix: t.CConst | str - exec_prefix: t.CConst | str - base_exec_prefix: t.CConst | str - platlibdir: t.CConst | str - stdio_filename: t.CConst | str + module_search_paths_set: int + executable: const str + base_executable: const str + prefix: const str + base_prefix: const str + exec_prefix: const str + base_exec_prefix: const str + platlibdir: const str + stdio_filename: const str extern def PyConfig_InitPythonConfig(config: PyConfig | t.CPtr) extern def PyConfig_InitIsolatedConfig(config: PyConfig | t.CPtr) extern def PyConfig_Clear(config: PyConfig | t.CPtr) extern def PyConfig_Read(config: PyConfig | t.CPtr) -> PySTATUS extern def Py_InitializeFromConfig(config: PyConfig | t.CPtr) -> PySTATUS -extern def Py_DecodeLocale(s: t.CConst | str) -> str -extern def PyStatus_Exception(status: PySTATUS) -> t.CInt +extern def Py_DecodeLocale(s: const str) -> str +extern def PyStatus_Exception(status: PySTATUS) -> int # ============================================================ # 整数操作 (PyLong) # ============================================================ -extern def PyLong_FromLong(v: t.CInt) -> PyObject | t.CPtr +extern def PyLong_FromLong(v: int) -> PyObject | t.CPtr extern def PyLong_FromUnsignedLong(v: t.CUnsignedLong) -> PyObject | t.CPtr extern def PyLong_FromLongLong(v: t.CLong) -> PyObject | t.CPtr extern def PyLong_FromUnsignedLongLong(v: t.CUnsignedLong) -> PyObject | t.CPtr extern def PyLong_FromSsize_t(v: t.CPtrDiffT) -> PyObject | t.CPtr -extern def PyLong_FromSize_t(v: t.CSizeT) -> PyObject | t.CPtr -extern def PyLong_FromDouble(v: t.CDouble) -> PyObject | t.CPtr -extern def PyLong_AsLong(obj: PyObject | t.CPtr) -> t.CInt +extern def PyLong_FromSize_t(v: sizet) -> PyObject | t.CPtr +extern def PyLong_FromDouble(v: double) -> PyObject | t.CPtr +extern def PyLong_AsLong(obj: PyObject | t.CPtr) -> int extern def PyLong_AsUnsignedLong(obj: PyObject | t.CPtr) -> t.CUnsignedLong extern def PyLong_AsLongLong(obj: PyObject | t.CPtr) -> t.CLong extern def PyLong_AsUnsignedLongLong(obj: PyObject | t.CPtr) -> t.CUnsignedLong -extern def PyLong_AsDouble(obj: PyObject | t.CPtr) -> t.CDouble +extern def PyLong_AsDouble(obj: PyObject | t.CPtr) -> double extern def PyLong_AsSsize_t(obj: PyObject | t.CPtr) -> t.CPtrDiffT -extern def PyLong_AsSize_t(obj: PyObject | t.CPtr) -> t.CSizeT +extern def PyLong_AsSize_t(obj: PyObject | t.CPtr) -> sizet # ============================================================ # 浮点数操作 (PyFloat) # ============================================================ -extern def PyFloat_FromDouble(v: t.CDouble) -> PyObject | t.CPtr -extern def PyFloat_AsDouble(obj: PyObject | t.CPtr) -> t.CDouble +extern def PyFloat_FromDouble(v: double) -> PyObject | t.CPtr +extern def PyFloat_AsDouble(obj: PyObject | t.CPtr) -> double extern def PyFloat_FromString(s: PyObject | t.CPtr) -> PyObject | t.CPtr # ============================================================ # 字符串操作 (PyUnicode / PyBytes) # ============================================================ -extern def PyUnicode_FromString(u: t.CConst | str) -> PyObject | t.CPtr -extern def PyUnicode_FromStringAndSize(u: t.CConst | str, size: t.CSizeT) -> PyObject | t.CPtr -extern def PyUnicode_FromFormat(fmt: t.CConst | str) -> PyObject | t.CPtr +extern def PyUnicode_FromString(u: const str) -> PyObject | t.CPtr +extern def PyUnicode_FromStringAndSize(u: const str, size: sizet) -> PyObject | t.CPtr +extern def PyUnicode_FromFormat(fmt: const str) -> PyObject | t.CPtr extern def PyUnicode_AsUTF8(obj: PyObject | t.CPtr) -> str extern def PyUnicode_AsUTF8AndSize(obj: PyObject | t.CPtr, size: t.CPtrDiffT | t.CPtr) -> str -extern def PyUnicode_AsWideChar(obj: PyObject | t.CPtr, wbuf: t.CPtr, bufsize: t.CSizeT) -> t.CSizeT +extern def PyUnicode_AsWideChar(obj: PyObject | t.CPtr, wbuf: t.CPtr, bufsize: sizet) -> sizet extern def PyUnicode_GetLength(obj: PyObject | t.CPtr) -> t.CPtrDiffT -extern def PyUnicode_ReadChar(obj: PyObject | t.CPtr, idx: t.CSizeT) -> t.CUInt32T -extern def PyUnicode_WriteChar(obj: PyObject | t.CPtr, idx: t.CSizeT, ch: t.CUInt32T) -> t.CInt -extern def PyUnicode_Compare(l: PyObject | t.CPtr, r: PyObject | t.CPtr) -> t.CInt +extern def PyUnicode_ReadChar(obj: PyObject | t.CPtr, idx: sizet) -> uint32 +extern def PyUnicode_WriteChar(obj: PyObject | t.CPtr, idx: sizet, ch: uint32) -> int +extern def PyUnicode_Compare(l: PyObject | t.CPtr, r: PyObject | t.CPtr) -> int extern def PyUnicode_Concat(l: PyObject | t.CPtr, r: PyObject | t.CPtr) -> PyObject | t.CPtr -extern def PyUnicode_Contains(container: PyObject | t.CPtr, element: PyObject | t.CPtr) -> t.CInt +extern def PyUnicode_Contains(container: PyObject | t.CPtr, element: PyObject | t.CPtr) -> int extern def PyUnicode_Format(fmt: PyObject | t.CPtr, args: PyObject | t.CPtr) -> PyObject | t.CPtr extern def PyUnicode_InternInPlace(s: PyObject | t.CPtr | t.CPtr): pass -extern def PyUnicode_InternFromString(u: t.CConst | str) -> PyObject | t.CPtr +extern def PyUnicode_InternFromString(u: const str) -> PyObject | t.CPtr -extern def PyBytes_FromString(v: t.CConst | str) -> PyObject | t.CPtr -extern def PyBytes_FromStringAndSize(v: t.CConst | str, size: t.CSizeT) -> PyObject | t.CPtr +extern def PyBytes_FromString(v: const str) -> PyObject | t.CPtr +extern def PyBytes_FromStringAndSize(v: const str, size: sizet) -> PyObject | t.CPtr extern def PyBytes_AsString(obj: PyObject | t.CPtr) -> str -extern def PyBytes_Size(obj: PyObject | t.CPtr) -> t.CSizeT +extern def PyBytes_Size(obj: PyObject | t.CPtr) -> sizet extern def PyBytes_FromObject(o: PyObject | t.CPtr) -> PyObject | t.CPtr -extern def PyBytes_FromFormat(fmt: t.CConst | str) -> PyObject | t.CPtr +extern def PyBytes_FromFormat(fmt: const str) -> PyObject | t.CPtr # ============================================================ @@ -174,28 +174,28 @@ Py_None: PyObject | t.CPtr | t.State # ============================================================ # 列表操作 (PyList) # ============================================================ -extern def PyList_New(len: t.CSizeT) -> PyObject | t.CPtr -extern def PyList_Size(lst: PyObject | t.CPtr) -> t.CSizeT -extern def PyList_GetItem(lst: PyObject | t.CPtr, idx: t.CSizeT) -> PyObject | t.CPtr -extern def PyList_SetItem(lst: PyObject | t.CPtr, idx: t.CSizeT, item: PyObject | t.CPtr) -> t.CInt -extern def PyList_Insert(lst: PyObject | t.CPtr, idx: t.CSizeT, item: PyObject | t.CPtr) -> t.CInt -extern def PyList_Append(lst: PyObject | t.CPtr, item: PyObject | t.CPtr) -> t.CInt -extern def PyList_GetSlice(lst: PyObject | t.CPtr, lo: t.CSizeT, hi: t.CSizeT) -> PyObject | t.CPtr -extern def PyList_SetSlice(lst: PyObject | t.CPtr, lo: t.CSizeT, hi: t.CSizeT, items: PyObject | t.CPtr) -> t.CInt -extern def PyList_Sort(lst: PyObject | t.CPtr) -> t.CInt -extern def PyList_Reverse(lst: PyObject | t.CPtr) -> t.CInt +extern def PyList_New(len: sizet) -> PyObject | t.CPtr +extern def PyList_Size(lst: PyObject | t.CPtr) -> sizet +extern def PyList_GetItem(lst: PyObject | t.CPtr, idx: sizet) -> PyObject | t.CPtr +extern def PyList_SetItem(lst: PyObject | t.CPtr, idx: sizet, item: PyObject | t.CPtr) -> int +extern def PyList_Insert(lst: PyObject | t.CPtr, idx: sizet, item: PyObject | t.CPtr) -> int +extern def PyList_Append(lst: PyObject | t.CPtr, item: PyObject | t.CPtr) -> int +extern def PyList_GetSlice(lst: PyObject | t.CPtr, lo: sizet, hi: sizet) -> PyObject | t.CPtr +extern def PyList_SetSlice(lst: PyObject | t.CPtr, lo: sizet, hi: sizet, items: PyObject | t.CPtr) -> int +extern def PyList_Sort(lst: PyObject | t.CPtr) -> int +extern def PyList_Reverse(lst: PyObject | t.CPtr) -> int extern def PyList_AsTuple(lst: PyObject | t.CPtr) -> PyObject | t.CPtr # ============================================================ # 元组操作 (PyTuple) # ============================================================ -extern def PyTuple_New(len: t.CSizeT) -> PyObject | t.CPtr -extern def PyTuple_Size(tup: PyObject | t.CPtr) -> t.CSizeT -extern def PyTuple_GetItem(tup: PyObject | t.CPtr, idx: t.CSizeT) -> PyObject | t.CPtr -extern def PyTuple_SetItem(tup: PyObject | t.CPtr, idx: t.CSizeT, item: PyObject | t.CPtr) -> t.CInt -extern def PyTuple_GetSlice(tup: PyObject | t.CPtr, lo: t.CSizeT, hi: t.CSizeT) -> PyObject | t.CPtr -extern def PyTuple_Pack(n: t.CSizeT) -> PyObject | t.CPtr +extern def PyTuple_New(len: sizet) -> PyObject | t.CPtr +extern def PyTuple_Size(tup: PyObject | t.CPtr) -> sizet +extern def PyTuple_GetItem(tup: PyObject | t.CPtr, idx: sizet) -> PyObject | t.CPtr +extern def PyTuple_SetItem(tup: PyObject | t.CPtr, idx: sizet, item: PyObject | t.CPtr) -> int +extern def PyTuple_GetSlice(tup: PyObject | t.CPtr, lo: sizet, hi: sizet) -> PyObject | t.CPtr +extern def PyTuple_Pack(n: sizet) -> PyObject | t.CPtr # ============================================================ @@ -203,21 +203,21 @@ extern def PyTuple_Pack(n: t.CSizeT) -> PyObject | t.CPtr # ============================================================ extern def PyDict_New() -> PyObject | t.CPtr extern def PyDict_GetItem(d: PyObject | t.CPtr, key: PyObject | t.CPtr) -> PyObject | t.CPtr -extern def PyDict_GetItemString(d: PyObject | t.CPtr, key: t.CConst | str) -> PyObject | t.CPtr -extern def PyDict_SetItem(d: PyObject | t.CPtr, key: PyObject | t.CPtr, val: PyObject | t.CPtr) -> t.CInt -extern def PyDict_SetItemString(d: PyObject | t.CPtr, key: t.CConst | str, val: PyObject | t.CPtr) -> t.CInt -extern def PyDict_DelItem(d: PyObject | t.CPtr, key: PyObject | t.CPtr) -> t.CInt -extern def PyDict_DelItemString(d: PyObject | t.CPtr, key: t.CConst | str) -> t.CInt -extern def PyDict_Size(d: PyObject | t.CPtr) -> t.CSizeT +extern def PyDict_GetItemString(d: PyObject | t.CPtr, key: const str) -> PyObject | t.CPtr +extern def PyDict_SetItem(d: PyObject | t.CPtr, key: PyObject | t.CPtr, val: PyObject | t.CPtr) -> int +extern def PyDict_SetItemString(d: PyObject | t.CPtr, key: const str, val: PyObject | t.CPtr) -> int +extern def PyDict_DelItem(d: PyObject | t.CPtr, key: PyObject | t.CPtr) -> int +extern def PyDict_DelItemString(d: PyObject | t.CPtr, key: const str) -> int +extern def PyDict_Size(d: PyObject | t.CPtr) -> sizet extern def PyDict_Keys(d: PyObject | t.CPtr) -> PyObject | t.CPtr extern def PyDict_Values(d: PyObject | t.CPtr) -> PyObject | t.CPtr extern def PyDict_Items(d: PyObject | t.CPtr) -> PyObject | t.CPtr extern def PyDict_Copy(d: PyObject | t.CPtr) -> PyObject | t.CPtr extern def PyDict_Clear(d: PyObject | t.CPtr): pass -extern def PyDict_Contains(d: PyObject | t.CPtr, key: PyObject | t.CPtr) -> t.CInt -extern def PyDict_Next(d: PyObject | t.CPtr, pos: t.CPtrDiffT | t.CPtr, key: PyObject | t.CPtr | t.CPtr, val: PyObject | t.CPtr | t.CPtr) -> t.CInt -extern def PyDict_Merge(d: PyObject | t.CPtr, other: PyObject | t.CPtr, override: t.CInt) -> t.CInt -extern def PyDict_Update(d: PyObject | t.CPtr, other: PyObject | t.CPtr) -> t.CInt +extern def PyDict_Contains(d: PyObject | t.CPtr, key: PyObject | t.CPtr) -> int +extern def PyDict_Next(d: PyObject | t.CPtr, pos: t.CPtrDiffT | t.CPtr, key: PyObject | t.CPtr | t.CPtr, val: PyObject | t.CPtr | t.CPtr) -> int +extern def PyDict_Merge(d: PyObject | t.CPtr, other: PyObject | t.CPtr, override: int) -> int +extern def PyDict_Update(d: PyObject | t.CPtr, other: PyObject | t.CPtr) -> int # ============================================================ @@ -226,29 +226,29 @@ extern def PyDict_Update(d: PyObject | t.CPtr, other: PyObject | t.CPtr) -> t.CI extern def PyObject_Str(obj: PyObject | t.CPtr) -> PyObject | t.CPtr extern def PyObject_Repr(obj: PyObject | t.CPtr) -> PyObject | t.CPtr extern def PyObject_Type(obj: PyObject | t.CPtr) -> PyObject | t.CPtr -extern def PyObject_IsInstance(obj: PyObject | t.CPtr, cls: PyObject | t.CPtr) -> t.CInt -extern def PyObject_IsSubclass(obj: PyObject | t.CPtr, cls: PyObject | t.CPtr) -> t.CInt -extern def PyObject_HasAttr(obj: PyObject | t.CPtr, name: PyObject | t.CPtr) -> t.CInt -extern def PyObject_HasAttrString(obj: PyObject | t.CPtr, name: t.CConst | str) -> t.CInt +extern def PyObject_IsInstance(obj: PyObject | t.CPtr, cls: PyObject | t.CPtr) -> int +extern def PyObject_IsSubclass(obj: PyObject | t.CPtr, cls: PyObject | t.CPtr) -> int +extern def PyObject_HasAttr(obj: PyObject | t.CPtr, name: PyObject | t.CPtr) -> int +extern def PyObject_HasAttrString(obj: PyObject | t.CPtr, name: const str) -> int extern def PyObject_GetAttr(obj: PyObject | t.CPtr, name: PyObject | t.CPtr) -> PyObject | t.CPtr -extern def PyObject_GetAttrString(obj: PyObject | t.CPtr, name: t.CConst | str) -> PyObject | t.CPtr -extern def PyObject_SetAttr(obj: PyObject | t.CPtr, name: PyObject | t.CPtr, val: PyObject | t.CPtr) -> t.CInt -extern def PyObject_SetAttrString(obj: PyObject | t.CPtr, name: t.CConst | str, val: PyObject | t.CPtr) -> t.CInt -extern def PyObject_DelAttr(obj: PyObject | t.CPtr, name: PyObject | t.CPtr) -> t.CInt -extern def PyObject_DelAttrString(obj: PyObject | t.CPtr, name: t.CConst | str) -> t.CInt +extern def PyObject_GetAttrString(obj: PyObject | t.CPtr, name: const str) -> PyObject | t.CPtr +extern def PyObject_SetAttr(obj: PyObject | t.CPtr, name: PyObject | t.CPtr, val: PyObject | t.CPtr) -> int +extern def PyObject_SetAttrString(obj: PyObject | t.CPtr, name: const str, val: PyObject | t.CPtr) -> int +extern def PyObject_DelAttr(obj: PyObject | t.CPtr, name: PyObject | t.CPtr) -> int +extern def PyObject_DelAttrString(obj: PyObject | t.CPtr, name: const str) -> int extern def PyObject_Call(callable: PyObject | t.CPtr, args: PyObject | t.CPtr, kwargs: PyObject | t.CPtr) -> PyObject | t.CPtr extern def PyObject_CallObject(callable: PyObject | t.CPtr, args: PyObject | t.CPtr) -> PyObject | t.CPtr extern def PyObject_CallNoArgs(callable: PyObject | t.CPtr) -> PyObject | t.CPtr extern def PyObject_CallOneArg(callable: PyObject | t.CPtr, arg: PyObject | t.CPtr) -> PyObject | t.CPtr -extern def PyObject_IsTrue(obj: PyObject | t.CPtr) -> t.CInt -extern def PyObject_Not(obj: PyObject | t.CPtr) -> t.CInt -extern def PyObject_RichCompare(o1: PyObject | t.CPtr, o2: PyObject | t.CPtr, opid: t.CInt) -> PyObject | t.CPtr -extern def PyObject_RichCompareBool(o1: PyObject | t.CPtr, o2: PyObject | t.CPtr, opid: t.CInt) -> t.CInt +extern def PyObject_IsTrue(obj: PyObject | t.CPtr) -> int +extern def PyObject_Not(obj: PyObject | t.CPtr) -> int +extern def PyObject_RichCompare(o1: PyObject | t.CPtr, o2: PyObject | t.CPtr, opid: int) -> PyObject | t.CPtr +extern def PyObject_RichCompareBool(o1: PyObject | t.CPtr, o2: PyObject | t.CPtr, opid: int) -> int extern def PyObject_Hash(obj: PyObject | t.CPtr) -> t.CLong -extern def PyObject_Length(obj: PyObject | t.CPtr) -> t.CSizeT +extern def PyObject_Length(obj: PyObject | t.CPtr) -> sizet extern def PyObject_GetItem(obj: PyObject | t.CPtr, key: PyObject | t.CPtr) -> PyObject | t.CPtr -extern def PyObject_SetItem(obj: PyObject | t.CPtr, key: PyObject | t.CPtr, val: PyObject | t.CPtr) -> t.CInt -extern def PyObject_DelItem(obj: PyObject | t.CPtr, key: PyObject | t.CPtr) -> t.CInt +extern def PyObject_SetItem(obj: PyObject | t.CPtr, key: PyObject | t.CPtr, val: PyObject | t.CPtr) -> int +extern def PyObject_DelItem(obj: PyObject | t.CPtr, key: PyObject | t.CPtr) -> int extern def PyObject_Dir(obj: PyObject | t.CPtr) -> PyObject | t.CPtr extern def PyObject_GetIter(obj: PyObject | t.CPtr) -> PyObject | t.CPtr extern def PyIter_Next(obj: PyObject | t.CPtr) -> PyObject | t.CPtr @@ -257,45 +257,45 @@ extern def PyIter_Next(obj: PyObject | t.CPtr) -> PyObject | t.CPtr # ============================================================ # 比较常量 # ============================================================ -Py_LT: t.CInt | t.State -Py_LE: t.CInt | t.State -Py_EQ: t.CInt | t.State -Py_NE: t.CInt | t.State -Py_GT: t.CInt | t.State -Py_GE: t.CInt | t.State +Py_LT: int | t.State +Py_LE: int | t.State +Py_EQ: int | t.State +Py_NE: int | t.State +Py_GT: int | t.State +Py_GE: int | t.State # ============================================================ # 模块操作 # ============================================================ -extern def PyImport_ImportModule(name: t.CConst | str) -> PyObject | t.CPtr +extern def PyImport_ImportModule(name: const str) -> PyObject | t.CPtr extern def PyImport_Import(name: PyObject | t.CPtr) -> PyObject | t.CPtr -extern def PyImport_ImportModuleLevelObject(name: PyObject | t.CPtr, globs: PyObject | t.CPtr, locs: PyObject | t.CPtr, fromlist: PyObject | t.CPtr, level: t.CInt) -> PyObject | t.CPtr +extern def PyImport_ImportModuleLevelObject(name: PyObject | t.CPtr, globs: PyObject | t.CPtr, locs: PyObject | t.CPtr, fromlist: PyObject | t.CPtr, level: int) -> PyObject | t.CPtr extern def PyImport_ReloadModule(mod: PyObject | t.CPtr) -> PyObject | t.CPtr -extern def PyImport_AddModule(name: t.CConst | str) -> PyObject | t.CPtr +extern def PyImport_AddModule(name: const str) -> PyObject | t.CPtr extern def PyImport_GetModuleDict() -> PyObject | t.CPtr -extern def PyImport_ImportModuleEx(name: t.CConst | str, globs: PyObject | t.CPtr, locs: PyObject | t.CPtr, fromlist: PyObject | t.CPtr) -> PyObject | t.CPtr +extern def PyImport_ImportModuleEx(name: const str, globs: PyObject | t.CPtr, locs: PyObject | t.CPtr, fromlist: PyObject | t.CPtr) -> PyObject | t.CPtr # ============================================================ # 模块创建 # ============================================================ class PyMethodDef: - ml_name: t.CConst | str + ml_name: const str ml_meth: t.CPtr - ml_flags: t.CInt - ml_doc: t.CConst | str + ml_flags: int + ml_doc: const str class PyModuleDef_Base: ob_base: PyObject m_init: t.CPtr - m_index: t.CSizeT + m_index: sizet m_copy: PyObject | t.CPtr class PyModuleDef: m_base: PyModuleDef_Base - m_name: t.CConst | str - m_doc: t.CConst | str + m_name: const str + m_doc: const str m_size: t.CPtrDiffT m_methods: PyMethodDef | t.CPtr m_slots: t.CPtr @@ -304,28 +304,28 @@ class PyModuleDef: m_free: t.CPtr extern def PyModule_Create(mod: PyModuleDef | t.CPtr) -> PyObject | t.CPtr -extern def PyModule_Create2(mod: PyModuleDef | t.CPtr, ver: t.CInt) -> PyObject | t.CPtr +extern def PyModule_Create2(mod: PyModuleDef | t.CPtr, ver: int) -> PyObject | t.CPtr extern def PyModule_GetName(mod: PyObject | t.CPtr) -> str extern def PyModule_GetDict(mod: PyObject | t.CPtr) -> PyObject | t.CPtr extern def PyModule_GetFilenameObject(mod: PyObject | t.CPtr) -> PyObject | t.CPtr -extern def PyModule_AddObject(mod: PyObject | t.CPtr, name: t.CConst | str, val: PyObject | t.CPtr) -> t.CInt -extern def PyModule_AddObjectRef(mod: PyObject | t.CPtr, name: t.CConst | str, val: PyObject | t.CPtr) -> t.CInt -extern def PyModule_AddIntConstant(mod: PyObject | t.CPtr, name: t.CConst | str, val: t.CLong) -> t.CInt -extern def PyModule_AddStringConstant(mod: PyObject | t.CPtr, name: t.CConst | str, val: t.CConst | str) -> t.CInt +extern def PyModule_AddObject(mod: PyObject | t.CPtr, name: const str, val: PyObject | t.CPtr) -> int +extern def PyModule_AddObjectRef(mod: PyObject | t.CPtr, name: const str, val: PyObject | t.CPtr) -> int +extern def PyModule_AddIntConstant(mod: PyObject | t.CPtr, name: const str, val: t.CLong) -> int +extern def PyModule_AddStringConstant(mod: PyObject | t.CPtr, name: const str, val: const str) -> int # ============================================================ # GIL 管理 # ============================================================ -extern def PyGILState_Ensure() -> t.CInt -extern def PyGILState_Release(state: t.CInt): pass +extern def PyGILState_Ensure() -> int +extern def PyGILState_Release(state: int): pass extern def PyEval_SaveThread() -> t.CPtr extern def PyEval_RestoreThread(tstate: t.CPtr): pass extern def PyEval_AcquireThread(tstate: t.CPtr): pass extern def PyEval_ReleaseThread(tstate: t.CPtr): pass extern def PyEval_AcquireLock(): pass extern def PyEval_ReleaseLock(): pass -extern def PyEval_ThreadsInitialized() -> t.CInt +extern def PyEval_ThreadsInitialized() -> int extern def PyEval_InitThreads(): pass @@ -337,13 +337,13 @@ extern def PyErr_Clear(): pass extern def PyErr_Fetch(tp: PyObject | t.CPtr | t.CPtr, val: PyObject | t.CPtr | t.CPtr, tb: PyObject | t.CPtr | t.CPtr): pass extern def PyErr_Restore(tp: PyObject | t.CPtr, val: PyObject | t.CPtr, tb: PyObject | t.CPtr): pass extern def PyErr_NormalizeException(tp: PyObject | t.CPtr | t.CPtr, val: PyObject | t.CPtr | t.CPtr, tb: PyObject | t.CPtr | t.CPtr): pass -extern def PyErr_SetString(tp: PyObject | t.CPtr, msg: t.CConst | str): pass +extern def PyErr_SetString(tp: PyObject | t.CPtr, msg: const str): pass extern def PyErr_SetObject(tp: PyObject | t.CPtr, val: PyObject | t.CPtr): pass extern def PyErr_BadArgument() -> t.CPtr | t.State: pass extern def PyErr_NoMemory() -> t.CPtr | t.State: pass extern def PyErr_Print(): pass -extern def PyErr_ExceptionMatches(exc: PyObject | t.CPtr) -> t.CInt | t.State: pass -extern def PyErr_GivenExceptionMatches(given: PyObject | t.CPtr, exc: PyObject | t.CPtr) -> t.CInt | t.State: pass +extern def PyErr_ExceptionMatches(exc: PyObject | t.CPtr) -> int | t.State: pass +extern def PyErr_GivenExceptionMatches(given: PyObject | t.CPtr, exc: PyObject | t.CPtr) -> int | t.State: pass # ============================================================ @@ -376,103 +376,103 @@ PyExc_NotADirectoryError: PyObject | t.CPtr | t.State # ============================================================ # 内置函数 # ============================================================ -extern def Py_BuildValue(fmt: t.CConst | str) -> PyObject | t.CPtr -extern def Py_VaBuildValue(fmt: t.CConst | str, va: t.CPtr) -> PyObject | t.CPtr +extern def Py_BuildValue(fmt: const str) -> PyObject | t.CPtr +extern def Py_VaBuildValue(fmt: const str, va: t.CPtr) -> PyObject | t.CPtr # ============================================================ # 类型检查 # ============================================================ -extern def PyLong_Check(obj: PyObject | t.CPtr) -> t.CInt -extern def PyFloat_Check(obj: PyObject | t.CPtr) -> t.CInt -extern def PyUnicode_Check(obj: PyObject | t.CPtr) -> t.CInt -extern def PyBytes_Check(obj: PyObject | t.CPtr) -> t.CInt -extern def PyList_Check(obj: PyObject | t.CPtr) -> t.CInt -extern def PyTuple_Check(obj: PyObject | t.CPtr) -> t.CInt -extern def PyDict_Check(obj: PyObject | t.CPtr) -> t.CInt -extern def PyBool_Check(obj: PyObject | t.CPtr) -> t.CInt -extern def PyNone_Check(obj: PyObject | t.CPtr) -> t.CInt +extern def PyLong_Check(obj: PyObject | t.CPtr) -> int +extern def PyFloat_Check(obj: PyObject | t.CPtr) -> int +extern def PyUnicode_Check(obj: PyObject | t.CPtr) -> int +extern def PyBytes_Check(obj: PyObject | t.CPtr) -> int +extern def PyList_Check(obj: PyObject | t.CPtr) -> int +extern def PyTuple_Check(obj: PyObject | t.CPtr) -> int +extern def PyDict_Check(obj: PyObject | t.CPtr) -> int +extern def PyBool_Check(obj: PyObject | t.CPtr) -> int +extern def PyNone_Check(obj: PyObject | t.CPtr) -> int # ============================================================ # 内存管理 # ============================================================ -extern def PyMem_Malloc(size: t.CSizeT) -> t.CPtr -extern def PyMem_Realloc(ptr: t.CPtr, size: t.CSizeT) -> t.CPtr +extern def PyMem_Malloc(size: sizet) -> t.CPtr +extern def PyMem_Realloc(ptr: t.CPtr, size: sizet) -> t.CPtr extern def PyMem_Free(ptr: t.CPtr) -extern def PyMem_Calloc(nelem: t.CSizeT, elsize: t.CSizeT) -> t.CPtr -extern def PyObject_Malloc(size: t.CSizeT) -> t.CPtr -extern def PyObject_Realloc(ptr: t.CPtr, size: t.CSizeT) -> t.CPtr +extern def PyMem_Calloc(nelem: sizet, elsize: sizet) -> t.CPtr +extern def PyObject_Malloc(size: sizet) -> t.CPtr +extern def PyObject_Realloc(ptr: t.CPtr, size: sizet) -> t.CPtr extern def PyObject_Free(ptr: t.CPtr) -extern def PyObject_Calloc(nelem: t.CSizeT, elsize: t.CSizeT) -> t.CPtr +extern def PyObject_Calloc(nelem: sizet, elsize: sizet) -> t.CPtr extern def PyObject_Init(obj: PyObject | t.CPtr, tp: t.CPtr) -> PyObject | t.CPtr -extern def PyObject_InitVar(obj: PyObject | t.CPtr, tp: t.CPtr, size: t.CSizeT) -> PyObject | t.CPtr +extern def PyObject_InitVar(obj: PyObject | t.CPtr, tp: t.CPtr, size: sizet) -> PyObject | t.CPtr # ============================================================ # 文件操作 # ============================================================ -extern def PyFile_FromString(filename: t.CConst | str, mode: t.CConst | str) -> PyObject | t.CPtr +extern def PyFile_FromString(filename: const str, mode: const str) -> PyObject | t.CPtr extern def PyFile_AsFile(file: PyObject | t.CPtr) -> t.CPtr -extern def PyFile_WriteObject(obj: PyObject | t.CPtr, file: PyObject | t.CPtr, flags: t.CInt) -> t.CInt -extern def PyFile_WriteString(s: t.CConst | str, file: PyObject | t.CPtr) -> t.CInt +extern def PyFile_WriteObject(obj: PyObject | t.CPtr, file: PyObject | t.CPtr, flags: int) -> int +extern def PyFile_WriteString(s: const str, file: PyObject | t.CPtr) -> int # ============================================================ # 编译/执行 # ============================================================ -extern def Py_CompileString(s: t.CConst | str, filename: t.CConst | str, start: t.CInt) -> PyObject | t.CPtr +extern def Py_CompileString(s: const str, filename: const str, start: int) -> PyObject | t.CPtr extern def PyEval_EvalCode(code: PyObject | t.CPtr, globs: PyObject | t.CPtr, locs: PyObject | t.CPtr) -> PyObject | t.CPtr -extern def PyEval_EvalCodeEx(code: PyObject | t.CPtr, globs: PyObject | t.CPtr, locs: PyObject | t.CPtr, args: PyObject | t.CPtr | t.CPtr, argc: t.CInt, kws: PyObject | t.CPtr | t.CPtr, kwc: t.CInt, defs: PyObject | t.CPtr | t.CPtr, defc: t.CInt, kwdefs: PyObject | t.CPtr, closure: PyObject | t.CPtr) -> PyObject | t.CPtr: pass +extern def PyEval_EvalCodeEx(code: PyObject | t.CPtr, globs: PyObject | t.CPtr, locs: PyObject | t.CPtr, args: PyObject | t.CPtr | t.CPtr, argc: int, kws: PyObject | t.CPtr | t.CPtr, kwc: int, defs: PyObject | t.CPtr | t.CPtr, defc: int, kwdefs: PyObject | t.CPtr, closure: PyObject | t.CPtr) -> PyObject | t.CPtr: pass extern def PyEval_EvalFrame(frame: t.CPtr) -> PyObject | t.CPtr: pass extern def PyEval_CallObject(callable: PyObject | t.CPtr, args: PyObject | t.CPtr) -> PyObject | t.CPtr: pass -extern def PyEval_CallFunction(callable: PyObject | t.CPtr, fmt: t.CConst | str) -> PyObject | t.CPtr: pass -extern def PyEval_CallMethod(obj: PyObject | t.CPtr, method: t.CConst | str, fmt: t.CConst | str) -> PyObject | t.CPtr: pass +extern def PyEval_CallFunction(callable: PyObject | t.CPtr, fmt: const str) -> PyObject | t.CPtr: pass +extern def PyEval_CallMethod(obj: PyObject | t.CPtr, method: const str, fmt: const str) -> PyObject | t.CPtr: pass # ============================================================ # PyRun # ============================================================ -extern def PyRun_SimpleString(cmd: t.CConst | str) -> t.CInt -extern def PyRun_SimpleFile(fp: t.CPtr, filename: t.CConst | str) -> t.CInt -extern def PyRun_AnyFile(fp: t.CPtr, filename: t.CConst | str) -> t.CInt -extern def PyRun_String(s: t.CConst | str, start: t.CInt, globs: PyObject | t.CPtr, locs: PyObject | t.CPtr) -> PyObject | t.CPtr -extern def PyRun_File(fp: t.CPtr, filename: t.CConst | str, start: t.CInt, globs: PyObject | t.CPtr, locs: PyObject | t.CPtr) -> PyObject | t.CPtr +extern def PyRun_SimpleString(cmd: const str) -> int +extern def PyRun_SimpleFile(fp: t.CPtr, filename: const str) -> int +extern def PyRun_AnyFile(fp: t.CPtr, filename: const str) -> int +extern def PyRun_String(s: const str, start: int, globs: PyObject | t.CPtr, locs: PyObject | t.CPtr) -> PyObject | t.CPtr +extern def PyRun_File(fp: t.CPtr, filename: const str, start: int, globs: PyObject | t.CPtr, locs: PyObject | t.CPtr) -> PyObject | t.CPtr -Py_single_input: t.CInt | t.State -Py_file_input: t.CInt | t.State -Py_eval_input: t.CInt | t.State +Py_single_input: int | t.State +Py_file_input: int | t.State +Py_eval_input: int | t.State # ============================================================ # Capsule # ============================================================ -extern def PyCapsule_New(ptr: t.CPtr, name: t.CConst | str, dtor: t.CPtr) -> PyObject | t.CPtr -extern def PyCapsule_GetPointer(cap: PyObject | t.CPtr, name: t.CConst | str) -> t.CPtr +extern def PyCapsule_New(ptr: t.CPtr, name: const str, dtor: t.CPtr) -> PyObject | t.CPtr +extern def PyCapsule_GetPointer(cap: PyObject | t.CPtr, name: const str) -> t.CPtr extern def PyCapsule_GetName(cap: PyObject | t.CPtr) -> str -extern def PyCapsule_IsValid(cap: PyObject | t.CPtr, name: t.CConst | str) -> t.CInt -extern def PyCapsule_SetPointer(cap: PyObject | t.CPtr, ptr: t.CPtr) -> t.CInt -extern def PyCapsule_SetName(cap: PyObject | t.CPtr, name: t.CConst | str) -> t.CInt -extern def PyCapsule_SetDestructor(cap: PyObject | t.CPtr, dtor: t.CPtr) -> t.CInt +extern def PyCapsule_IsValid(cap: PyObject | t.CPtr, name: const str) -> int +extern def PyCapsule_SetPointer(cap: PyObject | t.CPtr, ptr: t.CPtr) -> int +extern def PyCapsule_SetName(cap: PyObject | t.CPtr, name: const str) -> int +extern def PyCapsule_SetDestructor(cap: PyObject | t.CPtr, dtor: t.CPtr) -> int # ============================================================ # 序列操作 # ============================================================ -extern def PySequence_Check(obj: PyObject | t.CPtr) -> t.CInt -extern def PySequence_Size(obj: PyObject | t.CPtr) -> t.CSizeT -extern def PySequence_Length(obj: PyObject | t.CPtr) -> t.CSizeT +extern def PySequence_Check(obj: PyObject | t.CPtr) -> int +extern def PySequence_Size(obj: PyObject | t.CPtr) -> sizet +extern def PySequence_Length(obj: PyObject | t.CPtr) -> sizet extern def PySequence_Concat(o1: PyObject | t.CPtr, o2: PyObject | t.CPtr) -> PyObject | t.CPtr -extern def PySequence_Repeat(obj: PyObject | t.CPtr, count: t.CSizeT) -> PyObject | t.CPtr -extern def PySequence_GetItem(obj: PyObject | t.CPtr, idx: t.CSizeT) -> PyObject | t.CPtr -extern def PySequence_SetItem(obj: PyObject | t.CPtr, idx: t.CSizeT, val: PyObject | t.CPtr) -> t.CInt -extern def PySequence_DelItem(obj: PyObject | t.CPtr, idx: t.CSizeT) -> t.CInt -extern def PySequence_GetSlice(obj: PyObject | t.CPtr, start: t.CSizeT, end: t.CSizeT) -> PyObject | t.CPtr -extern def PySequence_SetSlice(obj: PyObject | t.CPtr, start: t.CSizeT, end: t.CSizeT, val: PyObject | t.CPtr) -> t.CInt -extern def PySequence_DelSlice(obj: PyObject | t.CPtr, start: t.CSizeT, end: t.CSizeT) -> t.CInt -extern def PySequence_Contains(obj: PyObject | t.CPtr, val: PyObject | t.CPtr) -> t.CInt -extern def PySequence_Index(obj: PyObject | t.CPtr, val: PyObject | t.CPtr) -> t.CSizeT -extern def PySequence_Count(obj: PyObject | t.CPtr, val: PyObject | t.CPtr) -> t.CSizeT +extern def PySequence_Repeat(obj: PyObject | t.CPtr, count: sizet) -> PyObject | t.CPtr +extern def PySequence_GetItem(obj: PyObject | t.CPtr, idx: sizet) -> PyObject | t.CPtr +extern def PySequence_SetItem(obj: PyObject | t.CPtr, idx: sizet, val: PyObject | t.CPtr) -> int +extern def PySequence_DelItem(obj: PyObject | t.CPtr, idx: sizet) -> int +extern def PySequence_GetSlice(obj: PyObject | t.CPtr, start: sizet, end: sizet) -> PyObject | t.CPtr +extern def PySequence_SetSlice(obj: PyObject | t.CPtr, start: sizet, end: sizet, val: PyObject | t.CPtr) -> int +extern def PySequence_DelSlice(obj: PyObject | t.CPtr, start: sizet, end: sizet) -> int +extern def PySequence_Contains(obj: PyObject | t.CPtr, val: PyObject | t.CPtr) -> int +extern def PySequence_Index(obj: PyObject | t.CPtr, val: PyObject | t.CPtr) -> sizet +extern def PySequence_Count(obj: PyObject | t.CPtr, val: PyObject | t.CPtr) -> sizet extern def PySequence_List(obj: PyObject | t.CPtr) -> PyObject | t.CPtr extern def PySequence_Tuple(obj: PyObject | t.CPtr) -> PyObject | t.CPtr @@ -480,13 +480,13 @@ extern def PySequence_Tuple(obj: PyObject | t.CPtr) -> PyObject | t.CPtr # ============================================================ # 映射操作 # ============================================================ -extern def PyMapping_Check(obj: PyObject | t.CPtr) -> t.CInt -extern def PyMapping_Size(obj: PyObject | t.CPtr) -> t.CSizeT -extern def PyMapping_Length(obj: PyObject | t.CPtr) -> t.CSizeT -extern def PyMapping_HasKey(obj: PyObject | t.CPtr, key: PyObject | t.CPtr) -> t.CInt -extern def PyMapping_HasKeyString(obj: PyObject | t.CPtr, key: t.CConst | str) -> t.CInt -extern def PyMapping_GetItemString(obj: PyObject | t.CPtr, key: t.CConst | str) -> PyObject | t.CPtr -extern def PyMapping_SetItemString(obj: PyObject | t.CPtr, key: t.CConst | str, val: PyObject | t.CPtr) -> t.CInt +extern def PyMapping_Check(obj: PyObject | t.CPtr) -> int +extern def PyMapping_Size(obj: PyObject | t.CPtr) -> sizet +extern def PyMapping_Length(obj: PyObject | t.CPtr) -> sizet +extern def PyMapping_HasKey(obj: PyObject | t.CPtr, key: PyObject | t.CPtr) -> int +extern def PyMapping_HasKeyString(obj: PyObject | t.CPtr, key: const str) -> int +extern def PyMapping_GetItemString(obj: PyObject | t.CPtr, key: const str) -> PyObject | t.CPtr +extern def PyMapping_SetItemString(obj: PyObject | t.CPtr, key: const str, val: PyObject | t.CPtr) -> int extern def PyMapping_Keys(obj: PyObject | t.CPtr) -> PyObject | t.CPtr extern def PyMapping_Values(obj: PyObject | t.CPtr) -> PyObject | t.CPtr extern def PyMapping_Items(obj: PyObject | t.CPtr) -> PyObject | t.CPtr @@ -515,7 +515,7 @@ extern def PyNumber_Or(o1: PyObject | t.CPtr, o2: PyObject | t.CPtr) -> PyObject extern def PyNumber_Index(obj: PyObject | t.CPtr) -> PyObject | t.CPtr extern def PyNumber_Long(obj: PyObject | t.CPtr) -> PyObject | t.CPtr extern def PyNumber_Float(obj: PyObject | t.CPtr) -> PyObject | t.CPtr -extern def PyNumber_Check(obj: PyObject | t.CPtr) -> t.CInt +extern def PyNumber_Check(obj: PyObject | t.CPtr) -> int # ============================================================ @@ -523,71 +523,71 @@ extern def PyNumber_Check(obj: PyObject | t.CPtr) -> t.CInt # ============================================================ extern def PyWeakref_NewRef(obj: PyObject | t.CPtr, cb: PyObject | t.CPtr) -> PyObject | t.CPtr extern def PyWeakref_GetObject(ref: PyObject | t.CPtr) -> PyObject | t.CPtr -extern def PyWeakref_Check(obj: PyObject | t.CPtr) -> t.CInt +extern def PyWeakref_Check(obj: PyObject | t.CPtr) -> int # ============================================================ # 属性描述符 # ============================================================ class PyGetSetDef: - name: t.CConst | str + name: const str get: t.CPtr set: t.CPtr - doc: t.CConst | str + doc: const str closure: t.CPtr class PyMemberDef: - name: t.CConst | str - type: t.CInt + name: const str + type: int offset: t.CPtrDiffT - flags: t.CInt - doc: t.CConst | str + flags: int + doc: const str # ============================================================ # sys 模块 # ============================================================ -extern def PySys_GetObject(name: t.CConst | str) -> PyObject | t.CPtr -extern def PySys_SetObject(name: t.CConst | str, val: PyObject | t.CPtr) -> t.CInt +extern def PySys_GetObject(name: const str) -> PyObject | t.CPtr +extern def PySys_SetObject(name: const str, val: PyObject | t.CPtr) -> int extern def PySys_ResetWarnOptions(): pass extern def PySys_AddWarnOption(s: PyObject | t.CPtr): pass extern def PySYS_AddXOption(s: PyObject | t.CPtr): pass -extern def PySys_WriteStdout(fmt: t.CConst | str): pass -extern def PySys_WriteStderr(fmt: t.CConst | str): pass -extern def PySys_FormatStdout(fmt: t.CConst | str): pass -extern def PySys_FormatStderr(fmt: t.CConst | str): pass +extern def PySys_WriteStdout(fmt: const str): pass +extern def PySys_WriteStderr(fmt: const str): pass +extern def PySys_FormatStdout(fmt: const str): pass +extern def PySys_FormatStderr(fmt: const str): pass # ============================================================ # 内存视图 # ============================================================ extern def PyMemoryView_FromObject(obj: PyObject | t.CPtr) -> PyObject | t.CPtr -extern def PyMemoryView_GetContiguous(obj: PyObject | t.CPtr, btype: t.CInt, order: t.CChar) -> PyObject | t.CPtr -extern def PyMemoryView_Check(obj: PyObject | t.CPtr) -> t.CInt +extern def PyMemoryView_GetContiguous(obj: PyObject | t.CPtr, btype: int, order: char) -> PyObject | t.CPtr +extern def PyMemoryView_Check(obj: PyObject | t.CPtr) -> int # ============================================================ # set / frozenset # ============================================================ extern def PySet_New(iterable: PyObject | t.CPtr) -> PyObject | t.CPtr -extern def PySet_Add(s: PyObject | t.CPtr, key: PyObject | t.CPtr) -> t.CInt -extern def PySet_Discard(s: PyObject | t.CPtr, key: PyObject | t.CPtr) -> t.CInt -extern def PySet_Contains(s: PyObject | t.CPtr, key: PyObject | t.CPtr) -> t.CInt -extern def PySet_Size(s: PyObject | t.CPtr) -> t.CSizeT +extern def PySet_Add(s: PyObject | t.CPtr, key: PyObject | t.CPtr) -> int +extern def PySet_Discard(s: PyObject | t.CPtr, key: PyObject | t.CPtr) -> int +extern def PySet_Contains(s: PyObject | t.CPtr, key: PyObject | t.CPtr) -> int +extern def PySet_Size(s: PyObject | t.CPtr) -> sizet extern def PySet_Clear(s: PyObject | t.CPtr): pass -extern def PySet_Check(obj: PyObject | t.CPtr) -> t.CInt +extern def PySet_Check(obj: PyObject | t.CPtr) -> int extern def PyFrozenSet_New(iterable: PyObject | t.CPtr) -> PyObject | t.CPtr -extern def PyFrozenSet_Check(obj: PyObject | t.CPtr) -> t.CInt +extern def PyFrozenSet_Check(obj: PyObject | t.CPtr) -> int # ============================================================ # slice # ============================================================ extern def PySlice_New(start: PyObject | t.CPtr, stop: PyObject | t.CPtr, step: PyObject | t.CPtr) -> PyObject | t.CPtr -extern def PySlice_GetIndicesEx(sl: PyObject | t.CPtr, length: t.CSizeT, start: t.CSizeT | t.CPtr, stop: t.CSizeT | t.CPtr, step: t.CSizeT | t.CPtr, slicelen: t.CSizeT | t.CPtr) -> t.CInt +extern def PySlice_GetIndicesEx(sl: PyObject | t.CPtr, length: sizet, start: sizet | t.CPtr, stop: sizet | t.CPtr, step: sizet | t.CPtr, slicelen: sizet | t.CPtr) -> int extern def PySlice_Unpack(sl: PyObject | t.CPtr, start: t.CPtrDiffT | t.CPtr, stop: t.CPtrDiffT | t.CPtr, step: t.CPtrDiffT | t.CPtr): pass -extern def PySlice_AdjustIndices(length: t.CSizeT, start: t.CPtrDiffT | t.CPtr, stop: t.CPtrDiffT | t.CPtr, step: t.CPtrDiffT) -> t.CSizeT -extern def PySlice_Check(obj: PyObject | t.CPtr) -> t.CInt +extern def PySlice_AdjustIndices(length: sizet, start: t.CPtrDiffT | t.CPtr, stop: t.CPtrDiffT | t.CPtr, step: t.CPtrDiffT) -> sizet +extern def PySlice_Check(obj: PyObject | t.CPtr) -> int # ============================================================ @@ -645,7 +645,7 @@ class PyFloatObj: return t.CPtr(malloc(PyFloatObj.__sizeof__())) @staticmethod - def from_double(val: t.CDouble) -> 'PyFloatObj' | t.CPtr: + def from_double(val: double) -> 'PyFloatObj' | t.CPtr: obj: PyFloatObj | t.CPtr = PyFloatObj() obj.ptr = PyFloat_FromDouble(val) return obj @@ -675,7 +675,7 @@ class PyFloatObj: res.ptr = PyNumber_Negative(self.ptr) return res - def to_double(self) -> t.CDouble: + def to_double(self) -> double: return PyFloat_AsDouble(self.ptr) def __str__(self) -> PyObject | t.CPtr: @@ -693,7 +693,7 @@ class PyUnicodeObj: return t.CPtr(malloc(PyUnicodeObj.__sizeof__())) @staticmethod - def from_string(s: t.CChar | t.CPtr) -> 'PyUnicodeObj' | t.CPtr: + def from_string(s: char | t.CPtr) -> 'PyUnicodeObj' | t.CPtr: obj: PyUnicodeObj | t.CPtr = PyUnicodeObj() obj.ptr = PyUnicode_FromString(s) return obj @@ -706,7 +706,7 @@ class PyUnicodeObj: def __len__(self) -> t.CPtrDiffT: return PyUnicode_GetLength(self.ptr) - def as_utf8(self) -> t.CChar | t.CPtr: + def as_utf8(self) -> char | t.CPtr: return PyUnicode_AsUTF8(self.ptr) def __str__(self) -> PyObject | t.CPtr: @@ -729,16 +729,16 @@ class PyListObj: obj.ptr = PyList_New(0) return obj - def __getitem__(self, idx: t.CSizeT) -> PyObject | t.CPtr: + def __getitem__(self, idx: sizet) -> PyObject | t.CPtr: return PyList_GetItem(self.ptr, idx) - def __setitem__(self, idx: t.CSizeT, val: PyObject | t.CPtr): + def __setitem__(self, idx: sizet, val: PyObject | t.CPtr): PyList_SetItem(self.ptr, idx, val) - def __len__(self) -> t.CSizeT: + def __len__(self) -> sizet: return PyList_Size(self.ptr) - def append(self, item: PyObject | t.CPtr) -> t.CInt: + def append(self, item: PyObject | t.CPtr) -> int: return PyList_Append(self.ptr, item) def dec_ref(self): @@ -764,13 +764,13 @@ class PyDictObj: def __setitem__(self, key: PyObject | t.CPtr, val: PyObject | t.CPtr): PyDict_SetItem(self.ptr, key, val) - def __len__(self) -> t.CSizeT: + def __len__(self) -> sizet: return PyDict_Size(self.ptr) - def get_string(self, key: t.CChar | t.CPtr) -> PyObject | t.CPtr: + def get_string(self, key: char | t.CPtr) -> PyObject | t.CPtr: return PyDict_GetItemString(self.ptr, key) - def set_string(self, key: t.CChar | t.CPtr, val: PyObject | t.CPtr): + def set_string(self, key: char | t.CPtr, val: PyObject | t.CPtr): PyDict_SetItemString(self.ptr, key, val) def dec_ref(self): diff --git a/CPythonTest/App/main.vp b/CPythonTest/App/main.vp index 851e520..f233b7b 100644 --- a/CPythonTest/App/main.vp +++ b/CPythonTest/App/main.vp @@ -26,7 +26,7 @@ def test_long_operations(): testcheck.check(py_str != 0, "PyObject_Str != NULL", "PyObject_Str != NULL") # 获取 C 字符串 - c_str: t.CChar | CPtr = cpython.PyUnicode_AsUTF8(py_str) + c_str: char | CPtr = cpython.PyUnicode_AsUTF8(py_str) testcheck.check(c_str != 0, "PyUnicode_AsUTF8 != NULL", "PyUnicode_AsUTF8 != NULL") printf(" PyLong_FromLong(12345) -> str = %s\n", c_str) @@ -63,7 +63,7 @@ def test_string_operations(): testcheck.check(py_s1 != 0, "PyUnicode_FromString != NULL", "PyUnicode_FromString != NULL") # 获取 UTF8 - utf8: t.CChar | CPtr = cpython.PyUnicode_AsUTF8(py_s1) + utf8: char | CPtr = cpython.PyUnicode_AsUTF8(py_s1) testcheck.check(utf8 != 0, "AsUTF8 != NULL", "AsUTF8 != NULL") printf(" PyUnicode_FromString -> %s\n", utf8) @@ -74,7 +74,7 @@ def test_string_operations(): # 字符串拼接 py_s2: cpython.PyObject | CPtr = cpython.PyUnicode_FromString(" World") py_concat: cpython.PyObject | CPtr = cpython.PyUnicode_Concat(py_s1, py_s2) - concat_utf8: t.CChar | CPtr = cpython.PyUnicode_AsUTF8(py_concat) + concat_utf8: char | CPtr = cpython.PyUnicode_AsUTF8(py_concat) testcheck.check(py_concat != 0, "Concat != NULL", "Concat != NULL") printf(" Concat -> %s\n", concat_utf8) @@ -148,7 +148,7 @@ def test_dict_operations(): # 获取值 got_val: cpython.PyObject | CPtr = cpython.PyDict_GetItem(py_dict, py_key1) testcheck.check(got_val != 0, "GetItem(name) != NULL", "GetItem(name) != NULL") - got_str: t.CChar | CPtr = cpython.PyUnicode_AsUTF8(got_val) + got_str: char | CPtr = cpython.PyUnicode_AsUTF8(got_val) testcheck.check(got_str != 0, "name == Viper", "name == Viper") printf(" dict['name'] = %s\n", got_str) @@ -278,7 +278,7 @@ def test_operator_overload(): testcheck.check(sa != 0 and sb != 0, "PyUnicodeObj.from_string != NULL", "PyUnicodeObj.from_string != NULL") sc: cpython.PyUnicodeObj | CPtr = sa + sb - sc_utf8: t.CChar | CPtr = sc.as_utf8() + sc_utf8: char | CPtr = sc.as_utf8() testcheck.check(sc_utf8 != 0, "PyUnicodeObj concat != NULL", "PyUnicodeObj concat != NULL") if sc_utf8 != 0: printf(" PyUnicodeObj 'Hello' + ' World' = %s\n", sc_utf8) @@ -302,13 +302,13 @@ def test_operator_overload(): lst.append(e3) testcheck.check(len(lst) == 3, "PyListObj len == 3", "PyListObj len == 3") - item0: cpython.PyObject | CPtr = lst[t.CSizeT(0)] + item0: cpython.PyObject | CPtr = lst[sizet(0)] testcheck.check(cpython.PyLong_AsLong(item0) == 100, "PyListObj lst[0] == 100", "PyListObj lst[0] == 100") # __setitem__ e4: cpython.PyObject | CPtr = cpython.PyLong_FromLong(999) - lst[t.CSizeT(1)] = e4 - item1: cpython.PyObject | CPtr = lst[t.CSizeT(1)] + lst[sizet(1)] = e4 + item1: cpython.PyObject | CPtr = lst[sizet(1)] testcheck.check(cpython.PyLong_AsLong(item1) == 999, "PyListObj lst[1] = 999", "PyListObj lst[1] = 999") cpython.Py_DecRef(e4) @@ -327,7 +327,7 @@ def test_operator_overload(): testcheck.check(len(dct) == 1, "PyDictObj len == 1", "PyDictObj len == 1") got_lang: cpython.PyObject | CPtr = dct[dk1] - got_str: t.CChar | CPtr = cpython.PyUnicode_AsUTF8(got_lang) + got_str: char | CPtr = cpython.PyUnicode_AsUTF8(got_lang) testcheck.check(got_str != 0, "PyDictObj dct['lang'] == Viper", "PyDictObj dct['lang'] == Viper") if got_str != 0: printf(" PyDictObj dct['lang'] = %s\n", got_str) diff --git a/CharTest/App/main.vp b/CharTest/App/main.vp index f648772..9569e1a 100644 --- a/CharTest/App/main.vp +++ b/CharTest/App/main.vp @@ -7,7 +7,7 @@ def bump(v: char) -> char: return char(v + 1) -def main() -> t.CInt | t.CExport: +def main() -> int | t.CExport: # 1) char 注解：char = t.CChar = i8（标量内置类型，非指针） ch: char = 65 stdio.printf("1 char annot: %d (expect 65)\n", int(ch)) diff --git a/ClassArrayTest/App/class_test.vp b/ClassArrayTest/App/class_test.vp index c526cf1..a5bdd1e 100644 --- a/ClassArrayTest/App/class_test.vp +++ b/ClassArrayTest/App/class_test.vp @@ -5,48 +5,48 @@ import t, c class SimpleData(): - x: t.CInt - y: t.CInt + x: int + y: int class Point3D(): - x: t.CFloat - y: t.CFloat - z: t.CFloat + x: float + y: float + z: float class Student(): - name: t.CChar | t.CPtr - age: t.CInt - score: t.CInt + name: char | t.CPtr + age: int + score: int - def __init__(self, n: t.CChar | t.CPtr, a: t.CInt, s: t.CInt): + def __init__(self, n: char | t.CPtr, a: int, s: int): self.name = n self.age = a self.score = s - def get_age(self) -> t.CInt: + def get_age(self) -> int: return self.age - def get_score(self) -> t.CInt: + def get_score(self) -> int: return self.score class Counter(): - value: t.CInt + value: int - def __init__(self, initial: t.CInt): + def __init__(self, initial: int): self.value = initial def increment(self): self.value += 1 - def get_value(self) -> t.CInt: + def get_value(self) -> int: return self.value class StackObj(): - data: t.CInt + data: int next_ptr: t.CPtr @@ -111,7 +111,7 @@ def TestHeapAllocation(): def TestHeapObjectWithInit(): stdio.printf("=== Test Heap Object with Init ===\n") - mem_size: t.CSizeT = 256 + mem_size: sizet = 256 ptr: t.CPtr = stdlib.malloc(mem_size) if ptr != 0: stdio.printf("Allocated %d bytes\n", mem_size) @@ -156,8 +156,8 @@ def TestClassWithBitFields(): def TestIntArray(): stdio.printf("=== Test Int Array ===\n") - arr: t.CArray[t.CInt, 5] = t.CArray[t.CInt, 5]() - i: t.CInt = 0 + arr: t.CArray[int, 5] = t.CArray[int, 5]() + i: int = 0 while i < 5: arr[i] = i * 10 i += 1 @@ -169,12 +169,12 @@ def TestIntArray(): def TestFloatArray(): stdio.printf("=== Test Float Array ===\n") - farr: t.CArray[t.CFloat, 4] = t.CArray[t.CFloat, 4]() + farr: t.CArray[float, 4] = t.CArray[float, 4]() farr[0] = 1.5 farr[1] = 2.5 farr[2] = 3.5 farr[3] = 4.5 - i: t.CInt = 0 + i: int = 0 while i < 4: stdio.printf("farr[%d]=%.1f\n", i, farr[i]) i += 1 @@ -182,7 +182,7 @@ def TestFloatArray(): def TestCharArray(): stdio.printf("=== Test Char Array (String) ===\n") - str_arr: t.CArray[t.CChar, 32] = t.CArray[t.CChar, 32]() + str_arr: t.CArray[char, 32] = t.CArray[char, 32]() str_arr[0] = 'H' str_arr[1] = 'e' str_arr[2] = 'l' @@ -194,15 +194,15 @@ def TestCharArray(): def TestNestedArray(): stdio.printf("=== Test Nested Array (Array of Arrays) ===\n") - row0: t.CArray[t.CInt, 3] = t.CArray[t.CInt, 3]() - row1: t.CArray[t.CInt, 3] = t.CArray[t.CInt, 3]() + row0: t.CArray[int, 3] = t.CArray[int, 3]() + row1: t.CArray[int, 3] = t.CArray[int, 3]() row0[0] = 0 row0[1] = 1 row0[2] = 2 row1[0] = 10 row1[1] = 11 row1[2] = 12 - i: t.CInt = 0 + i: int = 0 while i < 3: stdio.printf("row0[%d]=%d ", i, row0[i]) i += 1 @@ -217,7 +217,7 @@ def TestNestedArray(): def TestArrayWithStruct(): stdio.printf("=== Test Array with Struct ===\n") points: t.CArray[SimpleData, 3] = t.CArray[SimpleData, 3]() - i: t.CInt = 0 + i: int = 0 while i < 3: points[i].x = i * 10 points[i].y = i * 100 @@ -230,11 +230,11 @@ def TestArrayWithStruct(): def TestArrayPointer(): stdio.printf("=== Test Array Pointer ===\n") - data: t.CArray[t.CInt, 8] = t.CArray[t.CInt, 8]() + data: t.CArray[int, 8] = t.CArray[int, 8]() data[0] = 100 data[1] = 200 data[2] = 300 - ptr: t.CInt | t.CPtr = data + ptr: int | t.CPtr = data stdio.printf("ptr[0]=%d\n", ptr[0]) stdio.printf("ptr[1]=%d\n", ptr[1]) stdio.printf("ptr[2]=%d\n", ptr[2]) diff --git a/ClassArrayTest/App/main.vp b/ClassArrayTest/App/main.vp index 31b6121..01ae3de 100644 --- a/ClassArrayTest/App/main.vp +++ b/ClassArrayTest/App/main.vp @@ -3,7 +3,7 @@ import testcheck import class_test -def main() -> t.CInt: +def main() -> int: testcheck.begin("ClassArrayTest: 类与数组测试") testcheck.section("CLASS TESTS") diff --git a/ClosureCallTest/App/main.vp b/ClosureCallTest/App/main.vp index 67048ec..bfd3c87 100644 --- a/ClosureCallTest/App/main.vp +++ b/ClosureCallTest/App/main.vp @@ -33,7 +33,7 @@ def test_closure_call(): testcheck.check(v == 1, "f() first call = 1", "expect 1") -def main() -> t.CInt: +def main() -> int: testcheck.begin("ClosureCallTest: t.CPtr function pointer call") test_closure_call() return testcheck.end() diff --git a/ClosureTest/App/main.vp b/ClosureTest/App/main.vp index 89a2fd8..f5d99bd 100644 --- a/ClosureTest/App/main.vp +++ b/ClosureTest/App/main.vp @@ -5,7 +5,7 @@ import testcheck # ============================================================ # Test 1: global 在嵌套函数中 # ============================================================ -g_val: t.CInt = 100 +g_val: int = 100 def outer_modify_global(): global g_val @@ -26,7 +26,7 @@ def test_global_in_nested(): # ============================================================ def test_nonlocal_multi_level(): testcheck.section("Test 2: nonlocal multi-level") - x: t.CInt = 1 + x: int = 1 def level1(): nonlocal x x += 10 @@ -44,13 +44,13 @@ def test_nonlocal_multi_level(): # ============================================================ # Test 3: global 和 nonlocal 混合 # ============================================================ -g_mixed: t.CInt = 0 +g_mixed: int = 0 def test_global_nonlocal_mixed(): testcheck.section("Test 3: global + nonlocal mixed") global g_mixed g_mixed = 0 - local_var: t.CInt = 0 + local_var: int = 0 def modify_both(): nonlocal local_var global g_mixed @@ -65,10 +65,10 @@ def test_global_nonlocal_mixed(): # ============================================================ def test_lambda_multi_capture(): testcheck.section("Test 4: lambda multi-capture") - a: t.CInt = 10 - b: t.CInt = 20 + a: int = 10 + b: int = 20 f = lambda: a + b - r: t.CInt = f() + r: int = f() testcheck.check(r == 30, "lambda multi-capture (a+b == 30)", "lambda multi-capture (expect 30)") # ============================================================ @@ -76,9 +76,9 @@ def test_lambda_multi_capture(): # ============================================================ def test_lambda_arg_capture(): testcheck.section("Test 5: lambda arg + capture") - base: t.CInt = 100 + base: int = 100 add = lambda x: base + x - r: t.CInt = add(42) + r: int = add(42) testcheck.check(r == 142, "lambda arg+capture (100+42 == 142)", "lambda arg+capture (expect 142)") # ============================================================ @@ -86,12 +86,12 @@ def test_lambda_arg_capture(): # ============================================================ def test_nested_return(): testcheck.section("Test 6: nested function return") - x: t.CInt = 5 - def double_x() -> t.CInt: + x: int = 5 + def double_x() -> int: nonlocal x x = x * 2 return x - r: t.CInt = double_x() + r: int = double_x() testcheck.check(r == 10 and x == 10, "nested return (r==10 x==10)", "nested return (expect r=10 x=10)") # ============================================================ @@ -99,8 +99,8 @@ def test_nested_return(): # ============================================================ def test_nonlocal_loop(): testcheck.section("Test 7: nonlocal with loop") - total: t.CInt = 0 - def accumulate(n: t.CInt): + total: int = 0 + def accumulate(n: int): nonlocal total for i in range(n): total += i @@ -112,7 +112,7 @@ def test_nonlocal_loop(): # ============================================================ # Test 8: global 数组操作 # ============================================================ -g_arr: t.CArray[t.CInt, 4] = [0] +g_arr: t.CArray[int, 4] = [0] def test_global_array(): testcheck.section("Test 8: global array") @@ -121,7 +121,7 @@ def test_global_array(): g_arr[1] = 20 g_arr[2] = 30 g_arr[3] = 40 - total: t.CInt = g_arr[0] + g_arr[1] + g_arr[2] + g_arr[3] + total: int = g_arr[0] + g_arr[1] + g_arr[2] + g_arr[3] testcheck.check(total == 100, "global array (total == 100)", "global array (expect 100)") # ============================================================ @@ -129,8 +129,8 @@ def test_global_array(): # ============================================================ def test_nested_conditional(): testcheck.section("Test 9: nested conditional call") - result: t.CInt = 0 - def set_result(val: t.CInt): + result: int = 0 + def set_result(val: int): nonlocal result result = val if 1: @@ -146,10 +146,10 @@ def test_lambda_chain(): testcheck.section("Test 10: lambda chain") f1 = lambda: 10 f2 = lambda: 20 - r: t.CInt = f1() + f2() + r: int = f1() + f2() testcheck.check(r == 30, "lambda chain (10+20 == 30)", "lambda chain (expect 30)") -def main() -> t.CInt: +def main() -> int: testcheck.begin("ClosureAdvancedTest: 高级闭包测试") test_global_in_nested() test_nonlocal_multi_level() diff --git a/ClosureTest2/App/main.vp b/ClosureTest2/App/main.vp index 24e8bfb..39ee0e0 100644 --- a/ClosureTest2/App/main.vp +++ b/ClosureTest2/App/main.vp @@ -7,8 +7,8 @@ import testcheck # ============================================================ def test_nonlocal_conditional(): testcheck.section("Test 1: nonlocal in conditional branches") - x: t.CInt = 0 - def modify(flag: t.CInt): + x: int = 0 + def modify(flag: int): nonlocal x if flag: x += 10 @@ -24,12 +24,12 @@ def test_nonlocal_conditional(): # ============================================================ def test_nonlocal_multi_var(): testcheck.section("Test 2: multiple nonlocal variables") - a: t.CInt = 1 - b: t.CInt = 2 - c_val: t.CInt = 3 + a: int = 1 + b: int = 2 + c_val: int = 3 def swap_add(): nonlocal a, b, c_val - tmp: t.CInt = a + tmp: int = a a = b b = c_val c_val = tmp @@ -39,13 +39,13 @@ def test_nonlocal_multi_var(): # ============================================================ # Test 3: global 在多个函数中交叉修改 # ============================================================ -g_counter: t.CInt = 0 +g_counter: int = 0 def inc_global(): global g_counter g_counter += 1 -def add_global(n: t.CInt): +def add_global(n: int): global g_counter g_counter += n @@ -64,13 +64,13 @@ def test_global_cross_functions(): # ============================================================ def test_nested_ref_capture(): testcheck.section("Test 4: nested function ref capture") - arr: t.CArray[t.CInt, 4] = [0] + arr: t.CArray[int, 4] = [0] def fill(): nonlocal arr for i in range(4): arr[i] = (i + 1) * 10 fill() - total: t.CInt = arr[0] + arr[1] + arr[2] + arr[3] + total: int = arr[0] + arr[1] + arr[2] + arr[3] testcheck.check(total == 100, "ref capture (total == 100)", "ref capture (expect 100)") # ============================================================ @@ -78,11 +78,11 @@ def test_nested_ref_capture(): # ============================================================ def test_lambda_capture_then_modify(): testcheck.section("Test 5: lambda capture then modify") - x: t.CInt = 10 + x: int = 10 f = lambda: x - r1: t.CInt = f() + r1: int = f() x = 20 - r2: t.CInt = f() + r2: int = f() testcheck.check(r1 == 10 and r2 == 10, "lambda value capture (before==10 after==10)", "lambda value capture (expect 10 10)") # ============================================================ @@ -90,9 +90,9 @@ def test_lambda_capture_then_modify(): # ============================================================ def test_nonlocal_loop_accumulate(): testcheck.section("Test 6: nonlocal with loop accumulate") - sum_val: t.CInt = 0 - count: t.CInt = 0 - def add_numbers(n: t.CInt): + sum_val: int = 0 + count: int = 0 + def add_numbers(n: int): nonlocal sum_val, count for i in range(1, n + 1): sum_val += i @@ -106,9 +106,9 @@ def test_nonlocal_loop_accumulate(): # ============================================================ def test_deep_nested_vars(): testcheck.section("Test 7: deep nested different vars") - a: t.CInt = 0 - b: t.CInt = 0 - c_val: t.CInt = 0 + a: int = 0 + b: int = 0 + c_val: int = 0 def level1(): nonlocal a a += 1 @@ -127,14 +127,14 @@ def test_deep_nested_vars(): # ============================================================ # Test 8: global + nonlocal 在同一嵌套函数中 # ============================================================ -g_state: t.CInt = 0 +g_state: int = 0 def test_global_nonlocal_same_func(): testcheck.section("Test 8: global+nonlocal in same nested func") global g_state g_state = 0 - local_state: t.CInt = 0 - def worker(n: t.CInt): + local_state: int = 0 + def worker(n: int): nonlocal local_state global g_state for i in range(n): @@ -148,10 +148,10 @@ def test_global_nonlocal_same_func(): # ============================================================ def test_lambda_default_and_capture(): testcheck.section("Test 9: lambda with arg and capture") - base: t.CInt = 100 + base: int = 100 multiply = lambda x: base * x - r1: t.CInt = multiply(3) - r2: t.CInt = multiply(5) + r1: int = multiply(3) + r2: int = multiply(5) testcheck.check(r1 == 300 and r2 == 500, "lambda arg+capture (100*3==300 100*5==500)", "lambda arg+capture (expect 300 500)") # ============================================================ @@ -159,8 +159,8 @@ def test_lambda_default_and_capture(): # ============================================================ def test_nested_accumulate(): testcheck.section("Test 10: nested function accumulate") - total: t.CInt = 0 - def add_val(n: t.CInt): + total: int = 0 + def add_val(n: int): nonlocal total total += n add_val(10) @@ -173,10 +173,10 @@ def test_nested_accumulate(): # ============================================================ def test_nonlocal_while(): testcheck.section("Test 11: nonlocal in while loop") - result: t.CInt = 0 - def countdown(n: t.CInt): + result: int = 0 + def countdown(n: int): nonlocal result - i: t.CInt = n + i: int = n while i > 0: result += i i -= 1 @@ -187,15 +187,15 @@ def test_nonlocal_while(): # Test 12: 嵌套函数修改结构体字段 # ============================================================ class Point: - x: t.CInt - y: t.CInt + x: int + y: int def test_nested_modify_struct(): testcheck.section("Test 12: nested modify struct") p: Point = Point() p.x = 0 p.y = 0 - def translate(dx: t.CInt, dy: t.CInt): + def translate(dx: int, dy: int): nonlocal p p.x += dx p.y += dy @@ -203,7 +203,7 @@ def test_nested_modify_struct(): translate(5, 15) testcheck.check(p.x == 15 and p.y == 35, "nested struct (x==15 y==35)", "nested struct (expect 15 35)") -def main() -> t.CInt: +def main() -> int: testcheck.begin("ClosureTest2: Advanced Closure/Lambda/Global/Nonlocal") test_nonlocal_conditional() test_nonlocal_multi_var() diff --git a/CoroTest/App/main.vp b/CoroTest/App/main.vp index fc53659..2f784a9 100644 --- a/CoroTest/App/main.vp +++ b/CoroTest/App/main.vp @@ -28,12 +28,12 @@ async def task() -> int: return 99 -def main() -> t.CInt: - n: t.CInt = 0 +def main() -> int: + n: int = 0 for i in range(3): tt: coro.Coroutine = coro.Coroutine(*&task()) - r: t.CInt = coro.coro_run(tt) - e: t.CInt = coro.coro_exception(tt) + r: int = coro.coro_run(tt) + e: int = coro.coro_exception(tt) m: t.CPtr = coro.coro_exception_msg(tt) stdio.printf("[%d] r = %d, exc = %d, msg = %s\n", i, r, e, m) coro.coro_destroy(tt) diff --git a/DecoratorTest/App/main.vp b/DecoratorTest/App/main.vp index 976f8ec..89f555e 100644 --- a/DecoratorTest/App/main.vp +++ b/DecoratorTest/App/main.vp @@ -18,10 +18,10 @@ import testcheck # ============================================================ # @log 装饰器：打印函数进入/退出，返回 1（正常调用一次） -def log(ctx: t.CPtr, func_name: str, phase: t.CInt, +def log(ctx: t.CPtr, func_name: str, phase: int, args_ptr: t.CPtr, ret_ptr: t.CPtr, - decor_args_ptr: t.CPtr) -> t.CInt | t.CExport: + decor_args_ptr: t.CPtr) -> int | t.CExport: if phase == 0: printf("[LOG] >> %s enter\n", func_name) return 1 @@ -30,10 +30,10 @@ def log(ctx: t.CPtr, func_name: str, phase: t.CInt, return 0 # @trace 装饰器：详细追踪 -def trace(ctx: t.CPtr, func_name: str, phase: t.CInt, +def trace(ctx: t.CPtr, func_name: str, phase: int, args_ptr: t.CPtr, ret_ptr: t.CPtr, - decor_args_ptr: t.CPtr) -> t.CInt | t.CExport: + decor_args_ptr: t.CPtr) -> int | t.CExport: if phase == 0: printf("[TRACE] calling %s...\n", func_name) return 1 @@ -45,27 +45,27 @@ def trace(ctx: t.CPtr, func_name: str, phase: t.CInt, # 注意：理想情况下应使用 ctx 栈帧局部上下文替代全局变量， # 但 Viper 当前前端尚不支持 i8* 到 i32* 的指针转型， # 因此暂时使用全局变量演示计时逻辑 -_timing_tmp: t.CInt = 0 +_timing_tmp: int = 0 -def timing(ctx: t.CPtr, func_name: str, phase: t.CInt, +def timing(ctx: t.CPtr, func_name: str, phase: int, args_ptr: t.CPtr, ret_ptr: t.CPtr, - decor_args_ptr: t.CPtr) -> t.CInt | t.CExport: + decor_args_ptr: t.CPtr) -> int | t.CExport: global _timing_tmp if phase == 0: _timing_tmp = 100 printf("[TIMING] %s start at t=%d\n", func_name, _timing_tmp) return 1 else: - elapsed: t.CInt = 105 - _timing_tmp + elapsed: int = 105 - _timing_tmp printf("[TIMING] %s took %d ms\n", func_name, elapsed) return 0 # @repeat 装饰器（带参数，流程劫持）：循环调用原函数 N 次 -def repeat(ctx: t.CPtr, func_name: str, phase: t.CInt, +def repeat(ctx: t.CPtr, func_name: str, phase: int, args_ptr: t.CPtr, ret_ptr: t.CPtr, - decor_args_ptr: t.CPtr) -> t.CInt | t.CExport: + decor_args_ptr: t.CPtr) -> int | t.CExport: if phase == 0: printf("[REPEAT] %s will run 3 times\n", func_name) return 3 @@ -74,12 +74,12 @@ def repeat(ctx: t.CPtr, func_name: str, phase: t.CInt, return 0 # @skip 装饰器：跳过原函数调用（流程劫持，返回 0） -_skip_count: t.CInt = 0 +_skip_count: int = 0 -def skip(ctx: t.CPtr, func_name: str, phase: t.CInt, +def skip(ctx: t.CPtr, func_name: str, phase: int, args_ptr: t.CPtr, ret_ptr: t.CPtr, - decor_args_ptr: t.CPtr) -> t.CInt | t.CExport: + decor_args_ptr: t.CPtr) -> int | t.CExport: global _skip_count if phase == 0: _skip_count = _skip_count + 1 @@ -90,12 +90,12 @@ def skip(ctx: t.CPtr, func_name: str, phase: t.CInt, return 0 # @count_calls 装饰器：统计函数被调用次数（递归保护测试用） -_call_count: t.CInt = 0 +_call_count: int = 0 -def count_calls(ctx: t.CPtr, func_name: str, phase: t.CInt, +def count_calls(ctx: t.CPtr, func_name: str, phase: int, args_ptr: t.CPtr, ret_ptr: t.CPtr, - decor_args_ptr: t.CPtr) -> t.CInt | t.CExport: + decor_args_ptr: t.CPtr) -> int | t.CExport: global _call_count if phase == 0: _call_count = _call_count + 1 @@ -111,7 +111,7 @@ def count_calls(ctx: t.CPtr, func_name: str, phase: t.CInt, # ============================================================ @log -def add(a: t.CInt, b: t.CInt) -> t.CInt | t.CExport: +def add(a: int, b: int) -> int | t.CExport: return a + b @@ -122,7 +122,7 @@ def add(a: t.CInt, b: t.CInt) -> t.CInt | t.CExport: @log @trace -def multiply(a: t.CInt, b: t.CInt) -> t.CInt | t.CExport: +def multiply(a: int, b: int) -> int | t.CExport: return a * b @@ -131,7 +131,7 @@ def multiply(a: t.CInt, b: t.CInt) -> t.CInt | t.CExport: # ============================================================ @log -def greet(name: str) -> t.CVoid | t.CExport: +def greet(name: str) -> void | t.CExport: printf("Hello, %s!\n", name) @@ -140,7 +140,7 @@ def greet(name: str) -> t.CVoid | t.CExport: # ============================================================ @log -def get_value() -> t.CInt | t.CExport: +def get_value() -> int | t.CExport: return 42 @@ -149,7 +149,7 @@ def get_value() -> t.CInt | t.CExport: # ============================================================ @timing -export def compute(x: t.CInt) -> t.CInt: +export def compute(x: int) -> int: return x * x + 1 @@ -168,9 +168,9 @@ export def echo(msg: str): @timing @log -export def power(base: t.CInt, exp: t.CInt) -> t.CInt: - result: t.CInt = 1 - i: t.CInt = 0 +export def power(base: int, exp: int) -> int: + result: int = 1 + i: int = 0 while i < exp: result = result * base i = i + 1 @@ -182,7 +182,7 @@ export def power(base: t.CInt, exp: t.CInt) -> t.CInt: # ============================================================ @skip -def dangerous() -> t.CInt | t.CExport: +def dangerous() -> int | t.CExport: printf("This should NOT be printed!\n") return 999 @@ -192,7 +192,7 @@ def dangerous() -> t.CInt | t.CExport: # ============================================================ @repeat(3) -def accumulate(x: t.CInt) -> t.CInt | t.CExport: +def accumulate(x: int) -> int | t.CExport: printf(" accumulate(%d)\n", x) return x * 10 @@ -204,7 +204,7 @@ def accumulate(x: t.CInt) -> t.CInt | t.CExport: # ============================================================ @count_calls -def factorial(n: t.CInt) -> t.CInt | t.CExport: +def factorial(n: int) -> int | t.CExport: if n <= 1: return 1 return n * factorial(n - 1) @@ -216,7 +216,7 @@ def factorial(n: t.CInt) -> t.CInt | t.CExport: # ============================================================ @log -def fib(n: t.CInt) -> t.CInt | t.CExport: +def fib(n: int) -> int | t.CExport: if n <= 1: return n return fib(n - 1) + fib(n - 2) @@ -226,18 +226,18 @@ def fib(n: t.CInt) -> t.CInt | t.CExport: # 主函数 # ============================================================ -def main() -> t.CInt | t.CExport: +def main() -> int | t.CExport: testcheck.begin("Decorator Test v4") # 测试 1：单个 @log testcheck.section("Test 1: single @log") - r1: t.CInt = add(3, 4) + r1: int = add(3, 4) printf("add(3,4) = %d\n", r1) testcheck.check(r1 == 7, "add(3,4) = 7", "add(3,4) expect 7") # 测试 2：链式 @log @trace testcheck.section("Test 2: chained @log @trace") - r2: t.CInt = multiply(5, 6) + r2: int = multiply(5, 6) printf("multiply(5,6) = %d\n", r2) testcheck.check(r2 == 30, "multiply(5,6) = 30", "multiply(5,6) expect 30") @@ -248,13 +248,13 @@ def main() -> t.CInt | t.CExport: # 测试 4：无参数 testcheck.section("Test 4: @log on no-arg function") - r4: t.CInt = get_value() + r4: int = get_value() printf("get_value() = %d\n", r4) testcheck.check(r4 == 42, "get_value() = 42", "get_value() expect 42") # 测试 5：@timing testcheck.section("Test 5: @timing") - r5: t.CInt = compute(7) + r5: int = compute(7) printf("compute(7) = %d\n", r5) testcheck.check(r5 == 50, "compute(7) = 50", "compute(7) expect 50") @@ -265,19 +265,19 @@ def main() -> t.CInt | t.CExport: # 测试 7：链式 @timing @log testcheck.section("Test 7: chained @timing @log") - r7: t.CInt = power(2, 10) + r7: int = power(2, 10) printf("power(2,10) = %d\n", r7) testcheck.check(r7 == 1024, "power(2,10) = 1024", "power(2,10) expect 1024") # 测试 8：@skip — 跳过原函数调用 testcheck.section("Test 8: @skip flow hijack") - r8: t.CInt = dangerous() + r8: int = dangerous() printf("dangerous() = %d (should be 0, skipped)\n", r8) testcheck.check(r8 == 0, "dangerous() skipped = 0", "dangerous() expect 0") # 测试 9：@repeat(3) 有返回值 testcheck.section("Test 9: @repeat(3) with return value") - r9: t.CInt = accumulate(5) + r9: int = accumulate(5) printf("accumulate(5) = %d (last iteration result)\n", r9) testcheck.check(r9 == 50, "accumulate(5) = 50", "accumulate(5) expect 50") @@ -285,14 +285,14 @@ def main() -> t.CInt | t.CExport: testcheck.section("Test 10: recursive decoration protection") global _call_count _call_count = 0 - r10: t.CInt = factorial(5) + r10: int = factorial(5) printf("factorial(5) = %d (should be 120)\n", r10) printf(" decorator call count = %d (should be 1, not 5)\n", _call_count) testcheck.check(r10 == 120 and _call_count == 1, "factorial(5)=120, calls=1", "factorial(5) expect 120, calls=1") # 测试 11：@log 递归保护 — fib testcheck.section("Test 11: @log on recursive fib") - r11: t.CInt = fib(6) + r11: int = fib(6) printf("fib(6) = %d (should be 8)\n", r11) testcheck.check(r11 == 8, "fib(6) = 8", "fib(6) expect 8") diff --git a/DefaultArgTest/App/main.vp b/DefaultArgTest/App/main.vp index 06a27d6..02df278 100644 --- a/DefaultArgTest/App/main.vp +++ b/DefaultArgTest/App/main.vp @@ -6,7 +6,7 @@ import random # 同模块：单个尾随默认值 -def local_one(x: int, cap: t.CSizeT = 4096) -> t.CSizeT: +def local_one(x: int, cap: sizet = 4096) -> sizet: return cap @@ -15,35 +15,35 @@ def local_quad(a: int, b: int = 10, c: int = 20, d: int = 30) -> int: return a + b * 100 + c * 10000 + d * 1000000 -def main() -> t.CInt: +def main() -> int: testcheck.begin("DefaultArgTest: default / named / out-of-order arguments") # ① 同模块默认值 testcheck.section("same-module defaults") - r1: t.CSizeT = local_one(1) + r1: sizet = local_one(1) testcheck.check(r1 == 4096, "local_one(1) cap = 4096", "local_one(1) cap != 4096") r2: int = local_quad(1) testcheck.check(r2 == 30201001, "local_quad(1) = 30201001", "local_quad(1) != 30201001") # ② 跨模块默认值 testcheck.section("cross-module defaults") - r3: t.CSizeT = remote.one(1) + r3: sizet = remote.one(1) testcheck.check(r3 == 4096, "remote.one(1) cap = 4096", "remote.one(1) cap != 4096") - r4: t.CSizeT = remote.write(1, 2, False) + r4: sizet = remote.write(1, 2, False) testcheck.check(r4 == 4096, "remote.write(1,2,False) cap = 4096", "remote.write(1,2,False) cap != 4096") # ③ 显式覆盖默认值 testcheck.section("explicit override") - r5: t.CSizeT = remote.one(1, 8) + r5: sizet = remote.one(1, 8) testcheck.check(r5 == 8, "remote.one(1,8) cap = 8", "remote.one(1,8) cap != 8") # ④ 命名 / 乱序传参 testcheck.section("named / out-of-order arguments") - r6: t.CSizeT = remote.one(cap = 8, x = 1) + r6: sizet = remote.one(cap = 8, x = 1) testcheck.check(r6 == 8, "remote.one(cap = 8, x = 1) = 8", "remote.one(cap = 8, x = 1) != 8") - r7: t.CSizeT = remote.one(x = 1, cap = 8) + r7: sizet = remote.one(x = 1, cap = 8) testcheck.check(r7 == 8, "remote.one(x = 1, cap = 8) = 8", "remote.one(x = 1, cap = 8) != 8") - r8: t.CSizeT = remote.one(x = 1) + r8: sizet = remote.one(x = 1) testcheck.check(r8 == 4096, "remote.one(x = 1) cap = 4096", "remote.one(x = 1) cap != 4096") r9: int = remote.many(z = 3, x = 1, y = 2) testcheck.check(r9 == 9, "remote.many(z = 3, x = 1, y = 2) = 9", "remote.many(z = 3, x = 1, y = 2) != 9") @@ -64,7 +64,7 @@ def main() -> t.CInt: # ⑥ include 模块（顶层 .vp）默认值：vrandom.randrange(start, stop, step = 1) # stop-start==1 ⇒ width==1 ⇒ 结果恒为 start；step 未填充时会退化为 0/垃圾 testcheck.section("include-module defaults") - r15: t.CInt = random.randrange(5, 6) + r15: int = random.randrange(5, 6) testcheck.check(r15 == 5, "vrandom.randrange(5,6) = 5 (step default)", "vrandom.randrange(5,6) != 5") return testcheck.end() diff --git a/DefaultArgTest/App/remote.vp b/DefaultArgTest/App/remote.vp index 9d49954..c93ac60 100644 --- a/DefaultArgTest/App/remote.vp +++ b/DefaultArgTest/App/remote.vp @@ -2,12 +2,12 @@ import t # 跨模块：单个尾随默认值（对照 includes/json/__writer.vp 的 write 形态） -def one(x: int, cap: t.CSizeT = 4096) -> t.CSizeT: +def one(x: int, cap: sizet = 4096) -> sizet: return cap # 跨模块：4 参、最后一个有默认值（与 json.write(pool, val, pretty, cap=4096) 同形） -def write(a: int, b: int, pretty: bool, cap: t.CSizeT = 4096) -> t.CSizeT: +def write(a: int, b: int, pretty: bool, cap: sizet = 4096) -> sizet: return cap diff --git a/DefineTest/App/main.vp b/DefineTest/App/main.vp index 0bc7b98..edbd688 100644 --- a/DefineTest/App/main.vp +++ b/DefineTest/App/main.vp @@ -16,20 +16,20 @@ import testcheck # ============================================================ -MAX_SIZE: t.CDefine = 1024 -MIN_VAL: t.CDefine = 0 -MAX_VAL: t.CDefine = 100 -MASK_BYTE: t.CDefine = 0xFF -SHIFT_BITS: t.CDefine = 8 -PI_INT: t.CDefine = 3 -ENABLED: t.CDefine = 1 -DISABLED: t.CDefine = 0 -PAGE_SIZE: t.CDefine = 4096 -BUFFER_LEN: t.CDefine = 256 +define MAX_SIZE = 1024 +define MIN_VAL = 0 +define MAX_VAL = 100 +define MASK_BYTE = 0xFF +define SHIFT_BITS = 8 +define PI_INT = 3 +define ENABLED = 1 +define DISABLED = 0 +define PAGE_SIZE = 4096 +define BUFFER_LEN = 256 -CODE_SEG: t.CDefine | t.CUInt16T = 0x08 -DATA_SEG: t.CDefine | t.CUInt16T = 0x10 -STACK_SEG: t.CDefine | t.CUInt16T = 0x20 +CODE_SEG: t.CDefine | uint16 = 0x08 +DATA_SEG: t.CDefine | uint16 = 0x10 +STACK_SEG: t.CDefine | uint16 = 0x20 def MAKE_FLAG(bit: CInt32T) -> t.CDefine: @@ -335,7 +335,7 @@ def test_cifdef_cross_module() -> CInt: return 0 def test_cifdef_guard() -> CInt: - MY_HEADER_GUARD: t.CDefine = 1 + define MY_HEADER_GUARD = 1 if c.CIfndef(MY_HEADER_GUARD): print(0) else: @@ -380,7 +380,7 @@ def test_cifdef_complex() -> CInt: return 0 -def main() -> t.CInt: +def main() -> int: w32.win32console.SetConsoleCP(65001) w32.win32console.SetConsoleOutputCP(65001) diff --git a/DictTest/App/main.vp b/DictTest/App/main.vp index 92ee880..80e7196 100644 --- a/DictTest/App/main.vp +++ b/DictTest/App/main.vp @@ -25,7 +25,7 @@ def main() -> CInt | CExport: d.set_int("alpha", 10) d.set_int("beta", 20) d.set_int("gamma", 30) - n: t.CSizeT = len(d) + n: sizet = len(d) stdio.printf("len=%lu\n", n) testcheck.check(n == 3, "dict len OK (3)", "dict len FAILED") @@ -38,10 +38,10 @@ def main() -> CInt | CExport: stdio.printf("p2=%p\n", p2) p3: t.CPtr = d["gamma"] stdio.printf("p3=%p\n", p3) - v1: int = c.Deref((int | t.CPtr)(p1)) + v1: int = *(int | t.CPtr)(p1) stdio.printf("v1=%d\n", v1) - v2: int = c.Deref((int | t.CPtr)(p2)) - v3: int = c.Deref((int | t.CPtr)(p3)) + v2: int = *(int | t.CPtr)(p2) + v3: int = *(int | t.CPtr)(p3) stdio.printf("alpha=%d beta=%d gamma=%d\n", v1, v2, v3) testcheck.check(v1 == 10, "dict[alpha]==10 OK", "dict[alpha] FAILED") testcheck.check(v2 == 20, "dict[beta]==20 OK", "dict[beta] FAILED") @@ -51,7 +51,7 @@ def main() -> CInt | CExport: testcheck.section("Test 2: 更新已有键") d.set_int("beta", 99) p2b: t.CPtr = d["beta"] - v2b: int = c.Deref((int | t.CPtr)(p2b)) + v2b: int = *(int | t.CPtr)(p2b) stdio.printf("beta(updated)=%d\n", v2b) testcheck.check(v2b == 99, "dict update OK", "dict update FAILED") testcheck.check(len(d) == 3, "dict len still 3 OK", "dict len changed FAILED") @@ -62,14 +62,14 @@ def main() -> CInt | CExport: testcheck.check(gv == None, "dict get missing OK (None)", "dict get missing FAILED") gp: t.CPtr = d.get("alpha", None) - ga: int = c.Deref((int | t.CPtr)(gp)) + ga: int = *(int | t.CPtr)(gp) stdio.printf("get(alpha)=%d\n", ga) testcheck.check(ga == 10, "dict get existing OK", "dict get existing FAILED") # === Test 4: contains === testcheck.section("Test 4: contains") - has_alpha: t.CInt = d.contains("alpha") - has_missing: t.CInt = d.contains("missing") + has_alpha: int = d.contains("alpha") + has_missing: int = d.contains("missing") stdio.printf("contains(alpha)=%d contains(missing)=%d\n", has_alpha, has_missing) testcheck.check(has_alpha == 1, "contains alpha OK", "contains alpha FAILED") testcheck.check(has_missing == 0, "not contains missing OK", "contains missing FAILED") @@ -79,7 +79,7 @@ def main() -> CInt | CExport: iter_count: int = 0 for key in d: kp: t.CPtr = d[key] - val: int = c.Deref((int | t.CPtr)(kp)) + val: int = *(int | t.CPtr)(kp) stdio.printf("dict[%s]=%d\n", key, val) iter_count += 1 testcheck.check(iter_count == 3, "dict iter OK (3)", "dict iter FAILED") @@ -90,7 +90,7 @@ def main() -> CInt | CExport: d2.set_str("name", "Alice") d2.set_str("city", "Beijing") d2.set_str("lang", "TransPyC") - n2: t.CSizeT = len(d2) + n2: sizet = len(d2) stdio.printf("d2 len=%lu\n", n2) testcheck.check(n2 == 3, "dict set_str len OK (3)", "dict set_str len FAILED") @@ -125,7 +125,7 @@ def main() -> CInt | CExport: stdio.sprintf(key_buf, "key%d", i) d3.set_int(key_buf, i * 100) i += 1 - n3: t.CSizeT = len(d3) + n3: sizet = len(d3) stdio.printf("d3 len=%lu (after 20 inserts)\n", n3) testcheck.check(n3 == 20, "dict expand OK (20)", "dict expand FAILED") @@ -133,14 +133,14 @@ def main() -> CInt | CExport: k5: str = stdlib.malloc(16) stdio.sprintf(k5, "key5") p5: t.CPtr = d3[k5] - v5: int = c.Deref((int | t.CPtr)(p5)) + v5: int = *(int | t.CPtr)(p5) stdio.printf("d3[key5]=%d\n", v5) testcheck.check(v5 == 500, "dict expand key5 OK", "dict expand key5 FAILED") k15: str = stdlib.malloc(16) stdio.sprintf(k15, "key15") p15: t.CPtr = d3[k15] - v15: int = c.Deref((int | t.CPtr)(p15)) + v15: int = *(int | t.CPtr)(p15) stdio.printf("d3[key15]=%d\n", v15) testcheck.check(v15 == 1500, "dict expand key15 OK", "dict expand key15 FAILED") @@ -165,9 +165,9 @@ def main() -> CInt | CExport: xp: t.CPtr = jd2["x"] yp: t.CPtr = jd2["y"] zp: t.CPtr = jd2["z"] - xv: int = c.Deref((int | t.CPtr)(xp)) - yv: int = c.Deref((int | t.CPtr)(yp)) - zv: int = c.Deref((int | t.CPtr)(zp)) + xv: int = *(int | t.CPtr)(xp) + yv: int = *(int | t.CPtr)(yp) + zv: int = *(int | t.CPtr)(zp) stdio.printf("loads: x=%d y=%d z=%d\n", xv, yv, zv) testcheck.check(xv == 1, "loads x OK", "loads x FAILED") testcheck.check(yv == 2, "loads y OK", "loads y FAILED") @@ -194,8 +194,8 @@ def main() -> CInt | CExport: rt2.loads(pool, rt_str) rta_p: t.CPtr = rt2["a"] rtb_p: t.CPtr = rt2["b"] - rta: int = c.Deref((int | t.CPtr)(rta_p)) - rtb: int = c.Deref((int | t.CPtr)(rtb_p)) + rta: int = *(int | t.CPtr)(rta_p) + rtb: int = *(int | t.CPtr)(rtb_p) stdio.printf("round-trip: a=%d b=%d\n", rta, rtb) testcheck.check(rta == 1, "round-trip a OK", "round-trip a FAILED") testcheck.check(rtb == 2, "round-trip b OK", "round-trip b FAILED") @@ -211,17 +211,17 @@ def main() -> CInt | CExport: sub: dict* = outer["sub"] sa_p: t.CPtr = sub["a"] sb_p: t.CPtr = sub["b"] - sa: int = c.Deref((int | t.CPtr)(sa_p)) - sb: int = c.Deref((int | t.CPtr)(sb_p)) + sa: int = *(int | t.CPtr)(sa_p) + sb: int = *(int | t.CPtr)(sb_p) stdio.printf("nested: sub.a=%d sub.b=%d\n", sa, sb) testcheck.check(sa == 1, "nested sub.a OK", "nested sub.a FAILED") testcheck.check(sb == 2, "nested sub.b OK", "nested sub.b FAILED") # === Test 14: get_vtype 类型标签 === testcheck.section("Test 14: get_vtype 类型标签") - vt1: t.CInt = d.get_vtype("alpha") - vt2: t.CInt = d2.get_vtype("name") - vt3: t.CInt = outer.get_vtype("sub") + vt1: int = d.get_vtype("alpha") + vt2: int = d2.get_vtype("name") + vt3: int = outer.get_vtype("sub") stdio.printf("vtype(alpha)=%d vtype(name)=%d vtype(sub)=%d\n", vt1, vt2, vt3) testcheck.check(vt1 == 1, "vtype int OK", "vtype int FAILED") testcheck.check(vt2 == 4, "vtype str OK", "vtype str FAILED") diff --git a/DocTest/App/main.vp b/DocTest/App/main.vp index 8e25085..5dbf976 100644 --- a/DocTest/App/main.vp +++ b/DocTest/App/main.vp @@ -20,7 +20,7 @@ def no_doc_func() -> int: # 同模块类（有 docstring） class LocalClass: "Local class docstring." - value: t.CInt + value: int def local_method(self) -> int: "Local method docstring." @@ -62,7 +62,7 @@ def test_cross_module_doc(): _check_doc_null("remote.no_doc_func", remote.no_doc_func.__doc__) -def main() -> t.CInt: +def main() -> int: testcheck.begin("DocTest: __doc__ magic string test") test_local_doc() test_cross_module_doc() diff --git a/DocTest/App/remote.vp b/DocTest/App/remote.vp index c466307..295658e 100644 --- a/DocTest/App/remote.vp +++ b/DocTest/App/remote.vp @@ -8,7 +8,7 @@ def remote_func() -> int: class RemoteClass: "Remote class docstring." - value: t.CInt + value: int def remote_method(self) -> int: "Remote method docstring." diff --git a/EdgeCaseTest/App/main.vp b/EdgeCaseTest/App/main.vp index 71508a0..977a363 100644 --- a/EdgeCaseTest/App/main.vp +++ b/EdgeCaseTest/App/main.vp @@ -32,8 +32,8 @@ enum Status: # Test 3: from t import CUnion as un; class X(un) # ============================================================ union Data: - i_val: t.CInt - f_val: t.CFloat + i_val: int + f_val: float # ============================================================ @@ -50,16 +50,16 @@ renum Opt: # （注：检测已修复，但成员继承仍需父类先处理） # ============================================================ class Parent: - a: t.CInt + a: int - def get_a(self) -> t.CInt: + def get_a(self) -> int: return self.a class Child(Parent): - b: t.CInt + b: int - def get_sum(self) -> t.CInt: + def get_sum(self) -> int: return self.a + self.b @@ -67,23 +67,23 @@ class Child(Parent): # Test 6: 多层继承 A -> B -> C，CVTable 向上传播 # ============================================================ class Base: - x: t.CInt + x: int - def base_val(self) -> t.CInt: + def base_val(self) -> int: return self.x class Mid(Base): - y: t.CInt + y: int - def mid_val(self) -> t.CInt: + def mid_val(self) -> int: return self.y class Leaf(Mid): - z: t.CInt + z: int - def leaf_val(self) -> t.CInt: + def leaf_val(self) -> int: return self.z @@ -97,9 +97,9 @@ val: myint = 42 # Test 8: BigEndian 字节序 # ============================================================ class NetHeader: - magic: t.CInt | t.BigEndian + magic: int | t.BigEndian length: t.CShort | t.BigEndian - normal: t.CInt + normal: int # ============================================================ @@ -114,17 +114,17 @@ class NetHeader: # Test 10: import t as tt; class X(tt.CStruct) # ============================================================ class TtPoint: - x: t.CInt - y: t.CInt + x: int + y: int # ============================================================ # Test 11: import t as tt; @tt.Object 装饰器 # ============================================================ class TtObject: - val: t.CInt + val: int - def get_val(self) -> t.CInt: + def get_val(self) -> int: return self.val @@ -132,37 +132,37 @@ class TtObject: # Test 12: from t import CStruct as cs; class X(cs) # ============================================================ class CsPoint: - x: t.CInt - y: t.CInt + x: int + y: int # ============================================================ # Test 13: import t as tt; class X(tt.CUnion) # ============================================================ union TtUnion: - a: t.CInt - b: t.CFloat + a: int + b: float # ============================================================ # Test 14: @tt.Object on class without methods (should fail?) # ============================================================ class TtEmptyObject: - val: t.CInt + val: int -def main() -> t.CInt: +def main() -> int: testcheck.begin("EdgeCaseTest: 类型别名与边界情况测试") # Test 1: CEnum alias testcheck.section("Test 1: CEnum alias") - c: t.CInt = Color.Green + c: int = Color.Green stdio.printf("Test1 CEnum alias: %d\n", c) testcheck.ok("CEnum alias (Color.Green=1)") # Test 2: module alias + CEnum testcheck.section("Test 2: module alias + CEnum") - s: t.CInt = Status.Error + s: int = Status.Error stdio.printf("Test2 t as tt.CEnum: %d\n", s) testcheck.ok("t as tt.CEnum (Status.Error=1)") diff --git a/EnumTest/App/enumtest.vp b/EnumTest/App/enumtest.vp index c935a48..a86d2e4 100644 --- a/EnumTest/App/enumtest.vp +++ b/EnumTest/App/enumtest.vp @@ -20,7 +20,7 @@ class Result(t.REnum): class Ok: value: CInt class Err: - msg: t.CChar | CPtr + msg: char | CPtr class GeoShape(t.REnum): diff --git a/EnumTest/App/main.vp b/EnumTest/App/main.vp index dd8eb58..19ba0ae 100644 --- a/EnumTest/App/main.vp +++ b/EnumTest/App/main.vp @@ -3,7 +3,7 @@ import testcheck import enumtest -def main() -> t.CInt | t.CExport: +def main() -> int | t.CExport: testcheck.begin("EnumTest: 枚举类型测试") testcheck.section("Enum") enumtest.enum_main() diff --git a/ExpandKeywordsTest/App/main.vp b/ExpandKeywordsTest/App/main.vp index dad7438..f9eadab 100644 --- a/ExpandKeywordsTest/App/main.vp +++ b/ExpandKeywordsTest/App/main.vp @@ -10,23 +10,23 @@ import testcheck # ============================================================ # fn: 单参数返回 -fn add_one(x: t.CInt) -> t.CInt: +fn add_one(x: int) -> int: return x + 1 # fun: 双参数返回 -fun add_two(a: t.CInt, b: t.CInt) -> t.CInt: +fun add_two(a: int, b: int) -> int: return a + b # func: 浮点参数返回 -func mul_float(a: t.CDouble, b: t.CDouble) -> t.CDouble: +func mul_float(a: double, b: double) -> double: return a * b # function: 内部用 def 定义再调用（别名与 def 混用） -function get_ten() -> t.CInt: - def inner() -> t.CInt: +function get_ten() -> int: + def inner() -> int: return 10 return inner() @@ -42,15 +42,15 @@ fn noop(): # fun 递归 -fun fact(n: t.CInt) -> t.CInt: +fun fact(n: int) -> int: if n <= 1: return 1 return n * fact(n - 1) # func 多语句 + 局部变量 -func avg3(a: t.CDouble, b: t.CDouble, c: t.CDouble) -> t.CDouble: - total: t.CDouble = a + b + c +func avg3(a: double, b: double, c: double) -> double: + total: double = a + b + c return total / 3.0 # func12344444 avg3(a: t.CDouble, b: t.CDouble, c: t.CDouble) -> t.CDouble: @@ -58,7 +58,7 @@ func avg3(a: t.CDouble, b: t.CDouble, c: t.CDouble) -> t.CDouble: # return total / 3.0 -def main() -> t.CInt: +def main() -> int: testcheck.begin("ExpandKeywordsTest: fn/fun/func/function") testcheck.section("function def keywords") diff --git a/Extern2Test/App/main.vp b/Extern2Test/App/main.vp index 9758b54..33f6209 100644 --- a/Extern2Test/App/main.vp +++ b/Extern2Test/App/main.vp @@ -15,11 +15,11 @@ import testcheck # Test 1: t.CExtern | t.CExport - 外部声明函数（pass 体） # 声明一个外部函数，翻译器应生成 declare 而非 define -def ExternalDecl(x: t.CInt) -> t.CInt | t.CExtern | t.CExport: pass +def ExternalDecl(x: int) -> int | t.CExtern | t.CExport: pass # Test 2: t.State - 状态声明（等价于 CExtern | CExport） -def StateDecl(x: t.CInt) -> t.CInt | t.State: pass +def StateDecl(x: int) -> int | t.State: pass # Test 3: t.State 返回 void @@ -35,7 +35,7 @@ def test_extern_decl(): testcheck.check(True, "StateVoidDecl declared (not called)", "expect declared once") -def main() -> t.CInt: +def main() -> int: testcheck.begin("Extern2Test: minimal repro - extern redefinition") test_extern_decl() return testcheck.end() diff --git a/FakeDuckTest/App/main.vp b/FakeDuckTest/App/main.vp index 7392cd5..f42dc84 100644 --- a/FakeDuckTest/App/main.vp +++ b/FakeDuckTest/App/main.vp @@ -44,7 +44,7 @@ def main() -> CInt | CExport: # 直接字段读取: b.__mbuddy__ (应返回 NULL) b_buddy: memhub.MemBuddy | t.CPtr = b.__mbuddy__ - if t.CInt(b_buddy) == 0: + if int(b_buddy) == 0: stdio.printf("mbuddy OK: b.__mbuddy__ is NULL (no pollution)\n") else: stdio.printf("mbuddy FAIL: b.__mbuddy__ polluted!\n") @@ -109,7 +109,7 @@ def main() -> CInt | CExport: s1: str = "a,b,c" s1.__mbuddy__ = bd parts = s1.split(',') - n1: t.CSizeT = parts.__len__() + n1: sizet = parts.__len__() stdio.printf("split('a,b,c', ',') len=%lu\n", n1) testcheck.check(n1 == 3, "split len OK (3)", "split len FAILED expect 3") p0: str = parts[0] @@ -125,7 +125,7 @@ def main() -> CInt | CExport: s2: str = "hello" s2.__mbuddy__ = bd parts2 = s2.split(',') - n2: t.CSizeT = parts2.__len__() + n2: sizet = parts2.__len__() stdio.printf("split('hello', ',') len=%lu\n", n2) testcheck.check(n2 == 1, "no-delim len OK (1)", "no-delim len FAILED expect 1") h0: str = parts2.get(0) @@ -136,7 +136,7 @@ def main() -> CInt | CExport: s3: str = "a,,b" s3.__mbuddy__ = bd parts3 = s3.split(',') - n3: t.CSizeT = parts3.__len__() + n3: sizet = parts3.__len__() stdio.printf("split('a,,b', ',') len=%lu\n", n3) testcheck.check(n3 == 3, "consecutive len OK (3)", "consecutive len FAILED expect 3") e0: str = parts3.get(0) @@ -152,7 +152,7 @@ def main() -> CInt | CExport: s4: str = "" s4.__mbuddy__ = bd parts4 = s4.split(',') - n4: t.CSizeT = parts4.__len__() + n4: sizet = parts4.__len__() stdio.printf("split('', ',') len=%lu\n", n4) testcheck.check(n4 == 1, "empty len OK (1)", "empty len FAILED expect 1") @@ -161,7 +161,7 @@ def main() -> CInt | CExport: s5: str = "hello world foo" s5.__mbuddy__ = bd parts5 = s5.split(' ') - n5: t.CSizeT = parts5.__len__() + n5: sizet = parts5.__len__() stdio.printf("split('hello world foo', ' ') len=%lu\n", n5) testcheck.check(n5 == 3, "space len OK (3)", "space len FAILED expect 3") w0: str = parts5[0] @@ -177,7 +177,7 @@ def main() -> CInt | CExport: s6: str = "a::b::c" s6.__mbuddy__ = bd parts6 = s6.split("::") - n6: t.CSizeT = parts6.__len__() + n6: sizet = parts6.__len__() stdio.printf("split('a::b::c', '::') len=%lu\n", n6) testcheck.check(n6 == 3, "multi-colon len OK (3)", "multi-colon len FAILED expect 3") m0: str = parts6[0] @@ -193,7 +193,7 @@ def main() -> CInt | CExport: s7: str = "hello, world, foo" s7.__mbuddy__ = bd parts7 = s7.split(", ") - n7: t.CSizeT = parts7.__len__() + n7: sizet = parts7.__len__() stdio.printf("split('hello, world, foo', ', ') len=%lu\n", n7) testcheck.check(n7 == 3, "comma-space len OK (3)", "comma-space len FAILED expect 3") cs0: str = parts7[0] @@ -209,7 +209,7 @@ def main() -> CInt | CExport: s8: str = "::a::b::" s8.__mbuddy__ = bd parts8 = s8.split("::") - n8: t.CSizeT = parts8.__len__() + n8: sizet = parts8.__len__() stdio.printf("split('::a::b::', '::') len=%lu\n", n8) testcheck.check(n8 == 4, "edge len OK (4)", "edge len FAILED expect 4") ed0: str = parts8[0] @@ -232,7 +232,7 @@ def main() -> CInt | CExport: # 验证 __mbuddy__ 已自动注入（非 NULL） w_buddy: memhub.MemBuddy | t.CPtr = w_str.__mbuddy__ - testcheck.check(t.CInt(w_buddy) != 0, "with inject OK: __mbuddy__ auto-injected", "with inject FAIL: __mbuddy__ is NULL") + testcheck.check(int(w_buddy) != 0, "with inject OK: __mbuddy__ auto-injected", "with inject FAIL: __mbuddy__ is NULL") # upper() 不需要手动设置 __mbuddy__ w_upper: str = w_str.upper() @@ -247,14 +247,14 @@ def main() -> CInt | CExport: # split() 不需要手动设置 __mbuddy__ w_split_str: str = "x,y,z" w_parts = w_split_str.split(',') - w_n: t.CSizeT = len(w_parts) + w_n: sizet = len(w_parts) stdio.printf("with split('x,y,z') len=%lu\n", w_n) testcheck.check(w_n == 3, "with split len OK (3)", "with split len FAILED") # 验证多个 str 变量都获得注入 w_str2: str = "Multiple" w_buddy2: memhub.MemBuddy | t.CPtr = w_str2.__mbuddy__ - testcheck.check(t.CInt(w_buddy2) != 0, "with multi inject OK", "with multi inject FAIL") + testcheck.check(int(w_buddy2) != 0, "with multi inject OK", "with multi inject FAIL") test_s: str = "www.gvsds.com" list_s: list[str] | t.CPtr = test_s.split('.') diff --git a/FileIoTest/App/fileiotest.vp b/FileIoTest/App/fileiotest.vp index 98d6e77..a0d3d7d 100644 --- a/FileIoTest/App/fileiotest.vp +++ b/FileIoTest/App/fileiotest.vp @@ -10,7 +10,7 @@ import w32.fileio from w32.fileio import File, FileW, MODE, FRESULT, SEEK_SET, SEEK_CUR, SEEK_END -BUF_SIZE: t.CDefine = 4096 +define BUF_SIZE = 4096 def fileio_main(): @@ -42,13 +42,13 @@ def fileio_main(): i: CInt = 0 ch: bytes = write_buf while i < BUF_SIZE: - if CInt(c.Deref(ch)) == 0: + if CInt(*ch) == 0: break write_len = write_len + 1 i = i + 1 ch = ch + 1 - result: BOOL = w32.win32file.WriteFile(hFile, write_buf, write_len, c.Addr(bytes_written), None) + result: BOOL = w32.win32file.WriteFile(hFile, write_buf, write_len, &bytes_written, None) if result == 0: print("WriteFile failed") else: @@ -73,7 +73,7 @@ def fileio_main(): return read_len: ULONG = 0 - result = w32.win32file.ReadFile(hFile, read_buf, BUF_SIZE - 1, c.Addr(read_len), None) + result = w32.win32file.ReadFile(hFile, read_buf, BUF_SIZE - 1, &read_len, None) if result == 0: print("ReadFile failed") else: @@ -335,7 +335,7 @@ def fileio_chinese_test(): print("[chinese] T2: create failed") else: # u"你好世界\n" = 5 WCHARs = 10 bytes (UTF-16LE) - w32.win32file.WriteFile(fw2.handle, u"你好世界\n", 10, c.Addr(bytes_written), None) + w32.win32file.WriteFile(fw2.handle, u"你好世界\n", 10, &bytes_written, None) viperlib.snprintf(buf, 256, "[chinese] T2: wrote %d WCHAR bytes", bytes_written) print(buf) fw2.close() @@ -357,7 +357,7 @@ def fileio_chinese_test(): else: fw3.write_str("ASCII line\n") # u"中文行\n" = 4 WCHARs = 8 bytes (UTF-16LE) - w32.win32file.WriteFile(fw3.handle, u"中文行\n", 8, c.Addr(bytes_written), None) + w32.win32file.WriteFile(fw3.handle, u"中文行\n", 8, &bytes_written, None) fw3.seek(0, SEEK_SET) n: LONG = fw3.read_all(buf, 512) viperlib.snprintf(buf, 256, "[chinese] T3: total %d bytes", n) @@ -374,7 +374,7 @@ def fileio_chinese_test(): print("[chinese] T4: create failed") else: # u"你好，世界！\n" = 7 WCHARs = 14 bytes (UTF-16LE) - w32.win32file.WriteFile(fw4.handle, u"你好，世界！\n", 14, c.Addr(bytes_written), None) + w32.win32file.WriteFile(fw4.handle, u"你好，世界！\n", 14, &bytes_written, None) viperlib.snprintf(buf, 256, "[chinese] T4: wrote %d WCHAR bytes", bytes_written) print(buf) fw4.close() @@ -386,7 +386,7 @@ def fileio_chinese_test(): # Print wide content to console using WriteConsoleW chars_written: ULONG = 0 hOut: w32.win32base.HANDLE = w32.win32file.GetStdHandle(w32.win32file.STD_OUTPUT_HANDLE) - w32.win32console.WriteConsoleW(hOut, u"你好，世界！\n", 7, c.Addr(chars_written), None) + w32.win32console.WriteConsoleW(hOut, u"你好，世界！\n", 7, &chars_written, None) fr4.close() w32.win32file.DeleteFileW(u"控制台测试.txt") diff --git a/FileIoTest/App/main.vp b/FileIoTest/App/main.vp index 6394d79..5e0d92f 100644 --- a/FileIoTest/App/main.vp +++ b/FileIoTest/App/main.vp @@ -3,7 +3,7 @@ import testcheck import fileiotest -def main() -> t.CInt | t.CExport: +def main() -> int | t.CExport: testcheck.begin("FileIoTest: Win32 FileIO 测试") testcheck.section("Win32 FileIO") fileiotest.fileio_main() diff --git a/ForAndLoopTest/App/main.vp b/ForAndLoopTest/App/main.vp index 31d935b..83491d7 100644 --- a/ForAndLoopTest/App/main.vp +++ b/ForAndLoopTest/App/main.vp @@ -9,7 +9,7 @@ import testcheck def test_for_in_range(): testcheck.section("Test 1: for i in range(n)") - s: t.CInt = 0 + s: int = 0 for i in range(10): s += i testcheck.check(s == 45, "range sum OK (45)", "range sum FAILED expect 45") @@ -17,7 +17,7 @@ def test_for_in_range(): def test_for_in_str(): testcheck.section("Test 2: for ch in str") - cnt: t.CInt = 0 + cnt: int = 0 for ch in "hello": cnt += 1 testcheck.check(cnt == 5, "str iter OK (5)", "str iter FAILED expect 5") @@ -32,7 +32,7 @@ def test_for_in_list(): lst.append("y") lst.append("z") lst.append("w") - total: t.CInt = 0 + total: int = 0 for v in lst: total += 1 testcheck.check(total == 4, "list iter OK (4)", "list iter FAILED expect 4") @@ -51,7 +51,7 @@ def test_zip_list_list(): lb.append("1") lb.append("2") lb.append("3") - cnt: t.CInt = 0 + cnt: int = 0 for ca, cb in zip(la, lb): stdio.printf("zip[%d]: '%s'='%s'\n", cnt, ca, cb) cnt += 1 @@ -67,7 +67,7 @@ def test_zip_range_list(): lst.append("p") lst.append("q") lst.append("r") - cnt: t.CInt = 0 + cnt: int = 0 for n, v in zip(range(3), lst): stdio.printf("zip range+list[%d]: %d='%s'\n", cnt, n, v) cnt += 1 @@ -79,7 +79,7 @@ def test_zip_str_str(): testcheck.section("Test 6: zip(str, str)") sa: str = "abc" sb: str = "123" - cnt: t.CInt = 0 + cnt: int = 0 for ca, cb in zip(sa, sb): stdio.printf("zip str+str[%d]: '%c'%c\n", cnt, ca, cb) cnt += 1 @@ -94,7 +94,7 @@ def test_zip_range_len_list(): lst.append("www") lst.append("gvsds") lst.append("com") - cnt: t.CInt = 0 + cnt: int = 0 for idx, v in zip(range(len(lst)), lst): stdio.printf("lst[%d]='%s'\n", idx, v) cnt += 1 @@ -110,8 +110,8 @@ def test_enumerate_list(): lst.append("alpha") lst.append("beta") lst.append("gamma") - cnt: t.CInt = 0 - last_idx: t.CInt = -1 + cnt: int = 0 + last_idx: int = -1 for idx, v in enumerate(lst): stdio.printf("enum[%d]='%s'\n", idx, v) last_idx = idx @@ -123,8 +123,8 @@ def test_enumerate_list(): def test_enumerate_str(): testcheck.section("Test 9: enumerate(str)") - cnt: t.CInt = 0 - last_idx: t.CInt = -1 + cnt: int = 0 + last_idx: int = -1 for idx, ch in enumerate("ABCD"): stdio.printf("enum str[%d]='%c'\n", idx, ch) last_idx = idx @@ -135,9 +135,9 @@ def test_enumerate_str(): def test_enumerate_range(): testcheck.section("Test 10: enumerate(range)") - cnt: t.CInt = 0 - last_idx: t.CInt = -1 - last_val: t.CInt = -1 + cnt: int = 0 + last_idx: int = -1 + last_val: int = -1 for idx, v in enumerate(range(5)): stdio.printf("enum range[%d]=%d\n", idx, v) last_idx = idx @@ -150,7 +150,7 @@ def test_enumerate_range(): def test_for_else_no_break(): testcheck.section("Test 11: for-else (迭代耗尽 → 执行 else)") - total: t.CInt = 0 + total: int = 0 for i in range(3): total += i else: @@ -160,7 +160,7 @@ def test_for_else_no_break(): def test_for_else_break(): testcheck.section("Test 12: for-else (break → 跳过 else)") - found: t.CInt = 0 + found: int = 0 for i in range(10): if i == 4: found = 1 @@ -172,7 +172,7 @@ def test_for_else_break(): def test_for_else_empty_range(): testcheck.section("Test 13: for-else (range(0) 空迭代 → 执行 else)") - v: t.CInt = 0 + v: int = 0 for i in range(0): v = 1 else: @@ -188,8 +188,8 @@ def test_for_else_list(): lst.append("a") lst.append("b") lst.append("c") - cnt: t.CInt = 0 - ran_else: t.CInt = 0 + cnt: int = 0 + ran_else: int = 0 for v in lst: cnt += 1 else: @@ -201,8 +201,8 @@ def test_for_else_list(): def test_while_else_cond_false(): testcheck.section("Test 15: while-else (条件变假 → 执行 else)") - i: t.CInt = 0 - acc: t.CInt = 0 + i: int = 0 + acc: int = 0 while i < 3: acc += i i += 1 @@ -213,7 +213,7 @@ def test_while_else_cond_false(): def test_while_else_zero_iter(): testcheck.section("Test 16: while-else (一次都不进循环 → 执行 else)") - n: t.CInt = 0 + n: int = 0 while n < 0: n = 99 else: @@ -223,8 +223,8 @@ def test_while_else_zero_iter(): def test_while_else_break(): testcheck.section("Test 17: while-else (break → 跳过 else)") - i: t.CInt = 0 - flag: t.CInt = 0 + i: int = 0 + flag: int = 0 while i < 10: if i == 2: flag = 1 @@ -235,7 +235,7 @@ def test_while_else_break(): testcheck.check(flag == 1, "while-else break OK (1)", "while-else break FAILED expect 1") -def main() -> t.CInt: +def main() -> int: testcheck.begin("ForAndLoopTest: 迭代器与循环测试") test_for_in_range() diff --git a/FormatStringTest/App/main.vp b/FormatStringTest/App/main.vp index 2ff8464..5eb62e4 100644 --- a/FormatStringTest/App/main.vp +++ b/FormatStringTest/App/main.vp @@ -39,7 +39,7 @@ export def main() -> int: # c.Addr(s) 取的是局部变量 s（str = i8*）的地址，结果是 i8**（char**）； # 与 INTPTR（= t.CInt | t.CPtr，int*，见 includes/stdint.vp）层数与基座都不同， # 且指针隐式转换已收紧（层数必须相同）⇒ 注解按实际类型写 str | t.CPtr（= i8**）。 - ptr_var: str | t.CPtr = c.Addr(s) + ptr_var: str | t.CPtr = &s val_var: int = 42 if c.CIf(ctraits.isptr(ptr_var)): print("ptr_var is pointer") diff --git a/G3/App/main.vp b/G3/App/main.vp index 95a4558..683518d 100644 --- a/G3/App/main.vp +++ b/G3/App/main.vp @@ -11,7 +11,7 @@ from linkedlist import GSListNode @t.NoVTable class Node(GSListNode[Node]): - value: t.CInt + value: int def __init__(self): self.value = 0 @@ -33,7 +33,7 @@ def test_node_next_field(): n2.value = 20 n1.Next = n2 next_node: Node = n1.Next - v: t.CInt = next_node.value + v: int = next_node.value testcheck.check(v == 20, "n1.Next.value = 20", "expect 20") @@ -47,7 +47,7 @@ def test_node_chain(): c.value = 3 a.Next = b b.Next = c - sum: t.CInt = a.value + sum: int = a.value p: Node = a.Next sum = sum + p.value p = p.Next @@ -55,7 +55,7 @@ def test_node_chain(): testcheck.check(sum == 6, "chain sum = 1+2+3 = 6", "expect 6") -def main() -> t.CInt: +def main() -> int: testcheck.begin("G3: GSListNode inheritance (F-bounded polymorphism)") test_node_create() test_node_next_field() diff --git a/G4/App/caller1.vp b/G4/App/caller1.vp index ac3b435..f988a4a 100644 --- a/G4/App/caller1.vp +++ b/G4/App/caller1.vp @@ -29,11 +29,11 @@ def caller1_make_chain(pool: memhub.MemBuddy | t.CPtr) -> G4Node | t.CPtr: return a -def caller1_sum_chain(head: G4Node | t.CPtr) -> t.CInt: +def caller1_sum_chain(head: G4Node | t.CPtr) -> int: """遍历链表求和，直接访问 Next 字段""" if head is None: return 0 - total: t.CInt = head.IntVal + total: int = head.IntVal cur: G4Node | t.CPtr = head # 直接访问 Next 字段（不通过 g4node_get_next 访问器） while cur.Next is not None: diff --git a/G4/App/caller2.vp b/G4/App/caller2.vp index d2f2ccb..9c73cbf 100644 --- a/G4/App/caller2.vp +++ b/G4/App/caller2.vp @@ -26,9 +26,9 @@ def caller2_reverse_chain(head: G4Node | t.CPtr) -> G4Node | t.CPtr: return prev -def caller2_count_nodes(head: G4Node | t.CPtr) -> t.CInt: +def caller2_count_nodes(head: G4Node | t.CPtr) -> int: """计算链表节点数""" - count: t.CInt = 0 + count: int = 0 cur: G4Node | t.CPtr = head while cur is not None: count = count + 1 diff --git a/G4/App/main.vp b/G4/App/main.vp index 696b2e3..af27990 100644 --- a/G4/App/main.vp +++ b/G4/App/main.vp @@ -30,7 +30,7 @@ def test_g4node_create(): testcheck.check(False, "new_g4node", "FAIL") return n.IntVal = 42 - v: t.CInt = n.IntVal + v: int = n.IntVal testcheck.check(v == 42, "G4Node.IntVal = 42", "expect 42") @@ -53,7 +53,7 @@ def test_g4node_next_field(): if next_node is None: testcheck.check(False, "g4node_get_next", "FAIL") return - v: t.CInt = next_node.IntVal + v: int = next_node.IntVal testcheck.check(v == 20, "n1.Next.IntVal = 20", "expect 20") @@ -75,7 +75,7 @@ def test_g4node_chain(): c.IntVal = 3 g4node_set_next(a, b) g4node_set_next(b, c) - sum: t.CInt = a.IntVal + sum: int = a.IntVal p: G4Node | t.CPtr = g4node_get_next(a) sum = sum + p.IntVal p = g4node_get_next(p) @@ -95,7 +95,7 @@ def test_caller1_direct_access(): if head is None: testcheck.check(False, "caller1_make_chain", "FAIL") return - total: t.CInt = caller1.caller1_sum_chain(head) + total: int = caller1.caller1_sum_chain(head) stdio.printf("caller1 chain total = %d\n", total) testcheck.check(total == 600, "caller1 sum = 100+200+300 = 600", "expect 600") @@ -112,9 +112,9 @@ def test_caller2_reverse(): if head is None: testcheck.check(False, "caller1_make_chain", "FAIL") return - count_before: t.CInt = caller2.caller2_count_nodes(head) + count_before: int = caller2.caller2_count_nodes(head) reversed_head: G4Node | t.CPtr = caller2.caller2_reverse_chain(head) - count_after: t.CInt = caller2.caller2_count_nodes(reversed_head) + count_after: int = caller2.caller2_count_nodes(reversed_head) stdio.printf("caller2 count before=%d after=%d\n", count_before, count_after) testcheck.check(count_before == 3 and count_after == 3, "caller2 reverse count OK (3,3)", "caller2 count mismatch") @@ -138,12 +138,12 @@ def test_caller3_append(): return extra.IntVal = 400 head = caller3.caller3_append(head, extra) - total: t.CInt = caller1.caller1_sum_chain(head) + total: int = caller1.caller1_sum_chain(head) stdio.printf("caller3 after append total = %d\n", total) testcheck.check(total == 1000, "caller3 append sum = 600+400 = 1000", "expect 1000") -def main() -> t.CInt: +def main() -> int: testcheck.begin("G4: GSListNode inheritance from includes (Phase1 path)") test_g4node_create() test_g4node_next_field() diff --git a/G4/includes/g4node.vp b/G4/includes/g4node.vp index bfd83e1..1db9b50 100644 --- a/G4/includes/g4node.vp +++ b/G4/includes/g4node.vp @@ -19,9 +19,9 @@ import memhub class G4Node(GSListNode[G4Node]): Ty: t.CPtr # 模拟 Value.Ty Name: t.CPtr # 模拟 Value.Name - IsConst: t.CInt # 模拟 Value.IsConst - IntVal: t.CInt64T # 模拟 Value.IntVal - FloatVal: t.CDouble # 模拟 Value.FloatVal + IsConst: int # 模拟 Value.IsConst + IntVal: int64 # 模拟 Value.IntVal + FloatVal: double # 模拟 Value.FloatVal def __init__(self): self.Ty = None diff --git a/G5/App/main.vp b/G5/App/main.vp index 5e247ad..7668d70 100644 --- a/G5/App/main.vp +++ b/G5/App/main.vp @@ -18,7 +18,7 @@ from linkedlist import GSListNode, GSList # G5Node: 继承 GSListNode[G5Node]（Phase2 路径，正确特化） @t.NoVTable class G5Node(GSListNode[G5Node]): - Value: t.CInt + Value: int def __init__(self): self.Next = None @@ -28,7 +28,7 @@ class G5Node(GSListNode[G5Node]): # G5ListWrapper: 包装 GSList[G5Node]，测试 GSList 字段访问 # 注意：GSList[G5Node] 走 Phase2 特化路径 # 用 pool 工厂函数分配 GSList，避免栈分配悬垂指针 -GSLIST_SIZE: t.CDefine = 24 # Head(8) + Tail(8) + Count(8) +define GSLIST_SIZE = 24 # Head(8) + Tail(8) + Count(8) @t.NoVTable class G5ListWrapper: @@ -51,7 +51,7 @@ def test_g5node_create(): testcheck.section("Test 1: G5Node create and field access") n: G5Node = G5Node() n.Value = 42 - v: t.CInt = n.Value + v: int = n.Value testcheck.check(v == 42, "G5Node.Value = 42", "expect 42") @@ -66,7 +66,7 @@ def test_g5node_next(): if next_node is None: testcheck.check(False, "n1.Next is None", "FAIL") return - v: t.CInt = next_node.Value + v: int = next_node.Value testcheck.check(v == 20, "n1.Next.Value = 20", "expect 20") @@ -83,7 +83,7 @@ def test_gslist_create(): # 检查初始状态 head: G5Node | t.CPtr = lst.Head tail: G5Node | t.CPtr = lst.Tail - count: t.CSizeT = lst.Count + count: sizet = lst.Count testcheck.check(head is None, "initial Head is None", "expect None") testcheck.check(tail is None, "initial Tail is None", "expect None") testcheck.check(count == 0, "initial Count = 0", "expect 0") @@ -107,7 +107,7 @@ def test_gslist_append(): lst.append(c) # 验证 Count - count: t.CSizeT = lst.Count + count: sizet = lst.Count testcheck.check(count == 3, "Count = 3 after 3 appends", "expect 3") # 验证 Head @@ -125,7 +125,7 @@ def test_gslist_append(): testcheck.check(tail.Value == 3, "Tail.Value = 3", "expect 3") # 遍历链表验证顺序 - sum: t.CInt = 0 + sum: int = 0 cur: G5Node | t.CPtr = lst.Head while cur is not None: sum = sum + cur.Value @@ -161,12 +161,12 @@ def test_wrapper_list_field(): if head is None: testcheck.check(False, "wrapper.List.Head is None", "FAIL") return - count: t.CSizeT = wrapper.List.Count + count: sizet = wrapper.List.Count testcheck.check(head.Value == 999, "wrapper.List.Head.Value = 999", "expect 999") testcheck.check(count == 1, "wrapper.List.Count = 1", "expect 1") -def main() -> t.CInt: +def main() -> int: testcheck.begin("G5: GSList[T] field access (Phase2 path, pool alloc for wrapper)") test_g5node_create() test_g5node_next() diff --git a/G5/includes/g5container.vp b/G5/includes/g5container.vp index 90534a9..4fe8c58 100644 --- a/G5/includes/g5container.vp +++ b/G5/includes/g5container.vp @@ -15,7 +15,7 @@ import memhub @t.NoVTable class G5Node(GSListNode[G5Node]): - Value: t.CInt + Value: int # ============================================================ @@ -40,7 +40,7 @@ class G5Container: # ============================================================ # G5Node 硬编码大小: Next(8) + Value(4) + padding(4) = 16 字节 -G5NODE_SIZE: t.CDefine = 16 +define G5NODE_SIZE = 16 def new_g5node(pool: memhub.MemBuddy | t.CPtr) -> G5Node | t.CPtr: """从 pool 分配并零初始化一个 G5Node""" @@ -51,7 +51,7 @@ def new_g5node(pool: memhub.MemBuddy | t.CPtr) -> G5Node | t.CPtr: # GSList 硬编码大小: Head(8) + Tail(8) + Count(8) = 24 字节 -G5LIST_SIZE: t.CDefine = 24 +define G5LIST_SIZE = 24 def new_g5list(pool: memhub.MemBuddy | t.CPtr) -> GSList[G5Node] | t.CPtr: """从 pool 分配并零初始化一个 GSList 容器（Head/Tail/Count 全零）""" @@ -62,7 +62,7 @@ def new_g5list(pool: memhub.MemBuddy | t.CPtr) -> GSList[G5Node] | t.CPtr: # G5Container 硬编码大小: List(8) = 8 字节 -G5CONTAINER_SIZE: t.CDefine = 8 +define G5CONTAINER_SIZE = 8 def new_g5container(pool: memhub.MemBuddy | t.CPtr) -> G5Container | t.CPtr: """从 pool 分配并零初始化一个 G5Container""" @@ -95,7 +95,7 @@ def g5list_get_tail(lst: GSList[G5Node] | t.CPtr) -> G5Node | t.CPtr: return lst.Tail -def g5list_get_count(lst: GSList[G5Node] | t.CPtr) -> t.CSizeT: +def g5list_get_count(lst: GSList[G5Node] | t.CPtr) -> sizet: """获取链表节点数""" if lst is None: return 0 return lst.Count @@ -113,7 +113,7 @@ def g5list_set_tail(lst: GSList[G5Node] | t.CPtr, node: G5Node | t.CPtr): lst.Tail = node -def g5list_set_count(lst: GSList[G5Node] | t.CPtr, count: t.CSizeT): +def g5list_set_count(lst: GSList[G5Node] | t.CPtr, count: sizet): """设置链表节点数""" if lst is None: return lst.Count = count @@ -139,12 +139,12 @@ def g5list_append(lst: GSList[G5Node] | t.CPtr, node: G5Node | t.CPtr): # G5Node 访问器 # ============================================================ -def g5node_get_value(node: G5Node | t.CPtr) -> t.CInt: +def g5node_get_value(node: G5Node | t.CPtr) -> int: if node is None: return 0 return node.Value -def g5node_set_value(node: G5Node | t.CPtr, value: t.CInt): +def g5node_set_value(node: G5Node | t.CPtr, value: int): if node is None: return node.Value = value diff --git a/G6/App/main.vp b/G6/App/main.vp index e93b5fc..773b4bd 100644 --- a/G6/App/main.vp +++ b/G6/App/main.vp @@ -15,21 +15,21 @@ import atom def test_atomic_test_and_set(): testcheck.section("Test 1: __atomic_test_and_set") - flag: t.CUInt8T = 0 - result: t.CBool = atom.__atomic_test_and_set(c.Addr(flag), atom.ATOMIC_ACQUIRE) + flag: uint8 = 0 + result: bool = atom.__atomic_test_and_set(&flag, atom.ATOMIC_ACQUIRE) # test_and_set 返回旧值: flag=0 -> 返回 0, flag 变为 1 - testcheck.check(result == t.CBool(0), "first set returns old value 0", "expect 0") + testcheck.check(result == bool(0), "first set returns old value 0", "expect 0") testcheck.check(flag == 1, "flag is 1 after set", "expect 1") # 第二次设置应返回 1（旧值已为 1） - result2: t.CBool = atom.__atomic_test_and_set(c.Addr(flag), atom.ATOMIC_ACQUIRE) - testcheck.check(result2 == t.CBool(1), "second set returns old value 1", "expect 1") + result2: bool = atom.__atomic_test_and_set(&flag, atom.ATOMIC_ACQUIRE) + testcheck.check(result2 == bool(1), "second set returns old value 1", "expect 1") def test_atomic_clear(): testcheck.section("Test 2: __atomic_clear") - flag: t.CUInt8T = 1 - atom.__atomic_clear(c.Addr(flag), atom.ATOMIC_RELEASE) + flag: uint8 = 1 + atom.__atomic_clear(&flag, atom.ATOMIC_RELEASE) testcheck.check(flag == 0, "flag is 0 after clear", "expect 0") @@ -42,26 +42,26 @@ def test_atomic_thread_fence(): def test_atomic_lock_free(): testcheck.section("Test 4: __atomic_is_lock_free") - flag: t.CUInt8T = 0 - result: t.CBool = atom.__atomic_is_lock_free(1, c.Addr(flag)) - testcheck.check(result == t.CBool(1), "1-byte is lock free", "expect 1") + flag: uint8 = 0 + result: bool = atom.__atomic_is_lock_free(1, &flag) + testcheck.check(result == bool(1), "1-byte is lock free", "expect 1") def test_atomic_spinlock(): testcheck.section("Test 5: spinlock pattern (test_and_set + clear)") - lock: t.CUInt8T = 0 + lock: uint8 = 0 # 获取锁 - while atom.__atomic_test_and_set(c.Addr(lock), atom.ATOMIC_ACQUIRE) == t.CBool(1): + while atom.__atomic_test_and_set(&lock, atom.ATOMIC_ACQUIRE) == bool(1): pass testcheck.check(lock == 1, "lock acquired", "expect lock=1") # 释放锁 - atom.__atomic_clear(c.Addr(lock), atom.ATOMIC_RELEASE) + atom.__atomic_clear(&lock, atom.ATOMIC_RELEASE) testcheck.check(lock == 0, "lock released", "expect lock=0") -def main() -> t.CInt: +def main() -> int: testcheck.begin("G6: atom module (inline asm atomic operations)") test_atomic_test_and_set() test_atomic_clear() diff --git a/G7/App/main.vp b/G7/App/main.vp index 96ec41d..e1034e2 100644 --- a/G7/App/main.vp +++ b/G7/App/main.vp @@ -38,15 +38,15 @@ def test_value_struct_fields(): node.IntVal = 42 node.FloatVal = 3.14 # 读取验证 - v: t.CInt = node.IntVal + v: int = node.IntVal testcheck.check(v == 42, "Value.IntVal = 42", "expect 42") - f: t.CDouble = node.FloatVal + f: double = node.FloatVal testcheck.check(f > 3.0 and f < 4.0, "Value.FloatVal = 3.14", "expect ~3.14") - c: t.CInt = node.IsConst + c: int = node.IsConst testcheck.check(c == 1, "Value.IsConst = 1", "expect 1") -def main() -> t.CInt: +def main() -> int: testcheck.begin("G7: Minimal repro - class name 'Value' conflicts with variable") test_value_struct_fields() return testcheck.end() diff --git a/G7/includes/conflict_node.vp b/G7/includes/conflict_node.vp index 3dd6917..9389a3c 100644 --- a/G7/includes/conflict_node.vp +++ b/G7/includes/conflict_node.vp @@ -17,9 +17,9 @@ from linkedlist import GSListNode class Value(GSListNode[Value]): Ty: t.CPtr Name: t.CPtr - IsConst: t.CInt - IntVal: t.CInt64T - FloatVal: t.CDouble + IsConst: int + IntVal: int64 + FloatVal: double def __init__(self): self.Ty = None diff --git a/GenericOopTest/App/main.vp b/GenericOopTest/App/main.vp index 307b858..b26d258 100644 --- a/GenericOopTest/App/main.vp +++ b/GenericOopTest/App/main.vp @@ -119,15 +119,15 @@ def main() -> CInt | CExport: # === 新语法类型强转 (t1|t2)(x) === testcheck.section("新语法类型强转 (t1|t2)(x)") val_i64: CUInt64T = CUInt64T(42) - val_i32 = (t.CInt)(val_i64) + val_i32 = (int)(val_i64) print(val_i32) ptr_raw = stdlib.malloc(8) - ptr_typed = (t.CInt | t.CPtr)(ptr_raw) + ptr_typed = (int | t.CPtr)(ptr_raw) viperlib.snprintf(buf, 256, "cast ptr=%p", ptr_typed) print(buf) - val_f = (t.CDouble)(42) + val_f = (double)(42) viperlib.snprintf(buf, 256, "cast float=%.1f", val_f) print(buf) testcheck.ok("新语法类型强转测试完成") diff --git a/GenericTest/App/main.vp b/GenericTest/App/main.vp index 0595c27..6e2186f 100644 --- a/GenericTest/App/main.vp +++ b/GenericTest/App/main.vp @@ -10,8 +10,8 @@ def add[T](a: T, b: T) -> T: def test_generic_add(): testcheck.section("Test 1: generic add") - r1: t.CInt = add(3, 5) - r2: t.CInt = add(100, 200) + r1: int = add(3, 5) + r2: int = add(100, 200) testcheck.check(r1 == 8 and r2 == 300, "generic add (3+5=8, 100+200=300)", "generic add expect 8 and 300") # ============================================================ @@ -22,7 +22,7 @@ def combine[T1, T2](a: T1, b: T2) -> T1: def test_generic_combine(): testcheck.section("Test 2: generic combine") - r: t.CInt = combine(10, 20) + r: int = combine(10, 20) testcheck.check(r == 30, "generic combine (10+T1(20)=30)", "generic combine expect 30") # ============================================================ @@ -35,8 +35,8 @@ def max_val[T](a: T, b: T) -> T: def test_generic_max(): testcheck.section("Test 3: generic max") - r1: t.CInt = max_val(10, 20) - r2: t.CInt = max_val(50, 30) + r1: int = max_val(10, 20) + r2: int = max_val(50, 30) testcheck.check(r1 == 20 and r2 == 50, "generic max (max(10,20)=20, max(50,30)=50)", "generic max expect 20 and 50") # ============================================================ @@ -57,7 +57,7 @@ class Box[T](): def test_generic_box(): testcheck.section("Test 4: generic Box[T]") b = Box(42) - v: t.CInt = b.get() + v: int = b.get() testcheck.check(v == 42, "Box[int] (get=42)", "Box[int] expect 42") # ============================================================ @@ -71,13 +71,13 @@ class Pair[T1, T2](): self.first = T1(a) self.second = T2(b) - def sum_as_int(self) -> t.CInt: - return t.CInt(self.first) + t.CInt(self.second) + def sum_as_int(self) -> int: + return int(self.first) + int(self.second) def test_generic_pair(): testcheck.section("Test 5: generic Pair[T1,T2]") p = Pair(10, 20) - r: t.CInt = p.sum_as_int() + r: int = p.sum_as_int() testcheck.check(r == 30, "Pair[int,int] (sum=30)", "Pair[int,int] expect 30") # ============================================================ @@ -85,10 +85,10 @@ def test_generic_pair(): # ============================================================ def test_fixed_array(): testcheck.section("Test 6: list[T, N] fixed array") - arr: t.CArray[t.CInt, 5] = [0] + arr: t.CArray[int, 5] = [0] for i in range(5): arr[i] = i * 10 - total: t.CInt = 0 + total: int = 0 for i in range(5): total += arr[i] # 0+10+20+30+40 = 100 @@ -99,7 +99,7 @@ def test_fixed_array(): # ============================================================ def test_char_array(): testcheck.section("Test 7: list[t.CChar, N] char array") - buf: t.CArray[t.CChar, 32] = [0] + buf: t.CArray[char, 32] = [0] buf[0] = 72 # H buf[1] = 105 # i buf[2] = 0 @@ -113,8 +113,8 @@ def identity[T](x: T) -> T: def test_generic_identity(): testcheck.section("Test 8: generic identity") - r1: t.CInt = identity(42) - r2: t.CInt = identity(0) + r1: int = identity(42) + r2: int = identity(0) testcheck.check(r1 == 42 and r2 == 0, "identity (42=42, 0=0)", "identity expect 42 and 0") # ============================================================ @@ -125,7 +125,7 @@ def double_val[T](x: T) -> T: def test_generic_nested(): testcheck.section("Test 9: generic nested call") - r: t.CInt = double_val(21) + r: int = double_val(21) testcheck.check(r == 42, "generic nested (double(21)=42)", "generic nested expect 42") # ============================================================ @@ -149,10 +149,10 @@ def test_generic_counter(): c.increment() c.increment() c.increment() - r: t.CInt = c.get_count() + r: int = c.get_count() testcheck.check(r == 3, "Counter[int] (count=3)", "Counter[int] expect 3") -def main() -> t.CInt: +def main() -> int: testcheck.begin("GenericTest: 泛型测试") test_generic_add() test_generic_combine() diff --git a/GenericTest2/App/main.vp b/GenericTest2/App/main.vp index 6298135..962cf7c 100644 --- a/GenericTest2/App/main.vp +++ b/GenericTest2/App/main.vp @@ -11,8 +11,8 @@ def square[T](x: T) -> T: def test_generic_square_types(): testcheck.section("Test 1: generic square with different types") - r1: t.CInt = square(5) - r2: t.CInt = square(10) + r1: int = square(5) + r2: int = square(10) testcheck.check(r1 == 25 and r2 == 100, "square (5^2=25 10^2=100)", "square expect 25 100") # ============================================================ @@ -27,38 +27,38 @@ def clamp[T](val: T, lo: T, hi: T) -> T: def test_generic_clamp(): testcheck.section("Test 2: generic clamp") - r1: t.CInt = clamp(5, 0, 10) - r2: t.CInt = clamp(-3, 0, 10) - r3: t.CInt = clamp(15, 0, 10) + r1: int = clamp(5, 0, 10) + r2: int = clamp(-3, 0, 10) + r3: int = clamp(15, 0, 10) testcheck.check(r1 == 5 and r2 == 0 and r3 == 10, "clamp (5 0 10)", "clamp expect 5 0 10") # ============================================================ # Test 3: 泛型类 - Stack[T] # ============================================================ class Stack[T](): - data: t.CArray[t.CInt, 16] - top: t.CInt + data: t.CArray[int, 16] + top: int def __init__(self): self.top = 0 def push(self, val: T): - self.data[self.top] = t.CInt(val) + self.data[self.top] = int(val) self.top += 1 def pop(self) -> T: self.top -= 1 return T(self.data[self.top]) - def is_empty(self) -> t.CInt: + def is_empty(self) -> int: if self.top == 0: return 1 return 0 - def size_of(self) -> t.CSizeT: + def size_of(self) -> sizet: return self.__sizeof__() - def type_size(self) -> t.CSizeT: + def type_size(self) -> sizet: return Stack[T].__sizeof__() def test_generic_stack(): @@ -69,29 +69,29 @@ def test_generic_stack(): s.push(10) s.push(20) s.push(30) - r1: t.CInt = s.pop() - r2: t.CInt = s.pop() - r3: t.CInt = s.pop() + r1: int = s.pop() + r2: int = s.pop() + r3: int = s.pop() testcheck.check(r1 == 30 and r2 == 20 and r3 == 10, "Stack (pop=30 20 10)", "Stack expect 30 20 10") # ============================================================ # Test 4: 泛型函数 - swap via pointer # ============================================================ class IntPair: - a: t.CInt - b: t.CInt + a: int + b: int def generic_swap(p: IntPair | t.CPtr): - tmp: t.CInt = c.Deref(p).a - c.Deref(p).a = c.Deref(p).b - c.Deref(p).b = tmp + tmp: int = (*p).a + (*p).a = (*p).b + (*p).b = tmp def test_generic_swap(): testcheck.section("Test 4: generic swap via pointer") p: IntPair = IntPair() p.a = 100 p.b = 200 - generic_swap(c.Addr(p)) + generic_swap(&p) testcheck.check(p.a == 200 and p.b == 100, "swap (a=200 b=100)", "swap expect 200 100") # ============================================================ @@ -118,24 +118,24 @@ class Range[T](): def test_generic_range(): testcheck.section("Test 5: generic Range[T]") r = Range(0, 10, 1) # 0+1+2+...+9=45 - s: t.CInt = r.sum_all() + s: int = r.sum_all() testcheck.check(s == 45, "Range sum (0..9=45)", "Range sum expect 45") # ============================================================ # Test 6: 泛型函数 - 数组求和（非泛型数组参数） # ============================================================ -def array_sum(arr: t.CArray[t.CInt, 8], n: t.CInt) -> t.CInt: - result: t.CInt = 0 +def array_sum(arr: t.CArray[int, 8], n: int) -> int: + result: int = 0 for i in range(n): result += arr[i] return result def test_generic_array_sum(): testcheck.section("Test 6: array sum") - arr: t.CArray[t.CInt, 8] = [0] + arr: t.CArray[int, 8] = [0] for i in range(8): arr[i] = (i + 1) * 10 - s: t.CInt = array_sum(arr, 8) + s: int = array_sum(arr, 8) testcheck.check(s == 360, "array sum (360)", "array sum expect 360") # ============================================================ @@ -151,31 +151,31 @@ def max_of_three[T](a: T, b: T, c_val: T) -> T: def test_generic_max_three(): testcheck.section("Test 7: generic max of three") - r1: t.CInt = max_of_three(1, 2, 3) - r2: t.CInt = max_of_three(10, 30, 20) - r3: t.CInt = max_of_three(50, 50, 50) + r1: int = max_of_three(1, 2, 3) + r2: int = max_of_three(10, 30, 20) + r3: int = max_of_three(50, 50, 50) testcheck.check(r1 == 3 and r2 == 30 and r3 == 50, "max3 (3 30 50)", "max3 expect 3 30 50") # ============================================================ # Test 8: 泛型类 - 带方法的容器 # ============================================================ class Container[T](): - values: t.CArray[t.CInt, 8] - size: t.CInt + values: t.CArray[int, 8] + size: int def __init__(self): self.size = 0 def add(self, v: T): - self.values[self.size] = t.CInt(v) + self.values[self.size] = int(v) self.size += 1 - def get(self, idx: t.CInt) -> T: + def get(self, idx: int) -> T: return T(self.values[idx]) - def contains(self, v: T) -> t.CInt: + def contains(self, v: T) -> int: for i in range(self.size): - if self.values[i] == t.CInt(v): + if self.values[i] == int(v): return 1 return 0 @@ -193,9 +193,9 @@ def test_generic_container(): c.add(10) c.add(20) c.add(30) - has20: t.CInt = c.contains(20) - has99: t.CInt = c.contains(99) - total: t.CInt = c.total() + has20: int = c.contains(20) + has99: int = c.contains(99) + total: int = c.total() testcheck.check(has20 == 1 and has99 == 0 and total == 60, "Container (has20=1 has99=0 total=60)", "Container expect 1 0 60") # ============================================================ @@ -211,8 +211,8 @@ def factorial[T](n: T) -> T: def test_generic_factorial(): testcheck.section("Test 9: generic factorial") - r1: t.CInt = factorial(5) - r2: t.CInt = factorial(10) + r1: int = factorial(5) + r2: int = factorial(10) testcheck.check(r1 == 120 and r2 == 3628800, "factorial (5!=120 10!=3628800)", "factorial expect 120 3628800") # ============================================================ @@ -236,7 +236,7 @@ def test_generic_accumulator(): a.add_val(10) a.add_val(20) a.add_val(30) - r: t.CInt = a.get_result() + r: int = a.get_result() testcheck.check(r == 60, "Accumulator (result=60)", "Accumulator expect 60") # ============================================================ @@ -249,15 +249,15 @@ def test_generic_sizeof_bug(): # 同 Test 3：无参构造必须显式标注类型实参；Stack[int] = { [16 x i32], i32 } = 68。 s = Stack[int]() s.push(10) - sz: t.CSizeT = s.__sizeof__() - inner_sz: t.CSizeT = s.size_of() - type_sz: t.CSizeT = s.type_size() + sz: sizet = s.__sizeof__() + inner_sz: sizet = s.size_of() + type_sz: sizet = s.type_size() stdio.printf("Stack[int] obj.__sizeof__() = %lu, self.__sizeof__() = %lu, Stack[T].__sizeof__() = %lu (expect 68)\n", sz, inner_sz, type_sz) testcheck.check(sz == 68, "obj.__sizeof__() == 68 OK", "obj.__sizeof__() FAILED") testcheck.check(inner_sz == 68, "self.__sizeof__() == 68 OK", "self.__sizeof__() FAILED") testcheck.check(type_sz == 68, "Stack[T].__sizeof__() == 68 OK", "Stack[T].__sizeof__() FAILED") -def main() -> t.CInt: +def main() -> int: testcheck.begin("GenericTest2: Advanced Generic Tests") test_generic_square_types() test_generic_clamp() diff --git a/GenericTest3/App/main.vp b/GenericTest3/App/main.vp index 77620af..939d69e 100644 --- a/GenericTest3/App/main.vp +++ b/GenericTest3/App/main.vp @@ -11,7 +11,7 @@ def double[T](x: int) -> int: def test_explicit_type_arg(): testcheck.section("Test 1: explicit type arg xxx[T](x)") - r: t.CInt = double[t.CInt](21) + r: int = double[int](21) testcheck.check(r == 42, "double[t.CInt](21) = 42", "expect 42") # ============================================================ @@ -22,8 +22,8 @@ def identity[T](x: int) -> int: def test_identity_explicit(): testcheck.section("Test 2: identity[T](x)") - r1: t.CInt = identity[t.CInt](10) - r2: t.CInt = identity[t.CInt](20) + r1: int = identity[int](10) + r2: int = identity[int](20) testcheck.check(r1 == 10 and r2 == 20, "identity[t.CInt](10)=10 (20)=20", "expect 10 20") # ============================================================ @@ -34,7 +34,7 @@ def add_one[T](x: T) -> T: def test_add_one_explicit(): testcheck.section("Test 3: add_one[T](x) with T param") - r: t.CInt = add_one[t.CInt](41) + r: int = add_one[int](41) testcheck.check(r == 42, "add_one[t.CInt](41) = 42", "expect 42") # ============================================================ @@ -43,12 +43,12 @@ def test_add_one_explicit(): def test_mixed_inference_explicit(): testcheck.section("Test 4: mixed inference and explicit") # 自动推导 - r1: t.CInt = add_one(99) + r1: int = add_one(99) # 手动传 - r2: t.CInt = add_one[t.CInt](99) + r2: int = add_one[int](99) testcheck.check(r1 == 100 and r2 == 100, "add_one(99)=100 add_one[t.CInt](99)=100", "expect 100 100") -def main() -> t.CInt: +def main() -> int: testcheck.begin("GenericTest3: 手动传类型参数 xxx[T](x)") test_explicit_type_arg() test_identity_explicit() diff --git a/GenericTest4/App/main.vp b/GenericTest4/App/main.vp index e576996..c94670a 100644 --- a/GenericTest4/App/main.vp +++ b/GenericTest4/App/main.vp @@ -19,8 +19,8 @@ class Box[T](): def test_explicit_box(): testcheck.section("Test 1: Box[t.CInt](42)") - b = Box[t.CInt](42) - v: t.CInt = b.get() + b = Box[int](42) + v: int = b.get() testcheck.check(v == 42, "Box[t.CInt](42).get() = 42", "expect 42") # ============================================================ @@ -34,13 +34,13 @@ class Pair[T1, T2](): self.first = T1(a) self.second = T2(b) - def sum_as_int(self) -> t.CInt: - return t.CInt(self.first) + t.CInt(self.second) + def sum_as_int(self) -> int: + return int(self.first) + int(self.second) def test_explicit_pair(): testcheck.section("Test 2: Pair[t.CInt, t.CInt](10, 20)") - p = Pair[t.CInt, t.CInt](10, 20) - r: t.CInt = p.sum_as_int() + p = Pair[int, int](10, 20) + r: int = p.sum_as_int() testcheck.check(r == 30, "Pair[t.CInt,t.CInt](10,20).sum = 30", "expect 30") # ============================================================ @@ -58,11 +58,11 @@ class Wrapper[T](): def test_mixed_generic_class(): testcheck.section("Test 3: mixed explicit and inferred") # 手动传 - w1 = Wrapper[t.CInt](100) + w1 = Wrapper[int](100) # 自动推导 w2 = Wrapper(200) - r1: t.CInt = w1.get() - r2: t.CInt = w2.get() + r1: int = w1.get() + r2: int = w2.get() testcheck.check(r1 == 100 and r2 == 200, "Wrapper[t.CInt](100)=100 Wrapper(200)=200", "expect 100 200") # ============================================================ @@ -82,11 +82,11 @@ class Counter[T](): def test_explicit_counter(): testcheck.section("Test 4: Counter[t.CInt](0) with methods") - c = Counter[t.CInt](0) + c = Counter[int](0) c.increment() c.increment() c.increment() - r: t.CInt = c.get_count() + r: int = c.get_count() testcheck.check(r == 3, "Counter[t.CInt](0) +3 = 3", "expect 3") # ============================================================ @@ -94,12 +94,12 @@ def test_explicit_counter(): # ============================================================ def test_explicit_box_set(): testcheck.section("Test 5: Box[t.CInt] set method") - b = Box[t.CInt](10) + b = Box[int](10) b.set(99) - v: t.CInt = b.get() + v: int = b.get() testcheck.check(v == 99, "Box[t.CInt].set(99) get = 99", "expect 99") -def main() -> t.CInt: +def main() -> int: testcheck.begin("GenericTest4: 泛型结构体手动传类型参数") test_explicit_box() test_explicit_pair() diff --git a/HashLibTest/App/main.vp b/HashLibTest/App/main.vp index ec994d4..892401f 100644 --- a/HashLibTest/App/main.vp +++ b/HashLibTest/App/main.vp @@ -12,17 +12,17 @@ import w32.win32console # ============================================== # 工具函数：打印十六进制哈希串 # ============================================== -def print_hex(buf: t.CUInt8T | t.CPtr, length: t.CInt): +def print_hex(buf: uint8 | t.CPtr, length: int): for i in range(length): stdio.printf("%02x", buf[i]) stdio.printf("\n") -def default_value_test_function(a: t.CInt, b: t.CInt = 1): +def default_value_test_function(a: int, b: int = 1): print(a, b) -def main() -> t.CInt | t.CExport: +def main() -> int | t.CExport: w32.win32console.SetConsoleCP(65001) w32.win32console.SetConsoleOutputCP(65001) @@ -32,7 +32,7 @@ def main() -> t.CInt | t.CExport: testcheck.section("HASHLIB") plain: str = "hello123" - md5_buf: t.CArray[t.CUInt8T, hashlib.MD5_DIGEST_LEN] + md5_buf: t.CArray[uint8, hashlib.MD5_DIGEST_LEN] mctx = hashlib.md5() mctx.update(plain) mctx.final(md5_buf) @@ -40,7 +40,7 @@ def main() -> t.CInt | t.CExport: print_hex(md5_buf, hashlib.MD5_DIGEST_LEN) testcheck.ok("HASHLIB md5 completed") - sha1_buf: t.CArray[t.CUInt8T, hashlib.SHA1_DIGEST_LEN] + sha1_buf: t.CArray[uint8, hashlib.SHA1_DIGEST_LEN] s1ctx = hashlib.sha1() s1ctx.update(plain) s1ctx.final(sha1_buf) @@ -48,7 +48,7 @@ def main() -> t.CInt | t.CExport: print_hex(sha1_buf, hashlib.SHA1_DIGEST_LEN) testcheck.ok("HASHLIB sha1 completed") - sha256_buf: t.CArray[t.CUInt8T, hashlib.SHA256_DIGEST_LEN] + sha256_buf: t.CArray[uint8, hashlib.SHA256_DIGEST_LEN] s2ctx = hashlib.sha256() s2ctx.update(plain) s2ctx.final(sha256_buf) @@ -56,7 +56,7 @@ def main() -> t.CInt | t.CExport: print_hex(sha256_buf, hashlib.SHA256_DIGEST_LEN) testcheck.ok("HASHLIB sha256 completed") - sha512_buf: t.CArray[t.CUInt8T, hashlib.SHA512_DIGEST_LEN] + sha512_buf: t.CArray[uint8, hashlib.SHA512_DIGEST_LEN] s5ctx = hashlib.sha512() s5ctx.update(plain) s5ctx.final(sha512_buf) @@ -69,11 +69,11 @@ def main() -> t.CInt | t.CExport: # ---------- base64 编解码测试 ---------- testcheck.section("BASE64") - b64_out: t.CArray[t.CChar, 256] - b64_dec: t.CArray[t.CUInt8T, 256] + b64_out: t.CArray[char, 256] + b64_dec: t.CArray[uint8, 256] base64.b64encode(plain, b64_out) print("Base64 编码:", b64_out) - dlen: t.CSizeT = base64.b64decode(b64_out, b64_dec) + dlen: sizet = base64.b64decode(b64_out, b64_dec) b64_dec[dlen] = 0 print("Base64 解码:", b64_dec) testcheck.ok("BASE64 encode/decode completed") @@ -82,7 +82,7 @@ def main() -> t.CInt | t.CExport: testcheck.section("BINASCII") binascii.init_binascii() raw: str = "HelloWorld!" - raw_length: t.CInt = 11 + raw_length: int = 11 hex_out: str = binascii.b2a_hex(raw, raw_length) if hex_out: @@ -90,7 +90,7 @@ def main() -> t.CInt | t.CExport: stdlib.free(hex_out) testcheck.ok("BINASCII b2a_hex completed") - crc_val: t.CUnsignedInt = binascii.crc32(raw, raw_length, 0) + crc_val: uint = binascii.crc32(raw, raw_length, 0) stdio.printf("CRC32: %u\n", crc_val) testcheck.ok("BINASCII crc32 completed") @@ -106,7 +106,7 @@ def main() -> t.CInt | t.CExport: stdlib.free(uu_out) testcheck.ok("BINASCII b2a_uu completed") - hqx_in: t.CArray[t.CChar, 4] = ['A', 'B', 'C', '\0'] + hqx_in: t.CArray[char, 4] = ['A', 'B', 'C', '\0'] hqx_crc: t.CUnsignedShort = 0 hqx_out: str unhqx: str @@ -116,7 +116,7 @@ def main() -> t.CInt | t.CExport: stdlib.free(hqx_out); stdlib.free(unhqx) testcheck.ok("BINASCII hqx completed") - adler_val: t.CUnsignedInt = binascii.adler32(raw, raw_length, 1) + adler_val: uint = binascii.adler32(raw, raw_length, 1) stdio.printf("Adler32: %u\n", adler_val) testcheck.ok("BINASCII adler32 completed") diff --git a/HashTableTest/App/main.vp b/HashTableTest/App/main.vp index 4b372d1..e6844eb 100644 --- a/HashTableTest/App/main.vp +++ b/HashTableTest/App/main.vp @@ -26,7 +26,7 @@ def main() -> CInt | CExport: ht.set_int("alpha", 10) ht.set_int("beta", 20) ht.set_int("gamma", 30) - n: t.CSizeT = len(ht) + n: sizet = len(ht) stdio.printf("len=%lu\n", n) testcheck.check(n == 3, "ht len OK (3)", "ht len FAILED") @@ -34,11 +34,11 @@ def main() -> CInt | CExport: # 须给出有元素类型的指针：c.Deref 的宽度只认 pointee 类型，i8*（t.CPtr）恒读 # 1 字节，不再按赋值目标注解反推 4 字节。 p1: t.CPtr = ht["alpha"] - v1: int = c.Deref((int | t.CPtr)(p1)) + v1: int = *(int | t.CPtr)(p1) p2: t.CPtr = ht["beta"] - v2: int = c.Deref((int | t.CPtr)(p2)) + v2: int = *(int | t.CPtr)(p2) p3: t.CPtr = ht["gamma"] - v3: int = c.Deref((int | t.CPtr)(p3)) + v3: int = *(int | t.CPtr)(p3) stdio.printf("alpha=%d beta=%d gamma=%d\n", v1, v2, v3) testcheck.check(v1 == 10, "ht[alpha]==10 OK", "ht[alpha] FAILED") testcheck.check(v2 == 20, "ht[beta]==20 OK", "ht[beta] FAILED") @@ -48,7 +48,7 @@ def main() -> CInt | CExport: testcheck.section("Test 2: 更新已有键") ht.set_int("beta", 99) p2b: t.CPtr = ht["beta"] - v2b: int = c.Deref((int | t.CPtr)(p2b)) + v2b: int = *(int | t.CPtr)(p2b) stdio.printf("beta(updated)=%d\n", v2b) testcheck.check(v2b == 99, "ht update OK", "ht update FAILED") testcheck.check(len(ht) == 3, "ht len still 3 OK", "ht len changed FAILED") @@ -58,36 +58,36 @@ def main() -> CInt | CExport: gv: t.CPtr = ht.get("missing", None) testcheck.check(gv == None, "ht get missing OK (None)", "ht get missing FAILED") gp: t.CPtr = ht.get("alpha", None) - ga: int = c.Deref((int | t.CPtr)(gp)) + ga: int = *(int | t.CPtr)(gp) stdio.printf("get(alpha)=%d\n", ga) testcheck.check(ga == 10, "ht get existing OK", "ht get existing FAILED") # === Test 4: contains === testcheck.section("Test 4: contains (in)") - has_alpha: t.CInt = "alpha" in ht - has_missing: t.CInt = "missing" in ht + has_alpha: int = "alpha" in ht + has_missing: int = "missing" in ht stdio.printf("contains(alpha)=%d contains(missing)=%d\n", has_alpha, has_missing) testcheck.check(has_alpha == 1, "contains alpha OK", "contains alpha FAILED") testcheck.check(has_missing == 0, "not contains missing OK", "contains missing FAILED") # === Test 5: 删除 === testcheck.section("Test 5: 删除 (del)") - deleted: t.CInt = ht.__delitem__("beta") + deleted: int = ht.__delitem__("beta") stdio.printf("del beta=%d\n", deleted) testcheck.check(deleted == 1, "del beta OK", "del beta FAILED") testcheck.check(len(ht) == 2, "ht len 2 after del OK", "ht len after del FAILED") - has_beta: t.CInt = "beta" in ht + has_beta: int = "beta" in ht testcheck.check(has_beta == 0, "beta gone OK", "beta still exists FAILED") # 删除不存在的 key - del_missing: t.CInt = ht.__delitem__("nokey") + del_missing: int = ht.__delitem__("nokey") testcheck.check(del_missing == 0, "del missing returns 0 OK", "del missing FAILED") # === Test 6: 删除后重新插入 === testcheck.section("Test 6: 删除后重新插入") ht.set_int("beta", 555) p2c: t.CPtr = ht["beta"] - v2c: int = c.Deref((int | t.CPtr)(p2c)) + v2c: int = *(int | t.CPtr)(p2c) stdio.printf("beta(re-inserted)=%d\n", v2c) testcheck.check(v2c == 555, "ht re-insert beta OK", "ht re-insert beta FAILED") testcheck.check(len(ht) == 3, "ht len 3 after re-insert OK", "ht len after re-insert FAILED") @@ -97,7 +97,7 @@ def main() -> CInt | CExport: iter_count: int = 0 for key in ht: kp: t.CPtr = ht[key] - val: int = c.Deref((int | t.CPtr)(kp)) + val: int = *(int | t.CPtr)(kp) stdio.printf("ht[%s]=%d\n", key, val) iter_count += 1 testcheck.check(iter_count == 3, "ht iter OK (3)", "ht iter FAILED") @@ -108,7 +108,7 @@ def main() -> CInt | CExport: ht2.set_str("name", "Alice") ht2.set_str("city", "Beijing") ht2.set_str("lang", "TransPyC") - n2: t.CSizeT = len(ht2) + n2: sizet = len(ht2) stdio.printf("ht2 len=%lu\n", n2) testcheck.check(n2 == 3, "ht set_str len OK (3)", "ht set_str len FAILED") @@ -133,7 +133,7 @@ def main() -> CInt | CExport: stdio.sprintf(key_buf, "key%d", i) ht3.set_int(key_buf, i * 100) i += 1 - n3: t.CSizeT = len(ht3) + n3: sizet = len(ht3) stdio.printf("ht3 len=%lu (after 50 inserts)\n", n3) testcheck.check(n3 == 50, "ht expand OK (50)", "ht expand FAILED") @@ -141,21 +141,21 @@ def main() -> CInt | CExport: k5: str = stdlib.malloc(16) stdio.sprintf(k5, "key5") p5: t.CPtr = ht3[k5] - v5: int = c.Deref((int | t.CPtr)(p5)) + v5: int = *(int | t.CPtr)(p5) stdio.printf("ht3[key5]=%d\n", v5) testcheck.check(v5 == 500, "ht expand key5 OK", "ht expand key5 FAILED") k25: str = stdlib.malloc(16) stdio.sprintf(k25, "key25") p25: t.CPtr = ht3[k25] - v25: int = c.Deref((int | t.CPtr)(p25)) + v25: int = *(int | t.CPtr)(p25) stdio.printf("ht3[key25]=%d\n", v25) testcheck.check(v25 == 2500, "ht expand key25 OK", "ht expand key25 FAILED") k49: str = stdlib.malloc(16) stdio.sprintf(k49, "key49") p49: t.CPtr = ht3[k49] - v49: int = c.Deref((int | t.CPtr)(p49)) + v49: int = *(int | t.CPtr)(p49) stdio.printf("ht3[key49]=%d\n", v49) testcheck.check(v49 == 4900, "ht expand key49 OK", "ht expand key49 FAILED") @@ -175,7 +175,7 @@ def main() -> CInt | CExport: stdio.sprintf(del_buf, "key%d", j) del ht3[del_buf] j += 1 - n3b: t.CSizeT = len(ht3) + n3b: sizet = len(ht3) stdio.printf("ht3 len=%lu (after 25 deletes)\n", n3b) testcheck.check(n3b == 25, "ht after del OK (25)", "ht after del FAILED") @@ -183,14 +183,14 @@ def main() -> CInt | CExport: k30: str = stdlib.malloc(16) stdio.sprintf(k30, "key30") p30: t.CPtr = ht3[k30] - v30: int = c.Deref((int | t.CPtr)(p30)) + v30: int = *(int | t.CPtr)(p30) stdio.printf("ht3[key30]=%d\n", v30) testcheck.check(v30 == 3000, "ht key30 after del OK", "ht key30 after del FAILED") # 验证已删除的 key 不存在 k0: str = stdlib.malloc(16) stdio.sprintf(k0, "key0") - has_k0: t.CInt = k0 in ht3 + has_k0: int = k0 in ht3 testcheck.check(has_k0 == 0, "ht key0 deleted OK", "ht key0 still exists FAILED") # === Test 12: 空表操作 === @@ -199,7 +199,7 @@ def main() -> CInt | CExport: testcheck.check(len(ht4) == 0, "empty ht len 0 OK", "empty ht len FAILED") empty_get: t.CPtr = ht4.get("none", None) testcheck.check(empty_get == None, "empty ht get OK", "empty ht get FAILED") - has_none: t.CInt = "none" in ht4 + has_none: int = "none" in ht4 testcheck.check(has_none == 0, "empty ht contains OK", "empty ht contains FAILED") empty_iter: int = 0 for ek in ht4: diff --git a/IterTest/App/main.vp b/IterTest/App/main.vp index da7c258..0891ca5 100644 --- a/IterTest/App/main.vp +++ b/IterTest/App/main.vp @@ -5,8 +5,8 @@ import testcheck def test_for_in_string(): testcheck.section("Test 1: for-in string iteration") - s: t.CChar | t.CPtr = "Hello" - result: t.CInt = 0 + s: char | t.CPtr = "Hello" + result: int = 0 for ch in s: result += ch # H=72, e=101, l=108, l=108, o=111 => 500 @@ -14,9 +14,9 @@ def test_for_in_string(): def test_for_in_char_ptr(): testcheck.section("Test 2: for-in char* iteration") - s: t.CChar | t.CPtr = "ABC" - chars: t.CArray[t.CInt, 4] = [0] - idx: t.CInt = 0 + s: char | t.CPtr = "ABC" + chars: t.CArray[int, 4] = [0] + idx: int = 0 for ch in s: if idx < 3: chars[idx] = ch @@ -25,16 +25,16 @@ def test_for_in_char_ptr(): def test_strcpy_for_in(): testcheck.section("Test 3: strcpy using for-in") - src: t.CChar | t.CPtr = "test" + src: char | t.CPtr = "test" # 手动实现 strcpy 用 for-in import w32.win32memory - buf: t.CChar | t.CPtr = w32.win32memory.VirtualAlloc(None, 64, 12288, 4) - if t.CUInt64T(buf) == 0: + buf: char | t.CPtr = w32.win32memory.VirtualAlloc(None, 64, 12288, 4) + if uint64(buf) == 0: stdio.printf("SKIP: VirtualAlloc returned NULL\n") return string.memset(buf, 0, 64) # 用 for-in 复制 - p: t.CChar | t.CPtr = buf + p: char | t.CPtr = buf for ch in src: p[0] = ch p += 1 @@ -44,7 +44,7 @@ def test_strcpy_for_in(): import w32.win32memory -def main() -> t.CInt: +def main() -> int: testcheck.begin("IterTest: 指针迭代测试") test_for_in_string() test_for_in_char_ptr() diff --git a/JsonTest/App/main.vp b/JsonTest/App/main.vp index f24bd4b..5960911 100644 --- a/JsonTest/App/main.vp +++ b/JsonTest/App/main.vp @@ -147,26 +147,26 @@ def test_write(pool: memhub.MemPool | t.CPtr): # 写整数 v1: json.JsonValue | t.CPtr = json.int_val(pool, 42) - s1: t.CChar | t.CPtr = json.write(pool, v1, False) + s1: char | t.CPtr = json.write(pool, v1, False) testcheck.check(string.strcmp(s1, "42") == 0, "write int 42", "write int 42") # 写字符串 v2: json.JsonValue | t.CPtr = json.string_val(pool, "hello") - s2: t.CChar | t.CPtr = json.write(pool, v2, False) + s2: char | t.CPtr = json.write(pool, v2, False) testcheck.check(string.strcmp(s2, '"hello"') == 0, "write string hello", "write string hello") # 写布尔 v3: json.JsonValue | t.CPtr = json.bool_val(pool, True) - s3: t.CChar | t.CPtr = json.write(pool, v3, False) + s3: char | t.CPtr = json.write(pool, v3, False) testcheck.check(string.strcmp(s3, "true") == 0, "write bool true", "write bool true") v4: json.JsonValue | t.CPtr = json.bool_val(pool, False) - s4: t.CChar | t.CPtr = json.write(pool, v4, False) + s4: char | t.CPtr = json.write(pool, v4, False) testcheck.check(string.strcmp(s4, "false") == 0, "write bool false", "write bool false") # 写 null v5: json.JsonValue | t.CPtr = json.null(pool) - s5: t.CChar | t.CPtr = json.write(pool, v5, False) + s5: char | t.CPtr = json.write(pool, v5, False) testcheck.check(string.strcmp(s5, "null") == 0, "write null", "write null") # 写数组 @@ -174,14 +174,14 @@ def test_write(pool: memhub.MemPool | t.CPtr): json.array_append(pool, arr, json.int_val(pool, 1)) json.array_append(pool, arr, json.int_val(pool, 2)) json.array_append(pool, arr, json.int_val(pool, 3)) - s6: t.CChar | t.CPtr = json.write(pool, arr, False) + s6: char | t.CPtr = json.write(pool, arr, False) testcheck.check(string.strcmp(s6, "[1,2,3]") == 0, "write array [1,2,3]", "write array [1,2,3]") # 写对象 obj: json.JsonValue | t.CPtr = json.object(pool) json.object_set(pool, obj, "a", json.int_val(pool, 1)) json.object_set(pool, obj, "b", json.string_val(pool, "x")) - s7: t.CChar | t.CPtr = json.write(pool, obj, False) + s7: char | t.CPtr = json.write(pool, obj, False) testcheck.check(s7 != None, "write object non-null", "write object non-null") @@ -191,7 +191,7 @@ def test_write(pool: memhub.MemPool | t.CPtr): def test_nested(pool: memhub.MemPool | t.CPtr): testcheck.section("Parse Nested JSON (Pythonic API)") - src: t.CChar | t.CPtr = '{"name": "Viper", "version": 1, "features": ["fast", "safe", "portable"], "nested": {"key": "value", "num": 99}}' + src: char | t.CPtr = '{"name": "Viper", "version": 1, "features": ["fast", "safe", "portable"], "nested": {"key": "value", "num": 99}}' root: json.JsonValue | t.CPtr = json.parse(pool, src) testcheck.check(root.is_object(), "nested is_object", "nested is_object") testcheck.check(len(root) == 4, "nested len()==4", "nested len()==4") @@ -262,12 +262,12 @@ def test_escape(pool: memhub.MemPool | t.CPtr): # 解析含转义字符的字符串 v1: json.JsonValue | t.CPtr = json.parse(pool, '"hello\\nworld"') testcheck.check(v1.is_string(), "escape \\n is_string", "escape \\n is_string") - sv1: t.CChar | t.CPtr = v1.as_string() + sv1: char | t.CPtr = v1.as_string() testcheck.check(sv1 != None and sv1[5] == '\n', "escape \\n contains newline", "escape \\n contains newline") v2: json.JsonValue | t.CPtr = json.parse(pool, '"tab\\there"') testcheck.check(v2.is_string(), "escape \\t is_string", "escape \\t is_string") - sv2: t.CChar | t.CPtr = v2.as_string() + sv2: char | t.CPtr = v2.as_string() testcheck.check(sv2 != None and sv2[3] == '\t', "escape \\t contains tab", "escape \\t contains tab") v3: json.JsonValue | t.CPtr = json.parse(pool, '"quote\\""') @@ -277,7 +277,7 @@ def test_escape(pool: memhub.MemPool | t.CPtr): # ============================================================ # 主函数 # ============================================================ -def main() -> t.CInt | t.CExport: +def main() -> int | t.CExport: testcheck.begin("JSON Library Test (Pythonic API)") # 使用 mpool 的 bump 分配器 diff --git a/ListTest/App/main.vp b/ListTest/App/main.vp index 86baf2f..9af3804 100644 --- a/ListTest/App/main.vp +++ b/ListTest/App/main.vp @@ -33,7 +33,7 @@ def main() -> CInt | CExport: # === Test 2: __len__ === testcheck.section("Test 2: __len__") - n: t.CSizeT = nums.__len__() + n: sizet = nums.__len__() stdio.printf("len=%lu\n", n) testcheck.check(n == 3, "__len__ OK (3)", "__len__ FAILED expect 3") @@ -49,13 +49,13 @@ def main() -> CInt | CExport: popped: CInt = nums.pop() stdio.printf("popped=%d\n", popped) testcheck.check(popped == 30, "pop OK (30)", "pop FAILED expect 30") - n2: t.CSizeT = nums.__len__() + n2: sizet = nums.__len__() testcheck.check(n2 == 2, "pop len OK (2)", "pop len FAILED expect 2") # === Test 5: clear === testcheck.section("Test 5: clear") nums.clear() - n3: t.CSizeT = nums.__len__() + n3: sizet = nums.__len__() testcheck.check(n3 == 0, "clear OK (0)", "clear FAILED expect 0") # === Test 6: 容量增长 (append 超过初始容量 8) === @@ -64,7 +64,7 @@ def main() -> CInt | CExport: i: CInt for i in range(20): nums2.append(i * 5) - n4: t.CSizeT = nums2.__len__() + n4: sizet = nums2.__len__() stdio.printf("after 20 appends: len=%lu\n", n4) testcheck.check(n4 == 20, "grow len OK (20)", "grow len FAILED") ok: CInt = 1 diff --git a/LogicFlowTest/App/config.vp b/LogicFlowTest/App/config.vp index 1b4e36f..1e6962f 100644 --- a/LogicFlowTest/App/config.vp +++ b/LogicFlowTest/App/config.vp @@ -1,24 +1,24 @@ import t, c -POSMAX: t.CDefine = 100 -MAX_RETRY: t.CDefine = 5 -BUFFER_SIZE: t.CDefine = 256 -PI: t.CDefine = 3.14159 -EULER: t.CDefine = 2.71828 -TRUE: t.CDefine = 1 -FALSE: t.CDefine = 0 -NULL: t.CDefine = 0 +define POSMAX = 100 +define MAX_RETRY = 5 +define BUFFER_SIZE = 256 +define PI = 3.14159 +define EULER = 2.71828 +define TRUE = 1 +define FALSE = 0 +define NULL = 0 -MATH_OFFSET: t.CDefine = 10 -MATH_SCALE: t.CDefine = 2 -THRESHOLD: t.CDefine = 50 -LOOP_LIMIT: t.CDefine = 20 -SHIFT_AMOUNT: t.CDefine = 2 -MASK_VALUE: t.CDefine = 0xFF -BIT_RANGE: t.CDefine = 4 -EXPONENT_BASE: t.CDefine = 3 -MODULO_DIVISOR: t.CDefine = 7 -SCALE_SHIFT: t.CDefine = 4 -HALF_SCALE: t.CDefine = 0.5 \ No newline at end of file +define MATH_OFFSET = 10 +define MATH_SCALE = 2 +define THRESHOLD = 50 +define LOOP_LIMIT = 20 +define SHIFT_AMOUNT = 2 +define MASK_VALUE = 0xFF +define BIT_RANGE = 4 +define EXPONENT_BASE = 3 +define MODULO_DIVISOR = 7 +define SCALE_SHIFT = 4 +define HALF_SCALE = 0.5 \ No newline at end of file diff --git a/LogicFlowTest/App/logic_test.vp b/LogicFlowTest/App/logic_test.vp index a204cfc..942a6c1 100644 --- a/LogicFlowTest/App/logic_test.vp +++ b/LogicFlowTest/App/logic_test.vp @@ -2,32 +2,32 @@ import config import t, c -def ForRangeBasicTest(stop: t.CInt): - i: t.CInt = 0 +def ForRangeBasicTest(stop: int): + i: int = 0 for i in range(stop): print("For range: ", i) print("Done") -def ForRangeWithStartStop(start: t.CInt, stop: t.CInt, step: t.CInt): - i: t.CInt = 0 +def ForRangeWithStartStop(start: int, stop: int, step: int): + i: int = 0 for i in range(start, stop, step): print("Range: ", i) print("Done") -def NestedForRangeTest(rows: t.CInt, cols: t.CInt): - r: t.CInt = 0 - c_val: t.CInt = 0 +def NestedForRangeTest(rows: int, cols: int): + r: int = 0 + c_val: int = 0 for r in range(rows): for c_val in range(cols): print("Cell: ", r, c_val) print("Grid done") -def ForWithIfBreakTest(data_size: t.CInt): - i: t.CInt = 0 - found: t.CInt = 0 +def ForWithIfBreakTest(data_size: int): + i: int = 0 + found: int = 0 for i in range(data_size): if i == 5: print("Found at: ", i) @@ -38,9 +38,9 @@ def ForWithIfBreakTest(data_size: t.CInt): print("Not found") -def ForWithIfContinueTest(n: t.CInt): - i: t.CInt = 0 - count: t.CInt = 0 +def ForWithIfContinueTest(n: int): + i: int = 0 + count: int = 0 for i in range(n): if i % 2 == 0: continue @@ -49,9 +49,9 @@ def ForWithIfContinueTest(n: t.CInt): print("Total odd: ", count) -def ForWithElifBranchTest(value: t.CInt): - i: t.CInt = 0 - result: t.CInt = 0 +def ForWithElifBranchTest(value: int): + i: int = 0 + result: int = 0 for i in range(value): if i < 3: result += 1 @@ -64,8 +64,8 @@ def ForWithElifBranchTest(value: t.CInt): print("Elif branch result: ", result) -def WhileWithIfElifElseTest(iterations: t.CInt): - counter: t.CInt = 0 +def WhileWithIfElifElseTest(iterations: int): + counter: int = 0 while counter < iterations: if counter < 2: print("Phase 1: ", counter) @@ -79,10 +79,10 @@ def WhileWithIfElifElseTest(iterations: t.CInt): print("While done") -def WhileWithNestedIfTest(limit: t.CInt): - outer: t.CInt = 0 +def WhileWithNestedIfTest(limit: int): + outer: int = 0 while outer < limit: - inner: t.CInt = 0 + inner: int = 0 while inner < limit: if inner == 2 and outer == 1: print("Target: ", outer, inner) @@ -95,8 +95,8 @@ def WhileWithNestedIfTest(limit: t.CInt): outer += 1 -def WhileWithMatchCaseTest(value: t.CInt): - result: t.CInt = 0 +def WhileWithMatchCaseTest(value: int): + result: int = 0 match value: case 1: result = 100 @@ -113,8 +113,8 @@ def WhileWithMatchCaseTest(value: t.CInt): print("Match result: ", result) -def WhileWithMatchCaseNoBreakTest(value: t.CInt): - result: t.CInt = 0 +def WhileWithMatchCaseNoBreakTest(value: int): + result: int = 0 match value: case 1: result = 10 @@ -131,10 +131,10 @@ def WhileWithMatchCaseNoBreakTest(value: t.CInt): print("No break match result: ", result) -def ComplexForWhileMatchTest(outer_limit: t.CInt, inner_limit: t.CInt): - i: t.CInt = 0 - j: t.CInt = 0 - result: t.CInt = 0 +def ComplexForWhileMatchTest(outer_limit: int, inner_limit: int): + i: int = 0 + j: int = 0 + result: int = 0 for i in range(outer_limit): j = 0 while j < inner_limit: @@ -153,9 +153,9 @@ def ComplexForWhileMatchTest(outer_limit: t.CInt, inner_limit: t.CInt): print("Complex match result: ", result) -def ForWithCaseAndNoBreakTest(n: t.CInt): - i: t.CInt = 0 - result: t.CInt = 0 +def ForWithCaseAndNoBreakTest(n: int): + i: int = 0 + result: int = 0 for i in range(n): match i: case 0: @@ -171,9 +171,9 @@ def ForWithCaseAndNoBreakTest(n: t.CInt): print("NoBreak result: ", result) -def WhileWithBreakConditionTest(limit: t.CInt): - i: t.CInt = 0 - early_exit: t.CInt = 0 +def WhileWithBreakConditionTest(limit: int): + i: int = 0 + early_exit: int = 0 while i < limit: if i == 3: early_exit = 1 @@ -185,10 +185,10 @@ def WhileWithBreakConditionTest(limit: t.CInt): i += 1 -def NestedWhileWithMultipleBreakPoints(depth: t.CInt, width: t.CInt): - d: t.CInt = 0 - w: t.CInt = 0 - count: t.CInt = 0 +def NestedWhileWithMultipleBreakPoints(depth: int, width: int): + d: int = 0 + w: int = 0 + count: int = 0 while d < depth: w = 0 while w < width: @@ -202,10 +202,10 @@ def NestedWhileWithMultipleBreakPoints(depth: t.CInt, width: t.CInt): print("Nested break count: ", count) -def ForWithMatchCaseInLoopTest(iterations: t.CInt): - i: t.CInt = 0 - sum_even: t.CInt = 0 - sum_odd: t.CInt = 0 +def ForWithMatchCaseInLoopTest(iterations: int): + i: int = 0 + sum_even: int = 0 + sum_odd: int = 0 for i in range(iterations): match i % 3: case 0: @@ -220,9 +220,9 @@ def ForWithMatchCaseInLoopTest(iterations: t.CInt): print("Sum odd: ", sum_odd) -def ComplexLogicWithElifChains(a: t.CInt, b: t.CInt, c_val: t.CInt): - i: t.CInt = 0 - result: t.CInt = 0 +def ComplexLogicWithElifChains(a: int, b: int, c_val: int): + i: int = 0 + result: int = 0 while i < 10: if i < a: if i < b: @@ -244,9 +244,9 @@ def ComplexLogicWithElifChains(a: t.CInt, b: t.CInt, c_val: t.CInt): print("Complex elif chain result: ", result) -def ForRangeWithStepAndCondition(n: t.CInt, step: t.CInt): - i: t.CInt = 0 - count: t.CInt = 0 +def ForRangeWithStepAndCondition(n: int, step: int): + i: int = 0 + count: int = 0 for i in range(0, n, step): if i % 2 == 0: print("Even step: ", i) @@ -259,8 +259,8 @@ def ForRangeWithStepAndCondition(n: t.CInt, step: t.CInt): print("Total steps: ", count) -def MatchCaseWithGuardConditions(value: t.CInt): - result: t.CInt = 0 +def MatchCaseWithGuardConditions(value: int): + result: int = 0 match value: case 1 if config.TRUE == 1: result = 100 @@ -273,9 +273,9 @@ def MatchCaseWithGuardConditions(value: t.CInt): print("Guard match result: ", result) -def WhileWithMultipleMatchCases(iterations: t.CInt): - i: t.CInt = 0 - state: t.CInt = 0 +def WhileWithMultipleMatchCases(iterations: int): + i: int = 0 + state: int = 0 while i < iterations: match state: case 0: @@ -291,10 +291,10 @@ def WhileWithMultipleMatchCases(iterations: t.CInt): i += 1 -def ForWhileMixWithBreakAndContinue(n: t.CInt): - i: t.CInt = 0 - j: t.CInt = 0 - count: t.CInt = 0 +def ForWhileMixWithBreakAndContinue(n: int): + i: int = 0 + j: int = 0 + count: int = 0 for i in range(n): j = 0 while j < n: @@ -308,12 +308,12 @@ def ForWhileMixWithBreakAndContinue(n: t.CInt): print("Mix break continue count: ", count) -def ComplexCaseMatchingWithRanges(start: t.CInt, end: t.CInt): - i: t.CInt = 0 - bucket0: t.CInt = 0 - bucket1: t.CInt = 0 - bucket2: t.CInt = 0 - bucket3: t.CInt = 0 +def ComplexCaseMatchingWithRanges(start: int, end: int): + i: int = 0 + bucket0: int = 0 + bucket1: int = 0 + bucket2: int = 0 + bucket3: int = 0 for i in range(start, end): match i: case _ if i < 10: @@ -330,9 +330,9 @@ def ComplexCaseMatchingWithRanges(start: t.CInt, end: t.CInt): print("Bucket3 (>=30): ", bucket3) -def WhileWithElifInElifChain(limit: t.CInt): - i: t.CInt = 0 - result: t.CInt = 0 +def WhileWithElifInElifChain(limit: int): + i: int = 0 + result: int = 0 while i < limit: if i < 2: if i == 0: @@ -355,10 +355,10 @@ def WhileWithElifInElifChain(limit: t.CInt): i += 1 -def ForWithCaseNoBreakNested(inner_limit: t.CInt): - i: t.CInt = 0 - j: t.CInt = 0 - result: t.CInt = 0 +def ForWithCaseNoBreakNested(inner_limit: int): + i: int = 0 + j: int = 0 + result: int = 0 for i in range(3): for j in range(inner_limit): match j: @@ -377,9 +377,9 @@ def ForWithCaseNoBreakNested(inner_limit: t.CInt): # 期望 limit=5：i=0 走 _ (+0)、i=1 走 case 1 (+100) 后 break 出 match（循环继续）、 # i=2 走 case 2 (+10)、i=3 (+3)、i=4 (+4) ⇒ 117 # ============================================================ -def MatchCaseBreakTest(limit: t.CInt) -> t.CInt: - i: t.CInt = 0 - result: t.CInt = 0 +def MatchCaseBreakTest(limit: int) -> int: + i: int = 0 + result: int = 0 for i in range(limit): match i: case 1: @@ -396,8 +396,8 @@ def MatchCaseBreakTest(limit: t.CInt) -> t.CInt: # switch（C switch 语义）：默认不穿透；case 体内写 `fallthrough` 才落到下一个 case。 # 期望 value=1 → 1+2+3=6；value=2 → 2+3=5；value=3 → 3；其它 → 77 # ============================================================ -def SwitchCaseFallthroughTest(value: t.CInt) -> t.CInt: - result: t.CInt = 0 +def SwitchCaseFallthroughTest(value: int) -> int: + result: int = 0 switch value: case 1: result += 1 @@ -417,9 +417,9 @@ def SwitchCaseFallthroughTest(value: t.CInt) -> t.CInt: # 期望 limit=5：i=0 走 default (+0)、i=1 走 case 1 (+100) 后 break 出 switch、 # i=2 走 case 2 (+10)、i=3 (+3)、i=4 (+4) ⇒ 117 # ============================================================ -def SwitchCaseBreakTest(limit: t.CInt) -> t.CInt: - i: t.CInt = 0 - result: t.CInt = 0 +def SwitchCaseBreakTest(limit: int) -> int: + i: int = 0 + result: int = 0 for i in range(limit): switch i: case 1: @@ -436,8 +436,8 @@ def SwitchCaseBreakTest(limit: t.CInt) -> t.CInt: # switch 多值 case：`case 1 | 2:` 命中同一个臂 # 期望 value=1 → 10；value=2 → 10；value=3 → 30；其它 → 99 # ============================================================ -def SwitchMultiValueTest(value: t.CInt) -> t.CInt: - result: t.CInt = 0 +def SwitchMultiValueTest(value: int) -> int: + result: int = 0 switch value: case 1 | 2: result = 10 diff --git a/LogicFlowTest/App/main.vp b/LogicFlowTest/App/main.vp index 80845ca..6d5bf65 100644 --- a/LogicFlowTest/App/main.vp +++ b/LogicFlowTest/App/main.vp @@ -4,7 +4,7 @@ import logic_test import testcheck -def main() -> t.CInt: +def main() -> int: testcheck.begin("LogicFlowTest: For/While/Match/控制流测试") testcheck.section("For Range Basic Test (stop=5)") diff --git a/LoopMathTest/App/config.vp b/LoopMathTest/App/config.vp index 1b4e36f..1e6962f 100644 --- a/LoopMathTest/App/config.vp +++ b/LoopMathTest/App/config.vp @@ -1,24 +1,24 @@ import t, c -POSMAX: t.CDefine = 100 -MAX_RETRY: t.CDefine = 5 -BUFFER_SIZE: t.CDefine = 256 -PI: t.CDefine = 3.14159 -EULER: t.CDefine = 2.71828 -TRUE: t.CDefine = 1 -FALSE: t.CDefine = 0 -NULL: t.CDefine = 0 +define POSMAX = 100 +define MAX_RETRY = 5 +define BUFFER_SIZE = 256 +define PI = 3.14159 +define EULER = 2.71828 +define TRUE = 1 +define FALSE = 0 +define NULL = 0 -MATH_OFFSET: t.CDefine = 10 -MATH_SCALE: t.CDefine = 2 -THRESHOLD: t.CDefine = 50 -LOOP_LIMIT: t.CDefine = 20 -SHIFT_AMOUNT: t.CDefine = 2 -MASK_VALUE: t.CDefine = 0xFF -BIT_RANGE: t.CDefine = 4 -EXPONENT_BASE: t.CDefine = 3 -MODULO_DIVISOR: t.CDefine = 7 -SCALE_SHIFT: t.CDefine = 4 -HALF_SCALE: t.CDefine = 0.5 \ No newline at end of file +define MATH_OFFSET = 10 +define MATH_SCALE = 2 +define THRESHOLD = 50 +define LOOP_LIMIT = 20 +define SHIFT_AMOUNT = 2 +define MASK_VALUE = 0xFF +define BIT_RANGE = 4 +define EXPONENT_BASE = 3 +define MODULO_DIVISOR = 7 +define SCALE_SHIFT = 4 +define HALF_SCALE = 0.5 \ No newline at end of file diff --git a/LoopMathTest/App/main.vp b/LoopMathTest/App/main.vp index 40c70ef..f9b9e2c 100644 --- a/LoopMathTest/App/main.vp +++ b/LoopMathTest/App/main.vp @@ -5,7 +5,7 @@ import test import testcheck -def main() -> t.CInt: +def main() -> int: testcheck.begin("LoopMathTest: While/数学/跨模块宏测试") testcheck.section("Cross-module macros") diff --git a/LoopMathTest/App/test.vp b/LoopMathTest/App/test.vp index 24a08a8..5d8ad87 100644 --- a/LoopMathTest/App/test.vp +++ b/LoopMathTest/App/test.vp @@ -2,8 +2,8 @@ import config import t, c -def AboutSizeTWhileTest(length: t.CSizeT): - pos: t.CSizeT = 0 +def AboutSizeTWhileTest(length: sizet): + pos: sizet = 0 while pos < length: print("Pos: ", pos) if pos > config.POSMAX: break @@ -24,8 +24,8 @@ def AboutSizeTWhileTest(length: t.CSizeT): pos += 1 -def MathBasicTest(x: t.CInt, y: t.CInt) -> t.CInt: - result: t.CInt = 0 +def MathBasicTest(x: int, y: int) -> int: + result: int = 0 result = x + y print("Add: ", result) result = x - y @@ -40,15 +40,15 @@ def MathBasicTest(x: t.CInt, y: t.CInt) -> t.CInt: return result -def MathAdvancedTest(value: t.CInt) -> t.CInt: - counter: t.CInt = 0 - scaled: t.CInt = 0 - offset: t.CInt = 0 +def MathAdvancedTest(value: int) -> int: + counter: int = 0 + scaled: int = 0 + offset: int = 0 scaled = value * config.MATH_SCALE print("Scaled: ", scaled) offset = scaled + config.MATH_OFFSET print("Offset: ", offset) - threshold: t.CInt = config.THRESHOLD + threshold: int = config.THRESHOLD if offset > threshold: print("Above threshold") counter = 1 @@ -61,8 +61,8 @@ def MathAdvancedTest(value: t.CInt) -> t.CInt: return counter -def WhileWithElifElseTest(start: t.CInt, end: t.CInt): - idx: t.CInt = start +def WhileWithElifElseTest(start: int, end: int): + idx: int = start while idx < end: if idx < 0: print("Negative: ", idx) @@ -77,10 +77,10 @@ def WhileWithElifElseTest(start: t.CInt, end: t.CInt): idx += 1 -def NestedWhileWithMacrosTest(outer_limit: t.CInt, inner_limit: t.CInt): - outer: t.CInt = 0 - inner: t.CInt = 0 - total_ops: t.CInt = 0 +def NestedWhileWithMacrosTest(outer_limit: int, inner_limit: int): + outer: int = 0 + inner: int = 0 + total_ops: int = 0 while outer < outer_limit: inner = 0 while inner < inner_limit: @@ -92,10 +92,10 @@ def NestedWhileWithMacrosTest(outer_limit: t.CInt, inner_limit: t.CInt): print("Total operations: ", total_ops) -def ComplexConditionTest(a: t.CInt, b: t.CInt, c_val: t.CInt): - x: t.CInt = a - y: t.CInt = b - z: t.CInt = c_val +def ComplexConditionTest(a: int, b: int, c_val: int): + x: int = a + y: int = b + z: int = c_val while x < config.LOOP_LIMIT: if x > 0 and y > 0 and z > 0: print("All positive: ", x, y, z) @@ -113,9 +113,9 @@ def ComplexConditionTest(a: t.CInt, b: t.CInt, c_val: t.CInt): z += 1 -def RetryLoopTest(retry_count: t.CInt) -> t.CInt: - attempt: t.CInt = 0 - success: t.CInt = 0 +def RetryLoopTest(retry_count: int) -> int: + attempt: int = 0 + success: int = 0 while attempt < retry_count: if attempt < config.MAX_RETRY: print("Attempt: ", attempt, " less than max") @@ -130,12 +130,12 @@ def RetryLoopTest(retry_count: t.CInt) -> t.CInt: return success -def BitwiseOperationsTest(value: t.CInt) -> t.CInt: - shifted: t.CInt = 0 - masked: t.CInt = 0 - xored: t.CInt = 0 - anded: t.CInt = 0 - ored: t.CInt = 0 +def BitwiseOperationsTest(value: int) -> int: + shifted: int = 0 + masked: int = 0 + xored: int = 0 + anded: int = 0 + ored: int = 0 shifted = value << config.SHIFT_AMOUNT print("Left shift: ", shifted) shifted = value >> config.SHIFT_AMOUNT @@ -151,10 +151,10 @@ def BitwiseOperationsTest(value: t.CInt) -> t.CInt: return masked -def CompoundAssignmentMathTest(a: t.CInt, b: t.CInt) -> t.CInt: - x: t.CInt = a - y: t.CInt = b - result: t.CInt = 0 +def CompoundAssignmentMathTest(a: int, b: int) -> int: + x: int = a + y: int = b + result: int = 0 x += y print("x += y: ", x) x -= y @@ -186,10 +186,10 @@ def CompoundAssignmentMathTest(a: t.CInt, b: t.CInt) -> t.CInt: return result -def PowerAndModuloTest(base: t.CInt, exponent: t.CInt) -> t.CInt: - result: t.CInt = 1 - temp: t.CInt = 0 - i: t.CInt = 0 +def PowerAndModuloTest(base: int, exponent: int) -> int: + result: int = 1 + temp: int = 0 + i: int = 0 while i < exponent: result *= base i += 1 @@ -203,8 +203,8 @@ def PowerAndModuloTest(base: t.CInt, exponent: t.CInt) -> t.CInt: return result -def MixedArithmeticTest(x: t.CInt, y: t.CInt, z: t.CInt) -> t.CInt: - result: t.CInt = 0 +def MixedArithmeticTest(x: int, y: int, z: int) -> int: + result: int = 0 result = (x + y) * z print("(x+y)*z: ", result) result = x + (y * z) @@ -215,7 +215,7 @@ def MixedArithmeticTest(x: t.CInt, y: t.CInt, z: t.CInt) -> t.CInt: print("x*scale + y*scale: ", result) result = ((x % config.MODULO_DIVISOR) + (y % config.MODULO_DIVISOR)) * config.MATH_SCALE print("(x%%mod + y%%mod)*scale: ", result) - temp: t.CInt = 0 + temp: int = 0 temp = x | y & z print("x | y & z: ", temp) temp = (x | y) & z @@ -225,12 +225,12 @@ def MixedArithmeticTest(x: t.CInt, y: t.CInt, z: t.CInt) -> t.CInt: return result -def MathWithWhileLoopTest(start: t.CInt, count: t.CInt) -> t.CInt: - idx: t.CInt = 0 - accumulator: t.CInt = 0 - multiplier: t.CInt = config.MATH_SCALE +def MathWithWhileLoopTest(start: int, count: int) -> int: + idx: int = 0 + accumulator: int = 0 + multiplier: int = config.MATH_SCALE while idx < count: - temp: t.CInt = (start + idx) * multiplier + temp: int = (start + idx) * multiplier temp = temp + config.MATH_OFFSET if temp > config.THRESHOLD: temp = config.THRESHOLD @@ -241,11 +241,11 @@ def MathWithWhileLoopTest(start: t.CInt, count: t.CInt) -> t.CInt: return accumulator -def ComplexNestedMathTest(a: t.CInt, b: t.CInt) -> t.CInt: - layer1: t.CInt = 0 - layer2: t.CInt = 0 - layer3: t.CInt = 0 - i: t.CInt = 0 +def ComplexNestedMathTest(a: int, b: int) -> int: + layer1: int = 0 + layer2: int = 0 + layer3: int = 0 + i: int = 0 layer1 = (a + b) * config.MATH_SCALE print("Layer1: ", layer1) while i < config.BIT_RANGE: @@ -259,9 +259,9 @@ def ComplexNestedMathTest(a: t.CInt, b: t.CInt) -> t.CInt: return layer3 -def ConditionalMathChainTest(value: t.CInt) -> t.CInt: - result: t.CInt = 0 - step: t.CInt = 0 +def ConditionalMathChainTest(value: int) -> int: + result: int = 0 + step: int = 0 while step < config.LOOP_LIMIT: if step < 5: result += step * config.MATH_SCALE @@ -279,10 +279,10 @@ def ConditionalMathChainTest(value: t.CInt) -> t.CInt: return result -def BitManipulationMathTest(value: t.CInt) -> t.CInt: - original: t.CInt = value - nibble: t.CInt = 0 - result: t.CInt = 0 +def BitManipulationMathTest(value: int) -> int: + original: int = value + nibble: int = 0 + result: int = 0 result = (value << config.SHIFT_AMOUNT) | (value >> (8 - config.SHIFT_AMOUNT)) print("Rotate left: ", result) result = (value >> config.SHIFT_AMOUNT) | (value << (8 - config.SHIFT_AMOUNT)) diff --git a/LoopTest/App/main.vp b/LoopTest/App/main.vp index e47117e..cb64b03 100644 --- a/LoopTest/App/main.vp +++ b/LoopTest/App/main.vp @@ -4,7 +4,7 @@ import testcheck def test_for_loop(): testcheck.section("Test 1: for loop") - sum_val: t.CInt = 0 + sum_val: int = 0 for i in range(10): sum_val += i # 0+1+2+...+9 = 45 @@ -12,8 +12,8 @@ def test_for_loop(): def test_while_loop(): testcheck.section("Test 2: while loop") - n: t.CInt = 100 - count: t.CInt = 0 + n: int = 100 + count: int = 0 while n > 1: if n % 2 == 0: n = n // 2 @@ -25,7 +25,7 @@ def test_while_loop(): def test_nested_loop(): testcheck.section("Test 3: nested loop") - count: t.CInt = 0 + count: int = 0 for i in range(5): for j in range(5): if i < j: @@ -35,7 +35,7 @@ def test_nested_loop(): def test_break(): testcheck.section("Test 4: break") - found: t.CInt = -1 + found: int = -1 for i in range(100): if i * i > 50: found = i @@ -45,7 +45,7 @@ def test_break(): def test_continue(): testcheck.section("Test 5: continue") - sum_val: t.CInt = 0 + sum_val: int = 0 for i in range(20): if i % 3 == 0: continue @@ -55,7 +55,7 @@ def test_continue(): def test_range_step(): testcheck.section("Test 6: range with step") - sum_val: t.CInt = 0 + sum_val: int = 0 for i in range(0, 20, 3): sum_val += i # 0+3+6+9+12+15+18 = 63 @@ -63,13 +63,13 @@ def test_range_step(): def test_loop_u64(): testcheck.section("Test 7: loop with u64 counter") - total: t.CUInt64T = 0 + total: uint64 = 0 for i in range(100): - total += t.CUInt64T(i) + total += uint64(i) # 0+1+2+...+99 = 4950 testcheck.check(total == 4950, "u64 loop (total=4950)", "u64 loop (expect 4950)") -def main() -> t.CInt: +def main() -> int: testcheck.begin("LoopTest: 循环与控制流基准测试") test_for_loop() test_while_loop() diff --git a/MemhubTest/App/main.vp b/MemhubTest/App/main.vp index 8ea0fe9..12118ea 100644 --- a/MemhubTest/App/main.vp +++ b/MemhubTest/App/main.vp @@ -7,7 +7,7 @@ import memhub # 多态测试: 通过 MemManager 基类指针调用, 验证 vtable 分派到正确子类 -def test_polymorphic(mgr: memhub.MemManager | t.CPtr, size: t.CSizeT) -> t.CInt: +def test_polymorphic(mgr: memhub.MemManager | t.CPtr, size: sizet) -> int: p: t.CPtr = mgr.alloc(size) if p is None: return 0 @@ -16,12 +16,12 @@ def test_polymorphic(mgr: memhub.MemManager | t.CPtr, size: t.CSizeT) -> t.CInt: # 测试 calloc 多态: calloc 是 MemManager 具体方法, 内部调 self.alloc (虚函数) -def test_calloc_polymorphic(mgr: memhub.MemManager | t.CPtr) -> t.CInt: +def test_calloc_polymorphic(mgr: memhub.MemManager | t.CPtr) -> int: p: t.CPtr = mgr.calloc(4, 8) if p is None: return 0 # 验证清零: 读第一个字节应为 0 - first_byte: t.CUInt8T = t.CUInt8T(c.Deref(t.CUInt64T(p, t.CPtr))) + first_byte: uint8 = uint8(*uint64(p, t.CPtr)) if first_byte != 0: return 0 return 1 @@ -42,11 +42,11 @@ def main() -> int: testcheck.check(p1 is not None, "MemPool alloc 100", "FAIL") p2: t.CPtr = pool.alloc(200) testcheck.check(p2 is not None, "MemPool alloc 200", "FAIL") - testcheck.check(t.CUInt64T(p1) != t.CUInt64T(p2), "MemPool different ptrs", "FAIL") + testcheck.check(uint64(p1) != uint64(p2), "MemPool different ptrs", "FAIL") pool.reset() p3: t.CPtr = pool.alloc(100) testcheck.check(p3 is not None, "MemPool alloc after reset", "FAIL") - testcheck.check(t.CUInt64T(p3) == t.CUInt64T(p1), "MemPool reset reuses addr", "FAIL") + testcheck.check(uint64(p3) == uint64(p1), "MemPool reset reuses addr", "FAIL") # ========== MemSlab (fixed block) ========== testcheck.section("MemSlab (fixed block)") @@ -60,7 +60,7 @@ def main() -> int: slab.free(s1) s4: t.CPtr = slab.alloc(32) testcheck.check(s4 is not None, "MemSlab alloc after free", "FAIL") - testcheck.check(t.CUInt64T(s4) == t.CUInt64T(s1), "MemSlab free reuse addr", "FAIL") + testcheck.check(uint64(s4) == uint64(s1), "MemSlab free reuse addr", "FAIL") # ========== MemBuddy (buddy system) ========== testcheck.section("MemBuddy (buddy system)") @@ -78,17 +78,17 @@ def main() -> int: # ========== 多态分派 (核心测试) ========== testcheck.section("polymorphic dispatch") - r1: t.CInt = test_polymorphic(pool, 50) + r1: int = test_polymorphic(pool, 50) testcheck.check(r1 == 1, "vtable: MemPool.alloc/free via MemManager", "FAIL") - r2: t.CInt = test_polymorphic(slab, 32) + r2: int = test_polymorphic(slab, 32) testcheck.check(r2 == 1, "vtable: MemSlab.alloc/free via MemManager", "FAIL") - r3: t.CInt = test_polymorphic(buddy, 50) + r3: int = test_polymorphic(buddy, 50) testcheck.check(r3 == 1, "vtable: MemBuddy.alloc/free via MemManager", "FAIL") # calloc 多态 (具体方法调虚函数) - rc1: t.CInt = test_calloc_polymorphic(pool) + rc1: int = test_calloc_polymorphic(pool) testcheck.check(rc1 == 1, "vtable: calloc dispatches MemPool.alloc", "FAIL") - rc2: t.CInt = test_calloc_polymorphic(buddy) + rc2: int = test_calloc_polymorphic(buddy) testcheck.check(rc2 == 1, "vtable: calloc dispatches MemBuddy.alloc", "FAIL") stdlib.free(arena1) diff --git a/MpoolOopTest/App/main.vp b/MpoolOopTest/App/main.vp index 4d9dbd7..47f502e 100644 --- a/MpoolOopTest/App/main.vp +++ b/MpoolOopTest/App/main.vp @@ -3,7 +3,7 @@ import testcheck import mpooltest -def main() -> t.CInt | t.CExport: +def main() -> int | t.CExport: testcheck.begin("MpoolOopTest: MemPool OOP 测试") testcheck.section("MPool OOP") mpooltest.mpool_main() diff --git a/NewAstTest/App/main.vp b/NewAstTest/App/main.vp index 9699dbc..1627780 100644 --- a/NewAstTest/App/main.vp +++ b/NewAstTest/App/main.vp @@ -35,8 +35,8 @@ def main() -> CInt | CExport: failed: CInt = 0 # --- 分配 dump 缓冲区（用于 AST 反向输出测试） --- - DUMP_BUF_SIZE: t.CSizeT = 8192 - dump_buf: t.CChar | CPtr = stdlib.malloc(DUMP_BUF_SIZE) + DUMP_BUF_SIZE: sizet = 8192 + dump_buf: char | CPtr = stdlib.malloc(DUMP_BUF_SIZE) if dump_buf is None: printf("FAIL: dump_buf alloc failed\n") stdlib.free(arena) @@ -120,7 +120,7 @@ def main() -> CInt | CExport: else: body.append(binop) body.append(unary) - cnt: t.CSizeT = body.__len__() + cnt: sizet = body.__len__() if cnt == 2: passed += 1 printf("PASS: list append x2, count=%zu\n", cnt) @@ -210,7 +210,7 @@ def main() -> CInt | CExport: printf("PASS: If, kind=%d\n", if_stmt.kind()) # --- Test 15: Compare 节点 --- - cmp_ops: list[t.CInt] | CPtr = list[t.CInt](pool) + cmp_ops: list[int] | CPtr = list[int](pool) cmp_ops.append(OpKind.Lt) cmp_comparators: list[AST | CPtr] | CPtr = list[AST | CPtr](pool, 8) cmp_comparators.append(int_42) @@ -269,7 +269,7 @@ def main() -> CInt | CExport: # --- Test 20: Module.children 遍历 --- if mod is not None and mod.children is not None: - mod_cnt: t.CSizeT = mod.children.__len__() + mod_cnt: sizet = mod.children.__len__() if mod_cnt == 2: passed += 1 printf("PASS: Module.children count=%zu (expected 2)\n", mod_cnt) @@ -302,7 +302,7 @@ def main() -> CInt | CExport: # --- Test 22: If.children 遍历 (ret + expr_stmt) --- if if_stmt is not None and if_stmt.children is not None: - if_cnt: t.CSizeT = if_stmt.children.__len__() + if_cnt: sizet = if_stmt.children.__len__() if if_cnt == 2: passed += 1 printf("PASS: If.children count=%zu (expected 2)\n", if_cnt) @@ -348,7 +348,7 @@ def main() -> CInt | CExport: # --- Test 26: parse 模块的 children 验证 --- if parsed_mod is not None and parsed_mod.children is not None: - pmod_cnt: t.CSizeT = parsed_mod.children.__len__() + pmod_cnt: sizet = parsed_mod.children.__len__() if pmod_cnt == 1: passed += 1 printf("PASS: parsed Module.children count=%zu (expected 1)\n", pmod_cnt) @@ -385,7 +385,7 @@ c = a + b """ multi_mod: Module | CPtr = parse(multi_src, pool) if multi_mod is not None and multi_mod.children is not None: - multi_cnt: t.CSizeT = multi_mod.children.__len__() + multi_cnt: sizet = multi_mod.children.__len__() if multi_cnt == 3: passed += 1 printf("PASS: parse multi-stmt, children=%zu (expected 3)\n", multi_cnt) @@ -402,7 +402,7 @@ c = a + b """ if_mod: Module | CPtr = parse(if_src, pool) if if_mod is not None and if_mod.children is not None: - if_cnt2: t.CSizeT = if_mod.children.__len__() + if_cnt2: sizet = if_mod.children.__len__() if_k: CInt = if_mod.children.get(0).kind() if if_cnt2 == 1 and if_k == ASTKind.If: passed += 1 @@ -420,7 +420,7 @@ c = a + b """ for_mod: Module | CPtr = parse(for_src, pool) if for_mod is not None and for_mod.children is not None: - for_cnt: t.CSizeT = for_mod.children.__len__() + for_cnt: sizet = for_mod.children.__len__() for_k: CInt = for_mod.children.get(0).kind() if for_cnt == 1 and for_k == ASTKind.For: passed += 1 @@ -438,7 +438,7 @@ c = a + b """ while_mod: Module | CPtr = parse(while_src, pool) if while_mod is not None and while_mod.children is not None: - while_cnt: t.CSizeT = while_mod.children.__len__() + while_cnt: sizet = while_mod.children.__len__() while_k: CInt = while_mod.children.get(0).kind() if while_cnt == 1 and while_k == ASTKind.While: passed += 1 @@ -456,7 +456,7 @@ c = a + b """ def_mod: Module | CPtr = parse(def_src, pool) if def_mod is not None and def_mod.children is not None: - def_cnt: t.CSizeT = def_mod.children.__len__() + def_cnt: sizet = def_mod.children.__len__() def_k: CInt = def_mod.children.get(0).kind() if def_cnt == 1 and def_k == ASTKind.FunctionDef: passed += 1 @@ -490,7 +490,7 @@ c = a + b """ nested_mod: Module | CPtr = parse(nested_src, pool) if nested_mod is not None and nested_mod.children is not None: - nested_cnt: t.CSizeT = nested_mod.children.__len__() + nested_cnt: sizet = nested_mod.children.__len__() nested_k: CInt = nested_mod.children.get(0).kind() if nested_cnt == 1 and nested_k == ASTKind.For: passed += 1 @@ -513,7 +513,7 @@ w = z * 2 """ mixed_mod: Module | CPtr = parse(mixed_src, pool) if mixed_mod is not None and mixed_mod.children is not None: - mixed_cnt: t.CSizeT = mixed_mod.children.__len__() + mixed_cnt: sizet = mixed_mod.children.__len__() if mixed_cnt == 4: passed += 1 printf("PASS: parse mixed module, children=%zu (expected 4)\n", mixed_cnt) @@ -640,7 +640,7 @@ w = z * 2 """ class_mod: Module | CPtr = parse(class_src, pool) if class_mod is not None and class_mod.children is not None: - class_cnt: t.CSizeT = class_mod.children.__len__() + class_cnt: sizet = class_mod.children.__len__() class_k: CInt = class_mod.children.get(0).kind() if class_cnt == 1 and class_k == ASTKind.ClassDef: passed += 1 @@ -660,7 +660,7 @@ except: """ try_mod: Module | CPtr = parse(try_src, pool) if try_mod is not None and try_mod.children is not None: - try_cnt: t.CSizeT = try_mod.children.__len__() + try_cnt: sizet = try_mod.children.__len__() try_k: CInt = try_mod.children.get(0).kind() if try_cnt == 1 and try_k == ASTKind.Try: passed += 1 @@ -678,7 +678,7 @@ from sys import path """ import_mod: Module | CPtr = parse(import_src, pool) if import_mod is not None and import_mod.children is not None: - import_cnt: t.CSizeT = import_mod.children.__len__() + import_cnt: sizet = import_mod.children.__len__() k0: CInt = import_mod.children.get(0).kind() k1: CInt = import_mod.children.get(1).kind() if import_cnt == 2 and k0 == ASTKind.Import and k1 == ASTKind.ImportFrom: @@ -698,7 +698,7 @@ x += 1 """ aug_mod: Module | CPtr = parse(aug_src, pool) if aug_mod is not None and aug_mod.children is not None: - aug_cnt: t.CSizeT = aug_mod.children.__len__() + aug_cnt: sizet = aug_mod.children.__len__() aug_k: CInt = aug_mod.children.get(1).kind() if aug_cnt == 2 and aug_k == ASTKind.AugAssign: passed += 1 @@ -735,7 +735,7 @@ x += 1 """ nested_def_mod: Module | CPtr = parse(nested_def_src, pool) if nested_def_mod is not None and nested_def_mod.children is not None: - nd_cnt: t.CSizeT = nested_def_mod.children.__len__() + nd_cnt: sizet = nested_def_mod.children.__len__() nd_k: CInt = nested_def_mod.children.get(0).kind() if nd_cnt == 1 and nd_k == ASTKind.FunctionDef: passed += 1 @@ -791,7 +791,7 @@ else: """ cmix_mod: Module | CPtr = parse(complex_mixed_src, pool) if cmix_mod is not None and cmix_mod.children is not None: - cmix_cnt: t.CSizeT = cmix_mod.children.__len__() + cmix_cnt: sizet = cmix_mod.children.__len__() dump(cmix_mod, dump_buf, DUMP_BUF_SIZE) printf("--- AST dump of complex mixed ---\n%s\n--- end dump ---\n", dump_buf) cm_def: str = string.strstr(dump_buf, "FunctionDef") @@ -800,7 +800,7 @@ else: cm_bool: str = string.strstr(dump_buf, "BoolOp(") cm_cmp: str = string.strstr(dump_buf, "Compare(") cm_ret: str = string.strstr(dump_buf, "Return(") - ok: t.CInt = 0 + ok: int = 0 if cmix_cnt == 3: if cm_def is not None and cm_while is not None: if cm_call is not None and cm_bool is not None: @@ -1524,7 +1524,7 @@ class C(Base1, Base2): """ adef_mod: Module | CPtr = parse(adef_src, pool) if adef_mod is not None and adef_mod.children is not None: - adef_cnt: t.CSizeT = adef_mod.children.__len__() + adef_cnt: sizet = adef_mod.children.__len__() if adef_cnt == 1: adef_child: AST | CPtr = adef_mod.children.get(0) if adef_child is not None and adef_child.kind() == ASTKind.FunctionDef: @@ -1553,7 +1553,7 @@ class C(Base1, Base2): """ afor_mod: Module | CPtr = parse(afor_src, pool) if afor_mod is not None and afor_mod.children is not None: - afor_cnt: t.CSizeT = afor_mod.children.__len__() + afor_cnt: sizet = afor_mod.children.__len__() if afor_cnt == 1: afor_child: AST | CPtr = afor_mod.children.get(0) if afor_child is not None and afor_child.kind() == ASTKind.FunctionDef: @@ -1597,7 +1597,7 @@ class C(Base1, Base2): """ awith_mod: Module | CPtr = parse(awith_src, pool) if awith_mod is not None and awith_mod.children is not None: - awith_cnt: t.CSizeT = awith_mod.children.__len__() + awith_cnt: sizet = awith_mod.children.__len__() if awith_cnt == 1: awith_child: AST | CPtr = awith_mod.children.get(0) if awith_child is not None and awith_child.kind() == ASTKind.FunctionDef: @@ -1673,7 +1673,7 @@ class C(Base1, Base2): """ acombo_mod: Module | CPtr = parse(acombo_src, pool) if acombo_mod is not None and acombo_mod.children is not None: - acombo_cnt: t.CSizeT = acombo_mod.children.__len__() + acombo_cnt: sizet = acombo_mod.children.__len__() if acombo_cnt == 1: acombo_child: AST | CPtr = acombo_mod.children.get(0) if acombo_child is not None and acombo_child.kind() == ASTKind.FunctionDef: diff --git a/NoVTableCrossMixinTest/App/main.vp b/NoVTableCrossMixinTest/App/main.vp index 33729f5..b3aceda 100644 --- a/NoVTableCrossMixinTest/App/main.vp +++ b/NoVTableCrossMixinTest/App/main.vp @@ -15,14 +15,14 @@ import testcheck # 期望：按实际定义类（BaseA）做前缀，或按最终组合类（Combined）。 # ============================================================ novirtual class BaseA: - a: t.CInt + a: int def helper(self) -> int: return self.a novirtual class BaseB: - b: t.CInt + b: int def caller(self) -> int: return self.helper() @@ -52,7 +52,7 @@ def test_cross_mixin_call(): # inner2 内写 self.a2（this_adjust 精确到组合类中 a2 字段）。 # ============================================================ novirtual class MixinA2: - a2: t.CInt + a2: int def inner2(self) -> int: self.a2 = self.a2 + 10 @@ -60,14 +60,14 @@ novirtual class MixinA2: novirtual class MixinB2(MixinA2): - b2: t.CInt + b2: int def mid2(self) -> int: return self.inner2() + self.b2 novirtual class MixinC2: - c2: t.CInt + c2: int def outer2(self) -> int: return self.mid2() + self.c2 @@ -97,14 +97,14 @@ def test_multilevel_chain(): # DataMixin.get_val 内 self.val 需 this_adjust 到第二父类字段区。 # ============================================================ novirtual class PtrMixin: - name: t.CChar | t.CPtr + name: char | t.CPtr - def get_name(self) -> t.CChar | t.CPtr: + def get_name(self) -> char | t.CPtr: return self.name novirtual class DataMixin: - val: t.CInt + val: int def get_val(self) -> int: return self.val @@ -127,7 +127,7 @@ def test_second_parent_offset(): "second parent this_adjust fail") -def main() -> t.CInt: +def main() -> int: testcheck.begin("NoVTableCrossMixinTest") test_cross_mixin_call() test_multilevel_chain() diff --git a/NoVTableTest/App/main.vp b/NoVTableTest/App/main.vp index 7bdd0b6..bbac0e9 100644 --- a/NoVTableTest/App/main.vp +++ b/NoVTableTest/App/main.vp @@ -14,7 +14,7 @@ import stdlib # 从 LinkedNode* 取回 Node* 需显式向下转型：(Node | t.CPtr)(ptr) # ============================================================ class Node(linkedlist.LinkedNode): - value: t.CInt + value: int # ============================================================ @@ -167,13 +167,13 @@ def test_insert_ops(): root.insert_after(a, d) # [1, 4, 2, 3] 在 a 后插入 d # 遍历验证顺序 cur: Node | t.CPtr = (Node | t.CPtr)(root.child) - v0: t.CInt = cur.value + v0: int = cur.value cur = (Node | t.CPtr)(cur.next) - v1: t.CInt = cur.value + v1: int = cur.value cur = (Node | t.CPtr)(cur.next) - v2: t.CInt = cur.value + v2: int = cur.value cur = (Node | t.CPtr)(cur.next) - v3: t.CInt = cur.value + v3: int = cur.value testcheck.check(v0 == 1 and v1 == 4 and v2 == 2 and v3 == 3, "order 1,4,2,3", "insert order fail") @@ -223,7 +223,7 @@ def test_index_access(): "child_at(5)=None", "child_at 5 fail") # count_children - cc: t.CSizeT = root.count_children() + cc: sizet = root.count_children() testcheck.check(cc == 5, "count_children=5", "count_children fail") @@ -291,7 +291,7 @@ def test_unlink(): # 测试 10：SListNode 单向链表（OOP 方法） # ============================================================ class SNode(linkedlist.SListNode): - value: t.CInt + value: int def test_slist(): @@ -358,7 +358,7 @@ def test_slist(): def test_sprintf_vararg(): testcheck.section("Test 11: viperlib.sprintf *args forwarding") # 测试 %d 单参数 - buf: t.CChar | t.CPtr = stdlib.malloc(32) + buf: char | t.CPtr = stdlib.malloc(32) if buf is None: return buf[0] = 0 viperlib.sprintf(buf, "key%d", 42) @@ -366,7 +366,7 @@ def test_sprintf_vararg(): "sprintf key42", "sprintf key%d fail") # 测试无参数 - buf2: t.CChar | t.CPtr = stdlib.malloc(32) + buf2: char | t.CPtr = stdlib.malloc(32) if buf2 is None: return buf2[0] = 0 viperlib.sprintf(buf2, "hello") @@ -374,7 +374,7 @@ def test_sprintf_vararg(): "sprintf hello", "sprintf no-arg fail") # 测试多参数 - buf3: t.CChar | t.CPtr = stdlib.malloc(32) + buf3: char | t.CPtr = stdlib.malloc(32) if buf3 is None: return buf3[0] = 0 viperlib.sprintf(buf3, "%d+%d=%d", 1, 2, 3) @@ -401,7 +401,7 @@ novirtual class GSListNode[T]: novirtual class GSList[T]: Head: T | t.CPtr Tail: T | t.CPtr - Count: t.CSizeT + Count: sizet def __init__(self): self.Head = None @@ -418,13 +418,13 @@ novirtual class GSList[T]: self.Tail = node self.Count += 1 - def count(self) -> t.CSizeT: + def count(self) -> sizet: return self.Count - def at(self, index: t.CSizeT) -> T | t.CPtr: + def at(self, index: sizet) -> T | t.CPtr: if self.Head is None: return None cur: T | t.CPtr = self.Head - i: t.CSizeT = 0 + i: sizet = 0 while cur is not None: if i == index: return cur i += 1 @@ -433,7 +433,7 @@ novirtual class GSList[T]: class GNode(GSListNode[GNode]): - Value: t.CInt + Value: int def test_generic_slist(): @@ -489,7 +489,7 @@ def test_generic_slist(): "a2.Next fail") -def main() -> t.CInt: +def main() -> int: testcheck.begin("NoVTableTest: linkedlist 库（@t.NoVTable OOP 方法 + 字段展平继承）") test_append() test_prev_link() diff --git a/NumpyTest/App/main.vp b/NumpyTest/App/main.vp index 8db7688..1b66fcc 100644 --- a/NumpyTest/App/main.vp +++ b/NumpyTest/App/main.vp @@ -3,7 +3,7 @@ import testcheck import test_numpy -def main() -> t.CInt | t.CExport: +def main() -> int | t.CExport: testcheck.begin("NumpyTest: numpy 正确性测试") testcheck.section("numpy Correctness Tests") test_numpy.test_numpy_correct() diff --git a/NumpyTest/App/test_numpy.vp b/NumpyTest/App/test_numpy.vp index 79cc7e4..2bc2de6 100644 --- a/NumpyTest/App/test_numpy.vp +++ b/NumpyTest/App/test_numpy.vp @@ -11,23 +11,23 @@ import t, c # ============================================================ # Constants # ============================================================ -EPS: t.CDouble = t.CDouble(1e-9) -EPS_LOOSE: t.CDouble = t.CDouble(1e-5) -SIMD_BLOCK: t.CSizeT = 4 +EPS: double = double(1e-9) +EPS_LOOSE: double = double(1e-5) +SIMD_BLOCK: sizet = 4 # ============================================================ # Global state # ============================================================ -arena: t.CUInt8T | t.CPtr = None +arena: uint8 | t.CPtr = None pool: memhub.MemPool | t.CPtr = None -test_passed: t.CInt = 0 -test_failed: t.CInt = 0 +test_passed: int = 0 +test_failed: int = 0 # ============================================================ # Global check function # ============================================================ -def check(name: str, condition: t.CInt, detail: str): +def check(name: str, condition: int, detail: str): global test_passed, test_failed if condition: test_passed += 1 @@ -40,18 +40,18 @@ def check(name: str, condition: t.CInt, detail: str): # ============================================================ # Approximate comparison (top-level, uses vipermath.fabs) # ============================================================ -def approx_eq(a: t.CDouble, b: t.CDouble) -> t.CInt: - d: t.CDouble = a - b - if d < t.CDouble(0.0): - d = t.CDouble(0.0) - d +def approx_eq(a: double, b: double) -> int: + d: double = a - b + if d < double(0.0): + d = double(0.0) - d if d < EPS: return 1 return 0 -def approx_loose(a: t.CDouble, b: t.CDouble) -> t.CInt: - d: t.CDouble = a - b - if d < t.CDouble(0.0): - d = t.CDouble(0.0) - d +def approx_loose(a: double, b: double) -> int: + d: double = a - b + if d < double(0.0): + d = double(0.0) - d if d < EPS_LOOSE: return 1 return 0 @@ -71,25 +71,25 @@ def section_footer(): # Timer: 单调时钟（GetTickCount64 毫秒 → 秒） # 原 c.Timer() 无编译器支持（TPC/TPV 均无），改用 Win32 API # ============================================================ -def timer_sec() -> t.CDouble: - return t.CDouble(w32.win32base.GetTickCount64()) / t.CDouble(1000.0) +def timer_sec() -> double: + return double(w32.win32base.GetTickCount64()) / double(1000.0) # ============================================================ # Utility: quick array creation # ============================================================ -def vec4(p: memhub.MemPool | t.CPtr, v0: t.CDouble, v1: t.CDouble, v2: t.CDouble, v3: t.CDouble) -> numpy.ndarray[t.CDouble] | t.CPtr: - a: numpy.ndarray[t.CDouble] | t.CPtr = numpy.zeros(p, 4) +def vec4(p: memhub.MemPool | t.CPtr, v0: double, v1: double, v2: double, v3: double) -> numpy.ndarray[double] | t.CPtr: + a: numpy.ndarray[double] | t.CPtr = numpy.zeros(p, 4) a.data[0] = v0; a.data[1] = v1; a.data[2] = v2; a.data[3] = v3 return a -def vec3(p: memhub.MemPool | t.CPtr, v0: t.CDouble, v1: t.CDouble, v2: t.CDouble) -> numpy.ndarray[t.CDouble] | t.CPtr: - a: numpy.ndarray[t.CDouble] | t.CPtr = numpy.zeros(p, 3) +def vec3(p: memhub.MemPool | t.CPtr, v0: double, v1: double, v2: double) -> numpy.ndarray[double] | t.CPtr: + a: numpy.ndarray[double] | t.CPtr = numpy.zeros(p, 3) a.data[0] = v0; a.data[1] = v1; a.data[2] = v2 return a -def vec2(p: memhub.MemPool | t.CPtr, v0: t.CDouble, v1: t.CDouble) -> numpy.ndarray[t.CDouble] | t.CPtr: - a: numpy.ndarray[t.CDouble] | t.CPtr = numpy.zeros(p, 2) +def vec2(p: memhub.MemPool | t.CPtr, v0: double, v1: double) -> numpy.ndarray[double] | t.CPtr: + a: numpy.ndarray[double] | t.CPtr = numpy.zeros(p, 2) a.data[0] = v0; a.data[1] = v1 return a @@ -100,20 +100,20 @@ def vec2(p: memhub.MemPool | t.CPtr, v0: t.CDouble, v1: t.CDouble) -> numpy.ndar def test_zeros_ones(): section_header("zeros / ones / full") - a: numpy.ndarray[t.CDouble] | t.CPtr = numpy.zeros(pool, 5) + a: numpy.ndarray[double] | t.CPtr = numpy.zeros(pool, 5) check("zeros not None", a != None, "zeros returned None") check("zeros size == 5", a.size == 5, "size mismatch") - check("zeros [0]==0", a.data[0] == t.CDouble(0.0), "not zero") - check("zeros [4]==0", a.data[4] == t.CDouble(0.0), "not zero") + check("zeros [0]==0", a.data[0] == double(0.0), "not zero") + check("zeros [4]==0", a.data[4] == double(0.0), "not zero") - b: numpy.ndarray[t.CDouble] | t.CPtr = numpy.ones(pool, 4) + b: numpy.ndarray[double] | t.CPtr = numpy.ones(pool, 4) check("ones not None", b != None, "ones returned None") - check("ones [0]==1", b.data[0] == t.CDouble(1.0), "not one") - check("ones [3]==1", b.data[3] == t.CDouble(1.0), "not one") + check("ones [0]==1", b.data[0] == double(1.0), "not one") + check("ones [3]==1", b.data[3] == double(1.0), "not one") - c: numpy.ndarray[t.CDouble] | t.CPtr = numpy.full(pool, 3, t.CDouble(7.5)) + c: numpy.ndarray[double] | t.CPtr = numpy.full(pool, 3, double(7.5)) check("full not None", c != None, "full returned None") - check("full value", c.data[0] == t.CDouble(7.5), "value mismatch") + check("full value", c.data[0] == double(7.5), "value mismatch") a.delete() b.delete() @@ -124,17 +124,17 @@ def test_zeros_ones(): def test_arange_linspace(): section_header("arange / linspace") - a: numpy.ndarray[t.CDouble] | t.CPtr = numpy.arange(pool, t.CDouble(0.0), t.CDouble(5.0), t.CDouble(1.0)) + a: numpy.ndarray[double] | t.CPtr = numpy.arange(pool, double(0.0), double(5.0), double(1.0)) check("arange not None", a != None, "arange returned None") check("arange size == 5", a.size == 5, "size mismatch") - check("arange [0]==0", approx_eq(a.data[0], t.CDouble(0.0)), "mismatch") - check("arange [4]==4", approx_eq(a.data[4], t.CDouble(4.0)), "mismatch") + check("arange [0]==0", approx_eq(a.data[0], double(0.0)), "mismatch") + check("arange [4]==4", approx_eq(a.data[4], double(4.0)), "mismatch") - b: numpy.ndarray[t.CDouble] | t.CPtr = numpy.linspace(pool, t.CDouble(0.0), t.CDouble(1.0), 5) + b: numpy.ndarray[double] | t.CPtr = numpy.linspace(pool, double(0.0), double(1.0), 5) check("linspace not None", b != None, "linspace returned None") check("linspace size == 5", b.size == 5, "size mismatch") - check("linspace [0]==0", approx_eq(b.data[0], t.CDouble(0.0)), "mismatch") - check("linspace [4]==1", approx_eq(b.data[4], t.CDouble(1.0)), "mismatch") + check("linspace [0]==0", approx_eq(b.data[0], double(0.0)), "mismatch") + check("linspace [4]==1", approx_eq(b.data[4], double(1.0)), "mismatch") a.delete() b.delete() @@ -144,19 +144,19 @@ def test_arange_linspace(): def test_eye_diag(): section_header("eye / diag") - e: numpy.ndarray[t.CDouble] | t.CPtr = numpy.eye(pool, 3) + e: numpy.ndarray[double] | t.CPtr = numpy.eye(pool, 3) check("eye not None", e != None, "eye returned None") check("eye ndim == 2", e.ndim == 2, "ndim mismatch") - check("eye [0,0]==1", e.at2d(0, 0) == t.CDouble(1.0), "mismatch") - check("eye [0,1]==0", e.at2d(0, 1) == t.CDouble(0.0), "mismatch") - check("eye [1,1]==1", e.at2d(1, 1) == t.CDouble(1.0), "mismatch") + check("eye [0,0]==1", e.at2d(0, 0) == double(1.0), "mismatch") + check("eye [0,1]==0", e.at2d(0, 1) == double(0.0), "mismatch") + check("eye [1,1]==1", e.at2d(1, 1) == double(1.0), "mismatch") - vals: numpy.ndarray[t.CDouble] | t.CPtr = vec3(pool, t.CDouble(1.0), t.CDouble(2.0), t.CDouble(3.0)) - d: numpy.ndarray[t.CDouble] | t.CPtr = numpy.diag(pool, vals) + vals: numpy.ndarray[double] | t.CPtr = vec3(pool, double(1.0), double(2.0), double(3.0)) + d: numpy.ndarray[double] | t.CPtr = numpy.diag(pool, vals) check("diag not None", d != None, "diag returned None") - check("diag [0,0]==1", d.at2d(0, 0) == t.CDouble(1.0), "mismatch") - check("diag [1,1]==2", d.at2d(1, 1) == t.CDouble(2.0), "mismatch") - check("diag [2,2]==3", d.at2d(2, 2) == t.CDouble(3.0), "mismatch") + check("diag [0,0]==1", d.at2d(0, 0) == double(1.0), "mismatch") + check("diag [1,1]==2", d.at2d(1, 1) == double(2.0), "mismatch") + check("diag [2,2]==3", d.at2d(2, 2) == double(3.0), "mismatch") e.delete() vals.delete() @@ -170,11 +170,11 @@ def test_eye_diag(): def test_sum_mean_min_max(): section_header("sum / mean / min / max / argmax / argmin") - a: numpy.ndarray[t.CDouble] | t.CPtr = numpy.arange(pool, t.CDouble(1.0), t.CDouble(6.0), t.CDouble(1.0)) - check("sum == 15", approx_eq(a.sum(), t.CDouble(15.0)), "mismatch") - check("mean == 3", approx_eq(a.mean(), t.CDouble(3.0)), "mismatch") - check("min == 1", approx_eq(a.min(), t.CDouble(1.0)), "mismatch") - check("max == 5", approx_eq(a.max(), t.CDouble(5.0)), "mismatch") + a: numpy.ndarray[double] | t.CPtr = numpy.arange(pool, double(1.0), double(6.0), double(1.0)) + check("sum == 15", approx_eq(a.sum(), double(15.0)), "mismatch") + check("mean == 3", approx_eq(a.mean(), double(3.0)), "mismatch") + check("min == 1", approx_eq(a.min(), double(1.0)), "mismatch") + check("max == 5", approx_eq(a.max(), double(5.0)), "mismatch") check("argmax == 4", a.argmax() == 4, "mismatch") check("argmin == 0", a.argmin() == 0, "mismatch") @@ -185,17 +185,17 @@ def test_sum_mean_min_max(): def test_fill_copy(): section_header("fill / copy") - a: numpy.ndarray[t.CDouble] | t.CPtr = numpy.zeros(pool, 3) - a.fill(t.CDouble(9.0)) - check("fill [0]==9", a.data[0] == t.CDouble(9.0), "mismatch") - check("fill [2]==9", a.data[2] == t.CDouble(9.0), "mismatch") + a: numpy.ndarray[double] | t.CPtr = numpy.zeros(pool, 3) + a.fill(double(9.0)) + check("fill [0]==9", a.data[0] == double(9.0), "mismatch") + check("fill [2]==9", a.data[2] == double(9.0), "mismatch") - b: numpy.ndarray[t.CDouble] | t.CPtr = a.copy() + b: numpy.ndarray[double] | t.CPtr = a.copy() check("copy not None", b != None, "copy returned None") - check("copy [0]==9", b.data[0] == t.CDouble(9.0), "mismatch") + check("copy [0]==9", b.data[0] == double(9.0), "mismatch") - b.data[0] = t.CDouble(0.0) - check("copy is independent", a.data[0] == t.CDouble(9.0), "copy not independent") + b.data[0] = double(0.0) + check("copy is independent", a.data[0] == double(9.0), "copy not independent") a.delete() b.delete() @@ -208,23 +208,23 @@ def test_fill_copy(): def test_add_sub_mul_div(): section_header("__add__ / __sub__ / __mul__ / __truediv__") - a: numpy.ndarray[t.CDouble] | t.CPtr = vec3(pool, t.CDouble(1.0), t.CDouble(2.0), t.CDouble(3.0)) - b: numpy.ndarray[t.CDouble] | t.CPtr = vec3(pool, t.CDouble(4.0), t.CDouble(5.0), t.CDouble(6.0)) + a: numpy.ndarray[double] | t.CPtr = vec3(pool, double(1.0), double(2.0), double(3.0)) + b: numpy.ndarray[double] | t.CPtr = vec3(pool, double(4.0), double(5.0), double(6.0)) - c_add: numpy.ndarray[t.CDouble] | t.CPtr = a + b + c_add: numpy.ndarray[double] | t.CPtr = a + b check("a+b not None", c_add != None, "add returned None") - check("a+b [0]==5", c_add.data[0] == t.CDouble(5.0), "mismatch") - check("a+b [2]==9", c_add.data[2] == t.CDouble(9.0), "mismatch") + check("a+b [0]==5", c_add.data[0] == double(5.0), "mismatch") + check("a+b [2]==9", c_add.data[2] == double(9.0), "mismatch") - c_sub: numpy.ndarray[t.CDouble] | t.CPtr = a - b - check("a-b [0]==-3", c_sub.data[0] == t.CDouble(-3.0), "mismatch") + c_sub: numpy.ndarray[double] | t.CPtr = a - b + check("a-b [0]==-3", c_sub.data[0] == double(-3.0), "mismatch") - c_mul: numpy.ndarray[t.CDouble] | t.CPtr = a * b - check("a*b [1]==10", c_mul.data[1] == t.CDouble(10.0), "mismatch") + c_mul: numpy.ndarray[double] | t.CPtr = a * b + check("a*b [1]==10", c_mul.data[1] == double(10.0), "mismatch") - c_div: numpy.ndarray[t.CDouble] | t.CPtr = b / a - check("b/a [0]==4", c_div.data[0] == t.CDouble(4.0), "mismatch") - check("b/a [2]==2", c_div.data[2] == t.CDouble(2.0), "mismatch") + c_div: numpy.ndarray[double] | t.CPtr = b / a + check("b/a [0]==4", c_div.data[0] == double(4.0), "mismatch") + check("b/a [2]==2", c_div.data[2] == double(2.0), "mismatch") a.delete() b.delete() @@ -238,11 +238,11 @@ def test_add_sub_mul_div(): def test_neg(): section_header("__neg__") - a: numpy.ndarray[t.CDouble] | t.CPtr = vec3(pool, t.CDouble(1.0), t.CDouble(-2.0), t.CDouble(3.0)) - neg_a: numpy.ndarray[t.CDouble] | t.CPtr = -a + a: numpy.ndarray[double] | t.CPtr = vec3(pool, double(1.0), double(-2.0), double(3.0)) + neg_a: numpy.ndarray[double] | t.CPtr = -a check("neg not None", neg_a != None, "neg returned None") - check("neg [0]==-1", neg_a.data[0] == t.CDouble(-1.0), "mismatch") - check("neg [1]==2", neg_a.data[1] == t.CDouble(2.0), "mismatch") + check("neg [0]==-1", neg_a.data[0] == double(-1.0), "mismatch") + check("neg [1]==2", neg_a.data[1] == double(2.0), "mismatch") a.delete() neg_a.delete() @@ -252,7 +252,7 @@ def test_neg(): def test_len(): section_header("__len__") - a: numpy.ndarray[t.CDouble] | t.CPtr = numpy.zeros(pool, 10) + a: numpy.ndarray[double] | t.CPtr = numpy.zeros(pool, 10) check("len == 10", len(a) == 10, "mismatch") a.delete() @@ -265,19 +265,19 @@ def test_len(): def test_scalar_ops(): section_header("add_scalar / mul_scalar / sub_scalar / div_scalar") - a: numpy.ndarray[t.CDouble] | t.CPtr = numpy.ones(pool, 3) + a: numpy.ndarray[double] | t.CPtr = numpy.ones(pool, 3) - r1: numpy.ndarray[t.CDouble] | t.CPtr = numpy.add_scalar(a, t.CDouble(2.0)) - check("add_scalar [0]==3", r1.data[0] == t.CDouble(3.0), "mismatch") + r1: numpy.ndarray[double] | t.CPtr = numpy.add_scalar(a, double(2.0)) + check("add_scalar [0]==3", r1.data[0] == double(3.0), "mismatch") - r2: numpy.ndarray[t.CDouble] | t.CPtr = numpy.mul_scalar(a, t.CDouble(5.0)) - check("mul_scalar [0]==5", r2.data[0] == t.CDouble(5.0), "mismatch") + r2: numpy.ndarray[double] | t.CPtr = numpy.mul_scalar(a, double(5.0)) + check("mul_scalar [0]==5", r2.data[0] == double(5.0), "mismatch") - r3: numpy.ndarray[t.CDouble] | t.CPtr = numpy.sub_scalar(a, t.CDouble(0.5)) - check("sub_scalar [0]==0.5", r3.data[0] == t.CDouble(0.5), "mismatch") + r3: numpy.ndarray[double] | t.CPtr = numpy.sub_scalar(a, double(0.5)) + check("sub_scalar [0]==0.5", r3.data[0] == double(0.5), "mismatch") - r4: numpy.ndarray[t.CDouble] | t.CPtr = numpy.div_scalar(a, t.CDouble(2.0)) - check("div_scalar [0]==0.5", r4.data[0] == t.CDouble(0.5), "mismatch") + r4: numpy.ndarray[double] | t.CPtr = numpy.div_scalar(a, double(2.0)) + check("div_scalar [0]==0.5", r4.data[0] == double(0.5), "mismatch") a.delete() r1.delete() @@ -293,23 +293,23 @@ def test_scalar_ops(): def test_math_funcs(): section_header("np_abs / np_sqrt / np_pow") - a: numpy.ndarray[t.CDouble] | t.CPtr = vec3(pool, t.CDouble(1.0), t.CDouble(4.0), t.CDouble(9.0)) + a: numpy.ndarray[double] | t.CPtr = vec3(pool, double(1.0), double(4.0), double(9.0)) - r_sqrt: numpy.ndarray[t.CDouble] | t.CPtr = numpy.np_sqrt(a) - check("sqrt [0]==1", approx_eq(r_sqrt.data[0], t.CDouble(1.0)), "mismatch") - check("sqrt [1]==2", approx_eq(r_sqrt.data[1], t.CDouble(2.0)), "mismatch") - check("sqrt [2]==3", approx_eq(r_sqrt.data[2], t.CDouble(3.0)), "mismatch") + r_sqrt: numpy.ndarray[double] | t.CPtr = numpy.np_sqrt(a) + check("sqrt [0]==1", approx_eq(r_sqrt.data[0], double(1.0)), "mismatch") + check("sqrt [1]==2", approx_eq(r_sqrt.data[1], double(2.0)), "mismatch") + check("sqrt [2]==3", approx_eq(r_sqrt.data[2], double(3.0)), "mismatch") - b: numpy.ndarray[t.CDouble] | t.CPtr = vec3(pool, t.CDouble(-1.0), t.CDouble(-4.0), t.CDouble(9.0)) - r_abs: numpy.ndarray[t.CDouble] | t.CPtr = numpy.np_abs(b) - check("abs [0]==1", approx_eq(r_abs.data[0], t.CDouble(1.0)), "mismatch") - check("abs [1]==4", approx_eq(r_abs.data[1], t.CDouble(4.0)), "mismatch") + b: numpy.ndarray[double] | t.CPtr = vec3(pool, double(-1.0), double(-4.0), double(9.0)) + r_abs: numpy.ndarray[double] | t.CPtr = numpy.np_abs(b) + check("abs [0]==1", approx_eq(r_abs.data[0], double(1.0)), "mismatch") + check("abs [1]==4", approx_eq(r_abs.data[1], double(4.0)), "mismatch") - c: numpy.ndarray[t.CDouble] | t.CPtr = vec3(pool, t.CDouble(1.0), t.CDouble(2.0), t.CDouble(3.0)) - r_pow: numpy.ndarray[t.CDouble] | t.CPtr = numpy.np_pow(c, t.CDouble(2.0)) - check("pow [0]==1", approx_eq(r_pow.data[0], t.CDouble(1.0)), "mismatch") - check("pow [1]==4", approx_eq(r_pow.data[1], t.CDouble(4.0)), "mismatch") - check("pow [2]==9", approx_eq(r_pow.data[2], t.CDouble(9.0)), "mismatch") + c: numpy.ndarray[double] | t.CPtr = vec3(pool, double(1.0), double(2.0), double(3.0)) + r_pow: numpy.ndarray[double] | t.CPtr = numpy.np_pow(c, double(2.0)) + check("pow [0]==1", approx_eq(r_pow.data[0], double(1.0)), "mismatch") + check("pow [1]==4", approx_eq(r_pow.data[1], double(4.0)), "mismatch") + check("pow [2]==9", approx_eq(r_pow.data[2], double(9.0)), "mismatch") a.delete() b.delete() @@ -327,20 +327,20 @@ def test_matmul(): section_header("matmul") # [1,2;3,4] x [5,6;7,8] = [19,22;43,50] - a: numpy.ndarray[t.CDouble] | t.CPtr = numpy.empty2d(pool, 2, 2) - a.set2d(0, 0, t.CDouble(1.0)); a.set2d(0, 1, t.CDouble(2.0)) - a.set2d(1, 0, t.CDouble(3.0)); a.set2d(1, 1, t.CDouble(4.0)) + a: numpy.ndarray[double] | t.CPtr = numpy.empty2d(pool, 2, 2) + a.set2d(0, 0, double(1.0)); a.set2d(0, 1, double(2.0)) + a.set2d(1, 0, double(3.0)); a.set2d(1, 1, double(4.0)) - b: numpy.ndarray[t.CDouble] | t.CPtr = numpy.empty2d(pool, 2, 2) - b.set2d(0, 0, t.CDouble(5.0)); b.set2d(0, 1, t.CDouble(6.0)) - b.set2d(1, 0, t.CDouble(7.0)); b.set2d(1, 1, t.CDouble(8.0)) + b: numpy.ndarray[double] | t.CPtr = numpy.empty2d(pool, 2, 2) + b.set2d(0, 0, double(5.0)); b.set2d(0, 1, double(6.0)) + b.set2d(1, 0, double(7.0)); b.set2d(1, 1, double(8.0)) - c: numpy.ndarray[t.CDouble] | t.CPtr = numpy.matmul(a, b) + c: numpy.ndarray[double] | t.CPtr = numpy.matmul(a, b) check("matmul not None", c != None, "matmul returned None") - check("matmul [0,0]==19", c.at2d(0, 0) == t.CDouble(19.0), "mismatch") - check("matmul [0,1]==22", c.at2d(0, 1) == t.CDouble(22.0), "mismatch") - check("matmul [1,0]==43", c.at2d(1, 0) == t.CDouble(43.0), "mismatch") - check("matmul [1,1]==50", c.at2d(1, 1) == t.CDouble(50.0), "mismatch") + check("matmul [0,0]==19", c.at2d(0, 0) == double(19.0), "mismatch") + check("matmul [0,1]==22", c.at2d(0, 1) == double(22.0), "mismatch") + check("matmul [1,0]==43", c.at2d(1, 0) == double(43.0), "mismatch") + check("matmul [1,1]==50", c.at2d(1, 1) == double(50.0), "mismatch") a.delete() b.delete() @@ -351,14 +351,14 @@ def test_matmul(): def test_dot(): section_header("dot / dot_product") - a: numpy.ndarray[t.CDouble] | t.CPtr = vec3(pool, t.CDouble(1.0), t.CDouble(2.0), t.CDouble(3.0)) - b: numpy.ndarray[t.CDouble] | t.CPtr = vec3(pool, t.CDouble(4.0), t.CDouble(5.0), t.CDouble(6.0)) + a: numpy.ndarray[double] | t.CPtr = vec3(pool, double(1.0), double(2.0), double(3.0)) + b: numpy.ndarray[double] | t.CPtr = vec3(pool, double(4.0), double(5.0), double(6.0)) - d: t.CDouble = a.dot(b) - check("dot == 32", approx_eq(d, t.CDouble(32.0)), "mismatch") + d: double = a.dot(b) + check("dot == 32", approx_eq(d, double(32.0)), "mismatch") - d2: t.CDouble = numpy.dot_product(a, b) - check("dot_product == 32", approx_eq(d2, t.CDouble(32.0)), "mismatch") + d2: double = numpy.dot_product(a, b) + check("dot_product == 32", approx_eq(d2, double(32.0)), "mismatch") a.delete() b.delete() @@ -368,17 +368,17 @@ def test_dot(): def test_transpose(): section_header("T (transpose)") - a: numpy.ndarray[t.CDouble] | t.CPtr = numpy.empty2d(pool, 2, 3) - a.set2d(0, 0, t.CDouble(1.0)); a.set2d(0, 1, t.CDouble(2.0)); a.set2d(0, 2, t.CDouble(3.0)) - a.set2d(1, 0, t.CDouble(4.0)); a.set2d(1, 1, t.CDouble(5.0)); a.set2d(1, 2, t.CDouble(6.0)) + a: numpy.ndarray[double] | t.CPtr = numpy.empty2d(pool, 2, 3) + a.set2d(0, 0, double(1.0)); a.set2d(0, 1, double(2.0)); a.set2d(0, 2, double(3.0)) + a.set2d(1, 0, double(4.0)); a.set2d(1, 1, double(5.0)); a.set2d(1, 2, double(6.0)) - at: numpy.ndarray[t.CDouble] | t.CPtr = a.T() + at: numpy.ndarray[double] | t.CPtr = a.T() check("T not None", at != None, "T returned None") check("T shape[0]==3", at.shape[0] == 3, "shape mismatch") check("T shape[1]==2", at.shape[1] == 2, "shape mismatch") - check("T [0,0]==1", at.at2d(0, 0) == t.CDouble(1.0), "mismatch") - check("T [0,1]==4", at.at2d(0, 1) == t.CDouble(4.0), "mismatch") - check("T [1,0]==2", at.at2d(1, 0) == t.CDouble(2.0), "mismatch") + check("T [0,0]==1", at.at2d(0, 0) == double(1.0), "mismatch") + check("T [0,1]==4", at.at2d(0, 1) == double(4.0), "mismatch") + check("T [1,0]==2", at.at2d(1, 0) == double(2.0), "mismatch") a.delete() at.delete() @@ -392,24 +392,24 @@ def test_var_std_norm(): section_header("var / std / norm") # [2,4,4,4,5,5,7,9] mean=5, var=4, std=2 - a: numpy.ndarray[t.CDouble] | t.CPtr = numpy.zeros(pool, 8) - a.data[0] = t.CDouble(2.0); a.data[1] = t.CDouble(4.0) - a.data[2] = t.CDouble(4.0); a.data[3] = t.CDouble(4.0) - a.data[4] = t.CDouble(5.0); a.data[5] = t.CDouble(5.0) - a.data[6] = t.CDouble(7.0); a.data[7] = t.CDouble(9.0) + a: numpy.ndarray[double] | t.CPtr = numpy.zeros(pool, 8) + a.data[0] = double(2.0); a.data[1] = double(4.0) + a.data[2] = double(4.0); a.data[3] = double(4.0) + a.data[4] = double(5.0); a.data[5] = double(5.0) + a.data[6] = double(7.0); a.data[7] = double(9.0) - v: t.CDouble = numpy.var(a) + v: double = numpy.var(a) printf(" var = %.6f (expect 4.0)\n", v) - check("var ~= 4", approx_eq(v, t.CDouble(4.0)), "mismatch") + check("var ~= 4", approx_eq(v, double(4.0)), "mismatch") - s: t.CDouble = numpy.std(a) + s: double = numpy.std(a) printf(" std = %.6f (expect 2.0)\n", s) - check("std ~= 2", approx_eq(s, t.CDouble(2.0)), "mismatch") + check("std ~= 2", approx_eq(s, double(2.0)), "mismatch") - b: numpy.ndarray[t.CDouble] | t.CPtr = vec2(pool, t.CDouble(3.0), t.CDouble(4.0)) - n: t.CDouble = numpy.norm(b) + b: numpy.ndarray[double] | t.CPtr = vec2(pool, double(3.0), double(4.0)) + n: double = numpy.norm(b) printf(" norm = %.6f (expect 5.0)\n", n) - check("norm ~= 5", approx_eq(n, t.CDouble(5.0)), "mismatch") + check("norm ~= 5", approx_eq(n, double(5.0)), "mismatch") a.delete() b.delete() @@ -419,19 +419,19 @@ def test_var_std_norm(): def test_clip_concatenate(): section_header("clip / concatenate") - a: numpy.ndarray[t.CDouble] | t.CPtr = vec3(pool, t.CDouble(1.0), t.CDouble(5.0), t.CDouble(10.0)) - r: numpy.ndarray[t.CDouble] | t.CPtr = numpy.clip(a, t.CDouble(2.0), t.CDouble(8.0)) - check("clip [0]==2", r.data[0] == t.CDouble(2.0), "mismatch") - check("clip [1]==5", r.data[1] == t.CDouble(5.0), "mismatch") - check("clip [2]==8", r.data[2] == t.CDouble(8.0), "mismatch") + a: numpy.ndarray[double] | t.CPtr = vec3(pool, double(1.0), double(5.0), double(10.0)) + r: numpy.ndarray[double] | t.CPtr = numpy.clip(a, double(2.0), double(8.0)) + check("clip [0]==2", r.data[0] == double(2.0), "mismatch") + check("clip [1]==5", r.data[1] == double(5.0), "mismatch") + check("clip [2]==8", r.data[2] == double(8.0), "mismatch") - b: numpy.ndarray[t.CDouble] | t.CPtr = vec2(pool, t.CDouble(1.0), t.CDouble(2.0)) - c: numpy.ndarray[t.CDouble] | t.CPtr = vec2(pool, t.CDouble(3.0), t.CDouble(4.0)) - cat: numpy.ndarray[t.CDouble] | t.CPtr = numpy.concatenate(b, c) + b: numpy.ndarray[double] | t.CPtr = vec2(pool, double(1.0), double(2.0)) + c: numpy.ndarray[double] | t.CPtr = vec2(pool, double(3.0), double(4.0)) + cat: numpy.ndarray[double] | t.CPtr = numpy.concatenate(b, c) check("concatenate not None", cat != None, "concatenate returned None") check("concatenate size == 4", cat.size == 4, "size mismatch") - check("concatenate [0]==1", cat.data[0] == t.CDouble(1.0), "mismatch") - check("concatenate [3]==4", cat.data[3] == t.CDouble(4.0), "mismatch") + check("concatenate [0]==1", cat.data[0] == double(1.0), "mismatch") + check("concatenate [3]==4", cat.data[3] == double(4.0), "mismatch") a.delete() r.delete() @@ -444,18 +444,18 @@ def test_clip_concatenate(): def test_sort_reverse(): section_header("sort_arr / reverse") - a: numpy.ndarray[t.CDouble] | t.CPtr = vec3(pool, t.CDouble(3.0), t.CDouble(1.0), t.CDouble(2.0)) - s: numpy.ndarray[t.CDouble] | t.CPtr = numpy.sort_arr(a) + a: numpy.ndarray[double] | t.CPtr = vec3(pool, double(3.0), double(1.0), double(2.0)) + s: numpy.ndarray[double] | t.CPtr = numpy.sort_arr(a) check("sort not None", s != None, "sort returned None") - check("sort [0]==1", s.data[0] == t.CDouble(1.0), "mismatch") - check("sort [1]==2", s.data[1] == t.CDouble(2.0), "mismatch") - check("sort [2]==3", s.data[2] == t.CDouble(3.0), "mismatch") + check("sort [0]==1", s.data[0] == double(1.0), "mismatch") + check("sort [1]==2", s.data[1] == double(2.0), "mismatch") + check("sort [2]==3", s.data[2] == double(3.0), "mismatch") - r: numpy.ndarray[t.CDouble] | t.CPtr = numpy.reverse(a) + r: numpy.ndarray[double] | t.CPtr = numpy.reverse(a) check("reverse not None", r != None, "reverse returned None") - check("reverse [0]==2", r.data[0] == t.CDouble(2.0), "mismatch") - check("reverse [1]==1", r.data[1] == t.CDouble(1.0), "mismatch") - check("reverse [2]==3", r.data[2] == t.CDouble(3.0), "mismatch") + check("reverse [0]==2", r.data[0] == double(2.0), "mismatch") + check("reverse [1]==1", r.data[1] == double(1.0), "mismatch") + check("reverse [2]==3", r.data[2] == double(3.0), "mismatch") a.delete() s.delete() @@ -466,11 +466,11 @@ def test_sort_reverse(): def test_print_arr(): section_header("print_arr") - a: numpy.ndarray[t.CDouble] | t.CPtr = vec3(pool, t.CDouble(1.0), t.CDouble(2.0), t.CDouble(3.0)) + a: numpy.ndarray[double] | t.CPtr = vec3(pool, double(1.0), double(2.0), double(3.0)) printf(" 1D array: ") a.print_arr() - b: numpy.ndarray[t.CDouble] | t.CPtr = numpy.eye(pool, 3) + b: numpy.ndarray[double] | t.CPtr = numpy.eye(pool, 3) printf(" 2D eye(3):\n") b.print_arr() @@ -485,18 +485,18 @@ def test_print_arr(): def test_floordiv_mod(): section_header("__floordiv__ / __mod__") - a: numpy.ndarray[t.CDouble] | t.CPtr = vec3(pool, t.CDouble(7.0), t.CDouble(10.0), t.CDouble(15.0)) - b: numpy.ndarray[t.CDouble] | t.CPtr = vec3(pool, t.CDouble(2.0), t.CDouble(3.0), t.CDouble(4.0)) + a: numpy.ndarray[double] | t.CPtr = vec3(pool, double(7.0), double(10.0), double(15.0)) + b: numpy.ndarray[double] | t.CPtr = vec3(pool, double(2.0), double(3.0), double(4.0)) - c_fd: numpy.ndarray[t.CDouble] | t.CPtr = a // b - check("7//2==3", c_fd.data[0] == t.CDouble(3.0), "mismatch") - check("10//3==3", c_fd.data[1] == t.CDouble(3.0), "mismatch") - check("15//4==3", c_fd.data[2] == t.CDouble(3.0), "mismatch") + c_fd: numpy.ndarray[double] | t.CPtr = a // b + check("7//2==3", c_fd.data[0] == double(3.0), "mismatch") + check("10//3==3", c_fd.data[1] == double(3.0), "mismatch") + check("15//4==3", c_fd.data[2] == double(3.0), "mismatch") - c_mod: numpy.ndarray[t.CDouble] | t.CPtr = a % b - check("7%%2==1", c_mod.data[0] == t.CDouble(1.0), "mismatch") - check("10%%3==1", c_mod.data[1] == t.CDouble(1.0), "mismatch") - check("15%%4==3", c_mod.data[2] == t.CDouble(3.0), "mismatch") + c_mod: numpy.ndarray[double] | t.CPtr = a % b + check("7%%2==1", c_mod.data[0] == double(1.0), "mismatch") + check("10%%3==1", c_mod.data[1] == double(1.0), "mismatch") + check("15%%4==3", c_mod.data[2] == double(3.0), "mismatch") a.delete() b.delete() @@ -511,38 +511,38 @@ def test_floordiv_mod(): def test_additional_math(): section_header("np_log10 / np_log2 / np_floor / np_ceil / np_round / np_sign") - a: numpy.ndarray[t.CDouble] | t.CPtr = vec3(pool, t.CDouble(10.0), t.CDouble(100.0), t.CDouble(1000.0)) - r_log10: numpy.ndarray[t.CDouble] | t.CPtr = numpy.np_log10(a) - check("log10(10)~=1", approx_loose(r_log10.data[0], t.CDouble(1.0)), "mismatch") - check("log10(100)~=2", approx_loose(r_log10.data[1], t.CDouble(2.0)), "mismatch") + a: numpy.ndarray[double] | t.CPtr = vec3(pool, double(10.0), double(100.0), double(1000.0)) + r_log10: numpy.ndarray[double] | t.CPtr = numpy.np_log10(a) + check("log10(10)~=1", approx_loose(r_log10.data[0], double(1.0)), "mismatch") + check("log10(100)~=2", approx_loose(r_log10.data[1], double(2.0)), "mismatch") - b: numpy.ndarray[t.CDouble] | t.CPtr = vec3(pool, t.CDouble(2.0), t.CDouble(4.0), t.CDouble(8.0)) - r_log2: numpy.ndarray[t.CDouble] | t.CPtr = numpy.np_log2(b) - check("log2(2)~=1", approx_loose(r_log2.data[0], t.CDouble(1.0)), "mismatch") - check("log2(4)~=2", approx_loose(r_log2.data[1], t.CDouble(2.0)), "mismatch") + b: numpy.ndarray[double] | t.CPtr = vec3(pool, double(2.0), double(4.0), double(8.0)) + r_log2: numpy.ndarray[double] | t.CPtr = numpy.np_log2(b) + check("log2(2)~=1", approx_loose(r_log2.data[0], double(1.0)), "mismatch") + check("log2(4)~=2", approx_loose(r_log2.data[1], double(2.0)), "mismatch") - c: numpy.ndarray[t.CDouble] | t.CPtr = vec3(pool, t.CDouble(1.5), t.CDouble(2.7), t.CDouble(-1.3)) - r_floor: numpy.ndarray[t.CDouble] | t.CPtr = numpy.np_floor(c) - check("floor(1.5)==1", r_floor.data[0] == t.CDouble(1.0), "mismatch") - check("floor(2.7)==2", r_floor.data[1] == t.CDouble(2.0), "mismatch") - check("floor(-1.3)==-2", r_floor.data[2] == t.CDouble(-2.0), "mismatch") + c: numpy.ndarray[double] | t.CPtr = vec3(pool, double(1.5), double(2.7), double(-1.3)) + r_floor: numpy.ndarray[double] | t.CPtr = numpy.np_floor(c) + check("floor(1.5)==1", r_floor.data[0] == double(1.0), "mismatch") + check("floor(2.7)==2", r_floor.data[1] == double(2.0), "mismatch") + check("floor(-1.3)==-2", r_floor.data[2] == double(-2.0), "mismatch") - r_ceil: numpy.ndarray[t.CDouble] | t.CPtr = numpy.np_ceil(c) - check("ceil(1.5)==2", r_ceil.data[0] == t.CDouble(2.0), "mismatch") - check("ceil(2.7)==3", r_ceil.data[1] == t.CDouble(3.0), "mismatch") - check("ceil(-1.3)==-1", r_ceil.data[2] == t.CDouble(-1.0), "mismatch") + r_ceil: numpy.ndarray[double] | t.CPtr = numpy.np_ceil(c) + check("ceil(1.5)==2", r_ceil.data[0] == double(2.0), "mismatch") + check("ceil(2.7)==3", r_ceil.data[1] == double(3.0), "mismatch") + check("ceil(-1.3)==-1", r_ceil.data[2] == double(-1.0), "mismatch") - d: numpy.ndarray[t.CDouble] | t.CPtr = vec3(pool, t.CDouble(1.4), t.CDouble(2.5), t.CDouble(3.6)) - r_round: numpy.ndarray[t.CDouble] | t.CPtr = numpy.np_round(d) - check("round(1.4)==1", r_round.data[0] == t.CDouble(1.0), "mismatch") - check("round(3.6)==4", r_round.data[2] == t.CDouble(4.0), "mismatch") + d: numpy.ndarray[double] | t.CPtr = vec3(pool, double(1.4), double(2.5), double(3.6)) + r_round: numpy.ndarray[double] | t.CPtr = numpy.np_round(d) + check("round(1.4)==1", r_round.data[0] == double(1.0), "mismatch") + check("round(3.6)==4", r_round.data[2] == double(4.0), "mismatch") - e: numpy.ndarray[t.CDouble] | t.CPtr = numpy.zeros(pool, 4) - e.data[0] = t.CDouble(-3.0); e.data[1] = t.CDouble(0.0); e.data[2] = t.CDouble(5.0); e.data[3] = t.CDouble(-0.1) - r_sign: numpy.ndarray[t.CDouble] | t.CPtr = numpy.np_sign(e) - check("sign(-3)==-1", r_sign.data[0] == t.CDouble(-1.0), "mismatch") - check("sign(0)==0", r_sign.data[1] == t.CDouble(0.0), "mismatch") - check("sign(5)==1", r_sign.data[2] == t.CDouble(1.0), "mismatch") + e: numpy.ndarray[double] | t.CPtr = numpy.zeros(pool, 4) + e.data[0] = double(-3.0); e.data[1] = double(0.0); e.data[2] = double(5.0); e.data[3] = double(-0.1) + r_sign: numpy.ndarray[double] | t.CPtr = numpy.np_sign(e) + check("sign(-3)==-1", r_sign.data[0] == double(-1.0), "mismatch") + check("sign(0)==0", r_sign.data[1] == double(0.0), "mismatch") + check("sign(5)==1", r_sign.data[2] == double(1.0), "mismatch") a.delete() b.delete() @@ -561,26 +561,26 @@ def test_additional_math(): def test_trig_hyperbolic(): section_header("np_tanh / np_sinh / np_cosh / np_arcsin / np_arccos / np_arctan") - a: numpy.ndarray[t.CDouble] | t.CPtr = vec3(pool, t.CDouble(0.0), t.CDouble(1.0), t.CDouble(-1.0)) + a: numpy.ndarray[double] | t.CPtr = vec3(pool, double(0.0), double(1.0), double(-1.0)) - r_tanh: numpy.ndarray[t.CDouble] | t.CPtr = numpy.np_tanh(a) - check("tanh(0)~=0", approx_loose(r_tanh.data[0], t.CDouble(0.0)), "mismatch") + r_tanh: numpy.ndarray[double] | t.CPtr = numpy.np_tanh(a) + check("tanh(0)~=0", approx_loose(r_tanh.data[0], double(0.0)), "mismatch") - r_sinh: numpy.ndarray[t.CDouble] | t.CPtr = numpy.np_sinh(a) - check("sinh(0)~=0", approx_loose(r_sinh.data[0], t.CDouble(0.0)), "mismatch") + r_sinh: numpy.ndarray[double] | t.CPtr = numpy.np_sinh(a) + check("sinh(0)~=0", approx_loose(r_sinh.data[0], double(0.0)), "mismatch") - r_cosh: numpy.ndarray[t.CDouble] | t.CPtr = numpy.np_cosh(a) - check("cosh(0)~=1", approx_loose(r_cosh.data[0], t.CDouble(1.0)), "mismatch") + r_cosh: numpy.ndarray[double] | t.CPtr = numpy.np_cosh(a) + check("cosh(0)~=1", approx_loose(r_cosh.data[0], double(1.0)), "mismatch") - b: numpy.ndarray[t.CDouble] | t.CPtr = vec2(pool, t.CDouble(0.0), t.CDouble(0.5)) - r_asin: numpy.ndarray[t.CDouble] | t.CPtr = numpy.np_arcsin(b) - check("arcsin(0)~=0", approx_loose(r_asin.data[0], t.CDouble(0.0)), "mismatch") + b: numpy.ndarray[double] | t.CPtr = vec2(pool, double(0.0), double(0.5)) + r_asin: numpy.ndarray[double] | t.CPtr = numpy.np_arcsin(b) + check("arcsin(0)~=0", approx_loose(r_asin.data[0], double(0.0)), "mismatch") - r_acos: numpy.ndarray[t.CDouble] | t.CPtr = numpy.np_arccos(b) - check("arccos(0)~=pi/2", approx_loose(r_acos.data[0], t.CDouble(1.5707963)), "mismatch") + r_acos: numpy.ndarray[double] | t.CPtr = numpy.np_arccos(b) + check("arccos(0)~=pi/2", approx_loose(r_acos.data[0], double(1.5707963)), "mismatch") - r_atan: numpy.ndarray[t.CDouble] | t.CPtr = numpy.np_arctan(b) - check("arctan(0)~=0", approx_loose(r_atan.data[0], t.CDouble(0.0)), "mismatch") + r_atan: numpy.ndarray[double] | t.CPtr = numpy.np_arctan(b) + check("arctan(0)~=0", approx_loose(r_atan.data[0], double(0.0)), "mismatch") a.delete() b.delete() @@ -596,16 +596,16 @@ def test_trig_hyperbolic(): def test_degrees_radians(): section_header("np_degrees / np_radians") - a: numpy.ndarray[t.CDouble] | t.CPtr = vec2(pool, t.CDouble(0.0), t.CDouble(1.5707963267948966)) + a: numpy.ndarray[double] | t.CPtr = vec2(pool, double(0.0), double(1.5707963267948966)) - r_deg: numpy.ndarray[t.CDouble] | t.CPtr = numpy.np_degrees(a) - check("deg(0)~=0", approx_loose(r_deg.data[0], t.CDouble(0.0)), "mismatch") - check("deg(pi/2)~=90", approx_loose(r_deg.data[1], t.CDouble(90.0)), "mismatch") + r_deg: numpy.ndarray[double] | t.CPtr = numpy.np_degrees(a) + check("deg(0)~=0", approx_loose(r_deg.data[0], double(0.0)), "mismatch") + check("deg(pi/2)~=90", approx_loose(r_deg.data[1], double(90.0)), "mismatch") - b: numpy.ndarray[t.CDouble] | t.CPtr = vec2(pool, t.CDouble(0.0), t.CDouble(90.0)) - r_rad: numpy.ndarray[t.CDouble] | t.CPtr = numpy.np_radians(b) - check("rad(0)~=0", approx_loose(r_rad.data[0], t.CDouble(0.0)), "mismatch") - check("rad(90)~=pi/2", approx_loose(r_rad.data[1], t.CDouble(1.5707963)), "mismatch") + b: numpy.ndarray[double] | t.CPtr = vec2(pool, double(0.0), double(90.0)) + r_rad: numpy.ndarray[double] | t.CPtr = numpy.np_radians(b) + check("rad(0)~=0", approx_loose(r_rad.data[0], double(0.0)), "mismatch") + check("rad(90)~=pi/2", approx_loose(r_rad.data[1], double(1.5707963)), "mismatch") a.delete() b.delete() @@ -620,21 +620,21 @@ def test_degrees_radians(): def test_cumsum_diff(): section_header("cumsum / diff") - a: numpy.ndarray[t.CDouble] | t.CPtr = numpy.zeros(pool, 4) - a.data[0] = t.CDouble(1.0); a.data[1] = t.CDouble(2.0); a.data[2] = t.CDouble(3.0); a.data[3] = t.CDouble(4.0) + a: numpy.ndarray[double] | t.CPtr = numpy.zeros(pool, 4) + a.data[0] = double(1.0); a.data[1] = double(2.0); a.data[2] = double(3.0); a.data[3] = double(4.0) - r_cs: numpy.ndarray[t.CDouble] | t.CPtr = numpy.cumsum(a) + r_cs: numpy.ndarray[double] | t.CPtr = numpy.cumsum(a) check("cumsum not None", r_cs != None, "cumsum returned None") - check("cumsum[0]==1", r_cs.data[0] == t.CDouble(1.0), "mismatch") - check("cumsum[1]==3", r_cs.data[1] == t.CDouble(3.0), "mismatch") - check("cumsum[2]==6", r_cs.data[2] == t.CDouble(6.0), "mismatch") - check("cumsum[3]==10", r_cs.data[3] == t.CDouble(10.0), "mismatch") + check("cumsum[0]==1", r_cs.data[0] == double(1.0), "mismatch") + check("cumsum[1]==3", r_cs.data[1] == double(3.0), "mismatch") + check("cumsum[2]==6", r_cs.data[2] == double(6.0), "mismatch") + check("cumsum[3]==10", r_cs.data[3] == double(10.0), "mismatch") - r_diff: numpy.ndarray[t.CDouble] | t.CPtr = numpy.diff(a) + r_diff: numpy.ndarray[double] | t.CPtr = numpy.diff(a) check("diff not None", r_diff != None, "diff returned None") check("diff size==3", r_diff.size == 3, "size mismatch") - check("diff[0]==1", r_diff.data[0] == t.CDouble(1.0), "mismatch") - check("diff[2]==1", r_diff.data[2] == t.CDouble(1.0), "mismatch") + check("diff[0]==1", r_diff.data[0] == double(1.0), "mismatch") + check("diff[2]==1", r_diff.data[2] == double(1.0), "mismatch") a.delete() r_cs.delete() @@ -645,25 +645,25 @@ def test_cumsum_diff(): def test_max_min_where(): section_header("np_maximum / np_minimum / np_where") - a: numpy.ndarray[t.CDouble] | t.CPtr = vec3(pool, t.CDouble(1.0), t.CDouble(5.0), t.CDouble(3.0)) - b: numpy.ndarray[t.CDouble] | t.CPtr = vec3(pool, t.CDouble(4.0), t.CDouble(2.0), t.CDouble(6.0)) + a: numpy.ndarray[double] | t.CPtr = vec3(pool, double(1.0), double(5.0), double(3.0)) + b: numpy.ndarray[double] | t.CPtr = vec3(pool, double(4.0), double(2.0), double(6.0)) - r_max: numpy.ndarray[t.CDouble] | t.CPtr = numpy.np_maximum(a, b) - check("maximum[0]==4", r_max.data[0] == t.CDouble(4.0), "mismatch") - check("maximum[1]==5", r_max.data[1] == t.CDouble(5.0), "mismatch") - check("maximum[2]==6", r_max.data[2] == t.CDouble(6.0), "mismatch") + r_max: numpy.ndarray[double] | t.CPtr = numpy.np_maximum(a, b) + check("maximum[0]==4", r_max.data[0] == double(4.0), "mismatch") + check("maximum[1]==5", r_max.data[1] == double(5.0), "mismatch") + check("maximum[2]==6", r_max.data[2] == double(6.0), "mismatch") - r_min: numpy.ndarray[t.CDouble] | t.CPtr = numpy.np_minimum(a, b) - check("minimum[0]==1", r_min.data[0] == t.CDouble(1.0), "mismatch") - check("minimum[1]==2", r_min.data[1] == t.CDouble(2.0), "mismatch") - check("minimum[2]==3", r_min.data[2] == t.CDouble(3.0), "mismatch") + r_min: numpy.ndarray[double] | t.CPtr = numpy.np_minimum(a, b) + check("minimum[0]==1", r_min.data[0] == double(1.0), "mismatch") + check("minimum[1]==2", r_min.data[1] == double(2.0), "mismatch") + check("minimum[2]==3", r_min.data[2] == double(3.0), "mismatch") # where: cond > 0 ? a : b - cond: numpy.ndarray[t.CDouble] | t.CPtr = vec3(pool, t.CDouble(0.0), t.CDouble(1.0), t.CDouble(0.0)) - r_where: numpy.ndarray[t.CDouble] | t.CPtr = numpy.np_where(cond, a, b) - check("where[0]==4", r_where.data[0] == t.CDouble(4.0), "mismatch") - check("where[1]==5", r_where.data[1] == t.CDouble(5.0), "mismatch") - check("where[2]==6", r_where.data[2] == t.CDouble(6.0), "mismatch") + cond: numpy.ndarray[double] | t.CPtr = vec3(pool, double(0.0), double(1.0), double(0.0)) + r_where: numpy.ndarray[double] | t.CPtr = numpy.np_where(cond, a, b) + check("where[0]==4", r_where.data[0] == double(4.0), "mismatch") + check("where[1]==5", r_where.data[1] == double(5.0), "mismatch") + check("where[2]==6", r_where.data[2] == double(6.0), "mismatch") a.delete() b.delete() @@ -677,22 +677,22 @@ def test_max_min_where(): def test_flatten_trace(): section_header("flatten / trace") - a: numpy.ndarray[t.CDouble] | t.CPtr = numpy.empty2d(pool, 2, 3) - a.set2d(0, 0, t.CDouble(1.0)); a.set2d(0, 1, t.CDouble(2.0)); a.set2d(0, 2, t.CDouble(3.0)) - a.set2d(1, 0, t.CDouble(4.0)); a.set2d(1, 1, t.CDouble(5.0)); a.set2d(1, 2, t.CDouble(6.0)) + a: numpy.ndarray[double] | t.CPtr = numpy.empty2d(pool, 2, 3) + a.set2d(0, 0, double(1.0)); a.set2d(0, 1, double(2.0)); a.set2d(0, 2, double(3.0)) + a.set2d(1, 0, double(4.0)); a.set2d(1, 1, double(5.0)); a.set2d(1, 2, double(6.0)) - r_flat: numpy.ndarray[t.CDouble] | t.CPtr = numpy.flatten(a) + r_flat: numpy.ndarray[double] | t.CPtr = numpy.flatten(a) check("flatten not None", r_flat != None, "flatten returned None") check("flatten ndim==1", r_flat.ndim == 1, "ndim mismatch") check("flatten size==6", r_flat.size == 6, "size mismatch") - check("flatten[0]==1", r_flat.data[0] == t.CDouble(1.0), "mismatch") + check("flatten[0]==1", r_flat.data[0] == double(1.0), "mismatch") # trace of [[1,2],[3,4]] = 1+4 = 5 - b: numpy.ndarray[t.CDouble] | t.CPtr = numpy.empty2d(pool, 2, 2) - b.set2d(0, 0, t.CDouble(1.0)); b.set2d(0, 1, t.CDouble(2.0)) - b.set2d(1, 0, t.CDouble(3.0)); b.set2d(1, 1, t.CDouble(4.0)) - tr: t.CDouble = numpy.trace(b) - check("trace == 5", tr == t.CDouble(5.0), "mismatch") + b: numpy.ndarray[double] | t.CPtr = numpy.empty2d(pool, 2, 2) + b.set2d(0, 0, double(1.0)); b.set2d(0, 1, double(2.0)) + b.set2d(1, 0, double(3.0)); b.set2d(1, 1, double(4.0)) + tr: double = numpy.trace(b) + check("trace == 5", tr == double(5.0), "mismatch") a.delete() r_flat.delete() @@ -703,16 +703,16 @@ def test_flatten_trace(): def test_outer(): section_header("outer") - a: numpy.ndarray[t.CDouble] | t.CPtr = vec2(pool, t.CDouble(1.0), t.CDouble(2.0)) - b: numpy.ndarray[t.CDouble] | t.CPtr = vec3(pool, t.CDouble(3.0), t.CDouble(4.0), t.CDouble(5.0)) + a: numpy.ndarray[double] | t.CPtr = vec2(pool, double(1.0), double(2.0)) + b: numpy.ndarray[double] | t.CPtr = vec3(pool, double(3.0), double(4.0), double(5.0)) - r: numpy.ndarray[t.CDouble] | t.CPtr = numpy.outer(a, b) + r: numpy.ndarray[double] | t.CPtr = numpy.outer(a, b) check("outer not None", r != None, "outer returned None") check("outer ndim==2", r.ndim == 2, "ndim mismatch") - check("outer[0,0]==3", r.at2d(0, 0) == t.CDouble(3.0), "mismatch") - check("outer[0,1]==4", r.at2d(0, 1) == t.CDouble(4.0), "mismatch") - check("outer[1,0]==6", r.at2d(1, 0) == t.CDouble(6.0), "mismatch") - check("outer[1,2]==10", r.at2d(1, 2) == t.CDouble(10.0), "mismatch") + check("outer[0,0]==3", r.at2d(0, 0) == double(3.0), "mismatch") + check("outer[0,1]==4", r.at2d(0, 1) == double(4.0), "mismatch") + check("outer[1,0]==6", r.at2d(1, 0) == double(6.0), "mismatch") + check("outer[1,2]==10", r.at2d(1, 2) == double(10.0), "mismatch") a.delete() b.delete() @@ -726,31 +726,31 @@ def test_outer(): def test_bool_comparison(): section_header("np_all / np_any / np_count_nonzero / np_equal / np_less / np_greater") - a: numpy.ndarray[t.CDouble] | t.CPtr = numpy.zeros(pool, 4) - a.data[0] = t.CDouble(1.0); a.data[1] = t.CDouble(0.0); a.data[2] = t.CDouble(3.0); a.data[3] = t.CDouble(0.0) + a: numpy.ndarray[double] | t.CPtr = numpy.zeros(pool, 4) + a.data[0] = double(1.0); a.data[1] = double(0.0); a.data[2] = double(3.0); a.data[3] = double(0.0) check("count_nonzero==2", numpy.np_count_nonzero(a) == 2, "mismatch") check("any==1", numpy.np_any(a) == 1, "mismatch") - b: numpy.ndarray[t.CDouble] | t.CPtr = vec3(pool, t.CDouble(1.0), t.CDouble(2.0), t.CDouble(3.0)) + b: numpy.ndarray[double] | t.CPtr = vec3(pool, double(1.0), double(2.0), double(3.0)) check("all(1,2,3)==1", numpy.np_all(b) == 1, "mismatch") - c: numpy.ndarray[t.CDouble] | t.CPtr = numpy.zeros(pool, 3) + c: numpy.ndarray[double] | t.CPtr = numpy.zeros(pool, 3) check("all(0,0,0)==0", numpy.np_all(c) == 0, "mismatch") check("any(0,0,0)==0", numpy.np_any(c) == 0, "mismatch") - d: numpy.ndarray[t.CDouble] | t.CPtr = vec3(pool, t.CDouble(1.0), t.CDouble(2.0), t.CDouble(3.0)) - e: numpy.ndarray[t.CDouble] | t.CPtr = vec3(pool, t.CDouble(1.0), t.CDouble(0.0), t.CDouble(4.0)) + d: numpy.ndarray[double] | t.CPtr = vec3(pool, double(1.0), double(2.0), double(3.0)) + e: numpy.ndarray[double] | t.CPtr = vec3(pool, double(1.0), double(0.0), double(4.0)) - r_eq: numpy.ndarray[t.CDouble] | t.CPtr = numpy.np_equal(d, e) - check("equal[0]==1", r_eq.data[0] == t.CDouble(1.0), "mismatch") - check("equal[1]==0", r_eq.data[1] == t.CDouble(0.0), "mismatch") + r_eq: numpy.ndarray[double] | t.CPtr = numpy.np_equal(d, e) + check("equal[0]==1", r_eq.data[0] == double(1.0), "mismatch") + check("equal[1]==0", r_eq.data[1] == double(0.0), "mismatch") - r_lt: numpy.ndarray[t.CDouble] | t.CPtr = numpy.np_less(d, e) - check("less[2]==1", r_lt.data[2] == t.CDouble(1.0), "mismatch") - check("less[0]==0", r_lt.data[0] == t.CDouble(0.0), "mismatch") + r_lt: numpy.ndarray[double] | t.CPtr = numpy.np_less(d, e) + check("less[2]==1", r_lt.data[2] == double(1.0), "mismatch") + check("less[0]==0", r_lt.data[0] == double(0.0), "mismatch") - r_gt: numpy.ndarray[t.CDouble] | t.CPtr = numpy.np_greater(d, e) - check("greater[1]==1", r_gt.data[1] == t.CDouble(1.0), "mismatch") + r_gt: numpy.ndarray[double] | t.CPtr = numpy.np_greater(d, e) + check("greater[1]==1", r_gt.data[1] == double(1.0), "mismatch") a.delete() b.delete() @@ -770,38 +770,38 @@ def test_linalg(): section_header("det2x2 / inv2x2 / cross3 / prod / median / percentile") # det2x2: [[1,2],[3,4]] -> 1*4-2*3 = -2 - a: numpy.ndarray[t.CDouble] | t.CPtr = numpy.empty2d(pool, 2, 2) - a.set2d(0, 0, t.CDouble(1.0)); a.set2d(0, 1, t.CDouble(2.0)) - a.set2d(1, 0, t.CDouble(3.0)); a.set2d(1, 1, t.CDouble(4.0)) - d: t.CDouble = numpy.det2x2(a) - check("det2x2==-2", d == t.CDouble(-2.0), "mismatch") + a: numpy.ndarray[double] | t.CPtr = numpy.empty2d(pool, 2, 2) + a.set2d(0, 0, double(1.0)); a.set2d(0, 1, double(2.0)) + a.set2d(1, 0, double(3.0)); a.set2d(1, 1, double(4.0)) + d: double = numpy.det2x2(a) + check("det2x2==-2", d == double(-2.0), "mismatch") # inv2x2 of [[1,2],[3,4]] - inv: numpy.ndarray[t.CDouble] | t.CPtr = numpy.inv2x2(a) + inv: numpy.ndarray[double] | t.CPtr = numpy.inv2x2(a) check("inv2x2 not None", inv != None, "inv2x2 returned None") - check("inv[0,0]==-2", approx_eq(inv.at2d(0, 0), t.CDouble(-2.0)), "mismatch") - check("inv[0,1]==1", approx_eq(inv.at2d(0, 1), t.CDouble(1.0)), "mismatch") + check("inv[0,0]==-2", approx_eq(inv.at2d(0, 0), double(-2.0)), "mismatch") + check("inv[0,1]==1", approx_eq(inv.at2d(0, 1), double(1.0)), "mismatch") # cross3: [1,0,0] x [0,1,0] = [0,0,1] - x: numpy.ndarray[t.CDouble] | t.CPtr = vec3(pool, t.CDouble(1.0), t.CDouble(0.0), t.CDouble(0.0)) - y: numpy.ndarray[t.CDouble] | t.CPtr = vec3(pool, t.CDouble(0.0), t.CDouble(1.0), t.CDouble(0.0)) - cr: numpy.ndarray[t.CDouble] | t.CPtr = numpy.cross3(x, y) + x: numpy.ndarray[double] | t.CPtr = vec3(pool, double(1.0), double(0.0), double(0.0)) + y: numpy.ndarray[double] | t.CPtr = vec3(pool, double(0.0), double(1.0), double(0.0)) + cr: numpy.ndarray[double] | t.CPtr = numpy.cross3(x, y) check("cross not None", cr != None, "cross returned None") - check("cross[2]==1", cr.data[2] == t.CDouble(1.0), "mismatch") + check("cross[2]==1", cr.data[2] == double(1.0), "mismatch") # prod - p: numpy.ndarray[t.CDouble] | t.CPtr = numpy.zeros(pool, 4) - p.data[0] = t.CDouble(1.0); p.data[1] = t.CDouble(2.0); p.data[2] = t.CDouble(3.0); p.data[3] = t.CDouble(4.0) - check("prod==24", numpy.prod(p) == t.CDouble(24.0), "mismatch") + p: numpy.ndarray[double] | t.CPtr = numpy.zeros(pool, 4) + p.data[0] = double(1.0); p.data[1] = double(2.0); p.data[2] = double(3.0); p.data[3] = double(4.0) + check("prod==24", numpy.prod(p) == double(24.0), "mismatch") # median - m: numpy.ndarray[t.CDouble] | t.CPtr = numpy.zeros(pool, 5) - m.data[0] = t.CDouble(3.0); m.data[1] = t.CDouble(1.0); m.data[2] = t.CDouble(2.0) - m.data[3] = t.CDouble(5.0); m.data[4] = t.CDouble(4.0) - check("median==3", numpy.median(m) == t.CDouble(3.0), "mismatch") + m: numpy.ndarray[double] | t.CPtr = numpy.zeros(pool, 5) + m.data[0] = double(3.0); m.data[1] = double(1.0); m.data[2] = double(2.0) + m.data[3] = double(5.0); m.data[4] = double(4.0) + check("median==3", numpy.median(m) == double(3.0), "mismatch") # percentile - check("p50==3", approx_eq(numpy.percentile(m, t.CDouble(50.0)), t.CDouble(3.0)), "mismatch") + check("p50==3", approx_eq(numpy.percentile(m, double(50.0)), double(3.0)), "mismatch") a.delete() inv.delete() @@ -819,31 +819,31 @@ def test_linalg(): def test_additional_creation(): section_header("full2d / zeros_like / ones_like / arange1 / constants") - f: numpy.ndarray[t.CDouble] | t.CPtr = numpy.full2d(pool, 2, 3, t.CDouble(7.0)) + f: numpy.ndarray[double] | t.CPtr = numpy.full2d(pool, 2, 3, double(7.0)) check("full2d not None", f != None, "full2d returned None") check("full2d ndim==2", f.ndim == 2, "ndim mismatch") - check("full2d[0,0]==7", f.at2d(0, 0) == t.CDouble(7.0), "mismatch") - check("full2d[1,2]==7", f.at2d(1, 2) == t.CDouble(7.0), "mismatch") + check("full2d[0,0]==7", f.at2d(0, 0) == double(7.0), "mismatch") + check("full2d[1,2]==7", f.at2d(1, 2) == double(7.0), "mismatch") - a: numpy.ndarray[t.CDouble] | t.CPtr = vec3(pool, t.CDouble(1.0), t.CDouble(2.0), t.CDouble(3.0)) - zl: numpy.ndarray[t.CDouble] | t.CPtr = numpy.zeros_like(a) + a: numpy.ndarray[double] | t.CPtr = vec3(pool, double(1.0), double(2.0), double(3.0)) + zl: numpy.ndarray[double] | t.CPtr = numpy.zeros_like(a) check("zeros_like not None", zl != None, "returned None") check("zeros_like size==3", zl.size == 3, "size mismatch") - check("zeros_like[0]==0", zl.data[0] == t.CDouble(0.0), "mismatch") + check("zeros_like[0]==0", zl.data[0] == double(0.0), "mismatch") - ol: numpy.ndarray[t.CDouble] | t.CPtr = numpy.ones_like(a) + ol: numpy.ndarray[double] | t.CPtr = numpy.ones_like(a) check("ones_like not None", ol != None, "returned None") - check("ones_like[0]==1", ol.data[0] == t.CDouble(1.0), "mismatch") + check("ones_like[0]==1", ol.data[0] == double(1.0), "mismatch") - ar: numpy.ndarray[t.CDouble] | t.CPtr = numpy.arange1(pool, t.CDouble(4.0)) + ar: numpy.ndarray[double] | t.CPtr = numpy.arange1(pool, double(4.0)) check("arange1 not None", ar != None, "returned None") check("arange1 size==4", ar.size == 4, "size mismatch") - check("arange1[0]==0", ar.data[0] == t.CDouble(0.0), "mismatch") - check("arange1[3]==3", ar.data[3] == t.CDouble(3.0), "mismatch") + check("arange1[0]==0", ar.data[0] == double(0.0), "mismatch") + check("arange1[3]==3", ar.data[3] == double(3.0), "mismatch") # Constants - check("pi ~= 3.14", approx_loose(numpy.pi, t.CDouble(3.14159265)), "mismatch") - check("e ~= 2.71", approx_loose(numpy.e, t.CDouble(2.71828182)), "mismatch") + check("pi ~= 3.14", approx_loose(numpy.pi, double(3.14159265)), "mismatch") + check("e ~= 2.71", approx_loose(numpy.e, double(2.71828182)), "mismatch") f.delete() a.delete() @@ -859,20 +859,20 @@ def test_additional_creation(): def test_interp(): section_header("np_interp") - xp: numpy.ndarray[t.CDouble] | t.CPtr = vec3(pool, t.CDouble(0.0), t.CDouble(1.0), t.CDouble(2.0)) - fp: numpy.ndarray[t.CDouble] | t.CPtr = vec3(pool, t.CDouble(0.0), t.CDouble(10.0), t.CDouble(20.0)) + xp: numpy.ndarray[double] | t.CPtr = vec3(pool, double(0.0), double(1.0), double(2.0)) + fp: numpy.ndarray[double] | t.CPtr = vec3(pool, double(0.0), double(10.0), double(20.0)) - v: t.CDouble = numpy.np_interp(t.CDouble(0.5), xp, fp) - check("interp(0.5)==5", approx_eq(v, t.CDouble(5.0)), "mismatch") + v: double = numpy.np_interp(double(0.5), xp, fp) + check("interp(0.5)==5", approx_eq(v, double(5.0)), "mismatch") - v2: t.CDouble = numpy.np_interp(t.CDouble(1.5), xp, fp) - check("interp(1.5)==15", approx_eq(v2, t.CDouble(15.0)), "mismatch") + v2: double = numpy.np_interp(double(1.5), xp, fp) + check("interp(1.5)==15", approx_eq(v2, double(15.0)), "mismatch") - v3: t.CDouble = numpy.np_interp(t.CDouble(-1.0), xp, fp) - check("interp(-1)==0", approx_eq(v3, t.CDouble(0.0)), "mismatch") + v3: double = numpy.np_interp(double(-1.0), xp, fp) + check("interp(-1)==0", approx_eq(v3, double(0.0)), "mismatch") - v4: t.CDouble = numpy.np_interp(t.CDouble(3.0), xp, fp) - check("interp(3)==20", approx_eq(v4, t.CDouble(20.0)), "mismatch") + v4: double = numpy.np_interp(double(3.0), xp, fp) + check("interp(3)==20", approx_eq(v4, double(20.0)), "mismatch") xp.delete() fp.delete() @@ -886,51 +886,51 @@ def test_numpy_edge(): section_header("edge: size=0 / size=1 / non-SIMD-block / negative / div-zero") # size=0: pool.alloc(0) returns None, so zeros(0) returns None (expected) - a0: numpy.ndarray[t.CDouble] | t.CPtr = numpy.zeros(pool, 0) + a0: numpy.ndarray[double] | t.CPtr = numpy.zeros(pool, 0) check("zeros(0) returns None", a0 == None, "expected None for size=0") # size=1 - a1: numpy.ndarray[t.CDouble] | t.CPtr = numpy.zeros(pool, 1) + a1: numpy.ndarray[double] | t.CPtr = numpy.zeros(pool, 1) check("zeros(1) not None", a1 != None, "returned None") check("zeros(1) size==1", a1.size == 1, "size mismatch") - check("zeros(1) [0]==0", a1.data[0] == t.CDouble(0.0), "mismatch") + check("zeros(1) [0]==0", a1.data[0] == double(0.0), "mismatch") a1.delete() # non-SIMD-block sizes (1,2,3,5,6,7) - a5: numpy.ndarray[t.CDouble] | t.CPtr = numpy.arange(pool, t.CDouble(0.0), t.CDouble(5.0), t.CDouble(1.0)) + a5: numpy.ndarray[double] | t.CPtr = numpy.arange(pool, double(0.0), double(5.0), double(1.0)) check("arange(5) size==5", a5.size == 5, "size mismatch") - check("arange(5) sum==10", approx_eq(a5.sum(), t.CDouble(10.0)), "mismatch") + check("arange(5) sum==10", approx_eq(a5.sum(), double(10.0)), "mismatch") a5.delete() - a6: numpy.ndarray[t.CDouble] | t.CPtr = numpy.arange(pool, t.CDouble(0.0), t.CDouble(6.0), t.CDouble(1.0)) - check("arange(6) sum==15", approx_eq(a6.sum(), t.CDouble(15.0)), "mismatch") + a6: numpy.ndarray[double] | t.CPtr = numpy.arange(pool, double(0.0), double(6.0), double(1.0)) + check("arange(6) sum==15", approx_eq(a6.sum(), double(15.0)), "mismatch") a6.delete() - a7: numpy.ndarray[t.CDouble] | t.CPtr = numpy.arange(pool, t.CDouble(0.0), t.CDouble(7.0), t.CDouble(1.0)) - check("arange(7) sum==21", approx_eq(a7.sum(), t.CDouble(21.0)), "mismatch") + a7: numpy.ndarray[double] | t.CPtr = numpy.arange(pool, double(0.0), double(7.0), double(1.0)) + check("arange(7) sum==21", approx_eq(a7.sum(), double(21.0)), "mismatch") a7.delete() # negative values in sqrt - neg_arr: numpy.ndarray[t.CDouble] | t.CPtr = vec3(pool, t.CDouble(-1.0), t.CDouble(0.0), t.CDouble(4.0)) - r_sqrt_neg: numpy.ndarray[t.CDouble] | t.CPtr = numpy.np_sqrt(neg_arr) + neg_arr: numpy.ndarray[double] | t.CPtr = vec3(pool, double(-1.0), double(0.0), double(4.0)) + r_sqrt_neg: numpy.ndarray[double] | t.CPtr = numpy.np_sqrt(neg_arr) check("sqrt(neg) not None", r_sqrt_neg != None, "returned None") # sqrt(4)=2, sqrt(0)=0; sqrt(-1) is NaN (implementation-defined) - check("sqrt(4)==2", approx_eq(r_sqrt_neg.data[2], t.CDouble(2.0)), "mismatch") + check("sqrt(4)==2", approx_eq(r_sqrt_neg.data[2], double(2.0)), "mismatch") neg_arr.delete() r_sqrt_neg.delete() # div-by-zero: b/a where a has zeros - za: numpy.ndarray[t.CDouble] | t.CPtr = vec3(pool, t.CDouble(0.0), t.CDouble(2.0), t.CDouble(0.0)) - zb: numpy.ndarray[t.CDouble] | t.CPtr = vec3(pool, t.CDouble(6.0), t.CDouble(4.0), t.CDouble(8.0)) - r_divz: numpy.ndarray[t.CDouble] | t.CPtr = za / zb - check("0/6==0", r_divz.data[0] == t.CDouble(0.0), "mismatch") - check("2/4==0.5", r_divz.data[1] == t.CDouble(0.5), "mismatch") + za: numpy.ndarray[double] | t.CPtr = vec3(pool, double(0.0), double(2.0), double(0.0)) + zb: numpy.ndarray[double] | t.CPtr = vec3(pool, double(6.0), double(4.0), double(8.0)) + r_divz: numpy.ndarray[double] | t.CPtr = za / zb + check("0/6==0", r_divz.data[0] == double(0.0), "mismatch") + check("2/4==0.5", r_divz.data[1] == double(0.5), "mismatch") za.delete() zb.delete() r_divz.delete() # large array (non-aligned, non-SIMD-block) - big: numpy.ndarray[t.CDouble] | t.CPtr = numpy.zeros(pool, 1000) + big: numpy.ndarray[double] | t.CPtr = numpy.zeros(pool, 1000) check("zeros(1000) not None", big != None, "returned None") check("zeros(1000) size==1000", big.size == 1000, "size mismatch") big.delete() @@ -944,46 +944,46 @@ def test_numpy_edge(): def bench_numpy_perf(): section_header("Benchmark: numpy ops") - N: t.CSizeT = 10000 - ITERS: t.CInt = 5 + N: sizet = 10000 + ITERS: int = 5 - a: numpy.ndarray[t.CDouble] | t.CPtr = numpy.zeros(pool, N) - b: numpy.ndarray[t.CDouble] | t.CPtr = numpy.zeros(pool, N) - i: t.CSizeT = 0 + a: numpy.ndarray[double] | t.CPtr = numpy.zeros(pool, N) + b: numpy.ndarray[double] | t.CPtr = numpy.zeros(pool, N) + i: sizet = 0 while i < N: - a.data[i] = t.CDouble(1.0) - b.data[i] = t.CDouble(2.0) + a.data[i] = double(1.0) + b.data[i] = double(2.0) i += 1 # add benchmark - t0: t.CDouble = timer_sec() - j: t.CInt = 0 + t0: double = timer_sec() + j: int = 0 while j < ITERS: - r: numpy.ndarray[t.CDouble] | t.CPtr = a + b + r: numpy.ndarray[double] | t.CPtr = a + b r.delete() j += 1 - t1: t.CDouble = timer_sec() - printf(" ADD: %.1f ms\n", (t1 - t0) * t.CDouble(1000.0)) + t1: double = timer_sec() + printf(" ADD: %.1f ms\n", (t1 - t0) * double(1000.0)) # mul benchmark t0 = timer_sec() j = 0 while j < ITERS: - r2: numpy.ndarray[t.CDouble] | t.CPtr = a * b + r2: numpy.ndarray[double] | t.CPtr = a * b r2.delete() j += 1 t1 = timer_sec() - printf(" MUL: %.1f ms\n", (t1 - t0) * t.CDouble(1000.0)) + printf(" MUL: %.1f ms\n", (t1 - t0) * double(1000.0)) # sqrt benchmark t0 = timer_sec() j = 0 while j < ITERS: - r3: numpy.ndarray[t.CDouble] | t.CPtr = numpy.np_sqrt(a) + r3: numpy.ndarray[double] | t.CPtr = numpy.np_sqrt(a) r3.delete() j += 1 t1 = timer_sec() - printf(" SQRT: %.1f ms\n", (t1 - t0) * t.CDouble(1000.0)) + printf(" SQRT: %.1f ms\n", (t1 - t0) * double(1000.0)) a.delete() b.delete() @@ -993,7 +993,7 @@ def bench_numpy_perf(): # ============================================================ # Entry points # ============================================================ -def test_numpy_correct() -> t.CInt: +def test_numpy_correct() -> int: global arena, pool, test_passed, test_failed arena = calloc(2 * 1024 * 1024, 1) @@ -1043,7 +1043,7 @@ def test_numpy_correct() -> t.CInt: return test_failed -def test_numpy_edge_main() -> t.CInt: +def test_numpy_edge_main() -> int: global arena, pool, test_passed, test_failed arena = calloc(2 * 1024 * 1024, 1) @@ -1065,7 +1065,7 @@ def test_numpy_edge_main() -> t.CInt: return test_failed -def bench_numpy_main() -> t.CInt: +def bench_numpy_main() -> int: global arena, pool arena = calloc(8 * 1024 * 1024, 1) @@ -1082,13 +1082,13 @@ def bench_numpy_main() -> t.CInt: # Backward-compatible entry -def test_numpy_main() -> t.CInt: +def test_numpy_main() -> int: global arena, pool arena = calloc(2 * 1024 * 1024, 1) pool = memhub.MemPool(arena, 2 * 1024 * 1024) - failed: t.CInt = test_numpy_correct() + failed: int = test_numpy_correct() if failed == 0: failed = test_numpy_edge_main() if failed == 0: diff --git a/PointerTest/App/main.vp b/PointerTest/App/main.vp index a2e46e1..82c612b 100644 --- a/PointerTest/App/main.vp +++ b/PointerTest/App/main.vp @@ -11,8 +11,8 @@ import testcheck # ============================================================ # --- Test 1: global 声明对模块级变量的影响 --- -_g_val: t.CInt = 0 -_g_ptr: t.CUInt32T | t.CPtr = None +_g_val: int = 0 +_g_ptr: uint32 | t.CPtr = None def test_global_write(): """测试：缺少 global 声明时，赋值是否修改模块级变量""" @@ -30,11 +30,11 @@ def test_global_write_no_decl(): def test_global_ptr(): global _g_ptr - buf: t.CUInt32T | t.CPtr = w32.win32memory.VirtualAlloc(None, 256, 0x3000, 0x04) + buf: uint32 | t.CPtr = w32.win32memory.VirtualAlloc(None, 256, 0x3000, 0x04) if buf: string.memset(buf, 0, 256) _g_ptr = buf - p: t.CUInt32T | t.CPtr = _g_ptr + p: uint32 | t.CPtr = _g_ptr p[0] = 0xAABBCCDD p[1] = 0x11223344 @@ -47,13 +47,13 @@ def test_global_ptr_no_decl(): - 修改全局：`global _g_ptr` + **无注解**赋值（见 test_global_ptr） - 独立局部：换成不与全局重名的变量名（本函数） """ - local_ptr: t.CUInt32T | t.CPtr = None # 独立局部变量，不触碰全局 _g_ptr + local_ptr: uint32 | t.CPtr = None # 独立局部变量，不触碰全局 _g_ptr # --- Test 2: 指针算术和数组索引 --- def test_pointer_arithmetic(): """测试指针算术：偏移计算是否正确""" - buf: t.CUInt32T | t.CPtr = w32.win32memory.VirtualAlloc(None, 256, 0x3000, 0x04) + buf: uint32 | t.CPtr = w32.win32memory.VirtualAlloc(None, 256, 0x3000, 0x04) if not buf: testcheck.fail("pointer arithmetic: VirtualAlloc returned NULL") return @@ -61,13 +61,13 @@ def test_pointer_arithmetic(): # 写入值 for i in range(8): - buf[i] = t.CUInt32T(i * 100) + buf[i] = uint32(i * 100) # 读取并验证 - ok: t.CInt = 1 + ok: int = 1 for i in range(8): - v: t.CUInt32T = buf[i] - expected: t.CUInt32T = t.CUInt32T(i * 100) + v: uint32 = buf[i] + expected: uint32 = uint32(i * 100) if v != expected: stdio.printf("buf[%d] = 0x%x, expected 0x%x\n", i, v, expected) ok = 0 @@ -77,32 +77,32 @@ def test_pointer_arithmetic(): # --- Test 3: 数组退化为指针 --- def test_array_decay(): """测试 list[t.CChar, N] 传递给 t.CConst | str 参数""" - arr: t.CArray[t.CChar, 32] - string.memset(c.Addr(arr), 0, 32) + arr: t.CArray[char, 32] + string.memset(&arr, 0, 32) # 手动写入字符串 src: str = "Hello" for i in range(5): - arr[i] = t.CChar(ord(src[i])) + arr[i] = char(ord(src[i])) arr[5] = 0 # 传递给 print (接受 t.CConst | str) - stdio.printf("array decay -> %s\n", c.Addr(arr)) + stdio.printf("array decay -> %s\n", &arr) testcheck.ok("array decay (Hello)") # --- Test 4: 指针类型转换 (CVoid/CPtr) --- def test_pointer_cast(): """测试指针与整数之间的类型转换""" - buf: t.CUInt32T | t.CPtr = w32.win32memory.VirtualAlloc(None, 256, 0x3000, 0x04) + buf: uint32 | t.CPtr = w32.win32memory.VirtualAlloc(None, 256, 0x3000, 0x04) if not buf: testcheck.fail("pointer cast: VirtualAlloc returned NULL") return string.memset(buf, 0, 256) # 通过 CVoid 指针写入 - raw: t.CPtr = t.CPtr(t.CUInt64T(buf)) + raw: t.CPtr = t.CPtr(uint64(buf)) # 将 CVoid 指针转回 CUInt32T 指针 - p32: t.CUInt32T | t.CPtr = (t.CUInt32T | t.CPtr)(raw) + p32: uint32 | t.CPtr = (uint32 | t.CPtr)(raw) p32[0] = 0xDEADBEEF # 通过原始指针读取 @@ -116,7 +116,7 @@ def test_pointer_cast(): # --- Test 5: 指针偏移计算 (byte offset vs element offset) --- def test_pointer_offset(): """测试指针偏移：CUInt8T* + N 应该偏移 N 字节，CUInt32T* + N 应该偏移 N*4 字节""" - buf: t.CUInt8T | t.CPtr = w32.win32memory.VirtualAlloc(None, 256, 0x3000, 0x04) + buf: uint8 | t.CPtr = w32.win32memory.VirtualAlloc(None, 256, 0x3000, 0x04) if not buf: testcheck.fail("pointer offset: VirtualAlloc returned NULL") return @@ -129,8 +129,8 @@ def test_pointer_offset(): buf[3] = 0x44 # 'D' # 通过 CUInt32T* 读取（应该读到 0x44434241 on little-endian） - p32: t.CUInt32T | t.CPtr = (t.CUInt32T | t.CPtr)(t.CPtr(t.CUInt64T(buf))) - val: t.CUInt32T = p32[0] + p32: uint32 | t.CPtr = (uint32 | t.CPtr)(t.CPtr(uint64(buf))) + val: uint32 = p32[0] # little-endian: 0x44434241 if val == 0x44434241: @@ -142,9 +142,9 @@ def test_pointer_offset(): # --- Test 6: 结构体指针访问 --- class TestStruct(): - a: t.CInt - b: t.CInt - c: t.CUInt64T + a: int + b: int + c: uint64 def test_struct_pointer(): """测试结构体指针的成员访问""" @@ -153,7 +153,7 @@ def test_struct_pointer(): s.b = 20 s.c = 0x123456789ABCDEF0 - p: TestStruct | t.CPtr = c.Addr(s) + p: TestStruct | t.CPtr = &s stdio.printf("struct pointer access (a=%d b=%d c=0x%llx)\n", p.a, p.b, p.c) testcheck.check(p.a == 10 and p.b == 20 and p.c == 0x123456789ABCDEF0, "struct pointer access", "struct pointer access mismatch") @@ -161,55 +161,55 @@ def test_struct_pointer(): # --- Test 7: memcpy/memset 通过指针 --- def test_memcpy_pointers(): """测试 memcpy 在指针之间的数据复制""" - src_buf: t.CUInt32T | t.CPtr = w32.win32memory.VirtualAlloc(None, 64, 0x3000, 0x04) - dst_buf: t.CUInt32T | t.CPtr = w32.win32memory.VirtualAlloc(None, 64, 0x3000, 0x04) + src_buf: uint32 | t.CPtr = w32.win32memory.VirtualAlloc(None, 64, 0x3000, 0x04) + dst_buf: uint32 | t.CPtr = w32.win32memory.VirtualAlloc(None, 64, 0x3000, 0x04) if not src_buf or not dst_buf: testcheck.fail("memcpy: VirtualAlloc returned NULL") return # 初始化 src for i in range(8): - src_buf[i] = t.CUInt32T(i + 1000) + src_buf[i] = uint32(i + 1000) # 复制 - string.memcpy(t.CPtr(t.CUInt64T(dst_buf)), t.CPtr(t.CUInt64T(src_buf)), 32) + string.memcpy(t.CPtr(uint64(dst_buf)), t.CPtr(uint64(src_buf)), 32) # 验证 - ok: t.CInt = 1 + ok: int = 1 for i in range(8): - if dst_buf[i] != t.CUInt32T(i + 1000): + if dst_buf[i] != uint32(i + 1000): stdio.printf("dst[%d] = %u, expected %u\n", i, dst_buf[i], i + 1000) ok = 0 testcheck.check(ok, "memcpy between pointers", "memcpy between pointers failed") # --- Test 8: 指针作为函数参数 --- -def fill_array(arr: t.CUInt32T | t.CPtr, count: t.CInt, val: t.CUInt32T): +def fill_array(arr: uint32 | t.CPtr, count: int, val: uint32): for i in range(count): arr[i] = val def test_pointer_param(): """测试指针作为函数参数传递""" - buf: t.CUInt32T | t.CPtr = w32.win32memory.VirtualAlloc(None, 64, 0x3000, 0x04) + buf: uint32 | t.CPtr = w32.win32memory.VirtualAlloc(None, 64, 0x3000, 0x04) if not buf: testcheck.fail("pointer param: VirtualAlloc returned NULL") return fill_array(buf, 8, 0xCAFEBABE) - ok: t.CInt = 1 + ok: int = 1 for i in range(8): if buf[i] != 0xCAFEBABE: ok = 0 testcheck.check(ok, "pointer as function parameter", "pointer as function parameter failed") -def main() -> t.CInt | t.CExport: +def main() -> int | t.CExport: w32.win32console.SetConsoleCP(65001) w32.win32console.SetConsoleOutputCP(65001) print("你好") - l: t.CArray[t.CChar, 2] = 0 + l: t.CArray[char, 2] = 0 for i in "hello": l[0] = i print(l) @@ -219,7 +219,7 @@ def main() -> t.CInt | t.CExport: # # l[0] = i # stdio.printf("0x%llx\n", i) - k: t.CArray[t.CChar, 12] = ['1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C'] + k: t.CArray[char, 12] = ['1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C'] for i in k: stdio.printf("%c\n", i) @@ -239,12 +239,12 @@ def main() -> t.CInt | t.CExport: testcheck.section("Test 1b: global pointer") test_global_ptr() if _g_ptr: - p: t.CUInt32T | t.CPtr = _g_ptr + p: uint32 | t.CPtr = _g_ptr stdio.printf("_g_ptr[0] = 0x%x (expect 0xAABBCCDD)\n", p[0]) stdio.printf("_g_ptr[1] = 0x%x (expect 0x11223344)\n", p[1]) testcheck.check(p[0] == 0xAABBCCDD and p[1] == 0x11223344, "global pointer values", "global pointer mismatch") test_global_ptr_no_decl() - stdio.printf("After test_global_ptr_no_decl(): _g_ptr = %p (expect 非 NULL：局部遮蔽未改全局)\n", t.CPtr(t.CUInt64T(_g_ptr))) + stdio.printf("After test_global_ptr_no_decl(): _g_ptr = %p (expect 非 NULL：局部遮蔽未改全局)\n", t.CPtr(uint64(_g_ptr))) if _g_ptr: testcheck.ok("global ptr no decl (global untouched by local shadow)") else: diff --git a/ProbeGen/App/main.vp b/ProbeGen/App/main.vp index 7921eb0..b082099 100644 --- a/ProbeGen/App/main.vp +++ b/ProbeGen/App/main.vp @@ -68,7 +68,7 @@ extern def ProbeCoordByVal(dwSize: w32console.COORD) -> BOOL # 全局小整型先例：ViperApps/ViperOS/VKernel/Kernel/services/desktop.vp:62 # （_cursor_buttons: uint8 = 0） # ============================================================ -U8Sink: t.CUInt8T = 0 +U8Sink: uint8 = 0 # ============================================================ @@ -78,7 +78,7 @@ U8Sink: t.CUInt8T = 0 # def ord(s: t.CChar) -> int: # return s # ============================================================ -def ProbeOrd(s: t.CChar) -> int: +def ProbeOrd(s: char) -> int: return s @@ -104,9 +104,9 @@ def ProbeMin(a: double, b: double) -> double: # 局部值落全局（global 声明 + 赋值）先例： # Test/ArgparseTest/App/main.vp:17（global _mbuddy）→ :26（_mbuddy = ...） # ============================================================ -def ProbeU8Literal() -> t.CUInt8T: +def ProbeU8Literal() -> uint8: global U8Sink - result: t.CUInt8T = 1 + result: uint8 = 1 U8Sink = result return result @@ -128,7 +128,7 @@ def ProbeU8Literal() -> t.CUInt8T: # （class Translator: def __init__(self): ...；实例化 TransPyV/App/main.vp:471） # ============================================================ class Box: - p: t.CChar | t.CPtr + p: char | t.CPtr def __init__(self): self.p = None @@ -151,7 +151,7 @@ class Box: # ============================================================ @t.CExport def main() -> int: - Ch: t.CChar = 'A' + Ch: char = 'A' BoxInst: Box = Box() BoxInst.Clear() ProbeOrd(Ch) diff --git a/RawArrayTest/App/main.vp b/RawArrayTest/App/main.vp index 3e0f254..350b411 100644 --- a/RawArrayTest/App/main.vp +++ b/RawArrayTest/App/main.vp @@ -4,7 +4,7 @@ import stdio # 模块级全局定长数组（rawarray 复刻 t.CArray） -g_arr: rawarray[t.CInt, 4] = [10, 20, 30, 40] +g_arr: rawarray[int, 4] = [10, 20, 30, 40] # struct 内嵌定长数组字段 @@ -13,7 +13,7 @@ class Ctx: buf: rawarray[uint8, 64] -def main() -> t.CInt | t.CExport: +def main() -> int | t.CExport: # 1) 全局数组读取 stdio.printf("1 g_arr[0]=%d g_arr[3]=%d (expect 10 40)\n", g_arr[0], g_arr[3]) diff --git a/SimdTest/App/main.vp b/SimdTest/App/main.vp index ed98962..9bed763 100644 --- a/SimdTest/App/main.vp +++ b/SimdTest/App/main.vp @@ -10,13 +10,13 @@ import testcheck # 全局内存池 -arena: t.CUInt8T | t.CPtr = None +arena: uint8 | t.CPtr = None pool: memhub.MemPool | t.CPtr = None # 外部函数: clock() 用于性能计时 def clock() -> t.CLong | t.CExtern: pass -CLOCK_PER_SEC: t.CDefine = 1000 +define CLOCK_PER_SEC = 1000 # ============================================================ @@ -25,43 +25,43 @@ CLOCK_PER_SEC: t.CDefine = 1000 def test_avx2_add_sub_mul_div(): testcheck.section("AVX2 add/sub/mul/div 4d") - a: numpy.ndarray[t.CDouble] | t.CPtr = numpy.zeros(pool, 4) - a.data[0] = t.CDouble(1.0) - a.data[1] = t.CDouble(2.0) - a.data[2] = t.CDouble(3.0) - a.data[3] = t.CDouble(4.0) + a: numpy.ndarray[double] | t.CPtr = numpy.zeros(pool, 4) + a.data[0] = double(1.0) + a.data[1] = double(2.0) + a.data[2] = double(3.0) + a.data[3] = double(4.0) - b: numpy.ndarray[t.CDouble] | t.CPtr = numpy.zeros(pool, 4) - b.data[0] = t.CDouble(5.0) - b.data[1] = t.CDouble(6.0) - b.data[2] = t.CDouble(7.0) - b.data[3] = t.CDouble(8.0) + b: numpy.ndarray[double] | t.CPtr = numpy.zeros(pool, 4) + b.data[0] = double(5.0) + b.data[1] = double(6.0) + b.data[2] = double(7.0) + b.data[3] = double(8.0) - out: numpy.ndarray[t.CDouble] | t.CPtr = numpy.zeros(pool, 4) + out: numpy.ndarray[double] | t.CPtr = numpy.zeros(pool, 4) # add vipersimd.simd_add4d(a.data, b.data, out.data) - testcheck.check(out.data[0] == t.CDouble(6.0), "add[0]==6", "add[0]==6") - testcheck.check(out.data[1] == t.CDouble(8.0), "add[1]==8", "add[1]==8") - testcheck.check(out.data[2] == t.CDouble(10.0), "add[2]==10", "add[2]==10") - testcheck.check(out.data[3] == t.CDouble(12.0), "add[3]==12", "add[3]==12") + testcheck.check(out.data[0] == double(6.0), "add[0]==6", "add[0]==6") + testcheck.check(out.data[1] == double(8.0), "add[1]==8", "add[1]==8") + testcheck.check(out.data[2] == double(10.0), "add[2]==10", "add[2]==10") + testcheck.check(out.data[3] == double(12.0), "add[3]==12", "add[3]==12") # sub vipersimd.simd_sub4d(a.data, b.data, out.data) - testcheck.check(out.data[0] == t.CDouble(-4.0), "sub[0]==-4", "sub[0]==-4") - testcheck.check(out.data[3] == t.CDouble(-4.0), "sub[3]==-4", "sub[3]==-4") + testcheck.check(out.data[0] == double(-4.0), "sub[0]==-4", "sub[0]==-4") + testcheck.check(out.data[3] == double(-4.0), "sub[3]==-4", "sub[3]==-4") # mul vipersimd.simd_mul4d(a.data, b.data, out.data) - testcheck.check(out.data[0] == t.CDouble(5.0), "mul[0]==5", "mul[0]==5") - testcheck.check(out.data[1] == t.CDouble(12.0), "mul[1]==12", "mul[1]==12") - testcheck.check(out.data[2] == t.CDouble(21.0), "mul[2]==21", "mul[2]==21") - testcheck.check(out.data[3] == t.CDouble(32.0), "mul[3]==32", "mul[3]==32") + testcheck.check(out.data[0] == double(5.0), "mul[0]==5", "mul[0]==5") + testcheck.check(out.data[1] == double(12.0), "mul[1]==12", "mul[1]==12") + testcheck.check(out.data[2] == double(21.0), "mul[2]==21", "mul[2]==21") + testcheck.check(out.data[3] == double(32.0), "mul[3]==32", "mul[3]==32") # div vipersimd.simd_div4d(b.data, a.data, out.data) - testcheck.check(out.data[0] == t.CDouble(5.0), "div[0]==5", "div[0]==5") - testcheck.check(out.data[1] == t.CDouble(3.0), "div[1]==3", "div[1]==3") + testcheck.check(out.data[0] == double(5.0), "div[0]==5", "div[0]==5") + testcheck.check(out.data[1] == double(3.0), "div[1]==3", "div[1]==3") a.delete() b.delete() @@ -70,34 +70,34 @@ def test_avx2_add_sub_mul_div(): def test_avx2_neg_abs_sqrt(): testcheck.section("AVX2 neg/abs/sqrt 4d") - a: numpy.ndarray[t.CDouble] | t.CPtr = numpy.zeros(pool, 4) - a.data[0] = t.CDouble(1.0) - a.data[1] = t.CDouble(-4.0) - a.data[2] = t.CDouble(9.0) - a.data[3] = t.CDouble(-16.0) + a: numpy.ndarray[double] | t.CPtr = numpy.zeros(pool, 4) + a.data[0] = double(1.0) + a.data[1] = double(-4.0) + a.data[2] = double(9.0) + a.data[3] = double(-16.0) - out: numpy.ndarray[t.CDouble] | t.CPtr = numpy.zeros(pool, 4) + out: numpy.ndarray[double] | t.CPtr = numpy.zeros(pool, 4) # neg vipersimd.simd_neg4d(a.data, out.data) - testcheck.check(out.data[0] == t.CDouble(-1.0), "neg[0]==-1", "neg[0]==-1") - testcheck.check(out.data[1] == t.CDouble(4.0), "neg[1]==4", "neg[1]==4") - testcheck.check(out.data[2] == t.CDouble(-9.0), "neg[2]==-9", "neg[2]==-9") - testcheck.check(out.data[3] == t.CDouble(16.0), "neg[3]==16", "neg[3]==16") + testcheck.check(out.data[0] == double(-1.0), "neg[0]==-1", "neg[0]==-1") + testcheck.check(out.data[1] == double(4.0), "neg[1]==4", "neg[1]==4") + testcheck.check(out.data[2] == double(-9.0), "neg[2]==-9", "neg[2]==-9") + testcheck.check(out.data[3] == double(16.0), "neg[3]==16", "neg[3]==16") # abs vipersimd.simd_abs4d(a.data, out.data) - testcheck.check(out.data[0] == t.CDouble(1.0), "abs[0]==1", "abs[0]==1") - testcheck.check(out.data[1] == t.CDouble(4.0), "abs[1]==4", "abs[1]==4") - testcheck.check(out.data[2] == t.CDouble(9.0), "abs[2]==9", "abs[2]==9") - testcheck.check(out.data[3] == t.CDouble(16.0), "abs[3]==16", "abs[3]==16") + testcheck.check(out.data[0] == double(1.0), "abs[0]==1", "abs[0]==1") + testcheck.check(out.data[1] == double(4.0), "abs[1]==4", "abs[1]==4") + testcheck.check(out.data[2] == double(9.0), "abs[2]==9", "abs[2]==9") + testcheck.check(out.data[3] == double(16.0), "abs[3]==16", "abs[3]==16") # sqrt vipersimd.simd_sqrt4d(out.data, out.data) - testcheck.check(out.data[0] == t.CDouble(1.0), "sqrt[0]==1", "sqrt[0]==1") - testcheck.check(out.data[1] == t.CDouble(2.0), "sqrt[1]==2", "sqrt[1]==2") - testcheck.check(out.data[2] == t.CDouble(3.0), "sqrt[2]==3", "sqrt[2]==3") - testcheck.check(out.data[3] == t.CDouble(4.0), "sqrt[3]==4", "sqrt[3]==4") + testcheck.check(out.data[0] == double(1.0), "sqrt[0]==1", "sqrt[0]==1") + testcheck.check(out.data[1] == double(2.0), "sqrt[1]==2", "sqrt[1]==2") + testcheck.check(out.data[2] == double(3.0), "sqrt[2]==3", "sqrt[2]==3") + testcheck.check(out.data[3] == double(4.0), "sqrt[3]==4", "sqrt[3]==4") a.delete() out.delete() @@ -105,31 +105,31 @@ def test_avx2_neg_abs_sqrt(): def test_avx2_min_max(): testcheck.section("AVX2 min/max 4d") - a: numpy.ndarray[t.CDouble] | t.CPtr = numpy.zeros(pool, 4) - a.data[0] = t.CDouble(1.0) - a.data[1] = t.CDouble(8.0) - a.data[2] = t.CDouble(3.0) - a.data[3] = t.CDouble(6.0) + a: numpy.ndarray[double] | t.CPtr = numpy.zeros(pool, 4) + a.data[0] = double(1.0) + a.data[1] = double(8.0) + a.data[2] = double(3.0) + a.data[3] = double(6.0) - b: numpy.ndarray[t.CDouble] | t.CPtr = numpy.zeros(pool, 4) - b.data[0] = t.CDouble(5.0) - b.data[1] = t.CDouble(2.0) - b.data[2] = t.CDouble(7.0) - b.data[3] = t.CDouble(4.0) + b: numpy.ndarray[double] | t.CPtr = numpy.zeros(pool, 4) + b.data[0] = double(5.0) + b.data[1] = double(2.0) + b.data[2] = double(7.0) + b.data[3] = double(4.0) - out: numpy.ndarray[t.CDouble] | t.CPtr = numpy.zeros(pool, 4) + out: numpy.ndarray[double] | t.CPtr = numpy.zeros(pool, 4) vipersimd.simd_min4d(a.data, b.data, out.data) - testcheck.check(out.data[0] == t.CDouble(1.0), "min[0]==1", "min[0]==1") - testcheck.check(out.data[1] == t.CDouble(2.0), "min[1]==2", "min[1]==2") - testcheck.check(out.data[2] == t.CDouble(3.0), "min[2]==3", "min[2]==3") - testcheck.check(out.data[3] == t.CDouble(4.0), "min[3]==4", "min[3]==4") + testcheck.check(out.data[0] == double(1.0), "min[0]==1", "min[0]==1") + testcheck.check(out.data[1] == double(2.0), "min[1]==2", "min[1]==2") + testcheck.check(out.data[2] == double(3.0), "min[2]==3", "min[2]==3") + testcheck.check(out.data[3] == double(4.0), "min[3]==4", "min[3]==4") vipersimd.simd_max4d(a.data, b.data, out.data) - testcheck.check(out.data[0] == t.CDouble(5.0), "max[0]==5", "max[0]==5") - testcheck.check(out.data[1] == t.CDouble(8.0), "max[1]==8", "max[1]==8") - testcheck.check(out.data[2] == t.CDouble(7.0), "max[2]==7", "max[2]==7") - testcheck.check(out.data[3] == t.CDouble(6.0), "max[3]==6", "max[3]==6") + testcheck.check(out.data[0] == double(5.0), "max[0]==5", "max[0]==5") + testcheck.check(out.data[1] == double(8.0), "max[1]==8", "max[1]==8") + testcheck.check(out.data[2] == double(7.0), "max[2]==7", "max[2]==7") + testcheck.check(out.data[3] == double(6.0), "max[3]==6", "max[3]==6") a.delete() b.delete() @@ -138,25 +138,25 @@ def test_avx2_min_max(): def test_avx2_scalar_ops(): testcheck.section("AVX2 scalar broadcast ops") - a: numpy.ndarray[t.CDouble] | t.CPtr = numpy.zeros(pool, 4) - a.data[0] = t.CDouble(1.0) - a.data[1] = t.CDouble(2.0) - a.data[2] = t.CDouble(3.0) - a.data[3] = t.CDouble(4.0) + a: numpy.ndarray[double] | t.CPtr = numpy.zeros(pool, 4) + a.data[0] = double(1.0) + a.data[1] = double(2.0) + a.data[2] = double(3.0) + a.data[3] = double(4.0) - s: numpy.ndarray[t.CDouble] | t.CPtr = numpy.zeros(pool, 1) - s.data[0] = t.CDouble(10.0) + s: numpy.ndarray[double] | t.CPtr = numpy.zeros(pool, 1) + s.data[0] = double(10.0) - out: numpy.ndarray[t.CDouble] | t.CPtr = numpy.zeros(pool, 4) + out: numpy.ndarray[double] | t.CPtr = numpy.zeros(pool, 4) vipersimd.simd_mul_scalar4d(a.data, s.data, out.data) - testcheck.check(out.data[0] == t.CDouble(10.0), "mul_scalar[0]==10", "mul_scalar[0]==10") - testcheck.check(out.data[1] == t.CDouble(20.0), "mul_scalar[1]==20", "mul_scalar[1]==20") - testcheck.check(out.data[3] == t.CDouble(40.0), "mul_scalar[3]==40", "mul_scalar[3]==40") + testcheck.check(out.data[0] == double(10.0), "mul_scalar[0]==10", "mul_scalar[0]==10") + testcheck.check(out.data[1] == double(20.0), "mul_scalar[1]==20", "mul_scalar[1]==20") + testcheck.check(out.data[3] == double(40.0), "mul_scalar[3]==40", "mul_scalar[3]==40") vipersimd.simd_add_scalar4d(a.data, s.data, out.data) - testcheck.check(out.data[0] == t.CDouble(11.0), "add_scalar[0]==11", "add_scalar[0]==11") - testcheck.check(out.data[3] == t.CDouble(14.0), "add_scalar[3]==14", "add_scalar[3]==14") + testcheck.check(out.data[0] == double(11.0), "add_scalar[0]==11", "add_scalar[0]==11") + testcheck.check(out.data[3] == double(14.0), "add_scalar[3]==14", "add_scalar[3]==14") a.delete() s.delete() @@ -165,25 +165,25 @@ def test_avx2_scalar_ops(): def test_avx2_hsum_dot(): testcheck.section("AVX2 hsum/dot 4d") - a: numpy.ndarray[t.CDouble] | t.CPtr = numpy.zeros(pool, 4) - a.data[0] = t.CDouble(1.0) - a.data[1] = t.CDouble(2.0) - a.data[2] = t.CDouble(3.0) - a.data[3] = t.CDouble(4.0) + a: numpy.ndarray[double] | t.CPtr = numpy.zeros(pool, 4) + a.data[0] = double(1.0) + a.data[1] = double(2.0) + a.data[2] = double(3.0) + a.data[3] = double(4.0) - b: numpy.ndarray[t.CDouble] | t.CPtr = numpy.zeros(pool, 4) - b.data[0] = t.CDouble(5.0) - b.data[1] = t.CDouble(6.0) - b.data[2] = t.CDouble(7.0) - b.data[3] = t.CDouble(8.0) + b: numpy.ndarray[double] | t.CPtr = numpy.zeros(pool, 4) + b.data[0] = double(5.0) + b.data[1] = double(6.0) + b.data[2] = double(7.0) + b.data[3] = double(8.0) - out: numpy.ndarray[t.CDouble] | t.CPtr = numpy.zeros(pool, 1) + out: numpy.ndarray[double] | t.CPtr = numpy.zeros(pool, 1) vipersimd.simd_hsum4d(a.data, out.data) - testcheck.check(out.data[0] == t.CDouble(10.0), "hsum==10", "hsum==10") + testcheck.check(out.data[0] == double(10.0), "hsum==10", "hsum==10") vipersimd.simd_dot4d(a.data, b.data, out.data) - testcheck.check(out.data[0] == t.CDouble(70.0), "dot==70", "dot==70") + testcheck.check(out.data[0] == double(70.0), "dot==70", "dot==70") a.delete() b.delete() @@ -192,27 +192,27 @@ def test_avx2_hsum_dot(): def test_avx2_fma(): testcheck.section("AVX2 FMA 4d") - a: numpy.ndarray[t.CDouble] | t.CPtr = numpy.zeros(pool, 4) - a.data[0] = t.CDouble(1.0) - a.data[1] = t.CDouble(2.0) - a.data[2] = t.CDouble(3.0) - a.data[3] = t.CDouble(4.0) + a: numpy.ndarray[double] | t.CPtr = numpy.zeros(pool, 4) + a.data[0] = double(1.0) + a.data[1] = double(2.0) + a.data[2] = double(3.0) + a.data[3] = double(4.0) - b: numpy.ndarray[t.CDouble] | t.CPtr = numpy.zeros(pool, 4) - b.data[0] = t.CDouble(5.0) - b.data[1] = t.CDouble(6.0) - b.data[2] = t.CDouble(7.0) - b.data[3] = t.CDouble(8.0) + b: numpy.ndarray[double] | t.CPtr = numpy.zeros(pool, 4) + b.data[0] = double(5.0) + b.data[1] = double(6.0) + b.data[2] = double(7.0) + b.data[3] = double(8.0) - c_val: numpy.ndarray[t.CDouble] | t.CPtr = numpy.ones(pool, 4) + c_val: numpy.ndarray[double] | t.CPtr = numpy.ones(pool, 4) - out: numpy.ndarray[t.CDouble] | t.CPtr = numpy.zeros(pool, 4) + out: numpy.ndarray[double] | t.CPtr = numpy.zeros(pool, 4) vipersimd.simd_fma4d(a.data, b.data, c_val.data, out.data) - testcheck.check(out.data[0] == t.CDouble(6.0), "fma[0]==6", "fma[0]==6") - testcheck.check(out.data[1] == t.CDouble(13.0), "fma[1]==13", "fma[1]==13") - testcheck.check(out.data[2] == t.CDouble(22.0), "fma[2]==22", "fma[2]==22") - testcheck.check(out.data[3] == t.CDouble(33.0), "fma[3]==33", "fma[3]==33") + testcheck.check(out.data[0] == double(6.0), "fma[0]==6", "fma[0]==6") + testcheck.check(out.data[1] == double(13.0), "fma[1]==13", "fma[1]==13") + testcheck.check(out.data[2] == double(22.0), "fma[2]==22", "fma[2]==22") + testcheck.check(out.data[3] == double(33.0), "fma[3]==33", "fma[3]==33") a.delete() b.delete() @@ -226,53 +226,53 @@ def test_avx2_fma(): def test_batch_array_ops(): testcheck.section("Batch array operations") - n: t.CSizeT = 16 - a: numpy.ndarray[t.CDouble] | t.CPtr = numpy.arange(pool, t.CDouble(1.0), t.CDouble(17.0), t.CDouble(1.0)) - b: numpy.ndarray[t.CDouble] | t.CPtr = numpy.full(pool, 16, t.CDouble(2.0)) - out: numpy.ndarray[t.CDouble] | t.CPtr = numpy.zeros(pool, 16) + n: sizet = 16 + a: numpy.ndarray[double] | t.CPtr = numpy.arange(pool, double(1.0), double(17.0), double(1.0)) + b: numpy.ndarray[double] | t.CPtr = numpy.full(pool, 16, double(2.0)) + out: numpy.ndarray[double] | t.CPtr = numpy.zeros(pool, 16) # add array vipersimd.simd_add_array(a.data, b.data, out.data, n) - testcheck.check(out.data[0] == t.CDouble(3.0), "add_arr[0]==3", "add_arr[0]==3") - testcheck.check(out.data[15] == t.CDouble(18.0), "add_arr[15]==18", "add_arr[15]==18") + testcheck.check(out.data[0] == double(3.0), "add_arr[0]==3", "add_arr[0]==3") + testcheck.check(out.data[15] == double(18.0), "add_arr[15]==18", "add_arr[15]==18") # mul array vipersimd.simd_mul_array(a.data, b.data, out.data, n) - testcheck.check(out.data[0] == t.CDouble(2.0), "mul_arr[0]==2", "mul_arr[0]==2") - testcheck.check(out.data[3] == t.CDouble(8.0), "mul_arr[3]==8", "mul_arr[3]==8") + testcheck.check(out.data[0] == double(2.0), "mul_arr[0]==2", "mul_arr[0]==2") + testcheck.check(out.data[3] == double(8.0), "mul_arr[3]==8", "mul_arr[3]==8") # sqrt array - c: numpy.ndarray[t.CDouble] | t.CPtr = numpy.zeros(pool, 4) - c.data[0] = t.CDouble(4.0) - c.data[1] = t.CDouble(9.0) - c.data[2] = t.CDouble(16.0) - c.data[3] = t.CDouble(25.0) - out4: numpy.ndarray[t.CDouble] | t.CPtr = numpy.zeros(pool, 4) - vipersimd.simd_sqrt_array(c.data, out4.data, t.CSizeT(4)) - testcheck.check(out4.data[0] == t.CDouble(2.0), "sqrt_arr[0]==2", "sqrt_arr[0]==2") - testcheck.check(out4.data[3] == t.CDouble(5.0), "sqrt_arr[3]==5", "sqrt_arr[3]==5") + c: numpy.ndarray[double] | t.CPtr = numpy.zeros(pool, 4) + c.data[0] = double(4.0) + c.data[1] = double(9.0) + c.data[2] = double(16.0) + c.data[3] = double(25.0) + out4: numpy.ndarray[double] | t.CPtr = numpy.zeros(pool, 4) + vipersimd.simd_sqrt_array(c.data, out4.data, sizet(4)) + testcheck.check(out4.data[0] == double(2.0), "sqrt_arr[0]==2", "sqrt_arr[0]==2") + testcheck.check(out4.data[3] == double(5.0), "sqrt_arr[3]==5", "sqrt_arr[3]==5") # abs array - d: numpy.ndarray[t.CDouble] | t.CPtr = numpy.zeros(pool, 4) - d.data[0] = t.CDouble(-1.0) - d.data[1] = t.CDouble(-2.0) - d.data[2] = t.CDouble(3.0) - d.data[3] = t.CDouble(-4.0) - vipersimd.simd_abs_array(d.data, out4.data, t.CSizeT(4)) - testcheck.check(out4.data[0] == t.CDouble(1.0), "abs_arr[0]==1", "abs_arr[0]==1") - testcheck.check(out4.data[1] == t.CDouble(2.0), "abs_arr[1]==2", "abs_arr[1]==2") - testcheck.check(out4.data[3] == t.CDouble(4.0), "abs_arr[3]==4", "abs_arr[3]==4") + d: numpy.ndarray[double] | t.CPtr = numpy.zeros(pool, 4) + d.data[0] = double(-1.0) + d.data[1] = double(-2.0) + d.data[2] = double(3.0) + d.data[3] = double(-4.0) + vipersimd.simd_abs_array(d.data, out4.data, sizet(4)) + testcheck.check(out4.data[0] == double(1.0), "abs_arr[0]==1", "abs_arr[0]==1") + testcheck.check(out4.data[1] == double(2.0), "abs_arr[1]==2", "abs_arr[1]==2") + testcheck.check(out4.data[3] == double(4.0), "abs_arr[3]==4", "abs_arr[3]==4") # dot array - e: numpy.ndarray[t.CDouble] | t.CPtr = numpy.zeros(pool, 4) - e.data[0] = t.CDouble(1.0) - e.data[1] = t.CDouble(2.0) - e.data[2] = t.CDouble(3.0) - e.data[3] = t.CDouble(4.0) - f: numpy.ndarray[t.CDouble] | t.CPtr = numpy.ones(pool, 4) - out1: numpy.ndarray[t.CDouble] | t.CPtr = numpy.zeros(pool, 1) - vipersimd.simd_dot_array(e.data, f.data, t.CSizeT(4), out1.data) - testcheck.check(out1.data[0] == t.CDouble(10.0), "dot_arr==10", "dot_arr==10") + e: numpy.ndarray[double] | t.CPtr = numpy.zeros(pool, 4) + e.data[0] = double(1.0) + e.data[1] = double(2.0) + e.data[2] = double(3.0) + e.data[3] = double(4.0) + f: numpy.ndarray[double] | t.CPtr = numpy.ones(pool, 4) + out1: numpy.ndarray[double] | t.CPtr = numpy.zeros(pool, 1) + vipersimd.simd_dot_array(e.data, f.data, sizet(4), out1.data) + testcheck.check(out1.data[0] == double(10.0), "dot_arr==10", "dot_arr==10") a.delete() b.delete() @@ -293,99 +293,99 @@ def test_llvmir_scalar(): testcheck.section("LLVMIR precise scalar ops") # sqrt - r: t.CDouble = vipersimd.simd_sqrt(t.CDouble(4.0)) - testcheck.check(r == t.CDouble(2.0), "sqrt(4)==2", "sqrt(4)==2") + r: double = vipersimd.simd_sqrt(double(4.0)) + testcheck.check(r == double(2.0), "sqrt(4)==2", "sqrt(4)==2") # fabs - r = vipersimd.simd_fabs(t.CDouble(-3.5)) - testcheck.check(r == t.CDouble(3.5), "fabs(-3.5)==3.5", "fabs(-3.5)==3.5") + r = vipersimd.simd_fabs(double(-3.5)) + testcheck.check(r == double(3.5), "fabs(-3.5)==3.5", "fabs(-3.5)==3.5") # floor - r = vipersimd.simd_floor(t.CDouble(3.7)) - testcheck.check(r == t.CDouble(3.0), "floor(3.7)==3", "floor(3.7)==3") + r = vipersimd.simd_floor(double(3.7)) + testcheck.check(r == double(3.0), "floor(3.7)==3", "floor(3.7)==3") # ceil - r = vipersimd.simd_ceil(t.CDouble(3.2)) - testcheck.check(r == t.CDouble(4.0), "ceil(3.2)==4", "ceil(3.2)==4") + r = vipersimd.simd_ceil(double(3.2)) + testcheck.check(r == double(4.0), "ceil(3.2)==4", "ceil(3.2)==4") # round - r = vipersimd.simd_round(t.CDouble(3.5)) - testcheck.check(r == t.CDouble(4.0), "round(3.5)==4", "round(3.5)==4") + r = vipersimd.simd_round(double(3.5)) + testcheck.check(r == double(4.0), "round(3.5)==4", "round(3.5)==4") # trunc - r = vipersimd.simd_trunc(t.CDouble(3.9)) - testcheck.check(r == t.CDouble(3.0), "trunc(3.9)==3", "trunc(3.9)==3") + r = vipersimd.simd_trunc(double(3.9)) + testcheck.check(r == double(3.0), "trunc(3.9)==3", "trunc(3.9)==3") # fma: 2*3+1 = 7 - r = vipersimd.simd_fma(t.CDouble(2.0), t.CDouble(3.0), t.CDouble(1.0)) - testcheck.check(r == t.CDouble(7.0), "fma(2,3,1)==7", "fma(2,3,1)==7") + r = vipersimd.simd_fma(double(2.0), double(3.0), double(1.0)) + testcheck.check(r == double(7.0), "fma(2,3,1)==7", "fma(2,3,1)==7") # copysign - r = vipersimd.simd_copysign(t.CDouble(3.0), t.CDouble(-1.0)) - testcheck.check(r == t.CDouble(-3.0), "copysign(3,-1)==-3", "copysign(3,-1)==-3") + r = vipersimd.simd_copysign(double(3.0), double(-1.0)) + testcheck.check(r == double(-3.0), "copysign(3,-1)==-3", "copysign(3,-1)==-3") # neg - r = vipersimd.simd_neg(t.CDouble(1.5)) - testcheck.check(r == t.CDouble(-1.5), "neg(1.5)==-1.5", "neg(1.5)==-1.5") + r = vipersimd.simd_neg(double(1.5)) + testcheck.check(r == double(-1.5), "neg(1.5)==-1.5", "neg(1.5)==-1.5") # minnum - r = vipersimd.simd_minnum(t.CDouble(2.0), t.CDouble(3.0)) - testcheck.check(r == t.CDouble(2.0), "minnum(2,3)==2", "minnum(2,3)==2") + r = vipersimd.simd_minnum(double(2.0), double(3.0)) + testcheck.check(r == double(2.0), "minnum(2,3)==2", "minnum(2,3)==2") # maxnum - r = vipersimd.simd_maxnum(t.CDouble(2.0), t.CDouble(3.0)) - testcheck.check(r == t.CDouble(3.0), "maxnum(2,3)==3", "maxnum(2,3)==3") + r = vipersimd.simd_maxnum(double(2.0), double(3.0)) + testcheck.check(r == double(3.0), "maxnum(2,3)==3", "maxnum(2,3)==3") # exp - r = vipersimd.simd_exp(t.CDouble(1.0)) - testcheck.check(r > t.CDouble(2.71) and r < t.CDouble(2.72), "exp(1)~=2.718", "exp(1)~=2.718") + r = vipersimd.simd_exp(double(1.0)) + testcheck.check(r > double(2.71) and r < double(2.72), "exp(1)~=2.718", "exp(1)~=2.718") # log - r = vipersimd.simd_log(t.CDouble(2.718281828459045)) - testcheck.check(r > t.CDouble(0.999) and r < t.CDouble(1.001), "log(e)~=1", "log(e)~=1") + r = vipersimd.simd_log(double(2.718281828459045)) + testcheck.check(r > double(0.999) and r < double(1.001), "log(e)~=1", "log(e)~=1") # sin - r = vipersimd.simd_sin(t.CDouble(0.0)) - testcheck.check(r > t.CDouble(-0.001) and r < t.CDouble(0.001), "sin(0)~=0", "sin(0)~=0") + r = vipersimd.simd_sin(double(0.0)) + testcheck.check(r > double(-0.001) and r < double(0.001), "sin(0)~=0", "sin(0)~=0") # cos - r = vipersimd.simd_cos(t.CDouble(0.0)) - testcheck.check(r > t.CDouble(0.999) and r < t.CDouble(1.001), "cos(0)~=1", "cos(0)~=1") + r = vipersimd.simd_cos(double(0.0)) + testcheck.check(r > double(0.999) and r < double(1.001), "cos(0)~=1", "cos(0)~=1") # pow - r = vipersimd.simd_pow(t.CDouble(2.0), t.CDouble(10.0)) - testcheck.check(r == t.CDouble(1024.0), "pow(2,10)==1024", "pow(2,10)==1024") + r = vipersimd.simd_pow(double(2.0), double(10.0)) + testcheck.check(r == double(1024.0), "pow(2,10)==1024", "pow(2,10)==1024") # ============================================================ # 4. 性能基准测试: SIMD vs 标量 # ============================================================ -N_ELEM: t.CDefine = 40000 -N_ITER: t.CDefine = 50000 +define N_ELEM = 40000 +define N_ITER = 50000 -def scalar_add_array(a: t.CPtr, b: t.CPtr, out: t.CPtr, n: t.CSizeT): - i: t.CSizeT = 0 - da: t.CDouble | t.CPtr = a - db: t.CDouble | t.CPtr = b - dout: t.CDouble | t.CPtr = out +def scalar_add_array(a: t.CPtr, b: t.CPtr, out: t.CPtr, n: sizet): + i: sizet = 0 + da: double | t.CPtr = a + db: double | t.CPtr = b + dout: double | t.CPtr = out while i < n: dout[i] = da[i] + db[i] i += 1 -def scalar_mul_array(a: t.CPtr, b: t.CPtr, out: t.CPtr, n: t.CSizeT): - i: t.CSizeT = 0 - da: t.CDouble | t.CPtr = a - db: t.CDouble | t.CPtr = b - dout: t.CDouble | t.CPtr = out +def scalar_mul_array(a: t.CPtr, b: t.CPtr, out: t.CPtr, n: sizet): + i: sizet = 0 + da: double | t.CPtr = a + db: double | t.CPtr = b + dout: double | t.CPtr = out while i < n: dout[i] = da[i] * db[i] i += 1 -def scalar_sqrt_array(a: t.CPtr, out: t.CPtr, n: t.CSizeT): - i: t.CSizeT = 0 - da: t.CDouble | t.CPtr = a - dout: t.CDouble | t.CPtr = out +def scalar_sqrt_array(a: t.CPtr, out: t.CPtr, n: sizet): + i: sizet = 0 + da: double | t.CPtr = a + dout: double | t.CPtr = out while i < n: dout[i] = vipersimd.simd_sqrt(da[i]) i += 1 @@ -393,15 +393,15 @@ def scalar_sqrt_array(a: t.CPtr, out: t.CPtr, n: t.CSizeT): def benchmark_simd_vs_scalar(): testcheck.section("Benchmark: SIMD vs Scalar") - a: numpy.ndarray[t.CDouble] | t.CPtr = numpy.full(pool, N_ELEM, t.CDouble(1.5)) - b: numpy.ndarray[t.CDouble] | t.CPtr = numpy.full(pool, N_ELEM, t.CDouble(2.5)) - out: numpy.ndarray[t.CDouble] | t.CPtr = numpy.zeros(pool, N_ELEM) + a: numpy.ndarray[double] | t.CPtr = numpy.full(pool, N_ELEM, double(1.5)) + b: numpy.ndarray[double] | t.CPtr = numpy.full(pool, N_ELEM, double(2.5)) + out: numpy.ndarray[double] | t.CPtr = numpy.zeros(pool, N_ELEM) # --- SIMD add benchmark --- t0: t.CLong = clock() - iter: t.CInt = 0 + iter: int = 0 while iter < N_ITER: - vipersimd.simd_add_array(a.data, b.data, out.data, t.CSizeT(N_ELEM)) + vipersimd.simd_add_array(a.data, b.data, out.data, sizet(N_ELEM)) iter += 1 t1: t.CLong = clock() simd_add_ms: t.CLong = t1 - t0 @@ -410,14 +410,14 @@ def benchmark_simd_vs_scalar(): t0 = clock() iter = 0 while iter < N_ITER: - scalar_add_array(a.data, b.data, out.data, t.CSizeT(N_ELEM)) + scalar_add_array(a.data, b.data, out.data, sizet(N_ELEM)) iter += 1 t1 = clock() scalar_add_ms: t.CLong = t1 - t0 printf(" ADD: SIMD=%ldms Scalar=%ldms", simd_add_ms, scalar_add_ms) if scalar_add_ms > 0: - printf(" speedup=%.1fx\n", t.CDouble(scalar_add_ms) / t.CDouble(simd_add_ms)) + printf(" speedup=%.1fx\n", double(scalar_add_ms) / double(simd_add_ms)) else: printf(" speedup=N/A\n") @@ -425,7 +425,7 @@ def benchmark_simd_vs_scalar(): t0 = clock() iter = 0 while iter < N_ITER: - vipersimd.simd_mul_array(a.data, b.data, out.data, t.CSizeT(N_ELEM)) + vipersimd.simd_mul_array(a.data, b.data, out.data, sizet(N_ELEM)) iter += 1 t1 = clock() simd_mul_ms: t.CLong = t1 - t0 @@ -434,14 +434,14 @@ def benchmark_simd_vs_scalar(): t0 = clock() iter = 0 while iter < N_ITER: - scalar_mul_array(a.data, b.data, out.data, t.CSizeT(N_ELEM)) + scalar_mul_array(a.data, b.data, out.data, sizet(N_ELEM)) iter += 1 t1 = clock() scalar_mul_ms: t.CLong = t1 - t0 printf(" MUL: SIMD=%ldms Scalar=%ldms", simd_mul_ms, scalar_mul_ms) if scalar_mul_ms > 0: - printf(" speedup=%.1fx\n", t.CDouble(scalar_mul_ms) / t.CDouble(simd_mul_ms)) + printf(" speedup=%.1fx\n", double(scalar_mul_ms) / double(simd_mul_ms)) else: printf(" speedup=N/A\n") @@ -449,7 +449,7 @@ def benchmark_simd_vs_scalar(): t0 = clock() iter = 0 while iter < N_ITER: - vipersimd.simd_sqrt_array(a.data, out.data, t.CSizeT(N_ELEM)) + vipersimd.simd_sqrt_array(a.data, out.data, sizet(N_ELEM)) iter += 1 t1 = clock() simd_sqrt_ms: t.CLong = t1 - t0 @@ -458,19 +458,19 @@ def benchmark_simd_vs_scalar(): t0 = clock() iter = 0 while iter < N_ITER: - scalar_sqrt_array(a.data, out.data, t.CSizeT(N_ELEM)) + scalar_sqrt_array(a.data, out.data, sizet(N_ELEM)) iter += 1 t1 = clock() scalar_sqrt_ms: t.CLong = t1 - t0 printf(" SQRT: SIMD=%ldms Scalar=%ldms", simd_sqrt_ms, scalar_sqrt_ms) if scalar_sqrt_ms > 0: - printf(" speedup=%.1fx\n", t.CDouble(scalar_sqrt_ms) / t.CDouble(simd_sqrt_ms)) + printf(" speedup=%.1fx\n", double(scalar_sqrt_ms) / double(simd_sqrt_ms)) else: printf(" speedup=N/A\n") # 验证结果正确性 - testcheck.check(out.data[0] > t.CDouble(0.0), "bench result[0] valid", "bench result[0] valid") + testcheck.check(out.data[0] > double(0.0), "bench result[0] valid", "bench result[0] valid") a.delete() b.delete() @@ -481,7 +481,7 @@ def benchmark_simd_vs_scalar(): # Main # ============================================================ -def main() -> t.CInt: +def main() -> int: global arena, pool arena = calloc(4096 * 1024, 1) # 4MB arena diff --git a/SprintfTest/App/main.vp b/SprintfTest/App/main.vp index e397247..3358236 100644 --- a/SprintfTest/App/main.vp +++ b/SprintfTest/App/main.vp @@ -19,37 +19,37 @@ def main() -> int: # ---------- 默认精度（核心正确性） ---------- testcheck.section("default precision") - v1: t.CDouble = 1.0 + v1: double = 1.0 viperlib.snprintf(buf, 64, "%a", v1) testcheck.info(buf) testcheck.check(string.strcmp(buf, "0x1p+0") == 0, "%a 1.0 -> 0x1p+0", "FAIL 1.0") - v2: t.CDouble = 2.0 + v2: double = 2.0 viperlib.snprintf(buf, 64, "%a", v2) testcheck.info(buf) testcheck.check(string.strcmp(buf, "0x1p+1") == 0, "%a 2.0 -> 0x1p+1", "FAIL 2.0") - v_half: t.CDouble = 0.5 + v_half: double = 0.5 viperlib.snprintf(buf, 64, "%a", v_half) testcheck.info(buf) testcheck.check(string.strcmp(buf, "0x1p-1") == 0, "%a 0.5 -> 0x1p-1", "FAIL 0.5") - v3: t.CDouble = 3.0 + v3: double = 3.0 viperlib.snprintf(buf, 64, "%a", v3) testcheck.info(buf) testcheck.check(string.strcmp(buf, "0x1.8p+1") == 0, "%a 3.0 -> 0x1.8p+1", "FAIL 3.0") - v_pi: t.CDouble = 3.14 + v_pi: double = 3.14 viperlib.snprintf(buf, 64, "%a", v_pi) testcheck.info(buf) testcheck.check(string.strcmp(buf, "0x1.91eb851eb851fp+1") == 0, "%a 3.14 -> 0x1.91eb851eb851fp+1", "FAIL 3.14") - v0: t.CDouble = 0.0 + v0: double = 0.0 viperlib.snprintf(buf, 64, "%a", v0) testcheck.info(buf) testcheck.check(string.strcmp(buf, "0x0p+0") == 0, "%a 0.0 -> 0x0p+0", "FAIL 0.0") - vn1: t.CDouble = -1.0 + vn1: double = -1.0 viperlib.snprintf(buf, 64, "%a", vn1) testcheck.info(buf) testcheck.check(string.strcmp(buf, "-0x1p+0") == 0, "%a -1.0 -> -0x1p+0", "FAIL -1.0") @@ -92,25 +92,25 @@ def main() -> int: testcheck.section("inf/nan") # 构造 +inf: bit pattern 0x7FF0000000000000 - inf_bits: t.CUInt64T = 0x7FF0000000000000 - inf_val: t.CDouble = 0.0 - c.Load(c.Addr(inf_val), c.Addr(inf_bits)) + inf_bits: uint64 = 0x7FF0000000000000 + inf_val: double = 0.0 + *(&inf_val) = *(&inf_bits) viperlib.snprintf(buf, 64, "%a", inf_val) testcheck.info(buf) testcheck.check(string.strcmp(buf, "inf") == 0, "%a +inf -> inf", "FAIL +inf") # 构造 -inf: bit pattern 0xFFF0000000000000 - ninf_bits: t.CUInt64T = 0xFFF0000000000000 - ninf_val: t.CDouble = 0.0 - c.Load(c.Addr(ninf_val), c.Addr(ninf_bits)) + ninf_bits: uint64 = 0xFFF0000000000000 + ninf_val: double = 0.0 + *(&ninf_val) = *(&ninf_bits) viperlib.snprintf(buf, 64, "%a", ninf_val) testcheck.info(buf) testcheck.check(string.strcmp(buf, "-inf") == 0, "%a -inf -> -inf", "FAIL -inf") # 构造 nan: bit pattern 0x7FF8000000000000 - nan_bits: t.CUInt64T = 0x7FF8000000000000 - nan_val: t.CDouble = 0.0 - c.Load(c.Addr(nan_val), c.Addr(nan_bits)) + nan_bits: uint64 = 0x7FF8000000000000 + nan_val: double = 0.0 + *(&nan_val) = *(&nan_bits) viperlib.snprintf(buf, 64, "%a", nan_val) testcheck.info(buf) testcheck.check(string.strcmp(buf, "nan") == 0, "%a nan -> nan", "FAIL nan") @@ -127,8 +127,8 @@ def main() -> int: # ============================================================ testcheck.section("viperlib %g bug diagnosis") - v_pi17: t.CDouble = 3.1415926535897931 - v_e17: t.CDouble = 2.7182818284590455 + v_pi17: double = 3.1415926535897931 + v_e17: double = 2.7182818284590455 # T1: 同一参数 %.17g vs %a（复现；%a 对则说明值本身正确） viperlib.snprintf(buf, 128, "T1 %.17g|%a", v_pi17, v_pi17) @@ -182,9 +182,9 @@ def main() -> int: testcheck.check(string.strcmp(buf, "R1 1024|4096|255") == 0, "R1 3-const-int (1024|4096|255)", "R1 FAIL (第2变参被误读)") # R2: 3 个运行时变量 int（排除常量折叠差异） - ia: t.CInt = 1024 - ib: t.CInt = 4096 - ic: t.CInt = 255 + ia: int = 1024 + ib: int = 4096 + ic: int = 255 viperlib.snprintf(buf, 128, "R2 %d|%d|%d", ia, ib, ic) testcheck.info(buf) testcheck.check(string.strcmp(buf, "R2 1024|4096|255") == 0, "R2 3-var-int (1024|4096|255)", "R2 FAIL (第2变参被误读)") diff --git a/StringIterTest/App/inline_test.vp b/StringIterTest/App/inline_test.vp index 256eaf1..980c2a1 100644 --- a/StringIterTest/App/inline_test.vp +++ b/StringIterTest/App/inline_test.vp @@ -5,26 +5,26 @@ import c # Test: class with inline list[struct, N] field class Inner: - code: t.CUnsignedInt - bits: t.CInt + code: uint + bits: int class Container: items: t.CArray[Inner, 10] - count: t.CInt + count: int def __init__(self): self.count = 0 def fill(self): for i in range(10): - self.items[i].code = t.CUnsignedInt(i * 100) + self.items[i].code = uint(i * 100) self.items[i].bits = i self.count += 1 def check(self): - ok: t.CInt = 1 + ok: int = 1 for i in range(10): - if self.items[i].code != t.CUnsignedInt(i * 100): + if self.items[i].code != uint(i * 100): stdio.printf("FAIL: items[%d].code=%u expect %d\n", i, self.items[i].code, i * 100) ok = 0 if self.items[i].bits != i: @@ -35,7 +35,7 @@ class Container: else: stdio.printf("FAIL: inline list[struct, N] in Container\n") -def inline_array_test() -> t.CInt: +def inline_array_test() -> int: stdio.printf("=== InlineArrayTest ===\n") c1 = Container() c1.fill() diff --git a/StringIterTest/App/main.vp b/StringIterTest/App/main.vp index 8155d8d..4d3f3b0 100644 --- a/StringIterTest/App/main.vp +++ b/StringIterTest/App/main.vp @@ -10,10 +10,10 @@ import inline_test # ============================================================ def test_string_ptr_iter(): testcheck.section("Test 1: string pointer iteration") - s: t.CChar | t.CPtr = "Hello" - p: t.CChar | t.CPtr = s - count: t.CInt = 0 - while c.Deref(p) != 0: + s: char | t.CPtr = "Hello" + p: char | t.CPtr = s + count: int = 0 + while *p != 0: count += 1 p += 1 testcheck.check(count == 5, "ptr iter (count=5)", "ptr iter (count expect 5)") @@ -23,11 +23,11 @@ def test_string_ptr_iter(): # ============================================================ def test_string_ascii_sum(): testcheck.section("Test 2: string ASCII sum") - s: t.CChar | t.CPtr = "ABC" - p: t.CChar | t.CPtr = s - total: t.CInt = 0 - while c.Deref(p) != 0: - total += t.CInt(c.Deref(p)) + s: char | t.CPtr = "ABC" + p: char | t.CPtr = s + total: int = 0 + while *p != 0: + total += int(*p) p += 1 # A=65, B=66, C=67 => 198 testcheck.check(total == 198, "ASCII sum (total=198)", "ASCII sum (total expect 198)") @@ -37,15 +37,15 @@ def test_string_ascii_sum(): # ============================================================ def test_manual_strcpy(): testcheck.section("Test 3: manual strcpy via pointers") - src: t.CChar | t.CPtr = "Test" - dst: t.CArray[t.CChar, 32] = [0] - sp: t.CChar | t.CPtr = src - dp: t.CChar | t.CPtr = c.Addr(dst) - while c.Deref(sp) != 0: - c.Set(c.Deref(dp), c.Deref(sp)) + src: char | t.CPtr = "Test" + dst: t.CArray[char, 32] = [0] + sp: char | t.CPtr = src + dp: char | t.CPtr = &dst + while *sp != 0: + *dp = *sp sp += 1 dp += 1 - c.Set(c.Deref(dp), 0) + *dp = 0 testcheck.check(dst[0] == 84 and dst[1] == 101 and dst[2] == 115 and dst[3] == 116, "manual strcpy (T=84 e=101 s=115 t=116)", "manual strcpy (expect T=84 e=101 s=115 t=116)") # ============================================================ @@ -53,14 +53,14 @@ def test_manual_strcpy(): # ============================================================ def test_ptr_offset_compare(): testcheck.section("Test 4: pointer offset and compare") - arr: t.CArray[t.CInt, 5] = [0] + arr: t.CArray[int, 5] = [0] for i in range(5): arr[i] = i * 10 - p: t.CInt | t.CPtr = c.Addr(arr) - start: t.CInt | t.CPtr = p - total: t.CInt = 0 + p: int | t.CPtr = &arr + start: int | t.CPtr = p + total: int = 0 while p != start + 5: - total += c.Deref(p) + total += *p p += 1 testcheck.check(total == 100, "ptr offset (total=100)", "ptr offset (total expect 100)") @@ -69,10 +69,10 @@ def test_ptr_offset_compare(): # ============================================================ def test_manual_strlen(): testcheck.section("Test 5: manual strlen") - s: t.CChar | t.CPtr = "Hello World!" - p: t.CChar | t.CPtr = s - length: t.CSizeT = 0 - while c.Deref(p) != 0: + s: char | t.CPtr = "Hello World!" + p: char | t.CPtr = s + length: sizet = 0 + while *p != 0: length += 1 p += 1 testcheck.check(length == 12, "manual strlen (len=12)", "manual strlen (len expect 12)") @@ -82,22 +82,22 @@ def test_manual_strlen(): # ============================================================ def test_reverse_string_ptr(): testcheck.section("Test 6: reverse string via pointer") - src: t.CChar | t.CPtr = "abcd" - dst: t.CArray[t.CChar, 32] = [0] + src: char | t.CPtr = "abcd" + dst: t.CArray[char, 32] = [0] # Find end of src - p: t.CChar | t.CPtr = src - length: t.CInt = 0 - while c.Deref(p) != 0: + p: char | t.CPtr = src + length: int = 0 + while *p != 0: length += 1 p += 1 # Copy in reverse - dp: t.CChar | t.CPtr = c.Addr(dst) + dp: char | t.CPtr = &dst p = src + length - 1 while p >= src: - c.Set(c.Deref(dp), c.Deref(p)) + *dp = *p dp += 1 p -= 1 - c.Set(c.Deref(dp), 0) + *dp = 0 # "abcd" reversed = "dcba" = 100,99,98,97 testcheck.check(dst[0] == 100 and dst[1] == 99 and dst[2] == 98 and dst[3] == 97, "reverse string (d=100 c=99 b=98 a=97)", "reverse string (expect d=100 c=99 b=98 a=97)") @@ -106,11 +106,11 @@ def test_reverse_string_ptr(): # ============================================================ def test_double_pointer(): testcheck.section("Test 7: double pointer") - x: t.CInt = 42 - px: t.CInt | t.CPtr = c.Addr(x) - ppx: t.CInt | t.CPtr | t.CPtr = c.Addr(px) + x: int = 42 + px: int | t.CPtr = &x + ppx: int | t.CPtr | t.CPtr = &px # Read through double pointer - val: t.CInt = c.Deref(c.Deref(ppx)) + val: int = *(*ppx) testcheck.check(val == 42, "double pointer (val=42)", "double pointer (val expect 42)") # ============================================================ @@ -118,12 +118,12 @@ def test_double_pointer(): # ============================================================ def test_ptr_arithmetic(): testcheck.section("Test 8: pointer arithmetic") - arr: t.CArray[t.CInt, 8] = [0] + arr: t.CArray[int, 8] = [0] for i in range(8): arr[i] = (i + 1) * (i + 1) - p: t.CInt | t.CPtr = c.Addr(arr) + p: int | t.CPtr = &arr # Access arr[3] via pointer: p + 3 - val: t.CInt = c.Deref(p + 3) + val: int = *(p + 3) # arr[3] = 4*4 = 16 testcheck.check(val == 16, "ptr arithmetic (arr[3]=16)", "ptr arithmetic (arr[3] expect 16)") @@ -132,18 +132,18 @@ def test_ptr_arithmetic(): # ============================================================ def test_manual_strcmp(): testcheck.section("Test 9: manual strcmp via pointers") - s1: t.CChar | t.CPtr = "Hello" - s2: t.CChar | t.CPtr = "Hello" - p1: t.CChar | t.CPtr = s1 - p2: t.CChar | t.CPtr = s2 - equal: t.CInt = 1 - while c.Deref(p1) != 0 and c.Deref(p2) != 0: - if c.Deref(p1) != c.Deref(p2): + s1: char | t.CPtr = "Hello" + s2: char | t.CPtr = "Hello" + p1: char | t.CPtr = s1 + p2: char | t.CPtr = s2 + equal: int = 1 + while *p1 != 0 and *p2 != 0: + if *p1 != *p2: equal = 0 break p1 += 1 p2 += 1 - if c.Deref(p1) != c.Deref(p2): + if *p1 != *p2: equal = 0 testcheck.check(equal == 1, "manual strcmp (equal=1)", "manual strcmp (equal expect 1)") @@ -151,21 +151,21 @@ def test_manual_strcmp(): # Test 10: 结构体指针访问 # ============================================================ class Vec2: - x: t.CInt - y: t.CInt + x: int + y: int def test_struct_ptr_access(): testcheck.section("Test 10: struct pointer access") v: Vec2 = Vec2() v.x = 10 v.y = 20 - p: Vec2 | t.CPtr = c.Addr(v) + p: Vec2 | t.CPtr = &v # Modify through pointer - c.Deref(p).x = 100 - c.Deref(p).y = 200 + (*p).x = 100 + (*p).y = 200 testcheck.check(v.x == 100 and v.y == 200, "struct ptr (x=100 y=200)", "struct ptr (x y expect 100 200)") -def main() -> t.CInt: +def main() -> int: testcheck.begin("StringIterTest: String/Pointer Iteration Tests") test_string_ptr_iter() test_string_ascii_sum() diff --git a/StringTest/App/main.vp b/StringTest/App/main.vp index b4b0fb2..8092151 100644 --- a/StringTest/App/main.vp +++ b/StringTest/App/main.vp @@ -6,74 +6,74 @@ import w32.win32memory def test_strlen(): testcheck.section("Test 1: strlen") - s: t.CChar | t.CPtr = "Hello, World!" - length: t.CUInt64T = string.strlen(s) + s: char | t.CPtr = "Hello, World!" + length: uint64 = string.strlen(s) testcheck.check(length == 13, "strlen (len=13)", "strlen (expect 13)") def test_strcpy(): testcheck.section("Test 2: strcpy") - buf: t.CChar | t.CPtr = w32.win32memory.VirtualAlloc(None, 64, 12288, 4) - if t.CUInt64T(buf) == 0: + buf: char | t.CPtr = w32.win32memory.VirtualAlloc(None, 64, 12288, 4) + if uint64(buf) == 0: stdio.printf("SKIP: VirtualAlloc returned NULL\n") return string.memset(buf, 0, 64) string.strcpy(buf, "test string") - cmp_result: t.CInt = string.strcmp(buf, "test string") + cmp_result: int = string.strcmp(buf, "test string") testcheck.check(cmp_result == 0, "strcpy (result=test string)", "strcpy (cmp mismatch)") def test_strcat(): testcheck.section("Test 3: strcat (via memcpy)") - buf: t.CChar | t.CPtr = w32.win32memory.VirtualAlloc(None, 64, 12288, 4) - if t.CUInt64T(buf) == 0: + buf: char | t.CPtr = w32.win32memory.VirtualAlloc(None, 64, 12288, 4) + if uint64(buf) == 0: stdio.printf("SKIP: VirtualAlloc returned NULL\n") return string.memset(buf, 0, 64) # 手动拼接: 先拷贝 "Hello"，再拷贝 " World" - hello: t.CChar | t.CPtr = "Hello" - world: t.CChar | t.CPtr = " World" + hello: char | t.CPtr = "Hello" + world: char | t.CPtr = " World" string.memcpy(buf, hello, 5) - string.memcpy(t.CPtr(t.CUInt64T(buf) + 5), world, 6) - cmp_result: t.CInt = string.strcmp(buf, "Hello World") + string.memcpy(t.CPtr(uint64(buf) + 5), world, 6) + cmp_result: int = string.strcmp(buf, "Hello World") testcheck.check(cmp_result == 0, "strcat via memcpy", "strcat via memcpy (cmp mismatch)") def test_strcmp(): testcheck.section("Test 4: strcmp") - r1: t.CInt = string.strcmp("abc", "abc") - r2: t.CInt = string.strcmp("abc", "abd") - r3: t.CInt = string.strcmp("abd", "abc") + r1: int = string.strcmp("abc", "abc") + r2: int = string.strcmp("abc", "abd") + r3: int = string.strcmp("abd", "abc") testcheck.check(r1 == 0 and r2 < 0 and r3 > 0, "strcmp (eq=0 lt<0 gt>0)", "strcmp (expect eq=0 lt<0 gt>0)") def test_strncpy(): testcheck.section("Test 5: strncpy") - buf: t.CChar | t.CPtr = w32.win32memory.VirtualAlloc(None, 64, 12288, 4) - if t.CUInt64T(buf) == 0: + buf: char | t.CPtr = w32.win32memory.VirtualAlloc(None, 64, 12288, 4) + if uint64(buf) == 0: stdio.printf("SKIP: VirtualAlloc returned NULL\n") return string.memset(buf, 0, 64) string.strncpy(buf, "ABCDEFGHIJ", 5) - cmp_result: t.CInt = string.strcmp(buf, "ABCDE") + cmp_result: int = string.strcmp(buf, "ABCDE") testcheck.check(cmp_result == 0, "strncpy (result=ABCDE)", "strncpy (cmp mismatch)") def test_char_access(): testcheck.section("Test 6: char access") - s: t.CChar | t.CPtr = "ABCDE" - val: t.CUInt8T = s[2] # 'C' = 67 + s: char | t.CPtr = "ABCDE" + val: uint8 = s[2] # 'C' = 67 testcheck.check(val == 67, "char access (s[2]=67='C')", "char access (s[2] expect 67)") def test_snprintf(): testcheck.section("Test 7: snprintf") - buf: t.CChar | t.CPtr = w32.win32memory.VirtualAlloc(None, 128, 12288, 4) - if t.CUInt64T(buf) == 0: + buf: char | t.CPtr = w32.win32memory.VirtualAlloc(None, 128, 12288, 4) + if uint64(buf) == 0: stdio.printf("SKIP: VirtualAlloc returned NULL\n") return string.memset(buf, 0, 128) stdio.snprintf(buf, 128, "value=%d hex=0x%x str=%s", 42, 255, "test") - cmp_result: t.CInt = string.strcmp(buf, "value=42 hex=0xff str=test") + cmp_result: int = string.strcmp(buf, "value=42 hex=0xff str=test") testcheck.check(cmp_result == 0, "snprintf (result=value=42 hex=0xff str=test)", "snprintf (result mismatch)") import w32.win32memory -def main() -> t.CInt: +def main() -> int: testcheck.begin("StringTest: 字符串操作基准测试") test_strlen() test_strcpy() diff --git a/StructTest/App/main.vp b/StructTest/App/main.vp index d88057a..edb9c67 100644 --- a/StructTest/App/main.vp +++ b/StructTest/App/main.vp @@ -5,15 +5,15 @@ import testcheck # 定义结构体 class Point(): - x: t.CInt - y: t.CInt + x: int + y: int class Rect(): origin: Point size: Point class Node(): - value: t.CInt + value: int next: t.CPtr # Node* 类型 def test_struct_basic(): @@ -38,7 +38,7 @@ def test_struct_pointer(): p.x = 42 p.y = 84 # 取结构体指针 - pp: Point | t.CPtr = t.CPtr(t.CUInt64T(p)) + pp: Point | t.CPtr = t.CPtr(uint64(p)) # 通过指针修改 pp.x = 100 pp.y = 200 @@ -50,17 +50,17 @@ def test_struct_param(): p: Point = Point() p.x = 5 p.y = 15 - sum_val: t.CInt = point_sum(p) + sum_val: int = point_sum(p) testcheck.check(sum_val == 20, "struct param (sum=20)", "struct param (sum expect 20)") -def point_sum(p: Point) -> t.CInt: +def point_sum(p: Point) -> int: return p.x + p.y def test_struct_array(): testcheck.section("Test 5: struct array") # 分配结构体数组 - buf: t.CUInt8T | t.CPtr = w32.win32memory.VirtualAlloc(None, 256, 12288, 4) - if t.CUInt64T(buf) == 0: + buf: uint8 | t.CPtr = w32.win32memory.VirtualAlloc(None, 256, 12288, 4) + if uint64(buf) == 0: stdio.printf("SKIP: VirtualAlloc returned NULL\n") return string.memset(buf, 0, 256) @@ -70,12 +70,12 @@ def test_struct_array(): pts[0].y = 2 pts[1].x = 3 pts[1].y = 4 - total: t.CInt = pts[0].x + pts[0].y + pts[1].x + pts[1].y + total: int = pts[0].x + pts[0].y + pts[1].x + pts[1].y testcheck.check(total == 10, "struct array (total=10)", "struct array (total expect 10)") import w32.win32memory -def main() -> t.CInt: +def main() -> int: testcheck.begin("StructTest: 结构体操作基准测试") test_struct_basic() test_struct_nested() diff --git a/SysLibTest/App/main.vp b/SysLibTest/App/main.vp index 9b4c375..032ebda 100644 --- a/SysLibTest/App/main.vp +++ b/SysLibTest/App/main.vp @@ -15,7 +15,7 @@ import syslibtest_impl # MBuddy arena 大小：1MB -ARENA_SIZE: t.CDefine = 1048576 +define ARENA_SIZE = 1048576 def main() -> CInt | CExport: diff --git a/SysLibTest/App/os_backend.vp b/SysLibTest/App/os_backend.vp index cf9a5f1..4271bb8 100644 --- a/SysLibTest/App/os_backend.vp +++ b/SysLibTest/App/os_backend.vp @@ -32,7 +32,7 @@ def os_isdir(path: str) -> bool: return os._posix.isdir(path) -def os_getsize(path: str) -> t.CInt64T: +def os_getsize(path: str) -> int64: """返回文件大小（字节，跨平台）。失败返回 -1。""" if platmacro.IS_WINDOWS: return os._win32.getsize(path) diff --git a/SysLibTest/App/syslibtest_impl.vp b/SysLibTest/App/syslibtest_impl.vp index 3318afa..232eaa6 100644 --- a/SysLibTest/App/syslibtest_impl.vp +++ b/SysLibTest/App/syslibtest_impl.vp @@ -19,11 +19,11 @@ 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" +define TEST_DIR = "__sylibtest_dir__" +define TEST_FILE = "__sylibtest_file.txt" +define TEST_COPY = "__sylibtest_copy.txt" +define TEST_TREE = "__sylibtest_tree__" +define TEST_MOVE = "__sylibtest_moved.txt" # ============================================================================= @@ -128,7 +128,7 @@ def run() -> CInt: testcheck.section("os.path 路径操作") # sep - sep_char: t.CChar = os.path.sep() + sep_char: char = os.path.sep() viperlib.snprintf(buf, 512, "sep = %c", sep_char) testcheck.info(buf) @@ -198,8 +198,8 @@ def run() -> CInt: 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) + src_size: int64 = os_backend.os_getsize(TEST_FILE) + dst_size: int64 = 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") diff --git a/TestFBProject/App/main.vp b/TestFBProject/App/main.vp index 0ca823f..005bf52 100644 --- a/TestFBProject/App/main.vp +++ b/TestFBProject/App/main.vp @@ -4,10 +4,10 @@ import t, c import testcheck -def add_inline(a: t.CInt, b: t.CInt) -> t.CDefine: +def add_inline(a: int, b: int) -> t.CDefine: return a + b -def mul_inline(a: t.CInt, b: t.CInt) -> t.CDefine: +def mul_inline(a: int, b: int) -> t.CDefine: return a * b @@ -34,7 +34,7 @@ def raise_timeout(): raise TimeoutError("operation timed out") -def main() -> t.CInt | t.CExport: +def main() -> int | t.CExport: w32.win32console.SetConsoleCP(65001) w32.win32console.SetConsoleOutputCP(65001) @@ -136,23 +136,23 @@ def main() -> t.CInt | t.CExport: testcheck.fail("Test 10: caught by generic except") testcheck.section("Test LLVMIR: inline LLVM IR add") - x: t.CInt = 10 - y: t.CInt = 20 - r: t.CInt + x: int = 10 + y: int = 20 + r: int c.LLVMIR(f"{c.LOut(r)} = add i32 {c.LInp(x)}, {c.LInp(y)}") print("LLVMIR add result:", r) testcheck.check(r == 30, "LLVMIR add (10+20=30)", "LLVMIR add result mismatch") testcheck.section("Test CDefine function macro") - s: t.CInt = add_inline(3, 4) + s: int = add_inline(3, 4) print("add_inline(3, 4) =", s) testcheck.check(s == 7, "add_inline(3, 4) = 7", "add_inline result mismatch") - m: t.CInt = mul_inline(5, 6) + m: int = mul_inline(5, 6) print("mul_inline(5, 6) =", m) testcheck.check(m == 30, "mul_inline(5, 6) = 30", "mul_inline result mismatch") testcheck.section("Test LLVMIR with LOut") - out_val: t.CInt = 0 + out_val: int = 0 c.LLVMIR(f"{c.LOut(out_val)} = add i32 {c.LInp(x)}, {c.LInp(y)}") print("LLVMIR LOut result:", out_val) testcheck.check(out_val == 30, "LLVMIR LOut (10+20=30)", "LLVMIR LOut result mismatch") diff --git a/ThreadingTest/App/main.vp b/ThreadingTest/App/main.vp index 3d594d0..5a2513c 100644 --- a/ThreadingTest/App/main.vp +++ b/ThreadingTest/App/main.vp @@ -19,18 +19,18 @@ import vthreading # ============================================================ # 共享状态（模块级全局，跨线程读写） # ============================================================ -_shared_count: t.CInt = 0 # Lock 并发测试共享计数器 -_evt_done: t.CInt = 0 # Event 测试完成标志 -_cond_ready: t.CInt = 0 # Condition 测试就绪标志 -_rw_value: t.CInt = 0 # RWLock 测试共享值 -_main_tid: t.CUInt32T = 0 # 主线程 ID +_shared_count: int = 0 # Lock 并发测试共享计数器 +_evt_done: int = 0 # Event 测试完成标志 +_cond_ready: int = 0 # Condition 测试就绪标志 +_rw_value: int = 0 # RWLock 测试共享值 +_main_tid: uint32 = 0 # 主线程 ID # 并发规模常量 -THREAD_NUM: t.CInt = 4 -LOCK_ITER: t.CInt = 1000 -RW_ITER: t.CInt = 100 -TLS_NUM: t.CInt = 4 -SYS_ITER: t.CInt = 10 +THREAD_NUM: int = 4 +LOCK_ITER: int = 1000 +RW_ITER: int = 100 +TLS_NUM: int = 4 +SYS_ITER: int = 10 # ============================================================ @@ -45,10 +45,10 @@ def _basic_worker(arg: t.CPtr) -> t.CPtr: # 传参: 通过 arg 指针自增 100 次（c.Deref/c.DerefAs 读写） def _increment_worker(arg: t.CPtr) -> t.CPtr: - ip: t.CInt | t.CPtr = (t.CInt | t.CPtr)(arg) - i: t.CInt + ip: int | t.CPtr = (int | t.CPtr)(arg) + i: int for i in range(100): - c.DerefAs(ip, c.Deref(ip) + 1) + c.DerefAs(ip, *ip + 1) return NULL @@ -67,7 +67,7 @@ def _lock_worker(arg: t.CPtr) -> t.CPtr: def _event_worker(arg: t.CPtr) -> t.CPtr: ev: vthreading.Event | t.CPtr = (vthreading.Event | t.CPtr)(arg) global _evt_done - r: t.CInt = ev.wait(5000) + r: int = ev.wait(5000) if r == 1: _evt_done = 1 return NULL @@ -77,7 +77,7 @@ def _event_worker(arg: t.CPtr) -> t.CPtr: def _cond_consumer(arg: t.CPtr) -> t.CPtr: cond: vthreading.Condition | t.CPtr = (vthreading.Condition | t.CPtr)(arg) global _cond_ready - tries: t.CInt = 0 + tries: int = 0 cond.acquire() while _cond_ready == 0 and tries < 100: cond.wait(100) @@ -102,10 +102,10 @@ def _cond_producer(arg: t.CPtr) -> t.CPtr: def _rw_reader(arg: t.CPtr) -> t.CPtr: rwl: vthreading.RWLock | t.CPtr = (vthreading.RWLock | t.CPtr)(arg) global _rw_value - i: t.CInt + i: int for i in range(RW_ITER * 10): rwl.acquire_read() - v: t.CInt = _rw_value + v: int = _rw_value rwl.release_read() return NULL @@ -114,7 +114,7 @@ def _rw_reader(arg: t.CPtr) -> t.CPtr: def _rw_writer(arg: t.CPtr) -> t.CPtr: rwl: vthreading.RWLock | t.CPtr = (vthreading.RWLock | t.CPtr)(arg) global _rw_value - i: t.CInt + i: int for i in range(RW_ITER): rwl.acquire_write() _rw_value += 1 @@ -125,38 +125,38 @@ def _rw_writer(arg: t.CPtr) -> t.CPtr: # TLS: 每线程 set/get 自校验（存入自身线程 ID 再读回比对） def _tls_worker(arg: t.CPtr) -> t.CPtr: tls: vthreading.local = vthreading.local() - tls.set(t.CPtr(t.CUInt64T(vthreading.get_current_thread_id()))) - tid_val: t.CUInt64T = t.CUInt64T(tls.get()) - ok: t.CInt = 0 - if tid_val == t.CUInt64T(vthreading.get_current_thread_id()): + tls.set(t.CPtr(uint64(vthreading.get_current_thread_id()))) + tid_val: uint64 = uint64(tls.get()) + ok: int = 0 + if tid_val == uint64(vthreading.get_current_thread_id()): ok = 1 tls.free() - return t.CPtr(t.CUInt64T(ok)) + return t.CPtr(uint64(ok)) # 线程 ID 隔离: 工作线程 ID 必须与主线程不同 def _tid_worker(arg: t.CPtr) -> t.CPtr: global _main_tid if vthreading.get_current_thread_id() == _main_tid: - return t.CPtr(t.CUInt64T(0)) - return t.CPtr(t.CUInt64T(1)) + return t.CPtr(uint64(0)) + return t.CPtr(uint64(1)) # stdlib.system 多线程并发: 每线程循环调 C 运行时 system()，统计失败次数 def _system_worker(arg: t.CPtr) -> t.CPtr: - i: t.CInt - fails: t.CInt = 0 + i: int + fails: int = 0 for i in range(SYS_ITER): - r: t.CInt = stdlib.system("echo ok > NUL") + r: int = stdlib.system("echo ok > NUL") if r != 0: fails += 1 - return t.CPtr(t.CUInt64T(fails)) + return t.CPtr(uint64(fails)) # ============================================================ # main # ============================================================ -def main() -> t.CInt | t.CExport: +def main() -> int | t.CExport: testcheck.begin("ThreadingTest: vthreading 专项测试") # ========== Thread: start/join/is_alive/get_exit_code ========== @@ -172,8 +172,8 @@ def main() -> t.CInt | t.CExport: # ========== Thread: 通过 arg 传参 ========== testcheck.section("Thread: arg 传参") - cnt: t.CInt = 0 - th2: vthreading.Thread = vthreading.Thread(_increment_worker, c.Addr(cnt)) + cnt: int = 0 + th2: vthreading.Thread = vthreading.Thread(_increment_worker, &cnt) th2.start() testcheck.check(th2.join(5000) != FALSE, "join 正常返回", "join 超时") th2.close() @@ -190,10 +190,10 @@ def main() -> t.CInt | t.CExport: t1.start() t2.start() t3.start() - j0: t.CInt = t0.join(10000) - j1: t.CInt = t1.join(10000) - j2: t.CInt = t2.join(10000) - j3: t.CInt = t3.join(10000) + j0: int = t0.join(10000) + j1: int = t1.join(10000) + j2: int = t2.join(10000) + j3: int = t3.join(10000) t0.close() t1.close() t2.close() @@ -247,7 +247,7 @@ def main() -> t.CInt | t.CExport: # ========== local: TLS 线程局部存储 ========== testcheck.section("local: TLS 线程局部存储") - i_t: t.CInt + i_t: int for i_t in range(TLS_NUM): th_t: vthreading.Thread = vthreading.Thread(_tls_worker, NULL) th_t.start() diff --git a/TypeCastTest/App/main.vp b/TypeCastTest/App/main.vp index 6cff824..1d62578 100644 --- a/TypeCastTest/App/main.vp +++ b/TypeCastTest/App/main.vp @@ -13,61 +13,61 @@ import testcheck # --- Test 1: CUInt8T -> CUInt32T 零扩展 (zext) --- def test_zext_u8_u32(): - v: t.CUInt8T = 200 # 0xC8, 如果 sign-extend 会变成 0xFFFFFFC8 - wide: t.CUInt32T = t.CUInt32T(v) + v: uint8 = 200 # 0xC8, 如果 sign-extend 会变成 0xFFFFFFC8 + wide: uint32 = uint32(v) testcheck.check(wide == 200, "zext u8->u32 (200)", "zext u8->u32 (expected 200)") # --- Test 2: CInt8T -> CInt32T 符号扩展 (sext) --- def test_sext_i8_i32(): - v: t.CInt8T = -50 # 0xCE - wide: t.CInt32T = t.CInt32T(v) + v: int8 = -50 # 0xCE + wide: int32 = int32(v) testcheck.check(wide == -50, "sext i8->i32 (-50)", "sext i8->i32 (expected -50)") # --- Test 3: CUInt32T -> CUInt64T 零扩展 --- def test_zext_u32_u64(): - v: t.CUInt32T = 0x80000000 # 最高位为1 - wide: t.CUInt64T = t.CUInt64T(v) + v: uint32 = 0x80000000 # 最高位为1 + wide: uint64 = uint64(v) testcheck.check(wide == 0x80000000, "zext u32->u64 (0x80000000)", "zext u32->u64 (expected 0x80000000)") # --- Test 4: CInt32T -> CInt64T 符号扩展 --- def test_sext_i32_i64(): - v: t.CInt32T = -1 # 0xFFFFFFFF - wide: t.CInt64T = t.CInt64T(v) + v: int32 = -1 # 0xFFFFFFFF + wide: int64 = int64(v) testcheck.check(wide == -1, "sext i32->i64 (-1)", "sext i32->i64 (expected -1)") # --- Test 5: CUInt64T -> CUInt32T 截断 (trunc) --- def test_trunc_u64_u32(): - v: t.CUInt64T = 0x123456789ABCDEF0 - narrow: t.CUInt32T = t.CUInt32T(v) + v: uint64 = 0x123456789ABCDEF0 + narrow: uint32 = uint32(v) testcheck.check(narrow == 0x9ABCDEF0, "trunc u64->u32 (0x9ABCDEF0)", "trunc u64->u32 (expected 0x9ABCDEF0)") # --- Test 6: 有符号/无符号混合运算 --- def test_mixed_signed_unsigned(): - a: t.CInt = -10 - b: t.CUInt32T = 20 + a: int = -10 + b: uint32 = 20 # C 中有符号/无符号混合运算，有符号会转为无符号 # -10 作为 unsigned 是 0xFFFFFFF6 = 4294967286 # 4294967286 + 20 = 4294967306 (overflow to 10 on u32) - result: t.CUInt32T = t.CUInt32T(a) + b - stdio.printf(" mixed signed+unsigned: %u (C behavior: %u)\n", result, t.CUInt32T(-10) + 20) + result: uint32 = uint32(a) + b + stdio.printf(" mixed signed+unsigned: %u (C behavior: %u)\n", result, uint32(-10) + 20) testcheck.ok("mixed signed+unsigned (C behavior)") # --- Test 7: CDefine 常量在运算中的行为 --- -VAL_32BIT: t.CDefine = 0x80000000 -VAL_NEG: t.CDefine = -1 -VAL_BIG: t.CDefine = 0xFFFFFFFF +define VAL_32BIT = 0x80000000 +define VAL_NEG = -1 +define VAL_BIG = 0xFFFFFFFF def test_cdefine_values(): """测试 CDefine 常量值是否正确""" - v1: t.CUInt32T = t.CUInt32T(VAL_32BIT) - v2: t.CInt = VAL_NEG - v3: t.CUInt32T = t.CUInt32T(VAL_BIG) + v1: uint32 = uint32(VAL_32BIT) + v2: int = VAL_NEG + v3: uint32 = uint32(VAL_BIG) stdio.printf(" CDefine: 0x80000000=%u, -1=%d, 0xFFFFFFFF=%u\n", v1, v2, v3) testcheck.ok("CDefine constants") @@ -76,30 +76,30 @@ def test_cdefine_values(): def test_bitops_width(): """测试位运算是否保持正确类型宽度""" # 左移 - v: t.CUInt32T = 1 - shifted: t.CUInt32T = v << 31 # 应该是 0x80000000 + v: uint32 = 1 + shifted: uint32 = v << 31 # 应该是 0x80000000 testcheck.check(shifted == 0x80000000, "bit shift (1<<31 = 0x80000000)", "bit shift (expected 0x80000000)") # 右移 - back: t.CUInt32T = shifted >> 31 # 应该是 1 + back: uint32 = shifted >> 31 # 应该是 1 testcheck.check(back == 1, "bit shift (0x80000000>>31 = 1)", "bit shift (expected 1)") # --- Test 9: 整数除法与取模 (无符号) --- def test_unsigned_divmod(): - a: t.CUInt32T = 100 - b: t.CUInt32T = 7 - q: t.CUInt32T = a // b - r: t.CUInt32T = a % b + a: uint32 = 100 + b: uint32 = 7 + q: uint32 = a // b + r: uint32 = a % b testcheck.check(q == 14 and r == 2, "unsigned div/mod (100//7=14, 100%7=2)", "unsigned div/mod (expected 14,2)") # --- Test 10: 整数除法与取模 (有符号负数) --- def test_signed_divmod_neg(): - a: t.CInt = -100 - b: t.CInt = 7 - q: t.CInt = a // b - r: t.CInt = a % b + a: int = -100 + b: int = 7 + q: int = a // b + r: int = a % b # C 语言: -100/7 = -14, -100%7 = -2 # Python: -100//7 = -15, -100%7 = 5 # TransPyC 应该遵循 C 语义 @@ -109,60 +109,60 @@ def test_signed_divmod_neg(): # --- Test 11: 比较运算返回值 --- def test_comparison_types(): - a: t.CInt = 10 - b: t.CInt = 20 - c_val: t.CInt = 10 - lt: t.CInt = 1 if a < b else 0 - eq: t.CInt = 1 if a == c_val else 0 - gt: t.CInt = 1 if b > a else 0 + a: int = 10 + b: int = 20 + c_val: int = 10 + lt: int = 1 if a < b else 0 + eq: int = 1 if a == c_val else 0 + gt: int = 1 if b > a else 0 testcheck.check(lt == 1 and eq == 1 and gt == 1, "comparison operations", "comparison operations failed") # --- Test 12: 指针与整数互转 --- def test_ptr_int_cast(): - buf: t.CUInt32T | t.CPtr = w32.win32memory.VirtualAlloc(None, 64, 0x3000, 0x04) + buf: uint32 | t.CPtr = w32.win32memory.VirtualAlloc(None, 64, 0x3000, 0x04) if not buf: testcheck.fail("VirtualAlloc returned NULL") return # 指针转整数 - addr: t.CUInt64T = t.CUInt64T(buf) + addr: uint64 = uint64(buf) stdio.printf(" ptr->int: addr=0x%lx\n", addr) # 整数转指针 - p2: t.CUInt32T | t.CPtr = (t.CUInt32T | t.CPtr)(addr) + p2: uint32 | t.CPtr = (uint32 | t.CPtr)(addr) p2[0] = 0x12345678 testcheck.check(buf[0] == 0x12345678, "ptr<->int roundtrip", "ptr<->int roundtrip failed") # --- Test 13: CUInt64T 乘法溢出行为 --- def test_u64_mul(): - a: t.CUInt64T = 1000 - b: t.CUInt64T = 1000 - c_val: t.CUInt64T = a * b + a: uint64 = 1000 + b: uint64 = 1000 + c_val: uint64 = a * b testcheck.check(c_val == 1000000, "u64 mul (1000*1000=1000000)", "u64 mul (expected 1000000)") # --- Test 14: bool 运算 (and/or) --- def test_bool_ops(): - a: t.CInt = 5 - b: t.CInt = 0 - c_val: t.CInt = 3 + a: int = 5 + b: int = 0 + c_val: int = 3 # Python `and`/`or` 是短路求值 - r1: t.CInt = a and c_val # 5 and 3 -> 在 C 中应该是 (5 && 3) = 1 - r2: t.CInt = b or c_val # 0 or 3 -> 在 C 中应该是 (0 || 3) = 1 + r1: int = a and c_val # 5 and 3 -> 在 C 中应该是 (5 && 3) = 1 + r2: int = b or c_val # 0 or 3 -> 在 C 中应该是 (0 || 3) = 1 stdio.printf(" bool: 5 and 3 = %d, 0 or 3 = %d (expect 1,1 in C)\n", r1, r2) testcheck.ok("bool ops (C semantics)") # --- Test 15: 条件表达式 (三元运算符) --- def test_ternary(): - a: t.CInt = 10 - b: t.CInt = 20 - max_val: t.CInt = a if a > b else b - min_val: t.CInt = a if a < b else b + a: int = 10 + b: int = 20 + max_val: int = a if a > b else b + min_val: int = a if a < b else b testcheck.check(max_val == 20 and min_val == 10, "ternary (max=20 min=10)", "ternary (expected 20,10)") -def main() -> t.CInt | t.CExport: +def main() -> int | t.CExport: w32.win32console.SetConsoleCP(65001) w32.win32console.SetConsoleOutputCP(65001) diff --git a/VRandomTest/App/main.vp b/VRandomTest/App/main.vp index d88b305..b745dab 100644 --- a/VRandomTest/App/main.vp +++ b/VRandomTest/App/main.vp @@ -9,13 +9,13 @@ import testcheck # VRandomTest - 硬件随机数生成 + 标准分布函数测试 # ============================================================ -def main() -> t.CInt: +def main() -> int: testcheck.begin("VRandomTest: Hardware RNG + Distributions") # --- Test 1: RDRAND basic --- testcheck.section("Test 1: RDRAND basic") - r32: t.CUInt32T = vrandom.rdrand32() - r64: t.CUInt64T = vrandom.rdrand64() + r32: uint32 = vrandom.rdrand32() + r64: uint64 = vrandom.rdrand64() stdio.printf(" rdrand32() = 0x%08x\n", r32) stdio.printf(" rdrand64() = 0x%016llx\n", r64) testcheck.ok("RDRAND basic") @@ -23,7 +23,7 @@ def main() -> t.CInt: # --- Test 2: randint --- testcheck.section("Test 2: randint(1, 100)") for _ in range(5): - v: t.CInt = vrandom.randint(1, 100) + v: int = vrandom.randint(1, 100) stdio.printf(" randint(1,100) = %d\n", v) testcheck.ok("randint range check") @@ -37,14 +37,14 @@ def main() -> t.CInt: # --- Test 4: getrandbits --- testcheck.section("Test 4: getrandbits(8)") for _ in range(3): - b: t.CUInt64T = vrandom.getrandbits(8) + b: uint64 = vrandom.getrandbits(8) stdio.printf(" getrandbits(8) = 0x%02llx\n", b) testcheck.ok("getrandbits width check") # --- Test 5: random() [0,1) --- testcheck.section("Test 5: random()") for _ in range(3): - f: t.CDouble = vrandom.random() + f: double = vrandom.random() stdio.printf(" random() = %f\n", f) testcheck.ok("random() in [0,1)") diff --git a/VariadicTest/App/main.vp b/VariadicTest/App/main.vp index b4c1da2..753729c 100644 --- a/VariadicTest/App/main.vp +++ b/VariadicTest/App/main.vp @@ -14,13 +14,13 @@ import w32.win32console def test_snprintf_u8(): """测试 CUInt8T 值通过 t.CUnsignedInt() 传递给 %u""" testcheck.section("Test 1: %u 格式化小整数 (CUInt8T -> CUnsignedInt)") - hr: t.CUInt8T = 14 - mn: t.CUInt8T = 30 - sc: t.CUInt8T = 59 - buf: t.CArray[t.CChar, 64] - string.memset(c.Addr(buf), 0, 64) - viperlib.snprintf(c.Addr(buf), 64, "%02u:%02u:%02u", t.CUnsignedInt(hr), t.CUnsignedInt(mn), t.CUnsignedInt(sc)) - stdio.printf("Test1 (CUInt8T->%%u): [%s] (expect 14:30:59)\n", c.Addr(buf)) + hr: uint8 = 14 + mn: uint8 = 30 + sc: uint8 = 59 + buf: t.CArray[char, 64] + string.memset(&buf, 0, 64) + viperlib.snprintf(&buf, 64, "%02u:%02u:%02u", uint(hr), uint(mn), uint(sc)) + stdio.printf("Test1 (CUInt8T->%%u): [%s] (expect 14:30:59)\n", &buf) testcheck.ok("CUInt8T -> %u (expect 14:30:59)") @@ -28,11 +28,11 @@ def test_snprintf_u8(): def test_snprintf_u16(): """测试 CUInt16T 值通过 t.CUnsignedInt() 传递给 %u""" testcheck.section("Test 2: %u 格式化 CUInt16T") - yr: t.CUInt16T = 2026 - buf: t.CArray[t.CChar, 64] - string.memset(c.Addr(buf), 0, 64) - viperlib.snprintf(c.Addr(buf), 64, "%04u", t.CUnsignedInt(yr)) - stdio.printf("Test2 (CUInt16T->%%u): [%s] (expect 2026)\n", c.Addr(buf)) + yr: uint16 = 2026 + buf: t.CArray[char, 64] + string.memset(&buf, 0, 64) + viperlib.snprintf(&buf, 64, "%04u", uint(yr)) + stdio.printf("Test2 (CUInt16T->%%u): [%s] (expect 2026)\n", &buf) testcheck.ok("CUInt16T -> %u (expect 2026)") @@ -40,11 +40,11 @@ def test_snprintf_u16(): def test_snprintf_u64(): """测试 CUInt64T 值传递给 %lu""" testcheck.section("Test 3: %lu 格式化 CUInt64T") - val: t.CUInt64T = 1234567890123 - buf: t.CArray[t.CChar, 64] - string.memset(c.Addr(buf), 0, 64) - viperlib.snprintf(c.Addr(buf), 64, "%lu", val) - stdio.printf("Test3 (CUInt64T->%%lu): [%s] (expect 1234567890123)\n", c.Addr(buf)) + val: uint64 = 1234567890123 + buf: t.CArray[char, 64] + string.memset(&buf, 0, 64) + viperlib.snprintf(&buf, 64, "%lu", val) + stdio.printf("Test3 (CUInt64T->%%lu): [%s] (expect 1234567890123)\n", &buf) testcheck.ok("CUInt64T -> %lu (expect 1234567890123)") @@ -52,33 +52,33 @@ def test_snprintf_u64(): def test_snprintf_d_neg(): """测试 %d 格式化负整数""" testcheck.section("Test 4: %d 格式化负数") - val: t.CInt = -42 - buf: t.CArray[t.CChar, 64] - string.memset(c.Addr(buf), 0, 64) - viperlib.snprintf(c.Addr(buf), 64, "%d", val) - stdio.printf("Test4 (CInt->%%d neg): [%s] (expect -42)\n", c.Addr(buf)) + val: int = -42 + buf: t.CArray[char, 64] + string.memset(&buf, 0, 64) + viperlib.snprintf(&buf, 64, "%d", val) + stdio.printf("Test4 (CInt->%%d neg): [%s] (expect -42)\n", &buf) testcheck.ok("CInt -> %d neg (expect -42)") # --- Test 5: %d 格式化正数 --- def test_snprintf_d_pos(): testcheck.section("Test 5: %d 格式化正数") - val: t.CInt = 42 - buf: t.CArray[t.CChar, 64] - string.memset(c.Addr(buf), 0, 64) - viperlib.snprintf(c.Addr(buf), 64, "%d", val) - stdio.printf("Test5 (CInt->%%d pos): [%s] (expect 42)\n", c.Addr(buf)) + val: int = 42 + buf: t.CArray[char, 64] + string.memset(&buf, 0, 64) + viperlib.snprintf(&buf, 64, "%d", val) + stdio.printf("Test5 (CInt->%%d pos): [%s] (expect 42)\n", &buf) testcheck.ok("CInt -> %d pos (expect 42)") # --- Test 6: %x 格式化十六进制 --- def test_snprintf_x(): testcheck.section("Test 6: %x 格式化十六进制") - val: t.CUInt32T = 0xDEADBEEF - buf: t.CArray[t.CChar, 64] - string.memset(c.Addr(buf), 0, 64) - viperlib.snprintf(c.Addr(buf), 64, "0x%08x", val) - stdio.printf("Test6 (%%x): [%s] (expect 0xdeadbeef)\n", c.Addr(buf)) + val: uint32 = 0xDEADBEEF + buf: t.CArray[char, 64] + string.memset(&buf, 0, 64) + viperlib.snprintf(&buf, 64, "0x%08x", val) + stdio.printf("Test6 (%%x): [%s] (expect 0xdeadbeef)\n", &buf) testcheck.ok("%x hex (expect 0xdeadbeef)") @@ -86,18 +86,18 @@ def test_snprintf_x(): def test_snprintf_mixed(): """模拟 desktop.py 的时间格式化""" testcheck.section("Test 7: 混合格式化 (模拟 desktop.py 时间格式)") - hr: t.CUInt8T = 14 - mn: t.CUInt8T = 5 - sc: t.CUInt8T = 9 - day: t.CUInt8T = 14 - mon: t.CUInt8T = 6 - yr: t.CUInt16T = 2026 - buf: t.CArray[t.CChar, 64] - string.memset(c.Addr(buf), 0, 64) - viperlib.snprintf(c.Addr(buf), 64, "%04u-%02u-%02u %02u:%02u:%02u", - t.CUnsignedInt(yr), t.CUnsignedInt(mon), t.CUnsignedInt(day), - t.CUnsignedInt(hr), t.CUnsignedInt(mn), t.CUnsignedInt(sc)) - stdio.printf("Test7 (time format): [%s] (expect 2026-06-14 14:05:09)\n", c.Addr(buf)) + hr: uint8 = 14 + mn: uint8 = 5 + sc: uint8 = 9 + day: uint8 = 14 + mon: uint8 = 6 + yr: uint16 = 2026 + buf: t.CArray[char, 64] + string.memset(&buf, 0, 64) + viperlib.snprintf(&buf, 64, "%04u-%02u-%02u %02u:%02u:%02u", + uint(yr), uint(mon), uint(day), + uint(hr), uint(mn), uint(sc)) + stdio.printf("Test7 (time format): [%s] (expect 2026-06-14 14:05:09)\n", &buf) testcheck.ok("time format (expect 2026-06-14 14:05:09)") @@ -106,7 +106,7 @@ def test_printf_variadic(): """测试 printf 直接输出 variadic 参数""" testcheck.section("Test 8: printf 直接输出 variadic") stdio.printf("Test8 (printf direct): %u %d %lu 0x%x (expect 100 -50 999999999 0xcafe)\n", - t.CUnsignedInt(100), -50, t.CUInt64T(999999999), 0xCAFE) + uint(100), -50, uint64(999999999), 0xCAFE) testcheck.ok("printf direct variadic (expect 100 -50 999999999 0xcafe)") @@ -114,35 +114,35 @@ def test_printf_variadic(): def test_snprintf_multi_lu(): """测试多个 %lu 连续（模拟 perf 日志格式）""" testcheck.section("Test 9: 多个 %lu 连续") - v1: t.CUInt64T = 16 - v2: t.CUInt64T = 2 - v3: t.CUInt64T = 11 - buf: t.CArray[t.CChar, 128] - string.memset(c.Addr(buf), 0, 128) - viperlib.snprintf(c.Addr(buf), 128, "wall=%lu work=%lu render=%lu", v1, v2, v3) - stdio.printf("Test9 (multi %%lu): [%s] (expect wall=16 work=2 render=11)\n", c.Addr(buf)) + v1: uint64 = 16 + v2: uint64 = 2 + v3: uint64 = 11 + buf: t.CArray[char, 128] + string.memset(&buf, 0, 128) + viperlib.snprintf(&buf, 128, "wall=%lu work=%lu render=%lu", v1, v2, v3) + stdio.printf("Test9 (multi %%lu): [%s] (expect wall=16 work=2 render=11)\n", &buf) testcheck.ok("multi %lu (expect wall=16 work=2 render=11)") # --- Test 10: %u 格式化 0 --- def test_snprintf_zero(): testcheck.section("Test 10: %u 格式化 0") - val: t.CUInt32T = 0 - buf: t.CArray[t.CChar, 64] - string.memset(c.Addr(buf), 0, 64) - viperlib.snprintf(c.Addr(buf), 64, "%u", val) - stdio.printf("Test10 (%%u zero): [%s] (expect 0)\n", c.Addr(buf)) + val: uint32 = 0 + buf: t.CArray[char, 64] + string.memset(&buf, 0, 64) + viperlib.snprintf(&buf, 64, "%u", val) + stdio.printf("Test10 (%%u zero): [%s] (expect 0)\n", &buf) testcheck.ok("%u zero (expect 0)") # --- Test 11: %u 格式化大值 --- def test_snprintf_large(): testcheck.section("Test 11: %u 格式化大值") - val: t.CUInt32T = 4294967295 # 0xFFFFFFFF - buf: t.CArray[t.CChar, 64] - string.memset(c.Addr(buf), 0, 64) - viperlib.snprintf(c.Addr(buf), 64, "%u", val) - stdio.printf("Test11 (%%u max): [%s] (expect 4294967295)\n", c.Addr(buf)) + val: uint32 = 4294967295 # 0xFFFFFFFF + buf: t.CArray[char, 64] + string.memset(&buf, 0, 64) + viperlib.snprintf(&buf, 64, "%u", val) + stdio.printf("Test11 (%%u max): [%s] (expect 4294967295)\n", &buf) testcheck.ok("%u max (expect 4294967295)") @@ -150,19 +150,19 @@ def test_snprintf_large(): def test_snprintf_u8_edge(): """测试 CUInt8T 边界值""" testcheck.section("Test 12: CUnsignedInt cast from CUInt8T edge values") - v0: t.CUInt8T = 0 - v127: t.CUInt8T = 127 - v128: t.CUInt8T = 128 - v255: t.CUInt8T = 255 - buf: t.CArray[t.CChar, 64] - string.memset(c.Addr(buf), 0, 64) - viperlib.snprintf(c.Addr(buf), 64, "%u %u %u %u", - t.CUnsignedInt(v0), t.CUnsignedInt(v127), t.CUnsignedInt(v128), t.CUnsignedInt(v255)) - stdio.printf("Test12 (CUInt8T edge): [%s] (expect 0 127 128 255)\n", c.Addr(buf)) + v0: uint8 = 0 + v127: uint8 = 127 + v128: uint8 = 128 + v255: uint8 = 255 + buf: t.CArray[char, 64] + string.memset(&buf, 0, 64) + viperlib.snprintf(&buf, 64, "%u %u %u %u", + uint(v0), uint(v127), uint(v128), uint(v255)) + stdio.printf("Test12 (CUInt8T edge): [%s] (expect 0 127 128 255)\n", &buf) testcheck.ok("CUInt8T edge (expect 0 127 128 255)") -def main() -> t.CInt | t.CExport: +def main() -> int | t.CExport: w32.win32console.SetConsoleCP(65001) w32.win32console.SetConsoleOutputCP(65001) diff --git a/VectorGenericTest/App/main.vp b/VectorGenericTest/App/main.vp index a056c77..62c2ff8 100644 --- a/VectorGenericTest/App/main.vp +++ b/VectorGenericTest/App/main.vp @@ -3,7 +3,7 @@ import testcheck import vectortest -def main() -> t.CInt | t.CExport: +def main() -> int | t.CExport: testcheck.begin("VectorGenericTest: Vector 泛型测试") testcheck.section("Vector 泛型") vectortest.vector_main() diff --git a/VectorGenericTest/App/vectortest.vp b/VectorGenericTest/App/vectortest.vp index 73ed21e..9a95634 100644 --- a/VectorGenericTest/App/vectortest.vp +++ b/VectorGenericTest/App/vectortest.vp @@ -5,7 +5,7 @@ import stdlib import vector import memhub -POOL_SIZE: t.CDefine = 4096 +define POOL_SIZE = 4096 def vector_main() -> CInt: buf: str = stdlib.malloc(256) diff --git a/ZlibDbg/App/main.vp b/ZlibDbg/App/main.vp index 5f73c98..90e73ae 100644 --- a/ZlibDbg/App/main.vp +++ b/ZlibDbg/App/main.vp @@ -10,8 +10,8 @@ import testcheck import t, c -def fill_data(data: BYTEPTR, size: t.CSizeT, seed: t.CSizeT, repeating: t.CInt): - i: t.CSizeT +def fill_data(data: BYTEPTR, size: sizet, seed: sizet, repeating: int): + i: sizet for i in range(size): if repeating: data[i] = BYTE(65 + (i % 3)) @@ -19,7 +19,7 @@ def fill_data(data: BYTEPTR, size: t.CSizeT, seed: t.CSizeT, repeating: t.CInt): data[i] = BYTE((i * 31 + seed * 17 + (i * i) % 251) % 256) -def huffman_probe(seed: t.CSizeT, size: t.CSizeT, repeating: t.CInt): +def huffman_probe(seed: sizet, size: sizet, repeating: int): """对 roundtrip 的同一份数据直接用 zhuff 复算字面量码表并打印分布。 背景：随机数据的 comp 远小于其字面量熵下限（250 字节数据熵下限约 221 字节， @@ -31,9 +31,9 @@ def huffman_probe(seed: t.CSizeT, size: t.CSizeT, repeating: t.CInt): """ data: BYTEPTR = BYTEPTR(stdlib.malloc(size)) fill_data(data, size, seed, repeating) - freqs: t.CArray[t.CInt, 288] + freqs: t.CArray[int, 288] string.memset(freqs, 0, freqs.__sizeof__()) - i: t.CSizeT + i: sizet for i in range(size): freqs[data[i]] += 1 freqs[256] = 1 @@ -41,13 +41,13 @@ def huffman_probe(seed: t.CSizeT, size: t.CSizeT, repeating: t.CInt): tree = zhuff.zhuff_tree() tree.build_codes(freqs, 257, 15) - hist: t.CArray[t.CInt, 16] + hist: t.CArray[int, 16] string.memset(hist, 0, hist.__sizeof__()) - active: t.CInt = 0 - no_code: t.CInt = 0 - sum15: t.CInt = 0 - k: t.CInt - bits: t.CInt + active: int = 0 + no_code: int = 0 + sum15: int = 0 + k: int + bits: int for k in range(257): bits = tree.codes[k].bits if freqs[k] > 0 and bits == 0: @@ -66,7 +66,7 @@ def huffman_probe(seed: t.CSizeT, size: t.CSizeT, repeating: t.CInt): stdlib.free(data) -def count_freqs_probe(seed: t.CSizeT, size: t.CSizeT, repeating: t.CInt): +def count_freqs_probe(seed: sizet, size: sizet, repeating: int): """调用真实的 zdeflate_count_freqs，与朴素直方图对照。 上面 huffman_probe 证明码表层正确，则 comp 远小于熵下限只能来自 @@ -80,8 +80,8 @@ def count_freqs_probe(seed: t.CSizeT, size: t.CSizeT, repeating: t.CInt): data: BYTEPTR = BYTEPTR(stdlib.malloc(size)) fill_data(data, size, seed, repeating) - lit: t.CArray[t.CInt, 288] - dist: t.CArray[t.CInt, 32] + lit: t.CArray[int, 288] + dist: t.CArray[int, 32] string.memset(lit, 0, lit.__sizeof__()) string.memset(dist, 0, dist.__sizeof__()) @@ -94,29 +94,29 @@ def count_freqs_probe(seed: t.CSizeT, size: t.CSizeT, repeating: t.CInt): # （-56 >= 128 恒假），既导致 count 阶段 lit_freqs[负数] 写到数组之前（漏计）， # 也让 encode_symbol(data[pos]) 收到负 symbol 被静默丢弃 ⇒ 码流截断。 up: UINT8PTR = UINT8PTR(data) - ge8_up: t.CInt = 0 - ge8_bp: t.CInt = 0 - i: t.CSizeT + ge8_up: int = 0 + ge8_bp: int = 0 + i: sizet for i in range(size): if up[i] >= 128: ge8_up += 1 if data[i] >= 128: ge8_bp += 1 testcheck.info(f"[countprobe] >=128 计数: UINT8PTR={ge8_up} BYTEPTR={ge8_bp} " f"(两者应相等且≈一半)") - sum_lit: t.CInt = 0 - active: t.CInt = 0 - k: t.CInt + sum_lit: int = 0 + active: int = 0 + k: int for k in range(288): sum_lit += lit[k] if k < 256 and lit[k] > 0: active += 1 - sum_dist: t.CInt = 0 + sum_dist: int = 0 for k in range(32): sum_dist += dist[k] - hlit: t.CInt = 286 + hlit: int = 286 while hlit > 257 and lit[hlit - 1] == 0: hlit -= 1 - hdist: t.CInt = 30 + hdist: int = 30 while hdist > 1 and dist[hdist - 1] == 0: hdist -= 1 @@ -127,23 +127,23 @@ def count_freqs_probe(seed: t.CSizeT, size: t.CSizeT, repeating: t.CInt): stdlib.free(data) -def roundtrip(seed: t.CSizeT, size: t.CSizeT, repeating: t.CInt, wbits: t.CInt) -> t.CInt: +def roundtrip(seed: sizet, size: sizet, repeating: int, wbits: int) -> int: data: BYTEPTR = BYTEPTR(stdlib.malloc(size)) fill_data(data, size, seed, repeating) - out_len: t.CSizeT = 0 + out_len: sizet = 0 comp: BYTEPTR = pyzlib.compress(None, data, size, - pyzlib.Z_DEFAULT_COMPRESSION, wbits, c.Addr(out_len)) + pyzlib.Z_DEFAULT_COMPRESSION, wbits, &out_len) if not comp: testcheck.fail(f"seed={seed} size={size} rep={repeating} wbits={wbits}: " f"compress 失败 err={pyzlib.get_error_code()} {pyzlib.get_error()}") stdlib.free(data) return -1 - dec_len: t.CSizeT = 0 + dec_len: sizet = 0 dec: BYTEPTR = pyzlib.decompress(None, comp, out_len, wbits, - pyzlib.DEF_BUF_SIZE, c.Addr(dec_len)) - ok: t.CInt = 1 + pyzlib.DEF_BUF_SIZE, &dec_len) + ok: int = 1 if not dec: ok = 0 testcheck.fail(f"seed={seed} size={size} rep={repeating} wbits={wbits}: " @@ -162,7 +162,7 @@ def roundtrip(seed: t.CSizeT, size: t.CSizeT, repeating: t.CInt, wbits: t.CInt) return 0 if ok else -1 -def main() -> t.CInt: +def main() -> int: testcheck.begin("ZlibDbg: zlib 多 seed/size/wbits 往返") # 先跑码表探针：定位 comp 远小于熵下限的根因（码表异常 / 还是别处） @@ -178,19 +178,19 @@ def main() -> t.CInt: count_freqs_probe(0, 256, 1) testcheck.section("随机数据 (wbits=15)") - sizes: t.CArray[t.CSizeT, None] = [250, 255, 256, 257, 260, 300, 500, 1000, 4096, 20000] - n: t.CInt + sizes: t.CArray[sizet, None] = [250, 255, 256, 257, 260, 300, 500, 1000, 4096, 20000] + n: int for n in range(10): - roundtrip(t.CSizeT(n), sizes[n], 0, pyzlib.MAX_WBITS) + roundtrip(sizet(n), sizes[n], 0, pyzlib.MAX_WBITS) testcheck.section("重复数据 (wbits=15)") - sizes2: t.CArray[t.CSizeT, None] = [256, 257, 300, 1000, 20000] + sizes2: t.CArray[sizet, None] = [256, 257, 300, 1000, 20000] for n in range(5): - roundtrip(t.CSizeT(n), sizes2[n], 1, pyzlib.MAX_WBITS) + roundtrip(sizet(n), sizes2[n], 1, pyzlib.MAX_WBITS) testcheck.section("gzip 容器 (wbits=31)") - sizes3: t.CArray[t.CSizeT, None] = [300, 1000] + sizes3: t.CArray[sizet, None] = [300, 1000] for n in range(2): - roundtrip(t.CSizeT(n), sizes3[n], 0, pyzlib.MAX_WBITS + 16) + roundtrip(sizet(n), sizes3[n], 0, pyzlib.MAX_WBITS + 16) return testcheck.end() diff --git a/ZlibTest/App/main.vp b/ZlibTest/App/main.vp index dae15c7..36708cb 100644 --- a/ZlibTest/App/main.vp +++ b/ZlibTest/App/main.vp @@ -7,7 +7,7 @@ import w32.win32memory import c import testcheck -def main() -> t.CInt: +def main() -> int: testcheck.begin("ZlibTest: Zlib 压缩库测试") tpz.main123456() testcheck.ok("zlib test_pyzlib completed") diff --git a/ZlibTest/App/test_pyzlib.vp b/ZlibTest/App/test_pyzlib.vp index ea2ab0c..6c9370c 100644 --- a/ZlibTest/App/test_pyzlib.vp +++ b/ZlibTest/App/test_pyzlib.vp @@ -9,9 +9,9 @@ import string import t, c -test_passed: t.CInt = 0 -test_failed: t.CInt = 0 -def check(name: str, condition: t.CInt, detail: str): +test_passed: int = 0 +test_failed: int = 0 +def check(name: str, condition: int, detail: str): global test_passed, test_failed if condition: test_passed += 1 @@ -20,12 +20,12 @@ def check(name: str, condition: t.CInt, detail: str): test_failed += 1 printf(" [FAIL] %s -- %s\n", name, detail if detail else "") -def print_hex_test(data: BYTEPTR, length: t.CSizeT, max_show: t.CSizeT): +def print_hex_test(data: BYTEPTR, length: sizet, max_show: sizet): if not data or length == 0: printf("(empty)\n") return - show: t.CSizeT = max_show if (length > max_show) else length - i: t.CSizeT + show: sizet = max_show if (length > max_show) else length + i: sizet for i in range(show): printf("%02X ", data[i]) if length > max_show: @@ -63,28 +63,28 @@ def test_compress_decompress(): section_header("compress / decompress") inp: str = "Hello, World! This is a test of zlib compression and decompression." - input_length: t.CSizeT = strlen(inp) + input_length: sizet = strlen(inp) printf(" Input (%zu bytes): \"%s\"\n", input_length, inp) - out_length: t.CSizeT = 0 + out_length: sizet = 0 compressed: BYTEPTR = pyzlib.compress(None, BYTEPTR(inp), input_length, - pyzlib.Z_DEFAULT_COMPRESSION, pyzlib.MAX_WBITS, c.Addr(out_length)) + pyzlib.Z_DEFAULT_COMPRESSION, pyzlib.MAX_WBITS, &out_length) check("compress returns non-None", compressed != None, "compress returned None") check("compress output size > 0", out_length > 0, "compressed size is 0") check("compress output produced", out_length > 0, "compressed size is 0") printf(" Compressed (%zu bytes): ", out_length) print_hex_test(compressed, out_length, 32) - printf(" Compression ratio: %.1f%%\n", t.CDouble(out_length) / input_length * 100) + printf(" Compression ratio: %.1f%%\n", double(out_length) / input_length * 100) - dec_length: t.CSizeT = 0 + dec_length: sizet = 0 decompressed: BYTEPTR = pyzlib.decompress(None, compressed, out_length, - pyzlib.MAX_WBITS, pyzlib.DEF_BUF_SIZE, c.Addr(dec_length)) + pyzlib.MAX_WBITS, pyzlib.DEF_BUF_SIZE, &dec_length) check("decompress returns non-None", decompressed != None, "decompress returned None") check("decompress output size matches input", dec_length == input_length, "size mismatch") check("decompress output matches input", decompressed != None and string.memcmp(decompressed, inp, input_length) == 0, "content mismatch") - printf(" Decompressed (%zu bytes): \"%.*s\"\n", dec_length, t.CInt(dec_length), str(decompressed)) + printf(" Decompressed (%zu bytes): \"%.*s\"\n", dec_length, int(dec_length), str(decompressed)) stdlib.free(compressed) stdlib.free(decompressed) @@ -95,35 +95,35 @@ def test_compress_levels(): section_header("Compression Levels") inp: str = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - input_length: t.CSizeT = strlen(inp) + input_length: sizet = strlen(inp) printf(" Input (%zu bytes): \"%s\"\n", input_length, inp) - out_length: t.CSizeT = 0 + out_length: sizet = 0 c0: BYTEPTR = pyzlib.compress(None, BYTEPTR(inp), input_length, - pyzlib.Z_NO_COMPRESSION, pyzlib.MAX_WBITS, c.Addr(out_length)) + pyzlib.Z_NO_COMPRESSION, pyzlib.MAX_WBITS, &out_length) check("level 0 compress OK", c0 != None, "level 0 returned None") printf(" Level 0 (Z_NO_COMPRESSION): %zu bytes\n", out_length) - length0: t.CSizeT = out_length + length0: sizet = out_length stdlib.free(c0) c1: BYTEPTR = pyzlib.compress(None, BYTEPTR(inp), input_length, - pyzlib.Z_BEST_SPEED, pyzlib.MAX_WBITS, c.Addr(out_length)) + pyzlib.Z_BEST_SPEED, pyzlib.MAX_WBITS, &out_length) check("level 1 compress OK", c1 != None, "level 1 returned None") printf(" Level 1 (Z_BEST_SPEED) : %zu bytes\n", out_length) stdlib.free(c1) c6: BYTEPTR = pyzlib.compress(None, BYTEPTR(inp), input_length, - pyzlib.Z_DEFAULT_COMPRESSION, pyzlib.MAX_WBITS, c.Addr(out_length)) + pyzlib.Z_DEFAULT_COMPRESSION, pyzlib.MAX_WBITS, &out_length) check("level -1 compress OK", c6 != None, "default level returned None") printf(" Level -1 (DEFAULT) : %zu bytes\n", out_length) stdlib.free(c6) c9: BYTEPTR = pyzlib.compress(None, BYTEPTR(inp), input_length, - pyzlib.Z_BEST_COMPRESSION, pyzlib.MAX_WBITS, c.Addr(out_length)) + pyzlib.Z_BEST_COMPRESSION, pyzlib.MAX_WBITS, &out_length) check("level 9 compress OK", c9 != None, "level 9 returned None") printf(" Level 9 (Z_BEST_COMPRESS) : %zu bytes\n", out_length) - length9: t.CSizeT = out_length + length9: sizet = out_length stdlib.free(c9) check("level 9 smaller than level 0", length9 < length0, "level 9 not smaller than level 0") @@ -139,7 +139,7 @@ def test_compressobj(): printf(" Part 1: \"%s\"\n", part1) printf(" Part 2: \"%s\"\n", part2) - out_length: t.CSizeT = 0 + out_length: sizet = 0 s: pyzlib.Compress | t.CPtr = pyzlib.compressobj(None, pyzlib.Z_DEFAULT_COMPRESSION, pyzlib.DEFLATED, pyzlib.MAX_WBITS, pyzlib.DEF_MEM_LEVEL, @@ -147,11 +147,11 @@ def test_compressobj(): check("compressobj created", s != None, "compressobj is None") print_separator() - c1: BYTEPTR = s.compress(BYTEPTR(part1), strlen(part1), c.Addr(out_length)) + c1: BYTEPTR = s.compress(BYTEPTR(part1), strlen(part1), &out_length) check("compress part1 OK", c1 != None, "compress part1 failed") printf(" Compressed part1: %zu bytes -> ", out_length) print_hex_test(c1, out_length, 16) - total: t.CSizeT = out_length + total: sizet = out_length all: BYTEPTR = None if out_length > 0 and c1: all = BYTEPTR(stdlib.malloc(total)) @@ -159,7 +159,7 @@ def test_compressobj(): stdlib.free(c1) c2: BYTEPTR = s.compress(BYTEPTR(part2), - strlen(part2), c.Addr(out_length)) + strlen(part2), &out_length) check("compress part2 OK", c2 != None, "compress part2 failed") printf(" Compressed part2: %zu bytes -> ", out_length) print_hex_test(c2, out_length, 16) @@ -171,7 +171,7 @@ def test_compressobj(): total += out_length stdlib.free(c2) - c3: BYTEPTR = s.flush(pyzlib.Z_FINISH, c.Addr(out_length)) + c3: BYTEPTR = s.flush(pyzlib.Z_FINISH, &out_length) check("flush (Z_FINISH) OK", c3 != None, "flush failed") printf(" Flush result : %zu bytes -> ", out_length) print_hex_test(c3, out_length, 16) @@ -186,14 +186,14 @@ def test_compressobj(): print_separator() if all: - dec_length: t.CSizeT = 0 - dec: BYTEPTR = pyzlib.decompress(None, all, total, pyzlib.MAX_WBITS, pyzlib.DEF_BUF_SIZE, c.Addr(dec_length)) + dec_length: sizet = 0 + dec: BYTEPTR = pyzlib.decompress(None, all, total, pyzlib.MAX_WBITS, pyzlib.DEF_BUF_SIZE, &dec_length) check("decompress incremental OK", dec != None, "decompress returned None") check("decompress incremental size", dec != None and dec_length == strlen(part1) + strlen(part2), "size mismatch") check("decompress incremental content", dec != None and string.memcmp(dec, "Hello, World!", dec_length) == 0, "content mismatch") if dec: - printf(" Decompressed: \"%.*s\" (%zu bytes)\n", t.CInt(dec_length), str(dec), dec_length) + printf(" Decompressed: \"%.*s\" (%zu bytes)\n", int(dec_length), str(dec), dec_length) stdlib.free(dec) stdlib.free(all) @@ -204,12 +204,12 @@ def test_decompressobj(): section_header("decompressobj") inp: str = "Test data for decompress object." - input_length: t.CSizeT = strlen(inp) + input_length: sizet = strlen(inp) printf(" Input (%zu bytes): \"%s\"\n", input_length, inp) - out_length: t.CSizeT = 0 + out_length: sizet = 0 compressed: BYTEPTR = pyzlib.compress(None, BYTEPTR(inp), input_length, - pyzlib.Z_DEFAULT_COMPRESSION, pyzlib.MAX_WBITS, c.Addr(out_length)) + pyzlib.Z_DEFAULT_COMPRESSION, pyzlib.MAX_WBITS, &out_length) printf(" Compressed: %zu bytes\n", out_length) d: pyzlib.Decompress | t.CPtr = pyzlib.decompressobj(None, pyzlib.MAX_WBITS, None, 0) @@ -217,16 +217,16 @@ def test_decompressobj(): check("eof is false initially", d.eof == 0, "eof should be 0") print_separator() - dec_length: t.CSizeT = 0 + dec_length: sizet = 0 dec: BYTEPTR = d.decompress(compressed, out_length, - 0, c.Addr(dec_length)) + 0, &dec_length) check("decompress OK", dec != None, "decompress returned None") check("decompress size", dec != None and dec_length == input_length, "size mismatch") check("decompress content", dec != None and string.memcmp(dec, inp, input_length) == 0, "content mismatch") check("eof is true after stream end", d.eof == 1, "eof should be 1") if dec: - printf(" Decompressed (%zu bytes): \"%.*s\"\n", dec_length, t.CInt(dec_length), str(dec)) + printf(" Decompressed (%zu bytes): \"%.*s\"\n", dec_length, int(dec_length), str(dec)) printf(" eof = %d\n", d.eof) stdlib.free(dec) @@ -238,35 +238,35 @@ def test_decompressobj_max_length(): section_header("decompressobj max_length") inp: str = "This is a longer string for testing max_length parameter in decompress." - input_length: t.CSizeT = strlen(inp) + input_length: sizet = strlen(inp) printf(" Input (%zu bytes): \"%s\"\n", input_length, inp) - out_length: t.CSizeT = 0 + out_length: sizet = 0 compressed: BYTEPTR = pyzlib.compress(None, BYTEPTR(inp), input_length, - pyzlib.Z_DEFAULT_COMPRESSION, pyzlib.MAX_WBITS, c.Addr(out_length)) + pyzlib.Z_DEFAULT_COMPRESSION, pyzlib.MAX_WBITS, &out_length) printf(" Compressed: %zu bytes\n", out_length) d: pyzlib.Decompress | t.CPtr = pyzlib.decompressobj(None, pyzlib.MAX_WBITS, None, 0) - dec_length: t.CSizeT = 0 + dec_length: sizet = 0 dec: BYTEPTR = d.decompress(compressed, out_length, - 10, c.Addr(dec_length)) + 10, &dec_length) check("max_length decompress OK", dec != None, "decompress returned None") check("max_length limits output", dec_length <= 10, "output exceeded max_length") if dec: - printf(" First chunk (max_length=10): \"%.*s\" (%zu bytes)\n", t.CInt(dec_length), str(dec), dec_length) + printf(" First chunk (max_length=10): \"%.*s\" (%zu bytes)\n", int(dec_length), str(dec), dec_length) stdlib.free(dec) - tail_length: t.CSizeT = 0 - tail: BYTEPTR = d.unconsumed_tail(c.Addr(tail_length)) + tail_length: sizet = 0 + tail: BYTEPTR = d.unconsumed_tail(&tail_length) check("unconsumed_tail exists", tail != None or tail_length == 0, "no unconsumed_tail") printf(" unconsumed_tail: %zu bytes remaining\n", tail_length) printf(" eof = %d\n", d.eof) if tail_length > 0 or not d.eof: - flushed: BYTEPTR = d.flush(pyzlib.DEF_BUF_SIZE, c.Addr(dec_length)) + flushed: BYTEPTR = d.flush(pyzlib.DEF_BUF_SIZE, &dec_length) check("flush after max_length OK", flushed != None, "flush returned None") - if flushed: printf(" Flushed (%zu bytes): \"%.*s\"\n", dec_length, t.CInt(dec_length), str(flushed)) + if flushed: printf(" Flushed (%zu bytes): \"%.*s\"\n", dec_length, int(dec_length), str(flushed)) stdlib.free(flushed) printf(" eof after flush = %d\n", d.eof) @@ -280,15 +280,15 @@ def test_decompressobj_unused_data(): section_header("decompressobj unused_data") inp: str = "Hello" - input_length: t.CSizeT = strlen(inp) + input_length: sizet = strlen(inp) printf(" Input: \"%s\"\n", inp) - out_length: t.CSizeT = 0 + out_length: sizet = 0 compressed: BYTEPTR = pyzlib.compress(None, BYTEPTR(inp), input_length, - pyzlib.Z_DEFAULT_COMPRESSION, pyzlib.MAX_WBITS, c.Addr(out_length)) + pyzlib.Z_DEFAULT_COMPRESSION, pyzlib.MAX_WBITS, &out_length) printf(" Compressed: %zu bytes\n", out_length) - total_length: t.CSizeT = out_length + 5 + total_length: sizet = out_length + 5 combined: BYTEPTR = BYTEPTR(stdlib.malloc(total_length)) string.memcpy(combined, compressed, out_length) string.memcpy(combined + out_length, "EXTRA", 5) @@ -297,22 +297,22 @@ def test_decompressobj_unused_data(): d: pyzlib.Decompress | t.CPtr = pyzlib.decompressobj(None, pyzlib.MAX_WBITS, None, 0) - dec_length: t.CSizeT = 0 + dec_length: sizet = 0 dec: BYTEPTR = d.decompress(combined, total_length, - 0, c.Addr(dec_length)) + 0, &dec_length) check("decompress with extra OK", dec != None, "decompress returned None") check("eof after stream end", d.eof == 1, "eof should be 1") if dec: - printf(" Decompressed: \"%.*s\" (%zu bytes)\n", t.CInt(dec_length), str(dec), dec_length) + printf(" Decompressed: \"%.*s\" (%zu bytes)\n", int(dec_length), str(dec), dec_length) stdlib.free(dec) print_separator() - unused_length: t.CSizeT = 0 - unused: BYTEPTR = d.unused_data(c.Addr(unused_length)) + unused_length: sizet = 0 + unused: BYTEPTR = d.unused_data(&unused_length) check("unused_data exists", unused != None and unused_length > 0, "no unused_data") check("unused_data is EXTRA", unused_length == 5 and unused != None and string.memcmp(unused, "EXTRA", 5) == 0, "unused_data mismatch") - printf(" unused_data (%zu bytes): \"%.*s\"\n", unused_length, t.CInt(unused_length), str(unused)) + printf(" unused_data (%zu bytes): \"%.*s\"\n", unused_length, int(unused_length), str(unused)) d.delete() stdlib.free(combined) @@ -323,14 +323,14 @@ def test_compress_copy(): section_header("Compress.copy()") inp: str = "Copy test data for compress object" - input_length: t.CSizeT = strlen(inp) + input_length: sizet = strlen(inp) printf(" Input: \"%s\"\n", inp) - out_length: t.CSizeT = 0 + out_length: sizet = 0 c1: pyzlib.Compress | t.CPtr = pyzlib.compressobj(None, pyzlib.Z_DEFAULT_COMPRESSION, pyzlib.DEFLATED, pyzlib.MAX_WBITS, pyzlib.DEF_MEM_LEVEL, pyzlib.Z_DEFAULT_STRATEGY, None, 0) - c1.compress(BYTEPTR(inp), input_length, c.Addr(out_length)) + c1.compress(BYTEPTR(inp), input_length, &out_length) printf(" Original: compressed %zu bytes so far\n", out_length) c2: pyzlib.Compress | t.CPtr = c1.copy() @@ -339,15 +339,15 @@ def test_compress_copy(): print_separator() - f1: BYTEPTR = c1.flush(pyzlib.Z_FINISH, c.Addr(out_length)) + f1: BYTEPTR = c1.flush(pyzlib.Z_FINISH, &out_length) check("flush original OK", f1 != None, "flush original failed") - length1: t.CSizeT = out_length + length1: sizet = out_length printf(" Original flush: %zu bytes\n", length1) stdlib.free(f1) - f2: BYTEPTR = c2.flush(pyzlib.Z_FINISH, c.Addr(out_length)) + f2: BYTEPTR = c2.flush(pyzlib.Z_FINISH, &out_length) check("flush copy OK", f2 != None, "flush copy failed") - length2: t.CSizeT = out_length + length2: sizet = out_length printf(" Copy flush : %zu bytes\n", length2) stdlib.free(f2) @@ -362,12 +362,12 @@ def test_decompress_copy(): section_header("Decompress.copy()") inp: str = "Decompress copy test" - input_length: t.CSizeT = strlen(inp) + input_length: sizet = strlen(inp) printf(" Input: \"%s\"\n", inp) - out_length: t.CSizeT = 0 + out_length: sizet = 0 compressed: BYTEPTR = pyzlib.compress(None, BYTEPTR(inp), input_length, - pyzlib.Z_DEFAULT_COMPRESSION, pyzlib.MAX_WBITS, c.Addr(out_length)) + pyzlib.Z_DEFAULT_COMPRESSION, pyzlib.MAX_WBITS, &out_length) printf(" Compressed: %zu bytes\n", out_length) d1: pyzlib.Decompress | t.CPtr = pyzlib.decompressobj(None, pyzlib.MAX_WBITS, None, 0) @@ -377,18 +377,18 @@ def test_decompress_copy(): print_separator() - dec_length1: t.CSizeT = 0 - dec_length2: t.CSizeT = 0 + dec_length1: sizet = 0 + dec_length2: sizet = 0 dec1: BYTEPTR = d1.decompress(compressed, out_length, - 0, c.Addr(dec_length1)) + 0, &dec_length1) dec2: BYTEPTR = d2.decompress(compressed, out_length, - 0, c.Addr(dec_length2)) + 0, &dec_length2) check("decompress copy output size", dec_length1 == dec_length2, "sizes differ") check("decompress copy output content", dec1 and dec2 and string.memcmp(dec1, dec2, dec_length1) == 0, "content differs") - if dec1: printf(" Original: \"%.*s\" (%zu bytes)\n", t.CInt(dec_length1), str(dec1), dec_length1) - if dec2: printf(" Copy : \"%.*s\" (%zu bytes)\n", t.CInt(dec_length2), str(dec2), dec_length2) + if dec1: printf(" Original: \"%.*s\" (%zu bytes)\n", int(dec_length1), str(dec1), dec_length1) + if dec2: printf(" Copy : \"%.*s\" (%zu bytes)\n", int(dec_length2), str(dec2), dec_length2) stdlib.free(dec1) stdlib.free(dec2) @@ -435,18 +435,18 @@ def test_crc32(): def test_empty_compress(): section_header("Empty data compress/decompress") - out_length: t.CSizeT = 0 + out_length: sizet = 0 compressed: BYTEPTR = pyzlib.compress(None, BYTEPTR(""), 0, - pyzlib.Z_DEFAULT_COMPRESSION, pyzlib.MAX_WBITS, c.Addr(out_length)) + pyzlib.Z_DEFAULT_COMPRESSION, pyzlib.MAX_WBITS, &out_length) check("compress empty OK", compressed != None, "compress empty returned None") check("compress empty output > 0", out_length > 0, "compressed empty is 0 bytes") printf(" Empty input compressed: %zu bytes (header only)\n", out_length) printf(" Hex: ") print_hex_test(compressed, out_length, 32) - dec_length: t.CSizeT = 0 + dec_length: sizet = 0 decompressed: BYTEPTR = pyzlib.decompress(None, compressed, out_length, - pyzlib.MAX_WBITS, pyzlib.DEF_BUF_SIZE, c.Addr(dec_length)) + pyzlib.MAX_WBITS, pyzlib.DEF_BUF_SIZE, &dec_length) check("decompress empty OK", decompressed != None, "decompress empty returned None") check("decompress empty size == 0", dec_length == 0, "decompressed size != 0") printf(" Decompressed back: %zu bytes\n", dec_length) @@ -460,27 +460,27 @@ def test_gzip_format(): section_header("Gzip format (wbits=31)") inp: str = "Gzip format test" - input_length: t.CSizeT = strlen(inp) + input_length: sizet = strlen(inp) printf(" Input: \"%s\" (%zu bytes)\n", inp, input_length) - gzip_wbits: t.CInt = pyzlib.MAX_WBITS + 16 + gzip_wbits: int = pyzlib.MAX_WBITS + 16 printf(" wbits = MAX_WBITS + 16 = %d\n", gzip_wbits) - out_length: t.CSizeT = 0 + out_length: sizet = 0 compressed: BYTEPTR = pyzlib.compress(None, BYTEPTR(inp), input_length, - pyzlib.Z_DEFAULT_COMPRESSION, gzip_wbits, c.Addr(out_length)) + pyzlib.Z_DEFAULT_COMPRESSION, gzip_wbits, &out_length) check("gzip compress OK", compressed != None, "gzip compress failed") printf(" Gzip compressed: %zu bytes\n", out_length) printf(" Header bytes: ") print_hex_test(compressed, 4 if (out_length > 4) else out_length, 4) - dec_length: t.CSizeT = 0 + dec_length: sizet = 0 decompressed: BYTEPTR = pyzlib.decompress(None, compressed, out_length, - gzip_wbits, pyzlib.DEF_BUF_SIZE, c.Addr(dec_length)) + gzip_wbits, pyzlib.DEF_BUF_SIZE, &dec_length) check("gzip decompress OK", decompressed != None, "gzip decompress failed") check("gzip decompress size", dec_length == input_length, "size mismatch") check("gzip decompress content", decompressed != None and string.memcmp(decompressed, inp, input_length) == 0, "content mismatch") - if decompressed: printf(" Decompressed: \"%.*s\" (%zu bytes)\n", t.CInt(dec_length), str(decompressed), dec_length) + if decompressed: printf(" Decompressed: \"%.*s\" (%zu bytes)\n", int(dec_length), str(decompressed), dec_length) stdlib.free(compressed) stdlib.free(decompressed) @@ -491,25 +491,25 @@ def test_raw_deflate(): section_header("Raw deflate (wbits=-15)") inp: str = "Raw deflate test" - input_length: t.CSizeT = strlen(inp) + input_length: sizet = strlen(inp) printf(" Input: \"%s\" (%zu bytes)\n", inp, input_length) - raw_wbits: t.CInt = -pyzlib.MAX_WBITS + raw_wbits: int = -pyzlib.MAX_WBITS printf(" wbits = -MAX_WBITS = %d\n", raw_wbits) - out_length: t.CSizeT = 0 + out_length: sizet = 0 compressed: BYTEPTR = pyzlib.compress(None, BYTEPTR(inp), input_length, - pyzlib.Z_DEFAULT_COMPRESSION, raw_wbits, c.Addr(out_length)) + pyzlib.Z_DEFAULT_COMPRESSION, raw_wbits, &out_length) check("raw deflate compress OK", compressed != None, "raw deflate compress failed") printf(" Raw compressed: %zu bytes\n", out_length) - dec_length: t.CSizeT = 0 + dec_length: sizet = 0 decompressed: BYTEPTR = pyzlib.decompress(None, compressed, out_length, - raw_wbits, pyzlib.DEF_BUF_SIZE, c.Addr(dec_length)) + raw_wbits, pyzlib.DEF_BUF_SIZE, &dec_length) check("raw deflate decompress OK", decompressed != None, "raw deflate decompress failed") check("raw deflate decompress size", dec_length == input_length, "size mismatch") check("raw deflate decompress content", decompressed != None and string.memcmp(decompressed, inp, input_length) == 0, "content mismatch") - if decompressed: printf(" Decompressed: \"%.*s\" (%zu bytes)\n", t.CInt(dec_length), str(decompressed), dec_length) + if decompressed: printf(" Decompressed: \"%.*s\" (%zu bytes)\n", int(dec_length), str(decompressed), dec_length) stdlib.free(compressed) stdlib.free(decompressed) @@ -521,11 +521,11 @@ def test_zdict(): dict: str = "common words that appear frequently in the data" inp: str = "common words that appear frequently" - input_length: t.CSizeT = strlen(inp) + input_length: sizet = strlen(inp) printf(" Dictionary: \"%s\" (%zu bytes)\n", dict, strlen(dict)) printf(" Input : \"%s\" (%zu bytes)\n", inp, input_length) - out_length: t.CSizeT = 0 + out_length: sizet = 0 s: pyzlib.Compress | t.CPtr = pyzlib.compressobj(None, pyzlib.Z_DEFAULT_COMPRESSION, pyzlib.DEFLATED, pyzlib.MAX_WBITS, pyzlib.DEF_MEM_LEVEL, pyzlib.Z_DEFAULT_STRATEGY, @@ -533,28 +533,28 @@ def test_zdict(): check("compressobj with zdict OK", s != None, "compressobj with zdict failed") comp_data: BYTEPTR = s.compress(BYTEPTR(inp), - input_length, c.Addr(out_length)) + input_length, &out_length) check("compress with zdict OK", comp_data != None, "compress with zdict failed") printf(" Compressed with zdict: %zu bytes\n", out_length) stdlib.free(comp_data) - flush_data: BYTEPTR = s.flush(pyzlib.Z_FINISH, c.Addr(out_length)) + flush_data: BYTEPTR = s.flush(pyzlib.Z_FINISH, &out_length) check("flush with zdict OK", flush_data != None, "flush with zdict failed") printf(" Flush: %zu bytes\n", out_length) stdlib.free(flush_data) print_separator() - total_comp: t.CSizeT = out_length + total_comp: sizet = out_length s.delete() s = pyzlib.compressobj(None, pyzlib.Z_DEFAULT_COMPRESSION, pyzlib.DEFLATED, pyzlib.MAX_WBITS, pyzlib.DEF_MEM_LEVEL, pyzlib.Z_DEFAULT_STRATEGY, None, 0) comp_no_dict: BYTEPTR = s.compress(BYTEPTR(inp), - input_length, c.Addr(out_length)) - flush_no_dict: BYTEPTR = s.flush(pyzlib.Z_FINISH, c.Addr(out_length)) - no_dict_total: t.CSizeT = 0 + input_length, &out_length) + flush_no_dict: BYTEPTR = s.flush(pyzlib.Z_FINISH, &out_length) + no_dict_total: sizet = 0 if comp_no_dict: no_dict_total += out_length if flush_no_dict: no_dict_total += out_length printf(" Without zdict: ~%zu bytes compressed\n", no_dict_total) @@ -576,9 +576,9 @@ def test_huffman_tree(): check("fixed lit tree count == 288", lit_tree.count == 288, "count mismatch") check("fixed lit tree max_bits == 9", lit_tree.max_bits == 9, "max_bits mismatch") - has_8bit: t.CInt = 0 - has_9bit: t.CInt = 0 - has_7bit: t.CInt = 0 + has_8bit: int = 0 + has_9bit: int = 0 + has_7bit: int = 0 for i in range(143 + 1): if lit_tree.codes[i].bits == 8: has_8bit += 1 @@ -605,7 +605,7 @@ def test_huffman_tree(): check("fixed dist tree count == 32", dist_tree.count == 32, "count mismatch") check("fixed dist tree max_bits == 5", dist_tree.max_bits == 5, "max_bits mismatch") - all_5bit: t.CInt = 1 + all_5bit: int = 1 for i in range(32): if dist_tree.codes[i].bits != 5: all_5bit = 0 @@ -613,7 +613,7 @@ def test_huffman_tree(): printf(" All 32 distance codes: 5 bits each\n") printf("\n --- Dynamic Huffman tree from frequencies ---\n") - dyn_freqs: t.CArray[t.CInt, 256] + dyn_freqs: t.CArray[int, 256] string.memset(dyn_freqs, 0, dyn_freqs.__sizeof__()) dyn_freqs['A'] = 50 dyn_freqs['B'] = 25 @@ -629,8 +629,8 @@ def test_huffman_tree(): check("dynamic tree count == 257", dyn_tree.count == 257, "count mismatch") check("dynamic tree max_bits <= 15", dyn_tree.max_bits <= 15, "max_bits overflow") - total_codes: t.CInt = 0 - max_length_found: t.CInt = 0 + total_codes: int = 0 + max_length_found: int = 0 for i in range(257): if dyn_tree.codes[i].bits > 0: total_codes += 1 @@ -644,7 +644,7 @@ def test_huffman_tree(): printf(" Code assignments:\n") names: t.CArray[str, None] = ["A","B","C","D","E","F"] # 一个都æ˜?char* 的数ç»? - syms: t.CArray[t.CInt, None] = ['A','B','C','D','E','F'] + syms: t.CArray[int, None] = ['A','B','C','D','E','F'] for i in range(6): printf(" '%s' (freq=%3d): code=0x%04X, bits=%d\n", names[i], dyn_freqs[syms[i]], @@ -655,15 +655,15 @@ def test_huffman_tree(): printf(" EOB (freq=1): code=0x%04X, bits=%d\n", dyn_tree.codes[256].code, dyn_tree.codes[256].bits) - a_bits: t.CInt = dyn_tree.codes['A'].bits - f_bits: t.CInt = dyn_tree.codes['F'].bits + a_bits: int = dyn_tree.codes['A'].bits + f_bits: int = dyn_tree.codes['F'].bits check("high-freq symbol has shorter code", a_bits <= f_bits, "A should be <= F") printf(" High-freq 'A' (%d bits) <= low-freq 'F' (%d bits): %s\n", a_bits, f_bits, "YES" if (a_bits <= f_bits) else "NO") printf("\n --- Huffman encode/decode roundtrip ---\n") - rt_freqs: t.CArray[t.CInt, 288] + rt_freqs: t.CArray[int, 288] string.memset(rt_freqs, 0, rt_freqs.__sizeof__()) rt_freqs['H'] = 10 rt_freqs['e'] = 8 @@ -680,15 +680,15 @@ def test_huffman_tree(): enc_tree.build_codes(rt_freqs, 257, 15) dec_tree = zhuff.zhuff_decode_tree() - dec_tree.build_decode_tree(c.Addr(enc_tree)) + dec_tree.build_decode_tree(&enc_tree) writer = zdef.zbit_writer(None) - symbols: t.CArray[t.CInt, None] = ['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd', '!', 256] - num_symbols: t.CInt = 13 + symbols: t.CArray[int, None] = ['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd', '!', 256] + num_symbols: int = 13 for i in range(num_symbols): - enc_tree.encode_symbol(symbols[i], c.Addr(writer)) + enc_tree.encode_symbol(symbols[i], &writer) reader = zdef.zbit_reader() reader.buf = writer.buf @@ -696,9 +696,9 @@ def test_huffman_tree(): reader.byte_pos = 0 reader.bit_pos = 0 - roundtrip_ok: t.CInt = 1 + roundtrip_ok: int = 1 for i in range(num_symbols): - decoded: t.CInt = dec_tree.decode_symbol(c.Addr(reader)) + decoded: int = dec_tree.decode_symbol(&reader) if decoded != symbols[i]: roundtrip_ok = 0 printf(" MISMATCH at symbol %d: expected %d, got %d\n", i, symbols[i], decoded) @@ -710,7 +710,7 @@ def test_huffman_tree(): stdlib.free(writer.buf) printf("\n --- Overflow handling (many symbols, limited max_bits) ---\n") - of_freqs: t.CArray[t.CInt, 256] + of_freqs: t.CArray[int, 256] for i in range(256): of_freqs[i] = 1 of_freqs[256] = 1 @@ -718,14 +718,14 @@ def test_huffman_tree(): of_tree = zhuff.zhuff_tree() of_tree.build_codes(of_freqs, 257, 15) - overflow_ok: t.CInt = 1 + overflow_ok: int = 1 for i in range(257): if of_tree.codes[i].bits > 15 or of_tree.codes[i].bits < 0: overflow_ok = 0 break check("all code lengthgths <= 15 with 257 symbols", overflow_ok, "code lengthgth overflow") - bl_count: t.CArray[t.CInt, 16] = [0] + bl_count: t.CArray[int, 16] = [0] for i in range(257): if of_tree.codes[i].bits > 0: bl_count[of_tree.codes[i].bits] += 1 @@ -735,13 +735,13 @@ def test_huffman_tree(): printf(" %2d bits: %3d codes\n", i, bl_count[i]) dt = zhuff.zhuff_decode_tree() - dt.build_decode_tree(c.Addr(of_tree)) + dt.build_decode_tree(&of_tree) w = zdef.zbit_writer(None) - of_tree.encode_symbol(0, c.Addr(w)) - of_tree.encode_symbol(128, c.Addr(w)) - of_tree.encode_symbol(255, c.Addr(w)) - of_tree.encode_symbol(256, c.Addr(w)) + of_tree.encode_symbol(0, &w) + of_tree.encode_symbol(128, &w) + of_tree.encode_symbol(255, &w) + of_tree.encode_symbol(256, &w) r = zdef.zbit_reader() r.buf = w.buf @@ -749,10 +749,10 @@ def test_huffman_tree(): r.byte_pos = 0 r.bit_pos = 0 - s0: t.CInt = dt.decode_symbol(c.Addr(r)) - s1: t.CInt = dt.decode_symbol(c.Addr(r)) - s2: t.CInt = dt.decode_symbol(c.Addr(r)) - s3: t.CInt = dt.decode_symbol(c.Addr(r)) + s0: int = dt.decode_symbol(&r) + s1: int = dt.decode_symbol(&r) + s2: int = dt.decode_symbol(&r) + s3: int = dt.decode_symbol(&r) check("overflow roundtrip: symbol 0", s0 == 0, "decode mismatch") check("overflow roundtrip: symbol 128", s1 == 128, "decode mismatch") @@ -766,7 +766,7 @@ def test_huffman_tree(): # 与 ZlibDbg 的失败形态（码表把部分符号编成无码位/错码位）直接对齐。 w2 = zdef.zbit_writer(None) for i in range(257): - of_tree.encode_symbol(i, c.Addr(w2)) + of_tree.encode_symbol(i, &w2) r2 = zdef.zbit_reader() r2.buf = w2.buf @@ -774,9 +774,9 @@ def test_huffman_tree(): r2.byte_pos = 0 r2.bit_pos = 0 - full_ok: t.CInt = 1 + full_ok: int = 1 for i in range(257): - got: t.CInt = dt.decode_symbol(c.Addr(r2)) + got: int = dt.decode_symbol(&r2) if got != i: full_ok = 0 printf(" FULL ROUNDTRIP MISMATCH at %d: got %d\n", i, got) @@ -786,7 +786,7 @@ def test_huffman_tree(): printf("\n --- Kraft inequality check ---\n") - kf_freqs: t.CArray[t.CInt, 256] + kf_freqs: t.CArray[int, 256] string.memset(kf_freqs, 0, kf_freqs.__sizeof__()) kf_freqs['X'] = 100 kf_freqs['Y'] = 50 @@ -796,10 +796,10 @@ def test_huffman_tree(): kf_tree = zhuff.zhuff_tree() kf_tree.build_codes(kf_freqs, 257, 15) - kraft_sum: t.CDouble = 0.0 + kraft_sum: double = 0.0 for i in range(257): if kf_tree.codes[i].bits > 0: - kraft_sum += 1.0 / (t.CDouble(ULONGLONG(1) << kf_tree.codes[i].bits)) + kraft_sum += 1.0 / (double(ULONGLONG(1) << kf_tree.codes[i].bits)) check("Kraft inequality: sum <= 1.0", kraft_sum <= 1.0 + 1e-9, "Kraft violated") printf(" Kraft sum = %.10f (must be <= 1.0)\n", kraft_sum) @@ -809,11 +809,11 @@ def test_huffman_tree(): def test_error_handling(): section_header("Error handling") - out_length: t.CSizeT = 0 + out_length: sizet = 0 printf(" Trying to decompress garbage data...\n") result: BYTEPTR = pyzlib.decompress(None, BYTEPTR("garbage"), 7, - pyzlib.MAX_WBITS, pyzlib.DEF_BUF_SIZE, c.Addr(out_length)) + pyzlib.MAX_WBITS, pyzlib.DEF_BUF_SIZE, &out_length) check("decompress garbage returns None", result == None, "should have returned None") printf(" Error code : %d\n", pyzlib.get_error_code()) printf(" Error message: \"%s\"\n", pyzlib.get_error()) @@ -869,7 +869,7 @@ def test_constants(): section_footer() -def main123456() -> t.CInt: +def main123456() -> int: printf("==============================================\n") printf(" Python zlib - C Implementation Tests\n") printf("==============================================\n")