DIRECTORY
AMTypes USING [Error],
Basics USING [LowHalf],
BasicTime USING [FromNSTime],
BcdDefs USING [BcdBase, FTSelf, SGIndex, SGHandle, SGNull, VersionID],
BcdOps USING [ProcessSegs],
ConvertUnsafe USING [SubString, SubStringToRope],
FS USING [Error, GetInfo, nullOpenFile, OpenFile, Read, WordsForPages],
IO USING [PutFR],
LupineSymbolTable USING [
ComponentProcedure,
DirectoryProcedure, FullTypeName, GMT,
Index, InterfaceInfo, OpenErrorCode,
ParamPassingMethod, STBase,
String, StringNIL, SymbolHandle, SymbolID,
TransferProcedure, TransferTypes, TypeHandle,
TypeInfo, VariantProcedure, VersionStamp, Words ],
Rope USING[ Fetch, Find, Length, Substr ],
RTSymbolDefs USING[ SymbolTableBase, SymbolIdIndex ],
RTSymbolOps USING[ EnumerateCtxIseis, NullISEI, NullCtx, ISECtx ],
RTSymbols USING [AcquireSTBFromSGI, ReleaseSTB ],
Symbols USING [
BodyRecord, BTIndex,
codeANY, codeCHAR, codeINT,
CSEIndex, CTXIndex, CTXRecord,
HTIndex, HTNull, ISEIndex, ISENull, lZ,
MDIndex, OwnMdi,
RecordSEIndex, RecordSENull, SEIndex, SENull, SERecord,
TransferMode, TypeClass, typeTYPE, WordLength ],
SymbolTable USING [Base],
Table USING [Base, Limit],
VM USING [Allocate, Free, Interval, nullInterval, AddressForPageNumber, PagesForWords];


LupineSymbolTableImpl: PROGRAM
IMPORTS AMTypes, Basics, BasicTime, BcdOps, ConvertUnsafe, FS, IO, Rope, RTSymbolOps, RTSymbols, VM
EXPORTS LupineSymbolTable
SHARES LupineSymbolTable
= BEGIN OPEN Symbols, ST: LupineSymbolTable;


STBase: TYPE = ST.STBase;

String: TYPE = ST.String;

AllocSubString: TYPE = ConvertUnsafe.SubString _
[base: NIL, offset: NULL, length: NULL] | NULL;




rootSTB: STBase _ NIL;
rootFile: FS.OpenFile _ FS.nullOpenFile;
rootSpace: VM.Interval _ VM.nullInterval;
rootBcd: BcdDefs.BcdBase _ NIL;


OpenInterface: PUBLIC PROCEDURE [
interfaceFilename: String,
interfaceCapability: FS.OpenFile ] =
BEGIN
ENABLE UNWIND => CloseInterface[];
symbols: BcdDefs.SGIndex;
rootFile _ interfaceCapability;
[rootSpace, rootBcd] _ LoadUpBcd[
interfaceCapability
! LoadVersionError => ERROR OpenError[interfaceFilename, badFileVersion] ];
IF (symbols _ GetOwnSymbolsSGI[rootBcd]) = BcdDefs.SGNull
THEN ERROR OpenError[interfaceFilename, badFileFormat];
rootSTB _ NARROW
[RTSymbols.AcquireSTBFromSGI[
bcd: rootBcd,
sgi: symbols 
! AMTypes.Error =>
BEGIN
IF reason = noSymbols
THEN ERROR OpenError[msg, badFileName] ;
END ],
RTSymbolDefs.SymbolTableBase.x].e;
IF ~rootBcd.definitions
THEN ERROR OpenError[interfaceFilename, notInterfaceModule];
InitializeBuiltinTypes[standardStb: rootSTB];
END;

OpenError: PUBLIC ERROR [fileOrModuleName: String, why: ST.OpenErrorCode]
= CODE;

CloseInterface: PUBLIC PROCEDURE = 
BEGIN
IF rootSTB # NIL THEN RTSymbols.ReleaseSTB[[x[rootSTB]]];
IF rootSpace # VM.nullInterval THEN VM.Free[rootSpace];
rootSTB _ NIL;
rootFile _ FS.nullOpenFile;
rootSpace _ VM.nullInterval;
rootBcd _ NIL;
END;

GetInterfaceInfo: PUBLIC PROCEDURE
RETURNS [
contents: ST.InterfaceInfo,
moduleName, fileName: String,
moduleVersion: ST.VersionStamp,
moduleCreateTime, sourceCreateTime: ST.GMT ] =
BEGIN
CheckContents: ContextProcedure =
BEGIN
SELECT itemStb.TypeForm[SymType[itemStb,itemIsei]] FROM
transfer =>
contents.transfers[XferModeToTransferType[
itemStb.XferMode[SymType[itemStb,itemIsei]]] ] _ TRUE;
opaque => contents.types _ TRUE;
ENDCASE => IF ~itemStb.seb[itemIsei].constant THEN contents.variables _ TRUE;
END;
contents _ [];  -- Initialize contents.
[] _ EnumerateContext[
ctxStb: rootSTB, ctx: rootSTB.stHandle.outerCtx, ctxProc: CheckContents];
[moduleName, fileName] _ GetModuleInfo[ rootSTB, OwnMdi];
moduleVersion _ rootSTB.stHandle.version;
moduleCreateTime _
FS.GetInfo[rootFile ! FS.Error => CONTINUE].created;
sourceCreateTime _ BasicTime.FromNSTime[rootSTB.stHandle.sourceVersion.time];
END;

VersionStampString: PUBLIC PROCEDURE [stamp: ST.VersionStamp]
RETURNS [stampString: String] =
BEGIN
stampString _ IO.PutFR["%b#%b#%b",
[integer[stamp.net]],
[integer[stamp.host]],
[cardinal[stamp.time]]
];
END;

XferModeToTransferType: PACKED ARRAY TransferMode OF ST.TransferTypes = [
proc: Procedure, error: Error, signal: Signal,
port: Port, program: Program, process: Process, none: Other  ];

GetModuleInfo: PROCEDURE [
stBase: STBase, module: MDIndex] RETURNS[moduleName, fileName: String] =
--INLINE-- BEGIN
moduleName _ HtiString[stBase, stBase.mdb[module].moduleId];
fileName _ HtiString[stBase, stBase.mdb[module].fileId];
END;

LoadVersionError: ERROR = CODE;

LoadUpBcd: PROC [bcdFile: FS.OpenFile]
RETURNS [bcdSpace: VM.Interval_VM.nullInterval, bcd: BcdDefs.BcdBase] =
BEGIN
bcdSpaceBase: INT = 0;
pages: CARDINAL;
BEGIN ENABLE UNWIND => IF bcdSpace#VM.nullInterval THEN VM.Free[bcdSpace];
bcdSpace _ VM.Allocate[VM.PagesForWords[FS.WordsForPages[1]]];
bcd _ VM.AddressForPageNumber[bcdSpace.page];
FS.Read[file: bcdFile, from: bcdSpaceBase, nPages: 1, to: bcd];
IF bcd.versionIdent # BcdDefs.VersionID THEN ERROR LoadVersionError;
pages _ bcd.nPages;
IF pages > 1 THEN
BEGIN
VM.Free[bcdSpace];
bcdSpace _ VM.Allocate[VM.PagesForWords[FS.WordsForPages[pages]]];
bcd _ VM.AddressForPageNumber[bcdSpace.page];
FS.Read[file: bcdFile, from: bcdSpaceBase, nPages: pages, to: bcd];
END;
END;
END;

GetOwnSymbolsSGI: PROC [ownBcd: BcdDefs.BcdBase]
RETURNS [ownSGI: BcdDefs.SGIndex] =
BEGIN OPEN BcdOps, BcdDefs;
CheckSeg: PROC [sgh: SGHandle, sgi: SGIndex]
RETURNS [--stop:-- BOOLEAN] =
{RETURN[sgh.class=symbols AND sgh.file=FTSelf]};
ownSGI _ ProcessSegs[bcd: ownBcd, proc: CheckSeg].sgi;
END;


EnumerateDirectory: PUBLIC PROCEDURE [proc: ST.DirectoryProcedure]
RETURNS [stopped: BOOLEAN_FALSE] =
BEGIN
DoDirItem: ContextProcedure =
BEGIN OPEN itemStb;
moduleName: String;
fileName: String;
imported: BOOLEAN;
defContext: CTXIndex;
module: MDIndex;
WITH seb[UnderType[seb[itemIsei].idType]] SELECT FROM
definition => defContext _ defCtx;
transfer => defContext _
bb[LOOPHOLE[seb[itemIsei].idInfo, BTIndex]].localCtx;
ENDCASE => ERROR;
WITH ctx: ctxb[defContext] SELECT FROM
simple => {module _ OwnMdi; imported _ FALSE};
included => {module _ ctx.module; imported _ FALSE};
imported => {module _ ctxb[ctx.includeLink].module; imported_TRUE};
ENDCASE => ERROR;
[moduleName, fileName] _ GetModuleInfo[itemStb, module];
{ index: INT = fileName.Find["."];
IF index >= 0 THEN fileName _ fileName.Substr[start: 0, len: index] };
RETURN[stop: proc[moduleName: moduleName, fileName: fileName,
imported: imported, directoryIndex: itemIndex].stop];
END;
stopped _ EnumerateContext[
ctxStb: rootSTB, ctx: rootSTB.stHandle.directoryCtx, ctxProc: DoDirItem];
END;

