DIRECTORY
AMFiles USING[OpenIt],
AMFilesExtras USING[FullFileNameList],
AMTypes USING[Error],
BcdDefs USING[
VersionStamp, NameRecord, MTIndex, SGIndex, SGNull, FTNull, FTSelf, VersionID, FTIndex, NullVersion, BcdBase, NameString, MTHandle, SGHandle, FTHandle],
BcdOps USING[ProcessModules, ProcessFiles],
BrandXSymbolDefs USING[
rootBodyIndex, nullSymbolIndex, SymbolTableBase, SymbolModuleIndex],
BrandYSymbolDefs USING[
rootBodyIndex, nullSymbolIndex, SymbolTableBase, SymbolModuleIndex],
ConvertUnsafe USING[SubString, SubStringToRope],
FileSegment USING[Pages],
FS USING[Error, Open, OpenFile, nullOpenFile, Read, Close],
LoadState USING[Acquire, Release, ConfigInfo, GlobalFrameToModule, local, ConfigID, ModuleIndex],
PrincOps USING[GlobalFrameHandle],
RCMapOps USING[EstablishOuter],
Rope USING[ROPE, Concat, Equal, Find, Substr, Index],
RTSymbolDefs USING[
SymbolTableBase, SymbolTableHandle, nullHandle, nullBase, SymbolModuleIndex],
RTSymbolOps USING[
STBToModuleName, STBVersion, SubStringForName, NullModuleIndex, NullSth],
RTSymbols USING[],  -- EXPORTS only
RTSymbolsPrivate USING[],  -- EXPORTS only
RTTypesBasicPrivate USING[SymbolTableIndex, FindSTI, MapStiStd, STDesc],
SymbolTable USING[SetCacheSize, Release, Acquire, BaseToHandle],
Table USING[Base],
VersionMap USING[MapList],
VersionMapDefaults USING[FileNameFromVersion, GetMapList],
VM USING[Interval, Allocate, AddressForPageNumber, Free, PageNumberForAddress];

RTGetSymbolsImpl: MONITOR
IMPORTS AMFiles, AMFilesExtras, AMTypes, BcdOps, FS, ConvertUnsafe, LoadState, RCMapOps, Rope, RTSymbolOps, RTTypesBasicPrivate, SymbolTable, VersionMapDefaults, VM
EXPORTS RTSymbols, RTSymbolsPrivate
SHARES Rope
= BEGIN

OPEN bx: BrandXSymbolDefs, by: BrandYSymbolDefs, XSymbolTable: SymbolTable, YSymbolTable: SymbolTable, XRCMapOps: RCMapOps, YRCMapOps: RCMapOps, RTSymbolDefs, RTSymbolOps;

onePageSpace: VM.Interval = VM.Allocate[1];

ROPE: TYPE = Rope.ROPE;

-- PUBLIC PROCS --

Outer: PUBLIC PROC[
stb: SymbolTableBase, mdi: SymbolModuleIndex, inner: PROC[base: SymbolTableBase]] = {
stb1: SymbolTableBase = AcquireSTBFromMDI[stb, mdi];
inner[stb1 ! UNWIND => ReleaseSTB[stb1]];
ReleaseSTB[stb1];
};

AcquireSTB: PUBLIC PROC[sth: SymbolTableHandle]
RETURNS[stb: SymbolTableBase] =
{stb _ WITH sth SELECT FROM
t: SymbolTableHandle.x => [x[XSymbolTable.Acquire[t.e]]],
t: SymbolTableHandle.y => [y[YSymbolTable.Acquire[t.e]]]
ENDCASE => ERROR;
IF NOT (WITH stb SELECT FROM
t: SymbolTableBase.x => t.e.stHandle.extended,
t: SymbolTableBase.y => t.e.stHandle.extended,
ENDCASE => ERROR) -- symbol table made by an old version of the compiler
OR (WITH stb SELECT FROM
t: SymbolTableBase.x => t.e.bb[bx.rootBodyIndex].type = bx.nullSymbolIndex,
t: SymbolTableBase.y => t.e.bb[by.rootBodyIndex].type = by.nullSymbolIndex,
ENDCASE => ERROR)
THEN {modName: ROPE = STBToModuleName[stb ! UNWIND => ReleaseSTB[stb]];
ReleaseSTB[stb];
ERROR AMTypes.Error[reason: noSymbols, msg: modName]}
ELSE RETURN[stb]};

ReleaseSTB: PUBLIC PROC[stb: SymbolTableBase] =
{WITH stb SELECT FROM
t: SymbolTableBase.x => XSymbolTable.Release[t.e];
t: SymbolTableBase.y => YSymbolTable.Release[t.e]
ENDCASE => ERROR};

BaseToHandle: PUBLIC PROC[stb: SymbolTableBase] RETURNS[SymbolTableHandle] = {
RETURN[WITH stb SELECT FROM
t: SymbolTableBase.x => [x[XSymbolTable.BaseToHandle[t.e]]],
t: SymbolTableBase.y => [y[YSymbolTable.BaseToHandle[t.e]]],
ENDCASE => ERROR];
};

STPages: PUBLIC PROC[sth: SymbolTableHandle] RETURNS[CARDINAL] =
{RETURN[WITH sth SELECT FROM
t: SymbolTableHandle.x => t.e.span.pages,
t: SymbolTableHandle.y => t.e.span.pages,
ENDCASE => ERROR]};

AcquireSTHFromSTX: PUBLIC PROC[stx: RTTypesBasicPrivate.SymbolTableIndex]
RETURNS[sth: SymbolTableHandle _ nullHandle, moduleName: ROPE _ NIL] = {
[sth, moduleName] _ DoAcquireSTHFromSTX[stx, TRUE];
};

