DIRECTORY
AMBridge USING
[GetWorld, GetWorldIncarnation, GFHFromTV, IsRemote, Loophole, RemoteGFHFromTV, RemotePointer, RemoteRef, SetTVFromLC, SetTVFromLI, TVForPointerReferent, TVForReadOnlyReferent, TVForReferent, TVForRemotePointerReferent, TVForRemoteReferent, TVToCardinal, TVToLC, TVToLI, TVToProc, TVToRemoteProc, TVToRemoteSignal, TVToRef, TVToSignal, TVToWordSequence, WordSequence, WordSequenceRecord],
AMTypes USING
[Assign, Class, Domain, Error, First, Globals, IndexToName, IndexToType, IsAtom, IsComputed, IsOverlaid, IsRope, Last, Locals, NameToIndex, NComponents, Range, ReferentStatus, Size, Status, TVStatus, TVType, TypeClass, UnderType, VariableType, TV, TypedVariable, Index],
AtomPrivate USING[AtomRec],
Basics USING[bitsPerWord],
List USING[AList],
LoaderOps USING[GetFrame, IR, IRRecord, IsNullLink],
PrincOps USING[GlobalFrameHandle, ProcDesc, SignalDesc],
RemoteRope USING[RemoteFetch, RemoteLength, RopeFromTV],
Rope USING[Fetch, Length, ROPE, RopeRep],
RTCommon USING[FetchField, FetchFieldLong, ShortenLongCardinal, ShortenLongInteger],
RTSymbolDefs USING
[SymbolConstructorIndex, SymbolIdIndex, SymbolIndex, SymbolRecordIndex, SymbolTableBase],
RTSymbolOps USING
[AcquireSequenceType, AcquireType, IDCardinalInfo, IDCardinalValue, ISEConstant, ISEImmutable, ISEType, IsSequence, SEBitsForType, SEUnderType, IsTypeSEI],
RTSymbols USING[GetTypeSymbols, ReleaseSTB],
RTTCache USING[FillIntEntry, IntEntry, LookupInt],
RTTypesPrivate,
RTTypesRemotePrivate USING
[GetRemoteReferentType, GetRemoteWord, RemoteGFHToName, RemotePDToName, RemoteSEDToName, RemoteTypeToLocal],
SafeStorage USING
[anyType, EquivalentTypes, fhType, GetCanonicalType, GetReferentType, gfhType, nullType, Type, unspecType],
SafeStoragePrivate USING[NewObject],
WorldVM USING[Address, CurrentIncarnation, LocalWorld, Long, World];

RTTypedVariablesImpl: PROGRAM
IMPORTS
AMBridge, AMTypes, LoaderOps, RemoteRope, Rope, RTCommon, RTSymbolOps, RTSymbols, RTTCache, RTTypesPrivate, RTTypesRemotePrivate, SafeStorage, SafeStoragePrivate, WorldVM
EXPORTS AMTypes, AMBridge, RTTypesPrivate
SHARES Rope

= BEGIN OPEN
AMBridge, AMTypes, Basics, PrincOps, Rope, tp: RTTypesPrivate, RTCommon, SafeStoragePrivate, RTSymbolDefs, RTSymbolOps, RTSymbols, RTTCache, SafeStorage, RTTypesRemotePrivate, WorldVM;

TypedVariableRec: TYPE = tp.TypedVariableRec;
Pointer: TYPE = LONG POINTER --TO UNSPECIFIED--; 

underTYPE: Type = UnderType[CODE[Type]];

New: PUBLIC SAFE PROC
[type: Type, status: Status _ mutable, world: WorldVM.World _ NIL, tag: TV _ NIL]
RETURNS [newTV: TypedVariable] = TRUSTED {
variantClass: Class;
length: CARDINAL _ 0;

IF type = nullType THEN RETURN[NIL];
IF type = fhType OR type = gfhType THEN ERROR Error[reason: typeFault, type: type];
IF world = NIL THEN world _ WorldVM.LocalWorld[];

variantClass _ VariableType[type].c;

IF tag # NIL AND variantClass = sequence THEN length _ TVToCardinal[tag];
IF world # WorldVM.LocalWorld[]
THEN {
IF tag # NIL AND (variantClass = union OR variantClass = sequence) 
THEN {
ws: WordSequence _ NEW[WordSequenceRecord[Size[type, length]]];
newTV: TV _ NEW[TypedVariableRec _ [
referentType: [
type,
IF IsComputed[type] OR (variantClass = union AND IsOverlaid[type])
THEN tag
ELSE NIL],
head: [copiedRemoteObject [
world: world,
worldIncarnation: CurrentIncarnation[world],
copy: ws]],
status: status,
field: entire[]]];
newTag: TV;

IF IsComputed[type] OR (variantClass = union AND IsOverlaid[type])
THEN RETURN[newTV];

newTag _ Tag[LastComponent[newTV, type]];  -- assume sharing
NARROW[newTag, REF TypedVariableRec].status _ mutable;
Assign[lhs: newTag, rhs: tag];
NARROW[newTag, REF TypedVariableRec].status _ readOnly;
RETURN[newTV];
}
ELSE RETURN [
NEW[TypedVariableRec _ [
referentType: [type],
head: [copiedRemoteObject [
world: world,
worldIncarnation: CurrentIncarnation[world],
copy: NEW[WordSequenceRecord[Size[type]]]]],
status: status,
field: entire[]]]]}  -- end make a new remote TV
ELSE {
canon: Type = SafeStorage.GetCanonicalType[type];
newRef: REF = NewObject[type: canon, size: Size[type, length]];
internalTV: REF TypedVariableRec = NARROW[TVForReferent[newRef]];
internalTV.referentType _ [type];
newTV _ internalTV;

IF tag # NIL AND (variantClass = union OR variantClass = sequence) THEN
IF IsComputed[type] OR (variantClass = union AND IsOverlaid[type])
THEN internalTV.referentType.tag _ tag
ELSE {
newTag: REF TypedVariableRec _ NARROW[Tag[LastComponent[newTV, type]]];
IF newTag # NIL THEN {
newTag.status _ mutable;
Assign[lhs: newTag, rhs: tag];
newTag.status _ readOnly;
};
};

RETURN[newTV];
};
};  -- end New

TVTag: PROC[tv: TypedVariable] RETURNS[TV] = {
RETURN[NARROW[tv, REF TypedVariableRec].referentType.tag];
};

TVSize: PUBLIC SAFE PROC[tv: TypedVariable] RETURNS[INT--words--] = TRUSTED {
type: Type = UnderType[TVType[tv]];
vClass: Class _ nil;
class: Class _ TypeClass[type];
SELECT class FROM
localFrame => RETURN [TVSize[AMTypes.Locals[tv]]];
globalFrame => RETURN [TVSize[AMTypes.Globals[tv]]];
record, structure, sequence, union => {
SELECT class FROM
record, structure => vClass _ VariableType[type].c;
sequence, union => vClass _ class;
ENDCASE;
IF vClass # nil THEN {
IF (IsOverlaid[type] OR IsComputed[type]) AND TVTag[tv] = NIL
THEN RETURN[Size[type: type]];
SELECT vClass FROM
union =>
RETURN [TVSize[Variant[LastComponent[tv, type]]]];
sequence =>
RETURN [Size[type: type, length: Length[LastComponent[tv, type]]]]
ENDCASE;
};
};
nil, ref, list, atom, rope, longPointer, basePointer, longCardinal, longInteger, real, countedZone, uncountedZone => RETURN [2];
integer, cardinal, character, pointer, unspecified, process, type, relativePointer, procedure, signal, error, program, port => RETURN [1];
ENDCASE;
RETURN[Size[type: type]];
};

Tag: PUBLIC SAFE PROC[tv: TypedVariable--union, sequence--]
RETURNS[ans: TypedVariable] = TRUSTED {
type: Type = TVType[tv];
stb: SymbolTableBase;
sei: SymbolIndex;
kludgeBits: NAT _ 0;

IF TVTag[tv] # NIL THEN RETURN[TVTag[tv]]; 
IF IsComputed[type] OR IsOverlaid[type] THEN RETURN[NIL];

[stb, sei] _ GetTypeSymbols[type];
{ENABLE UNWIND => ReleaseSTB[stb];
tagSei: SymbolIdIndex;
WITH stb SELECT FROM
t: SymbolTableBase.x =>
WITH ser: t.e.seb[t.e.UnderType[NARROW[sei, SymbolIndex.x].e]] SELECT FROM
union => tagSei _ [x[ser.tagSei]];
sequence => tagSei _ [x[ser.tagSei]];
ENDCASE => ERROR Error[reason: typeFault, type: type];
t: SymbolTableBase.y =>
WITH ser: t.e.seb[t.e.UnderType[NARROW[sei, SymbolIndex.x].e]] SELECT FROM
union => tagSei _ [y[ser.tagSei]];
sequence => tagSei _ [y[ser.tagSei]];
ENDCASE => ERROR Error[reason: typeFault, type: type];
ENDCASE => ERROR;

IF ISEConstant[stb, tagSei] THEN ERROR;
WITH tv SELECT FROM
rtr: REF tp.TypedVariableRec =>
WITH etr: rtr SELECT FROM
constant => {
ntv: TV _ AMBridge.TVForReadOnlyReferent[etr.value];
tv _ AMBridge.Loophole[ntv, type];
kludgeBits _ bitsPerWord;
};
ENDCASE;
ENDCASE;

ans _ NEW[TypedVariableRec _ [
referentType: [Domain[type]],
head: (WITH tv SELECT FROM
tr: REF TypedVariableRec => tr.head,
ENDCASE => ERROR),
status: readOnly,
field: embedded[fd: BuildRecordFieldDescriptor [
parentTV: tv,
fieldBitOffset: kludgeBits + IDCardinalValue[stb, tagSei],
fieldBits: IDCardinalInfo[stb, tagSei],
bitsForType: SEBitsForType[stb, ISEType[stb, tagSei]]
]]
]];
};
ReleaseSTB[stb];
};  -- end Tag

Variant: PUBLIC SAFE PROC[tv: TypedVariable--union--]
RETURNS[ans: TypedVariable _ NIL--record--] = TRUSTED {
type: Type = TVType[tv];
p: PROC[stb: SymbolTableBase, isei: SymbolIdIndex] = {
wordOffset: NAT _ 0;
cType: Type _ AcquireType[
stb,
LOOPHOLE[SEUnderType[stb, LOOPHOLE[isei, SymbolIndex]], SymbolIndex]];
ans _ AMBridge.Loophole[tv, cType];
};  -- end p

IF LocalUnderClass[type] # union THEN ERROR Error[reason: typeFault, type: type];
tp.ComponentISEI[type, NameToIndex[type, TVToName[Tag[tv]]], p];
};

