-- ThreeC4CProdImpl.ThreeC4
-- Sturgis, May 10, 1986 3:02:00 pm PDT
-- Shoup, July 1, 1986 0:14:45 am PDT

Include[ThreeC4BaseDecl, ThreeC4RecFcnDecl, ThreeC4BasicAbTypes, ThreeC4CProdAbGram];

ThreeC4CProdImpl: Module =
Begin

for ConcreteProduction: AbstractProduction[ModId, ConcreteRightSideList, BuildExp]
	let CollectProductions[tree, first, context] _
			<Add1ToInt[first], RecordProduction[context, FormName[ModId], first]>
	let ImplFileCode[tree, context, usage] _ <code, use>
		where code _ ConcatCode6[
			headCode,
			nodeVarDeclCode,
			nodeVarAssignCode,
			bodyCode,
			returnCode,
			endCode]
		
		where headCode _ ConcatCode4[	
			RopeCode1["See%g: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]\N", NameFill[prodName]],
			RopeCode["\TRETURNS[LIST OF REF ANY] =\N"],
			RopeCode["BEGIN\N"],
			RopeCode["stack: LIST OF REF ANY _ nodes;\N"]]
		
		where nodeVarDeclCode _ BuildVarDeclCode[subNodeNames, subNodeTypes]
		
		where nodeVarAssignCode  _ FormNodeVarAssignCode[ConcreteRightSideList]
		
		
		where bodyCode _ RopeCode1["stack _ CONS[%g, stack];\N", CodeFill[expCode]]
		where returnCode _ RopeCode["RETURN[stack]\N"]
		where endCode _ RopeCode["END;\N\N"]
		
		where use _ RecordTypesUse[use1, subNodeTypes]
		
		where check _ CompareValTypeWithVarType[expType, prodBuildType]
		where <expCode, expType, use1> _ FormBuildExpCode[BuildExp, False, context1, usage]
		where context1 _ FormRightSideContext[ConcreteRightSideList, context]
		
		where subNodeNames _ FormNameList[ConcreteRightSideList] 
		where subNodeTypes _ FormTypeList[ConcreteRightSideList, context]
		where prodName _ FormName[ModId]
		where prodBuildType _ LookUpGrammarSymbol[context, BuildName[FormFirstId[ModId]]]
		where False _ EqualRopes["False", "True"]
	
	let LinkFileCode[tree, context, usage] _ <code, FakeUsageCopy[usage]> 
		where code _ RopeCode2["prodLinkArray[%g] _ See%g;\N",
							IntFill[index],
							NameFill[prodName]]
		where index _ LookUpProduction[context, prodName]
		where prodName _ FormName[ModId]
	
	let SyntaxFileCodes[tree, context] _ <BuildEmptyCode[], prod>
		where prod _
			RopeCode2["%g _ %g;\N",
				DotedNameFill[FormName[ModId]],
				CodeFill[SyntaxRightSideFileCode[ConcreteRightSideList]]]
	let TestLinkPresent[tree] _ EqualRopes["True", "True"];


for ConcreteRightSideList.empty: AbstractProduction[]
	let FormRightSideContext[tree, context] _ context
	let FormNameList[tree] _ BuildEmptyNameList[]
	let FormTypeList[tree, context] _ BuildEmptyTypeList[]
	let FormNodeVarAssignCode[tree] _ BuildEmptyCode[]
	let SyntaxRightSideFileCode[tree] _ BuildEmptyCode[];
	
for ConcreteRightSideList.one: AbstractProduction[ConcreteRightSideItem]
	let FormRightSideContext[tree, context] _
			FormRightSideContext[ConcreteRightSideItem, context]
	let FormNameList[tree] _ FormNameList[ConcreteRightSideItem]
	let FormTypeList[tree, context] _ FormTypeList[ConcreteRightSideItem, context]
	let FormNodeVarAssignCode[tree] _ FormNodeVarAssignCode[ConcreteRightSideItem]
	let SyntaxRightSideFileCode[tree] _ SyntaxRightSideFileCode[ConcreteRightSideItem];
	
for ConcreteRightSideList.many: AbstractProduction[ConcreteRightSideList, ConcreteRightSideItem]
	let FormRightSideContext[tree, context] _
			FormRightSideContext[ConcreteRightSideItem,
				FormRightSideContext[ConcreteRightSideList, context]]
	let FormNameList[tree] _
		ConcatNameLists[
			FormNameList[ConcreteRightSideList],
			FormNameList[ConcreteRightSideItem]]
	let FormTypeList[tree, context] _
		ConcatTypeLists[
			FormTypeList[ConcreteRightSideList, context],
			FormTypeList[ConcreteRightSideItem, context]]
	let FormNodeVarAssignCode[tree] _ 
		ConcatCode2[
			FormNodeVarAssignCode[ConcreteRightSideItem],
			FormNodeVarAssignCode[ConcreteRightSideList]]
	let SyntaxRightSideFileCode[tree] _ 
		ConcatCode2[
			SyntaxRightSideFileCode[ConcreteRightSideList],
			SyntaxRightSideFileCode[ConcreteRightSideItem]];
			

