0
|
1 Import extendlib.vistxt
|
|
2
|
|
3
|
|
4
|
|
5 Company Parser
|
|
6 |:
|
|
7 Arg Begin
|
|
8 Arg End
|
|
9 Line Comment
|
|
10 Comment Begin
|
|
11 Comment End
|
|
12 Assign
|
|
13 Block Begin
|
|
14 Block End
|
|
15 Blueprint Type Delim
|
|
16 Empty Block
|
|
17 Binary Operator
|
|
18 String Begin
|
|
19 String End
|
|
20 String Escape
|
|
21 List Begin
|
|
22 List End
|
|
23 List Delim
|
|
24 In Out Delim
|
|
25 Do Worker
|
|
26 Index Begin
|
|
27 Index End
|
|
28 Previous
|
|
29 Block Val
|
|
30 Set Field
|
|
31 Get Field
|
|
32 Import
|
|
33 Blueprint
|
|
34 Global Separator
|
|
35 Uses
|
|
36 Hex Escape
|
|
37 Escape Map
|
|
38 :|
|
|
39
|
|
40 New@Parser(0,1)
|
|
41 |:
|
|
42 out(0) <- [[[[[[[[[[[[[[[[[[[[[[[[[[[[[[Build["Parser"]
|
|
43 ]Arg Begin << ["["]
|
|
44 ]Arg End <<["]"]
|
|
45 ]Line Comment <<["//"]
|
|
46 ]Comment Begin <<["/*"]
|
|
47 ]Comment End <<["*/"]
|
|
48 ]Assign <<["<-"]
|
|
49 ]Block Begin <<["{"]
|
|
50 ]Block End <<["}"]
|
|
51 ]Blueprint Type Delim <<[":"]
|
|
52 ]Empty Block <<[";"]
|
|
53 ]Binary Operator <<["`"]
|
|
54 ]String Begin <<["\""]
|
|
55 ]String End <<["\""]
|
|
56 ]String Escape <<["\\"]
|
|
57 ]List Begin <<["("]
|
|
58 ]List End <<[")"]
|
|
59 ]List Delim <<[","]
|
|
60 ]In Out Delim <<[":"]
|
|
61 ]Do Worker <<["$"]
|
|
62 ]Index Begin <<["("]
|
|
63 ]Index End <<[")"]
|
|
64 ]Previous <<["@"]
|
|
65 ]Set Field <<["<<"]
|
|
66 ]Get Field <<[">>"]
|
|
67 ]Import <<["Import"]
|
|
68 ]Blueprint <<["Blueprint"]
|
|
69 ]Global Separator <<["::"]
|
|
70 ]Hex Escape <<["x"]
|
|
71 ]Uses <<["uses"]
|
|
72 ]Escape Map <<[[[[New@Dictionary[]]Set["n","\n"]]Set["r","\r"]]Set["t","\t"]]
|
|
73 :|
|
|
74
|
|
75 Company Output Reference
|
|
76 |:
|
|
77 Index
|
|
78 Output Number
|
|
79 :|
|
|
80
|
|
81 New@Output Reference(2,1)
|
|
82 |:
|
|
83 out(0) <- [[Build["Output Reference"]]Index <<[index(0)]]Output Number <<[num(1)]
|
|
84 :|
|
|
85
|
|
86 Add Pipe Reference(3,1)
|
|
87 |:
|
|
88 reflist <- [refs(0)]Index[name(1)] |::|
|
|
89 |:
|
|
90 reflist <- New@List[]
|
|
91 :|
|
|
92 out(0) <- [refs(0)]Set[name(1), [reflist]Append[reference(2)]]
|
|
93 :|
|
|
94
|
|
95 Assignment Save Reference(5,1)
|
|
96 |:
|
|
97 [[parse worker(3)]Outputs >>]Find[assignment(1)]
|
|
98 |:
|
|
99 out(0) <- refs(0)
|
|
100 :||:
|
|
101 out(0) <- Add Pipe Reference[refs(0), assignment(1), New@Output Reference[index(4), output num(2)]]
|
|
102 :|
|
|
103 :|
|
|
104
|
|
105 Company Parse Program
|
|
106 |:
|
|
107 Workers
|
|
108 Imports
|
|
109 Blueprints
|
|
110 Errors
|
|
111 :|
|
|
112
|
|
113 New@Parse Program(0,1)
|
|
114 |:
|
|
115 out(0) <- [[[Build["Parse Program"]
|
|
116 ]Workers <<[New@Dictionary[]]
|
|
117 ]Imports <<[New@Dictionary[]]
|
|
118 ]Blueprints <<[New@Dictionary[]]
|
|
119 :|
|
|
120
|
|
121 Company Blueprint Definition
|
|
122 |:
|
|
123 Name
|
|
124 Fields
|
|
125 :|
|
|
126
|
|
127 New@Blueprint Definition(2,1)
|
|
128 |:
|
|
129 out(0) <- [[Build["Blueprint Definition"]]Name << [name(0)]]Fields <<[fields(1)]
|
|
130 :|
|
|
131
|
|
132 Company Parse Worker
|
|
133 |:
|
|
134 Name
|
|
135 Inputs
|
|
136 Outputs
|
|
137 Line Number
|
|
138 Trees
|
|
139 Uses Stores
|
|
140 :|
|
|
141
|
|
142 New@Parse Worker(4,1)
|
|
143 |:
|
|
144 out(0) <- [[[[[[Build["Parse Worker"]]Name <<[name(0)]]Inputs <<[inputs(1)]]Outputs <<[outputs(2)]]Line Number <<[line(3)]]Trees <<[New@List[]]]Uses Stores <<[New@List[]]
|
|
145 :|
|
|
146
|
|
147 Company Worker Node
|
|
148 |:
|
|
149 Name
|
|
150 Params
|
|
151 Assignments
|
|
152 Blocks
|
|
153 Index
|
|
154 :|
|
|
155
|
|
156 New@Worker Node(2,1)
|
|
157 |:
|
|
158 out(0) <- [[[[Build["Worker Node"]]Name <<[name(0)]]Params <<[params(1)]]Assignments <<[New@List[]]]Blocks <<[New@List[]]
|
|
159 :|
|
|
160
|
|
161 Add List Helper(6,3)
|
|
162 |:
|
|
163 ,nextworker,nextrefs <- [[list(0)]Index[key(3)]]Add to Worker[worker(1), program(2), parse worker(4), refs(5)]
|
|
164 |: nextlist <- [list(0)]Set[key(3), ~] :|
|
|
165 [list(0)]Next[key(3)]
|
|
166 |:
|
|
167 list(0),worker(1),refs(2) <- Add List Helper[nextlist, nextworker, program(2), ~, parse worker(4), nextrefs]
|
|
168 :||:
|
|
169 list(0) <- Val[nextlist]
|
|
170 worker(1) <- Val[nextworker]
|
|
171 refs(2) <- Val[nextrefs]
|
|
172 :|
|
|
173 :|
|
|
174
|
|
175 Add List to Worker(5,3)
|
|
176 |:
|
|
177 [list(0)]First
|
|
178 |:
|
|
179 list(0),worker(1),refs(2) <- Add List Helper[list(0), worker(1), program(2), ~, parse worker(3), refs(4)]
|
|
180 :||:
|
|
181 list(0) <- list(0)
|
|
182 worker(1) <- worker(1)
|
|
183 refs(2) <- refs(4)
|
|
184 :|
|
|
185 :|
|
|
186
|
|
187 _Add Blocks to Worker(6,3)
|
|
188 |:
|
|
189 block, next worker, nextrefs <- Add List to Worker[[blocks(0)]Index[key(4)], worker(1), program(2), parse worker(3), refs(5)]
|
|
190 next blocks <- [blocks(0)]Set[key(4), block]
|
|
191 [blocks(0)]Next[key(4)]
|
|
192 |:
|
|
193 blocks(0),worker(1),refs(2) <- _Add Blocks to Worker[next blocks, next worker, program(2), parseworker(3), ~, nextrefs]
|
|
194 :||:
|
|
195 blocks(0) <- Val[next blocks]
|
|
196 worker(1) <- Val[next worker]
|
|
197 refs(2) <- Val[nextrefs]
|
|
198 :|
|
|
199 :|
|
|
200
|
|
201 Add Blocks to Worker(5,3)
|
|
202 |:
|
|
203 [blocks(0)]First
|
|
204 |:
|
|
205 blocks(0), worker(1), refs(2) <- _Add Blocks to Worker[blocks(0), worker(1), program(2), parse worker(3), ~, refs(4)]
|
|
206 :||:
|
|
207 blocks(0) <- blocks(0)
|
|
208 worker(1) <- worker(1)
|
|
209 refs(2) <- refs(4)
|
|
210 :|
|
|
211 :|
|
|
212
|
|
213 Add to Worker@Worker Node(5,3)
|
|
214 |:
|
|
215 [program(2)]Find Worker[[node(0)]Name >>]
|
|
216 |:
|
|
217 after worker <- [worker(1)]Add Worker Call[~] |::|
|
|
218 |:
|
|
219 assignment refs <- Fold[[["Assignment Save Reference"]Set Input[3, parse worker(3)]]Set Input[4, ~], refs(4), [node(0)]Assignments >>]
|
|
220 [node(0)]Index <<[~]
|
|
221 |:
|
|
222 params list, params worker, params refs <- Add List to Worker[[~]Params >>, after worker, program(2), parse worker(3), assignment refs]
|
|
223 block list, worker(1), refs(2) <- Add Blocks to Worker[[~]Blocks >>, params worker, program(2), parse worker(3), params refs]
|
|
224 node(0) <- [[~]Params <<[params list]]Blocks <<[block list]
|
|
225 :|
|
|
226 :|
|
|
227 :||:
|
|
228 Print[["Error: Could not find a worker named "]Append[[node(0)]Name >>]]
|
|
229 :|
|
|
230 :|
|
|
231
|
|
232 Add Multi Wire(5,1)
|
|
233 |:
|
|
234 out(0) <- [worker(0)]Add Wire[[ref(1)]Index >>, [ref(1)]Output Number >>, end index(3), input num(4)]
|
|
235 :|
|
|
236
|
|
237 Add Param Wire(7,1)
|
|
238 |:
|
|
239 param worker, start index, output num <- [param(1)]Add Wires[worker(0), blocks(4), parse worker(5), assignments(6)] |::|
|
|
240 |:
|
|
241 out(0) <- [param worker]Add Wire[start index, output num, end index(3), input num(2)]
|
|
242 :||::||:
|
|
243 out(0) <- Fold[[["Add Multi Wire"]Set Input[3, end index(3)]]Set Input[4, input num(2)], param worker, ~]
|
|
244 :|
|
|
245 :|
|
|
246
|
|
247 _Add Block Wire(6,1)
|
|
248 |:
|
|
249 out(0) <- [node(1)]Add Wires[worker(0), blocks(3), parse worker(4), assignments(5)]
|
|
250 :|
|
|
251
|
|
252 Add Block Wire(7,1)
|
|
253 |:
|
|
254 blocks <- [existing blocks(4)]Append[New@Output Reference[parent index(3), output num(2)]]
|
|
255 out(0) <- Fold[[[["_Add Block Wire"]Set Input[3, blocks]]Set Input[4, parse worker(5)]]Set Input[5, assignments(6)], worker(0), block nodes(1)]
|
|
256 //out(0) <- [param(1)]Add Wires[worker(0), blocks]
|
|
257 :|
|
|
258
|
|
259 Assignments Add Wires(5,1)
|
|
260 |:
|
|
261 [[parse worker(3)]Outputs >>]Find[assignment(1)]
|
|
262 |:
|
|
263 ,output index <- [worker(0)]Add Output[assignment(1), ~]
|
|
264 |:
|
|
265 worker(0) <- [~]Add Wire[start index(4), output num(2), output index, 0]
|
|
266 :|
|
|
267 :||:
|
|
268 //Ugly hack alert!
|
|
269 If[[asignment(1)]Contains["::"]]
|
|
270 |:
|
|
271 parts <- [assignment(1)]Split["::"]
|
|
272 ,global index <- [worker(0)]Add Global Set[[parts]Index[0], [parts]Index[1]]
|
|
273 |:
|
|
274 worker(0) <- [~]Add Wire[start index(4), output num(2), global index, 0]
|
|
275 :|
|
|
276 :||:
|
|
277 worker(0) <- worker(0)
|
|
278 :|
|
|
279 :|
|
|
280 :|
|
|
281
|
|
282 Has Block@Worker Node(1,2)
|
|
283 |:
|
|
284 out(0) <- Yes
|
|
285 :|
|
|
286
|
|
287 _Has Block Params(2,1)
|
|
288 |:
|
|
289 param <- [param list(0)]Index[key(1)]
|
|
290 out(0) <- [param]Has Block |::|
|
|
291 |:
|
|
292 [param list(0)]Next[key(1)]
|
|
293 |:
|
|
294 out(0) <- _Has Block Params[param list(0), ~]
|
|
295 :||:
|
|
296 out(0) <- No
|
|
297 :|
|
|
298 :|
|
|
299
|
|
300 :|
|
|
301
|
|
302 Has Block Params(1,1)
|
|
303 |:
|
|
304 [param list(0)]First
|
|
305 |:
|
|
306 out(0) <- _Has Block Params[param list(0), ~]
|
|
307 :||:
|
|
308 out(0) <- No
|
|
309 :|
|
|
310 :|
|
|
311
|
|
312 Add Wires@Worker Node(5,4)
|
|
313 |:
|
|
314 worker(0),index(1),num(2) <- Add Wires Worker or Field[node(0), worker(1), blocks(2), parse worker(3), assignments(4)]
|
|
315 :|
|
|
316
|
|
317 Add Wires Worker or Field(5,4)
|
|
318 |:
|
|
319 Fold[[["Assignments Add Wires"]Set Input[3, parse worker(3)]]Set Input[4, [node(0)]Index >>], worker(1), [node(0)]Assignments >>]
|
|
320 |: Fold[[[[["Add Block Wire"]Set Input[3, [node(0)]Index >>]]Set Input[4, blocks(2)]]Set Input[5, parse worker(3)]]Set Input[6, assignments(4)], ~, [node(0)]Blocks >>]
|
|
321 |: params worker <- Fold[[[[["Add Param Wire"]Set Input[3, [node(0)]Index >>]]Set Input[4, blocks(2)]]Set Input[5, parse worker(3)]]Set Input[6, assignments(4)], ~, [node(0)]Params >>] :|:|
|
|
322 If[Has Block Params[[node(0)]Params >>]]
|
|
323 |:
|
|
324 worker(0) <- Val[params worker]
|
|
325 :||:
|
|
326 [blocks(2)]Peek
|
|
327 |:
|
|
328 worker(0) <- [params worker]Add Wire[[~]Index >>, [~]Output Number >>, [node(0)]Index >>, [0]-[1]]
|
|
329 :||:
|
|
330 worker(0) <- Val[params worker]
|
|
331 :|
|
|
332 :|
|
|
333 index(1) <- [node(0)]Index >>
|
|
334 num(2) <- 0
|
|
335 :|
|
|
336
|
|
337 Company Field Node
|
|
338 |:
|
|
339 Name
|
|
340 Params
|
|
341 Assignments
|
|
342 Blocks
|
|
343 Index
|
|
344 Set?
|
|
345 :|
|
|
346
|
|
347 Has Block@Field Node(1,2)
|
|
348 |:
|
|
349 has block(0) <- Yes
|
|
350 :|
|
|
351
|
|
352 New@Field Node(3,1)
|
|
353 |:
|
|
354 out(0) <- [[[[[Build["Field Node"]]Name <<[name(0)]]Assignments <<[New@List[]]]Blocks <<[New@List[]]]Set? <<[set(2)]]Params <<[params(1)]
|
|
355 :|
|
|
356
|
|
357 Add to Worker@Field Node(5,3)
|
|
358 |:
|
|
359 If[[node(0)]Set? >>]
|
|
360 |:
|
|
361 after worker,index <- [worker(1)]Add Object Set[[node(0)]Name >>]
|
|
362 :||:
|
|
363 after worker,index <- [worker(1)]Add Object Get[[node(0)]Name >>]
|
|
364 :|
|
|
365 index
|
|
366 |:
|
|
367 assignment refs <- Fold[[["Assignment Save Reference"]Set Input[3, parse worker(3)]]Set Input[4, ~], refs(4), [node(0)]Assignments >>]
|
|
368 [node(0)]Index <<[~]
|
|
369 |:
|
|
370 params list, params worker, params refs <- Add List to Worker[[~]Params >>, after worker, program(2), parse worker(3), assignment refs]
|
|
371 block list, worker(1), refs(2) <- Add Blocks to Worker[[~]Blocks >>, params worker, program(2), parse worker(3), params refs]
|
|
372 node(0) <- [[~]Params <<[params list]]Blocks <<[block list]
|
|
373 :|
|
|
374 :|
|
|
375 :|
|
|
376
|
|
377 Add Wires@Field Node(5,4)
|
|
378 |:
|
|
379 worker(0),index(1),num(2) <- Add Wires Worker or Field[node(0), worker(1), blocks(2), parse worker(3), assignments(4)]
|
|
380 :|
|
|
381
|
|
382 Company Named Pipe Node
|
|
383 |:
|
|
384 Name
|
|
385 Assignments
|
|
386 Blocks
|
|
387 Index
|
|
388 :|
|
|
389
|
|
390 Has Block@Named Pipe Node(1,2)
|
|
391 |:
|
|
392 If[[[node(0)]Index >>] < [0]]
|
|
393 |:
|
|
394 //~ should really be a parser parameter
|
|
395 If[[[node(0)]Name >>] = ["~"]]
|
|
396 |:
|
|
397 has block(0) <- Yes
|
|
398 :||:
|
|
399 no block(1) <- No
|
|
400 :|
|
|
401 :||:
|
|
402 has block(0) <- Yes
|
|
403 :|
|
|
404 :|
|
|
405
|
|
406 New@Named Pipe Node(1,1)
|
|
407 |:
|
|
408 out(0) <- [[[Build["Named Pipe Node"]]Name <<[name(0)]]Assignments <<[New@List[]]]Blocks <<[New@List[]]
|
|
409 :|
|
|
410
|
|
411 Add to Worker@Named Pipe Node(5,3)
|
|
412 |:
|
|
413 [[parse worker(3)]Inputs >>]Find[[node(0)]Name >>]
|
|
414 |:
|
|
415 after add <- [worker(1)]Add Input[[node(0)]Name >>, ~] |::|
|
|
416 |:
|
|
417 assign refs <- Fold[[["Assignment Save Reference"]Set Input[3, parse worker(3)]]Set Input[4, ~], refs(4), [node(0)]Assignments >>]
|
|
418 index node <- [node(0)]Index <<[~]
|
|
419 :|
|
|
420 :||:
|
|
421 after add <- worker(1)
|
|
422 index node <- [node(0)]Index <<[[0]-[1]]
|
|
423 //TODO: Handle assignments from a named pipe that isn't an input
|
|
424 assign refs <- refs(4)
|
|
425 :|
|
|
426 block list, worker(1), refs(2) <- Add Blocks to Worker[[node(0)]Blocks >>, after add, program(2), parse worker(3), assign refs]
|
|
427 node(0) <- [index node]Blocks <<[block list]
|
|
428 :|
|
|
429
|
|
430 Add Wires@Named Pipe Node(5,4)
|
|
431 |:
|
|
432 reflist(3) <- [assignments(4)]Index[[node(0)]Name >>]
|
|
433 |:
|
|
434 //TODO: Fix support for a named pipe with a block
|
|
435 worker(0) <- worker (1)
|
|
436 :||:
|
|
437 If[[[node(0)]Name >>] = ["~"]]
|
|
438 |:
|
|
439 wires worker <- worker(1)
|
|
440 [blocks(2)]Peek
|
|
441 |:
|
|
442 my index <- [~]Index >>
|
|
443 num(2) <- [~]Output Number >>
|
|
444 :||:
|
|
445 //TODO: Propagate an error rather than printing it out
|
|
446 Print["Error, block reference symbol (~) located outside of a block"]
|
|
447 :|
|
|
448 :||:
|
|
449 If[[[node(0)]Index >>] < [0]]
|
|
450 |:
|
|
451 Print[[[["Error, reference to named pipe "]Append[[node(0)]Name >>]]Append[" that was never assigned to in worker "]]Append[[parse worker(3)]Name >>]]
|
|
452 :||:
|
|
453 my index <- [node(0)]Index >>
|
|
454 num(2) <- 0
|
|
455 assignments worker <- Fold[[["Assignments Add Wires"]Set Input[3, parse worker(3)]]Set Input[4, [node(0)]Index >>], worker(1), [node(0)]Assignments >>]
|
|
456 [blocks(2)]Peek
|
|
457 |:
|
|
458 wires worker <- [assignments worker]Add Wire[[~]Index >>, [~]Output Number >>, [node(0)]Index >>, [0]-[1]]
|
|
459 :||:
|
|
460 wires worker <- Val[assignments worker]
|
|
461 :|
|
|
462 :|
|
|
463 :|
|
|
464 :|
|
|
465 index(1) <- my index
|
|
466
|
|
467 worker(0) <- Fold[[[[["Add Block Wire"]Set Input[3, my index]]Set Input[4, blocks(2)]]Set Input[5, parse worker(3)]]Set Input[6, assignments(4)], wires worker, [node(0)]Blocks >>]
|
|
468 :|
|
|
469
|
|
470 Company Global Node
|
|
471 |:
|
|
472 Store
|
|
473 Name
|
|
474 Assignments
|
|
475 Blocks
|
|
476 Index
|
|
477 :|
|
|
478
|
|
479 New@Global Node(2,1)
|
|
480 |:
|
|
481 out(0) <- [[[[Build["Global Node"]]Store <<[store(0)]]Name <<[name(1)]]Assignments <<[New@List[]]]Blocks <<[New@List[]]
|
|
482 :|
|
|
483
|
|
484 Add to Worker@Global Node(5,3)
|
|
485 |:
|
|
486 out worker(1) <- [worker(1)]Add Global Get[[node(0)]Store >>, [node(0)]Name >>] |::|
|
|
487 |:
|
|
488 refs(2) <- Fold[[["Assignment Save Reference"]Set Input[3, parse worker(3)]]Set Input[4, ~], refs(4), [node(0)]Assignments >>]
|
|
489 out node(0) <- [node(0)]Index <<[~]
|
|
490 :|
|
|
491 refs(2) <- refs(4)
|
|
492 :|
|
|
493
|
|
494 Add Wires@Global Node(5,4)
|
|
495 |:
|
|
496 worker(0),index(1),num(2) <- Add Wires Literal or Global[node(0), worker(1), blocks(2), parse worker(3), assignments(4)]
|
|
497 :|
|
|
498
|
|
499 Has Block@Global Node(1,2)
|
|
500 |:
|
|
501 out(0) <- Yes
|
|
502 :|
|
|
503
|
|
504 Company Literal Node
|
|
505 |:
|
|
506 Value
|
|
507 Assignments
|
|
508 Blocks
|
|
509 Index
|
|
510 :|
|
|
511
|
|
512 Has Block@Literal Node(1,2)
|
|
513 |:
|
|
514 out(0) <- Yes
|
|
515 :|
|
|
516
|
|
517 New@Literal Node(1,1)
|
|
518 |:
|
|
519 out(0) <- [[[Build["Literal Node"]]Value <<[value(0)]]Assignments <<[New@List[]]]Blocks <<[New@List[]]
|
|
520 :|
|
|
521
|
|
522 Add to Worker@Literal Node(5,3)
|
|
523 |:
|
|
524 out worker(1) <- [worker(1)]Add Constant[[node(0)]Value >>] |::|
|
|
525 |:
|
|
526 refs(2) <- Fold[[["Assignment Save Reference"]Set Input[3, parse worker(3)]]Set Input[4, ~], refs(4), [node(0)]Assignments >>]
|
|
527 out node(0) <- [node(0)]Index <<[~]
|
|
528 :|
|
|
529 :|
|
|
530
|
|
531 Add Wires@Literal Node(5,4)
|
|
532 |:
|
|
533 worker(0),index(1),num(2) <- Add Wires Literal or Global[node(0), worker(1), blocks(2), parse worker(3), assignments(4)]
|
|
534 :|
|
|
535
|
|
536 Add Wires Literal or Global(5,4)
|
|
537 |:
|
|
538 assignments worker <- Fold[[["Assignments Add Wires"]Set Input[3, parse worker(3)]]Set Input[4, [node(0)]Index >>], worker(1), [node(0)]Assignments >>]
|
|
539 [blocks(2)]Peek
|
|
540 |:
|
|
541 worker(0) <- [assignments worker]Add Wire[[~]Index >>, [~]Output Number>>, [node(0)]Index >>, [0]-[1]]
|
|
542 :||:
|
|
543 worker(0) <- Val[assignments worker]
|
|
544 :|
|
|
545 index(1) <- [node(0)]Index >>
|
|
546 num(2) <- 0
|
|
547 :|
|
|
548
|
|
549 Company Block Node
|
|
550 |:
|
|
551 Number
|
|
552 :|
|
|
553
|
|
554 Company Parse Error
|
|
555 |:
|
|
556 Type
|
|
557 Text
|
|
558 Line Number
|
|
559 :|
|
|
560
|
|
561 New@Parse Error(3,1)
|
|
562 |:
|
|
563 out(0) <- [[[Build["Parse Error"]]Type <<[type(0)]]Text <<[text(1)]]Line Number <<[number(2)]
|
|
564 :|
|
|
565
|
|
566 Filter Empty(1,1)
|
|
567 |:
|
|
568 If[[[string(0)]Length] > [0]]
|
|
569 |:
|
|
570 out(0) <- Yes
|
|
571 :||:
|
|
572 out(0) <- No
|
|
573 :|
|
|
574 :|
|
|
575
|
|
576 Company Blueprint Field
|
|
577 |:
|
|
578 Name
|
|
579 Type
|
|
580 :|
|
|
581
|
|
582 New@Blueprint Field(2,1)
|
|
583 |:
|
|
584 out(0) <- [[Build["Blueprint Field"]]Name <<[name(0)]]Type <<[type(1)]
|
|
585 :|
|
|
586
|
|
587 Process Blueprint Field(3,1)
|
|
588 |:
|
|
589 parts <- [field(1)]Split[delim(2)]
|
|
590 If[[[parts]Length] > [1]]
|
|
591 |:
|
|
592 out(0) <- [list(0)]Append[New@Blueprint Field[[parts]Index[1], [parts]Index[0]]]
|
|
593 :||:
|
|
594 out(0) <- [list(0)]Append[New@Blueprint Field[[parts]Index[0], "Any Type"]]
|
|
595 :|
|
|
596 :|
|
|
597
|
|
598 Block Comment(4,1)
|
|
599 |:
|
|
600 If[[block count(3)] > [0]]
|
|
601 |:
|
|
602 after, before <- [string(0)]Get DString[[[New@List[]]Append[begin comment(1)]]Append[end comment(2)]] |::| |::|
|
|
603 |:
|
|
604 If[[~] = [begin comment(1)]]
|
|
605 |:
|
|
606 out(0) <- Block Comment[after, begin comment(1), end comment(2), [block count(3)]+[1]]
|
|
607 :||:
|
|
608 out(0) <- Block Comment[after, begin comment(1), end comment(2), [block count(3)]-[1]]
|
|
609 :|
|
|
610 :||:
|
|
611 //No match
|
|
612 out(0) <- ""
|
|
613 :|
|
|
614 :||:
|
|
615 out(0) <- string(0)
|
|
616 :|
|
|
617 :|
|
|
618
|
|
619 Line Comment(1,1)
|
|
620 |:
|
|
621 [string(0)]Get DString["\n"]
|
|
622 |:
|
|
623 out(0) <- ["\n"]Append[~]
|
|
624 :| |::| |::| |:
|
|
625 out(0) <- ""
|
|
626 :|
|
|
627 :|
|
|
628
|
|
629 _Get Comment DString(6,4)
|
|
630 |:
|
|
631 after,before,delim,nomatch(3) <- [string(0)]Get DString[delims(1)]
|
|
632 |:
|
|
633 If[[delim] = [line comment(2)]]
|
|
634 |:
|
|
635 after comment <- Line Comment[after]
|
|
636 :||:
|
|
637 If[[delim] = [begin comment(3)]]
|
|
638 |:
|
|
639 after comment <- Block Comment[after, begin comment(3), end comment(4), 1]
|
|
640 :||:
|
|
641 rest(0) <- Val[after]
|
|
642 before(1) <- [prev before(5)]Append[before]
|
|
643 delim(2) <- Val[delim]
|
|
644 :|
|
|
645 :|
|
|
646 :| |::| |::| |:
|
|
647 before(1) <- [prev before(5)]Append[before]
|
|
648 :|
|
|
649
|
|
650 after comment
|
|
651 |:
|
|
652 rest(0),more before,delim(2),nomatch(3) <- _Get Comment DString[~, delims(1), line comment(2), begin comment(3), end comment(4), prev before(5)]
|
|
653 before(1) <- [before]Append[more before]
|
|
654 :|
|
|
655
|
|
656 :|
|
|
657
|
|
658 Get Comment DString(3,4)
|
|
659 |:
|
|
660 line comment <- [params(2)]Line Comment >>
|
|
661 begin comment <- [params(2)]Comment Begin >>
|
|
662 end comment <- [params(2)]Comment End >>
|
|
663 all delims <- [[[delims(1)]As List]Append[begin comment]]Append[line comment]
|
|
664 rest(0), before(1), delim(2), not found(3) <- _Get Comment DString[string(0), delims(1), line comment, begin comment, end comment, ""]
|
|
665 :|
|
|
666
|
|
667 Comment Left Trim(3,1)
|
|
668 |:
|
|
669 line comment <- [params(2)]Line Comment >>
|
|
670
|
|
671 end comment <- [params(2)]Comment End >>
|
|
672 trimmed <- Left Trim[string(0), trim chars(1)]
|
|
673 If[[trimmed]Starts With[line comment]]
|
|
674 |:
|
|
675 ,after delim <- [trimmed]Slice[[line comment]Length]
|
|
676 out(0) <- Comment Left Trim[Line Comment[after delim], trim chars(1), params(2)]
|
|
677 :||:
|
|
678 begin comment <- [params(2)]Comment Begin >>
|
|
679 If[[trimmed]Starts With[begin comment]]
|
|
680 |:
|
|
681 ,after delim <- [trimmed]Slice[[line comment]Length]
|
|
682 out(0) <- Comment Left Trim[Block Comment[after delim, begin comment, end comment, 1], trim chars(1), params(2)]
|
|
683 :||:
|
|
684 out(0) <- Val[trimmed]
|
|
685 :|
|
|
686 :|
|
|
687 :|
|
|
688
|
|
689 Blueprint(4,1)
|
|
690 |:
|
|
691 ,whitespace name <- [string(0)]Get Comment DString[[params(1)]Block Begin >>, params(1)]
|
|
692 |:
|
|
693 ,no blueprint <- [whitespace name]Slice[ [[params(1)]Blueprint >>]Length ]
|
|
694 name <- Trim[no blueprint, "\r\n\t "]
|
|
695 name lines <- 0//[Count Substring[left, "\n"]] + [Count Substring[right, "\n"]]
|
|
696 ,body <- [~]Get Comment DString[ [params(1)]Block End >>, params(1)]
|
|
697 |:
|
|
698 body lines <- [body]Split["\n"]
|
|
699 more lines <- [[[body lines]Length] - [1]] + [name lines]
|
|
700 fields <- Fold[["Process Blueprint Field"]Set Input[2, [params(1)]Blueprint Type Delim >>], New@List[], Filter[Map[body lines, ["Trim"]Set Input[1,"\n\r\t "]], "Filter Empty"]]
|
|
701 new tree <- [tree(2)]Blueprints << [ [[tree(2)]Blueprints >>]Set[name, New@Blueprint Definition[name, fields]] ]
|
|
702 out(0) <- Null[~, params(1), new tree, [lines(3)] + [more lines]]
|
|
703 :| |::| |:
|
|
704 out(0) <- [tree(2)]Errors <<[ [[tree(2)]Errors >>]Append[New@Parse Error["Error",[["Blueprint is missing an block close symbol \""]Append[[params(1)]Block End >>]]Append["\""], lines(3)]] ]
|
|
705 :|
|
|
706
|
|
707 :| |::| |:
|
|
708 out(0) <- [tree(2)]Errors <<[ [[tree(2)]Errors >>]Append[New@Parse Error["Error",[["Blueprint is missing an block open symbol \""]Append[[params(1)]Block Begin >>]]Append["\""], lines(3)]] ]
|
|
709 :|
|
|
710 :|
|
|
711
|
|
712 Parse Import(4,1)
|
|
713 |:
|
|
714 [line]Slice[ [[params(1)]Import >>]Length ] |::|
|
|
715 |:
|
|
716 filename <- Trim[~, " \n\r\t"]
|
|
717 :|
|
|
718 new tree <- [tree(2)]Imports <<[ [[tree(2)]Imports >>]Set[filename, Yes] ]
|
|
719 ,line <- [string(0)]Get Comment DString["\n", params(1)]
|
|
720 |:
|
|
721 out(0) <- Null[~, params(1), new tree, [lines(3)] + [1]]
|
|
722 :| |::| |:
|
|
723 out(0) <- Val[new tree]
|
|
724 :|
|
|
725 :|
|
|
726
|
|
727 Get Expression Blocks(3,2)
|
|
728 |:
|
|
729 check block <- Comment Left Trim[string(0), "\n\r\t ", params(1)]
|
|
730 If[[check block]Starts With[[params(1)]Block Begin >>]]
|
|
731 |:
|
|
732 ,begin block <- [check block]Slice[[[params(1)]Block Begin >>]Length]
|
|
733 trees, after block <- Worker Body[begin block, params(1), New@List[]]
|
|
734 blocks(0), after(1) <- Get Expression Blocks[after block, params(1), [blocks(2)]Append[trees]]
|
|
735 :||:
|
|
736 If[[check block]Starts With[[params(1)]Empty Block >>]]
|
|
737 |:
|
|
738 blocks(0) <- blocks(2)
|
|
739 ,after(1) <- [check block]Slice[[[params(1)]Empty Block >>]Length]
|
|
740 :||:
|
|
741 blocks(0) <- blocks(2)
|
|
742 after(1) <- Val[check block]
|
|
743 :|
|
|
744 :|
|
|
745 :|
|
|
746
|
|
747 Parse Escape(2,2)
|
|
748 |:
|
|
749 code,rest <- [string(0)]Slice[1]
|
|
750 If[[code] = [[params(1)]Hex Escape >>]]
|
|
751 |:
|
|
752 hex,after(1) <- [rest]Slice[2]
|
|
753 char(0) <- [""]Put Byte[From Hex@Whole Number[hex]]
|
|
754 :||:
|
|
755 after(1) <- Val[rest]
|
|
756 char(0) <- [[params(1)]Escape Map >>]Index[code] |::|
|
|
757 |:
|
|
758 char(0) <- Val[code]
|
|
759 :|
|
|
760 :|
|
|
761 :|
|
|
762
|
|
763 Parse String(3,2)
|
|
764 |:
|
|
765 delims <- [[New@List[]]Append[[params(1)]String End >>]]Append[[params(1)]String Escape >>]
|
|
766 after, before, delim <- [string(0)]Get Comment DString[delims, params(1)]
|
|
767 |:
|
|
768 If[[delim] = [[params(1)]String End >>]]
|
|
769 |:
|
|
770 value(0) <- [current(2)]Append[before]
|
|
771 after(1) <- Val[after]
|
|
772 :||:
|
|
773 char,after escape <- Parse Escape[after, params(1)]
|
|
774 value(0),after(1) <- Parse String[after escape, params(1), [[current(2)]Append[before]]Append[char]]
|
|
775 :|
|
|
776 :|
|
|
777 :|
|
|
778
|
|
779 Parse List(3,2)
|
|
780 |:
|
|
781 trimmed <- Comment Left Trim[string(0), "\r\n\t ", params(1)]
|
|
782 If[[trimmed]Starts With[[params(1)]List End >>]]
|
|
783 |:
|
|
784 value(0) <- list(2)
|
|
785 ,after(1) <- [trimmed]Slice[[[params(1)]List End >>]Length]
|
|
786 :||:
|
|
787 If[[trimmed]Starts With[[params(1)]List Delim >>]]
|
|
788 |:
|
|
789 ,el string <- [trimmed]Slice[[[params(1)]List Delim >>]Length]
|
|
790 :||:
|
|
791 el string <- Val[trimmed]
|
|
792 :|
|
|
793 element,after el <- Named Pipe or Literal[el string, params(1)]
|
|
794 value(0),after(1) <- Parse List[after el, params(1), [list(2)]Append[[element]Get Value]]
|
|
795 :|
|
|
796 :|
|
|
797
|
|
798 Get Value@Literal Node(1,1)
|
|
799 |:
|
|
800 out(0) <- [node(0)]Value >>
|
|
801 :|
|
|
802
|
|
803 Get Value@Named Pipe Node(1,1)
|
|
804 |:
|
|
805 out(0) <- node(0)
|
|
806 :|
|
|
807
|
|
808 Parse Number(2,2)
|
|
809 |:
|
|
810 delims <- [[[[{" ","\t","\n","\r"}]Append[[params(1)]List Delim >>]]Append[[params(1)]Block Begin >>]]Append[[params(1)]Arg End >>]]Append[[params(1)]List End >>]
|
|
811 after delim,valstring <- [string(0)]Get Comment DString[delims, params(1)] |::| |::|
|
|
812 |:
|
|
813 after(1) <- [~]Append[after delim]
|
|
814 :||:
|
|
815 after(1) <- ""
|
|
816 :|
|
|
817 first two,rest <- [valstring]Slice[2]
|
|
818 If[[first two] = ["0x"]]
|
|
819 |:
|
|
820 value(0) <- From Hex@Whole Number[rest]
|
|
821 :||:
|
|
822 If[[valstring]Contains["."]]
|
|
823 |:
|
|
824 value(0) <- <String@Real Number[valstring]
|
|
825 :||:
|
|
826 value(0) <- <String@Whole Number[valstring]
|
|
827 :|
|
|
828 :|
|
|
829 :|
|
|
830
|
|
831 Named Pipe or Literal(2,2)
|
|
832 |:
|
|
833 name <- Comment Left Trim[string(0), "\n\r\t ", params(1)]
|
|
834 If[[name]Starts With[[params(1)]String Begin >>]]
|
|
835 |:
|
|
836 ,string begin <- [name]Slice[[[params(1)]String Begin >>]Length]
|
|
837 value,after(1) <- Parse String[string begin, params(1), ""]
|
|
838 :||:
|
|
839 If[[name]Starts With[[params(1)]List Begin >>]]
|
|
840 |:
|
|
841 ,list start <- [name]Slice[[[params(1)]List Begin >>]Length]
|
|
842 value,after(1) <- Parse List[list start, params(1), New@List[]]
|
|
843 :||:
|
|
844 If[[[name]Slice[1]]In["-0123456789"]]
|
|
845 |:
|
|
846 value,after(1) <- Parse Number[name, params(1)]
|
|
847 :||:
|
|
848 delims <- [[[[[[{"\n"}]Append[[params(1)]Block Begin >>]]Append[[params(1)]Block End >>]]Append[[params(1)]Empty Block >>]]Append[[params(1)]Arg End >>]]Append[[params(1)]List Delim >>]]Append[[params(1)]List End >>]
|
|
849 ,before,delim <- [name]Get Comment DString[delims, params(1)]
|
|
850 |:
|
|
851 after(1) <- [delim]Append[~]
|
|
852 :| |::| |::| |:
|
|
853 after(1) <- ""
|
|
854 :|
|
|
855 If[[before] = ["Yes"]]
|
|
856 |:
|
|
857 yesno <- Yes
|
|
858 :||:
|
|
859 If[[before] = ["No"]]
|
|
860 |:
|
|
861 yesno <- No
|
|
862 :||:
|
|
863 If[[before] = [""]]
|
|
864 |:
|
|
865 Print[[["Found "]Append[delim]]Append[" where a named pipe or literal was expected"]]
|
|
866 :||:
|
|
867 If[[before]Contains[[params(1)]Global Separator >>]]
|
|
868 |:
|
|
869 parts <- [before]Split[[params(1)]Global Separator >>]
|
|
870 out(0) <- New@Global Node[Right Trim[[parts]Index[0],"\r\n\t "], Trim[[parts]Index[1], "\r\n\t "]]
|
|
871 :||:
|
|
872 out(0) <- New@Named Pipe Node[Right Trim[before,"\r\n\t "]]
|
|
873 :|
|
|
874 :|
|
|
875 :|
|
|
876 :|
|
|
877 out(0) <- New@Literal Node[yesno]
|
|
878 :|
|
|
879 :|
|
|
880 :|
|
|
881 out(0) <- New@Literal Node[value]
|
|
882 :|
|
|
883
|
|
884 Parse Arguments(3,2)
|
|
885 |:
|
|
886 args <- Comment Left Trim[string(0), "\r\n\t ", params(1)]
|
|
887 If[[args]Starts With[[params(1)]List Delim >>]]
|
|
888 |:
|
|
889 [args]Slice[[[params(1)]List Delim >>]Length] |::|
|
|
890 |:
|
|
891 final args <- Comment Left Trim[~, "\r\n\t ", params(1)]
|
|
892 :|
|
|
893 :||:
|
|
894 If[[args]Starts With[[params(1)]Arg End >>]]
|
|
895 |:
|
|
896 args(0) <- arglist(2)
|
|
897 ,after(1) <- [args]Slice[[[params(1)]Arg End >>]Length]
|
|
898 :||:
|
|
899 final args <- Val[args]
|
|
900 :|
|
|
901 :|
|
|
902 arg, after arg <- Parse Expression[final args, params(1)]
|
|
903 args(0), after(1) <- Parse Arguments[after arg, params(1), [arglist(2)]Append[arg]]
|
|
904 :|
|
|
905
|
|
906 Worker or Field(3,1)
|
|
907 |:
|
|
908 get field <- [params(2)]Get Field >>
|
|
909 If[[name(0)]Ends With[get field]]
|
|
910 |:
|
|
911 field <- Right Trim[[name(0)]Slice[[[name(0)]Length] - [[get field]Length]], "\n\r\t "]
|
|
912 out(0) <- New@Field Node[field, args(1), No]
|
|
913 :||:
|
|
914 set field <- [params(2)]Set Field >>
|
|
915 If[[name(0)]Ends With[set field]]
|
|
916 |:
|
|
917 field <- Right Trim[[name(0)]Slice[[[name(0)]Length] - [[set field]Length]], "\n\r\t "]
|
|
918 out(0) <- New@Field Node[field, args(1), Yes]
|
|
919 :||:
|
|
920 out(0) <- New@Worker Node[name(0), args(1)]
|
|
921 :|
|
|
922 :|
|
|
923 :|
|
|
924
|
|
925 Prefix(4,2)
|
|
926 |:
|
|
927 //Parse argument list
|
|
928 more args,after(1) <- Parse Arguments[string(0), params(1), existing args(3)]
|
|
929 expression(0) <- Worker or Field[name(2), more args, params(1)]
|
|
930 :|
|
|
931
|
|
932 Postfix or Infix(2,2)
|
|
933 |:
|
|
934 args, after args <- Parse Arguments[string(0), params(1), New@List[]]
|
|
935 delims <- [[[[[{"\n"}]Append[[params(1)]Arg Begin >>]]Append[[params(1)]Empty Block >>]]Append[[params(1)]Block Begin >>]]Append[[params(1)]Arg End >>]]Append[[params(1)]List Delim >>]
|
|
936 after,before,delim <- [after args]Get Comment DString[delims, params(1)]
|
|
937 |:
|
|
938 If[[delim] = [[params(1)]Arg Begin >>]]
|
|
939 |:
|
|
940 expression(0), after(1) <- Prefix[after, params(1), Trim[before,"\r\n\t "], args]
|
|
941 :||:
|
|
942 If[[delim] = [[params(1)]Empty Block >>]]
|
|
943 |:
|
|
944 after expression(1) <- Val[after]
|
|
945 :||:
|
|
946 ,after expression(1) <- [after args]Slice[[before]Length]
|
|
947 :|
|
|
948 expression(0) <- Worker or Field[Trim[before,"\r\n\t "], args, params(1)]
|
|
949 :|
|
|
950 :|
|
|
951 :|
|
|
952
|
|
953 Parse Expression(2,2)
|
|
954 |:
|
|
955 delims <- [[[[[[[{"\n"}]Append[[params(1)]Arg Begin >>]]Append[[params(1)]Arg End >>]]Append[[params(1)]Assign >>]]Append["\n"]]Append[[params(1)]Empty Block >>]]Append[[params(1)]Block End >>]]Append[[params(1)]String Begin >>]
|
|
956 after, before, delim <- [trimmed(0)]Get Comment DString[delims, params(1)]
|
|
957 |:
|
|
958 //If we find an arg begin token, we have a worker expression
|
|
959 If[[delim] = [[params(1)]Arg Begin >>]]
|
|
960 |:
|
|
961 maybe name <- Right Trim[before, "\r\t "]
|
|
962 //Prefix expressions will have the worker name before the first arg begin token
|
|
963 If[[maybe name] = [""]]
|
|
964 |:
|
|
965 expression, after expression <- Postfix or Infix[after, params(1)]
|
|
966 :||:
|
|
967 If[[maybe name]Contains[[params(1)]List Delim >>]]
|
|
968 |:
|
|
969 after expression <- [after literal]Append[[delim]Append[after]]
|
|
970 expression, after literal <- Named Pipe or Literal[Right Trim[before, "\r\n\t "], params(1)]
|
|
971 :||:
|
|
972 expression, after expression <- Prefix[after, params(1), maybe name, New@List[]]
|
|
973 :|
|
|
974 :|
|
|
975 :||:
|
|
976 If[[delim] = [[params(1)]Assign >>]]
|
|
977 |:
|
|
978 //Expressions starting with an assignment can be prefix, postfix or infix
|
|
979 //or they can be a simple literal or named pipe
|
|
980 assignments <- Map[[before]Split[[params(1)]List Delim >>], ["Trim"]Set Input[1,"\n\r\t "]]
|
|
981 ,after blocks(1) <- Parse Expression[Comment Left Trim[after, " \n\r\t", params(1)], params(1)]
|
|
982 |:
|
|
983 final expression(0) <- [~]Assignments <<[assignments]
|
|
984 :|
|
|
985 :||:
|
|
986 //If[[delim] = [[params(1)]String Begin >>]]
|
|
987 //|:
|
|
988 // If[[Trim[before, "\r\n\t "]] = [""]]
|
|
989 // |:
|
|
990 // expression, after expression <- Named Pipe or Literal[[delim]Append[after], params(1)]
|
|
991 // :||:
|
|
992 // after expression <- [after literal]Append[[delim]Append[after]]
|
|
993 // expression, after literal <- Named Pipe or Literal[Right Trim[before, "\r\n\t "], params(1)]
|
|
994 // :|
|
|
995 //:||:
|
|
996 // after expression <- [after literal]Append[[delim]Append[after]]
|
|
997 // expression, after literal <- Named Pipe or Literal[Right Trim[before, "\r\n\t "], params(1)]
|
|
998 //:|
|
|
999 expression, after expression <- Named Pipe or Literal[trimmed(0), params(1)]
|
|
1000 :|
|
|
1001 :|
|
|
1002 //Any expression can be followed by one or more blocks mapping the inputs of other expressions
|
|
1003 //to the outputs of the current one
|
|
1004 blocks,after blocks(1) <- Get Expression Blocks[after expression, params(1), New@List[]]
|
|
1005 final expression(0) <- [expression]Blocks <<[blocks]
|
|
1006 :|
|
|
1007 :|
|
|
1008
|
|
1009 Worker Body(3,2)
|
|
1010 |:
|
|
1011 trimmed <- Comment Left Trim[string(0), "\n\r\t ", params(1)]
|
|
1012 If[[trimmed]Starts With[[params(1)]Block End >>]]
|
|
1013 |:
|
|
1014 //We're done with this block, return
|
|
1015 ,after end(1) <- [trimmed]Slice[[[params(1)]Block End >>]Length]
|
|
1016 trees(0) <- trees(2)
|
|
1017 :||:
|
|
1018 expression, after expression <- Parse Expression[trimmed, params(1)]
|
|
1019 trees(0),after end(1) <- Worker Body[after expression, params(1), [trees(2)]Append[expression]]
|
|
1020 :|
|
|
1021 :|
|
|
1022
|
|
1023 Process Modifiers(3,1)
|
|
1024 |:
|
|
1025 //Eventually this will need to be more sophisticated to handle more modifiers
|
|
1026 trimmed <- Comment Left Trim[modifiers(2), "\n\r\t ", params(1)]
|
|
1027 If[[trimmed]Starts With[[params(1)]Uses >>]]
|
|
1028 |:
|
|
1029 ,after uses <- [trimmed]Slice[[[params(1)]Uses >>]Length]
|
|
1030 ,stores string <- [after uses]Get Comment DString["\n", params(1)]
|
|
1031 out(0) <- [worker(0)]Uses Stores <<[Map[[stores string]Split[[params(1)]List Delim >>], ["Trim"]Set Input[1, "\r\n\t "]]]
|
|
1032 :||:
|
|
1033 out(0) <- worker(0)
|
|
1034 :|
|
|
1035 :|
|
|
1036
|
|
1037 Worker Name(4,1)
|
|
1038 |:
|
|
1039 ,whitespace name <- [string(0)]Get Comment DString[[params(1)]Arg Begin >>, params(1)]
|
|
1040 |:
|
|
1041 worker name <- Trim[whitespace name, "\n\r\t "]
|
|
1042 in out <- [params(1)]In Out Delim >>
|
|
1043 arg end <- [params(1)]Arg End >>
|
|
1044 delims <- [[New@List[]]Append[in out]]Append[arg end]
|
|
1045 after <- [~]Get Comment DString[delims, params(1)] |::|
|
|
1046 |:
|
|
1047 arglist <- Trim[~,"\r\n\t "]
|
|
1048 :||:
|
|
1049 //check if there is an in/out separator
|
|
1050 //if it isn't present, everything in the arglist is an input
|
|
1051 If[[~] = [in out]]
|
|
1052 |:
|
|
1053 after arglist <- [after]Get Comment DString[arg end, params(1)] |::|
|
|
1054 |:
|
|
1055 output string <- Trim[~,"\n\r\t "]
|
|
1056 :|
|
|
1057 :||:
|
|
1058 after arglist <- Val[after]
|
|
1059 output string <- ""
|
|
1060 :|
|
|
1061 inputs <- Map[[arglist]Split[[params(1)]List Delim >>], ["Trim"]Set Input[1,"\n\r\t "]]
|
|
1062 outputs <- Map[[output string]Split[[params(1)]List Delim >>], ["Trim"]Set Input[1,"\n\r\t "]]
|
|
1063
|
|
1064 New@Parse Worker[worker name, inputs, outputs, 0]
|
|
1065 |:
|
|
1066 body text, modifiers <- [after arglist]Get Comment DString[[params(1)]Block Begin >>, params(1)]
|
|
1067 modified <- Process Modifiers[~, params(1), modifiers]
|
|
1068 expression trees, after body <- Worker Body[body text, params(1), New@List[]]
|
|
1069 worker <- [modified]Trees <<[expression trees]
|
|
1070 new worker dict <- [[tree(2)]Workers >>]Set[worker name, worker]
|
|
1071 out(0) <- Null[after body, params(1), [tree(2)]Workers <<[new worker dict], 0]
|
|
1072 :|
|
|
1073 :|
|
|
1074 :||::||::||:
|
|
1075 out(0) <- tree(2)
|
|
1076 :|
|
|
1077 :|
|
|
1078
|
|
1079 Null(4,1)
|
|
1080 |:
|
|
1081 trimmed <- Comment Left Trim[string(0), " \n\r\t", params(1)]
|
|
1082 current line <- 0//[lines(3)] + [Count Substring[whitespace, "\n"]]
|
|
1083 If[[trimmed]Starts With[ [params(1)]Blueprint >> ]]
|
|
1084 |:
|
|
1085 out(0) <- Blueprint[trimmed, params(1), tree(2), current line]
|
|
1086 :||:
|
|
1087 If[[trimmed]Starts With[ [params(1)]Import >> ]]
|
|
1088 |:
|
|
1089 out(0) <- Parse Import[trimmed, params(1), tree(2), current line]
|
|
1090 :||:
|
|
1091 out(0) <- Worker Name[trimmed, params(1), tree(2), current line]
|
|
1092 :|
|
|
1093 :|
|
|
1094 :|
|
|
1095
|
|
1096 Add Workers(3,1)
|
|
1097 |:
|
|
1098 prog,worker <- [program(2)]New Worker[name(1)]
|
|
1099 [worker]Set IO Counts[ [[[worker(0)]Index[name(1)]]Inputs >>]Length, [[[worker(0)]Index[name(1)]]Outputs >>]Length]
|
|
1100 [workers(0)]Next[name(1)]
|
|
1101 |:
|
|
1102 out(0) <- Add Workers[workers(0), ~, prog]
|
|
1103 :||:
|
|
1104 out(0) <- Val[prog]
|
|
1105 :|
|
|
1106 :|
|
|
1107
|
|
1108 Add Wires Helper(5,1)
|
|
1109 |:
|
|
1110 worker(0) <- [node(1)]Add Wires[worker(0), New@List[], parse worker(3), assignments(4)]
|
|
1111 :|
|
|
1112
|
|
1113 Add Contents(3,2)
|
|
1114 |:
|
|
1115 worker <- [[program(2)]Find Worker[name(1)]]Uses[[parse worker(0)]Uses Stores >>]
|
|
1116 trees, contents worker, refs <- Add List to Worker[[parse worker(0)]Trees >>, worker, program(2), parse worker(0), New@Dictionary[]]
|
|
1117 Fold[[["Add Wires Helper"]Set Input[3, parse worker(0)]]Set Input[4, refs], contents worker, trees]
|
|
1118 out(0) <- [parse worker(0)]Trees <<[trees]
|
|
1119 key(1) <- name(1)
|
|
1120 :|
|
|
1121
|
|
1122 Add Blueprint Field(3,1)
|
|
1123 |:
|
|
1124 out(0) <- [blueprint(0)]Add Field[[field(1)]Name >>, [field(1)]Type >>]
|
|
1125 :|
|
|
1126
|
|
1127 Add Blueprint(2,1)
|
|
1128 |:
|
|
1129 out(0) <- [prog(0)]New Blueprint[[def(1)]Name >>] |::|
|
|
1130 |:
|
|
1131 Fold["Add Blueprint Field", ~, [def(1)]Fields >>]
|
|
1132 :|
|
|
1133 :|
|
|
1134
|
|
1135 _Tree to Program(2,1)
|
|
1136 |:
|
|
1137 after blueprint <- Fold["Add Blueprint", program(1), [parse tree(0)]Blueprints >>]
|
|
1138 [[parse tree(0)]Workers >>]First
|
|
1139 |:
|
|
1140 prog <- Add Workers[[parse tree(0)]Workers >>, ~, after blueprint]
|
|
1141 :|
|
|
1142 Key Value Map[[parse tree(0)]Workers >>, ["Add Contents"]Set Input[2, prog]]
|
|
1143 out(0) <- prog
|
|
1144 :|
|
|
1145
|
|
1146 Tree to Program(1,1)
|
|
1147 |:
|
|
1148 out(0) <- _Tree to Program[parse tree(0), [New@Program[]]Add Builtins]
|
|
1149 :|
|
|
1150
|
|
1151 Needs Imports(3,1)
|
|
1152 |:
|
|
1153 If[not imported?(1)]
|
|
1154 |:
|
|
1155 out(0) <- [needs import(0)]Append[name(2)]
|
|
1156 :||:
|
|
1157 out(0) <- needs import(0)
|
|
1158 :|
|
|
1159 :|
|
|
1160
|
|
1161 Do Import(4,1)
|
|
1162 |:
|
|
1163 file <- <String@File[file name(1)]
|
|
1164 ,text <- [file]Get FString[[file]Length]
|
|
1165 after import <- Null[text, params(3), tree(0), 0]
|
|
1166 out(0) <- [after import]Imports <<[ [[after import]Imports >>]Set[file name(1), No] ]
|
|
1167 :|
|
|
1168
|
|
1169 Process Imports(2,1)
|
|
1170 |:
|
|
1171 needs import <- Fold["Needs Imports", New@List[], [parse tree(0)]Imports >>]
|
|
1172 If[[[needs import]Length] > [0]]
|
|
1173 |:
|
|
1174 import tree <- Fold[["Do Import"]Set Input[3, params(1)], parse tree(0), needs import]
|
|
1175 out(0) <- Process Imports[import tree, params(1)]
|
|
1176 :||:
|
|
1177 out(0) <- parse tree(0)
|
|
1178 :|
|
|
1179 :|
|
|
1180
|
|
1181 _Init Used Store(2,1)
|
|
1182 |:
|
|
1183 [dict(0)]Index[store name(1)]
|
|
1184 |:
|
|
1185 out(0) <- dict(0)
|
|
1186 :||:
|
|
1187 Init Store[store name(1)]
|
|
1188 out(0) <- [dict(0)]Set[store name(1), Yes]
|
|
1189 :|
|
|
1190 :|
|
|
1191
|
|
1192 _Init Used Stores(2,1)
|
|
1193 |:
|
|
1194 out(0) <- Fold["_Init Used Store", dict(0), [worker(1)]Uses Stores >>]
|
|
1195 :|
|
|
1196
|
|
1197 Init Used Stores(1,1)
|
|
1198 |:
|
|
1199 out(0) <- Fold["_Init Used Stores", existing stores(1), [parse tree(0)]Workers >>]
|
|
1200 :|
|
|
1201
|
|
1202 Until End(1,1)
|
|
1203 |:
|
|
1204 line <- Get Input[]
|
|
1205 If[[line] = ["End"]]
|
|
1206 |:
|
|
1207 out(0) <- [text(0)]Append["\n"]
|
|
1208 :||:
|
|
1209 out(0) <- Until End[[[text(0)]Append["\n"]]Append[line]]
|
|
1210 :|
|
|
1211 :|
|
|
1212
|
|
1213 _REPL(3,0)
|
|
1214 |:
|
|
1215 line <- Get Input[]
|
|
1216 If[[line] = ["Begin"]]
|
|
1217 |:
|
|
1218 text <- Until End[""]
|
|
1219 Null[text, params(0), New@Parse Program[], 0]
|
|
1220 |:
|
|
1221 define tree <- Process Imports[~, params(0)]
|
|
1222 Init Used Stores[define tree, stores(2)]
|
|
1223 |: _REPL[params(0), _Tree to Program[define tree, prog(1)], ~] :|
|
|
1224 :|
|
|
1225 :||:
|
|
1226 If[[line]Starts With[[params(0)]Import >>]]
|
|
1227 |:
|
|
1228 Parse Import[[line]Append["\n"], params(0), New@Parse Program[], 0]
|
|
1229 |:
|
|
1230 import tree <- Process Imports[~, params(0)]
|
|
1231 Init Used Stores[import tree, stores(2)]
|
|
1232 |: _REPL[params(0), _Tree to Program[import tree, prog(1)], ~] :|
|
|
1233 :|
|
|
1234 :||:
|
|
1235 trees <- Worker Body[[line]Append["}"], params(0), New@List[]]
|
|
1236 tree <- [New@Worker Node["Val", [New@List[]]Append[[trees]Index[0]]]]Assignments <<[{"__out"}]
|
|
1237 this stores <- [[tree]Gather Stores[params(0), New@Dictionary[]]]Keys
|
|
1238 next stores <- Fold["_Init Used Store", stores(2), this stores]
|
|
1239 |:
|
|
1240 pworker <- [[New@Parse Worker["__Eval", New@List[], {"__out"}, 0]]Trees <<[[New@List[]]Append[tree]]]Uses Stores <<[this stores]
|
|
1241 :|
|
|
1242 [[prog(1)]Find Worker["__Eval"]]Clear
|
|
1243 |: Add Contents[pworker, "__Eval", prog(1)]
|
|
1244 |: Pretty Print[[[[prog(1)]Find Worker["__Eval"]]Do[New@List[]]]Index[0], ""]
|
|
1245 |: _REPL[params(0), prog(1), next stores] :| :| :|
|
|
1246 :|
|
|
1247 :|
|
|
1248 :|
|
|
1249
|
|
1250 REPL(1,0)
|
|
1251 |:
|
|
1252 Print["Rhope Alpha 2\nCopyright 2008 by Michael Pavone\nEntering interactive mode\n"]
|
|
1253 prog <- Tree to Program[Null["Val[in:out]\n{\n out <- in\n}\n__Eval[:__out]\n{\n}\n", params(0), New@Parse Program[], 0]]
|
|
1254 _REPL[params(0), prog, New@Dictionary[]]
|
|
1255 :|
|
|
1256
|
|
1257 Add If Store(3,1)
|
|
1258 |:
|
|
1259 If[[name(1)]Contains[[params(2)]Global Separator >>]]
|
|
1260 |:
|
|
1261 parts <- [name(1)]Split[[params(2)]Global Separator >>]
|
|
1262 out(0) <- [stores(0)]Set[[parts]Index[0], Yes]
|
|
1263 :||:
|
|
1264 out(0) <- stores(0)
|
|
1265 :|
|
|
1266 :|
|
|
1267
|
|
1268 Param Gather Stores(3,1)
|
|
1269 |:
|
|
1270 out(0) <- [node(1)]Gather Stores[params(2), stores(0)]
|
|
1271 :|
|
|
1272
|
|
1273 Gather Stores@Named Pipe Node(3,1)
|
|
1274 |:
|
|
1275 out(0) <- Fold[["Add If Store"]Set Input[2, params(1)], stores(2), [node(0)]Assignments >>]
|
|
1276 :|
|
|
1277
|
|
1278 Gather Stores@Global Node(3,1)
|
|
1279 |:
|
|
1280 out(0) <- [stores(2)]Set[[node(0)]Store >>, Yes]
|
|
1281 :|
|
|
1282
|
|
1283 Gather Stores@Worker Node(3,1)
|
|
1284 |:
|
|
1285 //TODO: Handle blocks
|
|
1286 store list <- Fold[["Param Gather Stores"]Set Input[2, params(1)], stores(2), [node(0)]Params >>]
|
|
1287 out(0) <- Fold[["Add If Store"]Set Input[2, params(1)], store list, [node(0)]Assignments >>]
|
|
1288 :|
|
|
1289
|
|
1290 Gather Stores@Field Node(3,1)
|
|
1291 |:
|
|
1292 //TODO: Handle blocks
|
|
1293 store list <- Fold[["Param Gather Stores"]Set Input[2, params(1)], stores(2), [node(0)]Params >>]
|
|
1294 out(0) <- Fold[["Add If Store"]Set Input[2, params(1)], store list, [node(0)]Assignments >>]
|
|
1295 :|
|
|
1296
|
|
1297 Gather Stores@Literal Node(3,1)
|
|
1298 |:
|
|
1299 out(0) <- Fold[["Add If Store"]Set Input[2, params(1)], stores(2), [node(0)]Assignments >>]
|
|
1300 :|
|
|
1301
|
|
1302
|
|
1303 Main(1,0)
|
|
1304 |:
|
|
1305
|
|
1306 [args(0)]Index[1]
|
|
1307 |:
|
|
1308 file <- <String@File[~]
|
|
1309 ,text <- [file]Get FString[[file]Length]
|
|
1310 params <- New@Parser[]
|
|
1311 Null[text, params, New@Parse Program[], 0]
|
|
1312 |:
|
|
1313 tree <- Process Imports[~, params]
|
|
1314 Init Used Stores[tree, New@Dictionary[]]
|
|
1315 |: [Tree to Program[tree]]Run[[args(0)]Tail[1]] :|
|
|
1316 :|
|
|
1317 :||:
|
|
1318 REPL[New@Parser[]]
|
|
1319 :|
|
|
1320 :|
|