repos/rhope: cbackend.rhope comparison

comparison cbackend.rhope @ 49:3e20ed8959c4

Added initial FFI implementation, Array type and 64-bit integers

author	Mike Pavone <pavone@retrodev.com>
date	Thu, 08 Apr 2010 01:02:18 -0400
parents	a24eb366195c
children	689fb73e7612

comparison

equal deleted inserted replaced

-:a24eb366195c
+:3e20ed8959c4
 		variant <- [type]Variant >>
 		If[[[type]Name >>] = ["Array"]]
 		{
 			[("Naked","Raw Pointer")]Find[variant]
 			{
+				/*
+				//Below code assumes that paramaterized types are implemented
 				pre param <- [[type]Params >>]Index[0] {}
 				{ pre param <- Type Instance["Any Type"] }
 				[[type]Params >>]Index[1]
 				{ param,param <- [pre param]Set Variant[~] }
 				{ param <- Val[pre param] }
 					out <- Val[child type]
 					array <- "[1]"
 				}{
 					out <- [child type]Append[" *"]
 					array <- ""
-				}
+				} */
+				out <- "void *"
+				array <- ""
 			}{
 				typename <- "Array"
 			}
 			primitive <- No
 		}{
 			,regulartype <- [("Naked","Raw Pointer")]Find[variant]
 			{
-				[("Int32","Int16","Int8")]Find[[type]Name >>]
+				[("Int64","Int32","Int16","Int8")]Find[[type]Name >>]
 				{
 					primitive <- Yes
 					[[type]Name >>]Slice[3] {}
 					{ typename <- [["int"]Append[~]]Append["_t"] }
 				}{
-					,regulartype <- [("UInt32","UInt16","UInt8")]Find[[type]Name >>]
+					,regulartype <- [("UInt64","UInt32","UInt16","UInt8")]Find[[type]Name >>]
 					{
 						primitive <- Yes
 						[[type]Name >>]Slice[4] {}
 						{ typename <- [["uint"]Append[~]]Append["_t"] }
 					}
 {
 	If[[[[ctype]Fields >>]Length] = [1]]
 	{
 		out <- [[[_Type Def C Type["typedef struct {\n\tobject _SP_header;\n\t", [[ctype]Fields >>]Index[0]]]Append["\n} t_"]]Append[[ctype]Name >>]]Append[";"]
 	}{
-		out <- [Fold["_Type Def C Type", "OBegin", [ctype]Fields >>]]Append[ [["\nObject("]Append[Escape Rhope Name[[ctype]Name >>]]]Append[")"] ]
+		//HACK!!!
+		If[[[ctype]Name >>]=["Blueprint"]]
+		{
+			out <- ""
+		}{
+			If[[[ctype]Name >>]=["Array"]]
+			{ oend <- "\nMObject(" }
+			{ oend <- "\nObject(" }
+			out <- [Fold["_Type Def C Type", "OBegin", [ctype]Fields >>]]Append[ [[oend]Append[Escape Rhope Name[[ctype]Name >>]]]Append[")"] ]
+		}
 	}
 }
 _Type Init C[type name,method reg,text,method:out]
 {
 		]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["));"]
 }
 Type Init@C Type[ctype,id,method reg,field reg:out]
 {
+	If[[[ctype]Name >>]=["Array"]]
+	{ size <- "-1" }
+	{
+		[("Int64","Int32","Int16","Int8")]Find[[ctype]Name >>]
+		{
+			[[ctype]Name >>]Slice[3] {}
+			{ typename <- [["int"]Append[~]]Append["_t"] }
+		}{
+			[("UInt64","UInt32","UInt16","UInt8")]Find[[ctype]Name >>]
+			{
+				[[ctype]Name >>]Slice[4] {}
+				{ typename <- [["uint"]Append[~]]Append["_t"] }
+			}{
+				If[[[ctype]Name >>]=["Blueprint"]]
+				{ typename <- "blueprint *" }
+				{
+					If[[[ctype]Name >>]=["Boolean"]]
+					{ typename <- "int32_t" }
+					{ typename <- ["nt_"]Append[Escape Rhope Name[[ctype]Name >>]] }
+				}
+			}
+		}
+		size <- [["sizeof("]Append[typename]]Append[")"]
+	}
 	start <- [["\tbp = register_type_byid("
 		]Append[id]
 		]Append[
-			[[", sizeof("
+			[[", "]Append[size]
 			]Append[
-				["t_"]Append[Escape Rhope Name[ [ctype]Name >> ]]]
+				[", (special_func)"]Append[
-			]Append[
-				["), (special_func)"]Append[
 					[
 						[[[[Escape Rhope Name NU[[ctype]Init >>]
 						]Append[", (special_func)"]
 						]Append[Escape Rhope Name NU[[ctype]Copy >> ]]
 						]Append[", (special_func)"]
 }
 C Type Registry[:out]
 {
 	out <- [[[Build["C Type Registry"]]Lookup << [
-			[[[[[[[[[[[[[[[[Dictionary[]
+			[[[[[[[[[[[[[[[[[Dictionary[]
 			]Set["UInt8", "TYPE_UINT8"]
 			]Set["UInt16", "TYPE_UINT16"]
 			]Set["UInt32", "TYPE_UINT32"]
 			]Set["UInt64", "TYPE_UINT64"]
 			]Set["Int8", "TYPE_INT8"]
 			]Set["Int64", "TYPE_INT64"]
 			]Set["Boolean", "TYPE_BOOLEAN"]
 			]Set["Float32", "TYPE_FLOAT32"]
 			]Set["Float64", "TYPE_FLOAT64"]
 			]Set["Real Number", "TYPE_FLOAT64"]
+			]Set["Blueprint", "TYPE_BLUEPRINT"]
 			]Set["Array", "TYPE_ARRAY"]
 			]Set["Method Missing Exception", "TYPE_METHODMISSINGEXCEPTION"]
 			]Set["Field Missing Exception", "TYPE_FIELDMISSINGEXCEPTION"]
 			]Set["Wrong Type Exception", "TYPE_WRONGTYPEEXCEPTION"]]
 		]Definitions << [Dictionary[]]
 }
 Type Inits@C Type Registry[reg,method reg,field reg:out]
 {
 	out <- Fold[[[["_Type Inits C"]Set Input[0, reg]]Set Input[1, method reg]]Set Input[2, field reg], "", [reg]Definitions >>]
+	{ Print["Type inits got output"] }
 }
 Register Type@C Type Registry[reg,def:out]
 {
 	name <- [def]Name >>
 	}
 }
 Type ID@C Type Registry[reg,name:out,notfound]
 {
-	out,notfound <- [[reg]Lookup >>]Index[name]
+	out <- [[reg]Lookup >>]Index[name] {}
+	{
+		,notfound <- If[[name]=["Any Type"]]
+		{ out <- "0" }
+	}
 }
 Simple Type?@C Type Registry[reg,name:yep,nope,notfound]
 {
 	Print[["Symple Type?: "]Append[name]]
 Do AddRef@C Function[func,psource,pdest:out]
 {
 source <- [psource]Make Op[func]
 dest <- [pdest]Make Op[func]
-out <- [func]Add Statement[[[[dest]Append[" = add_ref("]]Append[source]]Append[")"]]
+out <- [func]Add Statement[[[[dest]Append[" = add_ref((object *)"]]Append[source]]Append[")"]]
 }
 AddRef No Dest@C Function[func,psource:out]
 {
 source <- [psource]Make Op[func]
-out <- [func]Add Statement[[["add_ref("]Append[source]]Append[")"]]
+out <- [func]Add Statement[[["add_ref((object *)"]Append[source]]Append[")"]]
 }
 Release@C Function[func,psource:out]
 {
 	source <- [psource]Make Op[func]
+	Print[["Release: "]Append[source]]
 	out <- [func]Add Statement[[["release_ref("]Append[source]]Append[")"]]
 }
 Set Null@C Function[func,pdest:out]
 {
 		]Append[", &"]
 		]Append[dest]
 		]Append[")"] ]
 }
+Get Raw Pointer@C Function[func,psource,pdest:out]
+{
+	dest <- [pdest]Make Op[func]
+	source <- [psource]Make Op[func]
+	out <- [func]Add Statement[ [[[dest]Append[" = &("]]Append[source]]Append["->payload)"] ]
+}
+Array Raw Pointer@C Function[func,psource,pdest:out]
+{
+	dest <- [pdest]Make Op[func]
+	source <- [psource]Make Op[func]
+	out <- [func]Add Statement[ [[[dest]Append[" = ((char *)"]]Append[source]]Append[")+ sizeof(t_Array)"] ]
+}
 _Function Arg C[func,val,inputnum:out]
 {
 	out <- [func]Add Statement[
 		[[["call->params["
 		]Append[inputnum]
 	out <- [func]Func Base[Escape Rhope Name[name],args, "Call"]
 }
 Func Base@C Function[func,tocall,args,type:out]
 {
+	Pretty Print[args, ""]
+	{
 	rargs <- Map[args, ["Make Op"]Set Input[1, func]]
 	out <- [Fold["_Function Arg C", func, rargs]
 	]Add Raw Line[[[[[ [type]Append["("] ]Append[tocall]]Append[", "]]Append[ [rargs]Length ]]Append[")"]]
+	}
+}
+Call Foreign@C Function[func,name,language,args,store result:out]
+{
+	rargs <- Map[args, ["Make Op"]Set Input[1, func]]
+	//Assume language = "C" for now
+	base <- [[[name]Append["("]]Append[ Join[rargs, ", "] ]]Append[")"]
+	,do store <- If[[Type Of[store result]]=["String"]]
+	{
+		,do store <- If[[store result]=[""]]
+		{ stmt <- Val[base] }
+	}
+	Val[do store]
+	{ stmt <- [[Make Op[store result, func]]Append[" = "]]Append[base] }
+	out <- [func]Add Statement[stmt]
 }
 Field Base@C Function[func,field,args,type:out]
 {
 	rargs <- Map[args, ["Make Op"]Set Input[1, func]]
 			out <- ["locals->"]Append[Escape Rhope Name[op]]
 		}
 	}{
 		out <- Escape Rhope Name[op]
 	}
+}
+Resolve Output@C Function[func,name:out]
+{
+	If[[[func]Convention >>] = ["rhope"]]
+	{
+		out <- ["locals->"]Append[Escape Rhope Name[name]]
+	}{
+		out <- Escape Rhope Name[name]
+	}
 }
 Instruction Stream@C Function[func:out]
 {
 	out <- [func]Statements <<[()]
 	out <- [["call->params["]Append[output]]Append["]"]
 }
 If Null Else@C Function[func,left,right:out]
 {
+	check <- [[Make Condition[left]]Strip Addref]Make Op[func]
+	l <- [left]Make Op[func]
+	r <- [right]Make Op[func]
 	out <- [[[[[["("
-		]Append[left]
+		]Append[check]
 		]Append[" ? "]
-		]Append[left]
+		]Append[l]
 		]Append[" : "]
-		]Append[right]
+		]Append[r]
 		]Append[")"]
 }
 _Set Outputs C[string,inputname,inputnum:out]
 {
 }
 Definitions@C Function[func:out]
 {
+	Print[["Definitions@C Function: "]Append[[func]Name >>]]
+	{
 	If[ [[[func]Convention >>] = ["rhope"]] And [[ [[[func]Variables >>]Length]+[[[func]Outputs >>]Length] ] > [0]] ]
 	{
 		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"]
 	}{
 		localtype <- ""
 		}
 	}{
 		proto <- [[func]Naked Proto]Append[";\n"]
 	}
 	out <- [localtype]Append[proto]
+	}
 }
 _Proto Input[list,input,index,types:out]
 {
 	out <- [list]Append[ [[Rhope Type to C[[types]Index[index]]]Append[" "]]Append[Escape Rhope Name[input]] ]
 	}
 }
 Text@C Function[func:out]
 {
+	Print[["Text@C Function: "]Append[[func]Name >>]]
 	If[ [[func]Convention >>] = ["rhope"] ]
 	{
 		cname <- Escape Rhope Name[[func]Name >>]
 		param check <- Fold[["Check Param Type C"]Set Input[3, func], "", [func]Input Types >>]
 		If[ [ [[[func]Variables >>]Length]+[[[func]Outputs >>]Length] ] = [0] ]
 {
 	Functions
 	Method Registry
 	Field Registry
 	Type Registry
+	Libraries
 }
 C Program[:out]
 {
-	out <- [[[[Build["C Program"]]Functions <<[Dictionary[]]]Method Registry <<[C Method Registry[]]]Type Registry <<[C Type Registry[]]]Field Registry <<[C Field Registry[]]
+	out <- [[[[[Build["C Program"]]Functions <<[Dictionary[]]]Method Registry <<[C Method Registry[]]]Type Registry <<[C Type Registry[]]]Field Registry <<[C Field Registry[]]]Libraries <<[Dictionary[]]
+}
+Link@C Program[program,language,library:out]
+{
+	If[[library] = ["runtime"]]
+	{
+		out <- program
+	}{
+		langlibs <- [[program]Libraries >>]Index[language] {}
+		{ langlibs <- Dictionary[] }
+		out <- [program]Libraries <<[ [[program]Libraries >>]Set[language, [langlibs]Set[library, Yes]] ]
+	}
 }
 Register Type@C Program[program,def:out]
 {
 	out <- [[[program]Type Registry <<[ [[program]Type Registry >>]Register Type[def] ]
 	out <- [text]Append[ [["object * _const_"]Append[Escape Rhope Name[name]]]Append[";\n"] ]
 }
 _Set Consts C Program[text,value,name,type reg:out]
 {
+	Print[["_Set Consts: "]Append[valtype]]
+	Pretty Print[value, "_Set Consts: "]
 	//TODO: Support more constant types
 	valtype <- Type Of[value]
 	[("Int32","Whole Number")]Find[valtype]
 	{
 		out <- [text]Append[[[[["\t_const_"]Append[Escape Rhope Name[name]]]Append[" = make_Int32("]]Append[value]]Append[");\n"]]
+		{ Print["_Set Consts got output integer"] }
 	}{
 		If[[valtype] = ["Type Instance"]]
 		{
 			//TODO: Support parametric types
 			typeid <- [type reg]Type ID[[value]Name >>]
 			out <- [text]Append[[[[["\t_const_"]Append[Escape Rhope Name[name]]]Append[" = make_Blueprint("]]Append[typeid]]Append[");\n"]]
+			{ Print["_Set Consts got output blueprint"] }
 		}{
 			If[[valtype] = ["Yes No"]]
 			{
 				If[value]
 				{
 					out <- [text]Append[[["\t_const_"]Append[Escape Rhope Name[name]]]Append[" = (object *)val_yes;\n"]]
+					{ Print["_Set Consts got output yes"] }
 				}{
 					out <- [text]Append[[["\t_const_"]Append[Escape Rhope Name[name]]]Append[" = (object *)val_no;\n"]]
+					{ Print["_Set Consts got output no"] }
 				}
 			}
 		}
 	}
 }
 #include \"object.h\"
 #include \"context.h\"
 #include \"func.h\"
 #include \"integer.h\"
 #include \"blueprint.h\"
+#include \"array.h\"
 #include \"bool.h\"\n\n"
 	out <- [[[[[[headers
 		]Append[[[program]Type Registry >>]Type Defs]
 		]Append[Fold[["_Text C Program"]Set Input[2, [program]Type Registry >>],
 				Fold["_Consts C Program",
 					Fold["_Defs C Program", "", [program]Functions >>],
 					constants
 				], [program]Functions >>]]
-		]Append["#include \"builtin.c\"\n\nint main(int argc, char **argv)
+		]Append["#include \"builtin.c\"\n#include \"array.c\"\n\nint main(int argc, char **argv)
 {
 	returntype ret;
 	calldata *cdata;
 	context * ct;
 	blueprint * bp;

Mercurial > repos > rhope

comparison cbackend.rhope @ 49:3e20ed8959c4