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

修复了大量存在的问题，增加了假鸭子类型等等机制

Browse Source
This commit is contained in:
TermiNexus
2026-06-25 14:49:46 +08:00
parent 19f2787db0
commit d88d11b646
827 changed files with 32617 additions and 18316 deletions
Download Patch File Download Diff File Expand all files Collapse all files

313
Test/FakeDuckTest/App/main.py Normal file
View File

@@ -0,0 +1,313 @@
from stdint import *
import w32.win32console
import t, c
from t import CInt, CExport
import _fakeduck
import stdio
import stdlib
import string
import mbuddy
import testcheck
import _withcontent
def main() -> CInt | CExport:
w32.win32console.SetConsoleCP(65001)
w32.win32console.SetConsoleOutputCP(65001)
# FakeDuck 测试: str 类型调用扩展方法 b()
a: str = "Hello"
result: CInt = a.b()
if result == 42:
stdio.printf("FakeDuck OK: a.b() = %d\n", result)
else:
stdio.printf("FakeDuck FAIL: a.b() = %d\n", result)
# Type 通用基类测试: str 变量调用 Type 的方法 type_id()
tid: CInt = a.type_id()
if tid == 99:
stdio.printf("Type OK: a.type_id() = %d\n", tid)
else:
stdio.printf("Type FAIL: a.type_id() = %d\n", tid)
# SELF 测试: 返回 self.__data__，应指向原始字符串数据
p: str = a.SELF()
stdio.printf("SELF test: %s\n", p)
# 直接字段访问测试: 读取 a.__data__ (应等于 a 本身)
data_ptr: str = a.__data__
stdio.printf("a.__data__ = %s\n", data_ptr)
# upper() 测试: 通过 mbuddy 分配内存，返回大写字符串
arena: bytes = stdlib.malloc(65536)
bd: mbuddy.MBuddy | t.CPtr = mbuddy.MBuddy(arena, 65536)
# 直接字段赋值: a.__mbuddy__ = bd (语法糖, 等价于 a.set_mbuddy(bd))
a.__mbuddy__ = bd
upper_str: str = a.upper()
stdio.printf("upper('Hello') = %s\n", upper_str)
# 验证 per-instance 不污染: b 没有设置 __mbuddy__ (初始为 NULL)
b: str = "World"
# 直接字段读取: b.__mbuddy__ (应返回 NULL)
b_buddy: mbuddy.MBuddy | t.CPtr = b.__mbuddy__
if t.CInt(b_buddy) == 0:
stdio.printf("mbuddy OK: b.__mbuddy__ is NULL (no pollution)\n")
else:
stdio.printf("mbuddy FAIL: b.__mbuddy__ polluted!\n")
# b 也设置 mbuddy 并 upper
b.__mbuddy__ = bd
upper_b: str = b.upper()
stdio.printf("upper('World') = %s\n", upper_b)
# lower() 测试
lower_str: str = a.lower()
stdio.printf("lower('Hello') = %s\n", lower_str)
# capitalize() 测试
cap_str: str = a.capitalize()
stdio.printf("capitalize('Hello') = %s\n", cap_str)
# swapcase() 测试
swap_str: str = a.swapcase()
stdio.printf("swapcase('Hello') = %s\n", swap_str)
# casefold() 测试
cf_str: str = a.casefold()
stdio.printf("casefold('Hello') = %s\n", cf_str)
# title() 测试
t_str: str = "hello world"
t_str.__mbuddy__ = bd
title_result: str = t_str.title()
stdio.printf("title('hello world') = %s\n", title_result)
# 布尔判断函数测试 (不需要 __mbuddy__)
u: str = "HELLO"
lo: str = "hello"
dig: str = "12345"
alnum_s: str = "Hello123"
space_s: str = " "
title_s: str = "Hello World"
punct_s: str = "Hello!"
stdio.printf("isupper('HELLO') = %d\n", u.isupper())
stdio.printf("isupper('Hello') = %d\n", a.isupper())
stdio.printf("islower('hello') = %d\n", lo.islower())
stdio.printf("islower('Hello') = %d\n", a.islower())
stdio.printf("isalpha('Hello') = %d\n", a.isalpha())
stdio.printf("isalpha('Hello123') = %d\n", alnum_s.isalpha())
stdio.printf("isdigit('12345') = %d\n", dig.isdigit())
stdio.printf("isdigit('Hello') = %d\n", a.isdigit())
stdio.printf("isalnum('Hello123') = %d\n", alnum_s.isalnum())
stdio.printf("isalnum('Hello!') = %d\n", punct_s.isalnum())
stdio.printf("isspace(' ') = %d\n", space_s.isspace())
stdio.printf("isspace('Hello') = %d\n", a.isspace())
stdio.printf("isascii('Hello') = %d\n", a.isascii())
stdio.printf("istitle('Hello World') = %d\n", title_s.istitle())
stdio.printf("istitle('hello world') = %d\n", t_str.istitle())
# === split() 测试 ===
testcheck.begin("FakeDuck split() 测试")
# Test 1: 基本分割
testcheck.section("Test 1: 基本分割 'a,b,c'")
s1: str = "a,b,c"
s1.__mbuddy__ = bd
parts = s1.split(',')
n1: t.CSizeT = parts.__len__()
stdio.printf("split('a,b,c', ',') len=%lu\n", n1)
testcheck.check(n1 == 3, "split len OK (3)", "split len FAILED expect 3")
p0: str = parts[0]
p1: str = parts[1]
p2: str = parts[2]
stdio.printf("parts[0]='%s' [1]='%s' [2]='%s'\n", p0, p1, p2)
testcheck.check(p0 == "a", "split[0]=='a' OK", "split[0] FAILED")
testcheck.check(p1 == "b", "split[1]=='b' OK", "split[1] FAILED")
testcheck.check(p2 == "c", "split[2]=='c' OK", "split[2] FAILED")
# Test 2: 空字符串分割
testcheck.section("Test 2: 无分隔符 'hello'")
s2: str = "hello"
s2.__mbuddy__ = bd
parts2 = s2.split(',')
n2: t.CSizeT = parts2.__len__()
stdio.printf("split('hello', ',') len=%lu\n", n2)
testcheck.check(n2 == 1, "no-delim len OK (1)", "no-delim len FAILED expect 1")
h0: str = parts2.get(0)
testcheck.check(h0 == "hello", "no-delim[0]=='hello' OK", "no-delim[0] FAILED")
# Test 3: 连续分隔符
testcheck.section("Test 3: 连续分隔符 'a,,b'")
s3: str = "a,,b"
s3.__mbuddy__ = bd
parts3 = s3.split(',')
n3: t.CSizeT = parts3.__len__()
stdio.printf("split('a,,b', ',') len=%lu\n", n3)
testcheck.check(n3 == 3, "consecutive len OK (3)", "consecutive len FAILED expect 3")
e0: str = parts3.get(0)
e1: str = parts3.get(1)
e2: str = parts3.get(2)
stdio.printf("parts[0]='%s' [1]='%s' [2]='%s'\n", e0, e1, e2)
testcheck.check(e0 == "a", "consec[0]=='a' OK", "consec[0] FAILED")
testcheck.check(e1 == "", "consec[1]=='' OK", "consec[1] FAILED")
testcheck.check(e2 == "b", "consec[2]=='b' OK", "consec[2] FAILED")
# Test 4: 空字符串
testcheck.section("Test 4: 空字符串 ''")
s4: str = ""
s4.__mbuddy__ = bd
parts4 = s4.split(',')
n4: t.CSizeT = parts4.__len__()
stdio.printf("split('', ',') len=%lu\n", n4)
testcheck.check(n4 == 1, "empty len OK (1)", "empty len FAILED expect 1")
# Test 5: 空格分割句子
testcheck.section("Test 5: 空格分割 'hello world foo'")
s5: str = "hello world foo"
s5.__mbuddy__ = bd
parts5 = s5.split(' ')
n5: t.CSizeT = parts5.__len__()
stdio.printf("split('hello world foo', ' ') len=%lu\n", n5)
testcheck.check(n5 == 3, "space len OK (3)", "space len FAILED expect 3")
w0: str = parts5[0]
w1: str = parts5[1]
w2: str = parts5[2]
stdio.printf("words[0]='%s' [1]='%s' [2]='%s'\n", w0, w1, w2)
testcheck.check(w0 == "hello", "space[0]=='hello' OK", "space[0] FAILED")
testcheck.check(w1 == "world", "space[1]=='world' OK", "space[1] FAILED")
testcheck.check(w2 == "foo", "space[2]=='foo' OK", "space[2] FAILED")
# Test 6: 多字符分隔符 '::'
testcheck.section("Test 6: 多字符分隔符 '::' on 'a::b::c'")
s6: str = "a::b::c"
s6.__mbuddy__ = bd
parts6 = s6.split("::")
n6: t.CSizeT = parts6.__len__()
stdio.printf("split('a::b::c', '::') len=%lu\n", n6)
testcheck.check(n6 == 3, "multi-colon len OK (3)", "multi-colon len FAILED expect 3")
m0: str = parts6[0]
m1: str = parts6[1]
m2: str = parts6[2]
stdio.printf("parts[0]='%s' [1]='%s' [2]='%s'\n", m0, m1, m2)
testcheck.check(m0 == "a", "multi-colon[0]=='a' OK", "multi-colon[0] FAILED")
testcheck.check(m1 == "b", "multi-colon[1]=='b' OK", "multi-colon[1] FAILED")
testcheck.check(m2 == "c", "multi-colon[2]=='c' OK", "multi-colon[2] FAILED")
# Test 7: 多字符分隔符 ', ' (逗号+空格)
testcheck.section("Test 7: 多字符分隔符 ', ' on 'hello, world, foo'")
s7: str = "hello, world, foo"
s7.__mbuddy__ = bd
parts7 = s7.split(", ")
n7: t.CSizeT = parts7.__len__()
stdio.printf("split('hello, world, foo', ', ') len=%lu\n", n7)
testcheck.check(n7 == 3, "comma-space len OK (3)", "comma-space len FAILED expect 3")
cs0: str = parts7[0]
cs1: str = parts7[1]
cs2: str = parts7[2]
stdio.printf("parts[0]='%s' [1]='%s' [2]='%s'\n", cs0, cs1, cs2)
testcheck.check(cs0 == "hello", "comma-space[0]=='hello' OK", "comma-space[0] FAILED")
testcheck.check(cs1 == "world", "comma-space[1]=='world' OK", "comma-space[1] FAILED")
testcheck.check(cs2 == "foo", "comma-space[2]=='foo' OK", "comma-space[2] FAILED")
# Test 8: 多字符分隔符在首尾
testcheck.section("Test 8: 多字符分隔符首尾 '::a::b::'")
s8: str = "::a::b::"
s8.__mbuddy__ = bd
parts8 = s8.split("::")
n8: t.CSizeT = parts8.__len__()
stdio.printf("split('::a::b::', '::') len=%lu\n", n8)
testcheck.check(n8 == 4, "edge len OK (4)", "edge len FAILED expect 4")
ed0: str = parts8[0]
ed1: str = parts8[1]
ed2: str = parts8[2]
ed3: str = parts8[3]
stdio.printf("parts[0]='%s' [1]='%s' [2]='%s' [3]='%s'\n", ed0, ed1, ed2, ed3)
testcheck.check(ed0 == "", "edge[0]=='' OK", "edge[0] FAILED")
testcheck.check(ed1 == "a", "edge[1]=='a' OK", "edge[1] FAILED")
testcheck.check(ed2 == "b", "edge[2]=='b' OK", "edge[2] FAILED")
testcheck.check(ed3 == "", "edge[3]=='' OK", "edge[3] FAILED")
# === with 上下文自动注入测试 ===
testcheck.section("Test 9: with 上下文自动注入 __mbuddy__")
arena2: bytes = stdlib.malloc(65536)
with mbuddy.MBuddy(arena2, 65536) as bd2:
# str 变量在 with 上下文内创建，__mbuddy__ 应自动注入（无需手动赋值）
w_str: str = "WithTest"
# 验证 __mbuddy__ 已自动注入（非 NULL）
w_buddy: mbuddy.MBuddy | t.CPtr = w_str.__mbuddy__
testcheck.check(t.CInt(w_buddy) != 0, "with inject OK: __mbuddy__ auto-injected", "with inject FAIL: __mbuddy__ is NULL")
# upper() 不需要手动设置 __mbuddy__
w_upper: str = w_str.upper()
stdio.printf("with upper('WithTest') = %s\n", w_upper)
testcheck.check(w_upper == "WITHTEST", "with upper OK", "with upper FAILED")
# lower() 不需要手动设置 __mbuddy__
w_lower: str = w_str.lower()
stdio.printf("with lower('WithTest') = %s\n", w_lower)
testcheck.check(w_lower == "withtest", "with lower OK", "with lower FAILED")
# split() 不需要手动设置 __mbuddy__
w_split_str: str = "x,y,z"
w_parts = w_split_str.split(',')
w_n: t.CSizeT = len(w_parts)
stdio.printf("with split('x,y,z') len=%lu\n", w_n)
testcheck.check(w_n == 3, "with split len OK (3)", "with split len FAILED")
# 验证多个 str 变量都获得注入
w_str2: str = "Multiple"
w_buddy2: mbuddy.MBuddy | t.CPtr = w_str2.__mbuddy__
testcheck.check(t.CInt(w_buddy2) != 0, "with multi inject OK", "with multi inject FAIL")
test_s: str = "www.gvsds.com"
list_s: list[str] = test_s.split('.')
# 迭代器测试: for idx, i in zip(range(len(list_s)), list_s)
iter_count: int = 0
for iter_idx, i in zip(range(len(list_s)), list_s):
stdio.printf("list_s[%d]='%s'\n", iter_idx, i)
iter_count += 1
testcheck.check(iter_count == 3, "zip(range(len), list) iter OK (3)", "zip(range(len), list) iter FAILED")
#for i in range(3):
# stdio.printf("list_s[%d]='%s'\n", i, list_s[i])
# === zip() 内置测试 ===
testcheck.section("Test 10: zip(list, list) 元组解包")
za: str = "a,b,c"
zb: str = "1,2,3"
list_a: list[str] = za.split(',')
list_b: list[str] = zb.split(',')
zip_idx: int = 0
for ca, cb in zip(list_a, list_b):
stdio.printf("zip[%d]: '%s'='%s'\n", zip_idx, ca, cb)
zip_idx += 1
testcheck.check(zip_idx == 3, "zip list+list OK (3)", "zip list+list FAILED")
testcheck.section("Test 11: zip(range, list) 混合迭代")
zip_idx2: int = 0
for n, s in zip(range(3), list_a):
stdio.printf("zip range+list[%d]: %d='%s'\n", zip_idx2, n, s)
zip_idx2 += 1
testcheck.check(zip_idx2 == 3, "zip range+list OK (3)", "zip range+list FAILED")
testcheck.section("Test 12: zip(str, str) 字符级并行")
sa: str = "abc"
sb: str = "123"
zip_idx3: int = 0
for ch_a, ch_b in zip(sa, sb):
stdio.printf("zip str+str[%d]: '%c'%c\n", zip_idx3, ch_a, ch_b)
zip_idx3 += 1
testcheck.check(zip_idx3 == 3, "zip str+str OK (3)", "zip str+str FAILED")
stdio.printf("%d\n", " ".isspace())
stdlib.free(arena2)
stdlib.free(arena)
return testcheck.end()

