DIRECTORY
	ThreeC4BaseDecl1Def,
	ThreeC4RecFcnImplAbGramDef,
	ThreeC4Support,
	ThreeC4BaseDecl2Def,
	ThreeC4BasicAbTypesDef;

ThreeC4RecFcnImplImpl1Impl: CEDAR PROGRAM IMPORTS ThreeC4BaseDecl1Def, ThreeC4RecFcnImplAbGramDef, ThreeC4Support, ThreeC4BaseDecl2Def EXPORTS ThreeC4RecFcnImplAbGramDef= 
BEGIN
OPEN ThreeC4BaseDecl1Def, ThreeC4RecFcnImplAbGramDef, ThreeC4Support, ThreeC4BaseDecl2Def, ThreeC4BasicAbTypesDef;
AbProductionFcnImplProdImplFileCode: PUBLIC PROC[ref: REF ANY, context: LookupContextNode, usage: UsageNode] RETURNS[temp0: MesaCodeNode, temp1: UsageNode] =
BEGIN
tree: AbProductionFcnImplNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: AbProductionFcnImplProdData _ NARROW[tree.data];
BEGIN
code: MesaCodeNode;
use1: UsageNode;
localContext: LookupContextNode;
check: BOOLEAN;
newRightSideList: NameListNode;
oldRightSideList: NameListNode;
prodContext: LockedContextNode;
abTypeName: NameNode;
abProdName: NameNode;
abProdName _ treeData.ModId.procs.FormName[treeData.ModId];
abTypeName _ BuildName[treeData.ModId.procs.FormFirstId[treeData.ModId]];
[oldRightSideList, prodContext] _ LookUpAbProduction[context, abProdName];
newRightSideList _ treeData.ModIdList.procs.FormNameList[treeData.ModIdList];
check _ BPrintError[CompareNameLists[oldRightSideList, newRightSideList], "name lists do not match"];
localContext _ PushProductionContext[context, prodContext];
[code, use1] _ treeData.RecFcnImplList.procs.ProdImplFileCode[treeData.RecFcnImplList, localContext, abTypeName, abProdName, usage];
temp1 _ use1;
temp0 _ code;
END;
END
END;

RecFcnImplListoneProdProdImplFileCode: PUBLIC PROC[ref: REF ANY, prodContext: LookupContextNode, abTypeName: NameNode, abProdName: NameNode, usage: UsageNode] RETURNS[temp0: MesaCodeNode, temp1: UsageNode] =
BEGIN
tree: RecFcnImplListNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: RecFcnImplListoneProdData _ NARROW[tree.data];
BEGIN
code: MesaCodeNode;
headCode: MesaCodeNode;
bodyCode: MesaCodeNode;
treeDataCode: MesaCodeNode;
check2: BOOLEAN;
temp2: FcnImplGraphNode;
temp3: SlotListNode;
temp4: CallGraphNodeNode;
check1: BOOLEAN;
use: UsageNode;
varDeclCode: MesaCodeNode;
statementCode: MesaCodeNode;
varTypes: TypeListNode;
restNames: NameListNode;
nextTempX: IntegerNode;
use5: UsageNode;
varContext: LookupContextNode;
modifiedArgTypes: TypeListNode;
argType1: TypeNode;
argTypesRest: TypeListNode;
modifiedArgNames: NameListNode;
argName1: NameNode;
argNamesRest: NameListNode;
argNames: NameListNode;
resultNames: NameListNode;
nextTempX1: IntegerNode;
use4: UsageNode;
use3: UsageNode;
use2: UsageNode;
use1: UsageNode;
abType: TypeNode;
rightSideNames: NameListNode;
abProd: LockedContextNode;
argTypes: TypeListNode;
fcnResultTypes: TypeListNode;
check0: BOOLEAN;
check0 _ MarkErrors[];
[argTypes, fcnResultTypes] _ LookUpRecFcnDef[prodContext, BuildName[treeData.Identifier]];
[rightSideNames, abProd] _ LookUpAbProduction[prodContext, abProdName];
abType _ LookUpType[prodContext, abTypeName];
use1 _ RecordAbstProdUse[usage, abProdName, Use.ref, prodContext];
use2 _ RecordAbstProdUse[use1, abProdName, Use.export, prodContext];
use3 _ RecordTypeUse[use2, abType];
use4 _ RecordTypesUse[RecordTypesUse[use3, fcnResultTypes], argTypes];
[resultNames, nextTempX1] _ InventTemps[CountTypes[fcnResultTypes], IntegerFromRope["0"]];
argNames _ treeData.IdList.procs.FormNameList[treeData.IdList];
[argName1, argNamesRest] _ PartitionFirstName[argNames];
modifiedArgNames _ PrefixToNameList[BuildRopeName["ref"], argNamesRest];
[argType1, argTypesRest] _ PartitionFirstType[argTypes];
modifiedArgTypes _ PrefixToTypeList[abType, argTypesRest];
varContext _ RecordVarSeq[prodContext, argNames, modifiedArgTypes];
[varDeclCode, statementCode, varTypes, restNames, nextTempX, use5] _ treeData.RecExpression.procs.CompForVars[treeData.RecExpression, resultNames, nextTempX1, varContext, use4];
use _ RecordDefFileUse[use5, "ThreeC4Support", Use.import];
check1 _ CompareValTypesWithVarTypes[varTypes, fcnResultTypes];
IF AreErrors[] THEN {check2 _ False[];
} ELSE {[temp2, temp3, temp4] _ treeData.RecExpression.procs.FormFcnImplGraph[treeData.RecExpression, prodContext, BuildFcnImplGraph[prodContext, treeData.Identifier, treeData.IdList.procs.FormNameList[treeData.IdList]]];
check2 _ CheckFcnImpl[prodContext, temp2, temp3, temp4];
};
IF TestEmptyNameList[rightSideNames] THEN {treeDataCode _ BuildEmptyCode[];
} ELSE {treeDataCode _ RopeCode1["treeData: %gProdData _ NARROW[tree.data];\N", NameFill[abProdName]];
};
bodyCode _ ConcatCode7[RopeCode2["%g: %g_ NARROW[ref];\N", NameFill[argName1], CodeFill[GetTypeCodeName[abType]]], RopeCode["BEGIN\N"], RopeCode2["ENABLE ThreeC4Support.GetSourceInfo => RESUME[%g.position, %g.length];\N", NameFill[argName1], NameFill[argName1]], treeDataCode, varDeclCode, statementCode, RopeCode["END\N"]];
headCode _ RopeCode4["%gProd%g: PUBLIC PROC[%g] RETURNS[%g] =\N", NameFill[abProdName], IdFill[treeData.Identifier], CodeFill[BuildArgNameTypeCode[modifiedArgNames, argTypes]], CodeFill[BuildArgNameTypeCode[resultNames, fcnResultTypes]]];
code _ ConcatCode4[headCode, RopeCode["BEGIN\N"], bodyCode, RopeCode["END;\N\N"]];
temp1 _ use;
temp0 _ code;
END;
END
END;

