补充

Test/TestProject3/temp/087c910044fab2d2.pyi

@@ -0,0 +1,30 @@
+"""
+Auto-generated Python stub file from fileiotest.py
+Module: fileiotest
+"""
+
+
+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() -> t.CVoid: pass
+
+def fileio_with_test() -> t.CVoid: pass
+
+def fileio_handle_test() -> t.CVoid: pass
+
+def fileio_rw_test() -> t.CVoid: pass
+
+def fileio_wide_test() -> t.CVoid: pass
+
+def fileio_chinese_test() -> t.CVoid: pass

Test/TestProject3/temp/0f4d14c17bf75b10.pyi

@@ -0,0 +1,130 @@
+"""
+Auto-generated Python stub file from main.py
+Module: main
+"""
+
+
+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 definetest
+import enumtest
+import mpooltest
+import vectortest
+import fileiotest
+
+def add[T](a: T, b: T) -> T: pass
+
+def add_u64[T](a: T, b: T, c: CUInt64T) -> T: pass
+
+def fxi[T1, T2](a: T1, b: T2) -> T1: pass
+
+def fxi2[T1, T2, T3](a: T1, b: T2, c: T3) -> T1: pass
+
+def wrap_add[T](a: T, b: T) -> T: pass
+
+def double_add[T](a: T, b: T) -> T: pass
+
+
+class A[T]:
+    def __init__(self: A, a: T) -> t.CVoid: pass
+    def get_a(self: A) -> T: pass
+class Pair[T1, T2]:
+    def __init__(self: Pair, first: T1, second: T2) -> t.CVoid: pass
+    def get_first(self: Pair) -> T1: pass
+    def get_second(self: Pair) -> T2: pass
+class Calculator[T]:
+    def __init__(self: Calculator, init_val: T) -> t.CVoid: pass
+    def compute(self: Calculator, other: T) -> T: pass
+    def double_compute(self: Calculator, other: T) -> T: pass
+class Container[T]:
+    def __init__(self: Container, v: T) -> t.CVoid: pass
+    def get_value(self: Container) -> T: pass
+    def get_flag(self: Container) -> CInt32T: pass
+@t.CVTable
+class Shape:
+    def __init__(self: Shape, x: CFloat64T, y: CFloat64T) -> t.CVoid: pass
+    def area(self: Shape) -> CFloat64T: pass
+    def perimeter(self: Shape) -> CFloat64T: pass
+    def describe(self: Shape) -> CFloat64T: pass
+@t.CVTable
+class Circle(Shape):
+    def __init__(self: Circle, x: CFloat64T, y: CFloat64T, r: CFloat64T) -> t.CVoid: pass
+    def area(self: Circle) -> CFloat64T: pass
+    def perimeter(self: Circle) -> CFloat64T: pass
+    def scale(self: Circle, factor: CFloat64T) -> 'Circle' | CPtr: pass
+    def move(self: Circle, dx: CFloat64T, dy: CFloat64T) -> 'Circle' | CPtr: pass
+@t.CVTable
+class Rect(Shape):
+    def __init__(self: Rect, x: CFloat64T, y: CFloat64T, w: CFloat64T, h: CFloat64T) -> t.CVoid: pass
+    def area(self: Rect) -> CFloat64T: pass
+    def perimeter(self: Rect) -> CFloat64T: pass
+    def scale(self: Rect, factor: CFloat64T) -> 'Rect' | CPtr: pass
+class Vec2:
+    x: CFloat64T
+    y: CFloat64T
+    def __new__() -> 'Vec2' | CPtr: pass
+    def __init__(self: Vec2, x: CFloat64T, y: CFloat64T) -> t.CVoid: pass
+    def __add__(self: Vec2, b: 'Vec2' | CPtr) -> 'Vec2' | CPtr: pass
+    def __sub__(self: Vec2, b: 'Vec2' | CPtr) -> 'Vec2' | CPtr: pass
+    def __mul__(self: Vec2, s: CFloat64T) -> 'Vec2' | CPtr: pass
+    def __neg__(self: Vec2) -> 'Vec2' | CPtr: pass
+    def dot(self: Vec2, b: 'Vec2' | CPtr) -> CFloat64T: pass
+    def len_sq(self: Vec2) -> CFloat64T: pass
+class Vec3:
+    x: CFloat64T
+    y: CFloat64T
+    z: CFloat64T
+    def __new__() -> 'Vec3' | CPtr: pass
+    def __init__(self: Vec3, x: CFloat64T, y: CFloat64T, z: CFloat64T) -> t.CVoid: pass
+    def __add__(self: Vec3, b: 'Vec3' | CPtr) -> 'Vec3' | CPtr: pass
+    def __sub__(self: Vec3, b: 'Vec3' | CPtr) -> 'Vec3' | CPtr: pass
+    def __mul__(self: Vec3, s: CFloat64T) -> 'Vec3' | CPtr: pass
+    def __neg__(self: Vec3) -> 'Vec3' | CPtr: pass
+    def dot(self: Vec3, b: 'Vec3' | CPtr) -> CFloat64T: pass
+    def cross(self: Vec3, b: 'Vec3' | CPtr) -> 'Vec3' | CPtr: pass
+    def len_sq(self: Vec3) -> CFloat64T: pass
+@t.CVTable
+class Dog:
+    def __init__(self: Dog, name_val: CInt, bark_power: CInt32T) -> t.CVoid: pass
+    def speak(self: Dog) -> CInt: pass
+    def bite(self: Dog) -> CInt32T: pass
+    def take_damage(self: Dog, dmg: CInt32T) -> 'Dog' | CPtr: pass
+    def is_alive(self: Dog) -> CInt: pass
+@t.CVTable
+class Cat:
+    def __init__(self: Cat, name_val: CInt, lives: CInt32T) -> t.CVoid: pass
+    def speak(self: Cat) -> CInt: pass
+    def scratch(self: Cat) -> CInt32T: pass
+    def take_damage(self: Cat, dmg: CInt32T) -> 'Cat' | CPtr: pass
+    def is_alive(self: Cat) -> CInt: pass
+class Transform:
+    px: CFloat64T
+    py: CFloat64T
+    pz: CFloat64T
+    scale_x: CFloat64T
+    scale_y: CFloat64T
+    scale_z: CFloat64T
+    def __new__() -> 'Transform' | CPtr: pass
+    def __init__(self: Transform, px: CFloat64T, py: CFloat64T, pz: CFloat64T) -> t.CVoid: pass
+    def apply_scale(self: Transform, sx: CFloat64T, sy: CFloat64T, sz: CFloat64T) -> 'Transform' | CPtr: pass
+    def world_position(self: Transform) -> 'Vec3' | CPtr: pass
+@t.CVTable
+class Vehicle:
+    def __init__(self: Vehicle, speed: CInt32T) -> t.CVoid: pass
+    def move(self: Vehicle) -> CInt: pass
+    def is_running(self: Vehicle) -> CInt: pass
+@t.CVTable
+class Car(Vehicle):
+    def __init__(self: Car, speed: CInt32T, doors: CInt32T) -> t.CVoid: pass
+    def honk(self: Car) -> CInt: pass
+@t.CVTable
+class ElectricCar(Car):
+    def __init__(self: ElectricCar, speed: CInt32T, doors: CInt32T, battery: CInt32T) -> t.CVoid: pass
+    def charge(self: ElectricCar) -> t.CVoid: pass
+    def move(self: ElectricCar) -> CInt: pass
+
+def main() -> CInt | CExport: pass

