-- SegmentsA.Mesa  Edited by Sandman on August 18, 1980  3:33 PM
-- Copyright  Xerox Corporation 1979, 1980

DIRECTORY
  AltoDefs USING [MaxMDSPage, PageSize],
  AltoFileDefs USING [CFA, eofDA, FA, FP, vDA],
  DiskDefs USING [DiskCheckError, DiskPageDesc, DiskRequest, nSectors, SwapPages],
  InlineDefs USING [BITAND, DIVMOD, HighHalf, LongDiv, LowHalf],
  NucleusOps USING [],
  ProcessDefs USING [DisableInterrupts, EnableInterrupts],
  Region USING [Index, Page, PagesPerRegion],
  SegmentDefs USING [
    AccessOptions, AddressFromPage, AllocInfo, Append, DataSegmentAddress,
    DataSegmentHandle, DefaultAccess, DefaultBase, DefaultPages,
    DeleteDataSegment, EasyDown, EnumerateFileSegments, FileAccessError,
    FileError, FileHandle, FileHint, FileSegmentClass, FileSegmentHandle,
    GetEndOfFile, MakeDataSegment, MaxRefs, MaxSegs, NewDataSegment, Object,
    ObjectHandle, ObjectType, OpenFile, PageFromAddress, PageCount, PageNumber,
    Read, RefCount, ReleaseFile, SegCount, SegLockCount, SegmentHandle,
    SegmentLocation, SegmentType, SetFileAccess, SwapError, SwapOut, Write],
  SwapperOps USING [AllocateObject, LiberateObject, regions, UpdateVM];

