DIRECTORY
AMTypes USING[Error],
Atom USING[MakeAtom],
BcdDefs USING[VersionStamp, NullVersion],
BrandXSymbolDefs USING[SymbolTableBase, SymbolIndex, SymbolContextIndex, nullHandle,
StandardSymbolContextIndex, contextLevelZero, PreDefinedSEI],
BrandYSymbolDefs USING[SymbolTableBase, SymbolIndex, SymbolContextIndex, nullHandle,
StandardSymbolContextIndex, contextLevelZero, PreDefinedSEI],
ConvertUnsafe USING[SubString, SubStringToRope, EqualSubStrings],
RCMap USING[Index],
RCMapOps USING[Acquire],
Rope USING[ROPE],
RTSymbolDefs USING[SymbolTableHandle, nullHandle, SymbolTableBase, SymbolIndex,
SymbolRecordIndex, SymbolNameIndex, nullBase,
SymbolConstructorIndex, nullSymbolIndex, SymbolIdIndex,
symbolIndexForANY],
RTSymbolOps USING[EnumerateCtxIseis, PeelAllButLast, SEUnderType, SETagIDP, NullISEI,
SubStringForName, IsSequence, NullStb, NullSth, ISEName],
RTSymbols USING[Outer, AcquireSTBFromMDI, AcquireSTB, ReleaseSTB, BaseToHandle,
GetSTHForModule],
RTSymbolsPrivate USING[AcquireSTHFromSTX],
RTTypesBasicPrivate USING[UniqueTypeFinger, SymbolAccess,
STDesc, SymbolTableIndex, FindSTI, PTypeDesc, MakeNewType, MapTiTd, MapStiStd, GetLastTypeIndex, FindCanonicalPTD, Enter, FindPTD],
SafeStorage USING[TypeIndex, Type, nullType, unspecType, anyType],
TypeStrings USING[Create, TypeString],
UnsafeStorage USING[GetSystemUZone];


RTTSupportImpl: PROGRAM
IMPORTS AMTypes, Atom, ConvertUnsafe, RCMapOps, RTSymbolOps,
RTSymbols, RTSymbolsPrivate, RTTypesBasicPrivate, TypeStrings, UnsafeStorage
EXPORTS RTSymbolOps, RTSymbols  

= BEGIN OPEN bx: BrandXSymbolDefs, by: BrandYSymbolDefs,
XRCMapOps: RCMapOps, YRCMapOps: RCMapOps,
XTypeStrings: TypeStrings, YTypeStrings: TypeStrings,
Rope, RTSymbolDefs, RTSymbolOps, RTSymbols, RTSymbolsPrivate, SafeStorage, TypeStrings;


standardXSTH: SymbolTableHandle _ [x[bx.nullHandle]];
standardYSTH: SymbolTableHandle _ [y[by.nullHandle]];

typeStringZone: UNCOUNTED ZONE = UnsafeStorage.GetSystemUZone[];


