Files
breeze/scripts/generate-module-codecs.py

285 lines
11 KiB
Python

#!/usr/bin/env python3
"""Emit typed Ziran value codecs for the app protocol, with schema-sized storage."""
from pathlib import Path
import re
root = Path(__file__).resolve().parent.parent
schema = {}
record_names = {}
for file in [
*sorted((root / "src/apps").glob("*_types.zi")),
root / "apps/diary/diary_types.zi",
root / "src/core/types.zi",
root / "src/practices/patterns/patterns_types.zi",
root / "src/practices/sun_salutation/sun_salutation_rules.zi",
root / "build/packages/kryon/src/ui/drawing_props.zi",
]:
for name, body in re.findall(
r"(\w+)\s*::\s*struct\s*\{([^{}]*)\}", file.read_text()
):
fields = re.findall(r"^\s*(\w+)\s*:\s*([^\n;]+)", body, re.M)
schema[name] = [(n, re.sub(r"\s+", "", t.split("//")[0])) for n, t in fields]
record_names[name] = f"{file.stem}.{name}"
constants = {"CountSize": 4, "MaxRounds": 12}
roots = [
"LumiMessage",
"InbeMessage",
"DiaryMessage",
"DiaryFileResult",
"ListsMessage",
"ListsMutation",
"ListsMutationResult",
"HabitsMessage",
"PracticeMessage",
"LeaderboardMessage",
]
needed = []
def discover(t):
if t.startswith("["):
discover(t[t.index("]") + 1 :])
return
if t in schema and t not in needed:
for _, sub in schema[t]:
discover(sub)
needed.append(t)
for t in roots:
discover(t)
lines = [
"// Generated from protocol records by scripts/generate-module-codecs.py.",
"// No native application pointers cross the portable module boundary.",
*[
f'#import, file "../../apps/diary/{name}_types.zi";' if name == "diary" else f'#import, file "{name}_types.zi";'
for name in ["module", "lists", "habits", "practice", "inbe", "diary", "lumi", "leaderboard"]
],
'#import "bundle_host"',
'#import "byte_text_linux"',
'#import "hosted_values"',
'#import "drawing_props"',
'#import, file "../core/types.zi";',
'#import, file "../practices/patterns/patterns_types.zi";',
'#import, file "../practices/sun_salutation/sun_salutation_rules.zi";',
"",
"using HostValueKind;",
"",
]
def dims(t):
return [
(constants.get(n, int(n) if n.isdigit() else 0))
for n in re.findall(r"\[([^]]+)\]", t)
]
def elemtype(t):
return re.sub(r"^\[[^]]+\]", "", t)
def scalar(t):
return (
"HostString"
if t == "string"
else (
"HostReal"
if t.startswith("float")
else "HostUnsigned" if t.startswith("u") else "HostInteger"
)
)
# Each codec owns its recursive fields/arrays. Strings borrow the caller's storage.
for t in needed:
lines += [f"{t}Codec :: struct {{", f" fields: [{len(schema[t])}]HostField"]
for n, sub in schema[t]:
if sub in needed:
lines += [f" {n}: {sub}Codec"]
elif sub.startswith("["):
ds = dims(sub)
if len(ds) > 1:
lines += [f" {n}_rows: [{ds[0]}]HostValue"]
lines += [
f" {n}_elements: " + "".join(f"[{d}]" for d in ds) + "HostValue"
]
lines += [
"}",
"",
f"Encode{t} :: (data: {t}, codec: *{t}Codec) -> HostValue {{",
" value: HostValue",
" value.kind = cast(s32)HostRecord",
f' value.type_name = "{record_names[t]}".data',
" value.fields = *codec.fields[0]",
f" value.field_count = {len(schema[t])}",
]
for i, (n, sub) in enumerate(schema[t]):
target = f"codec.fields[{i}].value"
lines += [f' codec.fields[{i}].name = "{n}".data']
if sub in needed:
lines += [f" {target} = Encode{sub}(data.{n}, *codec.{n})"]
elif sub.startswith("["):
ds = dims(sub)
base = re.sub(r"\[[^]]+\]", "", sub)
canonical = "".join(f"[{d}]" for d in ds) + base
lines += [
f" {target}.kind = cast(s32)HostArray",
f' {target}.type_name = "{canonical}".data',
f" {target}.length = {ds[0]}",
f" {target}.elements = *codec.{n}_"
+ ("rows[0]" if len(ds) > 1 else "elements[0]"),
" {",
" i: s32 = 0",
f" while i < {ds[0]} {{",
]
if len(ds) > 1:
row = f"codec.{n}_rows[i]"
lines += [
f" {row}.kind = cast(s32)HostArray",
f' {row}.type_name = "[{ds[1]}]{base}".data',
f" {row}.length = {ds[1]}",
f" {row}.elements = *codec.{n}_elements[i][0]",
" j: s32 = 0",
f" while j < {ds[1]} {{",
f' codec.{n}_elements[i][j] = HostScalar("{base}", cast(s64)data.{n}[i][j])',
" j += 1",
" }",
]
else:
lines += [
f' codec.{n}_elements[i] = HostScalar("{base}", cast(s64)data.{n}[i])'
]
lines += [" i += 1", " }", " }"]
elif sub == "string":
lines += [
f" {target}.kind = cast(s32)HostString",
f' {target}.type_name = "string".data',
f" {target}.data = data.{n}.data",
f" {target}.length = cast(usize)data.{n}.count",
]
elif sub.startswith("float"):
lines += [
f" {target}.kind = cast(s32)HostReal",
f' {target}.type_name = "{sub}".data',
f" {target}.real = cast(float64)data.{n}",
]
else:
lines += [
f' {target} = HostScalar("{sub}", '
+ (
f"ifx data.{n} then 1 else 0)"
if sub == "bool"
else f"cast(s64)data.{n})"
)
]
lines += [
" return value",
"}",
"",
f"Decode{t} :: (value: HostValue) -> {t} {{",
f" data: {t}",
]
for i, (n, sub) in enumerate(schema[t]):
v = "value.fields[field_at].value"
# A field the other side lacks keeps its zero value.
lines += [" {", f' field_at := HostFieldAt(value, {i}, "{n}")', " if field_at >= 0 {"]
start = len(lines)
if sub in needed:
lines += [f" data.{n} = Decode{sub}({v})"]
elif sub.startswith("["):
ds = dims(sub)
base = re.sub(r"\[[^]]+\]", "", sub)
lines += [" {", " i: s32 = 0", f" while i < {ds[0]} {{"]
if len(ds) > 1:
lines += [
" j: s32 = 0",
f" while j < {ds[1]} {{",
f" data.{n}[i][j] = cast({base}){v}.elements[i].elements[j].bits",
" j += 1",
" }",
]
else:
lines += [
f" data.{n}[i] = cast({base}){v}.elements[i]."
+ ("bits" if base.startswith("u") else "integer")
]
lines += [" i += 1", " }", " }"]
elif sub == "string":
lines += [
f" data.{n} = TextFromBytes(BytesFromPointer({v}.data, cast(u64){v}.length))"
]
elif sub == "bool":
lines += [f" data.{n} = {v}.integer != 0"]
else:
lines += [
f" data.{n} = cast({sub}){v}."
+ (
"real"
if sub.startswith("float")
else "bits" if sub.startswith("u") else "integer"
)
]
lines[start:] = [" " + line for line in lines[start:]]
lines += [" }", " }"]
lines += [" return data", "}", ""]
# Check every borrowed native value before any decoder can dereference it.
for t in needed:
lines += [
f"Valid{t} :: (value: HostValue) -> bool {{",
f' if !HostRecordValid(*value, "{record_names[t]}") {{',
" return false",
" }",
]
for i, (n, sub) in enumerate(schema[t]):
v = "value.fields[field_at].value"
lines += [" {", f' field_at := HostFieldAt(value, {i}, "{n}")', " if field_at >= 0 {"]
start = len(lines)
if sub in needed:
lines += [f" if !Valid{sub}({v}) {{", " return false", " }"]
elif sub.startswith("["):
ds = dims(sub)
base = re.sub(r"\[[^]]+\]", "", sub)
canonical = "".join(f"[{d}]" for d in ds) + base
lines += [
f' if !HostArrayValid({v}, "{canonical}", {ds[0]}) {{',
" return false",
" }",
" {",
" i: s32 = 0",
f" while i < {ds[0]} {{",
]
if len(ds) > 1:
lines += [
f' if !HostArrayValid({v}.elements[i], "[{ds[1]}]{base}", {ds[1]}) {{',
" return false",
" }",
" j: s32 = 0",
f" while j < {ds[1]} {{",
f' if !HostScalarValid({v}.elements[i].elements[j], "{base}", cast(s32){scalar(base)}) {{',
" return false",
" }",
" j += 1",
" }",
]
else:
lines += [
f' if !HostScalarValid({v}.elements[i], "{base}", cast(s32){scalar(base)}) {{',
" return false",
" }",
]
lines += [" i += 1", " }", " }"]
else:
lines += [
f' if !HostScalarValid({v}, "{sub}", cast(s32){scalar(sub)}) {{',
" return false",
" }",
]
lines[start:] = [" " + line for line in lines[start:]]
lines += [" }", " }"]
lines += [" return true", "}", ""]
source = "\n".join(lines)
source = re.sub(r'("[^"\n]+"|data\.\w+|type_name)\.data', r"HostTextData(\1)", source)
(root / "src/apps/value_codec.zi").write_text(source)