DoAcquireSTHFromSTX:
PROC[stx: RTTypesBasicPrivate.SymbolTableIndex, invokeGetSTHForModule: BOOL _ FALSE]
RETURNS[sth: SymbolTableHandle _ nullHandle, moduleName: ROPE _ NIL] = {
symbolsStamp: BcdDefs.VersionStamp;
bcd: BcdDefs.BcdBase;

IF NOT NullSth[RTTypesBasicPrivate.MapStiStd[stx].sth]
THEN RETURN[sth: RTTypesBasicPrivate.MapStiStd[stx].sth];

symbolsStamp _ RTTypesBasicPrivate.MapStiStd[stx].symbolsStamp;
bcd _ RTTypesBasicPrivate.MapStiStd[stx].bcd;
IF bcd = NIL
THEN {
IF invokeGetSTHForModule
THEN sth _ GetSTHForModule[
				stamp: symbolsStamp,
				fileName: NIL,
				moduleName: NIL
				! ANY => CONTINUE]
ELSE RETURN;
}
ELSE {  --bcd # NIL
sgb: Table.Base = LOOPHOLE[bcd + bcd.sgOffset];
ftb: Table.Base = LOOPHOLE[bcd + bcd.ftOffset];
ssb: BcdDefs.NameString = LOOPHOLE[bcd + bcd.ssOffset];
fti: BcdDefs.FTIndex;
sgi: BcdDefs.SGIndex = RTTypesBasicPrivate.MapStiStd[stx].sgi;
IF sgi = BcdDefs.SGNull  -- search the BCD's file table (find a DEFs)
THEN {  -- search the BCD's file table
findSymbolFTI: PROC[ffth: BcdDefs.FTHandle, ffti: BcdDefs.FTIndex]
RETURNS[stop: BOOL] = {
IF NOT EQStamps[ffth.version, symbolsStamp] THEN RETURN[FALSE];
moduleName _ GetModuleName[ssb, ffth.name];
sth _ GetSTHForModule[
		stamp: symbolsStamp,
		fileName: Rope.Concat[moduleName, ".bcd"],
		moduleName: moduleName
		! AMTypes.Error => CONTINUE];
RETURN[TRUE];
};
IF NOT invokeGetSTHForModule THEN RETURN;
[] _ BcdOps.ProcessFiles[bcd, findSymbolFTI];
IF NullSth[sth]
THEN sth _ GetSTHForModule[
				stamp: symbolsStamp,
				fileName: NIL,
				moduleName: NIL
				! ANY => CONTINUE];
RTTypesBasicPrivate.MapStiStd[stx].sth _ sth;
RETURN;
}
ELSE fti _ sgb[sgi].file;
IF fti = BcdDefs.FTSelf
THEN {
file: FS.OpenFile = FileFromBcdBase[bcd];
moduleName _ GetModuleName[ssb, bcd.source];
IF file # FS.nullOpenFile THEN {
p: FileSegment.Pages =
[file: file,
 span: [base: sgb[sgi].base - 1, pages: sgb[sgi].pages + sgb[sgi].extraPages]];
sth _ IF IsXBCD[bcd] THEN [x[p]] ELSE [y[p]];
};
}
ELSE  { -- look for the specified file
fileName: ROPE = GetFileName[ssb, ftb[fti].name];
moduleName _ GetModuleName[ssb, ftb[fti].name];
sth _ NewSymbolHandle[
		fileName: fileName,
		version: ftb[fti].version,
		base: sgb[sgi].base - 1,
		pages: sgb[sgi].pages + sgb[sgi].extraPages
		! AMTypes.Error => CONTINUE]
};
};  -- end ELSE (i.e. bcd # NIL)
RTTypesBasicPrivate.MapStiStd[stx].sth _ sth;
};  -- end DoAcquireSTHFromSTX

NewSymbolHandle: PUBLIC PROC[
fileName: ROPE,
base: CARDINAL,
pages: CARDINAL,
version: BcdDefs.VersionStamp _ BcdDefs.NullVersion]
RETURNS[sth: SymbolTableHandle _ nullHandle] = {
file: FS.OpenFile _ FS.nullOpenFile;
stb: SymbolTableBase;
symbolsStamp: BcdDefs.VersionStamp;
isXBCD: BOOL = TRUE;  -- NOTE XXX

IF EQStamps[version, BcdDefs.NullVersion]
THEN file _ AMFiles.OpenIt[fileName].openFile
ELSE file _ AcquireFCFromVersion[version, fileName];

IF file = FS.nullOpenFile THEN ERROR AMTypes.Error[reason: noSymbols, msg: fileName];

sth _ IF isXBCD THEN [x[[file: file, span: [base: base, pages: pages]]]]
ELSE [y[[file: file, span: [base: base, pages: pages]]]];
stb _ AcquireSTB[sth];
symbolsStamp _ STBVersion[stb];
ReleaseSTB[stb];
[] _ RTTypesBasicPrivate.FindSTI[[symbolsStamp: symbolsStamp, sth: sth]];
};  -- end NewSymbolHandle

RCMapOuterX: PROC[stb: bx.SymbolTableBase,
mdi: bx.SymbolModuleIndex,
inner: PROC[base: bx.SymbolTableBase]] =
{stb1: SymbolTableBase = AcquireSTBFromMDI[[x[stb]], [x[mdi]]];
inner[NARROW[stb1, SymbolTableBase.x].e ! UNWIND => ReleaseSTB[stb1]];
ReleaseSTB[stb1]};

RCMapOuterY: PROC[stb: by.SymbolTableBase,
mdi: by.SymbolModuleIndex,
inner: PROC[base: by.SymbolTableBase]] =
{stb1: SymbolTableBase = AcquireSTBFromMDI[[y[stb]], [y[mdi]]];
inner[NARROW[stb1, SymbolTableBase.y].e ! UNWIND => ReleaseSTB[stb1]];
ReleaseSTB[stb1]};