1
Test/FakeDuckTest/output/067c78e9f121dce3.deps.json Normal file
View File

@@ -0,0 +1 @@
{"w32.win32process": "067c78e9f121dce3", "win32process": "067c78e9f121dce3", "mbuddy": "0eaa586c42dcd931", "atom": "271ea3decb810db2", "stdint": "49bd8cba55979f76", "w32.win32base": "5a6a2137958c28c5", "win32base": "5a6a2137958c28c5", "stdlib": "6c2029b306556c00", "stdio": "73edbcf76e32d00b", "_list": "9d9d71cf83da7ca4", "testcheck": "9dbecd0942a39782", "string": "b5f1dc665c52a1bd", "_withcontent": "b9b237d0e206d76c", "w32.win32console": "bbdf3bbd4c3bc28c", "win32console": "bbdf3bbd4c3bc28c", "_fakeduck": "c6206460c42ccf10", "main": "ccd58bf663340b12", "w32.win32file": "abf9ce3160c9279e", "win32file": "abf9ce3160c9279e", "w32.fileio": "fa3691e66b426950", "fileio": "fa3691e66b426950", "w32.win32memory": "72e2d5ccb7cedcf1", "win32memory": "72e2d5ccb7cedcf1"}

1
Test/FakeDuckTest/output/06f53cc594b4ac6c.deps.json Normal file
View File

