Mercurial > repos > rhope

annotate cbackend.rhope @ 76:004f0fc8941f

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Fix list implementation
author Mike Pavone <pavone@retrodev.com>
date Wed, 07 Jul 2010 00:36:59 -0400
parents 0083b2f7b3c7
children dbe95bfec970
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
12
31f8182f3433 Finished fib test and did some small work on the c backend
Mike Pavone <pavone@retrodev.com>
parents: 2
diff changeset
1 Import extendlib.rhope
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
2 Import backendutils.rhope
2
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
4 Blueprint Blueprint Def
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
5 {
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
6 Name
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
7 Fixed Size
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
8 Fields
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
9 Methods
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
10 }
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
11
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
12 Blueprint Def[name]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
13 {
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
14 out <- [[[[Build["Blueprint Def"]]Name <<[name]]Fixed Size <<[0]]Fields <<[()]]Methods <<[Dictionary[]]
2
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
15 }
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
16
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
17 Blueprint C Method Registry
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
18 {
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
19 Lookup
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
20 Next ID
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
21 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
22
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
23 C Method Registry[:out]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
24 {
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
25 builtins <- [[[[[[[[[[[[[Dictionary[]
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
26 ]Set["+", "METHOD_ADD"]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
27 ]Set["-", "METHOD_SUB"]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
28 ]Set["/", "METHOD_DIV"]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
29 ]Set["*", "METHOD_MUL"]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
30 ]Set["LShift", "METHOD_LSHIFT"]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
31 ]Set["RShift", "METHOD_RSHIFT"]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
32 ]Set["=", "METHOD_EQUALS"]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
33 ]Set[">", "METHOD_GREATER"]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
34 ]Set["<", "METHOD_LESS"]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
35 ]Set["If", "METHOD_IF"]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
36 ]Set["Set Missing Field", "METHOD_SETFIELDMISSING"]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
37 ]Set["Get Missing Field", "METHOD_GETFIELDMISSING"]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
38 ]Set["Missing Method", "METHOD_MISSING"]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
39 out <- [[Build["C Method Registry"]]Lookup <<[builtins]]Next ID<<[0]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
40
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
41 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
42
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
43 Register Method@C Method Registry[reg,method:out]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
44 {
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
45 [[reg]Lookup >>]Index[method]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
46 {
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
47 out <- reg
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
48 }{
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
49 method ID <- [reg]Next ID>>
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
50 new lookup <- [[reg]Lookup >>]Set[method, ["METHOD_FIRST_USER+"]Append[method ID]]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
51 out <- [[reg]Lookup <<[new lookup]]Next ID <<[[method ID]+[1]]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
52 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
53 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
54
20
b715532225c0 Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents: 19
diff changeset
55 Method ID@C Method Registry[reg,method:out,notfound]
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
56 {
20
b715532225c0 Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents: 19
diff changeset
57 out,notfound <- [[reg]Lookup >>]Index[method]
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
58 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
59
34
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
60 Blueprint C Field Registry
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
61 {
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
62 Lookup
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
63 Next ID
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
64 }
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
65
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
66 C Field Registry[:out]
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
67 {
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
68 out <- [[Build["C Field Registry"]]Lookup <<[Dictionary[]]]Next ID<<[1]
34
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
69
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
70 }
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
71
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
72 Register Field@C Field Registry[reg,field:out]
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
73 {
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
74 [[reg]Lookup >>]Index[field]
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
75 {
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
76 out <- reg
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
77 }{
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
78 field ID <- [reg]Next ID>>
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
79 new lookup <- [[reg]Lookup >>]Set[field, field ID]
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
80 out <- [[reg]Lookup <<[new lookup]]Next ID <<[[field ID]+[1]]
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
81 }
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
82 }
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
83
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
84 Field ID@C Field Registry[reg,field:out,notfound]
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
85 {
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
86 out,notfound <- [[reg]Lookup >>]Index[field]
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
87 }
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
88
33
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
89 Blueprint C Type
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
90 {
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
91 Name
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
92 Fields
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
93 Methods
35
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
94 Init
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
95 Copy
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
96 Cleanup
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
97
33
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
98 }
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
99
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
100 C Type[name:out]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
101 {
35
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
102 out <- [[[[[[Build["C Type"]]Name <<[name]]Fields <<[()]]Methods <<[()]]Init <<["NULL"]]Copy <<["NULL"]]Cleanup <<["NULL"]
33
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
103 }
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
104
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
105 Add Field@C Type[ctype,name,type:out]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
106 {
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
107 out <- [ctype]Fields <<[ [[ctype]Fields >>]Append[ [[()]Append[name]]Append[type] ] ]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
108 }
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
109
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
110 Add Method@C Type[ctype,name:out]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
111 {
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
112 out <- [ctype]Methods <<[ [[ctype]Methods >>]Append[name] ]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
113 }
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
114
34
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
115 Register Methods@C Type[ctype,method reg:out]
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
116 {
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
117 out <- Fold["Register Method", method reg, [ctype]Methods >>]
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
118 }
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
119
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
120 _Register Field C[reg,field:out]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
121 {
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
122 name <- [field]Index[0]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
123 out <- [reg]Register Field[name]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
124 }
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
125
34
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
126 Register Fields@C Type[ctype,field reg:out]
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
127 {
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
128 out <- Fold["_Register Field C", field reg, [ctype]Fields >>]
34
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
129 }
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
130
38
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
131 Rhope Type to C[type:out,array]
34
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
132 {
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
133 If[[Type Of[type]]=["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
134 {
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
135 variant <- [type]Variant >>
38
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
136 If[[[type]Name >>] = ["Array"]]
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
137 {
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
138 [("Naked","Raw Pointer")]Find[variant]
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
139 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
140 /*
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
141 //Below code assumes that paramaterized types are implemented
38
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
142 pre param <- [[type]Params >>]Index[0] {}
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
143 { pre param <- Type Instance["Any Type"] }
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
144 [[type]Params >>]Index[1]
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
145 { param,param <- [pre param]Set Variant[~] }
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
146 { param <- Val[pre param] }
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
147 child type <- Rhope Type to C[param]
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
148 If[[variant] = ["Naked"]]
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
149 {
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
150 out <- Val[child type]
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
151 array <- "[1]"
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
152 }{
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
153 out <- [child type]Append[" *"]
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
154 array <- ""
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
155 } */
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
156 out <- "void *"
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
157 array <- ""
38
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
158 }{
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
159 typename <- "Array"
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
160 }
40
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
161 primitive <- No
38
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
162 }{
40
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
163 ,regulartype <- [("Naked","Raw Pointer")]Find[variant]
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
164 {
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
165 [("Int64","Int32","Int16","Int8")]Find[[type]Name >>]
40
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
166 {
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
167 primitive <- Yes
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
168 [[type]Name >>]Slice[3] {}
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
169 { typename <- [["int"]Append[~]]Append["_t"] }
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
170 }{
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
171 ,regulartype <- [("UInt64","UInt32","UInt16","UInt8")]Find[[type]Name >>]
40
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
172 {
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
173 primitive <- Yes
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
174 [[type]Name >>]Slice[4] {}
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
175 { typename <- [["uint"]Append[~]]Append["_t"] }
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
176 }
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
177 }
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
178 }
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
179
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
180 Val[regulartype]
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
181 {
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
182 typename <- [type]Name >>
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
183 primitive <- No
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
184 }
38
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
185 }
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
186 }{
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
187 typename <- type
38
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
188 param <- "Any Type"
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
189 variant <- "boxed"
40
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
190 primitive <- No
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
191 }
38
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
192 Val[typename]
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
193 { array <- "" }
34
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
194 If[[typename] = ["Any Type"]]
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
195 {
35
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
196 out <- "struct object *"
34
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
197 }{
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
198 [("Naked","Raw Pointer")]Find[variant]
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
199 {
40
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
200 If[primitive]
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
201 {
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
202 prefix <- ""
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
203 }{
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
204 prefix <- "nt_"
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
205 }
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
206 }{
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
207 prefix <- "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
208 }
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
209
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
210 If[[variant]=["Naked"]]
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
211 {
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
212 postfix <- ""
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
213 }{
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
214 postfix <- " *"
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
215 }
34
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
216 }
40
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
217 If[primitive]
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
218 {
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
219 escaped <- Val[typename]
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
220 }{
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
221 escaped <- Escape Rhope Name[typename]
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
222 }
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
223 out <- [[prefix]Append[escaped]]Append[postfix]
34
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
224 }
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
225
33
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
226 _Type Def C Type[text,field:out]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
227 {
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
228 name <- [field]Index[0]
38
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
229 ,postfix <- Rhope Type to C[[field]Index[1]]
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
230 { type <- ["\n\t"]Append[~] }
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
231
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
232 out <- [[[[text]Append[type]]Append[" "]]Append[[Escape Rhope Name[name]]Append[postfix]]]Append[";"]
33
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
233 }
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
234
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
235 Type Def@C Type[ctype:out]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
236 {
42
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
237 If[[[[ctype]Fields >>]Length] = [1]]
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
238 {
75
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
239 out <- [[[[_Type Def C Type["typedef struct {\n\tobject _SP_header;\n\t", [[ctype]Fields >>]Index[0]]]Append["\n} t_"]]Append[Escape Rhope Name[[ctype]Name >>]]]Append[";"]
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
240 ]Append[
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
241 [[[["typedef "
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
242 ]Append[Rhope Type to C[ [[[ctype]Fields >>]Index[0]]Index[1] ]]
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
243 ]Append[" nt_"]
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
244 ]Append[Escape Rhope Name[[ctype]Name >>]]
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
245 ]Append[";"] ]
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
246 }{
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
247 //HACK!!!
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
248 If[[[ctype]Name >>]=["Blueprint"]]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
249 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
250 out <- ""
74
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
251 }{
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
252 [("Array","Worker")]Find[[ctype]Name >>]
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
253 { oend <- "\nMObject(" }
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
254 { oend <- "\nObject(" }
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
255 out <- [Fold["_Type Def C Type", "OBegin", [ctype]Fields >>]]Append[ [[oend]Append[Escape Rhope Name[[ctype]Name >>]]]Append[")"] ]
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
256 }
42
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
257 }
33
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
258 }
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
259
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
260 _Type Init C[type name,method reg,text,method:out]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
261 {
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
262 out <- [[text]Append[[["\n\tadd_method(bp, "]Append[ [method reg]Method ID[method] ]]Append[ [[", MethodName("]Append[Escape Rhope Name[method]]]Append[[","]Append[Escape Rhope Name[type name]]]]]]Append["));"]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
263 }
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
264
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
265 _Type Init C Field[type name,field reg,text,field:out]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
266 {
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
267 fname <- [field]Index[0]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
268 out <- [[[[text]Append[[["\n\tadd_getter(bp, "]Append[ [field reg]Field ID[fname] ]]Append[ [[", MethodName("]Append[Escape Rhope Name[[fname]Append[" >>"]]]]Append[[","]Append[Escape Rhope Name[type name]]]]]]Append["));"]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
269 ]Append[[["\n\tadd_setter(bp, "]Append[ [field reg]Field ID[fname] ]]Append[ [[", MethodName("]Append[Escape Rhope Name[[fname]Append[" <<"]]]]Append[[","]Append[Escape Rhope Name[type name]]]]]]Append["));"]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
270 }
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
271
33
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
272 Type Init@C Type[ctype,id,method reg,field reg:out]
74
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
273 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
274 [("Array","Worker")]Find[[ctype]Name >>]
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
275 { size <- "-1" }
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
276 {
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
277 [("Int64","Int32","Int16","Int8")]Find[[ctype]Name >>]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
278 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
279 [[ctype]Name >>]Slice[3] {}
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
280 { typename <- [["int"]Append[~]]Append["_t"] }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
281 }{
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
282 [("UInt64","UInt32","UInt16","UInt8")]Find[[ctype]Name >>]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
283 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
284 [[ctype]Name >>]Slice[4] {}
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
285 { typename <- [["uint"]Append[~]]Append["_t"] }
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
286 }{
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
287 If[[[ctype]Name >>]=["Blueprint"]]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
288 { typename <- "blueprint *" }
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
289 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
290 If[[[ctype]Name >>]=["Boolean"]]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
291 { typename <- "int32_t" }
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
292 { typename <- ["nt_"]Append[Escape Rhope Name[[ctype]Name >>]] }
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
293 }
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
294 }
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
295 }
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
296 size <- [["sizeof("]Append[typename]]Append[")"]
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
297 }
35
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
298 start <- [["\tbp = register_type_byid("
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
299 ]Append[id]
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
300 ]Append[
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
301 [[", "]Append[size]
35
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
302 ]Append[
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
303 [", (special_func)"]Append[
35
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
304 [
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
305 [[[[Escape Rhope Name NU[[ctype]Init >>]
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
306 ]Append[", (special_func)"]
35
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
307 ]Append[Escape Rhope Name NU[[ctype]Copy >> ]]
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
308 ]Append[", (special_func)"]
35
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
309 ]Append[Escape Rhope Name NU[[ctype]Cleanup >>]]
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
310 ]Append[");"]]] ]
66
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
311 out <- Val[start]//Fold[[["_Type Init C Field"]Set Input[0, [ctype]Name >>]]Set Input[1, field reg], Fold[[["_Type Init C"]Set Input[0, [ctype]Name >>]]Set Input[1, method reg], start, [ctype]Methods >>], [ctype]Fields >>]
33
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
312 }
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
313
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
314 Blueprint C Type Registry
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
315 {
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
316 Lookup
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
317 Definitions
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
318 Next ID
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
319 }
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
320
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
321 C Type Registry[:out]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
322 {
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
323 out <- [[[Build["C Type Registry"]]Lookup << [
74
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
324 [[[[[[[[[[[[[[[[[[Dictionary[]
75
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
325 ]Set["UInt8", "TYPE_UINT8"] //1
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
326 ]Set["UInt16", "TYPE_UINT16"] //2
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
327 ]Set["UInt32", "TYPE_UINT32"] //3
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
328 ]Set["UInt64", "TYPE_UINT64"] //4
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
329 ]Set["Int8", "TYPE_INT8"] //5
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
330 ]Set["Int16", "TYPE_INT16"] //6
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
331 ]Set["Int32", "TYPE_INT32"] //7
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
332 ]Set["Int64", "TYPE_INT64"] //8
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
333 ]Set["Boolean", "TYPE_BOOLEAN"] //9
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
334 ]Set["Float32", "TYPE_FLOAT32"] //10
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
335 ]Set["Float64", "TYPE_FLOAT64"] //11
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
336 ]Set["Real Number", "TYPE_FLOAT64"] //12
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
337 ]Set["Blueprint", "TYPE_BLUEPRINT"] //13
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
338 ]Set["Array", "TYPE_ARRAY"] //14
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
339 ]Set["Worker", "TYPE_WORKER"] //15
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
340 ]Set["Method Missing Exception", "TYPE_METHODMISSINGEXCEPTION"] //16
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
341 ]Set["Field Missing Exception", "TYPE_FIELDMISSINGEXCEPTION"] //17
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
342 ]Set["Wrong Type Exception", "TYPE_WRONGTYPEEXCEPTION"]] //18
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
343 ]Definitions << [Dictionary[]]
33
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
344 ]Next ID <<[0]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
345 }
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
346
34
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
347 _Type Defs C[text,def:out]
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
348 {
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
349 out <- [[text]Append[[def]Type Def]]Append["\n\n"]
34
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
350 }
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
351
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
352 Type Defs@C Type Registry[reg:out]
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
353 {
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
354 out <- Fold["_Type Defs C", "", [reg]Definitions >>]
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
355 }
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
356
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
357 _Type Inits C[reg,method reg,field reg,text,def,name:out]
33
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
358 {
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
359 out <- [[text]Append[ [def]Type Init[[reg]Type ID[name], method reg, field reg] ]]Append["\n\n"]
34
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
360 }
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
361
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
362 Type Inits@C Type Registry[reg,method reg,field reg:out]
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
363 {
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
364 out <- Fold[[[["_Type Inits C"]Set Input[0, reg]]Set Input[1, method reg]]Set Input[2, field reg], "", [reg]Definitions >>]
34
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
365 }
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
366
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
367 Register Type@C Type Registry[reg,def:out]
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
368 {
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
369 name <- [def]Name >>
33
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
370 [[reg]Lookup >>]Index[name]
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
371 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
372 [[reg]Definitions >>]Index[name]
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
373 {
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
374 out <- reg
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
375 }{
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
376 out <- [reg]Definitions <<[[[reg]Definitions >>]Set[name, def]]
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
377 }
33
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
378 }{
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
379 out <- [[[reg]Lookup <<[ [[reg]Lookup >>]Set[name, ["TYPE_FIRST_USER+"]Append[[reg]Next ID >>]] ]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
380 ]Definitions <<[ [[reg]Definitions >>]Set[name, def] ]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
381 ]Next ID <<[ [[reg]Next ID >>]+[1] ]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
382 }
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
383 }
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
384
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
385 Type ID@C Type Registry[reg,name:out,notfound]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
386 {
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
387 out <- [[reg]Lookup >>]Index[name] {}
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
388 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
389 ,notfound <- If[[name]=["Any Type"]]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
390 { out <- "0" }
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
391 }
33
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
392 }
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
393
42
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
394 Simple Type?@C Type Registry[reg,name:yep,nope,notfound]
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
395 {
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
396 ,notfound <- [[reg]Definitions >>]Index[name]
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
397 {
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
398 yep,nope <- If[[[[~]Fields >>]Length] = [1]]
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
399 }
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
400 }
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
401
2
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
402 Blueprint C Function
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
403 {
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
404 Name
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
405 Inputs
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
406 Outputs
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
407 Convention
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
408 Variables
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
409 Statements
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
410 Method Registry
35
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
411 Field Registry
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
412 Type Registry
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
413 Constants
35
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
414 Input Types
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
415 Output Types
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
416 Resume Index
66
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
417 Last NumParams
2
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
418 }
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
419
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
420 C Function[name,inputs,outputs,convention:out]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
421 {
42
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
422 out <- C Function With Registry[name,inputs,outputs,convention, C Method Registry[], C Field Registry[], C Type Registry[]]
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
423 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
424
42
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
425 C Function With Registry[name,inputs,outputs,convention,registry,field reg,type reg:out]
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
426 {
66
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
427 out <- [[[[[[[[[[[[[[Build["C Function"]
2
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
428 ]Name <<[name]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
429 ]Inputs <<[inputs]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
430 ]Outputs <<[outputs]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
431 ]Convention <<[convention]
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
432 ]Variables <<[Dictionary[]]
2
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
433 ]Statements <<[()]
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
434 ]Method Registry <<[registry]
35
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
435 ]Field Registry <<[field reg]
42
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
436 ]Type Registry <<[type reg]
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
437 ]Constants <<[Dictionary[]]
35
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
438 ]Input Types <<[ Fold[["Append"]Set Input[1, "Any Type"], (), inputs] ]
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
439 ]Output Types <<[ Fold[["Append"]Set Input[1, "Any Type"], (), outputs] ]
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
440 ]Resume Index <<[1]
66
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
441 ]Last NumParams <<[-1]
35
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
442 }
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
443
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
444 Set Input Type@C Function[func,type,input num:out]
35
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
445 {
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
446 out <- [func]Input Types <<[ [[func]Input Types >>]Set[input num, type] ]
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
447 }
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
448
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
449 Set Output Type@C Function[func,type,output num:out]
35
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
450 {
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
451 out <- [func]Output Types <<[ [[func]Output Types >>]Set[output num, type] ]
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
452 }
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
453
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
454 Register Constant@C Function[func,name,constant:out]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
455 {
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
456 out <- [func]Constants <<[ [[func]Constants >>]Set[name, constant] ]
2
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
457 }
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
458
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
459 Allocate Var@C Function[func,name,type:out]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
460 {
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
461 out <- [func]Variables <<[ [[func]Variables >>]Set[name,type] ]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
462 }
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
463
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
464 Add Statement@C Function[func,statement:out]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
465 {
12
31f8182f3433 Finished fib test and did some small work on the c backend
Mike Pavone <pavone@retrodev.com>
parents: 2
diff changeset
466 out <- [func]Statements <<[ [[func]Statements >>]Append[["\t"]Append[[statement]Append[";\n"]]] ]
2
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
467 }
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
468
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
469 Add Raw Line@C Function[func,line:out]
2
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
470 {
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
471 out <- [func]Statements <<[ [[func]Statements >>]Append[["\t"]Append[[line]Append["\n"]]] ]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
472 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
473
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
474 Add Operator Statement@C Function[func,psource1,psource2,pdest,op:out]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
475 {
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
476 source1 <- [psource1]Make Op[func]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
477 source2 <- [psource2]Make Op[func]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
478 dest <- [pdest]Make Op[func]
2
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
479 out <- [func]Add Statement[[[[[dest]Append[" = "]]Append[source1]]Append[op]]Append[source2]]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
480 }
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
481
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
482 Add@C Function[func,source1,source2,dest:out]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
483 {
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
484 out <- [func]Add Operator Statement[source1,source2,dest," + "]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
485 }
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
486
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
487 Sub@C Function[func,source1,source2,dest:out]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
488 {
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
489 out <- [func]Add Operator Statement[source1,source2,dest," - "]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
490 }
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
491
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
492 Multiply@C Function[func,source1,source2,dest:out]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
493 {
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
494 out <- [func]Add Operator Statement[source1,source2,dest," * "]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
495 }
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
496
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
497 Divide@C Function[func,source1,source2,dest:out]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
498 {
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
499 out <- [func]Add Operator Statement[source1,source2,dest," / "]
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
500 }
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
501
48
a24eb366195c Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents: 42
diff changeset
502 DoLShift@C Function[func,source1,source2,dest:out]
a24eb366195c Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents: 42
diff changeset
503 {
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
504 out <- [func]Add Operator Statement[source1,source2,dest," << "]
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
505 }
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
506
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
507 DoRShift@C Function[func,source1,source2,dest:out]
a24eb366195c Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents: 42
diff changeset
508 {
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
509 out <- [func]Add Operator Statement[source1,source2,dest," >> "]
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
510 }
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
511
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
512 CompLess@C Function[func,source1,source2,dest:out]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
513 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
514 out <- [func]Add Operator Statement[source1,source2,dest," < "]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
515 }
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
516
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
517 CompGreater@C Function[func,source1,source2,dest:out]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
518 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
519 out <- [func]Add Operator Statement[source1,source2,dest," > "]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
520 }
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
521
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
522 CompEqual@C Function[func,source1,source2,dest:out]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
523 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
524 out <- [func]Add Operator Statement[source1,source2,dest," == "]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
525 }
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
526
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
527 CompLessEqual@C Function[func,source1,source2,dest:out]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
528 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
529 out <- [func]Add Operator Statement[source1,source2,dest," <= "]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
530 }
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
531
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
532 CompGreaterEqual@C Function[func,source1,source2,dest:out]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
533 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
534 out <- [func]Add Operator Statement[source1,source2,dest," >= "]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
535 }
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
536
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
537 CompNotEqual@C Function[func,source1,source2,dest:out]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
538 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
539 out <- [func]Add Operator Statement[source1,source2,dest," != "]
2
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
540 }
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
541
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
542 Move@C Function[func,psource,pdest:out]
2
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
543 {
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
544 source <- [psource]Make Op[func]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
545 dest <- [pdest]Make Op[func]
2
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
546 out <- [func]Add Statement[[[dest]Append[" = "]]Append[source]]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
547 }
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
548
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
549 Do AddRef@C Function[func,psource,pdest:out]
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
550 {
35
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
551 source <- [psource]Make Op[func]
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
552 dest <- [pdest]Make Op[func]
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
553 out <- [func]Add Statement[[[[dest]Append[" = add_ref((object *)"]]Append[source]]Append[")"]]
35
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
554 }
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
555
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
556 AddRef No Dest@C Function[func,psource:out]
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
557 {
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
558 source <- [psource]Make Op[func]
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
559 out <- [func]Add Statement[[["add_ref((object *)"]Append[source]]Append[")"]]
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
560 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
561
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
562 Release@C Function[func,psource:out]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
563 {
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
564 source <- [psource]Make Op[func]
66
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
565 out <- [func]Add Statement[[["release_ref((object *)"]Append[source]]Append[")"]]
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
566 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
567
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
568 Set Null@C Function[func,pdest:out]
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
569 {
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
570 dest <- [pdest]Make Op[func]
18
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
571 out <- [func]Add Statement[[dest]Append[" = NULL"]]
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
572 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
573
74
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
574 Lookup Constant@C Function[func,const,doaddref:out]
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
575 {
74
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
576 var <- ["_const_"]Append[Escape Rhope Name[const]]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
577 If[doaddref]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
578 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
579 out <- [["add_ref("]Append[var]]Append[")"]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
580 }{
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
581 out <- Val[var]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
582 }
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
583 }
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
584
35
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
585 Field Result@C Function[func,var,field:out]
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
586 {
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
587 as op <- [var]Make Op[func]
42
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
588 If[[Type Of[var]] = ["String"]]
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
589 {
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
590 [[func]Inputs >>]Find[var]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
591 {
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
592 type <- [[func]Input Types >>]Index[~]
42
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
593 }{
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
594 type <- [[func]Variables >>]Index[var] {}
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
595 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
596 [[func]Outputs >>]Find[var]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
597 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
598 type <- [[func]Output Types >>]Index[~]
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
599 }{
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
600 //Does it make sense for us to do this?
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
601 type <- Type Instance["Any Type"]
48
a24eb366195c Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents: 42
diff changeset
602 }
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
603 }
42
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
604 }
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
605 }{
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
606 type <- Type Instance["Any Type"]
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
607 }
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
608 If[[[func]Convention >>] = ["rhope"]]
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
609 {
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
610 If[[type] = ["Any Type"]]
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
611 {
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
612 rvar <- Val[as op]
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
613 }{
42
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
614 rvar <- [[[["(("]Append[ Rhope Type to C[type] ]]Append[")("]]Append[as op]]Append["))"]
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
615 }
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
616 }{
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
617 rvar <- Val[as op]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
618 }
42
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
619
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
620 [[func]Type Registry >>]Simple Type?[[type]Name >>]
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
621 { access <- "->" }
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
622 { access <- "->payload." }
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
623 out <- [[rvar]Append[access]]Append[Escape Rhope Name[field]]
35
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
624 }
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
625
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
626 Read Field@C Function[func,var,field:out,result op]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
627 {
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
628 out <- func
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
629 result op <- Field Ref[var,field]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
630 }
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
631
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
632 Write Field@C Function[func,var,field:out,result op]
35
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
633 {
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
634 out <- func
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
635 result op <- Field Ref[var,field]
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
636 }
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
637
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
638 Set Field Null@C Function[func,var,field:out]
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
639 {
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
640 out <- [func]Add Statement[ [[func]Field Result[var,field]]Append[" = NULL"] ]
35
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
641 }
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
642
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
643 Copy@C Function[func,pdest:out]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
644 {
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
645 dest <- [pdest]Make Op[func]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
646 out <- [func]Add Statement[ [dest]Append[[[" = copy_object("]Append[dest]]Append[")"]] ]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
647 }
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
648
42
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
649 Box@C Function[func,psource,pdest,type:out]
40
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
650 {
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
651 dest <- [pdest]Make Op[func]
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
652 source <- [psource]Make Op[func]
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
653 out <- [func]Add Statement[
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
654 [[[[[dest
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
655 ]Append[" = naked_to_boxed("]
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
656 ]Append[ [[func]Type Registry >>]Type ID[[type]Name >>] ]
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
657 ]Append[", &"]
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
658 ]Append[source]
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
659 ]Append[")"] ]
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
660 }
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
661
42
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
662 Unbox@C Function[func,psource,pdest:out]
40
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
663 {
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
664 dest <- [pdest]Make Op[func]
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
665 source <- [psource]Make Op[func]
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
666 out <- [func]Add Statement[
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
667 [[[["boxed_to_naked("
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
668 ]Append[source]
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
669 ]Append[", &"]
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
670 ]Append[dest]
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
671 ]Append[")"] ]
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
672 }
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
673
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
674 Get Raw Pointer@C Function[func,psource,pdest:out]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
675 {
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
676 dest <- [pdest]Make Op[func]
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
677 source <- [psource]Make Op[func]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
678 out <- [func]Add Statement[ [[[dest]Append[" = &("]]Append[source]]Append["->payload)"] ]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
679 }
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
680
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
681 Array Raw Pointer@C Function[func,psource,pdest:out]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
682 {
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
683 dest <- [pdest]Make Op[func]
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
684 source <- [psource]Make Op[func]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
685 out <- [func]Add Statement[ [[[dest]Append[" = ((char *)"]]Append[source]]Append[")+ sizeof(t_Array)"] ]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
686 }
40
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
687
18
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
688 _Function Arg C[func,val,inputnum:out]
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
689 {
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
690 out <- [func]Add Raw Line[
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
691 [[[["SetParam("
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
692 ]Append[inputnum]
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
693 ]Append[", "]
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
694 ]Append[val]
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
695 ]Append[")"]
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
696 ]
74
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
697 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
698
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
699 _Val Function Arg C[func,val,inputnum,worker:out]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
700 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
701 out <- [func]Add Raw Line[
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
702 [[[[[["VCSetParam("
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
703 ]Append[worker]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
704 ]Append[", "]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
705 ]Append[inputnum]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
706 ]Append[", "]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
707 ]Append[val]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
708 ]Append[")"]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
709 ]
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
710 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
711
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
712 Method Call@C Function[func,method,args:out]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
713 {
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
714 out <- [func]Call[method,args]
74
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
715 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
716
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
717 Val Call@C Function[func,to call,args:out]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
718 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
719 worker <- Make Op[Strip Addref[to call], func]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
720 rargs <- Map[args, ["Make Op"]Set Input[1, func]]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
721
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
722 If[[[func]Last NumParams >>] = [-1]]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
723 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
724 freed <- Val[func]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
725 }{
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
726 freed <- [func]Add Raw Line["FreeCall"]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
727 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
728 prepped <- [[freed]Add Raw Line[
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
729 [[[["VCPrepCall("
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
730 ]Append[worker]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
731 ]Append[", "]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
732 ]Append[[rargs]Length]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
733 ]Append[")"] ]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
734 ]Last NumParams <<[[rargs]Length]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
735
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
736
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
737 out <- [[[[Fold[["_Val Function Arg C"]Set Input[3, worker], prepped, rargs]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
738 ]Add Raw Line[
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
739 [[[[[[[["ValCall("
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
740 ]Append[worker]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
741 ]Append[", "]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
742 ]Append[[rargs]Length]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
743 ]Append[", "]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
744 ]Append[[func]Resume Index >>]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
745 ]Append[", "]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
746 ]Append[Escape Rhope Name[[func]Name >>]]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
747 ]Append[")"]]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
748 ]Add Raw Line["DISPATCH"]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
749 ]Add Raw Line[
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
750 [[[["ValCallPostlude("
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
751 ]Append[[func]Resume Index >>]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
752 ]Append[", "]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
753 ]Append[Escape Rhope Name[[func]Name >>]]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
754 ]Append[")"]]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
755 ]Resume Index <<[ [[func]Resume Index >>]+[1] ]
18
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
756 }
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
757
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
758 Call@C Function[func,name,args:out]
74
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
759 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
760 If[[name]=["Call@Worker"]]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
761 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
762 //TODO: Handle case when user explicitly calls the fully qualified version, but the type of the first arg isn't Worker
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
763 out <- [func]Val Call[[args]Index[0], Tail[args,1]]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
764 }{
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
765 If[[name]=["Call"]]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
766 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
767 to call <- [args]Index[0]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
768 out <- [[[[[func]Add Raw Line[[["if (get_blueprint("]Append[Make Op[Strip Addref[to call], func]]]Append[")->type_id == TYPE_WORKER) {"]]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
769 ]Val Call[to call, Tail[args,1]]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
770 ]Add Raw Line["} else {"]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
771 ]Func Base["Call",args, "Call"]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
772 ]Add Raw Line["}"]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
773 }{
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
774 out <- [func]Func Base[Escape Rhope Name[name],args, "Call"]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
775 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
776 }
18
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
777 }
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
778
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
779 Func Base@C Function[func,tocall,args,type:out]
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
780 {
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
781 rargs <- Map[args, ["Make Op"]Set Input[1, func]]
66
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
782
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
783 If[[[rargs]Length] > [[func]Last NumParams >>]]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
784 {
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
785 If[[[func]Last NumParams >>] = [-1]]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
786 {
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
787 freed <- Val[func]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
788 }{
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
789 freed <- [func]Add Raw Line["FreeCall"]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
790 }
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
791 prepped <- [[freed]Add Raw Line[ [["PrepCall("]Append[[rargs]Length]]Append[")"] ]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
792 ]Last NumParams <<[[rargs]Length]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
793 }{
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
794 prepped <- Val[func]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
795 }
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
796
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
797
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
798 out <- [[Fold["_Function Arg C", prepped, rargs]
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
799 ]Add Raw Line[
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
800 [[[[[[[[[type]Append["("]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
801 ]Append[tocall]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
802 ]Append[", "]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
803 ]Append[[rargs]Length]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
804 ]Append[", "]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
805 ]Append[[func]Resume Index >>]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
806 ]Append[", "]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
807 ]Append[Escape Rhope Name[[func]Name >>]]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
808 ]Append[")"]]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
809 ]Resume Index <<[ [[func]Resume Index >>]+[1] ]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
810 }
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
811
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
812 Call Foreign@C Function[func,name,language,args,store result:out]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
813 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
814 rargs <- Map[args, ["Make Op"]Set Input[1, func]]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
815 //Assume language = "C" for now
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
816 base <- [[[name]Append["("]]Append[ Join[rargs, ", "] ]]Append[")"]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
817 ,do store <- If[[Type Of[store result]]=["String"]]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
818 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
819 ,do store <- If[[store result]=[""]]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
820 { stmt <- Val[base] }
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
821 }
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
822
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
823 Val[do store]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
824 { stmt <- [[Make Op[store result, func]]Append[" = "]]Append[base] }
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
825 out <- [func]Add Statement[stmt]
18
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
826 }
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
827
35
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
828 Get Field Call@C Function[func,field,source:out]
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
829 {
66
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
830 out <- [func]Func Base[Escape Rhope Name[[field]Append[" >>"]], [()]Append[source], "Call"]
35
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
831 }
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
832
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
833 Set Field Call@C Function[func,field,object,value:out]
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
834 {
66
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
835 out <- [func]Func Base[Escape Rhope Name[[field]Append[" <<"]], [[()]Append[object]]Append[value], "Call"]
35
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
836 }
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
837
18
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
838 Tail Method Call@C Function[func,method,args:out]
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
839 {
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
840 out <- [func]Func Base[[[func]Method Registry >>]Method ID[method],args, "TMCall"]
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
841 }
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
842
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
843 Tail Call@C Function[func,name,args:out]
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
844 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
845 out <- [func]Func Base[Escape Rhope Name[name],args, "TCall"]
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
846 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
847
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
848 Resolve@C Function[func,op:out]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
849 {
35
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
850 If[[[func]Convention >>] = ["rhope"]]
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
851 {
35
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
852 [[func]Inputs >>]Find[op]
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
853 {
66
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
854 out <- [["my_cdata->params["]Append[~]]Append[" ]"]
35
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
855 }{
66
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
856 out <- [[["lv_"]Append[Escape Rhope Name[[func]Name >>]]]Append["->"]]Append[Escape Rhope Name[op]]
35
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
857 }
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
858 }{
35
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
859 out <- Escape Rhope Name[op]
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
860 }
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
861 }
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
862
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
863 Resolve Output@C Function[func,name:out]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
864 {
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
865 If[[[func]Convention >>] = ["rhope"]]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
866 {
66
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
867 out <- [[["lv_"]Append[Escape Rhope Name[[func]Name >>]]]Append["->"]]Append[Escape Rhope Name[name]]
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
868 }{
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
869 out <- Escape Rhope Name[name]
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
870 }
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
871 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
872
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
873 Instruction Stream@C Function[func:out]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
874 {
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
875 out <- [func]Statements <<[()]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
876 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
877
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
878 _If C[func, statement:out]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
879 {
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
880 out <- [func]Statements <<[ [[func]Statements >>]Append[ ["\t"]Append[statement] ] ]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
881 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
882
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
883 Do If@C Function[func,condition,stream:out]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
884 {
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
885 cond <- [condition]Make Op[func]
66
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
886 out <- [[Fold["_If C", [[func
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
887 ]Add Raw Line[ [["if("]Append[cond]]Append[")"] ]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
888 ]Add Raw Line["{"], [stream]Statements >>]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
889 ]Add Raw Line["}"]
66
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
890 ]Resume Index <<[[stream]Resume Index >>]
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
891
75
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
892 }
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
893
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
894 Discard Outputs@C Function[func,first to discard:out]
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
895 {
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
896 out <- [[[[[func
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
897 ]Add Raw Line[[["for(idx = "]Append[first to discard]]Append["; idx < cdata->num_params; ++idx)"]]
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
898 ]Add Raw Line["{"]
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
899 ]Add Raw Line[" if (cdata->params[idx])"]
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
900 ]Add Raw Line[" release_ref(cdata->params[idx]);"]
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
901 ]Add Raw Line["}"]
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
902 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
903
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
904 Result Reference@C Function[func,output:out]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
905 {
66
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
906 out <- [["cdata->params["]Append[output]]Append["]"]
75
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
907 }
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
908
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
909 Checked Result Reference@C Function[func,output:out]
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
910 {
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
911 out <- [[[["("]Append[output]]Append[" < cdata->num_params ? cdata->params["]]Append[output]]Append["] : NULL)"]
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
912 }
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
913
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
914
21
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 20
diff changeset
915 If Null Else@C Function[func,left,right:out]
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
916 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
917 check <- [[Make Condition[left]]Strip Addref]Make Op[func]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
918 l <- [left]Make Op[func]
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
919 r <- [right]Make Op[func]
21
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 20
diff changeset
920 out <- [[[[[["("
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
921 ]Append[check]
21
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 20
diff changeset
922 ]Append[" ? "]
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
923 ]Append[l]
21
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 20
diff changeset
924 ]Append[" : "]
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
925 ]Append[r]
21
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 20
diff changeset
926 ]Append[")"]
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 20
diff changeset
927 }
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 20
diff changeset
928
66
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
929 _Set Outputs C[string,inputname,inputnum,func:out]
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
930 {
74
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
931 out <- [string]Append[[[ [ ["\tRet("]Append[inputnum] ]Append[ [[", lv_"]Append[Escape Rhope Name[[func]Name >>]]]Append["->"]]]Append[Escape Rhope Name[inputname]]]Append[")\n"]]
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
932 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
933
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
934 Set Outputs@C Function[func:out]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
935 {
35
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
936 If[[[func]Convention >>] = ["rhope"]]
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
937 {
66
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
938 out <- [[[Fold[["_Set Outputs C"]Set Input[3, func], "", [func]Outputs >>]]Append["\tNumRet("]]Append[[[func]Outputs >>]Length]]Append[")\n"]
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
939 }{
35
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
940 [[func]Outputs >>]Index[0]
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
941 {
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
942 out <- [["\treturn "]Append[Escape Rhope Name[~]]]Append[";\n"]
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
943 }{
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
944 out <- ""
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
945 }
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
946 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
947 }
35
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
948 _Output Defs C[string,varname,index,func:out]
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
949 {
42
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
950 out <- [[[string]Append[ ["\t"]Append[Rhope Type to C[[[func]Output Types >>]Index[index]]] ]]Append[[" "]Append[Escape Rhope Name[varname]]]]Append[";\n"]
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
951 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
952 _Var Defs C[string,type,varname:out]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
953 {
42
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
954 out <- [[[string]Append[ ["\t"]Append[Rhope Type to C[type]] ]]Append[[" "]Append[Escape Rhope Name[varname]]]]Append[";\n"]
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
955 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
956
18
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
957
2
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
958 Definitions@C Function[func:out]
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
959 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
960 Print[["Definitions@C Function: "]Append[[func]Name >>]]
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
961 {
35
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
962 If[ [[[func]Convention >>] = ["rhope"]] And [[ [[[func]Variables >>]Length]+[[[func]Outputs >>]Length] ] > [0]] ]
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
963 {
66
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
964 localtype <- [[[Fold[["_Output Defs C"]Set Input[3, func], Fold["_Var Defs C","typedef struct {\n", [func]Variables >>], [func]Outputs >>]]Append["} lt_"]]Append[Escape Rhope Name[[func]Name >>]]]Append[";\n"]
35
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
965 }{
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
966 localtype <- ""
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
967 }
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
968
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
969 If[ [[func]Convention >>] = ["rhope"] ]
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
970 {
65
1db811fa4744 Handle native Rhope functions and plain C functions separately as part of move to new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 64
diff changeset
971 /* parts <- [[func]Name >>]Split["@"]
35
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
972 [parts]Index[1]
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
973 {
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
974 proto <- [[[["MethodDef("
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
975 ]Append[Escape Rhope Name[[parts]Index[0]]]
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
976 ]Append[", "]
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
977 ]Append[Escape Rhope Name[~]]
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
978 ]Append[")\n"]
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
979 }{
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
980 proto <- [["FuncDef("]Append[Escape Rhope Name[[func]Name >>]]]Append[")\n"]
66
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
981 } */
65
1db811fa4744 Handle native Rhope functions and plain C functions separately as part of move to new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 64
diff changeset
982 out <- Val[localtype]
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
983 }{
65
1db811fa4744 Handle native Rhope functions and plain C functions separately as part of move to new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 64
diff changeset
984 out <- [[func]Naked Proto]Append[";\n"]
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
985 }
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
986 }
35
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
987 }
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
988
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
989 _Proto Input[list,input,index,types:out]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
990 {
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
991 out <- [list]Append[ [[Rhope Type to C[[types]Index[index]]]Append[" "]]Append[Escape Rhope Name[input]] ]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
992 }
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
993
35
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
994 Naked Proto@C Function[func:out]
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
995 {
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
996 [[func]Output Types >>]Index[0]
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
997 {
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
998 outtype <- [Rhope Type to C[~]]Append[" "]
35
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
999 }{
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
1000 outtype <- "void "
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
1001 }
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
1002 out <- [[[[outtype
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
1003 ]Append[ Escape Rhope Name NU[[func]Name >>]]
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
1004 ]Append["("]
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1005 ]Append[ [Fold[["_Proto Input"]Set Input[3, [func]Input Types >>], (), [func]Inputs >>]]Join[", "] ]
35
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
1006 ]Append[")"]
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1007 }
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1008
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1009 Type Check@C Function[func,text,type,input num:out]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1010 {
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1011 If[[type] = ["Any Type"]]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1012 {
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1013 out <- text
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1014 }{
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1015 out <- [text]Append[ [["\tParam("]Append[input num]]Append[ [[", "]Append[ [[func]Type Registry >>]Type ID[type] ]]Append[")"] ] ]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1016 }
2
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1017 }
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1018
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
1019 Check Param Type C[text,type,input num,func: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
1020 {
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
1021 If[[Type Of[type]] = ["String"]]
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
1022 {
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
1023 typename <- 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
1024 }{
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
1025 typename <- [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
1026 }
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
1027 If[[typename] = ["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
1028 {
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
1029 out <- text
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
1030 }{
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
1031 out <- [text]Append[[[["\tParam("]Append[input num]]Append[ [","]Append[ [[func]Type Registry >>]Type ID[typename] ] ]]Append[")\n"]]
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
1032 }
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
1033 }
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
1034
2
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1035 Text@C Function[func:out]
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1036 {
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1037 Print[["Text@C Function: "]Append[[func]Name >>]]
34
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
1038 If[ [[func]Convention >>] = ["rhope"] ]
66
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1039 {
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1040 ,before <- [[func]Name >>]Get DString["@"]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1041 {
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1042 type <- "MethodImpl"
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1043 cname <- [[[[Escape Rhope Name[before]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1044 ]Append[", "]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1045 ]Append[Escape Rhope Name[~]]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1046 ]Append[", "]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1047 ]Append[ [[func]Type Registry >>]Type ID[~] ]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1048 }{}{}{
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1049 type <- "Func"
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1050 cname <- Val[fname]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1051 }
65
1db811fa4744 Handle native Rhope functions and plain C functions separately as part of move to new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 64
diff changeset
1052 fname <- Escape Rhope Name[[func]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
1053 param check <- Fold[["Check Param Type C"]Set Input[3, func], "", [func]Input Types >>]
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1054 If[ [ [[[func]Variables >>]Length]+[[[func]Outputs >>]Length] ] = [0] ]
34
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
1055 {
66
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1056 out <- [[[[[[[[ [type]Append["NoLocals("]
34
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
1057 ]Append[cname]
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
1058 ]Append[",\n\tNumParams "]
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
1059 ]Append[ [[func]Inputs >>]Length ]
65
1db811fa4744 Handle native Rhope functions and plain C functions separately as part of move to new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 64
diff changeset
1060 ]Append[")\n\n"]
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
1061 ]Append[param check]
34
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
1062 ]Append[ [[func]Statements >>]Join[""] ]
66
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1063 ]Append["EndFuncNoLocals\n"]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1064 ]Append["DISPATCH"]
34
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
1065 }{
66
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1066 If[[[func]Last NumParams >>] = [-1]]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1067 {
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1068 freecall <- ""
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1069 }{
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1070 freecall <- "\n\tFreeCall\n"
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1071 }
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1072 out <- [[[[[[[[[[ [type]Append["("]
34
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
1073 ]Append[cname]
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
1074 ]Append[",\n\tNumParams "]
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
1075 ]Append[ [[func]Inputs >>]Length ]
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
1076 ]Append[")\n\n"]
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
1077 ]Append[param check]
34
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
1078 ]Append[ [[func]Statements >>]Join[""] ]
66
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1079 ]Append[freecall]
34
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
1080 ]Append[[func]Set Outputs]
66
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1081 ]Append[[["EndFunc("]Append[fname]]Append[")\n"]]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1082 ]Append["DISPATCH"]
34
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
1083 }
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1084 }{
35
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
1085
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
1086 out <- [[[
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
1087 Fold[["_Output Defs C"]Set Input[3, func],
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
1088 Fold["_Var Defs C", [[func]Naked Proto]Append["\n{"], [func]Variables >>], [func]Outputs >>]
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
1089 ]Append[[[func]Statements >>]Join[""]]
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
1090 ]Append[[func]Set Outputs]
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 34
diff changeset
1091 ]Append["}"]
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1092 }
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
1093 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
1094
19
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
1095 Blueprint C Program
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
1096 {
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
1097 Functions
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
1098 Method Registry
34
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
1099 Field Registry
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1100 Type Registry
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1101 Libraries
19
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
1102 }
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
1103
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
1104 C Program[:out]
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
1105 {
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1106 out <- [[[[[Build["C Program"]]Functions <<[Dictionary[]]]Method Registry <<[C Method Registry[]]]Type Registry <<[C Type Registry[]]]Field Registry <<[C Field Registry[]]]Libraries <<[Dictionary[]]
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1107 }
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1108
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1109 Link@C Program[program,language,library:out]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1110 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1111 If[[library] = ["runtime"]]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1112 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1113 out <- program
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1114 }{
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1115 langlibs <- [[program]Libraries >>]Index[language] {}
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1116 { langlibs <- Dictionary[] }
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1117 out <- [program]Libraries <<[ [[program]Libraries >>]Set[language, [langlibs]Set[library, Yes]] ]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1118 }
34
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
1119 }
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
1120
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
1121 Register Type@C Program[program,def:out]
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
1122 {
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
1123 out <- [[[program]Type Registry <<[ [[program]Type Registry >>]Register Type[def] ]
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
1124 ]Method Registry <<[ [def]Register Methods[[program]Method Registry >>] ]
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
1125 ]Field Registry <<[ [def]Register Fields[[program]Field Registry >>] ]
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
1126 }
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
1127
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
1128 Create Type@C Program[program,name:out]
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
1129 {
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
1130 out <- C Type[name]
19
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
1131 }
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
1132
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
1133 Create Function@C Program[program,name,inputs,outputs,convention:out]
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
1134 {
42
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
1135 out <- C Function With Registry[name,inputs,outputs,convention, [program]Method Registry >>, [program]Field Registry >>, [program]Type Registry >>]
19
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
1136 }
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
1137
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
1138 Store Function@C Program[program,func:out]
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
1139 {
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
1140 out <- [program]Functions <<[ [[program]Functions >>]Set[ [func]Name >>, func] ]
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
1141 }
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
1142
20
b715532225c0 Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents: 19
diff changeset
1143 Method?@C Program[program,funcname:is,isnot]
b715532225c0 Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents: 19
diff changeset
1144 {
b715532225c0 Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents: 19
diff changeset
1145 is,isnot <- [[program]Method Registry >>]Method ID[funcname]
b715532225c0 Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents: 19
diff changeset
1146 }
b715532225c0 Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents: 19
diff changeset
1147
19
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
1148 _Defs C Program[text,func:out]
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
1149 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1150 def <- [func]Definitions
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1151 If[[def]=[""]]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1152 {
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1153 out <- text
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1154 }{
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1155 out <- [text]Append[[def]Append["\n\n"]]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1156 }
19
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
1157 }
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
1158
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1159 _Text C Program[text,func,type reg:out]
19
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
1160 {
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1161 out <- [text]Append[[[ [func]Type Registry <<[type reg] ]Text]Append["\n\n"]]
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1162 }
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1163
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1164 Combine Consts[consts,func:out]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1165 {
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1166 out <- Combine[[func]Constants >>, consts]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1167 }
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1168
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1169 _Consts C Program[text,value,name:out]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1170 {
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1171 out <- [text]Append[ [["object * _const_"]Append[Escape Rhope Name[name]]]Append[";\n"] ]
74
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1172 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1173
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1174 Const Construct C[value,type reg:out]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1175 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1176 valtype <- Type Of[value]
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1177 [("Int32","Whole Number")]Find[valtype]
74
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1178 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1179 out <- [["make_Int32("]Append[value]]Append[")"]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1180 }{
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
1181 If[[valtype] = ["Type Instance"]]
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1182 {
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1183 //TODO: Support parametric types
74
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1184 typeid <- [type reg]Type ID[[value]Name >>]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1185 out <- [["make_Blueprint("]Append[typeid]]Append[")"]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1186 }{
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
1187 If[[valtype] = ["Yes No"]]
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
1188 {
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
1189 If[value]
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
1190 {
74
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1191 out <- "make_Bool(1)"
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
1192 }{
74
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1193 out <- "make_Bool(0)"
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
1194 }
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1195 }{
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1196 If[[valtype] = ["Machine Integer"]]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1197 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1198 If[[value]Signed? >>]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1199 { s <- "I" }
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1200 { s <- "UI" }
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1201
74
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1202 out <- [[[[[["make_"
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1203 ]Append[s]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1204 ]Append["nt"]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1205 ]Append[[value]Size >>]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1206 ]Append["("]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1207 ]Append[[value]Value >>]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1208 ]Append[")"]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1209 }{
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1210 If[[valtype] = ["String"]]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1211 {
75
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
1212 out <- [["make_String(\""]Append[ [[[value]Replace["\\", "\\\\"]]Replace["\n", "\\n"]]Replace["\"", "\\\""] ]]Append["\")"]
74
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1213 }{
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1214 If[[valtype]=["Worker Literal"]]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1215 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1216 //TODO: Figure out how to fully support these in nested cases
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1217 //or workaround the problem higher up in the food chain
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1218 [[value]Args >>]Last
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1219 { size <- [~]+[1] }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1220 { size <- "0" }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1221 out <- [[[[[["make_Worker(FUNC_"
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1222 ]Append[Escape Rhope Name[[value]Name >>]]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1223 ]Append[", "]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1224 ]Append[size]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1225 ]Append[", "]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1226 ]Append[[[value]Args >>]Length]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1227 ]Append[")"]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1228 }{
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1229 out <- "UnhandledLiteralType"
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1230 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1231 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1232 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1233 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1234 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1235
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1236 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1237 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1238
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1239 _Set Worker Params C[text,param,num,type reg,name:out]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1240 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1241 out <- [text]Append[
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1242 [[[[[["\t((object **)(((t_Worker *)_const_"
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1243 ]Append[name]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1244 ]Append[")+1))["]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1245 ]Append[num]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1246 ]Append["] = "]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1247 ]Append[Const Construct C[param, type reg]]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1248 ]Append[";\n"] ]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1249 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1250
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1251 _Set Consts C Program[text,value,name,type reg:out]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1252 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1253 valtype <- Type Of[value]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1254 [("String","Worker Literal")]Find[valtype]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1255 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1256 out <- text
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1257 }{
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1258 Const Construct C[value,type reg]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1259 { out <- [text]Append[ [[[["\t_const_"]Append[Escape Rhope Name[name]]]Append[" = "]]Append[~]]Append[";\n"] ] }
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1260 }
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1261 }
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1262
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1263 _Set Late Consts C[text,value,name,type reg:out]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1264 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1265 valtype <- Type Of[value]
74
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1266 [("String","Worker Literal")]Find[valtype]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1267 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1268 Const Construct C[value,type reg]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1269 { init <- [text]Append[ [[[["\t_const_"]Append[Escape Rhope Name[name]]]Append[" = "]]Append[~]]Append[";\n"] ] }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1270
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1271 If[[valtype]=["Worker Literal"]]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1272 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1273 out <- Fold[[["_Set Worker Params C"]Set Input[3, type reg]]Set Input[4, Escape Rhope Name[name]], init, [value]Args >>]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1274 }{
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1275 out <- Val[init]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1276 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1277 }{
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1278 out <- text
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1279 }
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1280 }
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1281
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1282 _Dispatch Switch Sub[text, num, name:out]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1283 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1284 out <- [[[[[[[[[text
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1285 ]Append["\tcase RES_"]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1286 ]Append[num]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1287 ]Append["_"]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1288 ]Append[name]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1289 ]Append[": goto r"]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1290 ]Append[num]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1291 ]Append["_"]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1292 ]Append[name]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1293 ]Append[";\\\n"]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1294 }
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1295
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1296 _Dispatch Switch[text,func,raw name:out]
66
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1297 {
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1298 If[[[func]Convention >>] = ["rhope"]]
65
1db811fa4744 Handle native Rhope functions and plain C functions separately as part of move to new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 64
diff changeset
1299 {
1db811fa4744 Handle native Rhope functions and plain C functions separately as part of move to new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 64
diff changeset
1300 name <- Escape Rhope Name[raw name]
1db811fa4744 Handle native Rhope functions and plain C functions separately as part of move to new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 64
diff changeset
1301 out <- [[text]Append[ [[[["\tcase FUNC_"]Append[name]]Append[": goto f_"]]Append[name]]Append[";\\\n"] ]
66
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1302 ]Append[Fold[["_Dispatch Switch Sub"]Set Input[2, name], "", Range[1, [func]Resume Index >>]]]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1303 }{
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1304 out <- text
65
1db811fa4744 Handle native Rhope functions and plain C functions separately as part of move to new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 64
diff changeset
1305 }
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1306 }
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1307
66
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1308 _Dispatch Switch Methods[text,id,raw name:out]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1309 {
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1310 name <- Escape Rhope Name[raw name]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1311 out <- [text]Append[ [[[["\tcase FUNC_"]Append[name]]Append[": goto f_"]]Append[name]]Append[";\\\n"] ]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1312 }
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1313
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1314 _Dispatch Enum Sub[text, num, name:out]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1315 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1316 out <- [[[[[text
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1317 ]Append["\tRES_"]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1318 ]Append[num]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1319 ]Append["_"]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1320 ]Append[name]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1321 ]Append[",\n"]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1322 }
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1323
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1324 _Dispatch Enum[text,func,raw name:out]
66
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1325 {
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1326 If[[[func]Convention >>] = ["rhope"]]
65
1db811fa4744 Handle native Rhope functions and plain C functions separately as part of move to new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 64
diff changeset
1327 {
1db811fa4744 Handle native Rhope functions and plain C functions separately as part of move to new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 64
diff changeset
1328 name <- Escape Rhope Name[raw name]
1db811fa4744 Handle native Rhope functions and plain C functions separately as part of move to new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 64
diff changeset
1329 out <- [[text]Append[ [["\tFUNC_"]Append[name]]Append[",\n"] ]
66
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1330 ]Append[Fold[["_Dispatch Enum Sub"]Set Input[2, name], "", Range[1, [func]Resume Index >>]]]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1331 }{
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1332 out <- text
65
1db811fa4744 Handle native Rhope functions and plain C functions separately as part of move to new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 64
diff changeset
1333 }
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1334 }
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1335
66
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1336 _Dispatch Enum Methods[text,types,name:out]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1337 {
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1338 out <- [text]Append[ [["\tFUNC_"]Append[Escape Rhope Name[name]]]Append[",\n"] ]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1339 }
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1340
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1341 Dispatch@C Program[program,all methods:out]
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1342 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1343 out <- [[[[["typedef enum {\n"
66
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1344 ]Append[Fold["_Dispatch Enum",
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1345 [Fold["_Dispatch Enum Methods", "", all methods]]Append["\tFUNC_Build,\n\tFUNC_BlueprintSP_Of,\n"],
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1346 [program]Functions >>]]
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1347 ]Append["\tEND\n} funcids;\n\n"]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1348 ]Append["#define DISPATCH switch(func) { \\\n"]
66
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1349 ]Append[Fold["_Dispatch Switch",
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1350 [Fold["_Dispatch Switch Methods", "", all methods]]Append["\tcase FUNC_Build: goto f_Build;\\\n\tcase FUNC_BlueprintSP_Of: goto f_BlueprintSP_Of;\\\n"],
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1351 [program]Functions >>]]
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1352 ]Append["\tcase END: goto DO_END;\\\n}\n\n"]
66
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1353 }
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1354
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1355 Not Native[func:out]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1356 {
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1357 If[[[func]Convention >>] = ["rhope"]]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1358 { out <- No }
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1359 { out <- Yes }
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1360 }
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1361
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1362 Native[func:out]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1363 {
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1364 out <- [[func]Convention >>] = ["rhope"]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1365 }
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1366
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1367 Local Pointers[text,func:out]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1368 {
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1369 If[ [ [[[func]Variables >>]Length]+[[[func]Outputs >>]Length] ] = [0] ]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1370 {
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1371 out <- text
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1372 }{
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1373 out <- [text]Append[[["\tFuncDef("]Append[Escape Rhope Name[[func]Name >>]]]Append[")\n"]]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1374 }
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1375 }
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1376
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1377 _Method to Types[dict,name,type:out]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1378 {
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1379 typelist <- [dict]Index[name] {}
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1380 { typelist <- () }
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1381
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1382 out <- [dict]Set[name, [typelist]Append[[type]Name >>]]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1383
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1384 }
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1385
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1386 _Field to Types[dict,field,type:out]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1387 {
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1388 name <- [field]Index[0]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1389 out <- _Method to Types[_Method to Types[dict, [name]Append[" >>"], type], [name]Append[" <<"], type]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1390
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1391 }
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1392
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1393 Method to Types[dict,type:out]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1394 {
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1395 out <- Fold[["_Method to Types"]Set Input[2, type], dict, [type]Methods >>]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1396 }
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1397
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1398 Field to Types[dict,type:out]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1399 {
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1400 out <- Fold[["_Field to Types"]Set Input[2, type], dict, [type]Fields >>]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1401 }
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1402
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1403 _Method Dispatch[text, type, method, reg: out]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1404 {
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1405 out <- [[[[[[[text]Append["\tMethodDispatch("]]Append[ [reg]Type ID[type] ]]Append[","]]Append[Escape Rhope Name[method]]]Append[","]]Append[Escape Rhope Name[type]]]Append[")\n"]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1406 }
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1407
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1408 Method Dispatch[text, types, method, reg: out]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1409 {
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1410 out <- [[[Fold[[["_Method Dispatch"]Set Input[2, method]]Set Input[3, reg], [[[text]Append["Method("]]Append[ Escape Rhope Name[method] ]]Append[")\n"], types]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1411 ]Append["EndMethod("]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1412 ]Append[Escape Rhope Name[method]]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1413 ]Append[")\n\n"]
19
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
1414 }
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
1415
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
1416 Text@C Program[program:out]
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
1417 {
66
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1418 type defs <- [[program]Type Registry >>]Definitions >>
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
1419 constants <- Fold["Combine Consts", Dictionary[], [program]Functions >>]
66
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1420 all methods <- Fold["Field to Types", Fold["Method to Types", Dictionary[], type defs], type defs]
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1421 headers <- "#include <stdio.h>
66
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1422 #include <stdlib.h>
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1423 #include \"builtin.h\"
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1424 #include \"object.h\"
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1425 #include \"context.h\"
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1426 #include \"func.h\"
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1427 #include \"integer.h\"
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1428 #include \"blueprint.h\"
74
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1429 #include \"array.h\"
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1430 #include \"worker.h\"
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
1431 #include \"bool.h\"\n\n"
66
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1432 out <- [[[[[[[[[[[[[[[headers
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1433 ]Append[[program]Dispatch[all methods]]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1434 ]Append[[[program]Type Registry >>]Type Defs]
65
1db811fa4744 Handle native Rhope functions and plain C functions separately as part of move to new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 64
diff changeset
1435 ]Append[Fold["_Consts C Program",
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1436 Fold["_Defs C Program", "", [program]Functions >>],
65
1db811fa4744 Handle native Rhope functions and plain C functions separately as part of move to new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 64
diff changeset
1437 constants]]
66
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1438 ]Append[Fold[["_Text C Program"]Set Input[2, [program]Type Registry >>], "", Filter[[program]Functions >>, "Not Native"]]]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1439 ]Append["\n
75
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
1440 int32_t rhope(uint32_t func, object ** params, uint16_t numparams, uint16_t callspace)
66
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1441 {
74
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1442 uint16_t resume,idx, vcparam_offset, last_vcparam;
66
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1443 context * ct;
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1444 calldata * cdata, *temp_cdata, *my_cdata;\n\nFuncDef(Build)\nFuncDef(BlueprintSP_Of)\n"]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1445 ]Append[Fold["Local Pointers", "", [program]Functions >>]]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1446 ]Append["
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1447 ct = new_context();
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1448 cdata = alloc_cdata(ct, NULL, callspace);
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1449 cdata->num_params = numparams;
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1450 for(idx = 0; idx < numparams; ++idx)
75
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
1451 cdata->params[idx] = params[idx];
66
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1452 cdata->func = END;
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1453 DISPATCH\n"]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1454 ]Append[Fold[["Method Dispatch"]Set Input[3, [program]Type Registry >>], "", all methods]]
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1455 ]Append["
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1456 Func(Build,
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1457 NumParams 1)
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1458
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1459 Param(0, TYPE_BLUEPRINT)
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1460
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1461 lv_Build->bp = ((t_Blueprint *)(cdata->params[0]))->bp;
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1462 release_ref(cdata->params[0]);
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1463
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1464 Ret(0, new_object_bp(lv_Build->bp))
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1465 EndFunc(Build)
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1466 DISPATCH
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1467
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1468 Func(BlueprintSP_Of,
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1469 NumParams 1)
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1470
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1471 lv_BlueprintSP_Of->bp = get_blueprint(cdata->params[0]);
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1472 release_ref(cdata->params[0]);
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1473
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1474 Ret(0, new_object(TYPE_BLUEPRINT))
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1475 ((t_Blueprint *)cdata->params[0])->bp = lv_BlueprintSP_Of->bp;
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1476 EndFunc(BlueprintSP_Of)
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1477 DISPATCH\n"]
65
1db811fa4744 Handle native Rhope functions and plain C functions separately as part of move to new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 64
diff changeset
1478 ]Append[Fold[["_Text C Program"]Set Input[2, [program]Type Registry >>], "", Filter[[program]Functions >>, "Native"]]]
66
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1479 ]Append["
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1480 DO_END:
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1481 for(idx = 0; idx < cdata->num_params; ++idx)
75
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
1482 params[idx] = cdata->params[idx];
66
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1483 free_context(ct);
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1484 return cdata->num_params;
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1485
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1486 _exception:
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1487 puts(\"Exception! Trace follows:\");
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1488 while(cdata && cdata->func != END)
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1489 {
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1490 printf(\"%d\\n\", cdata->func);
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1491 cdata = cdata->lastframe;
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1492 }
75
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
1493 return -1;
66
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1494 }
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1495
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1496 #include \"builtin.c\"
74
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1497 #include \"array.c\"
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 72
diff changeset
1498 #include \"worker.c\"
66
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1499
d4b44ae2e34a New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents: 65
diff changeset
1500 int main(int argc, char **argv)
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1501 {
75
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
1502 blueprint * bp;
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
1503 int numret;
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
1504 int idx;
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
1505 object * inout[2];
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1506 register_builtin_types();\n\n"]
34
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
1507 ]Append[ [[program]Type Registry >>]Type Inits[[program]Method Registry >>, [program]Field Registry >>] ]
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1508 ]Append[Fold[["_Set Consts C Program"]Set Input[3, [program]Type Registry >>], "", constants]]
54
243d013a49cb Defer processing of string literals until after simpler ones to avoid a segfault
Mike Pavone <pavone@retrodev.com>
parents: 52
diff changeset
1509 ]Append[Fold[["_Set Late Consts C"]Set Input[3, [program]Type Registry >>], "", constants]]
75
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
1510 ]Append["
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
1511 rhope(FUNC_List, inout, 0, 1);
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
1512 for (idx = 0; idx < argc; ++idx)
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
1513 {
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
1514 inout[1] = make_String(argv[idx]);
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
1515 rhope(FUNC_Append, inout, 2, 2);
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
1516 }
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
1517 numret = rhope(FUNC_Main, inout, 1, 1);
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
1518 if (!numret)
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
1519 return 0;
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
1520 if (numret < 0)
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
1521 return numret;
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
1522 if (get_blueprint(inout[0])->type_id == TYPE_INT32)
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
1523 return ((t_Int32 *)inout[0])->Num;
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
1524
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
1525 rhope(FUNC_If, inout, 1, 2);
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
1526 if (inout[0])
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
1527 return 0;
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents: 74
diff changeset
1528 return 1;
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1529 }\n\n"]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1530
19
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
1531 }
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
1532
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
1533