AcquireSTBFromMDI: PUBLIC PROC[stb: SymbolTableBase, mdi: SymbolModuleIndex]
RETURNS[SymbolTableBase] = {
fileNameDesc, modNameDesc: ConvertUnsafe.SubString;
fileName: ROPE;
modName: ROPE;

IF NullModuleIndex[mdi] THEN ERROR;
modNameDesc _ SubStringForName[
stb,
WITH stb SELECT FROM
t: SymbolTableBase.x =>
[x[t.e.mdb[NARROW[mdi, SymbolModuleIndex.x].e].moduleId]],
t: SymbolTableBase.y =>
[y[t.e.mdb[NARROW[mdi, SymbolModuleIndex.y].e].moduleId]],
ENDCASE => ERROR];
modName _ ConvertUnsafe.SubStringToRope[modNameDesc];

fileNameDesc _ SubStringForName[stb,
WITH stb SELECT FROM
t: SymbolTableBase.x =>
[x[t.e.mdb[NARROW[mdi, SymbolModuleIndex.x].e].fileId]],
t: SymbolTableBase.y =>
[y[t.e.mdb[NARROW[mdi, SymbolModuleIndex.y].e].fileId]],
ENDCASE => ERROR];
fileName _ ConvertUnsafe.SubStringToRope[fileNameDesc];
RETURN[
AcquireSTB[
GetSTHForModule[
(WITH stb SELECT FROM
t: SymbolTableBase.x =>
t.e.mdb[NARROW[mdi, SymbolModuleIndex.x].e].stamp,
t: SymbolTableBase.y =>
t.e.mdb[NARROW[mdi, SymbolModuleIndex.y].e].stamp,
ENDCASE => ERROR),
fileName,
modName
]
]
];
};

GetSTHForModule: PUBLIC PROC[
stamp: BcdDefs.VersionStamp,
fileName: ROPE,  -- maybe NIL
moduleName: ROPE  -- maybe NIL
]
RETURNS[sth: SymbolTableHandle _ nullHandle] = {
bcd: BcdDefs.BcdBase;
newFile: FS.OpenFile _ FS.nullOpenFile;
sgb: Table.Base;
ftb: Table.Base;
ntb: BcdDefs.NameString;
versionMapTried: BOOL _ FALSE;

mth: BcdDefs.MTHandle;
sSeg: BcdDefs.SGIndex;
someNameMatched: BOOL _ FALSE;

FindVersionStampedModule: PROC[mth: BcdDefs.MTHandle, mti: BcdDefs.MTIndex]
RETURNS[stop: BOOL] = {
umid: BcdDefs.VersionStamp
= (IF mth.file = BcdDefs.FTSelf THEN bcd.version ELSE ftb[mth.file].version);
namesMatch: BOOL _ TRUE;

IF moduleName # NIL
THEN {
thisMN: ROPE = GetModuleName[ntb, mth.name];
namesMatch _ Rope.Equal[moduleName, thisMN];
someNameMatched _ someNameMatched OR namesMatch;
};
RETURN[
namesMatch AND (EQStamps[stamp, BcdDefs.NullVersion] OR EQStamps[stamp, umid])
];
}; -- end FindVersionStampedModule



IF NOT EQStamps[stamp, BcdDefs.NullVersion]
THEN {
found: BOOL;
stx: RTTypesBasicPrivate.SymbolTableIndex;
[stx, found] _ FindSTX[stamp];
IF found THEN sth _ DoAcquireSTHFromSTX[stx].sth;
IF NOT NullSth[sth] THEN RETURN[sth];
};
IF fileName # NIL THEN newFile _ AMFiles.OpenIt[fileName].openFile;

DO
IF newFile = FS.nullOpenFile  -- no local file with that name
THEN {
IF EQStamps[stamp, BcdDefs.NullVersion]
THEN GOTO noFile
ELSE {  -- look for the module's original file
fn: ROPE = IF moduleName = NIL THEN NIL ELSE Rope.Concat[moduleName, ".bcd"];
newFile _ VersionToReadableFile[versionStamp: stamp, shortNameHint: fn];
versionMapTried _ TRUE;
IF newFile = FS.nullOpenFile THEN GOTO noFile;
};
};
bcd _ AcquireBCDFromCap[newFile];
sgb _ LOOPHOLE[bcd + bcd.sgOffset];
ftb _ LOOPHOLE[bcd + bcd.ftOffset];
ntb _ LOOPHOLE[bcd + bcd.ssOffset];
IF bcd.versionIdent # BcdDefs.VersionID
THEN {
IF versionMapTried
THEN GOTO oldSymbols
ELSE {newFile _ FS.nullOpenFile; LOOP};
};
someNameMatched _ FALSE;
mth _ BcdOps.ProcessModules[bcd, FindVersionStampedModule].mth;
IF mth = NIL
THEN {
IF NOT versionMapTried THEN {newFile _ FS.nullOpenFile; LOOP};
IF someNameMatched
THEN GOTO wrongVersion
ELSE GOTO noSymbols;
};
sSeg _ mth.sseg;
IF sSeg = BcdDefs.SGNull
OR sgb[sSeg].pages = 0
OR ((NOT bcd.definitions) AND (sgb[sSeg].extraPages = 0))  -- compressed symbols
OR sgb[sSeg].file # BcdDefs.FTSelf
THEN {
IF versionMapTried
THEN GOTO noSymbols
ELSE {newFile _ FS.nullOpenFile; LOOP};
};
{p: FileSegment.Pages
= [file: newFile,
span: [base: sgb[sSeg].base - 1,
pages: sgb[sSeg].pages + sgb[sSeg].extraPages]
];
sth _ IF IsXBCD[bcd] THEN [x[p]] ELSE [y[p]];
};
IF EQStamps[stamp, BcdDefs.NullVersion]
THEN {
stb: SymbolTableBase = AcquireSTB[sth];
stamp _ STBVersion[stb];
ReleaseSTB[stb];
};
[] _ RTTypesBasicPrivate.FindSTI[[symbolsStamp: stamp, sth: sth]];
ReleaseBCD[bcd];
RETURN[sth];
ENDLOOP;

EXITS
noFile => ERROR AMTypes.Error[reason: noSymbols, msg: fileName];
oldSymbols => ERROR AMTypes.Error[reason: noSymbols, msg: moduleName];
noSymbols
=> ERROR AMTypes.Error[
			reason: noSymbols,
			msg: IF moduleName = NIL THEN fileName ELSE moduleName
			];
wrongVersion => ERROR AMTypes.Error[reason: noSymbols, msg: moduleName];
};  -- end GetSTHForModule

