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