> bodies: CodeList Ź MimP5U.NewCodeList[]; Body1: PROC [bti: Symbols.BTIndex] RETURNS [stop: BOOL Ź FALSE] = { <> WITH body: bb[bti] SELECT FROM Callable => IF ~body.inline AND body.hints.pad = 0 THEN [] Ź MakeProcDesc[bti]; ENDCASE; }; Body2: PROC [bti: Symbols.BTIndex] RETURNS [stop: BOOL Ź FALSE] = { <> WITH body: bb[bti] SELECT FROM Callable => IF ~body.inline AND body.hints.pad = 0 THEN MimP5U.MoreCode[bodies, ProcBody[LOOPHOLE[bti]]]; ENDCASE; }; (MimData.table).AddNotify[DriverNotify]; maxBti Ź Symbols.RootBti; procDescRoot Ź NIL; linkToVarSeq Ź NIL; inInline Ź FALSE; visibleContext Ź z.NEW[MimP5.VisibalContextArray Ź ALL[NIL]]; substState Ź z.NEW[SubstState Ź []]; { modNode Ź z.NEW[module NodeRep Ź [details: module[vars: VarsForCtx[MimData.mainCtx], procs: NIL]]]; <> maxGlobalVarId Ź 0; FOR each: VarList Ź modNode.vars, each.rest WHILE each # NIL DO id: INT Ź each.first.id; IF id > maxGlobalVarId THEN maxGlobalVarId Ź id; ENDLOOP; modVarsTail Ź modNode.vars; IF modVarsTail # NIL THEN WHILE modVarsTail.rest # NIL DO modVarsTail Ź modVarsTail.rest; ENDLOOP; bodyInRecord Ź bodyOutRecord Ź RecordSENull; MimP5U.CgenUtilInit[MimData.table]; inlineFileLoc Ź SourceMap.nullLoc; xtracting Ź FALSE; caseCV Ź NIL; catchoutrecord Ź RecordSENull; [] Ź SymbolOps.EnumerateBodies[SymbolOps.own, Symbols.RootBti, Body1]; IF MimData.nSigCodes # 0 THEN signalsVar Ź MakeGlobal[MimData.nSigCodes*bitsPerWord].v; [] Ź SymbolOps.EnumerateBodies[SymbolOps.own, Symbols.RootBti, Body2]; modNode.procs Ź bodies.head; }; z.FREE[@visibleContext]; z.FREE[@substState]; RETURN [modNode] }; NeedsTemp: PROC [node: Node] RETURNS [BOOL] = { <> n: Node Ź node; WHILE n # NIL DO list: NodeList Ź NIL; WITH n SELECT FROM v: REF NodeRep.var => { IF v.flags[constant] THEN EXIT; WITH v.location SELECT FROM local: REF LocationRep.localVar => RETURN [FALSE]; dummy: REF LocationRep.dummy => RETURN [FALSE]; field: REF LocationRep.field => {n Ź field.base; LOOP}; indexed: REF LocationRep.indexed => IF NeedsTemp[indexed.base] THEN RETURN [TRUE] ELSE {n Ź indexed.index; LOOP}; comp: REF LocationRep.composite => list Ź comp.parts; ENDCASE; RETURN [TRUE]; }; c: REF NodeRep.const => EXIT; block: REF NodeRep.block => list Ź block.nodes; decl: REF NodeRep.decl => {n Ź decl.init; LOOP}; assign: REF NodeRep.assign => IF NeedsTemp[assign.lhs] THEN RETURN [TRUE] ELSE {n Ź assign.rhs; LOOP}; cond: REF NodeRep.cond => { FOR each: CaseList Ź cond.cases, each.rest WHILE each # NIL DO IF ListNeedsTemp[each.tests] THEN RETURN [TRUE]; IF NeedsTemp[each.body] THEN RETURN [TRUE]; ENDLOOP; RETURN [FALSE]; }; label: REF NodeRep.label => {n Ź label.label.node; LOOP}; apply: REF NodeRep.apply => { WITH apply.proc SELECT FROM oper: REF NodeRep.oper => SELECT oper.oper.kind FROM arith, boolean, convert, check, compare, mesa, cedar => { <> IF apply.handler # NIL THEN RETURN [TRUE]; list Ź apply.args; }; ENDCASE => RETURN [TRUE]; ENDCASE => RETURN [TRUE]; }; source: REF NodeRep.source => list Ź source.nodes; ENDCASE => RETURN [TRUE]; WHILE list # NIL DO IF NeedsTemp[list.first] THEN RETURN [TRUE]; list Ź list.rest; IF list = NIL THEN RETURN [FALSE]; ENDLOOP; EXIT; ENDLOOP; RETURN [FALSE]; }; NodesForCtx: PROC [ctx: CTXIndex] RETURNS [vl: NodeList Ź NIL] = { IF ctx # CTXNull THEN { tail: NodeList Ź NIL; sei: ISEIndex Ź MimP5U.NextVar[ctxb[ctx].seList]; UNTIL sei = ISENull DO var: Var Ź MimP5.VarForSei[sei]; this: NodeList Ź MimP5U.MakeNodeList[var]; IF tail = NIL THEN vl Ź this ELSE tail.rest Ź this; tail Ź this; sei Ź MimP5U.NextVar[SymbolOps.NextSe[SymbolOps.own, sei]]; ENDLOOP; }; }; PrintSei: PROC [st: STREAM, sei: Symbols.ISEIndex] = TRUSTED { name: Symbols.Name = SymbolOps.NameForSe[SymbolOps.own, sei]; s: ConvertUnsafe.SubString Ź SymbolOps.SubStringForName[SymbolOps.own, name]; FOR i: CARDINAL IN [s.offset..s.offset+s.length) DO IO.PutChar[st, s.base[i]]; ENDLOOP; }; RopeForSei: PROC [sei: Symbols.ISEIndex] RETURNS [ROPE] = TRUSTED { name: Symbols.Name = SymbolOps.NameForSe[SymbolOps.own, sei]; s: ConvertUnsafe.SubString Ź SymbolOps.SubStringForName[SymbolOps.own, name]; i: CARDINAL Ź s.offset; eachChar: SAFE PROC RETURNS [c: CHAR] = TRUSTED { c Ź s.base[i]; i Ź i + 1; }; RETURN [Rope.FromProc[len: s.length, p: eachChar]]; }; ProcBody: PROC [bti: Symbols.CBTIndex] RETURNS [Node] = { <> oldSubstState: SubstState Ź substState; oldLocalProcList: CodeList Ź localProcCodeList; cl: CodeList Ź MimP5U.NewCodeList[]; desc: REF ProcDescEntry Ź FindProcDesc[bti]; procLabel: Label Ź desc.label; lambda: LambdaNode Ź NIL; enclosingContext: Label Ź NIL; substState Ź [cl: cl, prefixCL: NIL, postfixCL: NIL]; localProcCodeList Ź cl; mainBody Ź (bti = Symbols.RootBti); MimData.bodyIndex Ź bti; MimData.textIndex Ź SourceMap.Up[bb[bti].sourceIndex]; WITH bi: bb[bti].info SELECT FROM Internal => { bodyNode: Tree.Index Ź bi.bodyTree; kind: IntCodeDefs.LambdaKind Ź outer; curctxlvl Ź bb[bti].level; FOR pd: REF ProcDescEntry Ź desc, pd.parent WHILE pd # NIL DO <> pBti: CBTIndex = pd.bti; level: Symbols.ContextLevel Ź bb[pBti].level; visibleContext[level] Ź pd.label; ENDLOOP; IF curctxlvl >= Symbols.lL THEN { enclosingContext Ź visibleContext[curctxlvl.PRED]; IF curctxlvl > Symbols.lL THEN kind Ź inner; }; IF mainBody THEN kind Ź init; <> [bodyInRecord, bodyOutRecord] Ź SymbolOps.TransferTypes[SymbolOps.own, bb[bti].ioType]; fileLoc Ź SourceMap.Up[bb[bti].sourceIndex]; tailJumpOK Ź TRUE; SymbolOps.SetCtxLevel[tempcontext, curctxlvl]; lambda Ź z.NEW[NodeRep.lambda Ź [details: lambda[ parent: enclosingContext, kind: kind, descBody: NIL, bitsOut: MimP5U.BitsForType[bodyOutRecord], formalArgs: GetFormals[bodyInRecord], body: NIL]]]; <> <> substState.resultType Ź bodyOutRecord; IF bodyOutRecord # RecordSENull THEN { <> ctx: Symbols.CTXIndex = seb[bodyOutRecord].fieldCtx; sei: ISEIndex Ź MimP5U.NextVar[ctxb[ctx].seList]; IF MimP5U.BitsForType[bodyOutRecord] > bitsPerWord THEN { substState.exitLabel Ź MimP5U.AllocLabel[]; }; UNTIL sei = ISENull DO MimP5U.Declare[cl: cl, var: MimP5.VarForSei[sei]]; sei Ź MimP5U.NextVar[SymbolOps.NextSe[SymbolOps.own, sei]]; ENDLOOP; }; <> IF bti = Symbols.RootBti THEN { <> FOR each: REF ProcDescEntry Ź procDescRoot, each.rest WHILE each # NIL DO <> bodyVar: Var Ź MakeGlobal[bitsPerProcDesc].v; WITH bodyVar.location SELECT FROM glob: REF LocationRep.globalVar => bb[each.bti].frameOffset Ź glob.id / Target.bitsPerAU; ENDCASE => ERROR; each.body Ź bodyVar; bodyVar.flags[constant] Ź TRUE; ENDLOOP; <> IF collectConstants THEN CollectConstants[cl]; }; FOR each: REF ProcDescEntry Ź desc.child, each.rest WHILE each # NIL DO <> init: Node Ź MimP5U.MakeComposite[ MimP5U.MakeNodeList2[each.indirectEntry, MimP5U.MakeConstCard[1]], bitsPerProcDesc]; each.body Ź MimP5S.Temporize[cl, init]; ENDLOOP; <> mLock Ź Tree.Null; IF bb[bti].entry THEN { IF substState.exitLabel # NIL THEN substState.exitLabel Ź MimP5U.AllocLabel[]; mLock Ź tb[bodyNode].son[4]; SetLock[cl, mLock]; }; <> MimP5.DeclList[cl, tb[bodyNode].son[2]]; MimP5.StatementList[cl, tb[bodyNode].son[3]]; IF substState.exitLabel # NIL THEN { <> MimP5U.InsertLabel[cl, substState.exitLabel]; IF mLock # Tree.Null THEN LocalReleaseLock[cl, mLock]; IF bodyOutRecord # RecordSENull THEN { ctx: Symbols.CTXIndex = seb[bodyOutRecord].fieldCtx; sei: ISEIndex Ź MimP5U.NextVar[ctxb[ctx].seList]; head: NodeList Ź NIL; tail: NodeList Ź NIL; UNTIL sei = ISENull DO new: NodeList Ź MimP5U.MakeArgList[MimP5.VarForSei[sei]]; IF tail = NIL THEN head Ź new ELSE tail.rest Ź new; tail Ź new; sei Ź MimP5U.NextVar[SymbolOps.NextSe[SymbolOps.own, sei]]; ENDLOOP; MimP5U.MoreCode[cl, MimP5U.MakeReturn[head]]; }; }; }; ENDCASE; lambda.body Ź MimP5U.MakeNodeList[MimP5.WrapSourceBlock[cl, bti, FALSE]]; <> IF substState.postfixCL # NIL THEN <> lambda.body Ź MimP5U.ExtractList[ApplyPrefixAndPostfix[lambda.body]]; <> lambda.body Ź MimP5U.MakeNodeList[ z.NEW[NodeRep.comment Ź [details: comment[Rope.Concat[desc.name, ":"]]]], lambda.body]; IF desc.parent # NIL THEN lambda.descBody Ź desc.body; procLabel.node Ź lambda; substState Ź oldSubstState; localProcCodeList Ź oldLocalProcList; RETURN [z.NEW[NodeRep.label Ź [details: label[procLabel]]]]; }; SetLock: PROC [cl: CodeList, lock: Tree.Link] = { node: Node Ź MimP5.Exp[lock]; set: Node = MimP5U.ApplyOp[ oper: MimP5U.MesaOpNode[monitorEntry], args: MimP5U.MakeArgList[MimP5U.Address[node]], bits: 0]; MimP5U.MoreCode[cl, set]; }; StripExtraDecl: PROC [node: Node] RETURNS [Node] = { <> <<{decl V; V _ E; V}>> <> WITH StripSource[node] SELECT FROM block: REF NodeRep.block => { list: NodeList Ź block.nodes; IF list # NIL THEN WITH StripSource[list.first] SELECT FROM decl: REF NodeRep.decl => IF decl.init = NIL THEN { r1: NodeList Ź list.rest; IF r1 # NIL THEN { var: Var Ź decl.var; IF var # NIL AND NOT var.flags[named] THEN { <> n2: Node Ź StripSource[r1.first]; WITH StripSource[r1.first] SELECT FROM assign: REF NodeRep.assign => IF assign.lhs = var THEN { <> r2: NodeList Ź r1.rest; IF r2 # NIL AND r2.rest = NIL THEN WITH StripSource[r2.first] SELECT FROM rvar: Var => IF rvar = var THEN <> RETURN [assign.rhs]; ENDCASE; }; ENDCASE; }; }; }; ENDCASE; }; ENDCASE; RETURN [node]; }; StripSource: PROC [node: Node] RETURNS [Node] = { DO WITH node SELECT FROM source: SourceNode => { nodes: NodeList Ź source.nodes; IF nodes # NIL AND nodes.rest = NIL THEN {node Ź nodes.first; LOOP}; }; ENDCASE; RETURN [node]; ENDLOOP; }; ClearProcDesc: PROC [pd: REF ProcDescEntry] = { WHILE pd # NIL DO next: REF ProcDescEntry Ź pd.rest; ClearProcDesc[pd.child]; pd Ź []; pd Ź next; ENDLOOP; }; ClearNodes: IntCodeUtils.Visitor = CHECKED { <<[node: IntCodeDefs.Node] RETURNS [IntCodeDefs.Node]>> IF node # NIL THEN IntCodeUtils.MapNode[node, ClearNodes]; RETURN [NIL]; }; VarsForCtx: PROC [ctx: CTXIndex] RETURNS [vl: VarList Ź NIL] = { IF ctx # CTXNull THEN { tail: VarList Ź NIL; sei: ISEIndex Ź MimP5U.NextVar[ctxb[ctx].seList]; UNTIL sei = ISENull DO var: Var Ź MimP5.VarForSei[sei]; this: VarList Ź MimP5U.MakeVarList[var]; IF tail = NIL THEN vl Ź this ELSE tail.rest Ź this; tail Ź this; sei Ź MimP5U.NextVar[SymbolOps.NextSe[SymbolOps.own, sei]]; ENDLOOP; }; }; <> RewriteSymbols: PROC [baseModel: IntCodeTwig.BaseModel] = { <> <<>> <> modNode: ModuleNode = NARROW[baseModel.module]; FOR each: VarList Ź modNode.vars, each.rest WHILE each # NIL DO var: Var Ź each.first; IF var # NIL THEN WITH var.location SELECT FROM glob: REF LocationRep.globalVar => { id: INT Ź var.id; IF id > 0 AND id <= maxGlobalVarId THEN { <> sei: Symbols.SEIndex Ź Symbols.SENull + id; WITH se: seb[sei] SELECT FROM id => IF se.idCtx = MimData.mainCtx THEN <> se.idValue Ź SymbolOps.EncodeBitAddr[[glob.id]]; ENDCASE; CopyVarFlags[var]; }; }; ENDCASE; ENDLOOP; <> FOR lambda: IntCodeTwig.LambdaModel Ź baseModel.first, lambda.next WHILE lambda # NIL DO label: Label = lambda.label; IF label # NIL AND LOOPHOLE[label.id, CARD] <= LOOPHOLE[maxBti, CARD] THEN { bti: CBTIndex = LOOPHOLE[label.id]; MakeSpecialVar: PROC [var: Var, kind: Symbols.SpecialVarKind] = { IF var # NIL THEN WITH var.location SELECT FROM local: REF LocationRep.localVar => { bits: INT Ź var.bits; sei: ISEIndex Ź SymbolOps.MakeCtxSe[Symbols.HTNull, Symbols.CTXNull]; ctx: CTXIndex = bb[bti].localCtx; WITH se: seb[sei] SELECT FROM linked => se.link Ź ctxb[ctx].seList; ENDCASE => ERROR; seb[sei].idInfo Ź SymbolOps.EncodeInt[bits]; seb[sei].idType Ź typeANY; seb[sei].special Ź kind; var.id Ź LOOPHOLE[sei - Symbols.ISENull]; <> ctxb[ctx].seList Ź sei; <> }; ENDCASE; }; MakeSpecialVar[lambda.frameExtension, frameExtension]; MakeSpecialVar[lambda.globalLink, globalLink]; MakeSpecialVar[lambda.staticLink, staticLink]; MakeSpecialVar[lambda.memoryLink, memoryLink]; MakeSpecialVar[lambda.returnVar, returnLink]; }; [] Ź CopyFlags[lambda.lambda]; ENDLOOP; }; CopyFlags: IntCodeUtils.Visitor = TRUSTED { WITH node SELECT FROM decl: REF NodeRep.decl => CopyVarFlags[decl.var]; lambda: REF NodeRep.lambda => FOR each: VarList Ź lambda.formalArgs, each.rest WHILE each # NIL DO CopyVarFlags[each.first]; ENDLOOP; ENDCASE; IntCodeUtils.MapNode[node, CopyFlags]; RETURN [node]; }; CopyVarFlags: PROC [var: Var] = { IF var # NIL THEN { <> flags: IntCodeDefs.VariableFlags = var.flags; IF flags[named] THEN { sei: ISEIndex = Symbols.ISENull + CARD[var.id]; new: Symbols.VariableFlags Ź seb[sei].flags; IF flags[upLevel] THEN { <> offset: INT Ź 0; new.upLevel Ź new.valid Ź TRUE; WITH var.location SELECT FROM field: REF LocationRep.field => offset Ź field.start; ENDCASE; seb[sei].idValue Ź SymbolOps.EncodeBitAddr[[offset]]; }; IF flags[addressed] THEN new.addressed Ź new.valid Ź TRUE; IF flags[assigned] THEN new.assigned Ź new.valid Ź TRUE; IF flags[used] THEN new.used Ź new.valid Ź TRUE; IF flags[constant] THEN seb[sei].immutable Ź TRUE; seb[sei].flags Ź new; }; }; }; }.