
<<BcdFileLookup.mesa>>
<<Satterthwaite on September 15, 1982 10:48 am>>
<<Maxwell, August 11, 1983 2:39 pm>>
<<Paul Rovner, September 8, 1983 5:33 pm>>
<<Russ Atkinson, October 6, 1983 4:56 pm>>

DIRECTORY
Alloc: TYPE USING [AddNotify, Bounds, DropNotify, Handle, Notifier, Top, Words],
Ascii: TYPE USING [Lower],
BcdDefs: TYPE USING [
FTIndex, FTNull, FTRecord, fttype, NameRecord, NameString, NullVersion, sstype, sttype],
BcdFileDefs: TYPE USING [],
BcdUtilDefs: TYPE USING [NameForHti],
ConvertUnsafe: TYPE USING [SubString, SubStringToRope],
FS: TYPE USING [Close, Error, nullOpenFile, Open, OpenFile],
Rope: TYPE USING [Concat, Flatten, Text, ROPE],
Symbols: TYPE USING [HTIndex, STIndex, STRecord],
Table: TYPE USING [Base, Limit];

BcdFileLookup: PROGRAM
IMPORTS Alloc, Ascii, BcdUtilDefs, ConvertUnsafe, FS, Rope
EXPORTS BcdFileDefs
SHARES Rope = {

maxFiles: NAT ~ Table.Limit/BcdDefs.FTRecord.SIZE;
FileSequence: TYPE ~ RECORD [SEQUENCE length: [0..maxFiles] OF FS.OpenFile];
fileArray: REF FileSequence;
nullFile: FS.OpenFile ~ FS.nullOpenFile;

table: Alloc.Handle;

ftb, stb: Table.Base;

Notifier: Alloc.Notifier ~ {ftb _ base[BcdDefs.fttype]; stb _ base[BcdDefs.sttype]};


BuildFileTable: PUBLIC PROC [ownTable: Alloc.Handle] ~ {
OPEN Symbols;
stLimit: STIndex;
table _ ownTable; table.AddNotify[Notifier];
stLimit _ table.Top[BcdDefs.sttype];
FOR sti: STIndex _ STIndex.FIRST, sti+STRecord.SIZE UNTIL sti=stLimit DO
WITH s~~stb[sti] SELECT FROM
external =>
WITH p~~s SELECT FROM
file => IF p.fti = BcdDefs.FTNull THEN p.fti _ AddFile[s.hti];
ENDCASE;
ENDCASE;
ENDLOOP;
fileArray _ NEW[FileSequence[table.Bounds[BcdDefs.fttype].size/BcdDefs.FTRecord.SIZE]];
FOR i: NAT IN [0..fileArray.length) DO fileArray[i] _ nullFile ENDLOOP};

AddFile: PROC [hti: Symbols.HTIndex] RETURNS [fti: BcdDefs.FTIndex] ~ {
ftLimit: BcdDefs.FTIndex ~ table.Top[BcdDefs.fttype];
name: BcdDefs.NameRecord ~ BcdUtilDefs.NameForHti[hti];
FOR fti _ BcdDefs.FTIndex.FIRST, (fti + BcdDefs.FTRecord.SIZE) UNTIL fti = ftLimit DO
IF ftb[fti].name = name THEN RETURN  ENDLOOP;
fti _ table.Words[BcdDefs.fttype, BcdDefs.FTRecord.SIZE];
ftb[fti] _ [name~name, version~BcdDefs.NullVersion];
RETURN};

EraseFileTable: PUBLIC PROC ~ {
FOR i: NAT IN [0..fileArray.length) DO
IF fileArray[i] # nullFile THEN {
FS.Close[fileArray[i] ! FS.Error => IF error.code = $invalidOpenFile THEN CONTINUE];
fileArray[i] _ nullFile};
ENDLOOP;
FREE[@fileArray];
table.DropNotify[Notifier];
table _ NIL};


IndexForFti: PROC [fti: BcdDefs.FTIndex] RETURNS [CARDINAL] ~ INLINE {
RETURN [LOOPHOLE[fti, CARDINAL]/BcdDefs.FTRecord.SIZE]};

FtiForIndex: PROC [i: CARDINAL] RETURNS [BcdDefs.FTIndex] ~ INLINE {
RETURN [BcdDefs.FTIndex.FIRST + i*BcdDefs.FTRecord.SIZE]};


UnknownFile: PUBLIC ERROR [fti: BcdDefs.FTIndex] ~ CODE;

CapabilityForFile: PUBLIC PROC [fti: BcdDefs.FTIndex] RETURNS [FS.OpenFile] ~ {
index: CARDINAL ~ IndexForFti[fti];
IF index >= fileArray.length THEN ERROR UnknownFile[fti];
IF fileArray[index] = nullFile THEN {
ftb: Table.Base _ table.Bounds[BcdDefs.fttype].base;
name: BcdDefs.NameRecord ~ ftb[fti].name;
ssb: BcdDefs.NameString _ table.Bounds[BcdDefs.sstype].base;
ssd: ConvertUnsafe.SubString _ [
base~@ssb.string, offset~name, length~MIN[ssb.size[name], 100]];
fileArray[index] _ FS.Open[NormalizeFileName[in~ssd]
! FS.Error => TRUSTED {CONTINUE}];
IF fileArray[index] = nullFile THEN ERROR UnknownFile[fti]};
RETURN [fileArray[index]]};

NormalizeFileName: PROC [in: ConvertUnsafe.SubString] RETURNS[Rope.ROPE] = {
dot: BOOL _ FALSE;
flat: Rope.Text _ Rope.Flatten[ConvertUnsafe.SubStringToRope[in]];
FOR i: CARDINAL IN [0..flat.length) DO
IF flat.text[i] IN ['A..'Z] THEN flat.text[i] _ Ascii.Lower[flat.text[i]];
IF flat.text[i] = '. THEN dot _ TRUE;
ENDLOOP;
RETURN[IF ~dot THEN Rope.Concat[flat, ".bcd"] ELSE flat]};

}.