diff --git a/_dict.vp b/_dict.vp index 1b51756..2b7cd75 100644 --- a/_dict.vp +++ b/_dict.vp @@ -58,7 +58,7 @@ class dict: def _find(self, key: str) -> sizet: """Find index of target key; returns __count__ if not found""" - for i in range(self.__count__): + for i in range(int(self.__count__)): # Element address: `T*(base + byte_offset)`. rawptr is i8* and `+` scales by 1 byte, byte-identical to the old uint64(base)+n form (no integer round-trip). # Same form below (__getitem__/_set_variant_raw/get/get_vtype/__next__/to_json), not annotated again. key_ptr: str* = str*(self.__keys__ + i * 8) @@ -199,7 +199,7 @@ class dict: """Convert dict instance to JsonValue object (JSON_OBJECT). Automatically select corresponding JSON value type according to Variant tag.""" obj: json.JsonValue* = json.object(pool) - for i in range(self.__count__): + for i in range(int(self.__count__)): key_ptr: str* = str*(self.__keys__ + i * 8) vtype_ptr: int* = int*(self.__values__ + i * _VARIANT_SIZE) val_ptr: str* = str*(self.__values__ + i * _VARIANT_SIZE + 8) @@ -243,7 +243,7 @@ class dict: if cur.vtype == 2: # JSON_INT storage: rawptr = self.__mbuddy__.alloc(8) ip: int* = int*(storage) - ip[0] = cur.int_val + ip[0] = int(cur.int_val) self._set_variant_raw(cur.key, VARIANT_INT, storage) elif cur.vtype == 4: # JSON_STRING self._set_variant_raw(cur.key, VARIANT_STR, cur.str_val) diff --git a/argparse.vp b/argparse.vp index 51c2225..ae99d26 100644 --- a/argparse.vp +++ b/argparse.vp @@ -191,7 +191,7 @@ class ArgumentParser: def _find_long(self, token: str) -> int: """Exact match for long option name""" - for i in range(self._arg_count): + for i in range(int(self._arg_count)): arg: Argument* = self._get_arg(i) if string.strcmp(arg.name, token) == 0: return i @@ -199,7 +199,7 @@ class ArgumentParser: def _find_long_prefix(self, token: str) -> int: """Match prefix for --name=value syntax""" - for i in range(self._arg_count): + for i in range(int(self._arg_count)): arg: Argument* = self._get_arg(i) name_len: int = int(string.strlen(arg.name)) # 显式 cast：避免 64→32 隐式窄化 if string.strncmp(token, arg.name, name_len) == 0: @@ -208,7 +208,7 @@ class ArgumentParser: return -1 def _find_short(self, token: str) -> int: - for i in range(self._arg_count): + for i in range(int(self._arg_count)): arg: Argument* = self._get_arg(i) if arg.short_name is not None: if string.strcmp(arg.short_name, token) == 0: @@ -217,7 +217,7 @@ class ArgumentParser: def _find_positional(self, pos_idx: int) -> int: count: int = 0 - for i in range(self._arg_count): + for i in range(int(self._arg_count)): arg: Argument* = self._get_arg(i) if arg.is_positional: if count == pos_idx: @@ -386,7 +386,7 @@ class ArgumentParser: idx += 1 # Validate required arguments - for i in range(self._arg_count): + for i in range(int(self._arg_count)): arg = self._get_arg(i) if arg.required: if not args.has(arg.dest): @@ -412,7 +412,7 @@ class ArgumentParser: stdio.printf(" %-20s %s\n", arg.name, ht) i += 1 stdio.printf("\noptional arguments:\n") - for i in range(self._arg_count): + for i in range(int(self._arg_count)): arg = self._get_arg(i) if not arg.is_positional: ht: str = arg.help_text diff --git a/ast/base.vp b/ast/base.vp index cafb4bf..4e95cdb 100644 --- a/ast/base.vp +++ b/ast/base.vp @@ -145,7 +145,7 @@ def _init_ast(node: AST*, pool: memhub.MemManager*, lineno: int, col: int): def _set_parent_list(lst: list[AST*]*, parent: AST*): """Set list children parent pointers.""" if lst is None: return - for i in range(lst.__len__()): + for i in range(int(lst.__len__())): child: AST* = lst.get(i) if child is not None: child.parent = parent @@ -216,7 +216,7 @@ def _emit(buf: str, size: sizet, pos: sizet, text: str) -> sizet: if buf is None or pos >= size: return pos cur: str = str(uint64(buf) + pos) rem: sizet = size - pos - n: int = viperlib.snprintf(cur, rem, "%s", text) + n: int = int(viperlib.snprintf(cur, rem, "%s", text)) if n < 0: return pos return pos + sizet(n) @@ -226,7 +226,7 @@ def _emit_str(buf: str, size: sizet, pos: sizet, text: str) -> sizet: if buf is None or pos >= size: return pos cur: str = str(uint64(buf) + pos) rem: sizet = size - pos - n: int = viperlib.snprintf(cur, rem, "%s", text) + n: int = int(viperlib.snprintf(cur, rem, "%s", text)) if n < 0: return pos return pos + sizet(n) @@ -236,7 +236,7 @@ def _emit_int(buf: str, size: sizet, pos: sizet, val: int64) -> sizet: if buf is None or pos >= size: return pos cur: str = str(uint64(buf) + pos) rem: sizet = size - pos - n: int = viperlib.snprintf(cur, rem, "%lld", val) + n: int = int(viperlib.snprintf(cur, rem, "%lld", val)) if n < 0: return pos return pos + sizet(n) @@ -283,7 +283,7 @@ def _dump_list(lst: list[AST*]*, buf: str, size: sizet, pos: sizet) -> sizet: pos = _emit(buf, size, pos, "[]") return pos pos = _emit(buf, size, pos, "[") - for i in range(lst.__len__()): + for i in range(int(lst.__len__())): if i > 0: pos = _emit(buf, size, pos, ", ") child: AST* = lst.get(i) if child is not None: pos = child.dump(buf, size, pos) @@ -298,7 +298,7 @@ def _dump_op_list(lst: t.CPtr, buf: str, size: sizet, pos: sizet) -> sizet: return pos ops_list: list[int]* = (list[int]*)(lst) pos = _emit(buf, size, pos, "[") - for i in range(ops_list.__len__()): + for i in range(int(ops_list.__len__())): if i > 0: pos = _emit(buf, size, pos, ", ") op: int = ops_list.get(i) pos = _emit(buf, size, pos, _op_name(op)) diff --git a/base64.vp b/base64.vp index 56b4976..eb39e33 100644 --- a/base64.vp +++ b/base64.vp @@ -24,7 +24,7 @@ def b64encode(s: str, out: str) -> sizet: j: sizet = 0 val: uint32 = 0 # Process input in groups of 3 bytes, produce 4 Base64 characters - for i in range(0, length, 3): + for i in range(0, int(length), 3): # Assemble 24-bit chunk val = ((uint32(_s[i + 0]) << 16 ) | (uint32(_s[i + 1]) << 8 if (i + 1 < length) else 0) | @@ -50,7 +50,7 @@ def b64decode(s: str, out: uint8*) -> sizet: val: uint32 = 0 c: int # Restore 3 bytes from every 4 Base64 characters - for i in range(0, length, 4): + for i in range(0, int(length), 4): if s[i] == '=': break val = 0 diff --git a/binascii.vp b/binascii.vp index 1bf9d6d..8975a46 100644 --- a/binascii.vp +++ b/binascii.vp @@ -109,13 +109,13 @@ def init_binascii(): def crc32(data: str, length: int, crc: uint) -> uint: s: uint = crc ^ 0xFFFFFFFF - for i in range(length): + for i in range(int(length)): s = CRC32_TABLE[(s ^ uchar(data[i])) & 0xFF] ^ (s >> 8) return s ^ 0xFFFFFFFF def crc_hqx(data: str, length: int, crc: ushort) -> ushort: s: ushort = crc - for i in range(length): + for i in range(int(length)): s = CRC_HQX_TABLE[uchar(s >> 8)] ^ (s << 1 | (data[i] & 0xFF)) return s @@ -124,7 +124,7 @@ def hexlify(data: str, length: int) -> str: out: str = str(stdlib.malloc(length * 2 + 1)) if not out: return None oi: int = 0 - for i in range(length): + for i in range(int(length)): s: uchar = uchar(data[i]) out[oi + 0] = HEX_CHARS[(s >> 4) & 0x0F] out[oi + 1] = HEX_CHARS[(s >> 0) & 0x0F] @@ -141,7 +141,7 @@ def a2b_hex(hexstr: str, length: int) -> str: out: str = str(stdlib.malloc(out_len + 1)) if not out: return None oi: int = 0 - for i in range(0, length, 2): + for i in range(0, int(length), 2): hi: int = HEX_VALS[uchar(hexstr[i])] lo: int = HEX_VALS[uchar(hexstr[i + 1])] if hi < 0 or lo < 0: @@ -164,7 +164,7 @@ def b2a_base64(data: str, length: int) -> str: out: str = str(stdlib.malloc(olen + 1)) if not out: return None oi: int = 0 - for i in range(0, length, 3): + for i in range(0, int(length), 3): b0: uchar = uchar(data[i]) b1: uchar = 0 b2: uchar = 0 @@ -199,7 +199,7 @@ def a2b_base64(data: str, length: int) -> str: out: str = str(stdlib.malloc(olen + 1)) if not out: return None oi: int = 0 - for i in range(0, length, 4): + for i in range(0, int(length), 4): v0: int = 0 v1: int = 0 v2: int = 0 @@ -236,7 +236,7 @@ def b2a_uu(data: str, length: int) -> str: oi: int = 0 out[oi] = UU_CHARS[length] oi += 1 - for i in range(0, length, 3): + for i in range(0, int(length), 3): b0: uchar = uchar(data[i]) b1: uchar = 0 b2: uchar = 0 @@ -339,7 +339,7 @@ def a2b_hqx(data: str, crc: ushort = 0) -> tuple[str, ushort]: def adler32(data: str, length: int, adler: uint) -> uint: a: uint = adler & 0xFFFF b: uint = (adler >> 16) & 0xFFFF - for i in range(length): + for i in range(int(length)): a = (a + uchar(data[i])) % 65521 b = (b + a) % 65521 return (b << 16) | a diff --git a/gzip.vp b/gzip.vp index 11867d1..d242a18 100644 --- a/gzip.vp +++ b/gzip.vp @@ -172,7 +172,7 @@ def _fill(n: int) -> int: def _bits(n: int) -> int: global _g_bits, _g_bitcnt - if _fill(n) != 0: + if _fill(int(n)) != 0: return -1 v: uint64 = _g_bits & ((uint64(1) << n) - 1) _g_bits = _g_bits >> n @@ -244,7 +244,7 @@ def _collect(len_arr: int*, cnt: int*, sorted_arr: int*, nsym: int, pos: int*): string.memset(cnt, 0, 17 * 4) - for s1 in range(nsym): + for s1 in range(int(nsym)): if len_arr[s1] != 0: cnt[len_arr[s1]] += 1 run: int = 0 @@ -253,7 +253,7 @@ def _collect(len_arr: int*, cnt: int*, pos[l5] = run run += cnt[l5] l5 += 1 - for s2 in range(nsym): + for s2 in range(int(nsym)): if len_arr[s2] != 0: sorted_arr[pos[len_arr[s2]]] = s2 pos[len_arr[s2]] += 1 @@ -429,7 +429,7 @@ def _gzip_decode(src: rawptr, src_len: sizet, if (slen ^ snlen) != 0xFFFF: err = -7 break - for i in range(sizet(slen)): + for i in range(int(sizet(slen))): ch: int = _byte() if ch < 0: err = -8 @@ -468,7 +468,7 @@ def _gzip_decode(src: rawptr, src_len: sizet, err = -11 break string.memset(cl_len, 0, 19 * 4) - for k in range(hclen): + for k in range(int(hclen)): vv: int = _bits(3) if vv < 0: err = -12 @@ -577,7 +577,7 @@ def _gzip_decode(src: rawptr, src_len: sizet, if dist == 0 or dist > wpos: err = -22 break - for ci in range(length): + for ci in range(int(length)): if wpos >= dst_cap: err = -23 break diff --git a/hashtable.vp b/hashtable.vp index b48cf94..1a46cbc 100644 --- a/hashtable.vp +++ b/hashtable.vp @@ -100,7 +100,7 @@ class HashTable: mask: sizet = self.__capacity__ - 1 idx: sizet = sizet(h) & mask first_tombstone: sizet = self.__capacity__ - for i in range(self.__capacity__): + for i in range(int(self.__capacity__)): sh: uint64 = self._slot_hash(idx) if sh == _HT_EMPTY: if first_tombstone < self.__capacity__: @@ -131,7 +131,7 @@ class HashTable: self.__capacity__ = new_cap self.__count__ = 0 self.__tombstones__ = 0 - for i in range(old_cap): + for i in range(int(old_cap)): old_h_ptr: uint64* = t.CPtr(uint64(old_slots) + i * _HT_SLOT_SIZE) h: uint64 = old_h_ptr[0] if h != _HT_EMPTY and h != _HT_TOMBSTONE: diff --git a/json/__init__.vp b/json/__init__.vp index d4bebd7..a7ce222 100644 --- a/json/__init__.vp +++ b/json/__init__.vp @@ -1,7 +1,7 @@ from stdint import * import memhub import string -import viperio + # ============================================================ # JSON value type enum diff --git a/json/__parser.vp b/json/__parser.vp index f6dd804..422ac44 100644 --- a/json/__parser.vp +++ b/json/__parser.vp @@ -1,4 +1,3 @@ -import t, c from stdint import * import memhub import string @@ -145,7 +144,7 @@ def _parse_number(s: ParseState*) -> JsonValue*: if buf == None: return null(s.pool) - for i in range(num_len): + for i in range(int(num_len)): buf[i] = s.src[start + i] buf[num_len] = '\0' diff --git a/json/__writer.vp b/json/__writer.vp index 7778070..3945ab6 100644 --- a/json/__writer.vp +++ b/json/__writer.vp @@ -1,4 +1,3 @@ -import t, c from stdint import * import memhub import string @@ -35,12 +34,11 @@ def _write_char(buf: str, pos: sizet, cap: sizet, ch: char) -> sizet: def _write_str(buf: str, pos: sizet, cap: sizet, s: str) -> sizet: if s == None: return pos - if pos >= cap: - return pos # overflow flag already set: stop writing + if pos >= cap: return pos # overflow flag already set: stop writing slen: sizet = string.strlen(s) if pos + slen >= cap: return cap # cannot reserve trailing NUL slot => set overflow flag - string.memcpy(char(uint64(buf) + pos, t.CPtr), s, slen) + string.memcpy(buf + pos, s, slen) return pos + slen def _write_string_escaped(buf: str, pos: sizet, cap: sizet, s: str) -> sizet: @@ -51,7 +49,7 @@ def _write_string_escaped(buf: str, pos: sizet, cap: sizet, s: str) -> sizet: if pos >= cap: return pos # already overflowed: stop writing slen: sizet = string.strlen(s) - for i in range(slen): + for i in range(int(slen)): if pos >= cap: return pos # already overflowed: converge early, skip pointless per-char looping ch: char = s[i] diff --git a/math.vp b/math.vp index 81066e9..4a30d5b 100644 --- a/math.vp +++ b/math.vp @@ -405,7 +405,7 @@ def factorial(n: int) -> double: if n < 0: return 0.0 if n == 0 or n == 1: return 1.0 result: double = 1.0 - for i in range(2, n + 1): + for i in range(2, int(n + 1)): result *= i return result @@ -415,7 +415,7 @@ def combination(n: int, k: int) -> double: if k == 0 or k == n: return 1.0 k = k if k < n - k else n - k result: double = 1.0 - for i in range(1, k + 1): + for i in range(1, int(k + 1)): result = result * (n - k + i) / i return result @@ -423,7 +423,7 @@ def combination(n: int, k: int) -> double: def permutation(n: int, k: int) -> double: if k < 0 or k > n: return 0.0 result: double = 1.0 - for i in range(0, k): + for i in range(0, int(k)): result *= (n - i) return result diff --git a/memhub.vp b/memhub.vp index b3ec4ff..5ebe64b 100644 --- a/memhub.vp +++ b/memhub.vp @@ -302,7 +302,7 @@ def _zero_alloc_note() -> sizet: return _zero_alloc_hits -# [CTX] Current context (stage name / current file or module name): set by TPV via SetAllocCtx at +# [CTX] Current context (stage name / current file or module name): set by VPC via SetAllocCtx at # key stages, used only to attribute zero-size / allocation-failure reports. The two fields are kept # separate (no concatenation, no allocation). None = not set => report prints ? (never fabricated). _alloc_ctx_stage: bytes = None @@ -310,7 +310,7 @@ _alloc_ctx_detail: bytes = None def SetAllocCtx(stage: bytes, detail: bytes = None): - """Set the current context (TPV side); the caller keeps both strings alive for the stage.""" + """Set the current context (VPC side); the caller keeps both strings alive for the stage.""" global _alloc_ctx_stage, _alloc_ctx_detail _alloc_ctx_stage = stage _alloc_ctx_detail = detail @@ -573,7 +573,7 @@ class MemSlab(MemManager): self.block_size = bs # Clear bitmap - for idx in range(map_bytes): + for idx in range(int(map_bytes)): self.alloc_map[idx] = 0 self.block_count = self.usable_size / bs @@ -581,7 +581,7 @@ class MemSlab(MemManager): # Construct free list: the first 8 bytes of each block store pointer to next block self.free_list = None - for i in range(self.block_count): + for i in range(int(self.block_count)): block: rawptr = self.usable + i * bs *((uint64*)(block)) = uint64(self.free_list) self.free_list = block @@ -627,7 +627,7 @@ class MemSlab(MemManager): def reset(self) -> int: self.used_count = 0 self.free_list = None - for i in range(self.block_count): + for i in range(int(self.block_count)): block: rawptr = self.usable + i * self.block_size *((uint64*)(block)) = uint64(self.free_list) self.free_list = block @@ -713,7 +713,7 @@ class MemBuddy(MemManager): # Initialize all free list heads to be 0 i: int - for i in range(MEMBUDDY_MAX_ORDERS + 1): + for i in range(int(MEMBUDDY_MAX_ORDERS + 1)): self.free_lists[i] = 0 if size <= fl_bytes: @@ -987,7 +987,7 @@ class MemBuddy(MemManager): if self.detection != 0: l_usr = l_usr + 2 lr_hit: int = 0 - for lr_i in range(self._det_count): + for lr_i in range(int(self._det_count)): if uint64(self._det_records[lr_i * 2]) == l_usr: # Single load + explicit bit test (print and decision share the # source word): the raw 8 bytes of the size slot are read once. @@ -1085,7 +1085,7 @@ class MemBuddy(MemManager): if self.detection != 0: usr_d = usr_d + 2 hit_d: int = 0 - for ri_d in range(self._det_count): + for ri_d in range(int(self._det_count)): if uint64(self._det_records[ri_d * 2]) == usr_d: w_d: uint64 = self._det_records[ri_d * 2 + 1] d_sz: uint64 = w_d & ((uint64(1) << 63) - 1) @@ -1143,7 +1143,7 @@ class MemBuddy(MemManager): hit_v: sizet = 0 in_pool: sizet = 0 out_pool: sizet = 0 - for i in range(nw): + for i in range(int(nw)): wv: uint64 = self._ff_word(rawptr(l_addr), int(i) + 1) if wv == lcan: hit_v += 1 @@ -1234,7 +1234,7 @@ class MemBuddy(MemManager): if uint64(block) + bs + 16 <= uint64(self.usable) + self.usable_size: dump_n = 24 stdio.printf("[FREEFRAME] %d bytes from canary: ", dump_n) - for bi in range(dump_n): + for bi in range(int(dump_n)): bv: uint8 = *((uint8*)(can_addr + uint64(bi))) stdio.printf("%02X ", uint32(bv)) stdio.printf("\n") @@ -1451,7 +1451,7 @@ class MemBuddy(MemManager): # are no longer recorded, so the check is skipped to avoid rejecting valid frees. if self.chk_stack is not None and self.chk_depth < self.chk_cap: alive: int = 0 - for ci in range(self.chk_depth): + for ci in range(int(self.chk_depth)): if self.chk_stack[ci] == uint64(block): alive = 1 break @@ -1558,7 +1558,7 @@ class MemBuddy(MemManager): # Overlap check: the new block's address must not already be an active # record (same block allocated twice = free list corruption). ff_d: uint64 = uint64(1) << 63 - for dup_i in range(self._det_count): + for dup_i in range(int(self._det_count)): drp: uint64 = self._det_records[dup_i * 2] drs: uint64 = self._det_records[dup_i * 2 + 1] if drp == rec_ptr_d and (drs & ff_d) == 0: @@ -1625,7 +1625,7 @@ class MemBuddy(MemManager): "(constant unresolved/shadowed by a same-named symbol/evaluated to 0)\n") # Fields below are read from existing state only (this branch runs only on # failure): site tag, pool alloc sequence, zero-size hit count, pool state, - # and the stage/detail context set by TPV. + # and the stage/detail context set by VPC. usable_addr: uint64 = 0 if self.usable is not None: usable_addr = uint64(self.usable) @@ -1650,7 +1650,7 @@ class MemBuddy(MemManager): size, needed2, order2, self.max_order, self.used_bytes(), uint64(self.usable)) # Attribution (always-on, no --detection needed): site comes from the alloc_tagged site - # tag, ctx=stage/current file from TPV's SetAllocCtx (? if unset). Failure path only. + # tag, ctx=stage/current file from VPC's SetAllocCtx (? if unset). Failure path only. stdio.printf("[MEM] attribution site=%s ctx=%s/%s pool capacity=%zu\n", _det_site_name(_alloc_site_current()), _alloc_ctx_stage_str(), _alloc_ctx_detail_str(), @@ -1721,7 +1721,7 @@ class MemBuddy(MemManager): # Read this record's real size (detection fills 0xCD after free, so a later # write-through breaks the fill = use-after-free). Keep the record and set the # free bit; the probe checks the 0xCD fill of still-free blocks. - for ri in range(self._det_count): + for ri in range(int(self._det_count)): rp: uint64 = self._det_records[ri * 2] rs: uint64 = self._det_records[ri * 2 + 1] if rp == uint64(ptr) and (rs & (uint64(1) << 63)) == 0: @@ -1832,7 +1832,7 @@ class MemBuddy(MemManager): no longer match); a power-of-two arena is a single max_order block. """ i: int - for i in range(MEMBUDDY_MAX_ORDERS + 1): + for i in range(int(MEMBUDDY_MAX_ORDERS + 1)): self.free_lists[i] = 0 pos: sizet = 0 rem: sizet = self.usable_size @@ -1911,7 +1911,7 @@ class MemBuddy(MemManager): return 1 target: uint64 = uint64(ptr) free_flag: uint64 = uint64(1) << 63 - for i in range(self._det_count): + for i in range(int(self._det_count)): rp: uint64 = self._det_records[i * 2] rs: uint64 = self._det_records[i * 2 + 1] if rp == target and (rs & free_flag) == 0: @@ -1978,7 +1978,7 @@ class MemBuddy(MemManager): # Overlap check: a ptr with several records means alloc handed the same block to # different size requests (they overwrite each other). stdio.printf("\nsame-ptr records: ") - for ci3 in range(self._det_count): + for ci3 in range(int(self._det_count)): cp3: uint64 = self._det_records[ci3 * 2] cs3: uint64 = self._det_records[ci3 * 2 + 1] if cp3 == p and (cs3 & free_flag) == 0: @@ -2007,7 +2007,7 @@ class MemBuddy(MemManager): count: sizet = 0 i: int max_steps: sizet = self.usable_size / MEMBUDDY_MIN_BLOCK + 2 - for i in range(MEMBUDDY_MAX_ORDERS + 1): + for i in range(int(MEMBUDDY_MAX_ORDERS + 1)): head_val: uint64 = self.free_lists[i] cur: rawptr = rawptr(head_val) if uint64(cur) != 0 and self._fl_block_ok(cur) == 0: @@ -2044,7 +2044,7 @@ class MemBuddy(MemManager): total: sizet = 0 i: int max_steps: sizet = self.usable_size / MEMBUDDY_MIN_BLOCK + 2 - for i in range(MEMBUDDY_MAX_ORDERS + 1): + for i in range(int(MEMBUDDY_MAX_ORDERS + 1)): head_val: uint64 = self.free_lists[i] cur: rawptr = rawptr(head_val) if uint64(cur) != 0 and self._fl_block_ok(cur) == 0: @@ -2061,7 +2061,7 @@ class MemBuddy(MemManager): stdio.printf("[MEM] free_lists[%d] chain cyclic or node count over limit (next pointer damaged): head=%llu; stop counting to avoid spinning, heap corrupted\n", i, head_val) break - total += _block_size_at_order(i) + total += _block_size_at_order(int(i)) next_b: rawptr = rawptr(*((uint64*)(cur))) if uint64(next_b) != 0 and self._fl_block_ok(next_b) == 0: stdio.printf("[MEM] free_lists[%d] node invalid (not an in-pool aligned block address; metadata possibly uninitialized/written through): " @@ -2160,7 +2160,7 @@ class MemBuddy(MemManager): win_live, win_bytes_a) stdio.printf("[MEM] live-block order distribution (%zu blocks recorded total; single block=%llu<= uint64(self.usable) + self.usable_size: return 2 - # Check alignment: order i blocks must be aligned to size _block_size_at_order(i) + # Check alignment: order i blocks must be aligned to size _block_size_at_order(int(i)) offset: sizet = uint64(cur) - uint64(self.usable) - bs: sizet = _block_size_at_order(i) + bs: sizet = _block_size_at_order(int(i)) if offset % bs != 0: return 3 cur = rawptr(*((uint64*)(cur))) diff --git a/mlirlite/__verify.vp b/mlirlite/__verify.vp index ab91bd7..279ec2b 100644 --- a/mlirlite/__verify.vp +++ b/mlirlite/__verify.vp @@ -191,10 +191,10 @@ def _extract_def_name(pool: memhub.MemBuddy*, while text[i] != '\0': if text[i] == ' ' and text[i + 1] == '=' and text[i + 2] == ' ': # Found " = " at position i - name_len: int = i + name_len: int = int(i) name: str = pool.alloc(name_len + 1) if name is None: return None - for j in range(name_len): + for j in range(int(name_len)): name[j] = text[j] name[name_len] = '\0' return name @@ -233,11 +233,11 @@ def _check_uses_in_line(table: GSList[NameEntry]*, while text[i] != '\0': if text[i] == '%': # Extract name - name_start: int = i + name_start: int = int(i) i += 1 while text[i] != '\0' and _is_char_name(text[i]) == 1: i += 1 - name_len: int = i - name_start + name_len: int = int(i - name_start) if name_len > 1: # Build no temp string (no stack alloc); compare char by char. if _name_matches_at(text, name_start, name_len, table) == 0: @@ -272,7 +272,7 @@ def _str_matches_at(text: str, start: int, length: int, # Check target length target_len: sizet = string.strlen(target) if target_len != length: return 0 - for i in range(length): + for i in range(int(length)): if text[start + i] != target[i]: return 0 return 1 @@ -314,7 +314,7 @@ def verify_function(pool: memhub.MemBuddy*, if blk_ref is not None: # Build the "%" string blk_ref[0] = '%' - for k in range(blk_name_len): + for k in range(int(blk_name_len)): blk_ref[k + 1] = blk_iter.Name[k] blk_ref[blk_name_len + 1] = '\0' _name_table_add(name_table, pool, blk_ref) diff --git a/numpy/__init__.vp b/numpy/__init__.vp index c0ff936..738a0a3 100644 --- a/numpy/__init__.vp +++ b/numpy/__init__.vp @@ -1,9 +1,7 @@ from stdint import * -import stdlib import string import math import stdio -import t, c import memhub @@ -12,8 +10,8 @@ import memhub # ============================================================ define MAX_NDIM = 4 -float64: t.CTypedef = double -float32: t.CTypedef = float +typedef float64 = double +typedef float32 = float define pi = 3.14159265358979323846 define e = 2.71828182845904523536 @@ -29,8 +27,8 @@ define e = 2.71828182845904523536 # ============================================================ class ndarray[T]: data: T* - shape: t.CArray[sizet, MAX_NDIM] - strides: t.CArray[sizet, MAX_NDIM] + shape: [MAX_NDIM]sizet + strides: [MAX_NDIM]sizet ndim: int size: sizet owns_data: int @@ -50,28 +48,28 @@ class ndarray[T]: def __add__(self, other: ndarray[T]*) -> ndarray[T]*: result: ndarray[T]* = _empty_like(self) if not result: return None - for i in range(self.size): + for i in range(int(self.size)): result.data[i] = self.data[i] + other.data[i] return result def __sub__(self, other: ndarray[T]*) -> ndarray[T]*: result: ndarray[T]* = _empty_like(self) if not result: return None - for i in range(self.size): + for i in range(int(self.size)): result.data[i] = self.data[i] - other.data[i] return result def __mul__(self, other: ndarray[T]*) -> ndarray[T]*: result: ndarray[T]* = _empty_like(self) if not result: return None - for i in range(self.size): + for i in range(int(self.size)): result.data[i] = self.data[i] * other.data[i] return result def __truediv__(self, other: ndarray[T]*) -> ndarray[T]*: result: ndarray[T]* = _empty_like(self) if not result: return None - for i in range(self.size): + for i in range(int(self.size)): if other.data[i] != T(0): result.data[i] = self.data[i] / other.data[i] else: @@ -81,7 +79,7 @@ class ndarray[T]: def __floordiv__(self, other: ndarray[T]*) -> ndarray[T]*: result: ndarray[T]* = _empty_like(self) if not result: return None - for i in range(self.size): + for i in range(int(self.size)): if other.data[i] != T(0): result.data[i] = math.floor(self.data[i] / other.data[i]) else: @@ -91,7 +89,7 @@ class ndarray[T]: def __mod__(self, other: ndarray[T]*) -> ndarray[T]*: result: ndarray[T]* = _empty_like(self) if not result: return None - for i in range(self.size): + for i in range(int(self.size)): if other.data[i] != T(0): result.data[i] = math.fmod(self.data[i], other.data[i]) else: @@ -101,7 +99,7 @@ class ndarray[T]: def __neg__(self) -> ndarray[T]*: result: ndarray[T]* = _empty_like(self) if not result: return None - for i in range(self.size): + for i in range(int(self.size)): result.data[i] = -self.data[i] return result @@ -122,7 +120,7 @@ class ndarray[T]: self.pool.free(self) def fill(self, val: T): - for i in range(self.size): + for i in range(int(self.size)): self.data[i] = val def copy(self) -> ndarray[T]*: @@ -134,7 +132,7 @@ class ndarray[T]: def reshape(self, new_shape: INTPTR, new_ndim: int) -> ndarray[T]*: new_size: sizet = 1 i: int = 0 - for i in range(new_ndim): + for i in range(int(new_ndim)): new_size *= sizet(new_shape[i]) if new_size != self.size: return None result: ndarray[T]* = _alloc_ndarray(self.pool) @@ -144,14 +142,14 @@ class ndarray[T]: result.ndim = new_ndim result.size = self.size result.owns_data = 0 - for i in range(new_ndim): + for i in range(int(new_ndim)): result.shape[i] = sizet(new_shape[i]) _compute_strides(result) return result def sum(self) -> T: s: T = T(0) - for i in range(self.size): + for i in range(int(self.size)): s += self.data[i] return s @@ -204,7 +202,7 @@ class ndarray[T]: def dot(self, other: ndarray[T]*) -> T: s: T = T(0) n: sizet = self.size if (self.size < other.size) else other.size - for i in range(n): + for i in range(int(n)): s += self.data[i] * other.data[i] return s @@ -218,15 +216,15 @@ class ndarray[T]: result.shape[0] = cols result.shape[1] = rows _compute_strides(result) - for i in range(rows): - for j in range(cols): + for i in range(int(rows)): + for j in range(int(cols)): result.data[j * rows + i] = self.data[i * cols + j] return result def print_arr(self): if self.ndim == 1: stdio.printf("[") - for i in range(self.size): + for i in range(int(self.size)): if i > 0: stdio.printf(", ") stdio.printf("%.4f", self.data[i]) stdio.printf("]\n") @@ -234,10 +232,10 @@ class ndarray[T]: rows: sizet = self.shape[0] cols: sizet = self.shape[1] stdio.printf("[") - for i in range(rows): + for i in range(int(rows)): if i > 0: stdio.printf(" ") stdio.printf("[") - for j in range(cols): + for j in range(int(cols)): if j > 0: stdio.printf(", ") stdio.printf("%.4f", self.data[i * cols + j]) if i < rows - 1: @@ -250,11 +248,11 @@ class ndarray[T]: # Convenience aliases: typed ndarray instantiations # (must be after class ndarray[T] definition to avoid forward reference) # ============================================================ -Float64Array: t.CTypedef = ndarray[double] -Float32Array: t.CTypedef = ndarray[float] -Int64Array: t.CTypedef = ndarray[int32] -Int32Array: t.CTypedef = ndarray[int] -Uint8Array: t.CTypedef = ndarray[uchar] +typedef Float64Array = ndarray[double] +typedef Float32Array = ndarray[float] +typedef Int64Array = ndarray[int32] +typedef Int32Array = ndarray[int] +typedef Uint8Array = ndarray[uchar] # ============================================================ @@ -263,8 +261,7 @@ Uint8Array: t.CTypedef = ndarray[uchar] # ============================================================ def _alloc_ndarray(pool: memhub.MemManager*) -> ndarray[double]*: a: ndarray[double]* = pool.alloc(ndarray[double].__sizeof__()) - if a: - string.memset(a, 0, ndarray[double].__sizeof__()) + if a: string.memset(a, 0, ndarray[double].__sizeof__()) return a def _compute_strides(a: ndarray[double]*): @@ -287,7 +284,7 @@ def _empty_like(a: ndarray[double]*) -> ndarray[double]*: result.size = a.size result.owns_data = 1 i: int = 0 - for i in range(a.ndim): + for i in range(int(a.ndim)): result.shape[i] = a.shape[i] _compute_strides(result) return result @@ -357,7 +354,7 @@ def arange(pool: memhub.MemManager*, start: double, stop: double, step: double) a: ndarray[double]* = zeros(pool, n) if not a: return None v = start - for i in range(n): + for i in range(int(n)): a.data[i] = v v += step return a @@ -370,7 +367,7 @@ def linspace(pool: memhub.MemManager*, start: double, stop: double, num: sizet) a.data[0] = start return a step: double = (stop - start) / double(num - 1) - for i in range(num): + for i in range(int(num)): a.data[i] = start + double(i) * step return a @@ -404,7 +401,7 @@ def ones2d(pool: memhub.MemManager*, rows: sizet, cols: sizet) -> ndarray[double def eye(pool: memhub.MemManager*, n: sizet) -> ndarray[double]*: a: ndarray[double]* = empty2d(pool, n, n) if not a: return None - for i in range(n): + for i in range(int(n)): a.data[i * n + i] = double(1.0) return a @@ -412,7 +409,7 @@ def diag(pool: memhub.MemManager*, vals: ndarray[double]*) -> ndarray[double]*: n: sizet = vals.size a: ndarray[double]* = empty2d(pool, n, n) if not a: return None - for i in range(n): + for i in range(int(n)): a.data[i * n + i] = vals.data[i] return a @@ -423,7 +420,7 @@ def diag(pool: memhub.MemManager*, vals: ndarray[double]*) -> ndarray[double]*: def np_abs(a: ndarray[double]*) -> ndarray[double]*: result: ndarray[double]* = _empty_like(a) if not result: return None - for i in range(a.size): + for i in range(int(a.size)): v: double = a.data[i] result.data[i] = v if v >= double(0.0) else -v return result @@ -431,49 +428,49 @@ def np_abs(a: ndarray[double]*) -> ndarray[double]*: def np_sqrt(a: ndarray[double]*) -> ndarray[double]*: result: ndarray[double]* = _empty_like(a) if not result: return None - for i in range(a.size): + for i in range(int(a.size)): result.data[i] = math.sqrt(a.data[i]) return result def np_exp(a: ndarray[double]*) -> ndarray[double]*: result: ndarray[double]* = _empty_like(a) if not result: return None - for i in range(a.size): + for i in range(int(a.size)): result.data[i] = math.exp(a.data[i]) return result def np_log(a: ndarray[double]*) -> ndarray[double]*: result: ndarray[double]* = _empty_like(a) if not result: return None - for i in range(a.size): + for i in range(int(a.size)): result.data[i] = math.log(a.data[i]) return result def np_sin(a: ndarray[double]*) -> ndarray[double]*: result: ndarray[double]* = _empty_like(a) if not result: return None - for i in range(a.size): + for i in range(int(a.size)): result.data[i] = math.sin(a.data[i]) return result def np_cos(a: ndarray[double]*) -> ndarray[double]*: result: ndarray[double]* = _empty_like(a) if not result: return None - for i in range(a.size): + for i in range(int(a.size)): result.data[i] = math.cos(a.data[i]) return result def np_tan(a: ndarray[double]*) -> ndarray[double]*: result: ndarray[double]* = _empty_like(a) if not result: return None - for i in range(a.size): + for i in range(int(a.size)): result.data[i] = math.tan(a.data[i]) return result def np_pow(a: ndarray[double]*, p: double) -> ndarray[double]*: result: ndarray[double]* = _empty_like(a) if not result: return None - for i in range(a.size): + for i in range(int(a.size)): result.data[i] = math.pow(a.data[i], p) return result @@ -484,28 +481,28 @@ def np_pow(a: ndarray[double]*, p: double) -> ndarray[double]*: def add_scalar(a: ndarray[double]*, s: double) -> ndarray[double]*: result: ndarray[double]* = _empty_like(a) if not result: return None - for i in range(a.size): + for i in range(int(a.size)): result.data[i] = a.data[i] + s return result def mul_scalar(a: ndarray[double]*, s: double) -> ndarray[double]*: result: ndarray[double]* = _empty_like(a) if not result: return None - for i in range(a.size): + for i in range(int(a.size)): result.data[i] = a.data[i] * s return result def sub_scalar(a: ndarray[double]*, s: double) -> ndarray[double]*: result: ndarray[double]* = _empty_like(a) if not result: return None - for i in range(a.size): + for i in range(int(a.size)): result.data[i] = a.data[i] - s return result def div_scalar(a: ndarray[double]*, s: double) -> ndarray[double]*: result: ndarray[double]* = _empty_like(a) if not result: return None - for i in range(a.size): + for i in range(int(a.size)): if s != double(0.0): result.data[i] = a.data[i] / s else: @@ -526,10 +523,10 @@ def matmul(a: ndarray[double]*, b: ndarray[double]*) -> ndarray[double]*: if k != k2: return None c: ndarray[double]* = empty2d(a.pool, m, n) if not c: return None - for i in range(m): - for j in range(n): + for i in range(int(m)): + for j in range(int(n)): s: double = double(0.0) - for p in range(k): + for p in range(int(k)): s += a.data[i * k + p] * b.data[p * n + j] c.data[i * n + j] = s return c @@ -567,7 +564,7 @@ def var(a: ndarray[double]*) -> double: if a.size == 0: return double(0.0) m: double = a.mean() s: double = double(0.0) - for i in range(a.size): + for i in range(int(a.size)): d: double = a.data[i] - m s += d * d return s / double(a.size) @@ -581,7 +578,7 @@ def norm(a: ndarray[double]*) -> double: def clip(a: ndarray[double]*, lo: double, hi: double) -> ndarray[double]*: result: ndarray[double]* = _empty_like(a) if not result: return None - for i in range(a.size): + for i in range(int(a.size)): v: double = a.data[i] if v < lo: v = lo if v > hi: v = hi @@ -620,7 +617,7 @@ def sort_arr(a: ndarray[double]*) -> ndarray[double]*: def reverse(a: ndarray[double]*) -> ndarray[double]*: result: ndarray[double]* = _empty_like(a) if not result: return None - for i in range(a.size): + for i in range(int(a.size)): result.data[i] = a.data[a.size - 1 - i] return result @@ -631,42 +628,42 @@ def reverse(a: ndarray[double]*) -> ndarray[double]*: def np_log10(a: ndarray[double]*) -> ndarray[double]*: result: ndarray[double]* = _empty_like(a) if not result: return None - for i in range(a.size): + for i in range(int(a.size)): result.data[i] = math.log10(a.data[i]) return result def np_log2(a: ndarray[double]*) -> ndarray[double]*: result: ndarray[double]* = _empty_like(a) if not result: return None - for i in range(a.size): + for i in range(int(a.size)): result.data[i] = math.log2(a.data[i]) return result def np_floor(a: ndarray[double]*) -> ndarray[double]*: result: ndarray[double]* = _empty_like(a) if not result: return None - for i in range(a.size): + for i in range(int(a.size)): result.data[i] = math.floor(a.data[i]) return result def np_ceil(a: ndarray[double]*) -> ndarray[double]*: result: ndarray[double]* = _empty_like(a) if not result: return None - for i in range(a.size): + for i in range(int(a.size)): result.data[i] = math.ceil(a.data[i]) return result def np_round(a: ndarray[double]*) -> ndarray[double]*: result: ndarray[double]* = _empty_like(a) if not result: return None - for i in range(a.size): + for i in range(int(a.size)): result.data[i] = math.round(a.data[i]) return result def np_sign(a: ndarray[double]*) -> ndarray[double]*: result: ndarray[double]* = _empty_like(a) if not result: return None - for i in range(a.size): + for i in range(int(a.size)): if a.data[i] > double(0.0): result.data[i] = double(1.0) elif a.data[i] < double(0.0): @@ -678,91 +675,91 @@ def np_sign(a: ndarray[double]*) -> ndarray[double]*: def np_tanh(a: ndarray[double]*) -> ndarray[double]*: result: ndarray[double]* = _empty_like(a) if not result: return None - for i in range(a.size): + for i in range(int(a.size)): result.data[i] = math.tanh(a.data[i]) return result def np_sinh(a: ndarray[double]*) -> ndarray[double]*: result: ndarray[double]* = _empty_like(a) if not result: return None - for i in range(a.size): + for i in range(int(a.size)): result.data[i] = math.sinh(a.data[i]) return result def np_cosh(a: ndarray[double]*) -> ndarray[double]*: result: ndarray[double]* = _empty_like(a) if not result: return None - for i in range(a.size): + for i in range(int(a.size)): result.data[i] = math.cosh(a.data[i]) return result def np_arcsin(a: ndarray[double]*) -> ndarray[double]*: result: ndarray[double]* = _empty_like(a) if not result: return None - for i in range(a.size): + for i in range(int(a.size)): result.data[i] = math.asin(a.data[i]) return result def np_arccos(a: ndarray[double]*) -> ndarray[double]*: result: ndarray[double]* = _empty_like(a) if not result: return None - for i in range(a.size): + for i in range(int(a.size)): result.data[i] = math.acos(a.data[i]) return result def np_arctan(a: ndarray[double]*) -> ndarray[double]*: result: ndarray[double]* = _empty_like(a) if not result: return None - for i in range(a.size): + for i in range(int(a.size)): result.data[i] = math.atan(a.data[i]) return result def np_arctan2(y: ndarray[double]*, x: ndarray[double]*) -> ndarray[double]*: result: ndarray[double]* = _empty_like(y) if not result: return None - for i in range(y.size): + for i in range(int(y.size)): result.data[i] = math.atan2(y.data[i], x.data[i]) return result def np_degrees(a: ndarray[double]*) -> ndarray[double]*: result: ndarray[double]* = _empty_like(a) if not result: return None - for i in range(a.size): + for i in range(int(a.size)): result.data[i] = math.degrees(a.data[i]) return result def np_radians(a: ndarray[double]*) -> ndarray[double]*: result: ndarray[double]* = _empty_like(a) if not result: return None - for i in range(a.size): + for i in range(int(a.size)): result.data[i] = math.radians(a.data[i]) return result def np_isnan(a: ndarray[double]*) -> ndarray[double]*: result: ndarray[double]* = _empty_like(a) if not result: return None - for i in range(a.size): + for i in range(int(a.size)): result.data[i] = double(math.isnan(a.data[i])) return result def np_isinf(a: ndarray[double]*) -> ndarray[double]*: result: ndarray[double]* = _empty_like(a) if not result: return None - for i in range(a.size): + for i in range(int(a.size)): result.data[i] = double(math.isinf(a.data[i])) return result def np_maximum(a: ndarray[double]*, b: ndarray[double]*) -> ndarray[double]*: result: ndarray[double]* = _empty_like(a) if not result: return None - for i in range(a.size): + for i in range(int(a.size)): result.data[i] = a.data[i] if a.data[i] > b.data[i] else b.data[i] return result def np_minimum(a: ndarray[double]*, b: ndarray[double]*) -> ndarray[double]*: result: ndarray[double]* = _empty_like(a) if not result: return None - for i in range(a.size): + for i in range(int(a.size)): result.data[i] = a.data[i] if a.data[i] < b.data[i] else b.data[i] return result @@ -774,7 +771,7 @@ def cumsum(a: ndarray[double]*) -> ndarray[double]*: result: ndarray[double]* = _empty_like(a) if not result: return None s: double = double(0.0) - for i in range(a.size): + for i in range(int(a.size)): s += a.data[i] result.data[i] = s return result @@ -783,7 +780,7 @@ def diff(a: ndarray[double]*) -> ndarray[double]*: if a.size < 2: return None result: ndarray[double]* = zeros(a.pool, a.size - 1) if not result: return None - for i in range(a.size - 1): + for i in range(int(a.size - 1)): result.data[i] = a.data[i + 1] - a.data[i] return result @@ -800,22 +797,22 @@ def trace(a: ndarray[double]*) -> double: if a.ndim != 2: return double(0.0) n: sizet = a.shape[0] if a.shape[0] < a.shape[1] else a.shape[1] s: double = double(0.0) - for i in range(n): + for i in range(int(n)): s += a.data[i * a.shape[1] + i] return s def outer(a: ndarray[double]*, b: ndarray[double]*) -> ndarray[double]*: result: ndarray[double]* = empty2d(a.pool, a.size, b.size) if not result: return None - for i in range(a.size): - for j in range(b.size): + for i in range(int(a.size)): + for j in range(int(b.size)): result.data[i * b.size + j] = a.data[i] * b.data[j] return result def np_where(condition: ndarray[double]*, x: ndarray[double]*, y: ndarray[double]*) -> ndarray[double]*: result: ndarray[double]* = _empty_like(x) if not result: return None - for i in range(x.size): + for i in range(int(x.size)): if condition.data[i] != double(0.0): result.data[i] = x.data[i] else: @@ -824,19 +821,19 @@ def np_where(condition: ndarray[double]*, x: ndarray[double]*, y: ndarray[double def np_count_nonzero(a: ndarray[double]*) -> int: count: int = 0 - for i in range(a.size): + for i in range(int(a.size)): if a.data[i] != double(0.0): count += 1 return count def np_all(a: ndarray[double]*) -> int: - for i in range(a.size): + for i in range(int(a.size)): if a.data[i] == double(0.0): return 0 return 1 def np_any(a: ndarray[double]*) -> int: - for i in range(a.size): + for i in range(int(a.size)): if a.data[i] != double(0.0): return 1 return 0 @@ -844,42 +841,42 @@ def np_any(a: ndarray[double]*) -> int: def np_equal(a: ndarray[double]*, b: ndarray[double]*) -> ndarray[double]*: result: ndarray[double]* = _empty_like(a) if not result: return None - for i in range(a.size): + for i in range(int(a.size)): result.data[i] = double(1.0) if a.data[i] == b.data[i] else double(0.0) return result def np_not_equal(a: ndarray[double]*, b: ndarray[double]*) -> ndarray[double]*: result: ndarray[double]* = _empty_like(a) if not result: return None - for i in range(a.size): + for i in range(int(a.size)): result.data[i] = double(1.0) if a.data[i] != b.data[i] else double(0.0) return result def np_less(a: ndarray[double]*, b: ndarray[double]*) -> ndarray[double]*: result: ndarray[double]* = _empty_like(a) if not result: return None - for i in range(a.size): + for i in range(int(a.size)): result.data[i] = double(1.0) if a.data[i] < b.data[i] else double(0.0) return result def np_greater(a: ndarray[double]*, b: ndarray[double]*) -> ndarray[double]*: result: ndarray[double]* = _empty_like(a) if not result: return None - for i in range(a.size): + for i in range(int(a.size)): result.data[i] = double(1.0) if a.data[i] > b.data[i] else double(0.0) return result def np_less_equal(a: ndarray[double]*, b: ndarray[double]*) -> ndarray[double]*: result: ndarray[double]* = _empty_like(a) if not result: return None - for i in range(a.size): + for i in range(int(a.size)): result.data[i] = double(1.0) if a.data[i] <= b.data[i] else double(0.0) return result def np_greater_equal(a: ndarray[double]*, b: ndarray[double]*) -> ndarray[double]*: result: ndarray[double]* = _empty_like(a) if not result: return None - for i in range(a.size): + for i in range(int(a.size)): result.data[i] = double(1.0) if a.data[i] >= b.data[i] else double(0.0) return result @@ -909,7 +906,7 @@ def zeros_like(a: ndarray[double]*) -> ndarray[double]*: result.size = a.size result.owns_data = 1 i: int = 0 - for i in range(a.ndim): + for i in range(int(a.ndim)): result.shape[i] = a.shape[i] _compute_strides(result) return result @@ -931,8 +928,8 @@ def meshgrid(x: ndarray[double]*, y: ndarray[double]*) -> ndarray[double]*: # Returns X grid as 2D array (each row is x) result: ndarray[double]* = empty2d(x.pool, y.size, x.size) if not result: return None - for i in range(y.size): - for j in range(x.size): + for i in range(int(y.size)): + for j in range(int(x.size)): result.data[i * x.size + j] = x.data[j] return result @@ -972,7 +969,7 @@ def np_interp(x: double, xp: ndarray[double]*, fp: ndarray[double]*) -> double: if xp.size == 0: return double(0.0) if x <= xp.data[0]: return fp.data[0] if x >= xp.data[xp.size - 1]: return fp.data[xp.size - 1] - for i in range(xp.size - 1): + for i in range(int(xp.size - 1)): if x >= xp.data[i] and x <= xp.data[i + 1]: t_val: double = (x - xp.data[i]) / (xp.data[i + 1] - xp.data[i]) return fp.data[i] + t_val * (fp.data[i + 1] - fp.data[i]) @@ -980,7 +977,7 @@ def np_interp(x: double, xp: ndarray[double]*, fp: ndarray[double]*) -> double: def prod(a: ndarray[double]*) -> double: p: double = double(1.0) - for i in range(a.size): + for i in range(int(a.size)): p *= a.data[i] return p diff --git a/openssl/__init__.vp b/openssl/__init__.vp index 3e5a461..9227037 100644 --- a/openssl/__init__.vp +++ b/openssl/__init__.vp @@ -15,8 +15,6 @@ # * Password-callback parameters are always placeholder bytes; pass t.CPtr(0)/None when unused. # * Linked libraries: libcrypto + libssl (on Windows with mingw, this means -lcrypto -lssl). # ============================================================ - -import t from openssl.types import * from openssl.crypto import * from openssl.err import * diff --git a/openssl/bio.vp b/openssl/bio.vp index bc987e2..6914bfb 100644 --- a/openssl/bio.vp +++ b/openssl/bio.vp @@ -1,4 +1,3 @@ -import t, c from openssl.types import * # ============================================================ diff --git a/os/__init__.vp b/os/__init__.vp index e91f1d9..46d43da 100644 --- a/os/__init__.vp +++ b/os/__init__.vp @@ -1,4 +1,3 @@ -import t, c from stdint import * import platmacro import memhub diff --git a/os/_posix.vp b/os/_posix.vp index af1ef06..9dfe02a 100644 --- a/os/_posix.vp +++ b/os/_posix.vp @@ -1,4 +1,3 @@ -import t, c from stdint import * import posix import memhub diff --git a/os/_win32.vp b/os/_win32.vp index c5f3f3a..9a9bd87 100644 --- a/os/_win32.vp +++ b/os/_win32.vp @@ -1,4 +1,3 @@ -import t, c from stdint import * import win32.win32base import win32.win32file @@ -57,7 +56,7 @@ def getsize(path: str) -> int64: """Return the file size in bytes. Return -1 on failure.""" handle: win32.win32base.HANDLE = win32.win32file.CreateFileA( path, win32.win32file.GENERIC_READ, win32.win32file.FILE_SHARE_READ, - t.CPtr(0), win32.win32file.OPEN_EXISTING, win32.win32file.FILE_ATTRIBUTE_NORMAL, t.CPtr(0) + None, win32.win32file.OPEN_EXISTING, win32.win32file.FILE_ATTRIBUTE_NORMAL, None ) if handle == win32.win32base.INVALID_HANDLE_VALUE: return -1 @@ -107,17 +106,17 @@ def mkdir(path: str) -> int: """Create a directory. Return 0 on success, -1 on failure. If path is valid UTF-8, convert to UTF-16 and use CreateDirectoryW; otherwise fall back to the A-series.""" if win32.win32base.utf8_is_valid(path) == 0: - result: BOOL = win32.win32file.CreateDirectoryA(path, t.CPtr(0)) + result: BOOL = win32.win32file.CreateDirectoryA(path, None) if result == 0: return -1 return 0 wp: win32.win32base.WCHARPTR = win32.win32base.utf8_to_utf16_dup(path) if wp is None: - result_a: BOOL = win32.win32file.CreateDirectoryA(path, t.CPtr(0)) + result_a: BOOL = win32.win32file.CreateDirectoryA(path, None) if result_a == 0: return -1 return 0 - result_w: BOOL = win32.win32file.CreateDirectoryW(t.CPtr(wp), t.CPtr(0)) + result_w: BOOL = win32.win32file.CreateDirectoryW(t.CPtr(wp), None) stdlib.free(wp) if result_w == 0: return -1 diff --git a/os/path.vp b/os/path.vp index f6d4ab7..3190022 100644 --- a/os/path.vp +++ b/os/path.vp @@ -1,6 +1,4 @@ -import t, c from stdint import * -import string import memhub import platmacro diff --git a/random.vp b/random.vp index 73ad418..298ebc9 100644 --- a/random.vp +++ b/random.vp @@ -134,37 +134,37 @@ def rdseed64_step(p: uint64*) -> int: # ============================================================ def random_u16() -> uint16: r: uint16 = 0 - for i in range(RDRAND_RETRY_LIMIT): + for i in range(int(RDRAND_RETRY_LIMIT)): if rdrand16_step(&r) == 1: return r return 0 def random_u32() -> uint32: r: uint32 = 0 - for i in range(RDRAND_RETRY_LIMIT): + for i in range(int(RDRAND_RETRY_LIMIT)): if rdrand32_step(&r) == 1: return r return 0 def random_u64() -> uint64: r: uint64 = 0 - for i in range(RDRAND_RETRY_LIMIT): + for i in range(int(RDRAND_RETRY_LIMIT)): if rdrand64_step(&r) == 1: return r return 0 def seed_u16() -> uint16: r: uint16 = 0 - for i in range(RDRAND_RETRY_LIMIT): + for i in range(int(RDRAND_RETRY_LIMIT)): if rdseed16_step(&r) == 1: return r return 0 def seed_u32() -> uint32: r: uint32 = 0 - for i in range(RDRAND_RETRY_LIMIT): + for i in range(int(RDRAND_RETRY_LIMIT)): if rdseed32_step(&r) == 1: return r return 0 def seed_u64() -> uint64: r: uint64 = 0 - for i in range(RDSEED_RETRY_LIMIT): + for i in range(int(RDSEED_RETRY_LIMIT)): if rdseed64_step(&r) == 1: return r return 0 diff --git a/requests/__init__.vp b/requests/__init__.vp index b02c634..d35b789 100644 --- a/requests/__init__.vp +++ b/requests/__init__.vp @@ -299,7 +299,7 @@ def decode_chunked(src: str, src_len: INT, dst: str, dst_cap: INT) -> INT: if size == 0: return w # 4) Copy data + skip CRLF if w + size > dst_cap: return -1 - for k in range(size): + for k in range(int(size)): dst[w + k] = src[r + k] w += size r += size @@ -555,7 +555,7 @@ def _ResolveRedirectUrl(base: str, loc: str, out: str, cap: INT) -> INT: prefix_len: INT = INT(uint64(q) - uint64(base)) need: INT = prefix_len + lb + 2 if need >= cap: return -1 - for i in range(prefix_len): + for i in range(int(prefix_len)): out[i] = base[i] if loc[0] == '/': j: INT = 0 @@ -701,7 +701,7 @@ def _RawHeaderValue(buf: str, total: INT, name: str, out: str, out_size: INT) -> vlen: INT = eol - v if vlen > out_size - 1: vlen = out_size - 1 - for i in range(vlen): + for i in range(int(vlen)): out[i] = buf[v + i] out[vlen] = 0 return 0 diff --git a/requests/download.vp b/requests/download.vp index 55dfbb8..90d6afb 100644 --- a/requests/download.vp +++ b/requests/download.vp @@ -338,7 +338,7 @@ def download(url: str, path: str, threads: INT = 1, handles: t.CArray[VOIDPTR, DL_MAX_THREADS] threads_ok: INT = 0 - for i in range(threads): + for i in range(int(threads)): b_start: sizet = sizet(i) * band if b_start >= total: break @@ -392,21 +392,21 @@ def download(url: str, path: str, threads: INT = 1, return -3 # Wait for all threads to finish - for j in range(threads_ok): + for j in range(int(threads_ok)): wsync.WaitForSingleObject(handles[j], 0xFFFFFFFF) wb.CloseHandle(handles[j]) # Aggregate results total_done: sizet = 0 failed_job: INT = 0 - for k in range(threads_ok): + for k in range(int(threads_ok)): jobk: DlJob* = ctxs[k] total_done += jobk.done if jobk.status != 0: failed_job = 1 # Free thread contexts - for m in range(threads_ok): + for m in range(int(threads_ok)): jobm: DlJob* = ctxs[m] stdlib.free(jobm.path) stdlib.free(jobm.url) diff --git a/requests/https.vp b/requests/https.vp index b16c09a..4038c25 100644 --- a/requests/https.vp +++ b/requests/https.vp @@ -73,7 +73,7 @@ def stream_pull(out: str, cap: INT) -> INT: avail = INT(_st_len - _st_consumed) if avail > cap - 1: avail = cap - 1 - for i in range(sizet(avail)): + for i in range(int(sizet(avail))): out[i] = _st_buf[_st_consumed + i] out[sizet(avail)] = 0 _st_consumed += sizet(avail) @@ -805,7 +805,7 @@ def post_stream(url: str, data: str, content_type: str = "application/json", while True: # Find line end \n nl: INT = -1 - for k in range(llen): + for k in range(int(llen)): if leftover[k] == 10: nl = k break @@ -846,7 +846,7 @@ def post_stream(url: str, data: str, content_type: str = "application/json", _StreamAppendContent(dtx) # 3) Remove processed line rem: INT = llen - (nl + 1) - for j2 in range(rem): + for j2 in range(int(rem)): leftover[j2] = leftover[nl + 1 + j2] llen = rem diff --git a/sys.vp b/sys.vp index 87f420c..47c2e7c 100644 --- a/sys.vp +++ b/sys.vp @@ -86,7 +86,7 @@ def _init_argv_win32(): j: sizet = 0 in_quote: bool = False in_arg: bool = False - for i in range(cmdlen): + for i in range(int(cmdlen)): ch: int = cmdline[i] if ch == 34: # Double quote in_quote = not in_quote @@ -128,7 +128,7 @@ def _init_argv_posix(): # Calculate argument count (\0 delimited) argc: int = 0 total_size: sizet = sizet(total) - for i in range(total_size): + for i in range(int(total_size)): if buf[i] == 0: argc += 1 if argc == 0: return # Allocate pointer array for argv (argc pointers) diff --git a/tarfile.vp b/tarfile.vp index 77bcc6a..5cd9a02 100644 --- a/tarfile.vp +++ b/tarfile.vp @@ -128,7 +128,7 @@ def tar_num(p: uint8*, n: sizet) -> uint64: if n == 0: return 0 if (p[0] & 128) != 0: v: int64 = int64(p[0] & 127) - for i in range(1, n): + for i in range(1, int(n)): v = (v << 8) | int64(p[i]) if v < 0: return 0 return uint64(v) @@ -169,7 +169,7 @@ def tar_put_num(p: uint8*, n: sizet, v: uint64) -> int: # Parse up to the first non-digit as a decimal value (a PAX mtime may carry a fraction). def tar_dec(v: uint8*, n: sizet) -> uint64: out: uint64 = 0 - for i in range(n): + for i in range(int(n)): c: uint8 = v[i] if c < '0' or c > '9': break out = out * 10 + uint64(c - '0') @@ -208,14 +208,14 @@ def tar_pad(n: uint64) -> sizet: # Header checksum: the unsigned byte sum with the checksum field itself read as eight spaces. def tar_checksum(block: uint8*) -> uint32: sum: uint32 = 0 - for i in range(TAR_BLOCK): + for i in range(int(TAR_BLOCK)): if i >= TAR_OFF_CHKSUM and i < TAR_OFF_CHKSUM + 8: sum += 32 else: sum += uint32(block[i]) return sum def tar_is_zero(block: uint8*) -> bool: - for i in range(TAR_BLOCK): + for i in range(int(TAR_BLOCK)): if block[i] != 0: return False return True @@ -497,7 +497,7 @@ def tar_join(dest: str, name: bytes, name_len: sizet) -> bytes: def tar_mkdir_p(path: bytes) -> int: n: sizet = string.strlen(path) if n == 0: return -1 - for i in range(n): + for i in range(int(n)): c: char = path[i] if c != '/' and c != '\\': continue path[i] = 0 @@ -971,7 +971,7 @@ class TarFile: string.memcpy(buf, name, n) buf[n] = '/' buf[n + 1] = 0 - rc: int = self._write_entry(buf, n + 1, mode, 0, 0, uint64(0), mtime, TAR_DIR, None, 0) + rc: int = int(self._write_entry(buf, n + 1, mode, 0, 0, uint64(0), mtime, TAR_DIR, None, 0)) stdlib.free(buf) return rc diff --git a/tomllib/__parser.vp b/tomllib/__parser.vp index 5597fc3..d01547b 100644 --- a/tomllib/__parser.vp +++ b/tomllib/__parser.vp @@ -419,7 +419,7 @@ def _parse_inline_table(s: TomlState*) -> JsonValue*: _advance(s) val: JsonValue* = _parse_value(s) if val == None: return None - tbl: JsonValue* = _dotted_target(s, obj, segs, n, 0) + tbl: JsonValue* = _dotted_target(s, obj, segs, int(n), 0) if tbl == None: return None last: str = segs[n - 1] if tbl[last] != None: return None @@ -669,7 +669,7 @@ def _parse_keyval(s: TomlState*) -> int: _advance(s) val: JsonValue* = _parse_value(s) if val == None: return -1 - tbl: JsonValue* = _dotted_target(s, s.cur, segs, n, 1) + tbl: JsonValue* = _dotted_target(s, s.cur, segs, int(n), 1) if tbl == None: return -1 last: str = segs[n - 1] if tbl[last] != None: return -1 # duplicate key diff --git a/torch/__init__.vp b/torch/__init__.vp index e88b0cb..da93a86 100644 --- a/torch/__init__.vp +++ b/torch/__init__.vp @@ -119,7 +119,7 @@ def fill(t0: Tensor*, val: double): return d: double* = t0.Data n: sizet = t0.Rows * t0.Cols - for i in range(n): + for i in range(int(n)): d[i] = val @@ -159,7 +159,7 @@ def uniform_fill(t0: Tensor*, lo: double, hi: double): d: double* = t0.Data n: sizet = t0.Rows * t0.Cols span: double = hi - lo - for i in range(n): + for i in range(int(n)): d[i] = lo + _next_rand() * span @@ -237,8 +237,8 @@ def linear_fwd(w: Tensor*, b: Tensor*, if acc_buf is None: return accp: double* = acc_buf - for i in range(m): - for j in range(n): + for i in range(int(m)): + for j in range(int(n)): acc: double = bd[j] kk: sizet = 0 while kk + 4 <= k: @@ -286,12 +286,12 @@ def linear_bwd(w: Tensor*, x: Tensor*, string.memset(db.Data, 0, n * sizet(8)) string.memset(dx.Data, 0, m * k * sizet(8)) - for b in range(m): - for j in range(n): + for b in range(int(m)): + for j in range(int(n)): gj: double = gd[b * n + j] if gj != double(0.0): dbd[j] = dbd[j] + gj - for i in range(k): + for i in range(int(k)): dwd[j * k + i] = dwd[j * k + i] + gj * xd[b * k + i] dxd[b * k + i] = dxd[b * k + i] + gj * wd[j * k + i] @@ -334,7 +334,7 @@ def relu_backward(x: Tensor*, g: Tensor*, xd: double* = x.Data gd: double* = g.Data od: double* = gx.Data - for i in range(n): + for i in range(int(n)): if xd[i] > double(0.0): od[i] = gd[i] else: @@ -362,7 +362,7 @@ def softmax_crossentropy(logits: Tensor*, lb: int* = labels total: double = double(0.0) inv_m: double = double(1.0) / double(m) - for b in range(m): + for b in range(int(m)): # Numerically stable softmax mx: double = ld[b * c] j: sizet = 1 @@ -399,7 +399,7 @@ def row_argmax(x: Tensor*, pred: int*): m: sizet = x.Rows c: sizet = x.Cols d: double* = x.Data - for i in range(m): + for i in range(int(m)): best: sizet = 0 bv: double = d[i * c] j: sizet = 1 @@ -420,7 +420,7 @@ def sgd_step(param: Tensor*, lr: double): d: double* = param.Data g: double* = param.Grad n: sizet = param.Rows * param.Cols - for i in range(n): + for i in range(int(n)): d[i] = d[i] - lr * g[i] @@ -437,7 +437,7 @@ def sgd_step_momentum(param: Tensor*, vel: t.CPtr, g: double* = param.Grad v: double* = vel n: sizet = param.Rows * param.Cols - for i in range(n): + for i in range(int(n)): vv: double = momentum * v[i] + g[i] v[i] = vv d[i] = d[i] - lr * vv @@ -500,8 +500,8 @@ def conv2d_fwd(x: t.CPtr, w: t.CPtr, b: t.CPtr, out: t.CPtr, wbd: double* = wb t4d: double* = t4 - for bi in range(n): - for co in range(cout): + for bi in range(int(n)): + for co in range(int(cout)): bias: double = double(0.0) if b is not None: bd: double* = b @@ -509,13 +509,13 @@ def conv2d_fwd(x: t.CPtr, w: t.CPtr, b: t.CPtr, out: t.CPtr, # Pre-broadcast weight scalars: one 4-lane copy per (ci,ky,kx), shared by all output rows/cols of this channel. # Otherwise vbroadcastsd (4 stores) repeats in the 4-lane loop and halves the SIMD gain. if simd_on != 0: - for wb4 in range(kk): + for wb4 in range(int(kk)): wq: double = wd[co * kk + wb4] wbd[wb4 * 4] = wq wbd[wb4 * 4 + 1] = wq wbd[wb4 * 4 + 2] = wq wbd[wb4 * 4 + 3] = wq - for oy in range(hout): + for oy in range(int(hout)): oy0: sizet = oy * stride ox: sizet = 0 while ox < wout: @@ -525,14 +525,14 @@ def conv2d_fwd(x: t.CPtr, w: t.CPtr, b: t.CPtr, out: t.CPtr, t4d[1] = bias t4d[2] = bias t4d[3] = bias - for ci in range(cin): - for ky in range(k): + for ci in range(int(cin)): + for ky in range(int(k)): iy: sizet = oy0 + ky if iy >= pad: yy: sizet = iy - pad if yy < hin: xrow: sizet = ((bi * cin + ci) * hin + yy) * win - for kx in range(k): + for kx in range(int(k)): vipersimd.simd_fma4d( _dptr(x, xrow + ox + kx - pad), _dptr(wb, ((ci * k + ky) * k + kx) * 4), @@ -547,13 +547,13 @@ def conv2d_fwd(x: t.CPtr, w: t.CPtr, b: t.CPtr, out: t.CPtr, # ---- scalar: boundary columns / stride != 1 ---- ox0: sizet = ox * stride acc: double = bias - for ci2 in range(cin): - for ky2 in range(k): + for ci2 in range(int(cin)): + for ky2 in range(int(k)): iy2: sizet = oy0 + ky2 if iy2 >= pad: yy2: sizet = iy2 - pad if yy2 < hin: - for kx2 in range(k): + for kx2 in range(int(k)): ix2: sizet = ox0 + kx2 if ix2 >= pad: xx2: sizet = ix2 - pad @@ -598,8 +598,8 @@ def conv2d_bwd_dw(x: t.CPtr, dout: t.CPtr, dw: t.CPtr, db: t.CPtr, simd_on = 0 accd: double* = acc - for bi in range(n): - for co in range(cout): + for bi in range(int(n)): + for co in range(int(cout)): gp: sizet = (bi * cout + co) * hout * wout # ---- db[co] += sum(g): the whole channel plane of g is contiguous ---- if dbd is not None: @@ -628,16 +628,16 @@ def conv2d_bwd_dw(x: t.CPtr, dout: t.CPtr, dw: t.CPtr, db: t.CPtr, tot0 = tot0 + accd[0] dbd[co] = dbd[co] + tot0 # ---- dw[co][ci][ky][kx] ---- - for ci in range(cin): - for ky in range(k): - for kx in range(k): + for ci in range(int(cin)): + for ky in range(int(k)): + for kx in range(int(k)): tot: double = double(0.0) if simd_on != 0: accd[0] = double(0.0) accd[1] = double(0.0) accd[2] = double(0.0) accd[3] = double(0.0) - for oy in range(hout): + for oy in range(int(hout)): iy: sizet = oy * stride + ky if iy >= pad: yy: sizet = iy - pad @@ -698,17 +698,17 @@ def conv2d_bwd_dx(w: t.CPtr, dout: t.CPtr, dx: t.CPtr, if simd_on != 0: # Weights are constant within one call, so pre-broadcast once (do not repeat vbroadcastsd in the 4-lane loop: 4 stores halves the SIMD gain) wjn: sizet = cout * kk - for wj4 in range(wjn): + for wj4 in range(int(wjn)): wq2: double = wd[wj4] wbd[wj4 * 4] = wq2 wbd[wj4 * 4 + 1] = wq2 wbd[wj4 * 4 + 2] = wq2 wbd[wj4 * 4 + 3] = wq2 - for bi in range(n): - for ci in range(cin): - for ky in range(k): - for oy in range(hout): + for bi in range(int(n)): + for ci in range(int(cin)): + for ky in range(int(k)): + for oy in range(int(hout)): iy: sizet = oy * stride + ky if iy >= pad: yy: sizet = iy - pad @@ -717,8 +717,8 @@ def conv2d_bwd_dx(w: t.CPtr, dout: t.CPtr, dx: t.CPtr, ox: sizet = 0 while ox < wout: if simd_on != 0 and ox >= pad and ox <= smax and ox + 4 <= wout: - for co in range(cout): - for kx in range(k): + for co in range(int(cout)): + for kx in range(int(k)): goff: sizet = ((bi * cout + co) * hout + oy) * wout + ox doff: sizet = dxrow + ox + kx - pad vipersimd.simd_fma4d( @@ -727,8 +727,8 @@ def conv2d_bwd_dx(w: t.CPtr, dout: t.CPtr, dx: t.CPtr, _dptr(dx, doff), _dptr(dx, doff)) ox += 4 else: - for co2 in range(cout): - for kx2 in range(k): + for co2 in range(int(cout)): + for kx2 in range(int(k)): ix: sizet = ox * stride + kx2 if ix >= pad: xx: sizet = ix - pad @@ -756,19 +756,19 @@ def maxpool2d_fwd(x: t.CPtr, out: t.CPtr, argmax: t.CPtr, xd: double* = x od: double* = out am: int* = argmax - for bi in range(n): - for ch in range(c): + for bi in range(int(n)): + for ch in range(int(c)): plano: sizet = (bi * c + ch) * hin * win - for oy in range(hout): + for oy in range(int(hout)): oy0: sizet = oy * stride - for ox in range(wout): + for ox in range(int(wout)): ox0: sizet = ox * stride best: double = double(0.0) bidx: int = 0 first: int = 1 - for ky in range(k): + for ky in range(int(k)): yy: sizet = oy0 + ky - for kx in range(k): + for kx in range(int(k)): xx: sizet = ox0 + kx v: double = xd[plano + yy * win + xx] if first != 0 or v > best: @@ -792,11 +792,11 @@ def maxpool2d_bwd(dout: t.CPtr, argmax: t.CPtr, dx: t.CPtr, am: int* = argmax dxd: double* = dx string.memset(dx, 0, n * c * hin * win * sizet(8)) - for bi in range(n): - for ch in range(c): + for bi in range(int(n)): + for ch in range(int(c)): plano: sizet = (bi * c + ch) * hin * win - for oy in range(hout): - for ox in range(wout): + for oy in range(int(hout)): + for ox in range(int(wout)): oi: sizet = (bi * c + ch) * hout * wout + oy * wout + ox tgt: sizet = plano + sizet(am[oi]) dxd[tgt] = dxd[tgt] + gd[oi] diff --git a/traceback.vp b/traceback.vp index e478ea2..bb65e4e 100644 --- a/traceback.vp +++ b/traceback.vp @@ -197,7 +197,7 @@ import win32.win32dbghelp as dbg # a compiler intrinsic, has no exported symbol, and is not linkable). # New this round (real Python traceback output): **this module's own declaration** of kernel32!GetEnvironmentVariableA # (not declared by win32base; the repo declares it only in VET/App/lib/VDirs.vp:45; kernel32 is linked anyway, so both TPC and -# TPV can resolve it), used for the TRACEBACK_DIAG switch; everything else uses only existing APIs (see section 13). +# VPC can resolve it), used for the TRACEBACK_DIAG switch; everything else uses only existing APIs (see section 13). # # ----------------------------------------------------------------------------- # 9. Actionable conclusions for "0 frames" (which case -> which live field to look at) @@ -333,7 +333,7 @@ import win32.win32dbghelp as dbg # C. **Whether the frame pointer is preserved** (investigation conclusion and TPC-side fix location; this module reports only, no change): # * The single llc call site = `TransPyC/lib/Projectrans/Phase2Translator.py:2160 _llc_compile`, # which appends `-frame-pointer=all` to the command when `--traceback` is on (2187-2193); -# the App module (e.g. `TransPyV/App/lib/core/Gen/Expr/ExprGenOps.vp`, module sha1 +# the App module (e.g. `ViperC/App/lib/core/Gen/Expr/ExprGenOps.vp`, module sha1 # `8a96a2885bae09ca`) goes through the **same** call site (2608's _dso.ll / 2319's inlining merge), # so the flag's location itself is fine. # * Cache invalidation: App module obj = `output/{sha1}.obj`, `_compile_ll_files` skips it if it exists @@ -343,7 +343,7 @@ import win32.win32dbghelp as dbg # * Delivery conclusion: if `[diag] rbp:` shows `[rbp+8]` is still not a return address (`ret_out_of_module`), # then `-frame-pointer=all` (a flag at the level of an llc default) did not take effect; the most robust fix is to annotate # `"frame-pointer"="all"` explicitly per function **in the IR** -- location -# `TransPyV/App/lib/core/Gen/Func/FuncGenBase.vp` (attribute assembly `_append_llvm_attr`, 154-181) +# `ViperC/App/lib/core/Gen/Func/FuncGenBase.vp` (attribute assembly `_append_llvm_attr`, 154-181) # and `TransPyC/lib/core/Handles/HandlesFunctions.py:1735` (next to `func.attributes.add('noredzone')` # ) -- making the frame pointer a **function attribute** rather than an llc command-line default, immune at the root to "whether llc honors the default". # * [Extra measurement, Test/LLvmLiteTest Ctrl+C] `RBP=0x0`, RIP in a system DLL: the reject reason is @@ -427,7 +427,7 @@ import win32.win32dbghelp as dbg # This module needs kernel32!GetEnvironmentVariableA for the TRACEBACK_DIAG switch, but # includes/win32/win32base.vp does not declare it (the repository declares it only in # VET/App/lib/VDirs.vp:45). Declared here with the same style; kernel32 is linked anyway, -# so both TPC and TPV resolve it. +# so both TPC and VPC resolve it. # DWORD GetEnvironmentVariableA(LPCSTR lpName, LPSTR lpBuffer, DWORD nSize); extern def GetEnvironmentVariableA(lpName: LPCSTR, lpBuffer: CHARPTR, nSize: DWORD) -> DWORD @@ -1431,7 +1431,7 @@ def ScanStack(StartIndex: int, Rsp: uint64, Base: uint64) -> int: EmitLine(D1) Stop = "block_read_failed" break - for k in range(N): + for k in range(int(N)): W: uint64 = Words[int(k)] if W >= Base and W < ModEnd: # A neighbouring 8-byte word (A-8 or A+8) looks like a stack address: accept W. @@ -1446,7 +1446,7 @@ def ScanStack(StartIndex: int, Rsp: uint64, Base: uint64) -> int: # Deduplicate by candidate value (discovered in ascending stack order, so the # order is kept). Dup: int = 0 - for t_i in range(Hits): + for t_i in range(int(Hits)): if Found[t_i] == W: Dup = 1 break @@ -1758,13 +1758,13 @@ def DumpMainThread(IsBreak: int) -> int: SavedCount: int = _State.FrameCount SaveAddrBuf: [TRACEBACK_FRAME_BUF]uint64 SaveScanBuf: [TRACEBACK_FRAME_BUF]int32 - for si in range(SavedCount): + for si in range(int(SavedCount)): SaveAddrBuf[si] = _State.FrameAddr[si] SaveScanBuf[si] = _State.FrameScan[si] _State.FrameCount = 0 F2: int = WalkViaDbgHelp(wp.GetCurrentProcess(), hThread, _State.ContextBuf, Base) if F2 == 0: - for ri in range(SavedCount): + for ri in range(int(SavedCount)): if FramePush(SaveAddrBuf[ri], int(SaveScanBuf[ri])) == 0: break # The count that is actually buffered is authoritative. diff --git a/viperio.vp b/viperio.vp index 12658dc..1679c71 100644 --- a/viperio.vp +++ b/viperio.vp @@ -21,7 +21,7 @@ class Buf: avail: sizet = self.capacity - self.length if avail <= 0: return 0 n: sizet = count if count < avail else avail - for i in range(n): + for i in range(int(n)): self.data[self.length + i] = src[i] self.length += n # When exactly full (n==avail), data[capacity] would overflow by 1 byte, so guard it diff --git a/vipersimd.vp b/vipersimd.vp index 95d6557..7abcd26 100644 --- a/vipersimd.vp +++ b/vipersimd.vp @@ -623,7 +623,7 @@ vzeroupper""", op=[ASM_DESCR.CLOBBER_MEMORY, 'ymm0', 'ymm2', 'rcx', 'r8', 'r10']) -def simd_dot_array(a: double*, b: double*, n: sizet, out: double): +def simd_dot_array(a: double*, b: double*, n: sizet, out: double*): """AVX2 batch: out[0] = dot(a[0:n], b[0:n]) using FMA accumulation""" __asm__(f"""mov rcx, {asminp(n, ASM_DESCR.REG_ANY)} shr rcx, 2 diff --git a/vqt6/__init__.vp b/vqt6/__init__.vp index 79b3975..bddadff 100644 --- a/vqt6/__init__.vp +++ b/vqt6/__init__.vp @@ -96,10 +96,10 @@ def qtree_checked_count(tw: QtTreeWidgetPtr) -> int: """Count checked leaf nodes.""" n: int = 0 top_n: int = vqt6_qtreewidget_top_level_item_count(tw) - for gi in range(top_n): + for gi in range(int(top_n)): g: QtTreeWidgetItemPtr = vqt6_qtreewidget_top_level_item(tw, gi) cn: int = vqt6_qtreewidgetitem_child_count(g) - for ci in range(cn): + for ci in range(int(cn)): it: QtTreeWidgetItemPtr = vqt6_qtreewidgetitem_child(g, ci) if vqt6_qtreewidgetitem_check_state(it) == 2: n += 1 @@ -110,10 +110,10 @@ def qtree_checked_size(tw: QtTreeWidgetPtr) -> int: """Sum disk usage (MB) of checked leaf nodes.""" mb: int = 0 top_n: int = vqt6_qtreewidget_top_level_item_count(tw) - for gi in range(top_n): + for gi in range(int(top_n)): g: QtTreeWidgetItemPtr = vqt6_qtreewidget_top_level_item(tw, gi) cn: int = vqt6_qtreewidgetitem_child_count(g) - for ci in range(cn): + for ci in range(int(cn)): it: QtTreeWidgetItemPtr = vqt6_qtreewidgetitem_child(g, ci) if vqt6_qtreewidgetitem_check_state(it) == 2: mb += vqt6_qtreewidgetitem_data_int(it) diff --git a/zipfile.vp b/zipfile.vp index 6c63312..cffac39 100644 --- a/zipfile.vp +++ b/zipfile.vp @@ -140,7 +140,7 @@ def zf_write_all(h: wb.HANDLE, p: uint8*, n: sizet) -> int: if chunk > 0xFFFFFF00: chunk = 0xFFFFFF00 written: ulong = 0 - ok: int = wf.WriteFile(h, p + done, ulong(chunk), &written, None) + ok: int = int(wf.WriteFile(h, p + done, ulong(chunk), &written, None)) if ok == 0 or written == 0: global zipfile_error_code_val, zipfile_error_msg zipfile_error_code_val = ZIP_ERR_IO @@ -157,7 +157,7 @@ def zf_read_all(h: wb.HANDLE, p: uint8*, n: sizet) -> int: if chunk > 0xFFFFFF00: chunk = 0xFFFFFF00 bytes_read: ulong = 0 - ok: int = wf.ReadFile(h, p + done, ulong(chunk), &bytes_read, None) + ok: int = int(wf.ReadFile(h, p + done, ulong(chunk), &bytes_read, None)) if ok == 0 or bytes_read == 0: global zipfile_error_code_val, zipfile_error_msg zipfile_error_code_val = ZIP_ERR_IO @@ -330,7 +330,7 @@ class ZipFile: cp: sizet = sizet(cd_off) end: sizet = sizet(cd_off) + sizet(cd_size) - for idx in range(total): + for idx in range(int(total)): if cp + 46 > end: zipfile_set_error(ZIP_ERR_NOT_ZIP, "central directory entry truncated") return ZIP_ERR_NOT_ZIP diff --git a/zlib/zchecksum.vp b/zlib/zchecksum.vp index 9e75813..98b449b 100644 --- a/zlib/zchecksum.vp +++ b/zlib/zchecksum.vp @@ -8,7 +8,7 @@ def zchecksum_adler32(data: UINT8PTR, length: sizet, init: UINT32) -> uint32: if not data or length == 0: return init i: sizet - for i in range(length): + for i in range(int(length)): a = (a + data[i]) % 65521 b = (b + a) % 65521 return (b << 16) | a @@ -84,6 +84,6 @@ def zchecksum_crc32(data: UINT8PTR, length: sizet, init: uint32) -> uint32: crc: uint32 = init ^ 0xFFFFFFFF if not data or length == 0: return init i: sizet - for i in range(length): + for i in range(int(length)): crc = crc32_table[(crc ^ data[i]) & 0xFF] ^ (crc >> 8) return crc ^ 0xFFFFFFFF diff --git a/zlib/zdef.vp b/zlib/zdef.vp index fbd28ab..5da7dae 100644 --- a/zlib/zdef.vp +++ b/zlib/zdef.vp @@ -129,7 +129,7 @@ class zbit_writer: def write_bits(self, value: UINT, nbits: int): self.ensure((nbits + 7) / 8 + 1) - for i in range(nbits): + for i in range(int(nbits)): if value & (UINT(1) << i): self.buf[self.byte_pos] |= (UINT(1) << self.bit_pos) self.bit_pos += 1 @@ -139,7 +139,7 @@ class zbit_writer: def write_bits_rev(self, code: UINT, nbits: int): self.ensure((nbits + 7) / 8 + 1) - for i in range(nbits - 1, -1, -1): + for i in range(int(nbits - 1), -1, -1): if code & (UINT(1) << i): self.buf[self.byte_pos] |= (UINT(1) << self.bit_pos) self.bit_pos += 1 @@ -164,7 +164,7 @@ class zbit_writer: self.ensure(block_length) i: sizet = 0 - for i in range(block_length): + for i in range(int(block_length)): self.buf[self.byte_pos] = data[pos + i] self.byte_pos += 1 pos += block_length @@ -242,7 +242,7 @@ class zbit_reader: def read_bits(self, nbits: int, out: UINTPTR) -> int: val: UINT = 0 - for i in range(nbits): + for i in range(int(nbits)): if self.byte_pos >= self.length: return -1 if self.buf[self.byte_pos] & (UINT(1) << self.bit_pos): val |= (UINT(1) << i) @@ -255,7 +255,7 @@ class zbit_reader: def read_bits_rev(self, nbits: int, out: UINTPTR) -> int: val: UINT = 0 - for i in range(nbits - 1, 0, -1): + for i in range(int(nbits - 1), 0, -1): if self.byte_pos >= self.length: return -1 if self.buf[self.byte_pos] & (UINT(1) << self.bit_pos): val |= (UINT(1) << i) diff --git a/zlib/zdeflate.vp b/zlib/zdeflate.vp index b970677..7d4e91b 100644 --- a/zlib/zdeflate.vp +++ b/zlib/zdeflate.vp @@ -82,7 +82,7 @@ class zdeflate_stream: extra = zdef.zdeflate_dist_extra_bits[dist_sym] if extra > 0: self.writer.write_bits(best_dist - zdef.zdeflate_dist_base[dist_sym], extra) - for i in range(match_len): + for i in range(int(match_len)): self.update_hash(data, pos + i, length) pos += match_len else: @@ -110,7 +110,7 @@ class zdeflate_stream: extra = zdef.zdeflate_dist_extra_bits[dist_sym] if extra > 0: self.writer.write_bits(best_dist - zdef.zdeflate_dist_base[dist_sym], extra) - for j in range(match_len): + for j in range(int(match_len)): self.update_hash(data, pos + j, length) pos += match_len else: @@ -133,8 +133,8 @@ class zdeflate_stream: lit_tree.build_codes(lit_freqs, hlit, zdef.ZDEFLATE_MAX_BITS) dist_tree.build_codes(dist_freqs, hdist, zdef.ZDEFLATE_MAX_BITS) all_lengths: t.CArray[int, 288 + 32] - for i in range(hlit): all_lengths[i] = lit_tree.codes[i].bits - for i in range(hdist): all_lengths[hlit + i] = dist_tree.codes[i].bits + for i in range(int(hlit)): all_lengths[i] = lit_tree.codes[i].bits + for i in range(int(hdist)): all_lengths[hlit + i] = dist_tree.codes[i].bits total_lengths: int = hlit + hdist cl_freqs: t.CArray[int, 19] zdeflate_count_cl_freqs(all_lengths, total_lengths, cl_freqs) @@ -147,7 +147,7 @@ class zdeflate_stream: self.writer.write_bits(hlit - 257, 5) self.writer.write_bits(hdist - 1, 5) self.writer.write_bits(hclen - 4, 4) - for j in range(hclen): + for j in range(int(hclen)): self.writer.write_bits(cl_tree.codes[zdef.zdeflate_codelen_order[j]].bits, 3) zdeflate_write_cl_encoded(all_lengths, total_lengths, &self.writer, &cl_tree) self.encode_block_data(data, length, &lit_tree, &dist_tree) @@ -271,7 +271,7 @@ def zdeflate_count_freqs(lit_freqs: INTPTR, dist_freqs: INTPTR, len_sym: int = zdeflate_len_to_symbol(match_len) lit_freqs[len_sym] += 1 dist_freqs[zdeflate_dist_to_symbol(best_dist)] += 1 - for i in range(match_len): + for i in range(int(match_len)): zdeflate_stream.update_hash(s, data, pos + i, length) pos += match_len else: diff --git a/zlib/zhuff.vp b/zlib/zhuff.vp index ff2d25f..0cea11e 100644 --- a/zlib/zhuff.vp +++ b/zlib/zhuff.vp @@ -31,15 +31,15 @@ class zhuff_tree: self.max_bits = max_bits self.build_code_lengths(lengths, freqs, count, max_bits) string.memset(bl_count, 0, bl_count.__sizeof__()) - for i in range(count): + for i in range(int(count)): if lengths[i] > 0: bl_count[lengths[i]] += 1 code: uint = 0 next_code[0] = 0 - for bits in range(1, max_bits + 1): + for bits in range(1, int(max_bits + 1)): code = (code + bl_count[bits - 1]) << 1 next_code[bits] = code - for i in range(count): + for i in range(int(count)): self.codes[i].bits = lengths[i] if lengths[i] > 0: self.codes[i].code = next_code[lengths[i]] @@ -58,7 +58,7 @@ class zhuff_tree: bl_count[lengths[i]] += 1 code: uint = 0 next_code[0] = 0 - for bits in range(1, 9 + 1): + for bits in range(1, int(9 + 1)): code = (code + bl_count[bits - 1]) << 1 next_code[bits] = code self.count = 288 @@ -82,7 +82,7 @@ class zhuff_tree: bl_count[lengths[i]] += 1 code: uint = 0 next_code[0] = 0 - for bits in range(1, 5 + 1): + for bits in range(1, int(5 + 1)): code = (code + bl_count[bits - 1]) << 1 next_code[bits] = code self.count = 32 @@ -108,24 +108,24 @@ class zhuff_tree: sort_count: int = 0 string.memset(bl_count, 0, bl_count.__sizeof__()) string.memset(lengths, 0, int.__sizeof__() * count) - for i in range(count): + for i in range(int(count)): if freqs[i] > 0: sort_count += 1 if sort_count == 0: return if sort_count == 1: - for i in range(count): + for i in range(int(count)): if freqs[i] > 0: lengths[i] = 1 return items: int* = INTPTR(zdef.zdef_alloc(self.pool, sort_count * int.__sizeof__())) item_freqs: int* = INTPTR(zdef.zdef_alloc(self.pool, sort_count * int.__sizeof__())) idx: int = 0 - for i in range(count): + for i in range(int(count)): if freqs[i] > 0: items[idx] = i item_freqs[idx] = freqs[i] idx += 1 - for i in range(sort_count): + for i in range(int(sort_count)): key_item: int = items[i] key_freq: int = item_freqs[i] j: int = i - 1 @@ -136,11 +136,11 @@ class zhuff_tree: items[j + 1] = key_item item_freqs[j + 1] = key_freq parent: INTPTR = INTPTR(zdef.zdef_alloc(self.pool, (sort_count * 2) * int.__sizeof__())) - for i in range(sort_count * 2): + for i in range(int(sort_count * 2)): parent[i] = -1 heap: INTPTR = INTPTR(zdef.zdef_alloc(self.pool, (sort_count + 1) * int.__sizeof__())) heap_size: int = 0 - for i in range(sort_count): + for i in range(int(sort_count)): heap[heap_size] = i heap_size += 1 pos: int = heap_size - 1 @@ -153,7 +153,7 @@ class zhuff_tree: pos = par else: break combined_freq: INTPTR = INTPTR(zdef.zdef_alloc(self.pool, (sort_count * 2) * int.__sizeof__())) - for i in range(sort_count): + for i in range(int(sort_count)): combined_freq[i] = item_freqs[i] internal: int = sort_count while heap_size > 1: @@ -209,7 +209,7 @@ class zhuff_tree: pos = par else: break internal += 1 - for i in range(sort_count): + for i in range(int(sort_count)): node: int = i length: int = 0 while parent[node] >= 0: @@ -217,11 +217,11 @@ class zhuff_tree: node = parent[node] lengths[items[i]] = length string.memset(bl_count, 0, bl_count.__sizeof__()) - for i in range(count): + for i in range(int(count)): if lengths[i] > 0: bl_count[lengths[i]] += 1 overflow: int = 0 - for i in range(count): + for i in range(int(count)): if lengths[i] > max_bits: overflow += 1 bl_count[lengths[i]] -= 1 @@ -238,18 +238,18 @@ class zhuff_tree: overflow -= 2 sorted_items: INTPTR = INTPTR(zdef.zdef_alloc(self.pool, sort_count * int.__sizeof__())) si: int = 0 - for i in range(count): + for i in range(int(count)): if freqs[i] > 0: sorted_items[si] = i si += 1 - for i in range(si - 1): - for j in range(i + 1, si): + for i in range(int(si - 1)): + for j in range(int(i + 1), int(si)): if lengths[sorted_items[i]] < lengths[sorted_items[j]]: tmp: int = sorted_items[i] sorted_items[i] = sorted_items[j] sorted_items[j] = tmp sidx: int = 0 - for bits in range(max_bits, 1, -1): + for bits in range(int(max_bits), 1, -1): n: int = bl_count[bits] while n > 0 and sidx < si: lengths[sorted_items[sidx]] = bits @@ -263,10 +263,10 @@ class zhuff_tree: zdef.zdef_free(self.pool, items) def get_fixed_lit_lengths(self, lengths: INTPTR): - for i in range( 0, 143 + 1): lengths[i] = 8 - for i in range(143 + 1, 255 + 1): lengths[i] = 9 - for i in range(255 + 1, 279 + 1): lengths[i] = 7 - for i in range(279 + 1, 287 + 1): lengths[i] = 8 + for i in range( 0, int(143 + 1)): lengths[i] = 8 + for i in range(int(143 + 1), int(255 + 1)): lengths[i] = 9 + for i in range(int(255 + 1), int(279 + 1)): lengths[i] = 7 + for i in range(int(279 + 1), int(287 + 1)): lengths[i] = 8 def get_fixed_dist_lengths(self, lengths: INTPTR): for i in range(32): @@ -277,19 +277,19 @@ class zhuff_tree: next_code: t.CArray[uint, 16] string.memset(bl_count, 0, bl_count.__sizeof__()) - for i in range(count): + for i in range(int(count)): if lengths[i] > 0: bl_count[lengths[i]] += 1 code: UINT = 0 next_code[0] = 0 - for bits in range(1, max_bits + 1): + for bits in range(1, int(max_bits + 1)): code = (code + bl_count[bits - 1]) << 1 next_code[bits] = code self.count = count self.max_bits = max_bits - for i in range(count): + for i in range(int(count)): self.codes[i].bits = lengths[i] if lengths[i] > 0: self.codes[i].code = next_code[lengths[i]] @@ -318,10 +318,10 @@ class zhuff_decode_tree: self.nodes[0].children[0] = -1 self.nodes[0].children[1] = -1 self.nodes[0].symbol = -1 - for i in range(ht.count): + for i in range(int(ht.count)): if ht.codes[i].bits == 0: continue node: int = 0 - for bit in range(ht.codes[i].bits - 1, -1, -1): + for bit in range(int(ht.codes[i].bits - 1), -1, -1): dir: int = (ht.codes[i].code >> bit) & 1 if bit > 0: # Internal node: traverse or create diff --git a/zlib/zinflate.vp b/zlib/zinflate.vp index 79eb361..39e6fe7 100644 --- a/zlib/zinflate.vp +++ b/zlib/zinflate.vp @@ -96,7 +96,7 @@ class zinflate_stream: def read_bits_from_input(self, nbits: int, out: UINTPTR) -> int: val: UINT = 0 - for i in range(nbits): + for i in range(int(nbits)): if self.input_pos >= self.input_len: return -3 if self.input_data[self.input_pos] & (UINT(1) << (self.reader.bit_pos)): val |= (UINT(1) << i) @@ -129,7 +129,7 @@ class zinflate_stream: if (length ^ nlen) != 0xFFFF: return -3 if self.input_pos + length > self.input_len: return -3 i: uint - for i in range(length): + for i in range(int(length)): self.output_byte(self.input_data[self.input_pos]) self.input_pos += 1 return 0 @@ -190,7 +190,7 @@ class zinflate_stream: break dist += extra_val - for i in range(length): + for i in range(int(length)): if self.max_length > 0 and self.output_len >= self.max_length: break src_pos: int = (self.window_pos - dist) & (zdef.ZDEFLATE_WINDOW_SIZE - 1) byte: BYTE = self.window[src_pos] @@ -215,7 +215,7 @@ class zinflate_stream: cl_lengths: t.CArray[int, 19] string.memset(cl_lengths, 0, cl_lengths.__sizeof__()) - for i in range(hclen): + for i in range(int(hclen)): len_val: UINT if self.read_bits_from_input(3, &len_val) != 0: return -3 cl_lengths[zdef.zdeflate_codelen_order[i]] = int(len_val) @@ -250,7 +250,7 @@ class zinflate_stream: return -3 prev: int = all_lengths[idx - 1] i: uint - for i in range(rep): + for i in range(int(rep)): all_lengths[idx] = prev idx += 1 elif sym == 17: @@ -263,7 +263,7 @@ class zinflate_stream: zdef.zdef_free(self.pool, all_lengths) return -3 i: uint - for i in range(rep): + for i in range(int(rep)): all_lengths[idx] = 0 idx += 1 else: @@ -276,7 +276,7 @@ class zinflate_stream: zdef.zdef_free(self.pool, all_lengths) return -3 i: uint - for i in range(rep): + for i in range(int(rep)): all_lengths[idx] = 0 idx += 1 @@ -285,13 +285,13 @@ class zinflate_stream: lit_lengths: t.CArray[int, 288] string.memset(lit_lengths, 0, lit_lengths.__sizeof__()) - for i in range(hlit): + for i in range(int(hlit)): lit_lengths[i] = all_lengths[i] lit_tree.build_tree_from_lengths(lit_lengths, hlit, zdef.ZDEFLATE_MAX_BITS) dist_lengths: t.CArray[int, 32] string.memset(dist_lengths, 0, dist_lengths.__sizeof__()) - for i in range(hdist): + for i in range(int(hdist)): dist_lengths[i] = all_lengths[hlit + i] dist_tree.build_tree_from_lengths(dist_lengths, hdist, zdef.ZDEFLATE_MAX_BITS) @@ -326,7 +326,7 @@ class zinflate_stream: extra_val: UINT if self.read_bits_from_input(extra, &extra_val) != 0: return -3 dist += extra_val - for i in range(length): + for i in range(int(length)): if self.max_length > 0 and self.output_len >= self.max_length: return 0 src_pos: int = (self.window_pos - dist) & (zdef.ZDEFLATE_WINDOW_SIZE - 1) byte: BYTE = self.window[src_pos] @@ -435,7 +435,7 @@ def zinflate_one_shot(pool: memhub.MemManager*, data: UINT8PTR, length: sizet, s: zinflate_stream* = zinflate_create(pool, wbits) if not s: return None out: uint8* = None - err: int = s.decompress(data, length, 0, &out, out_len) + err: int = int(s.decompress(data, length, 0, &out, out_len)) s.destroy() if err != 0: return None return out