test: TestProject/2/3 拆分为 10 个具体测试项目; ZlibTest 并入标准 zlib 库
新项目(各含 project.json + App/main.vp): - LoopMathTest/LogicFlowTest/ClassArrayTest/NumpyTest (原 TestProject) - HashLibTest (原 TestProject2 去 zlib) - GenericOopTest/EnumTest/MpoolOopTest/VectorGenericTest/FileIoTest (原 TestProject3) ZlibTest 增加"标准 zlib 库(zlib.pyzlib)" section 与 __zlib 并存验证。
This commit is contained in:
TermiNexus committed
1 parent
61f07d4f9b
commit
6644d6ce3b
31 files changed
+3774
No files matched your search
@@ -0,0 +1,245 @@
|
||||
import stdio
|
||||
import stdint
|
||||
import t, c
|
||||
|
||||
|
||||
class SimpleData(t.Object):
|
||||
x: t.CInt
|
||||
y: t.CInt
|
||||
|
||||
|
||||
class Point3D(t.Object):
|
||||
x: t.CFloat
|
||||
y: t.CFloat
|
||||
z: t.CFloat
|
||||
|
||||
|
||||
class Student(t.Object):
|
||||
name: t.CChar | t.CPtr
|
||||
age: t.CInt
|
||||
score: t.CInt
|
||||
|
||||
def __init__(self, n: t.CChar | t.CPtr, a: t.CInt, s: t.CInt):
|
||||
self.name = n
|
||||
self.age = a
|
||||
self.score = s
|
||||
|
||||
def get_age(self) -> t.CInt:
|
||||
return self.age
|
||||
|
||||
def get_score(self) -> t.CInt:
|
||||
return self.score
|
||||
|
||||
|
||||
class Counter(t.Object):
|
||||
value: t.CInt
|
||||
|
||||
def __init__(self, initial: t.CInt):
|
||||
self.value = initial
|
||||
|
||||
def increment(self):
|
||||
self.value += 1
|
||||
|
||||
def get_value(self) -> t.CInt:
|
||||
return self.value
|
||||
|
||||
|
||||
class StackObj(t.Object):
|
||||
data: t.CInt
|
||||
next_ptr: t.CVoid | t.CPtr
|
||||
|
||||
|
||||
def TestBasicDataClass():
|
||||
stdio.printf("=== Test Basic Data Class ===\n")
|
||||
p: SimpleData = SimpleData()
|
||||
p.x = 10
|
||||
p.y = 20
|
||||
stdio.printf("SimpleData: x=%d, y=%d\n", p.x, p.y)
|
||||
|
||||
|
||||
def TestPoint3DClass():
|
||||
stdio.printf("=== Test Point3D Class ===\n")
|
||||
pt: Point3D = Point3D()
|
||||
pt.x = 1.5
|
||||
pt.y = 2.5
|
||||
pt.z = 3.5
|
||||
stdio.printf("Point3D: x=%.1f, y=%.1f, z=%.1f\n", pt.x, pt.y, pt.z)
|
||||
|
||||
|
||||
def TestStudentClass():
|
||||
stdio.printf("=== Test Student Class ===\n")
|
||||
s: Student = Student("Alice", 20, 95)
|
||||
stdio.printf("Student: name=%s, age=%d, score=%d\n", s.name, s.age, s.score)
|
||||
stdio.printf(" get_age()=%d, get_score()=%d\n", s.get_age(), s.get_score())
|
||||
|
||||
|
||||
def TestCounterClass():
|
||||
stdio.printf("=== Test Counter Class ===\n")
|
||||
cnt: Counter = Counter(0)
|
||||
stdio.printf("Initial value: %d\n", cnt.get_value())
|
||||
cnt.increment()
|
||||
cnt.increment()
|
||||
cnt.increment()
|
||||
stdio.printf("After 3 increments: %d\n", cnt.get_value())
|
||||
|
||||
|
||||
def TestStackAllocation():
|
||||
stdio.printf("=== Test Stack Allocation ===\n")
|
||||
obj1: SimpleData = SimpleData()
|
||||
obj1.x = 100
|
||||
obj1.y = 200
|
||||
stdio.printf("Stack obj1: x=%d, y=%d\n", obj1.x, obj1.y)
|
||||
|
||||
obj2: Point3D = Point3D()
|
||||
obj2.x = 10.0
|
||||
obj2.y = 20.0
|
||||
obj2.z = 30.0
|
||||
stdio.printf("Stack obj2: x=%.1f, y=%.1f, z=%.1f\n", obj2.x, obj2.y, obj2.z)
|
||||
|
||||
|
||||
def TestHeapAllocation():
|
||||
stdio.printf("=== Test Heap Allocation ===\n")
|
||||
ptr: t.CVoid | t.CPtr = c.malloc(1024)
|
||||
if ptr != 0:
|
||||
stdio.printf("Allocated 1024 bytes at %p\n", ptr)
|
||||
c.free(ptr)
|
||||
stdio.printf("Freed memory\n")
|
||||
else:
|
||||
stdio.printf("malloc failed\n")
|
||||
|
||||
|
||||
def TestHeapObjectWithInit():
|
||||
stdio.printf("=== Test Heap Object with Init ===\n")
|
||||
mem_size: t.CSizeT = 256
|
||||
ptr: t.CVoid | t.CPtr = c.malloc(mem_size)
|
||||
if ptr != 0:
|
||||
stdio.printf("Allocated %d bytes\n", mem_size)
|
||||
c.free(ptr)
|
||||
else:
|
||||
stdio.printf("malloc failed\n")
|
||||
|
||||
|
||||
def TestMultipleStackObjects():
|
||||
stdio.printf("=== Test Multiple Stack Objects ===\n")
|
||||
objs: SimpleData = SimpleData()
|
||||
objs.x = 1
|
||||
objs.y = 2
|
||||
obj2: Point3D = Point3D()
|
||||
obj2.x = 5.0
|
||||
obj2.y = 10.0
|
||||
obj2.z = 15.0
|
||||
obj3: Counter = Counter(42)
|
||||
stdio.printf("objs: x=%d, y=%d\n", objs.x, objs.y)
|
||||
stdio.printf("obj2: x=%.1f, y=%.1f, z=%.1f\n", obj2.x, obj2.y, obj2.z)
|
||||
stdio.printf("obj3 initial: %d\n", obj3.get_value())
|
||||
obj3.increment()
|
||||
obj3.increment()
|
||||
stdio.printf("obj3 after 2 increments: %d\n", obj3.get_value())
|
||||
|
||||
|
||||
def TestImplicitInitCall():
|
||||
stdio.printf("=== Test Implicit Init Call ===\n")
|
||||
stu1: Student = Student("Bob", 22, 88)
|
||||
stu2: Student = Student("Charlie", 19, 77)
|
||||
stdio.printf("stu1: name=%s, age=%d, score=%d\n", stu1.name, stu1.age, stu1.score)
|
||||
stdio.printf("stu2: name=%s, age=%d, score=%d\n", stu2.name, stu2.age, stu2.score)
|
||||
|
||||
|
||||
def TestClassWithBitFields():
|
||||
stdio.printf("=== Test Class with Bit Fields ===\n")
|
||||
flags: StackObj = StackObj()
|
||||
flags.data = 0
|
||||
flags.next_ptr = 0
|
||||
stdio.printf("StackObj: data=%d, next_ptr=%p\n", flags.data, flags.next_ptr)
|
||||
|
||||
|
||||
def TestIntArray():
|
||||
stdio.printf("=== Test Int Array ===\n")
|
||||
arr: t.CArray[t.CInt, 5] = t.CArray[t.CInt, 5]()
|
||||
i: t.CInt = 0
|
||||
while i < 5:
|
||||
arr[i] = i * 10
|
||||
i += 1
|
||||
i = 0
|
||||
while i < 5:
|
||||
stdio.printf("arr[%d]=%d\n", i, arr[i])
|
||||
i += 1
|
||||
|
||||
|
||||
def TestFloatArray():
|
||||
stdio.printf("=== Test Float Array ===\n")
|
||||
farr: t.CArray[t.CFloat, 4] = t.CArray[t.CFloat, 4]()
|
||||
farr[0] = 1.5
|
||||
farr[1] = 2.5
|
||||
farr[2] = 3.5
|
||||
farr[3] = 4.5
|
||||
i: t.CInt = 0
|
||||
while i < 4:
|
||||
stdio.printf("farr[%d]=%.1f\n", i, farr[i])
|
||||
i += 1
|
||||
|
||||
|
||||
def TestCharArray():
|
||||
stdio.printf("=== Test Char Array (String) ===\n")
|
||||
str_arr: t.CArray[t.CChar, 32] = t.CArray[t.CChar, 32]()
|
||||
str_arr[0] = 'H'
|
||||
str_arr[1] = 'e'
|
||||
str_arr[2] = 'l'
|
||||
str_arr[3] = 'l'
|
||||
str_arr[4] = 'o'
|
||||
str_arr[5] = '\0'
|
||||
stdio.printf("String: %s\n", str_arr)
|
||||
|
||||
|
||||
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[0] = 0
|
||||
row0[1] = 1
|
||||
row0[2] = 2
|
||||
row1[0] = 10
|
||||
row1[1] = 11
|
||||
row1[2] = 12
|
||||
i: t.CInt = 0
|
||||
while i < 3:
|
||||
stdio.printf("row0[%d]=%d ", i, row0[i])
|
||||
i += 1
|
||||
stdio.printf("\n")
|
||||
i = 0
|
||||
while i < 3:
|
||||
stdio.printf("row1[%d]=%d ", i, row1[i])
|
||||
i += 1
|
||||
stdio.printf("\n")
|
||||
|
||||
|
||||
def TestArrayWithStruct():
|
||||
stdio.printf("=== Test Array with Struct ===\n")
|
||||
points: t.CArray[SimpleData, 3] = t.CArray[SimpleData, 3]()
|
||||
i: t.CInt = 0
|
||||
while i < 3:
|
||||
points[i].x = i * 10
|
||||
points[i].y = i * 100
|
||||
i += 1
|
||||
i = 0
|
||||
while i < 3:
|
||||
stdio.printf("Point[%d]: x=%d, y=%d\n", i, points[i].x, points[i].y)
|
||||
i += 1
|
||||
|
||||
|
||||
def TestArrayPointer():
|
||||
stdio.printf("=== Test Array Pointer ===\n")
|
||||
data: t.CArray[t.CInt, 8] = t.CArray[t.CInt, 8]()
|
||||
data[0] = 100
|
||||
data[1] = 200
|
||||
data[2] = 300
|
||||
ptr: t.CInt | 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])
|
||||
|
||||
|
||||
def TestDynamicString():
|
||||
stdio.printf("=== Test Dynamic String ===\n")
|
||||
name: str = "TransPyC"
|
||||
stdio.printf("Hello %s!\n", name)
|
||||
@@ -0,0 +1,47 @@
|
||||
import t, c
|
||||
import testcheck
|
||||
import class_test
|
||||
|
||||
|
||||
def main() -> t.CInt:
|
||||
testcheck.begin("ClassArrayTest: 类与数组测试")
|
||||
|
||||
testcheck.section("CLASS TESTS")
|
||||
class_test.TestBasicDataClass()
|
||||
testcheck.ok("TestBasicDataClass")
|
||||
class_test.TestPoint3DClass()
|
||||
testcheck.ok("TestPoint3DClass")
|
||||
class_test.TestStudentClass()
|
||||
testcheck.ok("TestStudentClass")
|
||||
class_test.TestCounterClass()
|
||||
testcheck.ok("TestCounterClass")
|
||||
class_test.TestStackAllocation()
|
||||
testcheck.ok("TestStackAllocation")
|
||||
class_test.TestHeapAllocation()
|
||||
testcheck.ok("TestHeapAllocation")
|
||||
class_test.TestHeapObjectWithInit()
|
||||
testcheck.ok("TestHeapObjectWithInit")
|
||||
class_test.TestMultipleStackObjects()
|
||||
testcheck.ok("TestMultipleStackObjects")
|
||||
class_test.TestImplicitInitCall()
|
||||
testcheck.ok("TestImplicitInitCall")
|
||||
class_test.TestClassWithBitFields()
|
||||
testcheck.ok("TestClassWithBitFields")
|
||||
|
||||
testcheck.section("ARRAY TESTS")
|
||||
class_test.TestIntArray()
|
||||
testcheck.ok("TestIntArray")
|
||||
class_test.TestFloatArray()
|
||||
testcheck.ok("TestFloatArray")
|
||||
class_test.TestCharArray()
|
||||
testcheck.ok("TestCharArray")
|
||||
class_test.TestNestedArray()
|
||||
testcheck.ok("TestNestedArray")
|
||||
class_test.TestArrayWithStruct()
|
||||
testcheck.ok("TestArrayWithStruct")
|
||||
class_test.TestArrayPointer()
|
||||
testcheck.ok("TestArrayPointer")
|
||||
class_test.TestDynamicString()
|
||||
testcheck.ok("TestDynamicString")
|
||||
|
||||
return testcheck.end()
|
||||
@@ -0,0 +1,29 @@
|
||||
{
|
||||
"$schema": "https://raw.githubusercontent.com/TermiNexus/TransPyC/main/schemas/project-schema.json",
|
||||
"name": "ClassArrayTest",
|
||||
"version": "1.0.0",
|
||||
"source_dir": "./App",
|
||||
"build_dir": "./.tpv_build",
|
||||
"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": "ClassArrayTest.exe"
|
||||
},
|
||||
"includes": [
|
||||
"../../includes"
|
||||
],
|
||||
"target": {
|
||||
"triple": "x86_64-pc-windows-gnu",
|
||||
"datalayout": "e-m:w-p270:32:32-p271:32:32-p272:64:64-f80:128-n8:16:32:64-S128"
|
||||
},
|
||||
"options": {
|
||||
"slice_level": 3,
|
||||
"sha1_slice_level": 1,
|
||||
"target": "llvm",
|
||||
"strict_mode": true
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,95 @@
|
||||
import t, c
|
||||
from t import CInt, CPtr, CChar, CInt32T, CExport
|
||||
import viperlib
|
||||
import stdlib
|
||||
|
||||
|
||||
class Color(t.CEnum):
|
||||
Red = 0
|
||||
Green = 1
|
||||
Blue = 2
|
||||
|
||||
|
||||
class Option(t.REnum):
|
||||
class Some:
|
||||
value: CInt
|
||||
Empty = 1
|
||||
|
||||
|
||||
class Result(t.REnum):
|
||||
class Ok:
|
||||
value: CInt
|
||||
class Err:
|
||||
msg: t.CChar | CPtr
|
||||
|
||||
|
||||
class GeoShape(t.REnum):
|
||||
class GCircle:
|
||||
radius: CInt
|
||||
class GRect:
|
||||
w: CInt
|
||||
h: CInt
|
||||
class GPoint:
|
||||
x: CInt
|
||||
y: CInt
|
||||
|
||||
|
||||
def enum_main() -> CInt:
|
||||
buf: CChar | CPtr = CPtr(stdlib.malloc(256))
|
||||
|
||||
c1: CInt = Color.Red
|
||||
c2: CInt = Color.Green
|
||||
c3: CInt = Color.Blue
|
||||
viperlib.snprintf(buf, 256, "CEnum: Red=%d Green=%d Blue=%d", c1, c2, c3)
|
||||
print(buf)
|
||||
|
||||
opt: Option = Option.Some(42)
|
||||
match opt:
|
||||
case Option.Some(v):
|
||||
viperlib.snprintf(buf, 256, "Option.Some: value=%d", v)
|
||||
print(buf)
|
||||
case Option.Empty():
|
||||
pass
|
||||
|
||||
res1: Result = Result.Ok(100)
|
||||
match res1:
|
||||
case Result.Ok(v):
|
||||
viperlib.snprintf(buf, 256, "Result.Ok: value=%d", v)
|
||||
print(buf)
|
||||
case Result.Err(e):
|
||||
pass
|
||||
|
||||
res2: Result = Result.Err("not found")
|
||||
match res2:
|
||||
case Result.Ok(v):
|
||||
pass
|
||||
case Result.Err(e):
|
||||
viperlib.snprintf(buf, 256, "Result.Err: msg=%s", e)
|
||||
print(buf)
|
||||
|
||||
s1: GeoShape = GeoShape.GCircle(5)
|
||||
match s1:
|
||||
case GeoShape.GCircle(r):
|
||||
viperlib.snprintf(buf, 256, "GeoShape.GCircle: radius=%d", r)
|
||||
print(buf)
|
||||
case _:
|
||||
pass
|
||||
|
||||
s2: GeoShape = GeoShape.GRect(10, 20)
|
||||
match s2:
|
||||
case GeoShape.GRect(w, h):
|
||||
viperlib.snprintf(buf, 256, "GeoShape.GRect: w=%d h=%d", w, h)
|
||||
print(buf)
|
||||
case _:
|
||||
pass
|
||||
|
||||
s3: GeoShape = GeoShape.GPoint(3, 4)
|
||||
match s3:
|
||||
case GeoShape.GPoint(x, y):
|
||||
viperlib.snprintf(buf, 256, "GeoShape.GPoint: x=%d y=%d", x, y)
|
||||
print(buf)
|
||||
case _:
|
||||
pass
|
||||
|
||||
stdlib.free(buf)
|
||||
return 0
|
||||
@@ -0,0 +1,11 @@
|
||||
import t, c
|
||||
import testcheck
|
||||
import enumtest
|
||||
|
||||
|
||||
def main() -> t.CInt | t.CExport:
|
||||
testcheck.begin("EnumTest: 枚举类型测试")
|
||||
testcheck.section("Enum")
|
||||
enumtest.enum_main()
|
||||
testcheck.ok("Enum 测试完成")
|
||||
return testcheck.end()
|
||||
@@ -0,0 +1,29 @@
|
||||
{
|
||||
"$schema": "https://raw.githubusercontent.com/TermiNexus/TransPyC/main/schemas/project-schema.json",
|
||||
"name": "EnumTest",
|
||||
"version": "1.0.0",
|
||||
"source_dir": "./App",
|
||||
"build_dir": "./.tpv_build",
|
||||
"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": "EnumTest.exe"
|
||||
},
|
||||
"includes": [
|
||||
"../../includes"
|
||||
],
|
||||
"target": {
|
||||
"triple": "x86_64-pc-windows-gnu",
|
||||
"datalayout": "e-m:w-p270:32:32-p271:32:32-p272:64:64-f80:128-n8:16:32:64-S128"
|
||||
},
|
||||
"options": {
|
||||
"slice_level": 3,
|
||||
"sha1_slice_level": 1,
|
||||
"target": "llvm",
|
||||
"strict_mode": true
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,395 @@
|
||||
import t, c
|
||||
from t import CInt, CInt32T, CUInt32T, CPtr, CChar, CExport
|
||||
from stdint import *
|
||||
import stdlib
|
||||
import viperlib
|
||||
import w32.win32base
|
||||
import w32.win32file
|
||||
import w32.win32console
|
||||
import w32.fileio
|
||||
from w32.fileio import File, FileW, MODE, FRESULT, SEEK_SET, SEEK_CUR, SEEK_END
|
||||
|
||||
|
||||
BUF_SIZE: t.CDefine = 4096
|
||||
|
||||
|
||||
def fileio_main():
|
||||
buf: bytes = stdlib.malloc(256)
|
||||
write_buf: bytes = stdlib.malloc(BUF_SIZE)
|
||||
read_buf: bytes = stdlib.malloc(BUF_SIZE)
|
||||
bytes_written: ULONG = 0
|
||||
bytes_read: ULONG = 0
|
||||
|
||||
w32.win32console.SetConsoleCP(65001)
|
||||
w32.win32console.SetConsoleOutputCP(65001)
|
||||
|
||||
hFile: w32.win32base.HANDLE = w32.win32file.CreateFileA(
|
||||
"testfile.txt",
|
||||
w32.win32file.GENERIC_WRITE,
|
||||
w32.win32file.FILE_SHARE_READ,
|
||||
None,
|
||||
w32.win32file.CREATE_ALWAYS,
|
||||
w32.win32file.FILE_ATTRIBUTE_NORMAL,
|
||||
None
|
||||
)
|
||||
|
||||
if hFile == w32.win32base.INVALID_HANDLE_VALUE:
|
||||
print("Failed to create file")
|
||||
return
|
||||
|
||||
viperlib.snprintf(write_buf, BUF_SIZE, "Hello from TransPyC Win32 FileIO!\nLine 2: %d + %d = %d\n", 10, 20, 30)
|
||||
write_len: ULONG = 0
|
||||
i: CInt = 0
|
||||
ch: bytes = write_buf
|
||||
while i < BUF_SIZE:
|
||||
if CInt(c.Deref(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)
|
||||
if result == 0:
|
||||
print("WriteFile failed")
|
||||
else:
|
||||
viperlib.snprintf(buf, 256, "Written %d bytes to testfile.txt", bytes_written)
|
||||
print(buf)
|
||||
|
||||
w32.win32file.FlushFileBuffers(hFile)
|
||||
w32.win32base.CloseHandle(hFile)
|
||||
|
||||
hFile = w32.win32file.CreateFileA(
|
||||
"testfile.txt",
|
||||
w32.win32file.GENERIC_READ,
|
||||
w32.win32file.FILE_SHARE_READ,
|
||||
None,
|
||||
w32.win32file.OPEN_EXISTING,
|
||||
w32.win32file.FILE_ATTRIBUTE_NORMAL,
|
||||
None
|
||||
)
|
||||
|
||||
if hFile == w32.win32base.INVALID_HANDLE_VALUE:
|
||||
print("Failed to open file for reading")
|
||||
return
|
||||
|
||||
read_len: ULONG = 0
|
||||
result = w32.win32file.ReadFile(hFile, read_buf, BUF_SIZE - 1, c.Addr(read_len), None)
|
||||
if result == 0:
|
||||
print("ReadFile failed")
|
||||
else:
|
||||
viperlib.snprintf(buf, 256, "Read %d bytes from testfile.txt", read_len)
|
||||
print(buf)
|
||||
|
||||
read_ptr: bytes = read_buf
|
||||
read_ptr = read_ptr + read_len
|
||||
c.DerefAs(read_ptr, 0)
|
||||
print("--- File content ---")
|
||||
print(read_buf)
|
||||
print("--- End ---")
|
||||
|
||||
fileSize: ULONG = w32.win32file.GetFileSize(hFile, None)
|
||||
viperlib.snprintf(buf, 256, "File size: %d bytes", fileSize)
|
||||
print(buf)
|
||||
|
||||
w32.win32base.CloseHandle(hFile)
|
||||
|
||||
attrs: ULONG = w32.win32file.GetFileAttributesA("testfile.txt")
|
||||
if attrs == w32.win32base.INVALID_HANDLE_VALUE:
|
||||
print("GetFileAttributes failed")
|
||||
else:
|
||||
viperlib.snprintf(buf, 256, "File attributes: 0x%X", attrs)
|
||||
print(buf)
|
||||
|
||||
w32.win32file.DeleteFileA("testfile.txt")
|
||||
print("File deleted")
|
||||
|
||||
stdlib.free(write_buf)
|
||||
stdlib.free(read_buf)
|
||||
|
||||
print("=== OOP FileIO: with context manager ===")
|
||||
fileio_with_test()
|
||||
|
||||
print("=== OOP FileIO: f handle style ===")
|
||||
fileio_handle_test()
|
||||
|
||||
print("=== OOP FileIO: RP/WP/AP modes ===")
|
||||
fileio_rw_test()
|
||||
|
||||
|
||||
def fileio_with_test():
|
||||
buf: bytes = stdlib.malloc(256)
|
||||
write_buf: bytes = stdlib.malloc(BUF_SIZE)
|
||||
read_buf: bytes = stdlib.malloc(BUF_SIZE)
|
||||
|
||||
with File("oop_with.txt", MODE.W) as f:
|
||||
viperlib.snprintf(write_buf, BUF_SIZE, "with context manager test!\nLine 2: %d\n", 42)
|
||||
n: LONG = f.write_str(write_buf)
|
||||
if n < 0:
|
||||
print("[with] write failed")
|
||||
else:
|
||||
viperlib.snprintf(buf, 256, "[with] wrote %d bytes", n)
|
||||
print(buf)
|
||||
|
||||
with File("oop_with.txt", MODE.R) as f:
|
||||
n = f.read_all(read_buf, BUF_SIZE)
|
||||
if n < 0:
|
||||
print("[with] read failed")
|
||||
else:
|
||||
viperlib.snprintf(buf, 256, "[with] read %d bytes", n)
|
||||
print(buf)
|
||||
print("[with] content:")
|
||||
print(read_buf)
|
||||
|
||||
with File("oop_with.txt", MODE.R) as f:
|
||||
line1_len: LONG = f.readline(buf, 256)
|
||||
viperlib.snprintf(read_buf, BUF_SIZE, "[with] Line1(%d): ", line1_len)
|
||||
print(read_buf)
|
||||
print(buf)
|
||||
line2_len: LONG = f.readline(buf, 256)
|
||||
viperlib.snprintf(read_buf, BUF_SIZE, "[with] Line2(%d): ", line2_len)
|
||||
print(read_buf)
|
||||
print(buf)
|
||||
|
||||
with File("oop_with.txt", MODE.A) as f:
|
||||
f.write_str("Appended line!\n")
|
||||
|
||||
with File("oop_with.txt", MODE.R) as f:
|
||||
n = f.read_all(read_buf, BUF_SIZE)
|
||||
print("[with] after append:")
|
||||
print(read_buf)
|
||||
|
||||
with File("oop_with.txt", MODE.R) as f:
|
||||
sz: LONGLONG = f.size()
|
||||
pos: LONG = f.tell()
|
||||
viperlib.snprintf(buf, 256, "[with] Size=%lld Pos=%d", sz, pos)
|
||||
print(buf)
|
||||
f.seek(5, SEEK_SET)
|
||||
pos = f.tell()
|
||||
viperlib.snprintf(buf, 256, "[with] After seek: Pos=%d", pos)
|
||||
print(buf)
|
||||
|
||||
w32.win32file.DeleteFileA("oop_with.txt")
|
||||
print("[with] test file deleted")
|
||||
|
||||
stdlib.free(buf)
|
||||
stdlib.free(write_buf)
|
||||
stdlib.free(read_buf)
|
||||
|
||||
|
||||
def fileio_handle_test():
|
||||
buf: bytes = stdlib.malloc(256)
|
||||
write_buf: bytes = stdlib.malloc(BUF_SIZE)
|
||||
read_buf: bytes = stdlib.malloc(BUF_SIZE)
|
||||
|
||||
fw: File = File("oop_handle.txt", MODE.W)
|
||||
viperlib.snprintf(write_buf, BUF_SIZE, "f handle style test!\nLine 2: %d\n", 99)
|
||||
n: LONG = fw.write_str(write_buf)
|
||||
viperlib.snprintf(buf, 256, "[handle] wrote %d bytes", n)
|
||||
print(buf)
|
||||
fw.flush()
|
||||
fw.close()
|
||||
|
||||
fr: File = File("oop_handle.txt", MODE.R)
|
||||
n = fr.read_all(read_buf, BUF_SIZE)
|
||||
viperlib.snprintf(buf, 256, "[handle] read %d bytes", n)
|
||||
print(buf)
|
||||
print("[handle] content:")
|
||||
print(read_buf)
|
||||
fr.close()
|
||||
|
||||
fr2: File = File("oop_handle.txt", MODE.R)
|
||||
line1_len: LONG = fr2.readline(buf, 256)
|
||||
viperlib.snprintf(read_buf, BUF_SIZE, "[handle] Line1(%d): ", line1_len)
|
||||
print(read_buf)
|
||||
print(buf)
|
||||
line2_len: LONG = fr2.readline(buf, 256)
|
||||
viperlib.snprintf(read_buf, BUF_SIZE, "[handle] Line2(%d): ", line2_len)
|
||||
print(read_buf)
|
||||
print(buf)
|
||||
fr2.close()
|
||||
|
||||
fa: File = File("oop_handle.txt", MODE.A)
|
||||
fa.write_str("Appended by handle!\n")
|
||||
fa.close()
|
||||
|
||||
fr3: File = File("oop_handle.txt", MODE.R)
|
||||
n = fr3.read_all(read_buf, BUF_SIZE)
|
||||
print("[handle] after append:")
|
||||
print(read_buf)
|
||||
fr3.close()
|
||||
|
||||
fr4: File = File("oop_handle.txt", MODE.R)
|
||||
sz: LONGLONG = fr4.size()
|
||||
pos: LONG = fr4.tell()
|
||||
viperlib.snprintf(buf, 256, "[handle] Size=%lld Pos=%d", sz, pos)
|
||||
print(buf)
|
||||
fr4.seek(5, SEEK_SET)
|
||||
pos = fr4.tell()
|
||||
viperlib.snprintf(buf, 256, "[handle] After seek: Pos=%d", pos)
|
||||
print(buf)
|
||||
fr4.close()
|
||||
|
||||
w32.win32file.DeleteFileA("oop_handle.txt")
|
||||
print("[handle] test file deleted")
|
||||
|
||||
stdlib.free(buf)
|
||||
stdlib.free(write_buf)
|
||||
stdlib.free(read_buf)
|
||||
|
||||
|
||||
def fileio_rw_test():
|
||||
buf: bytes = stdlib.malloc(256)
|
||||
|
||||
fw: File = File("rw_test.txt", MODE.W)
|
||||
fw.write_str("original content\n")
|
||||
fw.close()
|
||||
|
||||
frp: File = File("rw_test.txt", MODE.RP)
|
||||
n: LONG = frp.read_all(buf, 256)
|
||||
viperlib.snprintf(buf, 256, "[rp] read %d bytes", n)
|
||||
print(buf)
|
||||
|
||||
frp.seek(0, SEEK_END)
|
||||
frp.write_str("appended via RP\n")
|
||||
frp.seek(0, SEEK_SET)
|
||||
n = frp.read_all(buf, 256)
|
||||
print("[rp] after RP append:")
|
||||
print(buf)
|
||||
frp.close()
|
||||
|
||||
fwp: File = File("rw_test.txt", MODE.WP)
|
||||
fwp.write_str("truncated + new\n")
|
||||
fwp.seek(0, SEEK_SET)
|
||||
n = fwp.read_all(buf, 256)
|
||||
print("[wp] WP (truncate+read):")
|
||||
print(buf)
|
||||
fwp.close()
|
||||
|
||||
fap: File = File("rw_test.txt", MODE.AP)
|
||||
fap.write_str("a+ appended\n")
|
||||
fap.seek(0, SEEK_SET)
|
||||
n = fap.read_all(buf, 256)
|
||||
print("[ap] AP (append+read):")
|
||||
print(buf)
|
||||
fap.close()
|
||||
|
||||
w32.win32file.DeleteFileA("rw_test.txt")
|
||||
print("[rw] test file deleted")
|
||||
|
||||
print("=== OOP FileIO: wide char (u\"...\") ===")
|
||||
fileio_wide_test()
|
||||
|
||||
stdlib.free(buf)
|
||||
|
||||
|
||||
def fileio_wide_test():
|
||||
buf: bytes = stdlib.malloc(256)
|
||||
|
||||
fw: File = File("wide_test.txt", MODE.W)
|
||||
fw.write_str("wide char test\n")
|
||||
fw.close()
|
||||
|
||||
fw2: FileW = FileW(u"wide_test.txt", MODE.R)
|
||||
n: LONG = fw2.read_all(buf, 256)
|
||||
viperlib.snprintf(buf, 256, "[wide] read %d bytes", n)
|
||||
print(buf)
|
||||
fw2.close()
|
||||
|
||||
w32.win32file.DeleteFileA("wide_test.txt")
|
||||
print("[wide] test file deleted")
|
||||
|
||||
stdlib.free(buf)
|
||||
|
||||
print("=== OOP FileIO: Chinese filename & content (u\"...\" = WCHAR_T) ===")
|
||||
fileio_chinese_test()
|
||||
|
||||
|
||||
def fileio_chinese_test():
|
||||
buf: bytes = stdlib.malloc(512)
|
||||
bytes_written: ULONG = 0
|
||||
|
||||
# === T1: Chinese filename (WCHAR_T) + ANSI content ===
|
||||
print("[chinese] T1: Chinese filename + ANSI content")
|
||||
fw: FileW = FileW(u"中文文件.txt", MODE.W)
|
||||
if fw.closed:
|
||||
print("[chinese] T1: create failed")
|
||||
else:
|
||||
fw.write_str("Hello from Chinese filename!\n")
|
||||
fw.close()
|
||||
|
||||
fr: FileW = FileW(u"中文文件.txt", MODE.R)
|
||||
n: LONG = fr.read_all(buf, 512)
|
||||
viperlib.snprintf(buf, 256, "[chinese] T1: read %d bytes", n)
|
||||
print(buf)
|
||||
print("[chinese] T1 content:")
|
||||
print(buf)
|
||||
fr.close()
|
||||
|
||||
w32.win32file.DeleteFileW(u"中文文件.txt")
|
||||
print("[chinese] T1: deleted")
|
||||
|
||||
# === T2: Chinese filename + Chinese wide content (WCHAR_T) ===
|
||||
print("[chinese] T2: Chinese filename + Chinese wide content")
|
||||
fw2: FileW = FileW(u"中文内容.txt", MODE.W)
|
||||
if fw2.closed:
|
||||
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)
|
||||
viperlib.snprintf(buf, 256, "[chinese] T2: wrote %d WCHAR bytes", bytes_written)
|
||||
print(buf)
|
||||
fw2.close()
|
||||
|
||||
fr2: FileW = FileW(u"中文内容.txt", MODE.R)
|
||||
n = fr2.read_all(buf, 512)
|
||||
viperlib.snprintf(buf, 256, "[chinese] T2: read %d bytes (UTF-16LE)", n)
|
||||
print(buf)
|
||||
fr2.close()
|
||||
|
||||
w32.win32file.DeleteFileW(u"中文内容.txt")
|
||||
print("[chinese] T2: deleted")
|
||||
|
||||
# === T3: Chinese filename + mixed ANSI + wide content ===
|
||||
print("[chinese] T3: Chinese filename + mixed content")
|
||||
fw3: FileW = FileW(u"混合测试.txt", MODE.WP)
|
||||
if fw3.closed:
|
||||
print("[chinese] T3: create failed")
|
||||
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)
|
||||
fw3.seek(0, SEEK_SET)
|
||||
n: LONG = fw3.read_all(buf, 512)
|
||||
viperlib.snprintf(buf, 256, "[chinese] T3: total %d bytes", n)
|
||||
print(buf)
|
||||
fw3.close()
|
||||
|
||||
w32.win32file.DeleteFileW(u"混合测试.txt")
|
||||
print("[chinese] T3: deleted")
|
||||
|
||||
# === T4: Chinese filename + Chinese content via WriteConsoleW ===
|
||||
print("[chinese] T4: Write wide content and print via WriteConsoleW")
|
||||
fw4: FileW = FileW(u"控制台测试.txt", MODE.W)
|
||||
if fw4.closed:
|
||||
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)
|
||||
viperlib.snprintf(buf, 256, "[chinese] T4: wrote %d WCHAR bytes", bytes_written)
|
||||
print(buf)
|
||||
fw4.close()
|
||||
|
||||
fr4: FileW = FileW(u"控制台测试.txt", MODE.R)
|
||||
n = fr4.read_all(buf, 512)
|
||||
viperlib.snprintf(buf, 256, "[chinese] T4: read %d bytes", n)
|
||||
print(buf)
|
||||
# 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)
|
||||
fr4.close()
|
||||
|
||||
w32.win32file.DeleteFileW(u"控制台测试.txt")
|
||||
print("[chinese] T4: deleted")
|
||||
|
||||
stdlib.free(buf)
|
||||
@@ -0,0 +1,11 @@
|
||||
import t, c
|
||||
import testcheck
|
||||
import fileiotest
|
||||
|
||||
|
||||
def main() -> t.CInt | t.CExport:
|
||||
testcheck.begin("FileIoTest: Win32 FileIO 测试")
|
||||
testcheck.section("Win32 FileIO")
|
||||
fileiotest.fileio_main()
|
||||
testcheck.ok("Win32 FileIO 测试完成")
|
||||
return testcheck.end()
|
||||
@@ -0,0 +1,29 @@
|
||||
{
|
||||
"$schema": "https://raw.githubusercontent.com/TermiNexus/TransPyC/main/schemas/project-schema.json",
|
||||
"name": "FileIoTest",
|
||||
"version": "1.0.0",
|
||||
"source_dir": "./App",
|
||||
"build_dir": "./.tpv_build",
|
||||
"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": "FileIoTest.exe"
|
||||
},
|
||||
"includes": [
|
||||
"../../includes"
|
||||
],
|
||||
"target": {
|
||||
"triple": "x86_64-pc-windows-gnu",
|
||||
"datalayout": "e-m:w-p270:32:32-p271:32:32-p272:64:64-f80:128-n8:16:32:64-S128"
|
||||
},
|
||||
"options": {
|
||||
"slice_level": 3,
|
||||
"sha1_slice_level": 1,
|
||||
"target": "llvm",
|
||||
"strict_mode": true
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,490 @@
|
||||
from stdint import *
|
||||
import w32.win32console
|
||||
import t, c
|
||||
from t import CInt, CPtr, CChar, CInt32T, CUInt64T, CFloat64T, CExport, State
|
||||
import viperlib
|
||||
import stdlib
|
||||
import testcheck
|
||||
|
||||
|
||||
# === 函数泛型 ===
|
||||
|
||||
def add[T](a: T, b: T) -> T:
|
||||
return a + b
|
||||
|
||||
def add_u64[T](a: T, b: T, c: CUInt64T) -> T:
|
||||
return a + b + T(c)
|
||||
|
||||
def fxi[T1, T2](a: T1, b: T2) -> T1:
|
||||
return a + fxi2(a, b, CUInt64T(178900))
|
||||
|
||||
def fxi2[T1, T2, T3](a: T1, b: T2, c: T3) -> T1:
|
||||
return a + T1(b) + T1(c)
|
||||
|
||||
def wrap_add[T](a: T, b: T) -> T:
|
||||
return add(a, b)
|
||||
|
||||
def double_add[T](a: T, b: T) -> T:
|
||||
return add(a, b) + add(a, b)
|
||||
|
||||
|
||||
# === 结构体泛型 ===
|
||||
|
||||
class A[T]():
|
||||
def __init__(self, a: T):
|
||||
self.a = T(a)
|
||||
def get_a(self) -> T:
|
||||
return self.a
|
||||
|
||||
class Pair[T1, T2]():
|
||||
def __init__(self, first: T1, second: T2):
|
||||
self.first = T1(first)
|
||||
self.second = T2(second)
|
||||
def get_first(self) -> T1:
|
||||
return self.first
|
||||
def get_second(self) -> T2:
|
||||
return self.second
|
||||
|
||||
class Calculator[T]():
|
||||
def __init__(self, init_val: T):
|
||||
self.val = T(init_val)
|
||||
def compute(self, other: T) -> T:
|
||||
return add(self.val, other)
|
||||
def double_compute(self, other: T) -> T:
|
||||
return double_add(self.val, other)
|
||||
|
||||
class Container[T]():
|
||||
def __init__(self, v: T):
|
||||
self.value = T(v)
|
||||
self.flag = CInt32T(1)
|
||||
def get_value(self) -> T:
|
||||
return self.value
|
||||
def get_flag(self) -> CInt32T:
|
||||
return self.flag
|
||||
|
||||
|
||||
# === OOP 继承 + 虚方法 ===
|
||||
|
||||
@t.CVTable
|
||||
class Shape:
|
||||
def __init__(self, x: CFloat64T, y: CFloat64T):
|
||||
self.x = x
|
||||
self.y = y
|
||||
def area(self) -> CFloat64T:
|
||||
return 0.0
|
||||
def perimeter(self) -> CFloat64T:
|
||||
return 0.0
|
||||
def describe(self) -> CFloat64T:
|
||||
return self.area() + self.perimeter()
|
||||
|
||||
@t.CVTable
|
||||
class Circle(Shape):
|
||||
def __init__(self, x: CFloat64T, y: CFloat64T, r: CFloat64T):
|
||||
self.x = x
|
||||
self.y = y
|
||||
self.r = r
|
||||
def area(self) -> CFloat64T:
|
||||
return 3.14159265 * self.r * self.r
|
||||
def perimeter(self) -> CFloat64T:
|
||||
return 2.0 * 3.14159265 * self.r
|
||||
def scale(self, factor: CFloat64T) -> 'Circle' | CPtr:
|
||||
self.r = self.r * factor
|
||||
return t.CVoid(c.Addr(self), CPtr)
|
||||
def move(self, dx: CFloat64T, dy: CFloat64T) -> 'Circle' | CPtr:
|
||||
self.x = self.x + dx
|
||||
self.y = self.y + dy
|
||||
return t.CVoid(c.Addr(self), CPtr)
|
||||
|
||||
@t.CVTable
|
||||
class Rect(Shape):
|
||||
def __init__(self, x: CFloat64T, y: CFloat64T, w: CFloat64T, h: CFloat64T):
|
||||
self.x = x
|
||||
self.y = y
|
||||
self.w = w
|
||||
self.h = h
|
||||
def area(self) -> CFloat64T:
|
||||
return self.w * self.h
|
||||
def perimeter(self) -> CFloat64T:
|
||||
return 2.0 * (self.w + self.h)
|
||||
def scale(self, factor: CFloat64T) -> 'Rect' | CPtr:
|
||||
self.w = self.w * factor
|
||||
self.h = self.h * factor
|
||||
return t.CVoid(c.Addr(self), CPtr)
|
||||
|
||||
|
||||
# === 运算符重载 + 链式调用（堆分配） ===
|
||||
|
||||
class Vec2:
|
||||
x: CFloat64T
|
||||
y: CFloat64T
|
||||
|
||||
def __new__() -> 'Vec2' | CPtr:
|
||||
return t.CVoid(t.CUInt64T(stdlib.malloc(16)), CPtr)
|
||||
|
||||
def __init__(self, x: CFloat64T, y: CFloat64T):
|
||||
self.x = x
|
||||
self.y = y
|
||||
|
||||
def __add__(self, b: 'Vec2' | CPtr) -> 'Vec2' | CPtr:
|
||||
return Vec2(self.x + b.x, self.y + b.y)
|
||||
|
||||
def __sub__(self, b: 'Vec2' | CPtr) -> 'Vec2' | CPtr:
|
||||
return Vec2(self.x - b.x, self.y - b.y)
|
||||
|
||||
def __mul__(self, s: CFloat64T) -> 'Vec2' | CPtr:
|
||||
return Vec2(self.x * s, self.y * s)
|
||||
|
||||
def __neg__(self) -> 'Vec2' | CPtr:
|
||||
return Vec2(-self.x, -self.y)
|
||||
|
||||
def dot(self, b: 'Vec2' | CPtr) -> CFloat64T:
|
||||
return self.x * b.x + self.y * b.y
|
||||
|
||||
def len_sq(self) -> CFloat64T:
|
||||
return self.x * self.x + self.y * self.y
|
||||
|
||||
|
||||
class Vec3:
|
||||
x: CFloat64T
|
||||
y: CFloat64T
|
||||
z: CFloat64T
|
||||
|
||||
def __new__() -> 'Vec3' | CPtr:
|
||||
return t.CVoid(t.CUInt64T(stdlib.malloc(24)), CPtr)
|
||||
|
||||
def __init__(self, x: CFloat64T, y: CFloat64T, z: CFloat64T):
|
||||
self.x = x
|
||||
self.y = y
|
||||
self.z = z
|
||||
|
||||
def __add__(self, b: 'Vec3' | CPtr) -> 'Vec3' | CPtr:
|
||||
return Vec3(self.x + b.x, self.y + b.y, self.z + b.z)
|
||||
|
||||
def __sub__(self, b: 'Vec3' | CPtr) -> 'Vec3' | CPtr:
|
||||
return Vec3(self.x - b.x, self.y - b.y, self.z - b.z)
|
||||
|
||||
def __mul__(self, s: CFloat64T) -> 'Vec3' | CPtr:
|
||||
return Vec3(self.x * s, self.y * s, self.z * s)
|
||||
|
||||
def __neg__(self) -> 'Vec3' | CPtr:
|
||||
return Vec3(-self.x, -self.y, -self.z)
|
||||
|
||||
def dot(self, b: 'Vec3' | CPtr) -> CFloat64T:
|
||||
return self.x * b.x + self.y * b.y + self.z * b.z
|
||||
|
||||
def cross(self, b: 'Vec3' | CPtr) -> 'Vec3' | CPtr:
|
||||
return Vec3(self.y * b.z - self.z * b.y,
|
||||
self.z * b.x - self.x * b.z,
|
||||
self.x * b.y - self.y * b.x)
|
||||
|
||||
def len_sq(self) -> CFloat64T:
|
||||
return self.dot(self)
|
||||
|
||||
|
||||
# === 独立类（非继承） ===
|
||||
|
||||
@t.CVTable
|
||||
class Dog:
|
||||
def __init__(self, name_val: CInt, bark_power: CInt32T):
|
||||
self.name_val = name_val
|
||||
self.health = CInt32T(100)
|
||||
self.bark_power = bark_power
|
||||
def speak(self) -> CInt:
|
||||
return 1
|
||||
def bite(self) -> CInt32T:
|
||||
return self.bark_power
|
||||
def take_damage(self, dmg: CInt32T) -> 'Dog' | CPtr:
|
||||
self.health = self.health - dmg
|
||||
return t.CVoid(c.Addr(self), CPtr)
|
||||
def is_alive(self) -> CInt:
|
||||
if self.health > 0:
|
||||
return 1
|
||||
return 0
|
||||
|
||||
@t.CVTable
|
||||
class Cat:
|
||||
def __init__(self, name_val: CInt, lives: CInt32T):
|
||||
self.name_val = name_val
|
||||
self.health = CInt32T(80)
|
||||
self.lives = lives
|
||||
def speak(self) -> CInt:
|
||||
return 2
|
||||
def scratch(self) -> CInt32T:
|
||||
return CInt32T(15)
|
||||
def take_damage(self, dmg: CInt32T) -> 'Cat' | CPtr:
|
||||
self.health = self.health - dmg
|
||||
return t.CVoid(c.Addr(self), CPtr)
|
||||
def is_alive(self) -> CInt:
|
||||
if self.health > 0:
|
||||
return 1
|
||||
return 0
|
||||
|
||||
|
||||
# === 嵌套对象组合（堆分配） ===
|
||||
|
||||
class Transform:
|
||||
px: CFloat64T
|
||||
py: CFloat64T
|
||||
pz: CFloat64T
|
||||
scale_x: CFloat64T
|
||||
scale_y: CFloat64T
|
||||
scale_z: CFloat64T
|
||||
|
||||
def __new__() -> 'Transform' | CPtr:
|
||||
return t.CVoid(t.CUInt64T(stdlib.malloc(48)), CPtr)
|
||||
|
||||
def __init__(self, px: CFloat64T, py: CFloat64T, pz: CFloat64T):
|
||||
self.px = px
|
||||
self.py = py
|
||||
self.pz = pz
|
||||
self.scale_x = 1.0
|
||||
self.scale_y = 1.0
|
||||
self.scale_z = 1.0
|
||||
|
||||
def apply_scale(self, sx: CFloat64T, sy: CFloat64T, sz: CFloat64T) -> 'Transform' | CPtr:
|
||||
self.scale_x = self.scale_x * sx
|
||||
self.scale_y = self.scale_y * sy
|
||||
self.scale_z = self.scale_z * sz
|
||||
return t.CVoid(c.Addr(self), CPtr)
|
||||
|
||||
def world_position(self) -> 'Vec3' | CPtr:
|
||||
return Vec3(self.px * self.scale_x, self.py * self.scale_y, self.pz * self.scale_z)
|
||||
|
||||
|
||||
# === 多层继承（子类只重写需要的方法） ===
|
||||
|
||||
@t.CVTable
|
||||
class Vehicle:
|
||||
def __init__(self, speed: CInt32T):
|
||||
self.speed = speed
|
||||
self.fuel = CInt32T(100)
|
||||
def move(self) -> CInt:
|
||||
self.fuel = self.fuel - CInt32T(10)
|
||||
return self.speed
|
||||
def is_running(self) -> CInt:
|
||||
if self.fuel > 0:
|
||||
return 1
|
||||
return 0
|
||||
|
||||
@t.CVTable
|
||||
class Car(Vehicle):
|
||||
def __init__(self, speed: CInt32T, doors: CInt32T):
|
||||
self.speed = speed
|
||||
self.fuel = CInt32T(100)
|
||||
self.doors = doors
|
||||
def honk(self) -> CInt:
|
||||
return 1
|
||||
|
||||
@t.CVTable
|
||||
class ElectricCar(Car):
|
||||
def __init__(self, speed: CInt32T, doors: CInt32T, battery: CInt32T):
|
||||
self.speed = speed
|
||||
self.fuel = CInt32T(100)
|
||||
self.doors = doors
|
||||
self.battery = battery
|
||||
def charge(self):
|
||||
self.battery = self.battery + CInt32T(20)
|
||||
def move(self) -> CInt:
|
||||
self.battery = self.battery - CInt32T(5)
|
||||
return self.speed
|
||||
|
||||
|
||||
def main() -> CInt | CExport:
|
||||
w32.win32console.SetConsoleCP(65001)
|
||||
w32.win32console.SetConsoleOutputCP(65001)
|
||||
|
||||
testcheck.begin("GenericOopTest: 泛型与OOP综合测试")
|
||||
|
||||
buf: CChar | CPtr = CPtr(stdlib.malloc(256))
|
||||
|
||||
# === 基础函数泛型 ===
|
||||
testcheck.section("基础函数泛型")
|
||||
print(add(3, 5))
|
||||
print(add(1.5, 2.5))
|
||||
print(add_u64(1, 2, CUInt64T(3000000000000000)))
|
||||
print(fxi(0.2, 6))
|
||||
print(wrap_add(10, 20))
|
||||
print(double_add(5, 7))
|
||||
testcheck.ok("基础函数泛型测试完成")
|
||||
|
||||
# === 基础结构体泛型 ===
|
||||
testcheck.section("基础结构体泛型")
|
||||
a = A(100)
|
||||
print(a.get_a())
|
||||
p1 = Pair(10, 20)
|
||||
print(p1.get_first())
|
||||
print(p1.get_second())
|
||||
testcheck.ok("基础结构体泛型测试完成")
|
||||
|
||||
# === OOP 继承测试 ===
|
||||
testcheck.section("OOP 继承测试")
|
||||
c1 = Circle(0.0, 0.0, 5.0)
|
||||
viperlib.snprintf(buf, 256, "Circle area=%.2f perim=%.2f", c1.area(), c1.perimeter())
|
||||
print(buf)
|
||||
|
||||
r1 = Rect(0.0, 0.0, 4.0, 3.0)
|
||||
viperlib.snprintf(buf, 256, "Rect area=%.2f perim=%.2f", r1.area(), r1.perimeter())
|
||||
print(buf)
|
||||
|
||||
# 链式调用: scale -> move
|
||||
c2 = Circle(1.0, 2.0, 3.0)
|
||||
c2.scale(2.0).move(10.0, 20.0)
|
||||
viperlib.snprintf(buf, 256, "Circle after scale+move: x=%.1f y=%.1f r=%.1f area=%.2f",
|
||||
c2.x, c2.y, c2.r, c2.area())
|
||||
print(buf)
|
||||
|
||||
r2 = Rect(0.0, 0.0, 10.0, 5.0)
|
||||
r2.scale(2.0).scale(0.5)
|
||||
viperlib.snprintf(buf, 256, "Rect after double scale: w=%.1f h=%.1f area=%.2f",
|
||||
r2.w, r2.h, r2.area())
|
||||
print(buf)
|
||||
testcheck.ok("OOP 继承测试完成")
|
||||
|
||||
# === Vec2 运算符重载 + 链式调用（堆分配） ===
|
||||
testcheck.section("Vec2 运算符重载 + 链式调用")
|
||||
v1 = Vec2(3.0, 4.0)
|
||||
v2 = Vec2(1.0, 2.0)
|
||||
v3 = v1 + v2
|
||||
viperlib.snprintf(buf, 256, "Vec2 add: (%.1f, %.1f)", v3.x, v3.y)
|
||||
print(buf)
|
||||
|
||||
v4 = v1 - v2
|
||||
viperlib.snprintf(buf, 256, "Vec2 sub: (%.1f, %.1f)", v4.x, v4.y)
|
||||
print(buf)
|
||||
|
||||
v5 = v1 * 2.0
|
||||
viperlib.snprintf(buf, 256, "Vec2 mul: (%.1f, %.1f)", v5.x, v5.y)
|
||||
print(buf)
|
||||
|
||||
v6 = -v1
|
||||
viperlib.snprintf(buf, 256, "Vec2 neg: (%.1f, %.1f)", v6.x, v6.y)
|
||||
print(buf)
|
||||
|
||||
d = v1.dot(v2)
|
||||
viperlib.snprintf(buf, 256, "Vec2 dot: %.1f", d)
|
||||
print(buf)
|
||||
|
||||
# 链式运算: (v1 + v2) * 3.0
|
||||
v_chain = (v1 + v2) * 3.0
|
||||
viperlib.snprintf(buf, 256, "Vec2 chain (v1+v2)*3: (%.1f, %.1f)", v_chain.x, v_chain.y)
|
||||
print(buf)
|
||||
testcheck.ok("Vec2 运算符重载测试完成")
|
||||
|
||||
# === Vec3 运算符重载 + 链式调用（堆分配） ===
|
||||
testcheck.section("Vec3 运算符重载 + 链式调用")
|
||||
a1 = Vec3(1.0, 0.0, 0.0)
|
||||
a2 = Vec3(0.0, 1.0, 0.0)
|
||||
cross_v = a1.cross(a2)
|
||||
viperlib.snprintf(buf, 256, "Vec3 cross: (%.1f, %.1f, %.1f)", cross_v.x, cross_v.y, cross_v.z)
|
||||
print(buf)
|
||||
|
||||
dot_v = a1.dot(a2)
|
||||
viperlib.snprintf(buf, 256, "Vec3 dot: %.1f", dot_v)
|
||||
print(buf)
|
||||
|
||||
# 链式: (a + b).dot(c)
|
||||
a3 = Vec3(1.0, 2.0, 3.0)
|
||||
a4 = Vec3(4.0, 5.0, 6.0)
|
||||
a5 = Vec3(7.0, 8.0, 9.0)
|
||||
chain_dot = (a3 + a4).dot(a5)
|
||||
viperlib.snprintf(buf, 256, "Vec3 chain dot: %.1f", chain_dot)
|
||||
print(buf)
|
||||
|
||||
# 链式: (a * 2.0 - b).cross(c)
|
||||
chain_cross = (a3 * 2.0 - a4).cross(a5)
|
||||
viperlib.snprintf(buf, 256, "Vec3 chain cross: (%.1f, %.1f, %.1f)", chain_cross.x, chain_cross.y, chain_cross.z)
|
||||
print(buf)
|
||||
|
||||
# len_sq 链式
|
||||
lsq = a3.len_sq()
|
||||
viperlib.snprintf(buf, 256, "Vec3 len_sq: %.1f", lsq)
|
||||
print(buf)
|
||||
testcheck.ok("Vec3 运算符重载测试完成")
|
||||
|
||||
# === Dog/Cat 虚方法 ===
|
||||
testcheck.section("Dog/Cat 虚方法")
|
||||
dog = Dog(1, CInt32T(30))
|
||||
cat = Cat(2, CInt32T(9))
|
||||
|
||||
viperlib.snprintf(buf, 256, "Dog speak=%d bite=%d alive=%d", dog.speak(), dog.bite(), dog.is_alive())
|
||||
print(buf)
|
||||
viperlib.snprintf(buf, 256, "Cat speak=%d scratch=%d alive=%d", cat.speak(), cat.scratch(), cat.is_alive())
|
||||
print(buf)
|
||||
|
||||
dog.take_damage(CInt32T(40)).take_damage(CInt32T(30))
|
||||
viperlib.snprintf(buf, 256, "Dog after 70dmg: health=%d alive=%d", dog.health, dog.is_alive())
|
||||
print(buf)
|
||||
|
||||
cat.take_damage(CInt32T(50))
|
||||
viperlib.snprintf(buf, 256, "Cat after 50dmg: health=%d alive=%d", cat.health, cat.is_alive())
|
||||
print(buf)
|
||||
testcheck.ok("Dog/Cat 虚方法测试完成")
|
||||
|
||||
# === Transform 嵌套组合（堆分配，链式调用） ===
|
||||
testcheck.section("Transform 嵌套组合")
|
||||
tr = Transform(10.0, 20.0, 30.0)
|
||||
tr.apply_scale(2.0, 3.0, 4.0)
|
||||
pos = tr.world_position()
|
||||
viperlib.snprintf(buf, 256, "Transform pos: (%.1f, %.1f, %.1f)", pos.x, pos.y, pos.z)
|
||||
print(buf)
|
||||
|
||||
tr2 = Transform(5.0, 10.0, 15.0)
|
||||
tr2.apply_scale(2.0, 2.0, 2.0)
|
||||
pos2 = tr2.world_position()
|
||||
viperlib.snprintf(buf, 256, "Transform2 pos: (%.1f, %.1f, %.1f)", pos2.x, pos2.y, pos2.z)
|
||||
print(buf)
|
||||
testcheck.ok("Transform 嵌套组合测试完成")
|
||||
|
||||
# === 多层继承 ===
|
||||
testcheck.section("多层继承")
|
||||
ec = ElectricCar(CInt32T(120), CInt32T(4), CInt32T(80))
|
||||
viperlib.snprintf(buf, 256, "ECar speed=%d doors=%d battery=%d", ec.speed, ec.doors, ec.battery)
|
||||
print(buf)
|
||||
ec.charge()
|
||||
viperlib.snprintf(buf, 256, "ECar after charge: battery=%d", ec.battery)
|
||||
print(buf)
|
||||
spd = ec.move()
|
||||
viperlib.snprintf(buf, 256, "ECar move: speed=%d battery=%d", spd, ec.battery)
|
||||
print(buf)
|
||||
viperlib.snprintf(buf, 256, "ECar honk=%d running=%d", ec.honk(), ec.is_running())
|
||||
print(buf)
|
||||
testcheck.ok("多层继承测试完成")
|
||||
|
||||
# === 泛型 + OOP 组合 ===
|
||||
testcheck.section("泛型 + OOP 组合")
|
||||
calc1 = Calculator(10)
|
||||
print(calc1.compute(5))
|
||||
calc2 = Calculator(1.5)
|
||||
print(calc2.compute(2.5))
|
||||
|
||||
c1_gen = Container(42)
|
||||
print(c1_gen.get_value())
|
||||
print(c1_gen.get_flag())
|
||||
testcheck.ok("泛型 + OOP 组合测试完成")
|
||||
|
||||
# === snprintf 格式化 ===
|
||||
testcheck.section("snprintf 格式化")
|
||||
viperlib.snprintf(buf, 256, "int=%d, float=%.2f", 42, 3.14)
|
||||
print(buf)
|
||||
viperlib.snprintf(buf, 256, "result=%d", add(100, 200))
|
||||
print(buf)
|
||||
testcheck.ok("snprintf 格式化测试完成")
|
||||
|
||||
# === 新语法类型强转 (t1|t2)(x) ===
|
||||
testcheck.section("新语法类型强转 (t1|t2)(x)")
|
||||
val_i64: CUInt64T = CUInt64T(42)
|
||||
val_i32 = (t.CInt)(val_i64)
|
||||
print(val_i32)
|
||||
|
||||
ptr_raw = stdlib.malloc(8)
|
||||
ptr_typed = (t.CInt | t.CPtr)(ptr_raw)
|
||||
viperlib.snprintf(buf, 256, "cast ptr=%p", ptr_typed)
|
||||
print(buf)
|
||||
|
||||
val_f = (t.CDouble)(42)
|
||||
viperlib.snprintf(buf, 256, "cast float=%.1f", val_f)
|
||||
print(buf)
|
||||
testcheck.ok("新语法类型强转测试完成")
|
||||
|
||||
stdlib.free(buf)
|
||||
return testcheck.end()
|
||||
@@ -0,0 +1,29 @@
|
||||
{
|
||||
"$schema": "https://raw.githubusercontent.com/TermiNexus/TransPyC/main/schemas/project-schema.json",
|
||||
"name": "GenericOopTest",
|
||||
"version": "1.0.0",
|
||||
"source_dir": "./App",
|
||||
"build_dir": "./.tpv_build",
|
||||
"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": "GenericOopTest.exe"
|
||||
},
|
||||
"includes": [
|
||||
"../../includes"
|
||||
],
|
||||
"target": {
|
||||
"triple": "x86_64-pc-windows-gnu",
|
||||
"datalayout": "e-m:w-p270:32:32-p271:32:32-p272:64:64-f80:128-n8:16:32:64-S128"
|
||||
},
|
||||
"options": {
|
||||
"slice_level": 3,
|
||||
"sha1_slice_level": 1,
|
||||
"target": "llvm",
|
||||
"strict_mode": true
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,26 @@
|
||||
import t, c
|
||||
import testcheck
|
||||
import hashlib
|
||||
import binascii
|
||||
import w32.win32console
|
||||
|
||||
|
||||
def main() -> t.CInt | t.CExport:
|
||||
w32.win32console.SetConsoleCP(65001)
|
||||
w32.win32console.SetConsoleOutputCP(65001)
|
||||
|
||||
testcheck.begin("HashLibTest: 哈希与校验测试")
|
||||
|
||||
testcheck.section("HASHLIB")
|
||||
md5_buf: t.CArray[t.CUInt8T, hashlib.MD5_DIGEST_LEN]
|
||||
mctx = hashlib.md5()
|
||||
mctx.update("hello")
|
||||
mctx.final(md5_buf)
|
||||
testcheck.ok("HASHLIB md5 completed")
|
||||
|
||||
testcheck.section("BINASCII")
|
||||
binascii.init_binascii()
|
||||
crc_val: t.CUnsignedInt = binascii.crc32("hello", 5, 0)
|
||||
testcheck.ok("BINASCII crc32 completed")
|
||||
|
||||
return testcheck.end()
|
||||
@@ -0,0 +1,29 @@
|
||||
{
|
||||
"$schema": "https://raw.githubusercontent.com/TermiNexus/TransPyC/main/schemas/project-schema.json",
|
||||
"name": "HashLibTest",
|
||||
"version": "1.0.0",
|
||||
"source_dir": "./App",
|
||||
"build_dir": "./.tpv_build",
|
||||
"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": "HashLibTest.exe"
|
||||
},
|
||||
"includes": [
|
||||
"../../includes"
|
||||
],
|
||||
"target": {
|
||||
"triple": "x86_64-pc-windows-gnu",
|
||||
"datalayout": "e-m:w-p270:32:32-p271:32:32-p272:64:64-f80:128-n8:16:32:64-S128"
|
||||
},
|
||||
"options": {
|
||||
"slice_level": 3,
|
||||
"sha1_slice_level": 1,
|
||||
"target": "llvm",
|
||||
"strict_mode": true
|
||||
}
|
||||
}
|
||||
@@ -0,0 +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
|
||||
|
||||
|
||||
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
|
||||
@@ -0,0 +1,372 @@
|
||||
import config
|
||||
import t, c
|
||||
|
||||
|
||||
def ForRangeBasicTest(stop: t.CInt):
|
||||
i: t.CInt = 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
|
||||
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
|
||||
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
|
||||
for i in range(data_size):
|
||||
if i == 5:
|
||||
print("Found at: ", i)
|
||||
found = 1
|
||||
break
|
||||
print("Checking: ", i)
|
||||
if found == 0:
|
||||
print("Not found")
|
||||
|
||||
|
||||
def ForWithIfContinueTest(n: t.CInt):
|
||||
i: t.CInt = 0
|
||||
count: t.CInt = 0
|
||||
for i in range(n):
|
||||
if i % 2 == 0:
|
||||
continue
|
||||
print("Odd: ", i)
|
||||
count += 1
|
||||
print("Total odd: ", count)
|
||||
|
||||
|
||||
def ForWithElifBranchTest(value: t.CInt):
|
||||
i: t.CInt = 0
|
||||
result: t.CInt = 0
|
||||
for i in range(value):
|
||||
if i < 3:
|
||||
result += 1
|
||||
elif i < 6:
|
||||
result += 2
|
||||
elif i < 9:
|
||||
result += 3
|
||||
else:
|
||||
result += 4
|
||||
print("Elif branch result: ", result)
|
||||
|
||||
|
||||
def WhileWithIfElifElseTest(iterations: t.CInt):
|
||||
counter: t.CInt = 0
|
||||
while counter < iterations:
|
||||
if counter < 2:
|
||||
print("Phase 1: ", counter)
|
||||
elif counter < 4:
|
||||
print("Phase 2: ", counter)
|
||||
elif counter < 6:
|
||||
print("Phase 3: ", counter)
|
||||
else:
|
||||
print("Phase 4: ", counter)
|
||||
counter += 1
|
||||
print("While done")
|
||||
|
||||
|
||||
def WhileWithNestedIfTest(limit: t.CInt):
|
||||
outer: t.CInt = 0
|
||||
while outer < limit:
|
||||
inner: t.CInt = 0
|
||||
while inner < limit:
|
||||
if inner == 2 and outer == 1:
|
||||
print("Target: ", outer, inner)
|
||||
inner += 1
|
||||
continue
|
||||
if inner > 3:
|
||||
break
|
||||
print("Inner: ", inner)
|
||||
inner += 1
|
||||
outer += 1
|
||||
|
||||
|
||||
def WhileWithMatchCaseTest(value: t.CInt):
|
||||
result: t.CInt = 0
|
||||
match value:
|
||||
case 1:
|
||||
result = 100
|
||||
print("Case 1")
|
||||
case 2:
|
||||
result = 200
|
||||
print("Case 2")
|
||||
case 3:
|
||||
result = 300
|
||||
print("Case 3")
|
||||
case _:
|
||||
result = 999
|
||||
print("Default case")
|
||||
print("Match result: ", result)
|
||||
|
||||
|
||||
def WhileWithMatchCaseNoBreakTest(value: t.CInt):
|
||||
result: t.CInt = 0
|
||||
match value:
|
||||
case 1:
|
||||
result = 10
|
||||
print("Case 1: ", result)
|
||||
case 2:
|
||||
result = 20
|
||||
print("Case 2: ", result)
|
||||
result += 5
|
||||
case 3:
|
||||
result = 30
|
||||
print("Case 3: ", result)
|
||||
case _:
|
||||
result = 0
|
||||
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
|
||||
for i in range(outer_limit):
|
||||
j = 0
|
||||
while j < inner_limit:
|
||||
match (i, j):
|
||||
case (0, 0):
|
||||
result += 1
|
||||
case (1, 1):
|
||||
result += 10
|
||||
case (2, _):
|
||||
result += 100
|
||||
case (_, 0):
|
||||
result += 1000
|
||||
case _:
|
||||
result += 10000
|
||||
j += 1
|
||||
print("Complex match result: ", result)
|
||||
|
||||
|
||||
def ForWithCaseAndNoBreakTest(n: t.CInt):
|
||||
i: t.CInt = 0
|
||||
result: t.CInt = 0
|
||||
for i in range(n):
|
||||
match i:
|
||||
case 0:
|
||||
result += 1
|
||||
case 1:
|
||||
result += 2
|
||||
case 2:
|
||||
result += 3
|
||||
result += 10
|
||||
case _:
|
||||
result += i
|
||||
c.NoBreak
|
||||
print("NoBreak result: ", result)
|
||||
|
||||
|
||||
def WhileWithBreakConditionTest(limit: t.CInt):
|
||||
i: t.CInt = 0
|
||||
early_exit: t.CInt = 0
|
||||
while i < limit:
|
||||
if i == 3:
|
||||
early_exit = 1
|
||||
break
|
||||
if i == 2:
|
||||
i += 1
|
||||
continue
|
||||
print("While i: ", i)
|
||||
i += 1
|
||||
|
||||
|
||||
def NestedWhileWithMultipleBreakPoints(depth: t.CInt, width: t.CInt):
|
||||
d: t.CInt = 0
|
||||
w: t.CInt = 0
|
||||
count: t.CInt = 0
|
||||
while d < depth:
|
||||
w = 0
|
||||
while w < width:
|
||||
if w == 2:
|
||||
break
|
||||
if d == 1 and w == 1:
|
||||
c.Break
|
||||
count += 1
|
||||
w += 1
|
||||
d += 1
|
||||
print("Nested break count: ", count)
|
||||
|
||||
|
||||
def ForWithMatchCaseInLoopTest(iterations: t.CInt):
|
||||
i: t.CInt = 0
|
||||
sum_even: t.CInt = 0
|
||||
sum_odd: t.CInt = 0
|
||||
for i in range(iterations):
|
||||
match i % 3:
|
||||
case 0:
|
||||
sum_even += i
|
||||
case 1:
|
||||
sum_odd += i
|
||||
case 2:
|
||||
sum_even += i * 2
|
||||
case _:
|
||||
pass
|
||||
print("Sum even: ", sum_even)
|
||||
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
|
||||
while i < 10:
|
||||
if i < a:
|
||||
if i < b:
|
||||
result += 1
|
||||
elif i < c_val:
|
||||
result += 2
|
||||
else:
|
||||
result += 3
|
||||
elif i < b:
|
||||
if i < c_val:
|
||||
result += 4
|
||||
else:
|
||||
result += 5
|
||||
elif i < c_val:
|
||||
result += 6
|
||||
else:
|
||||
result += 7
|
||||
i += 1
|
||||
print("Complex elif chain result: ", result)
|
||||
|
||||
|
||||
def ForRangeWithStepAndCondition(n: t.CInt, step: t.CInt):
|
||||
i: t.CInt = 0
|
||||
count: t.CInt = 0
|
||||
for i in range(0, n, step):
|
||||
if i % 2 == 0:
|
||||
print("Even step: ", i)
|
||||
count += 1
|
||||
else:
|
||||
if i > 5:
|
||||
print("Large odd: ", i)
|
||||
else:
|
||||
print("Small odd: ", i)
|
||||
print("Total steps: ", count)
|
||||
|
||||
|
||||
def MatchCaseWithGuardConditions(value: t.CInt):
|
||||
result: t.CInt = 0
|
||||
match value:
|
||||
case 1 if config.TRUE == 1:
|
||||
result = 100
|
||||
case 2 if config.FALSE == 0:
|
||||
result = 200
|
||||
case 3:
|
||||
result = 300
|
||||
case _:
|
||||
result = 0
|
||||
print("Guard match result: ", result)
|
||||
|
||||
|
||||
def WhileWithMultipleMatchCases(iterations: t.CInt):
|
||||
i: t.CInt = 0
|
||||
state: t.CInt = 0
|
||||
while i < iterations:
|
||||
match state:
|
||||
case 0:
|
||||
if i > 3:
|
||||
state = 1
|
||||
case 1:
|
||||
if i > 6:
|
||||
state = 2
|
||||
case 2:
|
||||
if i > 9:
|
||||
state = 0
|
||||
print("State at i=", i, ": ", state)
|
||||
i += 1
|
||||
|
||||
|
||||
def ForWhileMixWithBreakAndContinue(n: t.CInt):
|
||||
i: t.CInt = 0
|
||||
j: t.CInt = 0
|
||||
count: t.CInt = 0
|
||||
for i in range(n):
|
||||
j = 0
|
||||
while j < n:
|
||||
if j == 2:
|
||||
j += 1
|
||||
continue
|
||||
if i == 3 and j == 3:
|
||||
break
|
||||
count += 1
|
||||
j += 1
|
||||
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
|
||||
for i in range(start, end):
|
||||
match i:
|
||||
case _ if i < 10:
|
||||
bucket0 += 1
|
||||
case _ if i < 20:
|
||||
bucket1 += 1
|
||||
case _ if i < 30:
|
||||
bucket2 += 1
|
||||
case _:
|
||||
bucket3 += 1
|
||||
print("Bucket0 (<10): ", bucket0)
|
||||
print("Bucket1 (10-19): ", bucket1)
|
||||
print("Bucket2 (20-29): ", bucket2)
|
||||
print("Bucket3 (>=30): ", bucket3)
|
||||
|
||||
|
||||
def WhileWithElifInElifChain(limit: t.CInt):
|
||||
i: t.CInt = 0
|
||||
result: t.CInt = 0
|
||||
while i < limit:
|
||||
if i < 2:
|
||||
if i == 0:
|
||||
result = 1
|
||||
else:
|
||||
result = 2
|
||||
elif i < 4:
|
||||
if i == 2:
|
||||
result = 3
|
||||
else:
|
||||
result = 4
|
||||
elif i < 6:
|
||||
if i == 4:
|
||||
result = 5
|
||||
else:
|
||||
result = 6
|
||||
else:
|
||||
result = 7
|
||||
print("Chain result[", i, "]: ", result)
|
||||
i += 1
|
||||
|
||||
|
||||
def ForWithCaseNoBreakNested(inner_limit: t.CInt):
|
||||
i: t.CInt = 0
|
||||
j: t.CInt = 0
|
||||
result: t.CInt = 0
|
||||
for i in range(3):
|
||||
for j in range(inner_limit):
|
||||
match j:
|
||||
case 0:
|
||||
result += 1
|
||||
case 1:
|
||||
result += 2
|
||||
case _:
|
||||
result += 3
|
||||
c.NoBreak
|
||||
print("Nested NoBreak result: ", result)
|
||||
@@ -0,0 +1,106 @@
|
||||
import t, c
|
||||
import config
|
||||
import logic_test
|
||||
import testcheck
|
||||
|
||||
|
||||
def main() -> t.CInt:
|
||||
testcheck.begin("LogicFlowTest: For/While/Match/控制流测试")
|
||||
|
||||
testcheck.section("For Range Basic Test (stop=5)")
|
||||
logic_test.ForRangeBasicTest(5)
|
||||
testcheck.ok("For Range Basic Test (5)")
|
||||
|
||||
testcheck.section("For Range With Start Stop Step (start=1, stop=10, step=2)")
|
||||
logic_test.ForRangeWithStartStop(1, 10, 2)
|
||||
testcheck.ok("For Range With Start Stop (1, 10, 2)")
|
||||
|
||||
testcheck.section("Nested For Range Test (rows=2, cols=3)")
|
||||
logic_test.NestedForRangeTest(2, 3)
|
||||
testcheck.ok("Nested For Range Test (2, 3)")
|
||||
|
||||
testcheck.section("For With If Break Test (size=8)")
|
||||
logic_test.ForWithIfBreakTest(8)
|
||||
testcheck.ok("For With If Break Test (8)")
|
||||
|
||||
testcheck.section("For With If Continue Test (n=10)")
|
||||
logic_test.ForWithIfContinueTest(10)
|
||||
testcheck.ok("For With If Continue Test (10)")
|
||||
|
||||
testcheck.section("For With Elif Branch Test (value=10)")
|
||||
logic_test.ForWithElifBranchTest(10)
|
||||
testcheck.ok("For With Elif Branch Test (10)")
|
||||
|
||||
testcheck.section("While With If Elif Else Test (iterations=7)")
|
||||
logic_test.WhileWithIfElifElseTest(7)
|
||||
testcheck.ok("While With If Elif Else Test (7)")
|
||||
|
||||
testcheck.section("While With Nested If Test (limit=4)")
|
||||
logic_test.WhileWithNestedIfTest(4)
|
||||
testcheck.ok("While With Nested If Test (4)")
|
||||
|
||||
testcheck.section("While With Match Case Test (value=2)")
|
||||
logic_test.WhileWithMatchCaseTest(2)
|
||||
testcheck.ok("While With Match Case Test (2)")
|
||||
|
||||
testcheck.section("While With Match Case Test (value=99)")
|
||||
logic_test.WhileWithMatchCaseTest(99)
|
||||
testcheck.ok("While With Match Case Test (99)")
|
||||
|
||||
testcheck.section("While With Match Case NoBreak Test (value=3)")
|
||||
logic_test.WhileWithMatchCaseNoBreakTest(3)
|
||||
testcheck.ok("While With Match Case NoBreak Test (3)")
|
||||
|
||||
testcheck.section("Complex For While Match Test (outer=3, inner=3)")
|
||||
logic_test.ComplexForWhileMatchTest(3, 3)
|
||||
testcheck.ok("Complex For While Match Test (3, 3)")
|
||||
|
||||
testcheck.section("For With Case And NoBreak Test (n=5)")
|
||||
logic_test.ForWithCaseAndNoBreakTest(5)
|
||||
testcheck.ok("For With Case And NoBreak Test (5)")
|
||||
|
||||
testcheck.section("While With Break Condition Test (limit=6)")
|
||||
logic_test.WhileWithBreakConditionTest(6)
|
||||
testcheck.ok("While With Break Condition Test (6)")
|
||||
|
||||
testcheck.section("Nested While With Multiple BreakPoints (depth=3, width=4)")
|
||||
logic_test.NestedWhileWithMultipleBreakPoints(3, 4)
|
||||
testcheck.ok("Nested While With Multiple BreakPoints (3, 4)")
|
||||
|
||||
testcheck.section("For With Match Case In Loop Test (iterations=9)")
|
||||
logic_test.ForWithMatchCaseInLoopTest(9)
|
||||
testcheck.ok("For With Match Case In Loop Test (9)")
|
||||
|
||||
testcheck.section("Complex Logic With Elif Chains (a=3, b=5, c=7)")
|
||||
logic_test.ComplexLogicWithElifChains(3, 5, 7)
|
||||
testcheck.ok("Complex Logic With Elif Chains (3, 5, 7)")
|
||||
|
||||
testcheck.section("For Range With Step And Condition (n=12, step=2)")
|
||||
logic_test.ForRangeWithStepAndCondition(12, 2)
|
||||
testcheck.ok("For Range With Step And Condition (12, 2)")
|
||||
|
||||
testcheck.section("Match Case With Guard Conditions (value=1)")
|
||||
logic_test.MatchCaseWithGuardConditions(1)
|
||||
testcheck.ok("Match Case With Guard Conditions (1)")
|
||||
|
||||
testcheck.section("While With Multiple Match Cases (iterations=12)")
|
||||
logic_test.WhileWithMultipleMatchCases(12)
|
||||
testcheck.ok("While With Multiple Match Cases (12)")
|
||||
|
||||
testcheck.section("For While Mix With Break And Continue (n=5)")
|
||||
logic_test.ForWhileMixWithBreakAndContinue(5)
|
||||
testcheck.ok("For While Mix With Break And Continue (5)")
|
||||
|
||||
testcheck.section("Complex Case Matching With Ranges (start=0, end=35)")
|
||||
logic_test.ComplexCaseMatchingWithRanges(0, 35)
|
||||
testcheck.ok("Complex Case Matching With Ranges (0, 35)")
|
||||
|
||||
testcheck.section("While With Elif In Elif Chain (limit=7)")
|
||||
logic_test.WhileWithElifInElifChain(7)
|
||||
testcheck.ok("While With Elif In Elif Chain (7)")
|
||||
|
||||
testcheck.section("For With Case NoBreak Nested (inner_limit=4)")
|
||||
logic_test.ForWithCaseNoBreakNested(4)
|
||||
testcheck.ok("For With Case NoBreak Nested (4)")
|
||||
|
||||
return testcheck.end()
|
||||
@@ -0,0 +1,29 @@
|
||||
{
|
||||
"$schema": "https://raw.githubusercontent.com/TermiNexus/TransPyC/main/schemas/project-schema.json",
|
||||
"name": "LogicFlowTest",
|
||||
"version": "1.0.0",
|
||||
"source_dir": "./App",
|
||||
"build_dir": "./.tpv_build",
|
||||
"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": "LogicFlowTest.exe"
|
||||
},
|
||||
"includes": [
|
||||
"../../includes"
|
||||
],
|
||||
"target": {
|
||||
"triple": "x86_64-pc-windows-gnu",
|
||||
"datalayout": "e-m:w-p270:32:32-p271:32:32-p272:64:64-f80:128-n8:16:32:64-S128"
|
||||
},
|
||||
"options": {
|
||||
"slice_level": 3,
|
||||
"sha1_slice_level": 1,
|
||||
"target": "llvm",
|
||||
"strict_mode": true
|
||||
}
|
||||
}
|
||||
@@ -0,0 +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
|
||||
|
||||
|
||||
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
|
||||
@@ -0,0 +1,79 @@
|
||||
import stdio
|
||||
import t, c
|
||||
import config
|
||||
import test
|
||||
import testcheck
|
||||
|
||||
|
||||
def main() -> t.CInt:
|
||||
testcheck.begin("LoopMathTest: While/数学/跨模块宏测试")
|
||||
|
||||
testcheck.section("Cross-module macros")
|
||||
stdio.printf(" POSMAX: %d\n", config.POSMAX)
|
||||
stdio.printf(" MATH_SCALE: %d\n", config.MATH_SCALE)
|
||||
stdio.printf(" THRESHOLD: %d\n", config.THRESHOLD)
|
||||
stdio.printf(" SHIFT_AMOUNT: %d\n", config.SHIFT_AMOUNT)
|
||||
stdio.printf(" MASK_VALUE: 0x%x\n", config.MASK_VALUE)
|
||||
testcheck.ok("config macros accessible")
|
||||
|
||||
testcheck.section("While Loop Test")
|
||||
test.AboutSizeTWhileTest(10)
|
||||
testcheck.ok("While Loop Test (10)")
|
||||
|
||||
testcheck.section("Math Basic Test (20, 6)")
|
||||
test.MathBasicTest(20, 6)
|
||||
testcheck.ok("Math Basic Test (20, 6)")
|
||||
|
||||
testcheck.section("Math Advanced Test (value=15)")
|
||||
test.MathAdvancedTest(15)
|
||||
testcheck.ok("Math Advanced Test (value=15)")
|
||||
|
||||
testcheck.section("While with Elif-Else Test (-2 to 12)")
|
||||
test.WhileWithElifElseTest(-2, 12)
|
||||
testcheck.ok("While with Elif-Else Test (-2 to 12)")
|
||||
|
||||
testcheck.section("Nested While with Macros Test")
|
||||
test.NestedWhileWithMacrosTest(3, 4)
|
||||
testcheck.ok("Nested While with Macros Test (3, 4)")
|
||||
|
||||
testcheck.section("Complex Condition Test (1, 2, 3)")
|
||||
test.ComplexConditionTest(1, 2, 3)
|
||||
testcheck.ok("Complex Condition Test (1, 2, 3)")
|
||||
|
||||
testcheck.section("Retry Loop Test (8)")
|
||||
test.RetryLoopTest(8)
|
||||
testcheck.ok("Retry Loop Test (8)")
|
||||
|
||||
testcheck.section("Bitwise Operations Test (0b1101101)")
|
||||
test.BitwiseOperationsTest(109)
|
||||
testcheck.ok("Bitwise Operations Test (109)")
|
||||
|
||||
testcheck.section("Compound Assignment Math Test (15, 4)")
|
||||
test.CompoundAssignmentMathTest(15, 4)
|
||||
testcheck.ok("Compound Assignment Math Test (15, 4)")
|
||||
|
||||
testcheck.section("Power and Modulo Test (2, 8)")
|
||||
test.PowerAndModuloTest(2, 8)
|
||||
testcheck.ok("Power and Modulo Test (2, 8)")
|
||||
|
||||
testcheck.section("Mixed Arithmetic Test (5, 3, 4)")
|
||||
test.MixedArithmeticTest(5, 3, 4)
|
||||
testcheck.ok("Mixed Arithmetic Test (5, 3, 4)")
|
||||
|
||||
testcheck.section("Math with While Loop Test (start=1, count=5)")
|
||||
test.MathWithWhileLoopTest(1, 5)
|
||||
testcheck.ok("Math with While Loop Test (1, 5)")
|
||||
|
||||
testcheck.section("Complex Nested Math Test (7, 3)")
|
||||
test.ComplexNestedMathTest(7, 3)
|
||||
testcheck.ok("Complex Nested Math Test (7, 3)")
|
||||
|
||||
testcheck.section("Conditional Math Chain Test (value=10)")
|
||||
test.ConditionalMathChainTest(10)
|
||||
testcheck.ok("Conditional Math Chain Test (value=10)")
|
||||
|
||||
testcheck.section("Bit Manipulation Math Test (0xABCD)")
|
||||
test.BitManipulationMathTest(0xABCD)
|
||||
testcheck.ok("Bit Manipulation Math Test (0xABCD)")
|
||||
|
||||
return testcheck.end()
|
||||
@@ -0,0 +1,298 @@
|
||||
import config
|
||||
import t, c
|
||||
|
||||
|
||||
def AboutSizeTWhileTest(length: t.CSizeT):
|
||||
pos: t.CSizeT = 0
|
||||
while pos < length:
|
||||
print("Pos: ", pos)
|
||||
if pos > config.POSMAX: break
|
||||
pos += 1
|
||||
while pos < length:
|
||||
if pos > config.POSMAX:
|
||||
print("Pos: ", pos)
|
||||
pos += 1
|
||||
else:
|
||||
print("Pos: ", pos)
|
||||
pos += 1
|
||||
if pos > config.POSMAX: break
|
||||
else:
|
||||
pos += 1
|
||||
print("Pos: ", pos)
|
||||
while pos < length:
|
||||
print("Pos: ", pos)
|
||||
pos += 1
|
||||
|
||||
|
||||
def MathBasicTest(x: t.CInt, y: t.CInt) -> t.CInt:
|
||||
result: t.CInt = 0
|
||||
result = x + y
|
||||
print("Add: ", result)
|
||||
result = x - y
|
||||
print("Sub: ", result)
|
||||
result = x * y
|
||||
print("Mul: ", result)
|
||||
if y != 0:
|
||||
result = x / y
|
||||
print("Div: ", result)
|
||||
result = x % y if y != 0 else 0
|
||||
print("Mod: ", result)
|
||||
return result
|
||||
|
||||
|
||||
def MathAdvancedTest(value: t.CInt) -> t.CInt:
|
||||
counter: t.CInt = 0
|
||||
scaled: t.CInt = 0
|
||||
offset: t.CInt = 0
|
||||
scaled = value * config.MATH_SCALE
|
||||
print("Scaled: ", scaled)
|
||||
offset = scaled + config.MATH_OFFSET
|
||||
print("Offset: ", offset)
|
||||
threshold: t.CInt = config.THRESHOLD
|
||||
if offset > threshold:
|
||||
print("Above threshold")
|
||||
counter = 1
|
||||
elif offset == threshold:
|
||||
print("At threshold")
|
||||
counter = 0
|
||||
else:
|
||||
print("Below threshold")
|
||||
counter = -1
|
||||
return counter
|
||||
|
||||
|
||||
def WhileWithElifElseTest(start: t.CInt, end: t.CInt):
|
||||
idx: t.CInt = start
|
||||
while idx < end:
|
||||
if idx < 0:
|
||||
print("Negative: ", idx)
|
||||
elif idx == 0:
|
||||
print("Zero: ", idx)
|
||||
elif idx > 0 and idx < 5:
|
||||
print("Small positive: ", idx)
|
||||
elif idx >= 5 and idx < 10:
|
||||
print("Medium positive: ", idx)
|
||||
else:
|
||||
print("Large: ", idx)
|
||||
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
|
||||
while outer < outer_limit:
|
||||
inner = 0
|
||||
while inner < inner_limit:
|
||||
if inner == config.TRUE:
|
||||
print("Inner loop break condition at: ", inner)
|
||||
total_ops += 1
|
||||
inner += 1
|
||||
outer += 1
|
||||
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
|
||||
while x < config.LOOP_LIMIT:
|
||||
if x > 0 and y > 0 and z > 0:
|
||||
print("All positive: ", x, y, z)
|
||||
elif x <= 0 and y <= 0 and z <= 0:
|
||||
print("All non-positive: ", x, y, z)
|
||||
else:
|
||||
if x > 0:
|
||||
print("X positive")
|
||||
elif y > 0:
|
||||
print("Y positive")
|
||||
else:
|
||||
print("Z positive")
|
||||
x += 1
|
||||
y += 1
|
||||
z += 1
|
||||
|
||||
|
||||
def RetryLoopTest(retry_count: t.CInt) -> t.CInt:
|
||||
attempt: t.CInt = 0
|
||||
success: t.CInt = 0
|
||||
while attempt < retry_count:
|
||||
if attempt < config.MAX_RETRY:
|
||||
print("Attempt: ", attempt, " less than max")
|
||||
success = attempt * 2
|
||||
elif attempt == config.MAX_RETRY:
|
||||
print("At max retry")
|
||||
success = -1
|
||||
else:
|
||||
print("Beyond max retry")
|
||||
success = -2
|
||||
attempt += 1
|
||||
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
|
||||
shifted = value << config.SHIFT_AMOUNT
|
||||
print("Left shift: ", shifted)
|
||||
shifted = value >> config.SHIFT_AMOUNT
|
||||
print("Right shift: ", shifted)
|
||||
masked = value & config.MASK_VALUE
|
||||
print("Bitwise AND mask: ", masked)
|
||||
xored = value ^ config.MASK_VALUE
|
||||
print("Bitwise XOR: ", xored)
|
||||
anded = value & (config.MASK_VALUE >> config.SHIFT_AMOUNT)
|
||||
print("Bitwise AND shifted mask: ", anded)
|
||||
ored = value | config.SHIFT_AMOUNT
|
||||
print("Bitwise OR shift: ", ored)
|
||||
return masked
|
||||
|
||||
|
||||
def CompoundAssignmentMathTest(a: t.CInt, b: t.CInt) -> t.CInt:
|
||||
x: t.CInt = a
|
||||
y: t.CInt = b
|
||||
result: t.CInt = 0
|
||||
x += y
|
||||
print("x += y: ", x)
|
||||
x -= y
|
||||
print("x -= y: ", x)
|
||||
x *= y
|
||||
print("x *= y: ", x)
|
||||
x = a
|
||||
y = b
|
||||
if b != 0:
|
||||
x /= b
|
||||
print("x /= y: ", x)
|
||||
x = a
|
||||
if b != 0:
|
||||
x %= b
|
||||
print("x %%= y: ", x)
|
||||
x = a
|
||||
x <<= config.SHIFT_AMOUNT
|
||||
print("x <<= shift: ", x)
|
||||
x >>= config.SHIFT_AMOUNT
|
||||
print("x >>= shift: ", x)
|
||||
x &= config.MASK_VALUE
|
||||
print("x &= mask: ", x)
|
||||
x |= config.SHIFT_AMOUNT
|
||||
print("x |= shift: ", x)
|
||||
result = (a + b) * config.MATH_SCALE - config.MATH_OFFSET
|
||||
print("Compound: (a+b)*scale-offset: ", result)
|
||||
result = (a * b) + (config.MATH_OFFSET / 2)
|
||||
print("Compound: a*b+offset/2: ", result)
|
||||
return result
|
||||
|
||||
|
||||
def PowerAndModuloTest(base: t.CInt, exponent: t.CInt) -> t.CInt:
|
||||
result: t.CInt = 1
|
||||
temp: t.CInt = 0
|
||||
i: t.CInt = 0
|
||||
while i < exponent:
|
||||
result *= base
|
||||
i += 1
|
||||
print("Power: ", result)
|
||||
temp = result % config.MODULO_DIVISOR
|
||||
print("Power mod: ", temp)
|
||||
temp = (base * config.EXPONENT_BASE) % config.MODULO_DIVISOR
|
||||
print("base*exp %% divisor: ", temp)
|
||||
temp = ((base + config.MATH_OFFSET) * config.MATH_SCALE) % config.MODULO_DIVISOR
|
||||
print("(base+offset)*scale %% divisor: ", temp)
|
||||
return result
|
||||
|
||||
|
||||
def MixedArithmeticTest(x: t.CInt, y: t.CInt, z: t.CInt) -> t.CInt:
|
||||
result: t.CInt = 0
|
||||
result = (x + y) * z
|
||||
print("(x+y)*z: ", result)
|
||||
result = x + (y * z)
|
||||
print("x+(y*z): ", result)
|
||||
result = ((x + y) * config.MATH_SCALE) - config.MATH_OFFSET
|
||||
print("((x+y)*scale)-offset: ", result)
|
||||
result = (x * config.MATH_SCALE) + (y * config.MATH_SCALE)
|
||||
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 = x | y & z
|
||||
print("x | y & z: ", temp)
|
||||
temp = (x | y) & z
|
||||
print("(x | y) & z: ", temp)
|
||||
temp = x ^ y ^ z
|
||||
print("x ^ y ^ z: ", temp)
|
||||
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
|
||||
while idx < count:
|
||||
temp: t.CInt = (start + idx) * multiplier
|
||||
temp = temp + config.MATH_OFFSET
|
||||
if temp > config.THRESHOLD:
|
||||
temp = config.THRESHOLD
|
||||
accumulator += temp
|
||||
multiplier += 1
|
||||
idx += 1
|
||||
print("Accumulator: ", accumulator)
|
||||
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
|
||||
layer1 = (a + b) * config.MATH_SCALE
|
||||
print("Layer1: ", layer1)
|
||||
while i < config.BIT_RANGE:
|
||||
layer2 += layer1 >> 1
|
||||
i += 1
|
||||
print("Layer2: ", layer2)
|
||||
layer3 = layer1 + layer2 - config.MATH_OFFSET
|
||||
print("Layer3: ", layer3)
|
||||
layer3 = layer3 * config.MATH_SCALE / 2 if config.MATH_SCALE != 0 else layer3
|
||||
print("Layer3 scaled: ", layer3)
|
||||
return layer3
|
||||
|
||||
|
||||
def ConditionalMathChainTest(value: t.CInt) -> t.CInt:
|
||||
result: t.CInt = 0
|
||||
step: t.CInt = 0
|
||||
while step < config.LOOP_LIMIT:
|
||||
if step < 5:
|
||||
result += step * config.MATH_SCALE
|
||||
print("step<5: ", result)
|
||||
elif step < 10:
|
||||
result -= step - config.MATH_OFFSET
|
||||
print("step<10: ", result)
|
||||
elif step < 15:
|
||||
result += (step * config.MATH_OFFSET) / config.MATH_SCALE
|
||||
print("step<15: ", result)
|
||||
else:
|
||||
result = result * config.EXPONENT_BASE % config.MODULO_DIVISOR
|
||||
print("step>=15: ", result)
|
||||
step += 1
|
||||
return result
|
||||
|
||||
|
||||
def BitManipulationMathTest(value: t.CInt) -> t.CInt:
|
||||
original: t.CInt = value
|
||||
nibble: t.CInt = 0
|
||||
result: t.CInt = 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))
|
||||
print("Rotate right: ", result)
|
||||
nibble = value & 0xF
|
||||
print("Lower nibble: ", nibble)
|
||||
nibble = (value >> config.BIT_RANGE) & 0xF
|
||||
print("Upper nibble: ", nibble)
|
||||
result = ((value & config.MASK_VALUE) + config.MATH_OFFSET) * config.MATH_SCALE
|
||||
print("Masked and scaled: ", result)
|
||||
result = ((original << config.SHIFT_AMOUNT) ^ original) & config.MASK_VALUE
|
||||
print("XOR shifted: ", result)
|
||||
return result
|
||||
@@ -0,0 +1,29 @@
|
||||
{
|
||||
"$schema": "https://raw.githubusercontent.com/TermiNexus/TransPyC/main/schemas/project-schema.json",
|
||||
"name": "LoopMathTest",
|
||||
"version": "1.0.0",
|
||||
"source_dir": "./App",
|
||||
"build_dir": "./.tpv_build",
|
||||
"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": "LoopMathTest.exe"
|
||||
},
|
||||
"includes": [
|
||||
"../../includes"
|
||||
],
|
||||
"target": {
|
||||
"triple": "x86_64-pc-windows-gnu",
|
||||
"datalayout": "e-m:w-p270:32:32-p271:32:32-p272:64:64-f80:128-n8:16:32:64-S128"
|
||||
},
|
||||
"options": {
|
||||
"slice_level": 3,
|
||||
"sha1_slice_level": 1,
|
||||
"target": "llvm",
|
||||
"strict_mode": true
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,11 @@
|
||||
import t, c
|
||||
import testcheck
|
||||
import mpooltest
|
||||
|
||||
|
||||
def main() -> t.CInt | t.CExport:
|
||||
testcheck.begin("MpoolOopTest: MemPool OOP 测试")
|
||||
testcheck.section("MPool OOP")
|
||||
mpooltest.mpool_main()
|
||||
testcheck.ok("MPool OOP 测试完成")
|
||||
return testcheck.end()
|
||||
@@ -0,0 +1,91 @@
|
||||
import t, c
|
||||
from t import CInt, CPtr, CChar
|
||||
import viperlib
|
||||
import viperio
|
||||
import stdlib
|
||||
import memhub
|
||||
|
||||
|
||||
def mpool_main() -> CInt:
|
||||
buf: bytes = stdlib.malloc(256)
|
||||
|
||||
arena: bytes = stdlib.malloc(4096)
|
||||
with memhub.MemPool(arena, 4096) as pool:
|
||||
p1: bytes = pool.alloc(32)
|
||||
p2: bytes = pool.alloc(64)
|
||||
p3: bytes = pool.alloc(128)
|
||||
if p1 != None and p2 != None and p3 != None:
|
||||
viperlib.snprintf(buf, 256, "MPool bump: 3 allocs OK")
|
||||
print(buf)
|
||||
else:
|
||||
viperlib.snprintf(buf, 256, "MPool bump: alloc FAILED")
|
||||
print(buf)
|
||||
|
||||
pool.reset()
|
||||
p4: bytes = pool.alloc(256)
|
||||
if p4 != None:
|
||||
viperlib.snprintf(buf, 256, "MPool bump: reset+alloc OK")
|
||||
print(buf)
|
||||
else:
|
||||
viperlib.snprintf(buf, 256, "MPool bump: reset+alloc FAILED")
|
||||
print(buf)
|
||||
|
||||
stdlib.free(arena)
|
||||
|
||||
arena2: bytes = stdlib.malloc(4096)
|
||||
with memhub.MemSlab(arena2, 4096, 64) as spool:
|
||||
b1: bytes = spool.alloc(64)
|
||||
b2: bytes = spool.alloc(64)
|
||||
b3: bytes = spool.alloc(64)
|
||||
if b1 != None and b2 != None and b3 != None:
|
||||
viperlib.snprintf(buf, 256, "MPool slab: 3 allocs OK")
|
||||
print(buf)
|
||||
else:
|
||||
viperlib.snprintf(buf, 256, "MPool slab: alloc FAILED")
|
||||
print(buf)
|
||||
|
||||
spool.free(b2)
|
||||
b4: bytes = spool.alloc(64)
|
||||
if b4 != None:
|
||||
viperlib.snprintf(buf, 256, "MPool slab: free+realloc OK")
|
||||
print(buf)
|
||||
else:
|
||||
viperlib.snprintf(buf, 256, "MPool slab: free+realloc FAILED")
|
||||
print(buf)
|
||||
|
||||
stdlib.free(arena2)
|
||||
|
||||
arena3: bytes = stdlib.malloc(4096)
|
||||
hpool: memhub.MemPool | CPtr = memhub.MemPool(arena3, 4096)
|
||||
h1: bytes = hpool.alloc(32)
|
||||
h2: bytes = hpool.alloc(64)
|
||||
if h1 != None and h2 != None:
|
||||
viperlib.snprintf(buf, 256, "MPool manual: 2 allocs OK")
|
||||
print(buf)
|
||||
else:
|
||||
viperlib.snprintf(buf, 256, "MPool manual: alloc FAILED")
|
||||
print(buf)
|
||||
hpool.reset()
|
||||
h3: bytes = hpool.alloc(128)
|
||||
if h3 != None:
|
||||
viperlib.snprintf(buf, 256, "MPool manual: reset+alloc OK")
|
||||
print(buf)
|
||||
else:
|
||||
viperlib.snprintf(buf, 256, "MPool manual: reset+alloc FAILED")
|
||||
print(buf)
|
||||
|
||||
stdlib.free(arena3)
|
||||
|
||||
arena4: bytes = stdlib.malloc(4096)
|
||||
with memhub.MemPool(arena4, 4096) as bpool:
|
||||
wb: viperio.Buf | CPtr = bpool.alloc_buf(128)
|
||||
if wb.data != None:
|
||||
viperlib.snprintf(wb.cstr(), 128, "MPool alloc_buf: hello from Buf!")
|
||||
print(wb.cstr())
|
||||
else:
|
||||
viperlib.snprintf(buf, 256, "MPool alloc_buf: FAILED")
|
||||
print(buf)
|
||||
|
||||
stdlib.free(arena4)
|
||||
stdlib.free(buf)
|
||||
return 0
|
||||
@@ -0,0 +1,29 @@
|
||||
{
|
||||
"$schema": "https://raw.githubusercontent.com/TermiNexus/TransPyC/main/schemas/project-schema.json",
|
||||
"name": "MpoolOopTest",
|
||||
"version": "1.0.0",
|
||||
"source_dir": "./App",
|
||||
"build_dir": "./.tpv_build",
|
||||
"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": "MpoolOopTest.exe"
|
||||
},
|
||||
"includes": [
|
||||
"../../includes"
|
||||
],
|
||||
"target": {
|
||||
"triple": "x86_64-pc-windows-gnu",
|
||||
"datalayout": "e-m:w-p270:32:32-p271:32:32-p272:64:64-f80:128-n8:16:32:64-S128"
|
||||
},
|
||||
"options": {
|
||||
"slice_level": 3,
|
||||
"sha1_slice_level": 1,
|
||||
"target": "llvm",
|
||||
"strict_mode": true
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,11 @@
|
||||
import t, c
|
||||
import testcheck
|
||||
import test_numpy
|
||||
|
||||
|
||||
def main() -> t.CInt | t.CExport:
|
||||
testcheck.begin("NumpyTest: numpy 正确性测试")
|
||||
testcheck.section("numpy Correctness Tests")
|
||||
test_numpy.test_numpy_correct()
|
||||
testcheck.ok("numpy 正确性测试完成")
|
||||
return testcheck.end()
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,29 @@
|
||||
{
|
||||
"$schema": "https://raw.githubusercontent.com/TermiNexus/TransPyC/main/schemas/project-schema.json",
|
||||
"name": "NumpyTest",
|
||||
"version": "1.0.0",
|
||||
"source_dir": "./App",
|
||||
"build_dir": "./.tpv_build",
|
||||
"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": "NumpyTest.exe"
|
||||
},
|
||||
"includes": [
|
||||
"../../includes"
|
||||
],
|
||||
"target": {
|
||||
"triple": "x86_64-pc-windows-gnu",
|
||||
"datalayout": "e-m:w-p270:32:32-p271:32:32-p272:64:64-f80:128-n8:16:32:64-S128"
|
||||
},
|
||||
"options": {
|
||||
"slice_level": 3,
|
||||
"sha1_slice_level": 1,
|
||||
"target": "llvm",
|
||||
"strict_mode": true
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,11 @@
|
||||
import t, c
|
||||
import testcheck
|
||||
import vectortest
|
||||
|
||||
|
||||
def main() -> t.CInt | t.CExport:
|
||||
testcheck.begin("VectorGenericTest: Vector 泛型测试")
|
||||
testcheck.section("Vector 泛型")
|
||||
vectortest.vector_main()
|
||||
testcheck.ok("Vector 泛型测试完成")
|
||||
return testcheck.end()
|
||||
@@ -0,0 +1,43 @@
|
||||
import t, c
|
||||
from t import CInt, CPtr, CChar, CFloat64T
|
||||
import viperlib
|
||||
import stdlib
|
||||
import vector
|
||||
import memhub
|
||||
|
||||
POOL_SIZE: t.CDefine = 4096
|
||||
|
||||
def vector_main() -> CInt:
|
||||
buf: str = stdlib.malloc(256)
|
||||
pool_mem: t.CVoid | t.CPtr = stdlib.malloc(POOL_SIZE)
|
||||
pool: memhub.MemPool | CPtr = memhub.MemPool(pool_mem, POOL_SIZE)
|
||||
|
||||
vi: vector.Vector | CPtr = vector.Vector(pool, 10, CInt(0))
|
||||
vi.push(CInt(10))
|
||||
vi.push(CInt(20))
|
||||
vi.push(CInt(30))
|
||||
viperlib.snprintf(buf, 256, "Vector[int]: len=%d, [0]=%d, [1]=%d, [2]=%d", vi.len(), vi.get(0), vi.get(1), vi.get(2))
|
||||
print(buf)
|
||||
|
||||
vi.set(1, CInt(99))
|
||||
viperlib.snprintf(buf, 256, "Vector[int]: set[1]=99, [1]=%d", vi.get(1))
|
||||
print(buf)
|
||||
|
||||
vi.clear()
|
||||
viperlib.snprintf(buf, 256, "Vector[int]: cleared, len=%d", vi.len())
|
||||
print(buf)
|
||||
|
||||
vi.free()
|
||||
|
||||
vd: vector.Vector | CPtr = vector.Vector(pool, 8, CFloat64T(0.0))
|
||||
vd.push(CFloat64T(1.5))
|
||||
vd.push(CFloat64T(2.7))
|
||||
vd.push(CFloat64T(3.14))
|
||||
viperlib.snprintf(buf, 256, "Vector[double]: len=%d, [0]=%.1f, [1]=%.1f, [2]=%.2f", vd.len(), vd.get(0), vd.get(1), vd.get(2))
|
||||
print(buf)
|
||||
|
||||
vd.free()
|
||||
|
||||
stdlib.free(pool_mem)
|
||||
stdlib.free(buf)
|
||||
return 0
|
||||
@@ -0,0 +1,29 @@
|
||||
{
|
||||
"$schema": "https://raw.githubusercontent.com/TermiNexus/TransPyC/main/schemas/project-schema.json",
|
||||
"name": "VectorGenericTest",
|
||||
"version": "1.0.0",
|
||||
"source_dir": "./App",
|
||||
"build_dir": "./.tpv_build",
|
||||
"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": "VectorGenericTest.exe"
|
||||
},
|
||||
"includes": [
|
||||
"../../includes"
|
||||
],
|
||||
"target": {
|
||||
"triple": "x86_64-pc-windows-gnu",
|
||||
"datalayout": "e-m:w-p270:32:32-p271:32:32-p272:64:64-f80:128-n8:16:32:64-S128"
|
||||
},
|
||||
"options": {
|
||||
"slice_level": 3,
|
||||
"sha1_slice_level": 1,
|
||||
"target": "llvm",
|
||||
"strict_mode": true
|
||||
}
|
||||
}
|
||||
@@ -8,6 +8,7 @@ import __zlib.zchecksum as zchecksum
|
||||
import __zlib.zdef as zdef
|
||||
import __zlib.zhuff as zhuff
|
||||
import __zlib.test_pyzlib as tpz
|
||||
import zlib.pyzlib as stdzp
|
||||
import w32.win32memory
|
||||
import c
|
||||
import testcheck
|
||||
@@ -16,4 +17,10 @@ def main() -> t.CInt:
|
||||
testcheck.begin("ZlibTest: Zlib 压缩库测试")
|
||||
tpz.main123456()
|
||||
testcheck.ok("zlib test_pyzlib completed")
|
||||
|
||||
# 标准 zlib 库（includes/zlib）与 __zlib 并存验证
|
||||
testcheck.section("标准 zlib 库 (zlib.pyzlib)")
|
||||
print(stdzp.runtime_version())
|
||||
testcheck.ok("zlib runtime version printed")
|
||||
|
||||
return testcheck.end()
|
||||
Reference in new issue
Block a user