-- ThreeC4RecFcnImplImpl.ThreeC4
-- Sturgis, May 9, 1986 9:54:38 am PDT
-- Shoup, June 23, 1986 9:39:03 am PDT
-- Bhargava, July 1, 1986 10:23:54 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 _ BPrintError[CompareNameLists[oldRightSideList, newRightSideList], "name lists do not match"]
		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 _ (if AreErrors[] then False[] else
			CheckFcnImpl[
				prodContext,
				FormFcnImplGraph[
					RecExpression,
					prodContext,
					BuildFcnImplGraph[prodContext, Identifier, FormNameList[IdList]]]])
				
		where check1 _ CompareValTypesWithVarTypes[varTypes, fcnResultTypes]
		
		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]]
				
		where check0 _ MarkErrors[];

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 _ BAbort[BPrintError[CompareNameLists[restNames, BuildEmptyNameList[]], "name lists do not match"]]
		
		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 _ BAbort[BPrintError[CompareNameLists[rn2, rn3], "name lists do not match"]]
			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], use>
			where argCode _ code
			where firstArgCode _ if EqualTreeCallFlags[treeCallFlag, TreeCallFlag.yes]
					then RopeCode1["%g", CodeFill[code]]
					else BuildEmptyCode[]
			where idTypes _ BuildOneTypeList[type]	
			where use _ RecordTypeUse[usage, 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.