Mercurial > repos > rhope
annotate cbackend.rhope @ 64:e1fd6d244f14
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 |
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 | 4 |
5 Blueprint Blueprint Def | |
6 { | |
7 Name | |
8 Fixed Size | |
9 Fields | |
10 Methods | |
11 } | |
12 | |
13 Blueprint Def[name] | |
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 | 16 } |
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 | 402 Blueprint C Function |
403 { | |
404 Name | |
405 Inputs | |
406 Outputs | |
407 Convention | |
408 Variables | |
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 | 417 } |
418 | |
419 C Function[name,inputs,outputs,convention:out] | |
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 | 427 ]Name <<[name] |
428 ]Inputs <<[inputs] | |
429 ]Outputs <<[outputs] | |
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 | 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 | 458 } |
459 | |
460 Allocate Var@C Function[func,name,type:out] | |
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 | 463 out <- [func]Variables <<[ [[func]Variables >>]Set[name,type] ] |
464 } | |
465 | |
466 Add Statement@C Function[func,statement:out] | |
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 | 469 } |
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 | 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 | 481 out <- [func]Add Statement[[[[[dest]Append[" = "]]Append[source1]]Append[op]]Append[source2]] |
482 } | |
483 | |
484 Add@C Function[func,source1,source2,dest:out] | |
485 { | |
486 out <- [func]Add Operator Statement[source1,source2,dest," + "] | |
487 } | |
488 | |
489 Sub@C Function[func,source1,source2,dest:out] | |
490 { | |
491 out <- [func]Add Operator Statement[source1,source2,dest," - "] | |
492 } | |
493 | |
494 Multiply@C Function[func,source1,source2,dest:out] | |
495 { | |
496 out <- [func]Add Operator Statement[source1,source2,dest," * "] | |
497 } | |
498 | |
499 Divide@C Function[func,source1,source2,dest:out] | |
500 { | |
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 | 542 } |
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 | 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 | 548 out <- [func]Add Statement[[[dest]Append[" = "]]Append[source]] |
549 } | |
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 | 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 | 922 } |
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 | 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 |