snapshot before regression test

Test/TestProject/temp/271ea3decb810db2.pyi

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

Test/TestProject/temp/3cd87018ba1e76bc.doc.json

@@ -0,0 +1 @@
+{}

Test/TestProject/temp/3cd87018ba1e76bc.pyi

@@ -0,0 +1,108 @@
+"""
+Auto-generated Python stub file from test_numpy.py
+Module: test_numpy
+"""
+
+
+from stdint import *
+import numpy
+from stdio import printf
+from stdlib import calloc, free
+import string
+import vipermath
+import memhub
+import t, c
+
+EPS: t.CExtern | t.CDouble
+EPS_LOOSE: t.CExtern | t.CDouble
+SIMD_BLOCK: t.CExtern | t.CSizeT
+arena: t.CExtern | t.CUInt8T | t.CPtr
+pool: t.CExtern | memhub.MemPool | t.CPtr
+test_passed: t.CExtern | t.CInt
+test_failed: t.CExtern | t.CInt
+
+def check(name: str, condition: t.CInt, detail: str) -> t.CInt: pass
+
+def approx_eq(a: t.CDouble, b: t.CDouble) -> t.CInt: pass
+
+def approx_loose(a: t.CDouble, b: t.CDouble) -> t.CInt: pass
+
+def section_header(title: str) -> t.CInt: pass
+
+def section_footer() -> t.CInt: pass
+
+def vec4(p: memhub.MemPool | t.CPtr, v0: t.CDouble, v1: t.CDouble, v2: t.CDouble, v3: t.CDouble) -> numpy.ndarray | t.CPtr: pass
+
+def vec3(p: memhub.MemPool | t.CPtr, v0: t.CDouble, v1: t.CDouble, v2: t.CDouble) -> numpy.ndarray | t.CPtr: pass
+
+def vec2(p: memhub.MemPool | t.CPtr, v0: t.CDouble, v1: t.CDouble) -> numpy.ndarray | t.CPtr: pass
+
+def test_zeros_ones() -> t.CInt: pass
+
+def test_arange_linspace() -> t.CInt: pass
+
+def test_eye_diag() -> t.CInt: pass
+
+def test_sum_mean_min_max() -> t.CInt: pass
+
+def test_fill_copy() -> t.CInt: pass
+
+def test_add_sub_mul_div() -> t.CInt: pass
+
+def test_neg() -> t.CInt: pass
+
+def test_len() -> t.CInt: pass
+
+def test_scalar_ops() -> t.CInt: pass
+
+def test_math_funcs() -> t.CInt: pass
+
+def test_matmul() -> t.CInt: pass
+
+def test_dot() -> t.CInt: pass
+
+def test_transpose() -> t.CInt: pass
+
+def test_var_std_norm() -> t.CInt: pass
+
+def test_clip_concatenate() -> t.CInt: pass
+
+def test_sort_reverse() -> t.CInt: pass
+
+def test_print_arr() -> t.CInt: pass
+
+def test_floordiv_mod() -> t.CInt: pass
+
+def test_additional_math() -> t.CInt: pass
+
+def test_trig_hyperbolic() -> t.CInt: pass
+
+def test_degrees_radians() -> t.CInt: pass
+
+def test_cumsum_diff() -> t.CInt: pass
+
+def test_max_min_where() -> t.CInt: pass
+
+def test_flatten_trace() -> t.CInt: pass
+
+def test_outer() -> t.CInt: pass
+
+def test_bool_comparison() -> t.CInt: pass
+
+def test_linalg() -> t.CInt: pass
+
+def test_additional_creation() -> t.CInt: pass
+
+def test_interp() -> t.CInt: pass
+
+def test_numpy_edge() -> t.CInt: pass
+
+def bench_numpy_perf() -> t.CInt: pass
+
+def test_numpy_correct() -> t.CInt: pass
+
+def test_numpy_edge_main() -> t.CInt: pass
+
+def bench_numpy_main() -> t.CInt: pass
+
+def test_numpy_main() -> t.CInt: pass

Test/TestProject/temp/3f7c5e78d8652535.pyi

