-- ThreeC4CSyntax.ThreeC4
-- Sturgis, May 7, 1986 4:33:09 pm PDT

Include[ThreeC4BaseDecl, ThreeC4BasicAbTypes, ThreeC4RootAbGram, ThreeC4ModItemAbGram,
            ThreeC4OtherModItemsAbGram, ThreeC4RecFcnImplAbGram, ThreeC4CProdAbGram,
            ThreeC4MiscAbGram, ThreeC4FlowGraphAbGram];

ThreeC4Central: Control Module;

ThreeC4CSyntax1: Module =
Begin

{"Include" "Module" "Control" "Begin" "End" } : SimpleTokens;
{ ":" "=" "[" "]" "," "_" "." "{" "}" ";" } : SimpleTokens;
{ "CedarType" "CedarFunction" "AbstractType" "From" } : SimpleTokens;
{ "BaseType" "EnumeratedBaseType" "BaseFunction" } : SimpleTokens;
{ "AbstractProduction" "TreeRecursiveFunction" } : SimpleTokens;
{ "Returns" "CedarEnumType" "GenericToken" "SimpleTokens" "NonTerminal" } : SimpleTokens;
{ "Builds" "Build" } : SimpleTokens;
{ "for" "let" "if" "then" "else" "where" "(" ")" "<" ">" } : SimpleTokens;
{ "SourcePosition" "SourceLength" } : SimpleTokens;

{ "DamagedReps" "SharedReps" } : SimpleTokens;

MainGoal: NonTerminal Builds MainGoal;
    for MainGoal _ WholeFile
        Build MainGoal[WholeFile];
    
WholeFile: NonTerminal Builds WholeFile;
    for WholeFile _ OptionalIncludeClause ModuleList "."
        Build WholeFile[OptionalIncludeClause, ModuleList];

OptionalIncludeClause: NonTerminal Builds IncludeClause;
    for OptionalIncludeClause.empty _ 
        Build IncludeClause[IdList.Empty[]];
    
    for OptionalIncludeClause.nonEmpty _ "Include" "[" IdList "]" ";"
        Build IncludeClause[IdList];
        
ModuleList: NonTerminal Builds ModuleList;
    for ModuleList.one _ ModuleBody
        Build ModuleList.One[ModuleBody];
    
    for ModuleList.many _ ModuleList ";" ModuleBody
        Build ModuleList.Many[ModuleList, ModuleBody];
        
ModuleBody: NonTerminal Builds ModuleBody;
    for ModuleBody.control _ Identifier ":" "Control" "Module"
        Build ModuleBody.control[Identifier];
    
    for ModuleBody.normal _ Identifier ":" "Module" "=" "Begin" ModuleItemList "End"
        Build ModuleBody.normal[Identifier, ModuleItemList];
        
ModuleItemList: NonTerminal Builds ModuleItemList;
    for ModuleItemList.one _ ModuleItem
        Build ModuleItemList.One[ModuleItem];
        
    for ModuleItemList.many _ ModuleItemList ";" ModuleItem
        Build ModuleItemList.Many[ModuleItemList, ModuleItem];
        
        
ModuleItem: NonTerminal Builds ModuleItem;    
    for ModuleItem.cedarItems _ CedarItems
        Build ModuleItem.cedarItems[CedarItems];
    
    for ModuleItem.baseItems _ BaseItems
        Build ModuleItem.baseItems[BaseItems];
    
    for ModuleItem.abGramItems _ AbGramItems
        Build ModuleItem.abGramItems[AbGramItems];
    
    for ModuleItem.cGramItems    _ CGramItems
        Build ModuleItem.cGramItems[CGramItems];
        
    for ModuleItem.genTkn _ Identifier ":" "GenericToken" "=" Rope
        Build ModuleItem.genTkn[Identifier, Rope];

