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

refactor: 全量迁移 includes 到新规范语法

Browse Source 
按根目录 新规范 迁移 R1/R2/R3/R4/R6/R7/R8/R9：指针 T* 后缀、内建类型短别名、c.Addr/c.Deref 单目化、c.Asm 改 __asm__、t.CDefine 改 define 软关键字、t.CEnum 改 enum。R4 对内建 cast 多参实参保留 c.Deref 原写法（单目化会致 TPC 类型退化）。验证：includes 52/52 编译通过，TransPyV 自举产物顺序回归 77/77 全通过。
This commit is contained in:
TermiNexus committed 2026-10-05 09:04:46 +08:00
1 parent aecdf27132
commit e80284a6d5
88 files changed
+4474 -4474
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

zlib/zinflate.vp
+97 -97
View File
@@ -12,18 +12,18 @@ class zinflate_stream:
reader: zdef.zbit_reader
window: BYTEPTR
window_pos: t.CInt
window_size: t.CInt
window_pos: int
window_size: int
wbits: t.CInt
is_finished: t.CInt
is_initialized: t.CInt
wbits: int
is_finished: int
is_initialized: int
header_parsed: t.CInt
is_gzip: t.CInt
header_parsed: int
is_gzip: int
adler: t.CUInt32T
crc: t.CUInt32T
adler: uint32
crc: uint32
output: BYTEPTR
output_len: sizet
@@ -56,7 +56,7 @@ class zinflate_stream:
self.window_pos += 1
def parse_header(self) -> t.CInt:
def parse_header(self) -> int:
if self.header_parsed: return 0
if self.wbits < 0:
self.header_parsed = 1
@@ -87,14 +87,14 @@ class zinflate_stream:
else:
self.is_gzip = 0
if (b0 * 256 + b1) % 31 != 0: return -3
cm: t.CInt = b0 & 0x0F
cm: int = b0 & 0x0F
if cm != 8: return -3
self.input_pos += 2
self.header_parsed = 1
return 0
def read_bits_from_input(self, nbits: t.CInt, out: UINTPTR) -> t.CInt:
def read_bits_from_input(self, nbits: int, out: UINTPTR) -> int:
val: UINT = 0
for i in range(nbits):
if self.input_pos >= self.input_len: return -3
@@ -104,21 +104,21 @@ class zinflate_stream:
if self.reader.bit_pos == 8:
self.reader.bit_pos = 0
self.input_pos += 1
c.Set(c.Deref(out), val)
c.Set(*out, val)
return 0
def read_huffman(self, dt: rawptr[zhuff.zhuff_decode_tree]) -> t.CInt:
def read_huffman(self, dt: rawptr[zhuff.zhuff_decode_tree]) -> int:
node: int = dt.root
while dt.nodes[node].symbol == -1:
bit: UINT
if self.read_bits_from_input(1, c.Addr(bit)) != 0: return -1
dir: int = t.CInt(bit)
if self.read_bits_from_input(1, &bit) != 0: return -1
dir: int = int(bit)
if dt.nodes[node].children[dir] == -1: return -3
node = dt.nodes[node].children[dir]
return dt.nodes[node].symbol
def inflate_block_stored(self) -> t.CInt:
def inflate_block_stored(self) -> int:
if self.reader.bit_pos != 0:
self.reader.bit_pos = 0
self.input_pos += 1
@@ -128,14 +128,14 @@ class zinflate_stream:
self.input_pos += 4
if (length ^ nlen) != 0xFFFF: return -3
if self.input_pos + length > self.input_len: return -3
i: t.CUnsignedInt
i: uint
for i in range(length):
self.output_byte(self.input_data[self.input_pos])
self.input_pos += 1
return 0
def inflate_block_fixed(self) -> t.CInt:
def inflate_block_fixed(self) -> int:
lit_tree = zhuff.zhuff_tree()
dist_tree = zhuff.zhuff_tree()
lit_tree.build_fixed_lit_tree()
@@ -149,14 +149,14 @@ class zinflate_stream:
return -4
string.memset(lit_dt, 0, zhuff.zhuff_decode_tree.__sizeof__())
string.memset(dist_dt, 0, zhuff.zhuff_decode_tree.__sizeof__())
lit_dt.build_decode_tree(c.Addr(lit_tree))
dist_dt.build_decode_tree(c.Addr(dist_tree))
lit_dt.build_decode_tree(&lit_tree)
dist_dt.build_decode_tree(&dist_tree)
result: t.CInt = 0
result: int = 0
while True:
if self.max_length > 0 and self.output_len >= self.max_length: break
sym: t.CInt = self.read_huffman(lit_dt)
sym: int = self.read_huffman(lit_dt)
if sym < 0:
result = -3
break
@@ -164,35 +164,35 @@ class zinflate_stream:
if sym < 256:
self.output_byte(BYTE(sym))
else:
len_idx: t.CInt = sym - 257
len_idx: int = sym - 257
if len_idx < 0 or len_idx >= 29:
result = -3
break
length: t.CInt = zdef.zdeflate_len_base[len_idx]
extra: t.CInt = zdef.zdeflate_len_extra_bits[len_idx]
length: int = zdef.zdeflate_len_base[len_idx]
extra: int = zdef.zdeflate_len_extra_bits[len_idx]
if extra > 0:
extra_val: UINT
if self.read_bits_from_input(extra, c.Addr(extra_val)) != 0:
if self.read_bits_from_input(extra, &extra_val) != 0:
result = -3
break
length += extra_val
dist_sym: t.CInt = self.read_huffman(dist_dt)
dist_sym: int = self.read_huffman(dist_dt)
if dist_sym < 0 or dist_sym >= 30:
result = -3
break
dist: t.CInt = zdef.zdeflate_dist_base[dist_sym]
dist: int = zdef.zdeflate_dist_base[dist_sym]
extra = zdef.zdeflate_dist_extra_bits[dist_sym]
if extra > 0:
extra_val: UINT
if self.read_bits_from_input(extra, c.Addr(extra_val)) != 0:
if self.read_bits_from_input(extra, &extra_val) != 0:
result = -3
break
dist += extra_val
for i in range(length):
if self.max_length > 0 and self.output_len >= self.max_length: break
src_pos: t.CInt = (self.window_pos - dist) & (zdef.ZDEFLATE_WINDOW_SIZE - 1)
src_pos: int = (self.window_pos - dist) & (zdef.ZDEFLATE_WINDOW_SIZE - 1)
byte: BYTE = self.window[src_pos]
self.output_byte(byte)
@@ -201,38 +201,38 @@ class zinflate_stream:
return result
def inflate_block_dynamic(self) -> t.CInt:
def inflate_block_dynamic(self) -> int:
hlit_val: UINT
hdist_val: UINT
hclen_val: UINT
if self.read_bits_from_input(5, c.Addr(hlit_val)) != 0: return -3
if self.read_bits_from_input(5, c.Addr(hdist_val)) != 0: return -3
if self.read_bits_from_input(4, c.Addr(hclen_val)) != 0: return -3
if self.read_bits_from_input(5, &hlit_val) != 0: return -3
if self.read_bits_from_input(5, &hdist_val) != 0: return -3
if self.read_bits_from_input(4, &hclen_val) != 0: return -3
hlit: t.CInt = t.CInt(hlit_val) + 257
hdist: t.CInt = t.CInt(hdist_val) + 1
hclen: t.CInt = t.CInt(hclen_val) + 4
hlit: int = int(hlit_val) + 257
hdist: int = int(hdist_val) + 1
hclen: int = int(hclen_val) + 4
cl_lengths: t.CArray[t.CInt, 19]
cl_lengths: t.CArray[int, 19]
string.memset(cl_lengths, 0, cl_lengths.__sizeof__())
for i in range(hclen):
len_val: UINT
if self.read_bits_from_input(3, c.Addr(len_val)) != 0: return -3
cl_lengths[zdef.zdeflate_codelen_order[i]] = t.CInt(len_val)
if self.read_bits_from_input(3, &len_val) != 0: return -3
cl_lengths[zdef.zdeflate_codelen_order[i]] = int(len_val)
cl_tree = zhuff.zhuff_tree()
cl_tree.build_tree_from_lengths(cl_lengths, 19, 7)
cl_dt = zhuff.zhuff_decode_tree()
cl_dt.build_decode_tree(c.Addr(cl_tree))
cl_dt.build_decode_tree(&cl_tree)
total: t.CInt = hlit + hdist
all_lengths: t.CInt | t.CPtr = zdef.zdef_alloc(self.pool, total * int.__sizeof__())
total: int = hlit + hdist
all_lengths: int* = zdef.zdef_alloc(self.pool, total * int.__sizeof__())
if not all_lengths: return -4
idx: t.CInt = 0
idx: int = 0
while idx < total:
sym: t.CInt = self.read_huffman(c.Addr(cl_dt))
sym: int = self.read_huffman(&cl_dt)
if sym < 0 or sym > 18:
zdef.zdef_free(self.pool, all_lengths)
return -3
@@ -241,41 +241,41 @@ class zinflate_stream:
idx += 1
elif sym == 16:
rep: UINT
if self.read_bits_from_input(2, c.Addr(rep)) != 0:
if self.read_bits_from_input(2, &rep) != 0:
zdef.zdef_free(self.pool, all_lengths)
return -3
rep += 3
if idx == 0 or idx + rep > total:
zdef.zdef_free(self.pool, all_lengths)
return -3
prev: t.CInt = all_lengths[idx - 1]
i: t.CUnsignedInt
prev: int = all_lengths[idx - 1]
i: uint
for i in range(rep):
all_lengths[idx] = prev
idx += 1
elif sym == 17:
rep: t.CUnsignedInt
if self.read_bits_from_input(3, c.Addr(rep)) != 0:
rep: uint
if self.read_bits_from_input(3, &rep) != 0:
zdef.zdef_free(self.pool, all_lengths)
return -3
rep += 3
if idx + rep > total:
zdef.zdef_free(self.pool, all_lengths)
return -3
i: t.CUnsignedInt
i: uint
for i in range(rep):
all_lengths[idx] = 0
idx += 1
else:
rep: t.CUnsignedInt
if self.read_bits_from_input(7, c.Addr(rep)) != 0:
rep: uint
if self.read_bits_from_input(7, &rep) != 0:
zdef.zdef_free(self.pool, all_lengths)
return -3
rep += 11
if idx + rep > total:
zdef.zdef_free(self.pool, all_lengths)
return -3
i: t.CUnsignedInt
i: uint
for i in range(rep):
all_lengths[idx] = 0
idx += 1
@@ -283,13 +283,13 @@ class zinflate_stream:
lit_tree = zhuff.zhuff_tree()
dist_tree = zhuff.zhuff_tree()
lit_lengths: t.CArray[t.CInt, 288]
lit_lengths: t.CArray[int, 288]
string.memset(lit_lengths, 0, lit_lengths.__sizeof__())
for i in range(hlit):
lit_lengths[i] = all_lengths[i]
lit_tree.build_tree_from_lengths(lit_lengths, hlit, zdef.ZDEFLATE_MAX_BITS)
dist_lengths: t.CArray[t.CInt, 32]
dist_lengths: t.CArray[int, 32]
string.memset(dist_lengths, 0, dist_lengths.__sizeof__())
for i in range(hdist):
dist_lengths[i] = all_lengths[hlit + i]
@@ -299,49 +299,49 @@ class zinflate_stream:
lit_dt = zhuff.zhuff_decode_tree()
dist_dt = zhuff.zhuff_decode_tree()
lit_dt.build_decode_tree(c.Addr(lit_tree))
dist_dt.build_decode_tree(c.Addr(dist_tree))
lit_dt.build_decode_tree(&lit_tree)
dist_dt.build_decode_tree(&dist_tree)
while True:
if self.max_length > 0 and self.output_len >= self.max_length: return 0
sym: t.CInt = self.read_huffman(c.Addr(lit_dt))
sym: int = self.read_huffman(&lit_dt)
if sym < 0: return -3
if sym == 256: return 0
if sym < 256:
self.output_byte(BYTE(sym))
else:
len_idx: t.CInt = sym - 257
len_idx: int = sym - 257
if len_idx < 0 or len_idx >= 29: return -3
length: t.CInt = zdef.zdeflate_len_base[len_idx]
extra: t.CInt = zdef.zdeflate_len_extra_bits[len_idx]
length: int = zdef.zdeflate_len_base[len_idx]
extra: int = zdef.zdeflate_len_extra_bits[len_idx]
if extra > 0:
extra_val: UINT
if self.read_bits_from_input(extra, c.Addr(extra_val)) != 0: return -3
if self.read_bits_from_input(extra, &extra_val) != 0: return -3
length += extra_val
dist_sym: t.CInt = self.read_huffman(c.Addr(dist_dt))
dist_sym: int = self.read_huffman(&dist_dt)
if dist_sym < 0 or dist_sym >= 30: return -3
dist: t.CInt = zdef.zdeflate_dist_base[dist_sym]
dist: int = zdef.zdeflate_dist_base[dist_sym]
extra = zdef.zdeflate_dist_extra_bits[dist_sym]
if extra > 0:
extra_val: UINT
if self.read_bits_from_input(extra, c.Addr(extra_val)) != 0: return -3
if self.read_bits_from_input(extra, &extra_val) != 0: return -3
dist += extra_val
for i in range(length):
if self.max_length > 0 and self.output_len >= self.max_length: return 0
src_pos: t.CInt = (self.window_pos - dist) & (zdef.ZDEFLATE_WINDOW_SIZE - 1)
src_pos: int = (self.window_pos - dist) & (zdef.ZDEFLATE_WINDOW_SIZE - 1)
byte: BYTE = self.window[src_pos]
self.output_byte(byte)
def inflate_stream(self) -> t.CInt:
err: t.CInt = self.parse_header()
def inflate_stream(self) -> int:
err: int = self.parse_header()
if err != 0: return err
while not self.is_finished:
bfinal_val: UINT
btype_val: UINT
if self.read_bits_from_input(1, c.Addr(bfinal_val)) != 0: return -3
if self.read_bits_from_input(2, c.Addr(btype_val)) != 0: return -3
bfinal: t.CInt = t.CInt(bfinal_val)
btype: t.CInt = t.CInt(btype_val)
if self.read_bits_from_input(1, &bfinal_val) != 0: return -3
if self.read_bits_from_input(2, &btype_val) != 0: return -3
bfinal: int = int(bfinal_val)
btype: int = int(btype_val)
if btype == 0:
err = self.inflate_block_stored()
elif btype == 1:
@@ -358,20 +358,20 @@ class zinflate_stream:
self.reader.bit_pos = 0
self.input_pos += 1
if self.input_pos + 8 <= self.input_len:
self.crc = ((t.CUInt32T(self.input_data[self.input_pos + 0]) << 0) |
(t.CUInt32T(self.input_data[self.input_pos + 1]) << 8) |
(t.CUInt32T(self.input_data[self.input_pos + 2]) << 16) |
(t.CUInt32T(self.input_data[self.input_pos + 3]) << 24))
self.crc = ((uint32(self.input_data[self.input_pos + 0]) << 0) |
(uint32(self.input_data[self.input_pos + 1]) << 8) |
(uint32(self.input_data[self.input_pos + 2]) << 16) |
(uint32(self.input_data[self.input_pos + 3]) << 24))
self.input_pos += 8
elif self.wbits >= 0:
if self.reader.bit_pos != 0:
self.reader.bit_pos = 0
self.input_pos += 1
if self.input_pos + 4 <= self.input_len:
self.adler = ((t.CUInt32T(self.input_data[self.input_pos + 0]) << 24) |
(t.CUInt32T(self.input_data[self.input_pos + 1]) << 16) |
(t.CUInt32T(self.input_data[self.input_pos + 2]) << 8) |
(t.CUInt32T(self.input_data[self.input_pos + 3]) << 0))
self.adler = ((uint32(self.input_data[self.input_pos + 0]) << 24) |
(uint32(self.input_data[self.input_pos + 1]) << 16) |
(uint32(self.input_data[self.input_pos + 2]) << 8) |
(uint32(self.input_data[self.input_pos + 3]) << 0))
self.input_pos += 4
return 0
@@ -384,7 +384,7 @@ class zinflate_stream:
# 同形先例：includes/w32/win32sync.vp:65 `Context: VOIDPTR | t.CPtr`、
# includes/posix.vp:199 `argv: CHARPTR | t.CPtr`。
def decompress(self, data: UINT8PTR, length: sizet,
max_length: sizet, out: BYTEPTR | t.CPtr, out_len: sizet*) -> t.CInt:
max_length: sizet, out: BYTEPTR*, out_len: sizet*) -> int:
if not self.is_initialized: return -2
self.input_data = data
self.input_len = length
@@ -392,30 +392,30 @@ class zinflate_stream:
self.reader.bit_pos = 0
self.output_len = 0
self.max_length = max_length
err: t.CInt = self.inflate_stream()
err: int = self.inflate_stream()
if err != 0: return err
c.Set(c.Deref(out_len), self.output_len)
c.Set(*out_len, self.output_len)
if self.output_len == 0:
c.Set(c.Deref(out), UINT8PTR(zdef.zdef_alloc(self.pool, 1)))
c.Set(*out, UINT8PTR(zdef.zdef_alloc(self.pool, 1)))
else:
dst: UINT8PTR = UINT8PTR(zdef.zdef_alloc(self.pool, self.output_len))
c.Set(c.Deref(out), dst)
c.Set(*out, dst)
if dst:
string.memcpy(dst, self.output, self.output_len)
return 0
def set_dictionary(self, dict: UINT8PTR, length: sizet) -> t.CInt:
def set_dictionary(self, dict: UINT8PTR, length: sizet) -> int:
if not dict: return -2
use: sizet = length
if use > zdef.ZDEFLATE_WINDOW_SIZE:
dict += length - zdef.ZDEFLATE_WINDOW_SIZE
use = zdef.ZDEFLATE_WINDOW_SIZE
string.memcpy(self.window, dict, use)
self.window_pos = t.CInt(use)
self.window_pos = int(use)
return 0
def copy(self) -> zinflate_stream | t.CPtr:
z: zinflate_stream | t.CPtr = zdef.zdef_alloc(self.pool, zinflate_stream.__sizeof__())
def copy(self) -> zinflate_stream*:
z: zinflate_stream* = zdef.zdef_alloc(self.pool, zinflate_stream.__sizeof__())
if not z: return None
string.memcpy(z, self, zinflate_stream.__sizeof__())
z.window = BYTEPTR(zdef.zdef_alloc(self.pool, zdef.ZDEFLATE_WINDOW_SIZE))
@@ -435,18 +435,18 @@ class zinflate_stream:
def zinflate_one_shot(pool: rawptr[memhub.MemManager], data: UINT8PTR, length: sizet,
wbits: t.CInt, bufsize: sizet, out_len: sizet*) -> t.CUInt8T | t.CPtr:
s: zinflate_stream | t.CPtr = zinflate_create(pool, wbits)
wbits: int, bufsize: sizet, out_len: sizet*) -> uint8*:
s: zinflate_stream* = zinflate_create(pool, wbits)
if not s: return None
out: t.CUInt8T | t.CPtr = None
err: t.CInt = s.decompress(data, length, 0, c.Addr(out), out_len)
out: uint8* = None
err: int = s.decompress(data, length, 0, &out, out_len)
s.destroy()
if err != 0: return None
return out
def zinflate_create(pool: rawptr[memhub.MemManager], wbits: t.CInt) -> zinflate_stream | t.CPtr:
s: zinflate_stream | t.CPtr = zdef.zdef_alloc(pool, zinflate_stream.__sizeof__())
def zinflate_create(pool: rawptr[memhub.MemManager], wbits: int) -> zinflate_stream*:
s: zinflate_stream* = zdef.zdef_alloc(pool, zinflate_stream.__sizeof__())
if not s: return None
string.memset(s, 0, zinflate_stream.__sizeof__())
s.pool = pool