SegmentsA: PROGRAM
  IMPORTS SwapperOps, DiskDefs, InlineDefs, ProcessDefs, SegmentDefs
  EXPORTS SwapperOps, SegmentDefs, NucleusOps
  SHARES SegmentDefs =
  BEGIN OPEN AltoFileDefs, SwapperOps, SegmentDefs;

  InvalidSegmentSize: PUBLIC SIGNAL [pages: PageCount] = CODE;

  NewFileSegment: PUBLIC PROCEDURE [
    file: FileHandle, base: PageNumber, pages: PageCount, access: AccessOptions]
    RETURNS [seg: FileSegmentHandle] =
    BEGIN OPEN InlineDefs;
    IF access = DefaultAccess THEN access _ Read;
    IF file.segcount = MaxSegs THEN ERROR FileError[file];
    IF BITAND[access, Append] # 0 THEN ERROR FileAccessError[file];
    IF base = DefaultBase THEN base _ 1;
    IF pages = DefaultPages THEN pages _ GetEndOfFile[file].page - base + 1;
    IF pages ~IN (0..AltoDefs.MaxMDSPage + 1] THEN
      ERROR InvalidSegmentSize[pages];
    SetFileAccess[file, access];
    seg _ LOOPHOLE[AllocateObject[SIZE[file segment Object]]];
    seg^ _ Object[
      busy: FALSE,
      body: segment[
      VMpage: 0,
      info: file[
      swappedin: FALSE, write: BITAND[access, Write] # 0, class: other,
      inuse: FALSE, lock: 0, file: file, base: base, pages: pages,
      location: disk[FileHint[eofDA, 0]]]]];
    file.segcount _ file.segcount + 1;
    RETURN
    END;

  DeleteFileSegment: PUBLIC PROCEDURE [seg: FileSegmentHandle] =
    BEGIN
    file: FileHandle _ seg.file;
    SwapOut[seg];
    LiberateObject[seg];
    file.segcount _ file.segcount - 1;
    IF file.segcount = 0 THEN ReleaseFile[file];
    RETURN
    END;

  FileSegmentAddress: PUBLIC PROCEDURE [seg: FileSegmentHandle]
    RETURNS [POINTER] =
    BEGIN
    IF ~seg.swappedin THEN ERROR SwapError[seg];
    RETURN[AddressFromPage[seg.VMpage]]
    END;

  -- Segment Positioning


  PositionSeg: PUBLIC PROCEDURE [seg: FileSegmentHandle, useseg: BOOLEAN]
    RETURNS [BOOLEAN] =
    BEGIN -- returns TRUE if it read a non-null page into the segment.
    cfa: CFA;
    buf: DataSegmentHandle;
    buffer: POINTER;
    WITH s: seg SELECT FROM
      disk =>
	BEGIN
	IF s.hint.da = eofDA AND s.base > 8 AND s.file.segcount > 1 THEN
	  FindSegHint[@s];
	IF s.hint.da = eofDA OR s.hint.page # s.base THEN
	  BEGIN
	  buffer _
	    IF useseg THEN AddressFromPage[s.VMpage]
	    ELSE DataSegmentAddress[buf _ NewDataSegment[DefaultBase, 1]];
	  cfa.fp _ s.file.fp;
	  cfa.fa _ FA[s.hint.da, s.hint.page, 0];
	  [] _ JumpToPage[
	    @cfa, s.base, buffer !
	    UNWIND => IF ~useseg THEN DeleteDataSegment[buf]];
	  IF ~useseg THEN DeleteDataSegment[buf];
	  IF cfa.fa.page # s.base THEN ERROR SwapError[@s];
	  s.hint _ FileHint[cfa.fa.da, cfa.fa.page];
	  RETURN[useseg AND cfa.fa.byte # 0];
	  END;
	END;
      ENDCASE;
    RETURN[FALSE]
    END;

  FindSegHint: PUBLIC PROCEDURE [seg: FileSegmentHandle] =
    BEGIN
    CheckHint: PROCEDURE [other: FileSegmentHandle] RETURNS [BOOLEAN] =
      BEGIN
      WITH o: other SELECT FROM
	disk =>
	  BEGIN
	  IF o.file = seg.file AND o.hint.da # eofDA AND o.hint.page IN
	    (hint.page..seg.base] THEN hint _ o.hint;
	  RETURN[hint.page = seg.base]
	  END;
	ENDCASE;
      RETURN[FALSE]
      END;
    hint: FileHint;
    WITH s: seg SELECT FROM
      disk =>
	BEGIN
	hint _ s.hint;
	[] _ EnumerateFileSegments[CheckHint];
	s.hint _ hint;
	END;
      ENDCASE;
    RETURN
    END;

  GetFileSegmentDA: PUBLIC PROCEDURE [seg: FileSegmentHandle] RETURNS [vDA] =
    BEGIN
    WITH s: seg SELECT FROM
      disk => BEGIN [] _ PositionSeg[seg, FALSE]; RETURN[s.hint.da]; END;
      ENDCASE;
    RETURN[AltoFileDefs.eofDA]
    END;

  SetFileSegmentDA: PUBLIC PROCEDURE [seg: FileSegmentHandle, da: vDA] =
    BEGIN
    WITH s: seg SELECT FROM disk => s.hint _ FileHint[da, s.base]; ENDCASE;
    RETURN
    END;

  -- File Positioning

  jump: INTEGER = 10*DiskDefs.nSectors;

  InvalidFP: PUBLIC SIGNAL [fp: POINTER TO FP] = CODE;

  JumpToPage: PUBLIC PROCEDURE [
    cfa: POINTER TO CFA, page: PageNumber, buf: POINTER]
    RETURNS [prev, next: vDA] =
    BEGIN OPEN DiskDefs;
    desc: DiskPageDesc;
    da: vDA _ cfa.fa.da;
    startpage: PageNumber;
    direction: INTEGER _ 1;
    firstpage: PageNumber _ cfa.fa.page;
    arg: swap DiskRequest _ DiskRequest[
      buf, @da, , , @cfa.fp, TRUE, ReadD, ReadD, TRUE, swap[@desc]];
    BEGIN
    IF da = eofDA THEN GO TO reset;
    SELECT firstpage - page FROM
      <= 0 => NULL;
      = 1, < firstpage/10 => direction _ -1;
      ENDCASE => GO TO reset;
    EXITS reset => BEGIN firstpage _ 0; da _ cfa.fp.leaderDA; END;
    END;
    BEGIN
    ENABLE
      DiskCheckError --[page]-- =>
	BEGIN
	IF page # startpage THEN RESUME
	;
	IF startpage = 0 THEN GO TO failed;
	firstpage _ 0;
	da _ cfa.fp.leaderDA;
	direction _ 1;
	RETRY;
	END;
    IF da = eofDA THEN GO TO failed;
    startpage _ firstpage;
    UNTIL da = eofDA DO
      arg.firstPage _ firstpage;
      arg.lastPage _
	IF direction < 0 THEN firstpage ELSE MIN[page, firstpage + jump - 1];
      [] _ SwapPages[@arg];
      IF desc.page = page THEN EXIT;
      da _ IF direction < 0 THEN desc.prev ELSE desc.next;
      firstpage _ desc.page + direction;
      ENDLOOP;
    cfa.fa _ FA[desc.this, desc.page, desc.bytes];
    RETURN[desc.prev, desc.next];
    EXITS failed => ERROR InvalidFP[@cfa.fp];
    END;
    END;

  ChangeDataToFileSegment: PUBLIC PROCEDURE [
    dataseg: DataSegmentHandle, fileseg: FileSegmentHandle] =
    BEGIN
    IF dataseg.pages # fileseg.pages OR ~fileseg.write OR fileseg.swappedin OR
      fileseg.file.swapcount = MaxRefs THEN SIGNAL SwapError[fileseg];
    IF ~fileseg.file.open THEN OpenFile[fileseg.file];
    ProcessDefs.DisableInterrupts[];
    fileseg.swappedin _ TRUE;
    fileseg.lock _ fileseg.lock + 1;
    fileseg.file.swapcount _ fileseg.file.swapcount + 1;
    SwapperOps.UpdateVM[
      base: fileseg.VMpage _ dataseg.VMpage, pages: fileseg.pages, seg: fileseg];
    ProcessDefs.EnableInterrupts[];
    SwapperOps.LiberateObject[dataseg];
    END;

  InvalidLongPointer: PUBLIC ERROR [lp: LONG UNSPECIFIED] = CODE;

  ValidateLongPointer: PUBLIC PROCEDURE [a: LONG UNSPECIFIED] =
    BEGIN
    page: PageNumber;
    index: Region.Index;
    IF InlineDefs.HighHalf[a] > LAST[Region.Index] THEN
      ERROR InvalidLongPointer[a];
    page _ InlineDefs.LongDiv[a, AltoDefs.PageSize];
    [quotient: index] _ InlineDefs.DIVMOD[page, Region.PagesPerRegion];
    IF regions[index] = NIL THEN ERROR InvalidLongPointer[a];
    END;

  LongVMtoSegment: PUBLIC PROCEDURE [a: LONG POINTER] RETURNS [SegmentHandle] =
    BEGIN
    relPage: Region.Page;
    ValidateLongPointer[a];
    relPage _ PageFromAddress[InlineDefs.LowHalf[a]];
    RETURN[regions[InlineDefs.HighHalf[a]].status[relPage].seg]
    END;

  LongVMtoFileSegment: PUBLIC PROCEDURE [a: LONG POINTER]
    RETURNS [FileSegmentHandle] =
    BEGIN
    seg: SegmentHandle _ LongVMtoSegment[a];
    IF seg = NIL THEN RETURN[NIL];
    WITH s: seg SELECT FROM file => RETURN[@s]; ENDCASE;
    RETURN[NIL];
    END;


  END.