Mercurial > repos > rhope
annotate parser.vistxt @ 185:4580c08fd4e8
Fix an import missed in last commit
author | Mike Pavone <pavone@retrodev.com> |
---|---|
date | Wed, 27 Jul 2011 21:32:40 -0700 |
parents | 6202b866d72c |
children |
rev | line source |
---|---|
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"] | |
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
72 ]Escape Map <<[[[[Dictionary[]]Set["n","\n"]]Set["r","\r"]]Set["t","\t"]] |
0 | 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 |: | |
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
90 reflist <- List[] |
0 | 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"] | |
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
116 ]Workers <<[Dictionary[]] |
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
117 ]Imports <<[Dictionary[]] |
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
118 ]Blueprints <<[Dictionary[]] |
0 | 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 |: | |
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
144 out(0) <- [[[[[[Build["Parse Worker"]]Name <<[name(0)]]Inputs <<[inputs(1)]]Outputs <<[outputs(2)]]Line Number <<[line(3)]]Trees <<[List[]]]Uses Stores <<[List[]] |
0 | 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 |: | |
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
158 out(0) <- [[[[Build["Worker Node"]]Name <<[name(0)]]Params <<[params(1)]]Assignments <<[List[]]]Blocks <<[List[]] |
0 | 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 :||: | |
37
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
13
diff
changeset
|
228 Print[[[["Error: Could not find a worker named "]Append[[node(0)]Name >>]]Append[" in worker "]]Append[ [parse worker(3)]Name >> ]] |
0 | 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 |: | |
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
354 out(0) <- [[[[[Build["Field Node"]]Name <<[name(0)]]Assignments <<[List[]]]Blocks <<[List[]]]Set? <<[set(2)]]Params <<[params(1)] |
0 | 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 |: | |
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
408 out(0) <- [[[Build["Named Pipe Node"]]Name <<[name(0)]]Assignments <<[List[]]]Blocks <<[List[]] |
0 | 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 |: | |
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
481 out(0) <- [[[[Build["Global Node"]]Store <<[store(0)]]Name <<[name(1)]]Assignments <<[List[]]]Blocks <<[List[]] |
0 | 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 |: | |
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
519 out(0) <- [[[Build["Literal Node"]]Value <<[value(0)]]Assignments <<[List[]]]Blocks <<[List[]] |
0 | 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 |: | |
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
602 after, before <- [string(0)]Get DString[[[List[]]Append[begin comment(1)]]Append[end comment(2)]] |::| |::| |
0 | 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 | |
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
689 PBlueprint(4,1) |
0 | 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] | |
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
700 fields <- Fold[["Process Blueprint Field"]Set Input[2, [params(1)]Blueprint Type Delim >>], List[], Filter[Map[body lines, ["Trim"]Set Input[1,"\n\r\t "]], "Filter Empty"]] |
0 | 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] | |
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
733 trees, after block <- Worker Body[begin block, params(1), List[]] |
0 | 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 |: | |
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
765 delims <- [[List[]]Append[[params(1)]String End >>]]Append[[params(1)]String Escape >>] |
0 | 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] | |
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
842 value,after(1) <- Parse List[list start, params(1), List[]] |
0 | 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 >>] | |
1
b3f71490858c
Small fixes and enhancements from main windows box
Mike Pavone <pavone@retrodev.com>
parents:
0
diff
changeset
|
849 afterdelim,raw before,delim <- [name]Get Comment DString[delims, params(1)] |
0 | 850 |: |
851 after(1) <- [delim]Append[~] | |
852 :| |::| |::| |: | |
853 after(1) <- "" | |
854 :| | |
1
b3f71490858c
Small fixes and enhancements from main windows box
Mike Pavone <pavone@retrodev.com>
parents:
0
diff
changeset
|
855 before <- Trim[raw before, "\r\n\t "] |
0 | 856 If[[before] = ["Yes"]] |
857 |: | |
858 yesno <- Yes | |
859 :||: | |
860 If[[before] = ["No"]] | |
861 |: | |
862 yesno <- No | |
863 :||: | |
864 If[[before] = [""]] | |
865 |: | |
866 Print[[["Found "]Append[delim]]Append[" where a named pipe or literal was expected"]] | |
13 | 867 |: Print[["Near: "]Append[ [afterdelim]Slice[40]]] :| |
0 | 868 :||: |
869 If[[before]Contains[[params(1)]Global Separator >>]] | |
870 |: | |
871 parts <- [before]Split[[params(1)]Global Separator >>] | |
872 out(0) <- New@Global Node[Right Trim[[parts]Index[0],"\r\n\t "], Trim[[parts]Index[1], "\r\n\t "]] | |
873 :||: | |
874 out(0) <- New@Named Pipe Node[Right Trim[before,"\r\n\t "]] | |
875 :| | |
876 :| | |
877 :| | |
878 :| | |
879 out(0) <- New@Literal Node[yesno] | |
880 :| | |
881 :| | |
882 :| | |
883 out(0) <- New@Literal Node[value] | |
884 :| | |
885 | |
886 Parse Arguments(3,2) | |
887 |: | |
888 args <- Comment Left Trim[string(0), "\r\n\t ", params(1)] | |
889 If[[args]Starts With[[params(1)]List Delim >>]] | |
890 |: | |
891 [args]Slice[[[params(1)]List Delim >>]Length] |::| | |
892 |: | |
893 final args <- Comment Left Trim[~, "\r\n\t ", params(1)] | |
894 :| | |
895 :||: | |
896 If[[args]Starts With[[params(1)]Arg End >>]] | |
897 |: | |
898 args(0) <- arglist(2) | |
899 ,after(1) <- [args]Slice[[[params(1)]Arg End >>]Length] | |
900 :||: | |
901 final args <- Val[args] | |
902 :| | |
903 :| | |
904 arg, after arg <- Parse Expression[final args, params(1)] | |
905 args(0), after(1) <- Parse Arguments[after arg, params(1), [arglist(2)]Append[arg]] | |
906 :| | |
907 | |
908 Worker or Field(3,1) | |
909 |: | |
910 get field <- [params(2)]Get Field >> | |
911 If[[name(0)]Ends With[get field]] | |
912 |: | |
913 field <- Right Trim[[name(0)]Slice[[[name(0)]Length] - [[get field]Length]], "\n\r\t "] | |
914 out(0) <- New@Field Node[field, args(1), No] | |
915 :||: | |
916 set field <- [params(2)]Set Field >> | |
917 If[[name(0)]Ends With[set field]] | |
918 |: | |
919 field <- Right Trim[[name(0)]Slice[[[name(0)]Length] - [[set field]Length]], "\n\r\t "] | |
920 out(0) <- New@Field Node[field, args(1), Yes] | |
921 :||: | |
922 out(0) <- New@Worker Node[name(0), args(1)] | |
923 :| | |
924 :| | |
925 :| | |
926 | |
927 Prefix(4,2) | |
928 |: | |
929 //Parse argument list | |
930 more args,after(1) <- Parse Arguments[string(0), params(1), existing args(3)] | |
931 expression(0) <- Worker or Field[name(2), more args, params(1)] | |
932 :| | |
933 | |
934 Postfix or Infix(2,2) | |
935 |: | |
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
936 args, after args <- Parse Arguments[string(0), params(1), List[]] |
0 | 937 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 >>] |
938 after,before,delim <- [after args]Get Comment DString[delims, params(1)] | |
939 |: | |
940 If[[delim] = [[params(1)]Arg Begin >>]] | |
941 |: | |
942 expression(0), after(1) <- Prefix[after, params(1), Trim[before,"\r\n\t "], args] | |
943 :||: | |
944 If[[delim] = [[params(1)]Empty Block >>]] | |
945 |: | |
946 after expression(1) <- Val[after] | |
947 :||: | |
948 ,after expression(1) <- [after args]Slice[[before]Length] | |
949 :| | |
950 expression(0) <- Worker or Field[Trim[before,"\r\n\t "], args, params(1)] | |
951 :| | |
952 :| | |
953 :| | |
954 | |
955 Parse Expression(2,2) | |
956 |: | |
957 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 >>] | |
958 after, before, delim <- [trimmed(0)]Get Comment DString[delims, params(1)] | |
959 |: | |
960 //If we find an arg begin token, we have a worker expression | |
961 If[[delim] = [[params(1)]Arg Begin >>]] | |
962 |: | |
963 maybe name <- Right Trim[before, "\r\t "] | |
964 //Prefix expressions will have the worker name before the first arg begin token | |
965 If[[maybe name] = [""]] | |
966 |: | |
967 expression, after expression <- Postfix or Infix[after, params(1)] | |
968 :||: | |
969 If[[maybe name]Contains[[params(1)]List Delim >>]] | |
970 |: | |
971 after expression <- [after literal]Append[[delim]Append[after]] | |
972 expression, after literal <- Named Pipe or Literal[Right Trim[before, "\r\n\t "], params(1)] | |
973 :||: | |
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
974 expression, after expression <- Prefix[after, params(1), maybe name, List[]] |
0 | 975 :| |
976 :| | |
977 :||: | |
978 If[[delim] = [[params(1)]Assign >>]] | |
979 |: | |
980 //Expressions starting with an assignment can be prefix, postfix or infix | |
981 //or they can be a simple literal or named pipe | |
982 assignments <- Map[[before]Split[[params(1)]List Delim >>], ["Trim"]Set Input[1,"\n\r\t "]] | |
983 ,after blocks(1) <- Parse Expression[Comment Left Trim[after, " \n\r\t", params(1)], params(1)] | |
984 |: | |
985 final expression(0) <- [~]Assignments <<[assignments] | |
986 :| | |
987 :||: | |
988 //If[[delim] = [[params(1)]String Begin >>]] | |
989 //|: | |
990 // If[[Trim[before, "\r\n\t "]] = [""]] | |
991 // |: | |
992 // expression, after expression <- Named Pipe or Literal[[delim]Append[after], params(1)] | |
993 // :||: | |
994 // after expression <- [after literal]Append[[delim]Append[after]] | |
995 // expression, after literal <- Named Pipe or Literal[Right Trim[before, "\r\n\t "], params(1)] | |
996 // :| | |
997 //:||: | |
998 // after expression <- [after literal]Append[[delim]Append[after]] | |
999 // expression, after literal <- Named Pipe or Literal[Right Trim[before, "\r\n\t "], params(1)] | |
1000 //:| | |
1001 expression, after expression <- Named Pipe or Literal[trimmed(0), params(1)] | |
1002 :| | |
1003 :| | |
1004 //Any expression can be followed by one or more blocks mapping the inputs of other expressions | |
1005 //to the outputs of the current one | |
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1006 blocks,after blocks(1) <- Get Expression Blocks[after expression, params(1), List[]] |
0 | 1007 final expression(0) <- [expression]Blocks <<[blocks] |
1008 :| | |
1009 :| | |
1010 | |
1011 Worker Body(3,2) | |
1012 |: | |
1013 trimmed <- Comment Left Trim[string(0), "\n\r\t ", params(1)] | |
1014 If[[trimmed]Starts With[[params(1)]Block End >>]] | |
1015 |: | |
1016 //We're done with this block, return | |
1017 ,after end(1) <- [trimmed]Slice[[[params(1)]Block End >>]Length] | |
1018 trees(0) <- trees(2) | |
1019 :||: | |
1020 expression, after expression <- Parse Expression[trimmed, params(1)] | |
1021 trees(0),after end(1) <- Worker Body[after expression, params(1), [trees(2)]Append[expression]] | |
1022 :| | |
1023 :| | |
1024 | |
1025 Process Modifiers(3,1) | |
1026 |: | |
1027 //Eventually this will need to be more sophisticated to handle more modifiers | |
1028 trimmed <- Comment Left Trim[modifiers(2), "\n\r\t ", params(1)] | |
1029 If[[trimmed]Starts With[[params(1)]Uses >>]] | |
1030 |: | |
1031 ,after uses <- [trimmed]Slice[[[params(1)]Uses >>]Length] | |
1032 ,stores string <- [after uses]Get Comment DString["\n", params(1)] | |
1033 out(0) <- [worker(0)]Uses Stores <<[Map[[stores string]Split[[params(1)]List Delim >>], ["Trim"]Set Input[1, "\r\n\t "]]] | |
1034 :||: | |
1035 out(0) <- worker(0) | |
1036 :| | |
1037 :| | |
1038 | |
1039 Worker Name(4,1) | |
1040 |: | |
1041 ,whitespace name <- [string(0)]Get Comment DString[[params(1)]Arg Begin >>, params(1)] | |
1042 |: | |
1043 worker name <- Trim[whitespace name, "\n\r\t "] | |
1044 in out <- [params(1)]In Out Delim >> | |
1045 arg end <- [params(1)]Arg End >> | |
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1046 delims <- [[List[]]Append[in out]]Append[arg end] |
0 | 1047 after <- [~]Get Comment DString[delims, params(1)] |::| |
1048 |: | |
1049 arglist <- Trim[~,"\r\n\t "] | |
1050 :||: | |
1051 //check if there is an in/out separator | |
1052 //if it isn't present, everything in the arglist is an input | |
1053 If[[~] = [in out]] | |
1054 |: | |
1055 after arglist <- [after]Get Comment DString[arg end, params(1)] |::| | |
1056 |: | |
1057 output string <- Trim[~,"\n\r\t "] | |
1058 :| | |
1059 :||: | |
1060 after arglist <- Val[after] | |
1061 output string <- "" | |
1062 :| | |
1063 inputs <- Map[[arglist]Split[[params(1)]List Delim >>], ["Trim"]Set Input[1,"\n\r\t "]] | |
1064 outputs <- Map[[output string]Split[[params(1)]List Delim >>], ["Trim"]Set Input[1,"\n\r\t "]] | |
1065 | |
1066 New@Parse Worker[worker name, inputs, outputs, 0] | |
1067 |: | |
1068 body text, modifiers <- [after arglist]Get Comment DString[[params(1)]Block Begin >>, params(1)] | |
1069 modified <- Process Modifiers[~, params(1), modifiers] | |
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1070 expression trees, after body <- Worker Body[body text, params(1), List[]] |
0 | 1071 worker <- [modified]Trees <<[expression trees] |
1072 new worker dict <- [[tree(2)]Workers >>]Set[worker name, worker] | |
1073 out(0) <- Null[after body, params(1), [tree(2)]Workers <<[new worker dict], 0] | |
1074 :| | |
1075 :| | |
1076 :||::||::||: | |
1077 out(0) <- tree(2) | |
1078 :| | |
1079 :| | |
1080 | |
1081 Null(4,1) | |
1082 |: | |
1083 trimmed <- Comment Left Trim[string(0), " \n\r\t", params(1)] | |
1084 current line <- 0//[lines(3)] + [Count Substring[whitespace, "\n"]] | |
1085 If[[trimmed]Starts With[ [params(1)]Blueprint >> ]] | |
1086 |: | |
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1087 out(0) <- PBlueprint[trimmed, params(1), tree(2), current line] |
0 | 1088 :||: |
1089 If[[trimmed]Starts With[ [params(1)]Import >> ]] | |
1090 |: | |
1091 out(0) <- Parse Import[trimmed, params(1), tree(2), current line] | |
1092 :||: | |
1093 out(0) <- Worker Name[trimmed, params(1), tree(2), current line] | |
1094 :| | |
1095 :| | |
1096 :| | |
1097 | |
1098 Add Workers(3,1) | |
1099 |: | |
1100 prog,worker <- [program(2)]New Worker[name(1)] | |
1101 [worker]Set IO Counts[ [[[worker(0)]Index[name(1)]]Inputs >>]Length, [[[worker(0)]Index[name(1)]]Outputs >>]Length] | |
1102 [workers(0)]Next[name(1)] | |
1103 |: | |
1104 out(0) <- Add Workers[workers(0), ~, prog] | |
1105 :||: | |
1106 out(0) <- Val[prog] | |
1107 :| | |
1108 :| | |
1109 | |
1110 Add Wires Helper(5,1) | |
1111 |: | |
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1112 worker(0) <- [node(1)]Add Wires[worker(0), List[], parse worker(3), assignments(4)] |
0 | 1113 :| |
1114 | |
1115 Add Contents(3,2) | |
1116 |: | |
1117 worker <- [[program(2)]Find Worker[name(1)]]Uses[[parse worker(0)]Uses Stores >>] | |
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1118 trees, contents worker, refs <- Add List to Worker[[parse worker(0)]Trees >>, worker, program(2), parse worker(0), Dictionary[]] |
0 | 1119 Fold[[["Add Wires Helper"]Set Input[3, parse worker(0)]]Set Input[4, refs], contents worker, trees] |
1120 out(0) <- [parse worker(0)]Trees <<[trees] | |
1121 key(1) <- name(1) | |
1122 :| | |
1123 | |
1124 Add Blueprint Field(3,1) | |
1125 |: | |
1126 out(0) <- [blueprint(0)]Add Field[[field(1)]Name >>, [field(1)]Type >>] | |
1127 :| | |
1128 | |
1129 Add Blueprint(2,1) | |
1130 |: | |
1131 out(0) <- [prog(0)]New Blueprint[[def(1)]Name >>] |::| | |
1132 |: | |
1133 Fold["Add Blueprint Field", ~, [def(1)]Fields >>] | |
1134 :| | |
1135 :| | |
1136 | |
1137 _Tree to Program(2,1) | |
1138 |: | |
1139 after blueprint <- Fold["Add Blueprint", program(1), [parse tree(0)]Blueprints >>] | |
1140 [[parse tree(0)]Workers >>]First | |
1141 |: | |
1142 prog <- Add Workers[[parse tree(0)]Workers >>, ~, after blueprint] | |
1143 :| | |
1144 Key Value Map[[parse tree(0)]Workers >>, ["Add Contents"]Set Input[2, prog]] | |
1145 out(0) <- prog | |
1146 :| | |
1147 | |
1148 Tree to Program(1,1) | |
1149 |: | |
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1150 out(0) <- _Tree to Program[parse tree(0), [Program[]]Add Builtins] |
0 | 1151 :| |
1152 | |
1153 Needs Imports(3,1) | |
1154 |: | |
1155 If[not imported?(1)] | |
1156 |: | |
1157 out(0) <- [needs import(0)]Append[name(2)] | |
1158 :||: | |
1159 out(0) <- needs import(0) | |
1160 :| | |
1161 :| | |
1162 | |
1163 Do Import(4,1) | |
1164 |: | |
1165 file <- <String@File[file name(1)] | |
1166 ,text <- [file]Get FString[[file]Length] | |
1167 after import <- Null[text, params(3), tree(0), 0] | |
1168 out(0) <- [after import]Imports <<[ [[after import]Imports >>]Set[file name(1), No] ] | |
1169 :| | |
1170 | |
1171 Process Imports(2,1) | |
1172 |: | |
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1173 needs import <- Fold["Needs Imports", List[], [parse tree(0)]Imports >>] |
0 | 1174 If[[[needs import]Length] > [0]] |
1175 |: | |
1176 import tree <- Fold[["Do Import"]Set Input[3, params(1)], parse tree(0), needs import] | |
1177 out(0) <- Process Imports[import tree, params(1)] | |
1178 :||: | |
1179 out(0) <- parse tree(0) | |
1180 :| | |
1181 :| | |
1182 | |
1183 _Init Used Store(2,1) | |
1184 |: | |
1185 [dict(0)]Index[store name(1)] | |
1186 |: | |
1187 out(0) <- dict(0) | |
1188 :||: | |
1189 Init Store[store name(1)] | |
1190 out(0) <- [dict(0)]Set[store name(1), Yes] | |
1191 :| | |
1192 :| | |
1193 | |
1194 _Init Used Stores(2,1) | |
1195 |: | |
1196 out(0) <- Fold["_Init Used Store", dict(0), [worker(1)]Uses Stores >>] | |
1197 :| | |
1198 | |
1199 Init Used Stores(1,1) | |
1200 |: | |
1201 out(0) <- Fold["_Init Used Stores", existing stores(1), [parse tree(0)]Workers >>] | |
1202 :| | |
1203 | |
1204 Until End(1,1) | |
1205 |: | |
1206 line <- Get Input[] | |
1207 If[[line] = ["End"]] | |
1208 |: | |
1209 out(0) <- [text(0)]Append["\n"] | |
1210 :||: | |
1211 out(0) <- Until End[[[text(0)]Append["\n"]]Append[line]] | |
1212 :| | |
1213 :| | |
1214 | |
1215 _REPL(3,0) | |
1216 |: | |
1217 line <- Get Input[] | |
1218 If[[line] = ["Begin"]] | |
1219 |: | |
1220 text <- Until End[""] | |
1221 Null[text, params(0), New@Parse Program[], 0] | |
1222 |: | |
1223 define tree <- Process Imports[~, params(0)] | |
1224 Init Used Stores[define tree, stores(2)] | |
1225 |: _REPL[params(0), _Tree to Program[define tree, prog(1)], ~] :| | |
1226 :| | |
1227 :||: | |
1228 If[[line]Starts With[[params(0)]Import >>]] | |
1229 |: | |
1230 Parse Import[[line]Append["\n"], params(0), New@Parse Program[], 0] | |
1231 |: | |
1232 import tree <- Process Imports[~, params(0)] | |
1233 Init Used Stores[import tree, stores(2)] | |
1234 |: _REPL[params(0), _Tree to Program[import tree, prog(1)], ~] :| | |
1235 :| | |
1236 :||: | |
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1237 trees <- Worker Body[[line]Append["}"], params(0), List[]] |
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1238 tree <- [New@Worker Node["Val", [List[]]Append[[trees]Index[0]]]]Assignments <<[{"__out"}] |
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1239 this stores <- [[tree]Gather Stores[params(0), Dictionary[]]]Keys |
0 | 1240 next stores <- Fold["_Init Used Store", stores(2), this stores] |
1241 |: | |
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1242 pworker <- [[New@Parse Worker["__Eval", List[], {"__out"}, 0]]Trees <<[[List[]]Append[tree]]]Uses Stores <<[this stores] |
0 | 1243 :| |
1244 [[prog(1)]Find Worker["__Eval"]]Clear | |
1245 |: Add Contents[pworker, "__Eval", prog(1)] | |
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1246 |: Pretty Print[[[[prog(1)]Find Worker["__Eval"]]Do[List[]]]Index[0], ""] |
0 | 1247 |: _REPL[params(0), prog(1), next stores] :| :| :| |
1248 :| | |
1249 :| | |
1250 :| | |
1251 | |
1252 REPL(1,0) | |
1253 |: | |
1254 Print["Rhope Alpha 2\nCopyright 2008 by Michael Pavone\nEntering interactive mode\n"] | |
1255 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]] | |
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1256 _REPL[params(0), prog, Dictionary[]] |
0 | 1257 :| |
1258 | |
1259 Add If Store(3,1) | |
1260 |: | |
1261 If[[name(1)]Contains[[params(2)]Global Separator >>]] | |
1262 |: | |
1263 parts <- [name(1)]Split[[params(2)]Global Separator >>] | |
1264 out(0) <- [stores(0)]Set[[parts]Index[0], Yes] | |
1265 :||: | |
1266 out(0) <- stores(0) | |
1267 :| | |
1268 :| | |
1269 | |
1270 Param Gather Stores(3,1) | |
1271 |: | |
1272 out(0) <- [node(1)]Gather Stores[params(2), stores(0)] | |
1273 :| | |
1274 | |
1275 Gather Stores@Named Pipe Node(3,1) | |
1276 |: | |
1277 out(0) <- Fold[["Add If Store"]Set Input[2, params(1)], stores(2), [node(0)]Assignments >>] | |
1278 :| | |
1279 | |
1280 Gather Stores@Global Node(3,1) | |
1281 |: | |
1282 out(0) <- [stores(2)]Set[[node(0)]Store >>, Yes] | |
1283 :| | |
1284 | |
1285 Gather Stores@Worker Node(3,1) | |
1286 |: | |
1287 //TODO: Handle blocks | |
1288 store list <- Fold[["Param Gather Stores"]Set Input[2, params(1)], stores(2), [node(0)]Params >>] | |
1289 out(0) <- Fold[["Add If Store"]Set Input[2, params(1)], store list, [node(0)]Assignments >>] | |
1290 :| | |
1291 | |
1292 Gather Stores@Field Node(3,1) | |
1293 |: | |
1294 //TODO: Handle blocks | |
1295 store list <- Fold[["Param Gather Stores"]Set Input[2, params(1)], stores(2), [node(0)]Params >>] | |
1296 out(0) <- Fold[["Add If Store"]Set Input[2, params(1)], store list, [node(0)]Assignments >>] | |
1297 :| | |
1298 | |
1299 Gather Stores@Literal Node(3,1) | |
1300 |: | |
1301 out(0) <- Fold[["Add If Store"]Set Input[2, params(1)], stores(2), [node(0)]Assignments >>] | |
1302 :| | |
1303 | |
1304 | |
1305 Main(1,0) | |
1306 |: | |
1307 | |
1308 [args(0)]Index[1] | |
1309 |: | |
1310 file <- <String@File[~] | |
1311 ,text <- [file]Get FString[[file]Length] | |
1312 params <- New@Parser[] | |
1313 Null[text, params, New@Parse Program[], 0] | |
1314 |: | |
1315 tree <- Process Imports[~, params] | |
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1316 Init Used Stores[tree, Dictionary[]] |
0 | 1317 |: [Tree to Program[tree]]Run[[args(0)]Tail[1]] :| |
1318 :| | |
1319 :||: | |
1320 REPL[New@Parser[]] | |
1321 :| | |
1322 :| |