Test/TestProject3/temp/1b58766d38d05de3.pyi

@@ -0,0 +1,35 @@
+"""
+Auto-generated Python stub file from enumtest.py
+Module: enumtest
+"""
+
+
+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: pass

Test/TestProject3/temp/21ffad37f6fc3fcf.pyi

@@ -0,0 +1,44 @@
+"""
+Auto-generated Python stub file from mpool.py
+Module: mpool
+"""
+
+
+import t, c
+from stdint import *
+import viperio
+import string
+
+MPOOL_ALIGN: t.CDefine = 8
+MPOOL_TYPE_SLAB: t.CDefine = 0
+MPOOL_TYPE_BUMP: t.CDefine = 2
+
+def _align_up(val: t.CSizeT, align: t.CSizeT) -> t.CSizeT: pass
+
+
+class MPool:
+    mtype: t.CInt
+    mem: t.CVoid | t.CPtr
+    mem_size: t.CSizeT
+    offset: t.CSizeT
+    high_water: t.CSizeT
+    block_size: t.CSizeT
+    block_count: t.CSizeT
+    used_count: t.CSizeT
+    free_list: t.CVoid | t.CPtr
+    alloc_map: t.CUInt8T | t.CPtr
+    alloc_map_size: t.CSizeT
+    def __init__(self: MPool, mem: t.CVoid | t.CPtr, mem_size: t.CSizeT, block_size: t.CSizeT) -> t.CVoid: pass
+    def _init_bump(self: MPool, mem: t.CVoid | t.CPtr, mem_size: t.CSizeT) -> t.CVoid: pass
+    def _init_slab(self: MPool, mem: t.CVoid | t.CPtr, mem_size: t.CSizeT, block_size: t.CSizeT) -> t.CVoid: pass
+    def __enter__(self: MPool) -> 'MPool' | t.CPtr: pass
+    def __exit__(self: MPool) -> t.CVoid: pass
+    def _slab_reset(self: MPool) -> t.CVoid: pass
+    def alloc(self: MPool, size: t.CSizeT) -> t.CVoid | t.CPtr: pass
+    def alloc_buf(self: MPool, capacity: t.CSizeT) -> viperio.Buf | t.CPtr: pass
+    def free(self: MPool, ptr: t.CVoid | t.CPtr) -> t.CVoid: pass
+    def realloc(self: MPool, ptr: t.CVoid | t.CPtr, old_size: t.CSizeT, new_size: t.CSizeT) -> t.CVoid | t.CPtr: pass
+    def reset(self: MPool) -> t.CVoid: pass
+    def _bump_alloc(self: MPool, size: t.CSizeT) -> t.CVoid | t.CPtr: pass
+    def _slab_alloc(self: MPool) -> t.CVoid | t.CPtr: pass
+    def _slab_free(self: MPool, ptr: t.CVoid | t.CPtr) -> t.CVoid: pass