for ConcreteRightSideItem.rope: AbstractProduction[Rope]
	let FormRightSideContext[tree, context] _ context
		where check _ CheckLegalRopeToken[context, Rope]
	let FormNameList[tree] _ BuildEmptyNameList[]
	let FormTypeList[tree, context] _ BuildEmptyTypeList[]
	let FormNodeVarAssignCode[tree] _ BuildEmptyCode[]
	let SyntaxRightSideFileCode[tree] _ ConcatCode3[
				RopeCode[" \""],
				RopeCode[itemRope],
				RopeCode["\" "]]
			where itemRope _ RopeFromRopeNode[Rope];
		
for ConcreteRightSideItem.modId: AbstractProduction[ModId]
	let FormRightSideContext[tree, context] _ PushLocalRSS[context, FormName[ModId], type]
		where type _ LookUpGrammarSymbol[context, BuildName[FormFirstId[ModId]]]
	let FormNameList[tree] _ BuildOneNameList[FormName[ModId]]
	let FormTypeList[tree, context] _ BuildOneTypeList[type]
		where type _ LookUpGrammarSymbol[context, name]
		where name _ BuildName[FormFirstId[ModId]]
	let FormNodeVarAssignCode[tree] _ ConcatCode2[
			RopeCode1["%g _ NARROW[stack.first];\N", NameFill[FormName[ModId]]],
			RopeCode["stack _ stack.rest;\N"]]
	let SyntaxRightSideFileCode[tree] _ RopeCode1["%g ", IdFill[FormFirstId[ModId]]];

for BuildExp.modId: AbstractProduction[ModId]
	let FormBuildExpCode[tree, nested, context, usage] _ FormExpCode[ModId, context, usage]
	let FormBuildPositionCode[tree, nested, context, usage] _ <code, use>
		where code _ RopeCode1["%g.position", CodeFill[nodeCode]]
		where <nodeCode, unused, use> _ FormExpCode[ModId, context, usage]
	let FormBuildLengthCode[tree, nested, context, usage] _ <code, use>
		where code _ RopeCode1["%g.length", CodeFill[nodeCode]]
		where <nodeCode, unused, use> _ FormExpCode[ModId, context, usage];
	

for BuildExp.buildNode: AbstractProduction[ModId, IntervalExp, BuildExpList]
	let FormBuildExpCode[tree, nested, context, usage] _ <code, type, use>
		where code _ RopeCode4["Build%gProdNode[%g%g%g]", NameFill[name], CodeFill[intervalCode], CodeFill[spacerCode], CodeFill[expCode]]
		where use _ RecordAbstProdUse[use1, name, Use.import, context]
		where check _ CompareValTypesWithVarTypes[expListTypes, argTypes]
		where <type, argTypes> _ LookUpAbstractProduction[context, name]
		where name _ FormName[ModId]
		where spacerCode _ if TestEmptyCode[expCode] then BuildEmptyCode[]
								else RopeCode[", "]
		where <expCode, expListTypes, use1> _ FormBuildExpListCode[BuildExpList, context, use0]
		where intervalCode _
					RopeCode2["%g, %g", CodeFill[positionCode], CodeFill[lengthCode]]
		where <positionCode, use0> _
			FormIntervalBuildPositionCode[IntervalExp, BuildExpList, nested, context, use00]
		where <lengthCode, use00> _
			FormIntervalBuildLengthCode[IntervalExp, BuildExpList, nested, context, usage]
	let FormBuildPositionCode[tree, nested, context, usage] _
			FormIntervalBuildPositionCode[IntervalExp, BuildExpList, nested, context, usage]
	let FormBuildLengthCode[tree, nested, context, usage] _
			FormIntervalBuildLengthCode[IntervalExp, BuildExpList, nested, context, usage];
	


for BuildExpList.empty: AbstractProduction[]
	let FormBuildExpListCode[tree, context, usage] _
			<BuildEmptyCode[], BuildEmptyTypeList[], FakeUsageCopy[usage]>
	let FormBuildPositionCode[tree, nested, context, usage] _
			if EmptyRSContext[context]
				then <RopeCode["position"], FakeUsageCopy[usage]>
				else <BuildErrorCode["expecting a build exp list"], FakeUsageCopy[usage]>
	let FormBuildLengthCode[tree, nested, context, usage] _
			if EmptyRSContext[context]
				then <RopeCode["length"], FakeUsageCopy[usage]>
				else <BuildErrorCode["expecting a build exp list"], FakeUsageCopy[usage]>;

for BuildExpList.one: AbstractProduction[BuildExp]
	let FormBuildExpListCode[tree, context, usage] _ <code, BuildOneTypeList[type], use>
		where <code, type, use> _ FormBuildExpCode[BuildExp, True, context, usage]
		where True _ EqualRopes["True", "True"]
	let FormBuildPositionCode[tree, nested, context, usage] _
			FormBuildPositionCode[BuildExp, nested, context, usage]
	let FormBuildLengthCode[tree, nested, context, usage] _
			FormBuildLengthCode[BuildExp, nested, context, usage];
	