EnumerateTransfers: PUBLIC PROCEDURE [
proc: ST.TransferProcedure,
all, procs, signals, errors: BOOLEAN _ FALSE ]
RETURNS [stopped: BOOLEAN_FALSE] =
BEGIN
index: ST.Index _ 0;
DoTransfer: ContextProcedure =
BEGIN
InlineOrMachineCode: PROCEDURE [transfer: ISEIndex] RETURNS [BOOLEAN] =
INLINE {RETURN[itemStb.seb[transfer].constant]};
topType: SEIndex = SymType[itemStb, itemIsei];
type: CSEIndex = itemStb.UnderType[topType];
WITH xfer: itemStb.seb[type] SELECT FROM
transfer =>
SELECT xfer.mode FROM
proc =>
IF (all OR procs) AND ~InlineOrMachineCode[itemIsei] THEN
stop _ proc[
transfer: [itemStb, itemIsei],
transferType: [itemStb, topType], kind: Procedure,
argumentRecordType: [itemStb, xfer.typeIn],
resultRecordType: [itemStb, xfer.typeOut],
transferIndex: (index _ index+1) ];
error =>
IF all OR errors THEN
stop _ proc[
transfer: [itemStb, itemIsei],
transferType: [itemStb, topType], kind: Error,
argumentRecordType: [itemStb, xfer.typeIn],
resultRecordType: [itemStb, xfer.typeOut],
transferIndex: (index _ index+1) ];
signal =>
IF all OR signals THEN
stop _ proc[
transfer: [itemStb, itemIsei],
transferType: [itemStb, topType], kind: Signal,
argumentRecordType: [itemStb, xfer.typeIn],
resultRecordType: [itemStb, xfer.typeOut],
transferIndex: (index _ index+1) ];
ENDCASE => 
IF all THEN
stop _ proc[
transfer: [itemStb, itemIsei],
transferType: [itemStb, topType],
kind: XferModeToTransferType[xfer.mode],
argumentRecordType: [itemStb, xfer.typeIn],
resultRecordType: [itemStb, xfer.typeOut],
transferIndex: (index _ index+1) ];
ENDCASE => NULL;
END;
stopped _ EnumerateContext[
ctxStb: rootSTB, ctx: rootSTB.stHandle.outerCtx, ctxProc: DoTransfer];
END;

EnumerateRecord: PUBLIC PROCEDURE [
recordType: ST.TypeHandle, proc: ST.ComponentProcedure]
RETURNS [stopped: BOOLEAN_FALSE] =
BEGIN
recStb: STBase = recordType.base;
IF recordType.type = SENull THEN RETURN;
WITH rec: recStb.seb[recStb.UnderType[recordType.type]] SELECT FROM
record =>
BEGIN
DoComponent: ContextProcedure =
BEGIN
RETURN[
stop: proc[
component: [itemStb, itemIsei],
componentType: [itemStb, SymType[itemStb, itemIsei]],
componentIndex: itemIndex ].stop  ];
END;
stopped _ EnumerateContext[
ctxStb: recStb, ctx: rec.fieldCtx, ctxProc: DoComponent]
END;
ENDCASE => ERROR;
END;

EnumerateVariants: PUBLIC PROCEDURE [
variantPartType: ST.TypeHandle, proc: ST.VariantProcedure]
RETURNS [stopped: BOOLEAN_FALSE] =
BEGIN
varStb: STBase = variantPartType.base;
IF variantPartType.type = SENull THEN ERROR;
WITH var: varStb.seb[varStb.UnderType[variantPartType.type]] SELECT FROM
union =>
BEGIN
DoVariant: ContextProcedure =
BEGIN
RETURN[
stop: proc[
variantTag: [itemStb, itemIsei],
variantNumber: itemStb.seb[itemIsei].idValue,
variantRecordType: [itemStb, itemStb.seb[itemIsei].idInfo],
variantIndex: itemIndex ].stop  ];
END;
stopped _ EnumerateContext[
ctxStb: varStb, ctx: var.caseCtx, ctxProc: DoVariant];
END;
ENDCASE => ERROR;
END;

ContextProcedure: TYPE = PROCEDURE [
itemStb: SymbolTable.Base, itemIsei: ISEIndex, itemIndex: ST.Index]
RETURNS [stop: BOOLEAN_FALSE];

EnumerateContext: PROCEDURE [
ctxStb: STBase,
ctx: CTXIndex,
ctxProc: ContextProcedure ]
RETURNS [stopped: BOOLEAN_FALSE] =
BEGIN
item: ST.Index _ 0;
SkipRecordPackingInfo: PROCEDURE [stb: RTSymbolDefs.SymbolTableBase,
isei: RTSymbolDefs.SymbolIdIndex]
RETURNS [--stop:-- BOOLEAN] =
BEGIN
RETURN[IF item=0 AND NOT RTSymbolOps.NullISEI[isei]
AND RTSymbolOps.NullCtx[RTSymbolOps.ISECtx[stb, isei]]
THEN FALSE
ELSE ctxProc[itemStb: NARROW[stb, RTSymbolDefs.SymbolTableBase.x].e,
itemIsei: NARROW[isei, RTSymbolDefs.SymbolIdIndex.x].e,
itemIndex: (item_item+1) ].stop  ];
END;
stopped _ RTSymbolOps.EnumerateCtxIseis[
stb: [x[ctxStb]], ctx: [x[ctx]], proc: SkipRecordPackingInfo
!
AMTypes.Error =>
BEGIN
IF reason = noSymbols THEN ERROR OpenError[msg, badFileName];
END  ];
END;


SymbolName: PUBLIC PROCEDURE [symbol: ST.SymbolHandle]
RETURNS [String] =
BEGIN
stb: STBase = symbol.base;
IF IsAnonymous[symbol]
THEN RETURN[NIL]
ELSE RETURN[IseiString[stb, symbol.symbol]]
END;

IsAnonymous: PUBLIC PROCEDURE [symbol: ST.SymbolHandle]
RETURNS [yes: BOOLEAN] =
{RETURN[symbol.base.seb[symbol.symbol].hash = HTNull]};

SymbolType: PUBLIC PROCEDURE [symbol: ST.SymbolHandle]
RETURNS [type: ST.TypeHandle] = {
RETURN[ST.TypeHandle[symbol.base, SymType[symbol.base, symbol.symbol]]]};

SymType: PROCEDURE [stb: STBase, isei: ISEIndex] RETURNS [SEIndex] =
INLINE BEGIN
RETURN[ IF stb.seb[isei].idType = SENull
THEN ERROR ELSE stb.seb[isei].idType];
END;

SymbolUniqueID: PUBLIC PROCEDURE [symbol: ST.SymbolHandle]
RETURNS [uniqueID: ST.SymbolID] = {
RETURN[LOOPHOLE[@symbol.base.seb[symbol.symbol]]]};

SearchTypeDefinition: PUBLIC PROCEDURE [
rootDef: ST.TypeHandle,
candidateDefs: LONG DESCRIPTOR FOR READONLY ARRAY OF ST.FullTypeName ]
RETURNS [indexOfMatch: INTEGER _ -1 --No match--] =
BEGIN
thisBase: STBase = rootDef.base;
thisType: SEIndex _ rootDef.type;
thisName, thisModule: AllocSubString;
DO
WITH sei: thisBase.seb[thisType] SELECT FROM
id =>
BEGIN
thisName _ IseiSubString[
stb: thisBase,
isei: ISEI[thisType] ];
thisModule _ HtiSubString[
stb: thisBase,
hti: ModuleHtiOfTypeName[thisBase, ISEI[thisType]]];
FOR type: INTEGER IN [0..LENGTH[candidateDefs]) DO
IF StringEqualSubString[candidateDefs[type].name, thisName] AND
StringEqualSubString[candidateDefs[type].module, thisModule]
THEN RETURN[type];
REPEAT
FINISHED => thisType _ sei.idInfo;
ENDLOOP;
END;
cons =>
WITH csei: sei SELECT FROM
long => thisType _ csei.rangeType;
ENDCASE => RETURN;
ENDCASE => ERROR; 
ENDLOOP;
END;

Size: PUBLIC PROCEDURE [type: ST.TypeHandle] RETURNS [size: ST.Words] =
BEGIN RETURN[type.base.WordsForType[type.type]]; END;

ComputeArraySize: PUBLIC PROCEDURE [
index, elements: ST.TypeHandle, packed: BOOLEAN ]
RETURNS [--size:-- ST.Words] =
BEGIN
bits: LONG CARDINAL;
cardinality: ST.Words = WITH indexInfo: GetTypeInfo[type: index] SELECT FROM
Basic => indexInfo.cardinality,
ENDCASE => ERROR;
RETURN[
IF (bits_elements.base.BitsPerElement[elements.type, packed]) < WordLength
THEN (cardinality+(WordLength/bits-1)) / (WordLength/bits)
ELSE cardinality * ((bits+WordLength-1)/WordLength) ];
END;


ModuleHtiOfTypeName: PROCEDURE [stBase: STBase, typeName: ISEIndex]
RETURNS [--moduleHti:-- HTIndex] =
--INLINE-- BEGIN
RETURN[stBase.mdb[ModuleOfTypeName[stBase, typeName]].moduleId]
END;

ModuleOfTypeName: PROCEDURE [stBase: STBase, typeName: ISEIndex]
RETURNS [module: MDIndex] =
BEGIN
typeNameCtx: CTXRecord = stBase.ctxb[stBase.seb[typeName].idCtx];
WITH ctx: typeNameCtx SELECT FROM
simple => module _ OwnMdi;
included => module _ ctx.module;
imported => module _ stBase.ctxb[ctx.includeLink].module;
ENDCASE => ERROR;
END;

HtiSubString: PROCEDURE [stb: STBase, hti: HTIndex]
RETURNS[ConvertUnsafe.SubString] =
INLINE BEGIN  -- hti=HTNull is OK; returns null substring.
RETURN[stb.SubStringForName[hti]];
END;

HtiString: PROCEDURE [stb: STBase, hti: HTIndex] RETURNS[String] =
BEGIN
RETURN[ConvertUnsafe.SubStringToRope[HtiSubString[stb, hti]]]
END;

ISEI: PROCEDURE [sei: SEIndex] RETURNS [--isei:-- ISEIndex] =
INLINE BEGIN RETURN[LOOPHOLE[sei]] END;

IseiSubString: PROCEDURE [stb: STBase, isei: ISEIndex]
RETURNS[ConvertUnsafe.SubString] =
--INLINE-- BEGIN
RETURN[HtiSubString[stb,
(IF isei=ISENull THEN HTNull ELSE stb.seb[isei].hash)] ];
END;