IndexToTV: PUBLIC SAFE PROC[tv: TypedVariable--record, structure--, index: Index]
RETURNS[TypedVariable] = TRUSTED {
cType: Type;
type: Type _ UnderType[TVType[tv]];
et: REF TypedVariableRec;
argRec: BOOL;
interfaceRec: BOOL;
bitsForTV: LONG CARDINAL;

BuildEmbeddedTV: PROC[stb: SymbolTableBase, isei: SymbolIdIndex] = {
sei: SymbolIndex = ISEType[stb, isei];
csei: SymbolConstructorIndex _ SEUnderType[stb, sei];
bitsForType: CARDINAL _ SEBitsForType[stb, sei];
fieldBits: CARDINAL _ IDCardinalInfo[stb, isei];
fieldBitOffset: CARDINAL _ IF argRec
THEN (WITH stb SELECT FROM
t: SymbolTableBase.x =>
t.e.FnField[NARROW[isei, SymbolIdIndex.x].e].offset.wd*bitsPerWord,
t: SymbolTableBase.y =>
t.e.FnField[NARROW[isei, SymbolIdIndex.y].e].offset.wd*bitsPerWord,
ENDCASE => ERROR)
ELSE IF interfaceRec
THEN IDCardinalValue[stb, isei]*bitsPerWord
ELSE IDCardinalValue[stb, isei];

isSequence: BOOL _ FALSE;

WITH stb SELECT FROM  -- NOTE SymbolPack bug workaround
t: SymbolTableBase.x =>
WITH cse: t.e.seb[NARROW[csei, SymbolConstructorIndex.x].e] SELECT FROM
relative => bitsForType _ t.e.BitsForType[cse.offsetType];
ENDCASE;
t: SymbolTableBase.y =>
WITH cse: t.e.seb[NARROW[csei, SymbolConstructorIndex.y].e] SELECT FROM
relative => bitsForType _ t.e.BitsForType[cse.offsetType];
ENDCASE
ENDCASE => ERROR;

IF (NOT Embedded[tv]) AND bitsForTV < bitsPerWord
THEN fieldBitOffset _ fieldBitOffset + bitsPerWord - ShortenLongCardinal[bitsForTV];

IF IsSequence[stb, sei]
THEN {
recstb: SymbolTableBase;
recsei: SymbolIndex;
[recstb, recsei] _ GetTypeSymbols[type];
cType _ AcquireSequenceType[
stb, sei, recstb, LOOPHOLE[recsei, SymbolRecordIndex]
! UNWIND => ReleaseSTB[recstb]];
isSequence _ TRUE;
ReleaseSTB[recstb]}
ELSE cType _ AcquireType[stb, sei];
SELECT TRUE FROM
ISEConstant[stb, isei] => {
ENABLE Error => IF reason = notImplemented THEN GOTO nimp;
IF IsRemote[tv] AND NOT IsTypeSEI[ISEType[stb, isei]]
THEN et _ NEW[TypedVariableRec _ [
referentType: [cType, TVTag[tv]],
head: [remoteConstant [
world: GetWorld[tv],
worldIncarnation: GetWorldIncarnation[tv]]],
status: const,
field: constant[value: tp.GetIdConstantValue[tv, stb, isei]]
]]
ELSE et _ NEW[TypedVariableRec _ [
referentType: [cType, TVTag[tv]],
head: [constant[]],
status: const,
field: constant[value: tp.GetIdConstantValue[tv, stb, isei]]
]];
EXITS nimp => et _ NIL};
interfaceRec AND NOT IsInterfaceElementType[cType] => {
fD: tp.FieldDescriptor;
headP: Pointer;
ptr: POINTER;
status: Status _ mutable;
ir: LoaderOps.IR;

IF IsRemote[tv] THEN
ERROR Error[reason: notImplemented, msg: "remote interface variables"];
WITH tv SELECT FROM
tr: REF TypedVariableRec =>
WITH head: tr.head SELECT FROM
reference => ir _ NARROW[head.ref, LoaderOps.IR];
ENDCASE => ERROR Error[reason: internalTV];
ENDCASE => ERROR;

fD _ BuildRecordFieldDescriptor[tv, fieldBitOffset, 16, 16];

headP _ LOOPHOLE[ir, Pointer];
ptr _ LOOPHOLE[headP + fD.wordOffset, LONG POINTER TO POINTER]^;

IF LoaderOps.IsNullLink[ptr] THEN {et _ NIL; RETURN};  -- not bound

WITH stb SELECT FROM
t: SymbolTableBase.x =>
WITH e: t.e.seb[NARROW[csei, SymbolConstructorIndex.x].e] SELECT FROM
ref => IF e.var
THEN {cType _ AcquireType[stb, [x[e.refType]]];
IF e.readOnly THEN status _ readOnly}
ELSE {IF ISEImmutable[stb, isei] THEN status _ readOnly};
ENDCASE => IF ISEImmutable[stb, isei] THEN status _ readOnly;
t: SymbolTableBase.y =>
WITH e: t.e.seb[NARROW[csei, SymbolConstructorIndex.y].e] SELECT FROM
ref => IF e.var
THEN {cType _ AcquireType[stb, [y[e.refType]]];
IF e.readOnly THEN status _ readOnly}
ELSE {IF ISEImmutable[stb, isei] THEN status _ readOnly};
ENDCASE => IF ISEImmutable[stb, isei] THEN status _ readOnly;
ENDCASE => ERROR;

{
gfh: GlobalFrameHandle = LoaderOps.GetFrame[
interface: ir,
index: fD.wordOffset - SIZE[LoaderOps.IRRecord]];
et _ NEW[TypedVariableRec _ [
referentType: [cType],
head: [gfh[gfh: gfh]],
status: status,
field: embedded
[fd: BuildLargeFieldDescriptor[wordOffset: ptr-gfh, nWords: Size[cType]]]
]];
};
};
Constant[tv] =>
WITH tv SELECT FROM
tr: REF constant TypedVariableRec => {
wordOffset: CARDINAL _ fieldBitOffset / bitsPerWord;
words: CARDINAL _ fieldBits / bitsPerWord;
ws: WordSequence _ NEW[WordSequenceRecord[MAX[1, words]]];
IF words > 0 
THEN {
lim: NAT = tr.value.size;
FOR i: NAT IN [0..words) DO
ws[i] _ IF (i+wordOffset) >= lim THEN 0 ELSE tr.value[i+wordOffset];
ENDLOOP;
}
ELSE {
ws[0] _ FetchField[
@tr.value[wordOffset],
[bitFirst: fieldBitOffset MOD bitsPerWord, bitCount: fieldBits]];
};
IF IsRemote[tv]
THEN et _ NEW[TypedVariableRec _ [
referentType: [cType, TVTag[tv]],
head: [remoteConstant [
world: GetWorld[tv],
worldIncarnation: GetWorldIncarnation[tv]]],
status: const,
field: constant[value: ws]
]]
ELSE et _ NEW [TypedVariableRec _ [
referentType: [cType, TVTag[tv]],
head: [constant[]],
status: const,
field: constant[value: ws]
]];
};
ENDCASE => ERROR
ENDCASE => {
under: Type = UnderType[cType];
forceWords: BOOL _ FALSE;
wordOffset: CARDINAL _ 0;
SELECT TypeClass[under] FROM
union => {
IF fieldBits < bitsPerWord
THEN bitsForType _ fieldBits
ELSE forceWords _ TRUE;
};
sequence => forceWords _ TRUE;
ENDCASE;
IF forceWords THEN
WITH tv SELECT FROM
embed: REF embedded TypedVariableRec =>
wordOffset _ embed.fd.wordOffset;
ENDCASE;
et _ NEW[TypedVariableRec _ [
referentType: [cType, TVTag[tv]],
head: (WITH tv SELECT FROM
tr: REF TypedVariableRec => tr.head,
ENDCASE => ERROR),  -- [reference[ref: tv]]),
status: (
IF NOT interfaceRec AND ISEImmutable[stb, isei]
THEN readOnly
ELSE TVStatus[tv]),
field: embedded[fd: (
IF forceWords
THEN [wordOffset: wordOffset, extent: large[size: Size[type, 0]]]
ELSE BuildRecordFieldDescriptor[tv, fieldBitOffset, fieldBits, bitsForType]
)]]];
IF isSequence THEN {
entry: RTTCache.IntEntry = RTTCache.LookupInt[under, GetSequenceOffset];
words: INT = Size[type, GetSequenceLength[et]];
WITH x: et SELECT FROM
embedded => x.fd.extent _ large[size: words];
ENDCASE => ERROR;
IF NOT entry.valid THEN
[] _ RTTCache.FillIntEntry[entry, Size[type, 0]];
};
}};  -- END BuildEmbeddedTV

[bitsForTV, argRec, interfaceRec] _ tp.BitsForType[type];
tp.RecordComponentISEI[type, index, BuildEmbeddedTV];
RETURN[et];
};  -- end IndexToTV

GetSequenceOffset: SAFE PROC [type: Type] RETURNS [offset: INT] = TRUSTED {
entry: RTTCache.IntEntry _ RTTCache.LookupInt[type, GetSequenceOffset];
offset _ entry.int;
};

GetSequenceLength: SAFE PROC [tv: TV] RETURNS [length: INT _ 0] = TRUSTED {
tag: TV = Tag[tv];
IF tag # NIL THEN {
tagType: Type = TVType[tag];
length _ TVToLI[tag];
SELECT LocalUnderClass[tagType] FROM
integer, longInteger, cardinal, longCardinal => {};
ENDCASE => length _ length - TVToLI[First[tagType]];
};
};

IsInterfaceElementType: PROC[type: Type] RETURNS[BOOL] = {
SELECT LocalUnderClass[type] FROM
program, procedure, signal, error => RETURN[TRUE];
ENDCASE => RETURN[FALSE];
};

TVToType: PUBLIC SAFE PROC[tv: TypedVariable--type--] RETURNS[rtn: Type] = TRUSTED {
type: Type = UnderType[TVType[tv]];
class: Class _ TypeClass[type];
IF type = underTYPE THEN class _ type;
SELECT class FROM
type =>
IF IsRemote[tv]
THEN rtn _ RemoteTypeToLocal[world: GetWorld[tv], remoteType: TVToCardinal[tv]]
ELSE rtn _ LOOPHOLE[TVToCardinal[tv], Type];
ENDCASE => ERROR Error[reason: typeFault, type: type];
};