@@ -0,0 +1 @@
{"w32.win32process": "067c78e9f121dce3", "win32process": "067c78e9f121dce3", "mbuddy": "0eaa586c42dcd931", "atom": "271ea3decb810db2", "stdint": "49bd8cba55979f76", "w32.win32base": "5a6a2137958c28c5", "win32base": "5a6a2137958c28c5", "stdlib": "6c2029b306556c00", "stdio": "73edbcf76e32d00b", "_list": "9d9d71cf83da7ca4", "testcheck": "9dbecd0942a39782", "string": "b5f1dc665c52a1bd", "_withcontent": "b9b237d0e206d76c", "w32.win32console": "bbdf3bbd4c3bc28c", "win32console": "bbdf3bbd4c3bc28c", "_fakeduck": "c6206460c42ccf10", "main": "ccd58bf663340b12", "w32.win32file": "abf9ce3160c9279e", "win32file": "abf9ce3160c9279e", "w32.fileio": "fa3691e66b426950", "fileio": "fa3691e66b426950", "w32.win32memory": "72e2d5ccb7cedcf1", "win32memory": "72e2d5ccb7cedcf1", "w32.win32sync": "06f53cc594b4ac6c", "win32sync": "06f53cc594b4ac6c"}

1
Test/FakeDuckTest/output/0eaa586c42dcd931.deps.json Normal file
View File