IseiString: PROCEDURE [stb: STBase, isei: ISEIndex]
RETURNS[ String] =
INLINE BEGIN
RETURN[HtiString[stb,
(IF isei=ISENull THEN HTNull ELSE stb.seb[isei].hash)]]
END;

StringEqualSubString: PROCEDURE [a: String, b: ConvertUnsafe.SubString]
RETURNS [--exactMatch:-- BOOLEAN] =
INLINE BEGIN
RETURN [a.Length[]=b.length AND SlowStringEqualSubString[a,b]];
END;

SlowStringEqualSubString: PROCEDURE [a: String, b: ConvertUnsafe.SubString]
RETURNS [exactMatch: BOOLEAN] =
BEGIN
IF a.Length[] # b.length THEN RETURN[FALSE];
FOR i: CARDINAL IN [0..b.length)
DO IF a.Fetch[i] # b.base[b.offset+i] THEN RETURN[FALSE] ENDLOOP;
RETURN[TRUE]
END;


GetTypeInfo: PUBLIC PROC [type: ST.TypeHandle] RETURNS [info: ST.TypeInfo_[]] =
BEGIN OPEN ST;
typeStb: STBase = type.base;
typeSei: SEIndex = type.type;
IF typeSei = SENull THEN RETURN[[self: type, info: Null[]]];
WITH typeSer: typeStb.seb[typeSei] SELECT FROM
id =>
SELECT TRUE FROM
typeSer.idType # typeTYPE => ERROR;
typeSer.idCtx = StandardTypeContext =>
SELECT typeSei FROM
UNSPECIFIEDIndex => RETURN[
[self: type,
info: Basic[
kind: Unspecified,
origin: FIRST[WORD],
cardinality: (LONG[LAST[WORD]]-FIRST[WORD]+1) ]] ];
INTEGERIndex => RETURN[
[self: type,
info: Basic[
kind: Integer,
origin: FIRST[INTEGER],
cardinality: (LONG[LAST[INTEGER]]-FIRST[INTEGER]+1) ]] ];
CARDINALIndex => RETURN[
[self: type,
info: Basic[
kind: Cardinal,
origin: FIRST[CARDINAL],
cardinality: (LONG[LAST[CARDINAL]]-FIRST[CARDINAL]+1) ]] ];
NATIndex => RETURN[
[self: type,
info: Basic[
kind: Nat,
origin: FIRST[NAT],
cardinality: (LONG[LAST[NAT]]-FIRST[NAT]+1) ]] ];
REALIndex => RETURN[
[self: type,
info: Basic[
kind: Real,
origin: 0, cardinality: 0 ]] ];
WORDIndex => RETURN[
[self: type,
info: Basic[
kind: Word,
origin: FIRST[WORD],
cardinality: (LONG[LAST[WORD]]-FIRST[WORD]+1) ]] ];
CHARACTERIndex => RETURN[
[self: type,
info: Basic[
kind: Character,
origin: LOOPHOLE[FIRST[CHARACTER], INTEGER],
cardinality: LONG[ LOOPHOLE[LAST[CHARACTER], INTEGER]
- LOOPHOLE[FIRST[CHARACTER], INTEGER]
+ 1 ] ]] ];
BOOLEANIndex => RETURN[
[self: type,
info: Basic[
kind: Boolean,
origin: LOOPHOLE[FIRST[BOOLEAN], INTEGER],
cardinality: 2 ]] ];
TEXTIndex => RETURN[[self: type, info: Text[]]];
STRINGIndex => RETURN[[self: type, info: String[]]];
StringBodyIndex => RETURN[[self: type, info: StringBody[]]];
ATOMIndex => RETURN[[self: type, info: Atom[], readonly: FALSE]];
MONITORLOCKIndex, CONDITIONIndex =>
RETURN[[self: type, info: Other[]]];
MDSZoneIndex => RETURN[
[self: type,
info: Zone[allocation: Uncounted, mdsZone: TRUE]] ];
ENDCASE =>
BEGIN 
synonymInfo: TypeInfo _ GetTypeInfo[[typeStb, typeSer.idInfo]];
synonymInfo.self _ type;
RETURN[ SELECT synonymInfo.type FROM
Basic, String, StringBody, Text, Atom, Rope, Any => synonymInfo,
ENDCASE => [self: type, info: Other[]] ];
END;
IsType[["Rope", "ROPE"], typeStb, ISEI[typeSei]] =>
RETURN[[self: type, info: Rope[], readonly: FALSE]];
ENDCASE =>
BEGIN
method: ParamPassingMethod=GetParamMethod[typeStb, ISEI[typeSei]];
symInfo: TypeInfo _ GetTypeInfo[[typeStb, typeSer.idInfo]];
symInfo.self _ type;
IF method # standard THEN symInfo.passingMethod _ method;
RETURN[symInfo];
END;
cons =>
WITH typeCser: typeSer SELECT FROM
basic, real => ERROR;  -- Should have been in StandardTypeContext.
definition => RETURN[[self: type, info: Definition[]]];
subrange => RETURN[
[self: type,
info: Basic[
kind: Subrange,
origin: typeCser.origin,
cardinality: IF typeCser.empty
THEN 0 ELSE typeCser.range+1]] ];
enumerated => RETURN[
[self: type,
info:  Basic[
kind: Enumeration,
origin: 0,
cardinality: typeCser.nValues]] ];
transfer => RETURN[
[self: type,
info:  Transfer[
kind: XferModeToTransferType[typeCser.mode],
safe: typeCser.safe,
argumentType: TypeHandle[typeStb, typeCser.typeIn],
resultType: TypeHandle[typeStb, typeCser.typeOut]]] ];
record =>
BEGIN
variantType: TypeClass _ record;
GetVariantType: ComponentProcedure =
BEGIN
variantType _ componentType.base.TypeForm[componentType.type];
RETURN[
stop: SELECT variantType FROM
union, sequence => TRUE, ENDCASE => FALSE];
END;  -- GetVariantType.
IF typeCser.hints.variant THEN
[] _ EnumerateRecord[type, GetVariantType];
RETURN[
[self: type,
info:  Record[
painted: typeCser.painted,
paramRecord: typeCser.argument,
monitored: typeCser.monitored,
uniField: typeCser.hints.unifield,
hasVariants: variantType=union,
hasSequences: variantType=sequence]] ];
END;
union =>
IF typeCser.controlled THEN
SELECT typeStb.seb[SymType[typeStb, typeCser.tagSei]].seTag FROM
id => RETURN[
[self: type,
info: VariantPart[
tag: Named[
name: SymbolHandle[typeStb, typeCser.tagSei],
type: SymbolType[[typeStb, typeCser.tagSei]]]]] ];
cons => RETURN[
[self: type,
info: VariantPart[
tag: Star[
name: SymbolHandle[typeStb, typeCser.tagSei]]]] ];
ENDCASE => ERROR
ELSE RETURN[
[self: type,
info: VariantPart[tag: Computed[]]] ];
ref =>
SELECT TRUE FROM
~typeCser.counted => RETURN[
[self: type,
info: Pointer[
referentType: TypeHandle[typeStb,typeCser.refType]],
readonly: typeCser.readOnly] ];
typeCser.list => {
base: STBase;
first, rest: SEIndex;
[base, first, rest] _ ListTypes[typeStb, typeSei];
RETURN[
[self: type,
info: List[
firstType: TypeHandle[base, first],
restType: TypeHandle[base, rest]],
readonly: typeCser.readOnly] ] };
typeCser.counted => RETURN[
[self: type,
info: Ref[
referentType: TypeHandle[typeStb,typeCser.refType]],
readonly: typeCser.readOnly] ];
ENDCASE => ERROR;
relative => RETURN[
[self: type,
info:  RelativePtr[
baseType: TypeHandle[typeStb, typeCser.baseType],
offsetType: TypeHandle[typeStb, typeCser.offsetType],
resultType: TypeHandle[typeStb, typeCser.resultType]]] ];
array => RETURN[
[self: type,
info:  Array[
packed: typeCser.packed,
indexType: TypeHandle[typeStb, typeCser.indexType],
elementType:
TypeHandle[typeStb, typeCser.componentType]]] ];
arraydesc =>
BEGIN
arrayInfo: TypeInfo _
GetTypeInfo[[typeStb, typeCser.describedType]];
WITH array: arrayInfo SELECT FROM
Array => RETURN[
[self: type,
info: Descriptor[
packed: array.packed,
indexType: array.indexType,
elementType: array.elementType],
readonly: typeCser.readOnly]  ];
ENDCASE => ERROR;
END;
sequence => 
IF typeCser.controlled
THEN RETURN [
[self: type,
info: Sequence[
packed: typeCser.packed,
indexType: SymbolType[[typeStb, typeCser.tagSei]],
elementType: TypeHandle[typeStb, typeCser.componentType],
tagName: Named[
name: SymbolHandle[typeStb, typeCser.tagSei]]]] ]
ELSE RETURN [
[self: type,
info: Sequence[
packed: typeCser.packed,
indexType: SymbolType[[typeStb, typeCser.tagSei]],
elementType: TypeHandle[typeStb, typeCser.componentType],
tagName: Computed[]]] ];
long =>
BEGIN
shortInfo: TypeInfo _ GetTypeInfo[[typeStb, typeCser.rangeType]];
shortInfo.self _ type;
shortInfo.long _ SELECT shortInfo.type FROM
Ref, List, Zone => FALSE, ENDCASE => TRUE;
RETURN[shortInfo];
END;
zone => RETURN[
[self: type,
info: Zone[
allocation: IF typeCser.counted THEN Counted ELSE Uncounted,
mdsZone: typeCser.mds  ]] ];
opaque => RETURN[
[self: type,
info: Opaque[lengthKnown: typeCser.lengthKnown]] ];
any => RETURN[[self: type, info: Any[]]];
ENDCASE => RETURN[[self: type, info: Other[]]];
ENDCASE => ERROR;
END;


