Mercurial > repos > rhope
annotate cbackend.rhope @ 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.
author | Mike Pavone <pavone@retrodev.com> |
---|---|
date | Tue, 06 Jul 2010 07:52:59 -0400 |
parents | a844c623c7df |
children | dbe95bfec970 |
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 { |
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
|
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[";"] |
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
|
240 ]Append[ |
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
|
241 [[[["typedef " |
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
|
242 ]Append[Rhope Type to C[ [[[ctype]Fields >>]Index[0]]Index[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
|
243 ]Append[" nt_"] |
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
|
244 ]Append[Escape Rhope Name[[ctype]Name >>]] |
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 <- "" |
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
251 }{ |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
252 [("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] |
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
273 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
274 [("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 << [ |
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
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 |
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
|
336 ]Set["Real Number", "TYPE_FLOAT64"] //12 |
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
|
337 ]Set["Blueprint", "TYPE_BLUEPRINT"] //13 |
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
|
338 ]Set["Array", "TYPE_ARRAY"] //14 |
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
|
339 ]Set["Worker", "TYPE_WORKER"] //15 |
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
|
340 ]Set["Method Missing Exception", "TYPE_METHODMISSINGEXCEPTION"] //16 |
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
|
341 ]Set["Field Missing Exception", "TYPE_FIELDMISSINGEXCEPTION"] //17 |
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
|
342 ]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
|
343 ]Definitions << [Dictionary[]] |
33
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
344 ]Next ID <<[0] |
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
345 } |
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
346 |
34
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
347 _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
|
348 { |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
349 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
|
350 } |
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 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
|
353 { |
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
354 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
|
355 } |
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 _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
|
358 { |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
359 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
|
360 } |
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
361 |
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
362 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
|
363 { |
64
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
364 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
|
365 } |
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 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
|
368 { |
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
369 name <- [def]Name >> |
33
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
370 [[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
|
371 { |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
372 [[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
|
373 { |
64
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
374 out <- reg |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
375 }{ |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
376 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
|
377 } |
33
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
378 }{ |
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
379 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
|
380 ]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
|
381 ]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
|
382 } |
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 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
|
386 { |
64
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
387 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
|
388 { |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
389 ,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
|
390 { out <- "0" } |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
391 } |
33
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
392 } |
3b47a8538df2
Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
393 |
42
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
394 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
|
395 { |
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
396 ,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
|
397 { |
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
398 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
|
399 } |
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
400 } |
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
401 |
2 | 402 Blueprint C Function |
403 { | |
404 Name | |
405 Inputs | |
406 Outputs | |
407 Convention | |
408 Variables | |
409 Statements | |
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
410 Method Registry |
35
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
411 Field Registry |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
412 Type Registry |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
413 Constants |
35
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
414 Input Types |
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
415 Output Types |
64
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
416 Resume Index |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
417 Last NumParams |
2 | 418 } |
419 | |
420 C Function[name,inputs,outputs,convention:out] | |
421 { | |
42
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
422 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
|
423 } |
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
424 |
42
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
425 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
|
426 { |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
427 out <- [[[[[[[[[[[[[[Build["C Function"] |
2 | 428 ]Name <<[name] |
429 ]Inputs <<[inputs] | |
430 ]Outputs <<[outputs] | |
431 ]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
|
432 ]Variables <<[Dictionary[]] |
2 | 433 ]Statements <<[()] |
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
434 ]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
|
435 ]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
|
436 ]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
|
437 ]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
|
438 ]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
|
439 ]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
|
440 ]Resume Index <<[1] |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
441 ]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
|
442 } |
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
443 |
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
|
444 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
|
445 { |
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
446 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
|
447 } |
3498713c3dc9
C backend portion of supporting user 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 |
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
|
449 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
|
450 { |
3498713c3dc9
C backend portion of supporting user 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 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
|
452 } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
453 |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
454 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
|
455 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
456 out <- [func]Constants <<[ [[func]Constants >>]Set[name, constant] ] |
2 | 457 } |
458 | |
459 Allocate Var@C Function[func,name,type:out] | |
460 { | |
461 out <- [func]Variables <<[ [[func]Variables >>]Set[name,type] ] | |
462 } | |
463 | |
464 Add Statement@C Function[func,statement:out] | |
465 { | |
12
31f8182f3433
Finished fib test and did some small work on the c backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
466 out <- [func]Statements <<[ [[func]Statements >>]Append[["\t"]Append[[statement]Append[";\n"]]] ] |
2 | 467 } |
468 | |
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
469 Add Raw Line@C Function[func,line:out] |
2 | 470 { |
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
471 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
|
472 } |
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
473 |
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
474 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
|
475 { |
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
476 source1 <- [psource1]Make Op[func] |
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
477 source2 <- [psource2]Make Op[func] |
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
478 dest <- [pdest]Make Op[func] |
2 | 479 out <- [func]Add Statement[[[[[dest]Append[" = "]]Append[source1]]Append[op]]Append[source2]] |
480 } | |
481 | |
482 Add@C Function[func,source1,source2,dest:out] | |
483 { | |
484 out <- [func]Add Operator Statement[source1,source2,dest," + "] | |
485 } | |
486 | |
487 Sub@C Function[func,source1,source2,dest:out] | |
488 { | |
489 out <- [func]Add Operator Statement[source1,source2,dest," - "] | |
490 } | |
491 | |
492 Multiply@C Function[func,source1,source2,dest:out] | |
493 { | |
494 out <- [func]Add Operator Statement[source1,source2,dest," * "] | |
495 } | |
496 | |
497 Divide@C Function[func,source1,source2,dest:out] | |
498 { | |
499 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
|
500 } |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
501 |
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
|
502 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
|
503 { |
a24eb366195c
Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
504 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
|
505 } |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
506 |
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
|
507 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
|
508 { |
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 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
|
510 } |
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 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
|
513 { |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
514 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
|
515 } |
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 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
|
518 { |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
519 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
|
520 } |
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 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
|
523 { |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
524 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
|
525 } |
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 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
|
528 { |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
529 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
|
530 } |
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 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
|
533 { |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
534 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
|
535 } |
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 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
|
538 { |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
539 out <- [func]Add Operator Statement[source1,source2,dest," != "] |
2 | 540 } |
541 | |
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
542 Move@C Function[func,psource,pdest:out] |
2 | 543 { |
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
544 source <- [psource]Make Op[func] |
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
545 dest <- [pdest]Make Op[func] |
2 | 546 out <- [func]Add Statement[[[dest]Append[" = "]]Append[source]] |
547 } | |
548 | |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
549 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
|
550 { |
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
|
551 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
|
552 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
|
553 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
|
554 } |
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
555 |
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
556 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
|
557 { |
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
558 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
|
559 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
|
560 } |
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
561 |
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
562 Release@C Function[func,psource:out] |
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
563 { |
64
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
564 source <- [psource]Make Op[func] |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
565 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
|
566 } |
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
567 |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
568 Set Null@C Function[func,pdest:out] |
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
569 { |
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
570 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
|
571 out <- [func]Add Statement[[dest]Append[" = NULL"]] |
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 |
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
574 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
|
575 { |
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
576 var <- ["_const_"]Append[Escape Rhope Name[const]] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
577 If[doaddref] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
578 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
579 out <- [["add_ref("]Append[var]]Append[")"] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
580 }{ |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
581 out <- Val[var] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
582 } |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
583 } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
584 |
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
|
585 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
|
586 { |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
587 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
|
588 If[[Type Of[var]] = ["String"]] |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
589 { |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
590 [[func]Inputs >>]Find[var] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
591 { |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
592 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
|
593 }{ |
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
594 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
|
595 { |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
596 [[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
|
597 { |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
598 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
|
599 }{ |
a24eb366195c
Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
600 //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
|
601 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
|
602 } |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
603 } |
42
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
604 } |
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
605 }{ |
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
606 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
|
607 } |
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
608 If[[[func]Convention >>] = ["rhope"]] |
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
609 { |
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
610 If[[type] = ["Any Type"]] |
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 rvar <- Val[as op] |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
613 }{ |
42
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
614 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
|
615 } |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
616 }{ |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
617 rvar <- Val[as op] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
618 } |
42
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
619 |
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
620 [[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
|
621 { access <- "->" } |
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
622 { access <- "->payload." } |
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
623 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
|
624 } |
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
625 |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
626 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
|
627 { |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
628 out <- func |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
629 result op <- Field Ref[var,field] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
630 } |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
631 |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
632 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
|
633 { |
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
634 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
|
635 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
|
636 } |
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
637 |
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
638 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
|
639 { |
37
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
640 out <- [func]Add Statement[ [[func]Field Result[var,field]]Append[" = NULL"] ] |
35
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
641 } |
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
642 |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
643 Copy@C Function[func,pdest:out] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
644 { |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
645 dest <- [pdest]Make Op[func] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
646 out <- [func]Add Statement[ [dest]Append[[[" = copy_object("]Append[dest]]Append[")"]] ] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
647 } |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
648 |
42
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
649 Box@C Function[func,psource,pdest,type:out] |
40
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
38
diff
changeset
|
650 { |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
38
diff
changeset
|
651 dest <- [pdest]Make Op[func] |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
38
diff
changeset
|
652 source <- [psource]Make Op[func] |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
38
diff
changeset
|
653 out <- [func]Add Statement[ |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
38
diff
changeset
|
654 [[[[[dest |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
38
diff
changeset
|
655 ]Append[" = naked_to_boxed("] |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
38
diff
changeset
|
656 ]Append[ [[func]Type Registry >>]Type ID[[type]Name >>] ] |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
38
diff
changeset
|
657 ]Append[", &"] |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
38
diff
changeset
|
658 ]Append[source] |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
38
diff
changeset
|
659 ]Append[")"] ] |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
38
diff
changeset
|
660 } |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
38
diff
changeset
|
661 |
42
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
662 Unbox@C Function[func,psource,pdest:out] |
40
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
38
diff
changeset
|
663 { |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
38
diff
changeset
|
664 dest <- [pdest]Make Op[func] |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
38
diff
changeset
|
665 source <- [psource]Make Op[func] |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
38
diff
changeset
|
666 out <- [func]Add Statement[ |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
38
diff
changeset
|
667 [[[["boxed_to_naked(" |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
38
diff
changeset
|
668 ]Append[source] |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
38
diff
changeset
|
669 ]Append[", &"] |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
38
diff
changeset
|
670 ]Append[dest] |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
38
diff
changeset
|
671 ]Append[")"] ] |
64
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
672 } |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
673 |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
674 Get Raw Pointer@C Function[func,psource,pdest:out] |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
675 { |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
676 dest <- [pdest]Make Op[func] |
64
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
677 source <- [psource]Make Op[func] |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
678 out <- [func]Add Statement[ [[[dest]Append[" = &("]]Append[source]]Append["->payload)"] ] |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
679 } |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
680 |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
681 Array Raw Pointer@C Function[func,psource,pdest:out] |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
682 { |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
683 dest <- [pdest]Make Op[func] |
64
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
684 source <- [psource]Make Op[func] |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
685 out <- [func]Add Statement[ [[[dest]Append[" = ((char *)"]]Append[source]]Append[")+ sizeof(t_Array)"] ] |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
686 } |
40
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
38
diff
changeset
|
687 |
18
ea991f95ae1f
C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents:
14
diff
changeset
|
688 _Function Arg C[func,val,inputnum:out] |
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
689 { |
64
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
690 out <- [func]Add Raw Line[ |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
691 [[[["SetParam(" |
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
692 ]Append[inputnum] |
64
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
693 ]Append[", "] |
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
694 ]Append[val] |
64
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
695 ]Append[")"] |
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
696 ] |
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
697 } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
698 |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
699 _Val Function Arg C[func,val,inputnum,worker:out] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
700 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
701 out <- [func]Add Raw Line[ |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
702 [[[[[["VCSetParam(" |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
703 ]Append[worker] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
704 ]Append[", "] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
705 ]Append[inputnum] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
706 ]Append[", "] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
707 ]Append[val] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
708 ]Append[")"] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
709 ] |
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
710 } |
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
711 |
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
712 Method Call@C Function[func,method,args:out] |
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
713 { |
64
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
714 out <- [func]Call[method,args] |
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
715 } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
716 |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
717 Val Call@C Function[func,to call,args:out] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
718 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
719 worker <- Make Op[Strip Addref[to call], func] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
720 rargs <- Map[args, ["Make Op"]Set Input[1, func]] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
721 |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
722 If[[[func]Last NumParams >>] = [-1]] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
723 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
724 freed <- Val[func] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
725 }{ |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
726 freed <- [func]Add Raw Line["FreeCall"] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
727 } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
728 prepped <- [[freed]Add Raw Line[ |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
729 [[[["VCPrepCall(" |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
730 ]Append[worker] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
731 ]Append[", "] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
732 ]Append[[rargs]Length] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
733 ]Append[")"] ] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
734 ]Last NumParams <<[[rargs]Length] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
735 |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
736 |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
737 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
|
738 ]Add Raw Line[ |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
739 [[[[[[[["ValCall(" |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
740 ]Append[worker] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
741 ]Append[", "] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
742 ]Append[[rargs]Length] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
743 ]Append[", "] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
744 ]Append[[func]Resume Index >>] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
745 ]Append[", "] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
746 ]Append[Escape Rhope Name[[func]Name >>]] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
747 ]Append[")"]] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
748 ]Add Raw Line["DISPATCH"] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
749 ]Add Raw Line[ |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
750 [[[["ValCallPostlude(" |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
751 ]Append[[func]Resume Index >>] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
752 ]Append[", "] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
753 ]Append[Escape Rhope Name[[func]Name >>]] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
754 ]Append[")"]] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
755 ]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
|
756 } |
ea991f95ae1f
C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents:
14
diff
changeset
|
757 |
ea991f95ae1f
C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents:
14
diff
changeset
|
758 Call@C Function[func,name,args:out] |
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
759 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
760 If[[name]=["Call@Worker"]] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
761 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
762 //TODO: Handle case when user explicitly calls the fully qualified version, but the type of the first arg isn't Worker |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
763 out <- [func]Val Call[[args]Index[0], Tail[args,1]] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
764 }{ |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
765 If[[name]=["Call"]] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
766 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
767 to call <- [args]Index[0] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
768 out <- [[[[[func]Add Raw Line[[["if (get_blueprint("]Append[Make Op[Strip Addref[to call], func]]]Append[")->type_id == TYPE_WORKER) {"]] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
769 ]Val Call[to call, Tail[args,1]] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
770 ]Add Raw Line["} else {"] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
771 ]Func Base["Call",args, "Call"] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
772 ]Add Raw Line["}"] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
773 }{ |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
774 out <- [func]Func Base[Escape Rhope Name[name],args, "Call"] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
775 } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
776 } |
18
ea991f95ae1f
C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents:
14
diff
changeset
|
777 } |
ea991f95ae1f
C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents:
14
diff
changeset
|
778 |
ea991f95ae1f
C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents:
14
diff
changeset
|
779 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
|
780 { |
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
781 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
|
782 |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
783 If[[[rargs]Length] > [[func]Last NumParams >>]] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
784 { |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
785 If[[[func]Last NumParams >>] = [-1]] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
786 { |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
787 freed <- Val[func] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
788 }{ |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
789 freed <- [func]Add Raw Line["FreeCall"] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
790 } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
791 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
|
792 ]Last NumParams <<[[rargs]Length] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
793 }{ |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
794 prepped <- Val[func] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
795 } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
796 |
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 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
|
799 ]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
|
800 [[[[[[[[[type]Append["("] |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
801 ]Append[tocall] |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
802 ]Append[", "] |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
803 ]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
|
804 ]Append[", "] |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
805 ]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
|
806 ]Append[", "] |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
807 ]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
|
808 ]Append[")"]] |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
809 ]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
|
810 } |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
811 |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
812 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
|
813 { |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
814 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
|
815 //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
|
816 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
|
817 ,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
|
818 { |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
819 ,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
|
820 { stmt <- Val[base] } |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
821 } |
64
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
822 |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
823 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
|
824 { 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
|
825 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
|
826 } |
ea991f95ae1f
C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents:
14
diff
changeset
|
827 |
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
|
828 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
|
829 { |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
830 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
|
831 } |
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
832 |
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
833 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
|
834 { |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
835 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
|
836 } |
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
837 |
18
ea991f95ae1f
C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents:
14
diff
changeset
|
838 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
|
839 { |
ea991f95ae1f
C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents:
14
diff
changeset
|
840 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
|
841 } |
ea991f95ae1f
C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents:
14
diff
changeset
|
842 |
ea991f95ae1f
C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents:
14
diff
changeset
|
843 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
|
844 { |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
845 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
|
846 } |
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
847 |
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
848 Resolve@C Function[func,op:out] |
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
849 { |
35
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
850 If[[[func]Convention >>] = ["rhope"]] |
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
851 { |
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
|
852 [[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
|
853 { |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
854 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
|
855 }{ |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
856 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
|
857 } |
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
858 }{ |
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
|
859 out <- Escape Rhope Name[op] |
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
860 } |
64
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
861 } |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
862 |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
863 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
|
864 { |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
865 If[[[func]Convention >>] = ["rhope"]] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
866 { |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
867 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
|
868 }{ |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
869 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
|
870 } |
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
871 } |
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
872 |
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
873 Instruction Stream@C Function[func:out] |
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
874 { |
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
875 out <- [func]Statements <<[()] |
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
876 } |
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
877 |
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
878 _If C[func, statement:out] |
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
879 { |
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
880 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
|
881 } |
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
882 |
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
883 Do If@C Function[func,condition,stream:out] |
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
884 { |
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
885 cond <- [condition]Make Op[func] |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
886 out <- [[Fold["_If C", [[func |
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
887 ]Add Raw Line[ [["if("]Append[cond]]Append[")"] ] |
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
888 ]Add Raw Line["{"], [stream]Statements >>] |
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
889 ]Add Raw Line["}"] |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
890 ]Resume Index <<[[stream]Resume Index >>] |
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
891 |
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
|
892 } |
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
|
893 |
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
|
894 Discard Outputs@C Function[func,first to discard:out] |
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
|
895 { |
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
|
896 out <- [[[[[func |
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
|
897 ]Add Raw Line[[["for(idx = "]Append[first to discard]]Append["; idx < cdata->num_params; ++idx)"]] |
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
|
898 ]Add Raw Line["{"] |
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
|
899 ]Add Raw Line[" if (cdata->params[idx])"] |
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
|
900 ]Add Raw Line[" release_ref(cdata->params[idx]);"] |
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
|
901 ]Add Raw Line["}"] |
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
902 } |
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
903 |
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
904 Result Reference@C Function[func,output:out] |
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
905 { |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
906 out <- [["cdata->params["]Append[output]]Append["]"] |
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
|
907 } |
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
|
908 |
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
|
909 Checked Result Reference@C Function[func,output:out] |
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
|
910 { |
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
|
911 out <- [[[["("]Append[output]]Append[" < cdata->num_params ? cdata->params["]]Append[output]]Append["] : NULL)"] |
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
|
912 } |
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
|
913 |
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
914 |
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
915 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
|
916 { |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
917 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
|
918 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
|
919 r <- [right]Make Op[func] |
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
920 out <- [[[[[["(" |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
921 ]Append[check] |
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
922 ]Append[" ? "] |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
923 ]Append[l] |
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
924 ]Append[" : "] |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
925 ]Append[r] |
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
926 ]Append[")"] |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
927 } |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
928 |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
929 _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
|
930 { |
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
931 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
|
932 } |
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
933 |
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
934 Set Outputs@C Function[func:out] |
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
935 { |
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
|
936 If[[[func]Convention >>] = ["rhope"]] |
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
937 { |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
938 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
|
939 }{ |
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
|
940 [[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
|
941 { |
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
942 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
|
943 }{ |
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
944 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
|
945 } |
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
946 } |
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
947 } |
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
|
948 _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
|
949 { |
42
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
950 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
|
951 } |
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
952 _Var Defs C[string,type,varname:out] |
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
953 { |
42
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
954 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
|
955 } |
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
956 |
18
ea991f95ae1f
C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents:
14
diff
changeset
|
957 |
2 | 958 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
|
959 { |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
960 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
|
961 { |
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
|
962 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
|
963 { |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
964 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
|
965 }{ |
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
966 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
|
967 } |
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
968 |
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
969 If[ [[func]Convention >>] = ["rhope"] ] |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
970 { |
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
|
971 /* 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
|
972 [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
|
973 { |
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
974 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
|
975 ]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
|
976 ]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
|
977 ]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
|
978 ]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
|
979 }{ |
3498713c3dc9
C backend portion of supporting user 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 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
|
981 } */ |
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
|
982 out <- Val[localtype] |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
983 }{ |
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
|
984 out <- [[func]Naked Proto]Append[";\n"] |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
985 } |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
986 } |
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 } |
3498713c3dc9
C backend portion of supporting user 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 |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
989 _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
|
990 { |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
991 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
|
992 } |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
993 |
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
|
994 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
|
995 { |
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
996 [[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
|
997 { |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
998 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
|
999 }{ |
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1000 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
|
1001 } |
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1002 out <- [[[[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
|
1003 ]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
|
1004 ]Append["("] |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1005 ]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
|
1006 ]Append[")"] |
36
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 |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1009 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
|
1010 { |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1011 If[[type] = ["Any Type"]] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1012 { |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1013 out <- text |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1014 }{ |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1015 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
|
1016 } |
2 | 1017 } |
1018 | |
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
|
1019 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
|
1020 { |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1021 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
|
1022 { |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1023 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
|
1024 }{ |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1025 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
|
1026 } |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1027 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
|
1028 { |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1029 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
|
1030 }{ |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1031 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
|
1032 } |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1033 } |
640f541e9116
Added support for type declarations on user defined workers 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 |
2 | 1035 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
|
1036 { |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1037 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
|
1038 If[ [[func]Convention >>] = ["rhope"] ] |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1039 { |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1040 ,before <- [[func]Name >>]Get DString["@"] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1041 { |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1042 type <- "MethodImpl" |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1043 cname <- [[[[Escape Rhope Name[before] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1044 ]Append[", "] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1045 ]Append[Escape Rhope Name[~]] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1046 ]Append[", "] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1047 ]Append[ [[func]Type Registry >>]Type ID[~] ] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1048 }{}{}{ |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1049 type <- "Func" |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1050 cname <- Val[fname] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1051 } |
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
|
1052 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
|
1053 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
|
1054 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
|
1055 { |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1056 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
|
1057 ]Append[cname] |
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
1058 ]Append[",\n\tNumParams "] |
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
1059 ]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
|
1060 ]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
|
1061 ]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
|
1062 ]Append[ [[func]Statements >>]Join[""] ] |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1063 ]Append["EndFuncNoLocals\n"] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1064 ]Append["DISPATCH"] |
34
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
1065 }{ |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1066 If[[[func]Last NumParams >>] = [-1]] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1067 { |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1068 freecall <- "" |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1069 }{ |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1070 freecall <- "\n\tFreeCall\n" |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1071 } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1072 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
|
1073 ]Append[cname] |
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
1074 ]Append[",\n\tNumParams "] |
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
1075 ]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
|
1076 ]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
|
1077 ]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
|
1078 ]Append[ [[func]Statements >>]Join[""] ] |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1079 ]Append[freecall] |
34
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
1080 ]Append[[func]Set Outputs] |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1081 ]Append[[["EndFunc("]Append[fname]]Append[")\n"]] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1082 ]Append["DISPATCH"] |
34
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
1083 } |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1084 }{ |
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
|
1085 |
3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1086 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
|
1087 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
|
1088 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
|
1089 ]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
|
1090 ]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
|
1091 ]Append["}"] |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1092 } |
14
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
1093 } |
69dfca29565f
C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents:
12
diff
changeset
|
1094 |
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1095 Blueprint C Program |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1096 { |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1097 Functions |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1098 Method Registry |
34
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
1099 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
|
1100 Type Registry |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1101 Libraries |
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1102 } |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1103 |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1104 C Program[:out] |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1105 { |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1106 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
|
1107 } |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1108 |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1109 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
|
1110 { |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1111 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
|
1112 { |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1113 out <- program |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1114 }{ |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1115 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
|
1116 { langlibs <- Dictionary[] } |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1117 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
|
1118 } |
34
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
1119 } |
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
1120 |
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
1121 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
|
1122 { |
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
1123 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
|
1124 ]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
|
1125 ]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
|
1126 } |
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
1127 |
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
1128 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
|
1129 { |
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
33
diff
changeset
|
1130 out <- C Type[name] |
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1131 } |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1132 |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1133 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
|
1134 { |
42
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1135 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
|
1136 } |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1137 |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1138 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
|
1139 { |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1140 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
|
1141 } |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1142 |
20
b715532225c0
Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents:
19
diff
changeset
|
1143 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
|
1144 { |
b715532225c0
Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents:
19
diff
changeset
|
1145 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
|
1146 } |
b715532225c0
Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents:
19
diff
changeset
|
1147 |
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1148 _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
|
1149 { |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1150 def <- [func]Definitions |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1151 If[[def]=[""]] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1152 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1153 out <- text |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1154 }{ |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1155 out <- [text]Append[[def]Append["\n\n"]] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1156 } |
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1157 } |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1158 |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1159 _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
|
1160 { |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1161 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
|
1162 } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1163 |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1164 Combine Consts[consts,func:out] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1165 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1166 out <- Combine[[func]Constants >>, consts] |
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 |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1169 _Consts C Program[text,value,name:out] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1170 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1171 out <- [text]Append[ [["object * _const_"]Append[Escape Rhope Name[name]]]Append[";\n"] ] |
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1172 } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1173 |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1174 Const Construct C[value,type reg:out] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1175 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1176 valtype <- Type Of[value] |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1177 [("Int32","Whole Number")]Find[valtype] |
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1178 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1179 out <- [["make_Int32("]Append[value]]Append[")"] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1180 }{ |
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
|
1181 If[[valtype] = ["Type Instance"]] |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1182 { |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1183 //TODO: Support parametric types |
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1184 typeid <- [type reg]Type ID[[value]Name >>] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1185 out <- [["make_Blueprint("]Append[typeid]]Append[")"] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1186 }{ |
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
|
1187 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
|
1188 { |
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1189 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
|
1190 { |
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1191 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
|
1192 }{ |
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1193 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
|
1194 } |
64
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1195 }{ |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1196 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
|
1197 { |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1198 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
|
1199 { s <- "I" } |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1200 { s <- "UI" } |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1201 |
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1202 out <- [[[[[["make_" |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1203 ]Append[s] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1204 ]Append["nt"] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1205 ]Append[[value]Size >>] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1206 ]Append["("] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1207 ]Append[[value]Value >>] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1208 ]Append[")"] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1209 }{ |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1210 If[[valtype] = ["String"]] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1211 { |
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
|
1212 out <- [["make_String(\""]Append[ [[[value]Replace["\\", "\\\\"]]Replace["\n", "\\n"]]Replace["\"", "\\\""] ]]Append["\")"] |
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1213 }{ |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1214 If[[valtype]=["Worker Literal"]] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1215 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1216 //TODO: Figure out how to fully support these in nested cases |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1217 //or workaround the problem higher up in the food chain |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1218 [[value]Args >>]Last |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1219 { size <- [~]+[1] } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1220 { size <- "0" } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1221 out <- [[[[[["make_Worker(FUNC_" |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1222 ]Append[Escape Rhope Name[[value]Name >>]] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1223 ]Append[", "] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1224 ]Append[size] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1225 ]Append[", "] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1226 ]Append[[[value]Args >>]Length] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1227 ]Append[")"] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1228 }{ |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1229 out <- "UnhandledLiteralType" |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1230 } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1231 } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1232 } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1233 } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1234 } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1235 |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1236 } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1237 } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1238 |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1239 _Set Worker Params C[text,param,num,type reg,name:out] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1240 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1241 out <- [text]Append[ |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1242 [[[[[["\t((object **)(((t_Worker *)_const_" |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1243 ]Append[name] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1244 ]Append[")+1))["] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1245 ]Append[num] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1246 ]Append["] = "] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1247 ]Append[Const Construct C[param, type reg]] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1248 ]Append[";\n"] ] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1249 } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1250 |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1251 _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
|
1252 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1253 valtype <- Type Of[value] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1254 [("String","Worker Literal")]Find[valtype] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1255 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1256 out <- text |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1257 }{ |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1258 Const Construct C[value,type reg] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1259 { 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
|
1260 } |
64
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1261 } |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1262 |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1263 _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
|
1264 { |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1265 valtype <- Type Of[value] |
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1266 [("String","Worker Literal")]Find[valtype] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1267 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1268 Const Construct C[value,type reg] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1269 { init <- [text]Append[ [[[["\t_const_"]Append[Escape Rhope Name[name]]]Append[" = "]]Append[~]]Append[";\n"] ] } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1270 |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1271 If[[valtype]=["Worker Literal"]] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1272 { |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1273 out <- Fold[[["_Set Worker Params C"]Set Input[3, type reg]]Set Input[4, Escape Rhope Name[name]], init, [value]Args >>] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1274 }{ |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1275 out <- Val[init] |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1276 } |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1277 }{ |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1278 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
|
1279 } |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1280 } |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1281 |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1282 _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
|
1283 { |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1284 out <- [[[[[[[[[text |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1285 ]Append["\tcase RES_"] |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1286 ]Append[num] |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1287 ]Append["_"] |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1288 ]Append[name] |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1289 ]Append[": goto r"] |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1290 ]Append[num] |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1291 ]Append["_"] |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1292 ]Append[name] |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1293 ]Append[";\\\n"] |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1294 } |
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 _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
|
1297 { |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1298 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
|
1299 { |
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
|
1300 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
|
1301 out <- [[text]Append[ [[[["\tcase FUNC_"]Append[name]]Append[": goto f_"]]Append[name]]Append[";\\\n"] ] |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1302 ]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
|
1303 }{ |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1304 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
|
1305 } |
64
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1306 } |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1307 |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1308 _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
|
1309 { |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1310 name <- Escape Rhope Name[raw name] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1311 out <- [text]Append[ [[[["\tcase FUNC_"]Append[name]]Append[": goto f_"]]Append[name]]Append[";\\\n"] ] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1312 } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1313 |
64
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1314 _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
|
1315 { |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1316 out <- [[[[[text |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1317 ]Append["\tRES_"] |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1318 ]Append[num] |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1319 ]Append["_"] |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1320 ]Append[name] |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1321 ]Append[",\n"] |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1322 } |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1323 |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1324 _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
|
1325 { |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1326 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
|
1327 { |
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
|
1328 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
|
1329 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
|
1330 ]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
|
1331 }{ |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1332 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
|
1333 } |
64
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 |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1336 _Dispatch Enum Methods[text,types,name:out] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1337 { |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1338 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
|
1339 } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1340 |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1341 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
|
1342 { |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1343 out <- [[[[["typedef enum {\n" |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1344 ]Append[Fold["_Dispatch Enum", |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1345 [Fold["_Dispatch Enum Methods", "", all methods]]Append["\tFUNC_Build,\n\tFUNC_BlueprintSP_Of,\n"], |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1346 [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
|
1347 ]Append["\tEND\n} funcids;\n\n"] |
e1fd6d244f14
Some progress on updating C backend to work with new C strategy
Mike Pavone <pavone@retrodev.com>
parents:
54
diff
changeset
|
1348 ]Append["#define DISPATCH switch(func) { \\\n"] |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1349 ]Append[Fold["_Dispatch Switch", |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1350 [Fold["_Dispatch Switch Methods", "", all methods]]Append["\tcase FUNC_Build: goto f_Build;\\\n\tcase FUNC_BlueprintSP_Of: goto f_BlueprintSP_Of;\\\n"], |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1351 [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
|
1352 ]Append["\tcase END: goto DO_END;\\\n}\n\n"] |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1353 } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1354 |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1355 Not Native[func:out] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1356 { |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1357 If[[[func]Convention >>] = ["rhope"]] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1358 { out <- No } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1359 { out <- Yes } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1360 } |
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 Native[func:out] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1363 { |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1364 out <- [[func]Convention >>] = ["rhope"] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1365 } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1366 |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1367 Local Pointers[text,func:out] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1368 { |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1369 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
|
1370 { |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1371 out <- text |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1372 }{ |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1373 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
|
1374 } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1375 } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1376 |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1377 _Method to Types[dict,name,type:out] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1378 { |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1379 typelist <- [dict]Index[name] {} |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1380 { typelist <- () } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1381 |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1382 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
|
1383 |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1384 } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1385 |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1386 _Field to Types[dict,field,type:out] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1387 { |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1388 name <- [field]Index[0] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1389 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
|
1390 |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1391 } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1392 |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1393 Method to Types[dict,type:out] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1394 { |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1395 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
|
1396 } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1397 |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1398 Field to Types[dict,type:out] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1399 { |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1400 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
|
1401 } |
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 _Method Dispatch[text, type, method, reg: out] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1404 { |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1405 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
|
1406 } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1407 |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1408 Method Dispatch[text, types, method, reg: out] |
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 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
|
1411 ]Append["EndMethod("] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1412 ]Append[Escape Rhope Name[method]] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1413 ]Append[")\n\n"] |
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1414 } |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1415 |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1416 Text@C Program[program:out] |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1417 { |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1418 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
|
1419 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
|
1420 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
|
1421 headers <- "#include <stdio.h> |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1422 #include <stdlib.h> |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1423 #include \"builtin.h\" |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1424 #include \"object.h\" |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1425 #include \"context.h\" |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1426 #include \"func.h\" |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
35
diff
changeset
|
1427 #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
|
1428 #include \"blueprint.h\" |
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1429 #include \"array.h\" |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1430 #include \"worker.h\" |
37
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1431 #include \"bool.h\"\n\n" |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1432 out <- [[[[[[[[[[[[[[[headers |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1433 ]Append[[program]Dispatch[all methods]] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1434 ]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
|
1435 ]Append[Fold["_Consts C Program", |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1436 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
|
1437 constants]] |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1438 ]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
|
1439 ]Append["\n |
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
|
1440 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
|
1441 { |
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1442 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
|
1443 context * ct; |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1444 calldata * cdata, *temp_cdata, *my_cdata;\n\nFuncDef(Build)\nFuncDef(BlueprintSP_Of)\n"] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1445 ]Append[Fold["Local Pointers", "", [program]Functions >>]] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1446 ]Append[" |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1447 ct = new_context(); |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1448 cdata = alloc_cdata(ct, NULL, callspace); |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1449 cdata->num_params = numparams; |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1450 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
|
1451 cdata->params[idx] = params[idx]; |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1452 cdata->func = END; |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1453 DISPATCH\n"] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1454 ]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
|
1455 ]Append[" |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1456 Func(Build, |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1457 NumParams 1) |
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 Param(0, TYPE_BLUEPRINT) |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1460 |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1461 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
|
1462 release_ref(cdata->params[0]); |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1463 |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1464 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
|
1465 EndFunc(Build) |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1466 DISPATCH |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1467 |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1468 Func(BlueprintSP_Of, |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1469 NumParams 1) |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1470 |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1471 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
|
1472 release_ref(cdata->params[0]); |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1473 |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1474 Ret(0, new_object(TYPE_BLUEPRINT)) |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1475 ((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
|
1476 EndFunc(BlueprintSP_Of) |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1477 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
|
1478 ]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
|
1479 ]Append[" |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1480 DO_END: |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1481 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
|
1482 params[idx] = cdata->params[idx]; |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1483 free_context(ct); |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1484 return cdata->num_params; |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1485 |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1486 _exception: |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1487 puts(\"Exception! Trace follows:\"); |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1488 while(cdata && cdata->func != END) |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1489 { |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1490 printf(\"%d\\n\", cdata->func); |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1491 cdata = cdata->lastframe; |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1492 } |
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
|
1493 return -1; |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1494 } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1495 |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1496 #include \"builtin.c\" |
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1497 #include \"array.c\" |
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
1498 #include \"worker.c\" |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1499 |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
65
diff
changeset
|
1500 int main(int argc, char **argv) |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1501 { |
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
|
1502 blueprint * bp; |
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
|
1503 int numret; |
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
|
1504 int idx; |
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 object * inout[2]; |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1506 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
|
1507 ]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
|
1508 ]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
|
1509 ]Append[Fold[["_Set Late Consts C"]Set Input[3, [program]Type Registry >>], "", constants]] |
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
|
1510 ]Append[" |
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
|
1511 rhope(FUNC_List, inout, 0, 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
|
1512 for (idx = 0; idx < argc; ++idx) |
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
|
1513 { |
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
|
1514 inout[1] = make_String(argv[idx]); |
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
|
1515 rhope(FUNC_Append, inout, 2, 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
|
1516 } |
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
|
1517 numret = rhope(FUNC_Main, inout, 1, 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
|
1518 if (!numret) |
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
|
1519 return 0; |
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
|
1520 if (numret < 0) |
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
|
1521 return numret; |
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
|
1522 if (get_blueprint(inout[0])->type_id == TYPE_INT32) |
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
|
1523 return ((t_Int32 *)inout[0])->Num; |
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 |
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
|
1525 rhope(FUNC_If, inout, 1, 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
|
1526 if (inout[0]) |
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
|
1527 return 0; |
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
|
1528 return 1; |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1529 }\n\n"] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1530 |
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1531 } |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1532 |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
18
diff
changeset
|
1533 |