AcquireSTBFromGFH: PUBLIC PROC[gfh: PrincOps.GlobalFrameHandle]
RETURNS[stb: SymbolTableBase _ nullBase] =
BEGIN 
bcd: BcdDefs.BcdBase;
bcdns: BcdDefs.NameString;
moduleName: ROPE;
mth: BcdDefs.MTHandle;
config: LoadState.ConfigID;
moduleIndex: LoadState.ModuleIndex;
umid: BcdDefs.VersionStamp;  -- functional version stamp of the module
ftb: Table.Base;
sth: SymbolTableHandle _ nullHandle;
FindModule: PROC [mth: BcdDefs.MTHandle, mti: BcdDefs.MTIndex] RETURNS [BOOL] =
{RETURN[(mth.gfi <= moduleIndex) AND (moduleIndex < (mth.gfi + mth.ngfi))]};

LoadState.local.Acquire[];
[config, moduleIndex] _ LoadState.local.GlobalFrameToModule[gfh];
bcd _ LoadState.local.ConfigInfo[config].bcd;
LoadState.local.Release[];

bcdns _ LOOPHOLE[bcd + bcd.ssOffset];
ftb _ LOOPHOLE[bcd + bcd.ftOffset];
[mth,] _ BcdOps.ProcessModules[bcd, FindModule];
IF mth = NIL THEN ERROR;

umid _ (IF mth.file = BcdDefs.FTSelf THEN bcd.version ELSE ftb[mth.file].version);

{found: BOOL;
stx: RTTypesBasicPrivate.SymbolTableIndex;
[stx, found] _ FindSTX[umid];
IF found THEN sth _ AcquireSTHFromSTX[stx].sth};

IF NullSth[sth]  -- then try for the one referenced in the bcd
THEN sth _ AcquireSTHFromSGI[bcd, mth.sseg];
IF NullSth[sth]  -- then try for the named module's file (locally)
THEN {
n: BcdDefs.NameRecord
= IF mth.file = BcdDefs.FTSelf THEN mth.name ELSE ftb[mth.file].name;
sth _ GetSTHForModule[
stamp: umid,
fileName: GetFileName[ssb: bcdns, n: n],
moduleName: GetModuleName[ssb: bcdns, n: mth.name]
! ANY => CONTINUE
];
};
IF NullSth[sth]  -- then try for the original one
THEN [sth: sth, moduleName: moduleName]
_ AcquireSTHFromSTX[RTTypesBasicPrivate.FindSTI[[symbolsStamp: umid,
bcd: bcd]]];

IF NullSth[sth]  -- then give up.
THEN {
sgb: Table.Base = LOOPHOLE[bcd + bcd.sgOffset];
IF moduleName = NIL THEN {
n: BcdDefs.NameRecord
= IF sgb[mth.sseg].file = BcdDefs.FTSelf
THEN mth.name
ELSE ftb[sgb[mth.sseg].file].name;
moduleName _ GetFileName[ssb: bcdns, n: n];
};
ERROR AMTypes.Error[reason: noSymbols, msg: moduleName]};
stb _ AcquireSTB[sth];
RETURN[stb];
END;  -- AcquireSTBFromGFH

AcquireSTBFromSGI: PUBLIC PROC[bcd: BcdDefs.BcdBase, sgi: BcdDefs.SGIndex]
RETURNS[stb: SymbolTableBase _ nullBase] = {
ftb: Table.Base = LOOPHOLE[bcd + bcd.ftOffset];
sgh: BcdDefs.SGHandle = @LOOPHOLE[bcd + bcd.sgOffset, Table.Base][sgi];
sth: SymbolTableHandle _ AcquireSTHFromSGI[bcd, sgi];  -- try for the referenced one
IF NullSth[sth]
THEN {
ssb: BcdDefs.NameString = LOOPHOLE[bcd + bcd.ssOffset];
ERROR AMTypes.Error[
		reason: noSymbols,
		msg: IF sgh.file = BcdDefs.FTSelf
			THEN GetFileName[ssb: ssb, n: bcd.source]
			ELSE GetFileName[ssb: ssb, n: ftb[sgh.file].name]];
};
RETURN[AcquireSTB[sth]];
};

-- PRIVATE PROCS --

EQStamps: PROC[s1, s2: BcdDefs.VersionStamp] RETURNS[BOOL] =
INLINE {RETURN[s1.net = s2.net AND s1.host = s2.host AND s1.time = s2.time]};

FindSTX: PROC[stamp: BcdDefs.VersionStamp]
RETURNS[stx: RTTypesBasicPrivate.SymbolTableIndex, found: BOOL] = {
FOR stx IN [1..RTTypesBasicPrivate.MapStiStd.length)
DO IF RTTypesBasicPrivate.MapStiStd[stx] = NIL THEN EXIT;
IF EQStamps[stamp, RTTypesBasicPrivate.MapStiStd[stx].symbolsStamp]
THEN RETURN[stx, TRUE];
ENDLOOP;
RETURN[0, FALSE];
};