IsType: PROCEDURE [
type: ST.FullTypeName,
candidateStb: STBase, candidateIsei: ISEIndex ]
RETURNS [--yes:-- BOOLEAN] =
BEGIN
candidate: AllocSubString _ IseiSubString[candidateStb, candidateIsei];
IF ~StringEqualSubString[type.name, candidate] THEN RETURN[FALSE];
candidate _ HtiSubString[
stb: candidateStb,
hti: ModuleHtiOfTypeName[candidateStb, candidateIsei]];
RETURN[StringEqualSubString[type.module, candidate]];
END;

GetParamMethod: PROC [paramStb: STBase, paramIsei: ISEIndex]
RETURNS [method: ST.ParamPassingMethod] =
BEGIN
Check: PROC [prefix: STRING] RETURNS [--isMatch:-- BOOLEAN] =
BEGIN
IF prefix.length >= typeName.length THEN RETURN[FALSE];
FOR i: CARDINAL IN NAT[0..prefix.length) DO
IF typeName.base[typeName.offset+i] # prefix[i] THEN RETURN[FALSE];
ENDLOOP;
RETURN[TRUE];
END;
typeName: AllocSubString = IseiSubString[paramStb, paramIsei];
RETURN[
SELECT TRUE FROM
Check["VAR"L], Check["VALUERESULT"L] => var,
Check["VALUE"L] => value,
Check["RESULT"L] => result,
Check["HANDLE"L] => handle,
ENDCASE => standard];
END;

ListTypes: PROC [listStb: STBase, listSei: --Ref--SEIndex]
RETURNS [base: STBase, first, rest: SEIndex_SENull] =
BEGIN
componentName: AllocSubString;
gotFirst, gotRest: BOOLEAN _ FALSE;
CheckFirstRest: ST.ComponentProcedure =
BEGIN
componentName _ IseiSubString[component.base, component.symbol];
SELECT TRUE FROM
gotFirst => NULL;
StringEqualSubString["first", componentName] =>
{gotFirst _ TRUE;
base _ componentType.base;
first _ componentType.type};
ENDCASE => NULL;
SELECT TRUE FROM
gotRest => NULL;
StringEqualSubString["rest", componentName] =>
{gotRest _ TRUE;
rest _ componentType.type};
ENDCASE => NULL;
RETURN[stop: gotFirst AND gotRest];
END;  -- CheckFirstRest.
listCsei: CSEIndex = listStb.UnderType[listSei];
WITH listRef: listStb.seb[listCsei] SELECT FROM
ref => {
IF ~listRef.list OR ~listRef.counted THEN ERROR;
IF ~EnumerateRecord[
recordType: [listStb, listRef.refType],
proc: CheckFirstRest ].stopped
THEN ERROR };
ENDCASE => ERROR;
END;

UNSPECIFIEDIndex, INTEGERIndex, CARDINALIndex,
NATIndex, REALIndex, WORDIndex, CHARACTERIndex, BOOLEANIndex,
TEXTIndex, STRINGIndex, StringBodyIndex, ATOMIndex,
MONITORLOCKIndex, CONDITIONIndex, MDSZoneIndex:   ISEIndex _ ISENull;

StandardTypeContext: CTXIndex = LOOPHOLE[2];

InitializeBuiltinTypes: PROCEDURE [standardStb: STBase] =
BEGIN
GetTypeISEIndex: PROC [standardType: STRING, system: {Mesa, Cedar}_Mesa]
RETURNS [typesISE: ISEIndex] =
BEGIN
subString: ConvertUnsafe.SubString = [standardType, 0, standardType.length];
typesISE _ standardStb.SearchContext[
name: standardStb.FindString[subString],
ctx: StandardTypeContext ];
IF typesISE=ISENull AND system=Mesa THEN ERROR;
END;
UNSPECIFIEDIndex _ GetTypeISEIndex["UNSPECIFIED"L];
INTEGERIndex _ GetTypeISEIndex["INTEGER"L];
CARDINALIndex _ GetTypeISEIndex["CARDINAL"L];
NATIndex _ GetTypeISEIndex["NAT"L, Cedar];
REALIndex _ GetTypeISEIndex["REAL"L];
WORDIndex _ GetTypeISEIndex["WORD"L];
CHARACTERIndex _ GetTypeISEIndex["CHARACTER"L];
BOOLEANIndex _ GetTypeISEIndex["BOOLEAN"L];
TEXTIndex _ GetTypeISEIndex["TEXT"L];
STRINGIndex _ GetTypeISEIndex["STRING"L];
StringBodyIndex _ GetTypeISEIndex["StringBody"L];
ATOMIndex _ GetTypeISEIndex["ATOM"L, Cedar];
MONITORLOCKIndex _ GetTypeISEIndex["MONITORLOCK"L];
CONDITIONIndex _ GetTypeISEIndex["CONDITION"L];
MDSZoneIndex _ GetTypeISEIndex["MDSZone"L];
END;


PutTypeName: PUBLIC PROCEDURE [
putProc: PROC[CHARACTER],
type: ST.TypeHandle,
includeReadonly: BOOLEAN_TRUE,
rootInterfaceOpenName: String_ST.StringNIL ] =
BEGIN ENABLE UNWIND => putChar _ NIL;
putChar _ putProc;
rootInterfaceQualifier _ rootInterfaceOpenName;
[] _ PrintType[
stBase: type.base,
tsei: type.type,
printReadonly: includeReadonly,
dosub: NoSub ];
END;

putChar: PROCEDURE [CHARACTER] _ NIL;  -- Set by PutTypeName.

PutChar: PROC [chr: CHARACTER] = INLINE {putChar[chr]};

PutString: PROC [str: String] =
BEGIN
FOR i: INT IN [0..str.Length[]) DO PutChar[str.Fetch[i]] ENDLOOP;
END;

PutSubString: PROC [subStr: ConvertUnsafe.SubString] =
BEGIN
FOR i: CARDINAL IN [subStr.offset..subStr.offset+subStr.length) DO
PutChar[subStr.base[i]];
ENDLOOP;
END;

