Mercurial > repos > rhope
annotate parser_old.rhope @ 78:4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
author | Mike Pavone <pavone@retrodev.com> |
---|---|
date | Thu, 08 Jul 2010 21:55:47 -0400 |
parents | 0083b2f7b3c7 |
children | 2e2e55fc12f9 |
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 { |
78
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
316 Print["Add Multi Wire"] |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
317 { Print[[ref]Index >>] |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
318 { Print[[ref]Output Number >>] |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
319 { Pretty Print[worker, ""] }}} |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
320 out <- [worker]Add Wire[[ref]Index >>, [ref]Output Number >>, end index, input num] |
78
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
321 { Print["Added wire"] } |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
322 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
323 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
324 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
|
325 { |
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
326 Print[["Add Param Wire: "]Append[input num]] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
327 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
328 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
|
329 { |
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
330 Print[["got normal output for param: "]Append[input num]] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
331 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
332 Print[["Start index: "]Append[start index]] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
333 Print[["Output num: "]Append[output num]] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
334 |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
335 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
|
336 { Print["Added param 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 }{}{ |
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
339 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
|
340 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
|
341 { Print["Added multi wire"] } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
342 } |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
343 } |
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,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
|
347 { |
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
|
348 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
|
349 } |
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 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
|
352 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
353 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
|
354 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
|
355 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
356 |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
357 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
|
358 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
359 [[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
|
360 { |
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
|
361 ,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
|
362 { |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
363 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
|
364 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
365 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
366 //Ugly hack alert! |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
367 If[[assignment]Contains["::"]] |
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 parts <- [assignment]Split["::"] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
370 ,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
|
371 { |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
372 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
|
373 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
374 }{ |
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
|
375 out worker <- worker |
22
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 } |
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 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
380 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
|
381 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
382 out <- Yes |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
383 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
384 |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
385 _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
|
386 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
387 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
|
388 out <- [param]Has Block {} |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
389 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
390 [param list]Next[key] |
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 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
|
393 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
394 out <- No |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
395 } |
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 |
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 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
400 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
|
401 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
402 [param list]First |
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 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
|
405 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
406 out <- No |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
407 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
408 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
409 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
410 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
|
411 { |
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
412 Print[["Add Wires@Worker Node: "]Append[[node]Name >>]] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
413 { |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
414 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
|
415 } |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
416 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
417 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
418 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
|
419 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
420 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
|
421 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
422 Print["Assignments Add Wires done"] |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
423 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
|
424 { |
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
425 Print["Add Block Wire done"] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
426 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
|
427 { Print["Add Param Wire done"] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
428 index <- [node]Index >> |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
429 num <- 0 |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
430 } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
431 } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
432 } |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
433 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
|
434 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
435 worker <- Val[params worker] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
436 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
437 [blocks]Peek |
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 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
|
440 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
441 worker <- Val[params worker] |
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 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
444 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
445 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
446 Blueprint Field Node |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
447 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
448 Name |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
449 Params |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
450 Assignments |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
451 Blocks |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
452 Index |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
453 Set? |
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 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
|
457 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
458 has block <- Yes |
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 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
461 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
|
462 { |
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
|
463 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
|
464 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
465 |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
466 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
|
467 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
468 If[[node]Set? >>] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
469 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
470 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
|
471 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
472 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
|
473 } |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
474 Val[index] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
475 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
476 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
|
477 [node]Index <<[~] |
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 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
|
480 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
|
481 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
|
482 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
483 } |
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 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
486 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
|
487 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
488 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
|
489 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
490 |
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
491 Check Worker Literals@Field Node[node,program:out] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
492 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
493 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
|
494 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
|
495 ]Params <<[new params] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
496 } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
497 |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
498 Blueprint Named Pipe Node |
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 Name |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
501 Assignments |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
502 Blocks |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
503 Index |
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 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
506 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
|
507 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
508 If[[[node]Index >>] < [0]] |
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 //~ 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
|
511 If[[[node]Name >>] = ["~"]] |
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 no block <- No |
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 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
518 has block <- Yes |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
519 } |
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 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
522 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
|
523 { |
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
|
524 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
|
525 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
526 |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
527 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
|
528 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
529 [[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
|
530 { |
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
|
531 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
|
532 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
533 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
|
534 index node <- [node]Index <<[~] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
535 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
536 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
537 after add <- worker |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
538 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
|
539 //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
|
540 assign refs <- refs |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
541 } |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
542 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
|
543 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
|
544 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
545 |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
546 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
|
547 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
548 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
|
549 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
550 //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
|
551 worker <- worker |
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 If[[[node]Name >>] = ["~"]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
554 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
555 wires worker <- worker |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
556 [blocks]Peek |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
557 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
558 my index <- [~]Index >> |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
559 num <- [~]Output Number >> |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
560 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
561 //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
|
562 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
|
563 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
564 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
565 If[[[node]Index >>] < [0]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
566 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
567 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
|
568 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
569 my index <- [node]Index >> |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
570 num <- 0 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
571 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
|
572 [blocks]Peek |
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 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
|
575 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
576 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
|
577 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
578 } |
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 } |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
581 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
|
582 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
583 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
|
584 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
585 |
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
586 Check Worker Literals@Named Pipe Node[node,program:out] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
587 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
588 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
|
589 } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
590 |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
591 Blueprint Global Node |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
592 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
593 Store |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
594 Name |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
595 Assignments |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
596 Blocks |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
597 Index |
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 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
|
601 { |
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
|
602 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
|
603 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
604 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
605 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
|
606 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
607 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
|
608 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
609 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
|
610 out node <- [node]Index <<[~] |
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 refs <- refs |
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 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
|
616 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
617 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
|
618 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
619 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
620 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
|
621 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
622 out <- Yes |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
623 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
624 |
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
625 Check Worker Literals@Global Node[node,program:out] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
626 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
627 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
|
628 } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
629 |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
630 Blueprint Literal Node |
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 Value |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
633 Assignments |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
634 Blocks |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
635 Index |
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 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
|
639 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
640 out <- Yes |
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 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
643 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
|
644 { |
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
|
645 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
|
646 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
647 |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
648 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
|
649 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
650 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
|
651 { |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
652 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
|
653 out node <- [node]Index <<[~] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
654 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
655 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
656 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
657 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
|
658 { |
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
659 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
|
660 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
|
661 { Print["Got worker"] } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
662 { Print["got index"] } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
663 { Print["got num"] } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
664 } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
665 |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
666 Check Worker Literals@Literal Node[node,program:out] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
667 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
668 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
|
669 } |
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 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
|
672 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
673 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
|
674 [blocks]Peek |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
675 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
676 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
|
677 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
678 worker <- Val[assignments worker] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
679 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
680 index <- [node]Index >> |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
681 num <- 0 |
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 Block Node |
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 Number |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
687 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
688 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
689 Blueprint Parse Error |
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 Type |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
692 Text |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
693 Line 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 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
696 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
|
697 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
698 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
|
699 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
700 |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
701 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
|
702 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
703 If[[[string]Length] > [0]] |
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 out <- Yes |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
706 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
707 out <- No |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
708 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
709 } |
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 Blueprint Blueprint Field |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
712 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
713 Name |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
714 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 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
717 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
|
718 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
719 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
|
720 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
721 |
40
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
722 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
|
723 { |
40
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
724 ,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
|
725 { |
40
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
726 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
|
727 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
|
728 { |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
729 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
|
730 { |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
731 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
|
732 }{ |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
733 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
|
734 } |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
735 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
|
736 { |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
737 ,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
|
738 { |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
739 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
|
740 } |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
741 Val[warn] |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
742 { |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
743 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
|
744 fieldtype <- Val[before variant] |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
745 } |
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 fieldtype <- Val[before variant] |
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 }{ |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
750 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
|
751 } |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
752 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
|
753 } {} {} { |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
754 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
|
755 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
756 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
757 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
758 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
|
759 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
760 If[[block count] > [0]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
761 { |
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
|
762 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
|
763 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
764 If[[~] = [begin comment]] |
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 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
|
767 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
768 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
|
769 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
770 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
771 //No match |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
772 out <- "" |
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 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
775 out <- string |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
776 } |
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 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
779 Line Comment[string:out] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
780 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
781 [string]Get DString["\n"] |
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 out <- ["\n"]Append[~] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
784 } {} {} { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
785 out <- "" |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
786 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
787 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
788 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
789 _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
|
790 { |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
791 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
|
792 { |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
793 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
|
794 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
795 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
|
796 }{ |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
797 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
|
798 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
799 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
|
800 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
801 rest <- Val[after] |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
802 before <- [prev before]Append[befored] |
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
803 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
|
804 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
805 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
806 } {} {} { |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
807 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
|
808 } |
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 after comment |
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 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
|
813 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
|
814 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
815 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
816 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
817 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
818 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
|
819 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
820 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
|
821 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
|
822 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
|
823 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
|
824 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
|
825 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
826 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
827 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
|
828 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
829 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
|
830 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
831 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
|
832 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
|
833 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
|
834 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
835 ,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
|
836 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
|
837 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
838 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
|
839 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
|
840 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
841 ,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
|
842 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
|
843 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
844 out <- Val[trimmed] |
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 } |
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 |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
849 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
|
850 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
851 ,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
|
852 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
853 ,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
|
854 name <- Trim[no blueprint, "\r\n\t "] |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
855 name lines <- 0 |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
856 ,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
|
857 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
858 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
|
859 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
|
860 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
|
861 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
|
862 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
|
863 } {} { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
864 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
|
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 } {} { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
868 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
|
869 } |
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 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
872 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
|
873 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
874 [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
|
875 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
876 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
|
877 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
878 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
|
879 ,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
|
880 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
881 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
|
882 } {} { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
883 out <- Val[new tree] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
884 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
885 } |
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 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
|
888 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
889 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
|
890 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
|
891 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
892 ,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
|
893 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
|
894 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
|
895 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
896 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
|
897 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
898 blocks <- blocks |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
899 ,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
|
900 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
901 blocks <- blocks |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
902 after <- Val[check block] |
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 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
905 } |
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 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
|
908 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
909 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
|
910 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
|
911 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
912 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
|
913 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
|
914 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
915 after <- Val[rest] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
916 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
|
917 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
918 char <- Val[code] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
919 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
920 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
921 } |
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 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
|
924 { |
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
|
925 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
|
926 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
|
927 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
928 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
|
929 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
930 value <- [current]Append[before] |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
931 after <- Val[afters] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
932 }{ |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
933 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
|
934 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
|
935 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
936 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
937 } |
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 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
|
940 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
941 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
|
942 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
|
943 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
944 value <- list |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
945 ,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
|
946 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
947 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
|
948 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
949 ,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
|
950 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
951 el string <- Val[trimmed] |
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 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
|
954 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
|
955 } |
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@Literal 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]Value >> |
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 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
963 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
|
964 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
965 out <- node |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
966 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
967 |
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
|
968 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
|
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 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
|
971 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
|
972 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 |
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
|
975 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
|
976 { |
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
|
977 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
|
978 } |
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
|
979 |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
980 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
|
981 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
982 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
|
983 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
|
984 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
985 after <- [~]Append[after delim] |
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 after <- "" |
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 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
|
990 If[[first two] = ["0x"]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
991 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
992 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
|
993 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
994 If[[valstring]Contains["."]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
995 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
996 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
|
997 }{ |
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
|
998 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
|
999 { |
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
|
1000 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
|
1001 } {} {} { |
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
|
1002 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
|
1003 } |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1004 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1005 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1006 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1007 |
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
|
1008 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
|
1009 { |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1010 plist,after <- Parse List[string,params,()] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1011 out <- [literal]Params <<[plist] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1012 } |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1013 |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1014 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
|
1015 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1016 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
|
1017 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
|
1018 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1019 ,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
|
1020 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
|
1021 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1022 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
|
1023 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1024 ,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
|
1025 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
|
1026 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1027 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
|
1028 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1029 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
|
1030 }{ |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1031 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
|
1032 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
|
1033 |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1034 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
|
1035 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
|
1036 { |
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
|
1037 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
|
1038 }{ |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1039 Val[afterdelim] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1040 { |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1041 after <- [delim]Append[~] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1042 } |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1043 Val[nodelim] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1044 { |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1045 after <- "" |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1046 } |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1047 If[[before] = ["Yes"]] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1048 { |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1049 yesno <- Yes |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1050 }{ |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1051 If[[before] = ["No"]] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1052 { |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1053 yesno <- No |
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] = [""]] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1056 { |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1057 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
|
1058 { 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
|
1059 }{ |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1060 If[[before]Contains[[params]Global Separator >>]] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1061 { |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1062 parts <- [before]Split[[params]Global Separator >>] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1063 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
|
1064 }{ |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1065 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
|
1066 } |
22
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 } |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1070 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
|
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 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1074 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1075 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
|
1076 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1077 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1078 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
|
1079 { |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1080 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
|
1081 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
|
1082 { |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1083 [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
|
1084 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1085 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
|
1086 } |
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 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
|
1089 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1090 args <- arglist |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1091 ,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
|
1092 }{ |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1093 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
|
1094 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1095 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1096 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
|
1097 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
|
1098 } |
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 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
|
1101 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1102 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
|
1103 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
|
1104 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1105 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
|
1106 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
|
1107 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1108 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
|
1109 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
|
1110 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1111 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
|
1112 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
|
1113 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1114 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
|
1115 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1116 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1117 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1118 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1119 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
|
1120 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1121 //Parse argument list |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1122 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
|
1123 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
|
1124 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1125 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1126 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
|
1127 { |
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
|
1128 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
|
1129 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
|
1130 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
|
1131 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1132 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
|
1133 { |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1134 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
|
1135 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1136 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
|
1137 { |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1138 after <- Val[aftere] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1139 }{ |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1140 ,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
|
1141 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1142 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
|
1143 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1144 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1145 } |
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 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
|
1148 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1149 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
|
1150 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
|
1151 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1152 //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
|
1153 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
|
1154 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1155 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
|
1156 //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
|
1157 If[[maybe name] = [""]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1158 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1159 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
|
1160 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1161 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
|
1162 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1163 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
|
1164 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
|
1165 }{ |
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
|
1166 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
|
1167 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1168 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1169 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1170 If[[delim] = [[params]Assign >>]] |
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 //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
|
1173 //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
|
1174 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
|
1175 ,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
|
1176 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1177 final expression <- [~]Assignments <<[assignments] |
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 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1180 //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
|
1181 //{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1182 // 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
|
1183 // { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1184 // 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
|
1185 // }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1186 // 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
|
1187 // 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
|
1188 // } |
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 // 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
|
1191 // 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
|
1192 //} |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1193 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
|
1194 } |
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 //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
|
1197 //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
|
1198 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
|
1199 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
|
1200 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1201 } |
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 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
|
1204 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1205 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
|
1206 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
|
1207 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1208 //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
|
1209 ,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
|
1210 trees <- trees |
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 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
|
1213 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
|
1214 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1215 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1216 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1217 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
|
1218 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1219 //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
|
1220 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
|
1221 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
|
1222 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1223 ,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
|
1224 ,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
|
1225 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
|
1226 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1227 out <- worker |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1228 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1229 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1230 |
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
|
1231 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
|
1232 { |
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 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
|
1234 { |
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 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
|
1236 }{ |
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 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
|
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 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
|
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 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
|
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 } |
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 } |
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 |
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
|
1246 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
|
1247 { |
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
|
1248 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
|
1249 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
|
1250 { |
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
|
1251 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
|
1252 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
|
1253 { |
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 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
|
1255 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
|
1256 }{ |
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
|
1257 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
|
1258 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
|
1259 } |
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
|
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[[~] = [[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
|
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 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
|
1264 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
|
1265 { |
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 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
|
1267 { |
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 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
|
1269 }{ |
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 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
|
1271 } |
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 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
|
1273 { |
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 ,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
|
1275 { |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1276 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
|
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 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
|
1279 { |
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
|
1280 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
|
1281 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
|
1282 } |
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
|
1283 }{ |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1284 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
|
1285 } |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1286 [type info]Index[2] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1287 { |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1288 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
|
1289 }{ |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1290 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
|
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 }{ |
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 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
|
1294 } |
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 [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
|
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 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
|
1298 } {} {} { |
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 <- 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
|
1300 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
|
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,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
|
1305 } |
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 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
|
1309 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
|
1310 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
|
1311 } |
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
|
1312 } |
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
|
1313 |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1314 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
|
1315 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1316 ,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
|
1317 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1318 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
|
1319 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
|
1320 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
|
1321 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
|
1322 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
|
1323 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1324 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
|
1325 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1326 //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
|
1327 //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
|
1328 If[[~] = [in out]] |
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 <- [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
|
1331 { |
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
|
1332 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
|
1333 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1334 }{ |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1335 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
|
1336 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
|
1337 output types <- () |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1338 } |
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
|
1339 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
|
1340 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
|
1341 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1342 }{}{}{ |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1343 no match <- string |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1344 } |
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 |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1347 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
|
1348 { |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1349 ,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
|
1350 { |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1351 worker name <- [~]Name >> |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1352 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
|
1353 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
|
1354 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
|
1355 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
|
1356 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
|
1357 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
|
1358 } {} { |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1359 out <- tree |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1360 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1361 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1362 |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1363 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
|
1364 { |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1365 ,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
|
1366 { |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1367 foreign <- [~]Trees << [lib] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1368 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
|
1369 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
|
1370 } {} { |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1371 out <- tree |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1372 } |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1373 } |
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 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
|
1376 { |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1377 ,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
|
1378 [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
|
1379 { |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1380 [~]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
|
1381 { |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1382 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
|
1383 } |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1384 { 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
|
1385 } |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1386 { 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
|
1387 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
|
1388 { |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1389 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
|
1390 } |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1391 } |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1392 |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1393 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
|
1394 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1395 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
|
1396 current line <- 0 |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1397 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
|
1398 { |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1399 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
|
1400 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1401 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
|
1402 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1403 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
|
1404 }{ |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1405 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
|
1406 { |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1407 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
|
1408 }{ |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1409 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
|
1410 } |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1411 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1412 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1413 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1414 |
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1415 Check Worker Literals@Parse Worker[worker,program:out] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1416 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1417 If[[Type Of[[worker]Trees >>]] = ["List"]] |
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 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
|
1420 }{ |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1421 out <- worker |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1422 } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1423 } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1424 |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1425 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
|
1426 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1427 prog,worker <- [program]New Worker[name] |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1428 [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
|
1429 [workers]Next[name] |
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 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
|
1432 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1433 out <- Val[prog] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1434 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1435 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1436 |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1437 Register Workers Compile[prog, worker, name:out] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1438 { |
73
6a1a7d5cc2d9
Add some error checking, cleanup output and add a bad test file
Mike Pavone <pavone@retrodev.com>
parents:
69
diff
changeset
|
1439 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
|
1440 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
|
1441 { 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
|
1442 { convention <- "rhope" } |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1443 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
|
1444 } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1445 |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1446 Add Workers Compile[prog, worker, name:out] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1447 { |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1448 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
|
1449 { |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1450 //TODO: Handle foreign func |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1451 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
|
1452 ]Inputs <<[ [worker]Inputs >> ] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1453 ]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
|
1454 ]Outputs <<[ [worker]Outputs >> ] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1455 ]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
|
1456 ]Library <<[ [[worker]Trees >>]Name >> ] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1457 |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1458 }{ |
73
6a1a7d5cc2d9
Add some error checking, cleanup output and add a bad test file
Mike Pavone <pavone@retrodev.com>
parents:
69
diff
changeset
|
1459 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
|
1460 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
|
1461 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1462 ,proceed <- If[[name] = ["Main"]] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1463 { Print["Added Trees to worker"] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1464 { proceed <- Pretty Print[trees, ""] }} |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1465 Val[proceed] |
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 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
|
1468 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1469 If[[name] = ["Main"]] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1470 { Print["Added wires to worker"] } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1471 } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1472 } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1473 } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1474 |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1475 } |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1476 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
|
1477 } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1478 |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1479 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
|
1480 { |
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
|
1481 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
|
1482 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1483 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1484 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
|
1485 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1486 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
|
1487 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
|
1488 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
|
1489 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
|
1490 key <- name |
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 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
|
1494 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1495 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
|
1496 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1497 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1498 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
|
1499 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1500 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
|
1501 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1502 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
|
1503 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1504 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1505 |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1506 Add Blueprint Compile[prog,def:out] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1507 { |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1508 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
|
1509 } |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1510 |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1511 _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
|
1512 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1513 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
|
1514 [[parse tree]Workers >>]First |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1515 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1516 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
|
1517 }{ |
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1518 Print["No workers!"] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1519 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1520 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
|
1521 out <- Val[prog] |
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 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1524 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
|
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 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
|
1527 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1528 |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1529 Tree to Program Native[parse tree:out] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1530 { |
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
|
1531 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
|
1532 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
|
1533 { Print["Transformed AST to dataflow graph "] } |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1534 } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1535 |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1536 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
|
1537 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1538 If[not imported?] |
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 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
|
1541 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1542 out <- needs import |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1543 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1544 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1545 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1546 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
|
1547 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1548 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
|
1549 ,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
|
1550 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
|
1551 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
|
1552 } |
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 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
|
1555 { |
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
|
1556 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
|
1557 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
|
1558 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1559 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
|
1560 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
|
1561 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1562 out <- parse tree |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1563 } |
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 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1566 _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
|
1567 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1568 [dict]Index[store name] |
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 out <- dict |
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 Store[store name] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1573 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
|
1574 } |
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[dict,worker: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 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
|
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 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
|
1583 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1584 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
|
1585 } |
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 Until End[text:out] |
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 line <- Get Input[] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1590 If[[line] = ["End"]] |
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 out <- [text]Append["\n"] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1593 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1594 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
|
1595 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1596 } |
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 _REPL[params,prog,stores] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1599 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1600 line <- Get Input[] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1601 If[[line] = ["Begin"]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1602 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1603 text <- Until End[""] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1604 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
|
1605 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1606 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
|
1607 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
|
1608 { _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
|
1609 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1610 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1611 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
|
1612 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1613 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
|
1614 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1615 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
|
1616 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
|
1617 { _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
|
1618 } |
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 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
|
1621 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
|
1622 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
|
1623 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
|
1624 { |
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
|
1625 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
|
1626 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1627 [[prog]Find Worker["__Eval"]]Clear |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1628 { |
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1629 Add Contents[pworker, "__Eval", prog] |
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1630 { |
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
|
1631 _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
|
1632 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1633 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1634 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1635 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1636 REPL[params] |
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 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
|
1639 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
|
1640 _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
|
1641 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1642 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1643 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
|
1644 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1645 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
|
1646 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1647 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
|
1648 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
|
1649 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1650 out <- stores |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1651 } |
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 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
|
1655 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1656 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
|
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@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
|
1660 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1661 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
|
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@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
|
1665 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1666 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
|
1667 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1668 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1669 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
|
1670 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1671 //TODO: Handle blocks |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1672 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
|
1673 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
|
1674 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1675 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1676 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
|
1677 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1678 //TODO: Handle blocks |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1679 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
|
1680 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
|
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 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
|
1684 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1685 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
|
1686 } |
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 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1689 Main[args] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1690 { |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1691 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
|
1692 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1693 file <- <String@File[~] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1694 ,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
|
1695 params <- New@Parser[] |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1696 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
|
1697 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
|
1698 { |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1699 Print["Parsing imports"] |
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1700 Process Imports[~, params] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1701 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1702 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
|
1703 { Print["Compiling"] } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1704 } |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1705 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
|
1706 { Print["Compiled program to backend"] } |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1707 outfile <- <String@File[ [fname]Append[".c"] ] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1708 [outfile]Put String[ [compiled]Text ] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1709 { 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
|
1710 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1711 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1712 REPL[New@Parser[]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1713 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1714 } |