补充

Test/StringIterTest/App/inline_test.py

@@ -0,0 +1,51 @@
+import t
+import stdio
+import c
+
+# Test: @t.Object class with inline list[struct, N] field
+
+class Inner:
+    code: t.CUnsignedInt
+    bits: t.CInt
+
+@t.Object
+class Container:
+    items: list[Inner, 10]
+    count: t.CInt
+
+    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].bits = i
+            self.count += 1
+
+    def check(self):
+        ok: t.CInt = 1
+        for i in range(10):
+            if self.items[i].code != t.CUnsignedInt(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:
+                stdio.printf("FAIL: items[%d].bits=%d expect %d\n", i, self.items[i].bits, i)
+                ok = 0
+        if ok:
+            stdio.printf("PASS: inline list[struct, N] in @t.Object\n")
+        else:
+            stdio.printf("FAIL: inline list[struct, N] in @t.Object\n")
+
+def main() -> t.CInt:
+    stdio.printf("=== InlineArrayTest ===\n")
+    c1 = Container()
+    c1.fill()
+    c1.check()
+
+    # Also test: local variable of @t.Object type
+    c2 = Container()
+    c2.fill()
+    c2.check()
+
+    stdio.printf("=== InlineArrayTest Complete ===\n")
+    return 0

Test/StringIterTest/App/main.py

@@ -0,0 +1,209 @@
+import t
+import stdio
+import string
+import c
+
+# ============================================================
+# Test 1: 字符串指针迭代 - 逐字符直到\0
+# ============================================================
+def test_string_ptr_iter():
+    stdio.printf("--- Test 1: string pointer iteration ---\n")
+    s: t.CChar | t.CPtr = "Hello"
+    p: t.CChar | t.CPtr = s
+    count: t.CInt = 0
+    while c.Deref(p) != 0:
+        count += 1
+        p += 1
+    if count == 5:
+        stdio.printf("PASS: ptr iter (count=%d)\n", count)
+    else:
+        stdio.printf("FAIL: ptr iter (count=%d, expect 5)\n", count)
+
+# ============================================================
+# Test 2: 字符串指针求和ASCII值
+# ============================================================
+def test_string_ascii_sum():
+    stdio.printf("--- Test 2: string ASCII sum ---\n")
+    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))
+        p += 1
+    # A=65, B=66, C=67 => 198
+    if total == 198:
+        stdio.printf("PASS: ASCII sum (total=%d)\n", total)
+    else:
+        stdio.printf("FAIL: ASCII sum (total=%d, expect 198)\n", total)
+
+# ============================================================
+# Test 3: 手动strcpy - 指针复制
+# ============================================================
+def test_manual_strcpy():
+    stdio.printf("--- Test 3: manual strcpy via pointers ---\n")
+    src: t.CChar | t.CPtr = "Test"
+    dst: list[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))
+        sp += 1
+        dp += 1
+    c.Set(c.Deref(dp), 0)
+    if dst[0] == 84 and dst[1] == 101 and dst[2] == 115 and dst[3] == 116:
+        stdio.printf("PASS: manual strcpy (T=%d e=%d s=%d t=%d)\n", dst[0], dst[1], dst[2], dst[3])
+    else:
+        stdio.printf("FAIL: manual strcpy (T=%d e=%d s=%d t=%d)\n", dst[0], dst[1], dst[2], dst[3])
+
+# ============================================================
+# Test 4: 指针比较和偏移
+# ============================================================
+def test_ptr_offset_compare():
+    stdio.printf("--- Test 4: pointer offset and compare ---\n")
+    arr: list[t.CInt, 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
+    while p != start + 5:
+        total += c.Deref(p)
+        p += 1
+    if total == 100:
+        stdio.printf("PASS: ptr offset (total=%d)\n", total)
+    else:
+        stdio.printf("FAIL: ptr offset (total=%d, expect 100)\n", total)
+
+# ============================================================
+# Test 5: 字符串长度手动计算
+# ============================================================
+def test_manual_strlen():
+    stdio.printf("--- Test 5: manual strlen ---\n")
+    s: t.CChar | t.CPtr = "Hello World!"
+    p: t.CChar | t.CPtr = s
+    length: t.CSizeT = 0
+    while c.Deref(p) != 0:
+        length += 1
+        p += 1
+    if length == 12:
+        stdio.printf("PASS: manual strlen (len=%zu)\n", length)
+    else:
+        stdio.printf("FAIL: manual strlen (len=%zu, expect 12)\n", length)
+
+# ============================================================
+# Test 6: 指针反向遍历字符串
+# ============================================================
+def test_reverse_string_ptr():
+    stdio.printf("--- Test 6: reverse string via pointer ---\n")
+    src: t.CChar | t.CPtr = "abcd"
+    dst: list[t.CChar, 32] = [0]
+    # Find end of src
+    p: t.CChar | t.CPtr = src
+    length: t.CInt = 0
+    while c.Deref(p) != 0:
+        length += 1
+        p += 1
+    # Copy in reverse
+    dp: t.CChar | t.CPtr = c.Addr(dst)
+    p = src + length - 1
+    while p >= src:
+        c.Set(c.Deref(dp), c.Deref(p))
+        dp += 1
+        p -= 1
+    c.Set(c.Deref(dp), 0)
+    # "abcd" reversed = "dcba" = 100,99,98,97
+    if dst[0] == 100 and dst[1] == 99 and dst[2] == 98 and dst[3] == 97:
+        stdio.printf("PASS: reverse string (d=%d c=%d b=%d a=%d)\n", dst[0], dst[1], dst[2], dst[3])
+    else:
+        stdio.printf("FAIL: reverse string (d=%d c=%d b=%d a=%d)\n", dst[0], dst[1], dst[2], dst[3])
+
+# ============================================================
+# Test 7: 多级指针 - 指向指针的指针
+# ============================================================
+def test_double_pointer():
+    stdio.printf("--- Test 7: double pointer ---\n")
+    x: t.CInt = 42
+    px: t.CInt | t.CPtr = c.Addr(x)
+    ppx: t.CInt | t.CPtr | t.CPtr = c.Addr(px)
+    # Read through double pointer
+    val: t.CInt = c.Deref(c.Deref(ppx))
+    if val == 42:
+        stdio.printf("PASS: double pointer (val=%d)\n", val)
+    else:
+        stdio.printf("FAIL: double pointer (val=%d, expect 42)\n", val)
+
+# ============================================================
+# Test 8: 指针算术 - 数组元素访问
+# ============================================================
+def test_ptr_arithmetic():
+    stdio.printf("--- Test 8: pointer arithmetic ---\n")
+    arr: list[t.CInt, 8] = [0]
+    for i in range(8):
+        arr[i] = (i + 1) * (i + 1)
+    p: t.CInt | t.CPtr = c.Addr(arr)
+    # Access arr[3] via pointer: p + 3
+    val: t.CInt = c.Deref(p + 3)
+    # arr[3] = 4*4 = 16
+    if val == 16:
+        stdio.printf("PASS: ptr arithmetic (arr[3]=%d)\n", val)
+    else:
+        stdio.printf("FAIL: ptr arithmetic (arr[3]=%d, expect 16)\n", val)
+
+# ============================================================
+# Test 9: 字符串比较 - 逐字符指针
+# ============================================================
+def test_manual_strcmp():
+    stdio.printf("--- Test 9: manual strcmp via pointers ---\n")
+    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):
+            equal = 0
+            break
+        p1 += 1
+        p2 += 1
+    if c.Deref(p1) != c.Deref(p2):
+        equal = 0
+    if equal == 1:
+        stdio.printf("PASS: manual strcmp (equal=%d)\n", equal)
+    else:
+        stdio.printf("FAIL: manual strcmp (equal=%d, expect 1)\n", equal)
+
+# ============================================================
+# Test 10: 结构体指针访问
+# ============================================================
+class Vec2:
+    x: t.CInt
+    y: t.CInt
+
+def test_struct_ptr_access():
+    stdio.printf("--- Test 10: struct pointer access ---\n")
+    v: Vec2 = Vec2()
+    v.x = 10
+    v.y = 20
+    p: Vec2 | t.CPtr = c.Addr(v)
+    # Modify through pointer
+    c.Deref(p).x = 100
+    c.Deref(p).y = 200
+    if v.x == 100 and v.y == 200:
+        stdio.printf("PASS: struct ptr (x=%d y=%d)\n", v.x, v.y)
+    else:
+        stdio.printf("FAIL: struct ptr (x=%d y=%d, expect 100 200)\n", v.x, v.y)
+
+def main() -> t.CInt:
+    stdio.printf("=== StringIterTest: String/Pointer Iteration Tests ===\n\n")
+    test_string_ptr_iter()
+    test_string_ascii_sum()
+    test_manual_strcpy()
+    test_ptr_offset_compare()
+    test_manual_strlen()
+    test_reverse_string_ptr()
+    test_double_pointer()
+    test_ptr_arithmetic()
+    test_manual_strcmp()
+    test_struct_ptr_access()
+    stdio.printf("\n=== StringIterTest Complete ===\n")
+    return 0

