-- File ModuleSymbolsImpl.Mesa 
-- Last edited by Lewis on 15-May-81 18:18:08
-- Last edited by Sweet on  2-Mar-81 15:15:02

DIRECTORY
  BcdDefs USING [
    FTIndex, FTNull, FTSelf, MTIndex, SGIndex, SGNull, VersionStamp],
  Error USING [ErrorFile, WrongSymbolsVersion],
  FileTable USING [Build, Destroy, HandleForFile, UnknownFile],
  LongStorage USING [FreePages, Pages, PagesForWords],
  ModuleSymbols USING [KnownSymbolsInfo],
  PackageSymbols USING [
    ConstRecord, InnerPackRecord, OPIndex, OPNull, OuterPackRecord],
  PackEnviron USING [Copy, SymbolSegmentBase, SymSegHandle],
  PackHeap USING [FreeSpace, GetSpace],
  Segments USING [
    Address, BaseFromSegment, DeleteSegment, FHandle, MoveSegment, NewSegment, 
    Read, SegmentAddress, SHandle, SwapIn, Unlock],
  SourceBcd USING [
    bcdBases, bcdHeader, EnumerateModules, ModuleNum, ModuleNumForMti],
  Strings,
  SymbolPack,
  Symbols USING [HTIndex, HTNull, HTRecord],
  SymbolSegment USING [VersionID],
  SymbolTable USING [Base],
  Table;

