Mercurial > repos > rhope
annotate cbackend.rhope @ 148:f582fd6c75ee
Fixed framework port, works for said.rhope example
| author | Mike Pavone <pavone@retrodev.com> |
|---|---|
| date | Mon, 22 Nov 2010 01:37:05 -0500 |
| parents | 72c648bca43b |
| children |
| 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 { |
|
83
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
239 out <- [[[[_Type Def C Type["typedef struct {\n\tobject _SP_header;\n\t", [[ctype]Fields >>]Index[0]]]Append["\n} t_"]]Append[Escape Rhope Name[[ctype]Name >>]]]Append[";"] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
240 ]Append[ |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
241 [[[["typedef " |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
242 ]Append[Rhope Type to C[ [[[ctype]Fields >>]Index[0]]Index[1] ]] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
243 ]Append[" nt_"] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
244 ]Append[Escape Rhope Name[[ctype]Name >>]] |
|
75
0083b2f7b3c7
Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents:
74
diff
changeset
|
245 ]Append[";"] ] |
|
64
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
246 }{ |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
247 //HACK!!! |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
248 If[[[ctype]Name >>]=["Blueprint"]] |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
249 { |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
250 out <- "" |
|
83
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
251 }{ |
|
96
5a08705f7610
Semi-broken cleanup of Array implementation
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
252 [("Array","Boxed Array","Worker")]Find[[ctype]Name >>] |
|
64
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
253 { oend <- "\nMObject(" } |
|
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
254 { oend <- "\nObject(" } |
|
64
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
255 out <- [Fold["_Type Def C Type", "OBegin", [ctype]Fields >>]]Append[ [[oend]Append[Escape Rhope Name[[ctype]Name >>]]]Append[")"] ] |
|
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
256 } |
|
42
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
257 } |
|
33
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
258 } |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
259 |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
260 _Type Init C[type name,method reg,text,method:out] |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
261 { |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
262 out <- [[text]Append[[["\n\tadd_method(bp, "]Append[ [method reg]Method ID[method] ]]Append[ [[", MethodName("]Append[Escape Rhope Name[method]]]Append[[","]Append[Escape Rhope Name[type name]]]]]]Append["));"] |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
263 } |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
264 |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
265 _Type Init C Field[type name,field reg,text,field:out] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
266 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
267 fname <- [field]Index[0] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
268 out <- [[[[text]Append[[["\n\tadd_getter(bp, "]Append[ [field reg]Field ID[fname] ]]Append[ [[", MethodName("]Append[Escape Rhope Name[[fname]Append[" >>"]]]]Append[[","]Append[Escape Rhope Name[type name]]]]]]Append["));"] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
269 ]Append[[["\n\tadd_setter(bp, "]Append[ [field reg]Field ID[fname] ]]Append[ [[", MethodName("]Append[Escape Rhope Name[[fname]Append[" <<"]]]]Append[[","]Append[Escape Rhope Name[type name]]]]]]Append["));"] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
270 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
271 |
|
33
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
272 Type Init@C Type[ctype,id,method reg,field reg:out] |
|
83
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
273 { |
|
96
5a08705f7610
Semi-broken cleanup of Array implementation
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
274 [("Array","Boxed Array", "Worker")]Find[[ctype]Name >>] |
|
64
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
275 { size <- "-1" } |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
276 { |
|
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
277 [("Int64","Int32","Int16","Int8")]Find[[ctype]Name >>] |
|
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
278 { |
|
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
279 [[ctype]Name >>]Slice[3] {} |
|
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
280 { typename <- [["int"]Append[~]]Append["_t"] } |
|
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
281 }{ |
|
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
282 [("UInt64","UInt32","UInt16","UInt8")]Find[[ctype]Name >>] |
|
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
283 { |
|
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
284 [[ctype]Name >>]Slice[4] {} |
|
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
285 { typename <- [["uint"]Append[~]]Append["_t"] } |
|
64
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
286 }{ |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
287 If[[[ctype]Name >>]=["Blueprint"]] |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
288 { typename <- "blueprint *" } |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
289 { |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
290 If[[[ctype]Name >>]=["Boolean"]] |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
291 { typename <- "int32_t" } |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
292 { typename <- ["nt_"]Append[Escape Rhope Name[[ctype]Name >>]] } |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
293 } |
|
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
294 } |
|
64
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
295 } |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
296 size <- [["sizeof("]Append[typename]]Append[")"] |
|
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
297 } |
|
35
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
298 start <- [["\tbp = register_type_byid(" |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
299 ]Append[id] |
|
64
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
300 ]Append[ |
|
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
301 [[", "]Append[size] |
|
35
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
302 ]Append[ |
|
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
303 [", (special_func)"]Append[ |
|
35
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
304 [ |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
305 [[[[Escape Rhope Name NU[[ctype]Init >>] |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
306 ]Append[", (special_func)"] |
|
35
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
307 ]Append[Escape Rhope Name NU[[ctype]Copy >> ]] |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
308 ]Append[", (special_func)"] |
|
35
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
309 ]Append[Escape Rhope Name NU[[ctype]Cleanup >>]] |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
310 ]Append[");"]]] ] |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
311 out <- Val[start]//Fold[[["_Type Init C Field"]Set Input[0, [ctype]Name >>]]Set Input[1, field reg], Fold[[["_Type Init C"]Set Input[0, [ctype]Name >>]]Set Input[1, method reg], start, [ctype]Methods >>], [ctype]Fields >>] |
|
33
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
312 } |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
313 |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
314 Blueprint C Type Registry |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
315 { |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
316 Lookup |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
317 Definitions |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
318 Next ID |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
319 } |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
320 |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
321 C Type Registry[:out] |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
322 { |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
323 out <- [[[Build["C Type Registry"]]Lookup << [ |
|
96
5a08705f7610
Semi-broken cleanup of Array implementation
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
324 [[[[[[[[[[[[[[[[[[[Dictionary[] |
|
75
0083b2f7b3c7
Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents:
74
diff
changeset
|
325 ]Set["UInt8", "TYPE_UINT8"] //1 |
|
0083b2f7b3c7
Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents:
74
diff
changeset
|
326 ]Set["UInt16", "TYPE_UINT16"] //2 |
|
0083b2f7b3c7
Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents:
74
diff
changeset
|
327 ]Set["UInt32", "TYPE_UINT32"] //3 |
|
0083b2f7b3c7
Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents:
74
diff
changeset
|
328 ]Set["UInt64", "TYPE_UINT64"] //4 |
|
0083b2f7b3c7
Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents:
74
diff
changeset
|
329 ]Set["Int8", "TYPE_INT8"] //5 |
|
0083b2f7b3c7
Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents:
74
diff
changeset
|
330 ]Set["Int16", "TYPE_INT16"] //6 |
|
0083b2f7b3c7
Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents:
74
diff
changeset
|
331 ]Set["Int32", "TYPE_INT32"] //7 |
|
0083b2f7b3c7
Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents:
74
diff
changeset
|
332 ]Set["Int64", "TYPE_INT64"] //8 |
|
0083b2f7b3c7
Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents:
74
diff
changeset
|
333 ]Set["Boolean", "TYPE_BOOLEAN"] //9 |
|
0083b2f7b3c7
Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents:
74
diff
changeset
|
334 ]Set["Float32", "TYPE_FLOAT32"] //10 |
|
0083b2f7b3c7
Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents:
74
diff
changeset
|
335 ]Set["Float64", "TYPE_FLOAT64"] //11 |
|
99
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
96
diff
changeset
|
336 ]Set["Real Number", "TYPE_FLOAT64"] |
|
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
96
diff
changeset
|
337 ]Set["Blueprint", "TYPE_BLUEPRINT"] //12 |
|
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
96
diff
changeset
|
338 ]Set["Array", "TYPE_ARRAY"] //13 |
|
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
96
diff
changeset
|
339 ]Set["Boxed Array", "TYPE_BOXEDARRAY"]//14 |
|
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
96
diff
changeset
|
340 ]Set["Worker", "TYPE_WORKER"] //15 |
|
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
96
diff
changeset
|
341 ]Set["Method Missing Exception", "TYPE_METHODMISSINGEXCEPTION"] //16 |
|
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
96
diff
changeset
|
342 ]Set["Field Missing Exception", "TYPE_FIELDMISSINGEXCEPTION"] //17 |
|
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
96
diff
changeset
|
343 ]Set["Wrong Type Exception", "TYPE_WRONGTYPEEXCEPTION"]] //18 |
|
48
a24eb366195c
Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
344 ]Definitions << [Dictionary[]] |
|
33
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
345 ]Next ID <<[0] |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
346 } |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
347 |
|
34
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
348 _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
|
349 { |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
350 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
|
351 } |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
352 |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
353 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
|
354 { |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
355 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
|
356 } |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
357 |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
358 _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
|
359 { |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
360 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
|
361 } |
|
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 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
|
364 { |
|
64
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
365 out <- Fold[[[["_Type Inits C"]Set Input[0, reg]]Set Input[1, method reg]]Set Input[2, field reg], "", [reg]Definitions >>] |
|
34
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
366 } |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
367 |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
368 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
|
369 { |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
370 name <- [def]Name >> |
|
33
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
371 [[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
|
372 { |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
373 [[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
|
374 { |
|
64
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
375 out <- reg |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
376 }{ |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
377 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
|
378 } |
|
33
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 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
|
381 ]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
|
382 ]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
|
383 } |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
384 } |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
385 |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
386 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
|
387 { |
|
64
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
388 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
|
389 { |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
390 ,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
|
391 { out <- "0" } |
|
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
392 } |
|
33
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
393 } |
|
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
394 |
|
42
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
395 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
|
396 { |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
397 ,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
|
398 { |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
399 yep,nope <- If[[[[~]Fields >>]Length] = [1]] |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
400 } |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
401 } |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
402 |
|
119
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
403 Defined?@C Type Registry[reg,name:yep,nope] |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
404 { |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
405 yep,nope <- [[reg]Definitions >>]Index[name] |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
406 } |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
407 |
| 2 | 408 Blueprint C Function |
| 409 { | |
| 410 Name | |
| 411 Inputs | |
| 412 Outputs | |
| 413 Convention | |
| 414 Variables | |
| 415 Statements | |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
416 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
|
417 Field Registry |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
418 Type Registry |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
419 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
|
420 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
|
421 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
|
422 Resume Index |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
423 Last NumParams |
| 2 | 424 } |
| 425 | |
| 426 C Function[name,inputs,outputs,convention:out] | |
| 427 { | |
|
42
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
428 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
|
429 } |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
430 |
|
42
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
431 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
|
432 { |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
433 out <- [[[[[[[[[[[[[[Build["C Function"] |
| 2 | 434 ]Name <<[name] |
| 435 ]Inputs <<[inputs] | |
| 436 ]Outputs <<[outputs] | |
| 437 ]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
|
438 ]Variables <<[Dictionary[]] |
| 2 | 439 ]Statements <<[()] |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
440 ]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
|
441 ]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
|
442 ]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
|
443 ]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
|
444 ]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
|
445 ]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
|
446 ]Resume Index <<[1] |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
447 ]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
|
448 } |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
449 |
|
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
|
450 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
|
451 { |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
452 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
|
453 } |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
454 |
|
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
|
455 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
|
456 { |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
457 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
|
458 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
459 |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
460 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
|
461 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
462 out <- [func]Constants <<[ [[func]Constants >>]Set[name, constant] ] |
| 2 | 463 } |
| 464 | |
| 465 Allocate Var@C Function[func,name,type:out] | |
| 466 { | |
| 467 out <- [func]Variables <<[ [[func]Variables >>]Set[name,type] ] | |
| 468 } | |
| 469 | |
| 470 Add Statement@C Function[func,statement:out] | |
| 471 { | |
|
12
31f8182f3433
Finished fib test and did some small work on the c backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
472 out <- [func]Statements <<[ [[func]Statements >>]Append[["\t"]Append[[statement]Append[";\n"]]] ] |
| 2 | 473 } |
| 474 | |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
475 Add Raw Line@C Function[func,line:out] |
| 2 | 476 { |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
477 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
|
478 } |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
479 |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
480 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
|
481 { |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
482 source1 <- [psource1]Make Op[func] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
483 source2 <- [psource2]Make Op[func] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
484 dest <- [pdest]Make Op[func] |
| 2 | 485 out <- [func]Add Statement[[[[[dest]Append[" = "]]Append[source1]]Append[op]]Append[source2]] |
| 486 } | |
| 487 | |
| 488 Add@C Function[func,source1,source2,dest:out] | |
| 489 { | |
| 490 out <- [func]Add Operator Statement[source1,source2,dest," + "] | |
| 491 } | |
| 492 | |
| 493 Sub@C Function[func,source1,source2,dest:out] | |
| 494 { | |
| 495 out <- [func]Add Operator Statement[source1,source2,dest," - "] | |
| 496 } | |
| 497 | |
| 498 Multiply@C Function[func,source1,source2,dest:out] | |
| 499 { | |
| 500 out <- [func]Add Operator Statement[source1,source2,dest," * "] | |
| 501 } | |
| 502 | |
| 503 Divide@C Function[func,source1,source2,dest:out] | |
| 504 { | |
| 505 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
|
506 } |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
507 |
|
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
|
508 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
|
509 { |
|
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 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
|
511 } |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
512 |
|
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
|
513 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
|
514 { |
|
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
|
515 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
|
516 } |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
517 |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
518 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
|
519 { |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
520 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
|
521 } |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
522 |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
523 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
|
524 { |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
525 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
|
526 } |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
527 |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
528 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
|
529 { |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
530 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
|
531 } |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
532 |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
533 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
|
534 { |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
535 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
|
536 } |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
537 |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
538 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
|
539 { |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
540 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
|
541 } |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
542 |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
543 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
|
544 { |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
545 out <- [func]Add Operator Statement[source1,source2,dest," != "] |
| 2 | 546 } |
| 547 | |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
548 Move@C Function[func,psource,pdest:out] |
| 2 | 549 { |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
550 source <- [psource]Make Op[func] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
551 dest <- [pdest]Make Op[func] |
| 2 | 552 out <- [func]Add Statement[[[dest]Append[" = "]]Append[source]] |
| 553 } | |
| 554 | |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
555 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
|
556 { |
|
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 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
|
558 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
|
559 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
|
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 |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
562 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
|
563 { |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
564 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
|
565 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
|
566 } |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
567 |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
568 Release@C Function[func,psource:out] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
569 { |
|
64
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
570 source <- [psource]Make Op[func] |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
571 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
|
572 } |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
573 |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
574 Set Null@C Function[func,pdest:out] |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
575 { |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
576 dest <- [pdest]Make Op[func] |
|
18
ea991f95ae1f
C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents:
14
diff
changeset
|
577 out <- [func]Add Statement[[dest]Append[" = NULL"]] |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
578 } |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
579 |
|
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
580 Lookup Constant@C Function[func,const,doaddref:out] |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
581 { |
|
83
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
582 var <- ["_const_"]Append[Escape Rhope Name[const]] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
583 If[doaddref] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
584 { |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
585 out <- [["add_ref("]Append[var]]Append[")"] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
586 }{ |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
587 out <- Val[var] |
|
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
588 } |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
589 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
590 |
|
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
|
591 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
|
592 { |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
593 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
|
594 If[[Type Of[var]] = ["String"]] |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
595 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
596 [[func]Inputs >>]Find[var] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
597 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
598 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
|
599 }{ |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
600 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
|
601 { |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
602 [[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
|
603 { |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
604 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
|
605 }{ |
|
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
|
606 //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
|
607 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
|
608 } |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
609 } |
|
42
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 }{ |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
612 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
|
613 } |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
614 If[[[func]Convention >>] = ["rhope"]] |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
615 { |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
616 If[[type] = ["Any Type"]] |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
617 { |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
618 rvar <- Val[as op] |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
619 }{ |
|
42
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
620 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
|
621 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
622 }{ |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
623 rvar <- Val[as op] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
624 } |
|
42
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
625 |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
626 [[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
|
627 { access <- "->" } |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
628 { access <- "->payload." } |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
629 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
|
630 } |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
631 |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
632 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
|
633 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
634 out <- func |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
635 result op <- Field Ref[var,field] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
636 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
637 |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
638 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
|
639 { |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
640 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
|
641 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
|
642 } |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
643 |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
644 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
|
645 { |
|
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
|
646 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
|
647 } |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
648 |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
649 Copy@C Function[func,pdest:out] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
650 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
651 dest <- [pdest]Make Op[func] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
652 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
|
653 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
654 |
|
42
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
655 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
|
656 { |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
38
diff
changeset
|
657 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
|
658 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
|
659 out <- [func]Add Statement[ |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
38
diff
changeset
|
660 [[[[[dest |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
38
diff
changeset
|
661 ]Append[" = naked_to_boxed("] |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
38
diff
changeset
|
662 ]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
|
663 ]Append[", &"] |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
38
diff
changeset
|
664 ]Append[source] |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
38
diff
changeset
|
665 ]Append[")"] ] |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
38
diff
changeset
|
666 } |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
38
diff
changeset
|
667 |
|
42
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
668 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
|
669 { |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
38
diff
changeset
|
670 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
|
671 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
|
672 out <- [func]Add Statement[ |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
38
diff
changeset
|
673 [[[["boxed_to_naked(" |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
38
diff
changeset
|
674 ]Append[source] |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
38
diff
changeset
|
675 ]Append[", &"] |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
38
diff
changeset
|
676 ]Append[dest] |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
38
diff
changeset
|
677 ]Append[")"] ] |
|
64
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
678 } |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
679 |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
680 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
|
681 { |
|
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
682 dest <- [pdest]Make Op[func] |
|
64
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
683 source <- [psource]Make Op[func] |
|
81
dbe95bfec970
Very basic file access is now working; however, there's a bug involving assigning a literal to a named pipe inside a conditional block that needs fixing
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
684 out <- [func]Add Statement[ [[[dest]Append[" = (void*)("]]Append[source]]Append[" + 1)"] ] |
|
64
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
685 } |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
686 |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
687 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
|
688 { |
|
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
689 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
|
690 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
|
691 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
|
692 } |
|
40
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
38
diff
changeset
|
693 |
|
18
ea991f95ae1f
C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents:
14
diff
changeset
|
694 _Function Arg C[func,val,inputnum:out] |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
695 { |
|
64
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
696 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
|
697 [[[["SetParam(" |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
698 ]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
|
699 ]Append[", "] |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
700 ]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
|
701 ]Append[")"] |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
702 ] |
|
83
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
703 } |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
704 |
|
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
705 _Val Function Arg C[func,val,inputnum,worker:out] |
|
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
706 { |
|
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
707 out <- [func]Add Raw Line[ |
|
83
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
708 [[[[[["VCSetParam(" |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
709 ]Append[worker] |
|
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
710 ]Append[", "] |
|
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
711 ]Append[inputnum] |
|
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
712 ]Append[", "] |
|
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
713 ]Append[val] |
|
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
714 ]Append[")"] |
|
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
715 ] |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
716 } |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
717 |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
718 Method Call@C Function[func,method,args:out] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
719 { |
|
64
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
720 out <- [func]Call[method,args] |
|
83
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
721 } |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
722 |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
723 Val Call@C Function[func,to call,args:out] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
724 { |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
725 worker <- Make Op[Strip Addref[to call], func] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
726 rargs <- Map[args, ["Make Op"]Set Input[1, func]] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
727 |
|
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
728 If[[[func]Last NumParams >>] = [-1]] |
|
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
729 { |
|
100
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
730 prepped <- [[func]Add Raw Line[ |
|
83
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
731 [[[["VCPrepCall(" |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
732 ]Append[worker] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
733 ]Append[", "] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
734 ]Append[[rargs]Length] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
735 ]Append[")"] ] |
|
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
736 ]Last NumParams <<[[rargs]Length] |
|
100
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
737 }{ |
|
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
738 prepped <- [[func]Add Raw Line[ |
|
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
739 [[[[[["VCRePrepCall(" |
|
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
740 ]Append[worker] |
|
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
741 ]Append[", "] |
|
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
742 ]Append[[rargs]Length] |
|
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
743 ]Append[", "] |
|
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
744 ]Append[[func]Last NumParams >>] |
|
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
745 ]Append[")"] ] |
|
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
746 ]Last NumParams <<[[rargs]Length] |
|
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
747 } |
|
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
748 |
|
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
749 out <- [[[[Fold[["_Val Function Arg C"]Set Input[3, worker], prepped, rargs] |
|
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
750 ]Add Raw Line[ |
|
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
751 [[[[[[[["ValCall(" |
|
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
752 ]Append[worker] |
|
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
753 ]Append[", "] |
|
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
754 ]Append[[rargs]Length] |
|
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
755 ]Append[", "] |
|
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
756 ]Append[[func]Resume Index >>] |
|
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
757 ]Append[", "] |
|
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
758 ]Append[Escape Rhope Name[[func]Name >>]] |
|
83
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
759 ]Append[")"]] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
760 ]Add Raw Line["DISPATCH"] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
761 ]Add Raw Line[ |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
762 [[[["ValCallPostlude(" |
|
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
763 ]Append[[func]Resume Index >>] |
|
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
764 ]Append[", "] |
|
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
765 ]Append[Escape Rhope Name[[func]Name >>]] |
|
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
766 ]Append[")"]] |
|
83
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
767 ]Resume Index <<[ [[func]Resume Index >>]+[1] ] |
|
18
ea991f95ae1f
C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents:
14
diff
changeset
|
768 } |
|
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 Call@C Function[func,name,args:out] |
|
83
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
771 { |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
772 If[[name]=["Call@Worker"]] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
773 { |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
774 //TODO: Handle case when user explicitly calls the fully qualified version, but the type of the first arg isn't Worker |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
775 out <- [func]Val Call[[args]Index[0], Tail[args,1]] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
776 }{ |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
777 If[[name]=["Call"]] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
778 { |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
779 to call <- [args]Index[0] |
|
92
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
91
diff
changeset
|
780 last numparams <- [func]Last NumParams >> |
|
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
91
diff
changeset
|
781 out <- [[[[[[func]Add Raw Line[[["if (get_blueprint("]Append[Make Op[Strip Addref[to call], func]]]Append[")->type_id == TYPE_WORKER) {"]] |
|
83
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
782 ]Val Call[to call, Tail[args,1]] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
783 ]Add Raw Line["} else {"] |
|
92
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
91
diff
changeset
|
784 ]Last NumParams <<[last numparams] |
|
83
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
785 ]Func Base["Call",args, "Call"] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
786 ]Add Raw Line["}"] |
|
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
787 }{ |
|
83
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
788 out <- [func]Func Base[Escape Rhope Name[name],args, "Call"] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
789 } |
|
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
790 } |
|
18
ea991f95ae1f
C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents:
14
diff
changeset
|
791 } |
|
ea991f95ae1f
C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents:
14
diff
changeset
|
792 |
|
ea991f95ae1f
C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents:
14
diff
changeset
|
793 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
|
794 { |
|
83
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
795 Print[ [[func]Name >>]Append[ [": Func Base("]Append[tocall] ] ] |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
796 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
|
797 |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
798 If[[[rargs]Length] > [[func]Last NumParams >>]] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
799 { |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
800 If[[[func]Last NumParams >>] = [-1]] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
801 { |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
802 freed <- Val[func] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
803 }{ |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
804 freed <- [func]Add Raw Line["FreeCall"] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
805 } |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
806 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
|
807 ]Last NumParams <<[[rargs]Length] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
808 }{ |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
809 prepped <- Val[func] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
810 } |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
811 |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
812 |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
813 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
|
814 ]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
|
815 [[[[[[[[[type]Append["("] |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
816 ]Append[tocall] |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
817 ]Append[", "] |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
818 ]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
|
819 ]Append[", "] |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
820 ]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
|
821 ]Append[", "] |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
822 ]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
|
823 ]Append[")"]] |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
824 ]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
|
825 } |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
826 |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
827 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
|
828 { |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
829 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
|
830 //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
|
831 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
|
832 ,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
|
833 { |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
834 ,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
|
835 { stmt <- Val[base] } |
|
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
836 } |
|
64
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
837 |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
838 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
|
839 { 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
|
840 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
|
841 } |
|
ea991f95ae1f
C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents:
14
diff
changeset
|
842 |
|
35
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
843 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
|
844 { |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
845 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
|
846 } |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
847 |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
848 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
|
849 { |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
850 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
|
851 } |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
852 |
|
18
ea991f95ae1f
C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents:
14
diff
changeset
|
853 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
|
854 { |
|
ea991f95ae1f
C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents:
14
diff
changeset
|
855 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
|
856 } |
|
ea991f95ae1f
C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents:
14
diff
changeset
|
857 |
|
ea991f95ae1f
C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents:
14
diff
changeset
|
858 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
|
859 { |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
860 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
|
861 } |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
862 |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
863 Resolve@C Function[func,op:out] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
864 { |
|
35
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
865 If[[[func]Convention >>] = ["rhope"]] |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
866 { |
|
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
|
867 [[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
|
868 { |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
869 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
|
870 }{ |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
871 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
|
872 } |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
873 }{ |
|
35
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
874 out <- Escape Rhope Name[op] |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
875 } |
|
64
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
876 } |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
877 |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
878 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
|
879 { |
|
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
880 If[[[func]Convention >>] = ["rhope"]] |
|
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
881 { |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
882 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
|
883 }{ |
|
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
884 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
|
885 } |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
886 } |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
887 |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
888 Instruction Stream@C Function[func:out] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
889 { |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
890 out <- [func]Statements <<[()] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
891 } |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
892 |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
893 _If C[func, statement:out] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
894 { |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
895 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
|
896 } |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
897 |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
898 Do If@C Function[func,condition,stream:out] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
899 { |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
900 cond <- [condition]Make Op[func] |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
901 out <- [[Fold["_If C", [[func |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
902 ]Add Raw Line[ [["if("]Append[cond]]Append[")"] ] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
903 ]Add Raw Line["{"], [stream]Statements >>] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
904 ]Add Raw Line["}"] |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
905 ]Resume Index <<[[stream]Resume Index >>] |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
906 |
|
83
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
907 } |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
908 |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
909 Discard Outputs@C Function[func,first to discard:out] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
910 { |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
911 out <- [[[[[func |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
912 ]Add Raw Line[[["for(idx = "]Append[first to discard]]Append["; idx < cdata->num_params; ++idx)"]] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
913 ]Add Raw Line["{"] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
914 ]Add Raw Line[" if (cdata->params[idx])"] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
915 ]Add Raw Line[" release_ref(cdata->params[idx]);"] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
916 ]Add Raw Line["}"] |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
917 } |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
918 |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
919 Result Reference@C Function[func,output:out] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
920 { |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
921 out <- [["cdata->params["]Append[output]]Append["]"] |
|
83
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
922 } |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
923 |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
924 Checked Result Reference@C Function[func,output:out] |
|
75
0083b2f7b3c7
Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents:
74
diff
changeset
|
925 { |
|
0083b2f7b3c7
Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents:
74
diff
changeset
|
926 out <- [[[["("]Append[output]]Append[" < cdata->num_params ? cdata->params["]]Append[output]]Append["] : NULL)"] |
|
83
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
927 } |
|
75
0083b2f7b3c7
Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents:
74
diff
changeset
|
928 |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
929 |
|
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
930 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
|
931 { |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
932 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
|
933 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
|
934 r <- [right]Make Op[func] |
|
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
935 out <- [[[[[["(" |
|
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
936 ]Append[check] |
|
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
937 ]Append[" ? "] |
|
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
938 ]Append[l] |
|
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
939 ]Append[" : "] |
|
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
940 ]Append[r] |
|
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
941 ]Append[")"] |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
942 } |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
943 |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
944 _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
|
945 { |
|
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
946 out <- [string]Append[[[ [ ["\tRet("]Append[inputnum] ]Append[ [[", lv_"]Append[Escape Rhope Name[[func]Name >>]]]Append["->"]]]Append[Escape Rhope Name[inputname]]]Append[")\n"]] |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
947 } |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
948 |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
949 Set Outputs@C Function[func:out] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
950 { |
|
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
|
951 If[[[func]Convention >>] = ["rhope"]] |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
952 { |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
953 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
|
954 }{ |
|
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
|
955 [[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
|
956 { |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
957 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
|
958 }{ |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
959 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
|
960 } |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
961 } |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
962 } |
|
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
|
963 _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
|
964 { |
|
42
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
965 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
|
966 } |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
967 _Var Defs C[string,type,varname:out] |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
968 { |
|
42
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
969 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
|
970 } |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
971 |
|
18
ea991f95ae1f
C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents:
14
diff
changeset
|
972 |
| 2 | 973 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
|
974 { |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
975 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
|
976 { |
|
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
|
977 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
|
978 { |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
979 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
|
980 }{ |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
981 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
|
982 } |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
983 |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
984 If[ [[func]Convention >>] = ["rhope"] ] |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
985 { |
|
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
|
986 /* 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
|
987 [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
|
988 { |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
989 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
|
990 ]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
|
991 ]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
|
992 ]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
|
993 ]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
|
994 }{ |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
995 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
|
996 } */ |
|
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
|
997 out <- Val[localtype] |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
998 }{ |
|
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
|
999 out <- [[func]Naked Proto]Append[";\n"] |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1000 } |
|
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1001 } |
|
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
|
1002 } |
|
3498713c3dc9
C backend portion of supporting user 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 |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1004 _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
|
1005 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1006 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
|
1007 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1008 |
|
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
|
1009 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
|
1010 { |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1011 [[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
|
1012 { |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1013 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
|
1014 }{ |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1015 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
|
1016 } |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1017 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
|
1018 ]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
|
1019 ]Append["("] |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1020 ]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
|
1021 ]Append[")"] |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1022 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1023 |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1024 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
|
1025 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1026 If[[type] = ["Any Type"]] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1027 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1028 out <- text |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1029 }{ |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1030 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
|
1031 } |
| 2 | 1032 } |
| 1033 | |
|
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
|
1034 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
|
1035 { |
|
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1036 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
|
1037 { |
|
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1038 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
|
1039 }{ |
|
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1040 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
|
1041 } |
|
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1042 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
|
1043 { |
|
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1044 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
|
1045 }{ |
|
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1046 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
|
1047 } |
|
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1048 } |
|
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1049 |
| 2 | 1050 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
|
1051 { |
|
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1052 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
|
1053 If[ [[func]Convention >>] = ["rhope"] ] |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1054 { |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1055 ,before <- [[func]Name >>]Get DString["@"] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1056 { |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1057 type <- "MethodImpl" |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1058 cname <- [[[[Escape Rhope Name[before] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1059 ]Append[", "] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1060 ]Append[Escape Rhope Name[~]] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1061 ]Append[", "] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1062 ]Append[ [[func]Type Registry >>]Type ID[~] ] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1063 }{}{}{ |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1064 type <- "Func" |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1065 cname <- Val[fname] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1066 } |
|
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
|
1067 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
|
1068 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
|
1069 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
|
1070 { |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1071 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
|
1072 ]Append[cname] |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
1073 ]Append[",\n\tNumParams "] |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
1074 ]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
|
1075 ]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
|
1076 ]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
|
1077 ]Append[ [[func]Statements >>]Join[""] ] |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1078 ]Append["EndFuncNoLocals\n"] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1079 ]Append["DISPATCH"] |
|
34
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
1080 }{ |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1081 If[[[func]Last NumParams >>] = [-1]] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1082 { |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1083 freecall <- "" |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1084 }{ |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1085 freecall <- "\n\tFreeCall\n" |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1086 } |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1087 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
|
1088 ]Append[cname] |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
1089 ]Append[",\n\tNumParams "] |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
1090 ]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
|
1091 ]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
|
1092 ]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
|
1093 ]Append[ [[func]Statements >>]Join[""] ] |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1094 ]Append[freecall] |
|
34
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
1095 ]Append[[func]Set Outputs] |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1096 ]Append[[["EndFunc("]Append[fname]]Append[")\n"]] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1097 ]Append["DISPATCH"] |
|
34
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
1098 } |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1099 }{ |
|
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
|
1100 |
|
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1101 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
|
1102 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
|
1103 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
|
1104 ]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
|
1105 ]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
|
1106 ]Append["}"] |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1107 } |
|
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
1108 } |
|
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
1109 |
|
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1110 Blueprint C Program |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1111 { |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1112 Functions |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1113 Method Registry |
|
34
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
1114 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
|
1115 Type Registry |
|
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1116 Libraries |
|
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1117 } |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1118 |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1119 C Program[:out] |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1120 { |
|
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1121 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
|
1122 } |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1123 |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1124 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
|
1125 { |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1126 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
|
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 <- program |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1129 }{ |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1130 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
|
1131 { langlibs <- Dictionary[] } |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1132 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
|
1133 } |
|
34
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
1134 } |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
1135 |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
1136 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
|
1137 { |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
1138 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
|
1139 ]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
|
1140 ]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
|
1141 } |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
1142 |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
1143 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
|
1144 { |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
1145 out <- C Type[name] |
|
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1146 } |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1147 |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1148 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
|
1149 { |
|
42
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1150 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
|
1151 } |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1152 |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1153 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
|
1154 { |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1155 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
|
1156 } |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1157 |
|
20
b715532225c0
Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents:
19
diff
changeset
|
1158 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
|
1159 { |
|
b715532225c0
Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents:
19
diff
changeset
|
1160 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
|
1161 } |
|
b715532225c0
Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents:
19
diff
changeset
|
1162 |
|
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1163 _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
|
1164 { |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1165 def <- [func]Definitions |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1166 If[[def]=[""]] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1167 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1168 out <- text |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1169 }{ |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1170 out <- [text]Append[[def]Append["\n\n"]] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1171 } |
|
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1172 } |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1173 |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1174 _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
|
1175 { |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1176 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
|
1177 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1178 |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1179 Combine Consts[consts,func:out] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1180 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1181 out <- Combine[[func]Constants >>, consts] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1182 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1183 |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1184 _Consts C Program[text,value,name:out] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1185 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1186 out <- [text]Append[ [["object * _const_"]Append[Escape Rhope Name[name]]]Append[";\n"] ] |
|
83
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1187 } |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1188 |
|
105
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
1189 _Consts C Release[text,value,name:out] |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
1190 { |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
1191 out <- [text]Append[ [["\trelease_ref(_const_"]Append[Escape Rhope Name[name]]]Append[");\n"] ] |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
1192 } |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
1193 |
|
99
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
96
diff
changeset
|
1194 _List Literal El[text,val,index,type reg:out] |
|
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
96
diff
changeset
|
1195 { |
|
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
96
diff
changeset
|
1196 out <- [[[[text |
|
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
96
diff
changeset
|
1197 ]Append[", "] |
|
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
96
diff
changeset
|
1198 ]Append[index] |
|
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
96
diff
changeset
|
1199 ]Append[", "] |
|
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
96
diff
changeset
|
1200 ]Append[Const Construct C[val, type reg]] |
|
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
96
diff
changeset
|
1201 } |
|
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
96
diff
changeset
|
1202 |
|
83
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1203 Const Construct C[value,type reg:out] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1204 { |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1205 valtype <- Type Of[value] |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1206 [("Int32","Whole Number")]Find[valtype] |
|
83
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1207 { |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1208 out <- [["make_Int32("]Append[value]]Append[")"] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1209 }{ |
|
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
|
1210 If[[valtype] = ["Type Instance"]] |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1211 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1212 //TODO: Support parametric types |
|
83
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1213 typeid <- [type reg]Type ID[[value]Name >>] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1214 out <- [["make_Blueprint("]Append[typeid]]Append[")"] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1215 }{ |
|
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
|
1216 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
|
1217 { |
|
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1218 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
|
1219 { |
|
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1220 out <- "make_Bool(1)" |
|
37
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1221 }{ |
|
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1222 out <- "make_Bool(0)" |
|
37
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1223 } |
|
64
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1224 }{ |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1225 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
|
1226 { |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1227 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
|
1228 { s <- "I" } |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1229 { s <- "UI" } |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1230 |
|
83
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1231 out <- [[[[[["make_" |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1232 ]Append[s] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1233 ]Append["nt"] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1234 ]Append[[value]Size >>] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1235 ]Append["("] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1236 ]Append[[value]Value >>] |
|
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1237 ]Append[")"] |
|
83
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1238 }{ |
|
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1239 If[[valtype] = ["String"]] |
|
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1240 { |
|
92
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
91
diff
changeset
|
1241 out <- [["make_String(\""]Append[ [[[[value]Replace["\\", "\\\\"]]Replace["\n", "\\n"]]Replace["\r", "\\r"]]Replace["\"", "\\\""] ]]Append["\")"] |
|
83
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1242 }{ |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1243 If[[valtype]=["Worker Literal"]] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1244 { |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1245 //TODO: Figure out how to fully support these in nested cases |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1246 //or workaround the problem higher up in the food chain |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1247 [[value]Args >>]Last |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1248 { size <- [~]+[1] } |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1249 { size <- "0" } |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1250 out <- [[[[[["make_Worker(FUNC_" |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1251 ]Append[Escape Rhope Name[[value]Name >>]] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1252 ]Append[", "] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1253 ]Append[size] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1254 ]Append[", "] |
|
85
6d10b5b9ebc3
Make dispatch type selectable between replicated switch and computed goto
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1255 ]Append[Fold[["+"]Set Input[0, 1], 0, [value]Args >>]] |
|
83
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1256 ]Append[")"] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1257 }{ |
|
99
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
96
diff
changeset
|
1258 If[[valtype]=["List"]] |
|
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
96
diff
changeset
|
1259 { |
|
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
96
diff
changeset
|
1260 out <- [Fold[["_List Literal El"]Set Input[3, type reg], ["make_List("]Append[[value]Length], value]]Append[")"] |
|
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
96
diff
changeset
|
1261 }{ |
|
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
96
diff
changeset
|
1262 out <- "UnhandledLiteralType" |
|
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
96
diff
changeset
|
1263 } |
|
83
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1264 } |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1265 } |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1266 } |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1267 } |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1268 } |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1269 |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1270 } |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1271 } |
|
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1272 |
|
83
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1273 _Set Worker Params C[text,param,num,type reg,name:out] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1274 { |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1275 out <- [text]Append[ |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1276 [[[[[["\t((object **)(((t_Worker *)_const_" |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1277 ]Append[name] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1278 ]Append[")+1))["] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1279 ]Append[num] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1280 ]Append["] = "] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1281 ]Append[Const Construct C[param, type reg]] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1282 ]Append[";\n"] ] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1283 } |
|
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1284 |
|
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1285 _Set Consts C Program[text,value,name,type reg:out] |
|
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1286 { |
|
83
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1287 valtype <- Type Of[value] |
|
91
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
88
diff
changeset
|
1288 [("String","Worker Literal","List")]Find[valtype] |
|
83
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1289 { |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1290 out <- text |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1291 }{ |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1292 Const Construct C[value,type reg] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1293 { out <- [text]Append[ [[[["\t_const_"]Append[Escape Rhope Name[name]]]Append[" = "]]Append[~]]Append[";\n"] ] } |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1294 } |
|
64
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1295 } |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1296 |
|
91
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
88
diff
changeset
|
1297 _Set List Els[text,el,index,type reg:out] |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
88
diff
changeset
|
1298 { |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
88
diff
changeset
|
1299 out <- [[text]Append[ |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
88
diff
changeset
|
1300 [["\tinout[1] = " |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
88
diff
changeset
|
1301 ]Append[Const Construct C[index,type reg]] |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
88
diff
changeset
|
1302 ]Append[ |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
88
diff
changeset
|
1303 [[";\n\tinout[2] = " |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
88
diff
changeset
|
1304 ]Append[Const Construct C[el, type reg]] |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
88
diff
changeset
|
1305 ]Append[";\n"] |
|
99
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
96
diff
changeset
|
1306 |
|
91
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
88
diff
changeset
|
1307 ]]]Append["\trhope(FUNC_Set, inout, 3, 3);\n"] |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
88
diff
changeset
|
1308 } |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
88
diff
changeset
|
1309 |
|
64
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1310 _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
|
1311 { |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1312 valtype <- Type Of[value] |
|
91
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
88
diff
changeset
|
1313 [("String","Worker Literal","List")]Find[valtype] |
|
83
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1314 { |
|
91
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
88
diff
changeset
|
1315 If[[valtype]=["List"]] |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
88
diff
changeset
|
1316 { |
|
92
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
91
diff
changeset
|
1317 out <- [Fold[["_Set List Els"]Set Input[3, type reg], [text]Append["\trhope(FUNC_List, inout, 0, 1);\n"], value] |
|
91
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
88
diff
changeset
|
1318 ]Append[[["\t_const_"]Append[Escape Rhope Name[name]]]Append[" = inout[0];\n"]] |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
88
diff
changeset
|
1319 }{ |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
88
diff
changeset
|
1320 Const Construct C[value,type reg] |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
88
diff
changeset
|
1321 { init <- [text]Append[ [[[["\t_const_"]Append[Escape Rhope Name[name]]]Append[" = "]]Append[~]]Append[";\n"] ] } |
|
83
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1322 |
|
91
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
88
diff
changeset
|
1323 If[[valtype]=["Worker Literal"]] |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
88
diff
changeset
|
1324 { |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
88
diff
changeset
|
1325 out <- Fold[[["_Set Worker Params C"]Set Input[3, type reg]]Set Input[4, Escape Rhope Name[name]], init, [value]Args >>] |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
88
diff
changeset
|
1326 }{ |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
88
diff
changeset
|
1327 out <- Val[init] |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
88
diff
changeset
|
1328 } |
|
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1329 } |
|
83
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1330 }{ |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1331 out <- text |
|
64
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1332 } |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1333 } |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1334 |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1335 _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
|
1336 { |
|
85
6d10b5b9ebc3
Make dispatch type selectable between replicated switch and computed goto
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1337 out <- [[[[[text |
|
6d10b5b9ebc3
Make dispatch type selectable between replicated switch and computed goto
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1338 ]Append["\tResumeEntry("] |
|
64
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1339 ]Append[num] |
|
85
6d10b5b9ebc3
Make dispatch type selectable between replicated switch and computed goto
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1340 ]Append[","] |
|
64
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1341 ]Append[name] |
|
85
6d10b5b9ebc3
Make dispatch type selectable between replicated switch and computed goto
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1342 ]Append[")\\\n"] |
|
64
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1343 } |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1344 |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1345 _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
|
1346 { |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1347 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
|
1348 { |
|
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
|
1349 name <- Escape Rhope Name[raw name] |
|
85
6d10b5b9ebc3
Make dispatch type selectable between replicated switch and computed goto
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1350 out <- [[text]Append[ [["\tDispatchEntry("]Append[name]]Append[")\\\n"] ] |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1351 ]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
|
1352 }{ |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1353 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
|
1354 } |
|
64
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1355 } |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1356 |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1357 _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
|
1358 { |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1359 name <- Escape Rhope Name[raw name] |
|
85
6d10b5b9ebc3
Make dispatch type selectable between replicated switch and computed goto
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1360 out <- [text]Append[ [["\tDispatchEntry("]Append[name]]Append[")\\\n"] ] |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1361 } |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1362 |
|
64
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1363 _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
|
1364 { |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1365 out <- [[[[[text |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1366 ]Append["\tRES_"] |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1367 ]Append[num] |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1368 ]Append["_"] |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1369 ]Append[name] |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1370 ]Append[",\n"] |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1371 } |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1372 |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1373 _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
|
1374 { |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1375 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
|
1376 { |
|
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
|
1377 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
|
1378 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
|
1379 ]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
|
1380 }{ |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1381 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
|
1382 } |
|
64
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1383 } |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1384 |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1385 _Dispatch Enum Methods[text,types,name:out] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1386 { |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1387 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
|
1388 } |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1389 |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1390 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
|
1391 { |
|
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1392 out <- [[[[["typedef enum {\n" |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1393 ]Append[Fold["_Dispatch Enum", |
|
87
3c4325e6298f
Add First@Dictionary (need to find mem man bug)
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1394 [Fold["_Dispatch Enum Methods", "", all methods]]Append["\tFUNC_Build,\n\tFUNC_BlueprintSP_Of,\n\tFUNC_ID,\n\tFUNC_BlueprintSP_FromSP_ID,\n"], |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1395 [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
|
1396 ]Append["\tEND\n} funcids;\n\n"] |
|
85
6d10b5b9ebc3
Make dispatch type selectable between replicated switch and computed goto
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1397 ]Append["#define DispatchEntries \\\n"] |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1398 ]Append[Fold["_Dispatch Switch", |
| 88 | 1399 [Fold["_Dispatch Switch Methods", "", all methods]]Append["\tDispatchEntry(Build)\\\n\tDispatchEntry(BlueprintSP_Of)\\\n\tDispatchEntry(ID)\\\n\tDispatchEntry(BlueprintSP_FromSP_ID)\\\n"], |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1400 [program]Functions >>]] |
|
85
6d10b5b9ebc3
Make dispatch type selectable between replicated switch and computed goto
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1401 ]Append["\tEndEntry\n\n"] |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1402 } |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1403 |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1404 Not Native[func:out] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1405 { |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1406 If[[[func]Convention >>] = ["rhope"]] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1407 { out <- No } |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1408 { out <- Yes } |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1409 } |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1410 |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1411 Native[func:out] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1412 { |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1413 out <- [[func]Convention >>] = ["rhope"] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1414 } |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1415 |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1416 Local Pointers[text,func:out] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1417 { |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1418 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
|
1419 { |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1420 out <- text |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1421 }{ |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1422 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
|
1423 } |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1424 } |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1425 |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1426 _Method to Types[dict,name,type:out] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1427 { |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1428 typelist <- [dict]Index[name] {} |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1429 { typelist <- () } |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1430 |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1431 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
|
1432 |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1433 } |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1434 |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1435 _Field to Types[dict,field,type:out] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1436 { |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1437 name <- [field]Index[0] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1438 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
|
1439 |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1440 } |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1441 |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1442 Method to Types[dict,type:out] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1443 { |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1444 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
|
1445 } |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1446 |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1447 Field to Types[dict,type:out] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1448 { |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1449 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
|
1450 } |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1451 |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1452 _Method Dispatch[text, type, method, reg: out] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1453 { |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1454 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
|
1455 } |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1456 |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1457 Method Dispatch[text, types, method, reg: out] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1458 { |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1459 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
|
1460 ]Append["EndMethod("] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1461 ]Append[Escape Rhope Name[method]] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1462 ]Append[")\n\n"] |
|
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1463 } |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1464 |
|
119
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1465 Init Type Names[text,typeid,name,reg:out] |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1466 { |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1467 [reg]Defined?[name] |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1468 { out <- [text]Append[ [[[["\tregistered_types["]Append[typeid]]Append["]->name = "]]Append[Const Construct C[name, reg]]]Append[";\n"] ] } |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1469 { out <- text } |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1470 } |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1471 |
|
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1472 Text@C Program[program:out] |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1473 { |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1474 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
|
1475 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
|
1476 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
|
1477 headers <- "#include <stdio.h> |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1478 #include <stdlib.h> |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1479 #include \"builtin.h\" |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1480 #include \"object.h\" |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1481 #include \"context.h\" |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1482 #include \"func.h\" |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1483 #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
|
1484 #include \"blueprint.h\" |
|
83
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1485 #include \"array.h\" |
|
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1486 #include \"worker.h\" |
|
105
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
1487 #include \"bool.h\" |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
1488 #include <sys/time.h>\n\n" |
|
119
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1489 out <- [[[[[[[[[[[[[[[[[[headers |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1490 ]Append[[program]Dispatch[all methods]] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1491 ]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
|
1492 ]Append[Fold["_Consts C Program", |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1493 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
|
1494 constants]] |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1495 ]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
|
1496 ]Append["\n |
|
105
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
1497 #ifdef ENABLE_PROFILING |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
1498 uint64_t profile_counts[END]; |
| 116 | 1499 uint64_t profile_nestedcounts[END]; |
|
105
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
1500 uint64_t profile_totals[END]; |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
1501 uint64_t profile_selftotals[END]; |
| 116 | 1502 uint64_t profile_activationlevel[END]; |
|
105
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
1503 #endif |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
1504 |
|
75
0083b2f7b3c7
Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents:
74
diff
changeset
|
1505 int32_t rhope(uint32_t func, object ** params, uint16_t numparams, uint16_t callspace) |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1506 { |
|
105
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
1507 #ifdef ENABLE_PROFILING |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
1508 struct timeval time; |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
1509 #endif |
|
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1510 uint16_t resume,idx, vcparam_offset, last_vcparam; |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1511 context * ct; |
|
85
6d10b5b9ebc3
Make dispatch type selectable between replicated switch and computed goto
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1512 calldata * cdata, *temp_cdata, *my_cdata; |
|
6d10b5b9ebc3
Make dispatch type selectable between replicated switch and computed goto
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1513 DispatchVar |
|
6d10b5b9ebc3
Make dispatch type selectable between replicated switch and computed goto
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1514 FuncDef(Build) |
|
6d10b5b9ebc3
Make dispatch type selectable between replicated switch and computed goto
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1515 FuncDef(BlueprintSP_Of) |
|
91
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
88
diff
changeset
|
1516 FuncDef(ID) |
| 88 | 1517 FuncDef(BlueprintSP_FromSP_ID)\n"] |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1518 ]Append[Fold["Local Pointers", "", [program]Functions >>]] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1519 ]Append[" |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1520 ct = new_context(); |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1521 cdata = alloc_cdata(ct, NULL, callspace); |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1522 cdata->num_params = numparams; |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1523 for(idx = 0; idx < numparams; ++idx) |
|
75
0083b2f7b3c7
Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents:
74
diff
changeset
|
1524 cdata->params[idx] = params[idx]; |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1525 cdata->func = END; |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1526 DISPATCH\n"] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1527 ]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
|
1528 ]Append[" |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1529 Func(Build, |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1530 NumParams 1) |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1531 |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1532 Param(0, TYPE_BLUEPRINT) |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1533 |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1534 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
|
1535 release_ref(cdata->params[0]); |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1536 |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1537 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
|
1538 EndFunc(Build) |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1539 DISPATCH |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1540 |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1541 Func(BlueprintSP_Of, |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1542 NumParams 1) |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1543 |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1544 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
|
1545 release_ref(cdata->params[0]); |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1546 |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1547 Ret(0, new_object(TYPE_BLUEPRINT)) |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1548 ((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
|
1549 EndFunc(BlueprintSP_Of) |
|
83
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1550 DISPATCH |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1551 |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1552 Func(ID, NumParams 1) |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1553 |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1554 Param(0, TYPE_BLUEPRINT) |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1555 |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1556 lv_ID->id = new_object(TYPE_UINT32); |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1557 ((t_UInt32 *)lv_ID->id)->Num = ((t_Blueprint *)cdata->params[0])->bp->type_id; |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1558 release_ref(cdata->params[0]); |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1559 Ret(0, lv_ID->id) |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1560 EndFunc(ID) |
|
87
3c4325e6298f
Add First@Dictionary (need to find mem man bug)
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1561 DISPATCH |
|
3c4325e6298f
Add First@Dictionary (need to find mem man bug)
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1562 |
|
3c4325e6298f
Add First@Dictionary (need to find mem man bug)
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1563 Func(BlueprintSP_FromSP_ID, NumParams 1) |
|
3c4325e6298f
Add First@Dictionary (need to find mem man bug)
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1564 |
|
3c4325e6298f
Add First@Dictionary (need to find mem man bug)
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1565 Param(0, TYPE_UINT32) |
|
3c4325e6298f
Add First@Dictionary (need to find mem man bug)
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1566 |
|
3c4325e6298f
Add First@Dictionary (need to find mem man bug)
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1567 lv_BlueprintSP_FromSP_ID->type = ((t_UInt32 *)cdata->params[0])->Num; |
|
3c4325e6298f
Add First@Dictionary (need to find mem man bug)
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1568 if (lv_BlueprintSP_FromSP_ID->type >= max_registered_type || !registered_types[lv_BlueprintSP_FromSP_ID->type]) { |
|
3c4325e6298f
Add First@Dictionary (need to find mem man bug)
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1569 Ret(1, cdata->params[0]) |
|
3c4325e6298f
Add First@Dictionary (need to find mem man bug)
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1570 Ret(0, NULL) |
|
3c4325e6298f
Add First@Dictionary (need to find mem man bug)
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1571 } else { |
|
3c4325e6298f
Add First@Dictionary (need to find mem man bug)
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1572 release_ref(cdata->params[0]); |
|
3c4325e6298f
Add First@Dictionary (need to find mem man bug)
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1573 Ret(0, new_object(TYPE_BLUEPRINT)) |
|
3c4325e6298f
Add First@Dictionary (need to find mem man bug)
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1574 ((t_Blueprint *)cdata->params[0])->bp = registered_types[lv_BlueprintSP_FromSP_ID->type]; |
|
3c4325e6298f
Add First@Dictionary (need to find mem man bug)
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1575 Ret(1, NULL) |
|
3c4325e6298f
Add First@Dictionary (need to find mem man bug)
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1576 } |
|
3c4325e6298f
Add First@Dictionary (need to find mem man bug)
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1577 |
|
3c4325e6298f
Add First@Dictionary (need to find mem man bug)
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1578 EndFunc(BlueprintSP_FromSP_ID) |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1579 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
|
1580 ]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
|
1581 ]Append[" |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1582 DO_END: |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1583 for(idx = 0; idx < cdata->num_params; ++idx) |
|
75
0083b2f7b3c7
Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents:
74
diff
changeset
|
1584 params[idx] = cdata->params[idx]; |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1585 free_context(ct); |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1586 return cdata->num_params; |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1587 |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1588 _exception: |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1589 puts(\"Exception! Trace follows:\"); |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1590 while(cdata && cdata->func != END) |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1591 { |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1592 printf(\"%d\\n\", cdata->func); |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1593 cdata = cdata->lastframe; |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1594 } |
|
75
0083b2f7b3c7
Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents:
74
diff
changeset
|
1595 return -1; |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1596 } |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1597 |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1598 #include \"builtin.c\" |
|
83
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1599 #include \"array.c\" |
|
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1600 #include \"worker.c\" |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1601 |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1602 int main(int argc, char **argv) |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1603 { |
|
83
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1604 blueprint * bp; |
|
119
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1605 int numret,retval; |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1606 int idx,sidx; |
|
91
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
88
diff
changeset
|
1607 object * inout[3]; |
|
119
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1608 int32_t *counts, string_type_id=0; |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1609 t_String ** live_strings; |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1610 char ** typenames; |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1611 t_Array * typename; |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1612 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
|
1613 ]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
|
1614 ]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
|
1615 ]Append[Fold[["_Set Late Consts C"]Set Input[3, [program]Type Registry >>], "", constants]] |
|
119
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1616 ]Append[Fold[["Init Type Names"]Set Input[3, [program]Type Registry >>], "", [[program]Type Registry >>]Lookup >>]] |
|
83
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1617 ]Append[" |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1618 rhope(FUNC_List, inout, 0, 1); |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1619 for (idx = 0; idx < argc; ++idx) |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1620 { |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1621 inout[1] = make_String(argv[idx]); |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
81
diff
changeset
|
1622 rhope(FUNC_Append, inout, 2, 2); |
|
75
0083b2f7b3c7
Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents:
74
diff
changeset
|
1623 } |
|
105
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
1624 numret = rhope(FUNC_Main, inout, 1, 1);"] |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
1625 ]Append[Fold["_Consts C Release", "", constants]] |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
1626 ]Append[ |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
1627 " |
|
119
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1628 if (!numret) |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1629 retval = 0; |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1630 else if (numret < 0) |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1631 retval = numret; |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1632 else if (get_blueprint(inout[0])->type_id == TYPE_INT32) |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1633 { |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1634 retval = ((t_Int32 *)inout[0])->Num; |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1635 release_ref(inout[0]); |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1636 } else { |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1637 rhope(FUNC_If, inout, 1, 2); |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1638 if (inout[0]) |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1639 { |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1640 retval = 0; |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1641 release_ref(inout[0]); |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1642 } else { |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1643 retval = 1; |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1644 release_ref(inout[1]); |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1645 } |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1646 } |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1647 typenames = malloc(sizeof(char *)*max_registered_type); |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1648 for(idx = 0; idx < max_registered_type; ++idx) |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1649 { |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1650 if(registered_types[idx]) |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1651 { |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1652 typename = (t_Array *)( ((t_String *)registered_types[idx]->name)->payload.Buffer ); |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1653 typenames[idx] = malloc(typename->payload.Length+1); |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1654 memcpy(typenames[idx], typename+1, typename->payload.Length); |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1655 typenames[idx][typename->payload.Length] = 0; |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1656 if(!strcmp(typenames[idx], \"String\")) |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1657 string_type_id = idx; |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1658 release_ref(registered_types[idx]->name); |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1659 } else { |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1660 typenames[idx] = NULL; |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1661 } |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1662 } |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1663 |
|
105
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
1664 print_mem_info(manager); |
|
119
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1665 counts = malloc(sizeof(int32_t)*max_registered_type); |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1666 get_live_object_counts(manager, counts); |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1667 for(idx = 0; idx < max_registered_type; ++idx) |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1668 { |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1669 if(counts[idx]) |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1670 { |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1671 printf(\"%d objects of type %s (%d)\\n\", counts[idx], typenames[idx], idx); |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1672 if(idx == string_type_id) |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1673 { |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1674 live_strings = malloc(sizeof(t_String *)*counts[idx]); |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1675 find_live_objects_oftype(manager, string_type_id, (void **)live_strings); |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1676 for(sidx = 0; sidx < counts[idx]; ++sidx) |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1677 { |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1678 printf(\"\t%d: \", sidx); |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1679 fwrite(((t_Array *)live_strings[sidx]->payload.Buffer)+1, 1, ((t_Array *)live_strings[sidx]->payload.Buffer)->payload.Length, stdout); |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1680 puts(\"\"); |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1681 } |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1682 } |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1683 } |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1684 } |
|
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1685 fflush(stdout); |
|
105
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
1686 |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
1687 #ifdef ENABLE_PROFILING |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
1688 for (idx = 0; idx < END; ++idx) |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
1689 { |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
1690 if(profile_counts[idx]) |
| 116 | 1691 printf(\"Func: %d\tCount: %llu\tTime: %llu\tAvg: %f\tSelf: %llu\tAvg: %f\tNested Count: %llu\\n\", idx, profile_counts[idx], profile_totals[idx], ((double)profile_totals[idx])/((double)profile_counts[idx]), profile_selftotals[idx], ((double)profile_selftotals[idx])/((double)profile_counts[idx]), profile_nestedcounts[idx]); |
|
105
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
1692 } |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
1693 #endif |
|
119
72c648bca43b
Improved memory debug output and fixed memory leak in Array
Mike Pavone <pavone@retrodev.com>
parents:
116
diff
changeset
|
1694 return retval; |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1695 }\n\n"] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1696 |
|
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1697 } |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1698 |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1699 |