CedarItems: NonTerminal Builds CedarItems;
    for CedarItems.cedarTypesFromOne _ Identifier.tName ":" "CedarType" "From" Identifier.fName
        Build CedarItems.cedarTypesFrom[IdList.nonEmpty[Identifier.tName, IdList.Empty[(Identifier.tName, Identifier.tName]]], 
Identifier.fName];
        
    for CedarItems.cedarTypesFromMany _ Identifier.tName  "," IdList ":" "CedarType" "From" Identifier.fName
        Build CedarItems.cedarTypesFrom[IdList.nonEmpty[Identifier.tName, IdList], Identifier.fName];
    
    for CedarItems.cedarTypesOne _ Identifier.tName ":" "CedarType" 
        Build CedarItems.cedarTypes[IdList.nonEmpty[Identifier.tName, IdList.Empty[(Identifier.tName, Identifier.tName]]]];
        
    for CedarItems.cedarTypesMany _ Identifier.tName  "," IdList ":" "CedarType" 
        Build CedarItems.cedarTypes[IdList.nonEmpty[Identifier.tName, IdList]];    
        
    for CedarItems.cedarEnumTypeFrom
        _ Identifier.tName ":" "CedarEnumType" "=" "{" IdList "}"  "From" Identifier.fName
            Build CedarItems.cedarEnumTypeFrom[Identifier.tName, IdList, Identifier.fName];
    
    for CedarItems.cedarFnFrom
        _ Identifier.fnName ":" "CedarFunction" OptionalArgModIdList "Returns" "[" ModIdList "]" "From" Identifier.fName 
DamageShareAssertionList
            Build CedarItems.cedarFunctionFrom[Identifier.fnName, OptionalArgModIdList, ModIdList, Identifier.fName, 
DamageShareAssertionList];
            
            
            
            
CGramItems: NonTerminal Builds CGramItems;
    for CGramItems.simpleTokens _ "{" RopeList "}" ":" "SimpleTokens"
        Build CGramItems.simpleTokens[RopeList];
    
    for CGramItems.nonTerminal _ Identifier.ntName ":" "NonTerminal" "Builds" Identifier.fName
        Build CGramItems.nonTerminal[Identifier.ntName, Identifier.fName];
    
    for CGramItems.concreteProduction _ "for" ModId "_" OptionalConcreteRightSideList "Build" BuildExp
        Build CGramItems.concreteProduction[ConcreteProduction[ModId, OptionalConcreteRightSideList, BuildExp]];

BaseItems: NonTerminal Builds BaseItems;
    for BaseItems.oneBaseType _ Identifier ":" "BaseType"
        Build BaseItems.baseTypes[IdList.nonEmpty[Identifier, IdList.Empty[(Identifier, Identifier]]]];
    
    for BaseItems.manyBaseTypes _ Identifier "," IdList ":" "BaseType"
        Build BaseItems.baseTypes[IdList.nonEmpty[Identifier, IdList]];
    
    for BaseItems.enumBaseType _ Identifier ":" "EnumeratedBaseType" "=" "{" IdList "}"
        Build BaseItems.enumBaseType[Identifier, IdList];
    
    for BaseItems.baseFcn _ Identifier ":" "BaseFunction" OptionalArgModIdList "Returns" "[" ModIdList "]" DamageShareAssertionList
        Build BaseItems.baseFcn[Identifier, OptionalArgModIdList, ModIdList, DamageShareAssertionList];
    
    for BaseItems.treeRecFcn _ Identifier ":" "TreeRecursiveFunction" "[" ModIdList.args "]" "Returns" "[" ModIdList.results "]" 
DamageShareAssertionList
        Build BaseItems.treeRecFcn[Identifier, ModIdList.args, ModIdList.results, DamageShareAssertionList];

OptionalArgModIdList: NonTerminal Builds ModIdList;
    for OptionalArgModIdList.empty _
        Build ModIdList.Empty[];
    
    for OptionalArgModIdList.present _ "[" ModIdList "]"
        Build ModIdList;

AbGramItems: NonTerminal Builds AbGramItems;
    for AbGramItems.abType _ Identifier ":" "AbstractType" "[" IdList "]"
        Build AbGramItems.abType[Identifier, IdList];
    
    for AbGramItems.abProdTwoIds _
                Identifier.a "." Identifier.b ":" "AbstractProduction" "[" OptionalModIdList "]"
        Build AbGramItems.abProd[ModId.twoIds[Identifier.a, Identifier.b], OptionalModIdList];
    
    for AbGramItems.abProdOneId _ Identifier ":" "AbstractProduction" "[" OptionalModIdList "]"
        Build AbGramItems.abProd[ModId.oneId[Identifier], OptionalModIdList];
    
    for AbGramItems.abProdFcnImpl _ AbProductionFcnImpl
        Build AbGramItems.abProdFcnImpl[AbProductionFcnImpl];

AbProductionFcnImpl: NonTerminal Builds AbProductionFcnImpl;
    for AbProductionFcnImpl.oneId _
                "for" Identifier ":" "AbstractProduction" "[" OptionalModIdList "]" RecFcnImplList
        Build AbProductionFcnImpl[ModId.oneId[Identifier], OptionalModIdList, RecFcnImplList];
    
    for AbProductionFcnImpl.twoIds _
                "for" Identifier.a "." Identifier.b ":" "AbstractProduction" "[" OptionalModIdList "]" RecFcnImplList
        Build AbProductionFcnImpl[ModId.twoIds[Identifier.a, Identifier.b], OptionalModIdList, RecFcnImplList];