AcquireSTHFromSGI: PROC [bcd: BcdDefs.BcdBase, sgi: BcdDefs.SGIndex]
RETURNS [sth: SymbolTableHandle _ nullHandle] = {
sgb: Table.Base = LOOPHOLE[bcd + bcd.sgOffset];
ftb: Table.Base = LOOPHOLE[bcd + bcd.ftOffset];
ssb: BcdDefs.NameString = LOOPHOLE[bcd + bcd.ssOffset];
sgh: BcdDefs.SGHandle _ @sgb[sgi];

IF sgh.class # symbols THEN ERROR;
IF (sgh.pages = 0)  -- empty symbol segment
OR ((NOT bcd.definitions) AND (sgh.extraPages = 0))  -- compressed symbols
OR sgh.file = BcdDefs.FTNull
THEN RETURN;

IF sgh.file = BcdDefs.FTSelf
THEN {
stb: SymbolTableBase;
symbolsStamp: BcdDefs.VersionStamp;
file: FS.OpenFile = FileFromBcdBase[bcd];
IF file = FS.nullOpenFile THEN RETURN;
{p: FileSegment.Pages =
[file: file, span: [base: sgh.base-1, pages: sgh.pages+sgh.extraPages]];
  sth _ IF IsXBCD[bcd] THEN [x[p]] ELSE [y[p]];
};
stb _ AcquireSTB[sth];
symbolsStamp _ STBVersion[stb];
ReleaseSTB[stb];
[] _ RTTypesBasicPrivate.FindSTI[[symbolsStamp: symbolsStamp, sth: sth]];
}
ELSE {
fileName: ROPE _ GetFileName[ssb, ftb[sgh.file].name];
sth _ NewSymbolHandle[
		fileName: fileName,
		base: sgh.base - 1,
		pages: sgh.pages+sgh.extraPages,
		version: ftb[sgh.file].version
		! ANY => CONTINUE];
};
};  -- end AcquireSTHFromSGI

GetModuleName: PROC[ssb: BcdDefs.NameString, n: BcdDefs.NameRecord]
RETURNS[name: ROPE _ NIL] = {
ssd: ConvertUnsafe.SubString = [base: @ssb.string, offset: n, length: ssb.size[n]];
name _ ConvertUnsafe.SubStringToRope[ssd];
name _ name.Substr[start: 0, len: name.Index[pos1: 0, s2: "."]]
};

GetFileName: PROC[ssb: BcdDefs.NameString, n: BcdDefs.NameRecord]
RETURNS[name: ROPE _ NIL] = {
ssd: ConvertUnsafe.SubString = [base: @ssb.string, offset: n, length: ssb.size[n]];
name _ ConvertUnsafe.SubStringToRope[ssd];
IF Rope.Find[name, "."] = -1 THEN name _ Rope.Concat[name, ".bcd"];
};

FileFromBcdBase: PROC[bcd: BcdDefs.BcdBase]
RETURNS[fc: FS.OpenFile _ FS.nullOpenFile] = {
ssb: BcdDefs.NameString = LOOPHOLE[bcd + bcd.ssOffset];
fc _ AcquireFCFromVersion[
      versionStamp: bcd.version,
   shortFileNameHint: Rope.Concat[GetModuleName[ssb, bcd.source], ".bcd"]
   ];
};

AcquireFCFromVersion: PROC[
versionStamp: BcdDefs.VersionStamp,
shortFileNameHint: ROPE _ NIL]
RETURNS[file: FS.OpenFile _ FS.nullOpenFile] = {
fileNameList: LIST OF ROPE;
IF shortFileNameHint # NIL THEN fileNameList _ AMFilesExtras.FullFileNameList[shortFileNameHint];
IF fileNameList # NIL THEN {
FOR fileNames: LIST OF ROPE _ fileNameList, fileNames.rest UNTIL fileNames = NIL DO
file _ FS.Open[fileNames.first ! FS.Error => {file _ FS.nullOpenFile; CONTINUE}];
IF file # FS.nullOpenFile THEN {
IF EQStamps[GetBCDVersionInfo[file].fileVersionStamp, versionStamp]
THEN RETURN[file];
FS.Close[file];
file _ FS.nullOpenFile;
};
ENDLOOP;
};
file _ VersionToReadableFile[versionStamp: versionStamp];
};

AcquireBCDFromVersion: PUBLIC PROC[versionStamp: BcdDefs.VersionStamp,
shortFileNameHint: ROPE _ NIL]
RETURNS[bcd: BcdDefs.BcdBase] =
{ file: FS.OpenFile _ AcquireFCFromVersion[versionStamp, shortFileNameHint];
IF file = FS.nullOpenFile
THEN RETURN[NIL]
ELSE RETURN[AcquireBCDFromCap[file]]};

AcquireBCDFromCap: ENTRY PROC[file: FS.OpenFile] RETURNS[bcd: BcdDefs.BcdBase] =
{ ENABLE UNWIND => NULL;
size: NAT;  -- pages
bcd _ LOOPHOLE[VM.AddressForPageNumber[onePageSpace.page]];
FS.Read[file: file, from: 0, nPages: 1, to: bcd];
IF bcd.extended
THEN size _ MAX[1, bcd.nPages - bcd.rtPages.pages]
ELSE size _ bcd.nPages;
bcd _ LOOPHOLE[VM.AddressForPageNumber[VM.Allocate[size].page]];
FS.Read[file: file, from: 0, nPages: size, to: bcd];
};

IsXBCD: PROC[bcd: BcdDefs.BcdBase--only the first page!!--] RETURNS[BOOL] =
{RETURN[TRUE]};  -- NOTE XXX