@@ -0,0 +1,128 @@
+"""
+Auto-generated Python stub file from vipermath.py
+Module: vipermath
+"""
+
+
+import t, c
+
+U_M_PI:   t.CDefine = 3.14159265358979323846
+U_M_E:    t.CDefine = 2.71828182845904523536
+U_M_PI_2: t.CDefine = 1.57079632679489661923
+U_M_PI_4: t.CDefine = 0.78539816339744830962
+U_M_1_PI: t.CDefine = 0.31830988618379067154
+U_M_2_PI: t.CDefine = 0.63661977236758134308
+U_M_LN2:  t.CDefine = 0.69314718055994530942
+U_M_LN10: t.CDefine = 2.30258509299404568402
+U_M_2_SQRT_PI: t.CDefine = 1.77245385090551602730
+
+def radians(degrees: t.CDouble) -> t.CDouble: pass
+
+def degrees(radians: t.CDouble) -> t.CDouble: pass
+
+def sin(x: t.CDouble) -> t.CDouble: pass
+
+def cos(x: t.CDouble) -> t.CDouble: pass
+
+def tan(x: t.CDouble) -> t.CDouble: pass
+
+def asin(x: t.CDouble) -> t.CDouble: pass
+
+def acos(x: t.CDouble) -> t.CDouble: pass
+
+def _atan_core(x: t.CDouble) -> t.CDouble: pass
+
+def atan(x: t.CDouble) -> t.CDouble: pass
+
+def atan2(y: t.CDouble, x: t.CDouble) -> t.CDouble: pass
+
+def sinh(x: t.CDouble) -> t.CDouble: pass
+
+def cosh(x: t.CDouble) -> t.CDouble: pass
+
+def tanh(x: t.CDouble) -> t.CDouble: pass
+
+def exp(x: t.CDouble) -> t.CDouble: pass
+
+def log(x: t.CDouble) -> t.CDouble: pass
+
+def sqrt(x: t.CDouble) -> t.CDouble: pass
+
+def abs(x: t.CInt) -> t.CInt: pass
+
+def fabs(x: t.CDouble) -> t.CDouble: pass
+
+def labs(x: t.CLong) -> t.CLong: pass
+
+def factorial(n: t.CInt) -> t.CDouble: pass
+
+def combination(n: t.CInt, k: t.CInt) -> t.CDouble: pass
+
+def permutation(n: t.CInt, k: t.CInt) -> t.CDouble: pass
+
+def pow(x: t.CDouble, y: t.CDouble) -> t.CDouble: pass
+
+def powf(x: t.CDouble, y: t.CDouble) -> t.CDouble: pass
+
+def cbrt(x: t.CDouble) -> t.CDouble: pass
+
+def hypot(x: t.CDouble, y: t.CDouble) -> t.CDouble: pass
+
+def floor(x: t.CDouble) -> t.CDouble: pass
+
+def ceil(x: t.CDouble) -> t.CDouble: pass
+
+def round(x: t.CDouble) -> t.CDouble: pass
+
+def trunc(x: t.CDouble) -> t.CDouble: pass
+
+def fmod(x: t.CDouble, y: t.CDouble) -> t.CDouble: pass
+
+def fmodf(x: float, y: float) -> float: pass
+
+def modf(x: t.CDouble, iptr: t.CDouble | t.CPtr) -> t.CDouble: pass
+
+def log10(x: t.CDouble) -> t.CDouble: pass
+
+def log2(x: t.CDouble) -> t.CDouble: pass
+
+def exp2(x: t.CDouble) -> t.CDouble: pass
+
+def expm1(x: t.CDouble) -> t.CDouble: pass
+
+def log1p(x: t.CDouble) -> t.CDouble: pass
+
+def asinh(x: t.CDouble) -> t.CDouble: pass
+
+def acosh(x: t.CDouble) -> t.CDouble: pass
+
+def atanh(x: t.CDouble) -> t.CDouble: pass
+
+def gamma(x: t.CDouble) -> t.CDouble: pass
+
+def erf(x: t.CDouble) -> t.CDouble: pass
+
+def erfc(x: t.CDouble) -> t.CDouble: pass
+
+def sqrtf(x: t.CFloat) -> t.CFloat: pass
+
+def sinf(x: t.CFloat) -> t.CFloat: pass
+
+def cosf(x: t.CFloat) -> t.CFloat: pass
+
+def tanf(x: t.CFloat) -> t.CFloat: pass
+
+def fabsf(x: t.CFloat) -> t.CFloat: pass
+
+def floorf(x: t.CFloat) -> t.CFloat: pass
+
+def ceilf(x: t.CFloat) -> t.CFloat: pass
+
+
+class _U(t.CUnion):
+    d: t.CDouble
+    u: t.CUInt64T
+
+def isnan(x: t.CDouble) -> t.CStatic | t.CInt: pass
+
+def isinf(x: t.CDouble) -> t.CStatic | t.CInt: pass

Test/TestProject/temp/49cae05490a513cb.doc.json

@@ -0,0 +1 @@
+{}

Test/TestProject/temp/49cae05490a513cb.pyi

@@ -0,0 +1,19 @@
+"""
+Auto-generated Python stub file from main.py
+Module: main
+"""
+
+import t
+import c
+
+
+import stdio
+import stdint
+import zc.config as config
+import zc.test as test
+import zc.logic_test as logic
+import zc.class_test as class_test
+import testcheck
+import test_numpy
+
+def main() -> stdint.INT: pass

Test/TestProject/temp/6f62fe05c5ea1ceb.pyi

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

Test/TestProject/temp/75583f20a922ab2e.doc.json

@@ -0,0 +1 @@
+{}

Test/TestProject/temp/75583f20a922ab2e.pyi

@@ -0,0 +1,38 @@
+"""
+Auto-generated Python stub file from zc.test.py
+Module: zc.test
+"""
+
+
+import config
+import t, c
+
+def AboutSizeTWhileTest(length: t.CSizeT) -> t.CInt: pass
+
+def MathBasicTest(x: t.CInt, y: t.CInt) -> t.CInt: pass
+
+def MathAdvancedTest(value: t.CInt) -> t.CInt: pass
+
+def WhileWithElifElseTest(start: t.CInt, end: t.CInt) -> t.CInt: pass
+
+def NestedWhileWithMacrosTest(outer_limit: t.CInt, inner_limit: t.CInt) -> t.CInt: pass
+
+def ComplexConditionTest(a: t.CInt, b: t.CInt, c_val: t.CInt) -> t.CInt: pass
+
+def RetryLoopTest(retry_count: t.CInt) -> t.CInt: pass
+
+def BitwiseOperationsTest(value: t.CInt) -> t.CInt: pass
+
+def CompoundAssignmentMathTest(a: t.CInt, b: t.CInt) -> t.CInt: pass
+
+def PowerAndModuloTest(base: t.CInt, exponent: t.CInt) -> t.CInt: pass
+
+def MixedArithmeticTest(x: t.CInt, y: t.CInt, z: t.CInt) -> t.CInt: pass
+
+def MathWithWhileLoopTest(start: t.CInt, count: t.CInt) -> t.CInt: pass
+
+def ComplexNestedMathTest(a: t.CInt, b: t.CInt) -> t.CInt: pass
+
+def ConditionalMathChainTest(value: t.CInt) -> t.CInt: pass
+
+def BitManipulationMathTest(value: t.CInt) -> t.CInt: pass

