SaffronMakeTypeMethods.ThreeC4
Copyright Ó 1987, 1988 by Xerox Corporation. All rights reserved.
Lucy Hederman August 20, 1987 3:49:01 pm PDT
Sturgis, July 21, 1987 3:16:17 pm PDT
James Rauen, June 18, 1988 12:27:04 pm PDT
replaced FreezeLocalContext[foo] with FreezeLocalContext[AnalyzeDependencies[foo]]
Last edited by: James Rauen August 25, 1988 3:26:59 pm PDT
Include [SaffronAG, SaffronTreeDecls, SaffronBaseDecls, SaffronProgramGraphDecls];
need DoTop to take MakeType of the TypeExp
SaffronMakeType1: Module = Begin
Top
for Top.modulep: AbstractProduction [ ModuleP ]
let DoTop[tree, fileName, env, cs] ← MakeEnvironment [ModuleP, fileName, env, cs]
;
ModuleP
for ModuleP.impl: AbstractProduction [ Directory, IdentList, Cedar, ProgHead, Checked, Block ]
let MakeEnvironment [tree, fileName, env, cs] ← env2
where env2 ← AddCompiledImplementationFileToEnvironment [env1, fileName, contextTree, pg2]
where pg2 ← AddMainProcedureGraphToProgramGraph[procGraph, pg1]
where procGraph ← MakeProcedureGraph[programFragment]
where <contextTree, programFragment, pg1> ←
Compile[Block, EmptyContextTree[contextRib], pg, cs]
where pg ← CreateEmptyProgramGraph[]
where contextRib ← FreezeLocalContext[lc4, moduleTGN]
where <lc4, moduleTGN> ← CreateModuleTGN[lc3, ffl]
where ffl ← FreezeFieldList[fl2]
where <fl2, lc3> ← AddTypeDeclarationToFieldList[IdentList, fl1, lc2, cs, access, access, implTGN, BogusTypeExpPTree[], NullDefaultVal[]]
where access ← GetAccessVal[ProgHead, AccessValConst["private"]]
where <lc2, implTGN> ← BuildImplementationTGN[ProgHead, lc1, cedar, cs]
where cedar ← IsKeywordPresent[Cedar]
where <fl1, lc1, env1> ← ProcessDirectoryClause [Directory, fl, lc, env, cs]
where fl ← CreateEmptyFieldList[]
where lc ← CreateEmptyContext [GetRootContextRib[cs], True[]]
;
for ModuleP.def: AbstractProduction [ Directory, IdentList, Cedar, DefHead, DefBody ]
let MakeEnvironment [tree, fileName, env, cs] ← env2
where env2 ← AddCompiledDefinitionsFileToEnvironment [env1, fileName, contextTree]
where contextTree ← AddSubContextTree[EmptyContextTree[contextRib], childContextTree]
where childContextTree ← MakeContextTree [DefBody, contextRib, True[], cs]
where contextRib ← FreezeLocalContext[lc4, moduleTGN]
where <lc4, moduleTGN> ← CreateModuleTGN[lc3, ffl]
where ffl ← FreezeFieldList[fl2]
where <fl2, lc3> ← AddTypeDeclarationToFieldList[IdentList, fl1, lc2, cs, access, access, interfaceTGN, BogusTypeExpPTree[], NullDefaultVal[]]
where access ← GetAccessVal[DefHead, AccessValConst["public"]]
where <lc2, interfaceTGN> ← BuildInterfaceTGN[DefHead, lc1, cedar, cs]
where cedar ← IsKeywordPresent[Cedar]
where <fl1, lc1, env1> ← ProcessDirectoryClause [Directory, fl, lc, env, cs]
where fl ← CreateEmptyFieldList[]
where lc ← CreateEmptyContext [GetRootContextRib[cs], True[]]
;
Directory
for Directory.empty: AbstractProduction [ ]
let ProcessDirectoryClause [tree, fl, localContext, env, cs] ← <
FakeDamageFieldList [fl],
FakeDamageContext [localContext],
FakeDamageEnvironment [env] >
;
for Directory.more: AbstractProduction [ Directory, IncludeItem ]
let ProcessDirectoryClause [tree, fl, localContext, env, cs] ← <fl2, lc2, env2>
where fl2 ← AppendFieldToFieldList[fl1, field]
where <field, lc2, env2> ← ProcessDirectoryItem[IncludeItem, lc1, env1, cs]
where <fl1, lc1, env1> ← ProcessDirectoryClause[Directory, fl, localContext, env, cs]
;
IncludeItem
for IncludeItem: AbstractProduction [Id.local, IdOrString, Id.moduleName, Using]
let ProcessDirectoryItem[tree, lc, env, cs] ← <field, lc1, env1>
where field ← CreateNamedTypeField[Id.local, position, access, tgn1, parseTree]
where parseTree ← BogusTypeExpPTree[]
where tgn1 ← RestrictNamedTGN[Using, tgn]
where <lc1, tgn> ← CreateNamedTGN[lc, Id.local, position, access, interface, default]
where position ← NullPosition[]
where access ← AccessValConst["public"]
where interface ← LookupInterfaceInEnv[env1, fileName, Id.moduleName]
where default ← NullDefaultVal[]
where env1 ←
if IsCompiledFileInEnv[env, fileName]
then FakeDamageEnvironment[env]
else ( MakeEnvironment [defFile, fileName, env, cs]
where defFile ← ModulePVal [ReadDefFile [fileName]] )
where fileName ← RopeFromIdOrString[IdOrString]
;
Using
for Using.restricted: AbstractProduction [ IdList ]
let RestrictNamedTGN [tree, namedTGN] ←
AddIdsToRestrictionList [IdList, namedTGN]
;
for Using.nothing: AbstractProduction [ ]
let RestrictNamedTGN [tree, namedTGN] ←
FakeDamageTypeGraphNode [namedTGN]
;
for Using.unrestricted: AbstractProduction [ ]
let RestrictNamedTGN [tree, namedTGN] ←
AddAllIdsToRestrictionList [namedTGN]
;
DefHead
for DefHead: AbstractProduction [Locks, ModuleList, Shares, Access]
let BuildInterfaceTGN[tree, lc, cedar, cs] ←
CreateInterfaceTGN[lc, cedar, locks, imports, shares]
where locks ← "I should be a locks foobar"
where imports ← "I should be an imports list"
where shares ← "I should be a shares list"
;
ProgHead
for ProgHead: AbstractProduction [Safe, Class, Arguments, Locks, Interface, Access]
let BuildImplementationTGN[tree, lc, cedar, cs] ←
CreateImplementationTGN[lc2, cedar, transferType, locks, imports, exports, shares]
where <lc2, transferType> ← CreateTransferTGN[lc1, safe, "program", input, output]
where safe ← IsKeywordPresent[Safe]
where <lc1, input, output> ← MakeArgumentLists[Arguments, lc, paintRecords, cs]
where paintRecords ← True[] -- crock!!
where locks ← "I should be a locks foobar"
where imports ← "I should be an imports list"
where exports ← "I should be an exports list"
where shares ← "I should be a shares list"
;
DefBody
for DefBody: AbstractProduction [ BindList, DecList ]
let MakeContextTree [tree, contextRib, paintRecords, cs] ←
Make the contextTree for the entire DefBody, nesting the DecList inside the bindlist's context.
MakeBindListContextTreeWithDefBody [BindList, defBodyPTree, contextRib, paintRecords, cs]
where defBodyPTree ← DefBodyPTreeVal [tree]
let MakeContextTree1 [tree, rib, paintRecords, cs] ←
Make the contextTree for the context nested within the BindList.
HangContextsFromContextTree [DecList, thisScopeContextTree, newRib, paintRecords, cs]
where thisScopeContextTree ← EmptyContextTree [newRib]
where newRib ← FreezeLocalContext[thisScopeLocalContext]
(note: Freeze will "process" the type graph, looking for cycles etc.)
where thisScopeLocalContext ← UpdateLocalContext [DecList, localContext, paintRecords, cs]
where localContext ← CreateEmptyContext [rib, True[]]
;
End;
SaffronMakeType2: Module = Begin
TypeExp
for TypeExp.record: AbstractProduction [ MachineDependent, Monitored, RecList ]
let MakeType[tree, localContext, paintRecords, cs] ← <localContext4, newTgn>
where <localContext4, newTgn> ←
CreateRecordTGN [ localContext2, paint, machineDependent, monitored, frozenFieldList]
where frozenFieldList ← FreezeFieldList [fieldList]
where <localContext2, fieldList> ← MakeFieldList [RecList, localContext1, paintRecords, cs]
where <localContext1, paint> ←
if paintRecords then GetUniquePaint [localContext]
  else GetUnpaintedPaint [localContext]
