test: 删除 TestProject/2/3 聚合项目(已拆分覆盖); HashLibTest 并入 binascii/base64/hashlib 全套测试
This commit is contained in:
TermiNexus committed
1 parent
19214c269c
commit
cd1f662e17
195 files changed
+99
-10254
No files matched your search
@@ -1,26 +1,123 @@
|
||||
import t, c
|
||||
import stdio
|
||||
import stdlib
|
||||
import string
|
||||
import testcheck
|
||||
import hashlib
|
||||
import binascii
|
||||
import base64
|
||||
import w32.win32console
|
||||
|
||||
|
||||
# ==============================================
|
||||
# 工具函数：打印十六进制哈希串
|
||||
# ==============================================
|
||||
def print_hex(buf: t.CUInt8T | t.CPtr, length: t.CInt):
|
||||
for i in range(length):
|
||||
stdio.printf("%02x", buf[i])
|
||||
stdio.printf("\n")
|
||||
|
||||
|
||||
def default_value_test_function(a: t.CInt, b: t.CInt = 1):
|
||||
print(a, b)
|
||||
|
||||
|
||||
def main() -> t.CInt | t.CExport:
|
||||
w32.win32console.SetConsoleCP(65001)
|
||||
w32.win32console.SetConsoleOutputCP(65001)
|
||||
|
||||
testcheck.begin("HashLibTest: 哈希与校验测试")
|
||||
|
||||
# ---------- hashlib 摘要测试 ----------
|
||||
testcheck.section("HASHLIB")
|
||||
plain: str = "hello123"
|
||||
|
||||
md5_buf: t.CArray[t.CUInt8T, hashlib.MD5_DIGEST_LEN]
|
||||
mctx = hashlib.md5()
|
||||
mctx.update("hello")
|
||||
mctx.update(plain)
|
||||
mctx.final(md5_buf)
|
||||
print("MD5: ")
|
||||
print_hex(md5_buf, hashlib.MD5_DIGEST_LEN)
|
||||
testcheck.ok("HASHLIB md5 completed")
|
||||
|
||||
sha1_buf: t.CArray[t.CUInt8T, hashlib.SHA1_DIGEST_LEN]
|
||||
s1ctx = hashlib.sha1()
|
||||
s1ctx.update(plain)
|
||||
s1ctx.final(sha1_buf)
|
||||
print("SHA1: ")
|
||||
print_hex(sha1_buf, hashlib.SHA1_DIGEST_LEN)
|
||||
testcheck.ok("HASHLIB sha1 completed")
|
||||
|
||||
sha256_buf: t.CArray[t.CUInt8T, hashlib.SHA256_DIGEST_LEN]
|
||||
s2ctx = hashlib.sha256()
|
||||
s2ctx.update(plain)
|
||||
s2ctx.final(sha256_buf)
|
||||
print("SHA256: ")
|
||||
print_hex(sha256_buf, hashlib.SHA256_DIGEST_LEN)
|
||||
testcheck.ok("HASHLIB sha256 completed")
|
||||
|
||||
sha512_buf: t.CArray[t.CUInt8T, hashlib.SHA512_DIGEST_LEN]
|
||||
s5ctx = hashlib.sha512()
|
||||
s5ctx.update(plain)
|
||||
s5ctx.final(sha512_buf)
|
||||
print("SHA512: ")
|
||||
print_hex(sha512_buf, hashlib.SHA512_DIGEST_LEN)
|
||||
testcheck.ok("HASHLIB sha512 completed")
|
||||
|
||||
default_value_test_function(b=2, a=1)
|
||||
testcheck.ok("default value test completed")
|
||||
|
||||
# ---------- base64 编解码测试 ----------
|
||||
testcheck.section("BASE64")
|
||||
b64_out: t.CArray[t.CChar, 256]
|
||||
b64_dec: t.CArray[t.CUInt8T, 256]
|
||||
base64.b64encode(plain, b64_out)
|
||||
print("Base64 编码:", b64_out)
|
||||
dlen: t.CSizeT = base64.b64decode(b64_out, b64_dec)
|
||||
b64_dec[dlen] = 0
|
||||
print("Base64 解码:", b64_dec)
|
||||
testcheck.ok("BASE64 encode/decode completed")
|
||||
|
||||
# ---------- binascii 全套测试 ----------
|
||||
testcheck.section("BINASCII")
|
||||
binascii.init_binascii()
|
||||
crc_val: t.CUnsignedInt = binascii.crc32("hello", 5, 0)
|
||||
raw: str = "HelloWorld!"
|
||||
raw_length: t.CInt = 11
|
||||
|
||||
hex_out: str = binascii.b2a_hex(raw, raw_length)
|
||||
if hex_out:
|
||||
stdio.printf("Hex: %s\n", hex_out)
|
||||
stdlib.free(hex_out)
|
||||
testcheck.ok("BINASCII b2a_hex completed")
|
||||
|
||||
crc_val: t.CUnsignedInt = binascii.crc32(raw, raw_length, 0)
|
||||
stdio.printf("CRC32: %u\n", crc_val)
|
||||
testcheck.ok("BINASCII crc32 completed")
|
||||
|
||||
b64_out2: str = binascii.b2a_base64(raw, raw_length)
|
||||
if b64_out2:
|
||||
stdio.printf("Base64: %s\n", b64_out2)
|
||||
stdlib.free(b64_out2)
|
||||
testcheck.ok("BINASCII b2a_base64 completed")
|
||||
|
||||
uu_out: str = binascii.b2a_uu(raw, raw_length)
|
||||
if uu_out:
|
||||
stdio.printf("UU: %s\n", uu_out)
|
||||
stdlib.free(uu_out)
|
||||
testcheck.ok("BINASCII b2a_uu completed")
|
||||
|
||||
hqx_in: t.CArray[t.CChar, 4] = ['A', 'B', 'C', '\0']
|
||||
hqx_crc: t.CUnsignedShort = 0
|
||||
hqx_out: str
|
||||
unhqx: str
|
||||
hqx_out, hqx_crc = binascii.b2a_hqx(hqx_in, 3)
|
||||
unhqx, hqx_crc = binascii.a2b_hqx(hqx_out)
|
||||
stdio.printf("HQX Test: ABC -> %s -> %s (CRC:%u)\n", hqx_out, unhqx, hqx_crc)
|
||||
stdlib.free(hqx_out); stdlib.free(unhqx)
|
||||
testcheck.ok("BINASCII hqx completed")
|
||||
|
||||
adler_val: t.CUnsignedInt = binascii.adler32(raw, raw_length, 1)
|
||||
stdio.printf("Adler32: %u\n", adler_val)
|
||||
testcheck.ok("BINASCII adler32 completed")
|
||||
|
||||
return testcheck.end()
|
||||
@@ -1,10 +0,0 @@
|
||||
"""Auto-generated Python stub file"""
|
||||
|
||||
|
||||
import stdio
|
||||
import stdlib
|
||||
import string
|
||||
import binascii
|
||||
import t, c
|
||||
def main222(): pass
|
||||
|
||||
@@ -1,10 +0,0 @@
|
||||
7a2aeb1d7ef1f519:BINASCII.vp
|
||||
22ae99fbf5fa16e6:config.vp
|
||||
49315f8913bda6a4:HASHLIB.vp
|
||||
49cae05490a513cb:main.vp
|
||||
3cd87018ba1e76bc:test_numpy.vp
|
||||
9ba2a595433e0d35:test_zlib.vp
|
||||
110d7d2c8a47ff77:zc/class_test.vp
|
||||
15b2db4f5d33f57e:zc/config.vp
|
||||
faec3233d98371da:zc/logic_test.vp
|
||||
07b189ae3dcfb270:zc/test.vp
|
||||
@@ -1,47 +0,0 @@
|
||||
import stdio
|
||||
import stdlib
|
||||
import string
|
||||
import binascii
|
||||
import t, c
|
||||
|
||||
|
||||
|
||||
|
||||
def main222():
|
||||
binascii.init_binascii()
|
||||
raw: str = "HelloWorld!"
|
||||
raw_length: t.CInt = 11
|
||||
|
||||
stdio.printf("你好\n")
|
||||
|
||||
hex_out: str = binascii.b2a_hex(raw, raw_length)
|
||||
if hex_out:
|
||||
stdio.printf("Hex: %s\n", hex_out)
|
||||
free(hex_out)
|
||||
|
||||
crc_val: t.CUnsignedInt = binascii.crc32(raw, raw_length, 0)
|
||||
stdio.printf("CRC32: %u\n", crc_val)
|
||||
|
||||
b64_out: str = binascii.b2a_base64(raw, raw_length)
|
||||
if b64_out:
|
||||
stdio.printf("Base64: %s\n", b64_out)
|
||||
free(b64_out)
|
||||
|
||||
uu_out: str = binascii.b2a_uu(raw, raw_length)
|
||||
if uu_out:
|
||||
stdio.printf("UU: %s\n", uu_out)
|
||||
free(uu_out)
|
||||
|
||||
hqx_in: t.CArray[t.CChar, 4] = ['A', 'B', 'C', '\0']
|
||||
hqx_crc: t.CUnsignedShort = 0
|
||||
hqx_out: str
|
||||
unhqx: str
|
||||
hqx_out, hqx_crc = binascii.b2a_hqx(hqx_in, 3)
|
||||
unhqx, hqx_crc = binascii.a2b_hqx(hqx_out)
|
||||
stdio.printf("HQX Test: ABC -> %s -> %s (CRC:%u)\n", hqx_out, unhqx, hqx_crc)
|
||||
free(hqx_out); free(unhqx)
|
||||
|
||||
adler_val: t.CUnsignedInt = binascii.adler32(raw, raw_length, 1)
|
||||
stdio.printf("Adler32: %u\n", adler_val)
|
||||
|
||||
stdio.printf("Bye\n")
|
||||
@@ -1,80 +0,0 @@
|
||||
import stdio
|
||||
import stdlib
|
||||
import string
|
||||
import stdint
|
||||
import t, c
|
||||
import base64
|
||||
import hashlib
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
def default_value_test_function(a: t.CInt, b: t.CInt = 1):
|
||||
print(a, b)
|
||||
|
||||
|
||||
|
||||
|
||||
# ==============================================
|
||||
# 工具函数：打印十六进制哈希串
|
||||
# ==============================================
|
||||
def print_hex(buf: t.CUInt8T | t.CPtr, length: t.CInt):
|
||||
for i in range(length):
|
||||
stdio.printf("%02x", buf[i])
|
||||
stdio.printf("\n")
|
||||
|
||||
# ==============================================
|
||||
# 主函数测试入口
|
||||
# ==============================================
|
||||
def main1() -> t.CInt:
|
||||
plain: str = "hello123"
|
||||
print("原文", plain)
|
||||
|
||||
# ---------- Base64 测试 ----------
|
||||
b64_out: t.CArray[t.CChar, 256]
|
||||
b64_dec: t.CArray[t.CUInt8T, 256]
|
||||
base64.b64encode(plain, b64_out)
|
||||
print("Base64 编码:", b64_out)
|
||||
dlen: t.CSizeT = base64.b64decode(b64_out, b64_dec)
|
||||
b64_dec[dlen] = 0
|
||||
print("Base64 解码:", b64_dec)
|
||||
|
||||
# ---------- MD5 测试 ----------
|
||||
md5_buf: t.CArray[t.CUInt8T, hashlib.MD5_DIGEST_LEN]
|
||||
mctx = hashlib.md5()
|
||||
mctx.update(plain)
|
||||
mctx.final(md5_buf)
|
||||
print("MD5: ")
|
||||
print_hex(md5_buf, hashlib.MD5_DIGEST_LEN)
|
||||
|
||||
# ---------- SHA1 测试 ----------
|
||||
sha1_buf: t.CArray[t.CUInt8T, hashlib.SHA1_DIGEST_LEN]
|
||||
s1ctx = hashlib.sha1()
|
||||
s1ctx.update(plain)
|
||||
s1ctx.final(sha1_buf)
|
||||
print("SHA1: ")
|
||||
print_hex(sha1_buf, hashlib.SHA1_DIGEST_LEN)
|
||||
|
||||
# ---------- SHA256 测试 ----------
|
||||
sha256_buf: t.CArray[t.CUInt8T, hashlib.SHA256_DIGEST_LEN]
|
||||
s2ctx = hashlib.sha256()
|
||||
s2ctx.update(plain)
|
||||
s2ctx.final(sha256_buf)
|
||||
print("SHA256: ")
|
||||
print_hex(sha256_buf, hashlib.SHA256_DIGEST_LEN)
|
||||
|
||||
# ---------- SHA512 测试 ----------
|
||||
sha512_buf: t.CArray[t.CUInt8T, hashlib.SHA512_DIGEST_LEN]
|
||||
s5ctx = hashlib.sha512()
|
||||
s5ctx.update(plain)
|
||||
s5ctx.final(sha512_buf)
|
||||
print("SHA512: ")
|
||||
print_hex(sha512_buf, hashlib.SHA512_DIGEST_LEN)
|
||||
|
||||
default_value_test_function(b=2, a=1)
|
||||
|
||||
return 0
|
||||
@@ -1,24 +0,0 @@
|
||||
import stdint
|
||||
import t, c
|
||||
|
||||
|
||||
A: 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):
|
||||
self.a = 0
|
||||
def __call__(self) -> stdint.UINT:
|
||||
return 123
|
||||
|
||||
class ENUM_TEST(t.CEnum):
|
||||
A: t.State = 0
|
||||
B: t.State
|
||||
C: t.State
|
||||
Len: t.State
|
||||
@@ -1,220 +0,0 @@
|
||||
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:
|
||||
testcheck.begin("Hello World!")
|
||||
testcheck.section("Cross-module macros")
|
||||
stdio.printf(" POSMAX: %d\n", config.POSMAX)
|
||||
stdio.printf(" MATH_SCALE: %d\n", config.MATH_SCALE)
|
||||
stdio.printf(" THRESHOLD: %d\n", config.THRESHOLD)
|
||||
stdio.printf(" SHIFT_AMOUNT: %d\n", config.SHIFT_AMOUNT)
|
||||
stdio.printf(" MASK_VALUE: 0x%x\n", config.MASK_VALUE)
|
||||
testcheck.ok("config macros accessible")
|
||||
|
||||
testcheck.section("While Loop Test")
|
||||
test.AboutSizeTWhileTest(10)
|
||||
testcheck.ok("While Loop Test (10)")
|
||||
|
||||
testcheck.section("Math Basic Test (20, 6)")
|
||||
test.MathBasicTest(20, 6)
|
||||
testcheck.ok("Math Basic Test (20, 6)")
|
||||
|
||||
testcheck.section("Math Advanced Test (value=15)")
|
||||
test.MathAdvancedTest(15)
|
||||
testcheck.ok("Math Advanced Test (value=15)")
|
||||
|
||||
testcheck.section("While with Elif-Else Test (-2 to 12)")
|
||||
test.WhileWithElifElseTest(-2, 12)
|
||||
testcheck.ok("While with Elif-Else Test (-2 to 12)")
|
||||
|
||||
testcheck.section("Nested While with Macros Test")
|
||||
test.NestedWhileWithMacrosTest(3, 4)
|
||||
testcheck.ok("Nested While with Macros Test (3, 4)")
|
||||
|
||||
testcheck.section("Complex Condition Test (1, 2, 3)")
|
||||
test.ComplexConditionTest(1, 2, 3)
|
||||
testcheck.ok("Complex Condition Test (1, 2, 3)")
|
||||
|
||||
testcheck.section("Retry Loop Test (8)")
|
||||
test.RetryLoopTest(8)
|
||||
testcheck.ok("Retry Loop Test (8)")
|
||||
|
||||
testcheck.section("Bitwise Operations Test (0b1101101)")
|
||||
test.BitwiseOperationsTest(109)
|
||||
testcheck.ok("Bitwise Operations Test (109)")
|
||||
|
||||
testcheck.section("Compound Assignment Math Test (15, 4)")
|
||||
test.CompoundAssignmentMathTest(15, 4)
|
||||
testcheck.ok("Compound Assignment Math Test (15, 4)")
|
||||
|
||||
testcheck.section("Power and Modulo Test (2, 8)")
|
||||
test.PowerAndModuloTest(2, 8)
|
||||
testcheck.ok("Power and Modulo Test (2, 8)")
|
||||
|
||||
testcheck.section("Mixed Arithmetic Test (5, 3, 4)")
|
||||
test.MixedArithmeticTest(5, 3, 4)
|
||||
testcheck.ok("Mixed Arithmetic Test (5, 3, 4)")
|
||||
|
||||
testcheck.section("Math with While Loop Test (start=1, count=5)")
|
||||
test.MathWithWhileLoopTest(1, 5)
|
||||
testcheck.ok("Math with While Loop Test (1, 5)")
|
||||
|
||||
testcheck.section("Complex Nested Math Test (7, 3)")
|
||||
test.ComplexNestedMathTest(7, 3)
|
||||
testcheck.ok("Complex Nested Math Test (7, 3)")
|
||||
|
||||
testcheck.section("Conditional Math Chain Test (value=10)")
|
||||
test.ConditionalMathChainTest(10)
|
||||
testcheck.ok("Conditional Math Chain Test (value=10)")
|
||||
|
||||
testcheck.section("Bit Manipulation Math Test (0xABCD)")
|
||||
test.BitManipulationMathTest(0xABCD)
|
||||
testcheck.ok("Bit Manipulation Math Test (0xABCD)")
|
||||
|
||||
testcheck.section("COMPLEX LOGIC TESTS")
|
||||
|
||||
testcheck.section("For Range Basic Test (stop=5)")
|
||||
logic.ForRangeBasicTest(5)
|
||||
testcheck.ok("For Range Basic Test (5)")
|
||||
|
||||
testcheck.section("For Range With Start Stop Step (start=1, stop=10, step=2)")
|
||||
logic.ForRangeWithStartStop(1, 10, 2)
|
||||
testcheck.ok("For Range With Start Stop (1, 10, 2)")
|
||||
|
||||
testcheck.section("Nested For Range Test (rows=2, cols=3)")
|
||||
logic.NestedForRangeTest(2, 3)
|
||||
testcheck.ok("Nested For Range Test (2, 3)")
|
||||
|
||||
testcheck.section("For With If Break Test (size=8)")
|
||||
logic.ForWithIfBreakTest(8)
|
||||
testcheck.ok("For With If Break Test (8)")
|
||||
|
||||
testcheck.section("For With If Continue Test (n=10)")
|
||||
logic.ForWithIfContinueTest(10)
|
||||
testcheck.ok("For With If Continue Test (10)")
|
||||
|
||||
testcheck.section("For With Elif Branch Test (value=10)")
|
||||
logic.ForWithElifBranchTest(10)
|
||||
testcheck.ok("For With Elif Branch Test (10)")
|
||||
|
||||
testcheck.section("While With If Elif Else Test (iterations=7)")
|
||||
logic.WhileWithIfElifElseTest(7)
|
||||
testcheck.ok("While With If Elif Else Test (7)")
|
||||
|
||||
testcheck.section("While With Nested If Test (limit=4)")
|
||||
logic.WhileWithNestedIfTest(4)
|
||||
testcheck.ok("While With Nested If Test (4)")
|
||||
|
||||
testcheck.section("While With Match Case Test (value=2)")
|
||||
logic.WhileWithMatchCaseTest(2)
|
||||
testcheck.ok("While With Match Case Test (2)")
|
||||
|
||||
testcheck.section("While With Match Case Test (value=99)")
|
||||
logic.WhileWithMatchCaseTest(99)
|
||||
testcheck.ok("While With Match Case Test (99)")
|
||||
|
||||
testcheck.section("While With Match Case NoBreak Test (value=3)")
|
||||
logic.WhileWithMatchCaseNoBreakTest(3)
|
||||
testcheck.ok("While With Match Case NoBreak Test (3)")
|
||||
|
||||
testcheck.section("Complex For While Match Test (outer=3, inner=3)")
|
||||
logic.ComplexForWhileMatchTest(3, 3)
|
||||
testcheck.ok("Complex For While Match Test (3, 3)")
|
||||
|
||||
testcheck.section("For With Case And NoBreak Test (n=5)")
|
||||
logic.ForWithCaseAndNoBreakTest(5)
|
||||
testcheck.ok("For With Case And NoBreak Test (5)")
|
||||
|
||||
testcheck.section("While With Break Condition Test (limit=6)")
|
||||
logic.WhileWithBreakConditionTest(6)
|
||||
testcheck.ok("While With Break Condition Test (6)")
|
||||
|
||||
testcheck.section("Nested While With Multiple BreakPoints (depth=3, width=4)")
|
||||
logic.NestedWhileWithMultipleBreakPoints(3, 4)
|
||||
testcheck.ok("Nested While With Multiple BreakPoints (3, 4)")
|
||||
|
||||
testcheck.section("For With Match Case In Loop Test (iterations=9)")
|
||||
logic.ForWithMatchCaseInLoopTest(9)
|
||||
testcheck.ok("For With Match Case In Loop Test (9)")
|
||||
|
||||
testcheck.section("Complex Logic With Elif Chains (a=3, b=5, c=7)")
|
||||
logic.ComplexLogicWithElifChains(3, 5, 7)
|
||||
testcheck.ok("Complex Logic With Elif Chains (3, 5, 7)")
|
||||
|
||||
testcheck.section("For Range With Step And Condition (n=12, step=2)")
|
||||
logic.ForRangeWithStepAndCondition(12, 2)
|
||||
testcheck.ok("For Range With Step And Condition (12, 2)")
|
||||
|
||||
testcheck.section("Match Case With Guard Conditions (value=1)")
|
||||
logic.MatchCaseWithGuardConditions(1)
|
||||
testcheck.ok("Match Case With Guard Conditions (1)")
|
||||
|
||||
testcheck.section("While With Multiple Match Cases (iterations=12)")
|
||||
logic.WhileWithMultipleMatchCases(12)
|
||||
testcheck.ok("While With Multiple Match Cases (12)")
|
||||
|
||||
testcheck.section("For While Mix With Break And Continue (n=5)")
|
||||
logic.ForWhileMixWithBreakAndContinue(5)
|
||||
testcheck.ok("For While Mix With Break And Continue (5)")
|
||||
|
||||
testcheck.section("Complex Case Matching With Ranges (start=0, end=35)")
|
||||
logic.ComplexCaseMatchingWithRanges(0, 35)
|
||||
testcheck.ok("Complex Case Matching With Ranges (0, 35)")
|
||||
|
||||
testcheck.section("While With Elif In Elif Chain (limit=7)")
|
||||
logic.WhileWithElifInElifChain(7)
|
||||
testcheck.ok("While With Elif In Elif Chain (7)")
|
||||
|
||||
testcheck.section("For With Case NoBreak Nested (inner_limit=4)")
|
||||
logic.ForWithCaseNoBreakNested(4)
|
||||
testcheck.ok("For With Case NoBreak Nested (4)")
|
||||
|
||||
testcheck.section("CLASS TESTS")
|
||||
class_test.TestBasicDataClass()
|
||||
testcheck.ok("TestBasicDataClass")
|
||||
class_test.TestPoint3DClass()
|
||||
testcheck.ok("TestPoint3DClass")
|
||||
class_test.TestStudentClass()
|
||||
testcheck.ok("TestStudentClass")
|
||||
class_test.TestCounterClass()
|
||||
testcheck.ok("TestCounterClass")
|
||||
class_test.TestStackAllocation()
|
||||
testcheck.ok("TestStackAllocation")
|
||||
class_test.TestHeapAllocation()
|
||||
testcheck.ok("TestHeapAllocation")
|
||||
class_test.TestHeapObjectWithInit()
|
||||
testcheck.ok("TestHeapObjectWithInit")
|
||||
class_test.TestMultipleStackObjects()
|
||||
testcheck.ok("TestMultipleStackObjects")
|
||||
class_test.TestImplicitInitCall()
|
||||
testcheck.ok("TestImplicitInitCall")
|
||||
class_test.TestClassWithBitFields()
|
||||
testcheck.ok("TestClassWithBitFields")
|
||||
|
||||
testcheck.section("ARRAY TESTS")
|
||||
class_test.TestIntArray()
|
||||
testcheck.ok("TestIntArray")
|
||||
class_test.TestFloatArray()
|
||||
testcheck.ok("TestFloatArray")
|
||||
class_test.TestCharArray()
|
||||
testcheck.ok("TestCharArray")
|
||||
class_test.TestNestedArray()
|
||||
testcheck.ok("TestNestedArray")
|
||||
class_test.TestArrayWithStruct()
|
||||
testcheck.ok("TestArrayWithStruct")
|
||||
class_test.TestArrayPointer()
|
||||
testcheck.ok("TestArrayPointer")
|
||||
class_test.TestDynamicString()
|
||||
testcheck.ok("TestDynamicString")
|
||||
|
||||
testcheck.section("numpy Correctness Tests")
|
||||
test_numpy.test_numpy_correct()
|
||||
|
||||
return testcheck.end()
|
||||
File diff suppressed because it is too large.
Load diff
@@ -1,883 +0,0 @@
|
||||
from stdint import *
|
||||
import zlib.pyzlib as pyzlib
|
||||
import zlib.zhuff as zhuff
|
||||
import zlib.zdef as zdef
|
||||
from stdio import printf
|
||||
from string import strlen, memcmp, memcpy, memset
|
||||
from stdlib import malloc, free, realloc
|
||||
import stdlib
|
||||
import string
|
||||
import memhub
|
||||
import t, c
|
||||
|
||||
pool: t.CPtr = None
|
||||
|
||||
test_passed: t.CInt = 0
|
||||
test_failed: t.CInt = 0
|
||||
def check(name: str, condition: t.CInt, detail: str):
|
||||
global test_passed, test_failed
|
||||
if condition:
|
||||
test_passed += 1
|
||||
printf(" [PASS] %s\n", name)
|
||||
else:
|
||||
test_failed += 1
|
||||
printf(" [FAIL] %s -- %s\n", name, detail if detail else "")
|
||||
|
||||
def print_hex_test(data: BYTEPTR, length: t.CSizeT, max_show: t.CSizeT):
|
||||
if not data or length == 0:
|
||||
printf("(empty)\n")
|
||||
return
|
||||
show: t.CSizeT = max_show if (length > max_show) else length
|
||||
i: t.CSizeT
|
||||
for i in range(show):
|
||||
printf("%02X ", data[i])
|
||||
if length > max_show:
|
||||
printf("... (%zu bytes total)", length)
|
||||
printf("\n")
|
||||
|
||||
def print_separator():
|
||||
printf(" -------------------------------------------\n")
|
||||
|
||||
def section_header(title: str):
|
||||
printf("\n+-- %s --+\n", title)
|
||||
|
||||
def section_footer():
|
||||
printf("+--------------------------------------------+\n")
|
||||
|
||||
# ============================================================
|
||||
|
||||
def test_version():
|
||||
section_header("Version Info")
|
||||
|
||||
ver: str = pyzlib.ZLIB_VERSION
|
||||
printf(" ZLIB_VERSION (compile-time) : %s\n", ver)
|
||||
check("ZLIB_VERSION not None", ver != None, "version string is None")
|
||||
check("ZLIB_VERSION not empty", strlen(ver) > 0, "version string is empty")
|
||||
|
||||
runtime_ver: str = pyzlib.runtime_version()
|
||||
printf(" ZLIB_RUNTIME_VERSION : %s\n", runtime_ver)
|
||||
check("runtime version not None", runtime_ver != None, "runtime version is None")
|
||||
check("runtime version not empty", strlen(runtime_ver) > 0, "runtime version is empty")
|
||||
|
||||
section_footer()
|
||||
|
||||
|
||||
def test_compress_decompress():
|
||||
section_header("compress / decompress")
|
||||
|
||||
inp: str = "Hello, World! This is a test of zlib compression and decompression."
|
||||
input_length: t.CSizeT = strlen(inp)
|
||||
printf(" Input (%zu bytes): \"%s\"\n", input_length, inp)
|
||||
|
||||
out_length: t.CSizeT = 0
|
||||
compressed: BYTEPTR = pyzlib.compress(pool, BYTEPTR(inp), input_length,
|
||||
pyzlib.Z_DEFAULT_COMPRESSION, pyzlib.MAX_WBITS, c.Addr(out_length))
|
||||
check("compress returns non-None", compressed != None, "compress returned None")
|
||||
check("compress output size > 0", out_length > 0, "compressed size is 0")
|
||||
check("compress output produced", out_length > 0, "compressed size is 0")
|
||||
|
||||
printf(" Compressed (%zu bytes): ", out_length)
|
||||
print_hex_test(compressed, out_length, 32)
|
||||
printf(" Compression ratio: %.1f%%\n", t.CDouble(out_length) / input_length * 100)
|
||||
|
||||
dec_length: t.CSizeT = 0
|
||||
decompressed: BYTEPTR = pyzlib.decompress(pool, compressed, out_length,
|
||||
pyzlib.MAX_WBITS, pyzlib.DEF_BUF_SIZE, c.Addr(dec_length))
|
||||
check("decompress returns non-None", decompressed != None, "decompress returned None")
|
||||
check("decompress output size matches input", dec_length == input_length, "size mismatch")
|
||||
check("decompress output matches input", decompressed != None and memcmp(decompressed, inp, input_length) == 0, "content mismatch")
|
||||
|
||||
printf(" Decompressed (%zu bytes): \"%.*s\"\n", dec_length, t.CInt(dec_length), str(decompressed))
|
||||
|
||||
free(compressed)
|
||||
free(decompressed)
|
||||
section_footer()
|
||||
|
||||
|
||||
def test_compress_levels():
|
||||
section_header("Compression Levels")
|
||||
|
||||
inp: str = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
|
||||
input_length: t.CSizeT = strlen(inp)
|
||||
printf(" Input (%zu bytes): \"%s\"\n", input_length, inp)
|
||||
|
||||
out_length: t.CSizeT = 0
|
||||
|
||||
c0: BYTEPTR = pyzlib.compress(pool, BYTEPTR(inp), input_length,
|
||||
pyzlib.Z_NO_COMPRESSION, pyzlib.MAX_WBITS, c.Addr(out_length))
|
||||
check("level 0 compress OK", c0 != None, "level 0 returned None")
|
||||
printf(" Level 0 (Z_NO_COMPRESSION): %zu bytes\n", out_length)
|
||||
length0: t.CSizeT = out_length
|
||||
free(c0)
|
||||
|
||||
c1: BYTEPTR = pyzlib.compress(pool, BYTEPTR(inp), input_length,
|
||||
pyzlib.Z_BEST_SPEED, pyzlib.MAX_WBITS, c.Addr(out_length))
|
||||
check("level 1 compress OK", c1 != None, "level 1 returned None")
|
||||
printf(" Level 1 (Z_BEST_SPEED) : %zu bytes\n", out_length)
|
||||
free(c1)
|
||||
|
||||
c6: BYTEPTR = pyzlib.compress(pool, BYTEPTR(inp), input_length,
|
||||
pyzlib.Z_DEFAULT_COMPRESSION, pyzlib.MAX_WBITS, c.Addr(out_length))
|
||||
check("level -1 compress OK", c6 != None, "default level returned None")
|
||||
printf(" Level -1 (DEFAULT) : %zu bytes\n", out_length)
|
||||
free(c6)
|
||||
|
||||
c9: BYTEPTR = pyzlib.compress(pool, BYTEPTR(inp), input_length,
|
||||
pyzlib.Z_BEST_COMPRESSION, pyzlib.MAX_WBITS, c.Addr(out_length))
|
||||
check("level 9 compress OK", c9 != None, "level 9 returned None")
|
||||
printf(" Level 9 (Z_BEST_COMPRESS) : %zu bytes\n", out_length)
|
||||
length9: t.CSizeT = out_length
|
||||
free(c9)
|
||||
|
||||
check("level 9 smaller than level 0", length9 < length0, "level 9 not smaller than level 0")
|
||||
|
||||
section_footer()
|
||||
|
||||
|
||||
def test_compressobj():
|
||||
section_header("compressobj (incremental)")
|
||||
|
||||
part1: str = "Hello, "
|
||||
part2: str = "World!"
|
||||
printf(" Part 1: \"%s\"\n", part1)
|
||||
printf(" Part 2: \"%s\"\n", part2)
|
||||
|
||||
out_length: t.CSizeT = 0
|
||||
|
||||
s: pyzlib.Compress | t.CPtr = pyzlib.compressobj(pool, pyzlib.Z_DEFAULT_COMPRESSION, pyzlib.DEFLATED,
|
||||
pyzlib.MAX_WBITS, pyzlib.DEF_MEM_LEVEL,
|
||||
pyzlib.Z_DEFAULT_STRATEGY, None, 0)
|
||||
check("compressobj created", s != None, "compressobj is None")
|
||||
print_separator()
|
||||
|
||||
c1: BYTEPTR = s.compress(BYTEPTR(part1), strlen(part1), c.Addr(out_length))
|
||||
check("compress part1 OK", c1 != None, "compress part1 failed")
|
||||
printf(" Compressed part1: %zu bytes -> ", out_length)
|
||||
print_hex_test(c1, out_length, 16)
|
||||
total: t.CSizeT = out_length
|
||||
all: BYTEPTR = None
|
||||
if out_length > 0 and c1:
|
||||
all = BYTEPTR(malloc(total))
|
||||
if all: memcpy(all, c1, out_length)
|
||||
free(c1)
|
||||
|
||||
c2: BYTEPTR = s.compress(BYTEPTR(part2),
|
||||
strlen(part2), c.Addr(out_length))
|
||||
check("compress part2 OK", c2 != None, "compress part2 failed")
|
||||
printf(" Compressed part2: %zu bytes -> ", out_length)
|
||||
print_hex_test(c2, out_length, 16)
|
||||
if out_length > 0 and c2:
|
||||
new_all: BYTEPTR = BYTEPTR(realloc(all, total + out_length))
|
||||
if new_all:
|
||||
all = new_all
|
||||
memcpy(all + total, c2, out_length)
|
||||
total += out_length
|
||||
free(c2)
|
||||
|
||||
c3: BYTEPTR = s.flush(pyzlib.Z_FINISH, c.Addr(out_length))
|
||||
check("flush (Z_FINISH) OK", c3 != None, "flush failed")
|
||||
printf(" Flush result : %zu bytes -> ", out_length)
|
||||
print_hex_test(c3, out_length, 16)
|
||||
if out_length > 0 and c3:
|
||||
new_all: BYTEPTR = realloc(all, total + out_length) # 隐式转换
|
||||
if new_all:
|
||||
all = new_all
|
||||
memcpy(all + total, c3, out_length)
|
||||
total += out_length
|
||||
free(c3)
|
||||
|
||||
print_separator()
|
||||
|
||||
if all:
|
||||
dec_length: t.CSizeT = 0
|
||||
dec: BYTEPTR = pyzlib.decompress(pool, all, total, pyzlib.MAX_WBITS, pyzlib.DEF_BUF_SIZE, c.Addr(dec_length))
|
||||
check("decompress incremental OK", dec != None, "decompress returned None")
|
||||
check("decompress incremental size", dec != None and dec_length == strlen(part1) + strlen(part2), "size mismatch")
|
||||
check("decompress incremental content",
|
||||
dec != None and memcmp(dec, "Hello, World!", dec_length) == 0, "content mismatch")
|
||||
if dec:
|
||||
printf(" Decompressed: \"%.*s\" (%zu bytes)\n", t.CInt(dec_length), str(dec), dec_length)
|
||||
free(dec)
|
||||
free(all)
|
||||
|
||||
s.delete() # del s
|
||||
section_footer()
|
||||
|
||||
def test_decompressobj():
|
||||
section_header("decompressobj")
|
||||
|
||||
inp: str = "Test data for decompress object."
|
||||
input_length: t.CSizeT = strlen(inp)
|
||||
printf(" Input (%zu bytes): \"%s\"\n", input_length, inp)
|
||||
|
||||
out_length: t.CSizeT = 0
|
||||
compressed: BYTEPTR = pyzlib.compress(pool, BYTEPTR(inp), input_length,
|
||||
pyzlib.Z_DEFAULT_COMPRESSION, pyzlib.MAX_WBITS, c.Addr(out_length))
|
||||
printf(" Compressed: %zu bytes\n", out_length)
|
||||
|
||||
d: pyzlib.Decompress | t.CPtr = pyzlib.decompressobj(pool, pyzlib.MAX_WBITS, None, 0)
|
||||
check("decompressobj created", d != None, "decompressobj is None")
|
||||
check("eof is false initially", d.eof == 0, "eof should be 0")
|
||||
print_separator()
|
||||
|
||||
dec_length: t.CSizeT = 0
|
||||
dec: BYTEPTR = d.decompress(compressed, out_length,
|
||||
0, c.Addr(dec_length))
|
||||
check("decompress OK", dec != None, "decompress returned None")
|
||||
check("decompress size", dec != None and dec_length == input_length, "size mismatch")
|
||||
check("decompress content", dec != None and memcmp(dec, inp, input_length) == 0, "content mismatch")
|
||||
check("eof is true after stream end", d.eof == 1, "eof should be 1")
|
||||
|
||||
if dec:
|
||||
printf(" Decompressed (%zu bytes): \"%.*s\"\n", dec_length, t.CInt(dec_length), str(dec))
|
||||
printf(" eof = %d\n", d.eof)
|
||||
|
||||
free(dec)
|
||||
free(compressed)
|
||||
d.delete()
|
||||
section_footer()
|
||||
|
||||
def test_decompressobj_max_lengthgth():
|
||||
section_header("decompressobj max_lengthgth")
|
||||
|
||||
inp: str = "This is a longer string for testing max_lengthgth parameter in decompress."
|
||||
input_length: t.CSizeT = strlen(inp)
|
||||
printf(" Input (%zu bytes): \"%s\"\n", input_length, inp)
|
||||
|
||||
out_length: t.CSizeT = 0
|
||||
compressed: BYTEPTR = pyzlib.compress(pool, BYTEPTR(inp), input_length,
|
||||
pyzlib.Z_DEFAULT_COMPRESSION, pyzlib.MAX_WBITS, c.Addr(out_length))
|
||||
printf(" Compressed: %zu bytes\n", out_length)
|
||||
|
||||
d: pyzlib.Decompress | t.CPtr = pyzlib.decompressobj(pool, pyzlib.MAX_WBITS, None, 0)
|
||||
|
||||
dec_length: t.CSizeT = 0
|
||||
dec: BYTEPTR = d.decompress(compressed, out_length,
|
||||
10, c.Addr(dec_length))
|
||||
check("max_lengthgth decompress OK", dec != None, "decompress returned None")
|
||||
check("max_lengthgth limits output", dec_length <= 10, "output exceeded max_lengthgth")
|
||||
if dec:
|
||||
printf(" First chunk (max_lengthgth=10): \"%.*s\" (%zu bytes)\n", t.CInt(dec_length), str(dec), dec_length)
|
||||
free(dec)
|
||||
|
||||
tail_length: t.CSizeT = 0
|
||||
tail: BYTEPTR = d.unconsumed_tail(c.Addr(tail_length))
|
||||
check("unconsumed_tail exists", tail != None or tail_length == 0, "no unconsumed_tail")
|
||||
printf(" unconsumed_tail: %zu bytes remaining\n", tail_length)
|
||||
printf(" eof = %d\n", d.eof)
|
||||
|
||||
if tail_length > 0 or not d.eof:
|
||||
flushed: BYTEPTR = d.flush(pyzlib.DEF_BUF_SIZE, c.Addr(dec_length))
|
||||
check("flush after max_lengthgth OK", flushed != None, "flush returned None")
|
||||
if flushed: printf(" Flushed (%zu bytes): \"%.*s\"\n", dec_length, t.CInt(dec_length), str(flushed))
|
||||
free(flushed)
|
||||
|
||||
printf(" eof after flush = %d\n", d.eof)
|
||||
|
||||
d.delete()
|
||||
free(compressed)
|
||||
section_footer()
|
||||
|
||||
|
||||
def test_decompressobj_unused_data():
|
||||
section_header("decompressobj unused_data")
|
||||
|
||||
inp: str = "Hello"
|
||||
input_length: t.CSizeT = strlen(inp)
|
||||
printf(" Input: \"%s\"\n", inp)
|
||||
|
||||
out_length: t.CSizeT = 0
|
||||
compressed: BYTEPTR = pyzlib.compress(pool, BYTEPTR(inp), input_length,
|
||||
pyzlib.Z_DEFAULT_COMPRESSION, pyzlib.MAX_WBITS, c.Addr(out_length))
|
||||
printf(" Compressed: %zu bytes\n", out_length)
|
||||
|
||||
total_length: t.CSizeT = out_length + 5
|
||||
combined: BYTEPTR = BYTEPTR(malloc(total_length))
|
||||
memcpy(combined, compressed, out_length)
|
||||
memcpy(combined + out_length, "EXTRA", 5)
|
||||
free(compressed)
|
||||
printf(" Combined (compressed + \"EXTRA\"): %zu bytes\n", total_length)
|
||||
|
||||
d: pyzlib.Decompress | t.CPtr = pyzlib.decompressobj(pool, pyzlib.MAX_WBITS, None, 0)
|
||||
|
||||
dec_length: t.CSizeT = 0
|
||||
dec: BYTEPTR = d.decompress(combined, total_length,
|
||||
0, c.Addr(dec_length))
|
||||
check("decompress with extra OK", dec != None, "decompress returned None")
|
||||
check("eof after stream end", d.eof == 1, "eof should be 1")
|
||||
if dec:
|
||||
printf(" Decompressed: \"%.*s\" (%zu bytes)\n", t.CInt(dec_length), str(dec), dec_length)
|
||||
free(dec)
|
||||
|
||||
print_separator()
|
||||
|
||||
unused_length: t.CSizeT = 0
|
||||
unused: BYTEPTR = d.unused_data(c.Addr(unused_length))
|
||||
check("unused_data exists", unused != None and unused_length > 0, "no unused_data")
|
||||
check("unused_data is EXTRA", unused_length == 5 and unused != None and memcmp(unused, "EXTRA", 5) == 0, "unused_data mismatch")
|
||||
printf(" unused_data (%zu bytes): \"%.*s\"\n", unused_length, t.CInt(unused_length), str(unused))
|
||||
|
||||
d.delete()
|
||||
free(combined)
|
||||
section_footer()
|
||||
|
||||
|
||||
def test_compress_copy():
|
||||
section_header("Compress.copy()")
|
||||
|
||||
inp: str = "Copy test data for compress object"
|
||||
input_length: t.CSizeT = strlen(inp)
|
||||
printf(" Input: \"%s\"\n", inp)
|
||||
|
||||
out_length: t.CSizeT = 0
|
||||
c1: pyzlib.Compress | t.CPtr = pyzlib.compressobj(pool, pyzlib.Z_DEFAULT_COMPRESSION, pyzlib.DEFLATED,
|
||||
pyzlib.MAX_WBITS, pyzlib.DEF_MEM_LEVEL,
|
||||
pyzlib.Z_DEFAULT_STRATEGY, None, 0)
|
||||
c1.compress(BYTEPTR(inp), input_length, c.Addr(out_length))
|
||||
printf(" Original: compressed %zu bytes so far\n", out_length)
|
||||
|
||||
c2: pyzlib.Compress | t.CPtr = c1.copy()
|
||||
check("compress copy OK", c2 != None, "copy returned None")
|
||||
printf(" Copied compressobj\n")
|
||||
|
||||
print_separator()
|
||||
|
||||
f1: BYTEPTR = c1.flush(pyzlib.Z_FINISH, c.Addr(out_length))
|
||||
check("flush original OK", f1 != None, "flush original failed")
|
||||
length1: t.CSizeT = out_length
|
||||
printf(" Original flush: %zu bytes\n", length1)
|
||||
free(f1)
|
||||
|
||||
f2: BYTEPTR = c2.flush(pyzlib.Z_FINISH, c.Addr(out_length))
|
||||
check("flush copy OK", f2 != None, "flush copy failed")
|
||||
length2: t.CSizeT = out_length
|
||||
printf(" Copy flush : %zu bytes\n", length2)
|
||||
free(f2)
|
||||
|
||||
check("copy produces same output", length1 == length2, "output lengthgths differ")
|
||||
|
||||
c1.delete()
|
||||
c2.delete()
|
||||
section_footer()
|
||||
|
||||
|
||||
def test_decompress_copy():
|
||||
section_header("Decompress.copy()")
|
||||
|
||||
inp: str = "Decompress copy test"
|
||||
input_length: t.CSizeT = strlen(inp)
|
||||
printf(" Input: \"%s\"\n", inp)
|
||||
|
||||
out_length: t.CSizeT = 0
|
||||
compressed: BYTEPTR = pyzlib.compress(pool, BYTEPTR(inp), input_length,
|
||||
pyzlib.Z_DEFAULT_COMPRESSION, pyzlib.MAX_WBITS, c.Addr(out_length))
|
||||
printf(" Compressed: %zu bytes\n", out_length)
|
||||
|
||||
d1: pyzlib.Decompress | t.CPtr = pyzlib.decompressobj(pool, pyzlib.MAX_WBITS, None, 0)
|
||||
d2: pyzlib.Decompress | t.CPtr = d1.copy()
|
||||
check("decompress copy OK", d2 != None, "copy returned None")
|
||||
printf(" Copied decompressobj\n")
|
||||
|
||||
print_separator()
|
||||
|
||||
dec_length1: t.CSizeT = 0
|
||||
dec_length2: t.CSizeT = 0
|
||||
dec1: BYTEPTR = d1.decompress(compressed, out_length,
|
||||
0, c.Addr(dec_length1))
|
||||
dec2: BYTEPTR = d2.decompress(compressed, out_length,
|
||||
0, c.Addr(dec_length2))
|
||||
check("decompress copy output size", dec_length1 == dec_length2, "sizes differ")
|
||||
check("decompress copy output content",
|
||||
dec1 and dec2 and memcmp(dec1, dec2, dec_length1) == 0, "content differs")
|
||||
|
||||
if dec1: printf(" Original: \"%.*s\" (%zu bytes)\n", t.CInt(dec_length1), str(dec1), dec_length1)
|
||||
if dec2: printf(" Copy : \"%.*s\" (%zu bytes)\n", t.CInt(dec_length2), str(dec2), dec_length2)
|
||||
|
||||
free(dec1)
|
||||
free(dec2)
|
||||
free(compressed)
|
||||
d1.delete()
|
||||
d2.delete()
|
||||
section_footer()
|
||||
|
||||
|
||||
def test_adler32():
|
||||
section_header("adler32 checksum")
|
||||
|
||||
checksum: ULONG = pyzlib.zlib_adler32(BYTEPTR("Hello"), 5, 1)
|
||||
printf(" adler32(\"Hello\") = 0x%08lX (%lu)\n", checksum, checksum)
|
||||
check("adler32 returns non-zero", checksum != 0, "checksum is 0")
|
||||
|
||||
incremental: ULONG = pyzlib.zlib_adler32(BYTEPTR("Hel"), 3, 1)
|
||||
printf(" adler32(\"Hel\") = 0x%08lX\n", incremental)
|
||||
incremental = pyzlib.zlib_adler32(BYTEPTR("lo"), 2, incremental)
|
||||
printf(" adler32(\"lo\", prev) = 0x%08lX\n", incremental)
|
||||
check("adler32 incremental matches one-shot", incremental == checksum, "incremental != one-shot")
|
||||
printf(" Incremental == One-shot: %s\n", incremental == checksum if checksum else "NO")
|
||||
|
||||
section_footer()
|
||||
|
||||
|
||||
def test_crc32():
|
||||
section_header("crc32 checksum")
|
||||
|
||||
checksum: ULONG = pyzlib.zlib_crc32(BYTEPTR("Hello"), 5, 0)
|
||||
printf(" crc32(\"Hello\") = 0x%08lX (%lu)\n", checksum, checksum)
|
||||
check("crc32 returns non-zero", checksum != 0, "checksum is 0")
|
||||
|
||||
incremental: ULONG = pyzlib.zlib_crc32(BYTEPTR("Hel"), 3, 0)
|
||||
printf(" crc32(\"Hel\") = 0x%08lX\n", incremental)
|
||||
incremental = pyzlib.zlib_crc32(BYTEPTR("lo"), 2, incremental)
|
||||
printf(" crc32(\"lo\", prev) = 0x%08lX\n", incremental)
|
||||
check("crc32 incremental matches one-shot", incremental == checksum, "incremental != one-shot")
|
||||
printf(" Incremental == One-shot: %s\n", incremental == checksum if checksum else "NO")
|
||||
|
||||
section_footer()
|
||||
|
||||
|
||||
def test_empty_compress():
|
||||
section_header("Empty data compress/decompress")
|
||||
|
||||
out_length: t.CSizeT = 0
|
||||
compressed: BYTEPTR = pyzlib.compress(pool, BYTEPTR(""), 0,
|
||||
pyzlib.Z_DEFAULT_COMPRESSION, pyzlib.MAX_WBITS, c.Addr(out_length))
|
||||
check("compress empty OK", compressed != None, "compress empty returned None")
|
||||
check("compress empty output > 0", out_length > 0, "compressed empty is 0 bytes")
|
||||
printf(" Empty input compressed: %zu bytes (header only)\n", out_length)
|
||||
printf(" Hex: ")
|
||||
print_hex_test(compressed, out_length, 32)
|
||||
|
||||
dec_length: t.CSizeT = 0
|
||||
decompressed: BYTEPTR = pyzlib.decompress(pool, compressed, out_length,
|
||||
pyzlib.MAX_WBITS, pyzlib.DEF_BUF_SIZE, c.Addr(dec_length))
|
||||
check("decompress empty OK", decompressed != None, "decompress empty returned None")
|
||||
check("decompress empty size == 0", dec_length == 0, "decompressed size != 0")
|
||||
printf(" Decompressed back: %zu bytes\n", dec_length)
|
||||
|
||||
free(compressed)
|
||||
free(decompressed)
|
||||
section_footer()
|
||||
|
||||
|
||||
def test_gzip_format():
|
||||
section_header("Gzip format (wbits=31)")
|
||||
|
||||
inp: str = "Gzip format test"
|
||||
input_length: t.CSizeT = strlen(inp)
|
||||
printf(" Input: \"%s\" (%zu bytes)\n", inp, input_length)
|
||||
|
||||
gzip_wbits: t.CInt = pyzlib.MAX_WBITS + 16
|
||||
printf(" wbits = MAX_WBITS + 16 = %d\n", gzip_wbits)
|
||||
|
||||
out_length: t.CSizeT = 0
|
||||
compressed: BYTEPTR = pyzlib.compress(pool, BYTEPTR(inp), input_length,
|
||||
pyzlib.Z_DEFAULT_COMPRESSION, gzip_wbits, c.Addr(out_length))
|
||||
check("gzip compress OK", compressed != None, "gzip compress failed")
|
||||
printf(" Gzip compressed: %zu bytes\n", out_length)
|
||||
printf(" Header bytes: ")
|
||||
print_hex_test(compressed, 4 if (out_length > 4) else out_length, 4)
|
||||
|
||||
dec_length: t.CSizeT = 0
|
||||
decompressed: BYTEPTR = pyzlib.decompress(pool, compressed, out_length,
|
||||
gzip_wbits, pyzlib.DEF_BUF_SIZE, c.Addr(dec_length))
|
||||
check("gzip decompress OK", decompressed != None, "gzip decompress failed")
|
||||
check("gzip decompress size", dec_length == input_length, "size mismatch")
|
||||
check("gzip decompress content", decompressed != None and memcmp(decompressed, inp, input_length) == 0, "content mismatch")
|
||||
if decompressed: printf(" Decompressed: \"%.*s\" (%zu bytes)\n", t.CInt(dec_length), str(decompressed), dec_length)
|
||||
|
||||
free(compressed)
|
||||
free(decompressed)
|
||||
section_footer()
|
||||
|
||||
|
||||
def test_raw_deflate():
|
||||
section_header("Raw deflate (wbits=-15)")
|
||||
|
||||
inp: str = "Raw deflate test"
|
||||
input_length: t.CSizeT = strlen(inp)
|
||||
printf(" Input: \"%s\" (%zu bytes)\n", inp, input_length)
|
||||
|
||||
raw_wbits: t.CInt = -pyzlib.MAX_WBITS
|
||||
printf(" wbits = -MAX_WBITS = %d\n", raw_wbits)
|
||||
|
||||
out_length: t.CSizeT = 0
|
||||
compressed: BYTEPTR = pyzlib.compress(pool, BYTEPTR(inp), input_length,
|
||||
pyzlib.Z_DEFAULT_COMPRESSION, raw_wbits, c.Addr(out_length))
|
||||
check("raw deflate compress OK", compressed != None, "raw deflate compress failed")
|
||||
printf(" Raw compressed: %zu bytes\n", out_length)
|
||||
|
||||
dec_length: t.CSizeT = 0
|
||||
decompressed: BYTEPTR = pyzlib.decompress(pool, compressed, out_length,
|
||||
raw_wbits, pyzlib.DEF_BUF_SIZE, c.Addr(dec_length))
|
||||
check("raw deflate decompress OK", decompressed != None, "raw deflate decompress failed")
|
||||
check("raw deflate decompress size", dec_length == input_length, "size mismatch")
|
||||
check("raw deflate decompress content", decompressed != None and memcmp(decompressed, inp, input_length) == 0, "content mismatch")
|
||||
if decompressed: printf(" Decompressed: \"%.*s\" (%zu bytes)\n", t.CInt(dec_length), str(decompressed), dec_length)
|
||||
|
||||
free(compressed)
|
||||
free(decompressed)
|
||||
section_footer()
|
||||
|
||||
|
||||
def test_zdict():
|
||||
section_header("Preset dictionary (zdict)")
|
||||
|
||||
dict: str = "common words that appear frequently in the data"
|
||||
inp: str = "common words that appear frequently"
|
||||
input_length: t.CSizeT = strlen(inp)
|
||||
printf(" Dictionary: \"%s\" (%zu bytes)\n", dict, strlen(dict))
|
||||
printf(" Input : \"%s\" (%zu bytes)\n", inp, input_length)
|
||||
|
||||
out_length: t.CSizeT = 0
|
||||
s: pyzlib.Compress | t.CPtr = pyzlib.compressobj(pool, pyzlib.Z_DEFAULT_COMPRESSION, pyzlib.DEFLATED,
|
||||
pyzlib.MAX_WBITS, pyzlib.DEF_MEM_LEVEL,
|
||||
pyzlib.Z_DEFAULT_STRATEGY,
|
||||
BYTEPTR(dict), strlen(dict))
|
||||
check("compressobj with zdict OK", s != None, "compressobj with zdict failed")
|
||||
|
||||
comp_data: BYTEPTR = s.compress(BYTEPTR(inp),
|
||||
input_length, c.Addr(out_length))
|
||||
check("compress with zdict OK", comp_data != None, "compress with zdict failed")
|
||||
printf(" Compressed with zdict: %zu bytes\n", out_length)
|
||||
free(comp_data)
|
||||
|
||||
flush_data: BYTEPTR = s.flush(pyzlib.Z_FINISH, c.Addr(out_length))
|
||||
check("flush with zdict OK", flush_data != None, "flush with zdict failed")
|
||||
printf(" Flush: %zu bytes\n", out_length)
|
||||
free(flush_data)
|
||||
|
||||
print_separator()
|
||||
|
||||
total_comp: t.CSizeT = out_length
|
||||
s.delete()
|
||||
|
||||
s = pyzlib.compressobj(pool, pyzlib.Z_DEFAULT_COMPRESSION, pyzlib.DEFLATED,
|
||||
pyzlib.MAX_WBITS, pyzlib.DEF_MEM_LEVEL,
|
||||
pyzlib.Z_DEFAULT_STRATEGY, None, 0)
|
||||
comp_no_dict: BYTEPTR = s.compress(BYTEPTR(inp),
|
||||
input_length, c.Addr(out_length))
|
||||
flush_no_dict: BYTEPTR = s.flush(pyzlib.Z_FINISH, c.Addr(out_length))
|
||||
no_dict_total: t.CSizeT = 0
|
||||
if comp_no_dict: no_dict_total += out_length
|
||||
if flush_no_dict: no_dict_total += out_length
|
||||
printf(" Without zdict: ~%zu bytes compressed\n", no_dict_total)
|
||||
printf(" With zdict : %zu bytes compressed\n", total_comp)
|
||||
free(comp_no_dict)
|
||||
free(flush_no_dict)
|
||||
s.delete()
|
||||
|
||||
section_footer()
|
||||
|
||||
|
||||
def test_huffman_tree():
|
||||
section_header("Huffman tree construction")
|
||||
|
||||
printf(" --- Fixed Huffman tree (literal/lengthgth) ---\n")
|
||||
lit_tree = zhuff.zhuff_tree()
|
||||
lit_tree.build_fixed_lit_tree()
|
||||
|
||||
check("fixed lit tree count == 288", lit_tree.count == 288, "count mismatch")
|
||||
check("fixed lit tree max_bits == 9", lit_tree.max_bits == 9, "max_bits mismatch")
|
||||
|
||||
has_8bit: t.CInt = 0
|
||||
has_9bit: t.CInt = 0
|
||||
has_7bit: t.CInt = 0
|
||||
for i in range(143 + 1):
|
||||
if lit_tree.codes[i].bits == 8:
|
||||
has_8bit += 1
|
||||
for i in range(143 + 1, 255 + 1):
|
||||
if lit_tree.codes[i].bits == 9:
|
||||
has_9bit += 1
|
||||
for i in range(255 + 1, 279 + 1):
|
||||
if lit_tree.codes[i].bits == 7:
|
||||
has_7bit += 1
|
||||
check("0-143 are 8-bit", has_8bit == 144, "wrong count")
|
||||
check("144-255 are 9-bit", has_9bit == 112, "wrong count")
|
||||
check("256-279 are 7-bit", has_7bit == 24, "wrong count")
|
||||
|
||||
printf(" 0-143: %d codes with 8 bits\n", has_8bit)
|
||||
printf(" 144-255: %d codes with 9 bits\n", has_9bit)
|
||||
printf(" 256-279: %d codes with 7 bits\n", has_7bit)
|
||||
printf(" 280-287: 8-bit (end-of-block 256 = 7-bit)\n")
|
||||
printf(" EOB (256): code=0x%X, bits=%d\n", lit_tree.codes[256].code, lit_tree.codes[256].bits)
|
||||
|
||||
printf("\n --- Fixed Huffman tree (distance) ---\n")
|
||||
dist_tree = zhuff.zhuff_tree()
|
||||
dist_tree.build_fixed_dist_tree()
|
||||
|
||||
check("fixed dist tree count == 32", dist_tree.count == 32, "count mismatch")
|
||||
check("fixed dist tree max_bits == 5", dist_tree.max_bits == 5, "max_bits mismatch")
|
||||
|
||||
all_5bit: t.CInt = 1
|
||||
for i in range(32):
|
||||
if dist_tree.codes[i].bits != 5:
|
||||
all_5bit = 0
|
||||
check("all 32 distance codes are 5-bit", all_5bit, "not all 5-bit")
|
||||
printf(" All 32 distance codes: 5 bits each\n")
|
||||
|
||||
printf("\n --- Dynamic Huffman tree from frequencies ---\n")
|
||||
freqs: t.CArray[t.CInt, 257]
|
||||
memset(freqs, 0, freqs.__sizeof__())
|
||||
freqs['A'] = 50
|
||||
freqs['B'] = 25
|
||||
freqs['C'] = 12
|
||||
freqs['D'] = 6
|
||||
freqs['E'] = 3
|
||||
freqs['F'] = 1
|
||||
freqs[256] = 1
|
||||
|
||||
dyn_tree = zhuff.zhuff_tree()
|
||||
dyn_tree.build_codes(freqs, 257, 15)
|
||||
|
||||
check("dynamic tree count == 257", dyn_tree.count == 257, "count mismatch")
|
||||
check("dynamic tree max_bits <= 15", dyn_tree.max_bits <= 15, "max_bits overflow")
|
||||
|
||||
total_codes: t.CInt = 0
|
||||
max_length_found: t.CInt = 0
|
||||
for i in range(257):
|
||||
if dyn_tree.codes[i].bits > 0:
|
||||
total_codes += 1
|
||||
if dyn_tree.codes[i].bits > max_length_found:
|
||||
max_length_found = dyn_tree.codes[i].bits
|
||||
check("dynamic tree has 7 active codes", total_codes == 7, "wrong active count")
|
||||
check("dynamic tree max code lengthgth found <= 15", max_length_found <= 15, "code lengthgth overflow")
|
||||
|
||||
printf(" Frequencies: A=50, B=25, C=12, D=6, E=3, F=1, EOB=1\n")
|
||||
printf(" Active codes: %d, max code lengthgth: %d\n", total_codes, max_length_found)
|
||||
|
||||
printf(" Code assignments:\n")
|
||||
names: t.CArray[str, None] = ["A","B","C","D","E","F"] # 一个都是char* 的数组
|
||||
syms: t.CArray[t.CInt, None] = ['A','B','C','D','E','F']
|
||||
for i in range(6):
|
||||
printf(" '%s' (freq=%3d): code=0x%04X, bits=%d\n",
|
||||
names[i], freqs[syms[i]],
|
||||
dyn_tree.codes[syms[i]].code,
|
||||
dyn_tree.codes[syms[i]].bits)
|
||||
|
||||
|
||||
|
||||
printf(" EOB (freq=1): code=0x%04X, bits=%d\n",
|
||||
dyn_tree.codes[256].code, dyn_tree.codes[256].bits)
|
||||
a_bits: t.CInt = dyn_tree.codes['A'].bits
|
||||
f_bits: t.CInt = dyn_tree.codes['F'].bits
|
||||
check("high-freq symbol has shorter code", a_bits <= f_bits, "A should be <= F")
|
||||
printf(" High-freq 'A' (%d bits) <= low-freq 'F' (%d bits): %s\n",
|
||||
a_bits, f_bits, "YES" if (a_bits <= f_bits) else "NO")
|
||||
|
||||
printf("\n --- Huffman encode/decode roundtrip ---\n")
|
||||
freqs: t.CArray[t.CInt, 288]
|
||||
memset(freqs, 0, freqs.__sizeof__())
|
||||
freqs['H'] = 10
|
||||
freqs['e'] = 8
|
||||
freqs['l'] = 20
|
||||
freqs['o'] = 8
|
||||
freqs[' '] = 5
|
||||
freqs['W'] = 3
|
||||
freqs['r'] = 5
|
||||
freqs['d'] = 3
|
||||
freqs['!'] = 2
|
||||
freqs[256] = 1
|
||||
|
||||
enc_tree = zhuff.zhuff_tree()
|
||||
enc_tree.build_codes(freqs, 257, 15)
|
||||
|
||||
dec_tree = zhuff.zhuff_decode_tree()
|
||||
dec_tree.build_decode_tree(c.Addr(enc_tree))
|
||||
|
||||
writer = zdef.zbit_writer()
|
||||
|
||||
symbols: t.CArray[t.CInt, 16]
|
||||
symbols[0] = 'H'; symbols[1] = 'e'; symbols[2] = 'l'; symbols[3] = 'l'
|
||||
symbols[4] = 'o'; symbols[5] = ' '; symbols[6] = 'W'; symbols[7] = 'o'
|
||||
symbols[8] = 'r'; symbols[9] = 'l'; symbols[10] = 'd'; symbols[11] = '!'
|
||||
symbols[12] = 256
|
||||
num_symbols: t.CInt = 13
|
||||
|
||||
for i in range(num_symbols):
|
||||
enc_tree.encode_symbol(symbols[i], c.Addr(writer))
|
||||
|
||||
reader = zdef.zbit_reader()
|
||||
reader.buf = writer.buf
|
||||
reader.length = writer.byte_pos + (1 if (writer.bit_pos > 0) else 0)
|
||||
reader.byte_pos = 0
|
||||
reader.bit_pos = 0
|
||||
|
||||
roundtrip_ok: t.CInt = 1
|
||||
for i in range(num_symbols):
|
||||
decoded: t.CInt = dec_tree.decode_symbol(c.Addr(reader))
|
||||
if decoded != symbols[i]:
|
||||
roundtrip_ok = 0
|
||||
printf(" MISMATCH at symbol %d: expected %d, got %d\n", i, symbols[i], decoded)
|
||||
break
|
||||
check("encode/decode roundtrip matches", roundtrip_ok, "roundtrip failed")
|
||||
printf(" Encoded %d symbols into %zu bytes, decoded all correctly\n",
|
||||
num_symbols, writer.byte_pos + (1 if (writer.bit_pos > 0) else 0))
|
||||
|
||||
free(writer.buf)
|
||||
|
||||
printf("\n --- Overflow handling (many symbols, limited max_bits) ---\n")
|
||||
freqs: t.CArray[t.CInt, 257]
|
||||
for i in range(256):
|
||||
freqs[i] = 1
|
||||
freqs[256] = 1
|
||||
|
||||
tree = zhuff.zhuff_tree()
|
||||
tree.build_codes(freqs, 257, 15)
|
||||
|
||||
overflow_ok: t.CInt = 1
|
||||
for i in range(257):
|
||||
if tree.codes[i].bits > 15 or tree.codes[i].bits < 0:
|
||||
overflow_ok = 0
|
||||
break
|
||||
check("all code lengthgths <= 15 with 257 symbols", overflow_ok, "code lengthgth overflow")
|
||||
|
||||
bl_count: t.CArray[t.CInt, 16] = [0]
|
||||
for i in range(257):
|
||||
if tree.codes[i].bits > 0:
|
||||
bl_count[tree.codes[i].bits] += 1
|
||||
printf(" Code lengthgth distribution (257 equal-freq symbols, max_bits=15):\n")
|
||||
for i in range(1, 15 + 1):
|
||||
if bl_count[i] > 0:
|
||||
printf(" %2d bits: %3d codes\n", i, bl_count[i])
|
||||
|
||||
dt = zhuff.zhuff_decode_tree()
|
||||
dt.build_decode_tree(c.Addr(tree))
|
||||
|
||||
w = zdef.zbit_writer()
|
||||
tree.encode_symbol(0, c.Addr(w))
|
||||
tree.encode_symbol(128, c.Addr(w))
|
||||
tree.encode_symbol(255, c.Addr(w))
|
||||
tree.encode_symbol(256, c.Addr(w))
|
||||
|
||||
r = zdef.zbit_reader()
|
||||
r.buf = w.buf
|
||||
r.length = w.byte_pos + (1 if (w.bit_pos > 0) else 0)
|
||||
r.byte_pos = 0
|
||||
r.bit_pos = 0
|
||||
|
||||
s0: t.CInt = dt.decode_symbol(c.Addr(r))
|
||||
s1: t.CInt = dt.decode_symbol(c.Addr(r))
|
||||
s2: t.CInt = dt.decode_symbol(c.Addr(r))
|
||||
s3: t.CInt = dt.decode_symbol(c.Addr(r))
|
||||
|
||||
check("overflow roundtrip: symbol 0", s0 == 0, "decode mismatch")
|
||||
check("overflow roundtrip: symbol 128", s1 == 128, "decode mismatch")
|
||||
check("overflow roundtrip: symbol 255", s2 == 255, "decode mismatch")
|
||||
check("overflow roundtrip: symbol 256 (EOB)", s3 == 256, "decode mismatch")
|
||||
|
||||
free(w.buf)
|
||||
|
||||
|
||||
printf("\n --- Kraft inequality check ---\n")
|
||||
freqs: t.CArray[t.CInt, 257]
|
||||
memset(freqs, 0, freqs.__sizeof__())
|
||||
freqs['X'] = 100
|
||||
freqs['Y'] = 50
|
||||
freqs['Z'] = 25
|
||||
freqs[256] = 1
|
||||
|
||||
tree = zhuff.zhuff_tree()
|
||||
tree.build_codes(freqs, 257, 15)
|
||||
|
||||
kraft_sum: t.CDouble = 0.0
|
||||
for i in range(257):
|
||||
if tree.codes[i].bits > 0:
|
||||
kraft_sum += 1.0 / (t.CDouble(ULONGLONG(1) << tree.codes[i].bits))
|
||||
check("Kraft inequality: sum <= 1.0", kraft_sum <= 1.0 + 1e-9, "Kraft violated")
|
||||
printf(" Kraft sum = %.10f (must be <= 1.0)\n", kraft_sum)
|
||||
|
||||
section_footer()
|
||||
|
||||
|
||||
def test_error_handling():
|
||||
section_header("Error handling")
|
||||
|
||||
out_length: t.CSizeT = 0
|
||||
printf(" Trying to decompress garbage data...\n")
|
||||
|
||||
result: BYTEPTR = pyzlib.decompress(pool, BYTEPTR("garbage"), 7,
|
||||
pyzlib.MAX_WBITS, pyzlib.DEF_BUF_SIZE, c.Addr(out_length))
|
||||
check("decompress garbage returns None", result == None, "should have returned None")
|
||||
printf(" Error code : %d\n", pyzlib.get_error_code())
|
||||
printf(" Error message: \"%s\"\n", pyzlib.get_error())
|
||||
check("error message set", strlen(pyzlib.get_error()) > 0, "error message is empty")
|
||||
check("error code is set", pyzlib.get_error_code() != pyzlib.Z_OK, "error code is Z_OK")
|
||||
|
||||
print_separator()
|
||||
|
||||
pyzlib.clear_error()
|
||||
check("clear error clears code", pyzlib.get_error_code() == 0, "error code not cleared")
|
||||
printf(" After clear: code=%d, msg=\"%s\"\n", pyzlib.get_error_code(), pyzlib.get_error())
|
||||
|
||||
section_footer()
|
||||
|
||||
|
||||
def test_constants():
|
||||
section_header("Constants")
|
||||
printf(" Compression Levels:\n")
|
||||
printf(" Z_NO_COMPRESSION = %d\n", pyzlib.Z_NO_COMPRESSION)
|
||||
printf(" Z_BEST_SPEED = %d\n", pyzlib.Z_BEST_SPEED)
|
||||
printf(" Z_BEST_COMPRESSION = %d\n", pyzlib.Z_BEST_COMPRESSION)
|
||||
printf(" Z_DEFAULT_COMPRESSION = %d\n", pyzlib.Z_DEFAULT_COMPRESSION)
|
||||
printf(" Methods:\n")
|
||||
printf(" DEFLATED = %d\n", pyzlib.DEFLATED)
|
||||
printf(" Flush Modes:\n")
|
||||
printf(" Z_NO_FLUSH = %d\n", pyzlib.Z_NO_FLUSH)
|
||||
printf(" Z_PARTIAL_FLUSH = %d\n", pyzlib.Z_PARTIAL_FLUSH)
|
||||
printf(" Z_SYNC_FLUSH = %d\n", pyzlib.Z_SYNC_FLUSH)
|
||||
printf(" Z_FULL_FLUSH = %d\n", pyzlib.Z_FULL_FLUSH)
|
||||
printf(" Z_FINISH = %d\n", pyzlib.Z_FINISH)
|
||||
printf(" Z_BLOCK = %d\n", pyzlib.Z_BLOCK)
|
||||
printf(" Z_TREES = %d\n", pyzlib.Z_TREES)
|
||||
printf(" Strategies:\n")
|
||||
printf(" Z_DEFAULT_STRATEGY = %d\n", pyzlib.Z_DEFAULT_STRATEGY)
|
||||
printf(" Z_FILTERED = %d\n", pyzlib.Z_FILTERED)
|
||||
printf(" Z_HUFFMAN_ONLY = %d\n", pyzlib.Z_HUFFMAN_ONLY)
|
||||
printf(" Z_RLE = %d\n", pyzlib.Z_RLE)
|
||||
printf(" Z_FIXED = %d\n", pyzlib.Z_FIXED)
|
||||
printf(" Return Codes:\n")
|
||||
printf(" Z_OK = %d\n", pyzlib.Z_OK)
|
||||
printf(" Z_STREAM_END = %d\n", pyzlib.Z_STREAM_END)
|
||||
printf(" Z_NEED_DICT = %d\n", pyzlib.Z_NEED_DICT)
|
||||
printf(" Z_ERRNO = %d\n", pyzlib.Z_ERRNO)
|
||||
printf(" Z_STREAM_ERROR = %d\n", pyzlib.Z_STREAM_ERROR)
|
||||
printf(" Z_DATA_ERROR = %d\n", pyzlib.Z_DATA_ERROR)
|
||||
printf(" Z_MEM_ERROR = %d\n", pyzlib.Z_MEM_ERROR)
|
||||
printf(" Z_BUF_ERROR = %d\n", pyzlib.Z_BUF_ERROR)
|
||||
printf(" Z_VERSION_ERROR = %d\n", pyzlib.Z_VERSION_ERROR)
|
||||
printf(" Window / Buffer:\n")
|
||||
printf(" MAX_WBITS = %d\n", pyzlib.MAX_WBITS)
|
||||
printf(" DEF_BUF_SIZE = %d\n", pyzlib.DEF_BUF_SIZE)
|
||||
printf(" DEF_MEM_LEVEL = %d\n", pyzlib.DEF_MEM_LEVEL)
|
||||
section_footer()
|
||||
|
||||
|
||||
def main123456() -> t.CInt:
|
||||
printf("==============================================\n")
|
||||
printf(" Python zlib - C Implementation Tests\n")
|
||||
printf("==============================================\n")
|
||||
|
||||
test_constants()
|
||||
test_version()
|
||||
test_compress_decompress()
|
||||
test_compress_levels()
|
||||
test_compressobj()
|
||||
test_decompressobj()
|
||||
test_decompressobj_max_lengthgth()
|
||||
test_decompressobj_unused_data()
|
||||
test_compress_copy()
|
||||
test_decompress_copy()
|
||||
test_adler32()
|
||||
test_crc32()
|
||||
test_empty_compress()
|
||||
test_gzip_format()
|
||||
test_raw_deflate()
|
||||
test_zdict()
|
||||
test_huffman_tree()
|
||||
test_error_handling()
|
||||
|
||||
printf("\n==============================================\n")
|
||||
printf(" Results: %d passed, %d failed\n", test_passed, test_failed)
|
||||
printf("==============================================\n")
|
||||
|
||||
return 1 if test_failed > 0 else 0
|
||||
@@ -1,245 +0,0 @@
|
||||
import stdio
|
||||
import stdint
|
||||
import t, c
|
||||
|
||||
|
||||
class SimpleData(t.Object):
|
||||
x: t.CInt
|
||||
y: t.CInt
|
||||
|
||||
|
||||
class Point3D(t.Object):
|
||||
x: t.CFloat
|
||||
y: t.CFloat
|
||||
z: t.CFloat
|
||||
|
||||
|
||||
class Student(t.Object):
|
||||
name: t.CChar | t.CPtr
|
||||
age: t.CInt
|
||||
score: t.CInt
|
||||
|
||||
def __init__(self, n: t.CChar | t.CPtr, a: t.CInt, s: t.CInt):
|
||||
self.name = n
|
||||
self.age = a
|
||||
self.score = s
|
||||
|
||||
def get_age(self) -> t.CInt:
|
||||
return self.age
|
||||
|
||||
def get_score(self) -> t.CInt:
|
||||
return self.score
|
||||
|
||||
|
||||
class Counter(t.Object):
|
||||
value: t.CInt
|
||||
|
||||
def __init__(self, initial: t.CInt):
|
||||
self.value = initial
|
||||
|
||||
def increment(self):
|
||||
self.value += 1
|
||||
|
||||
def get_value(self) -> t.CInt:
|
||||
return self.value
|
||||
|
||||
|
||||
class StackObj(t.Object):
|
||||
data: t.CInt
|
||||
next_ptr: t.CVoid | t.CPtr
|
||||
|
||||
|
||||
def TestBasicDataClass():
|
||||
stdio.printf("=== Test Basic Data Class ===\n")
|
||||
p: SimpleData = SimpleData()
|
||||
p.x = 10
|
||||
p.y = 20
|
||||
stdio.printf("SimpleData: x=%d, y=%d\n", p.x, p.y)
|
||||
|
||||
|
||||
def TestPoint3DClass():
|
||||
stdio.printf("=== Test Point3D Class ===\n")
|
||||
pt: Point3D = Point3D()
|
||||
pt.x = 1.5
|
||||
pt.y = 2.5
|
||||
pt.z = 3.5
|
||||
stdio.printf("Point3D: x=%.1f, y=%.1f, z=%.1f\n", pt.x, pt.y, pt.z)
|
||||
|
||||
|
||||
def TestStudentClass():
|
||||
stdio.printf("=== Test Student Class ===\n")
|
||||
s: Student = Student("Alice", 20, 95)
|
||||
stdio.printf("Student: name=%s, age=%d, score=%d\n", s.name, s.age, s.score)
|
||||
stdio.printf(" get_age()=%d, get_score()=%d\n", s.get_age(), s.get_score())
|
||||
|
||||
|
||||
def TestCounterClass():
|
||||
stdio.printf("=== Test Counter Class ===\n")
|
||||
cnt: Counter = Counter(0)
|
||||
stdio.printf("Initial value: %d\n", cnt.get_value())
|
||||
cnt.increment()
|
||||
cnt.increment()
|
||||
cnt.increment()
|
||||
stdio.printf("After 3 increments: %d\n", cnt.get_value())
|
||||
|
||||
|
||||
def TestStackAllocation():
|
||||
stdio.printf("=== Test Stack Allocation ===\n")
|
||||
obj1: SimpleData = SimpleData()
|
||||
obj1.x = 100
|
||||
obj1.y = 200
|
||||
stdio.printf("Stack obj1: x=%d, y=%d\n", obj1.x, obj1.y)
|
||||
|
||||
obj2: Point3D = Point3D()
|
||||
obj2.x = 10.0
|
||||
obj2.y = 20.0
|
||||
obj2.z = 30.0
|
||||
stdio.printf("Stack obj2: x=%.1f, y=%.1f, z=%.1f\n", obj2.x, obj2.y, obj2.z)
|
||||
|
||||
|
||||
def TestHeapAllocation():
|
||||
stdio.printf("=== Test Heap Allocation ===\n")
|
||||
ptr: t.CVoid | t.CPtr = c.malloc(1024)
|
||||
if ptr != 0:
|
||||
stdio.printf("Allocated 1024 bytes at %p\n", ptr)
|
||||
c.free(ptr)
|
||||
stdio.printf("Freed memory\n")
|
||||
else:
|
||||
stdio.printf("malloc failed\n")
|
||||
|
||||
|
||||
def TestHeapObjectWithInit():
|
||||
stdio.printf("=== Test Heap Object with Init ===\n")
|
||||
mem_size: t.CSizeT = 256
|
||||
ptr: t.CVoid | t.CPtr = c.malloc(mem_size)
|
||||
if ptr != 0:
|
||||
stdio.printf("Allocated %d bytes\n", mem_size)
|
||||
c.free(ptr)
|
||||
else:
|
||||
stdio.printf("malloc failed\n")
|
||||
|
||||
|
||||
def TestMultipleStackObjects():
|
||||
stdio.printf("=== Test Multiple Stack Objects ===\n")
|
||||
objs: SimpleData = SimpleData()
|
||||
objs.x = 1
|
||||
objs.y = 2
|
||||
obj2: Point3D = Point3D()
|
||||
obj2.x = 5.0
|
||||
obj2.y = 10.0
|
||||
obj2.z = 15.0
|
||||
obj3: Counter = Counter(42)
|
||||
stdio.printf("objs: x=%d, y=%d\n", objs.x, objs.y)
|
||||
stdio.printf("obj2: x=%.1f, y=%.1f, z=%.1f\n", obj2.x, obj2.y, obj2.z)
|
||||
stdio.printf("obj3 initial: %d\n", obj3.get_value())
|
||||
obj3.increment()
|
||||
obj3.increment()
|
||||
stdio.printf("obj3 after 2 increments: %d\n", obj3.get_value())
|
||||
|
||||
|
||||
def TestImplicitInitCall():
|
||||
stdio.printf("=== Test Implicit Init Call ===\n")
|
||||
stu1: Student = Student("Bob", 22, 88)
|
||||
stu2: Student = Student("Charlie", 19, 77)
|
||||
stdio.printf("stu1: name=%s, age=%d, score=%d\n", stu1.name, stu1.age, stu1.score)
|
||||
stdio.printf("stu2: name=%s, age=%d, score=%d\n", stu2.name, stu2.age, stu2.score)
|
||||
|
||||
|
||||
def TestClassWithBitFields():
|
||||
stdio.printf("=== Test Class with Bit Fields ===\n")
|
||||
flags: StackObj = StackObj()
|
||||
flags.data = 0
|
||||
flags.next_ptr = 0
|
||||
stdio.printf("StackObj: data=%d, next_ptr=%p\n", flags.data, flags.next_ptr)
|
||||
|
||||
|
||||
def TestIntArray():
|
||||
stdio.printf("=== Test Int Array ===\n")
|
||||
arr: t.CArray[t.CInt, 5] = t.CArray[t.CInt, 5]()
|
||||
i: t.CInt = 0
|
||||
while i < 5:
|
||||
arr[i] = i * 10
|
||||
i += 1
|
||||
i = 0
|
||||
while i < 5:
|
||||
stdio.printf("arr[%d]=%d\n", i, arr[i])
|
||||
i += 1
|
||||
|
||||
|
||||
def TestFloatArray():
|
||||
stdio.printf("=== Test Float Array ===\n")
|
||||
farr: t.CArray[t.CFloat, 4] = t.CArray[t.CFloat, 4]()
|
||||
farr[0] = 1.5
|
||||
farr[1] = 2.5
|
||||
farr[2] = 3.5
|
||||
farr[3] = 4.5
|
||||
i: t.CInt = 0
|
||||
while i < 4:
|
||||
stdio.printf("farr[%d]=%.1f\n", i, farr[i])
|
||||
i += 1
|
||||
|
||||
|
||||
def TestCharArray():
|
||||
stdio.printf("=== Test Char Array (String) ===\n")
|
||||
str_arr: t.CArray[t.CChar, 32] = t.CArray[t.CChar, 32]()
|
||||
str_arr[0] = 'H'
|
||||
str_arr[1] = 'e'
|
||||
str_arr[2] = 'l'
|
||||
str_arr[3] = 'l'
|
||||
str_arr[4] = 'o'
|
||||
str_arr[5] = '\0'
|
||||
stdio.printf("String: %s\n", str_arr)
|
||||
|
||||
|
||||
def TestNestedArray():
|
||||
stdio.printf("=== Test Nested Array (Array of Arrays) ===\n")
|
||||
row0: t.CArray[t.CInt, 3] = t.CArray[t.CInt, 3]()
|
||||
row1: t.CArray[t.CInt, 3] = t.CArray[t.CInt, 3]()
|
||||
row0[0] = 0
|
||||
row0[1] = 1
|
||||
row0[2] = 2
|
||||
row1[0] = 10
|
||||
row1[1] = 11
|
||||
row1[2] = 12
|
||||
i: t.CInt = 0
|
||||
while i < 3:
|
||||
stdio.printf("row0[%d]=%d ", i, row0[i])
|
||||
i += 1
|
||||
stdio.printf("\n")
|
||||
i = 0
|
||||
while i < 3:
|
||||
stdio.printf("row1[%d]=%d ", i, row1[i])
|
||||
i += 1
|
||||
stdio.printf("\n")
|
||||
|
||||
|
||||
def TestArrayWithStruct():
|
||||
stdio.printf("=== Test Array with Struct ===\n")
|
||||
points: t.CArray[SimpleData, 3] = t.CArray[SimpleData, 3]()
|
||||
i: t.CInt = 0
|
||||
while i < 3:
|
||||
points[i].x = i * 10
|
||||
points[i].y = i * 100
|
||||
i += 1
|
||||
i = 0
|
||||
while i < 3:
|
||||
stdio.printf("Point[%d]: x=%d, y=%d\n", i, points[i].x, points[i].y)
|
||||
i += 1
|
||||
|
||||
|
||||
def TestArrayPointer():
|
||||
stdio.printf("=== Test Array Pointer ===\n")
|
||||
data: t.CArray[t.CInt, 8] = t.CArray[t.CInt, 8]()
|
||||
data[0] = 100
|
||||
data[1] = 200
|
||||
data[2] = 300
|
||||
ptr: t.CInt | t.CPtr = data
|
||||
stdio.printf("ptr[0]=%d\n", ptr[0])
|
||||
stdio.printf("ptr[1]=%d\n", ptr[1])
|
||||
stdio.printf("ptr[2]=%d\n", ptr[2])
|
||||
|
||||
|
||||
def TestDynamicString():
|
||||
stdio.printf("=== Test Dynamic String ===\n")
|
||||
name: str = "TransPyC"
|
||||
stdio.printf("Hello %s!\n", name)
|
||||
@@ -1,24 +0,0 @@
|
||||
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
|
||||
@@ -1,372 +0,0 @@
|
||||
import config
|
||||
import t, c
|
||||
|
||||
|
||||
def ForRangeBasicTest(stop: t.CInt):
|
||||
i: t.CInt = 0
|
||||
for i in range(stop):
|
||||
print("For range: ", i)
|
||||
print("Done")
|
||||
|
||||
|
||||
def ForRangeWithStartStop(start: t.CInt, stop: t.CInt, step: t.CInt):
|
||||
i: t.CInt = 0
|
||||
for i in range(start, stop, step):
|
||||
print("Range: ", i)
|
||||
print("Done")
|
||||
|
||||
|
||||
def NestedForRangeTest(rows: t.CInt, cols: t.CInt):
|
||||
r: t.CInt = 0
|
||||
c_val: t.CInt = 0
|
||||
for r in range(rows):
|
||||
for c_val in range(cols):
|
||||
print("Cell: ", r, c_val)
|
||||
print("Grid done")
|
||||
|
||||
|
||||
def ForWithIfBreakTest(data_size: t.CInt):
|
||||
i: t.CInt = 0
|
||||
found: t.CInt = 0
|
||||
for i in range(data_size):
|
||||
if i == 5:
|
||||
print("Found at: ", i)
|
||||
found = 1
|
||||
break
|
||||
print("Checking: ", i)
|
||||
if found == 0:
|
||||
print("Not found")
|
||||
|
||||
|
||||
def ForWithIfContinueTest(n: t.CInt):
|
||||
i: t.CInt = 0
|
||||
count: t.CInt = 0
|
||||
for i in range(n):
|
||||
if i % 2 == 0:
|
||||
continue
|
||||
print("Odd: ", i)
|
||||
count += 1
|
||||
print("Total odd: ", count)
|
||||
|
||||
|
||||
def ForWithElifBranchTest(value: t.CInt):
|
||||
i: t.CInt = 0
|
||||
result: t.CInt = 0
|
||||
for i in range(value):
|
||||
if i < 3:
|
||||
result += 1
|
||||
elif i < 6:
|
||||
result += 2
|
||||
elif i < 9:
|
||||
result += 3
|
||||
else:
|
||||
result += 4
|
||||
print("Elif branch result: ", result)
|
||||
|
||||
|
||||
def WhileWithIfElifElseTest(iterations: t.CInt):
|
||||
counter: t.CInt = 0
|
||||
while counter < iterations:
|
||||
if counter < 2:
|
||||
print("Phase 1: ", counter)
|
||||
elif counter < 4:
|
||||
print("Phase 2: ", counter)
|
||||
elif counter < 6:
|
||||
print("Phase 3: ", counter)
|
||||
else:
|
||||
print("Phase 4: ", counter)
|
||||
counter += 1
|
||||
print("While done")
|
||||
|
||||
|
||||
def WhileWithNestedIfTest(limit: t.CInt):
|
||||
outer: t.CInt = 0
|
||||
while outer < limit:
|
||||
inner: t.CInt = 0
|
||||
while inner < limit:
|
||||
if inner == 2 and outer == 1:
|
||||
print("Target: ", outer, inner)
|
||||
inner += 1
|
||||
continue
|
||||
if inner > 3:
|
||||
break
|
||||
print("Inner: ", inner)
|
||||
inner += 1
|
||||
outer += 1
|
||||
|
||||
|
||||
def WhileWithMatchCaseTest(value: t.CInt):
|
||||
result: t.CInt = 0
|
||||
match value:
|
||||
case 1:
|
||||
result = 100
|
||||
print("Case 1")
|
||||
case 2:
|
||||
result = 200
|
||||
print("Case 2")
|
||||
case 3:
|
||||
result = 300
|
||||
print("Case 3")
|
||||
case _:
|
||||
result = 999
|
||||
print("Default case")
|
||||
print("Match result: ", result)
|
||||
|
||||
|
||||
def WhileWithMatchCaseNoBreakTest(value: t.CInt):
|
||||
result: t.CInt = 0
|
||||
match value:
|
||||
case 1:
|
||||
result = 10
|
||||
print("Case 1: ", result)
|
||||
case 2:
|
||||
result = 20
|
||||
print("Case 2: ", result)
|
||||
result += 5
|
||||
case 3:
|
||||
result = 30
|
||||
print("Case 3: ", result)
|
||||
case _:
|
||||
result = 0
|
||||
print("No break match result: ", result)
|
||||
|
||||
|
||||
def ComplexForWhileMatchTest(outer_limit: t.CInt, inner_limit: t.CInt):
|
||||
i: t.CInt = 0
|
||||
j: t.CInt = 0
|
||||
result: t.CInt = 0
|
||||
for i in range(outer_limit):
|
||||
j = 0
|
||||
while j < inner_limit:
|
||||
match (i, j):
|
||||
case (0, 0):
|
||||
result += 1
|
||||
case (1, 1):
|
||||
result += 10
|
||||
case (2, _):
|
||||
result += 100
|
||||
case (_, 0):
|
||||
result += 1000
|
||||
case _:
|
||||
result += 10000
|
||||
j += 1
|
||||
print("Complex match result: ", result)
|
||||
|
||||
|
||||
def ForWithCaseAndNoBreakTest(n: t.CInt):
|
||||
i: t.CInt = 0
|
||||
result: t.CInt = 0
|
||||
for i in range(n):
|
||||
match i:
|
||||
case 0:
|
||||
result += 1
|
||||
case 1:
|
||||
result += 2
|
||||
case 2:
|
||||
result += 3
|
||||
result += 10
|
||||
case _:
|
||||
result += i
|
||||
c.NoBreak
|
||||
print("NoBreak result: ", result)
|
||||
|
||||
|
||||
def WhileWithBreakConditionTest(limit: t.CInt):
|
||||
i: t.CInt = 0
|
||||
early_exit: t.CInt = 0
|
||||
while i < limit:
|
||||
if i == 3:
|
||||
early_exit = 1
|
||||
break
|
||||
if i == 2:
|
||||
i += 1
|
||||
continue
|
||||
print("While i: ", i)
|
||||
i += 1
|
||||
|
||||
|
||||
def NestedWhileWithMultipleBreakPoints(depth: t.CInt, width: t.CInt):
|
||||
d: t.CInt = 0
|
||||
w: t.CInt = 0
|
||||
count: t.CInt = 0
|
||||
while d < depth:
|
||||
w = 0
|
||||
while w < width:
|
||||
if w == 2:
|
||||
break
|
||||
if d == 1 and w == 1:
|
||||
c.Break
|
||||
count += 1
|
||||
w += 1
|
||||
d += 1
|
||||
print("Nested break count: ", count)
|
||||
|
||||
|
||||
def ForWithMatchCaseInLoopTest(iterations: t.CInt):
|
||||
i: t.CInt = 0
|
||||
sum_even: t.CInt = 0
|
||||
sum_odd: t.CInt = 0
|
||||
for i in range(iterations):
|
||||
match i % 3:
|
||||
case 0:
|
||||
sum_even += i
|
||||
case 1:
|
||||
sum_odd += i
|
||||
case 2:
|
||||
sum_even += i * 2
|
||||
case _:
|
||||
pass
|
||||
print("Sum even: ", sum_even)
|
||||
print("Sum odd: ", sum_odd)
|
||||
|
||||
|
||||
def ComplexLogicWithElifChains(a: t.CInt, b: t.CInt, c_val: t.CInt):
|
||||
i: t.CInt = 0
|
||||
result: t.CInt = 0
|
||||
while i < 10:
|
||||
if i < a:
|
||||
if i < b:
|
||||
result += 1
|
||||
elif i < c_val:
|
||||
result += 2
|
||||
else:
|
||||
result += 3
|
||||
elif i < b:
|
||||
if i < c_val:
|
||||
result += 4
|
||||
else:
|
||||
result += 5
|
||||
elif i < c_val:
|
||||
result += 6
|
||||
else:
|
||||
result += 7
|
||||
i += 1
|
||||
print("Complex elif chain result: ", result)
|
||||
|
||||
|
||||
def ForRangeWithStepAndCondition(n: t.CInt, step: t.CInt):
|
||||
i: t.CInt = 0
|
||||
count: t.CInt = 0
|
||||
for i in range(0, n, step):
|
||||
if i % 2 == 0:
|
||||
print("Even step: ", i)
|
||||
count += 1
|
||||
else:
|
||||
if i > 5:
|
||||
print("Large odd: ", i)
|
||||
else:
|
||||
print("Small odd: ", i)
|
||||
print("Total steps: ", count)
|
||||
|
||||
|
||||
def MatchCaseWithGuardConditions(value: t.CInt):
|
||||
result: t.CInt = 0
|
||||
match value:
|
||||
case 1 if config.TRUE == 1:
|
||||
result = 100
|
||||
case 2 if config.FALSE == 0:
|
||||
result = 200
|
||||
case 3:
|
||||
result = 300
|
||||
case _:
|
||||
result = 0
|
||||
print("Guard match result: ", result)
|
||||
|
||||
|
||||
def WhileWithMultipleMatchCases(iterations: t.CInt):
|
||||
i: t.CInt = 0
|
||||
state: t.CInt = 0
|
||||
while i < iterations:
|
||||
match state:
|
||||
case 0:
|
||||
if i > 3:
|
||||
state = 1
|
||||
case 1:
|
||||
if i > 6:
|
||||
state = 2
|
||||
case 2:
|
||||
if i > 9:
|
||||
state = 0
|
||||
print("State at i=", i, ": ", state)
|
||||
i += 1
|
||||
|
||||
|
||||
def ForWhileMixWithBreakAndContinue(n: t.CInt):
|
||||
i: t.CInt = 0
|
||||
j: t.CInt = 0
|
||||
count: t.CInt = 0
|
||||
for i in range(n):
|
||||
j = 0
|
||||
while j < n:
|
||||
if j == 2:
|
||||
j += 1
|
||||
continue
|
||||
if i == 3 and j == 3:
|
||||
break
|
||||
count += 1
|
||||
j += 1
|
||||
print("Mix break continue count: ", count)
|
||||
|
||||
|
||||
def ComplexCaseMatchingWithRanges(start: t.CInt, end: t.CInt):
|
||||
i: t.CInt = 0
|
||||
bucket0: t.CInt = 0
|
||||
bucket1: t.CInt = 0
|
||||
bucket2: t.CInt = 0
|
||||
bucket3: t.CInt = 0
|
||||
for i in range(start, end):
|
||||
match i:
|
||||
case _ if i < 10:
|
||||
bucket0 += 1
|
||||
case _ if i < 20:
|
||||
bucket1 += 1
|
||||
case _ if i < 30:
|
||||
bucket2 += 1
|
||||
case _:
|
||||
bucket3 += 1
|
||||
print("Bucket0 (<10): ", bucket0)
|
||||
print("Bucket1 (10-19): ", bucket1)
|
||||
print("Bucket2 (20-29): ", bucket2)
|
||||
print("Bucket3 (>=30): ", bucket3)
|
||||
|
||||
|
||||
def WhileWithElifInElifChain(limit: t.CInt):
|
||||
i: t.CInt = 0
|
||||
result: t.CInt = 0
|
||||
while i < limit:
|
||||
if i < 2:
|
||||
if i == 0:
|
||||
result = 1
|
||||
else:
|
||||
result = 2
|
||||
elif i < 4:
|
||||
if i == 2:
|
||||
result = 3
|
||||
else:
|
||||
result = 4
|
||||
elif i < 6:
|
||||
if i == 4:
|
||||
result = 5
|
||||
else:
|
||||
result = 6
|
||||
else:
|
||||
result = 7
|
||||
print("Chain result[", i, "]: ", result)
|
||||
i += 1
|
||||
|
||||
|
||||
def ForWithCaseNoBreakNested(inner_limit: t.CInt):
|
||||
i: t.CInt = 0
|
||||
j: t.CInt = 0
|
||||
result: t.CInt = 0
|
||||
for i in range(3):
|
||||
for j in range(inner_limit):
|
||||
match j:
|
||||
case 0:
|
||||
result += 1
|
||||
case 1:
|
||||
result += 2
|
||||
case _:
|
||||
result += 3
|
||||
c.NoBreak
|
||||
print("Nested NoBreak result: ", result)
|
||||
@@ -1,298 +0,0 @@
|
||||
import config
|
||||
import t, c
|
||||
|
||||
|
||||
def AboutSizeTWhileTest(length: t.CSizeT):
|
||||
pos: t.CSizeT = 0
|
||||
while pos < length:
|
||||
print("Pos: ", pos)
|
||||
if pos > config.POSMAX: break
|
||||
pos += 1
|
||||
while pos < length:
|
||||
if pos > config.POSMAX:
|
||||
print("Pos: ", pos)
|
||||
pos += 1
|
||||
else:
|
||||
print("Pos: ", pos)
|
||||
pos += 1
|
||||
if pos > config.POSMAX: break
|
||||
else:
|
||||
pos += 1
|
||||
print("Pos: ", pos)
|
||||
while pos < length:
|
||||
print("Pos: ", pos)
|
||||
pos += 1
|
||||
|
||||
|
||||
def MathBasicTest(x: t.CInt, y: t.CInt) -> t.CInt:
|
||||
result: t.CInt = 0
|
||||
result = x + y
|
||||
print("Add: ", result)
|
||||
result = x - y
|
||||
print("Sub: ", result)
|
||||
result = x * y
|
||||
print("Mul: ", result)
|
||||
if y != 0:
|
||||
result = x / y
|
||||
print("Div: ", result)
|
||||
result = x % y if y != 0 else 0
|
||||
print("Mod: ", result)
|
||||
return result
|
||||
|
||||
|
||||
def MathAdvancedTest(value: t.CInt) -> t.CInt:
|
||||
counter: t.CInt = 0
|
||||
scaled: t.CInt = 0
|
||||
offset: t.CInt = 0
|
||||
scaled = value * config.MATH_SCALE
|
||||
print("Scaled: ", scaled)
|
||||
offset = scaled + config.MATH_OFFSET
|
||||
print("Offset: ", offset)
|
||||
threshold: t.CInt = config.THRESHOLD
|
||||
if offset > threshold:
|
||||
print("Above threshold")
|
||||
counter = 1
|
||||
elif offset == threshold:
|
||||
print("At threshold")
|
||||
counter = 0
|
||||
else:
|
||||
print("Below threshold")
|
||||
counter = -1
|
||||
return counter
|
||||
|
||||
|
||||
def WhileWithElifElseTest(start: t.CInt, end: t.CInt):
|
||||
idx: t.CInt = start
|
||||
while idx < end:
|
||||
if idx < 0:
|
||||
print("Negative: ", idx)
|
||||
elif idx == 0:
|
||||
print("Zero: ", idx)
|
||||
elif idx > 0 and idx < 5:
|
||||
print("Small positive: ", idx)
|
||||
elif idx >= 5 and idx < 10:
|
||||
print("Medium positive: ", idx)
|
||||
else:
|
||||
print("Large: ", idx)
|
||||
idx += 1
|
||||
|
||||
|
||||
def NestedWhileWithMacrosTest(outer_limit: t.CInt, inner_limit: t.CInt):
|
||||
outer: t.CInt = 0
|
||||
inner: t.CInt = 0
|
||||
total_ops: t.CInt = 0
|
||||
while outer < outer_limit:
|
||||
inner = 0
|
||||
while inner < inner_limit:
|
||||
if inner == config.TRUE:
|
||||
print("Inner loop break condition at: ", inner)
|
||||
total_ops += 1
|
||||
inner += 1
|
||||
outer += 1
|
||||
print("Total operations: ", total_ops)
|
||||
|
||||
|
||||
def ComplexConditionTest(a: t.CInt, b: t.CInt, c_val: t.CInt):
|
||||
x: t.CInt = a
|
||||
y: t.CInt = b
|
||||
z: t.CInt = c_val
|
||||
while x < config.LOOP_LIMIT:
|
||||
if x > 0 and y > 0 and z > 0:
|
||||
print("All positive: ", x, y, z)
|
||||
elif x <= 0 and y <= 0 and z <= 0:
|
||||
print("All non-positive: ", x, y, z)
|
||||
else:
|
||||
if x > 0:
|
||||
print("X positive")
|
||||
elif y > 0:
|
||||
print("Y positive")
|
||||
else:
|
||||
print("Z positive")
|
||||
x += 1
|
||||
y += 1
|
||||
z += 1
|
||||
|
||||
|
||||
def RetryLoopTest(retry_count: t.CInt) -> t.CInt:
|
||||
attempt: t.CInt = 0
|
||||
success: t.CInt = 0
|
||||
while attempt < retry_count:
|
||||
if attempt < config.MAX_RETRY:
|
||||
print("Attempt: ", attempt, " less than max")
|
||||
success = attempt * 2
|
||||
elif attempt == config.MAX_RETRY:
|
||||
print("At max retry")
|
||||
success = -1
|
||||
else:
|
||||
print("Beyond max retry")
|
||||
success = -2
|
||||
attempt += 1
|
||||
return success
|
||||
|
||||
|
||||
def BitwiseOperationsTest(value: t.CInt) -> t.CInt:
|
||||
shifted: t.CInt = 0
|
||||
masked: t.CInt = 0
|
||||
xored: t.CInt = 0
|
||||
anded: t.CInt = 0
|
||||
ored: t.CInt = 0
|
||||
shifted = value << config.SHIFT_AMOUNT
|
||||
print("Left shift: ", shifted)
|
||||
shifted = value >> config.SHIFT_AMOUNT
|
||||
print("Right shift: ", shifted)
|
||||
masked = value & config.MASK_VALUE
|
||||
print("Bitwise AND mask: ", masked)
|
||||
xored = value ^ config.MASK_VALUE
|
||||
print("Bitwise XOR: ", xored)
|
||||
anded = value & (config.MASK_VALUE >> config.SHIFT_AMOUNT)
|
||||
print("Bitwise AND shifted mask: ", anded)
|
||||
ored = value | config.SHIFT_AMOUNT
|
||||
print("Bitwise OR shift: ", ored)
|
||||
return masked
|
||||
|
||||
|
||||
def CompoundAssignmentMathTest(a: t.CInt, b: t.CInt) -> t.CInt:
|
||||
x: t.CInt = a
|
||||
y: t.CInt = b
|
||||
result: t.CInt = 0
|
||||
x += y
|
||||
print("x += y: ", x)
|
||||
x -= y
|
||||
print("x -= y: ", x)
|
||||
x *= y
|
||||
print("x *= y: ", x)
|
||||
x = a
|
||||
y = b
|
||||
if b != 0:
|
||||
x /= b
|
||||
print("x /= y: ", x)
|
||||
x = a
|
||||
if b != 0:
|
||||
x %= b
|
||||
print("x %%= y: ", x)
|
||||
x = a
|
||||
x <<= config.SHIFT_AMOUNT
|
||||
print("x <<= shift: ", x)
|
||||
x >>= config.SHIFT_AMOUNT
|
||||
print("x >>= shift: ", x)
|
||||
x &= config.MASK_VALUE
|
||||
print("x &= mask: ", x)
|
||||
x |= config.SHIFT_AMOUNT
|
||||
print("x |= shift: ", x)
|
||||
result = (a + b) * config.MATH_SCALE - config.MATH_OFFSET
|
||||
print("Compound: (a+b)*scale-offset: ", result)
|
||||
result = (a * b) + (config.MATH_OFFSET / 2)
|
||||
print("Compound: a*b+offset/2: ", result)
|
||||
return result
|
||||
|
||||
|
||||
def PowerAndModuloTest(base: t.CInt, exponent: t.CInt) -> t.CInt:
|
||||
result: t.CInt = 1
|
||||
temp: t.CInt = 0
|
||||
i: t.CInt = 0
|
||||
while i < exponent:
|
||||
result *= base
|
||||
i += 1
|
||||
print("Power: ", result)
|
||||
temp = result % config.MODULO_DIVISOR
|
||||
print("Power mod: ", temp)
|
||||
temp = (base * config.EXPONENT_BASE) % config.MODULO_DIVISOR
|
||||
print("base*exp %% divisor: ", temp)
|
||||
temp = ((base + config.MATH_OFFSET) * config.MATH_SCALE) % config.MODULO_DIVISOR
|
||||
print("(base+offset)*scale %% divisor: ", temp)
|
||||
return result
|
||||
|
||||
|
||||
def MixedArithmeticTest(x: t.CInt, y: t.CInt, z: t.CInt) -> t.CInt:
|
||||
result: t.CInt = 0
|
||||
result = (x + y) * z
|
||||
print("(x+y)*z: ", result)
|
||||
result = x + (y * z)
|
||||
print("x+(y*z): ", result)
|
||||
result = ((x + y) * config.MATH_SCALE) - config.MATH_OFFSET
|
||||
print("((x+y)*scale)-offset: ", result)
|
||||
result = (x * config.MATH_SCALE) + (y * config.MATH_SCALE)
|
||||
print("x*scale + y*scale: ", result)
|
||||
result = ((x % config.MODULO_DIVISOR) + (y % config.MODULO_DIVISOR)) * config.MATH_SCALE
|
||||
print("(x%%mod + y%%mod)*scale: ", result)
|
||||
temp: t.CInt = 0
|
||||
temp = x | y & z
|
||||
print("x | y & z: ", temp)
|
||||
temp = (x | y) & z
|
||||
print("(x | y) & z: ", temp)
|
||||
temp = x ^ y ^ z
|
||||
print("x ^ y ^ z: ", temp)
|
||||
return result
|
||||
|
||||
|
||||
def MathWithWhileLoopTest(start: t.CInt, count: t.CInt) -> t.CInt:
|
||||
idx: t.CInt = 0
|
||||
accumulator: t.CInt = 0
|
||||
multiplier: t.CInt = config.MATH_SCALE
|
||||
while idx < count:
|
||||
temp: t.CInt = (start + idx) * multiplier
|
||||
temp = temp + config.MATH_OFFSET
|
||||
if temp > config.THRESHOLD:
|
||||
temp = config.THRESHOLD
|
||||
accumulator += temp
|
||||
multiplier += 1
|
||||
idx += 1
|
||||
print("Accumulator: ", accumulator)
|
||||
return accumulator
|
||||
|
||||
|
||||
def ComplexNestedMathTest(a: t.CInt, b: t.CInt) -> t.CInt:
|
||||
layer1: t.CInt = 0
|
||||
layer2: t.CInt = 0
|
||||
layer3: t.CInt = 0
|
||||
i: t.CInt = 0
|
||||
layer1 = (a + b) * config.MATH_SCALE
|
||||
print("Layer1: ", layer1)
|
||||
while i < config.BIT_RANGE:
|
||||
layer2 += layer1 >> 1
|
||||
i += 1
|
||||
print("Layer2: ", layer2)
|
||||
layer3 = layer1 + layer2 - config.MATH_OFFSET
|
||||
print("Layer3: ", layer3)
|
||||
layer3 = layer3 * config.MATH_SCALE / 2 if config.MATH_SCALE != 0 else layer3
|
||||
print("Layer3 scaled: ", layer3)
|
||||
return layer3
|
||||
|
||||
|
||||
def ConditionalMathChainTest(value: t.CInt) -> t.CInt:
|
||||
result: t.CInt = 0
|
||||
step: t.CInt = 0
|
||||
while step < config.LOOP_LIMIT:
|
||||
if step < 5:
|
||||
result += step * config.MATH_SCALE
|
||||
print("step<5: ", result)
|
||||
elif step < 10:
|
||||
result -= step - config.MATH_OFFSET
|
||||
print("step<10: ", result)
|
||||
elif step < 15:
|
||||
result += (step * config.MATH_OFFSET) / config.MATH_SCALE
|
||||
print("step<15: ", result)
|
||||
else:
|
||||
result = result * config.EXPONENT_BASE % config.MODULO_DIVISOR
|
||||
print("step>=15: ", result)
|
||||
step += 1
|
||||
return result
|
||||
|
||||
|
||||
def BitManipulationMathTest(value: t.CInt) -> t.CInt:
|
||||
original: t.CInt = value
|
||||
nibble: t.CInt = 0
|
||||
result: t.CInt = 0
|
||||
result = (value << config.SHIFT_AMOUNT) | (value >> (8 - config.SHIFT_AMOUNT))
|
||||
print("Rotate left: ", result)
|
||||
result = (value >> config.SHIFT_AMOUNT) | (value << (8 - config.SHIFT_AMOUNT))
|
||||
print("Rotate right: ", result)
|
||||
nibble = value & 0xF
|
||||
print("Lower nibble: ", nibble)
|
||||
nibble = (value >> config.BIT_RANGE) & 0xF
|
||||
print("Upper nibble: ", nibble)
|
||||
result = ((value & config.MASK_VALUE) + config.MATH_OFFSET) * config.MATH_SCALE
|
||||
print("Masked and scaled: ", result)
|
||||
result = ((original << config.SHIFT_AMOUNT) ^ original) & config.MASK_VALUE
|
||||
print("XOR shifted: ", result)
|
||||
return result
|
||||
@@ -1 +0,0 @@
|
||||
{"memhub": "04e5fe47ff2af528", "stdio": "285b6aa29a34754d", "test_numpy": "3cd87018ba1e76bc", "vipermath": "3f7c5e78d8652535", "stdlib": "6c658cc728d0bbf4", "testcheck": "748d0424e8976fa0", "zc.test": "75583f20a922ab2e", "test": "75583f20a922ab2e", "config": "cfc83b830141b00e", "string": "928c0ff6d8c69ec9", "atom": "aa246c6e6aa30484", "w32.win32console": "bbdf3bbd4c3bc28c", "win32console": "bbdf3bbd4c3bc28c", "numpy.__init__": "c3a6aed1f1fb8b1e", "__init__": "c3a6aed1f1fb8b1e", "numpy": "c3a6aed1f1fb8b1e", "viperio": "c9f4be41ca1cc2b4", "zc.config": "cfc83b830141b00e", "zc.class_test": "e5fb16127bce8f68", "class_test": "e5fb16127bce8f68", "stdint": "f5522571bcce7bcb", "zc.logic_test": "faec3233d98371da", "logic_test": "faec3233d98371da", "w32.win32base": "fc980acec33d69a7", "win32base": "fc980acec33d69a7"}
|
||||
@@ -1 +0,0 @@
|
||||
{"memhub": "04e5fe47ff2af528", "stdio": "285b6aa29a34754d", "test_numpy": "3cd87018ba1e76bc", "vipermath": "3f7c5e78d8652535", "main": "49cae05490a513cb", "stdlib": "6c658cc728d0bbf4", "testcheck": "748d0424e8976fa0", "config": "cfc83b830141b00e", "string": "928c0ff6d8c69ec9", "atom": "aa246c6e6aa30484", "w32.win32console": "bbdf3bbd4c3bc28c", "win32console": "bbdf3bbd4c3bc28c", "numpy.__init__": "c3a6aed1f1fb8b1e", "__init__": "c3a6aed1f1fb8b1e", "numpy": "c3a6aed1f1fb8b1e", "viperio": "c9f4be41ca1cc2b4", "zc.config": "cfc83b830141b00e", "zc.class_test": "e5fb16127bce8f68", "class_test": "e5fb16127bce8f68", "stdint": "f5522571bcce7bcb", "zc.logic_test": "faec3233d98371da", "logic_test": "faec3233d98371da", "w32.win32base": "fc980acec33d69a7", "win32base": "fc980acec33d69a7"}
|
||||
@@ -1 +0,0 @@
|
||||
{"memhub": "04e5fe47ff2af528", "stdio": "285b6aa29a34754d", "test_numpy": "3cd87018ba1e76bc", "vipermath": "3f7c5e78d8652535", "main": "49cae05490a513cb", "stdlib": "6c658cc728d0bbf4", "testcheck": "748d0424e8976fa0", "zc.test": "75583f20a922ab2e", "test": "75583f20a922ab2e", "string": "928c0ff6d8c69ec9", "atom": "aa246c6e6aa30484", "w32.win32console": "bbdf3bbd4c3bc28c", "win32console": "bbdf3bbd4c3bc28c", "numpy.__init__": "c3a6aed1f1fb8b1e", "__init__": "c3a6aed1f1fb8b1e", "numpy": "c3a6aed1f1fb8b1e", "viperio": "c9f4be41ca1cc2b4", "zc.config": "cfc83b830141b00e", "config": "cfc83b830141b00e", "zc.class_test": "e5fb16127bce8f68", "class_test": "e5fb16127bce8f68", "stdint": "f5522571bcce7bcb", "zc.logic_test": "faec3233d98371da", "logic_test": "faec3233d98371da", "w32.win32base": "fc980acec33d69a7", "win32base": "fc980acec33d69a7"}
|
||||
@@ -1 +0,0 @@
|
||||
{"memhub": "04e5fe47ff2af528", "stdio": "285b6aa29a34754d", "test_numpy": "3cd87018ba1e76bc", "vipermath": "3f7c5e78d8652535", "main": "49cae05490a513cb", "stdlib": "6c658cc728d0bbf4", "testcheck": "748d0424e8976fa0", "zc.test": "75583f20a922ab2e", "test": "75583f20a922ab2e", "config": "8e0d8fdba991b3b4", "string": "928c0ff6d8c69ec9", "atom": "aa246c6e6aa30484", "w32.win32console": "bbdf3bbd4c3bc28c", "win32console": "bbdf3bbd4c3bc28c", "numpy.__init__": "c3a6aed1f1fb8b1e", "__init__": "c3a6aed1f1fb8b1e", "numpy": "c3a6aed1f1fb8b1e", "viperio": "c9f4be41ca1cc2b4", "zc.class_test": "e5fb16127bce8f68", "class_test": "e5fb16127bce8f68", "stdint": "f5522571bcce7bcb", "zc.logic_test": "faec3233d98371da", "logic_test": "faec3233d98371da", "w32.win32base": "fc980acec33d69a7", "win32base": "fc980acec33d69a7"}
|
||||
@@ -1 +0,0 @@
|
||||
{"memhub": "04e5fe47ff2af528", "stdio": "285b6aa29a34754d", "test_numpy": "3cd87018ba1e76bc", "vipermath": "3f7c5e78d8652535", "main": "49cae05490a513cb", "stdlib": "6c658cc728d0bbf4", "testcheck": "748d0424e8976fa0", "zc.test": "75583f20a922ab2e", "test": "75583f20a922ab2e", "config": "cfc83b830141b00e", "string": "928c0ff6d8c69ec9", "atom": "aa246c6e6aa30484", "w32.win32console": "bbdf3bbd4c3bc28c", "win32console": "bbdf3bbd4c3bc28c", "numpy.__init__": "c3a6aed1f1fb8b1e", "__init__": "c3a6aed1f1fb8b1e", "numpy": "c3a6aed1f1fb8b1e", "viperio": "c9f4be41ca1cc2b4", "zc.config": "cfc83b830141b00e", "stdint": "f5522571bcce7bcb", "zc.logic_test": "faec3233d98371da", "logic_test": "faec3233d98371da", "w32.win32base": "fc980acec33d69a7", "win32base": "fc980acec33d69a7"}
|
||||
@@ -1 +0,0 @@
|
||||
{"memhub": "04e5fe47ff2af528", "stdio": "285b6aa29a34754d", "test_numpy": "3cd87018ba1e76bc", "vipermath": "3f7c5e78d8652535", "main": "49cae05490a513cb", "stdlib": "6c658cc728d0bbf4", "testcheck": "748d0424e8976fa0", "zc.test": "75583f20a922ab2e", "test": "75583f20a922ab2e", "config": "cfc83b830141b00e", "string": "928c0ff6d8c69ec9", "atom": "aa246c6e6aa30484", "w32.win32console": "bbdf3bbd4c3bc28c", "win32console": "bbdf3bbd4c3bc28c", "numpy.__init__": "c3a6aed1f1fb8b1e", "__init__": "c3a6aed1f1fb8b1e", "numpy": "c3a6aed1f1fb8b1e", "viperio": "c9f4be41ca1cc2b4", "zc.config": "cfc83b830141b00e", "zc.class_test": "e5fb16127bce8f68", "class_test": "e5fb16127bce8f68", "stdint": "f5522571bcce7bcb", "w32.win32base": "fc980acec33d69a7", "win32base": "fc980acec33d69a7"}
|
||||
@@ -1,29 +0,0 @@
|
||||
{
|
||||
"$schema": "https://raw.githubusercontent.com/TermiNexus/TransPyC/main/schemas/project-schema.json",
|
||||
"name": "TestProject",
|
||||
"version": "1.0.0",
|
||||
"source_dir": "./App",
|
||||
"build_dir": "./.tpv_build",
|
||||
"compiler": {
|
||||
"cmd": "llc",
|
||||
"flags": ["-filetype=obj"]
|
||||
},
|
||||
"linker": {
|
||||
"cmd": "clang++",
|
||||
"flags": ["-Wl,--allow-multiple-definition", "-Wl,--unresolved-symbols=ignore-in-object-files", "-lmsvcrt", "-lucrt", "-lpthread", "-lmingwex", "-lkernel32", "-luser32", "-latomic"],
|
||||
"output": "TestProject.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,
|
||||
"sha1_slice_level": 1,
|
||||
"target": "llvm",
|
||||
"strict_mode": true
|
||||
}
|
||||
}
|
||||
Whitespace-only changes.
@@ -1,23 +0,0 @@
|
||||
"""
|
||||
Auto-generated Python stub file from stdio.vp
|
||||
Module: stdio
|
||||
"""
|
||||
|
||||
|
||||
import t, c
|
||||
|
||||
def printf(fmt: t.CConst | str, *args) -> int | t.State: pass
|
||||
|
||||
def fprintf(stream: bytes, fmt: t.CConst | str, *args) -> int | t.State: pass
|
||||
|
||||
def sprintf(buf: bytes, fmt: t.CConst | str, *args) -> int | t.State: pass
|
||||
|
||||
def snprintf(buf: bytes, size: t.CSizeT, fmt: t.CConst | str, *args) -> int | t.State: pass
|
||||
|
||||
def puts(s: t.CConst | str) -> int | t.State: pass
|
||||
|
||||
def fputs(s: t.CConst | str, stream: bytes) -> int | t.State: pass
|
||||
|
||||
def fgets(buf: bytes, size: int, stream: bytes) -> bytes | t.State: pass
|
||||
|
||||
def fflush(stream: bytes) -> int | t.State: pass
|
||||
@@ -1 +0,0 @@
|
||||
{}
|
||||
@@ -1,108 +0,0 @@
|
||||
"""
|
||||
Auto-generated Python stub file from test_numpy.vp
|
||||
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
|
||||
Whitespace-only changes.
@@ -1,128 +0,0 @@
|
||||
"""
|
||||
Auto-generated Python stub file from vipermath.vp
|
||||
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
|
||||
@@ -1 +0,0 @@
|
||||
{}
|
||||
@@ -1,19 +0,0 @@
|
||||
"""
|
||||
Auto-generated Python stub file from main.vp
|
||||
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
|
||||
@@ -1 +0,0 @@
|
||||
f5522571bcce7bcb
|
||||
@@ -1,22 +0,0 @@
|
||||
"""
|
||||
Auto-generated Python stub file from stdlib.vp
|
||||
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
|
||||
|
||||
def exit(status: int) -> t.State: pass
|
||||
@@ -1 +0,0 @@
|
||||
285b6aa29a34754d|bbdf3bbd4c3bc28c|f5522571bcce7bcb|fc980acec33d69a7
|
||||
@@ -1,31 +0,0 @@
|
||||
"""
|
||||
Auto-generated Python stub file from testcheck.vp
|
||||
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
|
||||
@@ -1 +0,0 @@
|
||||
{}
|
||||
@@ -1,38 +0,0 @@
|
||||
"""
|
||||
Auto-generated Python stub file from zc.test.vp
|
||||
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
|
||||
@@ -1 +0,0 @@
|
||||
{}
|
||||
@@ -1,25 +0,0 @@
|
||||
"""
|
||||
Auto-generated Python stub file from config.vp
|
||||
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
|
||||
@@ -1 +0,0 @@
|
||||
{"d:\\Users\\TermiNexus\\Desktop\\TransPyC\\Test\\TestProject\\App\\config.vp": {"sha1": "8e0d8fdba991b3b4", "mtime": 1781111175.0269876, "size": 445}, "d:\\Users\\TermiNexus\\Desktop\\TransPyC\\Test\\TestProject\\App\\main.vp": {"sha1": "49cae05490a513cb", "mtime": 1782949786.0815294, "size": 8223}, "d:\\Users\\TermiNexus\\Desktop\\TransPyC\\Test\\TestProject\\App\\test_numpy.vp": {"sha1": "3cd87018ba1e76bc", "mtime": 1782828269.700148, "size": 40140}, "d:\\Users\\TermiNexus\\Desktop\\TransPyC\\Test\\TestProject\\App\\zc\\class_test.vp": {"sha1": "e5fb16127bce8f68", "mtime": 1782266207.4312654, "size": 6472}, "d:\\Users\\TermiNexus\\Desktop\\TransPyC\\Test\\TestProject\\App\\zc\\config.vp": {"sha1": "cfc83b830141b00e", "mtime": 1778402243.1661563, "size": 531}, "d:\\Users\\TermiNexus\\Desktop\\TransPyC\\Test\\TestProject\\App\\zc\\logic_test.vp": {"sha1": "faec3233d98371da", "mtime": 1778402365.7843194, "size": 8848}, "d:\\Users\\TermiNexus\\Desktop\\TransPyC\\Test\\TestProject\\App\\zc\\test.vp": {"sha1": "75583f20a922ab2e", "mtime": 1778401973.4865518, "size": 8976}, "d:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\atom.vp": {"sha1": "aa246c6e6aa30484", "mtime": 1785389628.701967, "size": 1198}, "d:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\memhub.vp": {"sha1": "04e5fe47ff2af528", "mtime": 1786093335.1900027, "size": 27855}, "d:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\numpy\\__init__.vp": {"sha1": "c3a6aed1f1fb8b1e", "mtime": 1784446436.2910569, "size": 39111}, "d:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\stdint.vp": {"sha1": "f5522571bcce7bcb", "mtime": 1785563642.3805652, "size": 4356}, "d:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\stdio.vp": {"sha1": "285b6aa29a34754d", "mtime": 1785332415.1829746, "size": 561}, "d:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\stdlib.vp": {"sha1": "6c658cc728d0bbf4", "mtime": 1785750602.5446548, "size": 413}, "d:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\string.vp": {"sha1": "928c0ff6d8c69ec9", "mtime": 1786032947.9330952, "size": 11557}, "d:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\testcheck.vp": {"sha1": "748d0424e8976fa0", "mtime": 1785332415.20287, "size": 1919}, "d:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\viperio.vp": {"sha1": "c9f4be41ca1cc2b4", "mtime": 1782812279.506002, "size": 1556}, "d:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\vipermath.vp": {"sha1": "3f7c5e78d8652535", "mtime": 1781532528.2518907, "size": 15412}, "d:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\w32\\win32base.vp": {"sha1": "fc980acec33d69a7", "mtime": 1785332415.2228394, "size": 2653}, "d:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\w32\\win32console.vp": {"sha1": "bbdf3bbd4c3bc28c", "mtime": 1781200703.5338137, "size": 5604}}
|
||||
@@ -1,19 +0,0 @@
|
||||
04e5fe47ff2af528:includes/memhub.vp
|
||||
285b6aa29a34754d:includes/stdio.vp
|
||||
3cd87018ba1e76bc:test_numpy.vp
|
||||
3f7c5e78d8652535:includes/vipermath.vp
|
||||
49cae05490a513cb:main.vp
|
||||
6c658cc728d0bbf4:includes/stdlib.vp
|
||||
748d0424e8976fa0:includes/testcheck.vp
|
||||
75583f20a922ab2e:zc/test.vp
|
||||
8e0d8fdba991b3b4:config.vp
|
||||
928c0ff6d8c69ec9:includes/string.vp
|
||||
aa246c6e6aa30484:includes/atom.vp
|
||||
bbdf3bbd4c3bc28c:includes/w32\win32console.vp
|
||||
c3a6aed1f1fb8b1e:includes/numpy\__init__.vp
|
||||
c9f4be41ca1cc2b4:includes/viperio.vp
|
||||
cfc83b830141b00e:zc/config.vp
|
||||
e5fb16127bce8f68:zc/class_test.vp
|
||||
f5522571bcce7bcb:includes/stdint.vp
|
||||
faec3233d98371da:zc/logic_test.vp
|
||||
fc980acec33d69a7:includes/w32\win32base.vp
|
||||
Binary file not shown.
Whitespace-only changes.
@@ -1,26 +0,0 @@
|
||||
"""
|
||||
Auto-generated Python stub file from atom.vp
|
||||
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
|
||||
@@ -1 +0,0 @@
|
||||
f5522571bcce7bcb|fc980acec33d69a7
|
||||
@@ -1,138 +0,0 @@
|
||||
"""
|
||||
Auto-generated Python stub file from w32.win32console.vp
|
||||
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
|
||||
Whitespace-only changes.
@@ -1,240 +0,0 @@
|
||||
"""
|
||||
Auto-generated Python stub file from numpy.__init__.vp
|
||||
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
|
||||
@@ -1 +0,0 @@
|
||||
f5522571bcce7bcb
|
||||
@@ -1,22 +0,0 @@
|
||||
"""
|
||||
Auto-generated Python stub file from viperio.vp
|
||||
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 = 0, owned: bool = False) -> 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
|
||||
@@ -1 +0,0 @@
|
||||
{}
|
||||
@@ -1,27 +0,0 @@
|
||||
"""
|
||||
Auto-generated Python stub file from zc.config.vp
|
||||
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
|
||||
@@ -1 +0,0 @@
|
||||
{}
|
||||
@@ -1,66 +0,0 @@
|
||||
"""
|
||||
Auto-generated Python stub file from zc.class_test.vp
|
||||
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
|
||||
Whitespace-only changes.
@@ -1,100 +0,0 @@
|
||||
"""
|
||||
Auto-generated Python stub file from stdint.vp
|
||||
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
|
||||
@@ -1 +0,0 @@
|
||||
{}
|
||||
@@ -1,54 +0,0 @@
|
||||
"""
|
||||
Auto-generated Python stub file from zc.logic_test.vp
|
||||
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
|
||||
@@ -1 +0,0 @@
|
||||
f5522571bcce7bcb
|
||||
@@ -1,100 +0,0 @@
|
||||
"""
|
||||
Auto-generated Python stub file from w32.win32base.vp
|
||||
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 = -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
|
||||
@@ -1,13 +0,0 @@
|
||||
"""Auto-generated Python stub file"""
|
||||
|
||||
|
||||
from stdint import *
|
||||
import w32.win32console
|
||||
import config
|
||||
import hashlib
|
||||
import binascii
|
||||
import zlib.pyzlib as zp
|
||||
import t, c
|
||||
import testcheck
|
||||
def main() -> t.CInt | t.CExport: pass
|
||||
|
||||
@@ -1,5 +0,0 @@
|
||||
541a1ed9b8be53c8:main.vp
|
||||
110d7d2c8a47ff77:zc/class_test.vp
|
||||
15b2db4f5d33f57e:zc/config.vp
|
||||
faec3233d98371da:zc/logic_test.vp
|
||||
07b189ae3dcfb270:zc/test.vp
|
||||
@@ -1,35 +0,0 @@
|
||||
from stdint import *
|
||||
import w32.win32console
|
||||
import config
|
||||
import hashlib
|
||||
import binascii
|
||||
import zlib.pyzlib as zp
|
||||
|
||||
import t, c
|
||||
import testcheck
|
||||
|
||||
|
||||
def main() -> t.CInt | t.CExport:
|
||||
w32.win32console.SetConsoleCP(65001)
|
||||
w32.win32console.SetConsoleOutputCP(65001)
|
||||
|
||||
testcheck.begin("TestProject2: 综合库测试")
|
||||
|
||||
testcheck.section("zlib runtime version")
|
||||
print(zp.runtime_version())
|
||||
testcheck.ok("zlib runtime version printed")
|
||||
|
||||
testcheck.section("HASHLIB")
|
||||
md5_buf: t.CArray[t.CUInt8T, hashlib.MD5_DIGEST_LEN]
|
||||
mctx = hashlib.md5()
|
||||
mctx.update("hello")
|
||||
mctx.final(md5_buf)
|
||||
testcheck.ok("HASHLIB md5 completed")
|
||||
|
||||
testcheck.section("BINASCII")
|
||||
binascii.init_binascii()
|
||||
crc_val: t.CUnsignedInt = binascii.crc32("hello", 5, 0)
|
||||
testcheck.ok("BINASCII crc32 completed")
|
||||
|
||||
testcheck.info("END")
|
||||
return testcheck.end()
|
||||
@@ -1,245 +0,0 @@
|
||||
import stdio
|
||||
import stdint
|
||||
import t, c
|
||||
|
||||
|
||||
class SimpleData(t.Object):
|
||||
x: t.CInt
|
||||
y: t.CInt
|
||||
|
||||
|
||||
class Point3D(t.Object):
|
||||
x: t.CFloat
|
||||
y: t.CFloat
|
||||
z: t.CFloat
|
||||
|
||||
|
||||
class Student(t.Object):
|
||||
name: t.CChar | t.CPtr
|
||||
age: t.CInt
|
||||
score: t.CInt
|
||||
|
||||
def __init__(self, n: t.CChar | t.CPtr, a: t.CInt, s: t.CInt):
|
||||
self.name = n
|
||||
self.age = a
|
||||
self.score = s
|
||||
|
||||
def get_age(self) -> t.CInt:
|
||||
return self.age
|
||||
|
||||
def get_score(self) -> t.CInt:
|
||||
return self.score
|
||||
|
||||
|
||||
class Counter(t.Object):
|
||||
value: t.CInt
|
||||
|
||||
def __init__(self, initial: t.CInt):
|
||||
self.value = initial
|
||||
|
||||
def increment(self):
|
||||
self.value += 1
|
||||
|
||||
def get_value(self) -> t.CInt:
|
||||
return self.value
|
||||
|
||||
|
||||
class StackObj(t.Object):
|
||||
data: t.CInt
|
||||
next_ptr: t.CVoid | t.CPtr
|
||||
|
||||
|
||||
def TestBasicDataClass():
|
||||
stdio.printf("=== Test Basic Data Class ===\n")
|
||||
p: SimpleData = SimpleData()
|
||||
p.x = 10
|
||||
p.y = 20
|
||||
stdio.printf("SimpleData: x=%d, y=%d\n", p.x, p.y)
|
||||
|
||||
|
||||
def TestPoint3DClass():
|
||||
stdio.printf("=== Test Point3D Class ===\n")
|
||||
pt: Point3D = Point3D()
|
||||
pt.x = 1.5
|
||||
pt.y = 2.5
|
||||
pt.z = 3.5
|
||||
stdio.printf("Point3D: x=%.1f, y=%.1f, z=%.1f\n", pt.x, pt.y, pt.z)
|
||||
|
||||
|
||||
def TestStudentClass():
|
||||
stdio.printf("=== Test Student Class ===\n")
|
||||
s: Student = Student("Alice", 20, 95)
|
||||
stdio.printf("Student: name=%s, age=%d, score=%d\n", s.name, s.age, s.score)
|
||||
stdio.printf(" get_age()=%d, get_score()=%d\n", s.get_age(), s.get_score())
|
||||
|
||||
|
||||
def TestCounterClass():
|
||||
stdio.printf("=== Test Counter Class ===\n")
|
||||
cnt: Counter = Counter(0)
|
||||
stdio.printf("Initial value: %d\n", cnt.get_value())
|
||||
cnt.increment()
|
||||
cnt.increment()
|
||||
cnt.increment()
|
||||
stdio.printf("After 3 increments: %d\n", cnt.get_value())
|
||||
|
||||
|
||||
def TestStackAllocation():
|
||||
stdio.printf("=== Test Stack Allocation ===\n")
|
||||
obj1: SimpleData = SimpleData()
|
||||
obj1.x = 100
|
||||
obj1.y = 200
|
||||
stdio.printf("Stack obj1: x=%d, y=%d\n", obj1.x, obj1.y)
|
||||
|
||||
obj2: Point3D = Point3D()
|
||||
obj2.x = 10.0
|
||||
obj2.y = 20.0
|
||||
obj2.z = 30.0
|
||||
stdio.printf("Stack obj2: x=%.1f, y=%.1f, z=%.1f\n", obj2.x, obj2.y, obj2.z)
|
||||
|
||||
|
||||
def TestHeapAllocation():
|
||||
stdio.printf("=== Test Heap Allocation ===\n")
|
||||
ptr: t.CVoid | t.CPtr = c.malloc(1024)
|
||||
if ptr != 0:
|
||||
stdio.printf("Allocated 1024 bytes at %p\n", ptr)
|
||||
c.free(ptr)
|
||||
stdio.printf("Freed memory\n")
|
||||
else:
|
||||
stdio.printf("malloc failed\n")
|
||||
|
||||
|
||||
def TestHeapObjectWithInit():
|
||||
stdio.printf("=== Test Heap Object with Init ===\n")
|
||||
mem_size: t.CSizeT = 256
|
||||
ptr: t.CVoid | t.CPtr = c.malloc(mem_size)
|
||||
if ptr != 0:
|
||||
stdio.printf("Allocated %d bytes\n", mem_size)
|
||||
c.free(ptr)
|
||||
else:
|
||||
stdio.printf("malloc failed\n")
|
||||
|
||||
|
||||
def TestMultipleStackObjects():
|
||||
stdio.printf("=== Test Multiple Stack Objects ===\n")
|
||||
objs: SimpleData = SimpleData()
|
||||
objs.x = 1
|
||||
objs.y = 2
|
||||
obj2: Point3D = Point3D()
|
||||
obj2.x = 5.0
|
||||
obj2.y = 10.0
|
||||
obj2.z = 15.0
|
||||
obj3: Counter = Counter(42)
|
||||
stdio.printf("objs: x=%d, y=%d\n", objs.x, objs.y)
|
||||
stdio.printf("obj2: x=%.1f, y=%.1f, z=%.1f\n", obj2.x, obj2.y, obj2.z)
|
||||
stdio.printf("obj3 initial: %d\n", obj3.get_value())
|
||||
obj3.increment()
|
||||
obj3.increment()
|
||||
stdio.printf("obj3 after 2 increments: %d\n", obj3.get_value())
|
||||
|
||||
|
||||
def TestImplicitInitCall():
|
||||
stdio.printf("=== Test Implicit Init Call ===\n")
|
||||
stu1: Student = Student("Bob", 22, 88)
|
||||
stu2: Student = Student("Charlie", 19, 77)
|
||||
stdio.printf("stu1: name=%s, age=%d, score=%d\n", stu1.name, stu1.age, stu1.score)
|
||||
stdio.printf("stu2: name=%s, age=%d, score=%d\n", stu2.name, stu2.age, stu2.score)
|
||||
|
||||
|
||||
def TestClassWithBitFields():
|
||||
stdio.printf("=== Test Class with Bit Fields ===\n")
|
||||
flags: StackObj = StackObj()
|
||||
flags.data = 0
|
||||
flags.next_ptr = 0
|
||||
stdio.printf("StackObj: data=%d, next_ptr=%p\n", flags.data, flags.next_ptr)
|
||||
|
||||
|
||||
def TestIntArray():
|
||||
stdio.printf("=== Test Int Array ===\n")
|
||||
arr: t.CArray[t.CInt, 5] = t.CArray[t.CInt, 5]()
|
||||
i: t.CInt = 0
|
||||
while i < 5:
|
||||
arr[i] = i * 10
|
||||
i += 1
|
||||
i = 0
|
||||
while i < 5:
|
||||
stdio.printf("arr[%d]=%d\n", i, arr[i])
|
||||
i += 1
|
||||
|
||||
|
||||
def TestFloatArray():
|
||||
stdio.printf("=== Test Float Array ===\n")
|
||||
farr: t.CArray[t.CFloat, 4] = t.CArray[t.CFloat, 4]()
|
||||
farr[0] = 1.5
|
||||
farr[1] = 2.5
|
||||
farr[2] = 3.5
|
||||
farr[3] = 4.5
|
||||
i: t.CInt = 0
|
||||
while i < 4:
|
||||
stdio.printf("farr[%d]=%.1f\n", i, farr[i])
|
||||
i += 1
|
||||
|
||||
|
||||
def TestCharArray():
|
||||
stdio.printf("=== Test Char Array (String) ===\n")
|
||||
str_arr: t.CArray[t.CChar, 32] = t.CArray[t.CChar, 32]()
|
||||
str_arr[0] = 'H'
|
||||
str_arr[1] = 'e'
|
||||
str_arr[2] = 'l'
|
||||
str_arr[3] = 'l'
|
||||
str_arr[4] = 'o'
|
||||
str_arr[5] = '\0'
|
||||
stdio.printf("String: %s\n", str_arr)
|
||||
|
||||
|
||||
def TestNestedArray():
|
||||
stdio.printf("=== Test Nested Array (Array of Arrays) ===\n")
|
||||
row0: t.CArray[t.CInt, 3] = t.CArray[t.CInt, 3]()
|
||||
row1: t.CArray[t.CInt, 3] = t.CArray[t.CInt, 3]()
|
||||
row0[0] = 0
|
||||
row0[1] = 1
|
||||
row0[2] = 2
|
||||
row1[0] = 10
|
||||
row1[1] = 11
|
||||
row1[2] = 12
|
||||
i: t.CInt = 0
|
||||
while i < 3:
|
||||
stdio.printf("row0[%d]=%d ", i, row0[i])
|
||||
i += 1
|
||||
stdio.printf("\n")
|
||||
i = 0
|
||||
while i < 3:
|
||||
stdio.printf("row1[%d]=%d ", i, row1[i])
|
||||
i += 1
|
||||
stdio.printf("\n")
|
||||
|
||||
|
||||
def TestArrayWithStruct():
|
||||
stdio.printf("=== Test Array with Struct ===\n")
|
||||
points: t.CArray[SimpleData, 3] = t.CArray[SimpleData, 3]()
|
||||
i: t.CInt = 0
|
||||
while i < 3:
|
||||
points[i].x = i * 10
|
||||
points[i].y = i * 100
|
||||
i += 1
|
||||
i = 0
|
||||
while i < 3:
|
||||
stdio.printf("Point[%d]: x=%d, y=%d\n", i, points[i].x, points[i].y)
|
||||
i += 1
|
||||
|
||||
|
||||
def TestArrayPointer():
|
||||
stdio.printf("=== Test Array Pointer ===\n")
|
||||
data: t.CArray[t.CInt, 8] = t.CArray[t.CInt, 8]()
|
||||
data[0] = 100
|
||||
data[1] = 200
|
||||
data[2] = 300
|
||||
ptr: t.CInt | t.CPtr = data
|
||||
stdio.printf("ptr[0]=%d\n", ptr[0])
|
||||
stdio.printf("ptr[1]=%d\n", ptr[1])
|
||||
stdio.printf("ptr[2]=%d\n", ptr[2])
|
||||
|
||||
|
||||
def TestDynamicString():
|
||||
stdio.printf("=== Test Dynamic String ===\n")
|
||||
name: str = "TransPyC"
|
||||
stdio.printf("Hello %s!\n", name)
|
||||
@@ -1,24 +0,0 @@
|
||||
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
|
||||
@@ -1,372 +0,0 @@
|
||||
import config
|
||||
import t, c
|
||||
|
||||
|
||||
def ForRangeBasicTest(stop: t.CInt):
|
||||
i: t.CInt = 0
|
||||
for i in range(stop):
|
||||
print("For range: ", i)
|
||||
print("Done")
|
||||
|
||||
|
||||
def ForRangeWithStartStop(start: t.CInt, stop: t.CInt, step: t.CInt):
|
||||
i: t.CInt = 0
|
||||
for i in range(start, stop, step):
|
||||
print("Range: ", i)
|
||||
print("Done")
|
||||
|
||||
|
||||
def NestedForRangeTest(rows: t.CInt, cols: t.CInt):
|
||||
r: t.CInt = 0
|
||||
c_val: t.CInt = 0
|
||||
for r in range(rows):
|
||||
for c_val in range(cols):
|
||||
print("Cell: ", r, c_val)
|
||||
print("Grid done")
|
||||
|
||||
|
||||
def ForWithIfBreakTest(data_size: t.CInt):
|
||||
i: t.CInt = 0
|
||||
found: t.CInt = 0
|
||||
for i in range(data_size):
|
||||
if i == 5:
|
||||
print("Found at: ", i)
|
||||
found = 1
|
||||
break
|
||||
print("Checking: ", i)
|
||||
if found == 0:
|
||||
print("Not found")
|
||||
|
||||
|
||||
def ForWithIfContinueTest(n: t.CInt):
|
||||
i: t.CInt = 0
|
||||
count: t.CInt = 0
|
||||
for i in range(n):
|
||||
if i % 2 == 0:
|
||||
continue
|
||||
print("Odd: ", i)
|
||||
count += 1
|
||||
print("Total odd: ", count)
|
||||
|
||||
|
||||
def ForWithElifBranchTest(value: t.CInt):
|
||||
i: t.CInt = 0
|
||||
result: t.CInt = 0
|
||||
for i in range(value):
|
||||
if i < 3:
|
||||
result += 1
|
||||
elif i < 6:
|
||||
result += 2
|
||||
elif i < 9:
|
||||
result += 3
|
||||
else:
|
||||
result += 4
|
||||
print("Elif branch result: ", result)
|
||||
|
||||
|
||||
def WhileWithIfElifElseTest(iterations: t.CInt):
|
||||
counter: t.CInt = 0
|
||||
while counter < iterations:
|
||||
if counter < 2:
|
||||
print("Phase 1: ", counter)
|
||||
elif counter < 4:
|
||||
print("Phase 2: ", counter)
|
||||
elif counter < 6:
|
||||
print("Phase 3: ", counter)
|
||||
else:
|
||||
print("Phase 4: ", counter)
|
||||
counter += 1
|
||||
print("While done")
|
||||
|
||||
|
||||
def WhileWithNestedIfTest(limit: t.CInt):
|
||||
outer: t.CInt = 0
|
||||
while outer < limit:
|
||||
inner: t.CInt = 0
|
||||
while inner < limit:
|
||||
if inner == 2 and outer == 1:
|
||||
print("Target: ", outer, inner)
|
||||
inner += 1
|
||||
continue
|
||||
if inner > 3:
|
||||
break
|
||||
print("Inner: ", inner)
|
||||
inner += 1
|
||||
outer += 1
|
||||
|
||||
|
||||
def WhileWithMatchCaseTest(value: t.CInt):
|
||||
result: t.CInt = 0
|
||||
match value:
|
||||
case 1:
|
||||
result = 100
|
||||
print("Case 1")
|
||||
case 2:
|
||||
result = 200
|
||||
print("Case 2")
|
||||
case 3:
|
||||
result = 300
|
||||
print("Case 3")
|
||||
case _:
|
||||
result = 999
|
||||
print("Default case")
|
||||
print("Match result: ", result)
|
||||
|
||||
|
||||
def WhileWithMatchCaseNoBreakTest(value: t.CInt):
|
||||
result: t.CInt = 0
|
||||
match value:
|
||||
case 1:
|
||||
result = 10
|
||||
print("Case 1: ", result)
|
||||
case 2:
|
||||
result = 20
|
||||
print("Case 2: ", result)
|
||||
result += 5
|
||||
case 3:
|
||||
result = 30
|
||||
print("Case 3: ", result)
|
||||
case _:
|
||||
result = 0
|
||||
print("No break match result: ", result)
|
||||
|
||||
|
||||
def ComplexForWhileMatchTest(outer_limit: t.CInt, inner_limit: t.CInt):
|
||||
i: t.CInt = 0
|
||||
j: t.CInt = 0
|
||||
result: t.CInt = 0
|
||||
for i in range(outer_limit):
|
||||
j = 0
|
||||
while j < inner_limit:
|
||||
match (i, j):
|
||||
case (0, 0):
|
||||
result += 1
|
||||
case (1, 1):
|
||||
result += 10
|
||||
case (2, _):
|
||||
result += 100
|
||||
case (_, 0):
|
||||
result += 1000
|
||||
case _:
|
||||
result += 10000
|
||||
j += 1
|
||||
print("Complex match result: ", result)
|
||||
|
||||
|
||||
def ForWithCaseAndNoBreakTest(n: t.CInt):
|
||||
i: t.CInt = 0
|
||||
result: t.CInt = 0
|
||||
for i in range(n):
|
||||
match i:
|
||||
case 0:
|
||||
result += 1
|
||||
case 1:
|
||||
result += 2
|
||||
case 2:
|
||||
result += 3
|
||||
result += 10
|
||||
case _:
|
||||
result += i
|
||||
c.NoBreak
|
||||
print("NoBreak result: ", result)
|
||||
|
||||
|
||||
def WhileWithBreakConditionTest(limit: t.CInt):
|
||||
i: t.CInt = 0
|
||||
early_exit: t.CInt = 0
|
||||
while i < limit:
|
||||
if i == 3:
|
||||
early_exit = 1
|
||||
break
|
||||
if i == 2:
|
||||
i += 1
|
||||
continue
|
||||
print("While i: ", i)
|
||||
i += 1
|
||||
|
||||
|
||||
def NestedWhileWithMultipleBreakPoints(depth: t.CInt, width: t.CInt):
|
||||
d: t.CInt = 0
|
||||
w: t.CInt = 0
|
||||
count: t.CInt = 0
|
||||
while d < depth:
|
||||
w = 0
|
||||
while w < width:
|
||||
if w == 2:
|
||||
break
|
||||
if d == 1 and w == 1:
|
||||
c.Break
|
||||
count += 1
|
||||
w += 1
|
||||
d += 1
|
||||
print("Nested break count: ", count)
|
||||
|
||||
|
||||
def ForWithMatchCaseInLoopTest(iterations: t.CInt):
|
||||
i: t.CInt = 0
|
||||
sum_even: t.CInt = 0
|
||||
sum_odd: t.CInt = 0
|
||||
for i in range(iterations):
|
||||
match i % 3:
|
||||
case 0:
|
||||
sum_even += i
|
||||
case 1:
|
||||
sum_odd += i
|
||||
case 2:
|
||||
sum_even += i * 2
|
||||
case _:
|
||||
pass
|
||||
print("Sum even: ", sum_even)
|
||||
print("Sum odd: ", sum_odd)
|
||||
|
||||
|
||||
def ComplexLogicWithElifChains(a: t.CInt, b: t.CInt, c_val: t.CInt):
|
||||
i: t.CInt = 0
|
||||
result: t.CInt = 0
|
||||
while i < 10:
|
||||
if i < a:
|
||||
if i < b:
|
||||
result += 1
|
||||
elif i < c_val:
|
||||
result += 2
|
||||
else:
|
||||
result += 3
|
||||
elif i < b:
|
||||
if i < c_val:
|
||||
result += 4
|
||||
else:
|
||||
result += 5
|
||||
elif i < c_val:
|
||||
result += 6
|
||||
else:
|
||||
result += 7
|
||||
i += 1
|
||||
print("Complex elif chain result: ", result)
|
||||
|
||||
|
||||
def ForRangeWithStepAndCondition(n: t.CInt, step: t.CInt):
|
||||
i: t.CInt = 0
|
||||
count: t.CInt = 0
|
||||
for i in range(0, n, step):
|
||||
if i % 2 == 0:
|
||||
print("Even step: ", i)
|
||||
count += 1
|
||||
else:
|
||||
if i > 5:
|
||||
print("Large odd: ", i)
|
||||
else:
|
||||
print("Small odd: ", i)
|
||||
print("Total steps: ", count)
|
||||
|
||||
|
||||
def MatchCaseWithGuardConditions(value: t.CInt):
|
||||
result: t.CInt = 0
|
||||
match value:
|
||||
case 1 if config.TRUE == 1:
|
||||
result = 100
|
||||
case 2 if config.FALSE == 0:
|
||||
result = 200
|
||||
case 3:
|
||||
result = 300
|
||||
case _:
|
||||
result = 0
|
||||
print("Guard match result: ", result)
|
||||
|
||||
|
||||
def WhileWithMultipleMatchCases(iterations: t.CInt):
|
||||
i: t.CInt = 0
|
||||
state: t.CInt = 0
|
||||
while i < iterations:
|
||||
match state:
|
||||
case 0:
|
||||
if i > 3:
|
||||
state = 1
|
||||
case 1:
|
||||
if i > 6:
|
||||
state = 2
|
||||
case 2:
|
||||
if i > 9:
|
||||
state = 0
|
||||
print("State at i=", i, ": ", state)
|
||||
i += 1
|
||||
|
||||
|
||||
def ForWhileMixWithBreakAndContinue(n: t.CInt):
|
||||
i: t.CInt = 0
|
||||
j: t.CInt = 0
|
||||
count: t.CInt = 0
|
||||
for i in range(n):
|
||||
j = 0
|
||||
while j < n:
|
||||
if j == 2:
|
||||
j += 1
|
||||
continue
|
||||
if i == 3 and j == 3:
|
||||
break
|
||||
count += 1
|
||||
j += 1
|
||||
print("Mix break continue count: ", count)
|
||||
|
||||
|
||||
def ComplexCaseMatchingWithRanges(start: t.CInt, end: t.CInt):
|
||||
i: t.CInt = 0
|
||||
bucket0: t.CInt = 0
|
||||
bucket1: t.CInt = 0
|
||||
bucket2: t.CInt = 0
|
||||
bucket3: t.CInt = 0
|
||||
for i in range(start, end):
|
||||
match i:
|
||||
case _ if i < 10:
|
||||
bucket0 += 1
|
||||
case _ if i < 20:
|
||||
bucket1 += 1
|
||||
case _ if i < 30:
|
||||
bucket2 += 1
|
||||
case _:
|
||||
bucket3 += 1
|
||||
print("Bucket0 (<10): ", bucket0)
|
||||
print("Bucket1 (10-19): ", bucket1)
|
||||
print("Bucket2 (20-29): ", bucket2)
|
||||
print("Bucket3 (>=30): ", bucket3)
|
||||
|
||||
|
||||
def WhileWithElifInElifChain(limit: t.CInt):
|
||||
i: t.CInt = 0
|
||||
result: t.CInt = 0
|
||||
while i < limit:
|
||||
if i < 2:
|
||||
if i == 0:
|
||||
result = 1
|
||||
else:
|
||||
result = 2
|
||||
elif i < 4:
|
||||
if i == 2:
|
||||
result = 3
|
||||
else:
|
||||
result = 4
|
||||
elif i < 6:
|
||||
if i == 4:
|
||||
result = 5
|
||||
else:
|
||||
result = 6
|
||||
else:
|
||||
result = 7
|
||||
print("Chain result[", i, "]: ", result)
|
||||
i += 1
|
||||
|
||||
|
||||
def ForWithCaseNoBreakNested(inner_limit: t.CInt):
|
||||
i: t.CInt = 0
|
||||
j: t.CInt = 0
|
||||
result: t.CInt = 0
|
||||
for i in range(3):
|
||||
for j in range(inner_limit):
|
||||
match j:
|
||||
case 0:
|
||||
result += 1
|
||||
case 1:
|
||||
result += 2
|
||||
case _:
|
||||
result += 3
|
||||
c.NoBreak
|
||||
print("Nested NoBreak result: ", result)
|
||||
@@ -1,298 +0,0 @@
|
||||
import config
|
||||
import t, c
|
||||
|
||||
|
||||
def AboutSizeTWhileTest(length: t.CSizeT):
|
||||
pos: t.CSizeT = 0
|
||||
while pos < length:
|
||||
print("Pos: ", pos)
|
||||
if pos > config.POSMAX: break
|
||||
pos += 1
|
||||
while pos < length:
|
||||
if pos > config.POSMAX:
|
||||
print("Pos: ", pos)
|
||||
pos += 1
|
||||
else:
|
||||
print("Pos: ", pos)
|
||||
pos += 1
|
||||
if pos > config.POSMAX: break
|
||||
else:
|
||||
pos += 1
|
||||
print("Pos: ", pos)
|
||||
while pos < length:
|
||||
print("Pos: ", pos)
|
||||
pos += 1
|
||||
|
||||
|
||||
def MathBasicTest(x: t.CInt, y: t.CInt) -> t.CInt:
|
||||
result: t.CInt = 0
|
||||
result = x + y
|
||||
print("Add: ", result)
|
||||
result = x - y
|
||||
print("Sub: ", result)
|
||||
result = x * y
|
||||
print("Mul: ", result)
|
||||
if y != 0:
|
||||
result = x / y
|
||||
print("Div: ", result)
|
||||
result = x % y if y != 0 else 0
|
||||
print("Mod: ", result)
|
||||
return result
|
||||
|
||||
|
||||
def MathAdvancedTest(value: t.CInt) -> t.CInt:
|
||||
counter: t.CInt = 0
|
||||
scaled: t.CInt = 0
|
||||
offset: t.CInt = 0
|
||||
scaled = value * config.MATH_SCALE
|
||||
print("Scaled: ", scaled)
|
||||
offset = scaled + config.MATH_OFFSET
|
||||
print("Offset: ", offset)
|
||||
threshold: t.CInt = config.THRESHOLD
|
||||
if offset > threshold:
|
||||
print("Above threshold")
|
||||
counter = 1
|
||||
elif offset == threshold:
|
||||
print("At threshold")
|
||||
counter = 0
|
||||
else:
|
||||
print("Below threshold")
|
||||
counter = -1
|
||||
return counter
|
||||
|
||||
|
||||
def WhileWithElifElseTest(start: t.CInt, end: t.CInt):
|
||||
idx: t.CInt = start
|
||||
while idx < end:
|
||||
if idx < 0:
|
||||
print("Negative: ", idx)
|
||||
elif idx == 0:
|
||||
print("Zero: ", idx)
|
||||
elif idx > 0 and idx < 5:
|
||||
print("Small positive: ", idx)
|
||||
elif idx >= 5 and idx < 10:
|
||||
print("Medium positive: ", idx)
|
||||
else:
|
||||
print("Large: ", idx)
|
||||
idx += 1
|
||||
|
||||
|
||||
def NestedWhileWithMacrosTest(outer_limit: t.CInt, inner_limit: t.CInt):
|
||||
outer: t.CInt = 0
|
||||
inner: t.CInt = 0
|
||||
total_ops: t.CInt = 0
|
||||
while outer < outer_limit:
|
||||
inner = 0
|
||||
while inner < inner_limit:
|
||||
if inner == config.TRUE:
|
||||
print("Inner loop break condition at: ", inner)
|
||||
total_ops += 1
|
||||
inner += 1
|
||||
outer += 1
|
||||
print("Total operations: ", total_ops)
|
||||
|
||||
|
||||
def ComplexConditionTest(a: t.CInt, b: t.CInt, c_val: t.CInt):
|
||||
x: t.CInt = a
|
||||
y: t.CInt = b
|
||||
z: t.CInt = c_val
|
||||
while x < config.LOOP_LIMIT:
|
||||
if x > 0 and y > 0 and z > 0:
|
||||
print("All positive: ", x, y, z)
|
||||
elif x <= 0 and y <= 0 and z <= 0:
|
||||
print("All non-positive: ", x, y, z)
|
||||
else:
|
||||
if x > 0:
|
||||
print("X positive")
|
||||
elif y > 0:
|
||||
print("Y positive")
|
||||
else:
|
||||
print("Z positive")
|
||||
x += 1
|
||||
y += 1
|
||||
z += 1
|
||||
|
||||
|
||||
def RetryLoopTest(retry_count: t.CInt) -> t.CInt:
|
||||
attempt: t.CInt = 0
|
||||
success: t.CInt = 0
|
||||
while attempt < retry_count:
|
||||
if attempt < config.MAX_RETRY:
|
||||
print("Attempt: ", attempt, " less than max")
|
||||
success = attempt * 2
|
||||
elif attempt == config.MAX_RETRY:
|
||||
print("At max retry")
|
||||
success = -1
|
||||
else:
|
||||
print("Beyond max retry")
|
||||
success = -2
|
||||
attempt += 1
|
||||
return success
|
||||
|
||||
|
||||
def BitwiseOperationsTest(value: t.CInt) -> t.CInt:
|
||||
shifted: t.CInt = 0
|
||||
masked: t.CInt = 0
|
||||
xored: t.CInt = 0
|
||||
anded: t.CInt = 0
|
||||
ored: t.CInt = 0
|
||||
shifted = value << config.SHIFT_AMOUNT
|
||||
print("Left shift: ", shifted)
|
||||
shifted = value >> config.SHIFT_AMOUNT
|
||||
print("Right shift: ", shifted)
|
||||
masked = value & config.MASK_VALUE
|
||||
print("Bitwise AND mask: ", masked)
|
||||
xored = value ^ config.MASK_VALUE
|
||||
print("Bitwise XOR: ", xored)
|
||||
anded = value & (config.MASK_VALUE >> config.SHIFT_AMOUNT)
|
||||
print("Bitwise AND shifted mask: ", anded)
|
||||
ored = value | config.SHIFT_AMOUNT
|
||||
print("Bitwise OR shift: ", ored)
|
||||
return masked
|
||||
|
||||
|
||||
def CompoundAssignmentMathTest(a: t.CInt, b: t.CInt) -> t.CInt:
|
||||
x: t.CInt = a
|
||||
y: t.CInt = b
|
||||
result: t.CInt = 0
|
||||
x += y
|
||||
print("x += y: ", x)
|
||||
x -= y
|
||||
print("x -= y: ", x)
|
||||
x *= y
|
||||
print("x *= y: ", x)
|
||||
x = a
|
||||
y = b
|
||||
if b != 0:
|
||||
x /= b
|
||||
print("x /= y: ", x)
|
||||
x = a
|
||||
if b != 0:
|
||||
x %= b
|
||||
print("x %%= y: ", x)
|
||||
x = a
|
||||
x <<= config.SHIFT_AMOUNT
|
||||
print("x <<= shift: ", x)
|
||||
x >>= config.SHIFT_AMOUNT
|
||||
print("x >>= shift: ", x)
|
||||
x &= config.MASK_VALUE
|
||||
print("x &= mask: ", x)
|
||||
x |= config.SHIFT_AMOUNT
|
||||
print("x |= shift: ", x)
|
||||
result = (a + b) * config.MATH_SCALE - config.MATH_OFFSET
|
||||
print("Compound: (a+b)*scale-offset: ", result)
|
||||
result = (a * b) + (config.MATH_OFFSET / 2)
|
||||
print("Compound: a*b+offset/2: ", result)
|
||||
return result
|
||||
|
||||
|
||||
def PowerAndModuloTest(base: t.CInt, exponent: t.CInt) -> t.CInt:
|
||||
result: t.CInt = 1
|
||||
temp: t.CInt = 0
|
||||
i: t.CInt = 0
|
||||
while i < exponent:
|
||||
result *= base
|
||||
i += 1
|
||||
print("Power: ", result)
|
||||
temp = result % config.MODULO_DIVISOR
|
||||
print("Power mod: ", temp)
|
||||
temp = (base * config.EXPONENT_BASE) % config.MODULO_DIVISOR
|
||||
print("base*exp %% divisor: ", temp)
|
||||
temp = ((base + config.MATH_OFFSET) * config.MATH_SCALE) % config.MODULO_DIVISOR
|
||||
print("(base+offset)*scale %% divisor: ", temp)
|
||||
return result
|
||||
|
||||
|
||||
def MixedArithmeticTest(x: t.CInt, y: t.CInt, z: t.CInt) -> t.CInt:
|
||||
result: t.CInt = 0
|
||||
result = (x + y) * z
|
||||
print("(x+y)*z: ", result)
|
||||
result = x + (y * z)
|
||||
print("x+(y*z): ", result)
|
||||
result = ((x + y) * config.MATH_SCALE) - config.MATH_OFFSET
|
||||
print("((x+y)*scale)-offset: ", result)
|
||||
result = (x * config.MATH_SCALE) + (y * config.MATH_SCALE)
|
||||
print("x*scale + y*scale: ", result)
|
||||
result = ((x % config.MODULO_DIVISOR) + (y % config.MODULO_DIVISOR)) * config.MATH_SCALE
|
||||
print("(x%%mod + y%%mod)*scale: ", result)
|
||||
temp: t.CInt = 0
|
||||
temp = x | y & z
|
||||
print("x | y & z: ", temp)
|
||||
temp = (x | y) & z
|
||||
print("(x | y) & z: ", temp)
|
||||
temp = x ^ y ^ z
|
||||
print("x ^ y ^ z: ", temp)
|
||||
return result
|
||||
|
||||
|
||||
def MathWithWhileLoopTest(start: t.CInt, count: t.CInt) -> t.CInt:
|
||||
idx: t.CInt = 0
|
||||
accumulator: t.CInt = 0
|
||||
multiplier: t.CInt = config.MATH_SCALE
|
||||
while idx < count:
|
||||
temp: t.CInt = (start + idx) * multiplier
|
||||
temp = temp + config.MATH_OFFSET
|
||||
if temp > config.THRESHOLD:
|
||||
temp = config.THRESHOLD
|
||||
accumulator += temp
|
||||
multiplier += 1
|
||||
idx += 1
|
||||
print("Accumulator: ", accumulator)
|
||||
return accumulator
|
||||
|
||||
|
||||
def ComplexNestedMathTest(a: t.CInt, b: t.CInt) -> t.CInt:
|
||||
layer1: t.CInt = 0
|
||||
layer2: t.CInt = 0
|
||||
layer3: t.CInt = 0
|
||||
i: t.CInt = 0
|
||||
layer1 = (a + b) * config.MATH_SCALE
|
||||
print("Layer1: ", layer1)
|
||||
while i < config.BIT_RANGE:
|
||||
layer2 += layer1 >> 1
|
||||
i += 1
|
||||
print("Layer2: ", layer2)
|
||||
layer3 = layer1 + layer2 - config.MATH_OFFSET
|
||||
print("Layer3: ", layer3)
|
||||
layer3 = layer3 * config.MATH_SCALE / 2 if config.MATH_SCALE != 0 else layer3
|
||||
print("Layer3 scaled: ", layer3)
|
||||
return layer3
|
||||
|
||||
|
||||
def ConditionalMathChainTest(value: t.CInt) -> t.CInt:
|
||||
result: t.CInt = 0
|
||||
step: t.CInt = 0
|
||||
while step < config.LOOP_LIMIT:
|
||||
if step < 5:
|
||||
result += step * config.MATH_SCALE
|
||||
print("step<5: ", result)
|
||||
elif step < 10:
|
||||
result -= step - config.MATH_OFFSET
|
||||
print("step<10: ", result)
|
||||
elif step < 15:
|
||||
result += (step * config.MATH_OFFSET) / config.MATH_SCALE
|
||||
print("step<15: ", result)
|
||||
else:
|
||||
result = result * config.EXPONENT_BASE % config.MODULO_DIVISOR
|
||||
print("step>=15: ", result)
|
||||
step += 1
|
||||
return result
|
||||
|
||||
|
||||
def BitManipulationMathTest(value: t.CInt) -> t.CInt:
|
||||
original: t.CInt = value
|
||||
nibble: t.CInt = 0
|
||||
result: t.CInt = 0
|
||||
result = (value << config.SHIFT_AMOUNT) | (value >> (8 - config.SHIFT_AMOUNT))
|
||||
print("Rotate left: ", result)
|
||||
result = (value >> config.SHIFT_AMOUNT) | (value << (8 - config.SHIFT_AMOUNT))
|
||||
print("Rotate right: ", result)
|
||||
nibble = value & 0xF
|
||||
print("Lower nibble: ", nibble)
|
||||
nibble = (value >> config.BIT_RANGE) & 0xF
|
||||
print("Upper nibble: ", nibble)
|
||||
result = ((value & config.MASK_VALUE) + config.MATH_OFFSET) * config.MATH_SCALE
|
||||
print("Masked and scaled: ", result)
|
||||
result = ((original << config.SHIFT_AMOUNT) ^ original) & config.MASK_VALUE
|
||||
print("XOR shifted: ", result)
|
||||
return result
|
||||
@@ -1 +0,0 @@
|
||||
{"memhub": "04e5fe47ff2af528", "hashlib.__sha1": "0df65b8ed15664b0", "__sha1": "0df65b8ed15664b0", "hashlib.__md5": "19f8024d10c828e8", "__md5": "19f8024d10c828e8", "zlib.zdef": "1f6617c02fc8899d", "zdef": "1f6617c02fc8899d", "stdio": "285b6aa29a34754d", "zlib.pyzlib": "3e775aa83705b119", "pyzlib": "3e775aa83705b119", "zlib.zinflate": "451745df21e598af", "zinflate": "451745df21e598af", "main": "541a1ed9b8be53c8", "stdlib": "6c658cc728d0bbf4", "hashlib.__sha512": "6ff26590374ae6fc", "__sha512": "6ff26590374ae6fc", "testcheck": "748d0424e8976fa0", "zlib.zchecksum": "8ebed83a7817fa0c", "zchecksum": "8ebed83a7817fa0c", "zlib.zdeflate": "90921d009fdd674c", "zdeflate": "90921d009fdd674c", "string": "928c0ff6d8c69ec9", "hashlib.__init__": "96837bcc64032444", "__init__": "d63d2c2a2bd9bd2a", "hashlib": "96837bcc64032444", "atom": "aa246c6e6aa30484", "w32.win32console": "bbdf3bbd4c3bc28c", "win32console": "bbdf3bbd4c3bc28c", "hashlib.__sha256": "c9d54a4158f7f5a8", "__sha256": "c9d54a4158f7f5a8", "viperio": "c9f4be41ca1cc2b4", "zc.config": "cfc83b830141b00e", "config": "cfc83b830141b00e", "binascii": "d3917d97537f703c", "zlib.zhuff": "d541ade6afb689a5", "zhuff": "d541ade6afb689a5", "stdint": "f5522571bcce7bcb", "w32.win32base": "fc980acec33d69a7", "win32base": "fc980acec33d69a7", "w32.win32file": "f6b51804a0ba8ff0", "win32file": "f6b51804a0ba8ff0", "w32.fileio": "d137b1f3311f3a7f", "fileio": "d137b1f3311f3a7f", "w32.win32memory": "72e2d5ccb7cedcf1", "win32memory": "72e2d5ccb7cedcf1", "w32.win32process": "067c78e9f121dce3", "win32process": "067c78e9f121dce3", "w32.win32sync": "06f53cc594b4ac6c", "win32sync": "06f53cc594b4ac6c", "w32.winsock2": "6446627d4f07a1b5", "winsock2": "6446627d4f07a1b5", "zlib.__init__": "d63d2c2a2bd9bd2a", "zlib": "d63d2c2a2bd9bd2a"}
|
||||
@@ -1 +0,0 @@
|
||||
{"memhub": "04e5fe47ff2af528", "hashlib.__sha1": "0df65b8ed15664b0", "__sha1": "0df65b8ed15664b0", "hashlib.__md5": "19f8024d10c828e8", "__md5": "19f8024d10c828e8", "zlib.zdef": "1f6617c02fc8899d", "zdef": "1f6617c02fc8899d", "stdio": "285b6aa29a34754d", "zlib.pyzlib": "3e775aa83705b119", "pyzlib": "3e775aa83705b119", "zlib.zinflate": "451745df21e598af", "zinflate": "451745df21e598af", "main": "541a1ed9b8be53c8", "stdlib": "6c658cc728d0bbf4", "hashlib.__sha512": "6ff26590374ae6fc", "__sha512": "6ff26590374ae6fc", "testcheck": "748d0424e8976fa0", "zlib.zchecksum": "8ebed83a7817fa0c", "zchecksum": "8ebed83a7817fa0c", "zlib.zdeflate": "90921d009fdd674c", "zdeflate": "90921d009fdd674c", "string": "928c0ff6d8c69ec9", "hashlib.__init__": "96837bcc64032444", "__init__": "d63d2c2a2bd9bd2a", "hashlib": "96837bcc64032444", "atom": "aa246c6e6aa30484", "w32.win32console": "bbdf3bbd4c3bc28c", "win32console": "bbdf3bbd4c3bc28c", "hashlib.__sha256": "c9d54a4158f7f5a8", "__sha256": "c9d54a4158f7f5a8", "viperio": "c9f4be41ca1cc2b4", "zc.config": "cfc83b830141b00e", "config": "cfc83b830141b00e", "binascii": "d3917d97537f703c", "zlib.zhuff": "d541ade6afb689a5", "zhuff": "d541ade6afb689a5", "stdint": "f5522571bcce7bcb", "w32.win32base": "fc980acec33d69a7", "win32base": "fc980acec33d69a7", "w32.win32file": "f6b51804a0ba8ff0", "win32file": "f6b51804a0ba8ff0", "w32.fileio": "d137b1f3311f3a7f", "fileio": "d137b1f3311f3a7f", "w32.win32memory": "72e2d5ccb7cedcf1", "win32memory": "72e2d5ccb7cedcf1", "w32.win32process": "067c78e9f121dce3", "win32process": "067c78e9f121dce3", "w32.win32sync": "06f53cc594b4ac6c", "win32sync": "06f53cc594b4ac6c", "w32.winsock2": "6446627d4f07a1b5", "winsock2": "6446627d4f07a1b5", "zlib.__init__": "d63d2c2a2bd9bd2a", "zlib": "d63d2c2a2bd9bd2a"}
|
||||
@@ -1 +0,0 @@
|
||||
{"memhub": "04e5fe47ff2af528", "hashlib.__sha1": "0df65b8ed15664b0", "__sha1": "0df65b8ed15664b0", "hashlib.__md5": "19f8024d10c828e8", "__md5": "19f8024d10c828e8", "zlib.zdef": "1f6617c02fc8899d", "zdef": "1f6617c02fc8899d", "stdio": "285b6aa29a34754d", "zlib.pyzlib": "3e775aa83705b119", "pyzlib": "3e775aa83705b119", "zlib.zinflate": "451745df21e598af", "zinflate": "451745df21e598af", "main": "541a1ed9b8be53c8", "stdlib": "6c658cc728d0bbf4", "hashlib.__sha512": "6ff26590374ae6fc", "__sha512": "6ff26590374ae6fc", "testcheck": "748d0424e8976fa0", "zlib.zchecksum": "8ebed83a7817fa0c", "zchecksum": "8ebed83a7817fa0c", "zlib.zdeflate": "90921d009fdd674c", "zdeflate": "90921d009fdd674c", "string": "928c0ff6d8c69ec9", "hashlib.__init__": "96837bcc64032444", "__init__": "d63d2c2a2bd9bd2a", "hashlib": "96837bcc64032444", "atom": "aa246c6e6aa30484", "w32.win32console": "bbdf3bbd4c3bc28c", "win32console": "bbdf3bbd4c3bc28c", "hashlib.__sha256": "c9d54a4158f7f5a8", "__sha256": "c9d54a4158f7f5a8", "viperio": "c9f4be41ca1cc2b4", "zc.config": "cfc83b830141b00e", "config": "cfc83b830141b00e", "binascii": "d3917d97537f703c", "zlib.zhuff": "d541ade6afb689a5", "zhuff": "d541ade6afb689a5", "stdint": "f5522571bcce7bcb", "w32.win32base": "fc980acec33d69a7", "win32base": "fc980acec33d69a7", "w32.win32file": "f6b51804a0ba8ff0", "win32file": "f6b51804a0ba8ff0", "w32.fileio": "d137b1f3311f3a7f", "fileio": "d137b1f3311f3a7f", "w32.win32memory": "72e2d5ccb7cedcf1", "win32memory": "72e2d5ccb7cedcf1", "w32.win32process": "067c78e9f121dce3", "win32process": "067c78e9f121dce3", "w32.win32sync": "06f53cc594b4ac6c", "win32sync": "06f53cc594b4ac6c", "w32.winsock2": "6446627d4f07a1b5", "winsock2": "6446627d4f07a1b5", "zlib.__init__": "d63d2c2a2bd9bd2a", "zlib": "d63d2c2a2bd9bd2a"}
|
||||
@@ -1 +0,0 @@
|
||||
{"memhub": "04e5fe47ff2af528", "hashlib.__sha1": "0df65b8ed15664b0", "__sha1": "0df65b8ed15664b0", "hashlib.__md5": "19f8024d10c828e8", "__md5": "19f8024d10c828e8", "zlib.zdef": "1f6617c02fc8899d", "zdef": "1f6617c02fc8899d", "stdio": "285b6aa29a34754d", "zlib.pyzlib": "3e775aa83705b119", "pyzlib": "3e775aa83705b119", "zlib.zinflate": "451745df21e598af", "zinflate": "451745df21e598af", "main": "541a1ed9b8be53c8", "stdlib": "6c658cc728d0bbf4", "hashlib.__sha512": "6ff26590374ae6fc", "__sha512": "6ff26590374ae6fc", "testcheck": "748d0424e8976fa0", "zlib.zchecksum": "8ebed83a7817fa0c", "zchecksum": "8ebed83a7817fa0c", "zlib.zdeflate": "90921d009fdd674c", "zdeflate": "90921d009fdd674c", "string": "928c0ff6d8c69ec9", "hashlib.__init__": "96837bcc64032444", "__init__": "d63d2c2a2bd9bd2a", "hashlib": "96837bcc64032444", "atom": "aa246c6e6aa30484", "w32.win32console": "bbdf3bbd4c3bc28c", "win32console": "bbdf3bbd4c3bc28c", "hashlib.__sha256": "c9d54a4158f7f5a8", "__sha256": "c9d54a4158f7f5a8", "viperio": "c9f4be41ca1cc2b4", "zc.config": "cfc83b830141b00e", "config": "cfc83b830141b00e", "binascii": "d3917d97537f703c", "zlib.zhuff": "d541ade6afb689a5", "zhuff": "d541ade6afb689a5", "stdint": "f5522571bcce7bcb", "w32.win32base": "fc980acec33d69a7", "win32base": "fc980acec33d69a7", "w32.win32file": "f6b51804a0ba8ff0", "win32file": "f6b51804a0ba8ff0", "w32.fileio": "d137b1f3311f3a7f", "fileio": "d137b1f3311f3a7f", "w32.win32memory": "72e2d5ccb7cedcf1", "win32memory": "72e2d5ccb7cedcf1", "w32.win32process": "067c78e9f121dce3", "win32process": "067c78e9f121dce3", "w32.win32sync": "06f53cc594b4ac6c", "win32sync": "06f53cc594b4ac6c", "w32.winsock2": "6446627d4f07a1b5", "winsock2": "6446627d4f07a1b5", "zlib.__init__": "d63d2c2a2bd9bd2a", "zlib": "d63d2c2a2bd9bd2a"}
|
||||
@@ -1 +0,0 @@
|
||||
{"memhub": "04e5fe47ff2af528", "hashlib.__sha1": "0df65b8ed15664b0", "__sha1": "0df65b8ed15664b0", "hashlib.__md5": "19f8024d10c828e8", "__md5": "19f8024d10c828e8", "zlib.zdef": "1f6617c02fc8899d", "zdef": "1f6617c02fc8899d", "stdio": "285b6aa29a34754d", "zlib.pyzlib": "3e775aa83705b119", "pyzlib": "3e775aa83705b119", "zlib.zinflate": "451745df21e598af", "zinflate": "451745df21e598af", "main": "541a1ed9b8be53c8", "stdlib": "6c658cc728d0bbf4", "hashlib.__sha512": "6ff26590374ae6fc", "__sha512": "6ff26590374ae6fc", "testcheck": "748d0424e8976fa0", "zlib.zchecksum": "8ebed83a7817fa0c", "zchecksum": "8ebed83a7817fa0c", "zlib.zdeflate": "90921d009fdd674c", "zdeflate": "90921d009fdd674c", "string": "928c0ff6d8c69ec9", "hashlib.__init__": "96837bcc64032444", "__init__": "d63d2c2a2bd9bd2a", "hashlib": "96837bcc64032444", "atom": "aa246c6e6aa30484", "w32.win32console": "bbdf3bbd4c3bc28c", "win32console": "bbdf3bbd4c3bc28c", "hashlib.__sha256": "c9d54a4158f7f5a8", "__sha256": "c9d54a4158f7f5a8", "viperio": "c9f4be41ca1cc2b4", "zc.config": "cfc83b830141b00e", "config": "cfc83b830141b00e", "binascii": "d3917d97537f703c", "zlib.zhuff": "d541ade6afb689a5", "zhuff": "d541ade6afb689a5", "stdint": "f5522571bcce7bcb", "w32.win32base": "fc980acec33d69a7", "win32base": "fc980acec33d69a7", "w32.win32file": "f6b51804a0ba8ff0", "win32file": "f6b51804a0ba8ff0", "w32.fileio": "d137b1f3311f3a7f", "fileio": "d137b1f3311f3a7f", "w32.win32memory": "72e2d5ccb7cedcf1", "win32memory": "72e2d5ccb7cedcf1", "w32.win32process": "067c78e9f121dce3", "win32process": "067c78e9f121dce3", "w32.win32sync": "06f53cc594b4ac6c", "win32sync": "06f53cc594b4ac6c", "w32.winsock2": "6446627d4f07a1b5", "winsock2": "6446627d4f07a1b5", "zlib.__init__": "d63d2c2a2bd9bd2a", "zlib": "d63d2c2a2bd9bd2a"}
|
||||
@@ -1 +0,0 @@
|
||||
{"memhub": "04e5fe47ff2af528", "hashlib.__sha1": "0df65b8ed15664b0", "__sha1": "0df65b8ed15664b0", "hashlib.__md5": "19f8024d10c828e8", "__md5": "19f8024d10c828e8", "zlib.zdef": "1f6617c02fc8899d", "zdef": "1f6617c02fc8899d", "stdio": "285b6aa29a34754d", "zlib.pyzlib": "3e775aa83705b119", "pyzlib": "3e775aa83705b119", "zlib.zinflate": "451745df21e598af", "zinflate": "451745df21e598af", "stdlib": "6c658cc728d0bbf4", "hashlib.__sha512": "6ff26590374ae6fc", "__sha512": "6ff26590374ae6fc", "testcheck": "748d0424e8976fa0", "zlib.zchecksum": "8ebed83a7817fa0c", "zchecksum": "8ebed83a7817fa0c", "zlib.zdeflate": "90921d009fdd674c", "zdeflate": "90921d009fdd674c", "string": "928c0ff6d8c69ec9", "hashlib.__init__": "96837bcc64032444", "__init__": "96837bcc64032444", "hashlib": "96837bcc64032444", "atom": "aa246c6e6aa30484", "w32.win32console": "bbdf3bbd4c3bc28c", "win32console": "bbdf3bbd4c3bc28c", "hashlib.__sha256": "c9d54a4158f7f5a8", "__sha256": "c9d54a4158f7f5a8", "viperio": "c9f4be41ca1cc2b4", "zc.config": "cfc83b830141b00e", "config": "cfc83b830141b00e", "binascii": "d3917d97537f703c", "zlib.zhuff": "d541ade6afb689a5", "zhuff": "d541ade6afb689a5", "stdint": "f5522571bcce7bcb", "w32.win32base": "fc980acec33d69a7", "win32base": "fc980acec33d69a7"}
|
||||
@@ -1 +0,0 @@
|
||||
{"memhub": "04e5fe47ff2af528", "hashlib.__sha1": "0df65b8ed15664b0", "__sha1": "0df65b8ed15664b0", "hashlib.__md5": "19f8024d10c828e8", "__md5": "19f8024d10c828e8", "zlib.zdef": "1f6617c02fc8899d", "zdef": "1f6617c02fc8899d", "stdio": "285b6aa29a34754d", "zlib.pyzlib": "3e775aa83705b119", "pyzlib": "3e775aa83705b119", "zlib.zinflate": "451745df21e598af", "zinflate": "451745df21e598af", "main": "541a1ed9b8be53c8", "stdlib": "6c658cc728d0bbf4", "hashlib.__sha512": "6ff26590374ae6fc", "__sha512": "6ff26590374ae6fc", "testcheck": "748d0424e8976fa0", "zlib.zchecksum": "8ebed83a7817fa0c", "zchecksum": "8ebed83a7817fa0c", "zlib.zdeflate": "90921d009fdd674c", "zdeflate": "90921d009fdd674c", "string": "928c0ff6d8c69ec9", "hashlib.__init__": "96837bcc64032444", "__init__": "d63d2c2a2bd9bd2a", "hashlib": "96837bcc64032444", "atom": "aa246c6e6aa30484", "w32.win32console": "bbdf3bbd4c3bc28c", "win32console": "bbdf3bbd4c3bc28c", "hashlib.__sha256": "c9d54a4158f7f5a8", "__sha256": "c9d54a4158f7f5a8", "viperio": "c9f4be41ca1cc2b4", "zc.config": "cfc83b830141b00e", "config": "cfc83b830141b00e", "binascii": "d3917d97537f703c", "zlib.zhuff": "d541ade6afb689a5", "zhuff": "d541ade6afb689a5", "stdint": "f5522571bcce7bcb", "w32.win32base": "fc980acec33d69a7", "win32base": "fc980acec33d69a7", "w32.win32file": "f6b51804a0ba8ff0", "win32file": "f6b51804a0ba8ff0", "w32.fileio": "d137b1f3311f3a7f", "fileio": "d137b1f3311f3a7f", "w32.win32memory": "72e2d5ccb7cedcf1", "win32memory": "72e2d5ccb7cedcf1", "w32.win32process": "067c78e9f121dce3", "win32process": "067c78e9f121dce3", "w32.win32sync": "06f53cc594b4ac6c", "win32sync": "06f53cc594b4ac6c", "w32.winsock2": "6446627d4f07a1b5", "winsock2": "6446627d4f07a1b5", "zlib.__init__": "d63d2c2a2bd9bd2a", "zlib": "d63d2c2a2bd9bd2a"}
|
||||
@@ -1 +0,0 @@
|
||||
{"memhub": "04e5fe47ff2af528", "hashlib.__sha1": "0df65b8ed15664b0", "__sha1": "0df65b8ed15664b0", "hashlib.__md5": "19f8024d10c828e8", "__md5": "19f8024d10c828e8", "zlib.zdef": "1f6617c02fc8899d", "zdef": "1f6617c02fc8899d", "stdio": "285b6aa29a34754d", "zlib.pyzlib": "3e775aa83705b119", "pyzlib": "3e775aa83705b119", "zlib.zinflate": "451745df21e598af", "zinflate": "451745df21e598af", "main": "541a1ed9b8be53c8", "stdlib": "6c658cc728d0bbf4", "hashlib.__sha512": "6ff26590374ae6fc", "__sha512": "6ff26590374ae6fc", "testcheck": "748d0424e8976fa0", "zlib.zchecksum": "8ebed83a7817fa0c", "zchecksum": "8ebed83a7817fa0c", "zlib.zdeflate": "90921d009fdd674c", "zdeflate": "90921d009fdd674c", "string": "928c0ff6d8c69ec9", "hashlib.__init__": "96837bcc64032444", "__init__": "d63d2c2a2bd9bd2a", "hashlib": "96837bcc64032444", "atom": "aa246c6e6aa30484", "w32.win32console": "bbdf3bbd4c3bc28c", "win32console": "bbdf3bbd4c3bc28c", "hashlib.__sha256": "c9d54a4158f7f5a8", "__sha256": "c9d54a4158f7f5a8", "viperio": "c9f4be41ca1cc2b4", "zc.config": "cfc83b830141b00e", "config": "cfc83b830141b00e", "binascii": "d3917d97537f703c", "zlib.zhuff": "d541ade6afb689a5", "zhuff": "d541ade6afb689a5", "stdint": "f5522571bcce7bcb", "w32.win32base": "fc980acec33d69a7", "win32base": "fc980acec33d69a7", "w32.win32file": "f6b51804a0ba8ff0", "win32file": "f6b51804a0ba8ff0", "w32.fileio": "d137b1f3311f3a7f", "fileio": "d137b1f3311f3a7f", "w32.win32memory": "72e2d5ccb7cedcf1", "win32memory": "72e2d5ccb7cedcf1", "w32.win32process": "067c78e9f121dce3", "win32process": "067c78e9f121dce3", "w32.win32sync": "06f53cc594b4ac6c", "win32sync": "06f53cc594b4ac6c", "w32.winsock2": "6446627d4f07a1b5", "winsock2": "6446627d4f07a1b5", "zlib.__init__": "d63d2c2a2bd9bd2a", "zlib": "d63d2c2a2bd9bd2a"}
|
||||
@@ -1 +0,0 @@
|
||||
{"memhub": "04e5fe47ff2af528", "hashlib.__sha1": "0df65b8ed15664b0", "__sha1": "0df65b8ed15664b0", "hashlib.__md5": "19f8024d10c828e8", "__md5": "19f8024d10c828e8", "zlib.zdef": "1f6617c02fc8899d", "zdef": "1f6617c02fc8899d", "stdio": "285b6aa29a34754d", "zlib.pyzlib": "3e775aa83705b119", "pyzlib": "3e775aa83705b119", "zlib.zinflate": "451745df21e598af", "zinflate": "451745df21e598af", "main": "541a1ed9b8be53c8", "stdlib": "6c658cc728d0bbf4", "hashlib.__sha512": "6ff26590374ae6fc", "__sha512": "6ff26590374ae6fc", "testcheck": "748d0424e8976fa0", "zlib.zchecksum": "8ebed83a7817fa0c", "zchecksum": "8ebed83a7817fa0c", "zlib.zdeflate": "90921d009fdd674c", "zdeflate": "90921d009fdd674c", "string": "928c0ff6d8c69ec9", "hashlib.__init__": "96837bcc64032444", "__init__": "d63d2c2a2bd9bd2a", "hashlib": "96837bcc64032444", "atom": "aa246c6e6aa30484", "w32.win32console": "bbdf3bbd4c3bc28c", "win32console": "bbdf3bbd4c3bc28c", "hashlib.__sha256": "c9d54a4158f7f5a8", "__sha256": "c9d54a4158f7f5a8", "viperio": "c9f4be41ca1cc2b4", "zc.config": "cfc83b830141b00e", "config": "cfc83b830141b00e", "binascii": "d3917d97537f703c", "zlib.zhuff": "d541ade6afb689a5", "zhuff": "d541ade6afb689a5", "stdint": "f5522571bcce7bcb", "w32.win32base": "fc980acec33d69a7", "win32base": "fc980acec33d69a7", "w32.win32file": "f6b51804a0ba8ff0", "win32file": "f6b51804a0ba8ff0", "w32.fileio": "d137b1f3311f3a7f", "fileio": "d137b1f3311f3a7f", "w32.win32memory": "72e2d5ccb7cedcf1", "win32memory": "72e2d5ccb7cedcf1", "w32.win32process": "067c78e9f121dce3", "win32process": "067c78e9f121dce3", "w32.win32sync": "06f53cc594b4ac6c", "win32sync": "06f53cc594b4ac6c", "w32.winsock2": "6446627d4f07a1b5", "winsock2": "6446627d4f07a1b5", "zlib.__init__": "d63d2c2a2bd9bd2a", "zlib": "d63d2c2a2bd9bd2a"}
|
||||
Binary file not shown.
@@ -1 +0,0 @@
|
||||
{"memhub": "04e5fe47ff2af528", "hashlib.__sha1": "0df65b8ed15664b0", "__sha1": "0df65b8ed15664b0", "hashlib.__md5": "19f8024d10c828e8", "__md5": "19f8024d10c828e8", "zlib.zdef": "1f6617c02fc8899d", "zdef": "1f6617c02fc8899d", "stdio": "285b6aa29a34754d", "zlib.pyzlib": "3e775aa83705b119", "pyzlib": "3e775aa83705b119", "zlib.zinflate": "451745df21e598af", "zinflate": "451745df21e598af", "main": "541a1ed9b8be53c8", "stdlib": "6c658cc728d0bbf4", "hashlib.__sha512": "6ff26590374ae6fc", "__sha512": "6ff26590374ae6fc", "testcheck": "748d0424e8976fa0", "zlib.zchecksum": "8ebed83a7817fa0c", "zchecksum": "8ebed83a7817fa0c", "zlib.zdeflate": "90921d009fdd674c", "zdeflate": "90921d009fdd674c", "string": "928c0ff6d8c69ec9", "hashlib.__init__": "96837bcc64032444", "__init__": "d63d2c2a2bd9bd2a", "hashlib": "96837bcc64032444", "atom": "aa246c6e6aa30484", "w32.win32console": "bbdf3bbd4c3bc28c", "win32console": "bbdf3bbd4c3bc28c", "hashlib.__sha256": "c9d54a4158f7f5a8", "__sha256": "c9d54a4158f7f5a8", "viperio": "c9f4be41ca1cc2b4", "zc.config": "cfc83b830141b00e", "config": "cfc83b830141b00e", "binascii": "d3917d97537f703c", "zlib.zhuff": "d541ade6afb689a5", "zhuff": "d541ade6afb689a5", "stdint": "f5522571bcce7bcb", "w32.win32base": "fc980acec33d69a7", "win32base": "fc980acec33d69a7", "w32.win32file": "f6b51804a0ba8ff0", "win32file": "f6b51804a0ba8ff0", "w32.fileio": "d137b1f3311f3a7f", "fileio": "d137b1f3311f3a7f", "w32.win32memory": "72e2d5ccb7cedcf1", "win32memory": "72e2d5ccb7cedcf1", "w32.win32process": "067c78e9f121dce3", "win32process": "067c78e9f121dce3", "w32.win32sync": "06f53cc594b4ac6c", "win32sync": "06f53cc594b4ac6c", "w32.winsock2": "6446627d4f07a1b5", "winsock2": "6446627d4f07a1b5", "zlib.__init__": "d63d2c2a2bd9bd2a", "zlib": "d63d2c2a2bd9bd2a"}
|
||||
@@ -1 +0,0 @@
|
||||
{"memhub": "04e5fe47ff2af528", "hashlib.__sha1": "0df65b8ed15664b0", "__sha1": "0df65b8ed15664b0", "hashlib.__md5": "19f8024d10c828e8", "__md5": "19f8024d10c828e8", "zlib.zdef": "1f6617c02fc8899d", "zdef": "1f6617c02fc8899d", "stdio": "285b6aa29a34754d", "zlib.pyzlib": "3e775aa83705b119", "pyzlib": "3e775aa83705b119", "zlib.zinflate": "451745df21e598af", "zinflate": "451745df21e598af", "main": "541a1ed9b8be53c8", "stdlib": "6c658cc728d0bbf4", "hashlib.__sha512": "6ff26590374ae6fc", "__sha512": "6ff26590374ae6fc", "testcheck": "748d0424e8976fa0", "zlib.zchecksum": "8ebed83a7817fa0c", "zchecksum": "8ebed83a7817fa0c", "zlib.zdeflate": "90921d009fdd674c", "zdeflate": "90921d009fdd674c", "string": "928c0ff6d8c69ec9", "hashlib.__init__": "96837bcc64032444", "__init__": "96837bcc64032444", "hashlib": "96837bcc64032444", "atom": "aa246c6e6aa30484", "w32.win32console": "bbdf3bbd4c3bc28c", "win32console": "bbdf3bbd4c3bc28c", "hashlib.__sha256": "c9d54a4158f7f5a8", "__sha256": "c9d54a4158f7f5a8", "viperio": "c9f4be41ca1cc2b4", "binascii": "d3917d97537f703c", "zlib.zhuff": "d541ade6afb689a5", "zhuff": "d541ade6afb689a5", "stdint": "f5522571bcce7bcb", "w32.win32base": "fc980acec33d69a7", "win32base": "fc980acec33d69a7"}
|
||||
@@ -1 +0,0 @@
|
||||
{"memhub": "04e5fe47ff2af528", "hashlib.__sha1": "0df65b8ed15664b0", "__sha1": "0df65b8ed15664b0", "hashlib.__md5": "19f8024d10c828e8", "__md5": "19f8024d10c828e8", "zlib.zdef": "1f6617c02fc8899d", "zdef": "1f6617c02fc8899d", "stdio": "285b6aa29a34754d", "zlib.pyzlib": "3e775aa83705b119", "pyzlib": "3e775aa83705b119", "zlib.zinflate": "451745df21e598af", "zinflate": "451745df21e598af", "main": "541a1ed9b8be53c8", "stdlib": "6c658cc728d0bbf4", "hashlib.__sha512": "6ff26590374ae6fc", "__sha512": "6ff26590374ae6fc", "testcheck": "748d0424e8976fa0", "zlib.zchecksum": "8ebed83a7817fa0c", "zchecksum": "8ebed83a7817fa0c", "zlib.zdeflate": "90921d009fdd674c", "zdeflate": "90921d009fdd674c", "string": "928c0ff6d8c69ec9", "hashlib.__init__": "96837bcc64032444", "__init__": "d63d2c2a2bd9bd2a", "hashlib": "96837bcc64032444", "atom": "aa246c6e6aa30484", "w32.win32console": "bbdf3bbd4c3bc28c", "win32console": "bbdf3bbd4c3bc28c", "hashlib.__sha256": "c9d54a4158f7f5a8", "__sha256": "c9d54a4158f7f5a8", "viperio": "c9f4be41ca1cc2b4", "zc.config": "cfc83b830141b00e", "config": "cfc83b830141b00e", "binascii": "d3917d97537f703c", "zlib.zhuff": "d541ade6afb689a5", "zhuff": "d541ade6afb689a5", "stdint": "f5522571bcce7bcb", "w32.win32base": "fc980acec33d69a7", "win32base": "fc980acec33d69a7", "w32.win32file": "f6b51804a0ba8ff0", "win32file": "f6b51804a0ba8ff0", "w32.fileio": "d137b1f3311f3a7f", "fileio": "d137b1f3311f3a7f", "w32.win32memory": "72e2d5ccb7cedcf1", "win32memory": "72e2d5ccb7cedcf1", "w32.win32process": "067c78e9f121dce3", "win32process": "067c78e9f121dce3", "w32.win32sync": "06f53cc594b4ac6c", "win32sync": "06f53cc594b4ac6c", "w32.winsock2": "6446627d4f07a1b5", "winsock2": "6446627d4f07a1b5", "zlib.__init__": "d63d2c2a2bd9bd2a", "zlib": "d63d2c2a2bd9bd2a"}
|
||||
@@ -1 +0,0 @@
|
||||
{"memhub": "04e5fe47ff2af528", "hashlib.__sha1": "0df65b8ed15664b0", "__sha1": "0df65b8ed15664b0", "hashlib.__md5": "19f8024d10c828e8", "__md5": "19f8024d10c828e8", "zlib.zdef": "1f6617c02fc8899d", "zdef": "1f6617c02fc8899d", "stdio": "285b6aa29a34754d", "zlib.pyzlib": "3e775aa83705b119", "pyzlib": "3e775aa83705b119", "zlib.zinflate": "451745df21e598af", "zinflate": "451745df21e598af", "main": "541a1ed9b8be53c8", "stdlib": "6c658cc728d0bbf4", "hashlib.__sha512": "6ff26590374ae6fc", "__sha512": "6ff26590374ae6fc", "testcheck": "748d0424e8976fa0", "zlib.zchecksum": "8ebed83a7817fa0c", "zchecksum": "8ebed83a7817fa0c", "zlib.zdeflate": "90921d009fdd674c", "zdeflate": "90921d009fdd674c", "string": "928c0ff6d8c69ec9", "hashlib.__init__": "96837bcc64032444", "__init__": "d63d2c2a2bd9bd2a", "hashlib": "96837bcc64032444", "atom": "aa246c6e6aa30484", "w32.win32console": "bbdf3bbd4c3bc28c", "win32console": "bbdf3bbd4c3bc28c", "hashlib.__sha256": "c9d54a4158f7f5a8", "__sha256": "c9d54a4158f7f5a8", "viperio": "c9f4be41ca1cc2b4", "zc.config": "cfc83b830141b00e", "config": "cfc83b830141b00e", "binascii": "d3917d97537f703c", "zlib.zhuff": "d541ade6afb689a5", "zhuff": "d541ade6afb689a5", "stdint": "f5522571bcce7bcb", "w32.win32base": "fc980acec33d69a7", "win32base": "fc980acec33d69a7", "w32.win32file": "f6b51804a0ba8ff0", "win32file": "f6b51804a0ba8ff0", "w32.fileio": "d137b1f3311f3a7f", "fileio": "d137b1f3311f3a7f", "w32.win32memory": "72e2d5ccb7cedcf1", "win32memory": "72e2d5ccb7cedcf1", "w32.win32process": "067c78e9f121dce3", "win32process": "067c78e9f121dce3", "w32.win32sync": "06f53cc594b4ac6c", "win32sync": "06f53cc594b4ac6c", "w32.winsock2": "6446627d4f07a1b5", "winsock2": "6446627d4f07a1b5", "zlib.__init__": "d63d2c2a2bd9bd2a", "zlib": "d63d2c2a2bd9bd2a"}
|
||||
@@ -1,29 +0,0 @@
|
||||
{
|
||||
"$schema": "https://raw.githubusercontent.com/TermiNexus/TransPyC/main/schemas/project-schema.json",
|
||||
"name": "TestProject2",
|
||||
"version": "1.0.0",
|
||||
"source_dir": "./App",
|
||||
"build_dir": "./.tpv_build",
|
||||
"compiler": {
|
||||
"cmd": "llc",
|
||||
"flags": ["-filetype=obj"]
|
||||
},
|
||||
"linker": {
|
||||
"cmd": "clang++",
|
||||
"flags": ["-lmsvcrt", "-lucrt", "-lpthread"],
|
||||
"output": "TestProject2.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,
|
||||
"sha1_slice_level": 1,
|
||||
"target": "llvm",
|
||||
"strict_mode": true
|
||||
}
|
||||
}
|
||||
@@ -1,136 +0,0 @@
|
||||
"""
|
||||
Auto-generated Python stub file from w32.win32process.vp
|
||||
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
|
||||
@@ -1,109 +0,0 @@
|
||||
"""
|
||||
Auto-generated Python stub file from w32.win32sync.vp
|
||||
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
|
||||
@@ -1 +0,0 @@
|
||||
285b6aa29a34754d|928c0ff6d8c69ec9|f5522571bcce7bcb
|
||||
@@ -1,30 +0,0 @@
|
||||
"""
|
||||
Auto-generated Python stub file from hashlib.__sha1.vp
|
||||
Module: hashlib.__sha1
|
||||
"""
|
||||
|
||||
|
||||
import string
|
||||
import t, c
|
||||
|
||||
SHA1_BLOCK_LEN: t.CDefine = 64
|
||||
SHA1_DIGEST_LEN: t.CDefine = 20
|
||||
|
||||
def sha1_rotl(x: t.CUInt32T, n: t.CInt) -> t.CUInt32T: pass
|
||||
|
||||
def sha1_f1(b: t.CUInt32T, c: t.CUInt32T, d: t.CUInt32T) -> t.CUInt32T: pass
|
||||
|
||||
def sha1_f2(b: t.CUInt32T, c: t.CUInt32T, d: t.CUInt32T) -> t.CUInt32T: pass
|
||||
|
||||
def sha1_f3(b: t.CUInt32T, c: t.CUInt32T, d: t.CUInt32T) -> t.CUInt32T: pass
|
||||
|
||||
|
||||
@t.Object
|
||||
class sha1:
|
||||
state: t.CArray[t.CUInt32T, 5]
|
||||
count: t.CUInt64T
|
||||
buf: t.CArray[t.CUInt8T, SHA1_BLOCK_LEN]
|
||||
def __init__(self: sha1) -> t.CInt: pass
|
||||
def transform(self: sha1, block: t.CUInt8T | t.CPtr) -> t.CInt: pass
|
||||
def update(self: sha1, s: str) -> t.CInt: pass
|
||||
def final(self: sha1, out: t.CArray[t.CUInt8T, SHA1_DIGEST_LEN]) -> t.CInt: pass
|
||||
@@ -1 +0,0 @@
|
||||
285b6aa29a34754d|928c0ff6d8c69ec9|f5522571bcce7bcb
|
||||
@@ -1,35 +0,0 @@
|
||||
"""
|
||||
Auto-generated Python stub file from hashlib.__md5.vp
|
||||
Module: hashlib.__md5
|
||||
"""
|
||||
|
||||
|
||||
import string
|
||||
import t, c
|
||||
|
||||
MD5_BLOCK_LEN: t.CDefine = 64 # 分组块大小
|
||||
MD5_DIGEST_LEN: t.CDefine = 16 # 摘要输出长度
|
||||
|
||||
def md5_F(x: t.CUInt32T, y: t.CUInt32T, z: t.CUInt32T) -> t.CUInt32T: pass
|
||||
|
||||
def md5_G(x: t.CUInt32T, y: t.CUInt32T, z: t.CUInt32T) -> t.CUInt32T: pass
|
||||
|
||||
def md5_H(x: t.CUInt32T, y: t.CUInt32T, z: t.CUInt32T) -> t.CUInt32T: pass
|
||||
|
||||
def md5_I(x: t.CUInt32T, y: t.CUInt32T, z: t.CUInt32T) -> t.CUInt32T: pass
|
||||
|
||||
def md5_rotl(x: t.CUInt32T, n: t.CInt) -> t.CUInt32T: pass
|
||||
|
||||
|
||||
md5_T: t.CExtern | t.CArray[t.CUInt32T, 64]
|
||||
md5_S: t.CExtern | t.CArray[t.CInt, 64]
|
||||
|
||||
@t.Object
|
||||
class md5:
|
||||
state: t.CArray[t.CUInt32T, 4]
|
||||
count: t.CUInt64T
|
||||
buf: t.CArray[t.CUInt8T, MD5_BLOCK_LEN]
|
||||
def __init__(self: md5) -> t.CInt: pass
|
||||
def transform(self: md5, block: t.CUInt8T | t.CPtr) -> t.CInt: pass
|
||||
def update(self: md5, s: str) -> t.CInt: pass
|
||||
def final(self: md5, out: t.CArray[t.CUInt8T, MD5_DIGEST_LEN]) -> t.CInt: pass
|
||||
@@ -1 +0,0 @@
|
||||
04e5fe47ff2af528|285b6aa29a34754d|6c658cc728d0bbf4|928c0ff6d8c69ec9|aa246c6e6aa30484|c9f4be41ca1cc2b4|f5522571bcce7bcb
|
||||
@@ -1,66 +0,0 @@
|
||||
"""
|
||||
Auto-generated Python stub file from zlib.zdef.vp
|
||||
Module: zlib.zdef
|
||||
"""
|
||||
|
||||
|
||||
from stdint import *
|
||||
import string
|
||||
import stdlib
|
||||
import memhub
|
||||
import t, c
|
||||
|
||||
ZDEFLATE_WINDOW_BITS: t.CDefine = 15
|
||||
ZDEFLATE_WINDOW_SIZE: t.CDefine = (1 << ZDEFLATE_WINDOW_BITS)
|
||||
ZDEFLATE_WINDOW_MASK: t.CDefine = (ZDEFLATE_WINDOW_SIZE - 1)
|
||||
ZDEFLATE_MIN_MATCH: t.CDefine = 3
|
||||
ZDEFLATE_MAX_MATCH: t.CDefine = 258
|
||||
ZDEFLATE_HASH_BITS: t.CDefine = 15
|
||||
ZDEFLATE_HASH_SIZE: t.CDefine = (1 << ZDEFLATE_HASH_BITS)
|
||||
ZDEFLATE_HASH_MASK: t.CDefine = (ZDEFLATE_HASH_SIZE - 1)
|
||||
ZDEFLATE_MAX_CODES: t.CDefine = 288
|
||||
ZDEFLATE_MAX_DIST_CODES: t.CDefine = 32
|
||||
ZDEFLATE_MAX_BITS: t.CDefine = 15
|
||||
ZDEFLATE_MAX_CODELEN_CODES: t.CDefine = 19
|
||||
ZDEFLATE_LIT_COUNT: t.CDefine = 286
|
||||
ZDEFLATE_DIST_COUNT: t.CDefine = 30
|
||||
ZDEFLATE_LEN_SYMBOLS_BASE: t.CDefine = 257
|
||||
ZDEFLATE_END_OF_BLOCK: t.CDefine = 256
|
||||
zdeflate_len_extra_bits: t.CExtern | t.CArray[t.CInt, 29]
|
||||
zdeflate_len_base: t.CExtern | t.CArray[t.CInt, 29]
|
||||
zdeflate_dist_extra_bits: t.CExtern | t.CArray[t.CInt, 30]
|
||||
zdeflate_dist_base: t.CExtern | t.CArray[t.CInt, 30]
|
||||
zdeflate_codelen_order: t.CExtern | t.CArray[int, 19]
|
||||
|
||||
@t.Object
|
||||
class zbit_writer:
|
||||
pool: memhub.MemManager | t.CPtr
|
||||
buf: BYTE | t.CPtr
|
||||
cap: t.CSizeT
|
||||
byte_pos: t.CSizeT
|
||||
bit_pos: t.CInt
|
||||
def __init__(self: zbit_writer, pool: memhub.MemManager | t.CPtr) -> t.CInt: pass
|
||||
def ensure(self: zbit_writer, need: t.CSizeT) -> t.CInt: pass
|
||||
def write_bits(self: zbit_writer, value: UINT, nbits: t.CInt) -> t.CInt: pass
|
||||
def write_bits_rev(self: zbit_writer, code: UINT, nbits: t.CInt) -> t.CInt: pass
|
||||
def stored_block(self: zbit_writer, data: UINT8PTR, length: t.CSizeT, final: t.CInt) -> t.CInt: pass
|
||||
def write_zlib_header(self: zbit_writer, wbits: t.CInt, level: t.CInt) -> t.CInt: pass
|
||||
def write_gzip_header(self: zbit_writer) -> t.CInt: pass
|
||||
def align(self: zbit_writer) -> t.CInt: pass
|
||||
def total(self: zbit_writer) -> t.CSizeT: pass
|
||||
def free(self: zbit_writer) -> t.CInt: pass
|
||||
def __del__(self: zbit_writer) -> t.CInt: pass
|
||||
@t.Object
|
||||
class zbit_reader:
|
||||
buf: BYTE | t.CPtr
|
||||
length: t.CSizeT
|
||||
byte_pos: t.CSizeT
|
||||
bit_pos: t.CInt
|
||||
def init(self: zbit_reader, buf: BYTE | t.CPtr, length: t.CSizeT) -> t.CInt: pass
|
||||
def read_bits(self: zbit_reader, nbits: t.CInt, out: UINTPTR) -> t.CInt: pass
|
||||
def read_bits_rev(self: zbit_reader, nbits: t.CInt, out: UINTPTR) -> t.CInt: pass
|
||||
def align(self: zbit_reader) -> t.CInt: pass
|
||||
|
||||
def zdef_alloc(pool: memhub.MemManager | t.CPtr, n: t.CSizeT) -> VOIDPTR: pass
|
||||
|
||||
def zdef_free(pool: memhub.MemManager | t.CPtr, p: VOIDPTR) -> t.CInt: pass
|
||||
Whitespace-only changes.
@@ -1,23 +0,0 @@
|
||||
"""
|
||||
Auto-generated Python stub file from stdio.vp
|
||||
Module: stdio
|
||||
"""
|
||||
|
||||
|
||||
import t, c
|
||||
|
||||
def printf(fmt: t.CConst | str, *args) -> int | t.State: pass
|
||||
|
||||
def fprintf(stream: bytes, fmt: t.CConst | str, *args) -> int | t.State: pass
|
||||
|
||||
def sprintf(buf: bytes, fmt: t.CConst | str, *args) -> int | t.State: pass
|
||||
|
||||
def snprintf(buf: bytes, size: t.CSizeT, fmt: t.CConst | str, *args) -> int | t.State: pass
|
||||
|
||||
def puts(s: t.CConst | str) -> int | t.State: pass
|
||||
|
||||
def fputs(s: t.CConst | str, stream: bytes) -> int | t.State: pass
|
||||
|
||||
def fgets(buf: bytes, size: int, stream: bytes) -> bytes | t.State: pass
|
||||
|
||||
def fflush(stream: bytes) -> int | t.State: pass
|
||||
@@ -1 +0,0 @@
|
||||
04e5fe47ff2af528|1f6617c02fc8899d|285b6aa29a34754d|451745df21e598af|6c658cc728d0bbf4|8ebed83a7817fa0c|90921d009fdd674c|928c0ff6d8c69ec9|aa246c6e6aa30484|c9f4be41ca1cc2b4|d541ade6afb689a5|f5522571bcce7bcb
|
||||
@@ -1,125 +0,0 @@
|
||||
"""
|
||||
Auto-generated Python stub file from zlib.pyzlib.vp
|
||||
Module: zlib.pyzlib
|
||||
"""
|
||||
|
||||
|
||||
from stdint import *
|
||||
import zlib.zdeflate as zdeflate
|
||||
import zlib.zinflate as zinflate
|
||||
import zlib.zchecksum as zchecksum
|
||||
import zlib.zdef as zdef
|
||||
import zlib.zhuff as zhuff
|
||||
import stdlib
|
||||
import string
|
||||
import memhub
|
||||
import t, c
|
||||
|
||||
Z_NO_COMPRESSION: t.CDefine = 0
|
||||
Z_BEST_SPEED: t.CDefine = 1
|
||||
Z_BEST_COMPRESSION: t.CDefine = 9
|
||||
Z_DEFAULT_COMPRESSION: t.CDefine = (-1)
|
||||
DEFLATED: t.CDefine = 8
|
||||
Z_NO_FLUSH: t.CDefine = 0
|
||||
Z_PARTIAL_FLUSH: t.CDefine = 1
|
||||
Z_SYNC_FLUSH: t.CDefine = 2
|
||||
Z_FULL_FLUSH: t.CDefine = 3
|
||||
Z_FINISH: t.CDefine = 4
|
||||
Z_BLOCK: t.CDefine = 5
|
||||
Z_TREES: t.CDefine = 6
|
||||
Z_DEFAULT_STRATEGY: t.CDefine = 0
|
||||
Z_FILTERED: t.CDefine = 1
|
||||
Z_HUFFMAN_ONLY: t.CDefine = 2
|
||||
Z_RLE: t.CDefine = 3
|
||||
Z_FIXED: t.CDefine = 4
|
||||
Z_OK: t.CDefine = 0
|
||||
Z_STREAM_END: t.CDefine = 1
|
||||
Z_NEED_DICT: t.CDefine = 2
|
||||
Z_ERRNO: t.CDefine = (-1)
|
||||
Z_STREAM_ERROR: t.CDefine = (-2)
|
||||
Z_DATA_ERROR: t.CDefine = (-3)
|
||||
Z_MEM_ERROR: t.CDefine = (-4)
|
||||
Z_BUF_ERROR: t.CDefine = (-5)
|
||||
Z_VERSION_ERROR: t.CDefine = (-6)
|
||||
MAX_WBITS: t.CDefine = 15
|
||||
DEF_BUF_SIZE: t.CDefine = 16384
|
||||
DEF_MEM_LEVEL: t.CDefine = 8
|
||||
ZLIB_VERSION: t.CDefine = "1.3.2"
|
||||
pyzlib_error_msg: t.CExtern | t.CArray[t.CChar, 512]
|
||||
pyzlib_error_code_val: t.CExtern | t.CInt
|
||||
|
||||
@t.Object
|
||||
class Compress:
|
||||
pool: memhub.MemManager | t.CPtr
|
||||
stream: VOIDPTR
|
||||
is_initialized: t.CInt
|
||||
is_finished: t.CInt
|
||||
level: t.CInt
|
||||
method: t.CInt
|
||||
wbits: t.CInt
|
||||
memLevel: t.CInt
|
||||
strategy: t.CInt
|
||||
zdict: BYTEPTR
|
||||
zdict_len: t.CSizeT
|
||||
last_pos: t.CSizeT
|
||||
input_buf: BYTEPTR
|
||||
input_buf_len: t.CSizeT
|
||||
input_buf_cap: t.CSizeT
|
||||
header_written: t.CInt
|
||||
def compress(self: Compress, data: BYTEPTR, data_len: t.CSizeT, out_len: t.CSizeT | t.CPtr) -> BYTEPTR: pass
|
||||
def flush(self: Compress, mode: t.CInt, out_len: t.CSizeT | t.CPtr) -> BYTEPTR: pass
|
||||
def copy(self: Compress) -> Compress | t.CPtr: pass
|
||||
def delete(self: Compress) -> t.CInt: pass
|
||||
def __del__(self: Compress) -> t.CInt: pass
|
||||
@t.Object
|
||||
class Decompress:
|
||||
pool: memhub.MemManager | t.CPtr
|
||||
stream: VOIDPTR
|
||||
is_initialized: t.CInt
|
||||
eof: t.CInt
|
||||
wbits: t.CInt
|
||||
zdict: BYTEPTR
|
||||
zdict_len: t.CSizeT
|
||||
_unused_data: BYTEPTR
|
||||
_unused_data_len: t.CSizeT
|
||||
_unused_data_cap: t.CSizeT
|
||||
_unconsumed_tail: BYTEPTR
|
||||
_unconsumed_tail_len: t.CSizeT
|
||||
_unconsumed_tail_cap: t.CSizeT
|
||||
input_buf: BYTEPTR
|
||||
input_buf_len: t.CSizeT
|
||||
input_buf_cap: t.CSizeT
|
||||
def decompress(self: Decompress, data: BYTEPTR, data_len: t.CSizeT, max_length: t.CSizeT, out_len: t.CSizeT | t.CPtr) -> BYTEPTR: pass
|
||||
def flush(self: Decompress, length: t.CSizeT, out_len: t.CSizeT | t.CPtr) -> BYTEPTR: pass
|
||||
def copy(self: Decompress) -> Decompress | t.CPtr: pass
|
||||
def delete(self: Decompress) -> t.CInt: pass
|
||||
def unused_data(self: Decompress, length: t.CSizeT | t.CPtr) -> BYTEPTR: pass
|
||||
def unconsumed_tail(self: Decompress, length: t.CSizeT | t.CPtr) -> BYTEPTR: pass
|
||||
|
||||
def set_error(code: int, msg: str) -> t.CInt: pass
|
||||
|
||||
def clone_bytes(pool: memhub.MemManager | t.CPtr, src: BYTEPTR, length: t.CSizeT) -> BYTEPTR: pass
|
||||
|
||||
def append_bytes(pool: memhub.MemManager | t.CPtr, buf: BYTE | t.CPtr[t.CPtr], length: t.CSizeT | t.CPtr, cap: t.CSizeT | t.CPtr, data: BYTEPTR, data_len: t.CSizeT) -> t.CInt: pass
|
||||
|
||||
def shrink_to_fit(pool: memhub.MemManager | t.CPtr, buf: BYTEPTR, length: t.CSizeT) -> BYTEPTR: pass
|
||||
|
||||
def runtime_version() -> str: pass
|
||||
|
||||
def get_error() -> str: pass
|
||||
|
||||
def get_error_code() -> t.CInt: pass
|
||||
|
||||
def clear_error() -> t.CInt: pass
|
||||
|
||||
def compress(pool: memhub.MemManager | t.CPtr, data: BYTEPTR, data_len: t.CSizeT, level: t.CInt, wbits: t.CInt, out_len: t.CSizeT | t.CPtr) -> BYTEPTR: pass
|
||||
|
||||
def decompress(pool: memhub.MemManager | t.CPtr, data: BYTEPTR, data_len: t.CSizeT, wbits: t.CInt, bufsize: t.CSizeT, out_len: t.CSizeT | t.CPtr) -> BYTEPTR: pass
|
||||
|
||||
def compressobj(pool: memhub.MemManager | t.CPtr, level: t.CInt, method: t.CInt, wbits: t.CInt, memLevel: t.CInt, strategy: t.CInt, zdict: BYTEPTR, zdict_len: t.CSizeT) -> Compress | t.CPtr: pass
|
||||
|
||||
def decompressobj(pool: memhub.MemManager | t.CPtr, wbits: t.CInt, zdict: BYTEPTR, zdict_len: t.CSizeT) -> Decompress | t.CPtr: pass
|
||||
|
||||
def zlib_adler32(data: BYTEPTR, length: t.CSizeT, value: t.CUnsignedLong) -> t.CUnsignedLong: pass
|
||||
|
||||
def zlib_crc32(data: BYTEPTR, length: t.CSizeT, value: t.CUnsignedLong) -> t.CUnsignedLong: pass
|
||||
@@ -1 +0,0 @@
|
||||
04e5fe47ff2af528|1f6617c02fc8899d|285b6aa29a34754d|6c658cc728d0bbf4|8ebed83a7817fa0c|928c0ff6d8c69ec9|aa246c6e6aa30484|c9f4be41ca1cc2b4|d541ade6afb689a5|f5522571bcce7bcb
|
||||
@@ -1,52 +0,0 @@
|
||||
"""
|
||||
Auto-generated Python stub file from zlib.zinflate.vp
|
||||
Module: zlib.zinflate
|
||||
"""
|
||||
|
||||
|
||||
from stdint import *
|
||||
import zlib.zchecksum as zchecksum
|
||||
import zlib.zdef as zdef
|
||||
import zlib.zhuff as zhuff
|
||||
import string
|
||||
import memhub
|
||||
import t, c
|
||||
|
||||
@t.Object
|
||||
class zinflate_stream:
|
||||
pool: memhub.MemManager | t.CPtr
|
||||
reader: zdef.zbit_reader
|
||||
window: BYTEPTR
|
||||
window_pos: t.CInt
|
||||
window_size: t.CInt
|
||||
wbits: t.CInt
|
||||
is_finished: t.CInt
|
||||
is_initialized: t.CInt
|
||||
header_parsed: t.CInt
|
||||
is_gzip: t.CInt
|
||||
adler: t.CUInt32T
|
||||
crc: t.CUInt32T
|
||||
output: BYTEPTR
|
||||
output_len: t.CSizeT
|
||||
output_cap: t.CSizeT
|
||||
input_data: t.CConst | BYTEPTR
|
||||
input_len: t.CSizeT
|
||||
input_pos: t.CSizeT
|
||||
max_length: t.CSizeT
|
||||
def __init__(self: zinflate_stream) -> t.CInt: pass
|
||||
def output_byte(self: zinflate_stream, byte: BYTE) -> t.CInt: pass
|
||||
def parse_header(self: zinflate_stream) -> t.CInt: pass
|
||||
def read_bits_from_input(self: zinflate_stream, nbits: t.CInt, out: UINTPTR) -> t.CInt: pass
|
||||
def read_huffman(self: zinflate_stream, dt: zhuff.zhuff_decode_tree | t.CPtr) -> t.CInt: pass
|
||||
def inflate_block_stored(self: zinflate_stream) -> t.CInt: pass
|
||||
def inflate_block_fixed(self: zinflate_stream) -> t.CInt: pass
|
||||
def inflate_block_dynamic(self: zinflate_stream) -> t.CInt: pass
|
||||
def inflate_stream(self: zinflate_stream) -> t.CInt: pass
|
||||
def decompress(self: zinflate_stream, data: UINT8PTR, length: t.CSizeT, max_length: t.CSizeT, out: t.CUInt8T | t.CPtr[t.CPtr], out_len: t.CSizeT | t.CPtr) -> t.CInt: pass
|
||||
def set_dictionary(self: zinflate_stream, dict: UINT8PTR, length: t.CSizeT) -> t.CInt: pass
|
||||
def copy(self: zinflate_stream) -> zinflate_stream | t.CPtr: pass
|
||||
def destroy(self: zinflate_stream) -> t.CInt: pass
|
||||
|
||||
def zinflate_one_shot(pool: memhub.MemManager | t.CPtr, data: UINT8PTR, length: t.CSizeT, wbits: t.CInt, bufsize: t.CSizeT, out_len: t.CSizeT | t.CPtr) -> t.CUInt8T | t.CPtr: pass
|
||||
|
||||
def zinflate_create(pool: memhub.MemManager | t.CPtr, wbits: t.CInt) -> zinflate_stream | t.CPtr: pass
|
||||
@@ -1 +0,0 @@
|
||||
{}
|
||||
@@ -1,16 +0,0 @@
|
||||
"""
|
||||
Auto-generated Python stub file from main.vp
|
||||
Module: main
|
||||
"""
|
||||
|
||||
|
||||
from stdint import *
|
||||
import w32.win32console
|
||||
import config
|
||||
import hashlib
|
||||
import binascii
|
||||
import zlib.pyzlib as zp
|
||||
import t, c
|
||||
import testcheck
|
||||
|
||||
def main() -> t.CInt | t.CExport: pass
|
||||
@@ -1,86 +0,0 @@
|
||||
"""
|
||||
Auto-generated Python stub file from w32.winsock2.vp
|
||||
Module: w32.winsock2
|
||||
"""
|
||||
|
||||
|
||||
import t, c
|
||||
from stdint import *
|
||||
from w32.win32base import *
|
||||
|
||||
WINSOCK_VERSION: t.CDefine = 0x0202 # 2.2
|
||||
AF_INET: t.CDefine = 2
|
||||
AF_INET6: t.CDefine = 23
|
||||
SOCK_STREAM: t.CDefine = 1 # TCP
|
||||
SOCK_DGRAM: t.CDefine = 2 # UDP
|
||||
SOCK_RAW: t.CDefine = 3 # 原始套接字
|
||||
IPPROTO_TCP: t.CDefine = 6
|
||||
IPPROTO_UDP: t.CDefine = 17
|
||||
SOL_SOCKET: t.CDefine = 0xFFFF # WinSock2 值
|
||||
SO_RCVTIMEO: t.CDefine = 0x1006 # WinSock2 值
|
||||
SO_SNDTIMEO: t.CDefine = 0x1005 # WinSock2 值
|
||||
SO_REUSEADDR: t.CDefine = 0x0004 # WinSock2 值
|
||||
INADDR_ANY: t.CDefine = 0
|
||||
SOCKET_ERROR: t.CDefine = -1
|
||||
INVALID_SOCKET: t.CDefine = 0xFFFFFFFF # WinSock2: ~0
|
||||
MSG_NOSIGNAL: t.CDefine = 0 # Windows 不支持，设为 0
|
||||
SD_SEND: t.CDefine = 1
|
||||
SD_RECV: t.CDefine = 0
|
||||
SD_BOTH: t.CDefine = 2
|
||||
|
||||
class WSASocketAddr:
|
||||
family: u16
|
||||
port: u16
|
||||
addr: u32
|
||||
zero: u64
|
||||
class WSAData:
|
||||
wVersion: WORD
|
||||
wHighVersion: WORD
|
||||
szDescription: BYTE
|
||||
szSystemStatus: BYTE
|
||||
iMaxSockets: u16
|
||||
iMaxUdpDg: u16
|
||||
lpVendorInfo: CHARPTR
|
||||
class WSAHostEnt:
|
||||
h_name: CHARPTR
|
||||
h_aliases: CHARPTR
|
||||
h_addrtype: SHORT
|
||||
h_length: SHORT
|
||||
h_addr_list: CHARPTR
|
||||
class WinTimeVal:
|
||||
tv_sec: LONG
|
||||
tv_usec: LONG
|
||||
|
||||
def WSAStartup(wVersionRequested: WORD, lpWSAData: WSAData | t.CPtr) -> INT | t.State: pass
|
||||
|
||||
def WSACleanup() -> INT | t.State: pass
|
||||
|
||||
def WSAGetLastError() -> INT | t.State: pass
|
||||
|
||||
def socket(family: INT, type: INT, protocol: INT) -> u64 | t.State: pass
|
||||
|
||||
def closesocket(s: u64) -> INT | t.State: pass
|
||||
|
||||
def connect(s: u64, name: WSASocketAddr | t.CPtr, namelen: INT) -> INT | t.State: pass
|
||||
|
||||
def send(s: u64, buf: t.CVoid | t.CPtr, len: INT, flags: INT) -> INT | t.State: pass
|
||||
|
||||
def recv(s: u64, buf: t.CVoid | t.CPtr, len: INT, flags: INT) -> INT | t.State: pass
|
||||
|
||||
def bind(s: u64, name: WSASocketAddr | t.CPtr, namelen: INT) -> INT | t.State: pass
|
||||
|
||||
def listen(s: u64, backlog: INT) -> INT | t.State: pass
|
||||
|
||||
def accept(s: u64, addr: WSASocketAddr | t.CPtr, addrlen: INT | t.CPtr) -> u64 | t.State: pass
|
||||
|
||||
def setsockopt(s: u64, level: INT, optname: INT, optval: t.CVoid | t.CPtr, optlen: INT) -> INT | t.State: pass
|
||||
|
||||
def shutdown(s: u64, how: INT) -> INT | t.State: pass
|
||||
|
||||
def gethostbyname(name: t.CChar | t.CConst | t.CPtr) -> WSAHostEnt | t.CPtr | t.State: pass
|
||||
|
||||
def ntohs(netshort: u16) -> u16 | t.State: pass
|
||||
|
||||
def htons(hostshort: u16) -> u16 | t.State: pass
|
||||
|
||||
def inet_addr(cp: t.CChar | t.CConst | t.CPtr) -> u32 | t.State: pass
|
||||
@@ -1 +0,0 @@
|
||||
f5522571bcce7bcb
|
||||
@@ -1,22 +0,0 @@
|
||||
"""
|
||||
Auto-generated Python stub file from stdlib.vp
|
||||
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
|
||||
|
||||
def exit(status: int) -> t.State: pass
|
||||
Whitespace-only changes.
@@ -1,39 +0,0 @@
|
||||
"""
|
||||
Auto-generated Python stub file from hashlib.__sha512.vp
|
||||
Module: hashlib.__sha512
|
||||
"""
|
||||
|
||||
|
||||
import t, c
|
||||
|
||||
SHA512_BLOCK_LEN: t.CDefine = 128
|
||||
SHA512_DIGEST_LEN: t.CDefine = 64
|
||||
|
||||
def sha512_ror(x: t.CUInt64T, n: int) -> t.CUInt64T: pass
|
||||
|
||||
def sha512_shr(x: t.CUInt64T, n: int) -> t.CUInt64T: pass
|
||||
|
||||
def sha512_Ch(x: t.CUInt64T, y: t.CUInt64T, z: t.CUInt64T) -> t.CUInt64T: pass
|
||||
|
||||
def sha512_Maj(x: t.CUInt64T, y: t.CUInt64T, z: t.CUInt64T) -> t.CUInt64T: pass
|
||||
|
||||
def sha512_BigSigma0(x: t.CUInt64T) -> t.CUInt64T: pass
|
||||
|
||||
def sha512_BigSigma1(x: t.CUInt64T) -> t.CUInt64T: pass
|
||||
|
||||
def sha512_Sigma0(x: t.CUInt64T) -> t.CUInt64T: pass
|
||||
|
||||
def sha512_Sigma1(x: t.CUInt64T) -> t.CUInt64T: pass
|
||||
|
||||
|
||||
sha512_K: t.CExtern | t.CArray[t.CUInt64T, 80]
|
||||
|
||||
@t.Object
|
||||
class sha512:
|
||||
state: t.CArray[t.CUInt64T, 8]
|
||||
count: t.CArray[t.CUInt64T, 2]
|
||||
buf: t.CArray[t.CUInt8T, SHA512_BLOCK_LEN]
|
||||
def __init__(self: sha512) -> t.CInt: pass
|
||||
def transform(self: sha512, block: t.CArray[t.CUInt8T, SHA512_BLOCK_LEN]) -> t.CInt: pass
|
||||
def update(self: sha512, s: str) -> t.CInt: pass
|
||||
def final(self: sha512, out: t.CArray[t.CUInt8T, SHA512_DIGEST_LEN]) -> t.CInt: pass
|
||||
Loaded 100 of 195 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user