git @ Cat's Eye Technologies Tamsin / master mains / mini-tamsin.tamsin
master

Tree @master (Download .tar.gz)

mini-tamsin.tamsin @master — raw · history · blame 

 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
# Copyright (c) 2014-2026, Chris Pressey, Cat's Eye Technologies.
# This file is distributed under a 2-clause BSD license, see LICENSES/ dir.
# SPDX-License-Identifier: LicenseRef-BSD-2-Clause-X-Tamsin

# Interpreter for "Mini-Tamsin", written in Tamsin.
# (see doc/Mini-Tamsin.md.)

# REQUIRES lib/tamsin_scanner.tamsin
# REQUIRES lib/tamsin_parser.tamsin

main = tamsin_parser:parse → AST & tamsin_scanner:skippable & "/" &
       new_state → S &
       interpret(AST, S, AST).

#
# FIXME there are several rather major shortcomings with this, still!
#

new_state = return state(123).

fst(pair(A, B)) = A.
snd(pair(A, B)) = B.

#
# interpret(EntireProgram, State, CurrentProgramPart)
# returns a pair(Result, NewState)
#
interpret(P, S, program(L)) =
    tamsin_parser:find_production_global('main', 'main', P) → Main &
    new_state → S &
    interpret(P, S, Main).

interpret(P, S, production(N, list(prodbranch(Fs, Ls, E), nil))) =
    interpret(P, S, E).

interpret(P, S, call(prodref('$', 'return'), list(atom(X), nil))) =
    return pair(X, S).

interpret(P, S, call(prodref('$', 'expect'), list(atom(X), nil))) =
    «X» → R &          # FIXME this isn't going to work if «X» fails, is it.
    return pair(R, S).

interpret(P, S, call(prodref('$', 'print'), list(atom(X), nil))) =
    print X &
    return pair(X, S).

interpret(P, S, call(prodref('', N), A)) =
    interpret(P, S, call(prodref('main', N), A)).

interpret(P, S, call(prodref(M, N), A)) =
    tamsin_parser:find_production_global(M, N, P) → Prod &
    new_state → S2 &
    interpret(P, S2, Prod).

interpret(P, S, or(L, R)) =
    interpret(P, S, L) → Blah.

# TODO the Tamsin parser in Tamsin cannot handle pattern matching
# i.e. it can only handle foo → Var, not foo → pair(...)
# so we write these so that they use destructuring functions.

interpret(P, S, or(L, R)) =
    interpret(P, S, L) → Pair & fst(Pair) → Res & snd(Pair) → S2 &
    (Res & return pair(Res, S2)) | interpret(P, S, R).
    # FIXME what happens to S?  I think this is right though

interpret(P, S, and(L, R)) =
    interpret(P, S, L) → Pair & fst(Pair) → Res & snd(Pair) → S2 &
    interpret(P, S2, R).

# interpret(P, S, not(X)) = !interpret(P, S, X).

interpret(P, S, while(X)) =
    {interpret(P, S, X) → Pair & fst(Pair) → Res & snd(Pair) → S2 & set S = S2}.