@@ -0,0 +1 @@
{"w32.win32process": "067c78e9f121dce3", "win32process": "067c78e9f121dce3", "mbuddy": "0eaa586c42dcd931", "atom": "271ea3decb810db2", "stdint": "49bd8cba55979f76", "w32.win32base": "5a6a2137958c28c5", "win32base": "5a6a2137958c28c5", "stdlib": "6c2029b306556c00", "stdio": "73edbcf76e32d00b", "_list": "9d9d71cf83da7ca4", "testcheck": "9dbecd0942a39782", "string": "b5f1dc665c52a1bd", "_withcontent": "b9b237d0e206d76c", "w32.win32console": "bbdf3bbd4c3bc28c", "win32console": "bbdf3bbd4c3bc28c", "_fakeduck": "c6206460c42ccf10", "main": "ccd58bf663340b12"}

1
Test/FakeDuckTest/output/271ea3decb810db2.deps.json Normal file
View File

@@ -0,0 +1 @@
{"w32.win32process": "067c78e9f121dce3", "win32process": "067c78e9f121dce3", "mbuddy": "0eaa586c42dcd931", "atom": "271ea3decb810db2", "stdint": "49bd8cba55979f76", "w32.win32base": "5a6a2137958c28c5", "win32base": "5a6a2137958c28c5", "stdlib": "6c2029b306556c00", "stdio": "73edbcf76e32d00b", "_list": "9d9d71cf83da7ca4", "testcheck": "9dbecd0942a39782", "string": "b5f1dc665c52a1bd", "_withcontent": "b9b237d0e206d76c", "w32.win32console": "bbdf3bbd4c3bc28c", "win32console": "bbdf3bbd4c3bc28c", "_fakeduck": "c6206460c42ccf10", "main": "ccd58bf663340b12"}

1
Test/FakeDuckTest/output/5a6a2137958c28c5.deps.json Normal file
View File

@@ -0,0 +1 @@
{"w32.win32process": "067c78e9f121dce3", "win32process": "067c78e9f121dce3", "mbuddy": "0eaa586c42dcd931", "atom": "271ea3decb810db2", "stdint": "49bd8cba55979f76", "w32.win32base": "5a6a2137958c28c5", "win32base": "5a6a2137958c28c5", "stdlib": "6c2029b306556c00", "stdio": "73edbcf76e32d00b", "_list": "9d9d71cf83da7ca4", "testcheck": "9dbecd0942a39782", "string": "b5f1dc665c52a1bd", "_withcontent": "b9b237d0e206d76c", "w32.win32console": "bbdf3bbd4c3bc28c", "win32console": "bbdf3bbd4c3bc28c", "_fakeduck": "c6206460c42ccf10", "main": "ccd58bf663340b12"}

1
Test/FakeDuckTest/output/72e2d5ccb7cedcf1.deps.json Normal file
View File

@@ -0,0 +1 @@
{"w32.win32process": "067c78e9f121dce3", "win32process": "067c78e9f121dce3", "mbuddy": "0eaa586c42dcd931", "atom": "271ea3decb810db2", "stdint": "49bd8cba55979f76", "w32.win32base": "5a6a2137958c28c5", "win32base": "5a6a2137958c28c5", "stdlib": "6c2029b306556c00", "stdio": "73edbcf76e32d00b", "_list": "9d9d71cf83da7ca4", "testcheck": "9dbecd0942a39782", "string": "b5f1dc665c52a1bd", "_withcontent": "b9b237d0e206d76c", "w32.win32console": "bbdf3bbd4c3bc28c", "win32console": "bbdf3bbd4c3bc28c", "_fakeduck": "c6206460c42ccf10", "main": "ccd58bf663340b12", "w32.win32file": "abf9ce3160c9279e", "win32file": "abf9ce3160c9279e", "w32.fileio": "fa3691e66b426950", "fileio": "fa3691e66b426950", "w32.win32memory": "72e2d5ccb7cedcf1", "win32memory": "72e2d5ccb7cedcf1"}

1
Test/FakeDuckTest/output/9d9d71cf83da7ca4.deps.json Normal file
View File

@@ -0,0 +1 @@
{"w32.win32process": "067c78e9f121dce3", "win32process": "067c78e9f121dce3", "mbuddy": "0eaa586c42dcd931", "atom": "271ea3decb810db2", "stdint": "49bd8cba55979f76", "w32.win32base": "5a6a2137958c28c5", "win32base": "5a6a2137958c28c5", "stdlib": "6c2029b306556c00", "stdio": "73edbcf76e32d00b", "_list": "9d9d71cf83da7ca4", "testcheck": "9dbecd0942a39782", "string": "b5f1dc665c52a1bd", "_withcontent": "b9b237d0e206d76c", "w32.win32console": "bbdf3bbd4c3bc28c", "win32console": "bbdf3bbd4c3bc28c", "_fakeduck": "c6206460c42ccf10", "main": "ccd58bf663340b12"}

1
Test/FakeDuckTest/output/9dbecd0942a39782.deps.json Normal file
View File

@@ -0,0 +1 @@
{"w32.win32process": "067c78e9f121dce3", "win32process": "067c78e9f121dce3", "mbuddy": "0eaa586c42dcd931", "atom": "271ea3decb810db2", "stdint": "49bd8cba55979f76", "w32.win32base": "5a6a2137958c28c5", "win32base": "5a6a2137958c28c5", "stdlib": "6c2029b306556c00", "stdio": "73edbcf76e32d00b", "_list": "9d9d71cf83da7ca4", "testcheck": "9dbecd0942a39782", "string": "b5f1dc665c52a1bd", "_withcontent": "b9b237d0e206d76c", "w32.win32console": "bbdf3bbd4c3bc28c", "win32console": "bbdf3bbd4c3bc28c", "_fakeduck": "c6206460c42ccf10", "main": "ccd58bf663340b12"}

1
Test/FakeDuckTest/output/abf9ce3160c9279e.deps.json Normal file
View File

