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, RTSymbolDefs, RTSymbolOps, RTSymbols, RTSymbolsPrivate, SafeStorage, TypeStrings;

ROPE: TYPE = Rope.ROPE;

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};

ErrorRecord: TYPE = RECORD [type: Type, name: ROPE];
errList: LIST OF ErrorRecord _ NIL;

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 {
FOR each: LIST OF ErrorRecord _ errList, each.rest WHILE each # NIL DO
IF each.first.type = type THEN GO TO gleep;
ENDLOOP;
errList _ CONS[[type, moduleName], errList];
GO TO gleep;
EXITS gleep => 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, NIL, 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.




æRTTSupportImpl.mesa
Copyright c 1984 by Xerox Corporation.  All rights reserved.
Russ Atkinson, July 19, 1984 3:15:22 pm PDT
Richard Koo, July 2, 1984 9:35:44 am PDT
*****************************
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

�Êà˜š
œ™Jšœ
Ïm
œ1™<J™+Jš
œ(™(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˜—šœž˜š
ž˜Jš
œ�
˜�
—Jšžœ˜ J˜—šœžœ
ž˜š
œÝ
˜Ý
J˜—Jšžœžœžœ
˜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šœ
žœžœžœ˜4šœ	žœ
žœžœ
˜#J˜—šŸœžœ
žœ˜'Jšžœ,˜3Jšœžœ
˜Jšžœžœ
žœ.˜KJ˜0šžœžœ˜šžœžœ
žœ"žœžœ
ž˜FJšžœžœ
žœ
žœ˜+Jšžœ
˜—Jšœ
žœ˜,Jšžœ
žœ˜Jšžœ
žœ3˜GJš
œ˜—˜J˜——šŸœžœ
žœ˜/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šžœžœžœžœ˜:Jšžœžœžœ
žœ
˜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™—…—DYÖ