Test/TestProject/temp/7e529fe7a078cfef.pyi

@@ -0,0 +1,100 @@
+"""
+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
+
+def GetCommandLineA() -> CHARPTR | t.State: pass

Test/TestProject/temp/8e0d8fdba991b3b4.doc.json

@@ -0,0 +1 @@
+{}

Test/TestProject/temp/8e0d8fdba991b3b4.pyi

@@ -0,0 +1,25 @@
+"""
+Auto-generated Python stub file from config.py
+Module: config
+"""
+
+
+import stdint
+import t, c
+
+A: t.CExtern | t.CChar | t.CPtr
+
+class BIT_TEST(t.Object):
+    a: t.CInt | t.Bit(1)
+    b: t.CInt | t.Bit(1)
+    c: t.CInt | t.Bit(1)
+    d: t.CInt | t.Bit(5)
+class OOP_TEST(t.Object):
+    a: t.CInt
+    def __init__(self: OOP_TEST) -> t.CInt: pass
+    def __call__(self: OOP_TEST) -> stdint.UINT: pass
+class ENUM_TEST(t.CEnum):
+    A: t.State = 0
+    B: t.State
+    C: t.State
+    Len: t.State

Test/TestProject/temp/90c53dd6db8d41cf.pyi

@@ -0,0 +1,20 @@
+"""
+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: pass
+
+def calloc(nmemb: t.CSizeT, size: t.CSizeT) -> t.CVoid | t.CPtr | t.State: pass
+
+def realloc(p: t.CVoid | t.CPtr, size: t.CSizeT) -> t.CVoid | t.CPtr | t.State: pass
+
+def free(p: t.CVoid | t.CPtr) -> t.State: pass
+
+def system(cmd: t.CConst | t.CChar | t.CPtr) -> INT | t.State: pass

Test/TestProject/temp/_phase1_manifest.json

@@ -0,0 +1 @@
+{"D:\\Users\\TermiNexus\\Desktop\\TransPyC\\Test\\TestProject\\App\\config.py": {"sha1": "8e0d8fdba991b3b4", "mtime": 1781111175.0269876, "size": 445}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\Test\\TestProject\\App\\main.py": {"sha1": "49cae05490a513cb", "mtime": 1782949786.0815294, "size": 8223}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\Test\\TestProject\\App\\test_numpy.py": {"sha1": "3cd87018ba1e76bc", "mtime": 1782828269.700148, "size": 40140}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\Test\\TestProject\\App\\zc\\class_test.py": {"sha1": "e5fb16127bce8f68", "mtime": 1782266207.4312654, "size": 6472}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\Test\\TestProject\\App\\zc\\config.py": {"sha1": "cfc83b830141b00e", "mtime": 1778402243.1661563, "size": 531}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\Test\\TestProject\\App\\zc\\logic_test.py": {"sha1": "faec3233d98371da", "mtime": 1778402365.7843194, "size": 8848}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\Test\\TestProject\\App\\zc\\test.py": {"sha1": "75583f20a922ab2e", "mtime": 1778401973.4865518, "size": 8976}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\atom.py": {"sha1": "271ea3decb810db2", "mtime": 1782226548.693161, "size": 1290}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\memhub.py": {"sha1": "ee084e9fc6ee413a", "mtime": 1784214242.4485993, "size": 17765}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\numpy\\__init__.py": {"sha1": "c3a6aed1f1fb8b1e", "mtime": 1782949786.0890937, "size": 39111}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\stdint.py": {"sha1": "f5522571bcce7bcb", "mtime": 1782383975.8824987, "size": 4356}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\stdio.py": {"sha1": "6f62fe05c5ea1ceb", "mtime": 1783239556.0959673, "size": 714}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\stdlib.py": {"sha1": "90c53dd6db8d41cf", "mtime": 1783874975.3597875, "size": 375}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\string.py": {"sha1": "ab6e54ba9a669f76", "mtime": 1783933178.7264287, "size": 9922}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\testcheck.py": {"sha1": "dd3002730623424b", "mtime": 1783927513.1159866, "size": 1818}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\viperio.py": {"sha1": "c9f4be41ca1cc2b4", "mtime": 1782812279.506002, "size": 1556}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\vipermath.py": {"sha1": "3f7c5e78d8652535", "mtime": 1781532528.2518907, "size": 15412}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\w32\\win32base.py": {"sha1": "7e529fe7a078cfef", "mtime": 1782488356.7736557, "size": 2662}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\w32\\win32console.py": {"sha1": "bbdf3bbd4c3bc28c", "mtime": 1781200703.5338137, "size": 5604}}

Test/TestProject/temp/_sha1_map.txt

@@ -0,0 +1,19 @@
+271ea3decb810db2:includes/atom.py
+3cd87018ba1e76bc:test_numpy.py
+3f7c5e78d8652535:includes/vipermath.py
+49cae05490a513cb:main.py
+6f62fe05c5ea1ceb:includes/stdio.py
+75583f20a922ab2e:zc\test.py
+7e529fe7a078cfef:includes/w32\win32base.py
+8e0d8fdba991b3b4:config.py
+90c53dd6db8d41cf:includes/stdlib.py
+ab6e54ba9a669f76:includes/string.py
+bbdf3bbd4c3bc28c:includes/w32\win32console.py
+c3a6aed1f1fb8b1e:includes/numpy\__init__.py
+c9f4be41ca1cc2b4:includes/viperio.py
+cfc83b830141b00e:zc\config.py
+dd3002730623424b:includes/testcheck.py
+e5fb16127bce8f68:zc\class_test.py
+ee084e9fc6ee413a:includes/memhub.py
+f5522571bcce7bcb:includes/stdint.py
+faec3233d98371da:zc\logic_test.py

