-- BcdFileLookup.Mesa
-- Last edited by Satterthwaite on October 4, 1982 12:18 pm
-- Last edited by Lewis on 18-Mar-81 15:31:15

DIRECTORY
  Alloc: TYPE USING [AddNotify, Bounds, DropNotify, Handle, Notifier, Top, Words],
  BcdDefs: TYPE USING [
    FTIndex, FTNull, FTRecord, fttype, NameRecord, NullVersion, sstype, sttype],
  BcdFileDefs: TYPE USING [],
  BcdOps: TYPE USING [NameString],
  BcdUtilDefs: TYPE USING [NameForHti],
  File: TYPE USING [Capability, nullCapability],
  OSMiscOps: TYPE USING [FindFile, FileError],
  Strings: TYPE USING [
    AppendChar, AppendString, String, SubStringDescriptor, SubString],
  Symbols: TYPE USING [HTIndex, STIndex, STRecord],
  Table: TYPE USING [Base, Limit];

BcdFileLookup: PROGRAM
    IMPORTS Alloc, BcdUtilDefs, OSMiscOps, Strings
    EXPORTS BcdFileDefs = {

  maxFiles: NAT ~ Table.Limit/BcdDefs.FTRecord.SIZE;
  FileSequence: TYPE ~ RECORD [SEQUENCE length: [0..maxFiles] OF File.Capability];
  fileArray: LONG POINTER TO FileSequence;
  nullFile: File.Capability ~ File.nullCapability;


  table: Alloc.Handle;
  zone: UNCOUNTED ZONE;
  
  ftb, stb: Table.Base;

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


  BuildFileTable: PUBLIC PROC [ownTable: Alloc.Handle, scratchZone: UNCOUNTED ZONE] ~ {
    OPEN Symbols;
    stLimit: STIndex;
    zone _ scratchZone;
    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 _ zone.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 ~ {
    zone.FREE[@fileArray];
    table.DropNotify[Notifier]; table _ NIL; zone _ 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 [File.Capability] ~ {
    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: BcdOps.NameString _ table.Bounds[BcdDefs.sstype].base;
      ssd: Strings.SubStringDescriptor _ [
          base~@ssb.string, offset~name, length~MIN[ssb.size[name], 100]];
      nameStr: STRING _ [100];
      NormalizeFileName[in~@ssd, out~nameStr];
      fileArray[index] _ OSMiscOps.FindFile[nameStr, $read
          ! OSMiscOps.FileError => {CONTINUE}];
      IF fileArray[index] = nullFile THEN ERROR UnknownFile[fti]};
    RETURN [fileArray[index]]};

  NormalizeFileName: PROC [in: Strings.SubString, out: Strings.String] ~ {
    char: CHAR;
    dot: BOOL _ FALSE;
    out.length _ 0;
    FOR i: CARDINAL IN [in.offset .. in.offset+in.length) DO
      SELECT (char _ in.base[i]) FROM
	IN ['A..'Z] =>  char _ char + ('a-'A);
	'. =>  dot _ TRUE;
	ENDCASE;
      Strings.AppendChar[out, char];
      ENDLOOP;
    IF ~dot THEN Strings.AppendString[out, ".bcd"L]};
    
  }.