Test/TestProject3/temp/3fdd11bdd589aa8c.pyi

@@ -0,0 +1,24 @@
+"""
+Auto-generated Python stub file from vector.py
+Module: vector
+"""
+
+
+import t, c
+from stdint import *
+import mpool
+
+class Vector[T]:
+    data: t.CVoid | t.CPtr
+    length: t.CSizeT
+    capacity: t.CSizeT
+    elem_size: t.CSizeT
+    pool: mpool.MPool | t.CPtr
+    def __init__(self: Vector, pool: mpool.MPool | t.CPtr, capacity: t.CSizeT, _hint: T) -> t.CVoid: pass
+    def push(self: Vector, value: T) -> t.CVoid: pass
+    def _grow(self: Vector) -> t.CVoid: pass
+    def get(self: Vector, index: t.CSizeT) -> T: pass
+    def set(self: Vector, index: t.CSizeT, value: T) -> t.CVoid: pass
+    def len(self: Vector) -> t.CSizeT: pass
+    def clear(self: Vector) -> t.CVoid: pass
+    def free(self: Vector) -> t.CVoid: pass

Test/TestProject3/temp/4d342c40331fc964.pyi

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

Test/TestProject3/temp/5325ec533a59d71b.pyi

@@ -0,0 +1,14 @@
+"""
+Auto-generated Python stub file from mpooltest.py
+Module: mpooltest
+"""
+
+
+import t, c
+from t import CInt, CPtr, CChar
+import viperlib
+import viperio
+import stdlib
+import mpool
+
+def mpool_main() -> CInt: pass

Test/TestProject3/temp/56cdd754a8a09347.pyi

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

Test/TestProject3/temp/5a6a2137958c28c5.pyi

@@ -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

Test/TestProject3/temp/64ac83614c9bdbc6.pyi