where machineDependent ← IsKeywordPresent [MachineDependent]
where monitored ← IsKeywordPresent [Monitored]
;
for TypeExp.union: AbstractProduction [ Tag, VariantList ]
let MakeType[tree, localContext, paintRecords, cs] ←
CreateVariantPartTGN [localContext3, variantFlavor, tagTypeTgn1, unionList]
where variantFlavor ← MakeVariantFlavor [Tag, cs]
where <localContext3, tagTypeTgn1> ←
if isStarTagType
then Make up a Tag type by an enumeration of the VariantList types
then MakeStarTagType [VariantList, localContext2]
else <FakeDamageContext [localContext2], tagTypeTgn>
where <localContext2, tagTypeTgn, isStarTagType> ←
MakeTagType [Tag, localContext1, paintRecords, cs]
where <localContext1, unionList> ←
MakeUnionList [VariantList, localContext, paintRecords, cs]
;
for TypeExp.sequence: AbstractProduction [ Packed, Tag, TypeExp ]
let MakeType[tree, localContext, paintRecords, cs] ←
CreateSequenceTGN [localContext2, packed, GetSequenceTagInfo [Tag, cs], tagTypeTgn, tgn]
where packed ← IsKeywordPresent [Packed]
where x ← if isStarTagType then Error ["Sequence Tag must not be a star"] else True[]
where <localContext2, tagTypeTgn, isStarTagType> ←
MakeTagType [Tag, localContext1, paintRecords, cs]
where <localContext1, tgn> ← MakeType [TypeExp, localContext, paintRecords, cs]
;
for TypeExp.enum: AbstractProduction [ MachineDependent, ElementList ]
let MakeType[tree, localContext, paintRecords, cs] ← MakeElementList [ElementList, localContext, machineDependent]
where machineDependent ← IsKeywordPresent [MachineDependent]
;
for TypeExp.ref: AbstractProduction [ ReadOnly, TypeExp ]
let MakeType[tree, localContext, paintRecords, cs] ←
  CreateRefTGN [localContext1, readOnly, referentTgn]