RecFcnImplListmanyProdProdImplFileCode: PUBLIC PROC[ref: REF ANY, context: LookupContextNode, abTypeName: NameNode, abProdName: NameNode, usage: UsageNode] RETURNS[temp0: MesaCodeNode, temp1: UsageNode] =
BEGIN
tree: RecFcnImplListNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: RecFcnImplListmanyProdData _ NARROW[tree.data];
BEGIN
code: MesaCodeNode;
code1: MesaCodeNode;
use1: UsageNode;
code2: MesaCodeNode;
use2: UsageNode;
[code2, use2] _ treeData.RecFcnImplListb.procs.ProdImplFileCode[treeData.RecFcnImplListb, context, abTypeName, abProdName, usage];
[code1, use1] _ treeData.RecFcnImplLista.procs.ProdImplFileCode[treeData.RecFcnImplLista, context, abTypeName, abProdName, use2];
code _ ConcatCode2[code2, code1];
temp1 _ use1;
temp0 _ code;
END;
END
END;

RecExpressionwithWhereListProdCountVals: PUBLIC PROC[ref: REF ANY, context: LookupContextNode] RETURNS[temp0: IntegerNode] =
BEGIN
tree: RecExpressionNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: RecExpressionwithWhereListProdData _ NARROW[tree.data];
temp0 _ treeData.RecExpression.procs.CountVals[treeData.RecExpression, context];
END
END;

RecExpressionwithWhereListProdCompForVars: PUBLIC PROC[ref: REF ANY, varNames: NameListNode, firstTempX: IntegerNode, context: LookupContextNode, usage: UsageNode] RETURNS[temp0: MesaCodeNode, temp1: MesaCodeNode, temp2: TypeListNode, temp3: NameListNode, temp4: IntegerNode, temp5: UsageNode] =
BEGIN
tree: RecExpressionNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: RecExpressionwithWhereListProdData _ NARROW[tree.data];
BEGIN
statementCode: MesaCodeNode;
declCode: MesaCodeNode;
expVarDeclCode: MesaCodeNode;
expStatementCode: MesaCodeNode;
varTypes: TypeListNode;
restNames: NameListNode;
nextTempX: IntegerNode;
use2: UsageNode;
whereVarDeclCode: MesaCodeNode;
whereStatementCode: MesaCodeNode;
nextTempX1: IntegerNode;
nestedContext: LookupContextNode;
use1: UsageNode;
[whereVarDeclCode, whereStatementCode, nextTempX1, nestedContext, use1] _ treeData.WhereExpSeq.procs.CompWhere[treeData.WhereExpSeq, firstTempX, context, usage];
[expVarDeclCode, expStatementCode, varTypes, restNames, nextTempX, use2] _ treeData.RecExpression.procs.CompForVars[treeData.RecExpression, varNames, nextTempX1, nestedContext, use1];
declCode _ BuildEmptyCode[];
statementCode _ ConcatCode6[RopeCode["BEGIN\N"], expVarDeclCode, whereVarDeclCode, whereStatementCode, expStatementCode, RopeCode["END;\N"]];
temp5 _ use2;
temp4 _ nextTempX;
temp3 _ restNames;
temp2 _ varTypes;
temp1 _ statementCode;
temp0 _ declCode;
END;
END
END;

