Mercurial > repos > rhope

annotate parser_old.rhope @ 134:386f4a874821

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
More work on new parser
author Mike Pavone <pavone@retrodev.com>
date Wed, 10 Nov 2010 22:29:49 -0500
parents 04148770c229
children
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1 Import nworker.rhope
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3 Blueprint Parser
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
4 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
5 Arg Begin
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
6 Arg End
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
7 Line Comment
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
8 Comment Begin
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
9 Comment End
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
10 Assign
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
11 Block Begin
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
12 Block End
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
13 Blueprint Type Delim
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
14 Empty Block
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
15 Binary Operator
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
16 String Begin
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
17 String End
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
18 String Escape
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
19 List Begin
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
20 List End
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
21 List Delim
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
22 In Out Delim
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
23 Do Worker
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
24 Index Begin
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
25 Index End
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
26 Previous
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
27 Block Val
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
28 Set Field
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
29 Get Field
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
30 Import
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
31 Blueprint
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
32 Global Separator
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
33 Uses
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
34 Hex Escape
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
35 Escape Map
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
36 Foreign
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
37 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
38
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
39 New@Parser[:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
40 {
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
41 out <- [[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[Build["Parser"]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
42 ]Arg Begin << ["["]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
43 ]Arg End <<["]"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
44 ]Line Comment <<["//"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
45 ]Comment Begin <<["/*"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
46 ]Comment End <<["*/"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
47 ]Assign <<["<-"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
48 ]Block Begin <<["{"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
49 ]Block End <<["}"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
50 ]Blueprint Type Delim <<[":"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
51 ]Empty Block <<[";"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
52 ]Binary Operator <<["`"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
53 ]String Begin <<["\""]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
54 ]String End <<["\""]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
55 ]String Escape <<["\\"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
56 ]List Begin <<["("]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
57 ]List End <<[")"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
58 ]List Delim <<[","]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
59 ]In Out Delim <<[":"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
60 ]Do Worker <<["$"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
61 ]Index Begin <<["("]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
62 ]Index End <<[")"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
63 ]Previous <<["@"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
64 ]Set Field <<["<<"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
65 ]Get Field <<[">>"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
66 ]Import <<["Import"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
67 ]Blueprint <<["Blueprint"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
68 ]Global Separator <<["::"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
69 ]Hex Escape <<["x"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
70 ]Uses <<["uses"]
48
a24eb366195c Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents: 42
diff changeset
71 ]Escape Map <<[[[[Dictionary[]]Set["n","\n"]]Set["r","\r"]]Set["t","\t"]]
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
72 ]Foreign <<["Foreign"]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
73 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
74
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
75 Blueprint Output Reference
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
76 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
77 Index
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
78 Output Number
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
79 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
80
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
81 New@Output Reference[index,num:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
82 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
83 out <- [[Build["Output Reference"]]Index <<[index]]Output Number <<[num]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
84 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
85
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
86 Add Pipe Reference[refs,name,reference:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
87 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
88 reflist <- [refs]Index[name] {}
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
89 {
48
a24eb366195c Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents: 42
diff changeset
90 reflist <- ()
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
91 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
92 out <- [refs]Set[name, [reflist]Append[reference]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
93 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
94
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
95 Assignment Save Reference[refs,assignment,output num,parse worker,index:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
96 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
97 [[parse worker]Outputs >>]Find[assignment]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
98 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
99 out <- refs
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
100 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
101 out <- Add Pipe Reference[refs, assignment, New@Output Reference[index, output num]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
102 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
103 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
104
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
105 Blueprint Foreign Lib
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
106 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
107 Language
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
108 Name
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
109 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
110
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
111 New Foreign Lib[language, library:out]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
112 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
113 out <- [[Build["Foreign Lib"]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
114 ]Language <<[language]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
115 ]Name <<[library]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
116 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
117
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
118 Blueprint Parse Program
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
119 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
120 Workers
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
121 Imports
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
122 Blueprints
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
123 Errors
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
124 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
125
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
126 New@Parse Program[:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
127 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
128 out <- [[[Build["Parse Program"]
48
a24eb366195c Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents: 42
diff changeset
129 ]Workers <<[Dictionary[]]
75
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
130 ]Imports <<[[Dictionary[]]Set["kernel.rhope", Yes]]
48
a24eb366195c Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents: 42
diff changeset
131 ]Blueprints <<[Dictionary[]]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
132 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
133
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
134 Blueprint Blueprint Definition
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
135 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
136 Name
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
137 Fields
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
138 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
139
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
140 New@Blueprint Definition[name,fields:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
141 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
142 out <- [[Build["Blueprint Definition"]]Name << [name]]Fields <<[fields]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
143 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
144
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
145 Blueprint Parse Worker
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
146 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
147 Name
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
148 Inputs
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
149 Outputs
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
150 Line Number
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
151 Trees
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
152 Uses Stores
37
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
153 Input Types
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
154 Output Types
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
155 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
156
37
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
157 New@Parse Worker[name,inputs,outputs,intypes,outtypes,line:out]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
158 {
48
a24eb366195c Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents: 42
diff changeset
159 out <- [[[[[[[[Build["Parse Worker"]]Name <<[name]]Inputs <<[inputs]]Outputs <<[outputs]]Line Number <<[line]]Trees <<[()]]Uses Stores <<[()]]Input Types <<[intypes]]Output Types <<[outtypes]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
160 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
161
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
162 Blueprint Worker Node
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
163 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
164 Name
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
165 Params
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
166 Assignments
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
167 Blocks
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
168 Index
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
169 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
170
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
171 New@Worker Node[name,params:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
172 {
48
a24eb366195c Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents: 42
diff changeset
173 out <- [[[[Build["Worker Node"]]Name <<[name]]Params <<[params]]Assignments <<[()]]Blocks <<[()]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
174 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
175
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
176 Add List Helper[inlist,worker,program,key,parse worker,refs:out list,out worker,out refs]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
177 {
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
178 ,nextworker,nextrefs <- [[inlist]Index[key]]Add to Worker[worker, program, parse worker, refs]
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
179 { nextlist <- [inlist]Set[key, ~] }
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
180 [inlist]Next[key]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
181 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
182 out list,out worker,out refs <- Add List Helper[nextlist, nextworker, program, ~, parse worker, nextrefs]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
183 }{
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
184 out list <- Val[nextlist]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
185 out worker <- Val[nextworker]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
186 out refs <- Val[nextrefs]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
187 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
188 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
189
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
190 Add List to Worker[list,worker,program,parse worker,refs:out list,out worker,out refs]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
191 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
192 [list]First
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
193 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
194 out list,out worker,out refs <- Add List Helper[list, worker, program, ~, parse worker, refs]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
195 }{
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
196 out list <- list
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
197 out worker <- worker
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
198 out refs <- refs
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
199 }
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
200 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
201
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
202 _Add Blocks to Worker[blocks,worker,program,parse worker,key,refs:out blocks,out worker,out refs]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
203 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
204 block, next worker, nextrefs <- Add List to Worker[[blocks]Index[key], worker, program, parse worker, refs]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
205 next blocks <- [blocks]Set[key, block]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
206 [blocks]Next[key]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
207 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
208 out blocks,out worker,out refs <- _Add Blocks to Worker[next blocks, next worker, program, parse worker, ~, nextrefs]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
209 }{
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
210 out blocks <- Val[next blocks]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
211 out worker <- Val[next worker]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
212 out refs <- Val[nextrefs]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
213 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
214 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
215
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
216 Add Blocks to Worker[blocks,worker,program,parse worker,refs:out blocks,out worker,out refs]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
217 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
218 [blocks]First
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
219 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
220 out blocks, out worker, out refs <- _Add Blocks to Worker[blocks, worker, program, parse worker, ~, refs]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
221 }{
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
222 out blocks <- blocks
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
223 out worker <- worker
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
224 out refs <- refs
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
225 }
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
226 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
227
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
228 Add to Worker@Worker Node[node,worker,program,parse worker,refs:out node,out worker,out refs]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
229 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
230 [program]Find Worker[[node]Name >>]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
231 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
232 after worker <- [worker]Add Worker Call[~] {}
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
233 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
234 //Print[[[[node]Name >>]Append[" has index "]]Append[~]]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
235 assignment refs <- Fold[[["Assignment Save Reference"]Set Input[3, parse worker]]Set Input[4, ~], refs, [node]Assignments >>]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
236 [node]Index <<[~]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
237 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
238 params list, params worker, params refs <- Add List to Worker[[~]Params >>, after worker, program, parse worker, assignment refs]
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
239 block list, out worker, out refs <- Add Blocks to Worker[[~]Blocks >>, params worker, program, parse worker, params refs]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
240 out node <- [[~]Params <<[params list]]Blocks <<[block list]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
241 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
242 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
243 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
244 Print[["Error: Could not find a worker named "]Append[[node]Name >>]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
245 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
246 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
247
74
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
248 Check Question Mark[params, index:has mark,no mark]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
249 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
250 param,no mark <-[params]Index[index]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
251 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
252 If[[Type Of[param]]=["Named Pipe Node"]]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
253 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
254 has mark <-If[[[param]Name >>] = ["?"]] {}
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
255 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
256 has mark,no mark <- Check Question Mark[params, [index]+[1]]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
257 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
258 }{
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
259 has mark,no mark <- Check Question Mark[params, [index]+[1]]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
260 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
261 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
262 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
263
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
264 Collect Literal Inputs[literal, params, index, complex inputs:literal out,complex out]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
265 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
266 param <- [params]Index[index]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
267 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
268 If[[Type Of[param]]=["Literal Node"]]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
269 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
270 next literal <- [literal]Set Input[index, [param]Value >>]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
271 next complex <- Val[complex inputs]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
272 }{
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
273 ,doset <- If[[Type Of[param]]=["Named Pipe Node"]]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
274 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
275 ,doset <- If[[[param]Name >>] = ["?"]]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
276 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
277 //Question mark indicates unpopulated input
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
278 next complex <- Val[complex inputs]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
279 next literal <- Val[literal]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
280 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
281 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
282
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
283 Val[doset]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
284 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
285 next complex <- [complex inputs]Set[index, param]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
286 next literal <- Val[literal]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
287 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
288 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
289 literal out, complex out <- Collect Literal Inputs[next literal, params, [index]+[1], next complex]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
290 }{
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
291 literal out <- literal
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
292 complex out <- complex inputs
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
293 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
294 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
295
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
296 Do Set Input[literal,param,index:out]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
297 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
298 out <- New@Worker Node["Set Input", [[[()]Append[literal]]Append[New@Literal Node[index]]]Append[param]]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
299 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
300
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
301 Check Worker Literals@Worker Node[node,program:out]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
302 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
303 new params <- Map[[node]Params >>, ["Check Worker Literals"]Set Input[1, program]]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
304 Check Question Mark[new params, 0]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
305 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
306 base literal, complex inputs <- Collect Literal Inputs[Worker Literal[[node]Name >>], new params, 0, ()]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
307 new node <- Fold["Do Set Input", New@Literal Node[base literal], complex inputs]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
308 }{
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
309 new node <- [node]Params <<[new params]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
310 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
311 out <- [new node]Blocks <<[ Map[[node]Blocks >>, ["Map"]Set Input[1, ["Check Worker Literals"]Set Input[1, program]]] ]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
312 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
313
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
314 Add Multi Wire[worker,ref,junk,end index,input num:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
315 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
316 out <- [worker]Add Wire[[ref]Index >>, [ref]Output Number >>, end index, input num]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
317 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
318
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
319 Add Param Wire[worker,param,input num,end index,blocks,parse worker,assignments:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
320 {
83
27bb051d631c Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents: 82
diff changeset
321 param worker, start index, output num <- [param]Add Wires[worker, blocks, parse worker, assignments] {}
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
322 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
323 out <- [param worker]Add Wire[start index, output num, end index, input num]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
324 }{}{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
325 out <- Fold[[["Add Multi Wire"]Set Input[3, end index]]Set Input[4, input num], param worker, ~]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
326 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
327 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
328
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
329 _Add Block Wire[worker,node,junk,blocks,parse worker,assignments:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
330 {
69
d0ce696786cc Clean up debug print statements a bit. Fix bug that prevented workers that took no inputs from working. Remove workaround in Array for said bug.
Mike Pavone <pavone@retrodev.com>
parents: 52
diff changeset
331 out <- [node]Add Wires[worker, blocks, parse worker, assignments]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
332 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
333
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
334 Add Block Wire[worker,block nodes,output num,parent index,existing blocks,parse worker,assignments:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
335 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
336 blocks <- [existing blocks]Append[New@Output Reference[parent index, output num]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
337 out <- Fold[[[["_Add Block Wire"]Set Input[3, blocks]]Set Input[4, parse worker]]Set Input[5, assignments], worker, block nodes]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
338 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
339
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
340 Assignments Add Wires[worker,assignment,output num,parse worker,start index:out worker]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
341 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
342 [[parse worker]Outputs >>]Find[assignment]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
343 {
37
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
344 ,output index <- [worker]Add Typed Output[assignment, ~, [[parse worker]Output Types >>]Index[~]]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
345 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
346 out worker <- [~]Add Wire[start index, output num, output index, 0]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
347 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
348 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
349 //Ugly hack alert!
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
350 If[[assignment]Contains["::"]]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
351 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
352 parts <- [assignment]Split["::"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
353 ,global index <- [worker]Add Global Set[[parts]Index[0], [parts]Index[1]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
354 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
355 out worker <- [~]Add Wire[start index, output num, global index, 0]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
356 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
357 }{
69
d0ce696786cc Clean up debug print statements a bit. Fix bug that prevented workers that took no inputs from working. Remove workaround in Array for said bug.
Mike Pavone <pavone@retrodev.com>
parents: 52
diff changeset
358 out worker <- worker
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
359 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
360 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
361 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
362
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
363 Has Block@Worker Node[junk:out,unused]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
364 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
365 out <- Yes
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
366 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
367
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
368 _Has Block Params[param list,key:out]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
369 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
370 param <- [param list]Index[key]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
371 out <- [param]Has Block {}
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
372 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
373 [param list]Next[key]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
374 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
375 out <- _Has Block Params[param list, ~]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
376 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
377 out <- No
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
378 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
379 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
380
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
381 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
382
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
383 Has Block Params[param list:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
384 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
385 [param list]First
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
386 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
387 out <- _Has Block Params[param list, ~]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
388 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
389 out <- No
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
390 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
391 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
392
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
393 Add Wires@Worker Node[node,worker,blocks,parse worker,assignments:worker,index,num,unused]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
394 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
395 worker,index,num <- Add Wires Worker or Field[node, worker, blocks, parse worker, assignments]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
396 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
397
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
398 Add Wires Worker or Field[node,worker,blocks,parse worker,assignments:worker,index,num,unused]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
399 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
400 Fold[[["Assignments Add Wires"]Set Input[3, parse worker]]Set Input[4, [node]Index >>], worker, [node]Assignments >>]
74
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
401 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
402 Fold[[[[["Add Block Wire"]Set Input[3, [node]Index >>]]Set Input[4, blocks]]Set Input[5, parse worker]]Set Input[6, assignments], ~, [node]Blocks >>]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
403 {
74
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
404 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 >>]
82
2e2e55fc12f9 Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents: 78
diff changeset
405 {
74
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
406 index <- [node]Index >>
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
407 num <- 0
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
408 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
409 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
410 }
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
411 If[Has Block Params[[node]Params >>]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
412 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
413 worker <- Val[params worker]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
414 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
415 [blocks]Peek
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
416 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
417 worker <- [params worker]Add Wire[[~]Index >>, [~]Output Number >>, [node]Index >>, [0]-[1]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
418 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
419 worker <- Val[params worker]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
420 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
421 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
422 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
423
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
424 Blueprint Field Node
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
425 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
426 Name
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
427 Params
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
428 Assignments
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
429 Blocks
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
430 Index
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
431 Set?
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
432 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
433
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
434 Has Block@Field Node[junk:has block,unused]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
435 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
436 has block <- Yes
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
437 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
438
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
439 New@Field Node[name,params,set:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
440 {
48
a24eb366195c Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents: 42
diff changeset
441 out <- [[[[[Build["Field Node"]]Name <<[name]]Assignments <<[()]]Blocks <<[()]]Set? <<[set]]Params <<[params]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
442 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
443
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
444 Add to Worker@Field Node[node,worker,program,parse worker,refs:out node,out worker,out refs]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
445 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
446 If[[node]Set? >>]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
447 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
448 after worker,index <- [worker]Add Object Set[[node]Name >>]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
449 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
450 after worker,index <- [worker]Add Object Get[[node]Name >>]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
451 }
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
452 Val[index]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
453 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
454 assignment refs <- Fold[[["Assignment Save Reference"]Set Input[3, parse worker]]Set Input[4, ~], refs, [node]Assignments >>]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
455 [node]Index <<[~]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
456 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
457 params list, params worker, params refs <- Add List to Worker[[~]Params >>, after worker, program, parse worker, assignment refs]
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
458 block list, out worker, out refs <- Add Blocks to Worker[[~]Blocks >>, params worker, program, parse worker, params refs]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
459 out node <- [[~]Params <<[params list]]Blocks <<[block list]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
460 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
461 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
462 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
463
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
464 Add Wires@Field Node[node,worker,blocks,parse worker,assignments:worker,index,num]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
465 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
466 worker,index,num <- Add Wires Worker or Field[node, worker, blocks, parse worker, assignments]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
467 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
468
74
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
469 Check Worker Literals@Field Node[node,program:out]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
470 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
471 new params <- Map[[node]Params >>, ["Check Worker Literals"]Set Input[1, program]]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
472 out <- [[node]Blocks <<[ Map[[node]Blocks >>, ["Map"]Set Input[1, ["Check Worker Literals"]Set Input[1, program]]] ]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
473 ]Params <<[new params]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
474 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
475
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
476 Blueprint Named Pipe Node
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
477 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
478 Name
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
479 Assignments
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
480 Blocks
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
481 Index
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
482 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
483
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
484 Has Block@Named Pipe Node[node:has block,no block]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
485 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
486 If[[[node]Index >>] < [0]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
487 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
488 //~ should really be a parser parameter
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
489 If[[[node]Name >>] = ["~"]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
490 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
491 has block <- Yes
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
492 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
493 no block <- No
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
494 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
495 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
496 has block <- Yes
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
497 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
498 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
499
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
500 New@Named Pipe Node[name:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
501 {
48
a24eb366195c Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents: 42
diff changeset
502 out <- [[[Build["Named Pipe Node"]]Name <<[name]]Assignments <<[()]]Blocks <<[()]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
503 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
504
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
505 Add to Worker@Named Pipe Node[node,worker,program,parse worker,refs:out node,out worker,out refs]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
506 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
507 [[parse worker]Inputs >>]Find[[node]Name >>]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
508 {
37
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
509 after add <- [worker]Add Typed Input[[node]Name >>, ~, [[parse worker]Input Types>>]Index[~]] {}
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
510 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
511 assign refs <- Fold[[["Assignment Save Reference"]Set Input[3, parse worker]]Set Input[4, ~], refs, [node]Assignments >>]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
512 index node <- [node]Index <<[~]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
513 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
514 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
515 after add <- worker
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
516 index node <- [node]Index <<[[0]-[1]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
517 //TODO: Handle assignments from a named pipe that isn't an input
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
518 assign refs <- refs
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
519 }
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
520 block list, out worker, out refs <- Add Blocks to Worker[[node]Blocks >>, after add, program, parse worker, assign refs]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
521 out node <- [index node]Blocks <<[block list]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
522 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
523
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
524 Add Wires@Named Pipe Node[node,worker,blocks,parse worker,assignments:worker,index,num,reflist]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
525 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
526 reflist <- [assignments]Index[[node]Name >>]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
527 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
528 //TODO: Fix support for a named pipe with a block
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
529 worker <- worker
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
530 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
531 If[[[node]Name >>] = ["~"]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
532 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
533 wires worker <- worker
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
534 [blocks]Peek
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
535 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
536 my index <- [~]Index >>
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
537 num <- [~]Output Number >>
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
538 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
539 //TODO: Propagate an error rather than printing it out
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
540 Print["Error, block reference symbol located outside of a block"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
541 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
542 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
543 If[[[node]Index >>] < [0]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
544 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
545 Print[[[["Error, reference to named pipe "]Append[[node]Name >>]]Append[" that was never assigned to in worker "]]Append[[parse worker]Name >>]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
546 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
547 my index <- [node]Index >>
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
548 num <- 0
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
549 assignments worker <- Fold[[["Assignments Add Wires"]Set Input[3, parse worker]]Set Input[4, [node]Index >>], worker, [node]Assignments >>]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
550 [blocks]Peek
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
551 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
552 wires worker <- [assignments worker]Add Wire[[~]Index >>, [~]Output Number >>, [node]Index >>, [0]-[1]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
553 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
554 wires worker <- Val[assignments worker]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
555 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
556 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
557 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
558 }
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
559 index <- Val[my index]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
560
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
561 worker <- Fold[[[[["Add Block Wire"]Set Input[3, my index]]Set Input[4, blocks]]Set Input[5, parse worker]]Set Input[6, assignments], wires worker, [node]Blocks >>]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
562 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
563
74
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
564 Check Worker Literals@Named Pipe Node[node,program:out]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
565 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
566 out <- [node]Blocks <<[ Map[[node]Blocks >>, ["Map"]Set Input[1, ["Check Worker Literals"]Set Input[1, program]]] ]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
567 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
568
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
569 Blueprint Global Node
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
570 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
571 Store
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
572 Name
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
573 Assignments
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
574 Blocks
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
575 Index
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
576 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
577
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
578 New@Global Node[store,name:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
579 {
48
a24eb366195c Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents: 42
diff changeset
580 out <- [[[[Build["Global Node"]]Store <<[store]]Name <<[name]]Assignments <<[()]]Blocks <<[()]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
581 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
582
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
583 Add to Worker@Global Node[node,worker,unused,parse worker,refs:out node,out worker,refs]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
584 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
585 out worker <- [worker]Add Global Get[[node]Store >>, [node]Name >>] {}
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
586 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
587 refs <- Fold[[["Assignment Save Reference"]Set Input[3, parse worker]]Set Input[4, ~], refs, [node]Assignments >>]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
588 out node <- [node]Index <<[~]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
589 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
590 refs <- refs
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
591 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
592
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
593 Add Wires@Global Node[node,worker,blocks,parse worker,assignments:worker,index,num,unused]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
594 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
595 worker,index,num <- Add Wires Literal or Global[node, worker, blocks, parse worker, assignments]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
596 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
597
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
598 Has Block@Global Node[junk:out,unused]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
599 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
600 out <- Yes
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
601 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
602
74
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
603 Check Worker Literals@Global Node[node,program:out]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
604 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
605 out <- [node]Blocks <<[ Map[[node]Blocks >>, ["Map"]Set Input[1, ["Check Worker Literals"]Set Input[1, program]]] ]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
606 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
607
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
608 Blueprint Literal Node
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
609 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
610 Value
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
611 Assignments
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
612 Blocks
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
613 Index
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
614 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
615
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
616 Has Block@Literal Node[junk:out,unused]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
617 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
618 out <- Yes
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
619 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
620
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
621 New@Literal Node[value:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
622 {
48
a24eb366195c Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents: 42
diff changeset
623 out <- [[[Build["Literal Node"]]Value <<[value]]Assignments <<[()]]Blocks <<[()]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
624 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
625
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
626 Add to Worker@Literal Node[node,worker,unused,parse worker,refs:out node,out worker,out refs]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
627 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
628 out worker <- [worker]Add Constant[[node]Value >>] {}
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
629 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
630 out refs <- Fold[[["Assignment Save Reference"]Set Input[3, parse worker]]Set Input[4, ~], refs, [node]Assignments >>]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
631 out node <- [node]Index <<[~]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
632 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
633 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
634
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
635 Add Wires@Literal Node[node,worker,blocks,parse worker,assignments:worker,index,num,unused]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
636 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
637 worker,index,num <- Add Wires Literal or Global[node, worker, blocks, parse worker, assignments]
74
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
638 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
639
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
640 Check Worker Literals@Literal Node[node,program:out]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
641 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
642 out <- [node]Blocks <<[ Map[[node]Blocks >>, ["Map"]Set Input[1, ["Check Worker Literals"]Set Input[1, program]]] ]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
643 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
644
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
645 Add Wires Literal or Global[node,worker,blocks,parse worker,junk:worker,index,num,unused]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
646 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
647 assignments worker <- Fold[[["Assignments Add Wires"]Set Input[3, parse worker]]Set Input[4, [node]Index >>], worker, [node]Assignments >>]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
648 [blocks]Peek
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
649 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
650 worker <- [assignments worker]Add Wire[[~]Index >>, [~]Output Number>>, [node]Index >>, [0]-[1]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
651 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
652 worker <- Val[assignments worker]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
653 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
654 index <- [node]Index >>
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
655 num <- 0
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
656 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
657
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
658 Blueprint Block Node
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
659 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
660 Number
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
661 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
662
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
663 Blueprint Parse Error
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
664 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
665 Type
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
666 Text
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
667 Line Number
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
668 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
669
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
670 New@Parse Error[type,text,number:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
671 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
672 out <- [[[Build["Parse Error"]]Type <<[type]]Text <<[text]]Line Number <<[number]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
673 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
674
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
675 Not Empty[string:out]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
676 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
677 If[[[string]Length] > [0]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
678 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
679 out <- Yes
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
680 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
681 out <- No
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
682 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
683 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
684
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
685 Blueprint Blueprint Field
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
686 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
687 Name
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
688 Type
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
689 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
690
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
691 New@Blueprint Field[name,type:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
692 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
693 out <- [[Build["Blueprint Field"]]Name <<[name]]Type <<[type]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
694 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
695
40
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
696 Process Blueprint Field[list,field,params:out]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
697 {
40
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
698 ,name <- [field]Get DString[[params]List Begin >>]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
699 {
40
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
700 type info <- Parse List[~,params,()]
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
701 type <- [type info]Index[0]
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
702 {
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
703 If[[Type Of[~]] = ["Named Pipe Node"]]
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
704 {
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
705 before variant <- Type Instance[[type]Name >>]
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
706 }{
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
707 before variant <- [type]Params <<[ Map[[type]Params >>, "Remove Named Pipe Node"] ]
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
708 }
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
709 variant <- [type info]Index[1]
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
710 {
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
711 ,warn <- If[[Type Of[~]] = ["Named Pipe Node"]]
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
712 {
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
713 fieldtype,warn <- [before variant]Set Variant[[variant]Name >>]
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
714 }
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
715 Val[warn]
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
716 {
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
717 Print[[[["Warning: Invalid variant for type "]Append[[before variant]Name >>]]Append[" on field "]]Append[name]]
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
718 fieldtype <- Val[before variant]
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
719 }
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
720 }{
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
721 fieldtype <- Val[before variant]
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
722 }
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
723 }{
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
724 fieldtype <- Type Instance["Any Type"]
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
725 }
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
726 out <- [list]Append[New@Blueprint Field[name, fieldtype]]
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
727 } {} {} {
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
728 out <- [list]Append[New@Blueprint Field[name, Type Instance["Any Type"]]]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
729 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
730 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
731
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
732 Block Comment[string,begin comment,end comment,block count:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
733 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
734 If[[block count] > [0]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
735 {
48
a24eb366195c Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents: 42
diff changeset
736 after, before <- [string]Get DString[[[()]Append[begin comment]]Append[end comment]] {} {}
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
737 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
738 If[[~] = [begin comment]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
739 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
740 out <- Block Comment[after, begin comment, end comment, [block count]+[1]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
741 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
742 out <- Block Comment[after, begin comment, end comment, [block count]-[1]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
743 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
744 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
745 //No match
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
746 out <- ""
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
747 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
748 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
749 out <- string
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
750 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
751 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
752
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
753 Line Comment[string:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
754 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
755 [string]Get DString["\n"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
756 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
757 out <- ["\n"]Append[~]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
758 } {} {} {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
759 out <- ""
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
760 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
761 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
762
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
763 _Get Comment DString[string,delims,line comment,begin comment,end comment,prev before:rest,before,delim,nomatch]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
764 {
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
765 after,befored,used delim,nomatch <- [string]Get DString[delims]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
766 {
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
767 If[[used delim] = [line comment]]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
768 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
769 after comment <- Line Comment[after]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
770 }{
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
771 If[[used delim] = [begin comment]]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
772 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
773 after comment <- Block Comment[after, begin comment, end comment, 1]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
774 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
775 rest <- Val[after]
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
776 before <- [prev before]Append[befored]
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
777 delim <- Val[used delim]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
778 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
779 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
780 } {} {} {
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
781 before <- [prev before]Append[befored]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
782 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
783
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
784 after comment
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
785 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
786 rest,more before,delim,nomatch <- _Get Comment DString[~, delims, line comment, begin comment, end comment, prev before]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
787 before <- [before]Append[more before]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
788 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
789
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
790 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
791
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
792 Get Comment DString[string,delims,params:rest,before,delim,not found]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
793 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
794 line comment <- [params]Line Comment >>
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
795 begin comment <- [params]Comment Begin >>
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
796 end comment <- [params]Comment End >>
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
797 all delims <- [[[delims]As List]Append[begin comment]]Append[line comment]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
798 rest, before, delim, not found <- _Get Comment DString[string, delims, line comment, begin comment, end comment, ""]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
799 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
800
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
801 Comment Left Trim[string,trim chars,params:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
802 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
803 line comment <- [params]Line Comment >>
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
804
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
805 end comment <- [params]Comment End >>
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
806 trimmed <- Left Trim[string, trim chars]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
807 If[[trimmed]Starts With[line comment]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
808 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
809 ,after delim <- [trimmed]Slice[[line comment]Length]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
810 out <- Comment Left Trim[Line Comment[after delim], trim chars, params]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
811 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
812 begin comment <- [params]Comment Begin >>
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
813 If[[trimmed]Starts With[begin comment]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
814 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
815 ,after delim <- [trimmed]Slice[[line comment]Length]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
816 out <- Comment Left Trim[Block Comment[after delim, begin comment, end comment, 1], trim chars, params]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
817 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
818 out <- Val[trimmed]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
819 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
820 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
821 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
822
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
823 PBlueprint[string,params,tree,lines:out]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
824 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
825 ,whitespace name <- [string]Get Comment DString[[params]Block Begin >>, params]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
826 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
827 ,no blueprint <- [whitespace name]Slice[ [[params]Blueprint >>]Length ]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
828 name <- Trim[no blueprint, "\r\n\t "]
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
829 name lines <- 0
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
830 ,body <- [~]Get Comment DString[ [params]Block End >>, params]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
831 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
832 body lines <- [body]Split["\n"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
833 more lines <- [[[body lines]Length] - [1]] + [name lines]
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
834 fields <- Fold[["Process Blueprint Field"]Set Input[2, params], (), Filter[Map[body lines, ["Trim"]Set Input[1,"\n\r\t "]], "Not Empty"]]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
835 new tree <- [tree]Blueprints << [ [[tree]Blueprints >>]Set[name, New@Blueprint Definition[name, fields]] ]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
836 out <- Null[~, params, new tree, [lines] + [more lines]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
837 } {} {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
838 out <- [tree]Errors <<[ [[tree]Errors >>]Append[New@Parse Error["Error",[["Blueprint is missing an block close symbol \""]Append[[params]Block End >>]]Append["\""], lines]] ]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
839 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
840
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
841 } {} {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
842 out <- [tree]Errors <<[ [[tree]Errors >>]Append[New@Parse Error["Error",[["Blueprint is missing an block open symbol \""]Append[[params]Block Begin >>]]Append["\""], lines]] ]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
843 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
844 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
845
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
846 Parse Import[string,params,tree,lines:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
847 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
848 [line]Slice[ [[params]Import >>]Length ] {}
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
849 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
850 filename <- Trim[~, " \n\r\t"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
851 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
852 new tree <- [tree]Imports <<[ [[tree]Imports >>]Set[filename, Yes] ]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
853 ,line <- [string]Get Comment DString["\n", params]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
854 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
855 out <- Null[~, params, new tree, [lines] + [1]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
856 } {} {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
857 out <- Val[new tree]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
858 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
859 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
860
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
861 Get Expression Blocks[string,params,blocks:blocks,after]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
862 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
863 check block <- Comment Left Trim[string, "\n\r\t ", params]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
864 If[[check block]Starts With[[params]Block Begin >>]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
865 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
866 ,begin block <- [check block]Slice[[[params]Block Begin >>]Length]
48
a24eb366195c Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents: 42
diff changeset
867 trees, after block <- Worker Body[begin block, params, ()]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
868 blocks, after <- Get Expression Blocks[after block, params, [blocks]Append[trees]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
869 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
870 If[[check block]Starts With[[params]Empty Block >>]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
871 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
872 blocks <- blocks
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
873 ,after <- [check block]Slice[[[params]Empty Block >>]Length]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
874 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
875 blocks <- blocks
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
876 after <- Val[check block]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
877 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
878 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
879 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
880
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
881 Parse Escape[string,params:char,after]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
882 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
883 code,rest <- [string]Slice[1]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
884 If[[code] = [[params]Hex Escape >>]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
885 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
886 hex,after <- [rest]Slice[2]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
887 char <- [""]Put Byte[From Hex@Whole Number[hex]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
888 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
889 after <- Val[rest]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
890 char <- [[params]Escape Map >>]Index[code] {}
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
891 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
892 char <- Val[code]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
893 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
894 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
895 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
896
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
897 Parse String[string,params,current:value,after]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
898 {
48
a24eb366195c Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents: 42
diff changeset
899 delims <- [[()]Append[[params]String End >>]]Append[[params]String Escape >>]
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
900 afters, before, delim <- [string]Get Comment DString[delims, params]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
901 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
902 If[[delim] = [[params]String End >>]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
903 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
904 value <- [current]Append[before]
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
905 after <- Val[afters]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
906 }{
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
907 char,after escape <- Parse Escape[afters, params]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
908 value,after <- Parse String[after escape, params, [[current]Append[before]]Append[char]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
909 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
910 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
911 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
912
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
913 Parse List[string,params,list:value,after]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
914 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
915 trimmed <- Comment Left Trim[string, "\r\n\t ", params]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
916 If[[trimmed]Starts With[[params]List End >>]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
917 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
918 value <- list
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
919 ,after <- [trimmed]Slice[[[params]List End >>]Length]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
920 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
921 If[[trimmed]Starts With[[params]List Delim >>]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
922 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
923 ,el string <- [trimmed]Slice[[[params]List Delim >>]Length]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
924 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
925 el string <- Val[trimmed]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
926 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
927 element,after el <- Named Pipe or Literal[el string, params]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
928 value,after <- Parse List[after el, params, [list]Append[[element]Get Value]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
929 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
930 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
931
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
932 Get Value@Literal Node[node:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
933 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
934 out <- [node]Value >>
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
935 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
936
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
937 Get Value@Named Pipe Node[node:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
938 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
939 out <- node
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
940 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
941
50
689fb73e7612 Add support for various integer literals and add support for raw pointers to objects and raw pointers to arrays in the FFI
Mike Pavone <pavone@retrodev.com>
parents: 49
diff changeset
942 Blueprint Machine Integer
689fb73e7612 Add support for various integer literals and add support for raw pointers to objects and raw pointers to arrays in the FFI
Mike Pavone <pavone@retrodev.com>
parents: 49
diff changeset
943 {
689fb73e7612 Add support for various integer literals and add support for raw pointers to objects and raw pointers to arrays in the FFI
Mike Pavone <pavone@retrodev.com>
parents: 49
diff changeset
944 Value
689fb73e7612 Add support for various integer literals and add support for raw pointers to objects and raw pointers to arrays in the FFI
Mike Pavone <pavone@retrodev.com>
parents: 49
diff changeset
945 Size
689fb73e7612 Add support for various integer literals and add support for raw pointers to objects and raw pointers to arrays in the FFI
Mike Pavone <pavone@retrodev.com>
parents: 49
diff changeset
946 Signed?
689fb73e7612 Add support for various integer literals and add support for raw pointers to objects and raw pointers to arrays in the FFI
Mike Pavone <pavone@retrodev.com>
parents: 49
diff changeset
947 }
689fb73e7612 Add support for various integer literals and add support for raw pointers to objects and raw pointers to arrays in the FFI
Mike Pavone <pavone@retrodev.com>
parents: 49
diff changeset
948
689fb73e7612 Add support for various integer literals and add support for raw pointers to objects and raw pointers to arrays in the FFI
Mike Pavone <pavone@retrodev.com>
parents: 49
diff changeset
949 Machine Integer[value,size,signed?:out]
689fb73e7612 Add support for various integer literals and add support for raw pointers to objects and raw pointers to arrays in the FFI
Mike Pavone <pavone@retrodev.com>
parents: 49
diff changeset
950 {
689fb73e7612 Add support for various integer literals and add support for raw pointers to objects and raw pointers to arrays in the FFI
Mike Pavone <pavone@retrodev.com>
parents: 49
diff changeset
951 out <- [[[Build["Machine Integer"]]Value <<[value]]Size <<[size]]Signed? <<[signed?]
689fb73e7612 Add support for various integer literals and add support for raw pointers to objects and raw pointers to arrays in the FFI
Mike Pavone <pavone@retrodev.com>
parents: 49
diff changeset
952 }
689fb73e7612 Add support for various integer literals and add support for raw pointers to objects and raw pointers to arrays in the FFI
Mike Pavone <pavone@retrodev.com>
parents: 49
diff changeset
953
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
954 Parse Number[string,params:value,after]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
955 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
956 delims <- [[[[(" ","\t","\n","\r")]Append[[params]List Delim >>]]Append[[params]Block Begin >>]]Append[[params]Arg End >>]]Append[[params]List End >>]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
957 after delim,valstring <- [string]Get Comment DString[delims, params] {} {}
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
958 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
959 after <- [~]Append[after delim]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
960 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
961 after <- ""
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
962 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
963 first two,rest <- [valstring]Slice[2]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
964 If[[first two] = ["0x"]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
965 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
966 value <- From Hex@Whole Number[rest]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
967 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
968 If[[valstring]Contains["."]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
969 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
970 value <- <String@Real Number[valstring]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
971 }{
50
689fb73e7612 Add support for various integer literals and add support for raw pointers to objects and raw pointers to arrays in the FFI
Mike Pavone <pavone@retrodev.com>
parents: 49
diff changeset
972 size, val, type <- [valstring]Get DString[("i","u")]
689fb73e7612 Add support for various integer literals and add support for raw pointers to objects and raw pointers to arrays in the FFI
Mike Pavone <pavone@retrodev.com>
parents: 49
diff changeset
973 {
689fb73e7612 Add support for various integer literals and add support for raw pointers to objects and raw pointers to arrays in the FFI
Mike Pavone <pavone@retrodev.com>
parents: 49
diff changeset
974 value <- Machine Integer[<String@Whole Number[val], <String@Whole Number[size], [type]=["i"]]
689fb73e7612 Add support for various integer literals and add support for raw pointers to objects and raw pointers to arrays in the FFI
Mike Pavone <pavone@retrodev.com>
parents: 49
diff changeset
975 } {} {} {
689fb73e7612 Add support for various integer literals and add support for raw pointers to objects and raw pointers to arrays in the FFI
Mike Pavone <pavone@retrodev.com>
parents: 49
diff changeset
976 value <- <String@Whole Number[valstring]
689fb73e7612 Add support for various integer literals and add support for raw pointers to objects and raw pointers to arrays in the FFI
Mike Pavone <pavone@retrodev.com>
parents: 49
diff changeset
977 }
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
978 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
979 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
980 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
981
37
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
982 Parse Params@Type Instance[literal,params,string:out,after]
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
983 {
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
984 plist,after <- Parse List[string,params,()]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
985 out <- [literal]Params <<[plist]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
986 }
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
987
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
988 Named Pipe or Literal[string,params:out,after]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
989 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
990 name <- Comment Left Trim[string, "\n\r\t ", params]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
991 If[[name]Starts With[[params]String Begin >>]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
992 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
993 ,string begin <- [name]Slice[[[params]String Begin >>]Length]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
994 value,after <- Parse String[string begin, params, ""]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
995 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
996 If[[name]Starts With[[params]List Begin >>]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
997 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
998 ,list start <- [name]Slice[[[params]List Begin >>]Length]
48
a24eb366195c Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents: 42
diff changeset
999 value,after <- Parse List[list start, params, ()]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1000 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1001 If[[[name]Slice[1]]In["-0123456789"]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1002 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1003 value,after <- Parse Number[name, params]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1004 }{
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1005 delims <- [[[[[[[("\n")]Append[[params]Block Begin >>]]Append[[params]Block End >>]]Append[[params]Empty Block >>]]Append[[params]Arg End >>]]Append[[params]List Delim >>]]Append[[params]List End >>]]Append[[params]List Begin >>]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1006 afterdelim,raw before,delim,nodelim <- [name]Get Comment DString[delims, params]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1007
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1008 before <- Trim[raw before, "\r\n\t "]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1009 If[[delim] = [[params]List Begin >>]]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1010 {
37
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1011 value,after <- [Type Instance[before]]Parse Params[params,afterdelim]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1012 }{
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1013 Val[afterdelim]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1014 {
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1015 after <- [delim]Append[~]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1016 }
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1017 Val[nodelim]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1018 {
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1019 after <- ""
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1020 }
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1021 If[[before] = ["Yes"]]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1022 {
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1023 yesno <- Yes
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1024 }{
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1025 If[[before] = ["No"]]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1026 {
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1027 yesno <- No
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1028 }{
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1029 If[[before] = [""]]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1030 {
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1031 Print[[["Found "]Append[delim]]Append[" where a named pipe or literal was expected"]]
99
e09c2d1d6d5b Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents: 83
diff changeset
1032 { Print[["Near: "]Append[ [afterdelim]Slice[80]]] }
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1033 }{
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1034 If[[before]Contains[[params]Global Separator >>]]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1035 {
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1036 parts <- [before]Split[[params]Global Separator >>]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1037 out <- New@Global Node[Right Trim[[parts]Index[0],"\r\n\t "], Trim[[parts]Index[1], "\r\n\t "]]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1038 }{
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1039 out <- New@Named Pipe Node[Right Trim[before,"\r\n\t "]]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1040 }
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1041 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1042 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1043 }
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1044 out <- New@Literal Node[yesno]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1045 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1046 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1047 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1048 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1049 out <- New@Literal Node[value]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1050 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1051
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1052 Parse Arguments[string,params,arglist:args,after]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1053 {
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1054 targs <- Comment Left Trim[string, "\r\n\t ", params]
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1055 If[[targs]Starts With[[params]List Delim >>]]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1056 {
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1057 [targs]Slice[[[params]List Delim >>]Length] {}
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1058 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1059 final args <- Comment Left Trim[~, "\r\n\t ", params]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1060 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1061 }{
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1062 If[[targs]Starts With[[params]Arg End >>]]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1063 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1064 args <- arglist
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1065 ,after <- [targs]Slice[[[params]Arg End >>]Length]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1066 }{
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1067 final args <- Val[targs]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1068 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1069 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1070 arg, after arg <- Parse Expression[final args, params]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1071 args, after <- Parse Arguments[after arg, params, [arglist]Append[arg]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1072 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1073
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1074 Worker or Field[name,args,params:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1075 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1076 get field <- [params]Get Field >>
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1077 If[[name]Ends With[get field]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1078 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1079 field <- Right Trim[[name]Slice[[[name]Length] - [[get field]Length]], "\n\r\t "]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1080 out <- New@Field Node[field, args, No]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1081 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1082 set field <- [params]Set Field >>
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1083 If[[name]Ends With[set field]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1084 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1085 field <- Right Trim[[name]Slice[[[name]Length] - [[set field]Length]], "\n\r\t "]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1086 out <- New@Field Node[field, args, Yes]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1087 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1088 out <- New@Worker Node[name, args]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1089 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1090 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1091 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1092
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1093 Prefix[string,params,name,existing args:expression,after]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1094 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1095 //Parse argument list
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1096 more args,after <- Parse Arguments[string, params, existing args]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1097 expression <- Worker or Field[name, more args, params]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1098 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1099
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1100 Postfix or Infix[string,params:expression,after]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1101 {
48
a24eb366195c Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents: 42
diff changeset
1102 args, after args <- Parse Arguments[string, params, ()]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1103 delims <- [[[[[("\n")]Append[[params]Arg Begin >>]]Append[[params]Empty Block >>]]Append[[params]Block Begin >>]]Append[[params]Arg End >>]]Append[[params]List Delim >>]
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1104 aftere,before,delim <- [after args]Get Comment DString[delims, params]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1105 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1106 If[[delim] = [[params]Arg Begin >>]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1107 {
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1108 expression, after <- Prefix[aftere, params, Trim[before,"\r\n\t "], args]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1109 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1110 If[[delim] = [[params]Empty Block >>]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1111 {
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1112 after <- Val[aftere]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1113 }{
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1114 ,after <- [after args]Slice[[before]Length]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1115 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1116 expression <- Worker or Field[Trim[before,"\r\n\t "], args, params]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1117 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1118 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1119 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1120
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1121 Parse Expression[trimmed,params:final expression,after blocks]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1122 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1123 delims <- [[[[[[[("\n")]Append[[params]Arg Begin >>]]Append[[params]Arg End >>]]Append[[params]Assign >>]]Append["\n"]]Append[[params]Empty Block >>]]Append[[params]Block End >>]]Append[[params]String Begin >>]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1124 after, before, delim <- [trimmed]Get Comment DString[delims, params]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1125 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1126 //If we find an arg begin token, we have a worker expression
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1127 If[[delim] = [[params]Arg Begin >>]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1128 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1129 maybe name <- Right Trim[before, "\r\t "]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1130 //Prefix expressions will have the worker name before the first arg begin token
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1131 If[[maybe name] = [""]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1132 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1133 expression, after expression <- Postfix or Infix[after, params]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1134 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1135 If[[maybe name]Contains[[params]List Delim >>]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1136 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1137 after expression <- [after literal]Append[[delim]Append[after]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1138 expression, after literal <- Named Pipe or Literal[Right Trim[before, "\r\n\t "], params]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1139 }{
48
a24eb366195c Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents: 42
diff changeset
1140 expression, after expression <- Prefix[after, params, maybe name, ()]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1141 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1142 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1143 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1144 If[[delim] = [[params]Assign >>]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1145 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1146 //Expressions starting with an assignment can be prefix, postfix or infix
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1147 //or they can be a simple literal or named pipe
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1148 assignments <- Map[[before]Split[[params]List Delim >>], ["Trim"]Set Input[1,"\n\r\t "]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1149 ,after blocks <- Parse Expression[Comment Left Trim[after, " \n\r\t", params], params]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1150 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1151 final expression <- [~]Assignments <<[assignments]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1152 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1153 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1154 //If[[delim] = [[params]String Begin >>]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1155 //{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1156 // If[[Trim[before, "\r\n\t "]] = [""]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1157 // {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1158 // expression, after expression <- Named Pipe or Literal[[delim]Append[after], params]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1159 // }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1160 // after expression <- [after literal]Append[[delim]Append[after]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1161 // expression, after literal <- Named Pipe or Literal[Right Trim[before, "\r\n\t "], params]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1162 // }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1163 //}{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1164 // after expression <- [after literal]Append[[delim]Append[after]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1165 // expression, after literal <- Named Pipe or Literal[Right Trim[before, "\r\n\t "], params]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1166 //}
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1167 expression, after expression <- Named Pipe or Literal[trimmed, params]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1168 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1169 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1170 //Any expression can be followed by one or more blocks mapping the inputs of other expressions
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1171 //to the outputs of the current one
48
a24eb366195c Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents: 42
diff changeset
1172 blocks,after blocks <- Get Expression Blocks[after expression, params, ()]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1173 final expression <- [expression]Blocks <<[blocks]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1174 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1175 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1176
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1177 Worker Body[string,params,trees:trees,after end]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1178 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1179 trimmed <- Comment Left Trim[string, "\n\r\t ", params]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1180 If[[trimmed]Starts With[[params]Block End >>]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1181 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1182 //We're done with this block, return
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1183 ,after end <- [trimmed]Slice[[[params]Block End >>]Length]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1184 trees <- trees
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1185 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1186 expression, after expression <- Parse Expression[trimmed, params]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1187 trees,after end <- Worker Body[after expression, params, [trees]Append[expression]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1188 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1189 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1190
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1191 Process Modifiers[worker,params,modifiers:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1192 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1193 //Eventually this will need to be more sophisticated to handle more modifiers
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1194 trimmed <- Comment Left Trim[modifiers, "\n\r\t ", params]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1195 If[[trimmed]Starts With[[params]Uses >>]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1196 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1197 ,after uses <- [trimmed]Slice[[[params]Uses >>]Length]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1198 ,stores string <- [after uses]Get Comment DString["\n", params]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1199 out <- [worker]Uses Stores <<[Map[[stores string]Split[[params]List Delim >>], ["Trim"]Set Input[1, "\r\n\t "]]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1200 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1201 out <- worker
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1202 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1203 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1204
37
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1205 Remove Named Pipe Node[element:out]
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1206 {
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1207 If[[Type Of[element]] = ["Named Pipe Node"]]
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1208 {
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1209 out <- [element]Name >>
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1210 }{
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1211 If[[Type Of[element]] = ["Type Instance"]]
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1212 {
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1213 out <- [element]Params <<[ Map[[element]Params >>, "Remove Named Pipe Node"] ]
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1214 }{
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1215 out <- element
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1216 }
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1217 }
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1218 }
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1219
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1220 Parse Param List[text,paramlist,typelist,params:out params,out types]
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1221 {
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1222 delims <- [[()]Append[[params]List Begin >>]]Append[[params]List Delim >>]
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1223 after,param name <-[text]Get DString[delims] {}
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1224 {
69
d0ce696786cc Clean up debug print statements a bit. Fix bug that prevented workers that took no inputs from working. Remove workaround in Array for said bug.
Mike Pavone <pavone@retrodev.com>
parents: 52
diff changeset
1225 tname <- Trim[~, "\r\n\t "]
d0ce696786cc Clean up debug print statements a bit. Fix bug that prevented workers that took no inputs from working. Remove workaround in Array for said bug.
Mike Pavone <pavone@retrodev.com>
parents: 52
diff changeset
1226 If[[tname] = [""]]
d0ce696786cc Clean up debug print statements a bit. Fix bug that prevented workers that took no inputs from working. Remove workaround in Array for said bug.
Mike Pavone <pavone@retrodev.com>
parents: 52
diff changeset
1227 {
d0ce696786cc Clean up debug print statements a bit. Fix bug that prevented workers that took no inputs from working. Remove workaround in Array for said bug.
Mike Pavone <pavone@retrodev.com>
parents: 52
diff changeset
1228 nextlist <- Val[paramlist]
d0ce696786cc Clean up debug print statements a bit. Fix bug that prevented workers that took no inputs from working. Remove workaround in Array for said bug.
Mike Pavone <pavone@retrodev.com>
parents: 52
diff changeset
1229 next types <- Val[typelist]
d0ce696786cc Clean up debug print statements a bit. Fix bug that prevented workers that took no inputs from working. Remove workaround in Array for said bug.
Mike Pavone <pavone@retrodev.com>
parents: 52
diff changeset
1230 }{
d0ce696786cc Clean up debug print statements a bit. Fix bug that prevented workers that took no inputs from working. Remove workaround in Array for said bug.
Mike Pavone <pavone@retrodev.com>
parents: 52
diff changeset
1231 nextlist <- [paramlist]Append[tname]
d0ce696786cc Clean up debug print statements a bit. Fix bug that prevented workers that took no inputs from working. Remove workaround in Array for said bug.
Mike Pavone <pavone@retrodev.com>
parents: 52
diff changeset
1232 next types <- [typelist]Append[paramtype]
d0ce696786cc Clean up debug print statements a bit. Fix bug that prevented workers that took no inputs from working. Remove workaround in Array for said bug.
Mike Pavone <pavone@retrodev.com>
parents: 52
diff changeset
1233 }
37
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1234 }{
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1235 If[[~] = [[params]List Begin >>]]
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1236 {
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1237 type info,after type <- Parse List[after,params,()]
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1238 type <- [type info]Index[0]
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1239 {
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1240 If[[Type Of[~]] = ["Named Pipe Node"]]
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1241 {
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1242 before variant <- Type Instance[[type]Name >>]
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1243 }{
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1244 before variant <- <- [type]Params <<[ Map[[type]Params >>, "Remove Named Pipe Node"] ]
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1245 }
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1246 variant <- [type info]Index[1]
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1247 {
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1248 ,warn <- If[[Type Of[~]] = ["Named Pipe Node"]]
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1249 {
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1250 before mutable,warn <- [before variant]Set Variant[[variant]Name >>]
37
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1251 }
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1252 Val[warn]
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1253 {
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1254 Print[[[["Warning: Invalid variant for type "]Append[[before variant]Name >>]]Append[" on input "]]Append[param name]]
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1255 before mutable <- Val[before variant]
37
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1256 }
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1257 }{
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1258 before mutable <- Val[before variant]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1259 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1260 [type info]Index[2]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1261 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1262 paramtype <- [before mutable]Mutable? <<[ [[~]Name >>] = ["Mutable"] ]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1263 }{
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1264 paramtype <- Val[before mutable]
37
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1265 }
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1266 }{
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1267 paramtype <- Type Instance["Any Type"]
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1268 }
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1269 [after type]Get DString[","]
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1270 {
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1271 out params,out types <- Parse Param List[~,nextlist,next types,params]
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1272 } {} {} {
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1273 out params <- Val[nextlist]
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1274 out types <- Val[next types]
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1275 }
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1276 }{
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1277 paramtype <- Type Instance["Any Type"]
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1278 out params,out types <- Parse Param List[after,nextlist,next types,params]
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1279 }
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1280
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1281 }{
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1282 paramtype <- Type Instance["Any Type"]
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1283 out params <- Val[nextlist]
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1284 out types <- Val[next types]
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1285 }
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1286 }
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1287
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1288 Worker Declaration[string,params:worker,rest,no match]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1289 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1290 ,whitespace name <- [string]Get Comment DString[[params]Arg Begin >>, params]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1291 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1292 worker name <- Trim[whitespace name, "\n\r\t "]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1293 in out <- [params]In Out Delim >>
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1294 arg end <- [params]Arg End >>
48
a24eb366195c Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents: 42
diff changeset
1295 delims <- [[()]Append[in out]]Append[arg end]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1296 after <- [~]Get Comment DString[delims, params] {}
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1297 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1298 arglist <- Trim[~,"\r\n\t "]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1299 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1300 //check if there is an in/out separator
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1301 //if it isn't present, everything in the arglist is an input
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1302 If[[~] = [in out]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1303 {
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1304 rest <- [after]Get Comment DString[arg end, params] {}
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1305 {
37
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1306 outputs,output types <- Parse Param List[~, (), (), params]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1307 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1308 }{
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1309 rest <- Val[after]
37
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1310 outputs <- ()
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1311 output types <- ()
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1312 }
37
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1313 inputs,input types <- Parse Param List[arglist, (), (), params]
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1314 worker <- New@Parse Worker[worker name, inputs, outputs, input types, output types, 0]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1315 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1316 }{}{}{
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1317 no match <- string
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1318 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1319 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1320
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1321 Worker Name[string,params,tree,lines:out]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1322 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1323 ,after arglist <- Worker Declaration[string, params]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1324 {
99
e09c2d1d6d5b Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents: 83
diff changeset
1325 Print[worker name]
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1326 worker name <- [~]Name >>
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1327 body text, modifiers <- [after arglist]Get Comment DString[[params]Block Begin >>, params]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1328 modified <- Process Modifiers[~, params, modifiers]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1329 expression trees, after body <- Worker Body[body text, params, ()]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1330 worker <- [modified]Trees <<[expression trees]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1331 new worker dict <- [[tree]Workers >>]Set[worker name, worker]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1332 out <- Null[after body, params, [tree]Workers <<[new worker dict], 0]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1333 } {} {
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1334 out <- tree
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1335 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1336 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1337
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1338 Parse Foreign Worker[tree, string, lib, params:out]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1339 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1340 ,rest <- Worker Declaration[string, params]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1341 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1342 foreign <- [~]Trees << [lib]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1343 next <- [tree]Workers << [[[tree]Workers >>]Set[[foreign]Name >>, foreign]]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1344 out <- Parse Foreign Worker[next, rest, lib, params]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1345 } {} {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1346 out <- tree
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1347 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1348 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1349
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1350 Parse Foreign[string,params,tree,lines:out]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1351 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1352 ,after foreign <- [string]Slice[[[params]Foreign >>]Length]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1353 [after foreign]Get Comment DString[[params]Blueprint Type Delim >>, params]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1354 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1355 [~]Get Comment DString[[params]Block Begin >>, params]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1356 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1357 rest, body <- [~]Get Comment DString[[params]Block End >>, params]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1358 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1359 { lib <- Trim[~, "\r\n\t "] }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1360 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1361 { language <- Trim[~, "\r\n\t "] }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1362 Parse Foreign Worker[tree, body, New Foreign Lib[language, lib], params]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1363 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1364 out <- Null[rest, params, ~, 0]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1365 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1366 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1367
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1368 Null[string,params,tree,lines:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1369 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1370 trimmed <- Comment Left Trim[string, " \n\r\t", params]
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1371 current line <- 0
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1372 If[[trimmed]Starts With[ [params]Blueprint >> ]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1373 {
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1374 out <- PBlueprint[trimmed, params, tree, current line]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1375 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1376 If[[trimmed]Starts With[ [params]Import >> ]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1377 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1378 out <- Parse Import[trimmed, params, tree, current line]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1379 }{
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1380 If[[trimmed]Starts With[ [params]Foreign >> ]]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1381 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1382 out <- Parse Foreign[trimmed, params, tree, current line]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1383 }{
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1384 out <- Worker Name[trimmed, params, tree, current line]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1385 }
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1386 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1387 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1388 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1389
74
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
1390 Check Worker Literals@Parse Worker[worker,program:out]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
1391 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
1392 If[[Type Of[[worker]Trees >>]] = ["List"]]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
1393 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
1394 out <- [worker]Trees <<[ Map[[worker]Trees >>, ["Check Worker Literals"]Set Input[1, program]] ]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
1395 }{
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
1396 out <- worker
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
1397 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
1398 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
1399
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1400 Add Workers[workers,name,program:out]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1401 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1402 prog,worker <- [program]New Worker[name]
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1403 [worker]Set IO Counts[ [[[workers]Index[name]]Inputs >>]Length, [[[workers]Index[name]]Outputs >>]Length]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1404 [workers]Next[name]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1405 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1406 out <- Add Workers[workers, ~, prog]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1407 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1408 out <- Val[prog]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1409 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1410 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1411
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1412 Register Workers Compile[prog, worker, name:out]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1413 {
83
27bb051d631c Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents: 82
diff changeset
1414 //Print[["Registering "]Append[name]]
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1415 If[[ Type Of[[worker]Trees >>] ] = ["Foreign Lib"]]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1416 { convention <- Val[[[worker]Trees >>]Language >>] }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1417 { convention <- "rhope" }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1418 out <- [prog]Register Worker[name, convention, [[worker]Inputs >>]Length, [[worker]Outputs >>]Length]
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1419 }
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1420
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1421 Add Workers Compile[prog, worker, name:out]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1422 {
83
27bb051d631c Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents: 82
diff changeset
1423 Print[["Transforming "]Append[name]]
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1424 If[[Type Of[[worker]Trees >>]] = ["Foreign Lib"]]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1425 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1426 //TODO: Handle foreign func
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1427 final nworker <- [[[[[NWorker[[[worker]Trees >>]Language >>]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1428 ]Inputs <<[ [worker]Inputs >> ]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1429 ]Input Types <<[ [worker]Input Types >> ]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1430 ]Outputs <<[ [worker]Outputs >> ]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1431 ]Output Types <<[ [worker]Output Types >> ]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1432 ]Library <<[ [[worker]Trees >>]Name >> ]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1433
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1434 }{
75
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
1435 trees, nworker, refs <- Add List to Worker[[worker]Trees >>, [[NWorker["rhope"]]Uses[[worker]Uses Stores >>]]Outputs <<[ [worker]Outputs >> ], prog, worker, Dictionary[]]
74
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
1436 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
1437 final nworker <- Fold[[["Add Wires Helper"]Set Input[3, worker]]Set Input[4, refs], nworker, trees]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
1438 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
1439
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1440 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1441 out <- [prog]Bind Worker[name, final nworker]
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1442 }
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1443
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1444 Add Wires Helper[worker,node,unused,parse worker,assignments:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1445 {
48
a24eb366195c Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents: 42
diff changeset
1446 out <- [node]Add Wires[worker, (), parse worker, assignments]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1447 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1448
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1449 Add Contents[parse worker,name,program:out,key]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1450 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1451 worker <- [[program]Find Worker[name]]Uses[[parse worker]Uses Stores >>]
48
a24eb366195c Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents: 42
diff changeset
1452 trees, contents worker, refs <- Add List to Worker[[parse worker]Trees >>, worker, program, parse worker, Dictionary[]]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1453 Fold[[["Add Wires Helper"]Set Input[3, parse worker]]Set Input[4, refs], contents worker, trees]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1454 out <- [parse worker]Trees <<[trees]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1455 key <- name
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1456 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1457
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1458 Add Blueprint Field[blueprint,field,unused:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1459 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1460 out <- [blueprint]Add Field[[field]Name >>, [field]Type >>]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1461 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1462
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1463 Add Blueprint[prog,def:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1464 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1465 out <- [prog]New Blueprint[[def]Name >>] {}
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1466 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1467 Fold["Add Blueprint Field", ~, [def]Fields >>]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1468 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1469 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1470
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1471 Add Blueprint Compile[prog,def:out]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1472 {
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1473 out <- [prog]Bind Blueprint[[def]Name >>, Fold["Add Blueprint Field", NBlueprint[], [def]Fields >>]]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1474 }
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1475
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1476 _Tree to Program[parse tree,program:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1477 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1478 after blueprint <- Fold["Add Blueprint", program, [parse tree]Blueprints >>]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1479 [[parse tree]Workers >>]First
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1480 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1481 prog <- Add Workers[[parse tree]Workers >>, ~, after blueprint]
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1482 }{
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1483 Print["No workers!"]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1484 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1485 Key Value Map[[parse tree]Workers >>, ["Add Contents"]Set Input[2, prog]]
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1486 out <- Val[prog]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1487 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1488
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1489 Tree to Program[parse tree:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1490 {
48
a24eb366195c Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents: 42
diff changeset
1491 out <- _Tree to Program[parse tree, [Program[]]Add Builtins]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1492 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1493
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1494 Tree to Program Native[parse tree:out]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1495 {
48
a24eb366195c Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents: 42
diff changeset
1496 registered <- Fold["Register Workers Compile", [Fold["Add Blueprint Compile", NProgram[], [parse tree]Blueprints >>]]Register Builtins, [parse tree]Workers >>]
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1497 out <- Fold["Add Workers Compile", registered, [parse tree]Workers >>]
42
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
1498 { Print["Transformed AST to dataflow graph "] }
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1499 }
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1500
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1501 Needs Imports[needs import,not imported?,name:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1502 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1503 If[not imported?]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1504 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1505 out <- [needs import]Append[name]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1506 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1507 out <- needs import
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1508 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1509 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1510
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1511 Do Import[tree,file name,unused,params:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1512 {
99
e09c2d1d6d5b Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents: 83
diff changeset
1513 Print[["Parsing: "]Append[file name]]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1514 file <- <String@File[file name]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1515 ,text <- [file]Get FString[[file]Length]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1516 after import <- Null[text, params, tree, 0]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1517 out <- [after import]Imports <<[ [[after import]Imports >>]Set[file name, No] ]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1518 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1519
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1520 Process Imports[parse tree,params:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1521 {
48
a24eb366195c Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents: 42
diff changeset
1522 needs import <- Fold["Needs Imports", (), [parse tree]Imports >>]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1523 If[[[needs import]Length] > [0]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1524 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1525 import tree <- Fold[["Do Import"]Set Input[3, params], parse tree, needs import]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1526 out <- Process Imports[import tree, params]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1527 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1528 out <- parse tree
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1529 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1530 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1531
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1532 _Init Used Store[dict,store name:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1533 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1534 [dict]Index[store name]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1535 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1536 out <- dict
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1537 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1538 Init Store[store name]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1539 out <- [dict]Set[store name, Yes]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1540 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1541 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1542
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1543 _Init Used Stores[dict,worker:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1544 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1545 out <- Fold["_Init Used Store", dict, [worker]Uses Stores >>]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1546 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1547
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1548 Init Used Stores[parse tree,existing stores:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1549 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1550 out <- Fold["_Init Used Stores", existing stores, [parse tree]Workers >>]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1551 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1552
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1553 Until End[text:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1554 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1555 line <- Get Input[]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1556 If[[line] = ["End"]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1557 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1558 out <- [text]Append["\n"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1559 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1560 out <- Until End[[[text]Append["\n"]]Append[line]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1561 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1562 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1563
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1564 _REPL[params,prog,stores]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1565 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1566 line <- Get Input[]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1567 If[[line] = ["Begin"]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1568 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1569 text <- Until End[""]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1570 Null[text, params, New@Parse Program[], 0]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1571 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1572 define tree <- Process Imports[~, params]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1573 Init Used Stores[define tree, stores]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1574 { _REPL[params, _Tree to Program[define tree, prog], ~] }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1575 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1576 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1577 If[[line]Starts With[[params]Import >>]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1578 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1579 Parse Import[[line]Append["\n"], params, New@Parse Program[], 0]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1580 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1581 import tree <- Process Imports[~, params]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1582 Init Used Stores[import tree, stores]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1583 { _REPL[params, _Tree to Program[import tree, prog], ~] }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1584 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1585 }{
48
a24eb366195c Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents: 42
diff changeset
1586 trees <- Worker Body[[line]Append["}"], params, ()]
a24eb366195c Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents: 42
diff changeset
1587 tree <- [New@Worker Node["Val", [()]Append[[trees]Index[0]]]]Assignments <<[("__out")]
a24eb366195c Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents: 42
diff changeset
1588 this stores <- [[tree]Gather Stores[params, Dictionary[]]]Keys
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1589 next stores <- Fold["_Init Used Store", stores, this stores]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1590 {
48
a24eb366195c Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents: 42
diff changeset
1591 pworker <- [[New@Parse Worker["__Eval", (), ("__out"), 0]]Trees <<[[()]Append[tree]]]Uses Stores <<[this stores]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1592 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1593 [[prog]Find Worker["__Eval"]]Clear
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1594 {
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1595 Add Contents[pworker, "__Eval", prog]
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1596 {
69
d0ce696786cc Clean up debug print statements a bit. Fix bug that prevented workers that took no inputs from working. Remove workaround in Array for said bug.
Mike Pavone <pavone@retrodev.com>
parents: 52
diff changeset
1597 _REPL[params, prog, next stores] } }
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1598 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1599 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1600 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1601
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1602 REPL[params]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1603 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1604 Print["Rhope Alpha 2\nCopyright 2008 by Michael Pavone\nEntering interactive mode\n"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1605 prog <- Tree to Program[Null["Val[in:out]\n{\n out <- in\n}\n__Eval[:__out]\n{\n}\n", params, New@Parse Program[], 0]]
48
a24eb366195c Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents: 42
diff changeset
1606 _REPL[params, prog, Dictionary[]]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1607 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1608
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1609 Add If Store[stores,name,params:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1610 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1611 If[[name]Contains[[params]Global Separator >>]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1612 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1613 parts <- [name]Split[[params]Global Separator >>]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1614 out <- [stores]Set[[parts]Index[0], Yes]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1615 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1616 out <- stores
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1617 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1618 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1619
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1620 Param Gather Stores[stores,node,params:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1621 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1622 out <- [node]Gather Stores[params, stores]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1623 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1624
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1625 Gather Stores@Named Pipe Node[node,params,stores:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1626 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1627 out <- Fold[["Add If Store"]Set Input[2, params], stores, [node]Assignments >>]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1628 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1629
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1630 Gather Stores@Global Node[node,params,stores:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1631 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1632 out <- [stores]Set[[node]Store >>, Yes]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1633 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1634
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1635 Gather Stores@Worker Node[node,params,stores:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1636 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1637 //TODO: Handle blocks
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1638 store list <- Fold[["Param Gather Stores"]Set Input[2, params], stores, [node]Params >>]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1639 out <- Fold[["Add If Store"]Set Input[2, params], store list, [node]Assignments >>]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1640 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1641
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1642 Gather Stores@Field Node[node,params,stores:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1643 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1644 //TODO: Handle blocks
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1645 store list <- Fold[["Param Gather Stores"]Set Input[2, params], stores, [node]Params >>]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1646 out <- Fold[["Add If Store"]Set Input[2, params], store list, [node]Assignments >>]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1647 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1648
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1649 Gather Stores@Literal Node[node,params,stores:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1650 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1651 out <- Fold[["Add If Store"]Set Input[2, params], stores, [node]Assignments >>]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1652 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1653