Import extendlib.rhope
Import backendutils.rhope

Blueprint Blueprint Def
{
	Name
	Fixed Size
	Fields
	Methods
}

Blueprint Def[name]
{
	out <- [[[[Build["Blueprint Def"]]Name <<[name]]Fixed Size <<[0]]Fields <<[()]]Methods <<[New@Dictionary[]]
}

Blueprint C Method Registry
{
	Lookup
	Next ID
}

C Method Registry[:out]
{
	builtins <- [[[[[[[[[[[[[New@Dictionary[]
		]Set["+", "METHOD_ADD"]
		]Set["-", "METHOD_SUB"]
		]Set["/", "METHOD_DIV"]
		]Set["*", "METHOD_MUL"]
		]Set["LShift", "METHOD_LSHIFT"]
		]Set["RShift", "METHOD_RSHIFT"]
		]Set["=", "METHOD_EQUALS"]
		]Set[">", "METHOD_GREATER"]
		]Set["<", "METHOD_LESS"]
		]Set["If", "METHOD_IF"]
		]Set["Set Missing Field", "METHOD_SETFIELDMISSING"]
		]Set["Get Missing Field", "METHOD_GETFIELDMISSING"]
		]Set["Missing Method", "METHOD_MISSING"]
	out <- [[Build["C Method Registry"]]Lookup <<[builtins]]Next ID<<[0]

}

Register Method@C Method Registry[reg,method:out]
{
	[[reg]Lookup >>]Index[method]
	{
		out <- reg
	}{
		method ID <- [reg]Next ID>>
		new lookup <- [[reg]Lookup >>]Set[method, ["METHOD_FIRST_USER+"]Append[method ID]]
		out <- [[reg]Lookup <<[new lookup]]Next ID <<[[method ID]+[1]]
	}
}

Method ID@C Method Registry[reg,method:out,notfound]
{
	out,notfound <- [[reg]Lookup >>]Index[method]
}

Blueprint C Function
{
	Name
	Inputs
	Outputs
	Convention
	Variables
	Statements
	Method Registry
	Constants
}

C Function[name,inputs,outputs,convention:out]
{
	out <- C Function With Registry[name,inputs,outputs,convention, C Method Registry[]]
}

C Function With Registry[name,inputs,outputs,convention,registry:out]
{
	out <- [[[[[[[[Build["C Function"]
		]Name <<[name]
		]Inputs <<[inputs]
		]Outputs <<[outputs]
		]Convention <<[convention]
		]Variables <<[New@Dictionary[]]
		]Statements <<[()]
		]Method Registry <<[registry]
		]Constants <<[New@Dictionary[]]
}

Register Constant@C Function[func,name,constant:out]
{
	Print["Register Constant"]
	Print[name]
	Print[constant]
	out <- [func]Constants <<[ [[func]Constants >>]Set[name, constant] ]
	{ Print["Got register constant output"] }
}

Allocate Var@C Function[func,name,type:out]
{
	out <- [func]Variables <<[ [[func]Variables >>]Set[name,type] ]
}

Add Statement@C Function[func,statement:out]
{
	out <- [func]Statements <<[ [[func]Statements >>]Append[["\t"]Append[[statement]Append[";\n"]]] ]
}

Add Raw Line@C Function[func,line:out]
{
	out <- [func]Statements <<[ [[func]Statements >>]Append[["\t"]Append[[line]Append["\n"]]] ]
}

Add Operator Statement@C Function[func,psource1,psource2,pdest,op:out]
{
	source1 <- [psource1]Make Op[func]
	source2 <- [psource2]Make Op[func]
	dest <- [pdest]Make Op[func]
	out <- [func]Add Statement[[[[[dest]Append[" = "]]Append[source1]]Append[op]]Append[source2]]
}

Add@C Function[func,source1,source2,dest:out]
{
	out <- [func]Add Operator Statement[source1,source2,dest," + "]
}

Sub@C Function[func,source1,source2,dest:out]
{
	out <- [func]Add Operator Statement[source1,source2,dest," - "]
}

Multiply@C Function[func,source1,source2,dest:out]
{
	out <- [func]Add Operator Statement[source1,source2,dest," * "]
}

Divide@C Function[func,source1,source2,dest:out]
{
	out <- [func]Add Operator Statement[source1,source2,dest," / "]
}

