Mercurial > repos > rhope
annotate parser_old.rhope @ 76:004f0fc8941f
Fix list implementation
author | Mike Pavone <pavone@retrodev.com> |
---|---|
date | Wed, 07 Jul 2010 00:36:59 -0400 |
parents | 0083b2f7b3c7 |
children | 4d5ea487f810 |
rev | line source |
---|---|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1 Import nworker.rhope |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
2 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
3 Blueprint Parser |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
4 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
5 Arg Begin |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
6 Arg End |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
7 Line Comment |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
8 Comment Begin |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
9 Comment End |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
10 Assign |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
11 Block Begin |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
12 Block End |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
13 Blueprint Type Delim |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
14 Empty Block |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
15 Binary Operator |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
16 String Begin |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
17 String End |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
18 String Escape |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
19 List Begin |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
20 List End |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
21 List Delim |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
22 In Out Delim |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
23 Do Worker |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
24 Index Begin |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
25 Index End |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
26 Previous |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
27 Block Val |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
28 Set Field |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
29 Get Field |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
30 Import |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
31 Blueprint |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
32 Global Separator |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
33 Uses |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
34 Hex Escape |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
35 Escape Map |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
36 Foreign |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
37 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
38 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
39 New@Parser[:out] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
40 { |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
41 out <- [[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[Build["Parser"] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
42 ]Arg Begin << ["["] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
43 ]Arg End <<["]"] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
44 ]Line Comment <<["//"] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
45 ]Comment Begin <<["/*"] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
46 ]Comment End <<["*/"] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
47 ]Assign <<["<-"] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
48 ]Block Begin <<["{"] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
49 ]Block End <<["}"] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
50 ]Blueprint Type Delim <<[":"] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
51 ]Empty Block <<[";"] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
52 ]Binary Operator <<["`"] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
53 ]String Begin <<["\""] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
54 ]String End <<["\""] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
55 ]String Escape <<["\\"] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
56 ]List Begin <<["("] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
57 ]List End <<[")"] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
58 ]List Delim <<[","] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
59 ]In Out Delim <<[":"] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
60 ]Do Worker <<["$"] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
61 ]Index Begin <<["("] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
62 ]Index End <<[")"] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
63 ]Previous <<["@"] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
64 ]Set Field <<["<<"] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
65 ]Get Field <<[">>"] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
66 ]Import <<["Import"] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
67 ]Blueprint <<["Blueprint"] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
68 ]Global Separator <<["::"] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
69 ]Hex Escape <<["x"] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
70 ]Uses <<["uses"] |
48
a24eb366195c
Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
71 ]Escape Map <<[[[[Dictionary[]]Set["n","\n"]]Set["r","\r"]]Set["t","\t"]] |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
72 ]Foreign <<["Foreign"] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
73 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
74 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
75 Blueprint Output Reference |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
76 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
77 Index |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
78 Output Number |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
79 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
80 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
81 New@Output Reference[index,num:out] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
82 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
83 out <- [[Build["Output Reference"]]Index <<[index]]Output Number <<[num] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
84 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
85 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
86 Add Pipe Reference[refs,name,reference:out] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
87 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
88 reflist <- [refs]Index[name] {} |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
89 { |
48
a24eb366195c
Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
90 reflist <- () |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
91 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
92 out <- [refs]Set[name, [reflist]Append[reference]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
93 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
94 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
95 Assignment Save Reference[refs,assignment,output num,parse worker,index:out] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
96 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
97 [[parse worker]Outputs >>]Find[assignment] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
98 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
99 out <- refs |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
100 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
101 out <- Add Pipe Reference[refs, assignment, New@Output Reference[index, output num]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
102 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
103 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
104 |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
105 Blueprint Foreign Lib |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
106 { |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
107 Language |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
108 Name |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
109 } |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
110 |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
111 New Foreign Lib[language, library:out] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
112 { |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
113 out <- [[Build["Foreign Lib"] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
114 ]Language <<[language] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
115 ]Name <<[library] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
116 } |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
117 |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
118 Blueprint Parse Program |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
119 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
120 Workers |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
121 Imports |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
122 Blueprints |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
123 Errors |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
124 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
125 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
126 New@Parse Program[:out] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
127 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
128 out <- [[[Build["Parse Program"] |
48
a24eb366195c
Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
129 ]Workers <<[Dictionary[]] |
75
0083b2f7b3c7
Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents:
74
diff
changeset
|
130 ]Imports <<[[Dictionary[]]Set["kernel.rhope", Yes]] |
48
a24eb366195c
Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
131 ]Blueprints <<[Dictionary[]] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
132 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
133 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
134 Blueprint Blueprint Definition |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
135 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
136 Name |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
137 Fields |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
138 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
139 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
140 New@Blueprint Definition[name,fields:out] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
141 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
142 out <- [[Build["Blueprint Definition"]]Name << [name]]Fields <<[fields] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
143 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
144 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
145 Blueprint Parse Worker |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
146 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
147 Name |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
148 Inputs |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
149 Outputs |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
150 Line Number |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
151 Trees |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
152 Uses Stores |
37
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
153 Input Types |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
154 Output Types |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
155 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
156 |
37
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
157 New@Parse Worker[name,inputs,outputs,intypes,outtypes,line:out] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
158 { |
48
a24eb366195c
Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
159 out <- [[[[[[[[Build["Parse Worker"]]Name <<[name]]Inputs <<[inputs]]Outputs <<[outputs]]Line Number <<[line]]Trees <<[()]]Uses Stores <<[()]]Input Types <<[intypes]]Output Types <<[outtypes] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
160 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
161 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
162 Blueprint Worker Node |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
163 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
164 Name |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
165 Params |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
166 Assignments |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
167 Blocks |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
168 Index |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
169 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
170 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
171 New@Worker Node[name,params:out] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
172 { |
48
a24eb366195c
Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
173 out <- [[[[Build["Worker Node"]]Name <<[name]]Params <<[params]]Assignments <<[()]]Blocks <<[()] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
174 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
175 |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
176 Add List Helper[inlist,worker,program,key,parse worker,refs:out list,out worker,out refs] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
177 { |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
178 ,nextworker,nextrefs <- [[inlist]Index[key]]Add to Worker[worker, program, parse worker, refs] |
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
179 { nextlist <- [inlist]Set[key, ~] } |
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
180 [inlist]Next[key] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
181 { |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
182 out list,out worker,out refs <- Add List Helper[nextlist, nextworker, program, ~, parse worker, nextrefs] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
183 }{ |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
184 out list <- Val[nextlist] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
185 out worker <- Val[nextworker] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
186 out refs <- Val[nextrefs] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
187 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
188 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
189 |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
190 Add List to Worker[list,worker,program,parse worker,refs:out list,out worker,out refs] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
191 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
192 [list]First |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
193 { |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
194 out list,out worker,out refs <- Add List Helper[list, worker, program, ~, parse worker, refs] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
195 }{ |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
196 out list <- list |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
197 out worker <- worker |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
198 out refs <- refs |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
199 } |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
200 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
201 |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
202 _Add Blocks to Worker[blocks,worker,program,parse worker,key,refs:out blocks,out worker,out refs] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
203 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
204 block, next worker, nextrefs <- Add List to Worker[[blocks]Index[key], worker, program, parse worker, refs] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
205 next blocks <- [blocks]Set[key, block] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
206 [blocks]Next[key] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
207 { |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
208 out blocks,out worker,out refs <- _Add Blocks to Worker[next blocks, next worker, program, parse worker, ~, nextrefs] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
209 }{ |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
210 out blocks <- Val[next blocks] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
211 out worker <- Val[next worker] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
212 out refs <- Val[nextrefs] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
213 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
214 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
215 |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
216 Add Blocks to Worker[blocks,worker,program,parse worker,refs:out blocks,out worker,out refs] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
217 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
218 [blocks]First |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
219 { |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
220 out blocks, out worker, out refs <- _Add Blocks to Worker[blocks, worker, program, parse worker, ~, refs] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
221 }{ |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
222 out blocks <- blocks |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
223 out worker <- worker |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
224 out refs <- refs |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
225 } |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
226 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
227 |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
228 Add to Worker@Worker Node[node,worker,program,parse worker,refs:out node,out worker,out refs] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
229 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
230 [program]Find Worker[[node]Name >>] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
231 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
232 after worker <- [worker]Add Worker Call[~] {} |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
233 { |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
234 //Print[[[[node]Name >>]Append[" has index "]]Append[~]] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
235 assignment refs <- Fold[[["Assignment Save Reference"]Set Input[3, parse worker]]Set Input[4, ~], refs, [node]Assignments >>] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
236 [node]Index <<[~] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
237 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
238 params list, params worker, params refs <- Add List to Worker[[~]Params >>, after worker, program, parse worker, assignment refs] |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
239 block list, out worker, out refs <- Add Blocks to Worker[[~]Blocks >>, params worker, program, parse worker, params refs] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
240 out node <- [[~]Params <<[params list]]Blocks <<[block list] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
241 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
242 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
243 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
244 Print[["Error: Could not find a worker named "]Append[[node]Name >>]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
245 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
246 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
247 |
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
248 Check Question Mark[params, index:has mark,no mark] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
249 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
250 param,no mark <-[params]Index[index] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
251 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
252 If[[Type Of[param]]=["Named Pipe Node"]] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
253 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
254 has mark <-If[[[param]Name >>] = ["?"]] {} |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
255 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
256 has mark,no mark <- Check Question Mark[params, [index]+[1]] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
257 } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
258 }{ |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
259 has mark,no mark <- Check Question Mark[params, [index]+[1]] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
260 } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
261 } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
262 } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
263 |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
264 Collect Literal Inputs[literal, params, index, complex inputs:literal out,complex out] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
265 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
266 param <- [params]Index[index] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
267 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
268 If[[Type Of[param]]=["Literal Node"]] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
269 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
270 next literal <- [literal]Set Input[index, [param]Value >>] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
271 next complex <- Val[complex inputs] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
272 }{ |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
273 ,doset <- If[[Type Of[param]]=["Named Pipe Node"]] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
274 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
275 ,doset <- If[[[param]Name >>] = ["?"]] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
276 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
277 //Question mark indicates unpopulated input |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
278 next complex <- Val[complex inputs] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
279 next literal <- Val[literal] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
280 } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
281 } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
282 |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
283 Val[doset] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
284 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
285 next complex <- [complex inputs]Set[index, param] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
286 next literal <- Val[literal] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
287 } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
288 } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
289 literal out, complex out <- Collect Literal Inputs[next literal, params, [index]+[1], next complex] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
290 }{ |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
291 literal out <- literal |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
292 complex out <- complex inputs |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
293 } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
294 } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
295 |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
296 Do Set Input[literal,param,index:out] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
297 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
298 out <- New@Worker Node["Set Input", [[[()]Append[literal]]Append[New@Literal Node[index]]]Append[param]] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
299 } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
300 |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
301 Check Worker Literals@Worker Node[node,program:out] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
302 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
303 new params <- Map[[node]Params >>, ["Check Worker Literals"]Set Input[1, program]] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
304 Check Question Mark[new params, 0] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
305 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
306 base literal, complex inputs <- Collect Literal Inputs[Worker Literal[[node]Name >>], new params, 0, ()] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
307 new node <- Fold["Do Set Input", New@Literal Node[base literal], complex inputs] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
308 }{ |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
309 new node <- [node]Params <<[new params] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
310 } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
311 out <- [new node]Blocks <<[ Map[[node]Blocks >>, ["Map"]Set Input[1, ["Check Worker Literals"]Set Input[1, program]]] ] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
312 } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
313 |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
314 Add Multi Wire[worker,ref,junk,end index,input num:out] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
315 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
316 out <- [worker]Add Wire[[ref]Index >>, [ref]Output Number >>, end index, input num] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
317 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
318 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
319 Add Param Wire[worker,param,input num,end index,blocks,parse worker,assignments:out] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
320 { |
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
321 Print[["Add Param Wire: "]Append[input num]] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
322 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
323 param worker, start index, output num <- [param]Add Wires[worker, blocks, parse worker, assignments] { Print["got param worker"] } |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
324 { |
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
325 Print[["got normal output for param: "]Append[input num]] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
326 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
327 Print[["Start index: "]Append[start index]] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
328 Print[["Output num: "]Append[output num]] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
329 |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
330 out <- [param worker]Add Wire[start index, output num, end index, input num] |
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
331 { Print["Added param wire"] } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
332 } |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
333 }{}{ |
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
334 Print["got multi output"] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
335 out <- Fold[[["Add Multi Wire"]Set Input[3, end index]]Set Input[4, input num], param worker, ~] |
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
336 { Print["Added multi wire"] } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
337 } |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
338 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
339 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
340 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
341 _Add Block Wire[worker,node,junk,blocks,parse worker,assignments:out] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
342 { |
69
d0ce696786cc
Clean up debug print statements a bit. Fix bug that prevented workers that took no inputs from working. Remove workaround in Array for said bug.
Mike Pavone <pavone@retrodev.com>
parents:
52
diff
changeset
|
343 out <- [node]Add Wires[worker, blocks, parse worker, assignments] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
344 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
345 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
346 Add Block Wire[worker,block nodes,output num,parent index,existing blocks,parse worker,assignments:out] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
347 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
348 blocks <- [existing blocks]Append[New@Output Reference[parent index, output num]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
349 out <- Fold[[[["_Add Block Wire"]Set Input[3, blocks]]Set Input[4, parse worker]]Set Input[5, assignments], worker, block nodes] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
350 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
351 |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
352 Assignments Add Wires[worker,assignment,output num,parse worker,start index:out worker] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
353 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
354 [[parse worker]Outputs >>]Find[assignment] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
355 { |
37
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
356 ,output index <- [worker]Add Typed Output[assignment, ~, [[parse worker]Output Types >>]Index[~]] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
357 { |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
358 out worker <- [~]Add Wire[start index, output num, output index, 0] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
359 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
360 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
361 //Ugly hack alert! |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
362 If[[assignment]Contains["::"]] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
363 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
364 parts <- [assignment]Split["::"] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
365 ,global index <- [worker]Add Global Set[[parts]Index[0], [parts]Index[1]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
366 { |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
367 out worker <- [~]Add Wire[start index, output num, global index, 0] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
368 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
369 }{ |
69
d0ce696786cc
Clean up debug print statements a bit. Fix bug that prevented workers that took no inputs from working. Remove workaround in Array for said bug.
Mike Pavone <pavone@retrodev.com>
parents:
52
diff
changeset
|
370 out worker <- worker |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
371 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
372 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
373 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
374 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
375 Has Block@Worker Node[junk:out,unused] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
376 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
377 out <- Yes |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
378 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
379 |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
380 _Has Block Params[param list,key:out] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
381 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
382 param <- [param list]Index[key] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
383 out <- [param]Has Block {} |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
384 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
385 [param list]Next[key] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
386 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
387 out <- _Has Block Params[param list, ~] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
388 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
389 out <- No |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
390 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
391 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
392 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
393 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
394 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
395 Has Block Params[param list:out] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
396 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
397 [param list]First |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
398 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
399 out <- _Has Block Params[param list, ~] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
400 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
401 out <- No |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
402 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
403 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
404 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
405 Add Wires@Worker Node[node,worker,blocks,parse worker,assignments:worker,index,num,unused] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
406 { |
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
407 Print[["Add Wires@Worker Node: "]Append[[node]Name >>]] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
408 { |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
409 worker,index,num <- Add Wires Worker or Field[node, worker, blocks, parse worker, assignments] |
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
410 } |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
411 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
412 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
413 Add Wires Worker or Field[node,worker,blocks,parse worker,assignments:worker,index,num,unused] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
414 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
415 Fold[[["Assignments Add Wires"]Set Input[3, parse worker]]Set Input[4, [node]Index >>], worker, [node]Assignments >>] |
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
416 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
417 Print["Assignments Add Wires done"] |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
418 Fold[[[[["Add Block Wire"]Set Input[3, [node]Index >>]]Set Input[4, blocks]]Set Input[5, parse worker]]Set Input[6, assignments], ~, [node]Blocks >>] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
419 { |
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
420 Print["Add Block Wire done"] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
421 params worker <- Fold[[[[["Add Param Wire"]Set Input[3, [node]Index >>]]Set Input[4, blocks]]Set Input[5, parse worker]]Set Input[6, assignments], ~, [node]Params >>] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
422 { Print["Add Param Wire done"] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
423 index <- [node]Index >> |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
424 num <- 0 |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
425 } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
426 } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
427 } |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
428 If[Has Block Params[[node]Params >>]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
429 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
430 worker <- Val[params worker] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
431 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
432 [blocks]Peek |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
433 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
434 worker <- [params worker]Add Wire[[~]Index >>, [~]Output Number >>, [node]Index >>, [0]-[1]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
435 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
436 worker <- Val[params worker] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
437 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
438 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
439 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
440 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
441 Blueprint Field Node |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
442 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
443 Name |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
444 Params |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
445 Assignments |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
446 Blocks |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
447 Index |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
448 Set? |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
449 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
450 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
451 Has Block@Field Node[junk:has block,unused] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
452 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
453 has block <- Yes |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
454 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
455 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
456 New@Field Node[name,params,set:out] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
457 { |
48
a24eb366195c
Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
458 out <- [[[[[Build["Field Node"]]Name <<[name]]Assignments <<[()]]Blocks <<[()]]Set? <<[set]]Params <<[params] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
459 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
460 |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
461 Add to Worker@Field Node[node,worker,program,parse worker,refs:out node,out worker,out refs] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
462 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
463 If[[node]Set? >>] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
464 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
465 after worker,index <- [worker]Add Object Set[[node]Name >>] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
466 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
467 after worker,index <- [worker]Add Object Get[[node]Name >>] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
468 } |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
469 Val[index] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
470 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
471 assignment refs <- Fold[[["Assignment Save Reference"]Set Input[3, parse worker]]Set Input[4, ~], refs, [node]Assignments >>] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
472 [node]Index <<[~] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
473 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
474 params list, params worker, params refs <- Add List to Worker[[~]Params >>, after worker, program, parse worker, assignment refs] |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
475 block list, out worker, out refs <- Add Blocks to Worker[[~]Blocks >>, params worker, program, parse worker, params refs] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
476 out node <- [[~]Params <<[params list]]Blocks <<[block list] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
477 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
478 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
479 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
480 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
481 Add Wires@Field Node[node,worker,blocks,parse worker,assignments:worker,index,num] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
482 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
483 worker,index,num <- Add Wires Worker or Field[node, worker, blocks, parse worker, assignments] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
484 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
485 |
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
486 Check Worker Literals@Field Node[node,program:out] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
487 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
488 new params <- Map[[node]Params >>, ["Check Worker Literals"]Set Input[1, program]] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
489 out <- [[node]Blocks <<[ Map[[node]Blocks >>, ["Map"]Set Input[1, ["Check Worker Literals"]Set Input[1, program]]] ] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
490 ]Params <<[new params] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
491 } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
492 |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
493 Blueprint Named Pipe Node |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
494 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
495 Name |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
496 Assignments |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
497 Blocks |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
498 Index |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
499 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
500 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
501 Has Block@Named Pipe Node[node:has block,no block] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
502 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
503 If[[[node]Index >>] < [0]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
504 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
505 //~ should really be a parser parameter |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
506 If[[[node]Name >>] = ["~"]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
507 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
508 has block <- Yes |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
509 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
510 no block <- No |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
511 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
512 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
513 has block <- Yes |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
514 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
515 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
516 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
517 New@Named Pipe Node[name:out] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
518 { |
48
a24eb366195c
Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
519 out <- [[[Build["Named Pipe Node"]]Name <<[name]]Assignments <<[()]]Blocks <<[()] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
520 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
521 |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
522 Add to Worker@Named Pipe Node[node,worker,program,parse worker,refs:out node,out worker,out refs] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
523 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
524 [[parse worker]Inputs >>]Find[[node]Name >>] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
525 { |
37
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
526 after add <- [worker]Add Typed Input[[node]Name >>, ~, [[parse worker]Input Types>>]Index[~]] {} |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
527 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
528 assign refs <- Fold[[["Assignment Save Reference"]Set Input[3, parse worker]]Set Input[4, ~], refs, [node]Assignments >>] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
529 index node <- [node]Index <<[~] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
530 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
531 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
532 after add <- worker |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
533 index node <- [node]Index <<[[0]-[1]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
534 //TODO: Handle assignments from a named pipe that isn't an input |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
535 assign refs <- refs |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
536 } |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
537 block list, out worker, out refs <- Add Blocks to Worker[[node]Blocks >>, after add, program, parse worker, assign refs] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
538 out node <- [index node]Blocks <<[block list] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
539 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
540 |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
541 Add Wires@Named Pipe Node[node,worker,blocks,parse worker,assignments:worker,index,num,reflist] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
542 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
543 reflist <- [assignments]Index[[node]Name >>] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
544 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
545 //TODO: Fix support for a named pipe with a block |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
546 worker <- worker |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
547 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
548 If[[[node]Name >>] = ["~"]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
549 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
550 wires worker <- worker |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
551 [blocks]Peek |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
552 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
553 my index <- [~]Index >> |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
554 num <- [~]Output Number >> |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
555 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
556 //TODO: Propagate an error rather than printing it out |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
557 Print["Error, block reference symbol located outside of a block"] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
558 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
559 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
560 If[[[node]Index >>] < [0]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
561 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
562 Print[[[["Error, reference to named pipe "]Append[[node]Name >>]]Append[" that was never assigned to in worker "]]Append[[parse worker]Name >>]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
563 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
564 my index <- [node]Index >> |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
565 num <- 0 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
566 assignments worker <- Fold[[["Assignments Add Wires"]Set Input[3, parse worker]]Set Input[4, [node]Index >>], worker, [node]Assignments >>] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
567 [blocks]Peek |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
568 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
569 wires worker <- [assignments worker]Add Wire[[~]Index >>, [~]Output Number >>, [node]Index >>, [0]-[1]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
570 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
571 wires worker <- Val[assignments worker] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
572 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
573 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
574 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
575 } |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
576 index <- Val[my index] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
577 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
578 worker <- Fold[[[[["Add Block Wire"]Set Input[3, my index]]Set Input[4, blocks]]Set Input[5, parse worker]]Set Input[6, assignments], wires worker, [node]Blocks >>] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
579 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
580 |
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
581 Check Worker Literals@Named Pipe Node[node,program:out] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
582 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
583 out <- [node]Blocks <<[ Map[[node]Blocks >>, ["Map"]Set Input[1, ["Check Worker Literals"]Set Input[1, program]]] ] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
584 } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
585 |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
586 Blueprint Global Node |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
587 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
588 Store |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
589 Name |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
590 Assignments |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
591 Blocks |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
592 Index |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
593 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
594 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
595 New@Global Node[store,name:out] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
596 { |
48
a24eb366195c
Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
597 out <- [[[[Build["Global Node"]]Store <<[store]]Name <<[name]]Assignments <<[()]]Blocks <<[()] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
598 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
599 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
600 Add to Worker@Global Node[node,worker,unused,parse worker,refs:out node,out worker,refs] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
601 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
602 out worker <- [worker]Add Global Get[[node]Store >>, [node]Name >>] {} |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
603 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
604 refs <- Fold[[["Assignment Save Reference"]Set Input[3, parse worker]]Set Input[4, ~], refs, [node]Assignments >>] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
605 out node <- [node]Index <<[~] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
606 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
607 refs <- refs |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
608 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
609 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
610 Add Wires@Global Node[node,worker,blocks,parse worker,assignments:worker,index,num,unused] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
611 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
612 worker,index,num <- Add Wires Literal or Global[node, worker, blocks, parse worker, assignments] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
613 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
614 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
615 Has Block@Global Node[junk:out,unused] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
616 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
617 out <- Yes |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
618 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
619 |
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
620 Check Worker Literals@Global Node[node,program:out] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
621 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
622 out <- [node]Blocks <<[ Map[[node]Blocks >>, ["Map"]Set Input[1, ["Check Worker Literals"]Set Input[1, program]]] ] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
623 } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
624 |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
625 Blueprint Literal Node |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
626 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
627 Value |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
628 Assignments |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
629 Blocks |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
630 Index |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
631 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
632 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
633 Has Block@Literal Node[junk:out,unused] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
634 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
635 out <- Yes |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
636 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
637 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
638 New@Literal Node[value:out] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
639 { |
48
a24eb366195c
Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
640 out <- [[[Build["Literal Node"]]Value <<[value]]Assignments <<[()]]Blocks <<[()] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
641 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
642 |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
643 Add to Worker@Literal Node[node,worker,unused,parse worker,refs:out node,out worker,out refs] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
644 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
645 out worker <- [worker]Add Constant[[node]Value >>] {} |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
646 { |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
647 out refs <- Fold[[["Assignment Save Reference"]Set Input[3, parse worker]]Set Input[4, ~], refs, [node]Assignments >>] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
648 out node <- [node]Index <<[~] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
649 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
650 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
651 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
652 Add Wires@Literal Node[node,worker,blocks,parse worker,assignments:worker,index,num,unused] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
653 { |
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
654 Print[["Add Wires@Literal Node, Literal Type: "]Append[Type Of[[node]Value >>]]] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
655 worker,index,num <- Add Wires Literal or Global[node, worker, blocks, parse worker, assignments] |
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
656 { Print["Got worker"] } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
657 { Print["got index"] } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
658 { Print["got num"] } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
659 } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
660 |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
661 Check Worker Literals@Literal Node[node,program:out] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
662 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
663 out <- [node]Blocks <<[ Map[[node]Blocks >>, ["Map"]Set Input[1, ["Check Worker Literals"]Set Input[1, program]]] ] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
664 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
665 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
666 Add Wires Literal or Global[node,worker,blocks,parse worker,junk:worker,index,num,unused] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
667 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
668 assignments worker <- Fold[[["Assignments Add Wires"]Set Input[3, parse worker]]Set Input[4, [node]Index >>], worker, [node]Assignments >>] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
669 [blocks]Peek |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
670 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
671 worker <- [assignments worker]Add Wire[[~]Index >>, [~]Output Number>>, [node]Index >>, [0]-[1]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
672 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
673 worker <- Val[assignments worker] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
674 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
675 index <- [node]Index >> |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
676 num <- 0 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
677 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
678 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
679 Blueprint Block Node |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
680 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
681 Number |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
682 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
683 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
684 Blueprint Parse Error |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
685 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
686 Type |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
687 Text |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
688 Line Number |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
689 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
690 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
691 New@Parse Error[type,text,number:out] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
692 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
693 out <- [[[Build["Parse Error"]]Type <<[type]]Text <<[text]]Line Number <<[number] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
694 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
695 |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
696 Not Empty[string:out] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
697 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
698 If[[[string]Length] > [0]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
699 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
700 out <- Yes |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
701 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
702 out <- No |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
703 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
704 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
705 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
706 Blueprint Blueprint Field |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
707 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
708 Name |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
709 Type |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
710 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
711 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
712 New@Blueprint Field[name,type:out] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
713 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
714 out <- [[Build["Blueprint Field"]]Name <<[name]]Type <<[type] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
715 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
716 |
40
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
717 Process Blueprint Field[list,field,params:out] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
718 { |
40
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
719 ,name <- [field]Get DString[[params]List Begin >>] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
720 { |
40
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
721 type info <- Parse List[~,params,()] |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
722 type <- [type info]Index[0] |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
723 { |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
724 If[[Type Of[~]] = ["Named Pipe Node"]] |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
725 { |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
726 before variant <- Type Instance[[type]Name >>] |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
727 }{ |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
728 before variant <- [type]Params <<[ Map[[type]Params >>, "Remove Named Pipe Node"] ] |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
729 } |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
730 variant <- [type info]Index[1] |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
731 { |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
732 ,warn <- If[[Type Of[~]] = ["Named Pipe Node"]] |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
733 { |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
734 fieldtype,warn <- [before variant]Set Variant[[variant]Name >>] |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
735 } |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
736 Val[warn] |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
737 { |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
738 Print[[[["Warning: Invalid variant for type "]Append[[before variant]Name >>]]Append[" on field "]]Append[name]] |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
739 fieldtype <- Val[before variant] |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
740 } |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
741 }{ |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
742 fieldtype <- Val[before variant] |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
743 } |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
744 }{ |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
745 fieldtype <- Type Instance["Any Type"] |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
746 } |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
747 out <- [list]Append[New@Blueprint Field[name, fieldtype]] |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
748 } {} {} { |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
749 out <- [list]Append[New@Blueprint Field[name, Type Instance["Any Type"]]] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
750 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
751 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
752 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
753 Block Comment[string,begin comment,end comment,block count:out] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
754 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
755 If[[block count] > [0]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
756 { |
48
a24eb366195c
Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
757 after, before <- [string]Get DString[[[()]Append[begin comment]]Append[end comment]] {} {} |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
758 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
759 If[[~] = [begin comment]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
760 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
761 out <- Block Comment[after, begin comment, end comment, [block count]+[1]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
762 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
763 out <- Block Comment[after, begin comment, end comment, [block count]-[1]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
764 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
765 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
766 //No match |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
767 out <- "" |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
768 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
769 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
770 out <- string |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
771 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
772 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
773 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
774 Line Comment[string:out] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
775 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
776 [string]Get DString["\n"] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
777 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
778 out <- ["\n"]Append[~] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
779 } {} {} { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
780 out <- "" |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
781 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
782 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
783 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
784 _Get Comment DString[string,delims,line comment,begin comment,end comment,prev before:rest,before,delim,nomatch] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
785 { |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
786 after,befored,used delim,nomatch <- [string]Get DString[delims] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
787 { |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
788 If[[used delim] = [line comment]] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
789 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
790 after comment <- Line Comment[after] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
791 }{ |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
792 If[[used delim] = [begin comment]] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
793 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
794 after comment <- Block Comment[after, begin comment, end comment, 1] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
795 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
796 rest <- Val[after] |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
797 before <- [prev before]Append[befored] |
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
798 delim <- Val[used delim] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
799 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
800 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
801 } {} {} { |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
802 before <- [prev before]Append[befored] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
803 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
804 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
805 after comment |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
806 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
807 rest,more before,delim,nomatch <- _Get Comment DString[~, delims, line comment, begin comment, end comment, prev before] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
808 before <- [before]Append[more before] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
809 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
810 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
811 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
812 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
813 Get Comment DString[string,delims,params:rest,before,delim,not found] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
814 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
815 line comment <- [params]Line Comment >> |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
816 begin comment <- [params]Comment Begin >> |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
817 end comment <- [params]Comment End >> |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
818 all delims <- [[[delims]As List]Append[begin comment]]Append[line comment] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
819 rest, before, delim, not found <- _Get Comment DString[string, delims, line comment, begin comment, end comment, ""] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
820 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
821 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
822 Comment Left Trim[string,trim chars,params:out] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
823 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
824 line comment <- [params]Line Comment >> |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
825 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
826 end comment <- [params]Comment End >> |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
827 trimmed <- Left Trim[string, trim chars] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
828 If[[trimmed]Starts With[line comment]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
829 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
830 ,after delim <- [trimmed]Slice[[line comment]Length] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
831 out <- Comment Left Trim[Line Comment[after delim], trim chars, params] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
832 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
833 begin comment <- [params]Comment Begin >> |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
834 If[[trimmed]Starts With[begin comment]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
835 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
836 ,after delim <- [trimmed]Slice[[line comment]Length] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
837 out <- Comment Left Trim[Block Comment[after delim, begin comment, end comment, 1], trim chars, params] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
838 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
839 out <- Val[trimmed] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
840 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
841 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
842 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
843 |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
844 PBlueprint[string,params,tree,lines:out] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
845 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
846 ,whitespace name <- [string]Get Comment DString[[params]Block Begin >>, params] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
847 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
848 ,no blueprint <- [whitespace name]Slice[ [[params]Blueprint >>]Length ] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
849 name <- Trim[no blueprint, "\r\n\t "] |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
850 name lines <- 0 |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
851 ,body <- [~]Get Comment DString[ [params]Block End >>, params] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
852 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
853 body lines <- [body]Split["\n"] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
854 more lines <- [[[body lines]Length] - [1]] + [name lines] |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
855 fields <- Fold[["Process Blueprint Field"]Set Input[2, params], (), Filter[Map[body lines, ["Trim"]Set Input[1,"\n\r\t "]], "Not Empty"]] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
856 new tree <- [tree]Blueprints << [ [[tree]Blueprints >>]Set[name, New@Blueprint Definition[name, fields]] ] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
857 out <- Null[~, params, new tree, [lines] + [more lines]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
858 } {} { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
859 out <- [tree]Errors <<[ [[tree]Errors >>]Append[New@Parse Error["Error",[["Blueprint is missing an block close symbol \""]Append[[params]Block End >>]]Append["\""], lines]] ] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
860 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
861 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
862 } {} { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
863 out <- [tree]Errors <<[ [[tree]Errors >>]Append[New@Parse Error["Error",[["Blueprint is missing an block open symbol \""]Append[[params]Block Begin >>]]Append["\""], lines]] ] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
864 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
865 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
866 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
867 Parse Import[string,params,tree,lines:out] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
868 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
869 [line]Slice[ [[params]Import >>]Length ] {} |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
870 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
871 filename <- Trim[~, " \n\r\t"] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
872 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
873 new tree <- [tree]Imports <<[ [[tree]Imports >>]Set[filename, Yes] ] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
874 ,line <- [string]Get Comment DString["\n", params] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
875 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
876 out <- Null[~, params, new tree, [lines] + [1]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
877 } {} { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
878 out <- Val[new tree] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
879 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
880 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
881 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
882 Get Expression Blocks[string,params,blocks:blocks,after] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
883 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
884 check block <- Comment Left Trim[string, "\n\r\t ", params] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
885 If[[check block]Starts With[[params]Block Begin >>]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
886 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
887 ,begin block <- [check block]Slice[[[params]Block Begin >>]Length] |
48
a24eb366195c
Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
888 trees, after block <- Worker Body[begin block, params, ()] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
889 blocks, after <- Get Expression Blocks[after block, params, [blocks]Append[trees]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
890 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
891 If[[check block]Starts With[[params]Empty Block >>]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
892 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
893 blocks <- blocks |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
894 ,after <- [check block]Slice[[[params]Empty Block >>]Length] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
895 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
896 blocks <- blocks |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
897 after <- Val[check block] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
898 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
899 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
900 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
901 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
902 Parse Escape[string,params:char,after] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
903 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
904 code,rest <- [string]Slice[1] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
905 If[[code] = [[params]Hex Escape >>]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
906 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
907 hex,after <- [rest]Slice[2] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
908 char <- [""]Put Byte[From Hex@Whole Number[hex]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
909 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
910 after <- Val[rest] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
911 char <- [[params]Escape Map >>]Index[code] {} |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
912 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
913 char <- Val[code] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
914 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
915 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
916 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
917 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
918 Parse String[string,params,current:value,after] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
919 { |
48
a24eb366195c
Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
920 delims <- [[()]Append[[params]String End >>]]Append[[params]String Escape >>] |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
921 afters, before, delim <- [string]Get Comment DString[delims, params] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
922 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
923 If[[delim] = [[params]String End >>]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
924 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
925 value <- [current]Append[before] |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
926 after <- Val[afters] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
927 }{ |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
928 char,after escape <- Parse Escape[afters, params] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
929 value,after <- Parse String[after escape, params, [[current]Append[before]]Append[char]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
930 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
931 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
932 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
933 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
934 Parse List[string,params,list:value,after] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
935 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
936 trimmed <- Comment Left Trim[string, "\r\n\t ", params] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
937 If[[trimmed]Starts With[[params]List End >>]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
938 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
939 value <- list |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
940 ,after <- [trimmed]Slice[[[params]List End >>]Length] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
941 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
942 If[[trimmed]Starts With[[params]List Delim >>]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
943 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
944 ,el string <- [trimmed]Slice[[[params]List Delim >>]Length] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
945 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
946 el string <- Val[trimmed] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
947 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
948 element,after el <- Named Pipe or Literal[el string, params] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
949 value,after <- Parse List[after el, params, [list]Append[[element]Get Value]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
950 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
951 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
952 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
953 Get Value@Literal Node[node:out] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
954 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
955 out <- [node]Value >> |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
956 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
957 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
958 Get Value@Named Pipe Node[node:out] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
959 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
960 out <- node |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
961 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
962 |
50
689fb73e7612
Add support for various integer literals and add support for raw pointers to objects and raw pointers to arrays in the FFI
Mike Pavone <pavone@retrodev.com>
parents:
49
diff
changeset
|
963 Blueprint Machine Integer |
689fb73e7612
Add support for various integer literals and add support for raw pointers to objects and raw pointers to arrays in the FFI
Mike Pavone <pavone@retrodev.com>
parents:
49
diff
changeset
|
964 { |
689fb73e7612
Add support for various integer literals and add support for raw pointers to objects and raw pointers to arrays in the FFI
Mike Pavone <pavone@retrodev.com>
parents:
49
diff
changeset
|
965 Value |
689fb73e7612
Add support for various integer literals and add support for raw pointers to objects and raw pointers to arrays in the FFI
Mike Pavone <pavone@retrodev.com>
parents:
49
diff
changeset
|
966 Size |
689fb73e7612
Add support for various integer literals and add support for raw pointers to objects and raw pointers to arrays in the FFI
Mike Pavone <pavone@retrodev.com>
parents:
49
diff
changeset
|
967 Signed? |
689fb73e7612
Add support for various integer literals and add support for raw pointers to objects and raw pointers to arrays in the FFI
Mike Pavone <pavone@retrodev.com>
parents:
49
diff
changeset
|
968 } |
689fb73e7612
Add support for various integer literals and add support for raw pointers to objects and raw pointers to arrays in the FFI
Mike Pavone <pavone@retrodev.com>
parents:
49
diff
changeset
|
969 |
689fb73e7612
Add support for various integer literals and add support for raw pointers to objects and raw pointers to arrays in the FFI
Mike Pavone <pavone@retrodev.com>
parents:
49
diff
changeset
|
970 Machine Integer[value,size,signed?:out] |
689fb73e7612
Add support for various integer literals and add support for raw pointers to objects and raw pointers to arrays in the FFI
Mike Pavone <pavone@retrodev.com>
parents:
49
diff
changeset
|
971 { |
689fb73e7612
Add support for various integer literals and add support for raw pointers to objects and raw pointers to arrays in the FFI
Mike Pavone <pavone@retrodev.com>
parents:
49
diff
changeset
|
972 out <- [[[Build["Machine Integer"]]Value <<[value]]Size <<[size]]Signed? <<[signed?] |
689fb73e7612
Add support for various integer literals and add support for raw pointers to objects and raw pointers to arrays in the FFI
Mike Pavone <pavone@retrodev.com>
parents:
49
diff
changeset
|
973 } |
689fb73e7612
Add support for various integer literals and add support for raw pointers to objects and raw pointers to arrays in the FFI
Mike Pavone <pavone@retrodev.com>
parents:
49
diff
changeset
|
974 |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
975 Parse Number[string,params:value,after] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
976 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
977 delims <- [[[[(" ","\t","\n","\r")]Append[[params]List Delim >>]]Append[[params]Block Begin >>]]Append[[params]Arg End >>]]Append[[params]List End >>] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
978 after delim,valstring <- [string]Get Comment DString[delims, params] {} {} |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
979 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
980 after <- [~]Append[after delim] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
981 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
982 after <- "" |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
983 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
984 first two,rest <- [valstring]Slice[2] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
985 If[[first two] = ["0x"]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
986 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
987 value <- From Hex@Whole Number[rest] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
988 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
989 If[[valstring]Contains["."]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
990 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
991 value <- <String@Real Number[valstring] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
992 }{ |
50
689fb73e7612
Add support for various integer literals and add support for raw pointers to objects and raw pointers to arrays in the FFI
Mike Pavone <pavone@retrodev.com>
parents:
49
diff
changeset
|
993 size, val, type <- [valstring]Get DString[("i","u")] |
689fb73e7612
Add support for various integer literals and add support for raw pointers to objects and raw pointers to arrays in the FFI
Mike Pavone <pavone@retrodev.com>
parents:
49
diff
changeset
|
994 { |
689fb73e7612
Add support for various integer literals and add support for raw pointers to objects and raw pointers to arrays in the FFI
Mike Pavone <pavone@retrodev.com>
parents:
49
diff
changeset
|
995 value <- Machine Integer[<String@Whole Number[val], <String@Whole Number[size], [type]=["i"]] |
689fb73e7612
Add support for various integer literals and add support for raw pointers to objects and raw pointers to arrays in the FFI
Mike Pavone <pavone@retrodev.com>
parents:
49
diff
changeset
|
996 } {} {} { |
689fb73e7612
Add support for various integer literals and add support for raw pointers to objects and raw pointers to arrays in the FFI
Mike Pavone <pavone@retrodev.com>
parents:
49
diff
changeset
|
997 value <- <String@Whole Number[valstring] |
689fb73e7612
Add support for various integer literals and add support for raw pointers to objects and raw pointers to arrays in the FFI
Mike Pavone <pavone@retrodev.com>
parents:
49
diff
changeset
|
998 } |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
999 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1000 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1001 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1002 |
37
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1003 Parse Params@Type Instance[literal,params,string:out,after] |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1004 { |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1005 plist,after <- Parse List[string,params,()] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1006 out <- [literal]Params <<[plist] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1007 } |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1008 |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1009 Named Pipe or Literal[string,params:out,after] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1010 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1011 name <- Comment Left Trim[string, "\n\r\t ", params] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1012 If[[name]Starts With[[params]String Begin >>]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1013 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1014 ,string begin <- [name]Slice[[[params]String Begin >>]Length] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1015 value,after <- Parse String[string begin, params, ""] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1016 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1017 If[[name]Starts With[[params]List Begin >>]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1018 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1019 ,list start <- [name]Slice[[[params]List Begin >>]Length] |
48
a24eb366195c
Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1020 value,after <- Parse List[list start, params, ()] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1021 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1022 If[[[name]Slice[1]]In["-0123456789"]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1023 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1024 value,after <- Parse Number[name, params] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1025 }{ |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1026 delims <- [[[[[[[("\n")]Append[[params]Block Begin >>]]Append[[params]Block End >>]]Append[[params]Empty Block >>]]Append[[params]Arg End >>]]Append[[params]List Delim >>]]Append[[params]List End >>]]Append[[params]List Begin >>] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1027 afterdelim,raw before,delim,nodelim <- [name]Get Comment DString[delims, params] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1028 |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1029 before <- Trim[raw before, "\r\n\t "] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1030 If[[delim] = [[params]List Begin >>]] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1031 { |
37
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1032 value,after <- [Type Instance[before]]Parse Params[params,afterdelim] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1033 }{ |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1034 Val[afterdelim] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1035 { |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1036 after <- [delim]Append[~] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1037 } |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1038 Val[nodelim] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1039 { |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1040 after <- "" |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1041 } |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1042 If[[before] = ["Yes"]] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1043 { |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1044 yesno <- Yes |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1045 }{ |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1046 If[[before] = ["No"]] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1047 { |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1048 yesno <- No |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1049 }{ |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1050 If[[before] = [""]] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1051 { |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1052 Print[[["Found "]Append[delim]]Append[" where a named pipe or literal was expected"]] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1053 { Print[["Near: "]Append[ [afterdelim]Slice[40]]] } |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1054 }{ |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1055 If[[before]Contains[[params]Global Separator >>]] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1056 { |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1057 parts <- [before]Split[[params]Global Separator >>] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1058 out <- New@Global Node[Right Trim[[parts]Index[0],"\r\n\t "], Trim[[parts]Index[1], "\r\n\t "]] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1059 }{ |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1060 out <- New@Named Pipe Node[Right Trim[before,"\r\n\t "]] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1061 } |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1062 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1063 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1064 } |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1065 out <- New@Literal Node[yesno] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1066 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1067 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1068 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1069 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1070 out <- New@Literal Node[value] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1071 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1072 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1073 Parse Arguments[string,params,arglist:args,after] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1074 { |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1075 targs <- Comment Left Trim[string, "\r\n\t ", params] |
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1076 If[[targs]Starts With[[params]List Delim >>]] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1077 { |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1078 [targs]Slice[[[params]List Delim >>]Length] {} |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1079 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1080 final args <- Comment Left Trim[~, "\r\n\t ", params] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1081 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1082 }{ |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1083 If[[targs]Starts With[[params]Arg End >>]] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1084 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1085 args <- arglist |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1086 ,after <- [targs]Slice[[[params]Arg End >>]Length] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1087 }{ |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1088 final args <- Val[targs] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1089 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1090 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1091 arg, after arg <- Parse Expression[final args, params] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1092 args, after <- Parse Arguments[after arg, params, [arglist]Append[arg]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1093 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1094 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1095 Worker or Field[name,args,params:out] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1096 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1097 get field <- [params]Get Field >> |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1098 If[[name]Ends With[get field]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1099 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1100 field <- Right Trim[[name]Slice[[[name]Length] - [[get field]Length]], "\n\r\t "] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1101 out <- New@Field Node[field, args, No] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1102 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1103 set field <- [params]Set Field >> |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1104 If[[name]Ends With[set field]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1105 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1106 field <- Right Trim[[name]Slice[[[name]Length] - [[set field]Length]], "\n\r\t "] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1107 out <- New@Field Node[field, args, Yes] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1108 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1109 out <- New@Worker Node[name, args] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1110 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1111 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1112 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1113 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1114 Prefix[string,params,name,existing args:expression,after] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1115 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1116 //Parse argument list |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1117 more args,after <- Parse Arguments[string, params, existing args] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1118 expression <- Worker or Field[name, more args, params] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1119 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1120 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1121 Postfix or Infix[string,params:expression,after] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1122 { |
48
a24eb366195c
Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1123 args, after args <- Parse Arguments[string, params, ()] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1124 delims <- [[[[[("\n")]Append[[params]Arg Begin >>]]Append[[params]Empty Block >>]]Append[[params]Block Begin >>]]Append[[params]Arg End >>]]Append[[params]List Delim >>] |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1125 aftere,before,delim <- [after args]Get Comment DString[delims, params] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1126 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1127 If[[delim] = [[params]Arg Begin >>]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1128 { |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1129 expression, after <- Prefix[aftere, params, Trim[before,"\r\n\t "], args] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1130 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1131 If[[delim] = [[params]Empty Block >>]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1132 { |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1133 after <- Val[aftere] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1134 }{ |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1135 ,after <- [after args]Slice[[before]Length] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1136 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1137 expression <- Worker or Field[Trim[before,"\r\n\t "], args, params] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1138 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1139 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1140 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1141 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1142 Parse Expression[trimmed,params:final expression,after blocks] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1143 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1144 delims <- [[[[[[[("\n")]Append[[params]Arg Begin >>]]Append[[params]Arg End >>]]Append[[params]Assign >>]]Append["\n"]]Append[[params]Empty Block >>]]Append[[params]Block End >>]]Append[[params]String Begin >>] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1145 after, before, delim <- [trimmed]Get Comment DString[delims, params] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1146 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1147 //If we find an arg begin token, we have a worker expression |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1148 If[[delim] = [[params]Arg Begin >>]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1149 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1150 maybe name <- Right Trim[before, "\r\t "] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1151 //Prefix expressions will have the worker name before the first arg begin token |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1152 If[[maybe name] = [""]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1153 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1154 expression, after expression <- Postfix or Infix[after, params] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1155 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1156 If[[maybe name]Contains[[params]List Delim >>]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1157 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1158 after expression <- [after literal]Append[[delim]Append[after]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1159 expression, after literal <- Named Pipe or Literal[Right Trim[before, "\r\n\t "], params] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1160 }{ |
48
a24eb366195c
Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1161 expression, after expression <- Prefix[after, params, maybe name, ()] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1162 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1163 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1164 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1165 If[[delim] = [[params]Assign >>]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1166 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1167 //Expressions starting with an assignment can be prefix, postfix or infix |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1168 //or they can be a simple literal or named pipe |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1169 assignments <- Map[[before]Split[[params]List Delim >>], ["Trim"]Set Input[1,"\n\r\t "]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1170 ,after blocks <- Parse Expression[Comment Left Trim[after, " \n\r\t", params], params] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1171 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1172 final expression <- [~]Assignments <<[assignments] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1173 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1174 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1175 //If[[delim] = [[params]String Begin >>]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1176 //{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1177 // If[[Trim[before, "\r\n\t "]] = [""]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1178 // { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1179 // expression, after expression <- Named Pipe or Literal[[delim]Append[after], params] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1180 // }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1181 // after expression <- [after literal]Append[[delim]Append[after]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1182 // expression, after literal <- Named Pipe or Literal[Right Trim[before, "\r\n\t "], params] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1183 // } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1184 //}{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1185 // after expression <- [after literal]Append[[delim]Append[after]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1186 // expression, after literal <- Named Pipe or Literal[Right Trim[before, "\r\n\t "], params] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1187 //} |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1188 expression, after expression <- Named Pipe or Literal[trimmed, params] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1189 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1190 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1191 //Any expression can be followed by one or more blocks mapping the inputs of other expressions |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1192 //to the outputs of the current one |
48
a24eb366195c
Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1193 blocks,after blocks <- Get Expression Blocks[after expression, params, ()] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1194 final expression <- [expression]Blocks <<[blocks] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1195 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1196 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1197 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1198 Worker Body[string,params,trees:trees,after end] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1199 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1200 trimmed <- Comment Left Trim[string, "\n\r\t ", params] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1201 If[[trimmed]Starts With[[params]Block End >>]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1202 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1203 //We're done with this block, return |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1204 ,after end <- [trimmed]Slice[[[params]Block End >>]Length] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1205 trees <- trees |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1206 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1207 expression, after expression <- Parse Expression[trimmed, params] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1208 trees,after end <- Worker Body[after expression, params, [trees]Append[expression]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1209 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1210 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1211 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1212 Process Modifiers[worker,params,modifiers:out] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1213 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1214 //Eventually this will need to be more sophisticated to handle more modifiers |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1215 trimmed <- Comment Left Trim[modifiers, "\n\r\t ", params] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1216 If[[trimmed]Starts With[[params]Uses >>]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1217 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1218 ,after uses <- [trimmed]Slice[[[params]Uses >>]Length] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1219 ,stores string <- [after uses]Get Comment DString["\n", params] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1220 out <- [worker]Uses Stores <<[Map[[stores string]Split[[params]List Delim >>], ["Trim"]Set Input[1, "\r\n\t "]]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1221 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1222 out <- worker |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1223 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1224 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1225 |
37
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1226 Remove Named Pipe Node[element:out] |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1227 { |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1228 If[[Type Of[element]] = ["Named Pipe Node"]] |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1229 { |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1230 out <- [element]Name >> |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1231 }{ |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1232 If[[Type Of[element]] = ["Type Instance"]] |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1233 { |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1234 out <- [element]Params <<[ Map[[element]Params >>, "Remove Named Pipe Node"] ] |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1235 }{ |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1236 out <- element |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1237 } |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1238 } |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1239 } |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1240 |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1241 Parse Param List[text,paramlist,typelist,params:out params,out types] |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1242 { |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1243 delims <- [[()]Append[[params]List Begin >>]]Append[[params]List Delim >>] |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1244 after,param name <-[text]Get DString[delims] {} |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1245 { |
69
d0ce696786cc
Clean up debug print statements a bit. Fix bug that prevented workers that took no inputs from working. Remove workaround in Array for said bug.
Mike Pavone <pavone@retrodev.com>
parents:
52
diff
changeset
|
1246 tname <- Trim[~, "\r\n\t "] |
d0ce696786cc
Clean up debug print statements a bit. Fix bug that prevented workers that took no inputs from working. Remove workaround in Array for said bug.
Mike Pavone <pavone@retrodev.com>
parents:
52
diff
changeset
|
1247 If[[tname] = [""]] |
d0ce696786cc
Clean up debug print statements a bit. Fix bug that prevented workers that took no inputs from working. Remove workaround in Array for said bug.
Mike Pavone <pavone@retrodev.com>
parents:
52
diff
changeset
|
1248 { |
d0ce696786cc
Clean up debug print statements a bit. Fix bug that prevented workers that took no inputs from working. Remove workaround in Array for said bug.
Mike Pavone <pavone@retrodev.com>
parents:
52
diff
changeset
|
1249 nextlist <- Val[paramlist] |
d0ce696786cc
Clean up debug print statements a bit. Fix bug that prevented workers that took no inputs from working. Remove workaround in Array for said bug.
Mike Pavone <pavone@retrodev.com>
parents:
52
diff
changeset
|
1250 next types <- Val[typelist] |
d0ce696786cc
Clean up debug print statements a bit. Fix bug that prevented workers that took no inputs from working. Remove workaround in Array for said bug.
Mike Pavone <pavone@retrodev.com>
parents:
52
diff
changeset
|
1251 }{ |
d0ce696786cc
Clean up debug print statements a bit. Fix bug that prevented workers that took no inputs from working. Remove workaround in Array for said bug.
Mike Pavone <pavone@retrodev.com>
parents:
52
diff
changeset
|
1252 nextlist <- [paramlist]Append[tname] |
d0ce696786cc
Clean up debug print statements a bit. Fix bug that prevented workers that took no inputs from working. Remove workaround in Array for said bug.
Mike Pavone <pavone@retrodev.com>
parents:
52
diff
changeset
|
1253 next types <- [typelist]Append[paramtype] |
d0ce696786cc
Clean up debug print statements a bit. Fix bug that prevented workers that took no inputs from working. Remove workaround in Array for said bug.
Mike Pavone <pavone@retrodev.com>
parents:
52
diff
changeset
|
1254 } |
37
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1255 }{ |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1256 If[[~] = [[params]List Begin >>]] |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1257 { |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1258 type info,after type <- Parse List[after,params,()] |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1259 type <- [type info]Index[0] |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1260 { |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1261 If[[Type Of[~]] = ["Named Pipe Node"]] |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1262 { |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1263 before variant <- Type Instance[[type]Name >>] |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1264 }{ |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1265 before variant <- <- [type]Params <<[ Map[[type]Params >>, "Remove Named Pipe Node"] ] |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1266 } |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1267 variant <- [type info]Index[1] |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1268 { |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1269 ,warn <- If[[Type Of[~]] = ["Named Pipe Node"]] |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1270 { |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1271 before mutable,warn <- [before variant]Set Variant[[variant]Name >>] |
37
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1272 } |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1273 Val[warn] |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1274 { |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1275 Print[[[["Warning: Invalid variant for type "]Append[[before variant]Name >>]]Append[" on input "]]Append[param name]] |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1276 before mutable <- Val[before variant] |
37
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1277 } |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1278 }{ |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1279 before mutable <- Val[before variant] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1280 } |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1281 [type info]Index[2] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1282 { |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1283 paramtype <- [before mutable]Mutable? <<[ [[~]Name >>] = ["Mutable"] ] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1284 }{ |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1285 paramtype <- Val[before mutable] |
37
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1286 } |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1287 }{ |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1288 paramtype <- Type Instance["Any Type"] |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1289 } |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1290 [after type]Get DString[","] |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1291 { |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1292 out params,out types <- Parse Param List[~,nextlist,next types,params] |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1293 } {} {} { |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1294 out params <- Val[nextlist] |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1295 out types <- Val[next types] |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1296 } |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1297 }{ |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1298 paramtype <- Type Instance["Any Type"] |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1299 out params,out types <- Parse Param List[after,nextlist,next types,params] |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1300 } |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1301 |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1302 }{ |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1303 paramtype <- Type Instance["Any Type"] |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1304 out params <- Val[nextlist] |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1305 out types <- Val[next types] |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1306 } |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1307 } |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1308 |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1309 Worker Declaration[string,params:worker,rest,no match] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1310 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1311 ,whitespace name <- [string]Get Comment DString[[params]Arg Begin >>, params] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1312 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1313 worker name <- Trim[whitespace name, "\n\r\t "] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1314 in out <- [params]In Out Delim >> |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1315 arg end <- [params]Arg End >> |
48
a24eb366195c
Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1316 delims <- [[()]Append[in out]]Append[arg end] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1317 after <- [~]Get Comment DString[delims, params] {} |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1318 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1319 arglist <- Trim[~,"\r\n\t "] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1320 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1321 //check if there is an in/out separator |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1322 //if it isn't present, everything in the arglist is an input |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1323 If[[~] = [in out]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1324 { |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1325 rest <- [after]Get Comment DString[arg end, params] {} |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1326 { |
37
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1327 outputs,output types <- Parse Param List[~, (), (), params] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1328 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1329 }{ |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1330 rest <- Val[after] |
37
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1331 outputs <- () |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1332 output types <- () |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1333 } |
37
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1334 inputs,input types <- Parse Param List[arglist, (), (), params] |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1335 worker <- New@Parse Worker[worker name, inputs, outputs, input types, output types, 0] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1336 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1337 }{}{}{ |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1338 no match <- string |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1339 } |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1340 } |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1341 |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1342 Worker Name[string,params,tree,lines:out] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1343 { |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1344 ,after arglist <- Worker Declaration[string, params] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1345 { |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1346 worker name <- [~]Name >> |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1347 body text, modifiers <- [after arglist]Get Comment DString[[params]Block Begin >>, params] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1348 modified <- Process Modifiers[~, params, modifiers] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1349 expression trees, after body <- Worker Body[body text, params, ()] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1350 worker <- [modified]Trees <<[expression trees] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1351 new worker dict <- [[tree]Workers >>]Set[worker name, worker] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1352 out <- Null[after body, params, [tree]Workers <<[new worker dict], 0] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1353 } {} { |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1354 out <- tree |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1355 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1356 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1357 |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1358 Parse Foreign Worker[tree, string, lib, params:out] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1359 { |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1360 ,rest <- Worker Declaration[string, params] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1361 { |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1362 foreign <- [~]Trees << [lib] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1363 next <- [tree]Workers << [[[tree]Workers >>]Set[[foreign]Name >>, foreign]] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1364 out <- Parse Foreign Worker[next, rest, lib, params] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1365 } {} { |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1366 out <- tree |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1367 } |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1368 } |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1369 |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1370 Parse Foreign[string,params,tree,lines:out] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1371 { |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1372 ,after foreign <- [string]Slice[[[params]Foreign >>]Length] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1373 [after foreign]Get Comment DString[[params]Blueprint Type Delim >>, params] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1374 { |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1375 [~]Get Comment DString[[params]Block Begin >>, params] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1376 { |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1377 rest, body <- [~]Get Comment DString[[params]Block End >>, params] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1378 } |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1379 { lib <- Trim[~, "\r\n\t "] } |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1380 } |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1381 { language <- Trim[~, "\r\n\t "] } |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1382 Parse Foreign Worker[tree, body, New Foreign Lib[language, lib], params] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1383 { |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1384 out <- Null[rest, params, ~, 0] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1385 } |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1386 } |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1387 |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1388 Null[string,params,tree,lines:out] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1389 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1390 trimmed <- Comment Left Trim[string, " \n\r\t", params] |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1391 current line <- 0 |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1392 If[[trimmed]Starts With[ [params]Blueprint >> ]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1393 { |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1394 out <- PBlueprint[trimmed, params, tree, current line] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1395 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1396 If[[trimmed]Starts With[ [params]Import >> ]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1397 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1398 out <- Parse Import[trimmed, params, tree, current line] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1399 }{ |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1400 If[[trimmed]Starts With[ [params]Foreign >> ]] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1401 { |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1402 out <- Parse Foreign[trimmed, params, tree, current line] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1403 }{ |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1404 out <- Worker Name[trimmed, params, tree, current line] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1405 } |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1406 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1407 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1408 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1409 |
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1410 Check Worker Literals@Parse Worker[worker,program:out] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1411 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1412 If[[Type Of[[worker]Trees >>]] = ["List"]] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1413 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1414 out <- [worker]Trees <<[ Map[[worker]Trees >>, ["Check Worker Literals"]Set Input[1, program]] ] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1415 }{ |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1416 out <- worker |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1417 } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1418 } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1419 |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1420 Add Workers[workers,name,program:out] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1421 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1422 prog,worker <- [program]New Worker[name] |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1423 [worker]Set IO Counts[ [[[workers]Index[name]]Inputs >>]Length, [[[workers]Index[name]]Outputs >>]Length] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1424 [workers]Next[name] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1425 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1426 out <- Add Workers[workers, ~, prog] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1427 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1428 out <- Val[prog] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1429 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1430 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1431 |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1432 Register Workers Compile[prog, worker, name:out] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1433 { |
73
6a1a7d5cc2d9
Add some error checking, cleanup output and add a bad test file
Mike Pavone <pavone@retrodev.com>
parents:
69
diff
changeset
|
1434 Print[["Registering "]Append[name]] |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1435 If[[ Type Of[[worker]Trees >>] ] = ["Foreign Lib"]] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1436 { convention <- Val[[[worker]Trees >>]Language >>] } |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1437 { convention <- "rhope" } |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1438 out <- [prog]Register Worker[name, convention, [[worker]Inputs >>]Length, [[worker]Outputs >>]Length] |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1439 } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1440 |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1441 Add Workers Compile[prog, worker, name:out] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1442 { |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1443 If[[Type Of[[worker]Trees >>]] = ["Foreign Lib"]] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1444 { |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1445 //TODO: Handle foreign func |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1446 final nworker <- [[[[[NWorker[[[worker]Trees >>]Language >>] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1447 ]Inputs <<[ [worker]Inputs >> ] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1448 ]Input Types <<[ [worker]Input Types >> ] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1449 ]Outputs <<[ [worker]Outputs >> ] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1450 ]Output Types <<[ [worker]Output Types >> ] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1451 ]Library <<[ [[worker]Trees >>]Name >> ] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1452 |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1453 }{ |
73
6a1a7d5cc2d9
Add some error checking, cleanup output and add a bad test file
Mike Pavone <pavone@retrodev.com>
parents:
69
diff
changeset
|
1454 Print[["Transforming "]Append[name]] |
75
0083b2f7b3c7
Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents:
74
diff
changeset
|
1455 trees, nworker, refs <- Add List to Worker[[worker]Trees >>, [[NWorker["rhope"]]Uses[[worker]Uses Stores >>]]Outputs <<[ [worker]Outputs >> ], prog, worker, Dictionary[]] |
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1456 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1457 ,proceed <- If[[name] = ["Main"]] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1458 { Print["Added Trees to worker"] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1459 { proceed <- Pretty Print[trees, ""] }} |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1460 Val[proceed] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1461 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1462 final nworker <- Fold[[["Add Wires Helper"]Set Input[3, worker]]Set Input[4, refs], nworker, trees] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1463 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1464 If[[name] = ["Main"]] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1465 { Print["Added wires to worker"] } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1466 } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1467 } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1468 } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1469 |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1470 } |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1471 out <- [prog]Bind Worker[name, final nworker] |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1472 } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1473 |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1474 Add Wires Helper[worker,node,unused,parse worker,assignments:out] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1475 { |
48
a24eb366195c
Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1476 out <- [node]Add Wires[worker, (), parse worker, assignments] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1477 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1478 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1479 Add Contents[parse worker,name,program:out,key] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1480 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1481 worker <- [[program]Find Worker[name]]Uses[[parse worker]Uses Stores >>] |
48
a24eb366195c
Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1482 trees, contents worker, refs <- Add List to Worker[[parse worker]Trees >>, worker, program, parse worker, Dictionary[]] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1483 Fold[[["Add Wires Helper"]Set Input[3, parse worker]]Set Input[4, refs], contents worker, trees] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1484 out <- [parse worker]Trees <<[trees] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1485 key <- name |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1486 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1487 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1488 Add Blueprint Field[blueprint,field,unused:out] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1489 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1490 out <- [blueprint]Add Field[[field]Name >>, [field]Type >>] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1491 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1492 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1493 Add Blueprint[prog,def:out] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1494 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1495 out <- [prog]New Blueprint[[def]Name >>] {} |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1496 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1497 Fold["Add Blueprint Field", ~, [def]Fields >>] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1498 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1499 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1500 |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1501 Add Blueprint Compile[prog,def:out] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1502 { |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1503 out <- [prog]Bind Blueprint[[def]Name >>, Fold["Add Blueprint Field", NBlueprint[], [def]Fields >>]] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1504 } |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1505 |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1506 _Tree to Program[parse tree,program:out] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1507 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1508 after blueprint <- Fold["Add Blueprint", program, [parse tree]Blueprints >>] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1509 [[parse tree]Workers >>]First |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1510 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1511 prog <- Add Workers[[parse tree]Workers >>, ~, after blueprint] |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1512 }{ |
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1513 Print["No workers!"] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1514 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1515 Key Value Map[[parse tree]Workers >>, ["Add Contents"]Set Input[2, prog]] |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1516 out <- Val[prog] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1517 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1518 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1519 Tree to Program[parse tree:out] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1520 { |
48
a24eb366195c
Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1521 out <- _Tree to Program[parse tree, [Program[]]Add Builtins] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1522 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1523 |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1524 Tree to Program Native[parse tree:out] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1525 { |
48
a24eb366195c
Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1526 registered <- Fold["Register Workers Compile", [Fold["Add Blueprint Compile", NProgram[], [parse tree]Blueprints >>]]Register Builtins, [parse tree]Workers >>] |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1527 out <- Fold["Add Workers Compile", registered, [parse tree]Workers >>] |
42
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1528 { Print["Transformed AST to dataflow graph "] } |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1529 } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1530 |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1531 Needs Imports[needs import,not imported?,name:out] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1532 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1533 If[not imported?] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1534 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1535 out <- [needs import]Append[name] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1536 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1537 out <- needs import |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1538 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1539 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1540 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1541 Do Import[tree,file name,unused,params:out] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1542 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1543 file <- <String@File[file name] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1544 ,text <- [file]Get FString[[file]Length] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1545 after import <- Null[text, params, tree, 0] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1546 out <- [after import]Imports <<[ [[after import]Imports >>]Set[file name, No] ] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1547 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1548 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1549 Process Imports[parse tree,params:out] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1550 { |
48
a24eb366195c
Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1551 needs import <- Fold["Needs Imports", (), [parse tree]Imports >>] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1552 If[[[needs import]Length] > [0]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1553 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1554 import tree <- Fold[["Do Import"]Set Input[3, params], parse tree, needs import] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1555 out <- Process Imports[import tree, params] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1556 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1557 out <- parse tree |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1558 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1559 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1560 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1561 _Init Used Store[dict,store name:out] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1562 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1563 [dict]Index[store name] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1564 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1565 out <- dict |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1566 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1567 Init Store[store name] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1568 out <- [dict]Set[store name, Yes] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1569 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1570 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1571 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1572 _Init Used Stores[dict,worker:out] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1573 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1574 out <- Fold["_Init Used Store", dict, [worker]Uses Stores >>] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1575 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1576 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1577 Init Used Stores[parse tree,existing stores:out] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1578 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1579 out <- Fold["_Init Used Stores", existing stores, [parse tree]Workers >>] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1580 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1581 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1582 Until End[text:out] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1583 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1584 line <- Get Input[] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1585 If[[line] = ["End"]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1586 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1587 out <- [text]Append["\n"] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1588 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1589 out <- Until End[[[text]Append["\n"]]Append[line]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1590 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1591 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1592 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1593 _REPL[params,prog,stores] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1594 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1595 line <- Get Input[] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1596 If[[line] = ["Begin"]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1597 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1598 text <- Until End[""] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1599 Null[text, params, New@Parse Program[], 0] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1600 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1601 define tree <- Process Imports[~, params] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1602 Init Used Stores[define tree, stores] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1603 { _REPL[params, _Tree to Program[define tree, prog], ~] } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1604 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1605 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1606 If[[line]Starts With[[params]Import >>]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1607 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1608 Parse Import[[line]Append["\n"], params, New@Parse Program[], 0] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1609 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1610 import tree <- Process Imports[~, params] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1611 Init Used Stores[import tree, stores] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1612 { _REPL[params, _Tree to Program[import tree, prog], ~] } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1613 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1614 }{ |
48
a24eb366195c
Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1615 trees <- Worker Body[[line]Append["}"], params, ()] |
a24eb366195c
Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1616 tree <- [New@Worker Node["Val", [()]Append[[trees]Index[0]]]]Assignments <<[("__out")] |
a24eb366195c
Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1617 this stores <- [[tree]Gather Stores[params, Dictionary[]]]Keys |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1618 next stores <- Fold["_Init Used Store", stores, this stores] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1619 { |
48
a24eb366195c
Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1620 pworker <- [[New@Parse Worker["__Eval", (), ("__out"), 0]]Trees <<[[()]Append[tree]]]Uses Stores <<[this stores] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1621 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1622 [[prog]Find Worker["__Eval"]]Clear |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1623 { |
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1624 Add Contents[pworker, "__Eval", prog] |
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1625 { |
69
d0ce696786cc
Clean up debug print statements a bit. Fix bug that prevented workers that took no inputs from working. Remove workaround in Array for said bug.
Mike Pavone <pavone@retrodev.com>
parents:
52
diff
changeset
|
1626 _REPL[params, prog, next stores] } } |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1627 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1628 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1629 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1630 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1631 REPL[params] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1632 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1633 Print["Rhope Alpha 2\nCopyright 2008 by Michael Pavone\nEntering interactive mode\n"] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1634 prog <- Tree to Program[Null["Val[in:out]\n{\n out <- in\n}\n__Eval[:__out]\n{\n}\n", params, New@Parse Program[], 0]] |
48
a24eb366195c
Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1635 _REPL[params, prog, Dictionary[]] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1636 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1637 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1638 Add If Store[stores,name,params:out] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1639 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1640 If[[name]Contains[[params]Global Separator >>]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1641 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1642 parts <- [name]Split[[params]Global Separator >>] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1643 out <- [stores]Set[[parts]Index[0], Yes] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1644 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1645 out <- stores |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1646 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1647 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1648 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1649 Param Gather Stores[stores,node,params:out] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1650 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1651 out <- [node]Gather Stores[params, stores] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1652 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1653 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1654 Gather Stores@Named Pipe Node[node,params,stores:out] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1655 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1656 out <- Fold[["Add If Store"]Set Input[2, params], stores, [node]Assignments >>] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1657 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1658 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1659 Gather Stores@Global Node[node,params,stores:out] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1660 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1661 out <- [stores]Set[[node]Store >>, Yes] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1662 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1663 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1664 Gather Stores@Worker Node[node,params,stores:out] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1665 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1666 //TODO: Handle blocks |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1667 store list <- Fold[["Param Gather Stores"]Set Input[2, params], stores, [node]Params >>] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1668 out <- Fold[["Add If Store"]Set Input[2, params], store list, [node]Assignments >>] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1669 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1670 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1671 Gather Stores@Field Node[node,params,stores:out] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1672 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1673 //TODO: Handle blocks |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1674 store list <- Fold[["Param Gather Stores"]Set Input[2, params], stores, [node]Params >>] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1675 out <- Fold[["Add If Store"]Set Input[2, params], store list, [node]Assignments >>] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1676 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1677 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1678 Gather Stores@Literal Node[node,params,stores:out] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1679 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1680 out <- Fold[["Add If Store"]Set Input[2, params], stores, [node]Assignments >>] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1681 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1682 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1683 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1684 Main[args] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1685 { |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1686 fname <- [args]Index[1] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1687 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1688 file <- <String@File[~] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1689 ,text <- [file]Get FString[[file]Length] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1690 params <- New@Parser[] |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1691 Print[["Parsing "]Append[fname]] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1692 Null[text, params, New@Parse Program[], 0] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1693 { |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1694 Print["Parsing imports"] |
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1695 Process Imports[~, params] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1696 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1697 tree <- [~]Workers << [ Map[[~]Workers >>, ["Check Worker Literals"]Set Input[1, ~]] ] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1698 { Print["Compiling"] } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1699 } |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1700 compiled <- [Tree to Program Native[tree]]Compile Program[C Program[]] |
69
d0ce696786cc
Clean up debug print statements a bit. Fix bug that prevented workers that took no inputs from working. Remove workaround in Array for said bug.
Mike Pavone <pavone@retrodev.com>
parents:
52
diff
changeset
|
1701 { Print["Compiled program to backend"] } |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1702 outfile <- <String@File[ [fname]Append[".c"] ] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1703 [outfile]Put String[ [compiled]Text ] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1704 { Print[["Wrote output to "]Append[ [fname]Append[".c"] ]] } |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1705 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1706 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1707 REPL[New@Parser[]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1708 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1709 } |