AcquireType: PUBLIC PROC[stb: SymbolTableBase,
seIndex: SymbolIndex,
canonicalize: BOOL _ FALSE,
rcmi: RCMap.Index _ LAST[RCMap.Index]]
RETURNS[type: Type] = {inner: PROC =
{ ptd: RTTypesBasicPrivate.PTypeDesc;
utf: RTTypesBasicPrivate.UniqueTypeFinger;
ustb: SymbolTableBase;
usei: SymbolIndex;
csei: SymbolConstructorIndex = SEUnderType[stb, seIndex];
isConsType: BOOL = NOT SETagIDP[stb, seIndex];

MakePredefinedType: PROC[preType: Type] =
INLINE{utf: RTTypesBasicPrivate.UniqueTypeFinger;
ustb: SymbolTableBase;
usei: SymbolIndex;
std: RTTypesBasicPrivate.STDesc;

[utf, ustb, usei] _ ComputeUTF[stb, seIndex];
std _ STDescFromSTB[ustb];
IF stb # ustb THEN ReleaseSTB[ustb];
IF rcmi = LAST[RCMap.Index]
THEN {rcmi _ WITH stb SELECT FROM
t: SymbolTableBase.x =>
XRCMapOps.Acquire
[t.e, NARROW[csei, SymbolConstructorIndex.x].e
! AMTypes.Error => REJECT;
 UNWIND => NULL;
 ANY => GOTO rcMapAcquisitionError],
t: SymbolTableBase.y =>
YRCMapOps.Acquire
[t.e, NARROW[csei, SymbolConstructorIndex.y].e
! AMTypes.Error => REJECT;
 UNWIND => NULL;
 ANY => GOTO rcMapAcquisitionError],
ENDCASE => ERROR;
EXITS rcMapAcquisitionError =>
ERROR AMTypes.Error[reason: notImplemented,
msg: "RCMaps for this type"]};
[] _ RTTypesBasicPrivate.MakeNewType
[utf, std, usei,
WITH stb SELECT FROM
t: SymbolTableBase.x =>
XTypeStrings.Create
[t.e,
NARROW[csei, SymbolConstructorIndex.x].e,
typeStringZone],
t: SymbolTableBase.y =>
YTypeStrings.Create
[t.e,
NARROW[csei, SymbolConstructorIndex.y].e,
typeStringZone],
ENDCASE => ERROR,
rcmi, FALSE, FALSE, preType]};

IF NullISEI[LOOPHOLE[seIndex]] THEN ERROR;
IF csei = symbolIndexForANY THEN
{IF RTTypesBasicPrivate.MapTiTd[unspecType] = NIL THEN MakePredefinedType[unspecType]; 
type _ unspecType;
RETURN};

IF isConsType THEN
{ isRefAny: BOOL _ FALSE;
isAny: BOOL _ FALSE;

WITH stb SELECT FROM
t: SymbolTableBase.x =>
WITH ser: t.e.seb[NARROW[csei, SymbolConstructorIndex.x].e] SELECT FROM
any => isAny _ TRUE;
ENDCASE;
t: SymbolTableBase.y =>
WITH ser: t.e.seb[NARROW[csei, SymbolConstructorIndex.y].e] SELECT FROM
any => isAny _ TRUE;
ENDCASE;
ENDCASE => ERROR;
IF isAny THEN
{IF RTTypesBasicPrivate.MapTiTd[anyType] = NIL THEN MakePredefinedType[anyType]; 
type _ anyType;
RETURN}};
IF canonicalize
THEN {ts: TypeString;
[ptd, ts, utf] _ FindCanonicalType[stb, csei];  -- ts new storage only if ptd = NIL
IF ptd # NIL
THEN {type _ ptd.equivalentType; RETURN}
ELSE {std: RTTypesBasicPrivate.STDesc = STDescFromSTB[stb];
IF rcmi = LAST[RCMap.Index]
THEN
{rcmi _ WITH stb SELECT FROM
t: SymbolTableBase.x =>
XRCMapOps.Acquire
[t.e, NARROW[csei, SymbolConstructorIndex.x].e
! AMTypes.Error => REJECT;
 UNWIND => NULL;
 ANY => GOTO rcMapAcquisitionError],
t: SymbolTableBase.y =>
YRCMapOps.Acquire
[t.e, NARROW[csei, SymbolConstructorIndex.y].e
! AMTypes.Error => REJECT;
 UNWIND => NULL;
 ANY => GOTO rcMapAcquisitionError],
ENDCASE => ERROR;
EXITS rcMapAcquisitionError =>
ERROR AMTypes.Error[reason: notImplemented,
msg: "RCMaps for this type"]};
type _ RTTypesBasicPrivate.MakeNewType[utf, std, LOOPHOLE[csei, SymbolIndex],
ts, rcmi, TRUE];
RETURN}}
ELSE { IF NOT isConsType
THEN seIndex _ LOOPHOLE[PeelAllButLast[stb, LOOPHOLE[seIndex,
SymbolIdIndex]],
SymbolIndex];
[ptd, utf, ustb, usei] _ FindUTF[stb, seIndex];
IF ptd # NIL
THEN {IF stb # ustb THEN ReleaseSTB[ustb];
type _ ptd.myType;
RETURN}
ELSE {std: RTTypesBasicPrivate.STDesc = STDescFromSTB[ustb];
IF stb # ustb THEN ReleaseSTB[ustb];
IF rcmi = LAST[RCMap.Index]
THEN {rcmi _
WITH stb SELECT FROM
t: SymbolTableBase.x =>
XRCMapOps.Acquire
[t.e, NARROW[csei, SymbolConstructorIndex.x].e
! AMTypes.Error => REJECT;
 UNWIND => NULL;
 ANY => GOTO rcMapAcquisitionError],
t: SymbolTableBase.y =>
YRCMapOps.Acquire
[t.e, NARROW[csei, SymbolConstructorIndex.y].e
! AMTypes.Error => REJECT;
 UNWIND => NULL;
 ANY => GOTO rcMapAcquisitionError],
ENDCASE => ERROR;
EXITS rcMapAcquisitionError =>
ERROR AMTypes.Error[reason: notImplemented,
msg: "RCMaps for this type"]};
type _ RTTypesBasicPrivate.MakeNewType
[utf, std, usei,
WITH stb SELECT FROM
t: SymbolTableBase.x =>
XTypeStrings.Create
[t.e,
NARROW[csei, SymbolConstructorIndex.x].e,
typeStringZone],
t: SymbolTableBase.y =>
YTypeStrings.Create
[t.e,
NARROW[csei, SymbolConstructorIndex.y].e,
typeStringZone],
ENDCASE => ERROR,
rcmi];
RETURN}}};
RTTypesBasicPrivate.Enter[inner ! AMTypes.Error => REJECT; UNWIND => NULL; ANY => GOTO unwind];
EXITS unwind => ERROR};

