Mercurial > repos > rhope
annotate parser_old.rhope @ 54:243d013a49cb
Defer processing of string literals until after simpler ones to avoid a segfault
author | Mike Pavone <pavone@retrodev.com> |
---|---|
date | Thu, 29 Apr 2010 01:12:43 -0400 |
parents | 079200bc3e75 |
children | d0ce696786cc |
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[]] |
52
079200bc3e75
String literals almost working. Print moved out of C runtime.
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
130 ]Imports <<[[[Dictionary[]]Set["kernel.rhope", Yes]]Set["string.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 { |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
218 Print["Add Blocks to Worker"] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
219 { |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
220 [blocks]First |
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, 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
|
223 }{ |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
224 out blocks <- blocks |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
225 out worker <- worker |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
226 out refs <- refs |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
227 } |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
228 } |
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 |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
231 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
|
232 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
233 [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
|
234 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
235 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
|
236 { |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
237 //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
|
238 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
|
239 [node]Index <<[~] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
240 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
241 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
|
242 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
|
243 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
|
244 } |
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 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
|
248 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
249 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
250 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
251 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
|
252 { |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
253 Print[ |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
254 [[[[[[["Wire: " |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
255 ]Append[ [ref]Index >> ] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
256 ]Append[","] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
257 ]Append[ [ref]Output Number >>] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
258 ]Append[" to "] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
259 ]Append[end index] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
260 ]Append[","] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
261 ]Append[input num] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
262 ] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
263 out <- [worker]Add Wire[[ref]Index >>, [ref]Output Number >>, end index, input num] |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
264 { Print["Wire added"] } |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
265 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
266 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
267 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
|
268 { |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
269 Print[[[["param type: " |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
270 ]Append[Type Of[param]] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
271 ]Append[", dest index:"] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
272 ]Append[end index]] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
273 { |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
274 param worker, start index, output num <- [param]Add Wires[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
|
275 { |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
276 Print[ |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
277 [[[[[[["Wire: " |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
278 ]Append[start index ] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
279 ]Append[","] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
280 ]Append[output num] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
281 ]Append[" to "] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
282 ]Append[end index] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
283 ]Append[","] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
284 ]Append[input num] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
285 ] { |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
286 out <- [param worker]Add Wire[start index, output num, end index, input num] |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
287 { Print["wire done, Add Param Wire"] } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
288 } |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
289 }{}{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
290 out <- Fold[[["Add Multi Wire"]Set Input[3, end index]]Set Input[4, input num], param worker, ~] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
291 } |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
292 } |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
293 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
294 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
295 _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
|
296 { |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
297 Print[["_Add Block Wire "]Append[Type Of[node]]] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
298 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
299 out <- [node]Add Wires[worker, blocks, parse worker, assignments] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
300 { Print[["_Add Block Wire done "]Append[Type Of[node]]] } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
301 } |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
302 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
303 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
304 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
|
305 { |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
306 Print["Add Block Wire"] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
307 { |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
308 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
|
309 out <- Fold[[[["_Add Block Wire"]Set Input[3, blocks]]Set Input[4, parse worker]]Set Input[5, assignments], worker, block nodes] |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
310 { Print["done: Add Block Wire"] } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
311 } |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
312 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
313 |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
314 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
|
315 { |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
316 Print[["Assignments Add Wires: "]Append[assignment]] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
317 { |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
318 [[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
|
319 { |
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
|
320 ,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
|
321 { |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
322 Print[ |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
323 [[[[[[["Wire: " |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
324 ]Append[ start index ] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
325 ]Append[","] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
326 ]Append[ output num] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
327 ]Append[" to "] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
328 ]Append[output index] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
329 ]Append[","] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
330 ]Append[ 0 ] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
331 ] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
332 out worker <- [~]Add Wire[start index, output num, output index, 0] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
333 { Print["wire done, Assignments Add Wires 1"] } |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
334 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
335 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
336 //Ugly hack alert! |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
337 If[[assignment]Contains["::"]] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
338 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
339 parts <- [assignment]Split["::"] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
340 ,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
|
341 { |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
342 out worker <- [~]Add Wire[start index, output num, global index, 0] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
343 { Print["wire done, Assignments Add Wires 2"] } |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
344 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
345 }{ |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
346 Print["Pipe assignment, do nothing"] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
347 { out worker <- worker } |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
348 } |
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 } |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
351 } |
22
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 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
|
354 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
355 out <- Yes |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
356 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
357 |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
358 _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
|
359 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
360 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
|
361 out <- [param]Has Block {} |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
362 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
363 [param list]Next[key] |
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 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
|
366 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
367 out <- No |
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 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
370 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
371 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
372 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
373 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
|
374 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
375 [param list]First |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
376 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
377 out <- _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
|
378 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
379 out <- No |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
380 } |
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 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
383 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
|
384 { |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
385 Print["Add Wires@Worker Node"] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
386 { |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
387 worker,index,num <- Add Wires Worker or Field[node, worker, blocks, parse worker, assignments] |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
388 } |
22
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 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
391 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
|
392 { |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
393 Print["Add Wires Worker or Field"] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
394 { |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
395 Fold[[["Assignments Add Wires"]Set Input[3, parse worker]]Set Input[4, [node]Index >>], worker, [node]Assignments >>] |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
396 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
397 Print["Assignments Add Wires done"] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
398 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
|
399 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
400 Print["Add Block Wire fold done"] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
401 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 >>] }} |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
402 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
|
403 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
404 worker <- Val[params worker] |
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 [blocks]Peek |
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 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
|
409 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
410 worker <- Val[params worker] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
411 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
412 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
413 index <- [node]Index >> |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
414 num <- 0 |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
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 Blueprint Field Node |
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 Name |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
421 Params |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
422 Assignments |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
423 Blocks |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
424 Index |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
425 Set? |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
426 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
427 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
428 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
|
429 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
430 has block <- Yes |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
431 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
432 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
433 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
|
434 { |
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
|
435 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
|
436 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
437 |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
438 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
|
439 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
440 If[[node]Set? >>] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
441 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
442 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
|
443 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
444 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
|
445 } |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
446 Val[index] |
22
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 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
|
449 [node]Index <<[~] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
450 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
451 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
|
452 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
|
453 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
|
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 } |
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 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
|
459 { |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
460 Print["Add Wires@Field Node"] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
461 { |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
462 worker,index,num <- Add Wires Worker or Field[node, worker, blocks, parse worker, assignments] |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
463 } |
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 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
466 Blueprint Named Pipe Node |
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 Name |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
469 Assignments |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
470 Blocks |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
471 Index |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
472 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
473 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
474 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
|
475 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
476 If[[[node]Index >>] < [0]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
477 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
478 //~ 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
|
479 If[[[node]Name >>] = ["~"]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
480 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
481 has block <- Yes |
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 no block <- No |
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 has block <- Yes |
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 } |
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 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
|
491 { |
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
|
492 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
|
493 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
494 |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
495 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
|
496 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
497 [[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
|
498 { |
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
|
499 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
|
500 { |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
501 Print[["Added input, node:"]Append[~]] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
502 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
|
503 index node <- [node]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 after add <- worker |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
507 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
|
508 //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
|
509 assign refs <- refs |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
510 } |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
511 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
|
512 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
|
513 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
514 |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
515 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
|
516 { |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
517 Print["Add Wires@Named Pipe Node"] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
518 { |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
519 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
|
520 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
521 //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
|
522 worker <- worker |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
523 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
524 If[[[node]Name >>] = ["~"]] |
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 wires worker <- worker |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
527 [blocks]Peek |
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 my index <- [~]Index >> |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
530 num <- [~]Output Number >> |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
531 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
532 //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
|
533 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
|
534 } |
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 If[[[node]Index >>] < [0]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
537 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
538 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
|
539 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
540 my index <- [node]Index >> |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
541 num <- 0 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
542 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
|
543 [blocks]Peek |
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 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
|
546 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
547 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
|
548 } |
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 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
551 } |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
552 } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
553 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
|
554 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
555 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
|
556 } |
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 Blueprint Global Node |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
559 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
560 Store |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
561 Name |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
562 Assignments |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
563 Blocks |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
564 Index |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
565 } |
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 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
|
568 { |
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
|
569 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
|
570 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
571 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
572 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
|
573 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
574 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
|
575 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
576 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
|
577 out node <- [node]Index <<[~] |
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 refs <- refs |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
580 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
581 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
582 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
|
583 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
584 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
|
585 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
586 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
587 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
|
588 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
589 out <- Yes |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
590 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
591 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
592 Blueprint Literal Node |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
593 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
594 Value |
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 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
|
601 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
602 out <- Yes |
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 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
|
606 { |
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
|
607 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
|
608 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
609 |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
610 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
|
611 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
612 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
|
613 { |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
614 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
|
615 out node <- [node]Index <<[~] |
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 } |
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 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
|
620 { |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
621 Print["Add Wires@Literal Node"] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
622 { |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
623 worker,index,num <- Add Wires Literal or Global[node, worker, blocks, parse worker, assignments] |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
624 } |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
625 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
626 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
627 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
|
628 { |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
629 Print["Add Wires Literal or Global"] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
630 { |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
631 assignments worker <- Fold[[["Assignments Add Wires"]Set Input[3, parse worker]]Set Input[4, [node]Index >>], worker, [node]Assignments >>] |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
632 { Print["Done fold Assignments Add Wires"] } |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
633 [blocks]Peek |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
634 { |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
635 Print["Add wire"] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
636 worker <- [assignments worker]Add Wire[[~]Index >>, [~]Output Number>>, [node]Index >>, [0]-[1]] |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
637 { Print["Add wire done"] } |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
638 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
639 worker <- Val[assignments worker] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
640 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
641 index <- [node]Index >> |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
642 num <- 0 |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
643 } |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
644 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
645 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
646 Blueprint Block Node |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
647 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
648 Number |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
649 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
650 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
651 Blueprint Parse Error |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
652 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
653 Type |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
654 Text |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
655 Line Number |
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 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
658 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
|
659 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
660 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
|
661 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
662 |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
663 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
|
664 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
665 If[[[string]Length] > [0]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
666 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
667 out <- Yes |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
668 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
669 out <- No |
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 } |
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 Blueprint Blueprint Field |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
674 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
675 Name |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
676 Type |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
677 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
678 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
679 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
|
680 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
681 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
|
682 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
683 |
40
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
684 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
|
685 { |
40
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
686 ,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
|
687 { |
40
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
688 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
|
689 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
|
690 { |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
691 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
|
692 { |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
693 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
|
694 }{ |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
695 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
|
696 } |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
697 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
|
698 { |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
699 ,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
|
700 { |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
701 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
|
702 } |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
703 Val[warn] |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
704 { |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
705 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
|
706 fieldtype <- Val[before variant] |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
707 } |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
708 }{ |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
709 fieldtype <- Val[before variant] |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
710 } |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
711 }{ |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
712 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
|
713 } |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
714 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
|
715 } {} {} { |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
716 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
|
717 } |
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 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
720 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
|
721 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
722 If[[block count] > [0]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
723 { |
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
|
724 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
|
725 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
726 If[[~] = [begin comment]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
727 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
728 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
|
729 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
730 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
|
731 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
732 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
733 //No match |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
734 out <- "" |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
735 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
736 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
737 out <- string |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
738 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
739 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
740 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
741 Line Comment[string:out] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
742 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
743 [string]Get DString["\n"] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
744 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
745 out <- ["\n"]Append[~] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
746 } {} {} { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
747 out <- "" |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
748 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
749 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
750 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
751 _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
|
752 { |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
753 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
|
754 { |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
755 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
|
756 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
757 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
|
758 }{ |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
759 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
|
760 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
761 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
|
762 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
763 rest <- Val[after] |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
764 before <- [prev before]Append[befored] |
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
765 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
|
766 } |
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 } {} {} { |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
769 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
|
770 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
771 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
772 after comment |
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 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
|
775 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
|
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 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
780 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
|
781 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
782 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
|
783 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
|
784 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
|
785 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
|
786 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
|
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 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
|
790 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
791 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
|
792 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
793 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
|
794 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
|
795 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
|
796 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
797 ,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
|
798 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
|
799 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
800 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
|
801 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
|
802 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
803 ,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
|
804 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
|
805 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
806 out <- Val[trimmed] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
807 } |
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 |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
811 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
|
812 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
813 ,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
|
814 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
815 ,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
|
816 name <- Trim[no blueprint, "\r\n\t "] |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
817 name lines <- 0 |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
818 ,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
|
819 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
820 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
|
821 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
|
822 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
|
823 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
|
824 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
|
825 } {} { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
826 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
|
827 } |
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 } {} { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
830 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
|
831 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
832 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
833 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
834 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
|
835 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
836 [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
|
837 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
838 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
|
839 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
840 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
|
841 ,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
|
842 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
843 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
|
844 } {} { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
845 out <- Val[new tree] |
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 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
849 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
|
850 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
851 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
|
852 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
|
853 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
854 ,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
|
855 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
|
856 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
|
857 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
858 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
|
859 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
860 blocks <- blocks |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
861 ,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
|
862 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
863 blocks <- blocks |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
864 after <- Val[check block] |
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 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
869 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
|
870 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
871 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
|
872 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
|
873 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
874 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
|
875 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
|
876 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
877 after <- Val[rest] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
878 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
|
879 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
880 char <- Val[code] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
881 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
882 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
883 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
884 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
885 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
|
886 { |
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
|
887 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
|
888 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
|
889 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
890 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
|
891 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
892 value <- [current]Append[before] |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
893 after <- Val[afters] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
894 }{ |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
895 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
|
896 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
|
897 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
898 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
899 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
900 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
901 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
|
902 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
903 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
|
904 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
|
905 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
906 value <- list |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
907 ,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
|
908 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
909 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
|
910 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
911 ,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
|
912 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
913 el string <- Val[trimmed] |
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 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
|
916 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
|
917 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
918 } |
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 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
|
921 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
922 out <- [node]Value >> |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
923 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
924 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
925 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
|
926 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
927 out <- node |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
928 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
929 |
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
|
930 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
|
931 { |
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
|
932 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
|
933 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
|
934 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
|
935 } |
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
|
936 |
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
|
937 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
|
938 { |
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
|
939 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
|
940 } |
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
|
941 |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
942 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
|
943 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
944 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
|
945 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
|
946 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
947 after <- [~]Append[after 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 after <- "" |
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 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
|
952 If[[first two] = ["0x"]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
953 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
954 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
|
955 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
956 If[[valstring]Contains["."]] |
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 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
|
959 }{ |
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
|
960 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
|
961 { |
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
|
962 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
|
963 } {} {} { |
689fb73e7612
Add support for various integer literals and add support for raw pointers to objects and raw pointers to arrays in the FFI
Mike Pavone <pavone@retrodev.com>
parents:
49
diff
changeset
|
964 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
|
965 } |
22
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 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
968 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
969 |
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
|
970 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
|
971 { |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
972 plist,after <- Parse List[string,params,()] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
973 out <- [literal]Params <<[plist] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
974 } |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
975 |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
976 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
|
977 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
978 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
|
979 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
|
980 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
981 ,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
|
982 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
|
983 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
984 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
|
985 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
986 ,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
|
987 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
|
988 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
989 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
|
990 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
991 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
|
992 }{ |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
993 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
|
994 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
|
995 |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
996 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
|
997 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
|
998 { |
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
|
999 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
|
1000 }{ |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1001 Val[afterdelim] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1002 { |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1003 after <- [delim]Append[~] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1004 } |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1005 Val[nodelim] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1006 { |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1007 after <- "" |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1008 } |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1009 If[[before] = ["Yes"]] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1010 { |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1011 yesno <- Yes |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1012 }{ |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1013 If[[before] = ["No"]] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1014 { |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1015 yesno <- No |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1016 }{ |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1017 If[[before] = [""]] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1018 { |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1019 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
|
1020 { 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
|
1021 }{ |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1022 If[[before]Contains[[params]Global Separator >>]] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1023 { |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1024 parts <- [before]Split[[params]Global Separator >>] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1025 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
|
1026 }{ |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1027 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
|
1028 } |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1029 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1030 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1031 } |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1032 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
|
1033 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1034 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1035 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1036 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1037 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
|
1038 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1039 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1040 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
|
1041 { |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1042 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
|
1043 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
|
1044 { |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1045 [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
|
1046 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1047 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
|
1048 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1049 }{ |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1050 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
|
1051 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1052 args <- arglist |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1053 ,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
|
1054 }{ |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1055 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
|
1056 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1057 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1058 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
|
1059 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
|
1060 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1061 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1062 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
|
1063 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1064 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
|
1065 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
|
1066 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1067 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
|
1068 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
|
1069 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1070 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
|
1071 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
|
1072 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1073 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
|
1074 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
|
1075 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1076 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
|
1077 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1078 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1079 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1080 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1081 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
|
1082 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1083 //Parse argument list |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1084 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
|
1085 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
|
1086 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1087 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1088 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
|
1089 { |
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
|
1090 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
|
1091 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
|
1092 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
|
1093 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1094 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
|
1095 { |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1096 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
|
1097 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1098 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
|
1099 { |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1100 after <- Val[aftere] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1101 }{ |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1102 ,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
|
1103 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1104 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
|
1105 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1106 } |
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 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1109 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
|
1110 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1111 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
|
1112 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
|
1113 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1114 //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
|
1115 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
|
1116 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1117 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
|
1118 //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
|
1119 If[[maybe name] = [""]] |
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 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
|
1122 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1123 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
|
1124 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1125 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
|
1126 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
|
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 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
|
1129 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1130 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1131 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1132 If[[delim] = [[params]Assign >>]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1133 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1134 //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
|
1135 //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
|
1136 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
|
1137 ,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
|
1138 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1139 final expression <- [~]Assignments <<[assignments] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1140 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1141 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1142 //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
|
1143 //{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1144 // 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
|
1145 // { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1146 // 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
|
1147 // }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1148 // 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
|
1149 // 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
|
1150 // } |
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 // 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
|
1153 // 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
|
1154 //} |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1155 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
|
1156 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1157 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1158 //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
|
1159 //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
|
1160 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
|
1161 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
|
1162 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1163 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1164 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1165 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
|
1166 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1167 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
|
1168 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
|
1169 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1170 //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
|
1171 ,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
|
1172 trees <- trees |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1173 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1174 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
|
1175 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
|
1176 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1177 } |
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 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
|
1180 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1181 //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
|
1182 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
|
1183 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
|
1184 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1185 ,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
|
1186 ,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
|
1187 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
|
1188 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1189 out <- worker |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1190 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1191 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1192 |
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
|
1193 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
|
1194 { |
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
|
1195 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
|
1196 { |
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
|
1197 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
|
1198 }{ |
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
|
1199 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
|
1200 { |
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
|
1201 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
|
1202 }{ |
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
|
1203 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
|
1204 } |
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
|
1205 } |
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
|
1206 } |
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
|
1207 |
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
|
1208 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
|
1209 { |
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
|
1210 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
|
1211 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
|
1212 { |
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
|
1213 nextlist <- [paramlist]Append[Trim[~, "\r\n\t "]] |
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
|
1214 next types <- [typelist]Append[paramtype] |
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
|
1215 }{ |
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
|
1216 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
|
1217 { |
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
|
1218 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
|
1219 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
|
1220 { |
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
|
1221 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
|
1222 { |
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
|
1223 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
|
1224 }{ |
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
|
1225 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
|
1226 } |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1227 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
|
1228 { |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1229 ,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
|
1230 { |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1231 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
|
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 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
|
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 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
|
1236 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
|
1237 } |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1238 }{ |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1239 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
|
1240 } |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1241 [type info]Index[2] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1242 { |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1243 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
|
1244 }{ |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1245 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
|
1246 } |
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 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
|
1249 } |
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 [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
|
1251 { |
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
|
1252 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
|
1253 } {} {} { |
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
|
1254 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
|
1255 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
|
1256 } |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1257 }{ |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1258 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
|
1259 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
|
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 |
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 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
|
1264 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
|
1265 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
|
1266 } |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1267 } |
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 |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1269 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
|
1270 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1271 ,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
|
1272 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1273 worker name <- Trim[whitespace name, "\n\r\t "] |
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
|
1274 Print[["Parsing worker: "]Append[worker name]] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1275 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
|
1276 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
|
1277 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
|
1278 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
|
1279 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1280 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
|
1281 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1282 //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
|
1283 //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
|
1284 If[[~] = [in out]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1285 { |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1286 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
|
1287 { |
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
|
1288 outputs,output types <- Parse Param List[~, (), (), 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
|
1289 { Print["got 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
|
1290 { Print["got output types"] } |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1291 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1292 }{ |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1293 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
|
1294 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
|
1295 output types <- () |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1296 } |
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
|
1297 inputs,input types <- Parse Param List[arglist, (), (), 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 { Print["got inputs"] } |
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 { Print["got input types"] } |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1300 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
|
1301 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1302 }{}{}{ |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1303 no match <- string |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1304 } |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1305 } |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1306 |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1307 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
|
1308 { |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1309 ,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
|
1310 { |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1311 Print["Got parse worker"] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1312 worker name <- [~]Name >> |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1313 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
|
1314 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
|
1315 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
|
1316 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
|
1317 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
|
1318 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
|
1319 } {} { |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1320 out <- tree |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1321 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1322 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1323 |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1324 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
|
1325 { |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1326 ,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
|
1327 { |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1328 foreign <- [~]Trees << [lib] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1329 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
|
1330 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
|
1331 } {} { |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1332 out <- tree |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1333 } |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1334 } |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1335 |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1336 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
|
1337 { |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1338 Print["Foreign block"] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1339 ,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
|
1340 Print[[after foreign]Slice[20]] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1341 [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
|
1342 { |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1343 [~]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
|
1344 { |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1345 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
|
1346 } |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1347 { 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
|
1348 } |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1349 { 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
|
1350 Print[[[["Language: "]Append[language]]Append[" Library: "]]Append[lib]] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1351 { |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1352 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
|
1353 { |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1354 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
|
1355 } |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1356 } |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1357 } |
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 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
|
1360 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1361 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
|
1362 current line <- 0 |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1363 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
|
1364 { |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1365 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
|
1366 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1367 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
|
1368 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1369 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
|
1370 }{ |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1371 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
|
1372 { |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1373 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
|
1374 }{ |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1375 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
|
1376 } |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1377 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1378 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1379 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1380 |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1381 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
|
1382 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1383 prog,worker <- [program]New Worker[name] |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1384 [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
|
1385 [workers]Next[name] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1386 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1387 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
|
1388 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1389 out <- Val[prog] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1390 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1391 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1392 |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1393 Register Workers Compile[prog, worker, name:out] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1394 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1395 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
|
1396 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
|
1397 { 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
|
1398 { convention <- "rhope" } |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1399 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
|
1400 } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1401 |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1402 Add Workers Compile[prog, worker, name:out] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1403 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1404 Print[["Add Workers Compile: "]Append[name]] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1405 { |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1406 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
|
1407 { |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1408 //TODO: Handle foreign func |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1409 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
|
1410 ]Inputs <<[ [worker]Inputs >> ] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1411 ]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
|
1412 ]Outputs <<[ [worker]Outputs >> ] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1413 ]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
|
1414 ]Library <<[ [[worker]Trees >>]Name >> ] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1415 |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1416 }{ |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1417 trees, nworker, refs <- Add List to Worker[[worker]Trees >>, [NWorker["rhope"]]Uses[[worker]Uses Stores >>], prog, worker, Dictionary[]] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1418 final nworker <- Fold[[["Add Wires Helper"]Set Input[3, worker]]Set Input[4, refs], nworker, trees] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1419 } |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1420 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
|
1421 } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1422 } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1423 |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1424 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
|
1425 { |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1426 Print["Add Wires Helper"] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1427 { |
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
|
1428 out <- [node]Add Wires[worker, (), parse worker, assignments] |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1429 { Print["Add Wires Helper Done"] } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1430 } |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1431 } |
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 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
|
1434 { |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1435 Print[["Add Contents: "]Append[name]] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1436 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
|
1437 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
|
1438 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
|
1439 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
|
1440 key <- name |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1441 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1442 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1443 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
|
1444 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1445 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
|
1446 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1447 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1448 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
|
1449 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1450 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
|
1451 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1452 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
|
1453 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1454 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1455 |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1456 Add Blueprint Compile[prog,def:out] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1457 { |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1458 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
|
1459 } |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1460 |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1461 _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
|
1462 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1463 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
|
1464 [[parse tree]Workers >>]First |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1465 { |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1466 Print["Adding workers"] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1467 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
|
1468 { Print["Add Workers done"] } |
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1469 }{ |
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1470 Print["No workers!"] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1471 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1472 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
|
1473 { Print["Done Add Contents"] } |
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1474 out <- Val[prog] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1475 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1476 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1477 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
|
1478 { |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1479 Print["Tree to 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
|
1480 out <- _Tree to Program[parse tree, [Program[]]Add Builtins] |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1481 { Print["done"] } |
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 |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1484 Tree to Program Native[parse tree:out] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1485 { |
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
|
1486 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
|
1487 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
|
1488 { Print["Transformed AST to dataflow graph "] } |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1489 } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1490 |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1491 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
|
1492 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1493 If[not imported?] |
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 <- [needs import]Append[name] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1496 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1497 out <- needs import |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1498 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1499 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1500 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1501 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
|
1502 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1503 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
|
1504 ,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
|
1505 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
|
1506 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
|
1507 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1508 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1509 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
|
1510 { |
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
|
1511 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
|
1512 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
|
1513 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1514 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
|
1515 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
|
1516 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1517 out <- parse tree |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1518 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1519 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1520 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1521 _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
|
1522 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1523 [dict]Index[store name] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1524 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1525 out <- dict |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1526 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1527 Init Store[store name] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1528 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
|
1529 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1530 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1531 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1532 _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
|
1533 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1534 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
|
1535 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1536 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1537 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
|
1538 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1539 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
|
1540 } |
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 Until End[text:out] |
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 line <- Get Input[] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1545 If[[line] = ["End"]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1546 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1547 out <- [text]Append["\n"] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1548 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1549 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
|
1550 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1551 } |
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 _REPL[params,prog,stores] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1554 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1555 line <- Get Input[] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1556 If[[line] = ["Begin"]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1557 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1558 text <- Until End[""] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1559 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
|
1560 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1561 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
|
1562 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
|
1563 { _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
|
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 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
|
1567 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1568 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
|
1569 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1570 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
|
1571 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
|
1572 { _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
|
1573 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1574 }{ |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1575 Print["Expression"] |
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
|
1576 trees <- Worker Body[[line]Append["}"], params, ()] |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1577 { Print["Parse done"] } |
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
|
1578 tree <- [New@Worker Node["Val", [()]Append[[trees]Index[0]]]]Assignments <<[("__out")] |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1579 { Print["Constructed new tree"] } |
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
|
1580 this stores <- [[tree]Gather Stores[params, Dictionary[]]]Keys |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1581 { Print["Got stores"] } |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1582 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
|
1583 { |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1584 Print["Initialized 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
|
1585 pworker <- [[New@Parse Worker["__Eval", (), ("__out"), 0]]Trees <<[[()]Append[tree]]]Uses Stores <<[this stores] |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1586 { Print["Constructed parse worker"] } |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1587 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1588 [[prog]Find Worker["__Eval"]]Clear |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1589 { |
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1590 Print["Cleared worker"] |
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1591 Add Contents[pworker, "__Eval", prog] |
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1592 { |
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1593 Print["Added Contents"] |
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
|
1594 Pretty Print[[[[prog]Find Worker["__Eval"]]Do[()]]Index[0], ""] |
24
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1595 { |
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1596 Print["Finished executeion"] |
8b2b3f4a2a58
Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents:
22
diff
changeset
|
1597 _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
|
1598 } |
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 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1601 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1602 REPL[params] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1603 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1604 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
|
1605 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
|
1606 _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
|
1607 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1608 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1609 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
|
1610 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1611 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
|
1612 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1613 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
|
1614 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
|
1615 }{ |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1616 out <- stores |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1617 } |
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 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1620 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
|
1621 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1622 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
|
1623 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1624 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1625 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
|
1626 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1627 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
|
1628 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1629 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1630 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
|
1631 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1632 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
|
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 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
|
1636 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1637 //TODO: Handle blocks |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1638 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
|
1639 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
|
1640 } |
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 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
|
1643 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1644 //TODO: Handle blocks |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1645 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
|
1646 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
|
1647 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1648 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1649 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
|
1650 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1651 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
|
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 |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1655 Main[args] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1656 { |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1657 Print["start"] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1658 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
|
1659 { |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1660 file <- <String@File[~] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1661 ,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
|
1662 params <- New@Parser[] |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1663 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
|
1664 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
|
1665 { |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1666 Print["Parsing imports"] |
22
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1667 tree <- Process Imports[~, params] |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1668 { Print["Compiling"] } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1669 compiled <- [Tree to Program Native[tree]]Compile Program[C Program[]] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1670 outfile <- <String@File[ [fname]Append[".c"] ] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1671 [outfile]Put String[ [compiled]Text ] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
24
diff
changeset
|
1672 { 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
|
1673 } |
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 REPL[New@Parser[]] |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1676 } |
812673a8b1ea
Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1677 } |