where <localContext1, referentTgn> ← MakeType[TypeExp, localContext, paintRecords, cs]
where readOnly ← IsKeywordPresent [ReadOnly]
;
for TypeExp.refany: AbstractProduction [ ReadOnly ]
let MakeType[tree, localContext, paintRecords, cs] ←
           CreateRefTGN [localContext1, readOnly, topTgn]
where topTgn ← GetTop [cs]
where localContext1 ← FakeDamageContext [localContext]
where readOnly ← IsKeywordPresent [ReadOnly]
;
for TypeExp.refunspecified: AbstractProduction [ ]
let MakeType[tree, localContext, paintRecords, cs] ←
           CreateRefTGN [localContext1, readOnly, topTgn]
where topTgn ← GetTop [cs]
where localContext1 ← FakeDamageContext [localContext]
where readOnly ← False []
;
for TypeExp.typeid: AbstractProduction [ TypeId ]
let MakeType[tree, localContext, paintRecords, cs] ←
MakeType [TypeId, localContext, paintRecords, cs]
;
for TypeExp.subrange: AbstractProduction [ Subrange ]
let MakeType[tree, localContext, paintRecords, cs] ←
MakeType[Subrange, localContext, paintRecords, cs]
;
for TypeExp.pointer: AbstractProduction [ Ordered, Base, PointerType ]
let MakeType[tree, localContext, paintRecords, cs] ←
     CreatePointerTGN [localContext1, ordered, base, bounds, readOnly, tgn]
where ordered ← IsKeywordPresent [Ordered]
where base ← IsKeywordPresent [Base]
where <localContext1, bounds, readOnly, tgn> ←
   GetPointerTypeInfo [PointerType, localContext, paintRecords, cs]
;
for TypeExp.var: AbstractProduction [ TypeExp ]
let MakeType[tree, localContext, paintRecords, cs] ← CreateVarTGN [localContext1, tgn]
where <localContext1, tgn> ← MakeType [TypeExp, localContext, paintRecords, cs]
;
for TypeExp.list: AbstractProduction [ ReadOnly, TypeExp ]
let MakeType[tree, localContext, paintRecords, cs] ←
  CreateListTGN [localContext1, readOnly, itemTgn]