AcquireSequenceType: PUBLIC PROC[stb: SymbolTableBase,
sei: SymbolIndex,  -- of sequence part
recordSTB: SymbolTableBase,
recordSEIndex: SymbolRecordIndex]
RETURNS[type: Type] = {inner: PROC = 
{ ptd: RTTypesBasicPrivate.PTypeDesc;
utf: RTTypesBasicPrivate.UniqueTypeFinger;
ustb: SymbolTableBase;
usei: SymbolIndex;
csei: SymbolConstructorIndex = SEUnderType[stb, sei];

IF NOT IsSequence[stb, sei] THEN ERROR;

IF SETagIDP[stb, sei]
THEN sei _ LOOPHOLE[PeelAllButLast[stb, LOOPHOLE[sei, SymbolIdIndex]], SymbolIndex];

[ptd, utf, ustb, usei] _ FindUTF[stb, sei];
IF ptd # NIL
THEN {IF stb # ustb THEN ReleaseSTB[ustb];
type _ ptd.myType}
ELSE {rcmi: RCMap.Index;
std: RTTypesBasicPrivate.STDesc = STDescFromSTB[ustb];
{rcmi _ WITH recordSTB SELECT FROM
t: SymbolTableBase.x =>
XRCMapOps.Acquire
[t.e, NARROW[recordSEIndex, SymbolRecordIndex.x].e
! AMTypes.Error => REJECT;
 UNWIND => NULL;
 ANY => GOTO rcMapAcquisitionError],
t: SymbolTableBase.y =>
YRCMapOps.Acquire
[t.e, NARROW[recordSEIndex, SymbolRecordIndex.y].e
! AMTypes.Error => REJECT;
 UNWIND => NULL;
 ANY => GOTO rcMapAcquisitionError],
ENDCASE => ERROR;
EXITS rcMapAcquisitionError =>
ERROR AMTypes.Error[reason: notImplemented,
msg: "RCMaps for this type"]};
IF stb # ustb THEN ReleaseSTB[ustb];
type _ RTTypesBasicPrivate.MakeNewType
[utf,
std,
usei,
WITH recordSTB SELECT FROM
t: SymbolTableBase.x =>
XTypeStrings.Create
[t.e,
NARROW[recordSEIndex, SymbolRecordIndex.x].e,
typeStringZone],
t: SymbolTableBase.y =>
YTypeStrings.Create
[t.e,
NARROW[recordSEIndex, SymbolRecordIndex.y].e,
typeStringZone],
ENDCASE => ERROR,
rcmi]}};
RTTypesBasicPrivate.Enter[inner ! AMTypes.Error => REJECT; UNWIND => NULL; ANY => GOTO unwind];
EXITS unwind => ERROR}; 

AcquireRope: PUBLIC PROC[stb: SymbolTableBase, hti: SymbolNameIndex]
RETURNS[ROPE] = {RETURN[ConvertUnsafe.SubStringToRope[SubStringForName[stb, hti]]]};

AcquireAtom: PUBLIC PROC[stb: SymbolTableBase, hti: SymbolNameIndex]
RETURNS[atom: ATOM] ={RETURN[Atom.MakeAtom[AcquireRope[stb, hti]]]};

EnumerateTypes: PROC[p: PROC[Type] RETURNS[stop: BOOL]]
RETURNS[stopped: BOOL _ FALSE] =
{FOR t: TypeIndex IN [FIRST[TypeIndex]..RTTypesBasicPrivate.GetLastTypeIndex[]]
DO IF p[[t]] THEN RETURN[TRUE] ENDLOOP};

GetTypeSymbols: PUBLIC PROC[type: Type]
RETURNS[stb: SymbolTableBase, sei: SymbolIndex] =
{ moduleName: ROPE;
IF type = nullType THEN ERROR AMTypes.Error[reason: typeFault, type: type];
[stb, sei, moduleName] _ DoGetTypeSymbols[type];
IF NullStb[stb] THEN ERROR AMTypes.Error[reason: noSymbols, msg: moduleName]};

GetOriginalTypeSymbols: PUBLIC PROC[type: Type]
RETURNS[stb: SymbolTableBase, sei: SymbolIndex] =
{ IF type = nullType THEN ERROR AMTypes.Error[reason: typeFault, type: type];
[stb, sei,] _ DoGetTypeSymbols[type, TRUE];
IF NullStb[stb] THEN ERROR AMTypes.Error[reason: noSymbols]};

IsPreDefinedSEI: PROC[sei: SymbolIndex] RETURNS[BOOL] =
{RETURN[WITH sei SELECT FROM
t: SymbolIndex.x => LOOPHOLE[t.e, CARDINAL] IN bx.PreDefinedSEI,
t: SymbolIndex.y => LOOPHOLE[t.e, CARDINAL] IN by.PreDefinedSEI,
ENDCASE => ERROR]};

