-- Copyright (C) 1984  by Xerox Corporation. All rights reserved. 
--FloppyImplPublicC.mesa   (last edited by JXG     on 18-Jan-84 17:25:19)

DIRECTORY
  Environment USING [wordsPerPage],
  File USING [File, PageCount, PageNumber, Type],
  Floppy USING [
    AlreadyFormatted, BootFilePointer, Close, CopyFromPilotFile, CopyToPilotFile,
    DataError, Density, Error, ErrorType, FileHandle, FileID, Format, 
    GetAttributes,    GetBootFiles, GetFileAttributes, GetNextFile, nullFileID,
    Open, PageCount,    PageNumber, SetBootFiles, SetRootFile, Sides,
    VolumeHandle],
  FloppyChannel USING [DiskAddress],
  FloppyFormat USING [
    ConvertPageNumber, DiskAddressToSector, firstDataAddress, nullSector, Sector,
    SectorToDiskAddress],
  FloppyImplInterface,
  Inline USING [LowHalf],
  Space USING [Interval, Map, Unmap],
  SpecialFloppy USING [CreateInitialMicrocodeWithID, CreateFileAtAddressWithID,
    Error, ErrorType, GetFileAtDiskAddress, nullDiskAddress];
  

FloppyImplPublicC: MONITOR LOCKS volumeDesc USING volumeDesc:
  FloppyImplInterface.VolumeDesc
  IMPORTS
    Floppy, FloppyFormat, FloppyImplInterface, Inline, Space,
    SpecialFloppy
  EXPORTS Floppy, SpecialFloppy =

  BEGIN OPEN FloppyImplInterface;

  FloppyFileInfo: TYPE = MACHINE DEPENDENT RECORD [
    fileID(0): Floppy.FileID,
    size(2): Floppy.PageCount,
    fileType(4): File.Type,
    offset(5): File.PageNumber];

  FloppyInfoSeq: TYPE = RECORD [
    length: CARDINAL, item: ARRAY [0..0) OF FloppyFileInfo];

  FloppyInfoSeqType: TYPE = LONG POINTER TO FloppyInfoSeq;

  HeaderPage0: TYPE = MACHINE DEPENDENT RECORD [
    seal(0): CARDINAL ¬ ImageSeal,
    version(1): CARDINAL¬ ImageVersion,
    currentNumberOfFiles(2): CARDINAL,
    maxNumberOfFiles(3): CARDINAL,
    fileList(4): Floppy.FileHandle,
    rootFile(8): Floppy.FileHandle,
    density(12): Floppy.Density,
    sides(13): Floppy.Sides,
    initialUCode(14): Floppy.BootFilePointer,
    pilotUCode(18): Floppy.BootFilePointer,
    diagUCode(22): Floppy.BootFilePointer,
    germ(26): Floppy.BootFilePointer, 
    pilotBootFile(30): Floppy.BootFilePointer,
    pilotUCodeAddress(34): FloppyChannel.DiskAddress,
    diagUCodeAddress(36): FloppyChannel.DiskAddress,
    germAddress(38): FloppyChannel.DiskAddress,
    pilotBootFileAddress(40): FloppyChannel.DiskAddress,
    sizeOfFile(42): Floppy.PageCount,
    pseudoRootPageIndex(44): CARDINAL,
    labelStringBody(45): StringBody];
    
  ImageSeal: CARDINAL = 146363B;
  ImageVersion: CARDINAL = 1;
  PseudoPVRootPageAddress: FloppyChannel.DiskAddress = [
      cylinder: 4, head: 0, sector: 1];


  CreateFileAtAddress: PUBLIC PROCEDURE [
    volume: Floppy.VolumeHandle, size: Floppy.PageCount, type: File.Type,
    location: FloppyChannel.DiskAddress] RETURNS [file: Floppy.FileHandle] =
    BEGIN
    volumeDesc: VolumeDesc;
    file.volume ¬ volume;
    volumeDesc ¬ ValidateHandle[volume];
    file.file ¬ CreateFileAtAddressWithIDInternal[
      volumeDesc, Floppy.nullFileID, size, type, location];
    END;

  CreateFileAtAddressWithID: PUBLIC PROCEDURE [
    volume: Floppy.VolumeHandle, id: Floppy.FileID, size: Floppy.PageCount,
    type: File.Type, location: FloppyChannel.DiskAddress]
    RETURNS [file: Floppy.FileHandle] =
    BEGIN
    volumeDesc: VolumeDesc;
    file.volume ¬ volume;
    volumeDesc ¬ ValidateHandle[volume];
    file.file ¬ CreateFileAtAddressWithIDInternal[
      volumeDesc, id, size, type, location];
    END;

  CreateFileAtAddressWithIDInternal: ENTRY PROCEDURE [
    volumeDesc: VolumeDesc, id: Floppy.FileID, size: Floppy.PageCount,
    type: File.Type, location: FloppyChannel.DiskAddress]
    RETURNS [file: Floppy.FileID] =
    BEGIN
    ENABLE BEGIN UNWIND => NULL; END;
    startSector: FloppyFormat.Sector;
    IF ~volumeDesc.open THEN RETURN WITH ERROR Floppy.Error[volumeNotOpen];
    IF location = SpecialFloppy.nullDiskAddress THEN
      startSector ¬ FloppyFormat.nullSector
    ELSE
      BEGIN
      startSector ¬ FloppyFormat.DiskAddressToSector[
        location, volumeDesc.sectorNine.cylinders,
        volumeDesc.sectorNine.tracksPerCylinder,
        volumeDesc.sectorNine.sectorsPerTrack];
      --check that location is valid
      IF
        (FloppyFormat.DiskAddressToSector[
          FloppyFormat.firstDataAddress, volumeDesc.sectorNine.cylinders,
          volumeDesc.sectorNine.tracksPerCylinder,
          volumeDesc.sectorNine.sectorsPerTrack] > startSector)
        OR (startSector + size > volumeDesc.numPages - 1) THEN
        RETURN WITH ERROR SpecialFloppy.Error[invalidDiskAddress];
      END;
    file ¬ CreateFileInternal[volumeDesc, size, type, startSector, id].fileID;
    END;


  CreateFloppyFromImage: PUBLIC PROCEDURE [
    floppyDrive: CARDINAL, imageFile: File.File,
    firstImagePage: File.PageNumber, reformatFloppy: BOOLEAN,
    floppyDensity: Floppy.Density, floppySides: Floppy.Sides,
    numberOfFiles: CARDINAL, newLabelString: LONG STRING] =
    
    BEGIN
    floppyFileInfoPerPage: CARDINAL = Environment.wordsPerPage/SIZE[FloppyFileInfo];
    headerPage0Ptr: LONG POINTER TO HeaderPage0;
    floppyHandle: Floppy.VolumeHandle;
    space1Interval: Space.Interval;
    space2Interval: Space.Interval;
    floppyInfoSeqPtr: FloppyInfoSeqType;
    fileHandle: Floppy.FileHandle;
    oldLabelString: LONG STRING;
    index: CARDINAL ¬ 0;
    spaceAvailable: Floppy.PageCount;
    dataErrorFile: Floppy.FileHandle;
    dataErrorPage: Floppy.PageNumber;

    BEGIN OPEN hdr:headerPage0Ptr, flptr: floppyInfoSeqPtr;
    space1Interval ¬ Space.Map[
      [file: imageFile, base: firstImagePage, count: 1]];
    headerPage0Ptr ¬ space1Interval.pointer;
    IF hdr.seal # ImageSeal OR hdr.version # ImageVersion THEN
      ERROR Floppy.Error[error: floppyImageInvalid];
    IF numberOfFiles # 0 AND hdr.currentNumberOfFiles > numberOfFiles THEN
      ERROR Floppy.Error[error: fileListLengthTooShort];
    oldLabelString ¬ @hdr.labelStringBody;
    space2Interval ¬ Space.Map[
      [file: imageFile, base: firstImagePage + 1, count: hdr.currentNumberOfFiles/floppyFileInfoPerPage + 1]];
    floppyInfoSeqPtr ¬ space2Interval.pointer;
    Floppy.Format[
      drive: floppyDrive,
      maxNumberOfFileListEntries:
      IF numberOfFiles = 0 THEN hdr.maxNumberOfFiles ELSE numberOfFiles,
      labelString:
      IF newLabelString = NIL THEN oldLabelString
      ELSE IF newLabelString.length = 0 THEN oldLabelString ELSE newLabelString,
      density: floppyDensity, sides: floppySides !
      Floppy.AlreadyFormatted => IF reformatFloppy THEN RESUME ELSE REJECT];
    floppyHandle ¬ Floppy.Open[floppyDrive];
    [freeSpace: spaceAvailable] ¬ Floppy.GetAttributes [
      volume: floppyHandle, labelString: NIL];
    IF hdr.sizeOfFile > spaceAvailable THEN ERROR Floppy.Error[error: floppySpaceTooSmall];
    

    FOR index IN [0..flptr.length) DO
    
      SELECT flptr.item[index].fileID FROM
        Floppy.nullFileID => EXIT;
        hdr.initialUCode.file =>
          fileHandle ¬ SpecialFloppy.CreateInitialMicrocodeWithID[
            volume: floppyHandle, id: flptr.item[index].fileID, size:
	    flptr.item[index].size, type: flptr.item[index].fileType,
	    startingPageNumber: hdr.initialUCode.page !
            SpecialFloppy.Error => SELECT error FROM
	      IDAlreadyInUse => ERROR Floppy.Error[error: floppyImageInvalid];
	      ENDCASE];
        flptr.item[hdr.pseudoRootPageIndex].fileID =>
          fileHandle ¬ SpecialFloppy.CreateFileAtAddressWithID[
            volume: floppyHandle, id: flptr.item[index].fileID,
	    size: flptr.item[index].size, type: flptr.item[index].fileType,
	    location: PseudoPVRootPageAddress !
            SpecialFloppy.Error => SELECT error FROM
	      IDAlreadyInUse => ERROR Floppy.Error[error: floppyImageInvalid];
	      ENDCASE];
        hdr.pilotUCode.file =>
	  fileHandle ¬ SpecialFloppy.CreateFileAtAddressWithID[
            volume: floppyHandle, id: flptr.item[index].fileID,
	    size: flptr.item[index].size, type: flptr.item[index].fileType,
	    location: hdr.pilotUCodeAddress !
            SpecialFloppy.Error => SELECT error FROM
	      IDAlreadyInUse => ERROR Floppy.Error[error: floppyImageInvalid];
	      ENDCASE];
        hdr.diagUCode.file =>
	  fileHandle ¬ SpecialFloppy.CreateFileAtAddressWithID[
            volume: floppyHandle, id: flptr.item[index].fileID,
	    size: flptr.item[index].size, type: flptr.item[index].fileType,
	    location: hdr.diagUCodeAddress !
            SpecialFloppy.Error => SELECT error FROM
	      IDAlreadyInUse => ERROR Floppy.Error[error: floppyImageInvalid];
	      ENDCASE];
	hdr.germ.file =>
	  fileHandle ¬ SpecialFloppy.CreateFileAtAddressWithID[
            volume: floppyHandle, id: flptr.item[index].fileID,
	    size: flptr.item[index].size, type: flptr.item[index].fileType,
	    location: hdr.germAddress !
            SpecialFloppy.Error => SELECT error FROM
	      IDAlreadyInUse => ERROR Floppy.Error[error: floppyImageInvalid];
	      ENDCASE];
        hdr.pilotBootFile.file =>
	  fileHandle ¬ SpecialFloppy.CreateFileAtAddressWithID[
            volume: floppyHandle, id: flptr.item[index].fileID,
	    size: flptr.item[index].size, type: flptr.item[index].fileType,
	    location: hdr.pilotBootFileAddress !
            SpecialFloppy.Error => SELECT error FROM
	      IDAlreadyInUse => ERROR Floppy.Error[error: floppyImageInvalid];
	      ENDCASE];
        ENDCASE =>
          fileHandle ¬ SpecialFloppy.CreateFileAtAddressWithID[
            volume: floppyHandle, id: flptr.item[index].fileID, 
	    size: flptr.item[index].size, type: flptr.item[index].fileType,
	    location: SpecialFloppy.nullDiskAddress !
            SpecialFloppy.Error => SELECT error FROM
	      IDAlreadyInUse => ERROR Floppy.Error[error: floppyImageInvalid];
	      ENDCASE];
      fileHandle ¬ [floppyHandle, flptr.item[index].fileID];
     Floppy. CopyFromPilotFile[
        pilotFile: imageFile, floppyFile: fileHandle,
        firstPilotPage: firstImagePage + flptr.item[index].offset, firstFloppyPage: 0,
        count: flptr.item[index].size !
        Floppy.DataError =>
          BEGIN
	    dataErrorFile ¬ file;
	    dataErrorPage ¬ page;
	    space2Interval.pointer ¬ Space.Unmap[space2Interval.pointer];
            space1Interval.pointer ¬ Space.Unmap[space1Interval.pointer];
            Floppy.Close[floppyHandle];
	    GOTO errorExit;
          END; ];
      ENDLOOP;

    Floppy.SetBootFiles[
      volume: floppyHandle, pilotMicrocode: hdr.pilotUCode,
      diagnosticMicrocode: hdr.diagUCode, germ: hdr.germ, 
      pilotBootFile: hdr.pilotBootFile];
    IF hdr.rootFile.file # Floppy.nullFileID THEN Floppy.SetRootFile[hdr.rootFile];
    space2Interval.pointer ¬ Space.Unmap[space2Interval.pointer];
    space1Interval.pointer ¬ Space.Unmap[space1Interval.pointer];
    Floppy.Close[floppyHandle];
    EXITS
      errorExit => ERROR Floppy.DataError[file: dataErrorFile, page: dataErrorPage , vm: NIL];
    END;
    END;


  CreateInitialMicrocodeWithID: PUBLIC PROCEDURE [
    volume: Floppy.VolumeHandle, id: Floppy.FileID, size: Floppy.PageCount,
    type: File.Type, startingPageNumber: Floppy.PageNumber]
    RETURNS [file: Floppy.FileHandle] =
    BEGIN
    volumeDesc: VolumeDesc;
    file.volume ¬ volume;
    volumeDesc ¬ ValidateHandle[volume];
    file.file ¬ CreateInitialMicrocodeInternal[
      volumeDesc, size, type, startingPageNumber, id];
    END;


  GetDiskAddress: PUBLIC PROCEDURE [
    file: Floppy.FileHandle, page: Floppy.PageNumber]
    RETURNS [diskAddress: FloppyChannel.DiskAddress] =
    BEGIN
    volumeDesc: VolumeDesc;
    GetDiskAddressInternal: ENTRY PROCEDURE [
      volumeDesc: VolumeDesc, page: Floppy.PageNumber] =
      BEGIN
      ENABLE BEGIN UNWIND => NULL; END;
      sector: FloppyFormat.Sector;
      IF ~volumeDesc.open THEN RETURN WITH ERROR Floppy.Error[volumeNotOpen];
      sector ¬
        FindFile[volumeDesc, file.file].address + FloppyFormat.ConvertPageNumber[
          page];
      diskAddress ¬ FloppyFormat.SectorToDiskAddress[
        sector, volumeDesc.sectorNine.cylinders,
        volumeDesc.sectorNine.tracksPerCylinder,
        volumeDesc.sectorNine.sectorsPerTrack];
      END;
    volumeDesc ¬ ValidateHandle[file.volume];
    GetDiskAddressInternal[volumeDesc, page];
    END;

  GetFileAtDiskAddress: PUBLIC PROCEDURE [
    volume: Floppy.VolumeHandle, diskAddress: FloppyChannel.DiskAddress]
    RETURNS [file: Floppy.FileHandle, pageNumber: Floppy.PageNumber] =
    BEGIN
    volumeDesc: VolumeDesc;
    GetFileAtDiskAddressInternal: ENTRY PROCEDURE [
      volumeDesc: VolumeDesc, diskAddress: FloppyChannel.DiskAddress] =
      BEGIN
      ENABLE BEGIN UNWIND => NULL; END;
      sector: FloppyFormat.Sector;
      file.volume ¬ volume;
      IF ~volumeDesc.open THEN RETURN WITH ERROR Floppy.Error[volumeNotOpen];
      sector ¬ FloppyFormat.DiskAddressToSector[
        diskAddress, volumeDesc.sectorNine.cylinders,
        volumeDesc.sectorNine.tracksPerCylinder,
        volumeDesc.sectorNine.sectorsPerTrack];
      IF volumeDesc.allocationMap[sector] ~= allocated THEN
        BEGIN file.file ¬ Floppy.nullFileID; pageNumber ¬ 0; RETURN; END
      ELSE
        BEGIN
        file.file ¬ Floppy.nullFileID;
        pageNumber ¬ 0;
        FOR i: CARDINAL IN [0..volumeDesc.fileList.count) DO
          IF sector IN
            [volumeDesc.fileList.files[
               i].location..volumeDesc.fileList.files[i].location +
                              volumeDesc.fileList.files[i].size) THEN
            BEGIN
            file.file ¬ volumeDesc.fileList.files[i].file;
            pageNumber ¬ sector - volumeDesc.fileList.files[i].location;
            EXIT;
            END;
          ENDLOOP;
        END;
      END;
    volumeDesc ¬ ValidateHandle[volume];
    GetFileAtDiskAddressInternal[volumeDesc, diskAddress];
    END;


  GetCurrentNumberOfFiles: PROCEDURE [volume: Floppy.VolumeHandle]
    RETURNS [currentNumberOfFiles: CARDINAL] =
    BEGIN
    volumeDesc: VolumeDesc;
    GetCurrentNumberOfFilesInternal: ENTRY PROCEDURE [volumeDesc: VolumeDesc] =
      BEGIN
      ENABLE BEGIN UNWIND => NULL; END;
      IF ~volumeDesc.open THEN RETURN WITH ERROR Floppy.Error[volumeNotOpen];
      currentNumberOfFiles ¬ volumeDesc.fileList.count;
      END;
    volumeDesc ¬ ValidateHandle[volume];
    GetCurrentNumberOfFilesInternal[volumeDesc];
    END;


  GetImageAttributes: PUBLIC PROCEDURE [
    imageFile: File.File, firstImagePage: File.PageNumber, name: LONG STRING]
    RETURNS [
      maxNumberOfFiles: CARDINAL, currentNumberOfFiles: CARDINAL,
      density: Floppy.Density[single..double], sides: Floppy.Sides[one..two]] =
    BEGIN
    headerPage0Ptr: LONG POINTER TO HeaderPage0;
    spaceInterval: Space.Interval;
    labelString: LONG STRING;

    spaceInterval ¬ Space.Map[[file: imageFile, base: firstImagePage, count: 1]];
    headerPage0Ptr ¬ spaceInterval.pointer;
    labelString ¬ @headerPage0Ptr.labelStringBody;
    IF name # NIL THEN
      BEGIN
      FOR index: CARDINAL IN [0..MIN[name.maxlength, labelString.length]) DO
        name.text[index] ¬ labelString.text[index]; ENDLOOP;
      name.length ¬ labelString.length;
      END;
    maxNumberOfFiles ¬ headerPage0Ptr.maxNumberOfFiles;
    currentNumberOfFiles ¬ headerPage0Ptr.currentNumberOfFiles;
    density ¬ headerPage0Ptr.density;
    sides ¬ headerPage0Ptr.sides;
    spaceInterval.pointer ¬ Space.Unmap[spaceInterval.pointer];
    END;



  MakeImage: PUBLIC PROCEDURE [
    floppyDrive: CARDINAL, imageFile: File.File,
    firstImagePage: File.PageNumber] =
    BEGIN
    
    floppyFileInfoPerPage: CARDINAL = Environment.wordsPerPage/SIZE[FloppyFileInfo];
    headerPage0Ptr: LONG POINTER TO HeaderPage0;
    floppyHandle: Floppy.VolumeHandle;
    space1Interval: Space.Interval;
    space2Interval: Space.Interval;
    floppyInfoSeqPtr: FloppyInfoSeqType;
    labelString: LONG STRING;
    numOfFiles: CARDINAL;
    fileHandle: Floppy.FileHandle;
    floppyID: Floppy.FileID ¬ Floppy.nullFileID;
    index: CARDINAL ¬ 0;
    numOfPages: LONG CARDINAL;
    pages: Floppy.PageCount;
    pseudoRootPageHandle: Floppy.FileHandle;
    dataErrorFile: Floppy.FileHandle;
    dataErrorPage: Floppy.PageNumber;

    BEGIN OPEN hdr: headerPage0Ptr, flptr: floppyInfoSeqPtr;
    floppyHandle ¬ Floppy.Open[floppyDrive];
    [pages: pages, files: numOfFiles] ¬ PagesForFloppyInfoSeq[
      floppyHandle];
    numOfPages ¬ pages;
    space2Interval ¬ Space.Map[[file: imageFile, base: firstImagePage + 1, count: pages]];
    floppyInfoSeqPtr ¬ space2Interval.pointer;
    space1Interval ¬ Space.Map[[file: imageFile, base: firstImagePage, count: 1]];
    headerPage0Ptr ¬ space1Interval.pointer;
    flptr.length ¬ numOfFiles - 1;  -- The fileList is not included
    numOfPages ¬ numOfPages + 1;
    [file: pseudoRootPageHandle] ¬ SpecialFloppy .GetFileAtDiskAddress[
      volume: floppyHandle, diskAddress: PseudoPVRootPageAddress];
    fileHandle ¬ [floppyHandle, floppyID];
    fileHandle ¬ Floppy.GetNextFile[fileHandle];

    FOR index IN [0..flptr.length) DO
    
      SELECT fileHandle.file FROM 
        pseudoRootPageHandle.file => hdr.pseudoRootPageIndex ¬ index;
	hdr.pilotUCode.file =>
	  hdr.pilotUCodeAddress ¬ GetDiskAddress[file: fileHandle, page: 0];
        hdr.diagUCode.file =>
	  hdr.diagUCodeAddress ¬ GetDiskAddress[file: fileHandle, page: 0];
	hdr.germ.file =>
	  hdr.germAddress ¬ GetDiskAddress[file: fileHandle, page: 0];
	hdr.pilotBootFile.file =>
	  hdr.pilotBootFileAddress ¬ GetDiskAddress[file: fileHandle, page: 0];
	ENDCASE => NULL;
	
      [size: flptr.item[index].size, type: flptr.item[index].fileType] ¬
        Floppy.GetFileAttributes[fileHandle];
      flptr.item[index].fileID ¬ fileHandle.file;
      flptr.item[index].offset ¬ numOfPages;
      Floppy.CopyToPilotFile[
        floppyFile: fileHandle, pilotFile: imageFile, firstFloppyPage: 0,
        firstPilotPage: firstImagePage + flptr.item[index].offset,
        count: flptr.item[index].size !
        Floppy.DataError =>
          BEGIN
	    dataErrorFile ¬ file;
	    dataErrorPage ¬ page;
            space1Interval.pointer ¬ Space.Unmap[space1Interval.pointer];
	    space2Interval.pointer ¬ Space.Unmap[space2Interval.pointer];
            Floppy.Close[floppyHandle];
	    GOTO errorExit;
          END; ];
      numOfPages ¬ numOfPages + flptr.item[index].size;
      fileHandle ¬ Floppy.GetNextFile[fileHandle];
      ENDLOOP;

    numOfPages ¬ numOfPages - flptr.item[0].offset;
    space2Interval.pointer ¬ Space.Unmap[space2Interval.pointer];
    
    labelString ¬ @hdr.labelStringBody;
    labelString­ ¬ StringBody[length: 0, maxlength: 128, text:];
    hdr.seal ¬ ImageSeal;
    hdr.version ¬ ImageVersion;
    hdr.currentNumberOfFiles ¬ GetCurrentNumberOfFiles[floppyHandle];
    [fileList: hdr.fileList, rootFile: hdr.rootFile, density: hdr.density,
    sides: hdr.sides, maxFileListEntries: hdr.maxNumberOfFiles] ¬
      Floppy.GetAttributes[volume: floppyHandle, labelString: labelString];
    [hdr.initialUCode, hdr.pilotUCode, hdr.diagUCode, hdr.germ, hdr.pilotBootFile] ¬
      Floppy.GetBootFiles[floppyHandle];
    hdr.sizeOfFile ¬ numOfPages;
    space1Interval.pointer ¬ Space.Unmap[space1Interval.pointer];
    Floppy.Close[floppyHandle];
    EXITS
      errorExit => ERROR Floppy.DataError[file: dataErrorFile, page: dataErrorPage, vm: NIL];
    END;
    END;



  PagesForFloppyInfoSeq: PROCEDURE [
    floppyHandle: Floppy.VolumeHandle]
    RETURNS [pages: File.PageCount, files: CARDINAL] =
    BEGIN

    files ¬ GetCurrentNumberOfFiles[floppyHandle];
    pages ¬ (files*SIZE[FloppyFileInfo] + Environment.wordsPerPage -1)/ Environment.wordsPerPage;
    END;


  PagesForImage: PUBLIC PROCEDURE [floppyDrive: CARDINAL]
    RETURNS [File.PageCount] =

    BEGIN
    floppyHandle: Floppy.VolumeHandle;
    fileHandle: Floppy.FileHandle;
    floppyID: Floppy.FileID ¬ Floppy.nullFileID;
    numOfPages: File.PageCount ¬ 1;  -- for the header
    sizeOfFile: Floppy.PageCount;
    pages: File.PageCount;

    floppyHandle ¬ Floppy.Open[floppyDrive];
    [pages: pages] ¬ PagesForFloppyInfoSeq[floppyHandle];
    numOfPages ¬ numOfPages + pages;
    fileHandle ¬ [floppyHandle, floppyID];
    fileHandle ¬ Floppy.GetNextFile[fileHandle];
    WHILE fileHandle.file # Floppy.nullFileID DO
      [size: sizeOfFile] ¬ Floppy.GetFileAttributes[fileHandle];
      numOfPages ¬ numOfPages + LOOPHOLE[sizeOfFile, LONG CARDINAL];
      fileHandle ¬ Floppy.GetNextFile[fileHandle];
      ENDLOOP;
    Floppy.Close[floppyHandle];
    RETURN[numOfPages];
    END;




  END.


LOG
Time:   1-Feb-82 15:08:14  by: LXD      
	Created File
Time:   9-Feb-82 19:04:53  by: LXD      
	added GetDiskAddress
Time:  11-Feb-82 18:05:30  by: LXD      
	added GetFileAtDiskAddress
Time:   6-Aug-82 18:47:49  by: AWL      
	Implemented GetFileListAttributes, CreateWithIDAtLocation,
CreateInitialMicrocodeWIthID
Time:   2-Nov-82 11:15:25  By: EKN   
   	Added CreateFloppyFromImage, GetImageAttributes, MakeImage,
	PagesForImage, PagesForFloppyInfoSeq, FCError. 
	(written by DXG     )
Time:	 2-Mar-83 15:16:57 By: EKN   
	Updated Space Stuff to Klamath.  ChangedGetFileListAttributes to GetCurrentNumberOfFiles. References to SpecialFloppyExtras and FloppyExtras are now SpecialFloppy and Floppy, respectively.
Time:	18-Jan-84 15:14:36 By: JXG     off by one error
Time:	18-Jan-84 17:26:08 By: JXG     undid erroneous fix