PropertyList: PUBLIC SAFE PROC
[tv: TypedVariable--atom--] RETURNS[rtn: TV--list--] = TRUSTED {
type: Type = UnderType[TVType[tv]];
SELECT TypeClass[type] FROM  -- NOTE assumption of remote AtomRec identity
atom =>
rtn _ Loophole[
IndexToTV[
Loophole[tv, CODE[REF AtomPrivate.AtomRec]],
NameToIndex[CODE[AtomPrivate.AtomRec], "propList"]],
CODE[List.AList]]; 
ENDCASE => ERROR Error[reason: typeFault, type: type];
};

TVToName: PUBLIC SAFE PROC [tv: TypedVariable] RETURNS[ans: ROPE _ NIL] = TRUSTED {
type: Type = UnderType[TVType[tv]];
world: World = GetWorld[tv];
SELECT TypeClass[type] FROM
ref => {
target: Type;
SELECT TRUE FROM
IsAtom[tv] => target _ CODE[ATOM];
IsRope[tv] => target _ CODE[ROPE];
ENDCASE => ERROR Error[reason: typeFault, type: type];
ans _ TVToName[Coerce[tv, target]];
};
atom =>
SELECT TRUE FROM
IsRemote[tv] =>
ans _ RemoteRope.RopeFromTV[
TVForRemotePointerReferent[
remotePointer: [
world: world, worldIncarnation: CurrentIncarnation[world], ptr: TVToLC[tv]],
type: CODE[ROPE]]];
TVToLC[tv] # 0 =>
ans _ NARROW[TVToRef[tv], REF AtomPrivate.AtomRec].pName;
ENDCASE;
rope =>
IF IsRemote[tv]
THEN ans _ RemoteRope.RopeFromTV[tv]
ELSE ans _ NARROW[TVToRef[tv], ROPE];
enumerated  => {
index: INT = TVToLC[tv] + 1;
IF index > LAST[CARDINAL] THEN
ERROR Error[reason: notImplemented, msg: "gigantic enumerations", type: type];
ans _ IndexToName[type, index];
};
program, procedure  =>
IF IsRemote[tv]
THEN ans _ RemotePDToName[TVToRemoteProc[tv]]
ELSE ans _ tp.PDToName[LOOPHOLE[TVToProc[tv], ProcDesc]];
signal, error  => 
IF IsRemote[tv]
THEN ans _ RemoteSEDToName[TVToRemoteSignal[tv]]
ELSE ans _ tp.SEDToName[LOOPHOLE[TVToSignal[tv], SignalDesc]];
globalFrame  => 
IF IsRemote[tv]
THEN ans _ RemoteGFHToName[RemoteGFHFromTV[tv]]
ELSE ans _ tp.GFHToName[GFHFromTV[tv]];
ENDCASE;
};