RecExpressionwithWhereListProdCompForArgs: PUBLIC PROC[ref: REF ANY, treeCallFlag: TreeCallFlag, firstTempX: IntegerNode, context: LookupContextNode, usage: UsageNode] RETURNS[temp0: MesaCodeNode, temp1: MesaCodeNode, temp2: MesaCodeNode, temp3: MesaCodeNode, temp4: TypeListNode, temp5: IntegerNode, temp6: UsageNode] =
BEGIN
tree: RecExpressionNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: RecExpressionwithWhereListProdData _ NARROW[tree.data];
BEGIN
statementCode: MesaCodeNode;
varDeclCode: MesaCodeNode;
firstArgCode: MesaCodeNode;
firstTempName: NameNode;
junk: NameListNode;
use3: UsageNode;
check: BOOLEAN;
expVarDeclCode: MesaCodeNode;
expStatementCode: MesaCodeNode;
varTypes: TypeListNode;
restNames: NameListNode;
nextTempX: IntegerNode;
use2: UsageNode;
whereVarDeclCode: MesaCodeNode;
whereStatementCode: MesaCodeNode;
nextTempX2: IntegerNode;
nestedContext: LookupContextNode;
use1: UsageNode;
argCode: MesaCodeNode;
tempNames: NameListNode;
nextTempX1: IntegerNode;
nTemps: IntegerNode;
nTemps _ treeData.RecExpression.procs.CountVals[treeData.RecExpression, context];
[tempNames, nextTempX1] _ InventTemps[nTemps, firstTempX];
argCode _ BuildNameSeqArgCode[tempNames];
[whereVarDeclCode, whereStatementCode, nextTempX2, nestedContext, use1] _ treeData.WhereExpSeq.procs.CompWhere[treeData.WhereExpSeq, nextTempX1, context, usage];
[expVarDeclCode, expStatementCode, varTypes, restNames, nextTempX, use2] _ treeData.RecExpression.procs.CompForVars[treeData.RecExpression, tempNames, nextTempX2, nestedContext, use1];
check _ BAbort[BPrintError[CompareNameLists[restNames, BuildEmptyNameList[]], "name lists do not match"]];
use3 _ RecordTypesUse[use2, varTypes];
[firstTempName, junk] _ PartitionFirstName[tempNames];
IF EqualTreeCallFlags[treeCallFlag, TreeCallFlag.yes] THEN {firstArgCode _ RopeCode1["%g", NameFill[firstTempName]];
} ELSE {firstArgCode _ BuildEmptyCode[];
};
varDeclCode _ BuildVarDeclCode[tempNames, varTypes];
statementCode _ ConcatCode6[RopeCode["BEGIN\N"], expVarDeclCode, whereVarDeclCode, whereStatementCode, expStatementCode, RopeCode["END;\N"]];
temp6 _ use3;
temp5 _ nextTempX;
temp4 _ varTypes;
temp3 _ firstArgCode;
temp2 _ argCode;
temp1 _ statementCode;
temp0 _ varDeclCode;
END;
END
END;

RecExpressioncondProdCountVals: PUBLIC PROC[ref: REF ANY, context: LookupContextNode] RETURNS[temp0: IntegerNode] =
BEGIN
tree: RecExpressionNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: RecExpressioncondProdData _ NARROW[tree.data];
temp0 _ treeData.RecExpressionthenClause.procs.CountVals[treeData.RecExpressionthenClause, context];
END
END;