@@ -0,0 +1 @@
{"w32.win32process": "067c78e9f121dce3", "win32process": "067c78e9f121dce3", "mbuddy": "0eaa586c42dcd931", "atom": "271ea3decb810db2", "stdint": "49bd8cba55979f76", "w32.win32base": "5a6a2137958c28c5", "win32base": "5a6a2137958c28c5", "stdlib": "6c2029b306556c00", "stdio": "73edbcf76e32d00b", "_list": "9d9d71cf83da7ca4", "testcheck": "9dbecd0942a39782", "string": "b5f1dc665c52a1bd", "_withcontent": "b9b237d0e206d76c", "w32.win32console": "bbdf3bbd4c3bc28c", "win32console": "bbdf3bbd4c3bc28c", "_fakeduck": "c6206460c42ccf10", "main": "ccd58bf663340b12", "w32.win32file": "abf9ce3160c9279e", "win32file": "abf9ce3160c9279e"}

1
Test/FakeDuckTest/output/b5f1dc665c52a1bd.deps.json Normal file
View File

@@ -0,0 +1 @@
{"w32.win32process": "067c78e9f121dce3", "win32process": "067c78e9f121dce3", "mbuddy": "0eaa586c42dcd931", "atom": "271ea3decb810db2", "stdint": "49bd8cba55979f76", "w32.win32base": "5a6a2137958c28c5", "win32base": "5a6a2137958c28c5", "stdlib": "6c2029b306556c00", "stdio": "73edbcf76e32d00b", "_list": "9d9d71cf83da7ca4", "testcheck": "9dbecd0942a39782", "string": "b5f1dc665c52a1bd", "_withcontent": "b9b237d0e206d76c", "w32.win32console": "bbdf3bbd4c3bc28c", "win32console": "bbdf3bbd4c3bc28c", "_fakeduck": "c6206460c42ccf10", "main": "ccd58bf663340b12"}

1
Test/FakeDuckTest/output/b9b237d0e206d76c.deps.json Normal file
View File

@@ -0,0 +1 @@
{"w32.win32process": "067c78e9f121dce3", "win32process": "067c78e9f121dce3", "mbuddy": "0eaa586c42dcd931", "atom": "271ea3decb810db2", "stdint": "49bd8cba55979f76", "w32.win32base": "5a6a2137958c28c5", "win32base": "5a6a2137958c28c5", "stdlib": "6c2029b306556c00", "stdio": "73edbcf76e32d00b", "_list": "9d9d71cf83da7ca4", "testcheck": "9dbecd0942a39782", "string": "b5f1dc665c52a1bd", "_withcontent": "b9b237d0e206d76c", "w32.win32console": "bbdf3bbd4c3bc28c", "win32console": "bbdf3bbd4c3bc28c", "_fakeduck": "c6206460c42ccf10", "main": "ccd58bf663340b12", "w32.win32file": "abf9ce3160c9279e", "win32file": "abf9ce3160c9279e", "w32.fileio": "fa3691e66b426950", "fileio": "fa3691e66b426950", "w32.win32memory": "72e2d5ccb7cedcf1", "win32memory": "72e2d5ccb7cedcf1"}

1
Test/FakeDuckTest/output/bbdf3bbd4c3bc28c.deps.json Normal file
View File

@@ -0,0 +1 @@
{"w32.win32process": "067c78e9f121dce3", "win32process": "067c78e9f121dce3", "mbuddy": "0eaa586c42dcd931", "atom": "271ea3decb810db2", "stdint": "49bd8cba55979f76", "w32.win32base": "5a6a2137958c28c5", "win32base": "5a6a2137958c28c5", "stdlib": "6c2029b306556c00", "stdio": "73edbcf76e32d00b", "_list": "9d9d71cf83da7ca4", "testcheck": "9dbecd0942a39782", "string": "b5f1dc665c52a1bd", "_withcontent": "b9b237d0e206d76c", "w32.win32console": "bbdf3bbd4c3bc28c", "win32console": "bbdf3bbd4c3bc28c", "_fakeduck": "c6206460c42ccf10", "main": "ccd58bf663340b12"}

1
Test/FakeDuckTest/output/c6206460c42ccf10.deps.json Normal file
View File

@@ -0,0 +1 @@
{"w32.win32process": "067c78e9f121dce3", "win32process": "067c78e9f121dce3", "mbuddy": "0eaa586c42dcd931", "atom": "271ea3decb810db2", "stdint": "49bd8cba55979f76", "w32.win32base": "5a6a2137958c28c5", "win32base": "5a6a2137958c28c5", "stdlib": "6c2029b306556c00", "stdio": "73edbcf76e32d00b", "_list": "9d9d71cf83da7ca4", "testcheck": "9dbecd0942a39782", "string": "b5f1dc665c52a1bd", "_withcontent": "b9b237d0e206d76c", "w32.win32console": "bbdf3bbd4c3bc28c", "win32console": "bbdf3bbd4c3bc28c", "_fakeduck": "c6206460c42ccf10", "main": "ccd58bf663340b12"}

1
Test/FakeDuckTest/output/ccd58bf663340b12.deps.json Normal file
View File

@@ -0,0 +1 @@
{"w32.win32process": "067c78e9f121dce3", "win32process": "067c78e9f121dce3", "mbuddy": "0eaa586c42dcd931", "atom": "271ea3decb810db2", "stdint": "49bd8cba55979f76", "w32.win32base": "5a6a2137958c28c5", "win32base": "5a6a2137958c28c5", "stdlib": "6c2029b306556c00", "stdio": "73edbcf76e32d00b", "_list": "9d9d71cf83da7ca4", "testcheck": "9dbecd0942a39782", "string": "b5f1dc665c52a1bd", "_withcontent": "b9b237d0e206d76c", "w32.win32console": "bbdf3bbd4c3bc28c", "win32console": "bbdf3bbd4c3bc28c", "_fakeduck": "c6206460c42ccf10"}

1
Test/FakeDuckTest/output/fa3691e66b426950.deps.json Normal file
View File

