Mercurial > repos > rhope

annotate cbackend.rhope @ 64:e1fd6d244f14

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Some progress on updating C backend to work with new C strategy
author Mike Pavone <pavone@retrodev.com>
date Sun, 30 May 2010 17:34:36 -0400
parents 243d013a49cb
children 1db811fa4744
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
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
3 Import number.rhope
2
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
4
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
5 Blueprint Blueprint Def
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
6 {
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
7 Name
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
8 Fixed Size
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
9 Fields
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
10 Methods
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
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
13 Blueprint Def[name]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
14 {
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
15 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
16 }
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
17
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
18 Blueprint C Method Registry
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
19 {
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
20 Lookup
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
21 Next ID
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
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
24 C Method Registry[:out]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
25 {
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
26 builtins <- [[[[[[[[[[[[[Dictionary[]
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
27 ]Set["+", "METHOD_ADD"]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
28 ]Set["-", "METHOD_SUB"]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
29 ]Set["/", "METHOD_DIV"]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
30 ]Set["*", "METHOD_MUL"]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
31 ]Set["LShift", "METHOD_LSHIFT"]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
32 ]Set["RShift", "METHOD_RSHIFT"]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
33 ]Set["=", "METHOD_EQUALS"]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
34 ]Set[">", "METHOD_GREATER"]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
35 ]Set["<", "METHOD_LESS"]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
36 ]Set["If", "METHOD_IF"]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
37 ]Set["Set Missing Field", "METHOD_SETFIELDMISSING"]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
38 ]Set["Get Missing Field", "METHOD_GETFIELDMISSING"]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
39 ]Set["Missing Method", "METHOD_MISSING"]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
40 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
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
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
44 Register Method@C Method Registry[reg,method:out]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
45 {
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
46 [[reg]Lookup >>]Index[method]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
47 {
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
48 out <- reg
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
49 }{
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
50 method ID <- [reg]Next ID>>
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
51 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
52 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
53 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
54 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
55
20
b715532225c0 Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents: 19
diff changeset
56 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
57 {
20
b715532225c0 Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents: 19
diff changeset
58 out,notfound <- [[reg]Lookup >>]Index[method]
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
59 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
60
34
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
61 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
62 {
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
63 Lookup
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
64 Next ID
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
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
67 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
68 {
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
69 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
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
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
73 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
74 {
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
75 [[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
76 {
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
77 out <- reg
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
78 }{
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
79 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
80 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
81 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
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
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
85 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
86 {
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
87 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
88 }
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
89
33
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
90 Blueprint C Type
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
91 {
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
92 Name
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
93 Fields
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
94 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
95 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
96 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
97 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
98
33
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
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
101 C Type[name:out]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
102 {
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
103 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
104 }
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
105
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
106 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
107 {
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
108 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
109 }
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
110
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
111 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
112 {
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
113 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
114 }
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
115
34
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
116 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
117 {
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
118 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
119 }
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
120
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
121 _Register Field C[reg,field:out]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
122 {
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
123 name <- [field]Index[0]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
124 out <- [reg]Register Field[name]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
125 }
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
126
34
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
127 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
128 {
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
129 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
130 }
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
131
38
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
132 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
133 {
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
134 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
135 {
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
136 variant <- [type]Variant >>
38
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
137 If[[[type]Name >>] = ["Array"]]
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
138 {
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
139 [("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
140 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
141 /*
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
142 //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
143 pre param <- [[type]Params >>]Index[0] {}
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
144 { pre param <- Type Instance["Any Type"] }
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
145 [[type]Params >>]Index[1]
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
146 { param,param <- [pre param]Set Variant[~] }
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
147 { param <- Val[pre param] }
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
148 child type <- Rhope Type to C[param]
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
149 If[[variant] = ["Naked"]]
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
150 {
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
151 out <- Val[child type]
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
152 array <- "[1]"
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
153 }{
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
154 out <- [child type]Append[" *"]
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
155 array <- ""
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
156 } */
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
157 out <- "void *"
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
158 array <- ""
38
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
159 }{
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
160 typename <- "Array"
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
161 }
40
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
162 primitive <- No
38
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
163 }{
40
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
164 ,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
165 {
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
166 [("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
167 {
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
168 primitive <- Yes
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
169 [[type]Name >>]Slice[3] {}
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
170 { 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
171 }{
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
172 ,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
173 {
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
174 primitive <- Yes
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
175 [[type]Name >>]Slice[4] {}
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
176 { 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
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
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
181 Val[regulartype]
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
182 {
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
183 typename <- [type]Name >>
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
184 primitive <- No
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
185 }
38
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
186 }
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
187 }{
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
188 typename <- type
38
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
189 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
190 variant <- "boxed"
40
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
191 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
192 }
38
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
193 Val[typename]
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
194 { array <- "" }
34
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
195 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
196 {
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
197 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
198 }{
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
199 [("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
200 {
40
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
201 If[primitive]
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
202 {
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
203 prefix <- ""
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
204 }{
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
205 prefix <- "nt_"
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
206 }
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
207 }{
640f541e9116 Added support for type declarations on user defined workers 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 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
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
640f541e9116 Added support for type declarations on user defined workers 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 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
212 {
640f541e9116 Added support for type declarations on user defined workers 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 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
214 }{
640f541e9116 Added support for type declarations on user defined workers 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 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
216 }
34
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
217 }
40
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
218 If[primitive]
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
219 {
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
220 escaped <- Val[typename]
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
221 }{
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
222 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
223 }
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
224 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
225 }
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
226
33
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
227 _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
228 {
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
229 name <- [field]Index[0]
38
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
230 ,postfix <- Rhope Type to C[[field]Index[1]]
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
231 { type <- ["\n\t"]Append[~] }
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
232
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
233 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
234 }
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
235
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
236 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
237 {
42
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
238 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
239 {
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
240 out <- [[[_Type Def C Type["typedef struct {\n\tobject _SP_header;\n\t", [[ctype]Fields >>]Index[0]]]Append["\n} t_"]]Append[[ctype]Name >>]]Append[";"]
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
241 }{
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
242 //HACK!!!
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
243 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
244 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
245 out <- ""
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 If[[[ctype]Name >>]=["Array"]]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
248 { oend <- "\nMObject(" }
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
249 { 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
250 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
251 }
42
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
252 }
33
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
253 }
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
254
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
255 _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
256 {
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
257 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
258 }
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
259
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
260 _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
261 {
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
262 fname <- [field]Index[0]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
263 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
264 ]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
265 }
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
266
33
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
267 Type Init@C Type[ctype,id,method reg,field reg:out]
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
268 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
269 If[[[ctype]Name >>]=["Array"]]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
270 { size <- "-1" }
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
271 {
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
272 [("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
273 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
274 [[ctype]Name >>]Slice[3] {}
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
275 { 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
276 }{
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
277 [("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
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[4] {}
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
280 { 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
281 }{
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
282 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
283 { typename <- "blueprint *" }
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
284 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
285 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
286 { 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
287 { 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
288 }
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
289 }
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
290 }
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
291 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
292 }
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
293 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
294 ]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
295 ]Append[
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
296 [[", "]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
297 ]Append[
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
298 [", (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
299 [
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
300 [[[[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
301 ]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
302 ]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
303 ]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
304 ]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
305 ]Append[");"]]] ]
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
306 out <- 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
307 }
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
308
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
309 Blueprint C Type Registry
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
310 {
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
311 Lookup
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
312 Definitions
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
313 Next ID
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
314 }
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 C Type Registry[:out]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
317 {
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
318 out <- [[[Build["C Type Registry"]]Lookup << [
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
319 [[[[[[[[[[[[[[[[[Dictionary[]
33
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
320 ]Set["UInt8", "TYPE_UINT8"]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
321 ]Set["UInt16", "TYPE_UINT16"]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
322 ]Set["UInt32", "TYPE_UINT32"]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
323 ]Set["UInt64", "TYPE_UINT64"]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
324 ]Set["Int8", "TYPE_INT8"]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
325 ]Set["Int16", "TYPE_INT16"]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
326 ]Set["Int32", "TYPE_INT32"]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
327 ]Set["Int64", "TYPE_INT64"]
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
328 ]Set["Boolean", "TYPE_BOOLEAN"]
33
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
329 ]Set["Float32", "TYPE_FLOAT32"]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
330 ]Set["Float64", "TYPE_FLOAT64"]
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
331 ]Set["Real Number", "TYPE_FLOAT64"]
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
332 ]Set["Blueprint", "TYPE_BLUEPRINT"]
33
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
333 ]Set["Array", "TYPE_ARRAY"]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
334 ]Set["Method Missing Exception", "TYPE_METHODMISSINGEXCEPTION"]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
335 ]Set["Field Missing Exception", "TYPE_FIELDMISSINGEXCEPTION"]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
336 ]Set["Wrong Type Exception", "TYPE_WRONGTYPEEXCEPTION"]]
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
337 ]Definitions << [Dictionary[]]
33
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
338 ]Next ID <<[0]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
339 }
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
340
34
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
341 _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
342 {
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
343 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
344 }
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
345
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
346 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
347 {
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
348 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
349 }
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 _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
352 {
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
353 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
354 }
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 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
357 {
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
358 out <- Fold[[[["_Type Inits C"]Set Input[0, reg]]Set Input[1, method reg]]Set Input[2, field reg], "", [reg]Definitions >>]
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
359 { Print["Type inits got output"] }
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 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
363 {
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
364 name <- [def]Name >>
33
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
365 [[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
366 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
367 [[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
368 {
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
369 out <- reg
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
370 }{
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
371 Print[["Registered def for "]Append[name]]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
372 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
373 }
33
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
374 }{
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
375 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
376 ]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
377 ]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
378 }
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
379 }
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
380
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
381 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
382 {
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
383 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
384 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
385 ,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
386 { out <- "0" }
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
387 }
33
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
388 }
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
389
42
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
390 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
391 {
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
392 Print[["Symple Type?: "]Append[name]]
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
393 ,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
394 {
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
395 Print["found type"]
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
396 yep,nope <- If[[[[~]Fields >>]Length] = [1]]
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
397 }{
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
398 Pretty Print[reg, ""]
42
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
2
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
417 }
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 C Function[name,inputs,outputs,convention:out]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
420 {
42
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
421 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
422 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
423
42
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
424 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
425 {
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
426 out <- [[[[[[[[[[[[[Build["C Function"]
2
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
427 ]Name <<[name]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
428 ]Inputs <<[inputs]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
429 ]Outputs <<[outputs]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
430 ]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
431 ]Variables <<[Dictionary[]]
2
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
432 ]Statements <<[()]
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
433 ]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
434 ]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
435 ]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
436 ]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
437 ]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
438 ]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
439 ]Resume Index <<[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
440 }
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
441
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
442 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
443 {
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
444 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
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
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
447 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
448 {
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
449 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
450 }
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
451
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
452 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
453 {
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
454 Print["Register Constant"]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
455 Print[name]
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] ]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
457 { Print["Got register constant output"] }
2
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
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
460 Allocate Var@C Function[func,name,type:out]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
461 {
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
462 Print[["Allocate Var: "]Append[name]]
2
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
463 out <- [func]Variables <<[ [[func]Variables >>]Set[name,type] ]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
464 }
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
465
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
466 Add Statement@C Function[func,statement:out]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
467 {
12
31f8182f3433 Finished fib test and did some small work on the c backend
Mike Pavone <pavone@retrodev.com>
parents: 2
diff changeset
468 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
469 }
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 Add Raw Line@C Function[func,line:out]
2
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
472 {
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
473 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
474 }
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 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
477 {
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
478 source1 <- [psource1]Make Op[func]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
479 source2 <- [psource2]Make Op[func]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
480 dest <- [pdest]Make Op[func]
2
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
481 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
482 }
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 Add@C Function[func,source1,source2,dest:out]
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 out <- [func]Add Operator Statement[source1,source2,dest," + "]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
487 }
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 Sub@C Function[func,source1,source2,dest:out]
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 out <- [func]Add Operator Statement[source1,source2,dest," - "]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
492 }
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 Multiply@C Function[func,source1,source2,dest:out]
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 out <- [func]Add Operator Statement[source1,source2,dest," * "]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
497 }
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 Divide@C Function[func,source1,source2,dest:out]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
500 {
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
501 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
502 }
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
503
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
504 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
505 {
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
506 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
507 }
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
508
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
509 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
510 {
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
511 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
512 }
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 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
515 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
516 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
517 }
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 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
520 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
521 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
522 }
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 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
525 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
526 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
527 }
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 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
530 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
531 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
532 }
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 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
535 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
536 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
537 }
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 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
540 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
541 out <- [func]Add Operator Statement[source1,source2,dest," != "]
2
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
542 }
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 Move@C Function[func,psource,pdest:out]
2
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
545 {
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
546 source <- [psource]Make Op[func]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
547 dest <- [pdest]Make Op[func]
2
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
548 out <- [func]Add Statement[[[dest]Append[" = "]]Append[source]]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
549 }
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
550
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
551 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
552 {
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
553 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
554 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
555 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
556 }
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 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
559 {
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
560 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
561 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
562 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
563
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
564 Release@C Function[func,psource:out]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
565 {
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
566 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
567 Print[["Release: "]Append[source]]
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
568 out <- [func]Add Statement[[["release_ref("]Append[source]]Append[")"]]
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
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
571 Set Null@C Function[func,pdest:out]
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 dest <- [pdest]Make Op[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
574 Print[["Set Null: "]Append[dest]]
18
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
575 out <- [func]Add Statement[[dest]Append[" = NULL"]]
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
576 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
577
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
578 Lookup Constant@C Function[func,const:out]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
579 {
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
580 out <- [["add_ref(_const_"]Append[Escape Rhope Name[const]]]Append[")"]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
581 }
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
582
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
583 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
584 {
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
585 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
586 If[[Type Of[var]] = ["String"]]
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
587 {
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
588 [[func]Inputs >>]Find[var]
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 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
591 }{
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
592 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
593 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
594 [[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
595 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
596 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
597 }{
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
598 //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
599 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
600 }
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
601 }
42
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
602 }
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
603 }{
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
604 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
605 }
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
606 If[[[func]Convention >>] = ["rhope"]]
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[[type] = ["Any Type"]]
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 rvar <- Val[as op]
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
611 }{
42
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
612 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
613 }
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
614 }{
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
615 rvar <- Val[as op]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
616 }
42
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
617
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
618 [[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
619 { access <- "->" }
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
620 { access <- "->payload." }
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
621 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
622 }
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
623
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
624 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
625 {
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
626 out <- func
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
627 result op <- Field Ref[var,field]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
628 }
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
629
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
630 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
631 {
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
632 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
633 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
634 }
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
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 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
637 {
42
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
638 Print["Set Field Null"]
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
639 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
640 }
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
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
642 Copy@C Function[func,pdest:out]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
643 {
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
644 dest <- [pdest]Make Op[func]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
645 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
646 }
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
647
42
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
648 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
649 {
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
650 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
651 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
652 out <- [func]Add Statement[
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
653 [[[[[dest
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
654 ]Append[" = naked_to_boxed("]
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
655 ]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
656 ]Append[", &"]
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
657 ]Append[source]
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
658 ]Append[")"] ]
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
659 }
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
660
42
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
661 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
662 {
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
663 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
664 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
665 out <- [func]Add Statement[
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
666 [[[["boxed_to_naked("
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
667 ]Append[source]
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
668 ]Append[", &"]
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
669 ]Append[dest]
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
670 ]Append[")"] ]
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
671 }
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 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
674 {
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
675 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
676 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
677 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
678 }
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 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
681 {
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
682 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
683 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
684 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
685 }
40
789a146a48e1 Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
686
18
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
687 _Function Arg C[func,val,inputnum:out]
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
688 {
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
689 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
690 [[[["SetParam("
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
691 ]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
692 ]Append[", "]
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
693 ]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
694 ]Append[")"]
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
695 ]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
696 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
697
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
698 Method Call@C Function[func,method,args:out]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
699 {
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
700 out <- [func]Call[method,args]
18
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
701 }
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
702
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
703 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
704 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
705 out <- [func]Func Base[Escape Rhope Name[name],args, "Call"]
18
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
706 }
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
707
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
708 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
709 {
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
710 rargs <- Map[args, ["Make Op"]Set Input[1, func]]
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
711 out <- [[Fold["_Function Arg C", [func]Add Raw Line[ [["PrepCall("]Append[[rargs]Length]]Append[")"] ], rargs]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
712 ]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
713 [[[[[[[[[type]Append["("]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
714 ]Append[tocall]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
715 ]Append[", "]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
716 ]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
717 ]Append[", "]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
718 ]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
719 ]Append[", "]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
720 ]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
721 ]Append[")"]]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
722 ]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
723 }
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
724
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
725 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
726 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
727 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
728 //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
729 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
730 ,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
731 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
732 ,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
733 { stmt <- Val[base] }
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
734 }
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
735
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
736 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
737 { 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
738 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
739 }
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
740
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
741 Field Base@C Function[func,field,args,type: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
742 {
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
743 rargs <- Map[args, ["Make Op"]Set Input[1, 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
744 out <- [Fold["_Function Arg C", func, rargs]
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
745 ]Add Raw Line[[[ [type]Append["("] ]Append[ [[func]Field Registry >>]Field ID[field] ]]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
746 }
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
747
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
748 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
749 {
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
750 out <- [func]Field Base[field, [()]Append[source], "GFieldCall"]
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
751 }
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
752
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
753 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
754 {
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
755 out <- [func]Field Base[field, [[()]Append[object]]Append[value], "SFieldCall"]
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
756 }
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
757
18
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
758 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
759 {
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
760 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
761 }
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
762
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
763 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
764 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
765 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
766 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
767
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
768 Resolve@C Function[func,op:out]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
769 {
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
770 If[[[func]Convention >>] = ["rhope"]]
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
771 {
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
772 [[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
773 {
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
774 out <- [["cdata->params["]Append[~]]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
775 }{
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
776 out <- ["locals->"]Append[Escape Rhope Name[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
777 }
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
778 }{
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
779 out <- Escape Rhope Name[op]
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
780 }
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
781 }
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
782
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
783 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
784 {
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
785 If[[[func]Convention >>] = ["rhope"]]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
786 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
787 out <- ["locals->"]Append[Escape Rhope Name[name]]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
788 }{
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
789 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
790 }
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
791 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
792
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
793 Instruction Stream@C Function[func:out]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
794 {
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
795 out <- [func]Statements <<[()]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
796 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
797
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
798 _If C[func, statement:out]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
799 {
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
800 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
801 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
802
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
803 Do If@C Function[func,condition,stream:out]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
804 {
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
805 cond <- [condition]Make Op[func]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
806 out <- [Fold["_If C", [[func
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
807 ]Add Raw Line[ [["if("]Append[cond]]Append[")"] ]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
808 ]Add Raw Line["{"], [stream]Statements >>]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
809 ]Add Raw Line["}"]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
810
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
811 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
812
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
813 Result Reference@C Function[func,output:out]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
814 {
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
815 out <- [["call->params["]Append[output]]Append["]"]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
816 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
817
21
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 20
diff changeset
818 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
819 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
820 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
821 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
822 r <- [right]Make Op[func]
21
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 20
diff changeset
823 out <- [[[[[["("
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
824 ]Append[check]
21
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 20
diff changeset
825 ]Append[" ? "]
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
826 ]Append[l]
21
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 20
diff changeset
827 ]Append[" : "]
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
828 ]Append[r]
21
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 20
diff changeset
829 ]Append[")"]
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 20
diff changeset
830 }
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 20
diff changeset
831
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
832 _Set Outputs C[string,inputname,inputnum:out]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
833 {
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
834 out <- [string]Append[[[ [ ["\tRet("]Append[inputnum] ]Append[", locals->"]]Append[inputname]]Append[")\n"]]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
835 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
836
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
837 Set Outputs@C Function[func:out]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
838 {
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
839 If[[[func]Convention >>] = ["rhope"]]
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
840 {
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
841 out <- Fold["_Set Outputs C", "", [func]Outputs >>]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
842 }{
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
843 [[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
844 {
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
845 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
846 }{
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
847 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
848 }
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
849 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
850 }
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
851 _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
852 {
42
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
853 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
854 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
855 _Var Defs C[string,type,varname:out]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
856 {
42
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
857 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
858 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
859
18
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
860
2
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
861 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
862 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
863 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
864 {
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
865 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
866 {
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
867 localtype <- [[[Fold[["_Output Defs C"]Set Input[3, func], Fold["_Var Defs C","typedef struct {\n", [func]Variables >>], [func]Outputs >>]]Append["} l_"]]Append[Escape Rhope Name[[func]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
868 }{
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
869 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
870 }
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
871
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
872 If[ [[func]Convention >>] = ["rhope"] ]
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
873 {
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
874 parts <- [[func]Name >>]Split["@"]
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
875 [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
876 {
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
877 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
878 ]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
879 ]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
880 ]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
881 ]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
882 }{
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
883 proto <- [["FuncDef("]Append[Escape Rhope Name[[func]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
884 }
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
885 }{
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
886 proto <- [[func]Naked Proto]Append[";\n"]
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
887 }
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
888 out <- [localtype]Append[proto]
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
889 }
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
890 }
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
891
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
892 _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
893 {
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
894 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
895 }
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
896
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
897 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
898 {
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
899 Print[["Naked Proto: "]Append[ [func]Name >>] ]
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
900 [[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
901 {
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
902 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
903 }{
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
904 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
905 }
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
906 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
907 ]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
908 ]Append["("]
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
909 ]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
910 ]Append[")"]
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
911 { Print[~] }
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
912 }
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
913
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
914 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
915 {
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
916 If[[type] = ["Any Type"]]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
917 {
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
918 out <- text
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
919 }{
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
920 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
921 }
2
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
922 }
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
923
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
924 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
925 {
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
926 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
927 {
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
928 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
929 }{
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
930 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
931 }
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
932 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
933 {
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
934 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
935 }{
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
936 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
937 }
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
938 }
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
939
2
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
940 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
941 {
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
942 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
943 If[ [[func]Convention >>] = ["rhope"] ]
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
944 {
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
945 cname <- 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
946 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
947 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
948 {
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
949 out <- [[[[[[["FuncNoLocals("
34
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
950 ]Append[cname]
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
951 ]Append[",\n\tNumParams "]
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
952 ]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
953 ]Append[",\n\tCallSpace 32)\n\n"]//TODO: Fill in with calculated callspace value
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
954 ]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
955 ]Append[ [[func]Statements >>]Join[""] ]
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
956 ]Append["EndFunc"]
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
957 }{
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
958 out <- [[[[[[[[[["Func("
34
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
959 ]Append[cname]
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
960 ]Append[",\n\tNumParams "]
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
961 ]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
962 ]Append[",\n\tCallSpace 32,\n\t"]//TODO: Fill in with calculated callspace value
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
963 ]Append[["l_"]Append[cname]]
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
964 ]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
965 ]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
966 ]Append[ [[func]Statements >>]Join[""] ]
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
967 ]Append[[func]Set Outputs]
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
968 ]Append["EndFunc"]
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
969 }
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
970 }{
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
971
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 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
973 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
974 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
975 ]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
976 ]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
977 ]Append["}"]
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
978 }
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
979 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
980
19
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
981 Blueprint C Program
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
982 {
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
983 Functions
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
984 Method Registry
34
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
985 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
986 Type Registry
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
987 Libraries
19
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
988 }
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
989
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
990 C Program[:out]
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
991 {
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
992 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
993 }
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
994
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
995 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
996 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
997 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
998 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
999 out <- program
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1000 }{
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1001 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
1002 { langlibs <- Dictionary[] }
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1003 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
1004 }
34
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
1005 }
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
1006
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
1007 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
1008 {
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
1009 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
1010 ]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
1011 ]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
1012 }
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
1013
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
1014 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
1015 {
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
1016 out <- C Type[name]
19
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
1017 }
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
1018
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
1019 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
1020 {
42
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 40
diff changeset
1021 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
1022 }
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
1023
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
1024 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
1025 {
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
1026 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
1027 }
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
1028
20
b715532225c0 Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents: 19
diff changeset
1029 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
1030 {
b715532225c0 Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents: 19
diff changeset
1031 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
1032 }
b715532225c0 Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents: 19
diff changeset
1033
19
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
1034 _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
1035 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1036 def <- [func]Definitions
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1037 If[[def]=[""]]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1038 {
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1039 out <- text
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1040 }{
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1041 out <- [text]Append[[def]Append["\n\n"]]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1042 }
19
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
1043 }
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
1044
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1045 _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
1046 {
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1047 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
1048 }
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1049
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1050 Combine Consts[consts,func:out]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1051 {
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1052 out <- Combine[[func]Constants >>, consts]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1053 }
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1054
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1055 _Consts C Program[text,value,name:out]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1056 {
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1057 out <- [text]Append[ [["object * _const_"]Append[Escape Rhope Name[name]]]Append[";\n"] ]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1058 }
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1059
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1060 _Set Consts C Program[text,value,name,type reg:out]
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1061 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1062 Print[["_Set Consts: "]Append[valtype]]
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1063 Pretty Print[value, "_Set Consts: "]
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1064 //TODO: Support more constant types
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1065 valtype <- Type Of[value]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1066 [("Int32","Whole Number")]Find[valtype]
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1067 {
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1068 out <- [text]Append[[[[["\t_const_"]Append[Escape Rhope Name[name]]]Append[" = make_Int32("]]Append[value]]Append[");\n"]]
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1069 { Print["_Set Consts got output integer"] }
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1070 }{
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
1071 If[[valtype] = ["Type Instance"]]
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1072 {
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1073 //TODO: Support parametric types
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1074 typeid <- [type reg]Type ID[[value]Name >>]
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1075 out <- [text]Append[[[[["\t_const_"]Append[Escape Rhope Name[name]]]Append[" = make_Blueprint("]]Append[typeid]]Append[");\n"]]
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1076 { Print["_Set Consts got output blueprint"] }
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 }{
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1078 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
1079 {
640f541e9116 Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents: 36
diff changeset
1080 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
1081 {
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1082 out <- [text]Append[[["\t_const_"]Append[Escape Rhope Name[name]]]Append[" = (object *)val_yes;\n"]]
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1083 { Print["_Set Consts got output yes"] }
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
1084 }{
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1085 out <- [text]Append[[["\t_const_"]Append[Escape Rhope Name[name]]]Append[" = (object *)val_no;\n"]]
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1086 { Print["_Set Consts got output 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
1087 }
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1088 }{
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1089 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
1090 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1091 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
1092 { s <- "I" }
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1093 { s <- "UI" }
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1094
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1095 make <- [[[" = make_"]Append[s]]Append["nt"]]Append[[value]Size >>]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1096 out <- [text]Append[ [[[[["\t_const_"]Append[Escape Rhope Name[name]]]Append[make]]Append["("]]Append[[value]Value >>]]Append[");\n"] ]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1097 }{
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1098 out <- text
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1099 }
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
1100 }
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1101 }
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1102 }
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1103 }
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1104
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1105 _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
1106 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1107 valtype <- Type Of[value]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1108 If[[valtype] = ["String"]]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1109 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1110 out <- [text]Append[ [[[["\t_const_"]Append[Escape Rhope Name[name]]]Append[" = make_String(\""]]Append[ [[value]Replace["\n", "\\n"]]Replace["\\", "\\\\"]]]Append["\");\n"] ]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1111 }{
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1112 out <- text
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1113 }
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
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1116 _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
1117 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1118 out <- [[[[[[[[[text
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1119 ]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
1120 ]Append[num]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1121 ]Append["_"]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1122 ]Append[name]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1123 ]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
1124 ]Append[num]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1125 ]Append["_"]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1126 ]Append[name]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1127 ]Append[";\\\n"]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1128 }
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1129
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1130 _Dispatch Switch[text,func,raw name:out]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1131 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1132 name <- Escape Rhope Name[raw name]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1133 out <- [[text]Append[ [[[["\tcase FUNC_"]Append[name]]Append[": goto f_"]]Append[name]]Append[";\\\n"] ]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1134 ]Append[Fold[["_Dispatch Switch Sub"]Set Input[2, name], "", Range[1, [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
1135 }
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1136
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1137 _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
1138 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1139 out <- [[[[[text
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1140 ]Append["\tRES_"]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1141 ]Append[num]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1142 ]Append["_"]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1143 ]Append[name]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1144 ]Append[",\n"]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1145 }
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1146
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1147 _Dispatch Enum[text,func,raw name:out]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1148 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1149 name <- Escape Rhope Name[raw name]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1150 out <- [[text]Append[ [["\tFUNC_"]Append[name]]Append[",\n"] ]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1151 ]Append[Fold[["_Dispatch Enum Sub"]Set Input[2, name], "", Range[1, [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
1152 }
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1153
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1154 Dispatch@C Program[program:out]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1155 {
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1156 out <- [[[[["typedef enum {\n"
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1157 ]Append[Fold["_Dispatch Enum", "", [program]Functions >>]]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1158 ]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
1159 ]Append["#define DISPATCH switch(func) { \\\n"]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1160 ]Append[Fold["_Dispatch Switch", "", [program]Functions >>]]
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1161 ]Append["\tcase END: goto DO_END;\\\n}\n\n"]
19
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
1162 }
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
1163
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
1164 Text@C Program[program:out]
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
1165 {
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1166 Print["Text@C Program"]
48
a24eb366195c Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents: 42
diff changeset
1167 constants <- Fold["Combine Consts", Dictionary[], [program]Functions >>]
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1168 headers <- "#include <stdio.h>
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1169 #include \"builtin.h\"
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1170 #include \"object.h\"
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1171 #include \"context.h\"
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1172 #include \"func.h\"
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1173 #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
1174 #include \"blueprint.h\"
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
1175 #include \"array.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
1176 #include \"bool.h\"\n\n"
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1177 out <- [[[[[[[[headers
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1178 ]Append[[program]Dispatch]
34
df038cef648b More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
1179 ]Append[[[program]Type Registry >>]Type Defs]
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
1180 ]Append[Fold[["_Text C Program"]Set Input[2, [program]Type Registry >>],
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1181 Fold["_Consts C Program",
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1182 Fold["_Defs C Program", "", [program]Functions >>],
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1183 constants
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1184 ], [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
1185 ]Append["\n\nint main(int argc, char **argv)
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1186 {
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1187 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
1188 ]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
1189 ]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
1190 ]Append[Fold[["_Set Late Consts C"]Set Input[3, [program]Type Registry >>], "", constants]]
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1191 ]Append["
64
e1fd6d244f14 Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents: 54
diff changeset
1192 rhope(FUNC_Main);
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1193 return 0;
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1194 }\n\n"]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
1195
19
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
1196 }
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
1197
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
1198