DoGetTypeSymbols: PROC[type: Type, originalOnly: BOOL _ FALSE]
RETURNS[stb: SymbolTableBase, sei: SymbolIndex, moduleName: ROPE _ NIL] = {
ptd: RTTypesBasicPrivate.PTypeDesc = RTTypesBasicPrivate.MapTiTd[type];
stInfo: RTTypesBasicPrivate.SymbolAccess _ ptd.symbolAccess;
sth: SymbolTableHandle _ IF originalOnly THEN nullHandle ELSE RTTypesBasicPrivate.MapStiStd[stInfo.sti].sth;
mn: ROPE _ NIL;
anySTHWillDo: BOOL
_ (ptd.utf.umid = BcdDefs.NullVersion AND IsPreDefinedSEI[ptd.utf.seIndex]);
originalUTF: BOOL
_ NOT(ptd.utf.umid = BcdDefs.NullVersion OR IsPreDefinedSEI[ptd.utf.seIndex]);

sei _ IF originalOnly AND originalUTF THEN ptd.utf.seIndex ELSE stInfo.sei;
IF NullSth[sth] THEN
IF anySTHWillDo
THEN {   -- standard symbol; any table will do
IF NOT (IF sei.brand = x THEN NullSth[standardXSTH] ELSE NullSth[standardYSTH])
THEN sth _ (IF sei.brand = x THEN standardXSTH ELSE standardYSTH)
ELSE
FOR i: RTTypesBasicPrivate.SymbolTableIndex IN [1..RTTypesBasicPrivate.MapStiStd.length)
DO
IF RTTypesBasicPrivate.MapStiStd[i] = NIL THEN LOOP
ELSE IF NOT NullSth[RTTypesBasicPrivate.MapStiStd[i].sth] THEN {sth _ RTTypesBasicPrivate.MapStiStd[i].sth; EXIT}
ELSE {  -- go find the symbol table bits
[sth: sth, moduleName: mn] _ AcquireSTHFromSTX[i];
IF moduleName = NIL THEN moduleName _ mn;
RTTypesBasicPrivate.MapStiStd[i].sth _ sth;
IF NOT NullSth[sth] THEN EXIT;  -- found one
};
ENDLOOP;
}
ELSE { -- go find the symbol table bits
IF originalOnly AND originalUTF
THEN sth _ GetSTHForModule[ptd.utf.umid, NIL, NIL
				! AMTypes.Error => CONTINUE]
ELSE {
[sth: sth, moduleName: moduleName] _ AcquireSTHFromSTX[stInfo.sti];
RTTypesBasicPrivate.MapStiStd[stInfo.sti].sth _ sth;
IF NullSth[sth] AND originalUTF
THEN { -- try for the original defining module
std: RTTypesBasicPrivate.STDesc = [symbolsStamp: ptd.utf.umid, bcd: RTTypesBasicPrivate.MapStiStd[stInfo.sti].bcd];
sei _ ptd.utf.seIndex;
IF anySTHWillDo
THEN {
IF NOT (IF sei.brand = x THEN NullSth[standardXSTH]
		ELSE NullSth[standardYSTH])
THEN sth _ (IF sei.brand = x THEN standardXSTH
			 ELSE standardYSTH)
ELSE
FOR i: RTTypesBasicPrivate.SymbolTableIndex IN [1..RTTypesBasicPrivate.MapStiStd.length)
DO
IF RTTypesBasicPrivate.MapStiStd[i] = NIL THEN LOOP
ELSE IF NOT NullSth[RTTypesBasicPrivate.MapStiStd[i].sth]
THEN {sth _ RTTypesBasicPrivate.MapStiStd[i].sth; EXIT}
ELSE {  -- go find the symbol table bits
[sth: sth, moduleName: mn] _ AcquireSTHFromSTX[i];
IF moduleName = NIL THEN moduleName _ mn;
RTTypesBasicPrivate.MapStiStd[i].sth _ sth;
IF NOT NullSth[sth] THEN EXIT;  -- found one
};
ENDLOOP;
}
ELSE {
[sth: sth, moduleName: mn] _ AcquireSTHFromSTX[RTTypesBasicPrivate.FindSTI[std]];
IF moduleName = NIL THEN moduleName _ mn;
};
};
};
};
IF NullSth[sth]
THEN stb _ nullBase
ELSE {
WITH sth SELECT FROM
t: SymbolTableHandle.x => IF NullSth[standardXSTH] THEN standardXSTH _ sth;
t: SymbolTableHandle.y => IF NullSth[standardYSTH] THEN standardYSTH _ sth;
ENDCASE => ERROR;
stb _ AcquireSTB[sth];
};
};