RecExpressioncondProdCompForVars: PUBLIC PROC[ref: REF ANY, varNames: NameListNode, firstTempX: IntegerNode, context: LookupContextNode, usage: UsageNode] RETURNS[temp0: MesaCodeNode, temp1: MesaCodeNode, temp2: TypeListNode, temp3: NameListNode, temp4: IntegerNode, temp5: UsageNode] =
BEGIN
tree: RecExpressionNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: RecExpressioncondProdData _ NARROW[tree.data];
BEGIN
varDeclCode: MesaCodeNode;
statementCode: MesaCodeNode;
varTypes: TypeListNode;
restNames: NameListNode;
check3: BOOLEAN;
check2: BOOLEAN;
vdc3: MesaCodeNode;
sc3: MesaCodeNode;
vt3: TypeListNode;
rn3: NameListNode;
nextTempX: IntegerNode;
use3: UsageNode;
vdc2: MesaCodeNode;
sc2: MesaCodeNode;
vt2: TypeListNode;
rn2: NameListNode;
ntx2: IntegerNode;
use2: UsageNode;
check1: BOOLEAN;
vdc1: MesaCodeNode;
sc1: MesaCodeNode;
ac1: MesaCodeNode;
junk: MesaCodeNode;
agt1: TypeListNode;
ntx1: IntegerNode;
use1: UsageNode;
[vdc1, sc1, ac1, junk, agt1, ntx1, use1] _ treeData.RecExpressionifClause.procs.CompForArgs[treeData.RecExpressionifClause, TreeCallFlag.no, firstTempX, context, usage];
check1 _ CheckForOneBoolean[agt1];
[vdc2, sc2, vt2, rn2, ntx2, use2] _ treeData.RecExpressionthenClause.procs.CompForVars[treeData.RecExpressionthenClause, varNames, ntx1, context, use1];
[vdc3, sc3, vt3, rn3, nextTempX, use3] _ treeData.RecExpressionelseClause.procs.CompForVars[treeData.RecExpressionelseClause, varNames, ntx2, context, use2];
check2 _ BAbort[BPrintError[CompareNameLists[rn2, rn3], "name lists do not match"]];
check3 _ CheckForEqualTypeLists[vt2, vt3];
restNames _ rn2;
varTypes _ vt2;
statementCode _ ConcatCode2[sc1, RopeCode3["IF %g THEN {%g} ELSE {%g};\N", CodeFill[ac1], CodeFill[sc2], CodeFill[sc3]]];
varDeclCode _ ConcatCode3[vdc1, vdc2, vdc3];
temp5 _ use3;
temp4 _ nextTempX;
temp3 _ restNames;
temp2 _ varTypes;
temp1 _ statementCode;
temp0 _ varDeclCode;
END;
END
END;

RecExpressioncondProdCompForArgs: PUBLIC PROC[ref: REF ANY, treeCallFlag: TreeCallFlag, firstTempX: IntegerNode, context: LookupContextNode, usage: UsageNode] RETURNS[temp0: MesaCodeNode, temp1: MesaCodeNode, temp2: MesaCodeNode, temp3: MesaCodeNode, temp4: TypeListNode, temp5: IntegerNode, temp6: UsageNode] =
BEGIN
tree: RecExpressionNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: RecExpressioncondProdData _ NARROW[tree.data];
BEGIN
varDeclCode: MesaCodeNode;
use: UsageNode;
bTypes: TypeListNode;
statementCode: MesaCodeNode;
argCode: MesaCodeNode;
firstArgCode: MesaCodeNode;
bt: NameListNode;
nextTempX: IntegerNode;
check2: BOOLEAN;
vdc3: MesaCodeNode;
sc3: MesaCodeNode;
ac3: MesaCodeNode;
fac3: MesaCodeNode;
at3: TypeListNode;
ntx3: IntegerNode;
use3: UsageNode;
vdc2: MesaCodeNode;
sc2: MesaCodeNode;
ac2: MesaCodeNode;
fac2: MesaCodeNode;
at2: TypeListNode;
ntx2: IntegerNode;
use2: UsageNode;
check1: BOOLEAN;
vdc1: MesaCodeNode;
sc1: MesaCodeNode;
ac1: MesaCodeNode;
junk: MesaCodeNode;
agt1: TypeListNode;
ntx1: IntegerNode;
use1: UsageNode;
[vdc1, sc1, ac1, junk, agt1, ntx1, use1] _ treeData.RecExpressionifClause.procs.CompForArgs[treeData.RecExpressionifClause, TreeCallFlag.no, firstTempX, context, usage];
check1 _ CheckForOneBoolean[agt1];
[vdc2, sc2, ac2, fac2, at2, ntx2, use2] _ treeData.RecExpressionthenClause.procs.CompForArgs[treeData.RecExpressionthenClause, treeCallFlag, ntx1, context, use1];
[vdc3, sc3, ac3, fac3, at3, ntx3, use3] _ treeData.RecExpressionelseClause.procs.CompForArgs[treeData.RecExpressionelseClause, treeCallFlag, ntx2, context, use2];
check2 _ CheckForEqualTypeLists[at2, at3];
[bt, nextTempX] _ InventTemps[IntegerFromRope["1"], ntx3];
IF EqualTreeCallFlags[treeCallFlag, TreeCallFlag.yes] THEN {firstArgCode _ RopeCode3["(IF %g THEN %g ELSE %g)", NameFill[TheOneName[bt]], CodeFill[fac2], CodeFill[fac3]];
} ELSE {firstArgCode _ BuildEmptyCode[];
};
argCode _ RopeCode3["(IF %g THEN %g ELSE %g)", NameFill[TheOneName[bt]], CodeFill[ac2], CodeFill[ac3]];
statementCode _ ConcatCode6[sc1, RopeCode2["IF %g _ %g THEN { NULL;\N", NameFill[TheOneName[bt]], CodeFill[ac1]], sc2, RopeCode["} ELSE {NULL;\N"], sc3, RopeCode["};\N"]];
bTypes _ BuildOneTypeList[LookUpType[context, BuildRopeName["BOOLEAN"]]];
use _ RecordTypesUse[use3, bTypes];
varDeclCode _ ConcatCode3[BuildVarDeclCode[bt, bTypes], vdc3, vdc2];
temp6 _ use;
temp5 _ nextTempX;
temp4 _ at2;
temp3 _ firstArgCode;
temp2 _ argCode;
temp1 _ statementCode;
temp0 _ varDeclCode;
END;
END
END;