Test/TestProject/temp/ab6e54ba9a669f76.pyi

@@ -0,0 +1,48 @@
+"""
+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 strcat(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 strstr(s: str, needle: str) -> 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

Test/TestProject/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/TestProject/temp/c3a6aed1f1fb8b1e.pyi

@@ -0,0 +1,240 @@
+"""
+Auto-generated Python stub file from numpy.__init__.py
+Module: numpy.__init__
+"""
+
+
+from stdint import *
+import stdlib
+import string
+import vipermath
+import stdio
+import t, c
+import memhub
+
+MAX_NDIM: t.CDefine = 4
+float64: t.CTypedef = t.CDouble
+float32: t.CTypedef = t.CFloat
+int64: t.CTypedef = t.CLong
+int32: t.CTypedef = t.CInt
+uint8: t.CTypedef = t.CUnsignedChar
+pi: t.CDefine = 3.14159265358979323846
+e:  t.CDefine = 2.71828182845904523536
+
+@t.Object
+class ndarray[T]:
+    data: T | t.CPtr
+    shape: t.CArray[t.CSizeT, MAX_NDIM]
+    strides: t.CArray[t.CSizeT, MAX_NDIM]
+    ndim: t.CInt
+    size: t.CSizeT
+    owns_data: t.CInt
+    pool: memhub.MemManager | t.CPtr
+    def __new__(self: ndarray, pool: memhub.MemManager | t.CPtr, n: t.CSizeT) -> t.CInt: pass
+    def __add__(self: ndarray, other: ndarray[T] | t.CPtr) -> ndarray[T] | t.CPtr: pass
+    def __sub__(self: ndarray, other: ndarray[T] | t.CPtr) -> ndarray[T] | t.CPtr: pass
+    def __mul__(self: ndarray, other: ndarray[T] | t.CPtr) -> ndarray[T] | t.CPtr: pass
+    def __truediv__(self: ndarray, other: ndarray[T] | t.CPtr) -> ndarray[T] | t.CPtr: pass
+    def __floordiv__(self: ndarray, other: ndarray[T] | t.CPtr) -> ndarray[T] | t.CPtr: pass
+    def __mod__(self: ndarray, other: ndarray[T] | t.CPtr) -> ndarray[T] | t.CPtr: pass
+    def __neg__(self: ndarray) -> ndarray[T] | t.CPtr: pass
+    def __len__(self: ndarray) -> t.CInt: pass
+    def at2d(self: ndarray, row: t.CSizeT, col: t.CSizeT) -> T: pass
+    def set2d(self: ndarray, row: t.CSizeT, col: t.CSizeT, val: T) -> t.CInt: pass
+    def delete(self: ndarray) -> t.CInt: pass
+    def fill(self: ndarray, val: T) -> t.CInt: pass
+    def copy(self: ndarray) -> ndarray[T] | t.CPtr: pass
+    def reshape(self: ndarray, new_shape: INTPTR, new_ndim: t.CInt) -> ndarray[T] | t.CPtr: pass
+    def sum(self: ndarray) -> T: pass
+    def mean(self: ndarray) -> T: pass
+    def min(self: ndarray) -> T: pass
+    def max(self: ndarray) -> T: pass
+    def argmax(self: ndarray) -> t.CInt: pass
+    def argmin(self: ndarray) -> t.CInt: pass
+    def dot(self: ndarray, other: ndarray[T] | t.CPtr) -> T: pass
+    def T(self: ndarray) -> ndarray[T] | t.CPtr: pass
+    def print_arr(self: ndarray) -> t.CInt: pass
+
+Float64Array: t.CTypedef = ndarray[t.CDouble]
+Float32Array: t.CTypedef = ndarray[t.CFloat]
+Int64Array: t.CTypedef = ndarray[t.CLong]
+Int32Array: t.CTypedef = ndarray[t.CInt]
+Uint8Array: t.CTypedef = ndarray[t.CUnsignedChar]
+
+def _alloc_ndarray(pool: memhub.MemManager | t.CPtr) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def _compute_strides(a: ndarray[t.CDouble] | t.CPtr) -> t.CInt: pass
+
+def _empty_like(a: ndarray[t.CDouble] | t.CPtr) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def array(pool: memhub.MemManager | t.CPtr, data: t.CDouble | t.CPtr, n: t.CSizeT) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def zeros(pool: memhub.MemManager | t.CPtr, n: t.CSizeT) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def ones(pool: memhub.MemManager | t.CPtr, n: t.CSizeT) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def full(pool: memhub.MemManager | t.CPtr, n: t.CSizeT, val: t.CDouble) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def arange(pool: memhub.MemManager | t.CPtr, start: t.CDouble, stop: t.CDouble, step: t.CDouble) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def linspace(pool: memhub.MemManager | t.CPtr, start: t.CDouble, stop: t.CDouble, num: t.CSizeT) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def empty2d(pool: memhub.MemManager | t.CPtr, rows: t.CSizeT, cols: t.CSizeT) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def zeros2d(pool: memhub.MemManager | t.CPtr, rows: t.CSizeT, cols: t.CSizeT) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def ones2d(pool: memhub.MemManager | t.CPtr, rows: t.CSizeT, cols: t.CSizeT) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def eye(pool: memhub.MemManager | t.CPtr, n: t.CSizeT) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def diag(pool: memhub.MemManager | t.CPtr, vals: ndarray[t.CDouble] | t.CPtr) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def np_abs(a: ndarray[t.CDouble] | t.CPtr) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def np_sqrt(a: ndarray[t.CDouble] | t.CPtr) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def np_exp(a: ndarray[t.CDouble] | t.CPtr) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def np_log(a: ndarray[t.CDouble] | t.CPtr) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def np_sin(a: ndarray[t.CDouble] | t.CPtr) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def np_cos(a: ndarray[t.CDouble] | t.CPtr) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def np_tan(a: ndarray[t.CDouble] | t.CPtr) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def np_pow(a: ndarray[t.CDouble] | t.CPtr, p: t.CDouble) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def add_scalar(a: ndarray[t.CDouble] | t.CPtr, s: t.CDouble) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def mul_scalar(a: ndarray[t.CDouble] | t.CPtr, s: t.CDouble) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def sub_scalar(a: ndarray[t.CDouble] | t.CPtr, s: t.CDouble) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def div_scalar(a: ndarray[t.CDouble] | t.CPtr, s: t.CDouble) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def matmul(a: ndarray[t.CDouble] | t.CPtr, b: ndarray[t.CDouble] | t.CPtr) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def dot_product(a: ndarray[t.CDouble] | t.CPtr, b: ndarray[t.CDouble] | t.CPtr) -> t.CDouble: pass
+
+def np_sum(a: ndarray[t.CDouble] | t.CPtr) -> t.CDouble: pass
+
+def np_mean(a: ndarray[t.CDouble] | t.CPtr) -> t.CDouble: pass
+
+def np_min(a: ndarray[t.CDouble] | t.CPtr) -> t.CDouble: pass
+
+def np_max(a: ndarray[t.CDouble] | t.CPtr) -> t.CDouble: pass
+
+def np_argmax(a: ndarray[t.CDouble] | t.CPtr) -> t.CInt: pass
+
+def np_argmin(a: ndarray[t.CDouble] | t.CPtr) -> t.CInt: pass
+
+def var(a: ndarray[t.CDouble] | t.CPtr) -> t.CDouble: pass
+
+def std(a: ndarray[t.CDouble] | t.CPtr) -> t.CDouble: pass
+
+def norm(a: ndarray[t.CDouble] | t.CPtr) -> t.CDouble: pass
+
+def clip(a: ndarray[t.CDouble] | t.CPtr, lo: t.CDouble, hi: t.CDouble) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def concatenate(a: ndarray[t.CDouble] | t.CPtr, b: ndarray[t.CDouble] | t.CPtr) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def sort_arr(a: ndarray[t.CDouble] | t.CPtr) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def reverse(a: ndarray[t.CDouble] | t.CPtr) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def np_log10(a: ndarray[t.CDouble] | t.CPtr) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def np_log2(a: ndarray[t.CDouble] | t.CPtr) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def np_floor(a: ndarray[t.CDouble] | t.CPtr) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def np_ceil(a: ndarray[t.CDouble] | t.CPtr) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def np_round(a: ndarray[t.CDouble] | t.CPtr) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def np_sign(a: ndarray[t.CDouble] | t.CPtr) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def np_tanh(a: ndarray[t.CDouble] | t.CPtr) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def np_sinh(a: ndarray[t.CDouble] | t.CPtr) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def np_cosh(a: ndarray[t.CDouble] | t.CPtr) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def np_arcsin(a: ndarray[t.CDouble] | t.CPtr) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def np_arccos(a: ndarray[t.CDouble] | t.CPtr) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def np_arctan(a: ndarray[t.CDouble] | t.CPtr) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def np_arctan2(y: ndarray[t.CDouble] | t.CPtr, x: ndarray[t.CDouble] | t.CPtr) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def np_degrees(a: ndarray[t.CDouble] | t.CPtr) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def np_radians(a: ndarray[t.CDouble] | t.CPtr) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def np_isnan(a: ndarray[t.CDouble] | t.CPtr) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def np_isinf(a: ndarray[t.CDouble] | t.CPtr) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def np_maximum(a: ndarray[t.CDouble] | t.CPtr, b: ndarray[t.CDouble] | t.CPtr) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def np_minimum(a: ndarray[t.CDouble] | t.CPtr, b: ndarray[t.CDouble] | t.CPtr) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def cumsum(a: ndarray[t.CDouble] | t.CPtr) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def diff(a: ndarray[t.CDouble] | t.CPtr) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def flatten(a: ndarray[t.CDouble] | t.CPtr) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def trace(a: ndarray[t.CDouble] | t.CPtr) -> t.CDouble: pass
+
+def outer(a: ndarray[t.CDouble] | t.CPtr, b: ndarray[t.CDouble] | t.CPtr) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def np_where(condition: ndarray[t.CDouble] | t.CPtr, x: ndarray[t.CDouble] | t.CPtr, y: ndarray[t.CDouble] | t.CPtr) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def np_count_nonzero(a: ndarray[t.CDouble] | t.CPtr) -> t.CInt: pass
+
+def np_all(a: ndarray[t.CDouble] | t.CPtr) -> t.CInt: pass
+
+def np_any(a: ndarray[t.CDouble] | t.CPtr) -> t.CInt: pass
+
+def np_equal(a: ndarray[t.CDouble] | t.CPtr, b: ndarray[t.CDouble] | t.CPtr) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def np_not_equal(a: ndarray[t.CDouble] | t.CPtr, b: ndarray[t.CDouble] | t.CPtr) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def np_less(a: ndarray[t.CDouble] | t.CPtr, b: ndarray[t.CDouble] | t.CPtr) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def np_greater(a: ndarray[t.CDouble] | t.CPtr, b: ndarray[t.CDouble] | t.CPtr) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def np_less_equal(a: ndarray[t.CDouble] | t.CPtr, b: ndarray[t.CDouble] | t.CPtr) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def np_greater_equal(a: ndarray[t.CDouble] | t.CPtr, b: ndarray[t.CDouble] | t.CPtr) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def empty(pool: memhub.MemManager | t.CPtr, n: t.CSizeT) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def full2d(pool: memhub.MemManager | t.CPtr, rows: t.CSizeT, cols: t.CSizeT, val: t.CDouble) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def zeros_like(a: ndarray[t.CDouble] | t.CPtr) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def ones_like(a: ndarray[t.CDouble] | t.CPtr) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def arange1(pool: memhub.MemManager | t.CPtr, stop: t.CDouble) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def linspace2(pool: memhub.MemManager | t.CPtr, start: t.CDouble, stop: t.CDouble) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def meshgrid(x: ndarray[t.CDouble] | t.CPtr, y: ndarray[t.CDouble] | t.CPtr) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def det2x2(a: ndarray[t.CDouble] | t.CPtr) -> t.CDouble: pass
+
+def inv2x2(a: ndarray[t.CDouble] | t.CPtr) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def cross3(a: ndarray[t.CDouble] | t.CPtr, b: ndarray[t.CDouble] | t.CPtr) -> ndarray[t.CDouble] | t.CPtr: pass
+
+def np_interp(x: t.CDouble, xp: ndarray[t.CDouble] | t.CPtr, fp: ndarray[t.CDouble] | t.CPtr) -> t.CDouble: pass
+
+def prod(a: ndarray[t.CDouble] | t.CPtr) -> t.CDouble: pass
+
+def median(a: ndarray[t.CDouble] | t.CPtr) -> t.CDouble: pass
+
+def percentile(a: ndarray[t.CDouble] | t.CPtr, q: t.CDouble) -> t.CDouble: pass

Test/TestProject/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.CInt: pass
+    def clear(self: Buf) -> t.CInt: 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.CInt: pass
+    def __enter__(self: Buf) -> 'Buf' | t.CPtr: pass
+    def __exit__(self: Buf) -> t.CInt: pass
+    def free(self: Buf) -> t.CInt: pass

Test/TestProject/temp/cfc83b830141b00e.doc.json

@@ -0,0 +1 @@
+{}

Test/TestProject/temp/cfc83b830141b00e.pyi

@@ -0,0 +1,27 @@
+"""
+Auto-generated Python stub file from zc.config.py
+Module: zc.config
+"""
+
+
+import t, c
+
+POSMAX: t.CDefine = 100
+MAX_RETRY: t.CDefine = 5
+BUFFER_SIZE: t.CDefine = 256
+PI: t.CDefine = 3.14159
+EULER: t.CDefine = 2.71828
+TRUE: t.CDefine = 1
+FALSE: t.CDefine = 0
+NULL: t.CDefine = 0
+MATH_OFFSET: t.CDefine = 10
+MATH_SCALE: t.CDefine = 2
+THRESHOLD: t.CDefine = 50
+LOOP_LIMIT: t.CDefine = 20
+SHIFT_AMOUNT: t.CDefine = 2
+MASK_VALUE: t.CDefine = 0xFF
+BIT_RANGE: t.CDefine = 4
+EXPONENT_BASE: t.CDefine = 3
+MODULO_DIVISOR: t.CDefine = 7
+SCALE_SHIFT: t.CDefine = 4
+HALF_SCALE: t.CDefine = 0.5

Test/TestProject/temp/dd3002730623424b.pyi

@@ -0,0 +1,31 @@
+"""
+Auto-generated Python stub file from testcheck.py
+Module: testcheck
+"""
+
+
+import t, c
+import stdio
+from w32.win32console import SetConsoleOutputCP, SetConsoleCP
+
+CP_UTF8: t.CDefine = 65001
+_pass_count: t.CExtern | t.CInt
+_fail_count: t.CExtern | t.CInt
+_total_pass: t.CExtern | t.CInt
+_total_fail: 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
+
+def summary() -> t.CInt: pass

Test/TestProject/temp/e5fb16127bce8f68.doc.json

@@ -0,0 +1 @@
+{}

Test/TestProject/temp/e5fb16127bce8f68.pyi

@@ -0,0 +1,66 @@
+"""
+Auto-generated Python stub file from zc.class_test.py
+Module: zc.class_test
+"""
+
+
+import stdio
+import stdint
+import t, c
+
+class SimpleData(t.Object):
+    x: t.CInt
+    y: t.CInt
+class Point3D(t.Object):
+    x: t.CFloat
+    y: t.CFloat
+    z: t.CFloat
+class Student(t.Object):
+    name: t.CChar | t.CPtr
+    age: t.CInt
+    score: t.CInt
+    def __init__(self: Student, n: t.CChar | t.CPtr, a: t.CInt, s: t.CInt) -> t.CInt: pass
+    def get_age(self: Student) -> t.CInt: pass
+    def get_score(self: Student) -> t.CInt: pass
+class Counter(t.Object):
+    value: t.CInt
+    def __init__(self: Counter, initial: t.CInt) -> t.CInt: pass
+    def increment(self: Counter) -> t.CInt: pass
+    def get_value(self: Counter) -> t.CInt: pass
+class StackObj(t.Object):
+    data: t.CInt
+    next_ptr: t.CVoid | t.CPtr
+
+def TestBasicDataClass() -> t.CInt: pass
+
+def TestPoint3DClass() -> t.CInt: pass
+
+def TestStudentClass() -> t.CInt: pass
+
+def TestCounterClass() -> t.CInt: pass
+
+def TestStackAllocation() -> t.CInt: pass
+
+def TestHeapAllocation() -> t.CInt: pass
+
+def TestHeapObjectWithInit() -> t.CInt: pass
+
+def TestMultipleStackObjects() -> t.CInt: pass
+
+def TestImplicitInitCall() -> t.CInt: pass
+
+def TestClassWithBitFields() -> t.CInt: pass
+
+def TestIntArray() -> t.CInt: pass
+
+def TestFloatArray() -> t.CInt: pass
+
+def TestCharArray() -> t.CInt: pass
+
+def TestNestedArray() -> t.CInt: pass
+
+def TestArrayWithStruct() -> t.CInt: pass
+
+def TestArrayPointer() -> t.CInt: pass
+
+def TestDynamicString() -> t.CInt: pass

Test/TestProject/temp/ee084e9fc6ee413a.pyi

@@ -0,0 +1,81 @@
+"""
+Auto-generated Python stub file from memhub.py
+Module: memhub
+"""
+
+
+import t, c
+from stdint import *
+import string
+import atom
+import viperio
+
+MEMHUB_ALIGN: t.CDefine = 8
+MEMSLAB_MIN_BLOCK: t.CDefine = 16
+MEMSLAB_BITMAP_BYTES: t.CDefine = 256
+MEMBUDDY_MIN_BLOCK: t.CDefine = 32
+MEMBUDDY_MAX_ORDERS: t.CDefine = 32
+MEMBUDDY_HEADER_SIZE: t.CDefine = 8
+
+def _align_up(val: t.CSizeT, align: t.CSizeT) -> t.CSizeT: pass
+
+def _largest_pow2_le(val: t.CSizeT) -> t.CSizeT: pass
+
+def _block_size_at_order(order: t.CInt) -> t.CSizeT: pass
+
+
+@t.CVTable
+class MemManager:
+    __provides__: list[str] = ['__memmgr__']
+    base: t.CVoid | t.CPtr
+    size: t.CSizeT
+    def __init__(self: MemManager, base: t.CVoid | t.CPtr, size: t.CSizeT) -> t.CInt: pass
+    def alloc(self: MemManager, size: t.CSizeT) -> t.CVoid | t.CPtr: pass
+    def free(self: MemManager, ptr: t.CVoid | t.CPtr) -> t.CInt: pass
+    def reset(self: MemManager) -> t.CInt: pass
+    def calloc(self: MemManager, count: t.CSizeT, size: t.CSizeT) -> t.CVoid | t.CPtr: pass
+    def realloc(self: MemManager, ptr: t.CVoid | t.CPtr, old_size: t.CSizeT, new_size: t.CSizeT) -> t.CVoid | t.CPtr: pass
+    def __enter__(self: MemManager) -> 'MemManager' | t.CPtr: pass
+    def __exit__(self: MemManager) -> t.CInt: pass
+    def alloc_buf(self: MemManager, capacity: t.CSizeT) -> viperio.Buf | t.CPtr: pass
+class MemPool(MemManager):
+    offset: t.CSizeT
+    high_water: t.CSizeT
+    def __init__(self: MemPool, base: t.CVoid | t.CPtr, size: t.CSizeT) -> t.CInt: pass
+    def alloc(self: MemPool, size: t.CSizeT) -> t.CVoid | t.CPtr: pass
+    def free(self: MemPool, ptr: t.CVoid | t.CPtr) -> t.CInt: pass
+    def reset(self: MemPool) -> t.CInt: pass
+class MemSlab(MemManager):
+    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
+    usable: t.CVoid | t.CPtr
+    usable_size: t.CSizeT
+    def __init__(self: MemSlab, base: t.CVoid | t.CPtr, size: t.CSizeT, block_size: t.CSizeT) -> t.CInt: pass
+    def alloc(self: MemSlab, size: t.CSizeT) -> t.CVoid | t.CPtr: pass
+    def free(self: MemSlab, ptr: t.CVoid | t.CPtr) -> t.CInt: pass
+    def reset(self: MemSlab) -> t.CInt: pass
+class MemBuddy(MemManager):
+    max_order: t.CInt
+    free_lists: t.CUInt64T | t.CPtr
+    lock_val: t.CVolatile | t.CInt
+    usable: t.CVoid | t.CPtr
+    usable_size: t.CSizeT
+    def __init__(self: MemBuddy, base: t.CVoid | t.CPtr, size: t.CSizeT) -> t.CInt: pass
+    def _fl_push(self: MemBuddy, order: t.CInt, block: t.CVoid | t.CPtr) -> t.CInt: pass
+    def _fl_pop(self: MemBuddy, order: t.CInt) -> t.CVoid | t.CPtr: pass
+    def _fl_find_and_remove(self: MemBuddy, order: t.CInt, target: t.CVoid | t.CPtr) -> t.CInt: pass
+    def _buddy_of(self: MemBuddy, block: t.CVoid | t.CPtr, order: t.CInt) -> t.CVoid | t.CPtr: pass
+    def _order_for_size(self: MemBuddy, size: t.CSizeT) -> t.CInt: pass
+    def _split_to_order(self: MemBuddy, to_order: t.CInt) -> t.CVoid | t.CPtr: pass
+    def _coalesce(self: MemBuddy, block: t.CVoid | t.CPtr, order: t.CInt) -> t.CInt: pass
+    def _is_valid_ptr(self: MemBuddy, ptr: t.CVoid | t.CPtr) -> t.CInt: pass
+    def _lock(self: MemBuddy) -> t.CInt: pass
+    def _unlock(self: MemBuddy) -> t.CInt: pass
+    def alloc(self: MemBuddy, size: t.CSizeT) -> t.CVoid | t.CPtr: pass
+    def free(self: MemBuddy, ptr: t.CVoid | t.CPtr) -> t.CInt: pass
+    def reset(self: MemBuddy) -> t.CInt: pass
+    def realloc(self: MemBuddy, ptr: t.CVoid | t.CPtr, old_size: t.CSizeT, new_size: t.CSizeT) -> t.CVoid | t.CPtr: pass

Test/TestProject/temp/f5522571bcce7bcb.pyi

@@ -0,0 +1,100 @@
+"""
+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.CLongLong
+ULONGLONG: t.CTypedef = t.CUnsignedLongLong
+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
+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
+SIZE_T: t.CTypedef = t.CSizeT
+SSIZE_T: t.CTypedef = t.CPtrDiffT
+PTRDIFF_T: t.CTypedef = t.CPtrDiffT
+int8_t: t.CTypedef = t.CInt8T
+int16_t: t.CTypedef = t.CInt16T
+int32_t: t.CTypedef = t.CInt32T
+int64_t: t.CTypedef = t.CInt64T
+uint8_t: t.CTypedef = t.CUInt8T
+uint16_t: t.CTypedef = t.CUInt16T
+uint32_t: t.CTypedef = t.CUInt32T
+uint64_t: t.CTypedef = t.CUInt64T
+size_t: t.CTypedef = t.CSizeT
+ssize_t: t.CTypedef = t.CPtrDiffT
+ptrdiff_t: t.CTypedef = t.CPtrDiffT
+intptr_t: t.CTypedef = t.CIntPtrT
+uintptr_t: t.CTypedef = t.CUIntPtrT
+wchar_t: t.CTypedef = t.CWCharT
+char8_t: t.CTypedef = t.CChar8T
+char16_t: t.CTypedef = t.CChar16T
+char32_t: t.CTypedef = t.CChar32T
+float8_t: t.CTypedef = t.CFloat8T
+float16_t: t.CTypedef = t.CFloat16T
+float32_t: t.CTypedef = t.CFloat32T
+float64_t: t.CTypedef = t.CFloat64T
+float128_t: t.CTypedef = t.CFloat128T
+_Bool: t.CTypedef = t.CBool