ModuleSymbolsImpl: PROGRAM
    IMPORTS Error, FileTable, LongStorage, PackEnviron, PackHeap, Segments, SourceBcd, 
      ownSymbolPack: SymbolPack
    EXPORTS ModuleSymbols =
  BEGIN  OPEN ModuleSymbols;

  InvalidSymbols: PUBLIC ERROR = CODE;
  SymbolsProblem: PUBLIC SIGNAL = CODE;

  outerPackArray: PUBLIC LONG DESCRIPTOR FOR ARRAY OF PackageSymbols.OuterPackRecord;
  innerPackArray: PUBLIC LONG DESCRIPTOR FOR ARRAY OF PackageSymbols.InnerPackRecord;
  constArray: PUBLIC LONG DESCRIPTOR FOR ARRAY OF PackageSymbols.ConstRecord;


  symbolSegmentOpen: BOOLEAN;
  currentFile: Segments.FHandle;
  currentSeg: Segments.SHandle;
  knownSymbols: LONG DESCRIPTOR FOR ARRAY OF ModuleSymbols.KnownSymbolsInfo;

  symbolPackStarted: BOOLEAN _ FALSE;

  Load: PUBLIC PROC [mti: BcdDefs.MTIndex] =
    BEGIN
    sgi: BcdDefs.SGIndex;
    fti: BcdDefs.FTIndex;
    loadedBefore: BOOLEAN;
    file: Segments.FHandle;
    base: CARDINAL;
    mNum: SourceBcd.ModuleNum;
    pSymPages: CARDINAL;
    codeVersion: BcdDefs.VersionStamp;
    handle: PackEnviron.SymSegHandle;

    sgi _ SourceBcd.bcdBases.mtb[mti].sseg;
    fti _ SourceBcd.bcdBases.mtb[mti].file;
    SELECT fti FROM
      BcdDefs.FTNull => {SIGNAL SymbolsProblem; RETURN};
      BcdDefs.FTSelf => codeVersion _ SourceBcd.bcdHeader.version;
      ENDCASE => codeVersion _ SourceBcd.bcdBases.ftb[fti].version; 
    IF symbolSegmentOpen OR sgi = BcdDefs.SGNull THEN {SIGNAL SymbolsProblem;  RETURN}
    ELSE
      BEGIN
      mNum _ SourceBcd.ModuleNumForMti[mti];
      [loadedBefore: loadedBefore, base: base, pages: pSymPages, file: file] _ knownSymbols[mNum];
      IF file = currentFile THEN  -- reuse (i.e. move) current file segment
        Segments.MoveSegment[
          seg: currentSeg,
          base: base,
          pages: pSymPages]
      ELSE 
        BEGIN
        IF currentSeg # NIL THEN Segments.DeleteSegment[currentSeg];
        currentSeg _ Segments.NewSegment[
          file: file,
          base: base, 
          pages: pSymPages,
          access: Segments.Read];
        END;
      symbolSegmentOpen _ TRUE;
      IF ~loadedBefore THEN
        BEGIN
        Segments.SwapIn[seg: currentSeg, base: PackEnviron.SymbolSegmentBase];
        handle _ Segments.SegmentAddress[currentSeg];
        IF handle.version # codeVersion THEN
	  BEGIN
          Error.WrongSymbolsVersion[
            class: error, module: mti, 
	    requiredVersion: codeVersion, actualVersion: handle.version];
	  Unload[];
	  ERROR InvalidSymbols;
	  END;
        pSymPages _ LongStorage.PagesForWords[handle.constBlock.offset + handle.constBlock.size];
        Segments.Unlock[currentSeg];
        Segments.MoveSegment[
          seg: currentSeg,
          base: Segments.BaseFromSegment[currentSeg],
          pages: pSymPages];
	END;
      currentFile _ file;
      Segments.SwapIn[seg: currentSeg, base: PackEnviron.SymbolSegmentBase];
      IF ~loadedBefore THEN 
        BEGIN
	knownSymbols[mNum].pages _ pSymPages;
	knownSymbols[mNum].loadedBefore _ TRUE;
	END;
      InstallTable[ownSymbolPack, currentSeg ! ANY => Unload[]];
      END;
    END;

  Unload: PUBLIC PROC =
    BEGIN
    IF symbolSegmentOpen THEN {
      Segments.Unlock[currentSeg];
      IF BASE[outerPackArray] # NIL THEN PackHeap.FreeSpace[BASE[outerPackArray]];
      outerPackArray _ DESCRIPTOR[NIL, 0];
      IF BASE[innerPackArray] # NIL THEN PackHeap.FreeSpace[BASE[innerPackArray]];  
      innerPackArray _ DESCRIPTOR[NIL, 0];
      IF BASE[constArray] # NIL THEN PackHeap.FreeSpace[BASE[constArray]];  
      constArray _ DESCRIPTOR[NIL, 0];
      symbolSegmentOpen _ FALSE};
    END;

  InstallTable: PROC [base: SymbolTable.Base, seg: Segments.SHandle] =
    BEGIN
    b: Segments.Address = Segments.SegmentAddress[seg];
    tB: Table.Base = LOOPHOLE[b];
    p: PackEnviron.SymSegHandle = b;
    IF p.versionIdent # SymbolSegment.VersionID THEN {Unload[]; ERROR InvalidSymbols};
    base.cacheInfo _ NIL;
    base.hashVec _ b + p.hvBlock.offset;
    base.ht _ DESCRIPTOR[
      b + p.htBlock.offset, 
      p.htBlock.size / SIZE[Symbols.HTRecord]];
    base.ssb _ b + p.ssBlock.offset;
    base.stHandle _ p;  
    base.sourceFile _ NIL;
    base.notifier _ NullNotifier;
    outerPackArray _ DESCRIPTOR[
      PackHeap.GetSpace[p.outerPackBlock.size],
      (p.outerPackBlock.size / SIZE[PackageSymbols.OuterPackRecord])];
    PackEnviron.Copy[
      from: (b + p.outerPackBlock.offset), to: BASE[outerPackArray], 
      nwords: p.outerPackBlock.size]; 
    innerPackArray _ DESCRIPTOR[
      PackHeap.GetSpace[p.innerPackBlock.size],
      (p.innerPackBlock.size / SIZE[PackageSymbols.InnerPackRecord])];
    PackEnviron.Copy[
      from: (b + p.innerPackBlock.offset), to: BASE[innerPackArray], 
      nwords: p.innerPackBlock.size]; 
    constArray _ DESCRIPTOR[
      PackHeap.GetSpace[p.constBlock.size],
      (p.constBlock.size / SIZE[PackageSymbols.ConstRecord])];
    PackEnviron.Copy[
      from: (b + p.constBlock.offset), to: BASE[constArray], 
      nwords: p.constBlock.size]; 
    END;

  NullNotifier: PROC [SymbolTable.Base] = {NULL};


  FindProc: PUBLIC PROC [
      ss: Strings.SubString] RETURNS [opi: PackageSymbols.OPIndex] =
    BEGIN
    hti: Symbols.HTIndex = ownSymbolPack.FindString[ss];
    l, u, i: PackageSymbols.OPIndex;

    IF hti = Symbols.HTNull THEN RETURN[PackageSymbols.OPNull];
    l _ 1;  u _ (LENGTH[outerPackArray] - 1);
    WHILE l <= u DO
      i _ CARDINAL[l+u]/2;
      SELECT outerPackArray[i].hti FROM
	> hti => u _ i-1;
	< hti => l _ i+1;
	ENDCASE => RETURN [i];
      ENDLOOP;
    RETURN [PackageSymbols.OPNull];
    END;


  Initialize: PUBLIC PROC [nModules: CARDINAL] = 
    BEGIN

    FillInKnowledge: PROC [mti: BcdDefs.MTIndex] RETURNS [stop: BOOLEAN] =
      BEGIN
      mNum: SourceBcd.ModuleNum = SourceBcd.ModuleNumForMti[mti];
      sgi: BcdDefs.SGIndex;
      file: Segments.FHandle _ NIL;
      base: CARDINAL;
      IF SourceBcd.bcdBases.mtb[mti].tableCompiled THEN  -- ignore any symbols
        knownSymbols[mNum] _ [
          loadedBefore: FALSE, file: NIL, base: 0, pages: 0]
      ELSE 
	BEGIN
        sgi _ SourceBcd.bcdBases.mtb[mti].sseg;
        base _ SourceBcd.bcdBases.sgb[sgi].base;
        file _ FileTable.HandleForFile[SourceBcd.bcdBases.sgb[sgi].file
          ! FileTable.UnknownFile => 
	      BEGIN
	      Error.ErrorFile[error, "was needed for symbols but could not be found"L, fti];
	      CONTINUE;
              END ];
        knownSymbols[mNum] _ [
          loadedBefore: FALSE, file: file, base: base, pages: 1];
        END; 
      RETURN[FALSE]
      END;

    FileTable.Build[];
    symbolSegmentOpen _ FALSE;
    currentFile _ NIL;  currentSeg _ NIL;
    knownSymbols _ DESCRIPTOR[
      LongStorage.Pages[LongStorage.PagesForWords[nModules * SIZE[KnownSymbolsInfo]]],
      nModules];
    SourceBcd.EnumerateModules[FillInKnowledge];
    -- the array in FileTableImpl could go away now
    IF ~symbolPackStarted THEN 
      {START ownSymbolPack;  symbolPackStarted _ TRUE};
    END;

  Finalize: PUBLIC PROC = 
    BEGIN
    IF symbolSegmentOpen THEN Unload[];
    IF currentSeg # NIL THEN Segments.DeleteSegment[currentSeg];
    symbolSegmentOpen _ FALSE;
    LongStorage.FreePages[BASE[knownSymbols]];
    FileTable.Destroy[];
    currentFile _ NIL;  currentSeg _ NIL;
    END;

  END.