RecExpressioncallProdCountVals: PUBLIC PROC[ref: REF ANY, context: LookupContextNode] RETURNS[temp0: IntegerNode] =
BEGIN
tree: RecExpressionNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: RecExpressioncallProdData _ NARROW[tree.data];
BEGIN
case: FunctionCase;
argTypes: TypeListNode;
resultTypes: TypeListNode;
[case, argTypes, resultTypes] _ LookUpFunction[context, BuildName[treeData.Identifier]];
temp0 _ CountTypes[resultTypes];
END;
END
END;

RecExpressioncallProdCompForVars: PUBLIC PROC[ref: REF ANY, varNames: NameListNode, firstTempX: IntegerNode, context: LookupContextNode, usage: UsageNode] RETURNS[temp0: MesaCodeNode, temp1: MesaCodeNode, temp2: TypeListNode, temp3: NameListNode, temp4: IntegerNode, temp5: UsageNode] =
BEGIN
tree: RecExpressionNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: RecExpressioncallProdData _ NARROW[tree.data];
BEGIN
statementCode: MesaCodeNode;
assignResultCode: MesaCodeNode;
oneResult: BOOLEAN;
fCall: MesaCodeNode;
argNames: NameListNode;
restNames: NameListNode;
check1: BOOLEAN;
varDeclCode: MesaCodeNode;
sc: MesaCodeNode;
ac: MesaCodeNode;
fac: MesaCodeNode;
at: TypeListNode;
nextTempX: IntegerNode;
use: UsageNode;
use0: UsageNode;
subTreeCallFlag: TreeCallFlag;
fCase: FunctionCase;
funArgTypes: TypeListNode;
funResultTypes: TypeListNode;
funName: NameNode;
funName _ BuildName[treeData.Identifier];
[fCase, funArgTypes, funResultTypes] _ LookUpFunction[context, funName];
IF EqualFunCase[fCase, FunctionCase.base] THEN {subTreeCallFlag _ TreeCallFlag.no;
} ELSE {subTreeCallFlag _ TreeCallFlag.yes;
};
IF EqualFunCase[fCase, FunctionCase.recursive] THEN {use0 _ FakeUsageCopy[usage];
} ELSE {use0 _ RecordFcnUse[usage, funName, Use.import, context];
};
[varDeclCode, sc, ac, fac, at, nextTempX, use] _ treeData.RecExpSeq.procs.CompForArgs[treeData.RecExpSeq, subTreeCallFlag, firstTempX, context, use0];
check1 _ CompareValTypesWithVarTypes[at, funArgTypes];
[argNames, restNames] _ PartitionNames[CountTypes[funResultTypes], varNames];
IF EqualFunCase[fCase, FunctionCase.base] THEN {fCall _ RopeCode2["%g[%g]", IdFill[treeData.Identifier], CodeFill[ac]];
} ELSE {fCall _ RopeCode3["%g.procs.%g[%g]", CodeFill[fac], IdFill[treeData.Identifier], CodeFill[ac]];
};
oneResult _ EqualInteger[CountTypes[funResultTypes], IntegerFromRope["1"]];
IF oneResult THEN {assignResultCode _ BuildNameSeqArgCode[argNames];
} ELSE {assignResultCode _ RopeCode1["[%g]", CodeFill[BuildNameSeqArgCode[argNames]]];
};
statementCode _ ConcatCode2[sc, RopeCode2["%g _ %g;\N", CodeFill[assignResultCode], CodeFill[fCall]]];
temp5 _ use;
temp4 _ nextTempX;
temp3 _ restNames;
temp2 _ funResultTypes;
temp1 _ statementCode;
temp0 _ varDeclCode;
END;
END
END;

