Mercurial > repos > rhope
annotate cbackend.rhope @ 57:2174878a6e4b
Avoid unnecessary nested switch
| author | Mike Pavone <pavone@retrodev.com> |
|---|---|
| date | Thu, 08 Oct 2009 02:12:25 -0400 |
| parents | 7f05bbe82f24 |
| children | 789a146a48e1 |
| 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 |
|
31f8182f3433
Finished fib test and did some small work on the c backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
2 Import backendutils.rhope |
| 2 | 3 |
| 4 Blueprint Blueprint Def | |
| 5 { | |
| 6 Name | |
| 7 Fixed Size | |
| 8 Fields | |
| 9 Methods | |
| 10 } | |
| 11 | |
| 12 Blueprint Def[name] | |
| 13 { | |
| 14 out <- [[[[Build["Blueprint Def"]]Name <<[name]]Fixed Size <<[0]]Fields <<[()]]Methods <<[New@Dictionary[]] | |
| 15 } | |
| 16 | |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
17 Blueprint C Method Registry |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
18 { |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
19 Lookup |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
20 Next ID |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
21 } |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
22 |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
23 C Method Registry[:out] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
24 { |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
25 builtins <- [[[[[[[[[[[[[New@Dictionary[] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
26 ]Set["+", "METHOD_ADD"] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
27 ]Set["-", "METHOD_SUB"] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
28 ]Set["/", "METHOD_DIV"] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
29 ]Set["*", "METHOD_MUL"] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
30 ]Set["LShift", "METHOD_LSHIFT"] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
31 ]Set["RShift", "METHOD_RSHIFT"] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
32 ]Set["=", "METHOD_EQUALS"] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
33 ]Set[">", "METHOD_GREATER"] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
34 ]Set["<", "METHOD_LESS"] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
35 ]Set["If", "METHOD_IF"] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
36 ]Set["Set Missing Field", "METHOD_SETFIELDMISSING"] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
37 ]Set["Get Missing Field", "METHOD_GETFIELDMISSING"] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
38 ]Set["Missing Method", "METHOD_MISSING"] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
39 out <- [[Build["C Method Registry"]]Lookup <<[builtins]]Next ID<<[0] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
40 |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
41 } |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
42 |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
43 Register Method@C Method Registry[reg,method:out] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
44 { |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
45 [[reg]Lookup >>]Index[method] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
46 { |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
47 out <- reg |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
48 }{ |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
49 method ID <- [reg]Next ID>> |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
50 new lookup <- [[reg]Lookup >>]Set[method, ["METHOD_FIRST_USER+"]Append[method ID]] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
51 out <- [[reg]Lookup <<[new lookup]]Next ID <<[[method ID]+[1]] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
52 } |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
53 } |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
54 |
|
20
b715532225c0
Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents:
19
diff
changeset
|
55 Method ID@C Method Registry[reg,method:out,notfound] |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
56 { |
|
20
b715532225c0
Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents:
19
diff
changeset
|
57 out,notfound <- [[reg]Lookup >>]Index[method] |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
58 } |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
59 |
|
34
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
60 Blueprint C Field Registry |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
61 { |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
62 Lookup |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
63 Next ID |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
64 } |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
65 |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
66 C Field Registry[:out] |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
67 { |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
68 out <- [[Build["C Field Registry"]]Lookup <<[New@Dictionary[]]]Next ID<<[1] |
|
34
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
69 |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
70 } |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
71 |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
72 Register Field@C Field Registry[reg,field:out] |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
73 { |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
74 [[reg]Lookup >>]Index[field] |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
75 { |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
76 out <- reg |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
77 }{ |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
78 field ID <- [reg]Next ID>> |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
79 new lookup <- [[reg]Lookup >>]Set[field, field ID] |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
80 out <- [[reg]Lookup <<[new lookup]]Next ID <<[[field ID]+[1]] |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
81 } |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
82 } |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
83 |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
84 Field ID@C Field Registry[reg,field:out,notfound] |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
85 { |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
86 out,notfound <- [[reg]Lookup >>]Index[field] |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
87 } |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
88 |
|
33
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
89 Blueprint C Type |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
90 { |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
91 Name |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
92 Fields |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
93 Methods |
|
35
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
94 Init |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
95 Copy |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
96 Cleanup |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
97 |
|
33
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
98 } |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
99 |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
100 C Type[name:out] |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
101 { |
|
35
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
102 out <- [[[[[[Build["C Type"]]Name <<[name]]Fields <<[()]]Methods <<[()]]Init <<["NULL"]]Copy <<["NULL"]]Cleanup <<["NULL"] |
|
33
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
103 } |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
104 |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
105 Add Field@C Type[ctype,name,type:out] |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
106 { |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
107 out <- [ctype]Fields <<[ [[ctype]Fields >>]Append[ [[()]Append[name]]Append[type] ] ] |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
108 } |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
109 |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
110 Add Method@C Type[ctype,name:out] |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
111 { |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
112 out <- [ctype]Methods <<[ [[ctype]Methods >>]Append[name] ] |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
113 } |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
114 |
|
34
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
115 Register Methods@C Type[ctype,method reg:out] |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
116 { |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
117 out <- Fold["Register Method", method reg, [ctype]Methods >>] |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
118 } |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
119 |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
120 _Register Field C[reg,field:out] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
121 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
122 name <- [field]Index[0] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
123 out <- [reg]Register Field[name] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
124 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
125 |
|
34
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
126 Register Fields@C Type[ctype,field reg:out] |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
127 { |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
128 out <- Fold["_Register Field C", field reg, [ctype]Fields >>] |
|
34
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
129 } |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
130 |
|
38
7f05bbe82f24
Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
131 Rhope Type to C[type:out,array] |
|
34
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
132 { |
|
37
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
133 If[[Type Of[type]]=["Type Instance"]] |
|
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
134 { |
|
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
135 variant <- [type]Variant >> |
|
38
7f05bbe82f24
Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
136 If[[[type]Name >>] = ["Array"]] |
|
7f05bbe82f24
Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
137 { |
|
7f05bbe82f24
Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
138 [("Naked","Raw Pointer")]Find[variant] |
|
7f05bbe82f24
Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
139 { |
|
7f05bbe82f24
Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
140 pre param <- [[type]Params >>]Index[0] {} |
|
7f05bbe82f24
Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
141 { pre param <- Type Instance["Any Type"] } |
|
7f05bbe82f24
Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
142 [[type]Params >>]Index[1] |
|
7f05bbe82f24
Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
143 { param,param <- [pre param]Set Variant[~] } |
|
7f05bbe82f24
Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
144 { param <- Val[pre param] } |
|
7f05bbe82f24
Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
145 child type <- Rhope Type to C[param] |
|
7f05bbe82f24
Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
146 If[[variant] = ["Naked"]] |
|
7f05bbe82f24
Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
147 { |
|
7f05bbe82f24
Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
148 out <- Val[child type] |
|
7f05bbe82f24
Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
149 array <- "[1]" |
|
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 <- [child type]Append[" *"] |
|
7f05bbe82f24
Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
152 array <- "" |
|
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 }{ |
|
7f05bbe82f24
Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
155 typename <- "Array" |
|
7f05bbe82f24
Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
156 } |
|
7f05bbe82f24
Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
157 }{ |
|
7f05bbe82f24
Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
158 typename <- [type]Name >> |
|
7f05bbe82f24
Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
159 } |
|
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
|
160 }{ |
|
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
161 typename <- type |
|
38
7f05bbe82f24
Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
162 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
|
163 variant <- "boxed" |
|
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
164 } |
|
38
7f05bbe82f24
Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
165 Val[typename] |
|
7f05bbe82f24
Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
166 { array <- "" } |
|
34
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
167 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
|
168 { |
|
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
|
169 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
|
170 }{ |
|
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
|
171 [("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
|
172 { |
|
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
173 prefix <- "nt_" |
|
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
174 }{ |
|
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
175 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
|
176 } |
|
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
177 |
|
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
178 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
|
179 { |
|
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
180 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
|
181 }{ |
|
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
182 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
|
183 } |
|
34
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
184 } |
|
38
7f05bbe82f24
Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
185 out <- [[prefix]Append[Escape Rhope Name[typename]]]Append[postfix] |
|
34
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
186 } |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
187 |
|
33
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
188 _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
|
189 { |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
190 name <- [field]Index[0] |
|
38
7f05bbe82f24
Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
191 ,postfix <- Rhope Type to C[[field]Index[1]] |
|
7f05bbe82f24
Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
192 { type <- ["\n\t"]Append[~] } |
|
7f05bbe82f24
Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
193 |
|
7f05bbe82f24
Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
194 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
|
195 } |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
196 |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
197 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
|
198 { |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
199 out <- [Fold["_Type Def C Type", "OBegin", [ctype]Fields >>]]Append[ [["\nObject("]Append[Escape Rhope Name[[ctype]Name >>]]]Append[")"] ] |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
200 } |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
201 |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
202 _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
|
203 { |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
204 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
|
205 } |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
206 |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
207 _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
|
208 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
209 fname <- [field]Index[0] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
210 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
|
211 ]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
|
212 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
213 |
|
33
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
214 Type Init@C Type[ctype,id,method reg,field reg:out] |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
215 { |
|
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
|
216 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
|
217 ]Append[id] |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
218 ]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
|
219 [[", sizeof(" |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
220 ]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
|
221 ["t_"]Append[Escape Rhope Name[ [ctype]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
|
222 ]Append[ |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
223 ["), (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
|
224 [ |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
225 [[[[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
|
226 ]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
|
227 ]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
|
228 ]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
|
229 ]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
|
230 ]Append[");"]]] ] |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
231 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
|
232 } |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
233 |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
234 Blueprint C Type Registry |
|
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 Lookup |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
237 Definitions |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
238 Next ID |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
239 } |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
240 |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
241 C Type Registry[:out] |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
242 { |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
243 out <- [[[Build["C Type Registry"]]Lookup << [ |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
244 [[[[[[[[[[[[[[[[New@Dictionary[] |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
245 ]Set["UInt8", "TYPE_UINT8"] |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
246 ]Set["UInt16", "TYPE_UINT16"] |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
247 ]Set["UInt32", "TYPE_UINT32"] |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
248 ]Set["UInt64", "TYPE_UINT64"] |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
249 ]Set["Int8", "TYPE_INT8"] |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
250 ]Set["Int16", "TYPE_INT16"] |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
251 ]Set["Int32", "TYPE_INT32"] |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
252 ]Set["Int64", "TYPE_INT64"] |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
253 ]Set["Yes No", "TYPE_BOOLEAN"] |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
254 ]Set["Float32", "TYPE_FLOAT32"] |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
255 ]Set["Float64", "TYPE_FLOAT64"] |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
256 ]Set["Real Number", "TYPE_FLOAT64"] |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
257 ]Set["Array", "TYPE_ARRAY"] |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
258 ]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
|
259 ]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
|
260 ]Set["Wrong Type Exception", "TYPE_WRONGTYPEEXCEPTION"]] |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
261 ]Definitions << [New@Dictionary[]] |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
262 ]Next ID <<[0] |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
263 } |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
264 |
|
34
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
265 _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
|
266 { |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
267 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
|
268 } |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
269 |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
270 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
|
271 { |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
272 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
|
273 } |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
274 |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
275 _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
|
276 { |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
277 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
|
278 } |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
279 |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
280 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
|
281 { |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
282 out <- Fold[[[["_Type Inits C"]Set Input[0, reg]]Set Input[1, method reg]]Set Input[2, field reg], "", [reg]Definitions >>] |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
283 } |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
284 |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
285 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
|
286 { |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
287 name <- [def]Name >> |
|
33
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
288 [[reg]Lookup >>]Index[name] |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
289 { |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
290 out <- reg |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
291 }{ |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
292 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
|
293 ]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
|
294 ]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
|
295 } |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
296 } |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
297 |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
298 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
|
299 { |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
300 out,notfound <- [[reg]Lookup >>]Index[name] |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
301 } |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
302 |
| 2 | 303 Blueprint C Function |
| 304 { | |
| 305 Name | |
| 306 Inputs | |
| 307 Outputs | |
| 308 Convention | |
| 309 Variables | |
| 310 Statements | |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
311 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
|
312 Field Registry |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
313 Type Registry |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
314 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
|
315 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
|
316 Output Types |
| 2 | 317 } |
| 318 | |
| 319 C Function[name,inputs,outputs,convention:out] | |
| 320 { | |
|
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
|
321 out <- C Function With Registry[name,inputs,outputs,convention, C Method Registry[], C Field Registry[]] |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
322 } |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
323 |
|
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
|
324 C Function With Registry[name,inputs,outputs,convention,registry,field reg:out] |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
325 { |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
326 out <- [[[[[[[[[[[[Build["C Function"] |
| 2 | 327 ]Name <<[name] |
| 328 ]Inputs <<[inputs] | |
| 329 ]Outputs <<[outputs] | |
| 330 ]Convention <<[convention] | |
| 331 ]Variables <<[New@Dictionary[]] | |
| 332 ]Statements <<[()] | |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
333 ]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
|
334 ]Field Registry <<[field reg] |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
335 ]Type Registry <<[C Type Registry[]] |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
336 ]Constants <<[New@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
|
337 ]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
|
338 ]Output Types <<[ Fold[["Append"]Set Input[1, "Any Type"], (), 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
|
339 } |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
340 |
|
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
|
341 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
|
342 { |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
343 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
|
344 } |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
345 |
|
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
|
346 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
|
347 { |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
348 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
|
349 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
350 |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
351 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
|
352 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
353 Print["Register Constant"] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
354 Print[name] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
355 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
|
356 { Print["Got register constant output"] } |
| 2 | 357 } |
| 358 | |
| 359 Allocate Var@C Function[func,name,type:out] | |
| 360 { | |
|
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
|
361 Print[["Allocate Var: "]Append[name]] |
| 2 | 362 out <- [func]Variables <<[ [[func]Variables >>]Set[name,type] ] |
| 363 } | |
| 364 | |
| 365 Add Statement@C Function[func,statement:out] | |
| 366 { | |
|
12
31f8182f3433
Finished fib test and did some small work on the c backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
367 out <- [func]Statements <<[ [[func]Statements >>]Append[["\t"]Append[[statement]Append[";\n"]]] ] |
| 2 | 368 } |
| 369 | |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
370 Add Raw Line@C Function[func,line:out] |
| 2 | 371 { |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
372 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
|
373 } |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
374 |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
375 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
|
376 { |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
377 source1 <- [psource1]Make Op[func] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
378 source2 <- [psource2]Make Op[func] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
379 dest <- [pdest]Make Op[func] |
| 2 | 380 out <- [func]Add Statement[[[[[dest]Append[" = "]]Append[source1]]Append[op]]Append[source2]] |
| 381 } | |
| 382 | |
| 383 Add@C Function[func,source1,source2,dest:out] | |
| 384 { | |
| 385 out <- [func]Add Operator Statement[source1,source2,dest," + "] | |
| 386 } | |
| 387 | |
| 388 Sub@C Function[func,source1,source2,dest:out] | |
| 389 { | |
| 390 out <- [func]Add Operator Statement[source1,source2,dest," - "] | |
| 391 } | |
| 392 | |
| 393 Multiply@C Function[func,source1,source2,dest:out] | |
| 394 { | |
| 395 out <- [func]Add Operator Statement[source1,source2,dest," * "] | |
| 396 } | |
| 397 | |
| 398 Divide@C Function[func,source1,source2,dest:out] | |
| 399 { | |
| 400 out <- [func]Add Operator Statement[source1,source2,dest," / "] | |
| 401 } | |
| 402 | |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
403 Move@C Function[func,psource,pdest:out] |
| 2 | 404 { |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
405 source <- [psource]Make Op[func] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
406 dest <- [pdest]Make Op[func] |
| 2 | 407 out <- [func]Add Statement[[[dest]Append[" = "]]Append[source]] |
| 408 } | |
| 409 | |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
410 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
|
411 { |
|
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
|
412 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
|
413 dest <- [pdest]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
|
414 out <- [func]Add Statement[[[[dest]Append[" = add_ref("]]Append[source]]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
|
415 } |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
416 |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
417 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
|
418 { |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
419 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
|
420 out <- [func]Add Statement[[["add_ref("]Append[source]]Append[")"]] |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
421 } |
|
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 Release@C Function[func,psource:out] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
424 { |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
425 source <- [psource]Make Op[func] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
426 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
|
427 } |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
428 |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
429 Set Null@C Function[func,pdest:out] |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
430 { |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
431 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
|
432 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
|
433 out <- [func]Add Statement[[dest]Append[" = NULL"]] |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
434 } |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
435 |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
436 Lookup Constant@C Function[func,const:out] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
437 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
438 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
|
439 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
440 |
|
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
|
441 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
|
442 { |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
443 as op <- [var]Make Op[func] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
444 If[[[Type Of[var]] = ["String"]] And[ [[func]Convention >>] = ["rhope"]] ] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
445 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
446 [[func]Inputs >>]Find[var] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
447 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
448 type <- [[func]Input Types >>]Index[~] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
449 If[[type] = ["Any Type"]] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
450 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
451 rvar <- Val[as op] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
452 }{ |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
453 rvar <- [[[["(("]Append[ Rhope Type to C[type] ]]Append[")("]]Append[as op]]Append["))"] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
454 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
455 }{ |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
456 rvar <- Val[as op] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
457 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
458 }{ |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
459 rvar <- Val[as op] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
460 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
461 out <- [[rvar]Append["->"]]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
|
462 } |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
463 |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
464 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
|
465 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
466 out <- func |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
467 result op <- Field Ref[var,field] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
468 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
469 |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
470 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
|
471 { |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
472 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
|
473 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
|
474 } |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
475 |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
476 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
|
477 { |
|
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
|
478 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
|
479 } |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
480 |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
481 Copy@C Function[func,pdest:out] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
482 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
483 dest <- [pdest]Make Op[func] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
484 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
|
485 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
486 |
|
18
ea991f95ae1f
C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents:
14
diff
changeset
|
487 _Function Arg C[func,val,inputnum:out] |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
488 { |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
489 out <- [func]Add Statement[ |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
490 [[["call->params[" |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
491 ]Append[inputnum] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
492 ]Append["] = "] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
493 ]Append[val] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
494 ] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
495 } |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
496 |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
497 Method Call@C Function[func,method,args:out] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
498 { |
|
18
ea991f95ae1f
C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents:
14
diff
changeset
|
499 out <- [func]Func Base[[[func]Method Registry >>]Method ID[method],args, "MCall"] |
|
ea991f95ae1f
C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents:
14
diff
changeset
|
500 } |
|
ea991f95ae1f
C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents:
14
diff
changeset
|
501 |
|
ea991f95ae1f
C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents:
14
diff
changeset
|
502 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
|
503 { |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
504 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
|
505 } |
|
ea991f95ae1f
C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents:
14
diff
changeset
|
506 |
|
ea991f95ae1f
C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents:
14
diff
changeset
|
507 Func Base@C Function[func,tocall,args,type:out] |
|
ea991f95ae1f
C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents:
14
diff
changeset
|
508 { |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
509 rargs <- Map[args, ["Make Op"]Set Input[1, func]] |
|
18
ea991f95ae1f
C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents:
14
diff
changeset
|
510 out <- [Fold["_Function Arg C", func, rargs] |
|
ea991f95ae1f
C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents:
14
diff
changeset
|
511 ]Add Raw Line[[[[[ [type]Append["("] ]Append[tocall]]Append[", "]]Append[ [rargs]Length ]]Append[")"]] |
|
ea991f95ae1f
C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents:
14
diff
changeset
|
512 } |
|
ea991f95ae1f
C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents:
14
diff
changeset
|
513 |
|
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
|
514 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
|
515 { |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
516 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
|
517 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
|
518 ]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
|
519 } |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
520 |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
521 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
|
522 { |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
523 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
|
524 } |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
525 |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
526 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
|
527 { |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
528 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
|
529 } |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
530 |
|
18
ea991f95ae1f
C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents:
14
diff
changeset
|
531 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
|
532 { |
|
ea991f95ae1f
C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents:
14
diff
changeset
|
533 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
|
534 } |
|
ea991f95ae1f
C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents:
14
diff
changeset
|
535 |
|
ea991f95ae1f
C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents:
14
diff
changeset
|
536 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
|
537 { |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
538 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
|
539 } |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
540 |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
541 Resolve@C Function[func,op:out] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
542 { |
|
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
|
543 If[[[func]Convention >>] = ["rhope"]] |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
544 { |
|
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
|
545 [[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
|
546 { |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
547 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
|
548 }{ |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
549 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
|
550 } |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
551 }{ |
|
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
|
552 out <- Escape Rhope Name[op] |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
553 } |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
554 } |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
555 |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
556 Instruction Stream@C Function[func:out] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
557 { |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
558 out <- [func]Statements <<[()] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
559 } |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
560 |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
561 _If C[func, statement:out] |
|
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 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
|
564 } |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
565 |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
566 Do If@C Function[func,condition,stream:out] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
567 { |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
568 cond <- [condition]Make Op[func] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
569 out <- [Fold["_If C", [[func |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
570 ]Add Raw Line[ [["if("]Append[cond]]Append[")"] ] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
571 ]Add Raw Line["{"], [stream]Statements >>] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
572 ]Add Raw Line["}"] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
573 |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
574 } |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
575 |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
576 Result Reference@C Function[func,output:out] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
577 { |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
578 out <- [["call->params["]Append[output]]Append["]"] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
579 } |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
580 |
|
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
581 If Null Else@C Function[func,left,right:out] |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
582 { |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
583 out <- [[[[[["(" |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
584 ]Append[left] |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
585 ]Append[" ? "] |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
586 ]Append[left] |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
587 ]Append[" : "] |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
588 ]Append[right] |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
589 ]Append[")"] |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
590 } |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
591 |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
592 _Set Outputs C[string,inputname,inputnum:out] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
593 { |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
594 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
|
595 } |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
596 |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
597 Set Outputs@C Function[func:out] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
598 { |
|
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
|
599 If[[[func]Convention >>] = ["rhope"]] |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
600 { |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
601 out <- Fold["_Set Outputs C", "", [func]Outputs >>] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
602 }{ |
|
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
|
603 [[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
|
604 { |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
605 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
|
606 }{ |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
607 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
|
608 } |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
609 } |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
610 } |
|
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
|
611 _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
|
612 { |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
613 out <- [[[string]Append[ ["\t"]Append[Rhope Type to C[[[func]Output Types >>]Index[index]]] ]]Append[Escape Rhope Name[varname]]]Append[";\n"] |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
614 } |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
615 _Var Defs C[string,type,varname:out] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
616 { |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
617 out <- [[[string]Append[ ["\t"]Append[Rhope Type to C[type]] ]]Append[Escape Rhope Name[varname]]]Append[";\n"] |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
618 } |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
619 |
|
18
ea991f95ae1f
C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents:
14
diff
changeset
|
620 |
| 2 | 621 Definitions@C Function[func:out] |
| 622 { | |
|
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
|
623 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
|
624 { |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
625 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
|
626 }{ |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
627 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
|
628 } |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
629 |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
630 If[ [[func]Convention >>] = ["rhope"] ] |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
631 { |
|
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
|
632 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
|
633 [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
|
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 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
|
636 ]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
|
637 ]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
|
638 ]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
|
639 ]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
|
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 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
|
642 } |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
643 }{ |
|
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
|
644 proto <- [[func]Naked Proto]Append[";\n"] |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
645 } |
|
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
|
646 out <- [localtype]Append[proto] |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
647 } |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
648 |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
649 _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
|
650 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
651 Print[["_Proto Input: "]Append[input]] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
652 { Print[[types]Index[index]] } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
653 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
|
654 { Pretty Print[~, ""] } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
655 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
656 |
|
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
|
657 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
|
658 { |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
659 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
|
660 [[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
|
661 { |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
662 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
|
663 }{ |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
664 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
|
665 } |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
666 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
|
667 ]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
|
668 ]Append["("] |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
669 ]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
|
670 ]Append[")"] |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
671 { Print[~] } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
672 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
673 |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
674 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
|
675 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
676 If[[type] = ["Any Type"]] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
677 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
678 out <- text |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
679 }{ |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
680 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
|
681 } |
| 2 | 682 } |
| 683 | |
|
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
|
684 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
|
685 { |
|
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
686 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
|
687 { |
|
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
688 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
|
689 }{ |
|
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
690 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
|
691 } |
|
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
692 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
|
693 { |
|
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
694 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
|
695 }{ |
|
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
696 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
|
697 } |
|
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
698 } |
|
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
699 |
| 2 | 700 Text@C Function[func: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
|
701 { |
|
34
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
702 If[ [[func]Convention >>] = ["rhope"] ] |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
703 { |
|
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
|
704 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
|
705 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
|
706 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
|
707 { |
|
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
|
708 out <- [[[[[[["FuncNoLocals(" |
|
34
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
709 ]Append[cname] |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
710 ]Append[",\n\tNumParams "] |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
711 ]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
|
712 ]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
|
713 ]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
|
714 ]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
|
715 ]Append["EndFunc"] |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
716 }{ |
|
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
|
717 out <- [[[[[[[[[["Func(" |
|
34
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
718 ]Append[cname] |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
719 ]Append[",\n\tNumParams "] |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
720 ]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
|
721 ]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
|
722 ]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
|
723 ]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
|
724 ]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
|
725 ]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
|
726 ]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
|
727 ]Append["EndFunc"] |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
728 } |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
729 }{ |
|
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
|
730 |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
731 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
|
732 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
|
733 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
|
734 ]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
|
735 ]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
|
736 ]Append["}"] |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
737 } |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
738 } |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
739 |
|
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
740 Blueprint C Program |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
741 { |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
742 Functions |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
743 Method Registry |
|
34
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
744 Field Registry |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
745 Type Registry |
|
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
746 } |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
747 |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
748 C Program[:out] |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
749 { |
|
34
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
750 out <- [[[[Build["C Program"]]Functions <<[New@Dictionary[]]]Method Registry <<[C Method Registry[]]]Type Registry <<[C Type Registry[]]]Field Registry <<[C Field Registry[]] |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
751 } |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
752 |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
753 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
|
754 { |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
755 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
|
756 ]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
|
757 ]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
|
758 } |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
759 |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
760 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
|
761 { |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
762 out <- C Type[name] |
|
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
763 } |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
764 |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
765 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
|
766 { |
|
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
|
767 out <- C Function With Registry[name,inputs,outputs,convention, [program]Method Registry >>, [program]Field Registry >>] |
|
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
768 } |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
769 |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
770 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
|
771 { |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
772 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
|
773 } |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
774 |
|
20
b715532225c0
Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents:
19
diff
changeset
|
775 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
|
776 { |
|
b715532225c0
Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents:
19
diff
changeset
|
777 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
|
778 } |
|
b715532225c0
Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents:
19
diff
changeset
|
779 |
|
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
780 _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
|
781 { |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
782 def <- [func]Definitions |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
783 If[[def]=[""]] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
784 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
785 out <- text |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
786 }{ |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
787 out <- [text]Append[[def]Append["\n\n"]] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
788 } |
|
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
789 } |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
790 |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
791 _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
|
792 { |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
793 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
|
794 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
795 |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
796 Combine Consts[consts,func:out] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
797 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
798 out <- Combine[[func]Constants >>, consts] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
799 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
800 |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
801 _Consts C Program[text,value,name:out] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
802 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
803 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
|
804 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
805 |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
806 _Set Consts C Program[text,value,name,type reg:out] |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
807 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
808 //TODO: Support more constant types |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
809 valtype <- Type Of[value] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
810 [("Int32","Whole Number")]Find[valtype] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
811 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
812 out <- [text]Append[[[[["\t_const_"]Append[Escape Rhope Name[name]]]Append[" = make_Int32("]]Append[value]]Append[");\n"]] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
813 }{ |
|
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
|
814 If[[valtype] = ["Type Instance"]] |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
815 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
816 //TODO: Support parametric types |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
817 typeid <- [type reg]Type ID[[value]Name >>] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
818 out <- [text]Append[[[[["\t_const_"]Append[Escape Rhope Name[name]]]Append[" = make_Blueprint("]]Append[typeid]]Append[");\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
|
819 }{ |
|
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
820 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
|
821 { |
|
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
822 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
|
823 { |
|
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
824 out <- [text]Append[[["\t_const_"]Append[Escape Rhope Name[name]]]Append[" = (object *)val_yes;\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
|
825 }{ |
|
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
826 out <- [text]Append[[["\t_const_"]Append[Escape Rhope Name[name]]]Append[" = (object *)val_no;\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
|
827 } |
|
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
828 } |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
829 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
830 } |
|
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
831 } |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
832 |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
833 Text@C Program[program:out] |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
834 { |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
835 Print["Text@C Program"] |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
836 constants <- Fold["Combine Consts", New@Dictionary[], [program]Functions >>] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
837 headers <- "#include <stdio.h> |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
838 #include \"builtin.h\" |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
839 #include \"object.h\" |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
840 #include \"context.h\" |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
841 #include \"func.h\" |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
842 #include \"integer.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
|
843 #include \"blueprint.h\" |
|
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
844 #include \"bool.h\"\n\n" |
|
34
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
845 out <- [[[[[[headers |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
846 ]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
|
847 ]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
|
848 Fold["_Consts C Program", |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
849 Fold["_Defs C Program", "", [program]Functions >>], |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
850 constants |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
851 ], [program]Functions >>]] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
852 ]Append["int main(int argc, char **argv) |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
853 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
854 returntype ret; |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
855 calldata *cdata; |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
856 context * ct; |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
857 blueprint * bp; |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
858 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
|
859 ]Append[ [[program]Type Registry >>]Type Inits[[program]Method Registry >>, [program]Field Registry >>] ] |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
860 ]Append[Fold[["_Set Consts C Program"]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
|
861 ]Append[" |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
862 ct = new_context(); |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
863 cdata = alloc_cdata(ct, 0); |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
864 cdata->num_params = 0; |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
865 cdata->resume = 0; |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
866 ret = f_Main(cdata); |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
867 while(ret == TAIL_RETURN) |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
868 ret = cdata->tail_func(cdata); |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
869 if(ret == EXCEPTION_RETURN) { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
870 puts(\"Exception!\"); |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
871 return -1; |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
872 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
873 return 0; |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
874 }\n\n"] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
875 |
|
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
876 } |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
877 |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
878 |