RecFcnImplList: NonTerminal Builds RecFcnImplList;
    for RecFcnImplList.one _ "let" Identifier "[" IdList "]" "_" RecExpression
        Build RecFcnImplList.one[Identifier, IdList, RecExpression];

    for RecFcnImplList.many _ RecFcnImplList "let" Identifier "[" IdList "]" "_" RecExpression
        Build RecFcnImplList.many[RecFcnImplList, RecFcnImplList.one[Identifier, IdList, RecExpression]]


End;

ThreeC4CSyntax2: Module =
Begin

RecExpression: NonTerminal Builds RecExpression;
    for RecExpression.RecExp1 _ RecExp1
        Build RecExp1;
        
    for RecExpression.withWhereList _ RecExp1 WhereExpSeq
        Build RecExpression.withWhereList[RecExp1, WhereExpSeq];    

RecExp1: NonTerminal Builds RecExpression;
    for RecExp1.cond _ "if" RecExp1.ifClause "then" RecExp1.thenClause "else" RecExp1.elseClause
        Build RecExpression.cond[RecExp1.ifClause, RecExp1.thenClause, RecExp1.elseClause];
    
    for RecExp1.paranthesis _ "(" RecExpression ")"
        Build RecExpression;
    
    for RecExp1.call _ Identifier "[" OptionalRecExpSeq "]"
        Build RecExpression.call[Identifier, OptionalRecExpSeq];
    
    for RecExp1.seq _ "<" RecExpSeq ">"
        Build RecExpression.seq[RecExpSeq];
    
    for RecExp1.id _ Identifier
        Build RecExpression.id[Identifier];
    
    for RecExp1.modId _ Identifier.a "." Identifier.b
        Build RecExpression.modId[Identifier.a, Identifier.b];
    
    for RecExp1.rope _ Rope
        Build RecExpression.rope[Rope];
    
    for RecExp1.numb _ NonNegInteger
        Build RecExpression.numb[NonNegInteger];
    
    for RecExp1.sourcePosition _ "SourcePosition" "[" ModId "]"
        Build RecExpression.sourcePosition[ModId];
    
    for RecExp1.sourceLength _ "SourceLength" "[" ModId "]"
        Build RecExpression.sourceLength[ModId];

OptionalRecExpSeq: NonTerminal Builds RecExpSeq;
    for OptionalRecExpSeq.empty _
        Build RecExpSeq.empty[];
    
    for OptionalRecExpSeq.nonEmpty _ RecExpSeq
        Build RecExpSeq;

RecExpSeq: NonTerminal Builds RecExpSeq;
    for RecExpSeq.one _ RecExpression
        Build RecExpSeq.one[RecExpression];

    for RecExpSeq.many _ RecExpSeq "," RecExpression
        Build RecExpSeq.many[RecExpSeq, RecExpSeq.one[RecExpression]];
        

WhereExpSeq: NonTerminal Builds WhereExpSeq;
    for WhereExpSeq.one _ WhereExp
        Build WhereExp;
    
    for WhereExpSeq.many _ WhereExpSeq WhereExp
        Build WhereExpSeq.many[WhereExpSeq, WhereExp];

WhereExp: NonTerminal Builds WhereExpSeq;
    for WhereExp.oneId _ "where" Identifier "_" RecExp1
        Build WhereExpSeq.one[IdList.nonEmpty[Identifier, IdList.Empty[(Identifier, Identifier]]], RecExp1];
    
    for WhereExp.manyIds _ "where" "<" IdList ">" "_" RecExp1
        Build WhereExpSeq.one[IdList, RecExp1];
         
    

    
    
    
            
    
    

OptionalConcreteRightSideList: NonTerminal Builds ConcreteRightSideList;
    for OptionalConcreteRightSideList.empty _
        Build ConcreteRightSideList.empty[];
        
    for OptionalConcreteRightSideList.nonEmpty _ ConcreteRightSideList
        Build ConcreteRightSideList;
    
ConcreteRightSideList: NonTerminal Builds ConcreteRightSideList;
    for ConcreteRightSideList.one _ ConcreteRightSideItem
        Build ConcreteRightSideList.one[ConcreteRightSideItem];
        
    for ConcreteRightSideList.many _ ConcreteRightSideList ConcreteRightSideItem
        Build ConcreteRightSideList.many[ConcreteRightSideList, ConcreteRightSideItem];
        