RecExpressioncallProdCompForArgs: PUBLIC PROC[ref: REF ANY, treeCallFlag: TreeCallFlag, firstTempX: IntegerNode, context: LookupContextNode, usage: UsageNode] RETURNS[temp0: MesaCodeNode, temp1: MesaCodeNode, temp2: MesaCodeNode, temp3: MesaCodeNode, temp4: TypeListNode, temp5: IntegerNode, temp6: UsageNode] =
BEGIN
tree: RecExpressionNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: RecExpressioncallProdData _ NARROW[tree.data];
BEGIN
nextTempX: IntegerNode;
firstArgCode: MesaCodeNode;
argCode: MesaCodeNode;
statementCode: MesaCodeNode;
varDeclCode: MesaCodeNode;
use: UsageNode;
use2: UsageNode;
localVars: NameListNode;
firstLocalVar: NameNode;
otherLocalVars: NameListNode;
inventedTemps: NameListNode;
ntx2: IntegerNode;
simple: BOOLEAN;
oneResult: BOOLEAN;
fCall: MesaCodeNode;
check1: BOOLEAN;
vdc1: MesaCodeNode;
sc1: MesaCodeNode;
ac: MesaCodeNode;
fac: MesaCodeNode;
at: TypeListNode;
ntx1: IntegerNode;
use1: UsageNode;
use0: UsageNode;
subTreeCallFlag: TreeCallFlag;
fCase: FunctionCase;
funArgTypes: TypeListNode;
funResultTypes: TypeListNode;
funName: NameNode;
funName _ BuildName[treeData.Identifier];
[fCase, funArgTypes, funResultTypes] _ LookUpFunction[context, funName];
IF EqualFunCase[fCase, FunctionCase.base] THEN {subTreeCallFlag _ TreeCallFlag.no;
} ELSE {subTreeCallFlag _ TreeCallFlag.yes;
};
IF EqualFunCase[fCase, FunctionCase.recursive] THEN {use0 _ FakeUsageCopy[usage];
} ELSE {use0 _ RecordFcnUse[usage, funName, Use.import, context];
};
[vdc1, sc1, ac, fac, at, ntx1, use1] _ treeData.RecExpSeq.procs.CompForArgs[treeData.RecExpSeq, subTreeCallFlag, firstTempX, context, use0];
check1 _ CompareValTypesWithVarTypes[at, funArgTypes];
IF EqualFunCase[fCase, FunctionCase.base] THEN {fCall _ RopeCode2["%g[%g]", IdFill[treeData.Identifier], CodeFill[ac]];
} ELSE {fCall _ RopeCode3["%g.procs.%g[%g]", CodeFill[fac], IdFill[treeData.Identifier], CodeFill[ac]];
};
oneResult _ EqualInteger[CountTypes[funResultTypes], IntegerFromRope["1"]];
simple _ AndLogical[EqualTreeCallFlags[treeCallFlag, TreeCallFlag.no], oneResult];
[inventedTemps, ntx2] _ InventTemps[CountTypes[funResultTypes], ntx1];
[firstLocalVar, otherLocalVars] _ PartitionFirstName[inventedTemps];
IF simple THEN {localVars _ BuildEmptyNameList[];
} ELSE {localVars _ inventedTemps;
};
IF simple THEN {use2 _ FakeUsageCopy[use1];
} ELSE {use2 _ RecordTypesUse[use1, funResultTypes];
};
IF EqualFunCase[fCase, FunctionCase.recursive] THEN {use _ FakeUsageCopy[use2];
} ELSE {use _ RecordFcnUse[use2, funName, Use.import, context];
};
IF simple THEN {varDeclCode _ FakeCopyCodeForConditional[vdc1];
} ELSE {varDeclCode _ ConcatCode2[BuildVarDeclCode[localVars, funResultTypes], vdc1];
};
IF simple THEN {statementCode _ FakeCopyCodeForConditional[sc1];
} ELSE {IF oneResult THEN {statementCode _ ConcatCode2[FakeCopyCodeForConditional[sc1], RopeCode2["%g _ %g;\N", CodeFill[BuildNameSeqArgCode[localVars]], CodeFill[fCall]]];
} ELSE {statementCode _ ConcatCode2[FakeCopyCodeForConditional[sc1], RopeCode2["[%g] _ %g;\N", CodeFill[BuildNameSeqArgCode[localVars]], CodeFill[fCall]]];
};
};
IF simple THEN {argCode _ fCall;
} ELSE {argCode _ BuildNameSeqArgCode[localVars];
};
IF simple THEN {firstArgCode _ BuildEmptyCode[];
} ELSE {firstArgCode _ RopeCode1["%g", NameFill[firstLocalVar]];
};
IF simple THEN {nextTempX _ ntx1;
} ELSE {nextTempX _ ntx2;
};
temp6 _ use;
temp5 _ nextTempX;
temp4 _ funResultTypes;
temp3 _ firstArgCode;
temp2 _ argCode;
temp1 _ statementCode;
temp0 _ varDeclCode;
END;
END
END;

