Mercurial > repos > rhope

annotate parser_old.rhope @ 22:812673a8b1ea

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Converted old parser to new syntax (needs work, currently crashes interpreter
author Mike Pavone <pavone@retrodev.com>
date Wed, 24 Jun 2009 02:07:12 -0400
parents
children 8b2b3f4a2a58
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1 Import extendlib.rhope
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
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 Blueprint Parser
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
6 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
7 Arg Begin
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
8 Arg End
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
9 Line Comment
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
10 Comment Begin
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
11 Comment End
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
12 Assign
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
13 Block Begin
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
14 Block End
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
15 Blueprint Type Delim
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
16 Empty Block
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
17 Binary Operator
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
18 String Begin
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
19 String End
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
20 String Escape
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
21 List Begin
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
22 List End
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
23 List Delim
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
24 In Out Delim
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
25 Do Worker
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
26 Index Begin
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
27 Index End
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
28 Previous
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
29 Block Val
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
30 Set Field
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
31 Get Field
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
32 Import
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
33 Blueprint
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
34 Global Separator
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
35 Uses
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
36 Hex Escape
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
37 Escape Map
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
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
40 New@Parser[:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
41 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
42 out <- [[[[[[[[[[[[[[[[[[[[[[[[[[[[[[Build["Parser"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
43 ]Arg Begin << ["["]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
44 ]Arg End <<["]"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
45 ]Line Comment <<["//"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
46 ]Comment Begin <<["/*"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
47 ]Comment End <<["*/"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
48 ]Assign <<["<-"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
49 ]Block Begin <<["{"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
50 ]Block End <<["}"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
51 ]Blueprint Type Delim <<[":"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
52 ]Empty Block <<[";"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
53 ]Binary Operator <<["`"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
54 ]String Begin <<["\""]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
55 ]String End <<["\""]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
56 ]String Escape <<["\\"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
57 ]List Begin <<["("]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
58 ]List End <<[")"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
59 ]List Delim <<[","]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
60 ]In Out Delim <<[":"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
61 ]Do Worker <<["$"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
62 ]Index Begin <<["("]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
63 ]Index End <<[")"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
64 ]Previous <<["@"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
65 ]Set Field <<["<<"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
66 ]Get Field <<[">>"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
67 ]Import <<["Import"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
68 ]Blueprint <<["Blueprint"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
69 ]Global Separator <<["::"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
70 ]Hex Escape <<["x"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
71 ]Uses <<["uses"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
72 ]Escape Map <<[[[[New@Dictionary[]]Set["n","\n"]]Set["r","\r"]]Set["t","\t"]]
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 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
90 reflist <- New@List[]
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
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
105 Blueprint Parse Program
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
106 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
107 Workers
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
108 Imports
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
109 Blueprints
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
110 Errors
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
111 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
112
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
113 New@Parse Program[:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
114 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
115 out <- [[[Build["Parse Program"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
116 ]Workers <<[New@Dictionary[]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
117 ]Imports <<[New@Dictionary[]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
118 ]Blueprints <<[New@Dictionary[]]
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
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
121 Blueprint Blueprint Definition
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
122 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
123 Name
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
124 Fields
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
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
127 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
128 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
129 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
130 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
131
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
132 Blueprint Parse Worker
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 Name
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
135 Inputs
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
136 Outputs
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
137 Line Number
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
138 Trees
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
139 Uses Stores
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
140 }
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 New@Parse Worker[name,inputs,outputs,line:out]
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 out <- [[[[[[Build["Parse Worker"]]Name <<[name]]Inputs <<[inputs]]Outputs <<[outputs]]Line Number <<[line]]Trees <<[New@List[]]]Uses Stores <<[New@List[]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
145 }
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 Blueprint Worker Node
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
148 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
149 Name
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
150 Params
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
151 Assignments
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
152 Blocks
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
153 Index
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
154 }
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 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
157 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
158 out <- [[[[Build["Worker Node"]]Name <<[name]]Params <<[params]]Assignments <<[New@List[]]]Blocks <<[New@List[]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
159 }
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 Add List Helper[list,worker,program,key,parse worker,refs:out,worker,refs]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
162 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
163 ,nextworker,nextrefs <- [[list]Index[key]]Add to Worker[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
164 { nextlist <- [list]Set[key, ~] }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
165 [list]Next[key]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
166 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
167 list,worker,refs <- Add List Helper[nextlist, nextworker, program, ~, parse worker, nextrefs]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
168 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
169 list <- Val[nextlist]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
170 worker <- Val[nextworker]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
171 refs <- Val[nextrefs]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
172 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
173 }
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 Add List to Worker[list,worker,program,parse worker,refs:list,worker,refs]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
176 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
177 [list]First
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
178 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
179 list,worker,refs <- Add List Helper[list, 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
180 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
181 list <- list
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
182 worker <- worker
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
183 refs <- refs
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
184 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
185 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
186
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
187 _Add Blocks to Worker[blocks,worker,program,parse worker,key,refs:blocks,worker,refs]
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 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
190 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
191 [blocks]Next[key]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
192 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
193 blocks,worker,refs <- _Add Blocks to Worker[next blocks, next worker, program, parseworker, ~, nextrefs]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
194 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
195 blocks <- Val[next blocks]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
196 worker <- Val[next worker]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
197 refs <- Val[nextrefs]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
198 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
199 }
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 Add Blocks to Worker[blocks,worker,program,parse worker,refs:blocks,worker,refs]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
202 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
203 [blocks]First
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
204 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
205 blocks, worker, refs <- _Add Blocks to Worker[blocks, 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
206 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
207 blocks <- blocks
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
208 worker <- worker
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
209 refs <- refs
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
210 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
211 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
212
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
213 Add to Worker@Worker Node[node,worker,program,parse worker,refs:node,worker,refs]
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 [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
216 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
217 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
218 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
219 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
220 [node]Index <<[~]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
221 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
222 params list, params worker, params refs <- Add List to Worker[[~]Params >>, after worker, program, parse worker, assignment refs]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
223 block list, worker, refs <- Add Blocks to Worker[[~]Blocks >>, params worker, program, parse worker, params refs]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
224 node <- [[~]Params <<[params list]]Blocks <<[block list]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
225 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
226 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
227 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
228 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
229 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
230 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
231
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
232 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
233 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
234 out <- [worker]Add Wire[[ref]Index >>, [ref]Output Number >>, end index, input num]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
235 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
236
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
237 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
238 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
239 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
240 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
241 out <- [param worker]Add Wire[start index, output num, end index, input num]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
242 }{}{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
243 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
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 _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
248 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
249 out <- [node]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
250 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
251
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
252 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
253 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
254 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
255 out <- Fold[[[["_Add Block Wire"]Set Input[3, blocks]]Set Input[4, parse worker]]Set Input[5, assignments], worker, block nodes]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
256 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
257
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
258 Assignments Add Wires[worker,assignement,output num,parse worker,start index:worker]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
259 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
260 [[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
261 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
262 ,output index <- [worker]Add Output[assignment, ~]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
263 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
264 worker <- [~]Add Wire[start index, output num, output index, 0]
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 //Ugly hack alert!
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
268 If[[asignment]Contains["::"]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
269 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
270 parts <- [assignment]Split["::"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
271 ,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
272 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
273 worker <- [~]Add Wire[start index, output num, global index, 0]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
274 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
275 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
276 worker <- worker
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
277 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
278 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
279 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
280
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
281 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
282 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
283 out <- Yes
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
284 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
285
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
286 _Has Block Params[list,key:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
287 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
288 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
289 out <- [param]Has Block {}
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
290 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
291 [param list]Next[key]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
292 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
293 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
294 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
295 out <- No
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
296 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
297 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
298
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
299 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
300
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
301 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
302 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
303 [param list]First
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
304 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
305 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
306 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
307 out <- No
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
308 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
309 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
310
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
311 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
312 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
313 worker,index,num <- Add Wires Worker or Field[node, worker, blocks, parse worker, assignments]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
314 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
315
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
316 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
317 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
318 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
319 { Fold[[[[["Add Block Wire"]Set Input[3, [node]Index >>]]Set Input[4, blocks]]Set Input[5, parse worker]]Set Input[6, assignments], ~, [node]Blocks >>]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
320 { 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 >>] :{|
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
321 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
322 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
323 worker <- Val[params worker]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
324 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
325 [blocks]Peek
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
326 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
327 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
328 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
329 worker <- Val[params worker]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
330 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
331 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
332 index <- [node]Index >>
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
333 num <- 0
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 Blueprint Field Node
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
337 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
338 Name
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
339 Params
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
340 Assignments
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
341 Blocks
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
342 Index
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
343 Set?
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
344 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
345
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
346 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
347 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
348 has block <- Yes
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
349 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
350
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
351 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
352 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
353 out <- [[[[[Build["Field Node"]]Name <<[name]]Assignments <<[New@List[]]]Blocks <<[New@List[]]]Set? <<[set]]Params <<[params]
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
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
356 Add to Worker@Field Node[node,worker,program,parse worker,refs:node,worker,refs,unused]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
357 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
358 If[[node]Set? >>]
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 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
361 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
362 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
363 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
364 index
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
365 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
366 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
367 [node]Index <<[~]
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 params list, params worker, params refs <- Add List to Worker[[~]Params >>, after worker, program, parse worker, assignment refs]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
370 block list, worker, refs <- Add Blocks to Worker[[~]Blocks >>, params worker, program, parse worker, params refs]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
371 node <- [[~]Params <<[params list]]Blocks <<[block list]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
372 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
373 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
374 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
375
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
376 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
377 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
378 worker,index,num <- Add Wires Worker or Field[node, worker, blocks, parse worker, assignments]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
379 }
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 Blueprint Named Pipe Node
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 Name
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
384 Assignments
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
385 Blocks
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
386 Index
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
387 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
388
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
389 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
390 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
391 If[[[node]Index >>] < [0]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
392 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
393 //~ 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
394 If[[[node]Name >>] = ["~"]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
395 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
396 has block <- Yes
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
397 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
398 no block <- No
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
399 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
400 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
401 has block <- Yes
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
402 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
403 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
404
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
405 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
406 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
407 out <- [[[Build["Named Pipe Node"]]Name <<[name]]Assignments <<[New@List[]]]Blocks <<[New@List[]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
408 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
409
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
410 Add to Worker@Named Pipe Node[node,worker,program,parse worker,refs:node,worker,refs]
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 [[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
413 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
414 after add <- [worker]Add Input[[node]Name >>, ~] {}
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
415 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
416 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
417 index node <- [node]Index <<[~]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
418 }
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 after add <- worker
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
421 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
422 //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
423 assign refs <- refs
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
424 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
425 block list, worker, refs <- Add Blocks to Worker[[node]Blocks >>, after add, program, parse worker, assign refs]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
426 node <- [index node]Blocks <<[block list]
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
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
429 Add Wires@Named Pipe 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
430 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
431 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
432 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
433 //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
434 worker <- worker
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
435 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
436 If[[[node]Name >>] = ["~"]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
437 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
438 wires worker <- worker
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
439 [blocks]Peek
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
440 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
441 my index <- [~]Index >>
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
442 num <- [~]Output Number >>
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 //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
445 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
446 }
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 If[[[node]Index >>] < [0]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
449 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
450 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
451 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
452 my index <- [node]Index >>
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
453 num <- 0
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
454 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
455 [blocks]Peek
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 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
458 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
459 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
460 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
461 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
462 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
463 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
464 index <- my index
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 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
467 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
468
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
469 Blueprint Global Node
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
470 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
471 Store
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
472 Name
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
473 Assignments
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
474 Blocks
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
475 Index
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
476 }
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 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
479 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
480 out <- [[[[Build["Global Node"]]Store <<[store]]Name <<[name]]Assignments <<[New@List[]]]Blocks <<[New@List[]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
481 }
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 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
484 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
485 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
486 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
487 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
488 out node <- [node]Index <<[~]
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 refs <- refs
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
491 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
492
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
493 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
494 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
495 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
496 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
497
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
498 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
499 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
500 out <- Yes
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
501 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
502
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
503 Blueprint Literal Node
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 Value
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
506 Assignments
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
507 Blocks
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
508 Index
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
509 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
510
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
511 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
512 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
513 out <- Yes
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
514 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
515
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
516 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
517 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
518 out <- [[[Build["Literal Node"]]Value <<[value]]Assignments <<[New@List[]]]Blocks <<[New@List[]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
519 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
520
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
521 Add to Worker@Literal Node[node,worker,unused,parse worker,refs:out node,out worker,refs,unused]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
522 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
523 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
524 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
525 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
526 out node <- [node]Index <<[~]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
527 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
528 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
529
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
530 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
531 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
532 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
533 }
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 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
536 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
537 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
538 [blocks]Peek
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 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
541 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
542 worker <- Val[assignments worker]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
543 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
544 index <- [node]Index >>
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
545 num <- 0
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
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
548 Blueprint Block Node
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 Number
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
551 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
552
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
553 Blueprint Parse Error
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 Type
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
556 Text
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
557 Line Number
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
558 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
559
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
560 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
561 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
562 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
563 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
564
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
565 Filter Empty[string:out]
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 If[[[string]Length] > [0]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
568 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
569 out <- Yes
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 out <- No
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
572 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
573 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
574
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
575 Blueprint Blueprint Field
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
576 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
577 Name
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
578 Type
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
579 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
580
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
581 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
582 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
583 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
584 }
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 Process Blueprint Field[list,field,delim:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
587 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
588 parts <- [field]Split[delim]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
589 If[[[parts]Length] > [1]]
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 out <- [list]Append[New@Blueprint Field[[parts]Index[1], [parts]Index[0]]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
592 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
593 out <- [list]Append[New@Blueprint Field[[parts]Index[0], "Any Type"]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
594 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
595 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
596
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
597 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
598 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
599 If[[block count] > [0]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
600 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
601 after, before <- [string]Get DString[[[New@List[]]Append[begin comment]]Append[end comment]] {} {}
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
602 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
603 If[[~] = [begin comment]]
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 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
606 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
607 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
608 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
609 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
610 //No match
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
611 out <- ""
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
612 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
613 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
614 out <- string
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
615 }
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 Line Comment[string:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
619 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
620 [string]Get DString["\n"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
621 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
622 out <- ["\n"]Append[~]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
623 } {} {} {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
624 out <- ""
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
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
628 _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
629 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
630 after,before,delim,nomatch <- [string]Get DString[delims]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
631 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
632 If[[delim] = [line comment]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
633 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
634 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
635 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
636 If[[delim] = [begin comment]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
637 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
638 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
639 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
640 rest <- Val[after]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
641 before <- [prev before]Append[before]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
642 delim <- Val[delim]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
643 }
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 before <- [prev before]Append[before]
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
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
649 after comment
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 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
652 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
653 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
654
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
655 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
656
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
657 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
658 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
659 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
660 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
661 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
662 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
663 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
664 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
665
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
666 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
667 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
668 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
669
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
670 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
671 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
672 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
673 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
674 ,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
675 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
676 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
677 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
678 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
679 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
680 ,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
681 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
682 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
683 out <- Val[trimmed]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
684 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
685 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
686 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
687
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
688 Blueprint[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
689 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
690 ,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
691 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
692 ,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
693 name <- Trim[no blueprint, "\r\n\t "]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
694 name lines <- 0//[Count Substring[left, "\n"]] + [Count Substring[right, "\n"]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
695 ,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
696 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
697 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
698 more lines <- [[[body lines]Length] - [1]] + [name lines]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
699 fields <- Fold[["Process Blueprint Field"]Set Input[2, [params]Blueprint Type Delim >>], New@List[], Filter[Map[body lines, ["Trim"]Set Input[1,"\n\r\t "]], "Filter Empty"]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
700 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
701 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
702 } {} {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
703 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
704 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
705
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
706 } {} {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
707 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
708 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
709 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
710
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
711 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
712 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
713 [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
714 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
715 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
716 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
717 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
718 ,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
719 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
720 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
721 } {} {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
722 out <- Val[new tree]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
723 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
724 }
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 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
727 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
728 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
729 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
730 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
731 ,begin block <- [check block]Slice[[[params]Block Begin >>]Length]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
732 trees, after block <- Worker Body[begin block, params, New@List[]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
733 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
734 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
735 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
736 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
737 blocks <- blocks
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
738 ,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
739 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
740 blocks <- blocks
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
741 after <- Val[check block]
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 }
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
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
746 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
747 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
748 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
749 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
750 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
751 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
752 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
753 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
754 after <- Val[rest]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
755 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
756 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
757 char <- Val[code]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
758 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
759 }
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
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
762 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
763 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
764 delims <- [[New@List[]]Append[[params]String End >>]]Append[[params]String Escape >>]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
765 after, before, delim <- [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
766 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
767 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
768 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
769 value <- [current]Append[before]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
770 after <- Val[after]
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 char,after escape <- Parse Escape[after, params]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
773 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
774 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
775 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
776 }
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 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
779 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
780 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
781 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
782 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
783 value <- list
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
784 ,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
785 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
786 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
787 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
788 ,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
789 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
790 el string <- Val[trimmed]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
791 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
792 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
793 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
794 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
795 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
796
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
797 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
798 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
799 out <- [node]Value >>
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
800 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
801
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
802 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
803 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
804 out <- node
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
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
807 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
808 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
809 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
810 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
811 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
812 after <- [~]Append[after delim]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
813 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
814 after <- ""
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
815 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
816 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
817 If[[first two] = ["0x"]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
818 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
819 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
820 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
821 If[[valstring]Contains["."]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
822 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
823 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
824 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
825 value <- <String@Whole Number[valstring]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
826 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
827 }
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 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
831 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
832 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
833 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
834 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
835 ,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
836 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
837 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
838 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
839 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
840 ,list start <- [name]Slice[[[params]List Begin >>]Length]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
841 value,after <- Parse List[list start, params, New@List[]]
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 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
844 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
845 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
846 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
847 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 >>]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
848 afterdelim,raw before,delim <- [name]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
849 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
850 after <- [delim]Append[~]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
851 } {} {} {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
852 after <- ""
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 before <- Trim[raw before, "\r\n\t "]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
855 If[[before] = ["Yes"]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
856 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
857 yesno <- Yes
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
858 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
859 If[[before] = ["No"]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
860 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
861 yesno <- No
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 If[[before] = [""]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
864 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
865 Print[[["Found "]Append[delim]]Append[" where a named pipe or literal was expected"]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
866 { Print[["Near: "]Append[ [afterdelim]Slice[40]]] }
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 If[[before]Contains[[params]Global Separator >>]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
869 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
870 parts <- [before]Split[[params]Global Separator >>]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
871 out <- New@Global Node[Right Trim[[parts]Index[0],"\r\n\t "], Trim[[parts]Index[1], "\r\n\t "]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
872 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
873 out <- New@Named Pipe Node[Right 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
874 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
875 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
876 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
877 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
878 out <- New@Literal Node[yesno]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
879 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
880 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
881 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
882 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
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 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
886 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
887 args <- 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
888 If[[args]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
889 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
890 [args]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
891 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
892 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
893 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
894 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
895 If[[args]Starts With[[params]Arg End >>]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
896 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
897 args <- arglist
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
898 ,after <- [args]Slice[[[params]Arg End >>]Length]
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 final args <- Val[args]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
901 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
902 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
903 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
904 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
905 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
906
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
907 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
908 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
909 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
910 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
911 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
912 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
913 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
914 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
915 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
916 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
917 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
918 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
919 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
920 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
921 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
922 }
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
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
926 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
927 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
928 //Parse argument list
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
929 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
930 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
931 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
932
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
933 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
934 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
935 args, after args <- Parse Arguments[string, params, New@List[]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
936 delims <- [[[[[("\n")]Append[[params]Arg Begin >>]]Append[[params]Empty Block >>]]Append[[params]Block Begin >>]]Append[[params]Arg End >>]]Append[[params]List Delim >>]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
937 after,before,delim <- [after args]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
938 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
939 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
940 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
941 expression, after <- Prefix[after, params, Trim[before,"\r\n\t "], args]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
942 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
943 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
944 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
945 after expression <- Val[after]
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 expression <- [after args]Slice[[before]Length]
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 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
950 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
951 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
952 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
953
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
954 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
955 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
956 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
957 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
958 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
959 //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
960 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
961 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
962 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
963 //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
964 If[[maybe name] = [""]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
965 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
966 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
967 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
968 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
969 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
970 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
971 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
972 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
973 expression, after expression <- Prefix[after, params, maybe name, New@List[]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
974 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
975 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
976 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
977 If[[delim] = [[params]Assign >>]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
978 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
979 //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
980 //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
981 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
982 ,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
983 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
984 final expression <- [~]Assignments <<[assignments]
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 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
987 //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
988 //{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
989 // 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
990 // {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
991 // 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
992 // }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
993 // 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
994 // 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
995 // }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
996 //}{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
997 // 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
998 // 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
999 //}
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1000 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
1001 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1002 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1003 //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
1004 //to the outputs of the current one
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1005 blocks,after blocks <- Get Expression Blocks[after expression, params, New@List[]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1006 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
1007 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1008 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1009
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1010 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
1011 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1012 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
1013 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
1014 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1015 //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
1016 ,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
1017 trees <- trees
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1018 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1019 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
1020 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
1021 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1022 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1023
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1024 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
1025 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1026 //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
1027 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
1028 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
1029 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1030 ,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
1031 ,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
1032 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
1033 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1034 out <- worker
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
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1038 Worker Name[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
1039 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1040 ,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
1041 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1042 worker name <- Trim[whitespace name, "\n\r\t "]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1043 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
1044 arg end <- [params]Arg End >>
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1045 delims <- [[New@List[]]Append[in out]]Append[arg end]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1046 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
1047 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1048 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
1049 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1050 //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
1051 //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
1052 If[[~] = [in out]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1053 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1054 after arglist <- [after]Get Comment DString[arg end, params] {}
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1055 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1056 output string <- Trim[~,"\n\r\t "]
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 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1059 after arglist <- Val[after]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1060 output string <- ""
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 inputs <- Map[[arglist]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
1063 outputs <- Map[[output string]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
1064
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1065 New@Parse Worker[worker name, inputs, outputs, 0]
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 body text, modifiers <- [after arglist]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
1068 modified <- Process Modifiers[~, params, modifiers]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1069 expression trees, after body <- Worker Body[body text, params, New@List[]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1070 worker <- [modified]Trees <<[expression trees]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1071 new worker dict <- [[tree]Workers >>]Set[worker name, worker]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1072 out <- Null[after body, params, [tree]Workers <<[new worker dict], 0]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1073 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1074 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1075 }{}{}{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1076 out <- tree
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 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
1081 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1082 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
1083 current line <- 0//[lines] + [Count Substring[whitespace, "\n"]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1084 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
1085 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1086 out <- Blueprint[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
1087 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1088 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
1089 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1090 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
1091 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1092 out <- Worker Name[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
1093 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1094 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1095 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1096
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1097 Add Workers[worker,name,program:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1098 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1099 prog,worker <- [program]New Worker[name]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1100 [worker]Set IO Counts[ [[[worker]Index[name]]Inputs >>]Length, [[[worker]Index[name]]Outputs >>]Length]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1101 [workers]Next[name]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1102 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1103 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
1104 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1105 out <- Val[prog]
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 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
1110 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1111 out <- [node]Add Wires[worker, New@List[], parse worker, assignments]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1112 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1113
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1114 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
1115 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1116 worker <- [[program]Find Worker[name]]Uses[[parse worker]Uses Stores >>]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1117 trees, contents worker, refs <- Add List to Worker[[parse worker]Trees >>, worker, program, parse worker, New@Dictionary[]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1118 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
1119 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
1120 key <- name
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1121 }
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 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
1124 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1125 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
1126 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1127
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1128 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
1129 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1130 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
1131 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1132 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
1133 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1134 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1135
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1136 _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
1137 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1138 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
1139 [[parse tree]Workers >>]First
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 prog <- Add Workers[[parse tree]Workers >>, ~, after blueprint]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1142 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1143 Key Value Map[[parse tree]Workers >>, ["Add Contents"]Set Input[2, prog]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1144 out <- prog
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1145 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1146
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1147 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
1148 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1149 out <- _Tree to Program[parse tree, [New@Program[]]Add Builtins]
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 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
1153 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1154 If[not imported?]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1155 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1156 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
1157 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1158 out <- needs import
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1159 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1160 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1161
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1162 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
1163 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1164 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
1165 ,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
1166 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
1167 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
1168 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1169
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1170 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
1171 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1172 needs import <- Fold["Needs Imports", New@List[], [parse tree]Imports >>]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1173 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
1174 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1175 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
1176 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
1177 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1178 out <- parse tree
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1179 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1180 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1181
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1182 _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
1183 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1184 [dict]Index[store name]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1185 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1186 out <- dict
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1187 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1188 Init Store[store name]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1189 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
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
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1193 _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
1194 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1195 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
1196 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1197
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1198 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
1199 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1200 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
1201 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1202
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1203 Until End[text:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1204 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1205 line <- Get Input[]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1206 If[[line] = ["End"]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1207 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1208 out <- [text]Append["\n"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1209 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1210 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
1211 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1212 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1213
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1214 _REPL[params,prog,stores]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1215 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1216 line <- Get Input[]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1217 If[[line] = ["Begin"]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1218 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1219 text <- Until End[""]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1220 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
1221 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1222 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
1223 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
1224 { _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
1225 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1226 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1227 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
1228 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1229 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
1230 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1231 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
1232 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
1233 { _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
1234 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1235 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1236 trees <- Worker Body[[line]Append["}"], params, New@List[]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1237 tree <- [New@Worker Node["Val", [New@List[]]Append[[trees]Index[0]]]]Assignments <<[("__out")]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1238 this stores <- [[tree]Gather Stores[params, New@Dictionary[]]]Keys
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1239 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
1240 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1241 pworker <- [[New@Parse Worker["__Eval", New@List[], ("__out"), 0]]Trees <<[[New@List[]]Append[tree]]]Uses Stores <<[this stores]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1242 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1243 [[prog]Find Worker["__Eval"]]Clear
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1244 { Add Contents[pworker, "__Eval", prog]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1245 { Pretty Print[[[[prog]Find Worker["__Eval"]]Do[New@List[]]]Index[0], ""]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1246 { _REPL[params, prog, next stores] } } }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1247 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1248 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1249 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1250
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1251 REPL[params]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1252 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1253 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
1254 prog <- Tree to Program[Null["Val[in:out]\n{\n out <- in\n}\n__Eval[:__out]\n{\n}\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
1255 _REPL[params, prog, New@Dictionary[]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1256 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1257
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1258 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
1259 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1260 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
1261 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1262 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
1263 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
1264 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1265 out <- stores
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1266 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1267 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1268
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1269 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
1270 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1271 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
1272 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1273
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1274 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
1275 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1276 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
1277 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1278
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1279 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
1280 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1281 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
1282 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1283
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1284 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
1285 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1286 //TODO: Handle blocks
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1287 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
1288 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
1289 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1290
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1291 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
1292 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1293 //TODO: Handle blocks
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1294 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
1295 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
1296 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1297
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1298 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
1299 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1300 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
1301 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1302
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1303
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1304 Main[args]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1305 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1306 [args]Index[1]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1307 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1308 file <- <String@File[~]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1309 ,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
1310 params <- New@Parser[]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1311 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
1312 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1313 tree <- Process Imports[~, params]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1314 Init Used Stores[tree, New@Dictionary[]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1315 { [Tree to Program[tree]]Run[[args]Tail[1]] }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1316 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1317 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1318 REPL[New@Parser[]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1319 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1320 }