Mercurial > repos > rhope

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