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 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
@@ -0,0 +1,7 @@
1
+ """Дозволяє запуск ``python -m sipl ...``."""
2
+
3
+ import sys
4
+
5
+ from sipl.cli import main
6
+
7
+ sys.exit(main())
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())