Move@C Function[func,psource,pdest:out]
{
	source <- [psource]Make Op[func]
	dest <- [pdest]Make Op[func]
	out <- [func]Add Statement[[[dest]Append[" = "]]Append[source]]
}

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[")"]]
}

Release@C Function[func,psource:out]
{
	source <- [psource]Make Op[func]
	out <- [func]Add Statement[[["release_ref("]Append[source]]Append[")"]]
}

Set Null@C Function[func,pdest:out]
{
	dest <- [pdest]Make Op[func]
	out <- [func]Add Statement[[dest]Append[" = NULL"]]
}

Lookup Constant@C Function[func,const:out]
{
	out <- [["add_ref(_const_"]Append[Escape Rhope Name[const]]]Append[")"]
}

_Function Arg C[func,val,inputnum:out]
{
	out <- [func]Add Statement[
		[[["call->params["
		]Append[inputnum]
		]Append["] = "]
		]Append[val]
	]
}

Method Call@C Function[func,method,args:out]
{
	out <- [func]Func Base[[[func]Method Registry >>]Method ID[method],args, "MCall"]
}

Call@C Function[func,name,args:out]
{
	out <- [func]Func Base[Escape Rhope Name[name],args, "Call"]
}

Func Base@C Function[func,tocall,args,type:out]
{
	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[")"]]
}

Tail Method Call@C Function[func,method,args:out]
{
	out <- [func]Func Base[[[func]Method Registry >>]Method ID[method],args, "TMCall"]
}

Tail Call@C Function[func,name,args:out]
{
	out <- [func]Func Base[Escape Rhope Name[name],args, "TCall"]
}

Resolve@C Function[func,op:out]
{
	[[func]Inputs >>]Find[op]
	{
		out <- [["cdata->params["]Append[~]]Append["]"]
	}{
		out <- ["locals->"]Append[Escape Rhope Name[op]]
	}
}

Instruction Stream@C Function[func:out]
{
	out <- [func]Statements <<[()]
}

_If C[func, statement:out]
{
	out <- [func]Statements <<[ [[func]Statements >>]Append[ ["\t"]Append[statement] ] ]
}

Do If@C Function[func,condition,stream:out]
{
	cond <- [condition]Make Op[func]
	out <- [Fold["_If C", [[func
		]Add Raw Line[ [["if("]Append[cond]]Append[")"] ]
		]Add Raw Line["{"], [stream]Statements >>]
		]Add Raw Line["}"]

}

Result Reference@C Function[func,output:out]
{
	out <- [["call->params["]Append[output]]Append["]"]
}

If Null Else@C Function[func,left,right:out]
{
	out <- [[[[[["("
		]Append[left]
		]Append[" ? "]
		]Append[left]
		]Append[" : "]
		]Append[right]
		]Append[")"]
}

Init Outputs@C Function[func:out]
{
	If[[[[func]Outputs >>]Length ] > [0]]
	{
		out <- [["\tlocals->"]Append[ [[func]Outputs >>]Join[" = NULL;\n\tlocals->"] ]]Append[" = NULL;\n"]
	}{
		out <- ""
	}
}

_Release Inputs[string,inputname,inputnum:out]
{
	out <- [[[string
		]Append["\trelease_ref(cdata->params["]
		]Append[inputnum]
		]Append["]);\n"]
}

Release Inputs@C Function[func:out]
{
	If[[[[func]Inputs >>]Length ] > [0]]
	{
		out <- Fold["_Release Inputs", "", [func]Inputs >>] 
	}{
		out <- ""
	}
}

_Set Outputs C[string,inputname,inputnum:out]
{
	out <- [string]Append[[[ [ ["\tRet("]Append[inputnum] ]Append[", locals->"]]Append[inputname]]Append[")\n"]]
}

Set Outputs@C Function[func:out]
{
	If[[[[func]Outputs >>]Length ] > [0]]
	{
		out <- Fold["_Set Outputs C", "", [func]Outputs >>]
	}{
		out <- ""
	}
}
_Output Defs C[string,varname:out]
{
	out <- [[[string]Append["\tobject *"]]Append[Escape Rhope Name[varname]]]Append[";\n"]
}
_Var Defs C[string,type,varname:out]
{
	out <- [[[string]Append["\tobject *"]]Append[Escape Rhope Name[varname]]]Append[";\n"]
}


