Include [SaffronAG, SaffronTreeDecls, SaffronBaseDecls, SaffronProgramGraphDecls];

SaffronMakeType1: Module = Begin
for Top.modulep:	AbstractProduction [ ModuleP ]
let DoTop[tree, fileName, env, cs] _ MakeEnvironment [ModuleP, fileName, env, cs]
;
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[]]
;
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]
;
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] 
;

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]
;
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"
;
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"
;

End;

SaffronMakeType2: Module = Begin
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 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]
;
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]
;
for TypeId.id:	AbstractProduction [ Id ]
let MakeType[tree, localContext, paintRecords, cs] _ CreateIdentifierTGN[localContext, Id]
let LookupTypeId[tree, localContext] _ CreateIdentifierTGN[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]
;
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]
;
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]
;
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], ")"]
;
for Bounds:	AbstractProduction [ Exp.lower, Exp.upper ]
let GetLowerAndUpper [tree] _ <MakeUnparsedValue[Exp.lower], MakeUnparsedValue [Exp.upper]>
;
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]
;
for OptInterval.absent:	AbstractProduction [ ]
let GetBoundsVal [tree] _ NullBounds []
;
for OptInterval.present:	AbstractProduction [ Interval ]
let GetBoundsVal [tree] _ GetBoundsVal [Interval]
;
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"
;
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]
;
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 ["_e", instance]
where instance _ MakeDummy["Default.getsexp"]
;
for Default.getstrash:	AbstractProduction [ ]
let GetDefaultExpVal [tree] _ DefaultExpVal ["_TRASH", MakeDummy["Default.getstrash"]]
;
for Default.getsexportrash:	AbstractProduction [ Exp ]
let GetDefaultExpVal [tree] _ DefaultExpVal ["_e|TRASH", instance]
where instance _ MakeDummy["Default.getsexportrash"]
;
for Packed.yes:	AbstractProduction [ ]
let IsKeywordPresent [tree] _ True []
;
for Packed.no:	AbstractProduction [ ]
let IsKeywordPresent [tree] _ False []
;
for Monitored.yes:	AbstractProduction [ ]
let IsKeywordPresent [tree] _ True []
;
for Monitored.no:	AbstractProduction [ ]
let IsKeywordPresent [tree] _ False []
;
for MachineDependent.yes:	AbstractProduction [ ]
let IsKeywordPresent [tree] _ True []
;
for MachineDependent.no:	AbstractProduction [ ]
let IsKeywordPresent [tree] _ False []
;
for Ordered.yes:	AbstractProduction [ ]
let IsKeywordPresent [tree] _ True []
;
for Ordered.no:	AbstractProduction [ ]
let IsKeywordPresent [tree] _ False []
;
for Base.yes:	AbstractProduction [ ]
let IsKeywordPresent [tree] _ True []
;
for Base.no:	AbstractProduction [ ]
let IsKeywordPresent [tree] _ False []
;
for Cedar.yes:	AbstractProduction [ ]
let IsKeywordPresent [tree] _ True []
;
for Cedar.no:	AbstractProduction [ ]
let IsKeywordPresent [tree] _ False []
;
for Safe.yes:	AbstractProduction [ ]
let IsKeywordPresent [tree] _ True []
;
for Safe.no:	AbstractProduction [ ]
let IsKeywordPresent [tree] _ False []
;
for Safe.empty:	AbstractProduction [ ]
let IsKeywordPresent [tree] _ False []
;
for Uncounted.yes:	AbstractProduction [ ]
let IsKeywordPresent [tree] _ True []
;
for Uncounted.no:	AbstractProduction [ ]
let IsKeywordPresent [tree] _ False []
;
for ReadOnly.yes:	AbstractProduction [ ]
let IsKeywordPresent [tree] _ True []
;
for ReadOnly.no:	AbstractProduction [ ]
let IsKeywordPresent [tree] _ False []
;

for Inline.yes:	AbstractProduction [ ]
let IsKeywordPresent [tree] _ True []
;
for Inline.no:	AbstractProduction [ ]
let IsKeywordPresent [tree] _ False []
;

End.

	*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


need DoTop to take MakeType of the TypeExp 
Top
ModuleP
Directory
IncludeItem
Using
DefHead
ProgHead
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[]]
;
TypeExp
then Make up a Tag type by an enumeration of the VariantList types
TypeApply
TypeId
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 ]
let MakeType[tree, localContext, paintRecords, cs] _ LookupTypeId [tree, localContext]
let LookupTypeId [tree, localContext] _
CreateSpecianatedTGNUsingId [localContext1, tgn, Id]
where <localContext1, tgn> _ LookupTypeId [TypeId, localContext]
OptType
Subrange
Interval
Bounds
PointerType
OptInterval
TransferMode
Arguments
Default
where instance _ CompileExpression[...]
where instance _ CompileExpression[...]
Packed
Monitored
MachineDependent
Ordered
Base
Cedar
Safe
ignoring safety default till we have flags.
Uncounted
ReadOnly
Inline

