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

将 _dict 的部分写法升级到最新范式，裸指针 uint64 手动计算便宜还需要重新处理，链表暂未做 linkedlist 范式化

Browse Source
This commit is contained in:
TermiNexus committed 2026-09-30 00:34:40 +08:00
1 parent ef61975165
commit f69e71b198
1 file changed
+62 -63
Download Patch File Download Diff File Expand all files Collapse all files
_dict.vp
+62 -63
View File
@@ -2,7 +2,7 @@ import t, c
import memhub import memhub
import string import string
import json import json
from stdint import *
# Variant type tags (consistent with _variant.py) # Variant type tags (consistent with _variant.py)
define VARIANT_NONE = 0 # Untyped / null value define VARIANT_NONE = 0 # Untyped / null value
@@ -29,14 +29,14 @@ class dict:
d: dict = dict(mb) d: dict = dict(mb)
d.set_int("x", 42) d.set_int("x", 42)
p: t.CPtr = d["x"] p: t.CPtr = d["x"]
v: int = c.Deref((int | t.CPtr)(p)) # int 值按 i32 存，读回须给 int* 视图 v: int = c.Deref((int*)(p)) # int 值按 i32 存，读回须给 int* 视图
# Nested dict # Nested dict
inner: dict = dict(mb) inner: dict = dict(mb)
inner.set_int("a", 1) inner.set_int("a", 1)
d.set_dict("sub", inner) d.set_dict("sub", inner)
sub: dict = c.Deref(d["sub"]) sub: dict = c.Deref(d["sub"])
av: int = c.Deref((int | t.CPtr)(sub["a"])) av: int = c.Deref((int*)(sub["a"]))
""" """
__keys__: rawptr __keys__: rawptr
__values__: rawptr __values__: rawptr
@@ -64,14 +64,14 @@ class dict:
if string.strcmp(key_ptr[0], key) == 0: return i if string.strcmp(key_ptr[0], key) == 0: return i
return self.__count__ return self.__count__
def __getitem__(self, key: str) -> t.CPtr: def __getitem__(self, key: str) -> rawptr:
"""Return untyped pointer to value. Use c.Deref to resolve the actual value. """Return untyped pointer to value. Use c.Deref to resolve the actual value.
Example: p: t.CPtr = d["x"]; v: int = c.Deref((int | t.CPtr)(p))""" Example: p: rawptr = d["x"]; v: int = *(int*(p))"""
idx: sizet = self._find(key) idx: sizet = self._find(key)
if idx >= self.__count__: return None if idx >= self.__count__: return None
# Variant.ptr is located at offset 8 within Variant structure # Variant.ptr is located at offset 8 within Variant structure
val_ptr: str | t.CPtr = (str | t.CPtr)(uint64(self.__values__) + idx * _VARIANT_SIZE + 8) val_ptr: str* = str*(uint64(self.__values__) + idx * _VARIANT_SIZE + 8)
return val_ptr[0] return *val_ptr
def __setitem__(self, key: str, val: t.CNeedPtr): def __setitem__(self, key: str, val: t.CNeedPtr):
"""Store value as VARIANT_PTR. Address is automatically resolved via t.CNeedPtr. """Store value as VARIANT_PTR. Address is automatically resolved via t.CNeedPtr.
@@ -79,31 +79,31 @@ class dict:
Use typed methods such as set_int / set_str for persistent storage.""" Use typed methods such as set_int / set_str for persistent storage."""
self._set_variant_raw(key, VARIANT_PTR, val) self._set_variant_raw(key, VARIANT_PTR, val)
def _set_variant_raw(self, key: str, vtype: t.CInt, ptr: t.CPtr): def _set_variant_raw(self, key: str, vtype: int, ptr: t.CPtr):
"""Internal method: store Variant entry (vtype + ptr). No automatic address resolution.""" """Internal method: store Variant entry (vtype + ptr). No automatic address resolution."""
idx: sizet = self._find(key) idx: sizet = self._find(key)
if idx < self.__count__: if idx < self.__count__:
# Update existing key # Update existing key
vtype_ptr: t.CInt | t.CPtr = t.CPtr(uint64(self.__values__) + idx * _VARIANT_SIZE) vtype_ptr: int* = int*(uint64(self.__values__) + idx * _VARIANT_SIZE)
vtype_ptr[0] = vtype vtype_ptr[0] = vtype
val_ptr: str | t.CPtr = (str | t.CPtr)(uint64(self.__values__) + idx * _VARIANT_SIZE + 8) val_ptr: str* = str*(uint64(self.__values__) + idx * _VARIANT_SIZE + 8)
val_ptr[0] = ptr val_ptr[0] = ptr
return return
if self.__count__ >= self.__capacity__: if self.__count__ >= self.__capacity__:
new_cap: sizet = self.__capacity__ * 2 new_cap: sizet = self.__capacity__ * 2
new_keys: t.CPtr = self.__mbuddy__.alloc(new_cap * 8) new_keys: rawptr = self.__mbuddy__.alloc(new_cap * 8)
new_values: t.CPtr = self.__mbuddy__.alloc(new_cap * _VARIANT_SIZE) new_values: rawptr = self.__mbuddy__.alloc(new_cap * _VARIANT_SIZE)
if new_keys is None or new_values is None: return if new_keys is None or new_values is None: return
string.memcpy(new_keys, self.__keys__, self.__count__ * 8) string.memcpy(new_keys, self.__keys__, self.__count__ * 8)
string.memcpy(new_values, self.__values__, self.__count__ * _VARIANT_SIZE) string.memcpy(new_values, self.__values__, self.__count__ * _VARIANT_SIZE)
self.__keys__ = new_keys self.__keys__ = new_keys
self.__values__ = new_values self.__values__ = new_values
self.__capacity__ = new_cap self.__capacity__ = new_cap
key_ptr: str | t.CPtr = (str | t.CPtr)(uint64(self.__keys__) + self.__count__ * 8) key_ptr: str* = str*(uint64(self.__keys__) + self.__count__ * 8)
key_ptr[0] = key key_ptr[0] = key
vtype_ptr: t.CInt | t.CPtr = t.CPtr(uint64(self.__values__) + self.__count__ * _VARIANT_SIZE) vtype_ptr: int* = int*(uint64(self.__values__) + self.__count__ * _VARIANT_SIZE)
vtype_ptr[0] = vtype vtype_ptr[0] = vtype
val_ptr: str | t.CPtr = (str | t.CPtr)(uint64(self.__values__) + self.__count__ * _VARIANT_SIZE + 8) val_ptr: str* = str*(uint64(self.__values__) + self.__count__ * _VARIANT_SIZE + 8)
val_ptr[0] = ptr val_ptr[0] = ptr
self.__count__ += 1 self.__count__ += 1
@@ -113,9 +113,9 @@ class dict:
def set_int(self, key: str, val: int): def set_int(self, key: str, val: int):
"""Store integer value (VARIANT_INT). Value is copied to persistent storage within __mbuddy__.""" """Store integer value (VARIANT_INT). Value is copied to persistent storage within __mbuddy__."""
storage: t.CPtr = self.__mbuddy__.alloc(8) storage: rawptr = self.__mbuddy__.alloc(8)
int_ptr: int | t.CPtr = t.CPtr(uint64(storage)) int_ptr: int* = int*(storage)
int_ptr[0] = val *int_ptr = val
self._set_variant_raw(key, VARIANT_INT, storage) self._set_variant_raw(key, VARIANT_INT, storage)
def set_str(self, key: str, val: str): def set_str(self, key: str, val: str):
@@ -124,19 +124,19 @@ class dict:
def set_float(self, key: str, val: float): def set_float(self, key: str, val: float):
"""Store float value (VARIANT_FLOAT). Value is copied to persistent storage within __mbuddy__.""" """Store float value (VARIANT_FLOAT). Value is copied to persistent storage within __mbuddy__."""
storage: t.CPtr = self.__mbuddy__.alloc(8) storage: rawptr = self.__mbuddy__.alloc(8)
float_ptr: float | t.CPtr = t.CPtr(uint64(storage)) float_ptr: float* = float*(storage)
float_ptr[0] = val *float_ptr = val
self._set_variant_raw(key, VARIANT_FLOAT, storage) self._set_variant_raw(key, VARIANT_FLOAT, storage)
def set_double(self, key: str, val: t.CDouble): def set_double(self, key: str, val: double):
"""Store double value (VARIANT_DOUBLE). Value is copied to persistent storage within __mbuddy__.""" """Store double value (VARIANT_DOUBLE). Value is copied to persistent storage within __mbuddy__."""
storage: t.CPtr = self.__mbuddy__.alloc(8) storage: rawptr = self.__mbuddy__.alloc(8)
dbl_ptr: t.CDouble | t.CPtr = t.CPtr(uint64(storage)) dbl_ptr: double* = double*(storage)
dbl_ptr[0] = val *dbl_ptr = val
self._set_variant_raw(key, VARIANT_DOUBLE, storage) self._set_variant_raw(key, VARIANT_DOUBLE, storage)
def set_dict(self, key: str, val: dict | t.CPtr): def set_dict(self, key: str, val: dict*):
"""Store nested dictionary pointer (VARIANT_DICT).""" """Store nested dictionary pointer (VARIANT_DICT)."""
self._set_variant_raw(key, VARIANT_DICT, val) self._set_variant_raw(key, VARIANT_DICT, val)
@@ -144,23 +144,23 @@ class dict:
"""Store nested list pointer (VARIANT_LIST).""" """Store nested list pointer (VARIANT_LIST)."""
self._set_variant_raw(key, VARIANT_LIST, val) self._set_variant_raw(key, VARIANT_LIST, val)
def set_bool(self, key: str, val: t.CInt): def set_bool(self, key: str, val: int):
"""Store boolean value (VARIANT_BOOL). Value is copied to persistent storage within __mbuddy__.""" """Store boolean value (VARIANT_BOOL). Value is copied to persistent storage within __mbuddy__."""
storage: t.CPtr = self.__mbuddy__.alloc(8) storage: rawptr = self.__mbuddy__.alloc(8)
bool_ptr: t.CInt | t.CPtr = t.CPtr(uint64(storage)) bool_ptr: int* = int*(storage)
bool_ptr[0] = val *bool_ptr = val
self._set_variant_raw(key, VARIANT_BOOL, storage) self._set_variant_raw(key, VARIANT_BOOL, storage)
# ============================================================ # ============================================================
# Query methods # Query methods
# ============================================================ # ============================================================
def get_vtype(self, key: str) -> t.CInt: def get_vtype(self, key: str) -> int:
"""Return Variant type tag associated with specified key.""" """Return Variant type tag associated with specified key."""
idx: sizet = self._find(key) idx: sizet = self._find(key)
if idx >= self.__count__: if idx >= self.__count__:
return VARIANT_NONE return VARIANT_NONE
vtype_ptr: t.CInt | t.CPtr = t.CPtr(uint64(self.__values__) + idx * _VARIANT_SIZE) vtype_ptr: int* = int*(uint64(self.__values__) + idx * _VARIANT_SIZE)
return vtype_ptr[0] return vtype_ptr[0]
def get(self, key: str, default: t.CPtr) -> t.CPtr: def get(self, key: str, default: t.CPtr) -> t.CPtr:
@@ -168,17 +168,16 @@ class dict:
idx: sizet = self._find(key) idx: sizet = self._find(key)
if idx >= self.__count__: if idx >= self.__count__:
return default return default
val_ptr: str | t.CPtr = (str | t.CPtr)(uint64(self.__values__) + idx * _VARIANT_SIZE + 8) val_ptr: str* = str*(uint64(self.__values__) + idx * _VARIANT_SIZE + 8)
return val_ptr[0] return *val_ptr
def contains(self, key: str) -> t.CInt: def contains(self, key: str) -> int:
"""Check whether target key exists.""" """Check whether target key exists."""
idx: sizet = self._find(key) idx: sizet = self._find(key)
if idx < self.__count__: if idx < self.__count__: return 1
return 1
return 0 return 0
def __iter__(self) -> dict | t.CPtr: def __iter__(self) -> dict*:
self.__iter_index__ = 0 self.__iter_index__ = 0
return self return self
@@ -187,85 +186,85 @@ class dict:
raise StopIteration raise StopIteration
idx: sizet = self.__iter_index__ idx: sizet = self.__iter_index__
self.__iter_index__ = idx + 1 self.__iter_index__ = idx + 1
key_ptr: str | t.CPtr = (str | t.CPtr)(uint64(self.__keys__) + idx * 8) key_ptr: str* = str*(uint64(self.__keys__) + idx * 8)
return key_ptr[0] return key_ptr[0]
# ============================================================ # ============================================================
# JSON utilities: serialization / deserialization via includes/json library # JSON utilities: serialization / deserialization via includes/json library
# ============================================================ # ============================================================
def to_json(self, pool: rawptr[memhub.MemManager]) -> rawptr[json.JsonValue]: def to_json(self, pool: memhub.MemManager*) -> json.JsonValue*:
"""Convert dict instance to JsonValue object (JSON_OBJECT). """Convert dict instance to JsonValue object (JSON_OBJECT).
Automatically select corresponding JSON value type according to Variant tag.""" Automatically select corresponding JSON value type according to Variant tag."""
obj: rawptr[json.JsonValue] = json.object(pool) obj: json.JsonValue* = json.object(pool)
i: sizet = 0 i: sizet = 0
while i < self.__count__: while i < self.__count__:
key_ptr: str | t.CPtr = (str | t.CPtr)(uint64(self.__keys__) + i * 8) key_ptr: str* = str*(uint64(self.__keys__) + i * 8)
vtype_ptr: t.CInt | t.CPtr = t.CPtr(uint64(self.__values__) + i * _VARIANT_SIZE) vtype_ptr: int* = int*(uint64(self.__values__) + i * _VARIANT_SIZE)
val_ptr: str | t.CPtr = (str | t.CPtr)(uint64(self.__values__) + i * _VARIANT_SIZE + 8) val_ptr: str* = str*(uint64(self.__values__) + i * _VARIANT_SIZE + 8)
vt: t.CInt = vtype_ptr[0] vt: int = vtype_ptr[0]
vp: t.CPtr = val_ptr[0] vp: rawptr = val_ptr[0]
jv: rawptr[json.JsonValue] = json.null(pool) jv: json.JsonValue* = json.null(pool)
if jv != None: if jv != None:
if vt == VARIANT_INT: if vt == VARIANT_INT:
jv.vtype = 2 # JSON_INT jv.vtype = 2 # JSON_INT
ip: int | t.CPtr = t.CPtr(uint64(vp)) ip: int* = int*(vp)
jv.int_val = ip[0] jv.int_val = ip[0]
elif vt == VARIANT_STR: elif vt == VARIANT_STR:
jv.vtype = 4 # JSON_STRING jv.vtype = 4 # JSON_STRING
jv.str_val = vp jv.str_val = vp
elif vt == VARIANT_BOOL: elif vt == VARIANT_BOOL:
jv.vtype = 1 # JSON_BOOL jv.vtype = 1 # JSON_BOOL
bp: t.CInt | t.CPtr = t.CPtr(uint64(vp)) bp: int* = int*(vp)
jv.bool_val = bp[0] jv.bool_val = bp[0]
elif vt == VARIANT_FLOAT: elif vt == VARIANT_FLOAT:
jv.vtype = 3 # JSON_FLOAT jv.vtype = 3 # JSON_FLOAT
fp: float | t.CPtr = t.CPtr(uint64(vp)) fp: float* = float*(vp)
jv.float_val = fp[0] jv.float_val = fp[0]
elif vt == VARIANT_PTR: elif vt == VARIANT_PTR:
# Fallback: treat raw pointer as integer # Fallback: treat raw pointer as integer
jv.vtype = 2 # JSON_INT jv.vtype = 2 # JSON_INT
ip: int | t.CPtr = t.CPtr(uint64(vp)) ip: int* = int*(vp)
jv.int_val = ip[0] jv.int_val = ip[0]
json.object_set(pool, obj, key_ptr[0], jv) json.object_set(pool, obj, key_ptr[0], jv)
i += 1 i += 1
return obj return obj
def from_json(self, pool: rawptr[memhub.MemManager], root: rawptr[json.JsonValue]): def from_json(self, pool: memhub.MemManager*, root: json.JsonValue*):
"""Populate dict from JsonValue object. """Populate dict from JsonValue object.
Extract values and store them as matching Variant types based on JSON type tag.""" Extract values and store them as matching Variant types based on JSON type tag."""
if root == None: if root == None:
return return
if root.vtype != 6: # JSON_OBJECT if root.vtype != 6: # JSON_OBJECT
return return
cur: rawptr[json.JsonValue] = root.child cur: json.JsonValue* = root.child
while cur != None: while cur != None:
if cur.key != None: if cur.key != None:
if cur.vtype == 2: # JSON_INT if cur.vtype == 2: # JSON_INT
storage: t.CPtr = self.__mbuddy__.alloc(8) storage: rawptr = self.__mbuddy__.alloc(8)
ip: int | t.CPtr = t.CPtr(uint64(storage)) ip: int* = int*(storage)
ip[0] = cur.int_val ip[0] = cur.int_val
self._set_variant_raw(cur.key, VARIANT_INT, storage) self._set_variant_raw(cur.key, VARIANT_INT, storage)
elif cur.vtype == 4: # JSON_STRING elif cur.vtype == 4: # JSON_STRING
self._set_variant_raw(cur.key, VARIANT_STR, cur.str_val) self._set_variant_raw(cur.key, VARIANT_STR, cur.str_val)
elif cur.vtype == 1: # JSON_BOOL elif cur.vtype == 1: # JSON_BOOL
storage: t.CPtr = self.__mbuddy__.alloc(8) storage: rawptr = self.__mbuddy__.alloc(8)
bp: t.CInt | t.CPtr = t.CPtr(uint64(storage)) bp: int* = int*(storage)
bp[0] = cur.bool_val bp[0] = cur.bool_val
self._set_variant_raw(cur.key, VARIANT_BOOL, storage) self._set_variant_raw(cur.key, VARIANT_BOOL, storage)
elif cur.vtype == 3: # JSON_FLOAT elif cur.vtype == 3: # JSON_FLOAT
storage: t.CPtr = self.__mbuddy__.alloc(8) storage: rawptr = self.__mbuddy__.alloc(8)
fp: float | t.CPtr = t.CPtr(uint64(storage)) fp: float* = float*(storage)
fp[0] = cur.float_val fp[0] = cur.float_val
self._set_variant_raw(cur.key, VARIANT_FLOAT, storage) self._set_variant_raw(cur.key, VARIANT_FLOAT, storage)
cur = cur.next cur = cur.next
def dumps(self, pool: rawptr[memhub.MemManager]) -> str: def dumps(self, pool: memhub.MemManager*) -> str:
"""Serialize dict to JSON string.""" """Serialize dict to JSON string."""
obj: rawptr[json.JsonValue] = self.to_json(pool) obj: json.JsonValue* = self.to_json(pool)
return json.write(pool, obj, False) return json.write(pool, obj, False)
def loads(self, pool: rawptr[memhub.MemManager], json_str: str): def loads(self, pool: memhub.MemManager*, json_str: str):
"""Parse JSON string and populate dict instance.""" """Parse JSON string and populate dict instance."""
root: rawptr[json.JsonValue] = json.parse(pool, json_str) root: json.JsonValue* = json.parse(pool, json_str)
self.from_json(pool, root) self.from_json(pool, root)