Definitions@C Function[func:out]
{
	If[ [ [[[func]Variables >>]Length]+[[[func]Outputs >>]Length] ] > [0]]
	{
		out <- [[[Fold["_Output Defs C", Fold["_Var Defs C","typedef struct {\n", [func]Variables >>], [func]Outputs >>]]Append["} l_"]]Append[Escape Rhope Name[[func]Name >>]]]Append[";\n"]
	}{
		out <- ""
	}
}

Text@C Function[func:out]
{
	cname <- Escape Rhope Name[[func]Name >>]
	If[ [[[func]Variables >>]Length] = [0] ]
	{
		out <- [[[[[["FuncNoLocals("
			]Append[cname]
			]Append[",\n\tNumParams "]
			]Append[ [[func]Inputs >>]Length ]
			]Append[",\n\tCallSpace 32)\n\n"]//TODO: Fill in with calculated callspace value
			]Append[ [[func]Statements >>]Join[""] ]
			]Append["EndFunc"]
	}{
		out <- [[[[[[[[["Func("
			]Append[cname]
			]Append[",\n\tNumParams "]
			]Append[ [[func]Inputs >>]Length ]
			]Append[",\n\tCallSpace 32,\n\t"]//TODO: Fill in with calculated callspace value
			]Append[["l_"]Append[cname]]
			]Append[")\n\n"]
			]Append[ [[func]Statements >>]Join[""] ]
			]Append[[func]Set Outputs]
			]Append["EndFunc"]
	}
}

Blueprint C Program
{
	Functions
	Method Registry
}

C Program[:out]
{
	out <- [[Build["C Program"]]Functions <<[New@Dictionary[]]]Method Registry <<[C Method Registry[]]
}

Create Function@C Program[program,name,inputs,outputs,convention:out]
{
	out <- C Function With Registry[name,inputs,outputs,convention, [program]Method Registry >>]
}

Store Function@C Program[program,func:out]
{
	out <- [program]Functions <<[ [[program]Functions >>]Set[ [func]Name >>, func] ]
}

Method?@C Program[program,funcname:is,isnot]
{
	is,isnot <- [[program]Method Registry >>]Method ID[funcname]
}

_Defs C Program[text,func:out]
{
	def <- [func]Definitions
	If[[def]=[""]]
	{
		out <- text
	}{
		out <- [text]Append[[def]Append["\n\n"]]
	}
}

_Text C Program[text,func:out]
{
	out <- [text]Append[[[func]Text]Append["\n\n"]]
}

Combine Consts[consts,func:out]
{
	out <- Combine[[func]Constants >>, consts]
}

_Consts C Program[text,value,name:out]
{
	out <- [text]Append[ [["object * _const_"]Append[Escape Rhope Name[name]]]Append[";\n"] ]
}

_Set Consts C Program[text,value,name:out]
{
	//TODO: Support more constant types
	out <- [text]Append[[[[["\t_const_"]Append[Escape Rhope Name[name]]]Append[" = make_Int32("]]Append[value]]Append[");\n"]]
}

Text@C Program[program:out]
{
	constants <- Fold["Combine Consts", New@Dictionary[], [program]Functions >>]
	headers <- "#include <stdio.h>
#include \"builtin.h\"
#include \"object.h\"
#include \"context.h\"
#include \"func.h\"
#include \"integer.h\"\n\n"
	out <- [[[[headers]Append[Fold["_Text C Program", 
				Fold["_Consts C Program", 
					Fold["_Defs C Program", "", [program]Functions >>], 
					constants
				], [program]Functions >>]]
		]Append["int main(int argc, char **argv)
{
	returntype ret;
	calldata *cdata;
	context * ct;
	register_builtin_types();\n\n"]
		]Append[Fold["_Set Consts C Program", "", constants]]
		]Append["
	ct = new_context();
	cdata = alloc_cdata(ct, 0);
	cdata->num_params = 0;
	cdata->resume = 0;
	ret = f_Main(cdata);
	while(ret == TAIL_RETURN)
		ret = cdata->tail_func(cdata);
	if(ret == EXCEPTION_RETURN) {
		puts(\"Exception!\");
		return -1;
	}
	return 0;
}\n\n"]

}