repos/rhope: cbackend.rhope annotate

annotate cbackend.rhope @ 74:a844c623c7df

Add support for Worker type

author	Mike Pavone <pavone@retrodev.com>
date	Thu, 01 Jul 2010 21:32:08 -0400
parents	f7bcf3db1342
children	0083b2f7b3c7

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

Mercurial > repos > rhope

annotate cbackend.rhope @ 74:a844c623c7df