RecExpressionseqProdCountVals: PUBLIC PROC[ref: REF ANY, context: LookupContextNode] RETURNS[temp0: IntegerNode] =
BEGIN
tree: RecExpressionNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: RecExpressionseqProdData _ NARROW[tree.data];
temp0 _ treeData.RecExpSeq.procs.CountVals[treeData.RecExpSeq, context];
END
END;

RecExpressionseqProdCompForVars: PUBLIC PROC[ref: REF ANY, varNames: NameListNode, firstTempX: IntegerNode, context: LookupContextNode, usage: UsageNode] RETURNS[temp0: MesaCodeNode, temp1: MesaCodeNode, temp2: TypeListNode, temp3: NameListNode, temp4: IntegerNode, temp5: UsageNode] =
BEGIN
tree: RecExpressionNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: RecExpressionseqProdData _ NARROW[tree.data];
BEGIN
varDeclCode: MesaCodeNode;
statementCode: MesaCodeNode;
varTypes: TypeListNode;
restNames: NameListNode;
nextTempX: IntegerNode;
use: UsageNode;
[varDeclCode, statementCode, varTypes, restNames, nextTempX, use] _ treeData.RecExpSeq.procs.CompForVars[treeData.RecExpSeq, varNames, firstTempX, context, usage];
temp5 _ use;
temp4 _ nextTempX;
temp3 _ restNames;
temp2 _ varTypes;
temp1 _ statementCode;
temp0 _ varDeclCode;
END;
END
END;

RecExpressionseqProdCompForArgs: PUBLIC PROC[ref: REF ANY, treeCallFlag: TreeCallFlag, firstTempX: IntegerNode, context: LookupContextNode, usage: UsageNode] RETURNS[temp0: MesaCodeNode, temp1: MesaCodeNode, temp2: MesaCodeNode, temp3: MesaCodeNode, temp4: TypeListNode, temp5: IntegerNode, temp6: UsageNode] =
BEGIN
tree: RecExpressionNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: RecExpressionseqProdData _ NARROW[tree.data];
BEGIN
varDeclCode: MesaCodeNode;
statementCode: MesaCodeNode;
argCode: MesaCodeNode;
firstArgCode: MesaCodeNode;
argTypes: TypeListNode;
nextTempX: IntegerNode;
use: UsageNode;
[varDeclCode, statementCode, argCode, firstArgCode, argTypes, nextTempX, use] _ treeData.RecExpSeq.procs.CompForArgs[treeData.RecExpSeq, treeCallFlag, firstTempX, context, usage];
temp6 _ use;
temp5 _ nextTempX;
temp4 _ argTypes;
temp3 _ firstArgCode;
temp2 _ argCode;
temp1 _ statementCode;
temp0 _ varDeclCode;
END;
END
END;

RecExpressionidProdCountVals: PUBLIC PROC[ref: REF ANY, context: LookupContextNode] RETURNS[temp0: IntegerNode] =
BEGIN
tree: RecExpressionNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: RecExpressionidProdData _ NARROW[tree.data];
temp0 _ IntegerFromRope["1"];
END
END;

RecExpressionidProdCompForVars: PUBLIC PROC[ref: REF ANY, varNames: NameListNode, firstTempX: IntegerNode, context: LookupContextNode, usage: UsageNode] RETURNS[temp0: MesaCodeNode, temp1: MesaCodeNode, temp2: TypeListNode, temp3: NameListNode, temp4: IntegerNode, temp5: UsageNode] =
BEGIN
tree: RecExpressionNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: RecExpressionidProdData _ NARROW[tree.data];
BEGIN
statementCode: MesaCodeNode;
firstName: NameNode;
restNames: NameListNode;
varDeclCode: MesaCodeNode;
valStatementCode: MesaCodeNode;
valCode: MesaCodeNode;
junk: MesaCodeNode;
valTypes: TypeListNode;
nextTempX: IntegerNode;
use: UsageNode;
[varDeclCode, valStatementCode, valCode, junk, valTypes, nextTempX, use] _ tree.procs.CompForArgs[tree, TreeCallFlag.no, firstTempX, context, usage];
[firstName, restNames] _ PartitionFirstName[varNames];
statementCode _ ConcatCode4[RopeCode1["%g _ ", NameFill[firstName]], valCode, RopeCode[";\N"], valStatementCode];
temp5 _ use;
temp4 _ nextTempX;
temp3 _ restNames;
temp2 _ valTypes;
temp1 _ statementCode;
temp0 _ varDeclCode;
END;
END
END;