@@ -0,0 +1,81 @@
+"""
+Auto-generated Python stub file from definetest.py
+Module: definetest
+"""
+
+
+import t, c
+from t import CInt, CInt32T, CUInt32T, CUInt64T, CFloat64T, CPtr, CChar, CDefine, CUInt16T
+import viperlib
+import stdlib
+import platmacro
+
+MAX_SIZE: t.CDefine = 1024
+MIN_VAL: t.CDefine = 0
+MAX_VAL: t.CDefine = 100
+MASK_BYTE: t.CDefine = 0xFF
+SHIFT_BITS: t.CDefine = 8
+PI_INT: t.CDefine = 3
+ENABLED: t.CDefine = 1
+DISABLED: t.CDefine = 0
+PAGE_SIZE: t.CDefine = 4096
+BUFFER_LEN: t.CDefine = 256
+CODE_SEG:  t.CDefine | t.CUInt16T = 0x08
+DATA_SEG:  t.CDefine | t.CUInt16T = 0x10
+STACK_SEG: t.CDefine | t.CUInt16T = 0x20
+
+def MAKE_FLAG(bit: CInt32T) -> t.CDefine:
+    pass
+
+def CLAMP(x: CInt32T, lo: CInt32T, hi: CInt32T) -> t.CDefine:
+    pass
+
+def test_basic_define() -> CInt: pass
+
+def test_define_arithmetic() -> CInt: pass
+
+def test_define_conditional() -> CInt: pass
+
+def test_define_loop() -> CInt: pass
+
+def test_typed_define() -> CInt: pass
+
+def test_define_function() -> CInt: pass
+
+def test_define_clamp() -> CInt: pass
+
+def test_define_string() -> CInt: pass
+
+def test_define_combined() -> CInt: pass
+
+def test_cif_basic() -> CInt: pass
+
+def test_cif_elif_else() -> CInt: pass
+
+def test_cifdef_cifndef() -> CInt: pass
+
+def test_cif_platform() -> CInt: pass
+
+def test_cif_nested() -> CInt: pass
+
+def test_cif_expr() -> CInt: pass
+
+def test_platmacro_platform() -> CInt: pass
+
+def test_platmacro_sizes() -> CInt: pass
+
+def test_platmacro_endian() -> CInt: pass
+
+def test_platmacro_features() -> CInt: pass
+
+def test_platmacro_align() -> CInt: pass
+
+def test_cifdef_cross_module() -> CInt: pass
+
+def test_cifdef_guard() -> CInt: pass
+
+def test_cifdef_undefined() -> CInt: pass
+
+def test_cifdef_complex() -> CInt: pass
+
+def define_main() -> CInt: pass

Test/TestProject3/temp/71e0a3ffcb3ebfad.pyi

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

Test/TestProject3/temp/93c1d18e35d188d6.pyi

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

Test/TestProject3/temp/_sha1_map.txt

@@ -0,0 +1,19 @@
+087c910044fab2d2:fileiotest.py
+0f4d14c17bf75b10:main.py
+1b58766d38d05de3:enumtest.py
+21ffad37f6fc3fcf:includes/mpool.py
+3fdd11bdd589aa8c:includes/vector.py
+4d342c40331fc964:includes/viperlib.py
+5325ec533a59d71b:mpooltest.py
+56cdd754a8a09347:includes/stdint.py
+5a6a2137958c28c5:includes/w32\win32base.py
+64ac83614c9bdbc6:definetest.py
+71e0a3ffcb3ebfad:includes/stdarg.py
+93c1d18e35d188d6:includes/platmacro.py
+a326a52b7c4bd6f0:includes/string.py
+a96738831f025829:includes/stdlib.py
+abf9ce3160c9279e:includes/w32\win32file.py
+bbdf3bbd4c3bc28c:includes/w32\win32console.py
+c9f4be41ca1cc2b4:includes/viperio.py
+fa3691e66b426950:includes/w32\fileio.py
+fc49f6314bad25e9:vectortest.py

Test/TestProject3/temp/a326a52b7c4bd6f0.pyi

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

Test/TestProject3/temp/a96738831f025829.pyi

@@ -0,0 +1,16 @@
+"""
+Auto-generated Python stub file from stdlib.py
+Module: stdlib
+"""
+
+import c
+
+
+from stdint import *
+import t
+
+def malloc(size: UINT) -> t.CVoid | t.CPtr | t.State | t.CExtern | t.CExport: pass
+
+def realloc(p: str, p2: t.CLong | t.CLong) -> 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

Test/TestProject3/temp/abf9ce3160c9279e.pyi

@@ -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

Test/TestProject3/temp/bbdf3bbd4c3bc28c.pyi

@@ -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

Test/TestProject3/temp/c9f4be41ca1cc2b4.pyi

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

Test/TestProject3/temp/fa3691e66b426950.pyi

@@ -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.CVoid: pass
+    def __enter__(self: File) -> 'File' | t.CPtr: pass
+    def __exit__(self: File) -> t.CVoid: 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.CVoid: pass
+    def __enter__(self: FileW) -> 'FileW' | t.CPtr: pass
+    def __exit__(self: FileW) -> t.CVoid: 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

Test/TestProject3/temp/fc49f6314bad25e9.pyi

@@ -0,0 +1,16 @@
+"""
+Auto-generated Python stub file from vectortest.py
+Module: vectortest
+"""
+
+
+import t, c
+from t import CInt, CPtr, CChar, CFloat64T
+import viperlib
+import stdlib
+import vector
+import mpool
+
+POOL_SIZE: t.CDefine = 4096
+
+def vector_main() -> CInt: pass