Mercurial > repos > icfp2013

annotate src/bv.tp @ 12:7d8b8f82cbef

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Help Bill work around some compiler bugs
author Mike Pavone <pavone@retrodev.com>
date Fri, 09 Aug 2013 02:35:37 -0700
parents 0ccebdbc3e80
children 655d5b19333d
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
3
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1 #{
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2 program <- {
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3 _input <- 0i64
5
538440e1c3d2 Add support for fold to evaluator
Mike Pavone <pavone@retrodev.com>
parents: 3
diff changeset
4 _acc <- 0i64
538440e1c3d2 Add support for fold to evaluator
Mike Pavone <pavone@retrodev.com>
parents: 3
diff changeset
5 _val <- 0i64
3
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
6 _zero <- #{
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
7 string <- { "0" }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
8 eval <- { 0i64 }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
9 }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
10
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
11 _one <- #{
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
12 string <- { "1" }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
13 eval <- { 1i64 }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
14 }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
15
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
16 _inputNode <- #{
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
17 string <- { "input" }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
18 eval <- { _input }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
19 }
5
538440e1c3d2 Add support for fold to evaluator
Mike Pavone <pavone@retrodev.com>
parents: 3
diff changeset
20 _accNode <- #{
538440e1c3d2 Add support for fold to evaluator
Mike Pavone <pavone@retrodev.com>
parents: 3
diff changeset
21 string <- { "acc" }
538440e1c3d2 Add support for fold to evaluator
Mike Pavone <pavone@retrodev.com>
parents: 3
diff changeset
22 eval <- { _acc }
538440e1c3d2 Add support for fold to evaluator
Mike Pavone <pavone@retrodev.com>
parents: 3
diff changeset
23 }
538440e1c3d2 Add support for fold to evaluator
Mike Pavone <pavone@retrodev.com>
parents: 3
diff changeset
24 _valNode <- #{
538440e1c3d2 Add support for fold to evaluator
Mike Pavone <pavone@retrodev.com>
parents: 3
diff changeset
25 string <- { "val" }
538440e1c3d2 Add support for fold to evaluator
Mike Pavone <pavone@retrodev.com>
parents: 3
diff changeset
26 eval <- { _val }
538440e1c3d2 Add support for fold to evaluator
Mike Pavone <pavone@retrodev.com>
parents: 3
diff changeset
27 }
3
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
28 #{
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
29 plus <- :left right {
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
30 #{
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
31 string <- { "(plus " . (string: left) . " " . (string: right) . ")" }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
32 eval <- { (eval: left) + (eval: right)}
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
33 }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
34 }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
35 zero <- {
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
36 _zero
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
37 }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
38
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
39 one <- {
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
40 _one
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
41 }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
42
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
43 opAnd <- :left right {
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
44 #{
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
45 string <- { "(and " . (string: left) . " " . (string: right) . ")" }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
46 eval <- { (eval: left) and (eval: right)}
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
47 }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
48 }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
49
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
50 opOr <- :left right {
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
51 #{
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
52 string <- { "(or " . (string: left) . " " . (string: right) . ")" }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
53 eval <- { (eval: left) or (eval: right)}
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
54 }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
55 }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
56
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
57 opXor <- :left right {
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
58 #{
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
59 string <- { "(xor " . (string: left) . " " . (string: right) . ")" }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
60 eval <- { (eval: left) xor (eval: right)}
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
61 }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
62 }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
63
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
64 opNot <- :exp {
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
65 #{
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
66 string <- { "(not " . (string: exp) . ")" }
5
538440e1c3d2 Add support for fold to evaluator
Mike Pavone <pavone@retrodev.com>
parents: 3
diff changeset
67 eval <- { (eval: exp) xor -1i64 }
3
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
68 }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
69 }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
70
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
71 shl1 <- :exp {
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
72 #{
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
73 string <- { "(shl1 " . (string: exp) . ")" }
5
538440e1c3d2 Add support for fold to evaluator
Mike Pavone <pavone@retrodev.com>
parents: 3
diff changeset
74 eval <- { lshift: (eval: exp) by: 1i64 }
3
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
75 }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
76 }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
77
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
78 shr1 <- :exp {
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
79 #{
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
80 string <- { "(shr1 " . (string: exp) . ")" }
5
538440e1c3d2 Add support for fold to evaluator
Mike Pavone <pavone@retrodev.com>
parents: 3
diff changeset
81 eval <- { rshift: (eval: exp) by: 1i64 }
3
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
82 }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
83 }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
84
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
85 shr4 <- :exp {
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
86 #{
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
87 string <- { "(shr4 " . (string: exp) . ")" }
5
538440e1c3d2 Add support for fold to evaluator
Mike Pavone <pavone@retrodev.com>
parents: 3
diff changeset
88 eval <- { rshift: (eval: exp) by: 4i64 }
3
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
89 }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
90 }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
91
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
92 shr16 <- :exp {
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
93 #{
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
94 string <- { "(shr16 " . (string: exp) . ")" }
5
538440e1c3d2 Add support for fold to evaluator
Mike Pavone <pavone@retrodev.com>
parents: 3
diff changeset
95 eval <- { rshift: (eval: exp) by: 16i64 }
3
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
96 }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
97 }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
98
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
99 input <- { _inputNode }
5
538440e1c3d2 Add support for fold to evaluator
Mike Pavone <pavone@retrodev.com>
parents: 3
diff changeset
100 acc <- { _accNode }
538440e1c3d2 Add support for fold to evaluator
Mike Pavone <pavone@retrodev.com>
parents: 3
diff changeset
101 val <- { _valNode }
3
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
102
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
103 if0:then:else <- :exp ifzero :ifnotzero {
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
104 #{
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
105 string <- { "(if0 " . (string: exp) . " " . (string: ifzero) . " " . (string: ifnotzero) . ")" }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
106 eval <- {
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
107 if: (eval: exp) = 0i64 {
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
108 eval: ifzero
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
109 } else: {
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
110 eval: ifnotzero
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
111 }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
112 }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
113 }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
114 }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
115
5
538440e1c3d2 Add support for fold to evaluator
Mike Pavone <pavone@retrodev.com>
parents: 3
diff changeset
116 fold:with:startingAt <- :toFold :fun :startAcc {
538440e1c3d2 Add support for fold to evaluator
Mike Pavone <pavone@retrodev.com>
parents: 3
diff changeset
117 #{
538440e1c3d2 Add support for fold to evaluator
Mike Pavone <pavone@retrodev.com>
parents: 3
diff changeset
118 string <- {
9
0ccebdbc3e80 Add support for generating programs that contain fold. Make the desired program size a command line argument.
Mike Pavone <pavone@retrodev.com>
parents: 8
diff changeset
119 "(fold " . (string: toFold) . " " . (string: startAcc) . " (lambda (val acc) " . (string: fun) . "))"
5
538440e1c3d2 Add support for fold to evaluator
Mike Pavone <pavone@retrodev.com>
parents: 3
diff changeset
120 }
538440e1c3d2 Add support for fold to evaluator
Mike Pavone <pavone@retrodev.com>
parents: 3
diff changeset
121 eval <- {
538440e1c3d2 Add support for fold to evaluator
Mike Pavone <pavone@retrodev.com>
parents: 3
diff changeset
122 _acc <- (eval: startAcc)
538440e1c3d2 Add support for fold to evaluator
Mike Pavone <pavone@retrodev.com>
parents: 3
diff changeset
123 source <- (eval: toFold)
538440e1c3d2 Add support for fold to evaluator
Mike Pavone <pavone@retrodev.com>
parents: 3
diff changeset
124 //parser doesn''t currently like vertical whitespace in arays so
538440e1c3d2 Add support for fold to evaluator
Mike Pavone <pavone@retrodev.com>
parents: 3
diff changeset
125 //this needs to be on a single line until that bug is fixed
538440e1c3d2 Add support for fold to evaluator
Mike Pavone <pavone@retrodev.com>
parents: 3
diff changeset
126 vals <- #[source and 255i64 (rshift: source by: 8i64) and 255i64 (rshift: source by: 16i64) and 255i64 (rshift: source by: 24i64) and 255i64 (rshift: source by: 32i64) and 255i64 (rshift: source by: 40i64) and 255i64 (rshift: source by: 48i64) and 255i64 (rshift: source by: 56i64) and 255i64]
538440e1c3d2 Add support for fold to evaluator
Mike Pavone <pavone@retrodev.com>
parents: 3
diff changeset
127 foreach: vals :idx cur {
538440e1c3d2 Add support for fold to evaluator
Mike Pavone <pavone@retrodev.com>
parents: 3
diff changeset
128 _val <- cur
538440e1c3d2 Add support for fold to evaluator
Mike Pavone <pavone@retrodev.com>
parents: 3
diff changeset
129 _acc <- (eval: fun)
538440e1c3d2 Add support for fold to evaluator
Mike Pavone <pavone@retrodev.com>
parents: 3
diff changeset
130 }
538440e1c3d2 Add support for fold to evaluator
Mike Pavone <pavone@retrodev.com>
parents: 3
diff changeset
131 _acc
538440e1c3d2 Add support for fold to evaluator
Mike Pavone <pavone@retrodev.com>
parents: 3
diff changeset
132 }
538440e1c3d2 Add support for fold to evaluator
Mike Pavone <pavone@retrodev.com>
parents: 3
diff changeset
133 }
538440e1c3d2 Add support for fold to evaluator
Mike Pavone <pavone@retrodev.com>
parents: 3
diff changeset
134 }
538440e1c3d2 Add support for fold to evaluator
Mike Pavone <pavone@retrodev.com>
parents: 3
diff changeset
135
3
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
136 run <- :in {
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
137 _input <- in
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
138 eval: root
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
139 }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
140
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
141 root <- _zero
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
142
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
143 string <- {
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
144 "(lambda (input) " . (string: root) . ")"
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
145 }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
146
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
147 gentestprog <- {
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
148 root <- if0: (opAnd: input one) then: (
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
149 plus: (opOr: input (shl1: one))
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
150 ) else: (
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
151 opXor: input (shr16: input)
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
152 )
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
153 self
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
154 }
5
538440e1c3d2 Add support for fold to evaluator
Mike Pavone <pavone@retrodev.com>
parents: 3
diff changeset
155
538440e1c3d2 Add support for fold to evaluator
Mike Pavone <pavone@retrodev.com>
parents: 3
diff changeset
156 exampleprog <- {
538440e1c3d2 Add support for fold to evaluator
Mike Pavone <pavone@retrodev.com>
parents: 3
diff changeset
157 root <- fold: input with: (opOr: val acc) startingAt: zero
538440e1c3d2 Add support for fold to evaluator
Mike Pavone <pavone@retrodev.com>
parents: 3
diff changeset
158 self
538440e1c3d2 Add support for fold to evaluator
Mike Pavone <pavone@retrodev.com>
parents: 3
diff changeset
159 }
7
301f16245955 Add support for generating all programs up to size 3 inclusive
Mike Pavone <pavone@retrodev.com>
parents: 5
diff changeset
160
301f16245955 Add support for generating all programs up to size 3 inclusive
Mike Pavone <pavone@retrodev.com>
parents: 5
diff changeset
161 //TODO: memoize this to improve runtime for large n
301f16245955 Add support for generating all programs up to size 3 inclusive
Mike Pavone <pavone@retrodev.com>
parents: 5
diff changeset
162 allOfSize:inFold? <- :n :infold? {
301f16245955 Add support for generating all programs up to size 3 inclusive
Mike Pavone <pavone@retrodev.com>
parents: 5
diff changeset
163 if: n = 1 {
301f16245955 Add support for generating all programs up to size 3 inclusive
Mike Pavone <pavone@retrodev.com>
parents: 5
diff changeset
164 res <- #[one zero input]
9
0ccebdbc3e80 Add support for generating programs that contain fold. Make the desired program size a command line argument.
Mike Pavone <pavone@retrodev.com>
parents: 8
diff changeset
165 if: infold? = 2 {
7
301f16245955 Add support for generating all programs up to size 3 inclusive
Mike Pavone <pavone@retrodev.com>
parents: 5
diff changeset
166 res append: acc
301f16245955 Add support for generating all programs up to size 3 inclusive
Mike Pavone <pavone@retrodev.com>
parents: 5
diff changeset
167 res append: val
301f16245955 Add support for generating all programs up to size 3 inclusive
Mike Pavone <pavone@retrodev.com>
parents: 5
diff changeset
168 }
301f16245955 Add support for generating all programs up to size 3 inclusive
Mike Pavone <pavone@retrodev.com>
parents: 5
diff changeset
169 res
301f16245955 Add support for generating all programs up to size 3 inclusive
Mike Pavone <pavone@retrodev.com>
parents: 5
diff changeset
170 } else: {
301f16245955 Add support for generating all programs up to size 3 inclusive
Mike Pavone <pavone@retrodev.com>
parents: 5
diff changeset
171 res <- #[]
301f16245955 Add support for generating all programs up to size 3 inclusive
Mike Pavone <pavone@retrodev.com>
parents: 5
diff changeset
172 foreach: (allOfSize: n - 1 inFold?: infold?) :idx exp {
301f16245955 Add support for generating all programs up to size 3 inclusive
Mike Pavone <pavone@retrodev.com>
parents: 5
diff changeset
173 res append: (opNot: exp)
301f16245955 Add support for generating all programs up to size 3 inclusive
Mike Pavone <pavone@retrodev.com>
parents: 5
diff changeset
174 res append: (shl1: exp)
301f16245955 Add support for generating all programs up to size 3 inclusive
Mike Pavone <pavone@retrodev.com>
parents: 5
diff changeset
175 res append: (shr1: exp)
301f16245955 Add support for generating all programs up to size 3 inclusive
Mike Pavone <pavone@retrodev.com>
parents: 5
diff changeset
176 res append: (shr4: exp)
301f16245955 Add support for generating all programs up to size 3 inclusive
Mike Pavone <pavone@retrodev.com>
parents: 5
diff changeset
177 res append: (shr16: exp)
301f16245955 Add support for generating all programs up to size 3 inclusive
Mike Pavone <pavone@retrodev.com>
parents: 5
diff changeset
178 }
301f16245955 Add support for generating all programs up to size 3 inclusive
Mike Pavone <pavone@retrodev.com>
parents: 5
diff changeset
179 if: n > 2 {
301f16245955 Add support for generating all programs up to size 3 inclusive
Mike Pavone <pavone@retrodev.com>
parents: 5
diff changeset
180 numLeft <- 1
301f16245955 Add support for generating all programs up to size 3 inclusive
Mike Pavone <pavone@retrodev.com>
parents: 5
diff changeset
181 argTotal <- n - 1
301f16245955 Add support for generating all programs up to size 3 inclusive
Mike Pavone <pavone@retrodev.com>
parents: 5
diff changeset
182 while: { numLeft < argTotal } do: {
301f16245955 Add support for generating all programs up to size 3 inclusive
Mike Pavone <pavone@retrodev.com>
parents: 5
diff changeset
183 numRight <- argTotal - numLeft
301f16245955 Add support for generating all programs up to size 3 inclusive
Mike Pavone <pavone@retrodev.com>
parents: 5
diff changeset
184 choicesRight <- (allOfSize: numRight inFold?: infold?)
301f16245955 Add support for generating all programs up to size 3 inclusive
Mike Pavone <pavone@retrodev.com>
parents: 5
diff changeset
185 foreach: (allOfSize: numLeft inFold?: infold?) :idx leftExp {
301f16245955 Add support for generating all programs up to size 3 inclusive
Mike Pavone <pavone@retrodev.com>
parents: 5
diff changeset
186 foreach: choicesRight :idx rightExp {
301f16245955 Add support for generating all programs up to size 3 inclusive
Mike Pavone <pavone@retrodev.com>
parents: 5
diff changeset
187 res append: (opAnd: leftExp rightExp)
301f16245955 Add support for generating all programs up to size 3 inclusive
Mike Pavone <pavone@retrodev.com>
parents: 5
diff changeset
188 res append: (opOr: leftExp rightExp)
301f16245955 Add support for generating all programs up to size 3 inclusive
Mike Pavone <pavone@retrodev.com>
parents: 5
diff changeset
189 res append: (opXor: leftExp rightExp)
301f16245955 Add support for generating all programs up to size 3 inclusive
Mike Pavone <pavone@retrodev.com>
parents: 5
diff changeset
190 res append: (plus: leftExp rightExp)
301f16245955 Add support for generating all programs up to size 3 inclusive
Mike Pavone <pavone@retrodev.com>
parents: 5
diff changeset
191 }
301f16245955 Add support for generating all programs up to size 3 inclusive
Mike Pavone <pavone@retrodev.com>
parents: 5
diff changeset
192 }
301f16245955 Add support for generating all programs up to size 3 inclusive
Mike Pavone <pavone@retrodev.com>
parents: 5
diff changeset
193 numLeft <- numLeft + 1
301f16245955 Add support for generating all programs up to size 3 inclusive
Mike Pavone <pavone@retrodev.com>
parents: 5
diff changeset
194 }
8
3f0172ceab81 Add support for generating programs with if0, thus allowing us to generate all programs up to size 5.
Mike Pavone <pavone@retrodev.com>
parents: 7
diff changeset
195 if: n > 3 {
3f0172ceab81 Add support for generating programs with if0, thus allowing us to generate all programs up to size 5.
Mike Pavone <pavone@retrodev.com>
parents: 7
diff changeset
196 numLeft <- 1
3f0172ceab81 Add support for generating programs with if0, thus allowing us to generate all programs up to size 5.
Mike Pavone <pavone@retrodev.com>
parents: 7
diff changeset
197 limitLeft <- n - 2
3f0172ceab81 Add support for generating programs with if0, thus allowing us to generate all programs up to size 5.
Mike Pavone <pavone@retrodev.com>
parents: 7
diff changeset
198 while: { numLeft < limitLeft } do: {
3f0172ceab81 Add support for generating programs with if0, thus allowing us to generate all programs up to size 5.
Mike Pavone <pavone@retrodev.com>
parents: 7
diff changeset
199 numMid <- 1
3f0172ceab81 Add support for generating programs with if0, thus allowing us to generate all programs up to size 5.
Mike Pavone <pavone@retrodev.com>
parents: 7
diff changeset
200 limitMid <- n - (1 + numLeft)
3f0172ceab81 Add support for generating programs with if0, thus allowing us to generate all programs up to size 5.
Mike Pavone <pavone@retrodev.com>
parents: 7
diff changeset
201 while: { numMid < limitMid } do: {
3f0172ceab81 Add support for generating programs with if0, thus allowing us to generate all programs up to size 5.
Mike Pavone <pavone@retrodev.com>
parents: 7
diff changeset
202 numRight <- n - (1 + numLeft + numMid)
3f0172ceab81 Add support for generating programs with if0, thus allowing us to generate all programs up to size 5.
Mike Pavone <pavone@retrodev.com>
parents: 7
diff changeset
203 choicesRight <- (allOfSize: numRight inFold?: infold?)
3f0172ceab81 Add support for generating programs with if0, thus allowing us to generate all programs up to size 5.
Mike Pavone <pavone@retrodev.com>
parents: 7
diff changeset
204 choicesMid <- (allOfSize: numMid inFold?: infold?)
3f0172ceab81 Add support for generating programs with if0, thus allowing us to generate all programs up to size 5.
Mike Pavone <pavone@retrodev.com>
parents: 7
diff changeset
205 foreach: (allOfSize: numLeft inFold?: infold?) :idx leftExp {
3f0172ceab81 Add support for generating programs with if0, thus allowing us to generate all programs up to size 5.
Mike Pavone <pavone@retrodev.com>
parents: 7
diff changeset
206 foreach: choicesMid :idx midExp {
3f0172ceab81 Add support for generating programs with if0, thus allowing us to generate all programs up to size 5.
Mike Pavone <pavone@retrodev.com>
parents: 7
diff changeset
207 foreach: choicesRight :idx rightExp {
3f0172ceab81 Add support for generating programs with if0, thus allowing us to generate all programs up to size 5.
Mike Pavone <pavone@retrodev.com>
parents: 7
diff changeset
208 res append: (if0: leftExp then: midExp else: rightExp)
3f0172ceab81 Add support for generating programs with if0, thus allowing us to generate all programs up to size 5.
Mike Pavone <pavone@retrodev.com>
parents: 7
diff changeset
209 }
3f0172ceab81 Add support for generating programs with if0, thus allowing us to generate all programs up to size 5.
Mike Pavone <pavone@retrodev.com>
parents: 7
diff changeset
210 }
3f0172ceab81 Add support for generating programs with if0, thus allowing us to generate all programs up to size 5.
Mike Pavone <pavone@retrodev.com>
parents: 7
diff changeset
211 }
3f0172ceab81 Add support for generating programs with if0, thus allowing us to generate all programs up to size 5.
Mike Pavone <pavone@retrodev.com>
parents: 7
diff changeset
212 numMid <- numMid + 1
3f0172ceab81 Add support for generating programs with if0, thus allowing us to generate all programs up to size 5.
Mike Pavone <pavone@retrodev.com>
parents: 7
diff changeset
213 }
3f0172ceab81 Add support for generating programs with if0, thus allowing us to generate all programs up to size 5.
Mike Pavone <pavone@retrodev.com>
parents: 7
diff changeset
214 numLeft <- numLeft + 1
3f0172ceab81 Add support for generating programs with if0, thus allowing us to generate all programs up to size 5.
Mike Pavone <pavone@retrodev.com>
parents: 7
diff changeset
215 }
9
0ccebdbc3e80 Add support for generating programs that contain fold. Make the desired program size a command line argument.
Mike Pavone <pavone@retrodev.com>
parents: 8
diff changeset
216 if: n > 4 && infold? = 0 {
0ccebdbc3e80 Add support for generating programs that contain fold. Make the desired program size a command line argument.
Mike Pavone <pavone@retrodev.com>
parents: 8
diff changeset
217 numSeq <- 1
0ccebdbc3e80 Add support for generating programs that contain fold. Make the desired program size a command line argument.
Mike Pavone <pavone@retrodev.com>
parents: 8
diff changeset
218 limitSeq <- n - 3
0ccebdbc3e80 Add support for generating programs that contain fold. Make the desired program size a command line argument.
Mike Pavone <pavone@retrodev.com>
parents: 8
diff changeset
219 while: { numSeq < limitSeq } do: {
0ccebdbc3e80 Add support for generating programs that contain fold. Make the desired program size a command line argument.
Mike Pavone <pavone@retrodev.com>
parents: 8
diff changeset
220 numFun <- 1
0ccebdbc3e80 Add support for generating programs that contain fold. Make the desired program size a command line argument.
Mike Pavone <pavone@retrodev.com>
parents: 8
diff changeset
221 limitFun <- n - (2 + numSeq)
0ccebdbc3e80 Add support for generating programs that contain fold. Make the desired program size a command line argument.
Mike Pavone <pavone@retrodev.com>
parents: 8
diff changeset
222 while: { numFun < limitFun } do: {
0ccebdbc3e80 Add support for generating programs that contain fold. Make the desired program size a command line argument.
Mike Pavone <pavone@retrodev.com>
parents: 8
diff changeset
223 numStart <- n - (2 + numSeq + numFun)
0ccebdbc3e80 Add support for generating programs that contain fold. Make the desired program size a command line argument.
Mike Pavone <pavone@retrodev.com>
parents: 8
diff changeset
224 choicesStart <- (allOfSize: numStart inFold?: 1)
0ccebdbc3e80 Add support for generating programs that contain fold. Make the desired program size a command line argument.
Mike Pavone <pavone@retrodev.com>
parents: 8
diff changeset
225 choicesFun <- (allOfSize: numFun inFold?: 2)
0ccebdbc3e80 Add support for generating programs that contain fold. Make the desired program size a command line argument.
Mike Pavone <pavone@retrodev.com>
parents: 8
diff changeset
226 foreach: (allOfSize: numSeq inFold?: 1) :idx seqExp {
0ccebdbc3e80 Add support for generating programs that contain fold. Make the desired program size a command line argument.
Mike Pavone <pavone@retrodev.com>
parents: 8
diff changeset
227 foreach: choicesFun :idx funExp {
0ccebdbc3e80 Add support for generating programs that contain fold. Make the desired program size a command line argument.
Mike Pavone <pavone@retrodev.com>
parents: 8
diff changeset
228 foreach: choicesStart :idx startExp {
0ccebdbc3e80 Add support for generating programs that contain fold. Make the desired program size a command line argument.
Mike Pavone <pavone@retrodev.com>
parents: 8
diff changeset
229 res append: (fold: seqExp with: funExp startingAt: startExp)
0ccebdbc3e80 Add support for generating programs that contain fold. Make the desired program size a command line argument.
Mike Pavone <pavone@retrodev.com>
parents: 8
diff changeset
230 }
0ccebdbc3e80 Add support for generating programs that contain fold. Make the desired program size a command line argument.
Mike Pavone <pavone@retrodev.com>
parents: 8
diff changeset
231 }
0ccebdbc3e80 Add support for generating programs that contain fold. Make the desired program size a command line argument.
Mike Pavone <pavone@retrodev.com>
parents: 8
diff changeset
232 }
0ccebdbc3e80 Add support for generating programs that contain fold. Make the desired program size a command line argument.
Mike Pavone <pavone@retrodev.com>
parents: 8
diff changeset
233 numFun <- numFun + 1
0ccebdbc3e80 Add support for generating programs that contain fold. Make the desired program size a command line argument.
Mike Pavone <pavone@retrodev.com>
parents: 8
diff changeset
234 }
0ccebdbc3e80 Add support for generating programs that contain fold. Make the desired program size a command line argument.
Mike Pavone <pavone@retrodev.com>
parents: 8
diff changeset
235 numSeq <- numSeq + 1
0ccebdbc3e80 Add support for generating programs that contain fold. Make the desired program size a command line argument.
Mike Pavone <pavone@retrodev.com>
parents: 8
diff changeset
236 }
0ccebdbc3e80 Add support for generating programs that contain fold. Make the desired program size a command line argument.
Mike Pavone <pavone@retrodev.com>
parents: 8
diff changeset
237 }
8
3f0172ceab81 Add support for generating programs with if0, thus allowing us to generate all programs up to size 5.
Mike Pavone <pavone@retrodev.com>
parents: 7
diff changeset
238 }
7
301f16245955 Add support for generating all programs up to size 3 inclusive
Mike Pavone <pavone@retrodev.com>
parents: 5
diff changeset
239 }
301f16245955 Add support for generating all programs up to size 3 inclusive
Mike Pavone <pavone@retrodev.com>
parents: 5
diff changeset
240 res
301f16245955 Add support for generating all programs up to size 3 inclusive
Mike Pavone <pavone@retrodev.com>
parents: 5
diff changeset
241 }
301f16245955 Add support for generating all programs up to size 3 inclusive
Mike Pavone <pavone@retrodev.com>
parents: 5
diff changeset
242 }
301f16245955 Add support for generating all programs up to size 3 inclusive
Mike Pavone <pavone@retrodev.com>
parents: 5
diff changeset
243
301f16245955 Add support for generating all programs up to size 3 inclusive
Mike Pavone <pavone@retrodev.com>
parents: 5
diff changeset
244 allOfSize <- :n {
9
0ccebdbc3e80 Add support for generating programs that contain fold. Make the desired program size a command line argument.
Mike Pavone <pavone@retrodev.com>
parents: 8
diff changeset
245 allOfSize: (n - 1) inFold?: 0
7
301f16245955 Add support for generating all programs up to size 3 inclusive
Mike Pavone <pavone@retrodev.com>
parents: 5
diff changeset
246 }
3
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
247 }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
248 }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
249
5
538440e1c3d2 Add support for fold to evaluator
Mike Pavone <pavone@retrodev.com>
parents: 3
diff changeset
250 test <- :prog {
3
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
251 print: (string: prog) . "\n"
5
538440e1c3d2 Add support for fold to evaluator
Mike Pavone <pavone@retrodev.com>
parents: 3
diff changeset
252 //parser doesn''t currently like vertical whitespace in arays so
538440e1c3d2 Add support for fold to evaluator
Mike Pavone <pavone@retrodev.com>
parents: 3
diff changeset
253 //this needs to be on a single line until that bug is fixed
538440e1c3d2 Add support for fold to evaluator
Mike Pavone <pavone@retrodev.com>
parents: 3
diff changeset
254 vals <- #[0i64 1i64 2i64 3i64 4i64 5i64 6i64 7i64 8i64 9i64 10i64 11i64 12i64 13i64 14i64 15i64 0x30001i64 0x50015i64 (lshift: 0x11223344i64 by: 32i64) or 0x55667788i64]
3
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
255 foreach: vals :idx val {
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
256 print: "p(0x" . (hex: val) . ") = 0x" . (hex: (prog run: val)) . "\n"
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
257 }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
258 }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
259
9
0ccebdbc3e80 Add support for generating programs that contain fold. Make the desired program size a command line argument.
Mike Pavone <pavone@retrodev.com>
parents: 8
diff changeset
260 main <- :args {
5
538440e1c3d2 Add support for fold to evaluator
Mike Pavone <pavone@retrodev.com>
parents: 3
diff changeset
261 test: (program gentestprog)
538440e1c3d2 Add support for fold to evaluator
Mike Pavone <pavone@retrodev.com>
parents: 3
diff changeset
262 test: (program exampleprog)
9
0ccebdbc3e80 Add support for generating programs that contain fold. Make the desired program size a command line argument.
Mike Pavone <pavone@retrodev.com>
parents: 8
diff changeset
263 size <- 3
0ccebdbc3e80 Add support for generating programs that contain fold. Make the desired program size a command line argument.
Mike Pavone <pavone@retrodev.com>
parents: 8
diff changeset
264 if: (args length) > 1 {
0ccebdbc3e80 Add support for generating programs that contain fold. Make the desired program size a command line argument.
Mike Pavone <pavone@retrodev.com>
parents: 8
diff changeset
265 size <- int32: (args get: 1)
7
301f16245955 Add support for generating all programs up to size 3 inclusive
Mike Pavone <pavone@retrodev.com>
parents: 5
diff changeset
266 }
9
0ccebdbc3e80 Add support for generating programs that contain fold. Make the desired program size a command line argument.
Mike Pavone <pavone@retrodev.com>
parents: 8
diff changeset
267 if: size >= 2 {
0ccebdbc3e80 Add support for generating programs that contain fold. Make the desired program size a command line argument.
Mike Pavone <pavone@retrodev.com>
parents: 8
diff changeset
268 prog <- program
0ccebdbc3e80 Add support for generating programs that contain fold. Make the desired program size a command line argument.
Mike Pavone <pavone@retrodev.com>
parents: 8
diff changeset
269 foreach: (prog allOfSize: size) :idx tree {
0ccebdbc3e80 Add support for generating programs that contain fold. Make the desired program size a command line argument.
Mike Pavone <pavone@retrodev.com>
parents: 8
diff changeset
270 prog root! tree
0ccebdbc3e80 Add support for generating programs that contain fold. Make the desired program size a command line argument.
Mike Pavone <pavone@retrodev.com>
parents: 8
diff changeset
271 test: prog
0ccebdbc3e80 Add support for generating programs that contain fold. Make the desired program size a command line argument.
Mike Pavone <pavone@retrodev.com>
parents: 8
diff changeset
272 }
0ccebdbc3e80 Add support for generating programs that contain fold. Make the desired program size a command line argument.
Mike Pavone <pavone@retrodev.com>
parents: 8
diff changeset
273 }
0ccebdbc3e80 Add support for generating programs that contain fold. Make the desired program size a command line argument.
Mike Pavone <pavone@retrodev.com>
parents: 8
diff changeset
274 0
3
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
275 }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
276 }