where <localContext1, itemTgn> ← MakeType [TypeExp, localContext, paintRecords, cs]
where readOnly ← IsKeywordPresent [ReadOnly]
;
for TypeExp.array: AbstractProduction [ Packed, OptType, TypeExp ]
let MakeType[tree, localContext, paintRecords, cs] ←
        CreateArrayTGN [localContext2, packed, indexTgn, itemTgn]
where <localContext2, itemTgn> ← MakeType [TypeExp, localContext1, paintRecords, cs]
where <localContext1, indexTgn> ← MakeType [OptType, localContext, paintRecords, cs]
where packed ← IsKeywordPresent [Packed]
;
for TypeExp.descriptor: AbstractProduction [ ReadOnly, TypeExp ]
let MakeType[tree, localContext, paintRecords, cs] ←
           CreateDescriptorTGN [localContext1, readOnly, tgn]
where <localContext1, tgn> ← MakeType [TypeExp, localContext, paintRecords, cs]
where readOnly ← IsKeywordPresent [ReadOnly]
;
for TypeExp.transfer: AbstractProduction [ Safe, TransferMode, Arguments ]
let MakeType[tree, localContext, paintRecords, cs] ←
    CreateTransferTGN [localContext1, safe, transferMode, fflInput, fflOutput]
where <localContext1, fflInput, fflOutput> ←
       MakeArgumentLists [Arguments, localContext, paintRecords, cs]
where transferMode ← MakeTransferMode [TransferMode]
where safe ← IsKeywordPresent [Safe]
;
for TypeExp.relative: AbstractProduction [ TypeId, TypeExp ]
let MakeType[tree, localContext, paintRecords, cs] ←
          CreateRelativeTGN [localContext2, baseTgn, tgn]
where <localContext2, tgn> ← MakeType [TypeExp, localContext1, paintRecords, cs]
where <localContext1, baseTgn> ← LookupTypeId [TypeId, localContext]
;
for TypeExp.zone: AbstractProduction [ Uncounted ]
let MakeType[tree, localContext, paintRecords, cs] ←
       CreateZoneTGN [localContext, IsKeywordPresent [Uncounted]]
;
for TypeExp.long: AbstractProduction [ TypeExp ]
let MakeType[tree, localContext, paintRecords, cs] ← CreateLongTGN [localContext1, tgn]
where <localContext1, tgn> ← MakeType [TypeExp, localContext, paintRecords, cs]
;
for TypeExp.frame: AbstractProduction [ Id ]
let MakeType[tree, localContext, paintRecords, cs] ←
           <localContext1, FindFrameTGN [localContext1, Id]>
where localContext1 ← FakeDamageContext [localContext]
;
for TypeExp.painted: AbstractProduction [ TypeId, TypeExp ]
let MakeType[tree, localContext, paintRecords, cs] ← <c, n>
where n ← GetBottom[cs]
where c ← FakeDamageContext [localContext]
where x ← Error [" Unimplemented Construct"]
;
for TypeExp.typeapply: AbstractProduction [ TypeApply ]
let MakeType[tree, localContext, paintRecords, cs] ←
         MakeType [TypeApply, localContext, paintRecords, cs]
