repos/rhope: cbackend.rhope annotate

annotate cbackend.rhope @ 48:a24eb366195c

Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler

author	Mike Pavone <pavone@retrodev.com>
date	Tue, 02 Mar 2010 00:18:49 -0500
parents	aabda74c7a88
children	3e20ed8959c4

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

Mercurial > repos > rhope

annotate cbackend.rhope @ 48:a24eb366195c