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 string
import json
from stdint import *
# Variant type tags (consistent with _variant.py)
define VARIANT_NONE = 0 # Untyped / null value
@@ -29,14 +29,14 @@ class dict:
d: dict = dict(mb)
d.set_int("x", 42)
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
inner: dict = dict(mb)
inner.set_int("a", 1)
d.set_dict("sub", inner)
sub: dict = c.Deref(d["sub"])
av: int = c.Deref((int | t.CPtr)(sub["a"]))
av: int = c.Deref((int*)(sub["a"]))
"""
__keys__: rawptr
__values__: rawptr
@@ -64,14 +64,14 @@ class dict:
if string.strcmp(key_ptr[0], key) == 0: return i
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.
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)
if idx >= self.__count__: return None
# 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)
return val_ptr[0]
val_ptr: str* = str*(uint64(self.__values__) + idx * _VARIANT_SIZE + 8)
return *val_ptr
def __setitem__(self, key: str, val: 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."""
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."""
idx: sizet = self._find(key)
if idx < self.__count__:
# 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
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
return
if self.__count__ >= self.__capacity__:
new_cap: sizet = self.__capacity__ * 2
new_keys: t.CPtr = self.__mbuddy__.alloc(new_cap * 8)
new_values: t.CPtr = self.__mbuddy__.alloc(new_cap * _VARIANT_SIZE)
new_keys: rawptr = self.__mbuddy__.alloc(new_cap * 8)
new_values: rawptr = self.__mbuddy__.alloc(new_cap * _VARIANT_SIZE)
if new_keys is None or new_values is None: return
string.memcpy(new_keys, self.__keys__, self.__count__ * 8)
string.memcpy(new_values, self.__values__, self.__count__ * _VARIANT_SIZE)
self.__keys__ = new_keys
self.__values__ = new_values
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
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
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
self.__count__ += 1
@@ -113,9 +113,9 @@ class dict:
def set_int(self, key: str, val: int):
"""Store integer value (VARIANT_INT). Value is copied to persistent storage within __mbuddy__."""
storage: t.CPtr = self.__mbuddy__.alloc(8)
int_ptr: int | t.CPtr = t.CPtr(uint64(storage))
int_ptr[0] = val
storage: rawptr = self.__mbuddy__.alloc(8)
int_ptr: int* = int*(storage)
*int_ptr = val
self._set_variant_raw(key, VARIANT_INT, storage)
def set_str(self, key: str, val: str):
@@ -124,19 +124,19 @@ class dict:
def set_float(self, key: str, val: float):
"""Store float value (VARIANT_FLOAT). Value is copied to persistent storage within __mbuddy__."""
storage: t.CPtr = self.__mbuddy__.alloc(8)
float_ptr: float | t.CPtr = t.CPtr(uint64(storage))
float_ptr[0] = val
storage: rawptr = self.__mbuddy__.alloc(8)
float_ptr: float* = float*(storage)
*float_ptr = val
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__."""
storage: t.CPtr = self.__mbuddy__.alloc(8)
dbl_ptr: t.CDouble | t.CPtr = t.CPtr(uint64(storage))
dbl_ptr[0] = val
storage: rawptr = self.__mbuddy__.alloc(8)
dbl_ptr: double* = double*(storage)
*dbl_ptr = val
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)."""
self._set_variant_raw(key, VARIANT_DICT, val)
@@ -144,23 +144,23 @@ class dict:
"""Store nested list pointer (VARIANT_LIST)."""
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__."""
storage: t.CPtr = self.__mbuddy__.alloc(8)
bool_ptr: t.CInt | t.CPtr = t.CPtr(uint64(storage))
bool_ptr[0] = val
storage: rawptr = self.__mbuddy__.alloc(8)
bool_ptr: int* = int*(storage)
*bool_ptr = val
self._set_variant_raw(key, VARIANT_BOOL, storage)
# ============================================================
# 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."""
idx: sizet = self._find(key)
if idx >= self.__count__:
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]
def get(self, key: str, default: t.CPtr) -> t.CPtr:
@@ -168,17 +168,16 @@ class dict:
idx: sizet = self._find(key)
if idx >= self.__count__:
return default
val_ptr: str | t.CPtr = (str | t.CPtr)(uint64(self.__values__) + idx * _VARIANT_SIZE + 8)
return val_ptr[0]
val_ptr: str* = str*(uint64(self.__values__) + idx * _VARIANT_SIZE + 8)
return *val_ptr
def contains(self, key: str) -> t.CInt:
def contains(self, key: str) -> int:
"""Check whether target key exists."""
idx: sizet = self._find(key)
if idx < self.__count__:
return 1
if idx < self.__count__: return 1
return 0
def __iter__(self) -> dict | t.CPtr:
def __iter__(self) -> dict*:
self.__iter_index__ = 0
return self
@@ -187,85 +186,85 @@ class dict:
raise StopIteration
idx: sizet = self.__iter_index__
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]
# ============================================================
# 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).
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
while i < self.__count__:
key_ptr: str | t.CPtr = (str | t.CPtr)(uint64(self.__keys__) + i * 8)
vtype_ptr: t.CInt | t.CPtr = t.CPtr(uint64(self.__values__) + i * _VARIANT_SIZE)
val_ptr: str | t.CPtr = (str | t.CPtr)(uint64(self.__values__) + i * _VARIANT_SIZE + 8)
vt: t.CInt = vtype_ptr[0]
vp: t.CPtr = val_ptr[0]
jv: rawptr[json.JsonValue] = json.null(pool)
key_ptr: str* = str*(uint64(self.__keys__) + i * 8)
vtype_ptr: int* = int*(uint64(self.__values__) + i * _VARIANT_SIZE)
val_ptr: str* = str*(uint64(self.__values__) + i * _VARIANT_SIZE + 8)
vt: int = vtype_ptr[0]
vp: rawptr = val_ptr[0]
jv: json.JsonValue* = json.null(pool)
if jv != None:
if vt == VARIANT_INT:
jv.vtype = 2 # JSON_INT
ip: int | t.CPtr = t.CPtr(uint64(vp))
ip: int* = int*(vp)
jv.int_val = ip[0]
elif vt == VARIANT_STR:
jv.vtype = 4 # JSON_STRING
jv.str_val = vp
elif vt == VARIANT_BOOL:
jv.vtype = 1 # JSON_BOOL
bp: t.CInt | t.CPtr = t.CPtr(uint64(vp))
bp: int* = int*(vp)
jv.bool_val = bp[0]
elif vt == VARIANT_FLOAT:
jv.vtype = 3 # JSON_FLOAT
fp: float | t.CPtr = t.CPtr(uint64(vp))
fp: float* = float*(vp)
jv.float_val = fp[0]
elif vt == VARIANT_PTR:
# Fallback: treat raw pointer as integer
jv.vtype = 2 # JSON_INT
ip: int | t.CPtr = t.CPtr(uint64(vp))
ip: int* = int*(vp)
jv.int_val = ip[0]
json.object_set(pool, obj, key_ptr[0], jv)
i += 1
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.
Extract values and store them as matching Variant types based on JSON type tag."""
if root == None:
return
if root.vtype != 6: # JSON_OBJECT
return
cur: rawptr[json.JsonValue] = root.child
cur: json.JsonValue* = root.child
while cur != None:
if cur.key != None:
if cur.vtype == 2: # JSON_INT
storage: t.CPtr = self.__mbuddy__.alloc(8)
ip: int | t.CPtr = t.CPtr(uint64(storage))
storage: rawptr = self.__mbuddy__.alloc(8)
ip: int* = int*(storage)
ip[0] = 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)
elif cur.vtype == 1: # JSON_BOOL
storage: t.CPtr = self.__mbuddy__.alloc(8)
bp: t.CInt | t.CPtr = t.CPtr(uint64(storage))
storage: rawptr = self.__mbuddy__.alloc(8)
bp: int* = int*(storage)
bp[0] = cur.bool_val
self._set_variant_raw(cur.key, VARIANT_BOOL, storage)
elif cur.vtype == 3: # JSON_FLOAT
storage: t.CPtr = self.__mbuddy__.alloc(8)
fp: float | t.CPtr = t.CPtr(uint64(storage))
storage: rawptr = self.__mbuddy__.alloc(8)
fp: float* = float*(storage)
fp[0] = cur.float_val
self._set_variant_raw(cur.key, VARIANT_FLOAT, storage)
cur = cur.next
def dumps(self, pool: rawptr[memhub.MemManager]) -> str:
def dumps(self, pool: memhub.MemManager*) -> str:
"""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)
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."""
root: rawptr[json.JsonValue] = json.parse(pool, json_str)
root: json.JsonValue* = json.parse(pool, json_str)
self.from_json(pool, root)