RecExpressionidProdCompForArgs: PUBLIC PROC[ref: REF ANY, treeCallFlag: TreeCallFlag, firstTempX: IntegerNode, context: LookupContextNode, usage: UsageNode] RETURNS[temp0: MesaCodeNode, temp1: MesaCodeNode, temp2: MesaCodeNode, temp3: MesaCodeNode, temp4: TypeListNode, temp5: IntegerNode, temp6: UsageNode] =
BEGIN
tree: RecExpressionNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: RecExpressionidProdData _ NARROW[tree.data];
BEGIN
argCode: MesaCodeNode;
firstArgCode: MesaCodeNode;
idTypes: TypeListNode;
type: TypeNode;
code: MesaCodeNode;
[type, code] _ LookUpSimpleValue[context, treeData.Identifier];
idTypes _ BuildOneTypeList[type];
IF EqualTreeCallFlags[treeCallFlag, TreeCallFlag.yes] THEN {firstArgCode _ RopeCode1["%g", CodeFill[code]];
} ELSE {firstArgCode _ BuildEmptyCode[];
};
argCode _ code;
temp6 _ FakeUsageCopy[usage];
temp5 _ FakeCopyInteger[firstTempX];
temp4 _ idTypes;
temp3 _ firstArgCode;
temp2 _ argCode;
temp1 _ BuildEmptyCode[];
temp0 _ BuildEmptyCode[];
END;
END
END;

RecExpressionmodIdProdCountVals: PUBLIC PROC[ref: REF ANY, context: LookupContextNode] RETURNS[temp0: IntegerNode] =
BEGIN
tree: RecExpressionNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: RecExpressionmodIdProdData _ NARROW[tree.data];
temp0 _ IntegerFromRope["1"];
END
END;

RecExpressionmodIdProdCompForVars: PUBLIC PROC[ref: REF ANY, varNames: NameListNode, firstTempX: IntegerNode, context: LookupContextNode, usage: UsageNode] RETURNS[temp0: MesaCodeNode, temp1: MesaCodeNode, temp2: TypeListNode, temp3: NameListNode, temp4: IntegerNode, temp5: UsageNode] =
BEGIN
tree: RecExpressionNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: RecExpressionmodIdProdData _ NARROW[tree.data];
BEGIN
statementCode: MesaCodeNode;
firstName: NameNode;
restNames: NameListNode;
varDeclCode: MesaCodeNode;
valStatementCode: MesaCodeNode;
valCode: MesaCodeNode;
junk: MesaCodeNode;
valTypes: TypeListNode;
nextTempX: IntegerNode;
use: UsageNode;
[varDeclCode, valStatementCode, valCode, junk, valTypes, nextTempX, use] _ tree.procs.CompForArgs[tree, TreeCallFlag.no, firstTempX, context, usage];
[firstName, restNames] _ PartitionFirstName[varNames];
statementCode _ ConcatCode4[RopeCode1["%g _ ", NameFill[firstName]], valCode, RopeCode[";\N"], valStatementCode];
temp5 _ use;
temp4 _ nextTempX;
temp3 _ restNames;
temp2 _ valTypes;
temp1 _ statementCode;
temp0 _ varDeclCode;
END;
END
END;

RecExpressionmodIdProdCompForArgs: PUBLIC PROC[ref: REF ANY, treeCallFlag: TreeCallFlag, firstTempX: IntegerNode, context: LookupContextNode, usage: UsageNode] RETURNS[temp0: MesaCodeNode, temp1: MesaCodeNode, temp2: MesaCodeNode, temp3: MesaCodeNode, temp4: TypeListNode, temp5: IntegerNode, temp6: UsageNode] =
BEGIN
tree: RecExpressionNode_ NARROW[ref];
BEGIN
ENABLE ThreeC4Support.GetSourceInfo => RESUME[tree.position, tree.length];
treeData: RecExpressionmodIdProdData _ NARROW[tree.data];
BEGIN
argCode: MesaCodeNode;
firstArgCode: MesaCodeNode;
idTypes: TypeListNode;
use: UsageNode;
type: TypeNode;
code: MesaCodeNode;
[type, code] _ LookUpValue2[context, treeData.Identifiera, treeData.Identifierb];
use _ RecordTypeUse[usage, type];
idTypes _ BuildOneTypeList[type];
IF EqualTreeCallFlags[treeCallFlag, TreeCallFlag.yes] THEN {firstArgCode _ RopeCode1["%g", CodeFill[code]];
} ELSE {firstArgCode _ BuildEmptyCode[];
};
argCode _ code;
temp6 _ use;
temp5 _ FakeCopyInteger[firstTempX];
temp4 _ idTypes;
temp3 _ firstArgCode;
temp2 _ argCode;
temp1 _ BuildEmptyCode[];
temp0 _ BuildEmptyCode[];
END;
END
END;

END..