;
TypeApply
for TypeApply.one: AbstractProduction [ TypeId, Exp ]
let MakeType[tree, localContext, paintRecords, cs] ←
CreateSpecianatedTGNUsingExp [localContext1, tgn, MakeUnparsedValue[Exp]]
where <localContext1, tgn> ← LookupTypeId [TypeId, localContext]
;
for TypeApply.morelengths: AbstractProduction [ TypeApply, Exp ]
let MakeType[tree, localContext, paintRecords, cs] ←
CreateSpecianatedTGNUsingExp [localContext1, tgn, MakeUnparsedValue[Exp]]
where <localContext1, tgn> ← MakeType [TypeApply, localContext, paintRecords, cs]
;
for TypeApply.moreids: AbstractProduction [ TypeApply, Id ]
let MakeType[tree, localContext, paintRecords, cs] ←
CreateSpecianatedTGNUsingId [localContext1, tgn, Id]
where <localContext1, tgn> ← MakeType [TypeApply, localContext, paintRecords, cs]
;
TypeId
for TypeId.id: AbstractProduction [ Id ]
let MakeType[tree, localContext, paintRecords, cs] ← CreateIdentifierTGN[localContext, Id]
let LookupTypeId[tree, localContext] ← CreateIdentifierTGN[localContext, Id]
let MakeType[tree, localContext, paintRecords, cs] ← <localContext1, tgn>
where localContext1 ← FakeDamageContext [localContext]
where tgn ← LookupTypeName [ localContext, Id ]
let LookupTypeId [tree, localContext] ←<localContext1, tgn>
where localContext1 ← FakeDamageContext [localContext]
where tgn ← LookupTypeName [ localContext, Id ]
;
for TypeId.qualifier: AbstractProduction [ TypeId, Id ]
let MakeType[tree, localContext, paintRecords, cs] ← LookupTypeId [tree, localContext]
let LookupTypeId[tree, localContext] ← CreateSpecianatedTGNUsingId [localContext1, tgn, Id]
where <localContext1, tgn> ← LookupTypeId [TypeId, localContext]
let MakeType[tree, localContext, paintRecords, cs] ← LookupTypeId [tree, localContext]
let LookupTypeId [tree, localContext] ←
CreateSpecianatedTGNUsingId [localContext1, tgn, Id]
where <localContext1, tgn> ← LookupTypeId [TypeId, localContext]
;
OptType
for OptType.absent: AbstractProduction [ ]
let MakeType[tree, localContext, paintRecords, cs] ← <localContext1, tgn>
where localContext1 ← FakeDamageContext [localContext]
where tgn ← GetBottom [cs]
;
for OptType.present: AbstractProduction [ TypeExp ]
let MakeType[tree, localContext, paintRecords, cs] ←
           MakeType[TypeExp, localContext, paintRecords, cs]