Κ˜˜™Icode™BK™,K™%™*Kš
œR™R—K™:K™—J˜JšΠizœK˜RK™Kš
Οn+™+K˜šžœœ˜ 
headš
Πnz™
codetabšœ
Οbœœ˜/MšœN˜QMš
œ
˜
——š
Ÿ™š 
œœ:˜^šœ1˜4MšœU˜ZMšœ:˜?Mšœ0˜5šœ'˜,Mš
œ4˜4Mšœ˜$—Mšœ0˜5Mšœ-˜2Mšœ˜ šœ„
˜‰
Mšœ;˜@—šœC˜HMšœ ˜%—šœG˜LMšœ˜!Mšœ8˜=——Mš
œ
˜
M˜—š œœ2˜Ušœ1˜4MšœM˜RMšœP˜UMšœE˜JMšœ0˜5Mšœ-˜2Mšœ˜ šœ‰
˜Ž
Mš
œ>˜>—šœB˜GMšœ ˜%—šœG˜LMšœ˜!Mšœ8˜=——M˜
——š
Ÿ	™	š œœ˜+šœ=˜@M˜Mš
œ!˜!Mš
œ˜—M˜
M˜—š œœ˜AšœL˜OMšœ)˜.MšœF˜KMšœP˜U—Mš
œ
˜
——š
Ÿ™šœ
žœœ-˜Pšœ=˜@MšœJ˜OMšœ ˜%Mšœ$˜)MšœP˜UMšœ˜Mšœ"˜'Mšœ@˜EMšœ˜ šœ˜šœ#˜%Mšœ˜šœ/˜3Mšœ0˜5———Mšœ+˜0—M˜
M˜——š
Ÿ™š œœ˜3šœ%˜(Mš
œ*˜*—Mš
œ
˜
—š œœ˜)šœ%˜(Mš
œ"˜"—Mš
œ
˜
—š œœ˜.šœ$˜'Mš
œ%˜%—Mš
œ
˜
——š
Ÿ™š 
Πbnœœ$˜Cšœ*˜-š
œ5˜5Mšœ%˜*Mšœ(˜-Mšœ%˜*——M˜
——š
Ÿ™š 
žœœ3˜Sšœ/˜2š
œR˜RšœM˜RMšœ˜#MšœJ˜OMšœΟc
˜&—Mšœ%˜*Mšœ(˜-Mšœ(˜-Mšœ%˜*——˜
M˜———š
Ÿ™šœ
ž	œ™5Mšœ7™:š
œ_™_Kš
œY™YKšœ&™+—Kšœ1™4™@Kš
œZ™ZKšœ1™6šœ3™8K™E—KšœU™ZKšœ0™5—Mš
œ
™
——M˜M˜—˜ š
Ÿ™šœ
 œœ)˜OšœI˜LMšœr˜wMšœ.˜3MšœV˜[Mšœœœ$œ!˜|Mšœ7˜<Mšœ)˜.—Mš
œ
˜
—šœ
 
œœ˜:šœ}˜€
Mšœ,˜1šœ ˜%šœ˜M™BMšœ.˜2Mšœ0˜4——Mšœa˜fMšœZ˜_—š
œ
˜
M˜——šœ
 œœ˜Ašœ‹
˜Ž
Mšœ$˜)Mšœœœ+œ˜VMšœa˜fMšœJ˜OM˜—M˜
—šœ
 œœ"˜Fšœo˜rMšœ7˜<—M˜
M˜—šœ
 œœ˜9šœg˜jKšœQ˜VKšœ'˜,—Kš
œ
˜
K˜—šœ
 œœ
˜3šœl˜oMšœ˜Mšœ1˜6Kšœ'˜,—Mš
œ
˜
—šœ
 œœ˜2šœm˜pMšœ˜Mšœ1˜6Kšœ˜—Mš
œ
˜
—šœ
 œœ˜1šœ2˜5Mš
œ2˜2—Mš
œ˜—šœ
 œœ
˜5šœ1˜4Mš
œ2˜2—š
œ
˜
M˜——šœ
 œœ˜Fšœ˜‚
Mšœ%˜*Mšœ˜$Mšœm˜r—š
œ
˜
M˜——šœ
 œœ˜/šœS˜VMšœJ˜O—š
œ
˜
M˜——šœ
 œœ˜:šœe˜hKšœN˜SKšœ'˜,—J˜
J˜—šœ
 
œœ˜Bšœt˜wMšœO˜TMšœO˜TMšœ#˜(—š
œ
˜
M˜——šœ
 œœ˜@šœp˜sMšœJ˜OKšœ'˜,—š
œ
˜
M˜——šœ
 œœ"˜Jšœ
˜„
Mšœl˜qMšœ/˜4Mšœ˜$—Mš
œ
˜
M˜—šœ
 œœ˜<šœl˜oMšœK˜PMšœ?˜D—š
œ
˜
M˜——šœ
 œœ˜2Mšœt˜wš
œ
˜
M˜——šœ
 œœ˜0šœT˜WMšœJ˜O—š
œ
˜
M˜——šœ
 
œœ˜,šœn˜qMšœ1˜6—š
œ
˜
M˜——šœ
 œœ˜;šœ9˜<Mšœ˜Mšœ%˜*Mšœ'˜,—š
œ
˜
M˜——šœ
 œœ˜7Mšœp˜sMš
œ
˜
——š
Ÿ	™	šœ
 
œœ˜5šœ2˜5Mš
œI˜IMšœ;˜@—Mš
œ
˜
—šœ
 œœ˜@šœ2˜5Mš
œI˜IMšœL˜Q—Mš
œ
˜
—šœ
 œœ˜;šœ2˜5Mš
œ4˜4MšœL˜Q—M˜
——š
Ÿ™šœ
 	œœ˜(MšœW˜ZMšœI˜LM˜MšœIœ4œ*™΄
Mšœ;œ4œ*™¦
Mš
œ
˜
M˜—šœ
 œœ˜7MšœS˜VšœX˜[Mšœ;˜@—MšœS™Všœ$™'Mš
œ4™4Mšœ;™@—Mš
œ
˜
——š
Οz™šœ
 œœ˜*MšœIœ4œ˜Ÿ
Mš
œ
˜
—šœ
 œœ˜3Mšœn˜qMš
œ
˜
——š
£™š œœ˜;šœ1˜4Mš
œ.˜.Mšœ;˜@Mšœ!˜&——Mš
œ
˜
š œœ
˜5šœ_˜bMšœ˜Mšœ!˜&—Mš
œ
˜
——š
Ÿ™š œœ˜.MšœI˜LMš
œ
˜
—š œœ˜.MšœI˜LMš
œ
˜
—š œœ˜.MšœI˜LMš
œ
˜
—š œœ˜.MšœI˜LMš
œ
˜
——š
Ÿ™šœ
žœœ˜7KšœX˜[K˜
——š
£™š œœ˜?šœc˜fKšœ$˜)Kšœ˜Kšœ˜Kš
œ6˜6—Kš
œ
˜
—š œœ#˜Pšœc˜fKšœ$˜)Kšœ'˜,KšœJ˜O—Mš
œ
˜
——š
Ÿ™š œœ˜.Mšœ$˜'Mš
œ
˜
—š œœ
˜8Mšœ.˜1Mš
œ
˜
——š
£™š œœ˜-Mšœ!˜$Mš
œ
˜
—š œœ˜-Mš
œ$˜$Mš
œ
˜
—š œœ˜/Mš
œ&˜&Mš
œ
˜
—š œœ˜.Mš
œ%˜%Mš
œ
˜
—š œœ˜0Mš
œ'˜'Mš
œ
˜
—š œœ˜0Mš
œ'˜'Mš
œ
˜
——š
£	™	š 
ž	œœ.˜Ošœn˜qKšœ4˜9š
œ)˜)Kš
œE˜E—Kšœ2˜7š
œ(˜(Kš
œD˜D——Kš
œ
˜
——š
Πbz™š œœ˜)MšœI˜LMš
œ
˜
—š 
œœ˜(MšœI˜LMš
œ
˜
—š œœ˜/šœ9˜<Mšœ
Οtœ₯
˜-Mšœ
₯!™'—Mš
œ
˜
—š œœ˜-MšœS˜VMš
œ
˜
—š œœ˜6šœ?˜BMšœ
₯œ"₯
˜4Mšœ
₯!™'—Mš
œ
˜
——š
Ÿ™šœ
 
œœ˜&Mšœ"˜%Mš
œ
˜
—šœ
 	œœ˜%Mšœ#˜&Mš
œ
˜
——š
€	™	šœ
 
œœ˜)Mšœ"˜%Mš
œ
˜
—šœ
 œœ˜(Mšœ#˜&Mš
œ
˜
——š
€™šœ
 œœ˜0Mšœ"˜%Mš
œ
˜
—šœ
 œœ˜/Mšœ#˜&Mš
œ
˜
——š
Ÿ™šœ
 œœ˜'Mšœ"˜%Mš
œ
˜
—šœ
 
œœ˜&Mšœ#˜&Mš
œ
˜
——š
Ÿ™šœ
 œœ˜$Mšœ"˜%Mš
œ
˜
—šœ
 œœ˜#Mšœ#˜&Mš
œ
˜
——š
Ÿ™šœ œœ˜%Mšœ"˜%Mš
œ
˜
—šœ œœ˜$Mšœ#˜&Mš
œ
˜
——š
Ÿ™šœ
 œœ˜$Mšœ"˜%Mš
œ
˜
—šœ
 œœ˜#Mšœ#˜&Mš
œ
˜
—šœ
 
œœ˜&Mšœ#˜&Mš
œ
˜
—M™+—š
Ÿ	™	šœ
 
œœ˜)Mšœ"˜%Mš
œ
˜
—šœ
 œœ˜(Mšœ#˜&Mš
œ
˜
——š
Ÿ™šœ
 œœ˜(Mšœ"˜%Mš
œ
˜
—šœ
 œœ˜'Mšœ#˜&Mš
œ
˜
M˜——š
Ÿ™šœ
 
œœ˜&Mšœ"˜%Mš
œ
˜
—šœ
 	œœ˜%Mšœ#˜&Mš
œ
˜
M˜——Kšœ
˜K˜—K™—…—I¨ej