-- ThreeC4RecFcnImplImpl.ThreeC4
-- Sturgis, May 9, 1986 9:54:38 am PDT
Include[ThreeC4BaseDecl, ThreeC4RecFcnDecl, ThreeC4BasicAbTypes, ThreeC4RecFcnImplAbGram];
ThreeC4RecFcnImplImpl1: Module =
Begin
for AbProductionFcnImpl: AbstractProduction[ModId, ModIdList, RecFcnImplList]
let ImplFileCode[tree, context, usage] _ <code, use1>
where <code, use1> _
ProdImplFileCode[RecFcnImplList, localContext, abTypeName, abProdName, usage]
where localContext _ PushProductionContext[context, prodContext]
where check _ CompareNameLists[oldRightSideList, newRightSideList]
where newRightSideList _ FormNameList[ModIdList]
where <oldRightSideList, prodContext> _
LookUpAbProduction[context, abProdName]
where abTypeName _ BuildName[FormFirstId[ModId]]
where abProdName _ FormName[ModId];
for RecFcnImplList.one: AbstractProduction[Identifier, IdList, RecExpression]
let ProdImplFileCode[tree, prodContext, abTypeName, abProdName, usage] _ <code, use>
where code _ ConcatCode4[
headCode,
RopeCode["BEGIN\N"],
bodyCode,
RopeCode["END;\N\N"]]
where headCode _ RopeCode4["%gProd%g: PUBLIC PROC[%g] RETURNS[%g] =\N",
NameFill[abProdName],
IdFill[Identifier],
CodeFill[BuildArgNameTypeCode[modifiedArgNames, argTypes]],
CodeFill[BuildArgNameTypeCode[resultNames, fcnResultTypes]]]
where 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"]]
where treeDataCode _ if TestEmptyNameList[rightSideNames]
then BuildEmptyCode[]
else RopeCode1["treeData: %gProdData _ NARROW[tree.data];\N",
NameFill[abProdName]]
where check2 _ CompareValTypesWithVarTypes[varTypes, fcnResultTypes]
where check1 _ CheckFcnImpl[
prodContext,
FormFcnImplGraph[
RecExpression,
prodContext,
BuildFcnImplGraph[prodContext, Identifier, FormNameList[IdList]]]]
where use _ RecordDefFileUse[use5, "ThreeC4Support", Use.import]
where <varDeclCode, statementCode, varTypes, restNames, nextTempX, use5> _
CompForVars[RecExpression, resultNames, nextTempX1, varContext, use4]
where varContext _ RecordVarSeq[prodContext, argNames, modifiedArgTypes]
where modifiedArgTypes _ PrefixToTypeList[abType, argTypesRest]
where <argType1, argTypesRest> _ PartitionFirstType[argTypes]
where modifiedArgNames _ PrefixToNameList[BuildRopeName["ref"], argNamesRest]
where <argName1, argNamesRest> _ PartitionFirstName[argNames]
where argNames _ FormNameList[IdList]
where <resultNames, nextTempX1> _
InventTemps[CountTypes[fcnResultTypes], IntegerFromRope["0"]]
where use4 _ RecordTypesUse[RecordTypesUse[use3, fcnResultTypes], argTypes]
where use3 _ RecordTypeUse[use2, abType]
where use2 _ RecordAbstProdUse[use1, abProdName, Use.export, prodContext]
where use1 _ RecordAbstProdUse[usage, abProdName, Use.ref, prodContext]
where abType _ LookUpType[prodContext, abTypeName]
where <rightSideNames, abProd> _ LookUpAbProduction[prodContext, abProdName]
where <argTypes, fcnResultTypes> _
LookUpRecFcnDef[prodContext, BuildName[Identifier]];
for RecFcnImplList.many: AbstractProduction[RecFcnImplList.a, RecFcnImplList.b]
let ProdImplFileCode[tree, context, abTypeName, abProdName, usage] _ <code, use1>
where code _ ConcatCode2[code2, code1]
where <code1, use1> _
ProdImplFileCode[RecFcnImplList.a, context, abTypeName, abProdName, use2]
where <code2, use2> _
ProdImplFileCode[RecFcnImplList.b, context, abTypeName, abProdName, usage];
for RecExpression.withWhereList: AbstractProduction[RecExpression, WhereExpSeq]
let CompForArgs[tree, treeCallFlag, firstTempX, context, usage] _
<varDeclCode, statementCode, argCode, firstArgCode, varTypes, nextTempX, use3>
where statementCode _ ConcatCode6[
RopeCode["BEGIN\N"],
expVarDeclCode,
whereVarDeclCode,
whereStatementCode,
expStatementCode,
RopeCode["END;\N"]]
where varDeclCode _ BuildVarDeclCode[tempNames, varTypes]
where firstArgCode _ if EqualTreeCallFlags[treeCallFlag, TreeCallFlag.yes] then RopeCode1["%g", NameFill[firstTempName]] else BuildEmptyCode[]
where <firstTempName, junk> _ PartitionFirstName[tempNames]
where use3 _ RecordTypesUse[use2, varTypes]
where check _ CompareNameLists[restNames, BuildEmptyNameList[]]
where <expVarDeclCode, expStatementCode, varTypes, restNames, nextTempX, use2> _
CompForVars[RecExpression, tempNames, nextTempX2, nestedContext, use1]
where <whereVarDeclCode, whereStatementCode, nextTempX2, nestedContext, use1> _
CompWhere[WhereExpSeq, nextTempX1, context, usage]
where argCode _ BuildNameSeqArgCode[tempNames]
where <tempNames, nextTempX1> _
InventTemps[nTemps, firstTempX]
where nTemps _ CountVals[RecExpression, context]
let CompForVars[tree, varNames, firstTempX, context, usage] _
<declCode, statementCode, varTypes, restNames, nextTempX, use2>
where statementCode _ ConcatCode6[
RopeCode["BEGIN\N"],
expVarDeclCode,
whereVarDeclCode,
whereStatementCode,
expStatementCode,
RopeCode["END;\N"]]
where declCode _ BuildEmptyCode[]
where <expVarDeclCode, expStatementCode, varTypes, restNames, nextTempX, use2> _
CompForVars[RecExpression, varNames, nextTempX1, nestedContext, use1]
where <whereVarDeclCode, whereStatementCode, nextTempX1, nestedContext, use1> _
CompWhere[WhereExpSeq, firstTempX, context, usage]
let CountVals[tree, context] _ CountVals[RecExpression, context];
for RecExpression.cond:
AbstractProduction[
RecExpression.ifClause,
RecExpression.thenClause,
RecExpression.elseClause]
let CompForArgs[tree, treeCallFlag, firstTempX, context, usage] _
<varDeclCode, statementCode, argCode, firstArgCode, at2, nextTempX, use>
where varDeclCode _ ConcatCode3[
BuildVarDeclCode[bt, bTypes],
vdc3,
vdc2]
where use _ RecordTypesUse[use3, bTypes]
where bTypes _
BuildOneTypeList[LookUpType[context, BuildRopeName["BOOLEAN"]]]
where statementCode _ ConcatCode6[
sc1,
RopeCode2["IF %g _ %g THEN { NULL;\N", NameFill[TheOneName[bt]], CodeFill[ac1]],
sc2,
RopeCode["} ELSE {NULL;\N"],
sc3,
RopeCode["};\N"]]
where argCode _ RopeCode3["(IF %g THEN %g ELSE %g)",
NameFill[TheOneName[bt]],
CodeFill[ac2],
CodeFill[ac3]]
where firstArgCode _ if EqualTreeCallFlags[treeCallFlag, TreeCallFlag.yes] then
RopeCode3["(IF %g THEN %g ELSE %g)",
NameFill[TheOneName[bt]],
CodeFill[fac2],
CodeFill[fac3]]
else BuildEmptyCode[]
where <bt, nextTempX> _ InventTemps[IntegerFromRope["1"], ntx3]
where check2 _ CheckForEqualTypeLists[at2, at3]
where <vdc3, sc3, ac3, fac3, at3, ntx3, use3> _
CompForArgs[RecExpression.elseClause, treeCallFlag, ntx2, context, use2]
where <vdc2, sc2, ac2, fac2, at2, ntx2, use2> _
CompForArgs[RecExpression.thenClause, treeCallFlag, ntx1, context, use1]
where check1 _ CheckForOneBoolean[agt1]
where <vdc1, sc1, ac1, junk, agt1, ntx1, use1> _
CompForArgs[RecExpression.ifClause, TreeCallFlag.no, firstTempX, context, usage]
let CompForVars[tree, varNames, firstTempX, context, usage] _
<varDeclCode, statementCode, varTypes, restNames, nextTempX, use3>
where varDeclCode _ ConcatCode3[vdc1, vdc2, vdc3]
where statementCode _ ConcatCode2[
sc1,
RopeCode3["IF %g THEN {%g} ELSE {%g};\N",
CodeFill[ac1], CodeFill[sc2], CodeFill[sc3]]]
where varTypes _ vt2
where restNames _ rn2
where check3 _ CheckForEqualTypeLists[vt2, vt3]
where check2 _ CompareNameLists[rn2, rn3]
where <vdc3, sc3, vt3, rn3, nextTempX, use3> _
CompForVars[RecExpression.elseClause, varNames, ntx2, context, use2]
where <vdc2, sc2, vt2, rn2, ntx2, use2> _
CompForVars[RecExpression.thenClause, varNames, ntx1, context, use1]
where check1 _ CheckForOneBoolean[agt1]
where <vdc1, sc1, ac1, junk, agt1, ntx1, use1> _
CompForArgs[RecExpression.ifClause, TreeCallFlag.no, firstTempX, context, usage]
let CountVals[tree, context] _ CountVals[RecExpression.thenClause, context];
for RecExpression.call: AbstractProduction[Identifier, RecExpSeq]
let CompForArgs[tree, treeCallFlag, firstTempX, context, usage] _
<varDeclCode, statementCode, argCode, firstArgCode, funResultTypes, nextTempX, use>
where nextTempX _ if simple then ntx1 else ntx2
where firstArgCode _ if simple then BuildEmptyCode[] else
RopeCode1["%g", NameFill[firstLocalVar]]
where argCode _ if simple then fCall else BuildNameSeqArgCode[localVars]
where statementCode _ if simple then FakeCopyCodeForConditional[sc1]
else
(if oneResult then ConcatCode2[
FakeCopyCodeForConditional[sc1],
RopeCode2["%g _ %g;\N",
CodeFill[BuildNameSeqArgCode[localVars]],
CodeFill[fCall]]]
else ConcatCode2[
FakeCopyCodeForConditional[sc1],
RopeCode2["[%g] _ %g;\N",
CodeFill[BuildNameSeqArgCode[localVars]],
CodeFill[fCall]]])
where varDeclCode _ if simple then FakeCopyCodeForConditional[vdc1]
else ConcatCode2[
BuildVarDeclCode[localVars, funResultTypes],
vdc1]
where use _ if EqualFunCase[fCase, FunctionCase.recursive]
then FakeUsageCopy[use2]
else RecordFcnUse[use2, funName, Use.import, context]
where use2 _ if simple then FakeUsageCopy[use1]
else RecordTypesUse[use1, funResultTypes]
where localVars _ if simple then BuildEmptyNameList[] else inventedTemps
where <firstLocalVar, otherLocalVars> _ PartitionFirstName[inventedTemps]
where <inventedTemps, ntx2> _ InventTemps[CountTypes[funResultTypes], ntx1]
where simple _ AndLogical[EqualTreeCallFlags[treeCallFlag, TreeCallFlag.no], oneResult]
where oneResult _ EqualInteger[CountTypes[funResultTypes], IntegerFromRope["1"]]
where fCall _ if EqualFunCase[fCase, FunctionCase.base]
then RopeCode2["%g[%g]", IdFill[Identifier], CodeFill[ac]]
else RopeCode3["%g.procs.%g[%g]", CodeFill[fac], IdFill[Identifier], CodeFill[ac]]
where check1 _ CompareValTypesWithVarTypes[at, funArgTypes]
where <vdc1, sc1, ac, fac, at, ntx1, use1> _
CompForArgs[RecExpSeq, subTreeCallFlag, firstTempX, context, use0]
where use0 _ if EqualFunCase[fCase, FunctionCase.recursive]
then FakeUsageCopy[usage]
else RecordFcnUse[usage, funName, Use.import, context]
where subTreeCallFlag _ if EqualFunCase[fCase, FunctionCase.base]
then TreeCallFlag.no else TreeCallFlag.yes
where <fCase, funArgTypes, funResultTypes> _
LookUpFunction[context, funName]
where funName _ BuildName[Identifier]
let CompForVars[tree, varNames, firstTempX, context, usage] _
<varDeclCode, statementCode, funResultTypes, restNames, nextTempX, use>
where statementCode _ ConcatCode2[
sc,
RopeCode2["%g _ %g;\N",
CodeFill[assignResultCode],
CodeFill[fCall]]]
where assignResultCode _ if oneResult then BuildNameSeqArgCode[argNames]
else RopeCode1["[%g]",
CodeFill[BuildNameSeqArgCode[argNames]]]
where oneResult _ EqualInteger[CountTypes[funResultTypes], IntegerFromRope["1"]]
where fCall _ if EqualFunCase[fCase, FunctionCase.base]
then RopeCode2["%g[%g]", IdFill[Identifier], CodeFill[ac]]
else RopeCode3["%g.procs.%g[%g]", CodeFill[fac], IdFill[Identifier], CodeFill[ac]]
where <argNames, restNames> _
PartitionNames[CountTypes[funResultTypes], varNames]
where check1 _ CompareValTypesWithVarTypes[at, funArgTypes]
where <varDeclCode, sc, ac, fac, at, nextTempX, use> _
CompForArgs[RecExpSeq, subTreeCallFlag, firstTempX, context, use0]
where use0 _ if EqualFunCase[fCase, FunctionCase.recursive]
then FakeUsageCopy[usage]
else RecordFcnUse[usage, funName, Use.import, context]
where subTreeCallFlag _ if EqualFunCase[fCase, FunctionCase.base]
then TreeCallFlag.no else TreeCallFlag.yes
where <fCase, funArgTypes, funResultTypes> _ LookUpFunction[context, funName]
where funName _ BuildName[Identifier]
let CountVals[tree, context] _ CountTypes[resultTypes]
where <case, argTypes, resultTypes> _ LookUpFunction[context, BuildName[Identifier]];
for RecExpression.seq: AbstractProduction[RecExpSeq]
let CompForArgs[tree, treeCallFlag, firstTempX, context, usage] _
<varDeclCode, statementCode, argCode, firstArgCode, argTypes, nextTempX, use>
where <varDeclCode, statementCode, argCode, firstArgCode, argTypes, nextTempX, use> _
CompForArgs[RecExpSeq, treeCallFlag, firstTempX, context, usage]
let CompForVars[tree, varNames, firstTempX, context, usage] _
<varDeclCode, statementCode, varTypes, restNames, nextTempX, use>
where <varDeclCode, statementCode, varTypes, restNames, nextTempX, use> _
CompForVars[RecExpSeq, varNames, firstTempX, context, usage]
let CountVals[tree, context] _ CountVals[RecExpSeq, context];
for RecExpression.id: AbstractProduction[Identifier]
let CompForArgs[tree, treeCallFlag, firstTempX, context, usage] _
<BuildEmptyCode[], BuildEmptyCode[], argCode, firstArgCode, idTypes, FakeCopyInteger[firstTempX], FakeUsageCopy[usage]>
where argCode _ code
where firstArgCode _ if EqualTreeCallFlags[treeCallFlag, TreeCallFlag.yes]
then RopeCode1["%g", CodeFill[code]]
else BuildEmptyCode[]
where idTypes _ BuildOneTypeList[type]
where <type, code> _ LookUpSimpleValue[context, Identifier]
let CompForVars[tree, varNames, firstTempX, context, usage] _
<varDeclCode, statementCode, valTypes, restNames, nextTempX, use>
where statementCode _ ConcatCode4[
RopeCode1["%g _ ", NameFill[firstName]],
valCode,
RopeCode[";\N"],
valStatementCode]
where <firstName, restNames> _ PartitionFirstName[varNames]
where <varDeclCode, valStatementCode, valCode, junk, valTypes, nextTempX, use>
_ CompForArgs[tree, TreeCallFlag.no, firstTempX, context, usage]
let CountVals[tree, context] _ IntegerFromRope["1"];
for RecExpression.modId: AbstractProduction[Identifier.a, Identifier.b]
let CompForArgs[tree, treeCallFlag, firstTempX, context, usage] _
<BuildEmptyCode[], BuildEmptyCode[], argCode, firstArgCode, idTypes, FakeCopyInteger[firstTempX], FakeUsageCopy[usage]>
where argCode _ code
where firstArgCode _ if EqualTreeCallFlags[treeCallFlag, TreeCallFlag.yes]
then RopeCode1["%g", CodeFill[code]]
else BuildEmptyCode[]
where idTypes _ BuildOneTypeList[type]
where <type, code> _
LookUpValue2[context, Identifier.a, Identifier.b]
let CompForVars[tree, varNames, firstTempX, context, usage] _
<varDeclCode, statementCode, valTypes, restNames, nextTempX, use>
where statementCode _ ConcatCode4[
RopeCode1["%g _ ", NameFill[firstName]],
valCode,
RopeCode[";\N"],
valStatementCode]
where <firstName, restNames> _ PartitionFirstName[varNames]
where <varDeclCode, valStatementCode, valCode, junk, valTypes, nextTempX, use>
_ CompForArgs[tree, TreeCallFlag.no, firstTempX, context, usage]
let CountVals[tree, context] _ IntegerFromRope["1"]
End;
ThreeC4RecFcnImplImpl2: Module =
Begin
for RecExpression.rope: AbstractProduction[Rope]
let CompForArgs[tree, treeCallFlag, firstTempX, context, usage] _
<BuildEmptyCode[], BuildEmptyCode[], argCode, firstArgCode, types, FakeCopyInteger[firstTempX], FakeUsageCopy[usage]>
where argCode _ RopeCode1["\"%g\"", CodeFill[RopeCode[RopeFromRopeNode[Rope]]]]
where firstArgCode _ if EqualTreeCallFlags[treeCallFlag, TreeCallFlag.yes]
then BuildErrorCode["rope is not a tree"]
else BuildEmptyCode[]
where types _ BuildOneTypeList[LookUpType[context, BuildRopeName["ROPE"]]]
let CompForVars[tree, varNames, firstTempX, context, usage] _
<varDeclCode, statementCode, valTypes, restNames, nextTempX, use>
where statementCode _ ConcatCode4[
RopeCode1["%g _ ", NameFill[firstName]],
valCode,
RopeCode[";\N"],
valStatementCode]
where <firstName, restNames> _ PartitionFirstName[varNames]
where <varDeclCode, valStatementCode, valCode, junk, valTypes, nextTempX, use>
_ CompForArgs[tree, TreeCallFlag.no, firstTempX, context, usage]
let CountVals[tree, context] _ IntegerFromRope["1"];
for RecExpression.numb: AbstractProduction[NonNegInteger]
let CompForArgs[tree, treeCallFlag, firstTempX, context, usage] _
<BuildEmptyCode[], BuildEmptyCode[], argCode, firstArgCode, types, FakeCopyInteger[firstTempX], FakeUsageCopy[usage]>
where argCode _ RopeCode[RopeFromNonNegIntegerNode[NonNegInteger]]
where firstArgCode _ if EqualTreeCallFlags[treeCallFlag, TreeCallFlag.yes]
then BuildErrorCode["number is not a tree"]
else BuildEmptyCode[]
where types _ BuildOneTypeList[LookUpType[context, BuildRopeName["INT"]]]
let CompForVars[tree, varNames, firstTempX, context, usage] _
<varDeclCode, statementCode, valTypes, restNames, nextTempX, use>
where statementCode _ ConcatCode4[
RopeCode1["%g _ ", NameFill[firstName]],
valCode,
RopeCode[";\N"],
valStatementCode]
where <firstName, restNames> _ PartitionFirstName[varNames]
where <varDeclCode, valStatementCode, valCode, junk, valTypes, nextTempX, use>
_ CompForArgs[tree, TreeCallFlag.no, firstTempX, context, usage]
let CountVals[tree, context] _ IntegerFromRope["1"];
for RecExpression.sourcePosition: AbstractProduction[ModId]
let CompForArgs[tree, treeCallFlag, firstTempX, context, usage] _
<BuildEmptyCode[], BuildEmptyCode[], argCode, firstArgCode, types, FakeCopyInteger[firstTempX], FakeUsageCopy[usage]>
where argCode _ RopeCode1["%g.position", NameFill[FormName[ModId]]]
where firstArgCode _ if EqualTreeCallFlags[treeCallFlag, TreeCallFlag.yes]
then BuildErrorCode["sourcePosition is not a tree"]
else BuildEmptyCode[]
where types _ BuildOneTypeList[LookUpType[context, BuildRopeName["INT"]]]
where check _ CompareValTypeWithVarType[
vType,
LookUpType[context, BuildRopeName["Tree"]]]
where <vType, unused> _ FormValueInfo[ModId, context]
let CompForVars[tree, varNames, firstTempX, context, usage] _
<varDeclCode, statementCode, valTypes, restNames, nextTempX, use>
where statementCode _ ConcatCode4[
RopeCode1["%g _ ", NameFill[firstName]],
valCode,
RopeCode[";\N"],
valStatementCode]
where <firstName, restNames> _ PartitionFirstName[varNames]
where <varDeclCode, valStatementCode, valCode, junk, valTypes, nextTempX, use>
_ CompForArgs[tree, TreeCallFlag.no, firstTempX, context, usage]
let CountVals[tree, context] _ IntegerFromRope["1"];
for RecExpression.sourceLength: AbstractProduction[ModId]
let CompForArgs[tree, treeCallFlag, firstTempX, context, usage] _
<BuildEmptyCode[], BuildEmptyCode[], argCode, firstArgCode, types, FakeCopyInteger[firstTempX], FakeUsageCopy[usage]>
where argCode _ RopeCode1["%g.length", NameFill[FormName[ModId]]]
where firstArgCode _ if EqualTreeCallFlags[treeCallFlag, TreeCallFlag.yes]
then BuildErrorCode["sourceLength is not a tree"]
else BuildEmptyCode[]
where types _ BuildOneTypeList[LookUpType[context, BuildRopeName["INT"]]]
where check _ CompareValTypeWithVarType[
vType,
LookUpType[context, BuildRopeName["Tree"]]]
where <vType, unused> _ FormValueInfo[ModId, context]
let CompForVars[tree, varNames, firstTempX, context, usage] _
<varDeclCode, statementCode, valTypes, restNames, nextTempX, use>
where statementCode _ ConcatCode4[
RopeCode1["%g _ ", NameFill[firstName]],
valCode,
RopeCode[";\N"],
valStatementCode]
where <firstName, restNames> _ PartitionFirstName[varNames]
where <varDeclCode, valStatementCode, valCode, junk, valTypes, nextTempX, use>
_ CompForArgs[tree, TreeCallFlag.no, firstTempX, context, usage]
let CountVals[tree, context] _ IntegerFromRope["1"];
for RecExpSeq.empty: AbstractProduction[]
let CompForArgs[tree, treeCallFlag, firstTempX, context, usage] _ <
BuildEmptyCode[],
BuildEmptyCode[],
BuildEmptyCode[],
if EqualTreeCallFlags[treeCallFlag, TreeCallFlag.yes]
then BuildErrorCode["expecting at least a tree argument"]
else BuildEmptyCode[],
BuildEmptyTypeList[],
FakeCopyInteger[firstTempX],
FakeUsageCopy[usage]>
let CompForVars[tree, varNames, firstTempX, context, usage] _ <
BuildEmptyCode[],
BuildEmptyCode[],
BuildEmptyTypeList[],
varNames,
FakeCopyInteger[firstTempX],
FakeUsageCopy[usage]>
let CountVals[tree, context] _ IntegerFromRope["0"];
for RecExpSeq.one: AbstractProduction[RecExpression]
let CompForArgs[tree, treeCallFlag, firstTempX, context, usage] _
CompForArgs[RecExpression, treeCallFlag, firstTempX, context, usage]
let CompForVars[tree, varNames, firstTempX, context, usage] _
CompForVars[RecExpression, varNames, firstTempX, context, usage]
let CountVals[tree, context] _ CountVals[RecExpression, context];
for RecExpSeq.many: AbstractProduction[RecExpSeq.a, RecExpSeq.b]
-- concrete grammar guarantees both non empty
let CompForArgs[tree, treeCallFlag, firstTempX, context, usage] _
<varDeclCode, statementCode, argCode, firstArgCode, argTypes, bNextTempX, use2>
where varDeclCode _ ConcatCode2[bDeclCode, aDeclCode]
where statementCode _ ConcatCode2[bStatementCode, aStatementCode]
where argCode _ ConcatCode3[aArgCode, RopeCode[", "], bArgCode]
where argTypes _ ConcatTypeLists[aVarTypes, bVarTypes]
where <bDeclCode, bStatementCode, bArgCode, unused, bVarTypes, bNextTempX, use2> _
CompForArgs[RecExpSeq.b, TreeCallFlag.no, aNextTempX, context, use1]
where <aDeclCode, aStatementCode, aArgCode, firstArgCode, aVarTypes, aNextTempX, use1> _
CompForArgs[RecExpSeq.a, treeCallFlag, firstTempX, context, usage]
let CompForVars[tree, varNames, firstTempX, context, usage] _
<varDeclCode, statementCode, varTypes, bRestNames, bNextTempX, use2>
where varDeclCode _ ConcatCode2[bDeclCode, aDeclCode]
where statementCode _ ConcatCode2[bStatementCode, aStatementCode]
where varTypes _ ConcatTypeLists[aVarTypes, bVarTypes]
where <bDeclCode, bStatementCode, bVarTypes, bRestNames, bNextTempX, use2> _
CompForVars[RecExpSeq.b, aRestNames, aNextTempX, context, use1]
where <aDeclCode, aStatementCode, aVarTypes, aRestNames, aNextTempX, use1> _
CompForVars[RecExpSeq.a, varNames, firstTempX, context, usage]
let CountVals[tree, context] _ Add[CountVals[RecExpSeq.b, context], CountVals[RecExpSeq.a, context]];
for WhereExpSeq.one: AbstractProduction[IdList, RecExpression]
let CompWhere[tree, firstTempX, context, usage] _
<varDeclCode, statementCode, nextTempX, nestedContext, use>
where nestedContext _
RecordVarSeq[context, FormNameList[IdList], expTypes]
where varDeclCode _ ConcatCode2[
FormVarDeclCode[IdList, expTypes],
expVarDeclCode]
where use _ RecordTypesUse[use1, expTypes]
where <expVarDeclCode, statementCode, expTypes, expRestNames, nextTempX, use1> _
CompForVars[RecExpression, FormNameList[IdList], firstTempX, context, usage];
for WhereExpSeq.many: AbstractProduction[WhereExpSeq.a, WhereExpSeq.b]
let CompWhere[tree, firstTempX, context, usage] _
<varDeclCode, statementCode, nextTempX, nestedContext, use2>
where varDeclCode _ ConcatCode2[aVarDeclCode,bVarDeclCode]
where statementCode _ ConcatCode2[bStatementCode, aStatementCode]
where <aVarDeclCode, aStatementCode, nextTempX, nestedContext, use2> _
CompWhere[WhereExpSeq.a, nextTempX1, nestedContext1, use1]
where <bVarDeclCode, bStatementCode, nextTempX1, nestedContext1, use1> _
CompWhere[WhereExpSeq.b, firstTempX, context, usage]
End;
ThreeC4RecFcnImplImpl3: Module =
Begin
-- this module contains the flow analysis code for a single implementation
for RecExpression.withWhereList: AbstractProduction[RecExpression, WhereExpSeq]
let FormFcnImplGraph[tree, lookup, graph] _ <newGraph, slots, cgNode>
where newGraph _ CloseWithWhereList[graph4]
where <graph4, cgNode> _ RecordSequential[graph3, whereNode, expNode]
where <graph3, slots, expNode> _ FormFcnImplGraph[RecExpression, lookup, graph2]
where <graph2, whereNode> _ FormFcnImplWhereGraph[WhereExpSeq, lookup, graph1]
where graph1 _ OpenWithWhereList[graph];
for RecExpression.cond:
AbstractProduction[
RecExpression.ifClause,
RecExpression.thenClause,
RecExpression.elseClause]
let FormFcnImplGraph[tree, lookup, graph] _ RecordCondition[graph3,
slotsIf, cgNodeIf,
slotsThen, cgNodeThen,
slotsElse, cgNodeElse]
where <graph3, slotsIf, cgNodeIf> _
FormFcnImplGraph[RecExpression.ifClause, lookup, graph2]
where <graph2, slotsThen, cgNodeThen> _
FormFcnImplGraph[RecExpression.thenClause, lookup, graph1]
where <graph1, slotsElse, cgNodeElse> _
FormFcnImplGraph[RecExpression.elseClause, lookup, graph];
for RecExpression.call: AbstractProduction[Identifier, RecExpSeq]
let FormFcnImplGraph[tree, lookup, graph] _ RecordCall[graph1, lookup, Identifier, slots, cgn]
where <graph1, slots, cgn> _ FormFcnImplGraph[RecExpSeq, lookup, graph];
for RecExpression.seq: AbstractProduction[RecExpSeq]
let FormFcnImplGraph[tree, lookup, graph] _ FormFcnImplGraph[RecExpSeq, lookup, graph];
for RecExpression.id: AbstractProduction[Identifier]
let FormFcnImplGraph[tree, lookup, graph] _ RecordSimpleVarUse[graph, lookup, Identifier];
for RecExpression.modId: AbstractProduction[Identifier.a, Identifier.b]
let FormFcnImplGraph[tree, lookup, graph] _
RecordModIdUse[graph, lookup, Identifier.a, Identifier.b];
for RecExpression.rope: AbstractProduction[Rope]
let FormFcnImplGraph[tree, lookup, graph] _ RecordLiteralUse[graph, SourcePosition[tree]];
for RecExpression.numb: AbstractProduction[NonNegInteger]
let FormFcnImplGraph[tree, lookup, graph] _ RecordLiteralUse[graph, SourcePosition[tree]];
for RecExpression.sourcePosition: AbstractProduction[ModId]
let FormFcnImplGraph[tree, lookup, graph] _ RecordLiteralUse[graph, SourcePosition[tree]];
for RecExpression.sourceLength: AbstractProduction[ModId]
let FormFcnImplGraph[tree, lookup, graph] _ RecordLiteralUse[graph, SourcePosition[tree]];
for RecExpSeq.empty: AbstractProduction[]
let FormFcnImplGraph[tree, lookup, graph] _
<FakeCopyFcnImplGraph[graph], BuildEmptySlotList[], BuildEmptyCallGraphNode[]>;
for RecExpSeq.one: AbstractProduction[RecExpression]
let FormFcnImplGraph[tree, lookup, graph] _
FormFcnImplGraph[RecExpression, lookup, graph];
for RecExpSeq.many: AbstractProduction[RecExpSeq.a, RecExpSeq.b]
let FormFcnImplGraph[tree, lookup, graph] _ <newGraph, slots, cgn>
where <newGraph, cgn> _ RecordParallel[graph2, cgna, cgnb]
where slots _ ConcatSlotList[slotsa, slotsb]
where <graph2, slotsb, cgnb> _ FormFcnImplGraph[RecExpSeq.b, lookup, graph1]
where <graph1, slotsa, cgna> _ FormFcnImplGraph[RecExpSeq.a, lookup, graph];
for WhereExpSeq.one: AbstractProduction[IdList, RecExpression]
let FormFcnImplWhereGraph[tree, lookup, graph] _
RecordAssignment[graph1, FormNameList[IdList], slots, cgn1]
where <graph1, slots, cgn1> _ FormFcnImplGraph[RecExpression, lookup, graph];
for WhereExpSeq.many: AbstractProduction[WhereExpSeq.a, WhereExpSeq.b]
let FormFcnImplWhereGraph[tree, lookup, graph] _ RecordSequential[graph2, cgnb, cgna]
where <graph2, cgna> _ FormFcnImplWhereGraph[WhereExpSeq.a, lookup, graph1]
where <graph1, cgnb> _ FormFcnImplWhereGraph[WhereExpSeq.b, lookup, graph]
End.
������Ê� ��˜�J˜ÑÜ—�…—����nT��nx��