ConcreteRightSideItem: NonTerminal Builds ConcreteRightSideItem;
    for ConcreteRightSideItem.rope _ Rope
        Build ConcreteRightSideItem.rope[Rope];
        
    for ConcreteRightSideItem.modId _ ModId
        Build ConcreteRightSideItem.modId[ModId];
        
BuildExp: NonTerminal Builds BuildExp;
    for BuildExp.modId _ ModId
        Build BuildExp.modId[ModId];
    
    for BuildExp.buildNodeBoth _ ModId "[" IntervalExp "," BuildExpList "]"
        Build BuildExp.buildNode[ModId, IntervalExp, BuildExpList];
        
    for BuildExp.buildNodeListOnly _ ModId "[" BuildExpList "]"
        Build BuildExp.buildNode[ModId, IntervalExp.none[[BuildExpList, BuildExpList)], BuildExpList];
    
    for BuildExp.buildNodeIntervalOnly _ ModId "[" IntervalExp "]"
        Build BuildExp.buildNode[ModId, IntervalExp, BuildExpList.empty[(IntervalExp, IntervalExp]]];
    
    for BuildExp.buildNodeNeither _ ModId "[" "]"
        Build BuildExp.buildNode[ModId, IntervalExp.none[(ModId, ModId]], BuildExpList.empty[(ModId, ModId]]];
        
IntervalExp: NonTerminal Builds IntervalExp;
    for IntervalExp.closed _ "[" ModId.left "," ModId.right "]"
        Build IntervalExp.present[IntervalForm.closed, ModId.left, ModId.right];

    for IntervalExp.leftOpen _ "(" ModId.left "," ModId.right "]"
        Build IntervalExp.present[IntervalForm.leftOpen, ModId.left, ModId.right];
        
    for IntervalExp.rightOpen _ "[" ModId.left "," ModId.right ")"
        Build IntervalExp.present[IntervalForm.rightOpen, ModId.left, ModId.right];
        
    for IntervalExp.fullOpen _ "(" ModId.left "," ModId.right ")"
        Build IntervalExp.present[IntervalForm.fullOpen, ModId.left, ModId.right];
    
BuildExpList: NonTerminal Builds BuildExpList;
    for BuildExpList.one _ BuildExp
        Build BuildExpList.one[BuildExp];
    for BuildExpList.many _ BuildExpList "," BuildExp
        Build BuildExpList.many[BuildExpList, BuildExp];
    
ModId: NonTerminal Builds ModId;
    for ModId.oneId _ Identifier
        Build ModId.oneId[Identifier];
        
    for ModId.twoIds _ Identifier.left "." Identifier.right
        Build ModId.twoIds[Identifier.left, Identifier.right];
    
    
IdList: NonTerminal Builds IdList;
    for IdList.one _ Identifier
        Build IdList.nonEmpty[Identifier, IdList.Empty[(Identifier, Identifier]]];
        
    for IdList.many _ Identifier "," IdList
        Build IdList.nonEmpty[Identifier, IdList];

OptionalModIdList: NonTerminal Builds ModIdList;
    for OptionalModIdList.empty _
        Build ModIdList.Empty[];
    
    for OptionalModIdList.nonEmpty _ ModIdList
        Build ModIdList;
    
ModIdList: NonTerminal Builds ModIdList;
    for ModIdList.one _ ModId
        Build ModIdList.Many[ModIdList.Empty[[ModId, ModId)], ModId];
    
    for ModIdList.many _ ModIdList "," ModId
        Build ModIdList.Many[ModIdList, ModId];
    
RopeList: NonTerminal Builds RopeList;
    for RopeList.one _ Rope
        Build RopeList.One[Rope];
        
    for RopeList.many _ RopeList Rope
        Build RopeList.Many[RopeList, Rope];


DamageShareAssertionList: NonTerminal Builds DamageShareAssertions;
    for DamageShareAssertionList.empty _
        Build DamageShareAssertions.empty[];
    
    for DamageShareAssertionList.nonEmpty _ DamageShareAssertionList DamageShareAssertion
        Build DamageShareAssertions.many[DamageShareAssertionList, DamageShareAssertion];

DamageShareAssertion: NonTerminal Builds DamageShareAssertion;
    for DamageShareAssertion.damageAssertion _ "DamagedReps" "[" ModIdList "]"
        Build DamageShareAssertion.damagedReps[ModIdList];
    
    for DamageShareAssertion.shareAssertion _ "SharedReps" "[" ModIdList "]"
        Build DamageShareAssertion.sharedReps[ModIdList]


End.