Mercurial > repos > rhope

annotate parser_old.rhope @ 68:38d9cd036d49

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Add missing file
author Mike Pavone <pavone@retrodev.com>
date Mon, 07 Jun 2010 15:36:04 -0400
parents 079200bc3e75
children d0ce696786cc
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[]]
52
079200bc3e75 String literals almost working. Print moved out of C runtime.
Mike Pavone <pavone@retrodev.com>
parents: 50
diff changeset
130 ]Imports <<[[[Dictionary[]]Set["kernel.rhope", Yes]]Set["string.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 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
218 Print["Add Blocks to Worker"]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
219 {
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
220 [blocks]First
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, 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
223 }{
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
224 out blocks <- blocks
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
225 out worker <- worker
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
226 out refs <- refs
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
227 }
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
228 }
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
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
231 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
232 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
233 [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
234 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
235 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
236 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
237 //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
238 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
239 [node]Index <<[~]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
240 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
241 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
242 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
243 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
244 }
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 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
248 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
249 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
250
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
251 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
252 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
253 Print[
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
254 [[[[[[["Wire: "
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
255 ]Append[ [ref]Index >> ]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
256 ]Append[","]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
257 ]Append[ [ref]Output Number >>]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
258 ]Append[" to "]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
259 ]Append[end index]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
260 ]Append[","]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
261 ]Append[input num]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
262 ]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
263 out <- [worker]Add Wire[[ref]Index >>, [ref]Output Number >>, end index, input num]
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
264 { Print["Wire added"] }
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
265 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
266
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
267 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
268 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
269 Print[[[["param type: "
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
270 ]Append[Type Of[param]]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
271 ]Append[", dest index:"]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
272 ]Append[end index]]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
273 {
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
274 param worker, start index, output num <- [param]Add Wires[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
275 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
276 Print[
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
277 [[[[[[["Wire: "
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
278 ]Append[start index ]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
279 ]Append[","]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
280 ]Append[output num]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
281 ]Append[" to "]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
282 ]Append[end index]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
283 ]Append[","]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
284 ]Append[input num]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
285 ] {
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
286 out <- [param worker]Add Wire[start index, output num, end index, input num]
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
287 { Print["wire done, Add Param Wire"] }
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
288 }
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
289 }{}{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
290 out <- Fold[[["Add Multi Wire"]Set Input[3, end index]]Set Input[4, input num], param worker, ~]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
291 }
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
292 }
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
293 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
294
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
295 _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
296 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
297 Print[["_Add Block Wire "]Append[Type Of[node]]]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
298 {
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
299 out <- [node]Add Wires[worker, blocks, parse worker, assignments]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
300 { Print[["_Add Block Wire done "]Append[Type Of[node]]] }
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
301 }
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
302 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
303
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
304 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
305 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
306 Print["Add Block Wire"]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
307 {
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
308 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
309 out <- Fold[[[["_Add Block Wire"]Set Input[3, blocks]]Set Input[4, parse worker]]Set Input[5, assignments], worker, block nodes]
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
310 { Print["done: Add Block Wire"] }
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
311 }
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
312 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
313
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
314 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
315 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
316 Print[["Assignments Add Wires: "]Append[assignment]]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
317 {
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
318 [[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
319 {
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
320 ,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
321 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
322 Print[
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
323 [[[[[[["Wire: "
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
324 ]Append[ start index ]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
325 ]Append[","]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
326 ]Append[ output num]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
327 ]Append[" to "]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
328 ]Append[output index]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
329 ]Append[","]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
330 ]Append[ 0 ]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
331 ]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
332 out worker <- [~]Add Wire[start index, output num, output index, 0]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
333 { Print["wire done, Assignments Add Wires 1"] }
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
334 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
335 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
336 //Ugly hack alert!
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
337 If[[assignment]Contains["::"]]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
338 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
339 parts <- [assignment]Split["::"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
340 ,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
341 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
342 out worker <- [~]Add Wire[start index, output num, global index, 0]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
343 { Print["wire done, Assignments Add Wires 2"] }
22
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 }{
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
346 Print["Pipe assignment, do nothing"]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
347 { out worker <- worker }
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
348 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
349 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
350 }
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
351 }
22
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 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
354 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
355 out <- Yes
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
356 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
357
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
358 _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
359 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
360 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
361 out <- [param]Has Block {}
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
362 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
363 [param list]Next[key]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
364 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
365 out <- _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
366 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
367 out <- No
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 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
370
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
371 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
372
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
373 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
374 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
375 [param list]First
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
376 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
377 out <- _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
378 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
379 out <- No
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
380 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
381 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
382
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
383 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
384 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
385 Print["Add Wires@Worker Node"]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
386 {
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
387 worker,index,num <- Add Wires Worker or Field[node, worker, blocks, parse worker, assignments]
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
388 }
22
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
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
391 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
392 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
393 Print["Add Wires Worker or Field"]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
394 {
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
395 Fold[[["Assignments Add Wires"]Set Input[3, parse worker]]Set Input[4, [node]Index >>], worker, [node]Assignments >>]
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
396 {
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
397 Print["Assignments Add Wires done"]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
398 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
399 {
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
400 Print["Add Block Wire fold done"]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
401 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 >>] }}
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
402 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
403 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
404 worker <- Val[params worker]
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 [blocks]Peek
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 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
409 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
410 worker <- Val[params worker]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
411 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
412 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
413 index <- [node]Index >>
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
414 num <- 0
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
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 Blueprint Field Node
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 Name
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
421 Params
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
422 Assignments
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
423 Blocks
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
424 Index
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
425 Set?
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
426 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
427
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
428 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
429 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
430 has block <- Yes
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
431 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
432
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
433 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
434 {
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
435 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
436 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
437
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
438 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
439 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
440 If[[node]Set? >>]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
441 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
442 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
443 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
444 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
445 }
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
446 Val[index]
22
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 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
449 [node]Index <<[~]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
450 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
451 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
452 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
453 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
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 }
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 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
459 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
460 Print["Add Wires@Field Node"]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
461 {
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
462 worker,index,num <- Add Wires Worker or Field[node, worker, blocks, parse worker, assignments]
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
463 }
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
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
466 Blueprint Named Pipe Node
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 Name
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
469 Assignments
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
470 Blocks
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
471 Index
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
472 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
473
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
474 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
475 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
476 If[[[node]Index >>] < [0]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
477 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
478 //~ 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
479 If[[[node]Name >>] = ["~"]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
480 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
481 has block <- Yes
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 no block <- No
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 has block <- Yes
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 }
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 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
491 {
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
492 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
493 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
494
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
495 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
496 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
497 [[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
498 {
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
499 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
500 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
501 Print[["Added input, node:"]Append[~]]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
502 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
503 index node <- [node]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 after add <- worker
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
507 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
508 //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
509 assign refs <- refs
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
510 }
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
511 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
512 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
513 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
514
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
515 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
516 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
517 Print["Add Wires@Named Pipe Node"]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
518 {
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
519 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
520 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
521 //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
522 worker <- worker
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
523 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
524 If[[[node]Name >>] = ["~"]]
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 wires worker <- worker
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
527 [blocks]Peek
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 my index <- [~]Index >>
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
530 num <- [~]Output Number >>
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
531 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
532 //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
533 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
534 }
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 If[[[node]Index >>] < [0]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
537 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
538 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
539 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
540 my index <- [node]Index >>
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
541 num <- 0
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
542 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
543 [blocks]Peek
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 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
546 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
547 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
548 }
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 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
551 }
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
552 }
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
553 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
554
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
555 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
556 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
557
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
558 Blueprint Global Node
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
559 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
560 Store
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
561 Name
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
562 Assignments
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
563 Blocks
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
564 Index
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
565 }
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 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
568 {
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
569 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
570 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
571
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
572 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
573 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
574 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
575 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
576 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
577 out node <- [node]Index <<[~]
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 refs <- refs
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
580 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
581
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
582 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
583 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
584 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
585 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
586
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
587 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
588 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
589 out <- Yes
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
590 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
591
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
592 Blueprint Literal Node
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
593 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
594 Value
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 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
601 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
602 out <- Yes
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 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
606 {
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
607 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
608 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
609
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
610 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
611 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
612 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
613 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
614 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
615 out node <- [node]Index <<[~]
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 }
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 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
620 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
621 Print["Add Wires@Literal Node"]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
622 {
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
623 worker,index,num <- Add Wires Literal or Global[node, worker, blocks, parse worker, assignments]
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
624 }
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
625 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
626
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
627 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
628 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
629 Print["Add Wires Literal or Global"]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
630 {
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
631 assignments worker <- Fold[[["Assignments Add Wires"]Set Input[3, parse worker]]Set Input[4, [node]Index >>], worker, [node]Assignments >>]
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
632 { Print["Done fold Assignments Add Wires"] }
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
633 [blocks]Peek
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
634 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
635 Print["Add wire"]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
636 worker <- [assignments worker]Add Wire[[~]Index >>, [~]Output Number>>, [node]Index >>, [0]-[1]]
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
637 { Print["Add wire done"] }
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
638 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
639 worker <- Val[assignments worker]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
640 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
641 index <- [node]Index >>
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
642 num <- 0
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
643 }
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
644 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
645
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
646 Blueprint Block Node
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
647 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
648 Number
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
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
651 Blueprint Parse Error
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
652 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
653 Type
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
654 Text
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
655 Line Number
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
656 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
657
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
658 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
659 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
660 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
661 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
662
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
663 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
664 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
665 If[[[string]Length] > [0]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
666 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
667 out <- Yes
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
668 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
669 out <- No
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 }
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 Blueprint Blueprint Field
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
674 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
675 Name
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
676 Type
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
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
679 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
680 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
681 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
682 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
683
40
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
684 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
685 {
40
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
686 ,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
687 {
40
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
688 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
689 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
690 {
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
691 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
692 {
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
693 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
694 }{
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
695 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
696 }
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
697 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
698 {
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
699 ,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
700 {
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
701 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
702 }
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
703 Val[warn]
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
704 {
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
705 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
706 fieldtype <- Val[before variant]
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
707 }
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
708 }{
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
709 fieldtype <- Val[before variant]
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
710 }
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
711 }{
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
712 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
713 }
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
714 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
715 } {} {} {
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
716 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
717 }
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
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
720 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
721 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
722 If[[block count] > [0]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
723 {
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
724 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
725 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
726 If[[~] = [begin comment]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
727 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
728 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
729 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
730 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
731 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
732 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
733 //No match
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
734 out <- ""
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
735 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
736 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
737 out <- string
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
738 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
739 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
740
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
741 Line Comment[string:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
742 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
743 [string]Get DString["\n"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
744 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
745 out <- ["\n"]Append[~]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
746 } {} {} {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
747 out <- ""
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
748 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
749 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
750
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
751 _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
752 {
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
753 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
754 {
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
755 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
756 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
757 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
758 }{
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
759 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
760 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
761 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
762 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
763 rest <- Val[after]
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
764 before <- [prev before]Append[befored]
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
765 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
766 }
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 } {} {} {
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
769 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
770 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
771
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
772 after comment
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 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
775 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
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
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
780 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
781 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
782 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
783 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
784 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
785 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
786 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
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 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
790 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
791 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
792
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
793 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
794 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
795 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
796 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
797 ,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
798 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
799 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
800 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
801 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
802 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
803 ,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
804 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
805 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
806 out <- Val[trimmed]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
807 }
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
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
811 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
812 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
813 ,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
814 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
815 ,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
816 name <- Trim[no blueprint, "\r\n\t "]
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
817 name lines <- 0
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
818 ,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
819 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
820 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
821 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
822 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
823 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
824 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
825 } {} {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
826 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
827 }
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 } {} {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
830 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
831 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
832 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
833
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
834 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
835 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
836 [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
837 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
838 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
839 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
840 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
841 ,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
842 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
843 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
844 } {} {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
845 out <- Val[new tree]
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
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
849 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
850 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
851 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
852 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
853 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
854 ,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
855 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
856 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
857 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
858 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
859 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
860 blocks <- blocks
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
861 ,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
862 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
863 blocks <- blocks
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
864 after <- Val[check block]
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
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
869 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
870 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
871 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
872 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
873 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
874 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
875 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
876 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
877 after <- Val[rest]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
878 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
879 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
880 char <- Val[code]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
881 }
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 }
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 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
886 {
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
887 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
888 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
889 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
890 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
891 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
892 value <- [current]Append[before]
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
893 after <- Val[afters]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
894 }{
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
895 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
896 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
897 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
898 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
899 }
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 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
902 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
903 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
904 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
905 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
906 value <- list
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
907 ,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
908 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
909 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
910 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
911 ,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
912 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
913 el string <- Val[trimmed]
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 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
916 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
917 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
918 }
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 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
921 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
922 out <- [node]Value >>
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
923 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
924
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
925 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
926 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
927 out <- node
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
928 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
929
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
930 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
931 {
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
932 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
933 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
934 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
935 }
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
936
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
937 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
938 {
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
939 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
940 }
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
941
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
942 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
943 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
944 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
945 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
946 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
947 after <- [~]Append[after 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 after <- ""
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 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
952 If[[first two] = ["0x"]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
953 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
954 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
955 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
956 If[[valstring]Contains["."]]
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 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
959 }{
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
960 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
961 {
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
962 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
963 } {} {} {
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
964 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
965 }
22
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 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
968 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
969
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
970 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
971 {
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
972 plist,after <- Parse List[string,params,()]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
973 out <- [literal]Params <<[plist]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
974 }
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
975
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
976 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
977 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
978 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
979 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
980 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
981 ,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
982 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
983 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
984 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
985 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
986 ,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
987 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
988 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
989 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
990 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
991 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
992 }{
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
993 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
994 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
995
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
996 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
997 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
998 {
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
999 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
1000 }{
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1001 Val[afterdelim]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1002 {
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1003 after <- [delim]Append[~]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1004 }
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1005 Val[nodelim]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1006 {
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1007 after <- ""
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1008 }
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1009 If[[before] = ["Yes"]]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1010 {
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1011 yesno <- Yes
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1012 }{
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1013 If[[before] = ["No"]]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1014 {
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1015 yesno <- No
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1016 }{
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1017 If[[before] = [""]]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1018 {
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1019 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
1020 { 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
1021 }{
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1022 If[[before]Contains[[params]Global Separator >>]]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1023 {
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1024 parts <- [before]Split[[params]Global Separator >>]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1025 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
1026 }{
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1027 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
1028 }
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1029 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1030 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1031 }
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1032 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
1033 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1034 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1035 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1036 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1037 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
1038 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1039
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1040 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
1041 {
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1042 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
1043 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
1044 {
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1045 [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
1046 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1047 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
1048 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1049 }{
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1050 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
1051 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1052 args <- arglist
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1053 ,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
1054 }{
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1055 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
1056 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1057 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1058 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
1059 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
1060 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1061
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1062 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
1063 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1064 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
1065 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
1066 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1067 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
1068 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
1069 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1070 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
1071 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
1072 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1073 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
1074 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
1075 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1076 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
1077 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1078 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1079 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1080
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1081 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
1082 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1083 //Parse argument list
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1084 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
1085 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
1086 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1087
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1088 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
1089 {
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
1090 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
1091 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
1092 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
1093 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1094 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
1095 {
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1096 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
1097 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1098 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
1099 {
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1100 after <- Val[aftere]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1101 }{
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1102 ,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
1103 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1104 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
1105 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1106 }
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
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1109 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
1110 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1111 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
1112 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
1113 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1114 //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
1115 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
1116 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1117 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
1118 //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
1119 If[[maybe name] = [""]]
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 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
1122 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1123 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
1124 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1125 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
1126 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
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 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
1129 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1130 }
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]Assign >>]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1133 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1134 //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
1135 //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
1136 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
1137 ,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
1138 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1139 final expression <- [~]Assignments <<[assignments]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1140 }
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 //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
1143 //{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1144 // 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
1145 // {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1146 // 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
1147 // }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1148 // 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
1149 // 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
1150 // }
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 // 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
1153 // 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
1154 //}
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1155 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
1156 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1157 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1158 //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
1159 //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
1160 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
1161 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
1162 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1163 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1164
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1165 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
1166 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1167 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
1168 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
1169 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1170 //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
1171 ,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
1172 trees <- trees
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1173 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1174 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
1175 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
1176 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1177 }
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 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
1180 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1181 //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
1182 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
1183 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
1184 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1185 ,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
1186 ,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
1187 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
1188 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1189 out <- worker
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1190 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1191 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1192
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
1193 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
1194 {
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
1195 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
1196 {
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
1197 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
1198 }{
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
1199 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
1200 {
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
1201 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
1202 }{
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
1203 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
1204 }
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1205 }
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1206 }
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1207
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1208 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
1209 {
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1210 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
1211 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
1212 {
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1213 nextlist <- [paramlist]Append[Trim[~, "\r\n\t "]]
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1214 next types <- [typelist]Append[paramtype]
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1215 }{
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1216 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
1217 {
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1218 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
1219 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
1220 {
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1221 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
1222 {
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1223 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
1224 }{
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
1225 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
1226 }
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
1227 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
1228 {
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
1229 ,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
1230 {
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1231 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
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 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
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 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
1236 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
1237 }
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 }{
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1239 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
1240 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1241 [type info]Index[2]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1242 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1243 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
1244 }{
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1245 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
1246 }
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 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
1249 }
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 [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
1251 {
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1252 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
1253 } {} {} {
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1254 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
1255 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
1256 }
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1257 }{
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
1258 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
1259 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
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
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 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
1264 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
1265 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
1266 }
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1267 }
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
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1269 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
1270 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1271 ,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
1272 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1273 worker name <- Trim[whitespace name, "\n\r\t "]
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
1274 Print[["Parsing worker: "]Append[worker name]]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1275 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
1276 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
1277 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
1278 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
1279 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1280 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
1281 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1282 //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
1283 //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
1284 If[[~] = [in out]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1285 {
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1286 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
1287 {
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
1288 outputs,output types <- Parse Param List[~, (), (), 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
1289 { Print["got 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
1290 { Print["got output types"] }
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1291 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1292 }{
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1293 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
1294 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
1295 output types <- ()
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1296 }
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
1297 inputs,input types <- Parse Param List[arglist, (), (), 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 { Print["got inputs"] }
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 { Print["got input types"] }
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1300 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
1301 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1302 }{}{}{
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1303 no match <- string
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1304 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1305 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1306
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1307 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
1308 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1309 ,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
1310 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1311 Print["Got parse worker"]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1312 worker name <- [~]Name >>
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1313 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
1314 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
1315 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
1316 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
1317 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
1318 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
1319 } {} {
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1320 out <- tree
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1321 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1322 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1323
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1324 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
1325 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1326 ,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
1327 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1328 foreign <- [~]Trees << [lib]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1329 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
1330 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
1331 } {} {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1332 out <- tree
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1333 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1334 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1335
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1336 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
1337 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1338 Print["Foreign block"]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1339 ,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
1340 Print[[after foreign]Slice[20]]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1341 [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
1342 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1343 [~]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
1344 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1345 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
1346 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1347 { 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
1348 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1349 { 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
1350 Print[[[["Language: "]Append[language]]Append[" Library: "]]Append[lib]]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1351 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1352 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
1353 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1354 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
1355 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1356 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1357 }
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 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
1360 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1361 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
1362 current line <- 0
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1363 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
1364 {
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1365 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
1366 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1367 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
1368 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1369 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
1370 }{
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1371 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
1372 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1373 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
1374 }{
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1375 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
1376 }
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1377 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1378 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1379 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1380
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1381 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
1382 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1383 prog,worker <- [program]New Worker[name]
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1384 [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
1385 [workers]Next[name]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1386 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1387 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
1388 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1389 out <- Val[prog]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1390 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1391 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1392
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1393 Register Workers Compile[prog, worker, name:out]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1394 {
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1395 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
1396 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
1397 { 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
1398 { convention <- "rhope" }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1399 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
1400 }
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1401
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1402 Add Workers Compile[prog, worker, name:out]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1403 {
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1404 Print[["Add Workers Compile: "]Append[name]]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1405 {
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1406 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
1407 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1408 //TODO: Handle foreign func
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1409 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
1410 ]Inputs <<[ [worker]Inputs >> ]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1411 ]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
1412 ]Outputs <<[ [worker]Outputs >> ]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1413 ]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
1414 ]Library <<[ [[worker]Trees >>]Name >> ]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1415
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1416 }{
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1417 trees, nworker, refs <- Add List to Worker[[worker]Trees >>, [NWorker["rhope"]]Uses[[worker]Uses Stores >>], prog, worker, Dictionary[]]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1418 final nworker <- Fold[[["Add Wires Helper"]Set Input[3, worker]]Set Input[4, refs], nworker, trees]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1419 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1420 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
1421 }
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1422 }
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1423
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1424 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
1425 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1426 Print["Add Wires Helper"]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1427 {
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
1428 out <- [node]Add Wires[worker, (), parse worker, assignments]
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1429 { Print["Add Wires Helper Done"] }
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1430 }
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1431 }
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 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
1434 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1435 Print[["Add Contents: "]Append[name]]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1436 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
1437 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
1438 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
1439 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
1440 key <- name
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1441 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1442
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1443 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
1444 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1445 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
1446 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1447
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1448 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
1449 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1450 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
1451 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1452 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
1453 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1454 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1455
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1456 Add Blueprint Compile[prog,def:out]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1457 {
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1458 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
1459 }
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1460
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1461 _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
1462 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1463 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
1464 [[parse tree]Workers >>]First
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1465 {
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1466 Print["Adding workers"]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1467 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
1468 { Print["Add Workers done"] }
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1469 }{
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1470 Print["No workers!"]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1471 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1472 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
1473 { Print["Done Add Contents"] }
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1474 out <- Val[prog]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1475 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1476
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1477 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
1478 {
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1479 Print["Tree to 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
1480 out <- _Tree to Program[parse tree, [Program[]]Add Builtins]
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1481 { Print["done"] }
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
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1484 Tree to Program Native[parse tree:out]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1485 {
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
1486 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
1487 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
1488 { Print["Transformed AST to dataflow graph "] }
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1489 }
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1490
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1491 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
1492 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1493 If[not imported?]
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 <- [needs import]Append[name]
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 out <- needs import
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1498 }
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
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1501 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
1502 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1503 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
1504 ,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
1505 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
1506 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
1507 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1508
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1509 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
1510 {
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
1511 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
1512 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
1513 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1514 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
1515 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
1516 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1517 out <- parse tree
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1518 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1519 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1520
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1521 _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
1522 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1523 [dict]Index[store name]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1524 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1525 out <- dict
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1526 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1527 Init Store[store name]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1528 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
1529 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1530 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1531
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1532 _Init Used Stores[dict,worker:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1533 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1534 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
1535 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1536
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1537 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
1538 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1539 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
1540 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1541
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1542 Until End[text:out]
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 line <- Get Input[]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1545 If[[line] = ["End"]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1546 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1547 out <- [text]Append["\n"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1548 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1549 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
1550 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1551 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1552
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1553 _REPL[params,prog,stores]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1554 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1555 line <- Get Input[]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1556 If[[line] = ["Begin"]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1557 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1558 text <- Until End[""]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1559 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
1560 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1561 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
1562 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
1563 { _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
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 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
1567 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1568 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
1569 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1570 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
1571 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
1572 { _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
1573 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1574 }{
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1575 Print["Expression"]
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
1576 trees <- Worker Body[[line]Append["}"], params, ()]
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1577 { Print["Parse done"] }
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
1578 tree <- [New@Worker Node["Val", [()]Append[[trees]Index[0]]]]Assignments <<[("__out")]
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1579 { Print["Constructed new tree"] }
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
1580 this stores <- [[tree]Gather Stores[params, Dictionary[]]]Keys
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1581 { Print["Got stores"] }
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1582 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
1583 {
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1584 Print["Initialized 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
1585 pworker <- [[New@Parse Worker["__Eval", (), ("__out"), 0]]Trees <<[[()]Append[tree]]]Uses Stores <<[this stores]
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1586 { Print["Constructed parse worker"] }
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1587 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1588 [[prog]Find Worker["__Eval"]]Clear
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1589 {
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1590 Print["Cleared worker"]
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1591 Add Contents[pworker, "__Eval", prog]
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1592 {
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1593 Print["Added Contents"]
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
1594 Pretty Print[[[[prog]Find Worker["__Eval"]]Do[()]]Index[0], ""]
24
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1595 {
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1596 Print["Finished executeion"]
8b2b3f4a2a58 Some fixes to parser_old.rhope
Mike Pavone <pavone@retrodev.com>
parents: 22
diff changeset
1597 _REPL[params, prog, next stores] } } }
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1598 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1599 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1600 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1601
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1602 REPL[params]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1603 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1604 Print["Rhope Alpha 2\nCopyright 2008 by Michael Pavone\nEntering interactive mode\n"]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1605 prog <- Tree to Program[Null["Val[in:out]\n{\n out <- in\n}\n__Eval[:__out]\n{\n}\n", params, New@Parse Program[], 0]]
48
a24eb366195c Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents: 42
diff changeset
1606 _REPL[params, prog, Dictionary[]]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1607 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1608
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1609 Add If Store[stores,name,params:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1610 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1611 If[[name]Contains[[params]Global Separator >>]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1612 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1613 parts <- [name]Split[[params]Global Separator >>]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1614 out <- [stores]Set[[parts]Index[0], Yes]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1615 }{
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1616 out <- stores
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1617 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1618 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1619
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1620 Param Gather Stores[stores,node,params:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1621 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1622 out <- [node]Gather Stores[params, stores]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1623 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1624
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1625 Gather Stores@Named Pipe Node[node,params,stores:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1626 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1627 out <- Fold[["Add If Store"]Set Input[2, params], stores, [node]Assignments >>]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1628 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1629
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1630 Gather Stores@Global Node[node,params,stores:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1631 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1632 out <- [stores]Set[[node]Store >>, Yes]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1633 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1634
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1635 Gather Stores@Worker Node[node,params,stores:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1636 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1637 //TODO: Handle blocks
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1638 store list <- Fold[["Param Gather Stores"]Set Input[2, params], stores, [node]Params >>]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1639 out <- Fold[["Add If Store"]Set Input[2, params], store list, [node]Assignments >>]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1640 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1641
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1642 Gather Stores@Field Node[node,params,stores:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1643 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1644 //TODO: Handle blocks
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1645 store list <- Fold[["Param Gather Stores"]Set Input[2, params], stores, [node]Params >>]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1646 out <- Fold[["Add If Store"]Set Input[2, params], store list, [node]Assignments >>]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1647 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1648
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1649 Gather Stores@Literal Node[node,params,stores:out]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1650 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1651 out <- Fold[["Add If Store"]Set Input[2, params], stores, [node]Assignments >>]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1652 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1653
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1654
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1655 Main[args]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1656 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1657 Print["start"]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1658 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
1659 {
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1660 file <- <String@File[~]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1661 ,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
1662 params <- New@Parser[]
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1663 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
1664 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
1665 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1666 Print["Parsing imports"]
22
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1667 tree <- Process Imports[~, params]
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1668 { Print["Compiling"] }
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1669 compiled <- [Tree to Program Native[tree]]Compile Program[C Program[]]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1670 outfile <- <String@File[ [fname]Append[".c"] ]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1671 [outfile]Put String[ [compiled]Text ]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 24
diff changeset
1672 { 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
1673 }
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 REPL[New@Parser[]]
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1676 }
812673a8b1ea Converted old parser to new syntax (needs work, currently crashes interpreter
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1677 }