Mercurial > repos > rhope
view cbackend_c.rhope @ 121:1af91ceaaf49
Fixed memory leak when an output is only attached to a single null input
author | Mike Pavone <pavone@retrodev.com> |
---|---|
date | Thu, 28 Oct 2010 21:04:12 -0400 |
parents | cd25171e1bb2 |
children | 4e4ecbca0b5d |
line wrap: on
line source
Import backendutils_c.rhope Blueprint C Method Registry { Lookup Next ID } C Method Registry[:out] { builtins <- [[[[[[[[[[[[[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[String[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 Field Registry { Lookup Next ID } C Field Registry[:out] { out <- [[Build[C Field Registry()]]Lookup <<[Dictionary[]]]Next ID<<[1] } Register Field@C Field Registry[reg,field:out] { [[reg]Lookup >>]Index[field] { out <- reg }{ field ID <- [reg]Next ID>> new lookup <- [[reg]Lookup >>]Set[field, field ID] out <- [[reg]Lookup <<[new lookup]]Next ID <<[[field ID]+[1]] } } Field ID@C Field Registry[reg,field:out,notfound] { out,notfound <- [[reg]Lookup >>]Index[field] } Blueprint C Type { Name Fields Methods Init Copy Cleanup } C Type[name:out] { out <- [[[[[[Build[C Type()]]Name <<[name]]Fields <<[()]]Methods <<[()]]Init <<["NULL"]]Copy <<["NULL"]]Cleanup <<["NULL"] } Add Field@C Type[ctype,name,type:out] { out <- [ctype]Fields <<[ [[ctype]Fields >>]Append[ [[()]Append[name]]Append[type] ] ] } Add Method@C Type[ctype,name:out] { out <- [ctype]Methods <<[ [[ctype]Methods >>]Append[name] ] } Register Methods@C Type[ctype,method reg:out] { out <- Fold[Register Method[?], method reg, [ctype]Methods >>] } _Register Field C[reg,field:out] { name <- [field]Index[0] out <- [reg]Register Field[name] } Register Fields@C Type[ctype,field reg:out] { out <- Fold[_Register Field C[?], field reg, [ctype]Fields >>] } Rhope Type to C[type,p:out,array] { If[[Blueprint Of[type]]=[Type Instance()]] { 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] } child type <- Rhope Type to C[param] If[[variant] = ["Naked"]] { out <- Val[child type] array <- "[1]" }{ out <- [child type]Append[" *"] array <- "" } */ out <- "void *" array <- "" }{ typename <- "Array" } primitive <- No }{ ,regulartype <- [("Naked","Raw Pointer")]Find[=[variant,?]] { [("Int64","Int32","Int16","Int8")]Find[=[[type]Name >>,?]] { primitive <- Yes [[type]Name >>]Slice[3] {} { typename <- [["int"]Append[~]]Append["_t"] } }{ ,regulartype <- [("UInt64","UInt32","UInt16","UInt8")]Find[=[[type]Name >>,?]] { primitive <- Yes [[type]Name >>]Slice[4] {} { typename <- [["uint"]Append[~]]Append["_t"] } } } } Val[regulartype] { typename <- [type]Name >> primitive <- No } } }{ typename <- type param <- "Any Type" variant <- "boxed" primitive <- No } Val[typename] { array <- "" } If[[typename] = ["Any Type"]] { out <- "struct object *" }{ [("Naked","Raw Pointer")]Find[=[variant,?]] { If[primitive] { prefix <- "" }{ prefix <- "nt_" } }{ prefix <- "t_" } If[[variant]=["Naked"]] { postfix <- "" }{ postfix <- " *" } } If[primitive] { escaped <- Val[typename] }{ escaped <- Escape Rhope Name[typename,p] } out <- [[prefix]Append[escaped]]Append[postfix] } _Type Def C Type[text,field,p:out] { name <- [field]Index[0] ,postfix <- Rhope Type to C[[field]Index[1],p] { type <- ["\n\t"]Append[~] } out <- [[[[text]Append[type]]Append[" "]]Append[[Escape Rhope Name[name,p]]Append[postfix]]]Append[";"] } Type Def@C Type[ctype,p:out] { If[[[[ctype]Fields >>]Length] = [1]] { out <- [[[[_Type Def C Type["typedef struct {\n\tobject _SP_header;\n\t", [[ctype]Fields >>]Index[0], p]]Append["\n} t_"]]Append[Escape Rhope Name[[ctype]Name >>,p]]]Append[";"] ]Append[ [[[["typedef " ]Append[Rhope Type to C[ [[[ctype]Fields >>]Index[0]]Index[1],p ]] ]Append[" nt_"] ]Append[Escape Rhope Name[[ctype]Name >>,p]] ]Append[";"] ] }{ //HACK!!! If[[[ctype]Name >>]=["Blueprint"]] { out <- "" }{ [("Array","Boxed Array","Worker")]Find[=[[ctype]Name >>,?]] { oend <- "\nMObject(" } { oend <- "\nObject(" } out <- [Fold[_Type Def C Type[?,?,p], "OBegin", [ctype]Fields >>]]Append[ [[oend]Append[Escape Rhope Name[[ctype]Name >>,p]]]Append[")"] ] } } } _Type Init C[type name,method reg,text,method,p:out] { out <- [[text]Append[[["\n\tadd_method(bp, "]Append[ [method reg]Method ID[method] ]]Append[ [[", MethodName("]Append[Escape Rhope Name[method,p]]]Append[[","]Append[Escape Rhope Name[type name,p]]]]]]Append["));"] } _Type Init C Field[type name,field reg,text,field,p:out] { fname <- [field]Index[0] out <- [[[[text]Append[[["\n\tadd_getter(bp, "]Append[ String[[field reg]Field ID[fname]] ]]Append[ [[", MethodName("]Append[Escape Rhope Name[[fname]Append[" >>"],p]]]Append[[","]Append[Escape Rhope Name[type name,p]]]]]]Append["));"] ]Append[[["\n\tadd_setter(bp, "]Append[ String[[field reg]Field ID[fname]] ]]Append[ [[", MethodName("]Append[Escape Rhope Name[[fname]Append[" <<"],p]]]Append[[","]Append[Escape Rhope Name[type name,p]]]]]]Append["));"] } Type Init@C Type[ctype,id,method reg,field reg,p:out] { [("Array","Boxed Array", "Worker")]Find[=[[ctype]Name >>, ?]] { 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 >>,p]] } } } } size <- [["sizeof("]Append[typename]]Append[")"] } start <- [["\tbp = register_type_byid(" ]Append[id] ]Append[ [[", "]Append[size] ]Append[ [", (special_func)"]Append[ [ [[[[Escape Rhope Name[[ctype]Init >>,p] ]Append[", (special_func)"] ]Append[Escape Rhope Name[[ctype]Copy >> ,p]] ]Append[", (special_func)"] ]Append[Escape Rhope Name[[ctype]Cleanup >>,p]] ]Append[");"]]] ] out <- Val[start]//Fold[[["_Type Init C Field"]Set Input[0, [ctype]Name >>]]Set Input[1, field reg], Fold[[["_Type Init C"]Set Input[0, [ctype]Name >>]]Set Input[1, method reg], start, [ctype]Methods >>], [ctype]Fields >>] } Blueprint C Type Registry { Lookup Definitions Next ID Escape Pattern } C Type Registry[p:out] { out <- [[[[Build[C Type Registry()]]Lookup << [ [[[[[[[[[[[[[[[[[[[Dictionary[] ]Set["UInt8", "TYPE_UINT8"] //1 ]Set["UInt16", "TYPE_UINT16"] //2 ]Set["UInt32", "TYPE_UINT32"] //3 ]Set["UInt64", "TYPE_UINT64"] //4 ]Set["Int8", "TYPE_INT8"] //5 ]Set["Int16", "TYPE_INT16"] //6 ]Set["Int32", "TYPE_INT32"] //7 ]Set["Int64", "TYPE_INT64"] //8 ]Set["Boolean", "TYPE_BOOLEAN"] //9 ]Set["Float32", "TYPE_FLOAT32"] //10 ]Set["Float64", "TYPE_FLOAT64"] //11 ]Set["Real Number", "TYPE_FLOAT64"] ]Set["Blueprint", "TYPE_BLUEPRINT"] //12 ]Set["Array", "TYPE_ARRAY"] //13 ]Set["Boxed Array", "TYPE_BOXEDARRAY"]//14 ]Set["Worker", "TYPE_WORKER"] //15 ]Set["Method Missing Exception", "TYPE_METHODMISSINGEXCEPTION"] //16 ]Set["Field Missing Exception", "TYPE_FIELDMISSINGEXCEPTION"] //17 ]Set["Wrong Type Exception", "TYPE_WRONGTYPEEXCEPTION"]] //18 ]Definitions << [Dictionary[]] ]Next ID <<[0] ]Escape Pattern <<[p] } _Type Defs C[text,def,p:out] { out <- [[text]Append[[def]Type Def[p]]]Append["\n\n"] } Type Defs@C Type Registry[reg:out] { out <- Fold[_Type Defs C[?,?,[reg]Escape Pattern >>], "", [reg]Definitions >>] } _Type Inits C[reg,method reg,field reg,text,def,name:out] { out <- [[text]Append[ [def]Type Init[[reg]Type ID[name], method reg, field reg,[reg]Escape Pattern >>] ]]Append["\n\n"] } Type Inits@C Type Registry[reg,method reg,field reg:out] { out <- Fold[_Type Inits C[reg, method reg, field reg, ?], "", [reg]Definitions >>] } Register Type@C Type Registry[reg,def:out] { name <- [def]Name >> [[reg]Lookup >>]Index[name] { [[reg]Definitions >>]Index[name] { out <- reg }{ out <- [reg]Definitions <<[[[reg]Definitions >>]Set[name, def]] } }{ out <- [[[reg]Lookup <<[ [[reg]Lookup >>]Set[name, ["TYPE_FIRST_USER+"]Append[String[[reg]Next ID >>]]] ] ]Definitions <<[ [[reg]Definitions >>]Set[name, def] ] ]Next ID <<[ [[reg]Next ID >>]+[1] ] } } Type ID@C Type Registry[reg,name:out,notfound] { out <- [[reg]Lookup >>]Index[name] {} { ,notfound <- If[[name]=["Any Type"]] { out <- "0" } } } Simple Type?@C Type Registry[reg,name:yep,nope,notfound] { ,notfound <- [[reg]Definitions >>]Index[name] { yep,nope <- If[[[[~]Fields >>]Length] = [1]] } } Blueprint C Function { Name Inputs Outputs Convention Variables Statements Method Registry Field Registry Type Registry Constants Input Types Output Types Resume Index Last NumParams Escape Pattern } C Function[name,inputs,outputs,convention,p:out] { out <- C Function With Registry[name,inputs,outputs,convention, C Method Registry[], C Field Registry[], C Type Registry[p],p] } C Function With Registry[name,inputs,outputs,convention,registry,field reg,type reg,p:out] { out <- [[[[[[[[[[[[[[[Build[C Function()] ]Name <<[name] ]Inputs <<[inputs] ]Outputs <<[outputs] ]Convention <<[convention] ]Variables <<[Dictionary[]] ]Statements <<[()] ]Method Registry <<[registry] ]Field Registry <<[field reg] ]Type Registry <<[type reg] ]Constants <<[Dictionary[]] ]Input Types <<[ Fold[Append[?, "Any Type"], (), inputs] ] ]Output Types <<[ Fold[Append[?, "Any Type"], (), outputs] ] ]Resume Index <<[1] ]Last NumParams <<[-1] ]Escape Pattern <<[p] } Set Input Type@C Function[func,type,input num:out] { out <- [func]Input Types <<[ [[func]Input Types >>]Set[input num, type] ] } Set Output Type@C Function[func,type,output num:out] { out <- [func]Output Types <<[ [[func]Output Types >>]Set[output num, type] ] } Register Constant@C Function[func,name,constant:out] { out <- [func]Constants <<[ [[func]Constants >>]Set[name, constant] ] } 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," / "] } DoLShift@C Function[func,source1,source2,dest:out] { out <- [func]Add Operator Statement[source1,source2,dest," << "] } DoRShift@C Function[func,source1,source2,dest:out] { out <- [func]Add Operator Statement[source1,source2,dest," >> "] } CompLess@C Function[func,source1,source2,dest:out] { out <- [func]Add Operator Statement[source1,source2,dest," < "] } CompGreater@C Function[func,source1,source2,dest:out] { out <- [func]Add Operator Statement[source1,source2,dest," > "] } CompEqual@C Function[func,source1,source2,dest:out] { out <- [func]Add Operator Statement[source1,source2,dest," == "] } CompLessEqual@C Function[func,source1,source2,dest:out] { out <- [func]Add Operator Statement[source1,source2,dest," <= "] } CompGreaterEqual@C Function[func,source1,source2,dest:out] { out <- [func]Add Operator Statement[source1,source2,dest," >= "] } CompNotEqual@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]] } 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((object *)"]]Append[source]]Append[")"]] } AddRef No Dest@C Function[func,psource:out] { source <- [psource]Make Op[func] out <- [func]Add Statement[[["add_ref((object *)"]Append[source]]Append[")"]] } Release@C Function[func,psource:out] { source <- [psource]Make Op[func] out <- [func]Add Statement[[["release_ref((object *)"]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,doaddref:out] { var <- ["_const_"]Append[Escape Rhope Name[const,[func]Escape Pattern >>]] If[doaddref] { out <- [["add_ref("]Append[var]]Append[")"] }{ out <- Val[var] } } Field Result@C Function[func,var,field:out] { as op <- [var]Make Op[func] [(String(),String Cat(),String Slice())]Find[=[Blueprint Of[var],?]] { [[func]Inputs >>]Find[=[var,?]] { type <- [[func]Input Types >>]Index[~] }{ type <- [[func]Variables >>]Index[var] { Print["op refers to a var"] } { [[func]Outputs >>]Find[=[var,?]] { type <- [[func]Output Types >>]Index[~] }{ //Does it make sense for us to do this? type <- Type Instance["Any Type"] } } } }{ type <- Type Instance["Any Type"] } If[[[func]Convention >>] = ["rhope"]] { If[[type] = ["Any Type"]] { rvar <- Val[as op] }{ rvar <- [[[["(("]Append[ Rhope Type to C[type,[func]Escape Pattern >>] ]]Append[")("]]Append[as op]]Append["))"] } }{ rvar <- Val[as op] } [[func]Type Registry >>]Simple Type?[[type]Name >>] { access <- "->" } { access <- "->payload." } { //TODO: Generate some kind of error/exception in this case access <- "->" } out <- [[rvar]Append[access]]Append[Escape Rhope Name[field,[func]Escape Pattern >>]] } Read Field@C Function[func,var,field:out,result op] { out <- func result op <- Field Ref[var,field] } Write Field@C Function[func,var,field:out,result op] { out <- func result op <- Field Ref[var,field] } Set Field Null@C Function[func,var,field:out] { out <- [func]Add Statement[ [[func]Field Result[var,field]]Append[" = NULL"] ] } Copy@C Function[func,pdest:out] { dest <- [pdest]Make Op[func] out <- [func]Add Statement[ [dest]Append[[[" = copy_object("]Append[dest]]Append[")"]] ] } Box@C Function[func,psource,pdest,type:out] { dest <- [pdest]Make Op[func] source <- [psource]Make Op[func] out <- [func]Add Statement[ [[[[[dest ]Append[" = naked_to_boxed("] ]Append[ [[func]Type Registry >>]Type ID[[type]Name >>] ] ]Append[", &"] ]Append[source] ]Append[")"] ] } Unbox@C Function[func,psource,pdest:out] { dest <- [pdest]Make Op[func] source <- [psource]Make Op[func] out <- [func]Add Statement[ [[[["boxed_to_naked(" ]Append[source] ]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[" = (void*)("]]Append[source]]Append[" + 1)"] ] } 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 Raw Line[ [[[["SetParam(" ]Append[String[inputnum]] ]Append[", "] ]Append[val] ]Append[")"] ] } _Val Function Arg C[func,val,inputnum,worker:out] { out <- [func]Add Raw Line[ [[[[[["VCSetParam(" ]Append[worker] ]Append[", "] ]Append[String[inputnum]] ]Append[", "] ]Append[val] ]Append[")"] ] } Method Call@C Function[func,method,args:out] { out <- [func]Call[method,args] } Val Call@C Function[func,to call,args:out] { worker <- Make Op[Strip Addref[to call], func] rargs <- Map[args, Make Op[?, func]] If[[[func]Last NumParams >>] = [-1]] { prepped <- [[func]Add Raw Line[ [[[["VCPrepCall(" ]Append[worker] ]Append[", "] ]Append[String[[rargs]Length]] ]Append[")"] ] ]Last NumParams <<[[rargs]Length] }{ prepped <- [[func]Add Raw Line[ [[[[[["VCRePrepCall(" ]Append[worker] ]Append[", "] ]Append[String[[rargs]Length]] ]Append[", "] ]Append[String[[func]Last NumParams >>]] ]Append[")"] ] ]Last NumParams <<[[rargs]Length] } out <- [[[[Fold[_Val Function Arg C[?, ?, ?, worker], prepped, rargs] ]Add Raw Line[ [[[[[[[["ValCall(" ]Append[worker] ]Append[", "] ]Append[String[[rargs]Length]] ]Append[", "] ]Append[String[[func]Resume Index >>]] ]Append[", "] ]Append[Escape Rhope Name[[func]Name >>,[func]Escape Pattern >>]] ]Append[")"]] ]Add Raw Line["DISPATCH"] ]Add Raw Line[ [[[["ValCallPostlude(" ]Append[String[[func]Resume Index >>]] ]Append[", "] ]Append[Escape Rhope Name[[func]Name >>,[func]Escape Pattern >>]] ]Append[")"]] ]Resume Index <<[ [[func]Resume Index >>]+[1] ] } Call@C Function[func,name,args:out] { If[[name]=["Call@Worker"]] { //TODO: Handle case when user explicitly calls the fully qualified version, but the type of the first arg isn't Worker out <- [func]Val Call[[args]Index[0], Tail[args,1]] }{ If[[name]=["Call"]] { to call <- [args]Index[0] last numparams <- [func]Last NumParams >> out <- [[[[[[func]Add Raw Line[[["if (get_blueprint("]Append[Make Op[Strip Addref[to call], func]]]Append[")->type_id == TYPE_WORKER) {"]] ]Val Call[to call, Tail[args,1]] ]Add Raw Line["} else {"] ]Last NumParams <<[last numparams] ]Func Base["Call",args, "Call"] ]Add Raw Line["}"] }{ out <- [func]Func Base[Escape Rhope Name[name,[func]Escape Pattern >>],args, "Call"] } } } Func Base@C Function[func,tocall,args,type:out] { Print[ [[func]Name >>]Append[ [": Func Base("]Append[tocall] ] ] rargs <- Map[args, Make Op[?, func]] If[[[rargs]Length] > [[func]Last NumParams >>]] { If[[[func]Last NumParams >>] = [-1]] { freed <- Val[func] }{ freed <- [func]Add Raw Line["FreeCall"] } prepped <- [[freed]Add Raw Line[ [["PrepCall("]Append[String[[rargs]Length]]]Append[")"] ] ]Last NumParams <<[[rargs]Length] }{ prepped <- Val[func] } out <- [[Fold[_Function Arg C[?], prepped, rargs] ]Add Raw Line[ [[[[[[[[[type]Append["("] ]Append[tocall] ]Append[", "] ]Append[String[[rargs]Length]] ]Append[", "] ]Append[String[[func]Resume Index >>]] ]Append[", "] ]Append[Escape Rhope Name[[func]Name >>,[func]Escape Pattern >>]] ]Append[")"]] ]Resume Index <<[ [[func]Resume Index >>]+[1] ] } Call Foreign@C Function[func,name,language,args,store result:out] { rargs <- Map[args, Make Op[?, func]] //Assume language = "C" for now base <- [[[name]Append["("]]Append[ Join[rargs, ", "] ]]Append[")"] ,do store <- [(String(), String Slice(), String Cat())]Find[=[Blueprint Of[store result], ?]] { ,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] } Get Field Call@C Function[func,field,source:out] { out <- [func]Func Base[Escape Rhope Name[[field]Append[" >>"],[func]Escape Pattern >>], [()]Append[source], "Call"] } Set Field Call@C Function[func,field,object,value:out] { out <- [func]Func Base[Escape Rhope Name[[field]Append[" <<"],[func]Escape Pattern >>], [[()]Append[object]]Append[value], "Call"] } 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,[func]Escape Pattern >>],args, "TCall"] } Resolve@C Function[func,op:out] { If[[[func]Convention >>] = ["rhope"]] { [[func]Inputs >>]Find[=[op,?]] { out <- [["my_cdata->params["]Append[String[~]]]Append[" ]"] }{ out <- [[["lv_"]Append[Escape Rhope Name[[func]Name >>,[func]Escape Pattern >>]]]Append["->"]]Append[Escape Rhope Name[op,[func]Escape Pattern >>]] } }{ out <- Escape Rhope Name[op,[func]Escape Pattern >>] } } Resolve Output@C Function[func,name:out] { If[[[func]Convention >>] = ["rhope"]] { out <- [[["lv_"]Append[Escape Rhope Name[[func]Name >>,[func]Escape Pattern >>]]]Append["->"]]Append[Escape Rhope Name[name,[func]Escape Pattern >>]] }{ out <- Escape Rhope Name[name,[func]Escape Pattern >>] } } 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["}"] ]Resume Index <<[[stream]Resume Index >>] } Discard Outputs@C Function[func,first to discard:out] { out <- [[[[[func ]Add Raw Line[[["for(idx = "]Append[String[first to discard]]]Append["; idx < cdata->num_params; ++idx)"]] ]Add Raw Line["{"] ]Add Raw Line[" if (cdata->params[idx])"] ]Add Raw Line[" release_ref(cdata->params[idx]);"] ]Add Raw Line["}"] } Result Reference@C Function[func,output:out] { out <- [["cdata->params["]Append[String[output]]]Append["]"] } Checked Result Reference@C Function[func,output:out] { out <- [[[["("]Append[String[output]]]Append[" < cdata->num_params ? cdata->params["]]Append[String[output]]]Append["] : NULL)"] } 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[check] ]Append[" ? "] ]Append[l] ]Append[" : "] ]Append[r] ]Append[")"] } _Set Outputs C[string,inputname,inputnum,func:out] { out <- [string]Append[[[ [ ["\tRet("]Append[String[inputnum]] ]Append[ [[", lv_"]Append[Escape Rhope Name[[func]Name >>,[func]Escape Pattern >>]]]Append["->"]]]Append[Escape Rhope Name[inputname,[func]Escape Pattern >>]]]Append[")\n"]] } Set Outputs@C Function[func:out] { If[[[func]Convention >>] = ["rhope"]] { out <- [[[Fold[_Set Outputs C[?, ?, ?, func], "", [func]Outputs >>]]Append["\tNumRet("]]Append[String[[[func]Outputs >>]Length]]]Append[")\n"] }{ [[func]Outputs >>]Index[0] { out <- [["\treturn "]Append[Escape Rhope Name[~,[func]Escape Pattern >>]]]Append[";\n"] }{ out <- "" } } } _Output Defs C[string,varname,index,func:out] { out <- [[[string]Append[ ["\t"]Append[Rhope Type to C[[[func]Output Types >>]Index[index],[func]Escape Pattern >>]] ]]Append[[" "]Append[Escape Rhope Name[varname,[func]Escape Pattern >>]]]]Append[";\n"] } _Var Defs C[string,type,varname,p:out] { out <- [[[string]Append[ ["\t"]Append[Rhope Type to C[type,p]] ]]Append[[" "]Append[Escape Rhope Name[varname,p]]]]Append[";\n"] } 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[?, ?, ?, func], Fold[_Var Defs C[?,?,?,[func]Escape Pattern >>],"typedef struct {\n", [func]Variables >>], [func]Outputs >>]]Append["} lt_"]]Append[Escape Rhope Name[[func]Name >>,[func]Escape Pattern >>]]]Append[";\n"] }{ localtype <- "" } If[ [[func]Convention >>] = ["rhope"] ] { /* parts <- [[func]Name >>]Split["@"] [parts]Index[1] { proto <- [[[["MethodDef(" ]Append[Escape Rhope Name[[parts]Index[0],[func]Escape Pattern >>]] ]Append[", "] ]Append[Escape Rhope Name[~,[func]Escape Pattern >>]] ]Append[")\n"] }{ proto <- [["FuncDef("]Append[Escape Rhope Name[[func]Name >>,[func]Escape Pattern >>]]]Append[")\n"] } */ out <- Val[localtype] }{ out <- [[func]Naked Proto]Append[";\n"] } } } _Proto Input[list,input,index,types,p:out] { out <- [list]Append[ [[Rhope Type to C[[types]Index[index],p]]Append[" "]]Append[Escape Rhope Name[input,p]] ] } Naked Proto@C Function[func:out] { [[func]Output Types >>]Index[0] { outtype <- [Rhope Type to C[~,[func]Escape Pattern >>]]Append[" "] }{ outtype <- "void " } out <- [[[[outtype ]Append[ Escape Rhope Name[[func]Name >>,[func]Escape Pattern >>]] ]Append["("] ]Append[ [Fold[_Proto Input[?, ?, ?, [func]Input Types >>,[func]Escape Pattern >>], (), [func]Inputs >>]]Join[", "] ] ]Append[")"] } Type Check@C Function[func,text,type,input num:out] { If[[type] = ["Any Type"]] { out <- text }{ out <- [text]Append[ [["\tParam("]Append[input num]]Append[ [[", "]Append[ [[func]Type Registry >>]Type ID[type] ]]Append[")"] ] ] } } Check Param Type C[text,type,input num,func:out] { [(String(),String Cat(),String Slice())]Find[=[Blueprint Of[type],?]] { typename <- type }{ typename <- [type]Name >> } If[[typename] = ["Any Type"]] { out <- text }{ out <- [text]Append[[[["\tParam("]Append[String[input num]]]Append[ [","]Append[ [[func]Type Registry >>]Type ID[typename] ] ]]Append[")\n"]] } } Text@C Function[func:out] { Print[["Text@C Function: "]Append[[func]Name >>]] If[ [[func]Convention >>] = ["rhope"] ] { before <- [[func]Name >>]Partition["@"] {} {} { type <- "MethodImpl" cname <- [[[[Escape Rhope Name[before,[func]Escape Pattern >>] ]Append[", "] ]Append[Escape Rhope Name[~,[func]Escape Pattern >>]] ]Append[", "] ]Append[ [[func]Type Registry >>]Type ID[~] ] }{ type <- "Func" cname <- Val[fname] } fname <- Escape Rhope Name[[func]Name >>,[func]Escape Pattern >>] param check <- Fold[Check Param Type C[?, ?, ?, func], "", [func]Input Types >>] If[ [ [[[func]Variables >>]Length]+[[[func]Outputs >>]Length] ] = [0] ] { out <- [[[[[[[[ [type]Append["NoLocals("] ]Append[cname] ]Append[",\n\tNumParams "] ]Append[ String[[[func]Inputs >>]Length] ] ]Append[")\n\n"] ]Append[param check] ]Append[ [[func]Statements >>]Join[""] ] ]Append["EndFuncNoLocals\n"] ]Append["DISPATCH"] }{ If[[[func]Last NumParams >>] = [-1]] { freecall <- "" }{ freecall <- "\n\tFreeCall\n" } out <- [[[[[[[[[[ [type]Append["("] ]Append[cname] ]Append[",\n\tNumParams "] ]Append[ String[[[func]Inputs >>]Length] ] ]Append[")\n\n"] ]Append[param check] ]Append[ [[func]Statements >>]Join[""] ] ]Append[freecall] ]Append[[func]Set Outputs] ]Append[[["EndFunc("]Append[fname]]Append[")\n"]] ]Append["DISPATCH"] } }{ out <- [[[ Fold[_Output Defs C[?, ?, ?, func], Fold[_Var Defs C[?], [[func]Naked Proto]Append["\n{"], [func]Variables >>], [func]Outputs >>] ]Append[[[func]Statements >>]Join[""]] ]Append[[func]Set Outputs] ]Append["}"] } } Blueprint C Program { Functions Method Registry Field Registry Type Registry Libraries Escape Pattern } C Program[:out] { p <- Pattern[("_", "@", " ", ":", "?", "+", "-", "*", "/", "<", ">", "(", ")", "!", "=", "'", "\"", "\t", ",", ".", "\n", "{", "}", "[", "]", "#", "\\", "\r", ";", "&", "|", "%", "^", "`", "~")] out <- [[[[[[Build[C Program()]]Functions <<[Dictionary[]]]Method Registry <<[C Method Registry[]]]Type Registry <<[C Type Registry[p]]]Field Registry <<[C Field Registry[]]]Libraries <<[Dictionary[]]]Escape Pattern <<[p] } 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] ] ]Method Registry <<[ [def]Register Methods[[program]Method Registry >>] ] ]Field Registry <<[ [def]Register Fields[[program]Field Registry >>] ] } Create Type@C Program[program,name:out] { out <- C Type[name] } Create Function@C Program[program,name,inputs,outputs,convention:out] { out <- C Function With Registry[name,inputs,outputs,convention, [program]Method Registry >>, [program]Field Registry >>, [program]Type Registry >>, [program]Escape Pattern >>] } 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,type reg:out] { out <- [text]Append[[[ [func]Type Registry <<[type reg] ]Text]Append["\n\n"]] } Combine Consts[consts,func:out] { out <- Combine[[func]Constants >>, consts] } _Consts C Program[text,value,name,p:out] { out <- [text]Append[ [["object * _const_"]Append[Escape Rhope Name[name,p]]]Append[";\n"] ] } _Consts C Release[text,value,name,p:out] { out <- [text]Append[ [["\trelease_ref(_const_"]Append[Escape Rhope Name[name,p]]]Append[");\n"] ] } _List Literal El[text,val,index,type reg:out] { out <- [[[[text ]Append[", "] ]Append[index] ]Append[", "] ]Append[Const Construct C[val, type reg]] } Const Construct C[value,type reg:out] { valtype <- Blueprint Of[value] [(Int8(),UInt8(),Int16(),UInt16(),Int32(),UInt32(),Int64(),UInt64())]Find[=[valtype,?]] { size <- [("8","16","32","64")]Index[[~]/[2]] If[[~]Mod[2]] { s <- "UI" } { s <- "I" } out <- [[[[[["make_" ]Append[s] ]Append["nt"] ]Append[size] ]Append["("] ]Append[String[value]] ]Append[")"] }{ If[[valtype] = [Type Instance()]] { //TODO: Support parametric types typeid <- [type reg]Type ID[[value]Name >>] out <- [["make_Blueprint("]Append[typeid]]Append[")"] }{ If[[valtype] = [Boolean()]] { If[value] { out <- "make_Bool(1)" }{ out <- "make_Bool(0)" } }{ [(String(),String Slice(),String Cat())]Find[=[valtype,?]] { out <- [["make_String(\""]Append[ [[[[value]Replace["\\", "\\\\"]]Replace["\n", "\\n"]]Replace["\"", "\\\""]]Replace["\r", "\\r"] ]]Append["\")"] }{ If[[valtype]=[Worker Literal()]] { //TODO: Figure out how to fully support these in nested cases //or workaround the problem higher up in the food chain [[value]Args >>]Last { size <- String[[~]+[1]] } { size <- "0" } out <- [[[[[["make_Worker(FUNC_" ]Append[Escape Rhope Name[[value]Name >>,[type reg]Escape Pattern >>]] ]Append[", "] ]Append[size] ]Append[", "] ]Append[String[Fold[+[1,?], 0, [value]Args >>]]] ]Append[")"] }{ [(List(), List Leaf())]Find[=[?,valtype]] { out <- [Fold[_List Literal El[?, ?, ?, type reg], ["make_List("]Append[String[[value]Length]], value]]Append[")"] }{ out <- "UnhandledLiteralType" } } } } } } } _Set Worker Params C[text,param,num,type reg,name:out] { out <- [text]Append[ [[[[[["\t((object **)(((t_Worker *)_const_" ]Append[name] ]Append[")+1))["] ]Append[String[num]] ]Append["] = "] ]Append[Const Construct C[param, type reg]] ]Append[";\n"] ] } _Set Consts C Program[text,value,name,type reg:out] { valtype <- Blueprint Of[value] [(String(),String Cat(),String Slice(),Worker Literal(),List(),List Leaf())]Find[=[valtype,?]] { Print[[name]Append[" is not of an early constant type"]] out <- text }{ Const Construct C[value,type reg] { out <- [text]Append[ [[[["\t_const_"]Append[Escape Rhope Name[name,[type reg]Escape Pattern >>]]]Append[" = "]]Append[~]]Append[";\n"] ] } } } _Set List Els[text,el,index,type reg:out] { out <- [[text]Append[ [["\tinout[1] = " ]Append[Const Construct C[index,type reg]] ]Append[ [[";\n\tinout[2] = " ]Append[Const Construct C[el, type reg]] ]Append[";\n"] ]]]Append["\trhope(FUNC_Set, inout, 3, 3);\n"] } _Set Late Consts C[text,value,name,type reg:out] { valtype <- Blueprint Of[value] [(String(),String Cat(),String Slice(),Worker Literal(),List(),List Leaf())]Find[=[valtype,?]] { If[[~]>[3]] { out <- [Fold[_Set List Els[?, ?, ?, type reg], [text]Append["\trhope(FUNC_List, inout, 0, 1);\n"], value] ]Append[[["\t_const_"]Append[Escape Rhope Name[name,[type reg]Escape Pattern >>]]]Append[" = inout[0];\n"]] }{ Const Construct C[value,type reg] { init <- [text]Append[ [[[["\t_const_"]Append[Escape Rhope Name[name,[type reg]Escape Pattern >>]]]Append[" = "]]Append[~]]Append[";\n"] ] } If[[valtype]=[Worker Literal()]] { out <- Fold[_Set Worker Params C[?, ?, ?, type reg, Escape Rhope Name[name,[type reg]Escape Pattern >>]], init, [value]Args >>] }{ out <- Val[init] } } }{ out <- text } } _Dispatch Switch Sub[text, num, name:out] { out <- [[[[[text ]Append["\tResumeEntry("] ]Append[String[num]] ]Append[","] ]Append[name] ]Append[")\\\n"] } _Dispatch Switch[text,func,raw name:out] { If[[[func]Convention >>] = ["rhope"]] { name <- Escape Rhope Name[raw name,[func]Escape Pattern >>] out <- [[text]Append[ [["\tDispatchEntry("]Append[name]]Append[")\\\n"] ] ]Append[Fold[_Dispatch Switch Sub[?, ?, name], "", Range[1, [func]Resume Index >>]]] }{ out <- text } } _Dispatch Switch Methods[p,text,id,raw name:out] { name <- Escape Rhope Name[raw name,p] out <- [text]Append[ [["\tDispatchEntry("]Append[name]]Append[")\\\n"] ] } _Dispatch Enum Sub[text, num, name:out] { out <- [[[[[text ]Append["\tRES_"] ]Append[String[num]] ]Append["_"] ]Append[name] ]Append[",\n"] } _Dispatch Enum[text,func,raw name:out] { If[[[func]Convention >>] = ["rhope"]] { name <- Escape Rhope Name[raw name,[func]Escape Pattern >>] out <- [[text]Append[ [["\tFUNC_"]Append[name]]Append[",\n"] ] ]Append[Fold[_Dispatch Enum Sub[?, ?, name], "", Range[1, [func]Resume Index >>]]] }{ out <- text } } _Dispatch Enum Methods[p,text,types,name:out] { out <- [text]Append[ [["\tFUNC_"]Append[Escape Rhope Name[name,p]]]Append[",\n"] ] } Dispatch@C Program[program,all methods:out] { out <- [[[[["typedef enum {\n" ]Append[Fold[_Dispatch Enum[?], [Fold[_Dispatch Enum Methods[[program]Escape Pattern >>,?], "", all methods]]Append["\tFUNC_Build,\n\tFUNC_BlueprintSP_Of,\n\tFUNC_ID,\n\tFUNC_BlueprintSP_FromSP_ID,\n"], [program]Functions >>]] ]Append["\tEND\n} funcids;\n\n"] ]Append["#define DispatchEntries \\\n"] ]Append[Fold[_Dispatch Switch[?], [Fold[_Dispatch Switch Methods[[program]Escape Pattern >>,?], "", all methods]]Append["\tDispatchEntry(Build)\\\n\tDispatchEntry(BlueprintSP_Of)\\\n\tDispatchEntry(ID)\\\n\tDispatchEntry(BlueprintSP_FromSP_ID)\\\n"], [program]Functions >>]] ]Append["\tEndEntry\n\n"] } Not Native[func:out] { If[[[func]Convention >>] = ["rhope"]] { out <- No } { out <- Yes } } Native[func:out] { out <- [[func]Convention >>] = ["rhope"] } Local Pointers[text,func:out] { If[ [ [[[func]Variables >>]Length]+[[[func]Outputs >>]Length] ] = [0] ] { out <- text }{ out <- [text]Append[[["\tFuncDef("]Append[Escape Rhope Name[[func]Name >>,[func]Escape Pattern >>]]]Append[")\n"]] } } _Method to Types[dict,name,type:out] { typelist <- [dict]Index[name] {} { typelist <- () } out <- [dict]Set[name, [typelist]Append[[type]Name >>]] } _Field to Types[dict,field,type:out] { name <- [field]Index[0] out <- _Method to Types[_Method to Types[dict, [name]Append[" >>"], type], [name]Append[" <<"], type] } Method to Types[dict,type:out] { out <- Fold[_Method to Types[?, ?, type], dict, [type]Methods >>] } Field to Types[dict,type:out] { out <- Fold[_Field to Types[?, ?, type], dict, [type]Fields >>] } _Method Dispatch[text, type, method, reg: out] { out <- [[[[[[[text]Append["\tMethodDispatch("]]Append[ [reg]Type ID[type] ]]Append[","]]Append[Escape Rhope Name[method,[reg]Escape Pattern >>]]]Append[","]]Append[Escape Rhope Name[type,[reg]Escape Pattern >>]]]Append[")\n"] } Method Dispatch[text, types, method, reg: out] { out <- [[[Fold[_Method Dispatch[?, ?, method, reg], [[[text]Append["Method("]]Append[ Escape Rhope Name[method,[reg]Escape Pattern >>] ]]Append[")\n"], types] ]Append["EndMethod("] ]Append[Escape Rhope Name[method,[reg]Escape Pattern >>]] ]Append[")\n\n"] } Text@C Program[program:out] { p <- [program]Escape Pattern >> type defs <- [[program]Type Registry >>]Definitions >> constants <- Fold[Combine Consts[?], Dictionary[], [program]Functions >>] all methods <- Fold[Field to Types[?], Fold[Method to Types[?], Dictionary[], type defs], type defs] headers <- "#include <stdio.h> #include <stdlib.h> #include \"builtin.h\" #include \"object.h\" #include \"context.h\" #include \"func.h\" #include \"integer.h\" #include \"blueprint.h\" #include \"array.h\" #include \"worker.h\" #include \"bool.h\" #include <sys/time.h>\n\n" out <- [[[[[[[[[[[[[[[[[headers ]Append[[program]Dispatch[all methods]] ]Append[[[program]Type Registry >>]Type Defs] ]Append[Fold[_Consts C Program[?,?,?,p], Fold[_Defs C Program[?], "", [program]Functions >>], constants]] ]Append[Fold[_Text C Program[?, ?, [program]Type Registry >>], "", Filter[[program]Functions >>, Not Native[?]]]] ]Append["\n #ifdef ENABLE_PROFILING uint64_t profile_counts[END]; uint64_t profile_nestedcounts[END]; uint64_t profile_totals[END]; uint64_t profile_selftotals[END]; uint64_t profile_activationlevel[END]; #endif int32_t rhope(uint32_t func, object ** params, uint16_t numparams, uint16_t callspace) { #ifdef ENABLE_PROFILING struct timeval time; #endif uint16_t resume,idx, vcparam_offset, last_vcparam; context * ct; calldata * cdata, *temp_cdata, *my_cdata; DispatchVar FuncDef(Build) FuncDef(BlueprintSP_Of) FuncDef(ID) FuncDef(BlueprintSP_FromSP_ID)\n"] ]Append[Fold[Local Pointers[?], "", [program]Functions >>]] ]Append[" ct = new_context(); cdata = alloc_cdata(ct, NULL, callspace); cdata->num_params = numparams; for(idx = 0; idx < numparams; ++idx) cdata->params[idx] = params[idx]; cdata->func = END; DISPATCH\n"] ]Append[Fold[Method Dispatch[?, ?, ?, [program]Type Registry >>], "", all methods]] ]Append[" Func(Build, NumParams 1) Param(0, TYPE_BLUEPRINT) lv_Build->bp = ((t_Blueprint *)(cdata->params[0]))->bp; release_ref(cdata->params[0]); Ret(0, new_object_bp(lv_Build->bp)) EndFunc(Build) DISPATCH Func(BlueprintSP_Of, NumParams 1) lv_BlueprintSP_Of->bp = get_blueprint(cdata->params[0]); release_ref(cdata->params[0]); Ret(0, new_object(TYPE_BLUEPRINT)) ((t_Blueprint *)cdata->params[0])->bp = lv_BlueprintSP_Of->bp; EndFunc(BlueprintSP_Of) DISPATCH Func(ID, NumParams 1) Param(0, TYPE_BLUEPRINT) lv_ID->id = new_object(TYPE_UINT32); ((t_UInt32 *)lv_ID->id)->Num = ((t_Blueprint *)cdata->params[0])->bp->type_id; release_ref(cdata->params[0]); Ret(0, lv_ID->id) EndFunc(ID) DISPATCH Func(BlueprintSP_FromSP_ID, NumParams 1) Param(0, TYPE_UINT32) lv_BlueprintSP_FromSP_ID->type = ((t_UInt32 *)cdata->params[0])->Num; if (lv_BlueprintSP_FromSP_ID->type >= max_registered_type || !registered_types[lv_BlueprintSP_FromSP_ID->type]) { Ret(1, cdata->params[0]) Ret(0, NULL) } else { release_ref(cdata->params[0]); Ret(0, new_object(TYPE_BLUEPRINT)) ((t_Blueprint *)cdata->params[0])->bp = registered_types[lv_BlueprintSP_FromSP_ID->type]; Ret(1, NULL) } EndFunc(BlueprintSP_FromSP_ID) DISPATCH\n"] ]Append[Fold[_Text C Program[?, ?, [program]Type Registry >>], "", Filter[[program]Functions >>, Native[?]]]] ]Append[" DO_END: for(idx = 0; idx < cdata->num_params; ++idx) params[idx] = cdata->params[idx]; free_context(ct); return cdata->num_params; _exception: puts(\"Exception! Trace follows:\"); while(cdata && cdata->func != END) { printf(\"%d\\n\", cdata->func); cdata = cdata->lastframe; } return -1; } #include \"builtin.c\" #include \"array.c\" #include \"worker.c\" int main(int argc, char **argv) { blueprint * bp; int numret; int idx; object * inout[3]; register_builtin_types();\n\n"] ]Append[ [[program]Type Registry >>]Type Inits[[program]Method Registry >>, [program]Field Registry >>] ] ]Append[Fold[_Set Consts C Program[?, ?, ?, [program]Type Registry >>], "", constants]] ]Append[Fold[_Set Late Consts C[?, ?, ?, [program]Type Registry >>], "", constants]] ]Append[" rhope(FUNC_List, inout, 0, 1); for (idx = 0; idx < argc; ++idx) { inout[1] = make_String(argv[idx]); rhope(FUNC_Append, inout, 2, 2); } numret = rhope(FUNC_Main, inout, 1, 1);"] ]Append[Fold[_Consts C Release[?, ?, ?, p], "", constants]] ]Append[ " print_mem_info(manager); print_live_object_types(manager); #ifdef ENABLE_PROFILING for (idx = 0; idx < END; ++idx) { if(profile_counts[idx]) printf(\"Func: %d\tCount: %llu\tTime: %llu\tAvg: %f\tSelf: %llu\tAvg: %f\tNested Count: %llu\\n\", idx, profile_counts[idx], profile_totals[idx], ((double)profile_totals[idx])/((double)profile_counts[idx]), profile_selftotals[idx], ((double)profile_selftotals[idx])/((double)profile_counts[idx]), profile_nestedcounts[idx]); } #endif if (!numret) return 0; if (numret < 0) return numret; if (get_blueprint(inout[0])->type_id == TYPE_INT32) return ((t_Int32 *)inout[0])->Num; rhope(FUNC_If, inout, 1, 2); if (inout[0]) return 0; return 1; }\n\n"] }