annotate parser_old.rhope @ 78:4d5ea487f810

Working String implementation and some basic (but nowhere near exhaustive) tests
author Mike Pavone <pavone@retrodev.com>
date Thu, 08 Jul 2010 21:55:47 -0400
parents 0083b2f7b3c7
children 2e2e55fc12f9
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 {
78
4d5ea487f810 Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents: 75
diff changeset
316 Print["Add Multi Wire"]
4d5ea487f810 Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents: 75
diff changeset
317 { Print[[ref]Index >>]
4d5ea487f810 Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents: 75
diff changeset
318 { Print[[ref]Output Number >>]
4d5ea487f810 Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents: 75
diff changeset
319 { Pretty Print[worker, ""] }}}
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
320 out <- [worker]Add Wire[[ref]Index >>, [ref]Output Number >>, end index, input num]
78
4d5ea487f810 Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents: 75
diff changeset
321 { Print["Added wire"] }
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
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
324 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
325 {
74
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
326 Print[["Add Param Wire: "]Append[input num]]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
327 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
328 param worker, start index, output num <- [param]Add Wires[worker, blocks, parse worker, assignments] { Print["got param worker"] }
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
329 {
74
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
330 Print[["got normal output for param: "]Append[input num]]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
331 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
332 Print[["Start index: "]Append[start index]]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
333 Print[["Output num: "]Append[output num]]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
334
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
335 out <- [param worker]Add Wire[start index, output num, end index, input num]
74
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
336 { Print["Added param wire"] }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
337 }
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
338 }{}{
74
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
339 Print["got multi output"]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
340 out <- Fold[[["Add Multi Wire"]Set Input[3, end index]]Set Input[4, input num], param worker, ~]
74
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
341 { Print["Added multi wire"] }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
342 }
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
343 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
344 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
345
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
346 _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
347 {
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
348 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
349 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
350
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
351 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
352 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
353 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
354 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
355 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
356
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
357 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
358 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
359 [[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
360 {
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
361 ,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
362 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
363 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
364 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
365 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
366 //Ugly hack alert!
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
367 If[[assignment]Contains["::"]]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
368 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
369 parts <- [assignment]Split["::"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
370 ,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
371 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
372 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
373 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
374 }{
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
375 out worker <- worker
22
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 }
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 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
381 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
382 out <- Yes
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
383 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
384
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
385 _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
386 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
387 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
388 out <- [param]Has Block {}
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
389 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
390 [param list]Next[key]
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 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
393 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
394 out <- No
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
395 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
396 }
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 }
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 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
401 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
402 [param list]First
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
403 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
404 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
405 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
406 out <- No
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
407 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
408 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
409
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
410 Add 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
411 {
74
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
412 Print[["Add Wires@Worker Node: "]Append[[node]Name >>]]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
413 {
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
414 worker,index,num <- Add Wires Worker or Field[node, worker, blocks, parse worker, assignments]
74
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
415 }
22
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
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
418 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
419 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
420 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
421 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
422 Print["Assignments Add Wires done"]
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
423 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
424 {
74
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
425 Print["Add Block Wire done"]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
426 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 >>]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
427 { Print["Add Param Wire done"]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
428 index <- [node]Index >>
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
429 num <- 0
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
430 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
431 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
432 }
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
433 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
434 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
435 worker <- Val[params worker]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
436 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
437 [blocks]Peek
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 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
440 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
441 worker <- Val[params worker]
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 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
444 }
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 Blueprint Field Node
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 Name
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
449 Params
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
450 Assignments
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
451 Blocks
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
452 Index
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
453 Set?
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
454 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
455
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
456 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
457 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
458 has block <- Yes
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
459 }
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 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
462 {
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
463 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
464 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
465
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
466 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
467 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
468 If[[node]Set? >>]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
469 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
470 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
471 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
472 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
473 }
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
474 Val[index]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
475 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
476 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
477 [node]Index <<[~]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
478 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
479 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
480 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
481 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
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 }
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 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
487 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
488 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
489 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
490
74
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
491 Check Worker Literals@Field Node[node,program:out]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
492 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
493 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
494 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
495 ]Params <<[new params]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
496 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
497
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
498 Blueprint Named Pipe Node
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 Name
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
501 Assignments
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
502 Blocks
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
503 Index
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
504 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
505
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
506 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
507 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
508 If[[[node]Index >>] < [0]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
509 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
510 //~ 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
511 If[[[node]Name >>] = ["~"]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
512 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
513 has block <- Yes
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
514 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
515 no block <- No
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
516 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
517 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
518 has block <- Yes
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
519 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
520 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
521
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
522 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
523 {
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
524 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
525 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
526
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
527 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
528 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
529 [[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
530 {
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
531 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
532 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
533 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
534 index node <- [node]Index <<[~]
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 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
537 after add <- worker
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
538 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
539 //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
540 assign refs <- refs
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
541 }
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
542 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
543 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
544 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
545
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
546 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
547 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
548 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
549 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
550 //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
551 worker <- worker
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
552 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
553 If[[[node]Name >>] = ["~"]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
554 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
555 wires worker <- worker
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
556 [blocks]Peek
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 my index <- [~]Index >>
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
559 num <- [~]Output Number >>
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 //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
562 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
563 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
564 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
565 If[[[node]Index >>] < [0]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
566 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
567 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
568 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
569 my index <- [node]Index >>
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
570 num <- 0
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
571 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
572 [blocks]Peek
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
573 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
574 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
575 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
576 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
577 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
578 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
579 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
580 }
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
581 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
582
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
583 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
584 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
585
74
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
586 Check Worker Literals@Named Pipe Node[node,program:out]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
587 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
588 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
589 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
590
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
591 Blueprint Global Node
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 Store
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
594 Name
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
595 Assignments
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
596 Blocks
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
597 Index
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
598 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
599
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
600 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
601 {
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
602 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
603 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
604
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
605 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
606 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
607 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
608 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
609 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
610 out node <- [node]Index <<[~]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
611 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
612 refs <- refs
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
613 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
614
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
615 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
616 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
617 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
618 }
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 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
621 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
622 out <- Yes
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
623 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
624
74
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
625 Check Worker Literals@Global Node[node,program:out]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
626 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
627 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
628 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
629
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
630 Blueprint Literal Node
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
631 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
632 Value
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
633 Assignments
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
634 Blocks
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
635 Index
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
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
638 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
639 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
640 out <- Yes
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
641 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
642
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
643 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
644 {
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
645 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
646 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
647
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
648 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
649 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
650 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
651 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
652 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
653 out node <- [node]Index <<[~]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
654 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
655 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
656
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
657 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
658 {
74
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
659 Print[["Add Wires@Literal Node, Literal Type: "]Append[Type Of[[node]Value >>]]]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
660 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
661 { Print["Got worker"] }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
662 { Print["got index"] }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
663 { Print["got num"] }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
664 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
665
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
666 Check Worker Literals@Literal Node[node,program:out]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
667 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
668 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
669 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
670
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
671 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
672 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
673 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
674 [blocks]Peek
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
675 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
676 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
677 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
678 worker <- Val[assignments worker]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
679 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
680 index <- [node]Index >>
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
681 num <- 0
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 Blueprint Block Node
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
685 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
686 Number
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
687 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
688
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
689 Blueprint Parse Error
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 Type
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
692 Text
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
693 Line Number
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
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
696 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
697 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
698 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
699 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
700
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
701 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
702 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
703 If[[[string]Length] > [0]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
704 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
705 out <- Yes
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
706 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
707 out <- No
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
708 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
709 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
710
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
711 Blueprint Blueprint Field
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
712 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
713 Name
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
714 Type
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
715 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
716
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
717 New@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
718 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
719 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
720 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
721
40
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
722 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
723 {
40
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
724 ,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
725 {
40
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
726 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
727 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
728 {
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
729 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
730 {
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
731 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
732 }{
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
733 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
734 }
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
735 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
736 {
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
737 ,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
738 {
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
739 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
740 }
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
741 Val[warn]
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
742 {
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
743 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
744 fieldtype <- Val[before variant]
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
745 }
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
746 }{
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
747 fieldtype <- Val[before variant]
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
748 }
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
749 }{
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
750 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
751 }
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
752 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
753 } {} {} {
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
754 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
755 }
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
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
758 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
759 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
760 If[[block count] > [0]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
761 {
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
762 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
763 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
764 If[[~] = [begin comment]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
765 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
766 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
767 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
768 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
769 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
770 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
771 //No match
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
772 out <- ""
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
773 }
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 out <- string
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
776 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
777 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
778
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
779 Line Comment[string:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
780 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
781 [string]Get DString["\n"]
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 out <- ["\n"]Append[~]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
784 } {} {} {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
785 out <- ""
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
786 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
787 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
788
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
789 _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
790 {
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
791 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
792 {
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
793 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
794 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
795 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
796 }{
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
797 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
798 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
799 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
800 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
801 rest <- Val[after]
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
802 before <- [prev before]Append[befored]
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
803 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
804 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
805 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
806 } {} {} {
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
807 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
808 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
809
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
810 after comment
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 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
813 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
814 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
815
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
816 }
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 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
819 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
820 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
821 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
822 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
823 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
824 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
825 }
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 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
828 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
829 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
830
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
831 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
832 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
833 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
834 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
835 ,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
836 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
837 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
838 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
839 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
840 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
841 ,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
842 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
843 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
844 out <- Val[trimmed]
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 }
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
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
849 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
850 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
851 ,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
852 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
853 ,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
854 name <- Trim[no blueprint, "\r\n\t "]
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
855 name lines <- 0
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
856 ,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
857 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
858 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
859 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
860 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
861 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
862 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
863 } {} {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
864 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
865 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
866
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
867 } {} {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
868 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
869 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
870 }
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 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
873 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
874 [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
875 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
876 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
877 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
878 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
879 ,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
880 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
881 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
882 } {} {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
883 out <- Val[new tree]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
884 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
885 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
886
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
887 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
888 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
889 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
890 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
891 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
892 ,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
893 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
894 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
895 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
896 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
897 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
898 blocks <- blocks
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
899 ,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
900 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
901 blocks <- blocks
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
902 after <- Val[check block]
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 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
905 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
906
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
907 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
908 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
909 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
910 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
911 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
912 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
913 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
914 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
915 after <- Val[rest]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
916 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
917 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
918 char <- Val[code]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
919 }
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 }
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 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
924 {
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
925 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
926 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
927 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
928 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
929 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
930 value <- [current]Append[before]
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
931 after <- Val[afters]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
932 }{
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
933 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
934 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
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 }
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 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
940 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
941 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
942 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
943 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
944 value <- list
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
945 ,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
946 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
947 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
948 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
949 ,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
950 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
951 el string <- Val[trimmed]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
952 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
953 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
954 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
955 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
956 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
957
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
958 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
959 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
960 out <- [node]Value >>
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
961 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
962
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
963 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
964 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
965 out <- node
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
966 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
967
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
968 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
969 {
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
970 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
971 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
972 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
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
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 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
976 {
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 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
978 }
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
979
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
980 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
981 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
982 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
983 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
984 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
985 after <- [~]Append[after delim]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
986 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
987 after <- ""
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
988 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
989 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
990 If[[first two] = ["0x"]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
991 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
992 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
993 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
994 If[[valstring]Contains["."]]
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 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
997 }{
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
998 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
999 {
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
1000 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
1001 } {} {} {
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
1002 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
1003 }
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1004 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1005 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1006 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1007
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
1008 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
1009 {
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1010 plist,after <- Parse List[string,params,()]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1011 out <- [literal]Params <<[plist]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1012 }
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1013
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1014 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
1015 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1016 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
1017 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
1018 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1019 ,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
1020 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
1021 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1022 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
1023 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1024 ,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
1025 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
1026 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1027 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
1028 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1029 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
1030 }{
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1031 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
1032 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
1033
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1034 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
1035 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
1036 {
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
1037 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
1038 }{
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1039 Val[afterdelim]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1040 {
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1041 after <- [delim]Append[~]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1042 }
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1043 Val[nodelim]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1044 {
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1045 after <- ""
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1046 }
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1047 If[[before] = ["Yes"]]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1048 {
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1049 yesno <- Yes
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1050 }{
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1051 If[[before] = ["No"]]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1052 {
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1053 yesno <- No
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1054 }{
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1055 If[[before] = [""]]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1056 {
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1057 Print[[["Found "]Append[delim]]Append[" where a named pipe or literal was expected"]]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1058 { Print[["Near: "]Append[ [afterdelim]Slice[40]]] }
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1059 }{
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1060 If[[before]Contains[[params]Global Separator >>]]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1061 {
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1062 parts <- [before]Split[[params]Global Separator >>]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1063 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
1064 }{
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1065 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
1066 }
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1067 }
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 }
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1070 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
1071 }
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 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1075 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
1076 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1077
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1078 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
1079 {
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1080 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
1081 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
1082 {
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1083 [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
1084 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1085 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
1086 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1087 }{
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1088 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
1089 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1090 args <- arglist
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1091 ,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
1092 }{
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1093 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
1094 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1095 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1096 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
1097 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
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 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
1101 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1102 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
1103 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
1104 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1105 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
1106 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
1107 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1108 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
1109 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
1110 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1111 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
1112 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
1113 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1114 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
1115 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1116 }
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 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
1120 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1121 //Parse argument list
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1122 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
1123 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
1124 }
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 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
1127 {
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
1128 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
1129 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
1130 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
1131 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1132 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
1133 {
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1134 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
1135 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1136 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
1137 {
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1138 after <- Val[aftere]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1139 }{
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1140 ,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
1141 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1142 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
1143 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1144 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1145 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1146
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1147 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
1148 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1149 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
1150 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
1151 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1152 //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
1153 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
1154 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1155 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
1156 //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
1157 If[[maybe name] = [""]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1158 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1159 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
1160 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1161 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
1162 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1163 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
1164 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
1165 }{
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
1166 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
1167 }
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 If[[delim] = [[params]Assign >>]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1171 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1172 //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
1173 //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
1174 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
1175 ,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
1176 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1177 final expression <- [~]Assignments <<[assignments]
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 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1180 //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
1181 //{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1182 // 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
1183 // {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1184 // 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
1185 // }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1186 // 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
1187 // 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
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 // 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
1191 // 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
1192 //}
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1193 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
1194 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1195 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1196 //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
1197 //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
1198 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
1199 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
1200 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1201 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1202
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1203 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
1204 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1205 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
1206 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
1207 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1208 //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
1209 ,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
1210 trees <- trees
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1211 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1212 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
1213 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
1214 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1215 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1216
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1217 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
1218 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1219 //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
1220 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
1221 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
1222 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1223 ,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
1224 ,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
1225 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
1226 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1227 out <- worker
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1228 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1229 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1230
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
1231 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
1232 {
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
1233 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
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 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
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 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
1238 {
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 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
1240 }{
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 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
1242 }
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 }
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 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
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 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
1249 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
1250 {
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
1251 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
1252 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
1253 {
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
1254 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
1255 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
1256 }{
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
1257 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
1258 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
1259 }
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
1260 }{
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
1261 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
1262 {
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
1263 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
1264 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
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 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
1267 {
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 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
1269 }{
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 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
1271 }
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 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
1273 {
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 ,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
1275 {
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1276 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
1277 }
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 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
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 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
1281 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
1282 }
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 }{
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1284 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
1285 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1286 [type info]Index[2]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1287 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1288 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
1289 }{
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1290 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
1291 }
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
1292 }{
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
1293 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
1294 }
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
1295 [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
1296 {
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
1297 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
1298 } {} {} {
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
1299 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
1300 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
1301 }
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
1302 }{
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
1303 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
1304 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
1305 }
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
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
1307 }{
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
1308 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
1309 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
1310 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
1311 }
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
1312 }
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
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1314 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
1315 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1316 ,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
1317 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1318 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
1319 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
1320 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
1321 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
1322 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
1323 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1324 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
1325 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1326 //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
1327 //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
1328 If[[~] = [in out]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1329 {
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1330 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
1331 {
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
1332 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
1333 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1334 }{
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1335 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
1336 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
1337 output types <- ()
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1338 }
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
1339 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
1340 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
1341 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1342 }{}{}{
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1343 no match <- string
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1344 }
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
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1347 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
1348 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1349 ,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
1350 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1351 worker name <- [~]Name >>
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1352 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
1353 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
1354 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
1355 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
1356 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
1357 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
1358 } {} {
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1359 out <- tree
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1360 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1361 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1362
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1363 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
1364 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1365 ,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
1366 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1367 foreign <- [~]Trees << [lib]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1368 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
1369 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
1370 } {} {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1371 out <- tree
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1372 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1373 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1374
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1375 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
1376 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1377 ,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
1378 [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
1379 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1380 [~]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
1381 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1382 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
1383 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1384 { 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
1385 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1386 { 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
1387 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
1388 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1389 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
1390 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1391 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1392
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1393 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
1394 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1395 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
1396 current line <- 0
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1397 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
1398 {
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1399 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
1400 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1401 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
1402 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1403 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
1404 }{
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1405 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
1406 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1407 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
1408 }{
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1409 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
1410 }
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1411 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1412 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1413 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1414
74
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
1415 Check Worker Literals@Parse Worker[worker,program:out]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
1416 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
1417 If[[Type Of[[worker]Trees >>]] = ["List"]]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
1418 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
1419 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
1420 }{
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
1421 out <- worker
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
1422 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
1423 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
1424
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1425 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
1426 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1427 prog,worker <- [program]New Worker[name]
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1428 [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
1429 [workers]Next[name]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1430 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1431 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
1432 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1433 out <- Val[prog]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1434 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1435 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1436
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1437 Register Workers Compile[prog, worker, name:out]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1438 {
73
6a1a7d5cc2d9 Add some error checking, cleanup output and add a bad test file
Mike Pavone <pavone@retrodev.com>
parents: 69
diff changeset
1439 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
1440 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
1441 { 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
1442 { convention <- "rhope" }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1443 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
1444 }
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1445
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1446 Add Workers Compile[prog, worker, name:out]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1447 {
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1448 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
1449 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1450 //TODO: Handle foreign func
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1451 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
1452 ]Inputs <<[ [worker]Inputs >> ]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1453 ]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
1454 ]Outputs <<[ [worker]Outputs >> ]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1455 ]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
1456 ]Library <<[ [[worker]Trees >>]Name >> ]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1457
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1458 }{
73
6a1a7d5cc2d9 Add some error checking, cleanup output and add a bad test file
Mike Pavone <pavone@retrodev.com>
parents: 69
diff changeset
1459 Print[["Transforming "]Append[name]]
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
1460 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
1461 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
1462 ,proceed <- If[[name] = ["Main"]]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
1463 { Print["Added Trees to worker"]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
1464 { proceed <- Pretty Print[trees, ""] }}
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
1465 Val[proceed]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
1466 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
1467 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
1468 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
1469 If[[name] = ["Main"]]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
1470 { Print["Added wires to worker"] }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
1471 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
1472 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
1473 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
1474
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1475 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1476 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
1477 }
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1478
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1479 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
1480 {
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
1481 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
1482 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1483
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1484 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
1485 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1486 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
1487 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
1488 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
1489 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
1490 key <- name
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1491 }
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 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
1494 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1495 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
1496 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1497
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1498 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
1499 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1500 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
1501 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1502 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
1503 }
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
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1506 Add Blueprint Compile[prog,def:out]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1507 {
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1508 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
1509 }
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1510
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1511 _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
1512 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1513 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
1514 [[parse tree]Workers >>]First
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1515 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1516 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
1517 }{
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1518 Print["No workers!"]
22
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 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
1521 out <- Val[prog]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1522 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1523
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1524 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
1525 {
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
1526 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
1527 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1528
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1529 Tree to Program Native[parse tree:out]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1530 {
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
1531 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
1532 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
1533 { Print["Transformed AST to dataflow graph "] }
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1534 }
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1535
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1536 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
1537 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1538 If[not imported?]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1539 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1540 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
1541 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1542 out <- needs import
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1543 }
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
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1546 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
1547 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1548 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
1549 ,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
1550 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
1551 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
1552 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1553
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1554 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
1555 {
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
1556 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
1557 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
1558 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1559 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
1560 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
1561 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1562 out <- parse tree
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 }
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 _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
1567 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1568 [dict]Index[store name]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1569 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1570 out <- dict
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 Init Store[store name]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1573 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
1574 }
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 _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
1578 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1579 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
1580 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1581
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1582 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
1583 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1584 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
1585 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1586
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1587 Until End[text:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1588 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1589 line <- Get Input[]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1590 If[[line] = ["End"]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1591 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1592 out <- [text]Append["\n"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1593 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1594 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
1595 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1596 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1597
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1598 _REPL[params,prog,stores]
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 line <- Get Input[]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1601 If[[line] = ["Begin"]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1602 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1603 text <- Until End[""]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1604 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
1605 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1606 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
1607 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
1608 { _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
1609 }
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[[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
1612 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1613 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
1614 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1615 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
1616 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
1617 { _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
1618 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1619 }{
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
1620 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
1621 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
1622 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
1623 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
1624 {
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
1625 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
1626 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1627 [[prog]Find Worker["__Eval"]]Clear
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1628 {
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1629 Add Contents[pworker, "__Eval", prog]
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1630 {
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
1631 _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
1632 }
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
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1636 REPL[params]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1637 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1638 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
1639 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
1640 _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
1641 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1642
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1643 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
1644 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1645 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
1646 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1647 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
1648 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
1649 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1650 out <- stores
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1651 }
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
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1654 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
1655 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1656 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
1657 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1658
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1659 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
1660 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1661 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
1662 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1663
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1664 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
1665 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1666 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
1667 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1668
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1669 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
1670 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1671 //TODO: Handle blocks
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1672 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
1673 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
1674 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1675
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1676 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
1677 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1678 //TODO: Handle blocks
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1679 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
1680 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
1681 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1682
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1683 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
1684 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1685 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
1686 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1687
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1688
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1689 Main[args]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1690 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1691 fname <- [args]Index[1]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1692 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1693 file <- <String@File[~]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1694 ,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
1695 params <- New@Parser[]
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1696 Print[["Parsing "]Append[fname]]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1697 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
1698 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1699 Print["Parsing imports"]
74
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
1700 Process Imports[~, params]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
1701 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
1702 tree <- [~]Workers << [ Map[[~]Workers >>, ["Check Worker Literals"]Set Input[1, ~]] ]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
1703 { Print["Compiling"] }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 73
diff changeset
1704 }
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1705 compiled <- [Tree to Program Native[tree]]Compile Program[C Program[]]
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
1706 { Print["Compiled program to backend"] }
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1707 outfile <- <String@File[ [fname]Append[".c"] ]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1708 [outfile]Put String[ [compiled]Text ]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1709 { Print[["Wrote output to "]Append[ [fname]Append[".c"] ]] }
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1710 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1711 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1712 REPL[New@Parser[]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1713 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1714 }