repos/rhope: cbackend.rhope annotate

annotate cbackend.rhope @ 50:689fb73e7612

Add support for various integer literals and add support for raw pointers to objects and raw pointers to arrays in the FFI

author	Mike Pavone <pavone@retrodev.com>
date	Fri, 16 Apr 2010 01:57:04 -0400
parents	3e20ed8959c4
children	079200bc3e75

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

Mercurial > repos > rhope

annotate cbackend.rhope @ 50:689fb73e7612