ReleaseBCD: PUBLIC ENTRY PROC[bcd: BcdDefs.BcdBase] = {ENABLE UNWIND => NULL;
count: INT _ MAX[1, IF bcd.extended THEN bcd.nPages - bcd.rtPages.pages ELSE bcd.nPages];
VM.Free[[page: VM.PageNumberForAddress[bcd], count: count]];
};

GetBCDVersionInfo: ENTRY PROC[file: FS.OpenFile]
RETURNS[fileVersionIdent: CARDINAL, fileVersionStamp: BcdDefs.VersionStamp, isXBCD: BOOL]
= {ENABLE UNWIND => NULL;
 bcd: BcdDefs.BcdBase = LOOPHOLE[VM.AddressForPageNumber[onePageSpace.page]];
 FS.Read[file: file, from: 0, nPages: 1, to: bcd];
 fileVersionIdent _ bcd.versionIdent;
 fileVersionStamp _ bcd.version;
 isXBCD _ IsXBCD[bcd];
};

VersionToReadableFile:
PUBLIC PROC[versionStamp: BcdDefs.VersionStamp, shortNameHint: ROPE _ NIL]
RETURNS[file: FS.OpenFile _ FS.nullOpenFile] = {
mn: ROPE _ NIL;
IF shortNameHint # NIL
THEN {
fileNameList: LIST OF ROPE;
IF shortNameHint # NIL THEN fileNameList _ AMFilesExtras.FullFileNameList[shortNameHint];
IF fileNameList # NIL THEN {
FOR fileNames: LIST OF ROPE _ fileNameList, fileNames.rest
UNTIL fileNames = NIL DO
file _ FS.Open[fileNames.first ! FS.Error => {file _ FS.nullOpenFile; CONTINUE}];
IF file # FS.nullOpenFile THEN {
IF EQStamps[GetBCDVersionInfo[file].fileVersionStamp, versionStamp]
THEN RETURN[file];
FS.Close[file];
file _ FS.nullOpenFile;
};
ENDLOOP;
};
};
mn _ VersionMapDefaults.FileNameFromVersion
			[which: $Symbols, version: versionStamp ! ANY => CONTINUE];
IF mn # NIL THEN file _ AMFiles.OpenIt[mn].openFile;
};

GetMapList: PUBLIC PROC RETURNS[VersionMap.MapList] =
{RETURN[VersionMapDefaults.GetMapList[$Symbols]]};


YRCMapOps.EstablishOuter[RCMapOuterY];  -- NOTE this line should precede the next one
XRCMapOps.EstablishOuter[RCMapOuterX];

YSymbolTable.SetCacheSize[pages: 512];
XSymbolTable.SetCacheSize[pages: 512];

END.


FRTGetSymbolsImpl.mesa
Copyright c 1984 by Xerox Corporation.  All rights reserved.
Russ Atkinson On June 14, 1984 2:08:15 pm PDT
Paul Rovner On December 12, 1983 5:06 pm
Bob Hagmann On May 7, 1984 3:33:31 pm PDT
Variables protected by the monitor
this may return nullHandle but will not raise any signals
		of indicated bcd. Should match bcd.version
version must match bcd.version
here if file is found and version matches
stamp on the MODULE, maybe different than bcd.version
START GetSTHForModule body here
here with a valid FC
raises Error if there are no symbols for the specified module
First look in the umid -> sth map
sgi identifies the symbol segment
returns nullHandle if there are no symbols
		version of the specified file, not necessarily of the module
may return FS.nullOpenFile
may return NIL

MODULE INITIALIZATION
Κ˜J˜š
œ™Jšœ
Οm
œ1™<Jš
œ-™-Jš
œ(™(Jš
œ)™)J˜—š
Οk	˜	Jšœžœ	˜Jšœžœ˜&Jšœžœ˜šœžœ
˜Jš
œ˜
˜˜
—Jšœžœ˜+šœžœ
˜Jš
œD˜D—šœžœ
˜Jš
œD˜D—Jšœžœ˜0Jšœžœ˜Jšžœ
žœ3˜;Jšœ
žœR˜aJšœ	žœ˜"Jšœ	žœ˜Jšœžœ
žœ&˜5šœ
žœ
˜Jš
œM˜M—šœžœ
˜Jš
œI˜I—Jšœ
žœΟc˜#JšœžœŸ˜*Jšœžœ/˜HJšœžœ/˜@Jšœžœ˜Jšœžœ
˜Jšœžœ"˜:Jšžœ
žœG˜OJ˜—šœž˜Jšžœ*žœq˜€
Jšžœ˜#Jšžœ˜—Jšœž˜J˜šžœ§
˜«
J˜—Jš
œ"™"J˜+J˜Jšžœžœžœ
˜J˜Jš
Ÿ˜J˜šΟnœžœ
žœ
˜šœ5žœ˜UJ˜4Jšœ
žœ˜)J˜J˜J˜——š 
œžœ
žœ˜/Jšžœ˜šœžœžœ
ž˜J˜9J˜8Jšžœžœ
˜š	žœ
žœžœžœ
ž˜J˜.J˜.JšžœžœŸ6˜Hšžœžœžœ
ž˜J˜KJ˜KJšžœžœ
˜—šžœžœžœ˜GJ˜Jšžœ0˜5—Jšžœ
žœ˜J˜———š 
œžœ
žœ˜/šœ
žœžœ
ž˜J˜2J˜1Jšžœžœ˜J˜——š œžœžœ˜Nšžœ
žœžœ
ž˜Jš
œ<˜<Jš
œ<˜<Jšžœžœ˜—Jš
œ˜—J˜š
 œžœ