Test/TestProject/temp/faec3233d98371da.doc.json

@@ -0,0 +1 @@
+{}

Test/TestProject/temp/faec3233d98371da.pyi

@@ -0,0 +1,54 @@
+"""
+Auto-generated Python stub file from zc.logic_test.py
+Module: zc.logic_test
+"""
+
+
+import config
+import t, c
+
+def ForRangeBasicTest(stop: t.CInt) -> t.CInt: pass
+
+def ForRangeWithStartStop(start: t.CInt, stop: t.CInt, step: t.CInt) -> t.CInt: pass
+
+def NestedForRangeTest(rows: t.CInt, cols: t.CInt) -> t.CInt: pass
+
+def ForWithIfBreakTest(data_size: t.CInt) -> t.CInt: pass
+
+def ForWithIfContinueTest(n: t.CInt) -> t.CInt: pass
+
+def ForWithElifBranchTest(value: t.CInt) -> t.CInt: pass
+
+def WhileWithIfElifElseTest(iterations: t.CInt) -> t.CInt: pass
+
+def WhileWithNestedIfTest(limit: t.CInt) -> t.CInt: pass
+
+def WhileWithMatchCaseTest(value: t.CInt) -> t.CInt: pass
+
+def WhileWithMatchCaseNoBreakTest(value: t.CInt) -> t.CInt: pass
+
+def ComplexForWhileMatchTest(outer_limit: t.CInt, inner_limit: t.CInt) -> t.CInt: pass
+
+def ForWithCaseAndNoBreakTest(n: t.CInt) -> t.CInt: pass
+
+def WhileWithBreakConditionTest(limit: t.CInt) -> t.CInt: pass
+
+def NestedWhileWithMultipleBreakPoints(depth: t.CInt, width: t.CInt) -> t.CInt: pass
+
+def ForWithMatchCaseInLoopTest(iterations: t.CInt) -> t.CInt: pass
+
+def ComplexLogicWithElifChains(a: t.CInt, b: t.CInt, c_val: t.CInt) -> t.CInt: pass
+
+def ForRangeWithStepAndCondition(n: t.CInt, step: t.CInt) -> t.CInt: pass
+
+def MatchCaseWithGuardConditions(value: t.CInt) -> t.CInt: pass
+
+def WhileWithMultipleMatchCases(iterations: t.CInt) -> t.CInt: pass
+
+def ForWhileMixWithBreakAndContinue(n: t.CInt) -> t.CInt: pass
+
+def ComplexCaseMatchingWithRanges(start: t.CInt, end: t.CInt) -> t.CInt: pass
+
+def WhileWithElifInElifChain(limit: t.CInt) -> t.CInt: pass
+
+def ForWithCaseNoBreakNested(inner_limit: t.CInt) -> t.CInt: pass