FindCanonicalType: PROC[stb: SymbolTableBase, csei: SymbolConstructorIndex]
RETURNS[ptd: RTTypesBasicPrivate.PTypeDesc, ts: TypeString, utf: RTTypesBasicPrivate.UniqueTypeFinger] = 
{ ts _ WITH stb SELECT FROM
t: SymbolTableBase.x => XTypeStrings.Create
[t.e,
NARROW[csei, SymbolConstructorIndex.x].e,
typeStringZone],
t: SymbolTableBase.y => YTypeStrings.Create
[t.e,
NARROW[csei, SymbolConstructorIndex.y].e,
typeStringZone],
ENDCASE => ERROR;
ptd _ RTTypesBasicPrivate.FindCanonicalPTD[ts];
IF ptd # NIL
THEN {typeStringZone.FREE[@ts]; RETURN[ptd, ts, ptd.utf]}
ELSE {[utf,,] _ ComputeUTF[stb, LOOPHOLE[csei, SymbolIndex]]; RETURN[NIL, ts, utf]}};


FindUTF: PROC [stb: SymbolTableBase, sei: SymbolIndex]
RETURNS[ptd: RTTypesBasicPrivate.PTypeDesc,
utf: RTTypesBasicPrivate.UniqueTypeFinger,
ustb: SymbolTableBase,
usei: SymbolIndex] =
{ [utf, ustb, usei] _ ComputeUTF[stb, sei];
RETURN[RTTypesBasicPrivate.FindPTD[utf], utf, ustb, usei]};

ComputeUTF: PROC [outerSTB: SymbolTableBase, sei: SymbolIndex]
RETURNS[utf: RTTypesBasicPrivate.UniqueTypeFinger, ustb: SymbolTableBase, usei: SymbolIndex] =
{ WITH outerSTB SELECT FROM
t: SymbolTableBase.x =>
[utf, ustb, usei] _ ComputeUTFX[t.e, NARROW[sei, SymbolIndex.x].e];
t: SymbolTableBase.y =>
[utf, ustb, usei] _ ComputeUTFY[t.e, NARROW[sei, SymbolIndex.y].e];
ENDCASE => ERROR};

ComputeUTFX: PROC [outerSTB: bx.SymbolTableBase, sei: bx.SymbolIndex]
RETURNS[utf: RTTypesBasicPrivate.UniqueTypeFinger, ustb: SymbolTableBase, usei: SymbolIndex] =
{ ustb _ [x[outerSTB]];
usei _ [x[sei]];
WITH ser: outerSTB.seb[sei] SELECT FROM
id => IF ser.idCtx IN bx.StandardSymbolContextIndex
THEN utf _ [umid: BcdDefs.NullVersion, seIndex: usei] -- a primitive type
ELSE
WITH ctxr: outerSTB.ctxb[ser.idCtx] SELECT FROM
included =>
IF ctxr.level # bx.contextLevelZero
THEN utf _ [umid: outerSTB.mdb[ctxr.module].stamp,
seIndex: [x[LOOPHOLE[ser.idValue, bx.SymbolIndex]]]]
ELSE
{ inner: PROC[stb: SymbolTableBase] =
{ p: PROC[stb: SymbolTableBase, isei: SymbolIdIndex]
RETURNS[stop: BOOL] =
{ ssd1: ConvertUnsafe.SubString
= SubStringForName[[x[outerSTB]], [x[ser.hash]]];
ssd2: ConvertUnsafe.SubString
= SubStringForName[stb, ISEName[stb, isei]];
IF ConvertUnsafe.EqualSubStrings[ssd1, ssd2]
THEN
{utf _ [umid: NARROW[stb, SymbolTableBase.x].e.stHandle.version,
seIndex: LOOPHOLE[isei, SymbolIndex]];
usei _ LOOPHOLE[isei, SymbolIndex];
RETURN[TRUE]}
ELSE RETURN[FALSE];
};
IF NOT EnumerateCtxIseis[stb: stb, ctx: [x[ctxr.map]], proc: p]
THEN ERROR;
};
Outer[stb: [x[outerSTB]], mdi: [x[ctxr.module]], inner: inner];
ustb _ AcquireSTBFromMDI[[x[outerSTB]], [x[ctxr.module]]];
RETURN
};
ENDCASE => utf _ [umid: outerSTB.stHandle.version, seIndex: [x[sei]]];
cons => utf _ [umid: (IF IsPreDefinedSEI[[x[sei]]]
THEN BcdDefs.NullVersion
ELSE outerSTB.stHandle.version),  -- NOTE
seIndex: [x[sei]]];
ENDCASE => ERROR};

