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™˜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šžœ5žœžœ˜KJšœG˜GJšœ<˜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Ö