Mercurial > repos > icfp2013
annotate src/bv.tp @ 13:6de264ba8eb3
Fix a tiny bug in my bugfix for Bill
author | Mike Pavone <pavone@retrodev.com> |
---|---|
date | Fri, 09 Aug 2013 02:39:12 -0700 |
parents | 0ccebdbc3e80 |
children | 655d5b19333d |
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 } |