Apply: PUBLIC SAFE PROC[mapper: TV--array, sequence, descriptor, longDescriptor--, arg: TV]
RETURNS[embeddedTV: TV] = TRUSTED {
type: Type _ UnderType[TVType[mapper]];
computed: BOOL _ IsComputed[type];
stb: SymbolTableBase;
sei: SymbolIndex;
class: Class = TypeClass[type];
IF mapper = NIL THEN ERROR Error[reason: typeFault, type: type];
IF class = descriptor OR class = longDescriptor
THEN {
ws: WordSequence = TVToWordSequence[mapper];
wsd: LONG POINTER TO DESCRIPTOR FOR ARRAY OF WORD = LOOPHOLE[@ws[0]];
wsld: LONG POINTER TO LONG DESCRIPTOR FOR ARRAY OF WORD = LOOPHOLE[wsd];
length: CARDINAL = IF class = descriptor THEN LENGTH[wsd^] ELSE LENGTH[wsld^];
type _ Range[type];
IF TVToCardinal[arg] >= length THEN ERROR Error[reason: rangeFault];
IF IsRemote[mapper]
THEN mapper _ TVForRemotePointerReferent[
remotePointer: [
world: GetWorld[mapper],
worldIncarnation: GetWorldIncarnation[mapper],
ptr: IF class = descriptor
THEN LOOPHOLE[LONG[BASE[wsd^]], WorldVM.Address]
ELSE LOOPHOLE [BASE[wsld^], WorldVM.Address]],
type: type,
status: ReferentStatus[TVType[mapper]]]
ELSE mapper _ TVForPointerReferent [
ptr: IF class = descriptor THEN BASE[wsd^] ELSE BASE[wsld^],
type: type,
status: ReferentStatus[TVType[mapper]]]};
[stb, sei] _ GetTypeSymbols[type];
{ENABLE UNWIND => ReleaseSTB[stb];
eltTypeEi: SymbolIndex;
domainType: Type = Domain[type];
upperLimit: INT _ TVToLI[Last[domainType]];
domainOffset: INT _ IF EquivalentTypes[domainType, CODE[INTEGER]]
THEN 0
ELSE TVToLI[First[domainType]];
argValue: INT = TVToLI[arg];
bitOffset: INT;
bitsPerElement: CARDINAL;
tagEndOffset: INTEGER _ 0;
isPacked: BOOL _ FALSE;
isSequence: BOOL _ FALSE;
fd: tp.FieldDescriptor;

WITH stb SELECT FROM
t: SymbolTableBase.x =>
WITH ser: t.e.seb[t.e.UnderType[NARROW[sei, SymbolIndex.x].e]] SELECT FROM
array => {isPacked _ ser.packed; eltTypeEi _ [x[ser.componentType]]};
sequence => {
isPacked _ ser.packed;
isSequence _ TRUE;
eltTypeEi _ [x[ser.componentType]];
tagEndOffset _ IF computed
THEN 0
ELSE (t.e.seb[ser.tagSei].idInfo + t.e.seb[ser.tagSei].idValue)};
ENDCASE => ERROR Error[reason: typeFault, type: TVType[mapper]];
t: SymbolTableBase.y =>
WITH ser: t.e.seb[t.e.UnderType[NARROW[sei, SymbolIndex.y].e]] SELECT FROM
array => {isPacked _ ser.packed; eltTypeEi _ [y[ser.componentType]]};
sequence => {
isPacked _ ser.packed;
isSequence _ TRUE;
eltTypeEi _ [y[ser.componentType]];
tagEndOffset _ IF computed
THEN 0
ELSE (t.e.seb[ser.tagSei].idInfo + t.e.seb[ser.tagSei].idValue)};
ENDCASE => ERROR Error[reason: typeFault, type: TVType[mapper]];
ENDCASE => ERROR;

IF isSequence AND computed THEN
tagEndOffset _ GetSequenceOffset[type] * bitsPerWord;

IF NOT computed THEN {
IF isSequence THEN
upperLimit _ TVToLI[Tag[mapper]] - 1;
IF (~InRange[domainType, arg] OR argValue > upperLimit) THEN
ERROR Error[reason: rangeFault];
};

WITH stb SELECT FROM
t: SymbolTableBase.x =>
bitsPerElement _ t.e.BitsPerElement[type: NARROW[eltTypeEi, SymbolIndex.x].e, packed: isPacked];
t: SymbolTableBase.y =>
bitsPerElement _ t.e.BitsPerElement[type: NARROW[eltTypeEi, SymbolIndex.y].e, packed: isPacked];
ENDCASE => ERROR;
bitOffset _ tagEndOffset + (argValue - domainOffset) * bitsPerElement;

IF (class # descriptor) AND (class # longDescriptor)
AND (NOT isSequence) AND (NOT Embedded[mapper])
THEN {
bitsForTV: LONG CARDINAL _ 0;
[bitsForTV,,] _ tp.BitsForType[type];
IF bitsForTV < bitsPerWord THEN
bitOffset _ bitOffset + bitsPerWord - ShortenLongCardinal[bitsForTV];
};

fd _ BuildRecordFieldDescriptor [
mapper,
bitOffset,
bitsPerElement,
(WITH stb SELECT FROM
t: SymbolTableBase.x =>t.e.BitsForType[type: NARROW[eltTypeEi, SymbolIndex.x].e],
t: SymbolTableBase.y =>t.e.BitsForType[type: NARROW[eltTypeEi, SymbolIndex.y].e],
ENDCASE => ERROR)];

{  -- for defn of mapperTVRec
mapperTVRec: REF TypedVariableRec = NARROW[mapper, REF TypedVariableRec];
WITH h: mapperTVRec.head SELECT FROM 
constant, remoteConstant => {  -- can't have an embedded const tvrec (sigh)
ws: WordSequence;
value: WordSequence
= WITH mtvr: mapperTVRec SELECT FROM
constant => mtvr.value,
ENDCASE => ERROR;
WITH ee: fd SELECT FROM
small => {
words: CARDINAL = IF ee.field.bitCount <= Basics.bitsPerWord THEN 1 ELSE 2;
ws _ NEW[WordSequenceRecord[words]];
IF words = 1
THEN
LOOPHOLE[@ws[0], LONG POINTER TO CARDINAL]^
_ RTCommon.FetchField[@value[0] + ee.wordOffset, ee.field]
ELSE
LOOPHOLE[@ws[0], LONG POINTER TO LONG CARDINAL]^
_ RTCommon.FetchFieldLong[@value[0] + ee.wordOffset, ee.field];
};
large => {
words: CARDINAL = ee.size;
ws _ NEW[WordSequenceRecord[words]];
FOR i: CARDINAL IN [0..words) DO
ws[i] _ value[i + ee.wordOffset]
ENDLOOP;
};
ENDCASE => ERROR;
embeddedTV _ NEW[TypedVariableRec _ [
referentType: [Range[type]],
head: h,
status: mapperTVRec.status, 
field: constant[value: ws]]];
}
ENDCASE =>
embeddedTV _ NEW[TypedVariableRec _ [
referentType: [Range[type]],
head: h,
status: mapperTVRec.status, 
field: embedded[fd: fd]]];
};  -- end scope of mapperTVRec defn
};  -- end ENABLE UNWIND
ReleaseSTB[stb];
};  -- end Apply

Fetch: PUBLIC SAFE PROC[tv: TypedVariable--rope--, index: INT] RETURNS [CHAR] = TRUSTED {
type: Type = TVType[tv];
SELECT LocalUnderClass[type] FROM
rope => IF IsRemote[tv]
THEN RETURN[RemoteRope.RemoteFetch[tv, index]]
ELSE RETURN[Rope.Fetch[TVToName[tv], index]];
ENDCASE;
ERROR Error[reason: typeFault, type: type]};

OctalRead: PUBLIC SAFE PROC
[tv: TypedVariable, offset: INT] RETURNS[ans: CARDINAL] = TRUSTED {
addr: tp.ValueAddress = tp.GetValueAddress[tv];
WITH t: addr SELECT FROM
constant => ans _ t.value[offset];
pointer => ans _ LOOPHOLE[t.ptr + offset, LONG POINTER TO CARDINAL]^;
remotePointer => ans _ 
RTTypesRemotePrivate.GetRemoteWord[[
world: GetWorld[tv],
worldIncarnation: GetWorldIncarnation[tv],
ptr: t.ptr.ptr + offset]];
copiedRemoteObject => ans _ LOOPHOLE[t.ptr + offset, LONG POINTER TO CARDINAL]^;
ENDCASE => ERROR;
};

Length: PUBLIC SAFE PROC
[tv: TV --sequence, rope, descriptor, longDescriptor--] RETURNS[INT] = TRUSTED {
type: Type = UnderType[TVType[tv]];
SELECT TypeClass[type] FROM
sequence =>
RETURN[GetSequenceLength[tv]];
rope =>
IF IsRemote[tv]
THEN RETURN[RemoteRope.RemoteLength[tv]]
ELSE RETURN[Rope.Length[TVToName[tv]]];
descriptor => {
ws: WordSequence = TVToWordSequence[tv];
RETURN[LENGTH[LOOPHOLE[
@ws[0],
LONG POINTER TO DESCRIPTOR FOR ARRAY OF WORD]^]]};
longDescriptor =>  {
ws: WordSequence = TVToWordSequence[tv];
RETURN[LENGTH[LOOPHOLE[
@ws[0],
LONG POINTER TO LONG DESCRIPTOR FOR ARRAY OF WORD]^]]};
ENDCASE =>
ERROR Error[reason: typeFault, type: type];
};

Loophole: PUBLIC PROC
[tv: TypedVariable, type: Type, tag: TypedVariable _ NIL] RETURNS[TypedVariable] = {
variantClass: Class = VariableType[type].c;
IF tag # NIL AND variantClass # union AND variantClass # sequence
THEN ERROR Error[reason: typeFault, type: type, msg: "non-NIL tag makes no sense"];
WITH tv SELECT FROM
tvr: REF TypedVariableRec =>
WITH tvr: tvr SELECT FROM
entire =>
RETURN[NEW[TypedVariableRec _ [
referentType: [type, tag],
head: tvr.head,
status: tvr.status,
field: entire[]]]];
embedded => 
RETURN[NEW[TypedVariableRec _ [
referentType: [type, tag],
head: tvr.head,
status: tvr.status,
field: embedded[fd: tvr.fd]]]];
constant =>
RETURN[NEW[TypedVariableRec _ [
referentType: [type, tag],
head: tvr.head,
status: tvr.status,
field: constant[value: tvr.value]]]];
ENDCASE => ERROR;
ENDCASE => ERROR;
};

ConcreteRef: PUBLIC SAFE PROC
[tv: TypedVariable--ref any--] RETURNS[ans: TypedVariable _ NIL] = TRUSTED {
type: Type _ UnderType[TVType[tv]];
class: Class _ TypeClass[type];
target: Type _ nullType;
IF class = nil OR TVToLC[tv] = 0 THEN RETURN[NIL];
IF class = atom OR class = rope OR class = list OR class = countedZone THEN RETURN[tv];
IF class # ref THEN ERROR Error[reason: typeFault, type: type];
IF TypeClass[Range[type]] # any THEN RETURN[tv];
SELECT TRUE FROM
IsAtom[tv] => target _ CODE[ATOM];
IsRope[tv] => target _ CODE[ROPE];
ENDCASE => {
realSourceRangeType: Type;
IF IsRemote[tv]
THEN {
r: RemoteRef = [
world: GetWorld[tv], worldIncarnation: GetWorldIncarnation[tv], ref: TVToLC[tv]];
realSourceRangeType _ RTTypesRemotePrivate.GetRemoteReferentType[r]}
ELSE realSourceRangeType _ GetReferentType[TVToRef[tv]];
IF LocalUnderClass[realSourceRangeType] = structure
AND NComponents[UnderType[realSourceRangeType]] = 2
AND LocalUnderClass[IndexToType[realSourceRangeType, 2]] = list
THEN target _ IndexToType[realSourceRangeType, 2];
};
IF target # nullType THEN RETURN [Coerce[tv, target]];
ERROR Error[
reason: notImplemented,
msg: "ConcreteRef for other than ATOM, ROPE or LIST targets"];
};

IsNil: PUBLIC SAFE PROC[tv: TypedVariable--address--] RETURNS [BOOL] = TRUSTED {
SELECT LocalUnderClass[TVType[tv]] FROM
relativePointer, atom, rope, list, ref, pointer, longPointer, basePointer, countedZone, uncountedZone, process, procedure, signal, error, program, port =>
RETURN[TVToLC[tv] = 0];
nil => RETURN[TRUE];
descriptor => {
ws: WordSequence = TVToWordSequence[tv];
RETURN[NIL = BASE[LOOPHOLE
[@ws[0], LONG POINTER TO DESCRIPTOR FOR ARRAY OF WORD]^]]};
longDescriptor => {
ws: WordSequence = TVToWordSequence[tv];
RETURN[NIL = BASE[LOOPHOLE
[@ws[0], LONG POINTER TO LONG DESCRIPTOR FOR ARRAY OF WORD]^]]};
ENDCASE => ERROR Error[typeFault];
};

Referent: PUBLIC SAFE PROC
[
tv: TypedVariable,  --ref, list, pointer, longPointer, basePointer, relativePointer--
base: TypedVariable _ NIL
]
RETURNS[TypedVariable] = TRUSTED {
type: Type _ TVType[tv];
referentType: Type _ Range[type];  -- raises Error[typeFault]
status: Status _ mutable;
ptr: Pointer;
stb: SymbolTableBase;
sei: SymbolIndex;
[stb, sei] _ GetTypeSymbols[type];
WITH stb SELECT FROM
t: SymbolTableBase.x => {
ENABLE UNWIND => ReleaseSTB[stb];
WITH ser: t.e.seb[t.e.UnderType[NARROW[sei, SymbolIndex.x].e]] SELECT FROM
long => WITH ser1: t.e.seb[t.e.UnderType[ser.rangeType]] SELECT FROM
ref => IF ser1.readOnly THEN status _ readOnly;
ENDCASE => ERROR Error[reason: typeFault, type: type];
ref => IF ser.readOnly THEN status _ readOnly;
relative => NULL;
ENDCASE => ERROR Error[reason: typeFault, type: type]};
t: SymbolTableBase.y => {
ENABLE UNWIND => ReleaseSTB[stb];
WITH ser: t.e.seb[t.e.UnderType[NARROW[sei, SymbolIndex.y].e]] SELECT FROM
long => WITH ser1: t.e.seb[t.e.UnderType[ser.rangeType]] SELECT FROM
ref => IF ser1.readOnly THEN status _ readOnly;
ENDCASE => ERROR Error[reason: typeFault, type: type];
ref => IF ser.readOnly THEN status _ readOnly;
relative => NULL;
ENDCASE => ERROR Error[reason: typeFault, type: type]};
ENDCASE => ERROR;
ReleaseSTB[stb];

IF referentType = unspecType THEN ERROR Error[reason: typeFault, type: referentType];
IF IsRemote[tv]
THEN
SELECT LocalUnderClass[type] FROM
relativePointer => {
world: World = GetWorld[tv];
ptr: RemotePointer = [
world: world,
worldIncarnation: CurrentIncarnation[world],
ptr: TVToLC[base] + TVToCardinal[tv]];
IF NOT LocalUnderClass[TVType[base]] = basePointer
THEN ERROR Error[reason: typeFault, type: TVType[base]];
RETURN[TVForRemotePointerReferent
[remotePointer: ptr, type: referentType, status: status]]};
ref, list => {
world: World = GetWorld[tv];
ref: RemoteRef = [world: world,
worldIncarnation: CurrentIncarnation[world],
ref: TVToLC[tv]];
RETURN[TVForRemoteReferent[remoteRef: ref, status: status]]};
pointer => {
world: World = GetWorld[tv];
ptr: RemotePointer = [
world: world,
worldIncarnation: CurrentIncarnation[world],
ptr: Long[world: world, addr: TVToCardinal[tv]]];
IF LocalUnderClass[referentType] = opaque
THEN ERROR Error[reason: typeFault, type: referentType];
RETURN[TVForRemotePointerReferent
[remotePointer: ptr, type: referentType, status: status]]};
longPointer, basePointer => {
world: World = GetWorld[tv];
IF LocalUnderClass[referentType] = opaque
THEN ERROR Error[reason: typeFault, type: referentType];
RETURN[TVForRemotePointerReferent [
remotePointer: [world: world,
worldIncarnation: CurrentIncarnation[world],
ptr: TVToLC[tv]],
type: referentType,
status: status]]};
ENDCASE => ERROR  -- end IsRemote[tv]
ELSE  -- local tv
SELECT LocalUnderClass[type] FROM
relativePointer => {
IF NOT LocalUnderClass[TVType[base]] = basePointer
THEN ERROR Error[reason: typeFault, type: TVType[base]];
ptr _ LOOPHOLE[TVToLC[base] + TVToCardinal[tv], Pointer];
RETURN[TVForPointerReferent[ptr: ptr, type: referentType, status: status]]};
ref, list => RETURN[TVForReferent[ref: TVToRef[tv], status: status]];
pointer => {
ptr _ LONG[LOOPHOLE[TVToCardinal[tv], POINTER]];
IF LocalUnderClass[referentType] = opaque
THEN ERROR Error[reason: typeFault, type: referentType];
RETURN[TVForPointerReferent[
ptr: ptr,
type: referentType,
status: status]]};
longPointer, basePointer => {
ptr _ LOOPHOLE[TVToLC[tv], Pointer];
IF LocalUnderClass[referentType] = opaque
THEN ERROR Error[reason: typeFault, type: referentType];
RETURN[TVForPointerReferent[
ptr: ptr,
type: referentType,
status: status]]};
ENDCASE => ERROR;
};  -- end Referent

Coerce: PUBLIC SAFE PROC
[tv: TypedVariable, targetType: Type] RETURNS[newTV: TypedVariable] = TRUSTED {
type: Type = TVType[tv];
{-- block for common errors
tvr: REF TypedVariableRec; -- utility
targetClass, sourceClass: Class;

IF type = targetType THEN RETURN[tv];
IF EquivalentTypes[type, targetType] THEN GO TO loophole;

targetClass _ LocalUnderClass[targetType];
sourceClass _ LocalUnderClass[type];

IF sourceClass = record AND AMTypes.NComponents[type] = 1 THEN {
element: TV _ IndexToTV[tv, 1];
SELECT LocalUnderClass[TVType[element]] FROM
union => element _ Variant[element];
sequence => GO TO error;
ENDCASE;
RETURN [Coerce[element, targetType]];
};

IF sourceClass = nil OR (sourceClass = ref AND TVToLC[tv] = 0) THEN
SELECT targetClass FROM
list, procedure, signal, error, program, port, ref, pointer, longPointer, rope, atom, unspecified, countedZone, uncountedZone, process, nil, descriptor, longDescriptor, basePointer, relativePointer =>
RETURN [New[targetType, readOnly]];
ENDCASE => GO TO error;

IF sourceClass = ref AND LocalUnderClass[Range[type]] = opaque
THEN RETURN[Coerce[Loophole[tv, CODE[REF ANY]], targetType]];

SELECT targetClass FROM
unspecified =>
IF TVSize[tv] = 1 THEN GO TO loophole ELSE GO TO error;
procedure => {
SELECT sourceClass FROM  -- look at the source type
procedure => {
IF LocalUnderClass[Domain[targetType]] = any
AND LocalUnderClass[Range[targetType]] = any
THEN {
IF IsRemote[tv]
THEN newTV _ NEW[TypedVariableRec _ [
referentType: [targetType],
head: [copiedRemoteObject [
world: GetWorld[tv],
worldIncarnation: GetWorldIncarnation[tv],
copy: NEW[WordSequenceRecord[1]]]],
status: mutable,
field: entire[]]]
ELSE newTV _ New[type: targetType];
Assign[lhs: newTV, rhs: Loophole[tv, targetType]];
}
ELSE GO TO error;
};
nil => RETURN[NIL];  -- NIL conforms to any PROC type
ENDCASE => GO TO error;
};
ref, list, atom, rope, countedZone => {
targetRangeType: Type _ nullType;
sourceRangeType: Type _ nullType;
realSourceRangeType: Type _ nullType;
narrowToAtomOrRopeOrZone: BOOL _ FALSE;
widenFromAtomOrRopeOrZone: BOOL _ FALSE;

SELECT sourceClass FROM  -- look at the source type
ref, list, atom, rope, countedZone => NULL;
ENDCASE => GO TO error;

SELECT targetClass FROM
ref, list => targetRangeType _ Range[targetType];
ENDCASE;

SELECT sourceClass FROM
ref, list => {
sourceRangeType _ Range[UnderType[type]];
IF IsRemote[tv]
THEN {
r: RemoteRef = [world: GetWorld[tv],
worldIncarnation: GetWorldIncarnation[tv],
ref: TVToLC[tv]];
realSourceRangeType _ RTTypesRemotePrivate.GetRemoteReferentType[r]}
ELSE realSourceRangeType _ GetReferentType[TVToRef[tv]]};
ENDCASE;

SELECT targetClass FROM
atom, rope, countedZone => {
IF sourceClass # ref OR sourceRangeType # anyType THEN GO TO badRange;
SELECT targetClass FROM
atom =>
IF NOT EquivalentTypes[realSourceRangeType, CODE[AtomPrivate.AtomRec]]
THEN GO TO badRange;
rope =>
IF NOT EquivalentTypes[realSourceRangeType, CODE[Rope.RopeRep]]
THEN GO TO badRange;
countedZone => NULL;
ENDCASE => ERROR;
narrowToAtomOrRopeOrZone _ TRUE;
};
ENDCASE;

SELECT sourceClass FROM
atom, rope, countedZone => {
widenFromAtomOrRopeOrZone
_ targetClass = ref
AND (targetRangeType = unspecType OR targetRangeType = anyType);
IF NOT widenFromAtomOrRopeOrZone THEN GO TO badRange};
ENDCASE;

IF narrowToAtomOrRopeOrZone OR widenFromAtomOrRopeOrZone
OR targetRangeType = unspecType --widen--
OR targetRangeType = anyType  --widen--
OR sourceRangeType = nullType --NIL conforms to any ref target type--
OR AsGoodAs[lhsType: targetRangeType, rhsType: sourceRangeType] --narrow--
OR ((sourceClass = ref OR sourceClass = list)
AND AsGoodAs[lhsType: targetRangeType, rhsType: realSourceRangeType]) --narrow--
THEN {
IF IsRemote[tv]
THEN {
world: World = GetWorld[tv];
ws: WordSequence = NEW[WordSequenceRecord[2]];
LOOPHOLE[@ws[0], LONG POINTER TO LONG CARDINAL]^ _ TVToLC[tv];
newTV _ NEW[TypedVariableRec _ [
referentType: [targetType],
head: [copiedRemoteObject [
world: world,
worldIncarnation: CurrentIncarnation[world],
copy: ws]],
status: readOnly,
field: entire[]]];
}
ELSE {
newTV _ New[type: targetType, status: readOnly];
tvr _ NARROW[newTV, REF TypedVariableRec];
WITH hd: tvr.head SELECT FROM
reference => LOOPHOLE[hd.ref, REF REF ANY]^ _ TVToRef[tv];
ENDCASE => ERROR}}
ELSE GO TO badRange};

subrange, character, enumerated, integer, cardinal, longInteger, longCardinal => {
li: INT = TVToLI[tv];
SELECT targetClass FROM
longCardinal => IF li < 0 THEN GO TO badRange;
cardinal => IF li < 0 OR li > LAST[CARDINAL] THEN GO TO badRange;
longInteger => {};
integer => IF li < FIRST[INTEGER] OR li > LAST[INTEGER] THEN GO TO badRange;
character => IF li < 0 OR li > 377B THEN GO TO badRange;
ENDCASE =>
IF li < TVToLI[First[targetType]] OR TVToLI[Last[targetType]] < li
THEN GO TO badRange;
newTV _ New[type: targetType, status: mutable];
SetTVFromLI[newTV, li];
NARROW[newTV, REF TypedVariableRec].status _ readOnly;
};

real => {
li: INT = TVToLI[tv];
ref: REF REAL _ NEW[REAL _ li];
RETURN [AMBridge.TVForReadOnlyReferent[ref]];
};

ENDCASE => GO TO error;
EXITS
loophole => RETURN [Loophole[tv, targetType]];
error => ERROR Error[reason: typeFault, type: targetType];
badRange => ERROR Error[reason: rangeFault]
}};  -- end Coerce

InRange: PUBLIC SAFE PROC[type: Type--subrange--, groundTV: TypedVariable]
RETURNS[val: BOOL _ TRUE] = TRUSTED {
[] _ Coerce[groundTV, type ! Error => IF reason = rangeFault THEN val _ FALSE];
};

Next: PUBLIC SAFE PROC[tv: TypedVariable--enumerated, subrange, basic--]
RETURNS[TypedVariable] = TRUSTED {
val: LONG INTEGER = TVToLI[tv];
type: Type = TVType[tv];
newTV: TypedVariable;
IF val = TVToLI[Last[type]] THEN RETURN[NIL];
newTV _ New[type];
SetTVFromLC[newTV, LOOPHOLE[val + 1, LONG CARDINAL]];  -- NOTE mach dep enum?
RETURN[newTV]};


LocalUnderClass: SAFE PROC [type: Type] RETURNS [class: Class] = TRUSTED {
class _ TypeClass[UnderType[type]];
};

LastComponent: PROC
[tv: TypedVariable, type: Type _ nullType] RETURNS [TypedVariable] = {
IF type = nullType THEN type _ TVType[tv];
RETURN [IndexToTV[tv, NComponents[type]]]};

Constant: PROC[tv: TypedVariable] RETURNS[ans: BOOL _ FALSE] = {
WITH tv SELECT FROM
rtr: REF TypedVariableRec =>
WITH etr: rtr SELECT FROM
constant => ans _ TRUE;
ENDCASE;
ENDCASE;
};

Embedded: PROC[tv: TypedVariable] RETURNS[ans: BOOL _ FALSE] = {
WITH tv SELECT FROM
rtr: REF TypedVariableRec =>
WITH etr: rtr SELECT FROM
embedded => ans _ TRUE;
ENDCASE;
ENDCASE;
};

BuildRecordFieldDescriptor: PUBLIC PROC
[parentTV: TypedVariable, fieldBitOffset, fieldBits, bitsForType: INT]
RETURNS[fD: tp.FieldDescriptor] = {
fD _ IF bitsForType < bitsPerWord
THEN BuildSmallFieldDescriptor[fieldBitOffset + fieldBits - bitsForType, bitsForType]
ELSE BuildLargeFieldDescriptor[fieldBitOffset / bitsPerWord, fieldBits / bitsPerWord];

IF parentTV = NIL THEN RETURN;

WITH parentTV SELECT FROM
parentTr: REF TypedVariableRec =>
WITH parentT: parentTr SELECT FROM
embedded=> {
fD.wordOffset _ fD.wordOffset + parentT.fd.wordOffset;
WITH parentF: parentT.fd SELECT FROM
small =>
WITH f: fD SELECT FROM
small=> f.field.bitFirst _ f.field.bitFirst + parentF.field.bitFirst;
ENDCASE => ERROR;
ENDCASE};
ENDCASE;
ENDCASE => ERROR;
};

BuildSmallFieldDescriptor: PROC[bitOffset, bitCount: INT]
RETURNS[small tp.FieldDescriptor] = INLINE {
RETURN[tp.FieldDescriptor[
wordOffset: ShortenLongInteger[bitOffset / bitsPerWord],
extent: small[field: [bitFirst: ShortenLongInteger
[bitOffset MOD bitsPerWord],
bitCount: ShortenLongInteger[bitCount]]]]]};

BuildLargeFieldDescriptor: PROC[wordOffset, nWords: INT]
RETURNS[large tp.FieldDescriptor] = INLINE {
RETURN[tp.FieldDescriptor[
wordOffset: ShortenLongInteger[wordOffset],
extent: large[size: ShortenLongInteger[nWords]]]]};

AsGoodAs: PROC[rhsType, lhsType: Type] RETURNS[BOOL] = {
RETURN[EquivalentTypes[rhsType, lhsType]];
};

END.


ÐRTTypedVariablesImpl.Mesa
try to avoid acquisition of already acquired symbol tables
status stuff is wrong. 
last modified on May 10, 1984 5:09:55 pm PDT by Russ Atkinson (RRA)
fixed New to use canonical type in the reference when making a new TV
last modified on November 9, 1983 11:22 pm by Paul Rovner
T Y P E S
V A R I A B L E S

PROCs exported to AMTypes
raises typeFault
variantClass = nil if type not a record or structure, or if non-variant (i.e. does
not contain a union or sequence)
make a new remote TV
here to initialize the tag of the new variant or sequence record
Make a new local TV.
RRA: Note that the type of the TV should retain the proper definitions level, although the type of the new object must be the canonical type.  We do cheat a little here, but I doubt that we will be caught at it.
if a new variant or sequence record, initialize the tag 
COPIED in AMVariablesImpl
Could overflow
lots of changes by RRA for speed and generality

The following hack is courtesy of RRA, who just can't resist.  The reason we have this here is that making an embedded TV is no easy task when the TV is a constant (particularly from an interface).  In this case, the value container is a word sequence in the 'field' component of the object, rather than in the 'head' component.  Blindly using the head component in Tag and Variant has caused problems for people who put variant record values in interfaces.  We take advantage of the readonly nature of constants to share the underlying word sequence, although we have to skip the first word in the word sequence to get to the contents (kludge).
it is OK to LOOPHOLE the result, since we have checked the tag
[1..NComponents[TVType[tv]]]
bits for the value in the field
bits for the field
bit offset of the field within the record
NOTE SymbolPack bug workaround
if the entire tv is smaller than a word and in an allocated object
an interface variable (OUT OF DATE) the 16-bit value in the indicated field of the IR instance is... a (loadstate config index (identifies a BCD), index in linksary of EXPRecord for this interface in that BCD)
get the pointer to the interface record

pick up the pointer to the global variable. Maybe not bound.
old symbol table
old symbol table
old symbol table
old symbol table
RRA: this code did not use the offset prior to this change.  We are even careful to pad with 0s if the value is not long enough.
oddly enough, unions don't take entire words all of the time
we may need the offset for later use (filed under the sequence type)
Begin IndexToTV Here
... returns the word offset of the first element of the sequence, -1 if there is no entry (should not happen unless you got the sequence TV without going through IndexToTV).  Note that if RTTCache ever changes to allow flushing of entries that entries of this flavor must never be flushed!
uses the tag field, then adjusts for the bottom of the range
raises typeFault
raises typeFault
requires that tv be a transfer, program, globalFrame, enumerated, atom, rope
this is rather dangerous
Sequence begins in the word beyond the tag!  Currently we have no way to find out what the offset is if the sequence is computed, so we assume 0 (which is wrong for some sequences).
See above comment about sequences...
RRA: This special value has been squirrelled away by IndexToTV! 
extra check for sequences!
now adjust bitOffset if the entire mapper is smaller than a word and in an allocated object
raises typeFault, badTV
NOTE no size check. You're on your own.
base non-nil only if ref is a relativePointer. UNSAFE in this case.
NOTE assumption that MDS is in the same place
NOTE assumption that MDS is in the same place
Raises typeFault, rangeFault. COPIES unless types are equivalent.
strip off excess layers of record
NIL is handled specially (we are quite generous here with different types of NIL)
unspecified matches anything of size = 1
the target type class
assignment of a proc to a PROC ANY ANY; copy it
the target type class
check that a REF ANY tv represents an atom or rope, respectively
IF NOT EquivalentTypes[realSourceRangeType, CODE[RTZones.ZoneRec]]
THEN GO TO badRange;
create a new TV of the specified targetType with the specified value
logically, the value of tv (a REF, LIST, ATOM, or ROPE)
Procedures private to this module
BuildRecordFieldDescriptor is used to build FieldDescriptors for components of TVs.  fieldBitOffset and fieldBits specify the component's container location and size relative to the container holding parentTV's value.  If the component is smaller than a word, bitsForType specifies its size, which may be smaller than the size of the component's container (if bitsForType >= bitsPerWord, the component size is the same as the container size).  The result of BuildRecordFieldDescriptor describes an embedded field WRT parentTV's head wherein the bits of the component reside.  Generally, an embedded field of a TV describes where WRT its head the bits of its value reside. 
adjust offsets relative to parent.
copied in AMVariablesImpl
NOTE freely conforms = Equivalent for now
�Ê.㘚
œ™š
œ:™:Jš
œ™—š
œC™CJ™E—š
œ9™9J˜——š
Ïk	˜	šœ	�˜Jš
œ„˜„—šœ�˜
Jšœô
�œ˜Ž—Jšœ�œ
˜Jšœ�œ˜Jšœ�œ˜Jšœ
�œ�œ˜4Jšœ	�œ*˜8Jšœ�œ(˜8Jšœ�œ�œ˜)Jšœ	�œF˜Tšœ
�˜Jš
œY˜Y—šœ�˜Jš
œ›
˜›
—Jšœ
�œ˜,Jšœ	�œ$˜2J˜šœ�˜Jš
œl˜l—šœ�˜Jš
œk˜k—Jšœ�œ˜$Jšœ�œ7˜DJ˜—šœ�˜š
�˜Jš
ϻ
˜ª
—Jš�œ"˜)Jš�œ˜J˜šœ�œ
�˜Jš
œ¸
˜¸
J˜——š
œ	™	Jšœ�œ˜-Jš	œ	�œ�œ
�œ
Ïcœ˜1—J˜™Jšœ�œ˜(—J™Jš
œ™J˜šÏnœ�œ
�œ
�˜Jšœ>�œ�œ�œ
˜QJš�œ�œ˜*Jš
œ™Jš
œ˜Jšœ�œ˜J˜Jš�œ�œ
�œ
�œ˜$Jš�œ�œ�œ
�œ&˜SJš�œ	�œ
�œ˜1J˜˜$Jš
œR™RJš
œ ™ J˜—Jš�œ�œ
�œ�œ˜Iš�œ˜š�œ˜Jš
œ™š�œ�œ
�œ�œ˜Cš�œ˜Jšœ�œ)˜?šœ�œ�œ˜$š
œ˜Jš
œ˜š�œ�œ�œ˜BJš�œ˜Jš�œ
�œ˜
——˜J˜
J˜,J˜—J˜J˜—Jšœ�œ
˜J˜š�œ�œ�œ˜BJš�œ
�œ˜J˜—Jš
œ@™@Jšœ+ž˜<Jš�œ	�œ$˜6J˜Jš�œ	�œ%˜7Jš�œ˜J˜
—š�œ
�œ˜
š�œ˜Jš
œ˜˜J˜
J˜,Jšœ�œ#˜,—J˜Jšœž˜0————š�œ˜š
œ™Jš
œÓ
™Ó
—Jš
œ1˜1Jšœ�œ4˜?Jšœ�œ�œ˜AJš
œ!˜!Jš
œ˜J˜Jš
œ8™8š	�œ�œ
�œ�œ�˜Gš�œ�œ�œ˜BJš�œ"˜&š�œ˜Jšœ�œ�œ"˜Gš�œ
�œ
�œ˜Jš
œ˜J˜Jš
œ˜Jš
œ˜—J˜—J˜——Jš�œ˜Jš
œ˜——Jšœž
˜J˜—šŸœ�œ�œ
�œ˜.Jš
œ™Jš�œ
�œ�œ%˜:Jš
œ˜J˜—šŸœ�œ
�œ
�œ�œ
�ž	œ�œ˜MJš
œ™Jš
œ/™/J˜#J˜J˜š�œ�˜Jšœ�œ˜2Jšœ�œ˜4˜'š�œ�˜J˜3J˜"Jš�œ
˜—š�œ�œ˜š�œ�œ�œ
�˜=Jš�œ
�œ˜—š�œ�˜˜Jš�œ,˜2—˜Jš�œ<˜B—Jš
�˜—Jš
œ˜—J˜—Jšœu�œ˜€
Jšœ�œ˜Š
Jš�œ
˜—Jš�œ˜J˜J˜—š
Ÿœ�œ
�œ
�œžœ
˜;Jš�œ�œ˜'Jš
œ˜J˜J˜Jšœ�œ˜J˜Jš�œ
�œ
�œ
�œ
˜+š
�œ�œ�œ
�œ
�œ˜9J˜—J˜"šœ
�œ
�œ˜"J˜š�œ�œ
�˜˜š�œ�œ�œ
�˜JJš
œ"˜"J˜%Jš�œ�œ&˜6——˜š�œ�œ�œ
�˜JJš
œ"˜"J˜%Jš�œ�œ&˜6——Jš�œ�œ
˜J˜—Jš�œ�œ
�œ
˜'J™Jš
œ…™…š�œ�œ
�˜šœ�œ˜š�œ
�œ
�˜š
œ
˜
Jšœ�œ-˜4Jš
œ"˜"Jš
œ˜Jš
œ˜—Jš�œ
˜——Jš�œ
˜—J˜šœ�œ˜J˜šœ�œ�œ
�˜Jšœ�œ˜$Jš�œ�œ˜—J˜˜0J˜
Jš
œ:˜:J˜'J˜5J˜—J˜—J˜—Jš
œ˜šœž
˜J˜——š
Ÿœ�œ
�œ
�œž	œ
˜5Jš�œ�ž
œ�œ˜7Jš
œ˜šœ�œ/˜6Jšœ�œ˜š
œ˜Jš
œ˜Jš�œ�œ$˜F—Jš
œ>™>Jš
œ#˜#šœž˜J˜——Jš�œ�œ
�œ&˜QJ˜@J˜J˜—š
Ÿ	œ�œ
�œ
�œžœ˜QJš�œ�	˜"Jš
œ™J˜J˜#Jšœ�œ˜Jšœ�œ
˜
Jšœ�œ
˜Jšœ�œ
�œ
˜J˜šŸœ�œ/˜DJš
œ&˜&J˜5šœ
�œ˜0Jš
œ™—šœ�œ˜0Jš
œ™—šœ�œ�œ˜$š�œ�œ�œ
�˜˜Jšœ�œ1˜C—˜Jšœ�œ1˜C—Jš�œ�œ
˜—š�œ
�œ
˜Jš�œ'˜+Jš�œ˜ —Jš
œ)™)J˜—Jšœ�œ�œ
˜J˜š�œ�œ
�œž!˜7˜š�œ�œ$�œ
�˜G˜:Jš
œ™—Jš�œ
˜——˜š�œ�œ$�œ
�˜GJ˜:Jš
�˜——Jš�œ�œ
˜J˜—š�œ�œ�œ˜1Jš
œB™BJš�œP˜TJ˜—š�œ˜š�œ˜Jš
œ˜J˜J˜(˜Jšœ�	œ˜5Jšœ�œ˜ —Jšœ
�œ
˜J˜—Jš�œ˜#—š
�˜šœ�œ˜Jš�œ
�œ�œ
�œ˜:š�œ�œ
�œ˜5š�œ˜"Jš
œ!˜!˜J˜J˜,—J˜J˜<J˜—š�œ˜"Jš
œ!˜!J˜J˜J˜<J˜——Jš�œ�œ˜—šœ
�œ
�œ#˜7Jš
τ
™Ñ
J˜J˜Jšœ�œ
˜
J˜Jšœ�œ
˜J˜š�œ
�˜Jš�œB˜G—š�œ�œ
�˜šœ�œ˜š�œ�œ
�˜Jšœ�œ�œ˜1Jš�œ�œ˜+——Jš�œ�œ
˜J˜—J˜<J˜Jš
œ'™'Jšœ�œ˜J™Jš
œ<™<šœ�œ�œ
�œ
�œ
�œ˜@J˜—Jš	�œ�œ�œ�œž˜CJ˜š�œ�œ
�˜˜š�œ�œ$�œ
�˜Ešœ�œ˜š�œ+˜/Jš�œ�œ˜%—š�œ�œ�œ˜9Jš
œ™——š�œ�œ�œ˜=Jš
œ™——˜š�œ�œ$�œ
�˜Ešœ�œ˜š�œ+˜/Jš�œ�œ˜%—š�œ�œ�œ˜9Jš
œ™——š�œ�œ�œ˜=Jš
œ™————Jš�œ�œ
˜J˜—˜
š
œ,˜,J˜Jšœ�œ˜1—š
œ˜Jš
œ˜J˜J˜˜J˜I—J˜—J˜—Jš
œ˜—šœ�˜š�œ�œ
�˜šœ�œ˜&Jšœ�œ ˜4Jšœ�œ˜*Jšœ�œ�œ
˜:š�œ˜
š�œ˜Jš
œ€
™€
Jšœ�œ˜š�œ�œ
�œ�˜Jšœ�œ�œ�œ˜DJš�œ
˜—J˜
—š�œ˜˜Jš
œ˜Jšœ�œ$˜A—Jš
œ˜——š�œ
˜š�œ˜"Jš
œ!˜!˜J˜J˜,—J˜J˜J˜—š�œ˜#Jš
œ!˜!J˜J˜J˜J˜——J˜—Jš�œ�˜——š�
œ˜Jš
œ˜Jšœ�œ�œ
˜Jšœ�œ˜š�œ�˜š
œ
˜
Jš
œ<™<š�œ˜Jš�œ˜Jš�œ�œ
˜—Jš
œ˜—Jšœ�œ
˜Jš�œ
˜—š�œ�˜š�œ�œ
�˜šœ�œ˜'Jš
œ!˜!—Jš�œ
˜——š
œ˜Jš
œ!˜!šœ�œ�œ
�˜Jšœ�œ˜$Jš�œ�œž˜-—š
œ	˜	š�œ
�œ�œ˜/Jš�œ	˜
Jš�œ˜——˜š�œ˜
Jš�œ=˜AJš�œG˜KJš
œ˜———š�œ�œ˜Jš
œH˜HJšœ�œ%˜/š�œ�œ
�˜J˜-Jš�œ�œ
˜—š�œ
�œ
�˜Jš
œD™DJš
œ1˜1—J˜—šœž˜J˜————Jš
œ™J˜9J˜5Jš�œ˜Jšœž˜J˜—šŸœ�œ
�œ�œ
�œ�œ˜KJšœZÏsRœu™¡Jš
œG˜GJ˜š
œ˜J˜——šŸœ�œ
�œ�œ�œ
�œ�œ˜KJ™<Jšœ�œ˜š�œ�œ
�œ˜J˜Jš
œ˜š�œ�˜$J˜3Jš�œ-˜4—J˜—š
œ˜J˜——šŸœ�œ
�œ
�œ˜:š�œ�˜!Jšœ%�œ
�œ˜2Jš�œ�œ
�œ˜—š
œ˜J˜——šŸœ�œ
�œ
�œžœ�œ�œ˜TJš
œ™Jš
œ#˜#Jš
œ˜Jš�œ�œ�œ˜&š�œ�˜š
œ˜š�œ
˜Jš�œK˜OJš�œ�œ˜,——Jš�œ�œ&˜6—š
œ˜J˜——šŸœ�œ
�œ
�˜Jš
œžœ�œ�žœ�œ˜@Jš
œ™Jš
œ#˜#š�œ�œž-˜Jš
œ˜š
œ˜š
œ
˜
Jšœ
�œ
�œ˜,Jšœ�œ$˜4—Jš�œ˜——Jš�œ�œ&˜6—š
œ˜J˜——šŸœ�œ
�œ
�œ�œ�œ�œ�œ˜SJš
œL™LJš
œ#˜#J˜š�œ�˜š
œ˜J˜
š�œ
�œ
�˜Jšœ�œ
�œ˜"Jšœ�œ
�œ˜"Jš�œ�œ&˜6—Jš
œ#˜#J˜—š
œ˜š�œ
�œ
�˜š
œ˜Jš
œ™š
œ˜š
œ˜˜J˜L—Jšœ�œ
�œ˜———š
œ˜Jšœ�œ�œ˜9—Jš�œ
˜——š
œ˜š�œ
˜Jš�œ ˜$Jš�œ�œ�œ˜%——˜Jšœ�œ˜š�œ	�œ
�œ�˜Jš�œI˜N—Jš
œ˜J˜—˜š�œ
˜Jš�œ)˜-Jš�œ�œ˜9——˜š�œ
˜Jš�œ,˜0Jš�œ�œ˜>——˜š�œ
˜Jš�œ+˜/Jš�œ#˜'——Jš�œ
˜—š
œ˜J˜——š
Ÿœ�œ
�œ
�œ	�ž/œ�œ
˜[Jš�œ
�œ�œ˜#Jš
œ'˜'Jšœ
�œ˜"J˜J˜J˜Jš�œ
�œ
�œ
�œ&˜@š�œ�œ˜/š�œ˜Jš
œ,˜,Jšœ�œ
�œ
�œ
�
œ
�œ
�œ
�œ
�œ�œ	˜EJšœ�œ
�œ
�œ
�
œ
�œ
�œ
�œ
�œ�œ˜HJš
œ�œ�œ�œ
�œ�œ
�œ˜NJ˜Jš�œ�œ
�œ˜Dš�œ˜š�œ%˜)š
œ˜Jš
œ˜J˜.šœ�œ˜Jš�œ
�œ
�œ
�œ˜0Jš�œ
�œ�œ˜.——J˜J˜'—š�œ ˜$Jšœ�œ�œ
�œ�œ
�œ˜<J˜J˜)————J˜"šœ
�œ
�œ˜"J˜J˜ Jšœ�œ˜+š	œ�œ�œ�œ
�œ˜AJš�œ˜Jš�œ˜—Jšœ
�œ˜Jšœ�œ
˜Jšœ�œ
˜Jšœ�œ˜Jšœ
�œ�œ
˜Jšœ�œ�œ
˜J˜J˜š�œ�œ
�˜˜š�œ�œ�œ
�˜JJ˜Eš
œ
˜
J˜Jšœ
�œ
˜Jš
œ#˜#Jš
ϵ
™µ
šœ�œ	˜Jš�œ˜Jš�œ=˜A——Jš�œ�œ0˜@——˜š�œ�œ�œ
�˜JJ˜Eš
œ
˜
J˜Jšœ
�œ
˜J˜#J™$šœ�œ	˜Jš�œ˜Jš�œ=˜A———Jš�œ�œ0˜@—Jš�œ�œ
˜J˜—š�œ�œ
�˜Jš
œ@™@Jš
œ5˜5—J˜š�œ
�œ
�œ˜š�œ�˜Jš
œ%˜%—š�œ�œ�˜<Jš
œ™Jš�œ˜ —J˜J˜—š�œ�œ
�˜˜Jšœ*�œ0˜`—˜Jšœ*�œ0˜`—Jš�œ�œ
˜—J˜FJ˜Jš
œ[™[š�œ�œ˜4Jš�œ�œ�œ�œ˜/š�œ˜Jšœ�œ
�œ˜J˜%š�œ�˜Jš
œE˜E—š
œ˜J˜———˜!J˜J˜
J˜šœ
�œ�œ
�˜Jšœ-�œ˜QJšœ-�œ˜QJš�œ�œ˜——J˜šœž˜Jšœ
�œ�œ	�œ˜Iš�œ�œ
�œ
˜%šœž,˜KJš
œ˜š
œ˜šœ�œ�œ
�˜$Jš
œ˜Jš�œ�œ
˜——š�œ�œ
�˜š
œ
˜
Jš	œ�œ�œ)�œ�œ˜KJšœ�œ˜$š�œ
˜š
�˜š
�œ	�œ
�œ
�œ
�œ˜+Jš
œ:˜:——š
�˜š
�œ	�œ
�œ
�œ
�
œ˜0Jš
œ?˜?———J˜—š
œ
˜
Jšœ�œ˜Jšœ�œ˜$š�œ�œ
�œ�˜ Jš
œ ˜ Jš�œ
˜—J˜—Jš�œ�œ
˜—šœ
�œ˜%Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜—Jš
œ
˜
—š�œ˜
šœ
�œ˜%Jš
œ˜Jš
œ˜Jš
œ˜J˜————Jšœž ˜$—Jšœž˜Jš
œ˜šœž˜J˜——šŸœ�œ
�œ
�œžœ	�œ�œ
�œ�œ˜YJš
œ˜š�œ�˜!šœ�œ
˜Jš�œ
�œ#˜.Jš�œ
�œ"˜-—Jš�œ
˜—š�œ'˜,J˜——šŸ	œ�œ
�œ
�˜Jš	œ�œ�œ�œ�œ˜CJš
œ/˜/š�œ	�œ
�˜Jš
œ"˜"Jšœ�œ�œ
�œ
�œ
�œ˜Eš
œ˜˜$J˜J˜*J˜——Jšœ�œ�œ
�œ
�œ
�œ˜PJš�œ�œ
˜—J˜J˜—šŸœ�œ
�œ
�˜Jšœ�œ
ž.œ
�œ
�œ�œ˜PJš
œ#˜#š�œ�˜˜Jš�œ˜—š
œ˜š�œ
˜Jš�œ
�œ˜(Jš�œ
�œ˜'——˜J˜(š�œ
�œ
�œ
˜Jš
œ˜Jš�œ
�œ
�
œ
�œ
�œ
�œ
�œ˜2——˜J˜(š�œ
�œ
�œ
˜Jš
œ˜Jš�œ
�œ
�œ
�
œ
�œ
�œ
�œ
�œ˜7——š�œ˜
Jš�œ&˜+——š
œ˜J˜——šŸœ�œ
�˜Jšœ5�œ�œ˜TJš
œ™Jš
œ'™'Jš
œ+˜+š�œ�œ
�œ�œ˜AJš�œ
�œI˜S—š�œ�œ
�˜šœ�œ˜š�œ
�œ
�˜˜	š�œ
�œ˜Jš
œ˜J˜J˜J˜——˜š�œ
�œ˜Jš
œ˜J˜J˜J˜——˜š�œ
�œ˜Jš
œ˜J˜J˜J˜%——Jš�œ�œ
˜——Jš�œ�œ
˜—J˜J˜—šŸœ�œ
�œ
�˜Jš	œžœ
�œ�œ�œ˜LJš
œ#˜#J˜J˜Jš
�œ
�œ�œ
�œ
�œ˜2Jš�œ�œ�œ�œ�œ
�œ˜WJš�œ
�œ
�œ&˜?Jš�œ�œ
�œ˜0š�œ
�œ
�˜Jšœ�œ
�œ˜"Jšœ�œ
�œ˜"š�œ˜Jš
œ˜š�œ
˜š�œ˜š
œ˜Jš
œQ˜Q—J˜D—Jš�œ4˜8—š�œ1˜3Jš�œ0˜3Jš�œ<˜?Jš�œ.˜2—J˜——Jš�œ�œ
�œ˜6š�œ˜Jš
œ˜J˜>—J˜J˜—šŸœ�œ
�œ
�œžœ�œ
�œ�œ˜Pš�œ�˜'š
œš
˜š
Jš�œ˜—Jšœ�œ
�œ˜˜J˜(š�œ
�œ�œ
�˜Jšœ�œ
�œ
�œ
�
œ
�œ
�œ
�œ
�œ˜;——˜J˜(š�œ
�œ�œ
�˜Jšœ�œ
�œ
�œ
�
œ
�œ
�œ
�œ
�œ˜@——Jš�œ�œ˜"—J˜J˜—šŸœ�œ
�œ
�˜š
œ
˜
JšœžA˜Ušœ�˜Jš
œC™C—Jš
œ
˜
—Jš�œ�œ˜"Jš
œ˜Jšœ#ž˜=J˜J˜
J˜J˜J˜"š�œ�œ
�˜š
œ˜Jš�œ
�œ˜!š�œ�œ�œ
�˜Jšœ�œ-�œ
�˜DJšœ�œ�œ˜/Jš�œ�œ&˜6—Jšœ�œ�œ˜.Jšœ�œ
˜Jš�œ�œ'˜7——š
œ˜Jš�œ
�œ˜!š�œ�œ�œ
�˜Jšœ�œ-�œ
�˜DJšœ�œ�œ˜/Jš�œ�œ&˜6—Jšœ�œ�œ˜.Jšœ�œ
˜Jš�œ�œ'˜7——Jš�œ�œ
˜—J˜J˜Jš�œ�œ
�œ.˜Uš�œ
˜š
�˜š�œ�˜!˜J˜˜J˜
J˜,˜&Jš
œ-™-——š�œ
�œ,˜2Jš�œ
�œ.˜8—š�œ˜!J˜;——˜J˜˜J˜,J˜—Jš�œ7˜=—˜J˜˜J˜
J˜,˜1Jš
œ-™-——š�œ'˜)Jš�œ
�œ.˜8—š�œ˜!J˜;——š
œ˜J˜š�œ'˜)Jš�œ
�œ.˜8—š�œ˜#Jš
œ˜J˜,J˜J˜J˜——Jš�œ�œž˜%——š�œž˜š�œ�˜!š
œ˜Jš�œ
�œ,˜2Jš�œ
�œ.˜8Jšœ�œ+˜9Jš�œF˜L—Jšœ
�œ2˜Eš
œ˜Jšœ�œ
�œ�œ˜0š�œ'˜)Jš�œ
�œ.˜8—š�œ˜Jš
œ	˜	J˜J˜——š
œ˜Jšœ�œ˜$š�œ'˜)Jš�œ
�œ.˜8—š�œ˜Jš
œ	˜	J˜J˜——Jš�œ�œ
˜———Jšœž˜J˜—šŸœ�œ
�œ
�˜Jšœ&�œ�œ˜OJš
œ˜Jšœ
ž˜Jš
œA™AJšœ�œž
˜%J˜ J˜Jš�œ�œ
�œ˜%Jš�œ#�œ
�œ
�œ
˜9J˜Jš
œ*˜*Jš
œ$˜$J˜š�œ�œ�œ˜@Jš
œ!™!Jšœ	�œ˜š�œ"�˜,Jš
œ$˜$Jšœ�œ
�œ˜Jš�œ
˜—Jš�œ˜%J˜—J˜š�œ�œ�œ�˜CJš
œQ™Qš�œ
�˜š
œÈ
˜È
Jš�œ˜#——Jš�œ�œ
�œ˜—J˜š�œ�œ&˜>Jš
�œ
�œ�œ
�œ
�œ˜=J˜—š�œ
�˜š
œ˜Jš
œ(™(Jš�œ�œ
�œ
�œ
�œ
�œ
�œ˜7—š
œ˜Jš
œ™š�œ
�œž˜3š
œ˜š�œ*˜,Jš�œ)˜,š�œ˜Jš
œ/™/š�œ
˜š�œ!˜%Jš
œ˜˜J˜J˜*Jš
œ#˜#—J˜J˜—Jš�œ˜#—J˜2J˜
—Jš�œ
�œ
�œ˜—J˜—Jšœ�œ
�œž ˜5Jš�œ�œ
�œ˜—J˜—š
œ'˜'Jš
œ™Jš
œ!˜!J˜!J˜%Jšœ�œ�œ
˜'Jšœ�œ�œ
˜(J˜š�œ
�œž˜3Jšœ&�œ
˜+Jš�œ�œ
�œ˜J˜—š�œ
�˜Jš
œ1˜1Jš�œ
˜J˜—š�œ
�˜š
œ˜Jš
œ)˜)š�œ
˜š�œ˜Jš
œ$˜$J˜*J˜J˜D—Jš�œ5˜9——Jš�œ
˜J˜—š�œ
�˜š
œ˜Jš
œ@™@Jš
�œ�œ�œ
�œ
�œ
˜Fš�œ
�˜š
œ˜š�œ
�œ&�œ˜FJš�œ
�œ
�œ
˜——š
œ˜š�œ
�œ&�œ˜?Jš�œ
�œ
�œ
˜——šœ�œ
˜š
œB™BJš
œ™——Jš�œ�œ
˜—Jšœ�œ
˜ Jš
œ˜—š�œ
˜J˜——š�œ
�˜š
œ˜š
œ˜˜Jš�œ�œ˜@——Jš
�œ
�œ�œ
�œ
�œ˜6—š�œ
˜J˜——š�œ�œ˜8Jš�œž	˜)Jš�œž	˜'Jš�œž'˜EJš�œ>ž
˜Jš�œ�œ˜-Jš�œCž
˜P—š�œ˜Jš
œD™Dš�œ
˜š�œ˜Jš
œ˜Jšœ�œ˜.Jš�œ	�œ
�œ
�œ
�œ
�œ˜>š
œ ˜ Jš
œ˜˜J˜
J˜,J˜—J˜J˜—J˜
—š�œ˜Jš
œ7™7J˜0Jšœ�œ�œ˜*š�œ�œ
�˜Jš	œ
�œ	�œ
�œ
�œ˜:Jš�œ�œ˜————Jš�œ
�œ
�œ˜J˜——˜RJšœ�œ˜š�œ
�˜Jš	œ�œ�œ
�œ
�œ
˜.Jšœ�œ�œ�œ
�œ�œ
�œ
�œ
˜AJ˜Jšœ�œ�œ
�œ�œ�œ
�œ�œ
�œ
�œ
˜LJšœ
�œ�œ�œ
�œ
�œ
˜8š�œ˜
š�œ �œ˜BJš�œ
�œ
�œ
˜———J˜/Jš
œ˜Jš�œ�œ%˜6Jš
œ˜J˜—˜	Jšœ�œ˜Jš	œ�œ
�œ�œ
�œ˜Jš�œ'˜-Jš
œ˜J˜—Jš�œ�œ
�œ˜—š
�˜Jšœ�œ˜.Jšœ	�œ,˜:Jšœ�œ˜+—šœž
˜J˜——š
Ÿœ�œ
�œ
�œžœ˜JJš�œ�œ�œ�œ˜%Jšœ&�œ�œ�œ˜OJš
œ˜J˜—š
Ÿœ�œ
�œ
�œžœ
˜HJš�œ�œ˜"Jšœ�œ
�œ˜J˜J˜Jš�œ�œ
�œ
�œ˜-J˜Jšœ�œ
�œ
�œž˜MJš�œ	˜J˜—š
œ!™!J˜—š
Ÿœ�œ
�œ�œ�œ˜JJš
œ#˜#Jš
œ˜J˜—šŸ
œ�˜Jšœ+�œ˜FJš�œ�œ˜*Jš�œ%˜+J˜—š
Ÿœ�œ�œ�œ�œ˜@š�œ�œ
�˜šœ�œ˜š�œ
�œ
�˜Jšœ�œ
˜Jš�œ
˜——Jš�œ
˜—Jš
œ˜J˜—š
Ÿœ�œ�œ�œ�œ˜@š�œ�œ
�˜šœ�œ˜š�œ
�œ
�˜Jšœ�œ
˜Jš�œ
˜——Jš�œ
˜—š
œ˜J˜——šŸœ�œ
�˜'JšœB�œ
˜FJš�œ˜#Jš
œ ™ šœ�œ˜!Jš�œQ˜Uš�œR˜VJ˜——Jš�œ�œ
�œ
�œ
˜J˜Jš
œ"™"š�œ
�œ
�˜šœ
�œ˜!š�œ�œ
�˜"˜J˜6š�œ�œ
�˜$š
œ˜š�œ�œ
�˜J˜EJš�œ�œ
˜——Jš�œ˜	——Jš�œ
˜——Jš�œ�˜—š
œ˜J˜——šŸœ�œ�œ
˜9Jš�œ�œ˜,š�œ˜Jš
œ8˜8˜2Jšœ�œ˜J˜,J˜———šŸœ�œ�œ
˜8Jš�œ�œ˜,š�œ˜Jš
œ+˜+J˜3—J˜—šŸœ�œ�œ
�œ˜8Jš
œ™Jš
œ)™)Jš�œ$˜*Jš
œ˜J˜—Jš�œ
˜J˜J˜—…—’âÕ•