žœžœ
žœ˜@šœ
žœ
žœžœ
ž˜J˜)J˜)Jšžœžœ˜J˜—Jš
œ9™9—š œžœ
žœ+˜IJšžœ2žœžœ˜HJšœ-žœ˜3Jš
œ˜J˜—š œ
˜JšžœCžœžœ
˜TJšžœ2žœžœ˜HJ˜#J˜J˜šžœ
žœ0˜6Jšžœ
žœ.˜9J˜—Jš
œ?˜?Jš
œ-˜-šžœž˜šžœ˜šžœ˜šžœ˜Jš
œ˜Jšœžœ
˜Jšœž˜Jšœžœžœ
˜—Jšžœ
ž˜—Jš
œ
˜
—šžœŸ˜Jšœžœ˜/Jšœžœ˜/Jšœžœ˜7J˜Jš
œ>˜>šžœŸ,˜EšžœŸ˜&šœžœ/˜BJšžœžœ˜Jš
žœ
žœ&žœ
žœ
žœ˜?J˜+˜J˜J˜,J˜Jšœžœ˜—Jšžœ
žœ˜
Jš
œ˜—Jšžœ
žœžœ
žœ
˜)J˜-šžœ
˜šžœ˜Jš
œ˜Jšœžœ
˜Jšœž˜Jšœžœžœ˜——Jš
œ-˜-Jšžœ
˜Jš
œ
˜
—Jšžœ˜—šžœ˜šžœ˜Jšœžœ!˜)J˜,šžœžœžœ˜ ˜J˜J˜O—Jšœžœ
žœžœ˜-Jš
œ˜—J˜
—šžœŸ˜&Jšœ
žœ#˜1J˜/˜J˜š
œ˜Jš
œ,™,—J˜J˜-Jšœžœ
˜—J˜———JšœŸ˜ —Jš
œ-˜-JšœŸ˜J˜Jš
œ™—š œžœ
žœ
˜Jšœ
žœ
˜Jšœžœ
˜Jšœžœ
˜J˜4šžœ)˜0Jš
œ$˜$J˜J˜#JšœžœžœŸ˜!J˜šžœ'˜)Jšžœ)˜-Jšžœ0˜4J˜—Jšžœžœ
žœ1˜U˜Jš
œ)™)—šœžœžœ4˜HJšžœ5˜9—J˜J˜J˜J˜I—JšœŸ˜J˜—š œžœ˜*˜Jšœžœ˜(—˜?Jšœžœžœ˜FJ˜J˜——š œžœ˜*˜Jšœžœ˜(—˜?Jšœžœžœ˜FJ˜J˜——š œžœ
žœ.˜Lšžœ˜Jš
œ3˜3Jšœ
žœ
˜Jšœ	žœ
˜J˜Jšžœžœ
žœ
˜#š
œ˜Jš
œ˜šžœžœ
ž˜˜Jšœžœ)˜:—˜Jšœžœ)˜:—Jšžœžœ˜——J˜5J˜š
œ$˜$šžœžœ
ž˜˜Jšœžœ'˜8—˜Jšœžœ'˜8—Jšžœžœ˜——J˜7šžœ
˜š
œ˜š
œ˜šœ
žœžœ
ž˜˜Jšœžœ$˜2—˜Jšœžœ$˜2—Jšžœžœ˜—Jš
œ	˜	Jš
œ˜Jš
œ
˜
—Jš
œ
˜
—Jš
œ˜—š
œ˜J˜——Jš
œ5™5—š œžœ
žœ
˜Jš
œ˜Jšœ
žœŸ˜JšœžœŸ˜J˜
šžœ)˜0J˜J˜'J˜J˜J˜Jšœžœžœ
˜J˜J˜J˜Jšœžœžœ
˜J˜š œžœ-˜KJšžœžœ˜š
œ˜Jšœžœžœ
žœ˜M—Jšœžœžœ
˜J˜šžœž˜šžœ˜Jšœžœ ˜,Jš
œ,˜,Jšœ"žœ˜0Jš
œ˜——šžœ
˜Jšœžœ'žœ˜NJš
œ˜—šœŸ˜"J˜J˜——Jš
œ™J˜šžœ
žœ%˜+šžœ˜Jšœžœ
˜J˜*J˜Jšžœžœ$˜1Jšžœ
žœžœ
žœ˜%Jš
œ˜——Jšžœžœ
žœ-˜CJ˜š
ž˜šžœŸ˜=šžœ˜šžœ%˜'Jšžœ
žœ˜šžœŸ&˜.Jšœžœžœžœ
žœ
žœ!˜MJš
œH˜HJšœžœ
˜Jšžœžœ
žœ˜.Jš
œ˜—Jš
œ˜—Jš
œ™——J˜!Jšœžœ˜#Jšœžœ˜#Jšœžœ˜#šžœ%˜'šžœ˜šžœ˜Jšžœ
žœ˜Jšžœžœ˜'—Jš
œ˜——Jšœžœ
˜J˜?šžœž˜šžœ˜Jšžœ
žœžœžœ˜>šžœ˜Jšžœ
žœ
˜Jšžœ
žœ˜—Jš
œ˜——J˜šžœ˜Jšžœ˜JšžœžœžœŸ˜PJšžœ ˜"šžœ˜šžœ˜Jšžœ
žœ
˜Jšžœžœ˜'—Jš
œ˜——˜˜J˜ J˜.J˜—Jšœžœ
žœžœ˜-—Jš
œ˜šžœ%˜'šžœ˜Jš
œ'˜'J˜J˜J˜——J˜BJ˜Jšžœ˜—Jšžœ
˜—˜š
ž˜Jšœ
žœ1˜@Jšœžœ3˜Fš
œ	˜	šœžœ˜Jš
œ˜Jš	œžœžœ
žœ
žœ˜9Jš
œ˜——Jšœžœ3˜H——JšœŸ˜˜Jš
œ=™=——š œžœ
žœ!˜?Jšžœ#˜*šžœ
˜J˜J˜Jšœžœ
˜J˜Jš
œ˜Jš
œ#˜#JšœŸ)˜FJ˜J˜$š 
œžœ/žœžœ˜OJšœ
žœžœ(˜LJ˜—Jš
œ˜Jš
œA˜AJš
œ-˜-Jš
œ˜J˜Jšœžœ˜%Jšœžœ˜#J˜0Jšžœžœ
žœ
žœ
˜J˜Jšœžœžœ
žœ˜R˜Jš
œ!™!—šœžœ
˜
J˜*J˜Jšžœžœ#˜0J˜šžœŸ-˜>Jšžœ(˜,—šžœŸ1˜Bšžœ˜š
œ˜Jšœžœžœ
žœ˜E—š
œ˜Jš
œ˜Jš
œ(˜(J˜2Jšœžœž˜Jš
œ˜—J˜——šžœŸ ˜1šžœ#˜'˜DJ˜J˜———šžœŸ˜!šžœ˜Jšœžœ˜/šžœžœ
ž˜š
œ˜šœžœ$˜(Jšžœ	˜
Jšžœ˜"——Jš
œ+˜+J˜—Jšžœ4˜9——J˜Jšžœ˜——JšžœŸ˜J˜—š œžœ
žœŸ
œ˜JJš
œ!™!šžœ%˜,Jšœžœ˜/Jšœžœ&˜GJšœ7Ÿ˜Tšžœ
˜šžœ˜Jšœžœ˜7šžœ˜Jš
œ˜šœžœ˜#Jšœžœ%˜,Jšœžœ/˜6——J˜——Jšžœ˜Jš
œ˜J˜——Jš
Ÿ˜J˜Jš œžœžœ
žœ˜<Jšžœžœžœžœ˜MJ˜š œžœ˜*Jšžœ3žœ˜Cšžœžœ*˜4š
žœ
žœ&žœ
žœ
žœ
˜9šžœA˜CJšžœ
žœžœ˜——Jšžœ
˜—Jšžœžœ˜š
œ˜J˜Jš
œ*™*——š œžœ-˜DJšžœ*˜1Jšœžœ˜/Jšœžœ˜/Jšœžœ˜7J˜"J˜Jšžœžœ
žœ
˜"šžœŸ˜+JšžœžœžœŸ˜JJšžœ˜Jšžœ
žœ
˜J˜—šžœ˜šžœ˜Jš
œ˜J˜#J˜)Jšžœžœ
žœ
˜&š
œ˜Jš
œH˜H—Jšœžœ
žœžœ˜/Jš
œ˜J˜J˜J˜J˜IJ˜
—šžœ˜Jšœ
žœ(˜6˜J˜J˜J˜"˜ Jš
œ>™>—Jšœžœžœ˜—Jš
œ˜——JšœŸ˜J˜—š 
œžœ0˜CJšžœž
œ˜Jš
œS˜SJš
œ*˜*Jš
œ?˜?š
œ˜J˜——š œžœ0˜AJšžœž
œ˜Jš
œS˜SJš
œ*˜*Iprocšžœžœ"˜Cš
œ˜J˜——š œžœ˜+Jšžœ'˜.Jšœžœ˜7˜˜ J˜IJ˜——˜J˜——Jš
œ™š œžœ
˜Jš
œ#˜#Jšœžœžœ
˜šžœžœžœ˜0Jšœžœ
žœ
žœ
˜Jšžœžœ
žœB˜ašžœžœ
žœ˜š
žœžœ
žœ
žœ žœ
žœ
ž˜SJš	œžœžœžœžœ˜Qšžœžœžœ˜ šžœA˜CJšžœ
žœ˜—Jšžœ
˜Jšœžœ˜J˜—Jšžœ
˜—J˜—Jš
œ9˜9—J˜J˜Jš
œ™—š œžœ
žœ$˜FJšœžœžœ
˜Jšžœ˜š
œL˜Lšžœ˜Jšžœ
žœ
žœ
˜Jšžœ
žœ˜&J˜———š œžœ
žœžœ˜Pšœžœ
žœžœ
˜JšœžœŸ˜Jšœžœ-˜;Jš
œ1˜1šžœ
˜Jšžœžœ#˜2Jšžœ˜—Jšœžœ2˜@Jš
œ4˜4—J˜J˜—š
 œžœŸœžœ
žœ˜KJšœ
žœ
žœŸ˜J˜—š 
œžœ
žœ
žœžœ
žœžœ
˜MJšœžœžœžœžœ žœ
˜YJšžœ
žœ+˜<J˜J˜—š œžœ
žœ˜0Jšžœžœ2žœ
˜Yšœžœ
žœžœ
˜Jšœžœ-˜MJš
œ2˜2J˜%J˜ J˜J˜—J˜—šΟbœ
˜Jšžœ
žœ4žœžœ
˜Jšžœžœžœ˜0Jšœžœžœ
˜šžœž˜šžœ˜Jšœžœ
žœ
žœ
˜Jšžœžœ
žœ>˜Yšžœžœ
žœ˜šžœžœ
žœ
žœ˜:Jšžœ
žœ
ž˜Jš	œžœžœžœžœ˜Qšžœžœžœ˜ šžœA˜CJšžœ
žœ˜—Jšžœ
˜Jšœžœ˜J˜—Jšžœ
˜—J˜—Jš
œ˜——˜+Jšœ-žœžœ˜>—Jšžœžœ
žœ$˜4J˜J˜——š 
œžœ
žœ
žœ˜5Jšœ
žœ+˜2—J˜J™Jš
œ™J˜Jšœ(Ÿ-˜UJ˜&J˜J˜&J˜&J˜Jšžœ
˜J˜J˜—…—P.jυ