repos/rhope: backendutils.rhope annotate

annotate backendutils.rhope @ 75:0083b2f7b3c7

Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.

author	Mike Pavone <pavone@retrodev.com>
date	Tue, 06 Jul 2010 07:52:59 -0400
parents	a844c623c7df
children	c25d75c2440b

rev	line source
12 31f8182f3433 Finished fib test and did some small work on the c backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1
35 3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work Mike Pavone <pavone@retrodev.com> parents: 30 diff changeset	2 Escape Rhope Name NU[name:escaped]
12 31f8182f3433 Finished fib test and did some small work on the c backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	3 {
75 0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler. Mike Pavone <pavone@retrodev.com> parents: 74 diff changeset	4 escaped <- [[[[[[[[[[[[[[[[[[[[name]Replace["_","UN_"]
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	5 ]Replace["@","AT_"]
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	6 ]Replace[" ","SP_"]
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	7 ]Replace[":","CN_"]
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	8 ]Replace["?","QN_"]
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	9 ]Replace["+","PL_"]
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	10 ]Replace["-","MN_"]
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	11 ]Replace["*","TM_"]
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	12 ]Replace["/","DV_"]
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	13 ]Replace["<","LT_"]
a24eb366195c Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler Mike Pavone <pavone@retrodev.com> parents: 42 diff changeset	14 ]Replace[">","GT_"]
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 ]Replace["(","LP_"]
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	16 ]Replace[")","RP_"]
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	17 ]Replace["!","NT_"]
75 0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler. Mike Pavone <pavone@retrodev.com> parents: 74 diff changeset	18 ]Replace["=","EQ_"]
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler. Mike Pavone <pavone@retrodev.com> parents: 74 diff changeset	19 ]Replace["'","PR_"]
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler. Mike Pavone <pavone@retrodev.com> parents: 74 diff changeset	20 ]Replace["\"","DP_"]
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler. Mike Pavone <pavone@retrodev.com> parents: 74 diff changeset	21 ]Replace["\t","TB_"]
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler. Mike Pavone <pavone@retrodev.com> parents: 74 diff changeset	22 ]Replace[",", "CM_"]
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler. Mike Pavone <pavone@retrodev.com> parents: 74 diff changeset	23 ]Replace[".", "PD_"]
12 31f8182f3433 Finished fib test and did some small work on the c backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	24 }
13 23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	25
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: 30 diff changeset	26 Escape Rhope Name[name:escaped]
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work Mike Pavone <pavone@retrodev.com> parents: 30 diff changeset	27 {
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work Mike Pavone <pavone@retrodev.com> parents: 30 diff changeset	28 escaped <- Escape Rhope Name NU[[name]Replace["_","__"]]
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work Mike Pavone <pavone@retrodev.com> parents: 30 diff changeset	29 }
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work Mike Pavone <pavone@retrodev.com> parents: 30 diff changeset	30
13 23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	31 Blueprint AddRef
23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	32 {
23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	33 Value
23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	34 }
23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	35
23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	36 AddRef[value:out]
23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	37 {
23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	38 out <- [Build["AddRef"]]Value <<[value]
23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	39 }
23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	40
23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	41 Make Op@AddRef[addref,func:out]
23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	42 {
18 ea991f95ae1f C backend working well enough to generate Fib test Mike Pavone <pavone@retrodev.com> parents: 13 diff changeset	43 //TODO: Make me work with other backends
49 3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	44 out <- [["add_ref((object *)"]Append[ [[addref]Value >>]Make Op[func] ]]Append[")"]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	45 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	46
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	47 Strip Addref@AddRef[op:out]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	48 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	49 out <- [[op]Value >>]Strip Addref
13 23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	50 }
23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	51
23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	52 Make Op@String[string,func:out]
23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	53 {
23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	54 out <- [func]Resolve[string]
49 3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	55 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	56
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	57 Strip Addref@String[op:out]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	58 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	59 out <- op
13 23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	60 }
23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	61
23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	62 Make Op@Whole Number[num,func:out]
23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	63 {
23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	64 out <- num
49 3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	65 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	66
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	67 Strip Addref@Whole Number[op:out]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	68 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	69 out <- op
13 23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	70 }
23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	71
23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	72 Make Op@Real Number[num,func:out]
23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	73 {
23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	74 out <- num
49 3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	75 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	76
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	77 Strip Addref@Real Number[op:out]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	78 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	79 out <- op
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	80 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	81
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	82 Blueprint Output
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	83 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	84 Name
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	85 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	86
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	87 Output[name:out]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	88 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	89 out <- [Build["Output"]]Name <<[name]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	90 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	91
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	92 Make Op@Output[op,func:out]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	93 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	94 out <- [func]Resolve Output[[op]Name >>]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	95 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	96
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	97 Strip Addref@Output[op:out]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	98 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	99 out <- op
13 23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	100 }
23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	101
23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	102 Blueprint Constant
23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	103 {
74 a844c623c7df Add support for Worker type Mike Pavone <pavone@retrodev.com> parents: 49 diff changeset	104 Value
a844c623c7df Add support for Worker type Mike Pavone <pavone@retrodev.com> parents: 49 diff changeset	105 Need Addref
13 23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	106 }
23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	107
23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	108 Constant[var:out]
23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	109 {
74 a844c623c7df Add support for Worker type Mike Pavone <pavone@retrodev.com> parents: 49 diff changeset	110 out <- [[Build["Constant"]]Value <<[var]]Need Addref <<[Yes]
13 23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	111 }
23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	112
23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	113 Make Op@Constant[const,func:out]
23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	114 {
74 a844c623c7df Add support for Worker type Mike Pavone <pavone@retrodev.com> parents: 49 diff changeset	115 out <- [func]Lookup Constant[[const]Value >>, [const]Need Addref >>]
49 3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	116 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	117
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	118 Strip Addref@Constant[op:out]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	119 {
74 a844c623c7df Add support for Worker type Mike Pavone <pavone@retrodev.com> parents: 49 diff changeset	120 out <- [op]Need Addref <<[No]
13 23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	121 }
23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	122
23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	123 Blueprint Result
23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	124 {
23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	125 Output Num
23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	126 }
23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	127
23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	128 Result[num:out]
23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	129 {
23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	130 out <- [Build["Result"]]Output Num <<[num]
23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	131 }
23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	132
23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	133 Make Op@Result[result,func:out]
23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	134 {
23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	135 out <- [func]Result Reference[[result]Output Num>>]
49 3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	136 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	137
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	138 Strip Addref@Result[op:out]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	139 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	140 out <- op
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
75 0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler. Mike Pavone <pavone@retrodev.com> parents: 74 diff changeset	143 Blueprint Check Result
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler. Mike Pavone <pavone@retrodev.com> parents: 74 diff changeset	144 {
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler. Mike Pavone <pavone@retrodev.com> parents: 74 diff changeset	145 Output Num
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler. Mike Pavone <pavone@retrodev.com> parents: 74 diff changeset	146 }
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler. Mike Pavone <pavone@retrodev.com> parents: 74 diff changeset	147
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler. Mike Pavone <pavone@retrodev.com> parents: 74 diff changeset	148 Check Result[num:out]
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler. Mike Pavone <pavone@retrodev.com> parents: 74 diff changeset	149 {
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler. Mike Pavone <pavone@retrodev.com> parents: 74 diff changeset	150 out <- [Build["Check Result"]]Output Num <<[num]
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler. Mike Pavone <pavone@retrodev.com> parents: 74 diff changeset	151 }
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler. Mike Pavone <pavone@retrodev.com> parents: 74 diff changeset	152
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler. Mike Pavone <pavone@retrodev.com> parents: 74 diff changeset	153 Make Op@Check Result[result,func:out]
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler. Mike Pavone <pavone@retrodev.com> parents: 74 diff changeset	154 {
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler. Mike Pavone <pavone@retrodev.com> parents: 74 diff changeset	155 out <- [func]Checked Result Reference[[result]Output Num>>]
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler. Mike Pavone <pavone@retrodev.com> parents: 74 diff changeset	156 }
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler. Mike Pavone <pavone@retrodev.com> parents: 74 diff changeset	157
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler. Mike Pavone <pavone@retrodev.com> parents: 74 diff changeset	158 Strip Addref@Check Result[op:out]
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler. Mike Pavone <pavone@retrodev.com> parents: 74 diff changeset	159 {
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler. Mike Pavone <pavone@retrodev.com> parents: 74 diff changeset	160 out <- op
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler. Mike Pavone <pavone@retrodev.com> parents: 74 diff changeset	161 }
0083b2f7b3c7 Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler. Mike Pavone <pavone@retrodev.com> parents: 74 diff changeset	162
49 3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	163 Make Condition[op:out]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	164 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	165 If[[Type Of[op]]=["OrValue"]]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	166 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	167 out <- OrCond[Make Condition[[op]Left >>], Make Condition[[op]Right >>]]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	168 }{
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	169 out <- op
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	170 }
13 23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	171 }
23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	172
21 e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 18 diff changeset	173 Blueprint OrValue
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 18 diff changeset	174 {
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 18 diff changeset	175 Left
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 18 diff changeset	176 Right
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 18 diff changeset	177 }
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 18 diff changeset	178
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 18 diff changeset	179 OrValue[left,right:out]
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 18 diff changeset	180 {
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 18 diff changeset	181 out <- [[Build["OrValue"]]Left <<[left]]Right <<[right]
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 18 diff changeset	182 }
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 18 diff changeset	183
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 18 diff changeset	184 Make Op@OrValue[orval,func:out]
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 18 diff changeset	185 {
49 3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	186 out <- [func]If Null Else[[orval]Left >>, [orval]Right >>]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	187 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	188
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	189 Strip Addref@OrValue[op:out]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	190 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	191 out <- [[op]Left <<[ [[op]Left >>]Strip Addref ]]Right <<[ [[op]Right >>]Strip Addref ]
21 e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 18 diff changeset	192 }
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 18 diff changeset	193
18 ea991f95ae1f C backend working well enough to generate Fib test Mike Pavone <pavone@retrodev.com> parents: 13 diff changeset	194 Blueprint NotCond
ea991f95ae1f C backend working well enough to generate Fib test Mike Pavone <pavone@retrodev.com> parents: 13 diff changeset	195 {
ea991f95ae1f C backend working well enough to generate Fib test Mike Pavone <pavone@retrodev.com> parents: 13 diff changeset	196 Condition
ea991f95ae1f C backend working well enough to generate Fib test Mike Pavone <pavone@retrodev.com> parents: 13 diff changeset	197 }
13 23dd9c766699 C backend close to being useable mpavone@ parents: 12 diff changeset	198
18 ea991f95ae1f C backend working well enough to generate Fib test Mike Pavone <pavone@retrodev.com> parents: 13 diff changeset	199 NotCond[cond:out]
ea991f95ae1f C backend working well enough to generate Fib test Mike Pavone <pavone@retrodev.com> parents: 13 diff changeset	200 {
49 3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	201 out <- [Build["NotCond"]]Condition <<[[cond]Strip Addref]
18 ea991f95ae1f C backend working well enough to generate Fib test Mike Pavone <pavone@retrodev.com> parents: 13 diff changeset	202 }
ea991f95ae1f C backend working well enough to generate Fib test Mike Pavone <pavone@retrodev.com> parents: 13 diff changeset	203
ea991f95ae1f C backend working well enough to generate Fib test Mike Pavone <pavone@retrodev.com> parents: 13 diff changeset	204 Make Op@NotCond[cond,func:out]
ea991f95ae1f C backend working well enough to generate Fib test Mike Pavone <pavone@retrodev.com> parents: 13 diff changeset	205 {
ea991f95ae1f C backend working well enough to generate Fib test Mike Pavone <pavone@retrodev.com> parents: 13 diff changeset	206 out <- ["!"]Append[[[cond]Condition >>]Make Op[func]]
49 3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	207 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	208
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	209 Strip Addref@NotCond[op:out]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	210 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	211 out <- op
18 ea991f95ae1f C backend working well enough to generate Fib test Mike Pavone <pavone@retrodev.com> parents: 13 diff changeset	212 }
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	213
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	214 Blueprint OrCond
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	215 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	216 Condition1
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	217 Condition2
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	218 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	219
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	220 OrCond[cond1,cond2:out]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	221 {
49 3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	222 out <- [[Build["OrCond"]]Condition1 <<[[cond1]Strip Addref]]Condition2 <<[[cond2]Strip Addref]
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	223 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	224
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	225 Make Op@OrCond[cond,func:out]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	226 {
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	227 out <- ["("]Append[[[ [[cond]Condition1 >>]Make Op[func] ]Append[" \|\| "]]Append[[ [[cond]Condition2 >>]Make Op[func] ]Append[")"]]]
49 3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	228 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	229
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	230 Strip Addref@OrCond[op:out]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	231 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	232 out <- op
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	233 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	234
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	235 Blueprint AndCond
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	236 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	237 Condition1
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	238 Condition2
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	239 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	240
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	241 AndCond[cond1,cond2:out]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	242 {
49 3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	243 out <- [[Build["AndCond"]]Condition1 <<[[cond1]Strip Addref]]Condition2 <<[[cond2]Strip Addref]
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	244 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	245
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	246 Make Op@AndCond[cond,func:out]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	247 {
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	248 out <- ["("]Append[[[ [[cond]Condition1 >>]Make Op[func] ]Append[" && "]]Append[[ [[cond]Condition2 >>]Make Op[func] ]Append[")"]]]
49 3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	249 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	250
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	251 Strip Addref@AndCond[op:out]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	252 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	253 out <- op
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	254 }
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: 30 diff changeset	255
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work Mike Pavone <pavone@retrodev.com> parents: 30 diff changeset	256 Blueprint Field Ref
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work Mike Pavone <pavone@retrodev.com> parents: 30 diff changeset	257 {
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work Mike Pavone <pavone@retrodev.com> parents: 30 diff changeset	258 Variable
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work Mike Pavone <pavone@retrodev.com> parents: 30 diff changeset	259 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: 30 diff changeset	260 }
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work Mike Pavone <pavone@retrodev.com> parents: 30 diff changeset	261
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work Mike Pavone <pavone@retrodev.com> parents: 30 diff changeset	262 Field Ref[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: 30 diff changeset	263 {
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work Mike Pavone <pavone@retrodev.com> parents: 30 diff changeset	264 out <- [[Build["Field Ref"]]Variable <<[var]]Field <<[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: 30 diff changeset	265 }
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work Mike Pavone <pavone@retrodev.com> parents: 30 diff changeset	266
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work Mike Pavone <pavone@retrodev.com> parents: 30 diff changeset	267 Make Op@Field Ref[ref,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: 30 diff changeset	268 {
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work Mike Pavone <pavone@retrodev.com> parents: 30 diff changeset	269 out <- [func]Field Result[[ref]Variable >>,[ref]Field >>]
49 3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	270 }
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 Strip Addref@Field Ref[op:out]
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 out <- 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: 30 diff changeset	275 }
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	276
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	277 Blueprint 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	278 {
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	279 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	280 Params
49 3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	281 Variant
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	282 Mutable?
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	283 }
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	284
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	285 Type Instance[raw name: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	286 {
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	287 If[[raw 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	288 {
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	289 name <- "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	290 }{
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	291 name <- raw 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	292 }
49 3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	293 out <- [[[[Build["Type Instance"]]Name <<[name]]Params <<[()]]Variant <<["Boxed"]]Mutable? <<[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	294 }
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	295
42 aabda74c7a88 Fields can now be defined to have naked primitive types Mike Pavone <pavone@retrodev.com> parents: 38 diff changeset	296 Set Variant@Type Instance[type,variant:out,invalid]
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	297 {
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	298 [("Boxed","Naked","Pointer","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	299 {
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	300 out <- [type]Variant <<[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	301 }{
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	302 invalid <- 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	303 }
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	304 }
42 aabda74c7a88 Fields can now be defined to have naked primitive types Mike Pavone <pavone@retrodev.com> parents: 38 diff changeset	305
aabda74c7a88 Fields can now be defined to have naked primitive types Mike Pavone <pavone@retrodev.com> parents: 38 diff changeset	306 =@Type Instance[type,compare:out]
aabda74c7a88 Fields can now be defined to have naked primitive types Mike Pavone <pavone@retrodev.com> parents: 38 diff changeset	307 {
aabda74c7a88 Fields can now be defined to have naked primitive types Mike Pavone <pavone@retrodev.com> parents: 38 diff changeset	308 If[[Type Of[compare]] = ["String"]]
aabda74c7a88 Fields can now be defined to have naked primitive types Mike Pavone <pavone@retrodev.com> parents: 38 diff changeset	309 {
aabda74c7a88 Fields can now be defined to have naked primitive types Mike Pavone <pavone@retrodev.com> parents: 38 diff changeset	310 out <- [[type]Name >>] = [compare]
aabda74c7a88 Fields can now be defined to have naked primitive types Mike Pavone <pavone@retrodev.com> parents: 38 diff changeset	311 }{
aabda74c7a88 Fields can now be defined to have naked primitive types Mike Pavone <pavone@retrodev.com> parents: 38 diff changeset	312 //TODO: Compare parameters
aabda74c7a88 Fields can now be defined to have naked primitive types Mike Pavone <pavone@retrodev.com> parents: 38 diff changeset	313 ,out <- If[[[type]Name >>] = [[compare]Name >>]]
aabda74c7a88 Fields can now be defined to have naked primitive types Mike Pavone <pavone@retrodev.com> parents: 38 diff changeset	314 { out <- [[type]Variant >>] = [[compare]Variant >>] }
aabda74c7a88 Fields can now be defined to have naked primitive types Mike Pavone <pavone@retrodev.com> parents: 38 diff changeset	315 }
74 a844c623c7df Add support for Worker type Mike Pavone <pavone@retrodev.com> parents: 49 diff changeset	316 }
a844c623c7df Add support for Worker type Mike Pavone <pavone@retrodev.com> parents: 49 diff changeset	317
a844c623c7df Add support for Worker type Mike Pavone <pavone@retrodev.com> parents: 49 diff changeset	318 Blueprint Worker Literal
a844c623c7df Add support for Worker type Mike Pavone <pavone@retrodev.com> parents: 49 diff changeset	319 {
a844c623c7df Add support for Worker type Mike Pavone <pavone@retrodev.com> parents: 49 diff changeset	320 Name
a844c623c7df Add support for Worker type Mike Pavone <pavone@retrodev.com> parents: 49 diff changeset	321 Args
a844c623c7df Add support for Worker type Mike Pavone <pavone@retrodev.com> parents: 49 diff changeset	322 }
a844c623c7df Add support for Worker type Mike Pavone <pavone@retrodev.com> parents: 49 diff changeset	323 Worker Literal[name:out]
a844c623c7df Add support for Worker type Mike Pavone <pavone@retrodev.com> parents: 49 diff changeset	324 {
a844c623c7df Add support for Worker type Mike Pavone <pavone@retrodev.com> parents: 49 diff changeset	325 out <- [[Build["Worker Literal"]]Name <<[name]]Args <<[()]
a844c623c7df Add support for Worker type Mike Pavone <pavone@retrodev.com> parents: 49 diff changeset	326 }
a844c623c7df Add support for Worker type Mike Pavone <pavone@retrodev.com> parents: 49 diff changeset	327
a844c623c7df Add support for Worker type Mike Pavone <pavone@retrodev.com> parents: 49 diff changeset	328 Set Input@Worker Literal[worker,argnum,val:out]
a844c623c7df Add support for Worker type Mike Pavone <pavone@retrodev.com> parents: 49 diff changeset	329 {
a844c623c7df Add support for Worker type Mike Pavone <pavone@retrodev.com> parents: 49 diff changeset	330 out <- [worker]Args <<[ [[worker]Args >>]Set[argnum, val] ]
a844c623c7df Add support for Worker type Mike Pavone <pavone@retrodev.com> parents: 49 diff changeset	331 }
a844c623c7df Add support for Worker type Mike Pavone <pavone@retrodev.com> parents: 49 diff changeset	332

Mercurial > repos > rhope

annotate backendutils.rhope @ 75:0083b2f7b3c7