Test/StringIterTest/output/2255fdda7aed5595.deps.json

@@ -0,0 +1 @@
+{"string": "4d5db7f970ef510f", "stdint": "56cdd754a8a09347", "stdio": "73edbcf76e32d00b"}

Test/StringIterTest/output/4d5db7f970ef510f.deps.json

@@ -0,0 +1 @@
+{"main": "2255fdda7aed5595", "string": "4d5db7f970ef510f", "stdint": "56cdd754a8a09347", "stdio": "73edbcf76e32d00b"}

Test/StringIterTest/project.json

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

Test/StringIterTest/temp/2255fdda7aed5595.pyi

@@ -0,0 +1,37 @@
+"""
+Auto-generated Python stub file from main.py
+Module: main
+"""
+
+
+import t
+import stdio
+import string
+import c
+
+def test_string_ptr_iter() -> t.CInt: pass
+
+def test_string_ascii_sum() -> t.CInt: pass
+
+def test_manual_strcpy() -> t.CInt: pass
+
+def test_ptr_offset_compare() -> t.CInt: pass
+
+def test_manual_strlen() -> t.CInt: pass
+
+def test_reverse_string_ptr() -> t.CInt: pass
+
+def test_double_pointer() -> t.CInt: pass
+
+def test_ptr_arithmetic() -> t.CInt: pass
+
+def test_manual_strcmp() -> t.CInt: pass
+
+
+class Vec2:
+    x: t.CInt
+    y: t.CInt
+
+def test_struct_ptr_access() -> t.CInt: pass
+
+def main() -> t.CInt: pass