@@ -0,0 +1 @@
{"w32.win32process": "067c78e9f121dce3", "win32process": "067c78e9f121dce3", "mbuddy": "0eaa586c42dcd931", "atom": "271ea3decb810db2", "stdint": "49bd8cba55979f76", "w32.win32base": "5a6a2137958c28c5", "win32base": "5a6a2137958c28c5", "stdlib": "6c2029b306556c00", "stdio": "73edbcf76e32d00b", "_list": "9d9d71cf83da7ca4", "testcheck": "9dbecd0942a39782", "string": "b5f1dc665c52a1bd", "_withcontent": "b9b237d0e206d76c", "w32.win32console": "bbdf3bbd4c3bc28c", "win32console": "bbdf3bbd4c3bc28c", "_fakeduck": "c6206460c42ccf10", "main": "ccd58bf663340b12", "w32.win32file": "abf9ce3160c9279e", "win32file": "abf9ce3160c9279e", "w32.fileio": "fa3691e66b426950", "fileio": "fa3691e66b426950"}

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

@@ -0,0 +1,29 @@
{
"$schema": "https://raw.githubusercontent.com/TermiNexus/TransPyC/main/schemas/project-schema.json",
"name": "FakeDuckTest",
"version": "1.0.0",
"source_dir": "./App",
"temp_dir": "./temp",
"output_dir": "./output",
"compiler": {
"cmd": "llc",
"flags": ["-filetype=obj", "-relocation-model=pic"]
},
"linker": {
"cmd": "clang++",
"flags": ["-lmsvcrt", "-lucrt", "-lpthread", "-lmingwex", "-lkernel32", "-Wl,--allow-multiple-definition"],
"output": "FakeDuckTest.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
}
}

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

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

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

@@ -0,0 +1,109 @@
"""
Auto-generated Python stub file from w32.win32sync.py
Module: w32.win32sync
"""
import c
import t
from stdint import *
from w32.win32base import *
class CRITICAL_SECTION:
DebugInfo: VOIDPTR
LockCount: LONG
RecursionCount: LONG
OwningThread: HANDLE
LockSemaphore: HANDLE
SpinCount: QWORD
def InitializeCriticalSection(lpCriticalSection: CRITICAL_SECTION | t.CPtr) -> VOID | t.State: pass
def EnterCriticalSection(lpCriticalSection: CRITICAL_SECTION | t.CPtr) -> VOID | t.State: pass
def LeaveCriticalSection(lpCriticalSection: CRITICAL_SECTION | t.CPtr) -> VOID | t.State: pass
def DeleteCriticalSection(lpCriticalSection: CRITICAL_SECTION | t.CPtr) -> VOID | t.State: pass
def TryEnterCriticalSection(lpCriticalSection: CRITICAL_SECTION | t.CPtr) -> BOOL | t.State: pass
def SetCriticalSectionSpinCount(lpCriticalSection: CRITICAL_SECTION | t.CPtr, dwSpinCount: ULONG) -> ULONG | t.State: pass
def InitializeCriticalSectionAndSpinCount(lpCriticalSection: CRITICAL_SECTION | t.CPtr, dwSpinCount: ULONG) -> BOOL | t.State: pass
def CreateMutexA(lpMutexAttributes: SECURITY_ATTRIBUTES | t.CPtr, bInitialOwner: BOOL, lpName: LPCSTR) -> HANDLE | t.State: pass
def CreateMutexW(lpMutexAttributes: SECURITY_ATTRIBUTES | t.CPtr, bInitialOwner: BOOL, lpName: LPCWSTR) -> HANDLE | t.State: pass
def OpenMutexA(dwDesiredAccess: ULONG, bInheritHandle: BOOL, lpName: LPCSTR) -> HANDLE | t.State: pass
def OpenMutexW(dwDesiredAccess: ULONG, bInheritHandle: BOOL, lpName: LPCWSTR) -> HANDLE | t.State: pass
def ReleaseMutex(hMutex: HANDLE) -> BOOL | t.State: pass
def CreateEventA(lpEventAttributes: SECURITY_ATTRIBUTES | t.CPtr, bManualReset: BOOL, bInitialState: BOOL, lpName: LPCSTR) -> HANDLE | t.State: pass
def CreateEventW(lpEventAttributes: SECURITY_ATTRIBUTES | t.CPtr, bManualReset: BOOL, bInitialState: BOOL, lpName: LPCWSTR) -> HANDLE | t.State: pass
def OpenEventA(dwDesiredAccess: ULONG, bInheritHandle: BOOL, lpName: LPCSTR) -> HANDLE | t.State: pass
def OpenEventW(dwDesiredAccess: ULONG, bInheritHandle: BOOL, lpName: LPCWSTR) -> HANDLE | t.State: pass
def SetEvent(hEvent: HANDLE) -> BOOL | t.State: pass
def ResetEvent(hEvent: HANDLE) -> BOOL | t.State: pass
def PulseEvent(hEvent: HANDLE) -> BOOL | t.State: pass
def CreateSemaphoreA(lpSemaphoreAttributes: SECURITY_ATTRIBUTES | t.CPtr, lInitialCount: LONG, lMaximumCount: LONG, lpName: LPCSTR) -> HANDLE | t.State: pass
def CreateSemaphoreW(lpSemaphoreAttributes: SECURITY_ATTRIBUTES | t.CPtr, lInitialCount: LONG, lMaximumCount: LONG, lpName: LPCWSTR) -> HANDLE | t.State: pass
def OpenSemaphoreA(dwDesiredAccess: ULONG, bInheritHandle: BOOL, lpName: LPCSTR) -> HANDLE | t.State: pass
def OpenSemaphoreW(dwDesiredAccess: ULONG, bInheritHandle: BOOL, lpName: LPCWSTR) -> HANDLE | t.State: pass
def ReleaseSemaphore(hSemaphore: HANDLE, lReleaseCount: LONG, lpPreviousCount: LONG | t.CPtr) -> BOOL | t.State: pass
def WaitForSingleObject(hHandle: HANDLE, dwMilliseconds: ULONG) -> ULONG | t.State: pass
def WaitForSingleObjectEx(hHandle: HANDLE, dwMilliseconds: ULONG, bAlertable: BOOL) -> ULONG | t.State: pass
def WaitForMultipleObjects(nCount: ULONG, lpHandles: VOIDPTR, bWaitAll: BOOL, dwMilliseconds: ULONG) -> ULONG | t.State: pass
def WaitForMultipleObjectsEx(nCount: ULONG, lpHandles: VOIDPTR, bWaitAll: BOOL, dwMilliseconds: ULONG, bAlertable: BOOL) -> ULONG | t.State: pass
def InitializeSRWLock(SRWLock: VOIDPTR) -> VOID | t.State: pass
def AcquireSRWLockExclusive(SRWLock: VOIDPTR) -> VOID | t.State: pass
def AcquireSRWLockShared(SRWLock: VOIDPTR) -> VOID | t.State: pass
def ReleaseSRWLockExclusive(SRWLock: VOIDPTR) -> VOID | t.State: pass
def ReleaseSRWLockShared(SRWLock: VOIDPTR) -> VOID | t.State: pass
CONDITION_VARIABLE_LOCKMODE_SHARED: t.CDefine = 0x1
def InitializeConditionVariable(ConditionVariable: VOIDPTR) -> VOID | t.State: pass
def SleepConditionVariableCS(ConditionVariable: VOIDPTR, CriticalSection: CRITICAL_SECTION | t.CPtr, dwMilliseconds: ULONG) -> BOOL | t.State: pass
def SleepConditionVariableSRW(ConditionVariable: VOIDPTR, SRWLock: VOIDPTR, dwMilliseconds: ULONG, Flags: ULONG) -> BOOL | t.State: pass
def WakeConditionVariable(ConditionVariable: VOIDPTR) -> VOID | t.State: pass
def WakeAllConditionVariable(ConditionVariable: VOIDPTR) -> VOID | t.State: pass
INIT_ONCE_STATIC_INIT: t.CDefine = 0x00000001
INIT_ONCE_CHECK_ONLY: t.CDefine = 0x00000002
INIT_ONCE_ASYNC: t.CDefine = 0x00000004
INIT_ONCE_INIT_FAILED: t.CDefine = 0x00000008
class INIT_ONCE:
Ptr: t.CPtr
def InitOnceExecuteOnce(InitOnce: INIT_ONCE | t.CPtr, InitFn: VOIDPTR, Parameter: VOIDPTR, Context: VOIDPTR | t.CPtr) -> BOOL | t.State: pass