PutDecimal: PROC [n: LONG INTEGER] = 
BEGIN
radix: CARDINAL = 10;
radixPower: LONG CARDINAL _ 1;
lwb: LONG CARDINAL _ n/radix;
IF n < 0 THEN { PutChar['-]; n _ -n };
WHILE radixPower <= lwb DO radixPower _ radixPower*radix ENDLOOP;
WHILE radixPower > 0
DO x: CARDINAL = n/radixPower;
PutChar['0+x];
n _ n - x*radixPower;
radixPower _ radixPower/radix;
ENDLOOP;
END;

PutOctal: PROC [n: LONG CARDINAL, trailingB: BOOLEAN_TRUE] =
BEGIN
radix: CARDINAL = 8;
radixPower: LONG CARDINAL _ 1;
lwb: LONG CARDINAL _ n/radix;
WHILE radixPower <= lwb DO radixPower _ radixPower*radix ENDLOOP;
WHILE radixPower > 0
DO x: CARDINAL = n/radixPower;
PutChar['0+x];
n _ n - x*radixPower;
radixPower _ radixPower/radix;
ENDLOOP;
IF trailingB THEN PutChar['B];
END;


PrintType: PROCEDURE [
stBase: STBase,
tsei: SEIndex,
dosub: PROCEDURE [vf: ValFormat],
printReadonly: BOOLEAN_TRUE ]
RETURNS [vf: ValFormat _ [none[]] ] =
BEGIN OPEN Symbols, stBase;  -- This damn OPEN was here when I arrived!
PrintReadonly: PROC [wantReadonly: BOOLEAN] =
BEGIN
IF wantReadonly AND printReadonly THEN PutString["READONLY "];
IF ~printReadonly THEN printReadonly _ TRUE;
END;
WITH t: seb[tsei] SELECT FROM
id =>
BEGIN
printBase: BOOLEAN _ TRUE;
ifInteger: BOOLEAN _ FALSE;
bsei: SEIndex _ tsei;
csei: CSEIndex;
DO
csei _ UnderType[bsei];
WITH c: seb[csei] SELECT FROM
basic =>
SELECT c.code FROM
codeINT => BEGIN printBase _ ifInteger; vf _ [num[]] END;
codeCHAR => vf _ [char[]];
ENDCASE;
subrange =>
{bsei _ c.rangeType; ifInteger _ TRUE; LOOP};
enumerated =>
{printBase _ TRUE; vf _ [enum[stBase, LOOPHOLE[csei]]]};
ENDCASE;
EXIT;
ENDLOOP;
SELECT TRUE FROM
~printReadonly AND GetTypeInfo[type: [stBase, csei]].readonly =>
[] _ PrintType[stBase, csei, dosub, FALSE];
printBase OR dosub = NoSub =>
BEGIN
PrintModuleQualifier[stBase, tsei];
WITH seb[csei] SELECT FROM
record =>
BEGIN
PrintBoundVariants: PROC [recordType: ISEIndex] =
BEGIN
parent: SEIndex;
IF (parent _ TypeLink[recordType]) = SENull
THEN PrintSei[stBase, recordType]
ELSE BEGIN
WITH seb[parent] SELECT FROM
id => PrintBoundVariants[ISEI[parent]]; 
cons => [] _ PrintType[stBase, parent, dosub]; 
ENDCASE => ERROR; 
PutChar['[];  PrintSei[stBase, recordType];  PutChar[']];
END;
END;  -- PrintBoundVariants.
PrintBoundVariants[ISEI[tsei]];
END;
ENDCASE => PrintSei[stBase, ISEI[tsei]];
END;
ENDCASE => NULL;
dosub[vf];
END;
cons =>
WITH t SELECT FROM
enumerated =>
BEGIN
PrintEnumItem: ContextProcedure =
BEGIN
IF itemIndex > 1 THEN PutString[", "];
PrintSei[itemStb, itemIsei];
END;
IF machineDep THEN PutString["MACHINE DEPENDENT "];
PutChar['{];
[] _ EnumerateContext[
ctxStb: stBase, ctx: valueCtx, ctxProc: PrintEnumItem];
PutChar['}];
END;
record =>
BEGIN
IF ctxb[fieldCtx].level # lZ THEN
BEGIN
fctx: CTXIndex = fieldCtx;
bti: BTIndex _ FIRST[BTIndex];
btlimit: BTIndex = bti + stHandle.bodyBlock.size;
PutString["FRAME ["];
UNTIL bti = btlimit DO
WITH entry: bb[bti] SELECT FROM
Callable =>
BEGIN
IF entry.localCtx = fctx THEN
BEGIN PrintSei[stBase, entry.id]; PutChar[']]; EXIT END;
bti _
bti +
(WITH entry SELECT FROM
Inner => SIZE[Inner Callable BodyRecord],
ENDCASE => SIZE[Outer Callable BodyRecord]);
END;
ENDCASE => bti _ bti + SIZE[Other BodyRecord];
ENDLOOP;
END
ELSE
BEGIN
IF machineDep THEN PutString["MACHINE DEPENDENT "];
PutString[IF painted THEN "RECORD " ELSE "STRUCT "];
PrintFieldCtx[stBase, fieldCtx];
END;
END;
ref =>
IF ~list
THEN {  -- Normal POINTER or REF.
IF ordered THEN PutString["ORDERED "];
IF basing THEN PutString["BASE "];
PutString[IF counted THEN "REF " ELSE "POINTER"];
IF dosub # NoSub THEN {PutChar[' ]; dosub[[num[]]]};
IF ~readOnly THEN WITH seb[UnderType[refType]] SELECT FROM
basic => IF code = Symbols.codeANY THEN GO TO noprint;
ENDCASE;
IF ~counted THEN PutString[" TO "];
PrintReadonly[readOnly];
[] _ PrintType[stBase, refType, NoSub];
EXITS noprint => NULL }
ELSE {  -- LIST OF something.
firstBase: STBase;  firstBody: SEIndex;
[base: firstBase, first: firstBody] _ ListTypes[stBase, tsei];
PutString["LIST OF "];
PrintReadonly[readOnly];
[] _ PrintType[firstBase, firstBody, NoSub] };
array =>
BEGIN
IF packed THEN PutString["PACKED "];
PutString["ARRAY "];
[] _ PrintType[stBase, indexType, NoSub];
PutString[" OF "];
[] _ PrintType[stBase, componentType, NoSub];
END;
arraydesc =>
BEGIN
PutString["DESCRIPTOR FOR "];
PrintReadonly[readOnly];
[] _ PrintType[stBase, describedType, NoSub];
END;
transfer =>
BEGIN
ArgRes: PROC[type: CSEIndex] =
BEGIN
WITH argRes: seb[type] SELECT FROM
record => PrintFieldCtx[stBase, argRes.fieldCtx];
any => PutString["ANY"];
ENDCASE => ERROR;--?--
END;
IF safe THEN PutString["SAFE "];
PrintModeName[mode];
IF typeIn # RecordSENull THEN
BEGIN
PutChar[' ];
ArgRes[typeIn];
END;
IF typeOut # RecordSENull THEN
BEGIN
PutString[" RETURNS "];
ArgRes[typeOut];
END;
END;
union =>
BEGIN
tagType: SEIndex;
PutString["SELECT "];
IF ~controlled THEN
IF overlaid THEN PutString["OVERLAID "]
ELSE PutString["COMPUTED "]
ELSE BEGIN PrintSei[stBase, tagSei]; PutString[": "] END;
tagType _ seb[tagSei].idType;
IF seb[tagSei].public # defaultPublic THEN
PutString[
IF defaultPublic THEN "PRIVATE " ELSE "PUBLIC "];
WITH seb[tagType] SELECT FROM
id => [] _ PrintType[stBase, tagType, NoSub];
cons => PutChar['*];
ENDCASE;
PutString[" FROM "];
BEGIN
isei: ISEIndex;
first: BOOLEAN _ TRUE;
varRec: RecordSEIndex;
FOR isei _ FirstCtxSe[caseCtx], NextSe[isei] UNTIL isei=ISENull DO
IF first THEN first _ FALSE ELSE PutString[", "];
PrintSei[stBase, isei];
PutString[" => "];
varRec _ seb[isei].idInfo;
PrintFieldCtx[stBase, seb[varRec].fieldCtx];
ENDLOOP;
PutString[" ENDCASE"];
END;
END;
sequence =>
BEGIN
IF packed THEN PutString["PACKED "];
PutString["SEQUENCE "];
IF controlled
THEN {PrintSei[stBase, tagSei]; PutString[": "]}
ELSE PutString["COMPUTED "];
[] _ PrintType[stBase, SymType[stBase,tagSei], NoSub];
PutString[" OF "];
[] _ PrintType[stBase, componentType, NoSub];
END;
relative =>
BEGIN
IF baseType # SENull
THEN [] _ PrintType[stBase, baseType, NoSub, printReadonly];
PutString[" RELATIVE "];
[] _ PrintType[stBase, offsetType, dosub, printReadonly];
END;
subrange =>
BEGIN
org: LONG INTEGER _ origin;
size: LONG CARDINAL _ range;
upperBound: LONG INTEGER = org + size;
doit: PROCEDURE [pvf: ValFormat] =
BEGIN
PutChar['[];
PrintTypedVal[org, pvf, TRUE];
PutString[".."];
IF empty
THEN {PrintTypedVal[org, pvf, TRUE]; PutChar[')]}
ELSE {
PrintTypedVal[
upperBound, pvf, upperBound < INTEGER[0]];
PutChar[']] };
END;
vf _ PrintType[stBase, rangeType, doit];
END;
long =>
BEGIN
range: CSEIndex = stBase.UnderType[rangeType];
refOrList: BOOLEAN =
WITH refType: stBase.seb[range] SELECT FROM
ref => refType.counted OR refType.list,
ENDCASE => FALSE;
IF ~refOrList THEN PutString["LONG "];
[] _ PrintType[stBase, rangeType, NoSub, printReadonly];
END;
real => PutString["REAL"];
opaque =>
BEGIN
PutString["TYPE"];
IF lengthKnown THEN {
PutString[" ["]; PrintValue[length]; PutString["]"]; };
END;
zone => --Not totally corrrect for MdsZone:--
PutString[IF ~counted THEN "UNCOUNTED ZONE" ELSE "ZONE"];
any => PutString["ANY"];
ENDCASE => PutString["--!!!Unknown Type!!!--"];
ENDCASE;
END;  -- PrintType.


rootInterfaceQualifier: String;  -- Set by PutTypeName.

PrintModuleQualifier: PROCEDURE [stBase: STBase, typeSei: SEIndex] =
--INLINE-- BEGIN
WITH type: stBase.seb[typeSei] SELECT FROM
id =>
BEGIN
module: MDIndex;
IF type.idCtx = StandardTypeContext THEN RETURN;
module _ ModuleOfTypeName[stBase, ISEI[typeSei]];
IF module = OwnMdi
THEN {IF rootInterfaceQualifier=NIL OR rootInterfaceQualifier.Length[]=0
THEN RETURN
ELSE PutString[rootInterfaceQualifier] }
ELSE PrintHti[stBase, stBase.mdb[module].moduleId];
PutChar['.];
END;
ENDCASE => NULL;
END;

defaultPublic: BOOLEAN _ TRUE;

PrintSymbolType: PRIVATE PROCEDURE [stb: STBase, sei: ISEIndex] =
BEGIN OPEN stb;
savePublic: BOOLEAN _ defaultPublic;
typeSei: SEIndex;
IF seb[sei].public # defaultPublic THEN
BEGIN
defaultPublic _ seb[sei].public;
PutString[IF defaultPublic THEN "PUBLIC " ELSE "PRIVATE "];
END;
IF seb[sei].idType = typeTYPE
THEN BEGIN
typeSei _ seb[sei].idInfo;
PutString["TYPE = "];
[] _ PrintType[tsei: typeSei, dosub: NoSub, stBase: stb];
END
ELSE BEGIN
vf: ValFormat;
typeSei _ seb[sei].idType;
vf _ PrintType[tsei: typeSei, dosub: NoSub, stBase: stb];
IF seb[sei].constant AND vf.tag # none THEN
BEGIN
PutString[" = "];
PrintTypedVal[LONG[seb[sei].idValue], vf];
END;
END;
defaultPublic _ savePublic;
END;

PrintFieldCtx: PROCEDURE [stBase: STBase, ctx: CTXIndex] =
BEGIN
PrintFieldItem: ContextProcedure =
BEGIN
IF itemIndex > 1 THEN PutString[", "];
IF ~IsAnonymous[[itemStb, itemIsei]]
THEN {PrintSei[itemStb, itemIsei]; PutString[": "] };
PrintSymbolType[itemStb, itemIsei];
END;
PutChar['[];
[] _ EnumerateContext[ctxStb: stBase, ctx: ctx, ctxProc: PrintFieldItem];
PutChar[']];
END;

PrintModeName: PROCEDURE [mode: TransferMode] =
BEGIN
ModePrintName: PACKED ARRAY TransferMode OF String =
["PROCEDURE", "PORT", "SIGNAL", "ERROR",
"PROCESS", "PROGRAM", "NONE"];
PutString[ModePrintName[mode]]
END;

ValFormat: TYPE = RECORD [
SELECT tag: * FROM
none => NULL,
num => NULL,
char => NULL,
enum => [stBase: STBase, esei: EnumeratedSEIndex],
ENDCASE];

PrintTypedVal: PROCEDURE [
val: LONG UNSPECIFIED, vf: ValFormat, integer: BOOLEAN_FALSE] =
BEGIN
WITH vf SELECT FROM
num =>  PrintValue[val, integer];
enum => PrintEnum[val, stBase, esei];
char => IF val IN [' ..'~]
THEN {PutChar[''];  PutChar[VAL[Basics.LowHalf[val]]]}
ELSE {PutOctal[n: val, trailingB: FALSE]; PutChar['C]};
ENDCASE;
END;

PrintValue: PROCEDURE [value: LONG UNSPECIFIED, integer: BOOLEAN _ FALSE] =
BEGIN
IF integer OR
LOOPHOLE[value,LONG CARDINAL] < LOOPHOLE[LAST[LONG INTEGER],LONG CARDINAL]
THEN PutDecimal[LOOPHOLE[value, LONG INTEGER]]
ELSE PutOctal[LOOPHOLE[value, LONG CARDINAL]];
END;

NoSub: PROCEDURE [vf: ValFormat] = BEGIN NULL END;

EnumeratedSEIndex: TYPE =
Table.Base RELATIVE POINTER [0..Table.Limit) TO enumerated cons SERecord;

PrintEnum: PROCEDURE [
val: LONG UNSPECIFIED, stBase: STBase, esei: EnumeratedSEIndex] =
BEGIN OPEN Symbols, stb: stBase;
sei: ISEIndex;
FOR sei _ stb.FirstCtxSe[stb.seb[esei].valueCtx], stb.NextSe[sei]
WHILE sei # ISENull DO
IF stb.seb[sei].idValue = val THEN {PrintSei[stBase, sei]; RETURN};
ENDLOOP;
PutString["LOOPHOLE ["];  PrintValue[val];  PutChar[']];
END;

PrintHti: PROCEDURE [stb: STBase, hti: Symbols.HTIndex] =
BEGIN
IF hti = HTNull THEN ERROR;
PutSubString[HtiSubString[stb, hti]];
END;

PrintSei: PROCEDURE [stb: STBase, sei: Symbols.ISEIndex] =
BEGIN
IF sei = ISENull THEN ERROR;
PutSubString[IseiSubString[stb, sei]];
END;





END.  -- LupineSymbolTableImpl.

4File [Ivy]<Nelson>Lupine>LupineSymbolTableImpl.mesa.
Last edited by BZM on 11-May-82 14:12:53.
Last edited by Andrew Birrell October 24, 1983 4:50 pm (changes for 3.4)
Last edited by Paul Rovner January 28, 1983 1:37 pm (changes for 4.0)
Interface file operations.
This is root interface symbol table info (from OpenInterface).
Be sure to set LupineSymbolTable.MaxVersionStampStringLength correctly.
Enumeration routines that generate an interface's contents.
The ContextProcedure's itemIndex is invalid here
because this enumeration is of the ST's outer context.
General operations for types and symbols.
This array size code is from from SymbolPack.WordsForType.
It's been changed to work properly for CARDINAL, INTEGER, etc.,
index types, for which the compiler's Cardinality is zero!
In many discriminating SELECT statements, an SEIndex
is properly known to be an ISEIndex, but Mesa cannot infer this
because both are relative pointers.  This procedure captures
the coercion.
Detailed operations for types.
This code automatically handles INT, CHAR, BOOL
and other synonyms.  It could cause unforeseeable
problems with future builtin types.  Beware.
Checks to see if the candidate type ID = FullTypeName.
Type printing routines.  The output must be compilable.
Most of these routines are derived from <Mesa>Lister>ListPub.mesa.
putChar _ NIL;
rootInterfaceQualifier _ NIL;
These global routines are used by PrintType and friends (below).
Exclude only the top-level appearance of READONLY in a type expression.
This prints variant records in the Cedar style.
For example:  short red Dress => Dress[red][short].
Old variant record code:
UNTIL (tsei _ TypeLink[tsei]) = SENull DO
WITH seb[tsei] SELECT FROM
id => {PutChar[' ]; PrintSei[stBase, ISEI[tsei]]};
ENDCASE;
ENDLOOP;
basic =>  Should see the ID first.
IF monitored THEN PutString["MONITORED "];
The LOCK field is printed below, so MONITORED is redundant.
This has changes to (TRY) do intervals with negative endpoints
such as (3..-1]) correctly.
It still has problems for values not contained in LONG INTEGERs.
Module Initialization
�Ê,+˜Jš
œ4™4Jš
œ)™)Jš
œH™HJš
œE™EJ˜J˜š
Ïk	˜	Jšœ�œ	˜Jšœ�œ˜Jšœ
�œ˜Jšœ�œ9˜FJšœ�œ˜Jšœ�œ˜1Jšœ�œ?˜GJš�œ
�œ	˜šœ�œ˜J˜Jšœ"�œ
˜&J˜$J˜J˜*J˜-J˜2—Jšœ�œ ˜*Jšœ
�œ#˜5Jšœ�œ1˜BJšœ
�œ"˜1šœ�œ˜J˜J˜J˜J˜'J˜J˜7J˜0—Jšœ�œ˜Jšœ�œ˜Jš
œW˜WJ˜J˜—šœ�˜Jš�œ4�œ�œ �˜cJš�œ˜Jš�œ˜Jšœ�œ
�œ
�œ˜,J˜J˜Jšœ�œ�œ˜J˜Jšœ�œ�œ˜J˜šœ�œ˜0Jš	œ�œ
�œ
�œ�œ
˜/J˜—J˜
Jš
œ™J˜˜Jš
œ>™>Jšœ�œ
˜J˜(J˜)Jšœ�œ
˜J˜J˜šÏn
œ�œ
�	œ˜!J˜J˜$Jš
�˜Jš�œ
�œ˜"J˜J˜˜!J˜Jšœ�œ0˜K—Jš�œ7˜9Jš�œ
�œ-˜7šœ
�˜˜J˜
˜
˜Jš
�˜š�œ˜Jš�œ
�œ˜(—Jš�œ˜——J˜"——Jš�œ˜Jš�œ
�œ2˜<J˜-Jš�œ
˜J˜—šœ�œ
�œ!�œ˜IJšœ�œ
˜J˜—šžœ�œ
�	œ˜#Jš
�˜Jš�œ�œ
�œ$˜9Jš�œ�œ˜7Jšœ
�œ
˜J˜Jš
œ˜Jšœ
�œ
˜Jš�œ
˜J˜—šžœ�œ
�	˜"š�œ˜	Jšœ
�œ˜J˜Jšœ�œ˜Jšœ$�œ
�œ˜.—Jš
�˜˜!Jš
�˜š�œ-�˜7˜˜*Jšœ1�œ
˜6——Jšœ�œ
˜ Jš�œ�œ!�œ�œ
˜M—Jš�œ
˜—JšœÏc˜'˜J˜I—J˜9J˜)˜Jšœ"�œ
˜4—Jš
œM˜MJš�œ
˜J˜—šžœ�œ
�	œ	�œ˜=Jš�œ˜Jš
œG™GJš
�˜šœ�œ˜"J˜J˜J˜J˜—Jš�œ
˜J˜—š	œ�œ
�œ�œ
�œ˜IJ˜.J˜?J˜—šž
œ�	œ˜Jšœ!�œ ˜HJšŸ
œ
�˜Jš
œ<˜<Jš
œ8˜8Jš�œ
˜J˜—Jšœ�œ�œ
˜J˜šž	œ�œ˜&Jš�œ@˜GJš
�˜Jšœ�œ˜Jšœ�œ
˜š
�œ
�œ
�œ�œ�œ˜JJ˜>J˜-Jš
œ?˜?Jš�œ&�œ
�œ˜DJ˜š�œ�˜Jš
�˜J˜Jš
œB˜BJ˜-Jš
œC˜CJš�œ
˜——Jš�œ
˜Jš�œ
˜J˜—šžœ�œ˜0Jš�œ˜#Jš�œ
�œ˜šžœ�œ˜,Jš�œŸ	œ
�œ˜Jšœ
�œ�œ˜0—J˜6Jš�œ
˜———˜
Jš
œ;™;J˜šžœ�œ
�	œ�œ˜BJš�œ�œ
�œ˜"Jš
�˜˜Jš�œ
�œ	˜J˜J˜Jšœ
�œ
˜J˜J˜š�œ&�œ
�˜5J˜"˜Jšœ�œ*˜5—Jš�œ�œ
˜—š�œ�œ
�˜&Jšœ'�œ˜.Jšœ-�œ˜4Jšœ=�œ˜CJš�œ�œ
˜—J˜8šœ	�œ˜"Jš�œ�œ4˜F—š�œ7˜=J˜5—Jš�œ
˜—˜J˜I—Jš�œ
˜J˜šžœ�œ
�	œ˜&Jšœ�œ˜Jšœ�œ�œ˜.Jš�œ�œ
�œ˜"Jš
�˜šœ�œ˜Jš
œ0™0Jš
œ6™6—˜Jš
�˜šžœ�	œ�œ�œ˜GJš�œ�œ"˜0—J˜.J˜,š�œ�œ
�˜(˜š�œ�˜˜š�œ�œ�œ �˜9˜J˜J˜2J˜+J˜*J˜#———˜š�œ�œ�˜˜J˜J˜.J˜+J˜*J˜#———˜	š�œ�œ	�˜˜J˜J˜/J˜+J˜*J˜#———š�œ˜š�œ�˜˜J˜J˜!J˜(J˜+J˜*J˜#————Jš�œ�œ
˜——Jš�œ
˜—˜J˜F—Jš�œ
˜J˜—šžœ�œ
�	œ˜#Jšœ�œ�œ˜7Jš�œ�œ
�œ˜"Jš
�˜J˜!Jš�œ�œ
�œ
˜(š�œ4�œ
�˜C˜	Jš
�˜˜Jš
�˜š�œ
˜˜J˜J˜5J˜$——Jš�œ
˜—˜J˜8—Jš�œ
˜—Jš�œ�œ
˜—Jš�œ
˜J˜—šžœ�œ
�	œ˜%Jšœ�œ�œ˜:Jš�œ�œ
�œ˜"Jš
�˜J˜&Jš�œ�œ
�œ
˜,š�œ9�œ
�˜H˜Jš
�˜˜Jš
�˜š�œ
˜˜J˜ J˜-J˜;J˜"——Jš�œ
˜—˜J˜6—Jš�œ
˜—Jš�œ�œ
˜—Jš�œ
˜J˜—šžœ�œ�	œ˜$Jšœ:�œ˜CJš�œ�œ
�œ˜J˜—šžœ�	œ˜J˜J˜J˜Jš�œ�œ
�œ˜"Jš
�˜Jšœ�œ˜šžœ�	œ$˜DJ˜!Jš�œŸ	œ
�œ˜Jš
�˜š�œ
�œ�œ
�œ˜3Jš�œ3˜6Jš�œ
�˜
š�œ�œ(˜DJšœ
�œ'˜7J˜#——Jš�œ
˜—˜(J˜<J˜
˜Jš
�˜Jš�œ�œ
�œ˜=Jš�œ˜——Jš�œ
˜———J˜
Jš
œ)™)˜šž
œ�œ
�	œ
�œ˜6Jš�œ˜Jš
�˜J˜š�œ˜Jš�œ
�œ
�œ
˜Jš�œ
�œ ˜+—Jš�œ
˜J˜—šžœ�œ
�	œ
�œ˜7Jš�œ�œ˜Jšœ
�œ0˜7J˜—šž
œ�œ
�	œ
�œ˜6Jš�œ�œ˜!Jš�œ
�œ@˜IJ˜—šžœ�	œ�œ˜DJš�œ
�˜š�œ�œ˜(Jš�œ
�œ
�œ˜&—Jš�œ
˜J˜—šžœ�œ
�	œ
�œ˜:Jš�œ�œ˜#Jš�œ
�œ$˜3J˜—šžœ�œ
�	œ˜(Jšœ	�œ˜Jšœ�œ
�
œ
�œ
�œ
�œ
�œ
�œ˜FJš�œ�œŸœ˜3Jš
�˜J˜ J˜!J˜%š
�˜š�œ�œ
�˜,˜Jš
�˜˜J˜Jšœ�œ
˜—˜J˜Jšœ#�œ
˜4—š	�œ�œ
�œ�œ�˜2š�œ:�˜?J˜<Jš�œ
�œ˜—š
�˜Jš�œ˜"—Jš�œ
˜—Jš�œ
˜—˜š�œ�œ
�˜J˜"Jš�œ�œ
˜——Jš�œ�œ˜—Jš�œ
˜—Jš�œ
˜J˜—šžœ�œ
�	œ�œ
�œ�œ	˜GJš�œ
�œ%�œ
˜5J˜—šžœ�œ
�	œ˜$Jšœ�œ�œ˜1Jš�œŸ	œ
�œ	˜Jš
�˜Jš
œ:™:Jš
œ?™?Jš
œ:™:Jšœ�œ
�œ
˜šœ
�œ	�œ%�œ
�˜LJ˜Jš�œ�œ
˜—š�œ
˜š�œH˜JJš�œ6˜:Jš�œ2˜6——Jš�œ
˜J˜J˜—šžœ�	œ%˜CJš�œŸœ˜"JšŸ
œ
�˜Jš�œ9˜?Jš�œ
˜J˜—šžœ�	œ%˜@Jš�œ˜Jš
�˜J˜Aš�œ�œ
�˜!J˜J˜ J˜9Jš�œ�œ
˜—Jš�œ
˜J˜—šžœ�	œ˜3Jš�œ˜"Jš�œ
�œŸ,˜:Jš�œ˜"Jš�œ
˜J˜—šž	œ�	œ�œ
˜BJš
�˜Jš�œ7˜=Jš�œ
˜J˜—š�œ�	œ�œŸ	œ˜=Jš
œ4™4Jš
œ?™?Jš
œ<™<Jš
œ
™
Jš
�œ
�œ
�œ
�œ�œ
˜'J˜—šž
œ�	œ˜6Jš�œ˜"JšŸ
œ
�˜š�œ˜Jšœ
�œ�œ�œ˜9—Jš�œ
˜J˜—šž
œ�	œ˜3Jš�œ˜Jš�œ
�˜š�œ˜Jšœ
�œ�œ�œ˜7—Jš�œ
˜J˜—šžœ�	œ(˜GJš�œŸœ
�œ˜#Jš�œ
�˜Jš�œ�œ ˜?Jš�œ
˜J˜—šžœ�	œ(˜KJš�œ�œ˜Jš
�˜Jš�œ�œ
�œ
�œ˜,Jš�œ�œ
�œ˜ Jš�œ
�œ!�œ
�œ
�œ�œ
˜AJš�œ
�œ
˜Jš�œ
˜——J˜
Jš
œ™˜šžœ�œ
�œ�œ
�œ�œ˜OJš�œ
�œ
�œ
˜J˜˜Jš�œ�œ
�œ˜<š�œ�œ
�˜.˜š�œ
�œ
�˜Jšœ�œ
˜#˜&š�œ	�˜šœ�œ
˜˜˜J˜Jšœ�œ
�œ˜Jšœ�œ
�œ
�œ�œ
�œ
˜3———šœ�œ
˜J˜˜J˜Jšœ�œ
�œ˜Jšœ�œ
�œ
�œ�œ
�œ
˜9——šœ�œ
˜J˜˜J˜Jšœ�œ
�œ˜Jšœ�œ
�œ
�œ�œ
�œ
˜;——šœ�œ
˜J˜˜J˜
Jšœ�œ
�œ˜Jšœ�œ
�œ
�œ�œ
�œ
˜1——šœ
�œ
˜J˜˜J˜J˜——šœ
�œ
˜J˜˜J˜Jšœ�œ
�œ˜Jšœ�œ
�œ
�œ�œ
�œ
˜3——šœ�œ
˜˜˜J˜Jš	œ�œ
�œ
�	œ�œ˜,šœ
�œ�œ
�œ
�	œ�œ
˜5Jš	œ�œ
�œ
�	œ�œ
˜%J˜————šœ�œ
˜J˜˜J˜Jš	œ�œ
�œ
�œ�œ˜*J˜——Jšœ
�œ˜0Jšœ�œ˜4Jšœ�œ#˜<Jšœ
�œ&�œ˜A˜#Jš�œ˜$—šœ�œ
˜˜Jšœ+�œ˜4——š�œ˜
Jš
œ/™/Jš
œ1™1Jš
œ,™,Jš�œ
˜J˜?J˜š�œ�œ�˜$J˜@Jš�œ"˜)—Jš�œ
˜———šœ"�œ
˜3Jš�œ&�œ˜4—š�œ˜
Jš
�˜Jšœ3�œ˜BJ˜;J˜Jš�œ�œ ˜9Jš�œ
˜Jš�œ
˜———˜š�œ�œ
�˜"Jšœ�œŸ+˜BJšœ�œ#˜7šœ�œ
˜˜˜J˜J˜šœ
�œ˜Jš�œ�œ˜!————šœ�œ
˜˜˜
J˜J˜
J˜"———šœ�œ
˜˜˜J˜,Jš
œ˜J˜3J˜6—————˜	Jš
�˜J˜ ˜$Jš
�˜J˜>š�œ
˜šœ�œ
�˜Jšœ�œ�œ�œ˜+——Jš�œŸ˜—š�œ�˜J˜+—š�œ
˜˜˜J˜J˜J˜J˜"J˜J˜'———Jš�œ
˜—˜š�œ�˜š�œ6�˜@šœ�œ
˜
J˜˜˜J˜-J˜2———šœ�œ
˜J˜˜˜
J˜2———Jš�œ�˜—š�œ
�œ
˜J˜J˜&———˜š�œ
�œ
�˜šœ�œ
˜˜˜J˜4—J˜——˜J˜
J˜J˜2š�œ
˜˜˜J˜#J˜"—J˜!———šœ�œ
˜˜˜
J˜4—J˜——Jš�œ�œ
˜——šœ�œ
˜˜˜J˜1J˜5J˜9———šœ	�œ
˜˜˜
J˜J˜3˜J˜0————˜Jš
�˜˜J˜/—š�œ�œ
�˜!šœ	�œ
˜˜˜J˜J˜J˜ —J˜ ——Jš�œ�œ
˜—Jš�œ
˜—˜š�œ˜š�œ
�œ˜
˜˜J˜J˜2J˜9˜J˜1————š�œ
�œ˜
˜˜J˜J˜2J˜9J˜—————˜Jš
�˜J˜AJ˜šœ�œ�˜+Jšœ�œ�œ�œ
˜*—Jš�œ˜Jš�œ
˜—šœ�œ
˜˜˜Jšœ�œ�œ	�œ˜<J˜———šœ
�œ
˜˜J˜3——Jšœ�œ˜)—Jš�œ�œ˜/——Jš�œ�œ
˜Jš�œ
˜J˜J˜šžœ�	œ˜Jšœ�œ˜J˜/Jš�œŸœ
�œ˜Jš
�˜Jš
œ6™6J˜GJš�œ-�œ
�œ
�œ˜B˜J˜J˜7—Jš�œ/˜5Jš�œ
˜J˜—šžœ�œ(˜<Jš�œ
�œ˜)Jš
�˜šžœ�œ
�œ�œŸœ
�œ˜=Jš
�˜Jš�œ"�œ
�œ
�œ˜7š	�œ�œ
�œ
�œ�˜+Jš�œ.�œ
�œ
�œ˜CJš�œ
˜—Jš�œ
�œ˜
Jš�œ
˜—J˜>š�œ
˜š�œ
�œ
�˜J˜,J˜J˜J˜Jš�œ˜——Jš�œ
˜J˜—šž	œ�œŸœ˜:Jš�œ.˜5Jš
�˜J˜Jšœ�œ�œ
˜#šœ�œ˜'Jš
�˜J˜@š�œ
�œ
�˜Jšœ�œ
˜˜/šœ�œ
˜J˜J˜——Jš�œ�œ
˜—š�œ
�œ
�˜Jšœ�œ
˜˜.šœ�œ
˜J˜——Jš�œ�œ
˜—Jš�œ�œ
˜#Jš�œŸ˜J˜0š�œ �œ
�˜/˜Jš�œ�œ�œ
�œ
˜0š�œ˜J˜'J˜Jš�œ
�œ˜
——Jš�œ�œ
˜——Jš�œ
˜J˜—J˜.J˜=J˜3J˜EJ˜Jšœ �œ˜,J˜šžœ�	œ˜9Jš
�˜šžœ�œ�œ˜HJš�œ˜Jš
�˜J˜L˜%Jš
œ(˜(J˜—Jš�œ�œ
�œ
�œ
˜/Jš�œ
˜—J˜3J˜+J˜-J˜*J˜%J˜%J˜/J˜+J˜%J˜)J˜1J˜,J˜3J˜/J˜+Jš�œ
˜——J˜
Jš
œ7™7Jš
œB™B˜šžœ�œ
�	œ˜Jšœ	�œ
�	œ˜Jšœ�œ˜Jšœ�œ
�œ
˜Jšœ�œ˜.Jš�œ
�œ
�œ�œ
˜%J˜J˜/˜J˜J˜J˜J˜—Jš
œ™Jš
œ™Jš�œ
˜J˜—Jš
œ@™@Jšœ	�	œ�	œ�œŸ˜=J˜Jšžœ�œ�	œ�œ˜7J˜šž	œ�œ˜Jš
�˜Jš
�œ�œ
�œ�œ�œ
˜AJš�œ
˜—J˜šžœ�œ$˜6Jš
�˜š�œ�œ
�œ.�˜BJ˜Jš�œ
˜—Jš�œ
˜—J˜šž
œ�œ�œ
�œ˜%Jš
�˜Jšœ�œ˜Jšœ�œ
�œ˜Jšœ�œ
�œ˜Jš�œ�œ˜&Jš�œ�œ�œ
˜AJš�œ˜š�œ�œ˜Jš
œ˜Jš
œ˜Jš
œ˜—Jš�œ
˜Jš�œ
˜—J˜šžœ�œ�œ
�œ
�œ
�œ˜<Jš
�˜Jšœ�œ˜Jšœ�œ
�œ˜Jšœ�œ
�œ˜Jš�œ�œ�œ
˜AJš�œ˜š�œ�œ˜Jš
œ˜Jš
œ˜Jš
œ˜—Jš�œ
˜Jš�œ�œ
˜Jš�œ
˜J˜J˜—šž	œ�	œ˜J˜J˜Jšœ�	œ˜!Jšœ�œ
�œ˜Jš�œ˜%Jš�œ
�œŸ*˜Gšž
œ�œ�œ˜-š
�˜Jš
œG™G—Jš�œ�œ�œ˜>Jš�œ�œ�œ
˜,Jš�œ
˜—š�œ�œ
�˜˜Jš
�˜Jšœ�œ�œ
˜Jšœ�œ�œ
˜J˜J˜š
�˜J˜š�œ�œ
�˜˜š�œ�˜Jšœ�œ%�œ
˜9J˜Jš�œ
˜——˜Jšœ!�œ�œ˜-—˜
Jšœ
�œ�œ
˜8—Jš�œ
˜—Jš�œ
˜Jš�œ
˜—š�œ
�œ
�˜šœ�œ.˜@Jšœ$�œ˜+—šœ
�œ˜Jš
�˜J˜#š�œ�œ
�˜˜	Jš
�˜Jš
œ/™/Jš
œ3™3Jš
œ™Jš
œ)™)Jš
œ™Jš
œ2™2Jš
œ™Jš
œ™šžœ�œ˜1Jš
�˜J˜š�œ)˜+Jš�œ˜!š�œ
�˜
š�œ
�œ
�˜Jšœ�œ˜(J˜/Jš�œ�œ˜—J˜9Jš�œ
˜——Jš�œŸ˜—Jšœ�œ˜Jš�œ
˜—Jš�œ�œ˜(—Jš�œ
˜—Jš�œ�œ
˜—J˜
Jš�œ
˜—˜š�œ�œ
�˜Jš
œ"™"˜
Jš
�˜˜!Jš
�˜Jš�œ�œ˜&J˜Jš�œ
˜—Jš�œ�œ!˜3J˜˜J˜7—J˜Jš�œ
˜—˜	Jš
�˜š�œ�˜!Jš
�˜J˜Jšœ�œ
˜J˜1J˜š�œ�˜š�œ�œ
�˜˜Jš
�˜š�œ�˜Jš�œ*�œ
�œ
˜8—˜˜šœ
�œ�œ
�˜Jšœ	�œ˜)Jš�œ�œ˜,———Jš�œ
˜—Jš�œ�œ˜.—Jš�œ
˜—Jš
�˜—š
�˜Jš
�˜—š
œ*™*Jš
œ;™;Jš�œ�œ!˜3Jšœ
�œ	�œ�œ˜4J˜ Jš�œ
˜—Jš�œ
˜—˜š�œ˜š�œŸ˜!Jš�œ	�œ˜&Jš�œ�œ˜"Jšœ
�œ	�œ�œ˜1Jš�œ�œ˜4š	�œ�œ
�œ�œ
�˜:Jš	œ	�œ�œ
�œ
�œ	˜6Jš�œ
˜—Jš�œ
�œ˜#J˜J˜'Jš�œ�œ˜—š�œŸ˜J˜'J˜>J˜J˜J˜.———˜Jš
�˜Jš�œ�œ˜$J˜J˜)J˜J˜-Jš�œ
˜—˜Jš
�˜J˜J˜J˜-Jš�œ
˜—˜Jš
�˜šžœ�œ˜Jš
�˜š�œ�œ
�˜"J˜1J˜—Jš�œ�œ
Ÿ˜Jš�œ
˜—Jš�œ�œ˜ J˜š�œ�˜Jš
�˜J˜J˜Jš�œ
˜—š�œ�˜Jš
�˜J˜J˜Jš�œ
˜—Jš�œ
˜—˜Jš
�˜J˜J˜š�œ
�˜Jš�œ
�œ˜'Jš�œ˜—Jš�œ
�œ+�œ
˜9J˜š�œ$�˜*˜
Jš�œ�œ�œ˜1——š�œ�œ
�˜J˜-J˜Jš�œ
˜—J˜Jš
�˜J˜Jšœ�œ�œ
˜J˜š�œ*�œ�˜BJš�œ�œ	�œ
�œ˜1J˜J˜J˜J˜,Jš�œ
˜—J˜Jš�œ
˜Jš�œ
˜—˜Jš
�˜Jš�œ�œ˜$J˜š�œ˜
Jš�œ,˜0Jš�œ˜—J˜6J˜J˜-Jš�œ
˜—˜Jš
�˜š�œ˜Jš�œ8˜<—J˜J˜9Jš�œ
˜—˜Jš
�˜Jš
œ>™>Jš
œ™Jš
œ@™@Jšœ�œ
�œ
˜Jšœ�œ
�œ	˜Jšœ�œ
�œ˜&šœ�	œ˜"Jš
�˜J˜Jšœ�œ˜J˜š�œ˜Jš�œ�œ˜1š�œ˜˜Jšœ�œ˜*—J˜——Jš�œ
˜—J˜(Jš�œ
˜—˜Jš
�˜J˜.šœ�œ˜š�œ�œ
�˜+Jšœ�œ˜'Jš�œ�œ
˜——Jš�œ�œ˜&J˜8Jš�œ
˜—J˜˜	Jš
�˜J˜š�œ
�œ˜J˜7—Jš�œ
˜—šœŸ%˜-Jšœ
�œ
�œ�œ	˜9—J˜—Jš�œ(˜/——Jš�œ
˜Jš�œŸ
˜—J˜J˜Jšœ!Ÿ˜7J˜šžœ�	œ%˜DJšŸ
œ
�˜š�œ�œ
�˜*˜Jš
�˜J˜Jš�œ"�œ
�œ
˜0Jšœ"�œ˜1š�œ˜š�œ�œ�œ
�œ"˜HJš�œ
�˜Jš�œ$˜(—Jš�œ/˜3—J˜Jš�œ
˜—Jš�œ�œ
˜—Jš�œ
˜J˜—Jšœ�œ�œ
˜J˜šžœ�œ
�	œ˜AJš�œ
�œ˜Jšœ�œ˜$J˜š�œ!�˜'Jš
�˜J˜ Jšœ
�œ�œ�œ
˜;Jš�œ
˜—š�œ˜š�œ
�˜
J˜J˜J˜9Jš
�˜—š�œ
�˜
J˜J˜J˜9š�œ�œ�˜+Jš
�˜J˜Jšœ�œ˜*Jš�œ
˜—Jš�œ
˜——J˜Jš�œ
˜J˜—šž
œ�	œ"˜:Jš
�˜˜"Jš
�˜Jš�œ�œ˜&š�œ"˜$Jš�œ1˜5—J˜#Jš�œ
˜—J˜J˜IJ˜Jš�œ
˜J˜—šž
œ�	œ˜/Jš
�˜Jšœ�œ
�œ�œ	˜4˜(J˜—J˜Jš�œ
˜J˜—šœ�œ�œ˜š�œ�˜Jšœ�œ
˜
Jšœ�œ
˜Jšœ�œ
˜
J˜2Jš�œ˜	J˜——šž
œ�	œ˜Jš	œ�œ
�œ�œ
�œ˜?Jš
�˜š�œ�œ
�˜J˜!J˜%šœ�œ�œ	˜Jš�œ�œ˜6Jš�œ�œ˜7—Jš�œ
˜—Jš�œ
˜J˜—šž
œ�	œ	�œ
�œ�œ�œ˜KJš
�˜š�œ	�˜
š�œ�œ
�œ�œ
�œ
�œ
�œ�œ
�œ
˜JJš�œ�œ�œ
�œ˜.Jš�œ
�œ�œ
�œ˜.——Jš�œ
˜J˜—Jš
žœ�	œ�œ
�œ
�œ
˜2J˜šœ�œ˜Jšœ�œ
�œ�œ˜IJ˜—šž	œ�	œ˜Jšœ�œ
�œ,˜AJš�œ
�œ˜ J˜š�œ>˜AJš�œ�˜Jš�œ�œ�œ˜CJš�œ
˜—J˜8Jš�œ
˜J˜—šžœ�	œ&˜9Jš
�˜Jš�œ�œ
�œ
˜J˜%Jš�œ
˜J˜—šžœ�	œ'˜:Jš
�˜Jš�œ�œ
�œ
˜J˜&Jš�œ
˜J˜J˜J˜—Jš
œ™J˜J˜Jš�œŸ˜J˜——…—‹€¿ß