Mercurial > repos > rhope

annotate cbackend.rhope @ 33:3b47a8538df2

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Started adding support for user defined types to C backend
author Mike Pavone <pavone@retrodev.com>
date Mon, 28 Sep 2009 22:08:40 -0400
parents 914ad38f9b59
children df038cef648b
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
12
31f8182f3433 Finished fib test and did some small work on the c backend
Mike Pavone <pavone@retrodev.com>
parents: 2
diff changeset
1 Import extendlib.rhope
31f8182f3433 Finished fib test and did some small work on the c backend
Mike Pavone <pavone@retrodev.com>
parents: 2
diff changeset
2 Import backendutils.rhope
2
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
4 Blueprint Blueprint Def
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
5 {
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
6 Name
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
7 Fixed Size
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
8 Fields
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
9 Methods
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
10 }
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
11
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
12 Blueprint Def[name]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
13 {
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
14 out <- [[[[Build["Blueprint Def"]]Name <<[name]]Fixed Size <<[0]]Fields <<[()]]Methods <<[New@Dictionary[]]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
15 }
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
16
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
17 Blueprint C Method Registry
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
18 {
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
19 Lookup
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
20 Next ID
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
21 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
22
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
23 C Method Registry[:out]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
24 {
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
25 builtins <- [[[[[[[[[[[[[New@Dictionary[]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
26 ]Set["+", "METHOD_ADD"]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
27 ]Set["-", "METHOD_SUB"]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
28 ]Set["/", "METHOD_DIV"]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
29 ]Set["*", "METHOD_MUL"]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
30 ]Set["LShift", "METHOD_LSHIFT"]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
31 ]Set["RShift", "METHOD_RSHIFT"]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
32 ]Set["=", "METHOD_EQUALS"]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
33 ]Set[">", "METHOD_GREATER"]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
34 ]Set["<", "METHOD_LESS"]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
35 ]Set["If", "METHOD_IF"]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
36 ]Set["Set Missing Field", "METHOD_SETFIELDMISSING"]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
37 ]Set["Get Missing Field", "METHOD_GETFIELDMISSING"]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
38 ]Set["Missing Method", "METHOD_MISSING"]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
39 out <- [[Build["C Method Registry"]]Lookup <<[builtins]]Next ID<<[0]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
40
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
41 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
42
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
43 Register Method@C Method Registry[reg,method:out]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
44 {
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
45 [[reg]Lookup >>]Index[method]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
46 {
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
47 out <- reg
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
48 }{
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
49 method ID <- [reg]Next ID>>
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
50 new lookup <- [[reg]Lookup >>]Set[method, ["METHOD_FIRST_USER+"]Append[method ID]]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
51 out <- [[reg]Lookup <<[new lookup]]Next ID <<[[method ID]+[1]]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
52 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
53 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
54
20
b715532225c0 Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents: 19
diff changeset
55 Method ID@C Method Registry[reg,method:out,notfound]
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
56 {
20
b715532225c0 Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents: 19
diff changeset
57 out,notfound <- [[reg]Lookup >>]Index[method]
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
58 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
59
33
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
60 Blueprint C Type
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
61 {
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
62 Name
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
63 Fields
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
64 Methods
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
65 }
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
66
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
67 C Type[name:out]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
68 {
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
69 out <- [[[Build["C Type"]]Name <<[name]]Fields <<[()]]Methods <<[()]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
70 }
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
71
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
72 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
73 {
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
74 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
75 }
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
76
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
77 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
78 {
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
79 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
80 }
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
81
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
82 _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
83 {
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
84 name <- [field]Index[0]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
85 rawtype <- [field]Index[1]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
86 If[[rawtype] = ["Any Type"]]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
87 {
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
88 type <- "\n\tobject * "
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
89 }{
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
90 type <- [["\n\tt_"]Append[Escape Rhope Name[rawtype]]]Append[" * "]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
91 }
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
92 out <- [[[text]Append[type]]Append[Escape Rhope Name[name]]]Append[";"]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
93 }
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
94
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
95 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
96 {
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
97 out <- [Fold["_Type Def C Type", "OBegin", [ctype]Fields >>]]Append[ [["\nObject("]Append[Escape Rhope Name[[ctype]Name >>]]]Append[")"] ]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
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 _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
101 {
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
102 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
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 Type Init@C Type[ctype,id,method reg,field reg:out]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
106 {
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
107 //TODO: Handle function pointers for build/copy/destroy funcs
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
108 start <- [["\tbp = register_type_byid("]Append[id]]Append[ [[", sizeof("]Append[["t_"]Append[Escape Rhope Name[ [ctype]Name >> ]]]]Append["), NULL, NULL, NULL);"] ]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
109 out <- Fold[[["_Type Init C"]Set Input[0, [ctype]Name >>]]Set Input[1, method reg], start, [ctype]Methods >>]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
110 }
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
111
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
112 Blueprint C Type Registry
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 Lookup
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
115 Definitions
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
116 Next ID
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
117 }
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
118
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
119 C Type Registry[:out]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
120 {
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
121 out <- [[[Build["C Type Registry"]]Lookup << [
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
122 [[[[[[[[[[[[[[[[New@Dictionary[]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
123 ]Set["UInt8", "TYPE_UINT8"]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
124 ]Set["UInt16", "TYPE_UINT16"]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
125 ]Set["UInt32", "TYPE_UINT32"]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
126 ]Set["UInt64", "TYPE_UINT64"]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
127 ]Set["Int8", "TYPE_INT8"]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
128 ]Set["Int16", "TYPE_INT16"]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
129 ]Set["Int32", "TYPE_INT32"]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
130 ]Set["Int64", "TYPE_INT64"]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
131 ]Set["Yes No", "TYPE_BOOLEAN"]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
132 ]Set["Float32", "TYPE_FLOAT32"]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
133 ]Set["Float64", "TYPE_FLOAT64"]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
134 ]Set["Real Number", "TYPE_FLOAT64"]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
135 ]Set["Array", "TYPE_ARRAY"]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
136 ]Set["Method Missing Exception", "TYPE_METHODMISSINGEXCEPTION"]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
137 ]Set["Field Missing Exception", "TYPE_FIELDMISSINGEXCEPTION"]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
138 ]Set["Wrong Type Exception", "TYPE_WRONGTYPEEXCEPTION"]]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
139 ]Definitions << [New@Dictionary[]]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
140 ]Next ID <<[0]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
141 }
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
142
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
143 Register Type@C Type Registry[reg,name,def:out]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
144 {
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
145 [[reg]Lookup >>]Index[name]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
146 {
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
147 out <- reg
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
148 }{
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
149 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
150 ]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
151 ]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
152 }
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
153 }
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
154
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
155 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
156 {
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
157 out,notfound <- [[reg]Lookup >>]Index[name]
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
158 }
3b47a8538df2 Started adding support for user defined types to C backend
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
159
2
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
160 Blueprint C Function
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
161 {
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
162 Name
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
163 Inputs
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
164 Outputs
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
165 Convention
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
166 Variables
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
167 Statements
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
168 Method Registry
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
169 Constants
2
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
170 }
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
171
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
172 C Function[name,inputs,outputs,convention:out]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
173 {
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
174 out <- C Function With Registry[name,inputs,outputs,convention, C Method Registry[]]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
175 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
176
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
177 C Function With Registry[name,inputs,outputs,convention,registry:out]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
178 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
179 out <- [[[[[[[[Build["C Function"]
2
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
180 ]Name <<[name]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
181 ]Inputs <<[inputs]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
182 ]Outputs <<[outputs]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
183 ]Convention <<[convention]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
184 ]Variables <<[New@Dictionary[]]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
185 ]Statements <<[()]
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
186 ]Method Registry <<[registry]
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
187 ]Constants <<[New@Dictionary[]]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
188 }
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
189
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
190 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
191 {
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
192 Print["Register Constant"]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
193 Print[name]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
194 Print[constant]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
195 out <- [func]Constants <<[ [[func]Constants >>]Set[name, constant] ]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
196 { Print["Got register constant output"] }
2
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
197 }
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
198
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
199 Allocate Var@C Function[func,name,type:out]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
200 {
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
201 out <- [func]Variables <<[ [[func]Variables >>]Set[name,type] ]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
202 }
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
203
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
204 Add Statement@C Function[func,statement:out]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
205 {
12
31f8182f3433 Finished fib test and did some small work on the c backend
Mike Pavone <pavone@retrodev.com>
parents: 2
diff changeset
206 out <- [func]Statements <<[ [[func]Statements >>]Append[["\t"]Append[[statement]Append[";\n"]]] ]
2
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
207 }
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
208
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
209 Add Raw Line@C Function[func,line:out]
2
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
210 {
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
211 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
212 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
213
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
214 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
215 {
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
216 source1 <- [psource1]Make Op[func]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
217 source2 <- [psource2]Make Op[func]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
218 dest <- [pdest]Make Op[func]
2
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
219 out <- [func]Add Statement[[[[[dest]Append[" = "]]Append[source1]]Append[op]]Append[source2]]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
220 }
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
221
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
222 Add@C Function[func,source1,source2,dest:out]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
223 {
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
224 out <- [func]Add Operator Statement[source1,source2,dest," + "]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
225 }
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
226
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
227 Sub@C Function[func,source1,source2,dest:out]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
228 {
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
229 out <- [func]Add Operator Statement[source1,source2,dest," - "]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
230 }
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
231
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
232 Multiply@C Function[func,source1,source2,dest:out]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
233 {
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
234 out <- [func]Add Operator Statement[source1,source2,dest," * "]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
235 }
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
236
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
237 Divide@C Function[func,source1,source2,dest:out]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
238 {
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
239 out <- [func]Add Operator Statement[source1,source2,dest," / "]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
240 }
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
241
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
242 Move@C Function[func,psource,pdest:out]
2
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
243 {
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
244 source <- [psource]Make Op[func]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
245 dest <- [pdest]Make Op[func]
2
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
246 out <- [func]Add Statement[[[dest]Append[" = "]]Append[source]]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
247 }
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
248
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
249 AddRef@C Function[func,psource,pdest:out]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
250 {
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
251 source <- [psource]Make Op[func]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
252 dest <- [pdest]Make Op[func]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
253 out <- [func]Add Statement[[[[dest]Append[" = add_ref("]]Append[source]]Append[")"]]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
254 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
255
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
256 Release@C Function[func,psource:out]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
257 {
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
258 source <- [psource]Make Op[func]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
259 out <- [func]Add Statement[[["release_ref("]Append[source]]Append[")"]]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
260 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
261
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
262 Set Null@C Function[func,pdest:out]
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
263 {
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
264 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
265 out <- [func]Add Statement[[dest]Append[" = NULL"]]
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
266 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
267
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
268 Lookup Constant@C Function[func,const:out]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
269 {
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
270 out <- [["add_ref(_const_"]Append[Escape Rhope Name[const]]]Append[")"]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
271 }
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
272
18
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
273 _Function Arg C[func,val,inputnum:out]
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
274 {
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
275 out <- [func]Add Statement[
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
276 [[["call->params["
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
277 ]Append[inputnum]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
278 ]Append["] = "]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
279 ]Append[val]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
280 ]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
281 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
282
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
283 Method Call@C Function[func,method,args:out]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
284 {
18
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
285 out <- [func]Func Base[[[func]Method Registry >>]Method ID[method],args, "MCall"]
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
286 }
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
287
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
288 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
289 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
290 out <- [func]Func Base[Escape Rhope Name[name],args, "Call"]
18
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
291 }
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
292
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
293 Func Base@C Function[func,tocall,args,type:out]
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
294 {
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
295 rargs <- Map[args, ["Make Op"]Set Input[1, func]]
18
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
296 out <- [Fold["_Function Arg C", func, rargs]
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
297 ]Add Raw Line[[[[[ [type]Append["("] ]Append[tocall]]Append[", "]]Append[ [rargs]Length ]]Append[")"]]
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
298 }
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
299
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
300 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
301 {
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
302 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
303 }
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
304
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
305 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
306 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
307 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
308 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
309
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
310 Resolve@C Function[func,op:out]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
311 {
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
312 [[func]Inputs >>]Find[op]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
313 {
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
314 out <- [["cdata->params["]Append[~]]Append["]"]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
315 }{
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
316 out <- ["locals->"]Append[Escape Rhope Name[op]]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
317 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
318 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
319
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
320 Instruction Stream@C Function[func:out]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
321 {
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
322 out <- [func]Statements <<[()]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
323 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
324
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
325 _If C[func, statement:out]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
326 {
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
327 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
328 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
329
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
330 Do If@C Function[func,condition,stream:out]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
331 {
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
332 cond <- [condition]Make Op[func]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
333 out <- [Fold["_If C", [[func
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
334 ]Add Raw Line[ [["if("]Append[cond]]Append[")"] ]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
335 ]Add Raw Line["{"], [stream]Statements >>]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
336 ]Add Raw Line["}"]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
337
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
338 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
339
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
340 Result Reference@C Function[func,output:out]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
341 {
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
342 out <- [["call->params["]Append[output]]Append["]"]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
343 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
344
21
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 20
diff changeset
345 If Null Else@C Function[func,left,right:out]
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 20
diff changeset
346 {
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 20
diff changeset
347 out <- [[[[[["("
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 20
diff changeset
348 ]Append[left]
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 20
diff changeset
349 ]Append[" ? "]
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 20
diff changeset
350 ]Append[left]
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 20
diff changeset
351 ]Append[" : "]
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 20
diff changeset
352 ]Append[right]
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 20
diff changeset
353 ]Append[")"]
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 20
diff changeset
354 }
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 20
diff changeset
355
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
356 Init Outputs@C Function[func:out]
12
31f8182f3433 Finished fib test and did some small work on the c backend
Mike Pavone <pavone@retrodev.com>
parents: 2
diff changeset
357 {
31f8182f3433 Finished fib test and did some small work on the c backend
Mike Pavone <pavone@retrodev.com>
parents: 2
diff changeset
358 If[[[[func]Outputs >>]Length ] > [0]]
31f8182f3433 Finished fib test and did some small work on the c backend
Mike Pavone <pavone@retrodev.com>
parents: 2
diff changeset
359 {
31f8182f3433 Finished fib test and did some small work on the c backend
Mike Pavone <pavone@retrodev.com>
parents: 2
diff changeset
360 out <- [["\tlocals->"]Append[ [[func]Outputs >>]Join[" = NULL;\n\tlocals->"] ]]Append[" = NULL;\n"]
31f8182f3433 Finished fib test and did some small work on the c backend
Mike Pavone <pavone@retrodev.com>
parents: 2
diff changeset
361 }{
31f8182f3433 Finished fib test and did some small work on the c backend
Mike Pavone <pavone@retrodev.com>
parents: 2
diff changeset
362 out <- ""
31f8182f3433 Finished fib test and did some small work on the c backend
Mike Pavone <pavone@retrodev.com>
parents: 2
diff changeset
363 }
31f8182f3433 Finished fib test and did some small work on the c backend
Mike Pavone <pavone@retrodev.com>
parents: 2
diff changeset
364 }
31f8182f3433 Finished fib test and did some small work on the c backend
Mike Pavone <pavone@retrodev.com>
parents: 2
diff changeset
365
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
366 _Release Inputs[string,inputname,inputnum:out]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
367 {
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
368 out <- [[[string
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
369 ]Append["\trelease_ref(cdata->params["]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
370 ]Append[inputnum]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
371 ]Append["]);\n"]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
372 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
373
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
374 Release Inputs@C Function[func:out]
12
31f8182f3433 Finished fib test and did some small work on the c backend
Mike Pavone <pavone@retrodev.com>
parents: 2
diff changeset
375 {
31f8182f3433 Finished fib test and did some small work on the c backend
Mike Pavone <pavone@retrodev.com>
parents: 2
diff changeset
376 If[[[[func]Inputs >>]Length ] > [0]]
31f8182f3433 Finished fib test and did some small work on the c backend
Mike Pavone <pavone@retrodev.com>
parents: 2
diff changeset
377 {
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
378 out <- Fold["_Release Inputs", "", [func]Inputs >>]
12
31f8182f3433 Finished fib test and did some small work on the c backend
Mike Pavone <pavone@retrodev.com>
parents: 2
diff changeset
379 }{
31f8182f3433 Finished fib test and did some small work on the c backend
Mike Pavone <pavone@retrodev.com>
parents: 2
diff changeset
380 out <- ""
31f8182f3433 Finished fib test and did some small work on the c backend
Mike Pavone <pavone@retrodev.com>
parents: 2
diff changeset
381 }
31f8182f3433 Finished fib test and did some small work on the c backend
Mike Pavone <pavone@retrodev.com>
parents: 2
diff changeset
382 }
31f8182f3433 Finished fib test and did some small work on the c backend
Mike Pavone <pavone@retrodev.com>
parents: 2
diff changeset
383
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
384 _Set Outputs C[string,inputname,inputnum:out]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
385 {
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
386 out <- [string]Append[[[ [ ["\tRet("]Append[inputnum] ]Append[", locals->"]]Append[inputname]]Append[")\n"]]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
387 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
388
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
389 Set Outputs@C Function[func:out]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
390 {
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
391 If[[[[func]Outputs >>]Length ] > [0]]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
392 {
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
393 out <- Fold["_Set Outputs C", "", [func]Outputs >>]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
394 }{
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
395 out <- ""
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
396 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
397 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
398 _Output Defs C[string,varname:out]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
399 {
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
400 out <- [[[string]Append["\tobject *"]]Append[Escape Rhope Name[varname]]]Append[";\n"]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
401 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
402 _Var Defs C[string,type,varname:out]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
403 {
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
404 out <- [[[string]Append["\tobject *"]]Append[Escape Rhope Name[varname]]]Append[";\n"]
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
405 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
406
18
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 14
diff changeset
407
2
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
408 Definitions@C Function[func:out]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
409 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
410 If[ [ [[[func]Variables >>]Length]+[[[func]Outputs >>]Length] ] > [0]]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
411 {
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
412 out <- [[[Fold["_Output Defs C", Fold["_Var Defs C","typedef struct {\n", [func]Variables >>], [func]Outputs >>]]Append["} l_"]]Append[Escape Rhope Name[[func]Name >>]]]Append[";\n"]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
413 }{
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
414 out <- ""
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
415 }
2
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
416 }
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
417
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
418 Text@C Function[func:out]
73e978d590c7 Adding WIP compiler code
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
419 {
12
31f8182f3433 Finished fib test and did some small work on the c backend
Mike Pavone <pavone@retrodev.com>
parents: 2
diff changeset
420 cname <- Escape Rhope Name[[func]Name >>]
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
421 If[ [[[func]Variables >>]Length] = [0] ]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
422 {
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
423 out <- [[[[[["FuncNoLocals("
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
424 ]Append[cname]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
425 ]Append[",\n\tNumParams "]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
426 ]Append[ [[func]Inputs >>]Length ]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
427 ]Append[",\n\tCallSpace 32)\n\n"]//TODO: Fill in with calculated callspace value
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
428 ]Append[ [[func]Statements >>]Join[""] ]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
429 ]Append["EndFunc"]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
430 }{
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
431 out <- [[[[[[[[["Func("
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
432 ]Append[cname]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
433 ]Append[",\n\tNumParams "]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
434 ]Append[ [[func]Inputs >>]Length ]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
435 ]Append[",\n\tCallSpace 32,\n\t"]//TODO: Fill in with calculated callspace value
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
436 ]Append[["l_"]Append[cname]]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
437 ]Append[")\n\n"]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
438 ]Append[ [[func]Statements >>]Join[""] ]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
439 ]Append[[func]Set Outputs]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
440 ]Append["EndFunc"]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
441 }
14
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
442 }
69dfca29565f C backend close to being useable
Mike Pavone <pavone@retrodev.com>
parents: 12
diff changeset
443
19
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
444 Blueprint C Program
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
445 {
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
446 Functions
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
447 Method Registry
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
448 }
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
449
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
450 C Program[:out]
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
451 {
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
452 out <- [[Build["C Program"]]Functions <<[New@Dictionary[]]]Method Registry <<[C Method Registry[]]
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
453 }
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
454
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
455 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
456 {
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
457 out <- C Function With Registry[name,inputs,outputs,convention, [program]Method Registry >>]
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
458 }
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
459
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
460 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
461 {
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
462 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
463 }
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
464
20
b715532225c0 Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents: 19
diff changeset
465 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
466 {
b715532225c0 Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents: 19
diff changeset
467 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
468 }
b715532225c0 Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents: 19
diff changeset
469
19
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
470 _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
471 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
472 def <- [func]Definitions
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
473 If[[def]=[""]]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
474 {
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
475 out <- text
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
476 }{
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
477 out <- [text]Append[[def]Append["\n\n"]]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
478 }
19
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
479 }
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
480
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
481 _Text C Program[text,func:out]
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
482 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
483 out <- [text]Append[[[func]Text]Append["\n\n"]]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
484 }
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
485
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
486 Combine Consts[consts,func:out]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
487 {
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
488 out <- Combine[[func]Constants >>, consts]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
489 }
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
490
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
491 _Consts C Program[text,value,name:out]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
492 {
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
493 out <- [text]Append[ [["object * _const_"]Append[Escape Rhope Name[name]]]Append[";\n"] ]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
494 }
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
495
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
496 _Set Consts C Program[text,value,name:out]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
497 {
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
498 //TODO: Support more constant types
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
499 out <- [text]Append[[[[["\t_const_"]Append[Escape Rhope Name[name]]]Append[" = make_Int32("]]Append[value]]Append[");\n"]]
19
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
500 }
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
501
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
502 Text@C Program[program:out]
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
503 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
504 constants <- Fold["Combine Consts", New@Dictionary[], [program]Functions >>]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
505 headers <- "#include <stdio.h>
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
506 #include \"builtin.h\"
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
507 #include \"object.h\"
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
508 #include \"context.h\"
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
509 #include \"func.h\"
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
510 #include \"integer.h\"\n\n"
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
511 out <- [[[[headers]Append[Fold["_Text C Program",
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
512 Fold["_Consts C Program",
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
513 Fold["_Defs C Program", "", [program]Functions >>],
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
514 constants
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
515 ], [program]Functions >>]]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
516 ]Append["int main(int argc, char **argv)
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
517 {
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
518 returntype ret;
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
519 calldata *cdata;
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
520 context * ct;
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
521 register_builtin_types();\n\n"]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
522 ]Append[Fold["_Set Consts C Program", "", constants]]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
523 ]Append["
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
524 ct = new_context();
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
525 cdata = alloc_cdata(ct, 0);
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
526 cdata->num_params = 0;
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
527 cdata->resume = 0;
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
528 ret = f_Main(cdata);
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
529 while(ret == TAIL_RETURN)
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
530 ret = cdata->tail_func(cdata);
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
531 if(ret == EXCEPTION_RETURN) {
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
532 puts(\"Exception!\");
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
533 return -1;
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
534 }
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
535 return 0;
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
536 }\n\n"]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
537
19
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
538 }
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
539
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
540