49
Test/FakeDuckTest/temp/0eaa586c42dcd931.pyi Normal file
View File

@@ -0,0 +1,49 @@
"""
Auto-generated Python stub file from mbuddy.py
Module: mbuddy
"""
import t, c
from stdint import *
import string
import atom
MBUDDY_MIN_BLOCK: t.CDefine = 32 # 最小块大小 (字节)，需 >= 16 以容纳链表指针
MBUDDY_MAX_ORDERS: t.CDefine = 32 # 最大阶数数量
MBUDDY_HEADER_SIZE: t.CDefine = 8 # 块头大小 (存储阶数)
def _largest_pow2_le(val: t.CSizeT) -> t.CSizeT: pass
def _block_size_at_order(order: t.CInt) -> t.CSizeT: pass
class MBuddy:
__provides__: list[str] = ['__mbuddy__']
mem: t.CVoid | t.CPtr
mem_size: t.CSizeT
max_order: t.CInt
free_lists: t.CUInt64T | t.CPtr
lock_val: t.CVolatile | t.CInt
def __init__(self: MBuddy, arena: t.CVoid | t.CPtr, arena_size: t.CSizeT) -> t.CInt: pass
def __enter__(self: MBuddy) -> 'MBuddy' | t.CPtr: pass
def __exit__(self: MBuddy) -> t.CInt: pass
def reset(self: MBuddy) -> t.CInt: pass
def _fl_push(self: MBuddy, order: t.CInt, block: t.CVoid | t.CPtr) -> t.CInt: pass
def _fl_pop(self: MBuddy, order: t.CInt) -> t.CVoid | t.CPtr: pass
def _fl_find_and_remove(self: MBuddy, order: t.CInt, target: t.CVoid | t.CPtr) -> t.CInt: pass
def _buddy_of(self: MBuddy, block: t.CVoid | t.CPtr, order: t.CInt) -> t.CVoid | t.CPtr: pass
def _order_for_size(self: MBuddy, size: t.CSizeT) -> t.CInt: pass
def _split_to_order(self: MBuddy, to_order: t.CInt) -> t.CVoid | t.CPtr: pass
def _coalesce(self: MBuddy, block: t.CVoid | t.CPtr, order: t.CInt) -> t.CInt: pass
def _is_valid_ptr(self: MBuddy, ptr: t.CVoid | t.CPtr) -> t.CInt: pass
def _fl_count(self: MBuddy, order: t.CInt) -> t.CSizeT: pass
def _lock(self: MBuddy) -> t.CInt: pass
def _unlock(self: MBuddy) -> t.CInt: pass
def alloc(self: MBuddy, size: t.CSizeT) -> t.CVoid | t.CPtr: pass
def free(self: MBuddy, ptr: t.CVoid | t.CPtr) -> t.CInt: pass
def calloc(self: MBuddy, count: t.CSizeT, size: t.CSizeT) -> t.CVoid | t.CPtr: pass
def realloc(self: MBuddy, ptr: t.CVoid | t.CPtr, new_size: t.CSizeT) -> t.CVoid | t.CPtr: pass
def stats(self: MBuddy) -> t.CSizeT: pass
def free_count(self: MBuddy) -> t.CSizeT: pass
def self_check(self: MBuddy) -> t.CInt: pass

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

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

75
Test/FakeDuckTest/temp/49bd8cba55979f76.pyi Normal file
View File