Test/StringIterTest/temp/4d5db7f970ef510f.pyi

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

Test/StringIterTest/temp/56cdd754a8a09347.pyi

@@ -0,0 +1,67 @@
+"""
+Auto-generated Python stub file from stdint.py
+Module: stdint
+"""
+
+import c
+
+
+import t
+
+INT: t.CTypedef = t.CInt
+INTPTR: t.CTypedef = t.CInt | t.CPtr
+BOOL: t.CTypedef = t.CInt
+UINT: t.CTypedef = t.CUnsignedInt
+UINTPTR: t.CTypedef = UINT | t.CPtr
+BYTE: t.CTypedef = t.CUnsignedChar
+BYTEPTR: t.CTypedef = BYTE | t.CPtr
+WORD: t.CTypedef = t.CUInt16T
+DWORD: t.CTypedef = t.CUInt32T
+QWORD: t.CTypedef = t.CUInt64T
+TCHAR: t.CTypedef = t.CChar
+CHARLIST: t.CTypedef = str | t.CPtr
+VOID: t.CTypedef = t.CVoid
+SHORT: t.CTypedef = t.CShort
+SHORTPTR: t.CTypedef = t.CShort | t.CPtr
+USHORT: t.CTypedef = t.CUnsignedShort
+USHORTPTR: t.CTypedef = t.CUnsignedShort | t.CPtr
+LONGLONG: t.CTypedef = t.CLong | t.CLong
+ULONGLONG: t.CTypedef = t.CUnsignedLong | t.CLong
+LONG: t.CTypedef = t.CLong
+ULONG: t.CTypedef = t.CUnsignedLong
+WCHAR: t.CTypedef = WORD
+WCHARPTR: t.CTypedef = WORD | t.CPtr
+CHARPTR: t.CTypedef = t.CChar | t.CPtr
+FSIZE_t: t.CTypedef = DWORD
+LBA_t: t.CTypedef = DWORD
+UINTPTR: t.CTypedef = t.CUnsignedInt | t.CPtr
+VOIDPTR: t.CTypedef = t.CVoid | t.CPtr
+FLOAT: t.CTypedef = t.CFloat
+DOUBLE: t.CTypedef = t.CDouble
+FLOAT8: t.CTypedef = t.CFloat8T
+FLOAT16: t.CTypedef = t.CFloat16T
+FLOAT32: t.CTypedef = t.CFloat32T
+FLOAT64: t.CTypedef = t.CFloat64T
+FLOAT128: t.CTypedef = t.CFloat128T
+INT8: t.CTypedef = t.CInt8T
+INT16: t.CTypedef = t.CInt16T
+INT32: t.CTypedef = t.CInt32T
+INT64: t.CTypedef = t.CInt64T
+UINT8: t.CTypedef = t.CUInt8T
+UINT16: t.CTypedef = t.CUInt16T
+UINT32: t.CTypedef = t.CUInt32T
+UINT64: t.CTypedef = t.CUInt64T
+INT8PTR: t.CTypedef = t.CInt8T | t.CPtr
+INT16PTR: t.CTypedef = t.CInt16T | t.CPtr
+INT32PTR: t.CTypedef = t.CInt32T | t.CPtr
+INT64PTR: t.CTypedef = t.CInt64T | t.CPtr
+UINT8PTR: t.CTypedef = t.CUInt8T | t.CPtr
+UINT16PTR: t.CTypedef = t.CUInt16T | t.CPtr
+UINT32PTR: t.CTypedef = t.CUInt32T | t.CPtr
+UINT64PTR: t.CTypedef = t.CUInt64T | t.CPtr
+CHAR8: t.CTypedef = t.CChar8T
+CHAR16: t.CTypedef = t.CChar16T
+CHAR32: t.CTypedef = t.CChar32T
+CHAR8PTR: t.CTypedef = t.CChar8T | t.CPtr
+CHAR16PTR: t.CTypedef = t.CChar16T | t.CPtr
+CHAR32PTR: t.CTypedef = t.CChar32T | t.CPtr

Test/StringIterTest/temp/73edbcf76e32d00b.pyi

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

Test/StringIterTest/temp/_sha1_map.txt

@@ -0,0 +1,4 @@
+2255fdda7aed5595:main.py
+4d5db7f970ef510f:includes/string.py
+56cdd754a8a09347:includes/stdint.py
+73edbcf76e32d00b:includes/stdio.py