ComputeUTFY: PROC [outerSTB: by.SymbolTableBase, sei: by.SymbolIndex]
RETURNS[utf: RTTypesBasicPrivate.UniqueTypeFinger, ustb: SymbolTableBase, usei: SymbolIndex] =
{ ustb _ [y[outerSTB]];
usei _ [y[sei]];
WITH ser: outerSTB.seb[sei] SELECT FROM
id => IF ser.idCtx IN by.StandardSymbolContextIndex
THEN utf _ [umid: BcdDefs.NullVersion, seIndex: usei] -- a primitive type
ELSE
WITH ctxr: outerSTB.ctxb[ser.idCtx] SELECT FROM
included =>
IF ctxr.level # by.contextLevelZero
THEN utf _ [umid: outerSTB.mdb[ctxr.module].stamp,
seIndex: [y[LOOPHOLE[ser.idValue, by.SymbolIndex]]]]
ELSE
{ inner: PROC[stb: SymbolTableBase] =
{ p: PROC[stb: SymbolTableBase, isei: SymbolIdIndex]
RETURNS[stop: BOOL] =
{ ssd1: ConvertUnsafe.SubString
= SubStringForName[[y[outerSTB]], [y[ser.hash]]];
ssd2: ConvertUnsafe.SubString
= SubStringForName[stb, ISEName[stb, isei]];
IF ConvertUnsafe.EqualSubStrings[ssd1, ssd2]
THEN
{utf _ [umid: NARROW[stb, SymbolTableBase.y].e.stHandle.version,
seIndex: LOOPHOLE[isei, SymbolIndex]];
usei _ LOOPHOLE[isei, SymbolIndex];
RETURN[TRUE]}
ELSE RETURN[FALSE];
};
IF NOT EnumerateCtxIseis[stb: stb, ctx: [y[ctxr.map]], proc: p]
THEN ERROR;
};
Outer[stb: [y[outerSTB]], mdi: [y[ctxr.module]], inner: inner];
ustb _ AcquireSTBFromMDI[[y[outerSTB]], [y[ctxr.module]]];
RETURN
};
ENDCASE => utf _ [umid: outerSTB.stHandle.version, seIndex: [y[sei]]];
cons => utf _ [umid: (IF IsPreDefinedSEI[[y[sei]]]
THEN BcdDefs.NullVersion
ELSE outerSTB.stHandle.version),  -- NOTE
seIndex: [y[sei]]];
ENDCASE => ERROR};

STDescFromSTB: PROC[stb: SymbolTableBase] RETURNS[RTTypesBasicPrivate.STDesc] =
{ version: BcdDefs.VersionStamp =
(WITH stb SELECT FROM
t: SymbolTableBase.x => t.e.stHandle.version,
t: SymbolTableBase.y => t.e.stHandle.version
ENDCASE => ERROR);
RETURN[[symbolsStamp: version, sth: RTSymbols.BaseToHandle[stb]]]};

END.




î///users/koo.pa/RTTSupportImpl.tmp

RTTSupportImpl.mesa
Last Modified On October 18, 1983 2:49 pm by Paul Rovner
Last Modified On July 2, 1984 9:35:44 am PDT by Richard Koo 
*****************************
S U P P O R T   F O R   T H E   D E B U G G E R 
Creation of new runtime Type descriptors
ts new storage only if ptd = NIL
Recognize identical type previously entered 
hash map: UniqueTypeFinger -> TypeIndex
ComputeUTF might return a new (ustb, usei) only if sei is a SymbolIdIndex