@@ -0,0 +1,75 @@
"""
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
i8: t.CTypedef = t.CInt8T
i16: t.CTypedef = t.CInt16T
i32: t.CTypedef = t.CInt32T
i64: t.CTypedef = t.CInt64T
u8: t.CTypedef = t.CUInt8T
u16: t.CTypedef = t.CUInt16T
u32: t.CTypedef = t.CUInt32T
u64: t.CTypedef = t.CUInt64T

98
Test/FakeDuckTest/temp/5a6a2137958c28c5.pyi Normal file
View File

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

18
Test/FakeDuckTest/temp/6c2029b306556c00.pyi Normal file
View File

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

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

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

28
Test/FakeDuckTest/temp/73edbcf76e32d00b.pyi Normal file
View File

@@ -0,0 +1,28 @@
"""
Auto-generated Python stub file from stdio.py
Module: stdio
"""
import t, c
def printf(fmt: t.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

29
Test/FakeDuckTest/temp/9d9d71cf83da7ca4.pyi Normal file
View File

@@ -0,0 +1,29 @@
"""
Auto-generated Python stub file from _list.py
Module: _list
"""
import t, c
import mbuddy
import string
from stdint import *
class list[T]:
__data__: t.CVoid | t.CPtr
__count__: t.CSizeT
__capacity__: t.CSizeT
__mbuddy__: mbuddy.MBuddy | t.CPtr
__iter_index__: t.CSizeT
def __new__(self: list, mb: mbuddy.MBuddy | t.CPtr) -> t.CInt: pass
def __init__(self: list, mb: mbuddy.MBuddy | t.CPtr) -> t.CInt: pass
def __len__(self: list) -> t.CSizeT: pass
def append(self: list, item: T) -> t.CInt: pass
def get(self: list, index: t.CSizeT) -> T: pass
def __getitem__(self: list, index: t.CSizeT) -> T: pass
def set(self: list, index: t.CSizeT, value: T) -> t.CInt: pass
def __setitem__(self: list, index: t.CSizeT, value: T) -> t.CInt: pass
def pop(self: list) -> T: pass
def clear(self: list) -> t.CInt: pass
def __iter__(self: list) -> t.CInt: pass
def __next__(self: list) -> T: pass

25
Test/FakeDuckTest/temp/9dbecd0942a39782.pyi Normal file
View File

@@ -0,0 +1,25 @@
"""
Auto-generated Python stub file from testcheck.py
Module: testcheck
"""
import t, c
import stdio
_pass_count: t.CExtern | t.CInt
_fail_count: t.CExtern | t.CInt
def begin(name: str) -> t.CInt: pass
def section(name: str) -> t.CInt: pass
def ok(msg: str) -> t.CInt: pass
def fail(msg: str) -> t.CInt: pass
def check(cond: t.CInt, ok_msg: str, fail_msg: str) -> t.CInt: pass
def info(msg: str) -> t.CInt: pass
def end() -> t.CInt: pass

14
Test/FakeDuckTest/temp/_sha1_map.txt Normal file
View File

@@ -0,0 +1,14 @@
067c78e9f121dce3:includes/w32\win32process.py
0eaa586c42dcd931:includes/mbuddy.py
271ea3decb810db2:includes/atom.py
49bd8cba55979f76:includes/stdint.py
5a6a2137958c28c5:includes/w32\win32base.py
6c2029b306556c00:includes/stdlib.py
73edbcf76e32d00b:includes/stdio.py
9d9d71cf83da7ca4:includes/_list.py
9dbecd0942a39782:includes/testcheck.py
b5f1dc665c52a1bd:includes/string.py
b9b237d0e206d76c:includes/_withcontent.py
bbdf3bbd4c3bc28c:includes/w32\win32console.py
c6206460c42ccf10:includes/_fakeduck.py
ccd58bf663340b12:main.py

179
Test/FakeDuckTest/temp/abf9ce3160c9279e.pyi Normal file
View File

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

44
Test/FakeDuckTest/temp/b5f1dc665c52a1bd.pyi Normal file
View File

@@ -0,0 +1,44 @@
"""
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 atoll(src: str) -> t.CInt64T: pass
def atof(src: str) -> t.CDouble: pass
def split(s: str, delim: str, result: t.CArray[str]) -> int: pass

33
Test/FakeDuckTest/temp/b9b237d0e206d76c.pyi Normal file
View File

@@ -0,0 +1,33 @@
"""
Auto-generated Python stub file from _withcontent.py
Module: _withcontent
"""
import t, c
from stdint import *
from w32.win32process import TlsAlloc, TlsGetValue, TlsSetValue
import stdlib
import stdio
import string
_MAX_PROVIDER_DEPTH: t.CDefine = 32
@t.Object
class _ProviderStack:
names: t.CArray[VOIDPTR, 32]
ptrs: t.CArray[VOIDPTR, 32]
top: UINT64
_tls_index: t.CExtern | ULONG
@t.TLS
def _init_tls() -> t.CInt: pass
def _get_stack() -> _ProviderStack | t.CPtr: pass
def _push_provider(field_name: str, ptr: t.CPtr) -> t.CInt: pass
def _pop_provider() -> t.CInt: pass
def _find_provider(field_name: str) -> t.CPtr: pass

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

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

35
Test/FakeDuckTest/temp/c6206460c42ccf10.pyi Normal file
View File

@@ -0,0 +1,35 @@
"""
Auto-generated Python stub file from _fakeduck.py
Module: _fakeduck
"""
import c
import t
import mbuddy
import string
class _Type:
def type_id(self: _Type) -> int: pass
class _str:
__requires__: list[str] = ['__mbuddy__']
__data__: str
__mbuddy__: mbuddy.MBuddy | t.CPtr
def b(self: _str) -> int: pass
def SELF(self: _str) -> str: pass
def upper(self: _str) -> str: pass
def lower(self: _str) -> str: pass
def capitalize(self: _str) -> str: pass
def swapcase(self: _str) -> str: pass
def title(self: _str) -> str: pass
def casefold(self: _str) -> str: pass
def isupper(self: _str) -> bool: pass
def islower(self: _str) -> bool: pass
def isalpha(self: _str) -> bool: pass
def isdigit(self: _str) -> bool: pass
def isalnum(self: _str) -> bool: pass
def isspace(self: _str) -> bool: pass
def isascii(self: _str) -> bool: pass
def istitle(self: _str) -> bool: pass
def split(self: _str, delimiter: str) -> list[str]: pass

19
Test/FakeDuckTest/temp/ccd58bf663340b12.pyi Normal file
View File

@@ -0,0 +1,19 @@
"""
Auto-generated Python stub file from main.py
Module: main
"""
from stdint import *
import w32.win32console
import t, c
from t import CInt, CExport
import _fakeduck
import stdio
import stdlib
import string
import mbuddy
import testcheck
import _withcontent
def main() -> CInt | CExport: pass

80
Test/FakeDuckTest/temp/fa3691e66b426950.pyi Normal file
View File

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