sipl-lang 0.1.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- sipl/__init__.py +40 -0
- sipl/__main__.py +7 -0
- sipl/analysis.py +55 -0
- sipl/ast.py +218 -0
- sipl/cli.py +292 -0
- sipl/diagnostics.py +102 -0
- sipl/grammar/sipl.lark +112 -0
- sipl/interpreter/__init__.py +44 -0
- sipl/interpreter/events.py +154 -0
- sipl/interpreter/machine.py +276 -0
- sipl/interpreter/trace.py +49 -0
- sipl/parser.py +316 -0
- sipl/printer.py +62 -0
- sipl/productions.py +61 -0
- sipl/py.typed +0 -0
- sipl/source.py +82 -0
- sipl/visualization/__init__.py +12 -0
- sipl/visualization/parse_tree.py +220 -0
- sipl_lang-0.1.0.dist-info/METADATA +198 -0
- sipl_lang-0.1.0.dist-info/RECORD +22 -0
- sipl_lang-0.1.0.dist-info/WHEEL +4 -0
- sipl_lang-0.1.0.dist-info/entry_points.txt +2 -0
sipl/__init__.py
ADDED
|
@@ -0,0 +1,40 @@
|
|
|
1
|
+
"""SIPL (SImple Programming Language) toolkit.
|
|
2
|
+
|
|
3
|
+
Публічне API::
|
|
4
|
+
|
|
5
|
+
from sipl import parse, run, trace
|
|
6
|
+
program = parse(source) # -> sipl.ast.Program
|
|
7
|
+
result = run(program, {"X": 2, "Y": 10}) # -> ExecutionResult
|
|
8
|
+
events, result = trace(program, {"X": 2, "Y": 10})
|
|
9
|
+
"""
|
|
10
|
+
|
|
11
|
+
from sipl.diagnostics import (
|
|
12
|
+
Diagnostic,
|
|
13
|
+
SiplError,
|
|
14
|
+
SiplInputError,
|
|
15
|
+
SiplRuntimeError,
|
|
16
|
+
SiplSyntaxError,
|
|
17
|
+
StepLimitExceeded,
|
|
18
|
+
)
|
|
19
|
+
from sipl.interpreter import ExecutionResult, Interpreter, Trace, run, trace
|
|
20
|
+
from sipl.parser import check, parse, parse_tree
|
|
21
|
+
|
|
22
|
+
__version__ = "0.1.0"
|
|
23
|
+
|
|
24
|
+
__all__ = [
|
|
25
|
+
"Diagnostic",
|
|
26
|
+
"ExecutionResult",
|
|
27
|
+
"Interpreter",
|
|
28
|
+
"SiplError",
|
|
29
|
+
"SiplInputError",
|
|
30
|
+
"SiplRuntimeError",
|
|
31
|
+
"SiplSyntaxError",
|
|
32
|
+
"StepLimitExceeded",
|
|
33
|
+
"Trace",
|
|
34
|
+
"__version__",
|
|
35
|
+
"check",
|
|
36
|
+
"parse",
|
|
37
|
+
"parse_tree",
|
|
38
|
+
"run",
|
|
39
|
+
"trace",
|
|
40
|
+
]
|
sipl/__main__.py
ADDED
sipl/analysis.py
ADDED
|
@@ -0,0 +1,55 @@
|
|
|
1
|
+
"""Статичний аналіз SIPL-програм.
|
|
2
|
+
|
|
3
|
+
``variable_info(program).inputs`` — вхідні змінні: ті, що можуть бути прочитані
|
|
4
|
+
раніше, ніж їм щось присвоєно. Їх треба задати в початковому стані (``-s X=...``),
|
|
5
|
+
інакше виконання може завершитися помилкою R201.
|
|
6
|
+
"""
|
|
7
|
+
|
|
8
|
+
from __future__ import annotations
|
|
9
|
+
|
|
10
|
+
from dataclasses import dataclass
|
|
11
|
+
|
|
12
|
+
from sipl import ast
|
|
13
|
+
|
|
14
|
+
|
|
15
|
+
@dataclass(frozen=True, slots=True)
|
|
16
|
+
class VariableInfo:
|
|
17
|
+
inputs: list[str]
|
|
18
|
+
"""Змінні, що можуть читатися до присвоєння (потрібні у початковому стані)."""
|
|
19
|
+
assigned: list[str]
|
|
20
|
+
"""Змінні, яким щось присвоюється."""
|
|
21
|
+
all: list[str]
|
|
22
|
+
"""Усі змінні програми."""
|
|
23
|
+
|
|
24
|
+
def to_dict(self) -> dict[str, list[str]]:
|
|
25
|
+
return {"inputs": self.inputs, "assigned": self.assigned, "all": self.all}
|
|
26
|
+
|
|
27
|
+
|
|
28
|
+
def _analyze(s: ast.Stmt, defined: frozenset[str], inputs: set[str]) -> frozenset[str]:
|
|
29
|
+
"""Повертає множину змінних, визначених *напевно* після виконання ``s``."""
|
|
30
|
+
match s:
|
|
31
|
+
case ast.Assign(target=t, value=v):
|
|
32
|
+
inputs |= ast.read_vars(v) - defined
|
|
33
|
+
return defined | {t.name}
|
|
34
|
+
case ast.Skip():
|
|
35
|
+
return defined
|
|
36
|
+
case ast.Seq(first=a, second=b):
|
|
37
|
+
return _analyze(b, _analyze(a, defined, inputs), inputs)
|
|
38
|
+
case ast.Block(body=b):
|
|
39
|
+
return _analyze(b, defined, inputs)
|
|
40
|
+
case ast.If(cond=c, then_branch=t, else_branch=e):
|
|
41
|
+
inputs |= ast.read_vars(c) - defined
|
|
42
|
+
return _analyze(t, defined, inputs) & _analyze(e, defined, inputs)
|
|
43
|
+
case ast.While(cond=c, body=b):
|
|
44
|
+
inputs |= ast.read_vars(c) - defined
|
|
45
|
+
# тіло може не виконатися жодного разу; перша ітерація — найгірший випадок
|
|
46
|
+
_analyze(b, defined, inputs)
|
|
47
|
+
return defined
|
|
48
|
+
raise TypeError(s) # pragma: no cover
|
|
49
|
+
|
|
50
|
+
|
|
51
|
+
def variable_info(program: ast.Program) -> VariableInfo:
|
|
52
|
+
inputs: set[str] = set()
|
|
53
|
+
_analyze(program.body, frozenset(), inputs)
|
|
54
|
+
read, written = ast.variables(program)
|
|
55
|
+
return VariableInfo(sorted(inputs), sorted(written), sorted(read | written))
|
sipl/ast.py
ADDED
|
@@ -0,0 +1,218 @@
|
|
|
1
|
+
"""Типізоване абстрактне синтаксичне дерево (AST) SIPL.
|
|
2
|
+
|
|
3
|
+
Вузли відповідають синтаксичним категоріям БНФ курсу:
|
|
4
|
+
|
|
5
|
+
* ``Program`` — P (P1)
|
|
6
|
+
* ``Stmt`` = Assign | Seq | If | While | Block | Skip — S (S1–S6)
|
|
7
|
+
* ``AExpr`` = Num | Var | BinOp — a (A1–A5; A6 (дужки) зникає в AST)
|
|
8
|
+
* ``BExpr`` = Compare | Or | Not — b (B1–B4; B5 (дужки) зникає в AST)
|
|
9
|
+
|
|
10
|
+
Вузли не можна змінювати після створення (frozen); кожен зберігає своє місце
|
|
11
|
+
у тексті програми — ``span`` (рядок і колонка початку та кінця).
|
|
12
|
+
"""
|
|
13
|
+
|
|
14
|
+
from __future__ import annotations
|
|
15
|
+
|
|
16
|
+
from collections.abc import Iterator
|
|
17
|
+
from dataclasses import dataclass, fields
|
|
18
|
+
from typing import Any, Literal, TypeAlias
|
|
19
|
+
|
|
20
|
+
from sipl.source import SourceSpan
|
|
21
|
+
|
|
22
|
+
|
|
23
|
+
@dataclass(frozen=True, slots=True, kw_only=True)
|
|
24
|
+
class Node:
|
|
25
|
+
span: SourceSpan
|
|
26
|
+
|
|
27
|
+
@property
|
|
28
|
+
def kind(self) -> str:
|
|
29
|
+
return type(self).__name__
|
|
30
|
+
|
|
31
|
+
|
|
32
|
+
# ---------------------------------------------------------------- a (Aexp)
|
|
33
|
+
|
|
34
|
+
|
|
35
|
+
@dataclass(frozen=True, slots=True, kw_only=True)
|
|
36
|
+
class Num(Node):
|
|
37
|
+
"""n — ціле число (A1)."""
|
|
38
|
+
|
|
39
|
+
value: int
|
|
40
|
+
|
|
41
|
+
|
|
42
|
+
@dataclass(frozen=True, slots=True, kw_only=True)
|
|
43
|
+
class Var(Node):
|
|
44
|
+
"""x — змінна (A2; також ліва частина присвоєння)."""
|
|
45
|
+
|
|
46
|
+
name: str
|
|
47
|
+
|
|
48
|
+
|
|
49
|
+
ArithOp: TypeAlias = Literal["+", "-", "*"]
|
|
50
|
+
|
|
51
|
+
|
|
52
|
+
@dataclass(frozen=True, slots=True, kw_only=True)
|
|
53
|
+
class BinOp(Node):
|
|
54
|
+
"""a1 op a2, op ∈ {+, -, *} (A3–A5)."""
|
|
55
|
+
|
|
56
|
+
op: ArithOp
|
|
57
|
+
left: AExpr
|
|
58
|
+
right: AExpr
|
|
59
|
+
|
|
60
|
+
|
|
61
|
+
AExpr: TypeAlias = Num | Var | BinOp
|
|
62
|
+
|
|
63
|
+
# ---------------------------------------------------------------- b (Bexp)
|
|
64
|
+
|
|
65
|
+
CompareOp: TypeAlias = Literal["=", ">"]
|
|
66
|
+
|
|
67
|
+
|
|
68
|
+
@dataclass(frozen=True, slots=True, kw_only=True)
|
|
69
|
+
class Compare(Node):
|
|
70
|
+
"""a1 = a2 | a1 > a2 (B1, B2)."""
|
|
71
|
+
|
|
72
|
+
op: CompareOp
|
|
73
|
+
left: AExpr
|
|
74
|
+
right: AExpr
|
|
75
|
+
|
|
76
|
+
|
|
77
|
+
@dataclass(frozen=True, slots=True, kw_only=True)
|
|
78
|
+
class Or(Node):
|
|
79
|
+
"""b1 ∨ b2 (B3)."""
|
|
80
|
+
|
|
81
|
+
left: BExpr
|
|
82
|
+
right: BExpr
|
|
83
|
+
|
|
84
|
+
|
|
85
|
+
@dataclass(frozen=True, slots=True, kw_only=True)
|
|
86
|
+
class Not(Node):
|
|
87
|
+
"""¬b (B4)."""
|
|
88
|
+
|
|
89
|
+
operand: BExpr
|
|
90
|
+
|
|
91
|
+
|
|
92
|
+
BExpr: TypeAlias = Compare | Or | Not
|
|
93
|
+
|
|
94
|
+
# ---------------------------------------------------------------- S (Stm)
|
|
95
|
+
|
|
96
|
+
|
|
97
|
+
@dataclass(frozen=True, slots=True, kw_only=True)
|
|
98
|
+
class Assign(Node):
|
|
99
|
+
"""x := a (S1)."""
|
|
100
|
+
|
|
101
|
+
target: Var
|
|
102
|
+
value: AExpr
|
|
103
|
+
|
|
104
|
+
|
|
105
|
+
@dataclass(frozen=True, slots=True, kw_only=True)
|
|
106
|
+
class Seq(Node):
|
|
107
|
+
"""S1 ; S2 (S2). Лівоасоціативна: ``A; B; C`` = ``(A; B); C``."""
|
|
108
|
+
|
|
109
|
+
first: Stmt
|
|
110
|
+
second: Stmt
|
|
111
|
+
|
|
112
|
+
|
|
113
|
+
@dataclass(frozen=True, slots=True, kw_only=True)
|
|
114
|
+
class If(Node):
|
|
115
|
+
"""if b then S1 else S2 (S3)."""
|
|
116
|
+
|
|
117
|
+
cond: BExpr
|
|
118
|
+
then_branch: Stmt
|
|
119
|
+
else_branch: Stmt
|
|
120
|
+
|
|
121
|
+
|
|
122
|
+
@dataclass(frozen=True, slots=True, kw_only=True)
|
|
123
|
+
class While(Node):
|
|
124
|
+
"""while b do S (S4)."""
|
|
125
|
+
|
|
126
|
+
cond: BExpr
|
|
127
|
+
body: Stmt
|
|
128
|
+
|
|
129
|
+
|
|
130
|
+
@dataclass(frozen=True, slots=True, kw_only=True)
|
|
131
|
+
class Block(Node):
|
|
132
|
+
"""begin S end (S5)."""
|
|
133
|
+
|
|
134
|
+
body: Stmt
|
|
135
|
+
|
|
136
|
+
|
|
137
|
+
@dataclass(frozen=True, slots=True, kw_only=True)
|
|
138
|
+
class Skip(Node):
|
|
139
|
+
"""skip (S6)."""
|
|
140
|
+
|
|
141
|
+
|
|
142
|
+
Stmt: TypeAlias = Assign | Seq | If | While | Block | Skip
|
|
143
|
+
|
|
144
|
+
|
|
145
|
+
@dataclass(frozen=True, slots=True, kw_only=True)
|
|
146
|
+
class Program(Node):
|
|
147
|
+
"""begin S end (P1)."""
|
|
148
|
+
|
|
149
|
+
body: Stmt
|
|
150
|
+
|
|
151
|
+
|
|
152
|
+
AnyNode: TypeAlias = Program | Stmt | AExpr | BExpr
|
|
153
|
+
|
|
154
|
+
|
|
155
|
+
# ---------------------------------------------------------------- утиліти
|
|
156
|
+
|
|
157
|
+
|
|
158
|
+
def children(node: Node) -> Iterator[Node]:
|
|
159
|
+
"""Безпосередні нащадки вузла у порядку полів."""
|
|
160
|
+
for f in fields(node):
|
|
161
|
+
if f.name == "span":
|
|
162
|
+
continue
|
|
163
|
+
value = getattr(node, f.name)
|
|
164
|
+
if isinstance(value, Node):
|
|
165
|
+
yield value
|
|
166
|
+
|
|
167
|
+
|
|
168
|
+
def walk(node: Node) -> Iterator[Node]:
|
|
169
|
+
"""Обхід дерева в прямому порядку (pre-order)."""
|
|
170
|
+
stack = [node]
|
|
171
|
+
while stack:
|
|
172
|
+
current = stack.pop()
|
|
173
|
+
yield current
|
|
174
|
+
stack.extend(reversed(list(children(current))))
|
|
175
|
+
|
|
176
|
+
|
|
177
|
+
def to_dict(node: Node) -> dict[str, Any]:
|
|
178
|
+
"""Серіалізація AST у JSON-сумісний словник::
|
|
179
|
+
|
|
180
|
+
{"kind": "Assign", "target": {...}, "value": {...}, "span": {...}}
|
|
181
|
+
"""
|
|
182
|
+
result: dict[str, Any] = {"kind": node.kind}
|
|
183
|
+
for f in fields(node):
|
|
184
|
+
if f.name == "span":
|
|
185
|
+
continue
|
|
186
|
+
value = getattr(node, f.name)
|
|
187
|
+
result[f.name] = to_dict(value) if isinstance(value, Node) else value
|
|
188
|
+
result["span"] = node.span.to_dict()
|
|
189
|
+
return result
|
|
190
|
+
|
|
191
|
+
|
|
192
|
+
def sequence(stmt: Stmt) -> list[Stmt]:
|
|
193
|
+
"""Розгортає ліве дерево ``Seq`` у плоский список операторів."""
|
|
194
|
+
items: list[Stmt] = []
|
|
195
|
+
while isinstance(stmt, Seq):
|
|
196
|
+
items.append(stmt.second)
|
|
197
|
+
stmt = stmt.first
|
|
198
|
+
items.append(stmt)
|
|
199
|
+
items.reverse()
|
|
200
|
+
return items
|
|
201
|
+
|
|
202
|
+
|
|
203
|
+
def read_vars(expr: Node) -> set[str]:
|
|
204
|
+
"""Імена змінних, що зустрічаються у виразі/умові."""
|
|
205
|
+
return {n.name for n in walk(expr) if isinstance(n, Var)}
|
|
206
|
+
|
|
207
|
+
|
|
208
|
+
def variables(node: Node) -> tuple[set[str], set[str]]:
|
|
209
|
+
"""Повертає (змінні, які читаються, змінні, яким присвоюють)."""
|
|
210
|
+
read: set[str] = set()
|
|
211
|
+
written: set[str] = set()
|
|
212
|
+
for n in walk(node):
|
|
213
|
+
if isinstance(n, Assign):
|
|
214
|
+
written.add(n.target.name)
|
|
215
|
+
read |= read_vars(n.value)
|
|
216
|
+
elif isinstance(n, If | While):
|
|
217
|
+
read |= read_vars(n.cond)
|
|
218
|
+
return read, written
|
sipl/cli.py
ADDED
|
@@ -0,0 +1,292 @@
|
|
|
1
|
+
"""Командний рядок SIPL.
|
|
2
|
+
|
|
3
|
+
sipl parse FILE [--json] AST програми
|
|
4
|
+
sipl check FILE [--json] синтаксична перевірка
|
|
5
|
+
sipl run FILE [-s X=1 ...] [--json] виконання, кінцевий стан
|
|
6
|
+
sipl trace FILE [-s X=1 ...] [--json] виконання з усіма подіями
|
|
7
|
+
sipl tree FILE [--format text|dot|svg] [-o OUT] [--json] дерево виводу
|
|
8
|
+
|
|
9
|
+
FILE = ``-`` — читати програму зі stdin. Коди завершення див. ``EXIT_*``.
|
|
10
|
+
"""
|
|
11
|
+
|
|
12
|
+
from __future__ import annotations
|
|
13
|
+
|
|
14
|
+
import argparse
|
|
15
|
+
import json
|
|
16
|
+
import re
|
|
17
|
+
import sys
|
|
18
|
+
from typing import Any, NoReturn
|
|
19
|
+
|
|
20
|
+
from sipl import __version__, ast
|
|
21
|
+
from sipl.analysis import variable_info
|
|
22
|
+
from sipl.diagnostics import Code, Diagnostic, SiplSyntaxError
|
|
23
|
+
from sipl.interpreter import DEFAULT_MAX_STEPS, ExecutionResult, run, trace
|
|
24
|
+
from sipl.interpreter.events import AnyEvent
|
|
25
|
+
from sipl.parser import parse
|
|
26
|
+
from sipl.visualization import build_tree, to_dot, to_svg, to_text
|
|
27
|
+
|
|
28
|
+
EXIT_OK = 0
|
|
29
|
+
EXIT_SYNTAX_ERROR = 1
|
|
30
|
+
EXIT_RUNTIME_ERROR = 2
|
|
31
|
+
EXIT_STEP_LIMIT = 3
|
|
32
|
+
EXIT_INPUT_ERROR = 4 # файл не знайдено, некоректний початковий стан або аргументи
|
|
33
|
+
|
|
34
|
+
JSON_FORMAT_VERSION = 1
|
|
35
|
+
|
|
36
|
+
_STATUS_EXIT = {"ok": EXIT_OK, "runtime_error": EXIT_RUNTIME_ERROR, "step_limit": EXIT_STEP_LIMIT}
|
|
37
|
+
_NAME = re.compile(r"[A-Za-z_][A-Za-z0-9_]*")
|
|
38
|
+
|
|
39
|
+
|
|
40
|
+
class _InputError(Exception):
|
|
41
|
+
pass
|
|
42
|
+
|
|
43
|
+
|
|
44
|
+
class _Parser(argparse.ArgumentParser):
|
|
45
|
+
def error(self, message: str) -> NoReturn:
|
|
46
|
+
self.print_usage(sys.stderr)
|
|
47
|
+
self.exit(EXIT_INPUT_ERROR, f"{self.prog}: error: {message}\n")
|
|
48
|
+
|
|
49
|
+
|
|
50
|
+
# ---------------------------------------------------------------- допоміжне
|
|
51
|
+
|
|
52
|
+
|
|
53
|
+
def _read_source(path: str) -> str:
|
|
54
|
+
if path == "-":
|
|
55
|
+
# завжди UTF-8 (на Windows sys.stdin інакше декодує в cp1251 і ламає ¬, ∨)
|
|
56
|
+
return sys.stdin.buffer.read().decode("utf-8-sig")
|
|
57
|
+
try:
|
|
58
|
+
with open(path, encoding="utf-8-sig") as f:
|
|
59
|
+
return f.read()
|
|
60
|
+
except OSError as err:
|
|
61
|
+
raise _InputError(f"cannot read '{path}': {err.strerror}") from None
|
|
62
|
+
|
|
63
|
+
|
|
64
|
+
def _parse_state(items: list[str]) -> dict[str, int]:
|
|
65
|
+
state: dict[str, int] = {}
|
|
66
|
+
for item in items:
|
|
67
|
+
name, sep, value = item.partition("=")
|
|
68
|
+
name, value = name.strip(), value.strip()
|
|
69
|
+
if not sep or not _NAME.fullmatch(name):
|
|
70
|
+
raise _InputError(f"invalid initial value '{item}', expected NAME=INTEGER")
|
|
71
|
+
try:
|
|
72
|
+
state[name] = int(value)
|
|
73
|
+
except ValueError:
|
|
74
|
+
raise _InputError(f"value of '{name}' must be an integer, got '{value}'") from None
|
|
75
|
+
return state
|
|
76
|
+
|
|
77
|
+
|
|
78
|
+
def _print_json(data: dict[str, Any]) -> None:
|
|
79
|
+
print(json.dumps(data, ensure_ascii=False, indent=2))
|
|
80
|
+
|
|
81
|
+
|
|
82
|
+
def _envelope(command: str, file: str, ok: bool, diagnostics: list[Diagnostic]) -> dict[str, Any]:
|
|
83
|
+
return {
|
|
84
|
+
"version": JSON_FORMAT_VERSION,
|
|
85
|
+
"command": command,
|
|
86
|
+
"file": file,
|
|
87
|
+
"ok": ok,
|
|
88
|
+
"diagnostics": [d.to_dict() for d in diagnostics],
|
|
89
|
+
}
|
|
90
|
+
|
|
91
|
+
|
|
92
|
+
def _ast_lines(node: ast.Node, indent: int = 0) -> list[str]:
|
|
93
|
+
details = ""
|
|
94
|
+
for attr in ("name", "value", "op"):
|
|
95
|
+
value = getattr(node, attr, None)
|
|
96
|
+
if value is not None and not isinstance(value, ast.Node):
|
|
97
|
+
details += f" {value}"
|
|
98
|
+
lines = [f"{' ' * indent}{node.kind}{details} [{node.span}]"]
|
|
99
|
+
for child in ast.children(node):
|
|
100
|
+
lines += _ast_lines(child, indent + 1)
|
|
101
|
+
return lines
|
|
102
|
+
|
|
103
|
+
|
|
104
|
+
def _format_state(state: dict[str, int]) -> str:
|
|
105
|
+
return ", ".join(f"{k}={v}" for k, v in state.items()) or "(empty)"
|
|
106
|
+
|
|
107
|
+
|
|
108
|
+
def _event_line(e: AnyEvent) -> str:
|
|
109
|
+
d = e.to_dict()
|
|
110
|
+
prefix = f"{e.index:>4} step {e.step:<5}"
|
|
111
|
+
node: dict[str, Any] = d.get("node") or {}
|
|
112
|
+
start = node.get("span", {}).get("start", {})
|
|
113
|
+
where = f"{start['line']}:{start['column']}" if start else ""
|
|
114
|
+
match d["event"]:
|
|
115
|
+
case "program_start":
|
|
116
|
+
return f"{prefix} start {_format_state(d['state'])}"
|
|
117
|
+
case "before_statement":
|
|
118
|
+
return f"{prefix} before {where:<6} {node['label']}"
|
|
119
|
+
case "after_statement":
|
|
120
|
+
return f"{prefix} after {where:<6} {node['label']}"
|
|
121
|
+
case "variable_changed":
|
|
122
|
+
old = "⊥" if d["old"] is None else d["old"]
|
|
123
|
+
return f"{prefix} set {where:<6} {d['name']}: {old} -> {d['new']}"
|
|
124
|
+
case "condition_evaluated":
|
|
125
|
+
value = "true" if d["value"] else "false"
|
|
126
|
+
return f"{prefix} condition {where:<6} {d['condition']['label']} → {value}"
|
|
127
|
+
case _:
|
|
128
|
+
return f"{prefix} end {d['status']} {_format_state(d['state'])}"
|
|
129
|
+
|
|
130
|
+
|
|
131
|
+
# ---------------------------------------------------------------- команди
|
|
132
|
+
|
|
133
|
+
|
|
134
|
+
def _cmd_parse(args: argparse.Namespace, source: str) -> int:
|
|
135
|
+
program = parse(source)
|
|
136
|
+
if args.json:
|
|
137
|
+
_print_json({**_envelope("parse", args.file, True, []), "ast": ast.to_dict(program)})
|
|
138
|
+
else:
|
|
139
|
+
print("\n".join(_ast_lines(program)))
|
|
140
|
+
return EXIT_OK
|
|
141
|
+
|
|
142
|
+
|
|
143
|
+
def _cmd_check(args: argparse.Namespace, source: str) -> int:
|
|
144
|
+
program = parse(source)
|
|
145
|
+
info = variable_info(program)
|
|
146
|
+
if args.json:
|
|
147
|
+
_print_json({**_envelope("check", args.file, True, []), "variables": info.to_dict()})
|
|
148
|
+
else:
|
|
149
|
+
print(f"{args.file}: OK")
|
|
150
|
+
print(f" input variables: {', '.join(info.inputs) or '(none)'}")
|
|
151
|
+
return EXIT_OK
|
|
152
|
+
|
|
153
|
+
|
|
154
|
+
def _report_result(args: argparse.Namespace, result: ExecutionResult, source: str) -> None:
|
|
155
|
+
if result.diagnostic is not None:
|
|
156
|
+
print(result.diagnostic.format(source, args.file), file=sys.stderr)
|
|
157
|
+
|
|
158
|
+
|
|
159
|
+
def _cmd_run(args: argparse.Namespace, source: str) -> int:
|
|
160
|
+
program = parse(source)
|
|
161
|
+
state = _parse_state(args.set)
|
|
162
|
+
result = run(program, state, max_steps=args.max_steps)
|
|
163
|
+
if args.json:
|
|
164
|
+
diags = [result.diagnostic] if result.diagnostic else []
|
|
165
|
+
_print_json(
|
|
166
|
+
{
|
|
167
|
+
**_envelope("run", args.file, result.ok, diags),
|
|
168
|
+
"initial_state": state,
|
|
169
|
+
"result": result.to_dict(),
|
|
170
|
+
}
|
|
171
|
+
)
|
|
172
|
+
else:
|
|
173
|
+
for name, value in result.state.items():
|
|
174
|
+
print(f"{name} = {value}")
|
|
175
|
+
_report_result(args, result, source)
|
|
176
|
+
return _STATUS_EXIT[result.status]
|
|
177
|
+
|
|
178
|
+
|
|
179
|
+
def _cmd_trace(args: argparse.Namespace, source: str) -> int:
|
|
180
|
+
program = parse(source)
|
|
181
|
+
state = _parse_state(args.set)
|
|
182
|
+
events, result = trace(program, state, max_steps=args.max_steps)
|
|
183
|
+
if args.json:
|
|
184
|
+
diags = [result.diagnostic] if result.diagnostic else []
|
|
185
|
+
_print_json(
|
|
186
|
+
{
|
|
187
|
+
**_envelope("trace", args.file, result.ok, diags),
|
|
188
|
+
"initial_state": state,
|
|
189
|
+
"events": events.to_list(),
|
|
190
|
+
"result": result.to_dict(),
|
|
191
|
+
}
|
|
192
|
+
)
|
|
193
|
+
else:
|
|
194
|
+
for e in events:
|
|
195
|
+
print(_event_line(e))
|
|
196
|
+
_report_result(args, result, source)
|
|
197
|
+
return _STATUS_EXIT[result.status]
|
|
198
|
+
|
|
199
|
+
|
|
200
|
+
def _cmd_tree(args: argparse.Namespace, source: str) -> int:
|
|
201
|
+
root = build_tree(source)
|
|
202
|
+
if args.json:
|
|
203
|
+
_print_json({**_envelope("tree", args.file, True, []), "tree": root.to_dict()})
|
|
204
|
+
return EXIT_OK
|
|
205
|
+
render = {"text": to_text, "dot": to_dot, "svg": to_svg}[args.format]
|
|
206
|
+
output = render(root).rstrip("\n") + "\n"
|
|
207
|
+
if args.output:
|
|
208
|
+
try:
|
|
209
|
+
with open(args.output, "w", encoding="utf-8", newline="\n") as f:
|
|
210
|
+
f.write(output)
|
|
211
|
+
except OSError as err:
|
|
212
|
+
raise _InputError(f"cannot write '{args.output}': {err.strerror}") from None
|
|
213
|
+
print(f"written {args.output}")
|
|
214
|
+
else:
|
|
215
|
+
print(output, end="")
|
|
216
|
+
return EXIT_OK
|
|
217
|
+
|
|
218
|
+
|
|
219
|
+
_COMMANDS = {
|
|
220
|
+
"parse": _cmd_parse,
|
|
221
|
+
"check": _cmd_check,
|
|
222
|
+
"run": _cmd_run,
|
|
223
|
+
"trace": _cmd_trace,
|
|
224
|
+
"tree": _cmd_tree,
|
|
225
|
+
}
|
|
226
|
+
|
|
227
|
+
|
|
228
|
+
def build_parser() -> argparse.ArgumentParser:
|
|
229
|
+
parser = _Parser(prog="sipl", description="SIPL toolkit")
|
|
230
|
+
parser.add_argument("--version", action="version", version=f"sipl {__version__}")
|
|
231
|
+
sub = parser.add_subparsers(dest="command", required=True, parser_class=_Parser)
|
|
232
|
+
|
|
233
|
+
def add(name: str, help_text: str, runs: bool = False) -> argparse.ArgumentParser:
|
|
234
|
+
p = sub.add_parser(name, help=help_text, description=help_text)
|
|
235
|
+
p.add_argument("file", help="SIPL source file ('-' for stdin)")
|
|
236
|
+
p.add_argument("--json", action="store_true", help="machine-readable JSON output")
|
|
237
|
+
if runs:
|
|
238
|
+
p.add_argument(
|
|
239
|
+
"-s",
|
|
240
|
+
"--set",
|
|
241
|
+
action="append",
|
|
242
|
+
default=[],
|
|
243
|
+
metavar="NAME=VALUE",
|
|
244
|
+
help="initial value of a variable (repeatable)",
|
|
245
|
+
)
|
|
246
|
+
p.add_argument(
|
|
247
|
+
"--max-steps",
|
|
248
|
+
type=int,
|
|
249
|
+
default=DEFAULT_MAX_STEPS,
|
|
250
|
+
metavar="N",
|
|
251
|
+
help=f"step limit (default {DEFAULT_MAX_STEPS})",
|
|
252
|
+
)
|
|
253
|
+
return p
|
|
254
|
+
|
|
255
|
+
add("parse", "print the abstract syntax tree")
|
|
256
|
+
add("check", "check syntax and list input variables")
|
|
257
|
+
add("run", "run the program and print the final state", runs=True)
|
|
258
|
+
add("trace", "run the program and print every execution event", runs=True)
|
|
259
|
+
tree = add("tree", "print the parse (derivation) tree")
|
|
260
|
+
tree.add_argument("--format", choices=["text", "dot", "svg"], default="text")
|
|
261
|
+
tree.add_argument("-o", "--output", metavar="OUT", help="write to a file instead of stdout")
|
|
262
|
+
return parser
|
|
263
|
+
|
|
264
|
+
|
|
265
|
+
def main(argv: list[str] | None = None) -> int:
|
|
266
|
+
for stream in (sys.stdout, sys.stderr):
|
|
267
|
+
if hasattr(stream, "reconfigure"):
|
|
268
|
+
stream.reconfigure(encoding="utf-8") # ¬, ∨, ⊥ у консолі Windows
|
|
269
|
+
|
|
270
|
+
args = build_parser().parse_args(argv)
|
|
271
|
+
if getattr(args, "max_steps", 0) < 0:
|
|
272
|
+
build_parser().error("--max-steps must be non-negative")
|
|
273
|
+
|
|
274
|
+
try:
|
|
275
|
+
source = _read_source(args.file)
|
|
276
|
+
return _COMMANDS[args.command](args, source)
|
|
277
|
+
except SiplSyntaxError as err:
|
|
278
|
+
diag, code = err.diagnostic, EXIT_SYNTAX_ERROR
|
|
279
|
+
except _InputError as err:
|
|
280
|
+
diag, code = Diagnostic(Code.INVALID_INPUT, str(err)), EXIT_INPUT_ERROR
|
|
281
|
+
|
|
282
|
+
if args.json:
|
|
283
|
+
_print_json(_envelope(args.command, args.file, False, [diag]))
|
|
284
|
+
else:
|
|
285
|
+
print(
|
|
286
|
+
diag.format(source if code == EXIT_SYNTAX_ERROR else None, args.file), file=sys.stderr
|
|
287
|
+
)
|
|
288
|
+
return code
|
|
289
|
+
|
|
290
|
+
|
|
291
|
+
if __name__ == "__main__": # pragma: no cover
|
|
292
|
+
sys.exit(main())
|