�ÊA˜J™"J™J˜š
œ™Jš
œ8™8Jš
œ<™<J˜—š
Ïk	˜	Jšœ�œ˜Jšœ�œ˜Jšœ�œ˜)šœ�œ>˜TJ˜=—šœ�œ>˜TJ˜=—Jšœ�œ.˜AJšœ�œ˜Jšœ	�œ
˜Jšœ�œ
�œ˜šœ
�œ=˜OJ˜-J˜7J˜—šœ�œD˜UJ˜9—šœ
�œ@˜OJ˜—Jšœ�œ˜*šœ�œ ˜9Jš
œƒ
˜ƒ
—Jšœ�œ1˜BJšœ�œ˜&Jšœ�œ˜$J˜J˜—šœ�˜š�œ5˜<Jš
œL˜L—Jš�œ˜ J˜—šœ�œ
�œ,˜8J˜)J˜5Jš
œW˜WJ˜J˜—J˜5J˜5J˜Jšœ�	œ
�œ"˜@J˜Jš
œ™Jš
œ0™0J˜šÏnœ�œ
�œ˜.J˜Jšœ�œ�œ
˜Jšœ�œ˜&Jš�œ�œ˜$š
œ%˜%Jš
œ*˜*J˜J˜J˜9Jšœ�œ�œ˜.J˜šžœ�œ˜)š�œ+˜1J˜J˜Jš
œ ˜ J˜J˜-Jš
œ˜Jš�œ�œ˜$š�œ�œ
˜š�œ	�œ�œ
�˜!˜˜šœ�œ"˜.Jšœ�œ
˜Jšœ
�œ�œ
˜Jšœ
�œ�œ˜$———˜˜šœ�œ"˜.Jšœ�œ
˜Jšœ
�œ�œ
˜Jšœ
�œ�œ˜$———Jš�œ�œ
˜š�œ˜š�œ&˜+J˜————š
œ$˜$˜š�œ�œ
�˜˜˜˜Jš�œ#˜)J˜———˜˜˜Jš�œ#˜)J˜———Jš�œ�œ
˜—Jšœ�œ�œ˜J˜————Jš�œ
�œ�œ
�œ
˜*š�œ�˜ šœ
�œ+�œ
�œ!˜WJ˜Jš�œ˜J˜——š�œ�˜šœ�œ�œ
˜Jšœ�œ�œ
˜J˜š�œ�œ
�˜˜š�œ�œ$�œ
�˜GJšœ�œ
˜Jš�œ
˜——˜š�œ�œ$�œ
�˜GJšœ�œ
˜Jš�œ
˜——Jš�œ�œ
˜—š�œ�˜
šœ
�œ(�œ
�œ˜QJ˜Jš�œ˜	————š�œ
˜š�œ˜Jšœ0Ïc#˜Sš�œ�˜Jš�œ�œ
˜(š�œ7˜;š�œ�œ
˜š
�˜šœ�œ�œ
�˜˜˜šœ�œ"˜.Jšœ�œ
˜Jšœ
�œ�œ
˜Jšœ
�œ�œ˜$———˜˜šœ�œ"˜.Jšœ�œ
˜Jšœ
�œ�œ
˜Jšœ
�œ�œ˜$———Jš�œ�œ
˜š�œ˜š�œ&˜+J˜—————šœ1�œ˜MJšœ
�œ˜—Jš�œ˜———š�œ�œ
�œ˜š�œ�œ�œ	˜=J˜J˜
—J˜/Jš�œ�˜š�œ�œ�œ˜*J˜Jš�œ
˜—š�œ8˜<Jš�œ�œ˜$š�œ�œ
˜š�œ˜š�œ�œ
�˜˜˜šœ�œ"˜.Jšœ�œ
˜Jšœ
�œ�œ
˜Jšœ
�œ�œ˜$———˜˜šœ�œ"˜.Jšœ�œ
˜Jšœ
�œ�œ
˜Jšœ
�œ�œ˜$———Jš�œ�œ
˜—š�œ˜š�œ&˜+J˜————š
œ&˜&˜š�œ�œ
�˜˜˜˜Jš�œ#˜)J˜———˜˜˜Jš�œ#˜)J˜———Jš�œ�œ
˜—J˜——Jš�œ˜
————Jšœ3�œ
�œ�œ
�œ�œ	˜_Jš�œ�œ˜J˜—šžœ�œ
�œ˜6JšœŸ˜&J˜J˜!Jš�œ�œ˜%š
œ%˜%Jš
œ*˜*J˜J˜J˜5J˜Jš�œ
�œ�œ
�œ
˜'J˜š�œ˜Jš�œ�œ�œ$˜TJ˜—J˜+š�œ�˜š�œ�œ�œ˜*J˜—š�œ˜Jš
œ6˜6šœ�œ�œ
�˜"˜˜šœ�œ&˜2Jšœ�œ
˜Jšœ
�œ�œ
˜Jšœ
�œ�œ˜$———˜˜šœ�œ&˜2Jšœ�œ
˜Jšœ
�œ�œ
˜Jšœ
�œ�œ˜$———Jš�œ�œ
˜š�œ˜š�œ&˜+J˜———Jš�œ�œ˜$š
œ&˜&˜J˜J˜š�œ�œ
�˜˜˜˜Jš�œ'˜-J˜———˜˜˜Jš�œ'˜-J˜———Jš�œ�œ
˜—J˜————Jšœ3�œ
�œ�œ
�œ�œ	˜_Jš�œ�œ˜J˜——šžœ�œ
�œ,˜DJš�œ
�œ�œ=˜TJ˜—šžœ�œ
�œ,˜DJš�œ�œ�œ(˜DJ˜—š
žœ�œ�œ�œ�œ˜7Jš�œ
�œ�œ˜ šœ
�œ�œ�œ4˜OJš�œ
�œ�œ
�œ
�œ�œ˜(J˜——šžœ�œ
�œ˜'Jš�œ*˜1šœ�œ
˜Jš�œ�œ
�œ.˜KJ˜0Jš�œ�œ
�œ4˜NJ˜——šžœ�œ
�œ˜/Jš�œ*˜1šœ�œ�œ
�œ.˜MJšœ%�œ˜+Jš�œ�œ
�œ#˜=J˜——šžœ�œ�œ
�œ˜7šœ
�œ
�œ�œ
�˜Jšœ�œ�œ�œ˜@Jšœ�œ�œ�œ˜@Jš�œ�œ˜J˜——šžœ�œ�œ�œ
˜>Jš�œ5�œ�œ˜KJš
œG˜GJš
œ<˜<Jšœ�œ�œ�œ/˜lJšœ�œ�œ
˜šœ�˜Jšœ&�œ#˜L—šœ
�˜Jšœ�œ$�œ#˜N—J˜Jš	œ�œ�œ
�œ�œ˜Kš�œ�˜š�œ
˜š�œŸ%˜.š
�œ
�œ�œ�œ�œ˜OJš�œ�œ�œ�œ˜Aš
�˜š�œ)�œ*˜Xš
�˜Jš�œ$�œ
�˜3Jš
�œ
�œ
�œ/�œ.�œ
˜qš�œŸ ˜(Jš
œ2˜2Jš�œ�œ
�œ˜)Jš
œ+˜+Jš	�œ
�œ�œ
�œŸ˜,Jš
œ˜——Jš�œ
˜———J˜
—š�œŸ ˜'š�œ�œ˜š�œ%�œ�˜1Jšœ�œ
˜ —š�œ˜J˜CJš
œ4˜4š�œ�œ˜š�œŸ'˜.Jš
œs˜sJš
œ˜š�œ
˜š�œ˜š�œ
�œ�œ�œ˜3Jšœ�œ˜š�œ�œ�œ
˜.Jšœ�œ˜—š
�˜š�œ)�œ*˜Xš
�˜Jš�œ$�œ
�˜3Jš�œ
�œ
�œ.˜9Jš�œ.�œ
˜7š�œŸ ˜(Jš
œ2˜2Jš�œ�œ
�œ˜)Jš
œ+˜+Jš	�œ
�œ�œ
�œŸ˜,Jš
œ˜——Jš�œ
˜———J˜
—š�œ˜Jš
œQ˜QJš�œ�œ
�œ˜)J˜——J˜——J˜——J˜———š�œ
˜Jš�œ˜š�œ˜š�œ�œ
�˜Jšœ�œ�œ˜KJšœ�œ�œ˜KJš�œ�œ
˜—J˜J˜——˜J˜——Jš
œ(™(˜Jš
œ ™ —šžœ�œ4˜KJš�œb˜išœ�œ�œ
�˜˜+˜Jš�œ#˜)J˜——˜+˜Jš�œ#˜)J˜——Jš�œ�œ
˜Jš
œ/˜/š�œ�˜Jš�œ�œ�œ˜9Jš�œ�œ�œ
�œ
˜UJ˜———š
œ,™,Jš
œ'™'J˜—šžœ�œ)˜6š�œ$˜+Jš
œ*˜*J˜J˜—˜+Jš�œ5˜;J˜—Jš
œI™I—šž
œ�œ.˜>Jš�œW˜^šœ�œ
�œ
�˜˜Jšœ%�œ˜C—˜Jšœ%�œ˜C—Jš�œ�œ˜J˜——šžœ�œ4˜EJš�œW˜^˜J˜š�œ�œ
�˜'šœ�œ�œ˜3Jš�œ2Ÿ˜Iš
�˜š�œ �œ
�˜/˜š�œ!˜#š�œ.˜2Jšœ�œ ˜4—Jš
�˜šœ	�œ˜%šœ�œ+˜4Jš�œ�œ˜˜J˜1˜J˜,—š�œ*˜,š
�˜šœ�œ,˜@Jšœ	�œ˜&Jšœ�œ˜#Jš�œ
�œ˜
——Jš�œ
�œ
�œ˜——J˜š�œ
�œ9˜?Jš�œ
�œ
˜——J˜J˜?J˜:Jš
�˜—J˜——Jš�œ?˜F———šœ�œ˜2Jš�œ˜Jš�œŸ˜)J˜—Jš�œ�œ˜J˜———šžœ�œ4˜EJš�œW˜^˜J˜š�œ�œ
�˜'šœ�œ�œ˜3Jš�œ2Ÿ˜Iš
�˜š�œ �œ
�˜/˜š�œ!˜#š�œ.˜2Jšœ�œ ˜4—Jš
�˜šœ	�œ˜%šœ�œ+˜4Jš�œ�œ˜˜J˜1˜J˜,—š�œ*˜,š
�˜šœ�œ,˜@Jšœ	�œ˜&Jšœ�œ˜#Jš�œ
�œ˜
——Jš�œ
�œ
�œ˜——J˜š�œ
�œ9˜?Jš�œ
�œ
˜——J˜J˜?J˜:Jš
�˜—J˜——Jš�œ?˜F———šœ�œ˜2Jš�œ˜Jš�œŸ˜)J˜—Jš�œ�œ˜J˜———šž
œ�œ�œ˜O˜!šœ
�œ�œ
�˜J˜-J˜,Jš�œ�œ˜—Jš�œ=˜CJ˜——Jš�œ
˜J˜J˜J˜J™—…—BØX