for BuildExpList.many: AbstractProduction[BuildExpList, BuildExp]
	let FormBuildExpListCode[tree, context, usage] _ <code, types, use>
		where code _ ConcatCode3[
							listCode,
							RopeCode[", "],
							expCode]
		where types _ AppendToTypeList[types1, type]
		where <expCode, type, use> _ FormBuildExpCode[BuildExp, True, context, use1]
		where <listCode, types1, use1> _ FormBuildExpListCode[BuildExpList, context, usage]
		where True _ EqualRopes["True", "True"]
	let FormBuildPositionCode[tree, nested, context, usage] _
			FormBuildPositionCode[BuildExpList, nested, context, usage]
	let FormBuildLengthCode[tree, nested, context, usage] _ <code, use>
			where code _ RopeCode3["%g + %g - %g",
									CodeFill[expPosCode],
									CodeFill[expLengthCode],
									CodeFill[listPosCode]]
			where <expPosCode, use> _ FormBuildPositionCode[BuildExp, nested, context, use2]
			where <expLengthCode, use2> _ FormBuildLengthCode[BuildExp, nested, context, use1]
			where <listPosCode, use1> _ FormBuildPositionCode[BuildExpList, nested, context, usage];

for IntervalExp.none: AbstractProduction[]
	let FormIntervalBuildPositionCode[tree, expList, nested, context, usage] _
			if nested then FormBuildPositionCode[expList, nested, context, usage]
			 else <RopeCode["position"], FakeUsageCopy[usage]>
	let FormIntervalBuildLengthCode[tree, expList, nested, context, usage] _
			if nested then FormBuildLengthCode[expList, nested, context, usage]
			 else <RopeCode["length"], FakeUsageCopy[usage]>;
			 
	
for IntervalExp.present: AbstractProduction[IntervalForm.form, ModId.left, ModId.right]
	let FormIntervalBuildPositionCode[tree, expList, nested, context, usage] _
			if nested then
					(if EqualIntervalForm[IntervalForm.form, IntervalForm.closed] then
							(<code, use>
								where code _ RopeCode1["%g.position", CodeFill[left]]
								where <left, unused, use> _
									FormExpCode[ModId.left, context, usage])
					else if EqualIntervalForm[IntervalForm.form, IntervalForm.leftOpen] then
							(<code, use>
								where code _ RopeCode2["%g.position + %g.length", 
									CodeFill[left], CodeFill[left]]
								where <left, unused, use> _
									FormExpCode[ModId.left, context, usage])
					else if EqualIntervalForm[IntervalForm.form, IntervalForm.rightOpen] then
							(<code, use>
								where code _ RopeCode1["%g.position", CodeFill[left]]
								where <left, unused, use> _
									FormExpCode[ModId.left, context, usage])
						else (<code, use>
								where code _ RopeCode2["%g.position + %g.length", 
									CodeFill[left], CodeFill[left]]
								where <left, unused, use> _
									FormExpCode[ModId.left, context, usage]))
			
			else <RopeCode["position"], FakeUsageCopy[usage]>
			
	let FormIntervalBuildLengthCode[tree, expList, nested, context, usage] _
			if nested then
					(if EqualIntervalForm[IntervalForm.form, IntervalForm.closed] then
							(<code, use>
								where code _ RopeCode3["%g.position + %g.length - %g.position",
									CodeFill[right],
									CodeFill[right],
									CodeFill[left]]
								where <right, unused, use> _
									FormExpCode[ModId.right, context, use1]
								where <left, unused1, use1> _ 
									FormExpCode[ModId.left, context, usage])
					else if EqualIntervalForm[IntervalForm.form, IntervalForm.leftOpen] then
							(<code, use>
								where code _ RopeCode4["%g.position + %g.length - %g.position - %g.length",
									CodeFill[right],
									CodeFill[right],
									CodeFill[left],
									CodeFill[left]]
								where <right, unused, use> _
									FormExpCode[ModId.right, context, use1]
								where <left, unused1, use1> _ 
									FormExpCode[ModId.left, context, usage])
					else if EqualIntervalForm[IntervalForm.form, IntervalForm.rightOpen] then
							(<code, use>
								where code _ RopeCode2["%g.position - %g.length",
									CodeFill[right],
									CodeFill[left]]
								where <right, unused, use> _
									FormExpCode[ModId.right, context, use1]
								where <left, unused1, use1> _ 
									FormExpCode[ModId.left, context, usage])
					else 
							(<code, use>
								where code _ RopeCode3["%g.position - %g.position - %g.length",
									CodeFill[right],
									CodeFill[left],
									CodeFill[left]]
								where <right, unused, use> _
									FormExpCode[ModId.right, context, use1]
								where <left, unused1, use1> _ 
									FormExpCode[ModId.left, context, usage]))
									
			else <RopeCode["length"], FakeUsageCopy[usage]>
					
				



End.