;
Subrange
for Subrange.named: AbstractProduction [ TypeId, Interval ]
let MakeType[tree, localContext, paintRecords, cs] ←
CreateSubrangeTGN [localContext1, tgn, bounds]
where <localContext1, tgn> ← LookupTypeId [TypeId, localContext]
where bounds ← GetBoundsVal [Interval]
;
for Subrange.unnamed: AbstractProduction [ Interval ]
let MakeType[tree, localContext, paintRecords, cs] ← CreateSubrangeTGN [localContext, tgn, bounds]
where tgn ← GetBottom [cs]
where bounds ← GetBoundsVal [Interval]
;
Interval
for Interval.cc: AbstractProduction [ Bounds ]
let GetBoundsVal [tree] ← BoundsValFun ["[", GetLowerAndUpper [Bounds], "]"]
;
for Interval.co: AbstractProduction [ Bounds ]
let GetBoundsVal [tree] ← BoundsValFun ["[", GetLowerAndUpper [Bounds], ")"]
;
for Interval.oc: AbstractProduction [ Bounds ]
let GetBoundsVal [tree] ← BoundsValFun ["(", GetLowerAndUpper [Bounds], "]"]
;
for Interval.oo: AbstractProduction [ Bounds ]
let GetBoundsVal [tree] ← BoundsValFun ["(", GetLowerAndUpper [Bounds], ")"]
;
Bounds
for Bounds: AbstractProduction [ Exp.lower, Exp.upper ]
let GetLowerAndUpper [tree] ← <MakeUnparsedValue[Exp.lower], MakeUnparsedValue [Exp.upper]>
;
PointerType
for PointerType.unspecified: AbstractProduction [ OptInterval ]
let GetPointerTypeInfo [tree, localContext, paintRecords, cs] ← <localContext1, bounds, readOnly, tgn>
where bounds ← GetBoundsVal [OptInterval]
where readOnly ← False []
where tgn ← GetBottom[cs]
where localContext1 ← FakeDamageContext [localContext]
;
for PointerType.specified: AbstractProduction [ OptInterval, ReadOnly, TypeExp ]
let GetPointerTypeInfo [tree, localContext, paintRecords, cs] ← <localContext1, bounds, readOnly, tgn>
where bounds ← GetBoundsVal [OptInterval]
where readOnly ← IsKeywordPresent [ReadOnly]
where <localContext1, tgn> ← MakeType [TypeExp, localContext, paintRecords, cs]
;
OptInterval
for OptInterval.absent: AbstractProduction [ ]
let GetBoundsVal [tree] ← NullBounds []
;
for OptInterval.present: AbstractProduction [ Interval ]
let GetBoundsVal [tree] ← GetBoundsVal [Interval]
;
TransferMode
for TransferMode.proc: AbstractProduction [ ]
let MakeTransferMode [tree] ← "proc"
;
for TransferMode.port: AbstractProduction [ ]
let MakeTransferMode [tree] ← "port"
;
for TransferMode.signal: AbstractProduction [ ]
let MakeTransferMode [tree] ← "signal"
;
for TransferMode.error: AbstractProduction [ ]
let MakeTransferMode [tree] ← "error"
;
for TransferMode.process: AbstractProduction [ ]
let MakeTransferMode [tree] ← "process"
;
for TransferMode.program: AbstractProduction [ ]
let MakeTransferMode [tree] ← "program"
;
Arguments
for Arguments: AbstractProduction [ ParameterList.input, ParameterList.output ]
let MakeArgumentLists [tree, localContext, paintRecords, cs] ← <localContext2, frozenInputlist, frozenOutputList>
where frozenOutputList ← FreezeFieldList[outputFieldList]
where <localContext2, outputFieldList> ←
MakeFieldList [ParameterList.output, localContext1, paintRecords, cs]
where frozenInputlist ← FreezeFieldList[inputFieldList]
where <localContext1, inputFieldList> ←
MakeFieldList [ParameterList.output, localContext, paintRecords, cs]
;
Default
for Default.empty: AbstractProduction [ ]
let GetDefaultExpVal [tree] ← DefaultExpVal ["", MakeDummy["Default.empty"]]
;
for Default.gets: AbstractProduction [ ]
let GetDefaultExpVal [tree] ← DefaultExpVal ["←", MakeDummy["Default.gets"]]
;
for Default.getsexp: AbstractProduction [ Exp ]
let GetDefaultExpVal [tree] ← DefaultExpVal ["𡤎", instance]
where instance ← MakeDummy["Default.getsexp"]
where instance ← CompileExpression[...]
;
for Default.getstrash: AbstractProduction [ ]
let GetDefaultExpVal [tree] ← DefaultExpVal ["←TRASH", MakeDummy["Default.getstrash"]]
;
for Default.getsexportrash: AbstractProduction [ Exp ]
let GetDefaultExpVal [tree] ← DefaultExpVal ["𡤎|TRASH", instance]
where instance ← MakeDummy["Default.getsexportrash"]
where instance ← CompileExpression[...]
;
Packed
for Packed.yes: AbstractProduction [ ]
let IsKeywordPresent [tree] ← True []
;
for Packed.no: AbstractProduction [ ]
let IsKeywordPresent [tree] ← False []
;
Monitored
for Monitored.yes: AbstractProduction [ ]
let IsKeywordPresent [tree] ← True []
;
for Monitored.no: AbstractProduction [ ]
let IsKeywordPresent [tree] ← False []
;
MachineDependent
for MachineDependent.yes: AbstractProduction [ ]
let IsKeywordPresent [tree] ← True []
;
for MachineDependent.no: AbstractProduction [ ]
let IsKeywordPresent [tree] ← False []
;
Ordered
for Ordered.yes: AbstractProduction [ ]
let IsKeywordPresent [tree] ← True []
;
for Ordered.no: AbstractProduction [ ]
let IsKeywordPresent [tree] ← False []
;
Base
for Base.yes: AbstractProduction [ ]
let IsKeywordPresent [tree] ← True []
;
for Base.no: AbstractProduction [ ]
let IsKeywordPresent [tree] ← False []
;
Cedar
for Cedar.yes: AbstractProduction [ ]
let IsKeywordPresent [tree] ← True []
;
for Cedar.no: AbstractProduction [ ]
let IsKeywordPresent [tree] ← False []
;
Safe
for Safe.yes: AbstractProduction [ ]
let IsKeywordPresent [tree] ← True []
;
for Safe.no: AbstractProduction [ ]
let IsKeywordPresent [tree] ← False []
;
for Safe.empty: AbstractProduction [ ]
let IsKeywordPresent [tree] ← False []
;
ignoring safety default till we have flags.
Uncounted
for Uncounted.yes: AbstractProduction [ ]
let IsKeywordPresent [tree] ← True []
;
for Uncounted.no: AbstractProduction [ ]
let IsKeywordPresent [tree] ← False []
;
ReadOnly
for ReadOnly.yes: AbstractProduction [ ]
let IsKeywordPresent [tree] ← True []
;
for ReadOnly.no: AbstractProduction [ ]
let IsKeywordPresent [tree] ← False []
;
Inline
for Inline.yes: AbstractProduction [ ]
let IsKeywordPresent [tree] ← True []
;
for Inline.no: AbstractProduction [ ]
let IsKeywordPresent [tree] ← False []
;
End.