unit 0.26.2

A self-replicating software nanobot — minimal Forth interpreter that is also a networked mesh agent
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

"""Minimal S-expression parser for the unit mesh protocol."""


def parse(s):
    """Parse an S-expression string into nested Python structures."""
    s = s.strip()
    if not s:
        raise ValueError("empty input")
    result, _ = _parse_expr(s, 0)
    return result


def _parse_expr(s, pos):
    pos = _skip_ws(s, pos)
    if pos >= len(s):
        raise ValueError("unexpected end of input")
    if s[pos] == '(':
        return _parse_list(s, pos)
    elif s[pos] == '"':
        return _parse_string(s, pos)
    else:
        return _parse_atom(s, pos)


def _parse_list(s, pos):
    pos += 1  # skip '('
    items = []
    while True:
        pos = _skip_ws(s, pos)
        if pos >= len(s):
            raise ValueError("unterminated list")
        if s[pos] == ')':
            return items, pos + 1
        item, pos = _parse_expr(s, pos)
        items.append(item)


def _parse_string(s, pos):
    pos += 1  # skip opening quote
    chars = []
    while pos < len(s):
        if s[pos] == '\\' and pos + 1 < len(s):
            chars.append(s[pos + 1])
            pos += 2
            continue
        if s[pos] == '"':
            return ''.join(chars), pos + 1
        chars.append(s[pos])
        pos += 1
    raise ValueError("unterminated string")


def _parse_atom(s, pos):
    start = pos
    while pos < len(s) and s[pos] not in ' \t\n\r()\"':
        pos += 1
    token = s[start:pos]
    try:
        return int(token), pos
    except ValueError:
        return token, pos


def _skip_ws(s, pos):
    while pos < len(s) and s[pos] in ' \t\n\r':
        pos += 1
    return pos


def get_keyword(parsed, name):
    """Extract the value following :name in a parsed list."""
    if not isinstance(parsed, list):
        return None
    key = ':' + name
    for i, item in enumerate(parsed):
        if item == key and i + 1 < len(parsed):
            return parsed[i + 1]
    return None


def msg_type(parsed):
    """Return the first atom of a parsed list (message type)."""
    if isinstance(parsed, list) and len(parsed) > 0 and isinstance(parsed[0], str):
        return parsed[0]
    return None


def format_sexp(data):
    """Serialize Python data back to an S-expression string."""
    if isinstance(data, list):
        return '(' + ' '.join(format_sexp(x) for x in data) + ')'
    elif isinstance(data, str):
        if data.startswith(':') or data.replace('-', '').isalpha():
            return data
        return '"' + data.replace('"', '\\"') + '"'
    elif isinstance(data, int):
        return str(data)
    return str(data)