DataMuseum.dk

Presents historical artifacts from the history of:

Bogika Butler

This is an automatic "excavation" of a thematic subset of
artifacts from Datamuseum.dk's BitArchive.

See our Wiki for more about Bogika Butler

Excavated with: AutoArchaeologist - Free & Open Source Software.


top - metrics - download

⟦a4265efe6⟧ TextFile

    Length: 15488 (0x3c80)
    Types: TextFile
    Names: »OPTIFS.SA«

Derivation

└─⟦2322e079b⟧ Bits:30009789/_.ft.Ibm2.50006594.imd Mogens Pelles Zilog 80,000 / EOS projekt
    └─⟦this⟧ »OPTIFS.SA« 
└─⟦311ba069f⟧ Bits:30009789/_.ft.Ibm2.50006625.imd Mogens Pelles Zilog 80,000 / EOS projekt
    └─⟦this⟧ »OPTIFS.SA« 
└─⟦49237ce80⟧ Bits:30009789/_.ft.Ibm2.50006627.imd Mogens Pelles Zilog 80,000 / EOS projekt
    └─⟦this⟧ »OPTIFS.SA« 

TextFile

 
æ*****************************************************************
                        Copyright 1984 by
                        NCR Corporation
                        Dayton, Ohio  U.S.A.
                        All Rights Reserved
******************************************************************
                        EOS Software produced by:
                        NCR Systems Engineering - Copenhagen
                        Copenhagen
                        DENMARK
*****************************************************************å
 
æ$h=0åæ no heap space å
æ
 
 
              OOOO   RRRRR   TTTTTT    II        FFFFFF   SSSS
             OO  OO  RR  RR    TT      II        FF      SS  SS
             OO  OO  RR  RR    TT      II        FF      SS
             OO  OO  RRRRR     TT      II    ==  FFFFF    SSSS
             OO  OO  RR        TT      II        FF          SS
             OO  OO  RR        TT      II        FF      SS  SS
              OOOO   RR        TT      II        FF       SSSS
 
 
å
æ$Eå
OBJECT PROGRAM OptiFs;
 
æ$F=FAMILY.UNIV.IDå
 
æ$Eå
æ$F=FAMILY.KNEL.IDå
 
PROCEDURE PrintText (text : fullId); FORWARD;
PROCEDURE PrintVar  (text : fullId; UNIV v : blockPtr); FORWARD;
 
æ$Eå
 
æ****** E X P O R T   D E S C R I P T I O N ******å
æ*************************************************å
 
æ$F=FAMILY.IOSYS.IDå
 
æ$Eå
 
æ****** I M P O R T   D E S C R I P T I O N ******å
æ*************************************************å
 
æ$F=FAMILY.ALLOC.IDå
 
æ$Eå
 
æ$F=FAMILY.SCHED.IDå
 
æ$Eå
 
æ$F=FAMILY.OBJDIR.IDå
 
æ$F=PASINCLU.TERMTOOL.SAå
 
 
æ$Eå
 
æ***** C O N S T A N T S   A N D   T Y P E S *****å
æ*************************************************å
 
CONST
  defaultTerm      = '/term0';
  maxIdLength      = 48;
  orgNo            = 00;
  orgSys           = 4004;
  Reject           = -1;
  space            = ' ';
  PageSize         = 256;
  PageNo           = 100;
  noControl        = 0;
 
æargument numberså
  objectArg        = 1;
  entryA           = 2;
  faoArg           = 4;
  bufArg           = 4;
  fNameArg         = -1;
  dNameArg         = -1;
  baseArg          = -1;
  ioArg            = -2;
  posArg           = -2;
  offsetArg        = -2;
  createArg        = -3;
  seekPosArg       = -3;
 
æ***** G L O B A L   P R O C E D U R E S *****å
æ*********************************************å
 
FUNCTION MakeRes (main, family, auxCause, argNo : integer)
                   : resultType;
  VAR
    r : resultType;
  BEGIN
    r.main     := main;
    r.family   := family;
    r.argNo    := argNo;
    r.auxCause := auxCause;
    r.orgNo    := orgNo;
    r.orgSys   := orgSys;
 
    MakeRes := r;
  END;  æ MakeRes å
 
 
PROCEDURE Check (res : resultType);
  BEGIN
    IF res.main <> Ok THEN printVar ('**** OptiFs Check ****  res=', res);
æ#b#printVar ('**** OptiFs Check ****  res=', res); #e#å
    IF res.main <> Ok THEN Exception (res);
  END;
 
PROCEDURE StopCheck (res : resultType);
  BEGIN
æ#b# printVar ('**** OptiFs StopCheck ****  res=', res); #e#å
    IF res.main <> Ok THEN Exception (res);
  END;
 
procedure CopyBytes ( univ source, dest: blockPtr );
  var i, max: integer;
  begin
    max := elements ( source );
    if max > elements ( dest ) then max := elements ( dest );
    for i := 1 to max do destÆiÅ := sourceÆiÅ;
  end;
 
procedure FillBytes ( univ b: Byte; univ dest: blockPtr );
  var i: integer;
  begin
    for i := 1 to elements ( dest ) do destÆiÅ := b;
  end;
æ$Eå
æ****** F A O   L O C A L   P O I N T E R S ******å
æ*************************************************å
 
TYPE
  refFao = ^^faoLocals;
 
  faoLocals = RECORD
      code     : ^^;
      data     : ^^FaoData;
      fsRef    : ^^filsysLocals;
      faoRef   : faoRefType;
    END;
 
  pageBuf = record
    pos,
    unreffed: integer;
   æcontents: array Æ1..pageSizeÅ of byte; å
    end;
 
  FaoData = RECORD
    name : arrayÆ1..maxIdLengthÅ of char;
    bufs: array Æ1..pageNoÅ of pageBuf;
    hitCount, noHitCount: integer;
    END;
 
æ$Eå
æ****** I O S Y S   L O C A L   P O I N T E R S ******å
æ*****************************************************å
 
TYPE
  fsLocRef  = ^^ filsysLocals;
 
  filsysLocals = RECORD
      code        : ^^;
      objDirRef   : ^^ObjDir;
      allocRef    : ^^Allocate;
      termRef     : faoRefType;
      faoMan      : ref;
    END;
 
æ$Eå
 
æ****** I M P L E M E N T   O P T I     F A O ******å
æ***************************************************å
 
PROGRAM FaoImplement OBJECT Fao WITH FaoLocals;
 
 
æ$Eå
 
æ*****   ReadSeq / WriteSeq   *****å
æ**********************************å
 
ENTRY ReadSeq
  æ segment ; OUT byteCount å
  WITH RECORD
    t : ^^;
  END;
 
 
BEGIN
æ#b#  printText ('-----Opti.ReadSeq-----');  #e#å
  Exception (MakeRes (Reject*EntryIllegal, Universal, entryA, 0));
æ#b#  printText ('--end Opti.ReadSeq-- ' );  #e#å
END;   æReadSeqå
 
 
ENTRY WriteSeq
  æ segment ; OUT byteCount å
  WITH RECORD
    t : ^^;
  END;
 
BEGIN
æ#b#  printText ('-----Opti.WriteSeq-----');  #e#å
  Exception (MakeRes (Reject*EntryIllegal, Universal, entryA, 0));
æ#b#  printText ('--end Opti.WriteSeq-- ' );  #e#å
END;   æWriteSeqå
 
 
æ$Eå
 
æ*****   ReadRandom   *****å
æ**************************å
 
ENTRY ReadRandom
  æ segment ; OUT byteCount, IN pos, OUT actualPos å
  WITH RECORD
    t : ^^;
  END;
 
  VAR
    maxUnreffed, maxIndex, hitIndex, i: integer;
 
BEGIN
æ#b#  printText ('-----Opti.ReadRandom-----');  #e#å
  with data^^ do begin
    actualPos := pos - pos mod pageSize;
    byteCount := pageSize;
 
    maxUnreffed := 0; maxIndex := 0;
    hitIndex := 0;
 
    for i := 1 to pageNo do with b = bufsÆiÅ do begin
      if b.pos = actualPos then begin æ hit å
        hitIndex := i;
      end else begin æ no hit å
        b.unreffed := b.unreffed + 1;
        if b.unreffed > maxUnreffed then begin
          maxIndex := i;
          maxUnreffed := b.unreffed;
        end;
      end;
    end;
 
    if hitIndex <> 0 then begin æ hit å
      hitCount := hitCount + 1;
    end else begin  æ no hit å
      noHitCount := noHitCount + 1;
      hitIndex := maxIndex;
      StopCheck(faoRef.ReadRandom( segment;
                out byteCount, actualpos, out actualpos ));
    end;
 
    with bufsÆhitIndexÅ do begin
      unreffed := 0;
      pos := actualPos;
      æ CopyBytes( .... )å
    end;
  end; æ with data^^ å
æ#b#  printText ('--end Opti.ReadRandom-- ');  #e#å
END;  æReadRandomå
 
 
æ$Eå
 
ENTRY WriteRandom
  æ segment ; OUT byteCount, IN pos, OUT actualPos å
  WITH RECORD
    t : ^^;
  END;
 
BEGIN
æ#b#  printText ('-----Opti.WriteRandom-----');  #e#å
  Exception (MakeRes (Reject*EntryIllegal, Universal, entryA, 0));
æ#b#  printText ('--end Opti.WriteRandom-- ' );  #e#å
END;  æWriteRandomå
 
 
æ$Eå
 
ENTRY Seek
  æ ; IN baseMode, IN offset, OUT pos å
  WITH RECORD t : ^^; END;
 
BEGIN
æ#b#  printText ('---------Opti.seek-----------');  #e#å
  Exception (MakeRes (Reject*EntryIllegal, Universal, entryA, 0));
æ#b#  printText ('---------end Opti.seek-------- ' );  #e#å
END;
 
æ$Eå
 
ENTRY SetMode
  WITH RECORD t : ^^; END;
BEGIN
  Exception (MakeRes (Reject*EntryIllegal, Universal, entryA, 0));
end;
 
ENTRY GetFileInf
  WITH RECORD t : ^^; END;
BEGIN
  Exception (MakeRes (Reject*EntryIllegal, Universal, entryA, 0));
end;
 
ENTRY SetRights
  WITH RECORD t : ^^; END;
BEGIN
  Exception (MakeRes (Reject*EntryIllegal, Universal, entryA, 0));
end;
 
ENTRY CheckRights
  WITH RECORD t : ^^; END;
BEGIN
  Exception (MakeRes (Reject*EntryIllegal, Universal, entryA, 0));
end;
 
ENTRY MoveRights
  WITH RECORD t : ^^; END;
BEGIN
  Exception (MakeRes (Reject*EntryIllegal, Universal, entryA, 0));
end;
 
ENTRY NewLink
  WITH RECORD t : ^^; END;
BEGIN
  Exception (MakeRes (Reject*EntryIllegal, Universal, entryA, 0));
end;
 
ENTRY AllocSize
  WITH RECORD t : ^^; END;
BEGIN
  Exception (MakeRes (Reject*EntryIllegal, Universal, entryA, 0));
end;
 
æ$Eå
 
ENTRY DataSize
  æ ; IN dataBytes å
  WITH RECORD t : ^^; END;
BEGIN
æ#b#  printText ('-----vs.DataSize----- ');  #e#å
  Exception (MakeRes (Reject*EntryIllegal, Universal, entryA, 0));
END;
 
 
 
ENTRY WaitBreak
  WITH RECORD t : ^^; END;
BEGIN
  Exception (MakeRes (Reject*EntryIllegal, Universal, entryA, 0));
end;
 
ENTRY WaitReady
  WITH RECORD t : ^^; END;
BEGIN
  Exception (MakeRes (Reject*EntryIllegal, Universal, entryA, 0));
end;
 
OTHERWISE FaoOther
  WITH RECORD t : ^^; END;
BEGIN
  Exception (MakeRes (Reject*EntryIllegal, Universal, entryA, 0));
END;  æotherwisweå
 
 
END;  æOptiFaoImplementå
 
 
 
æ$Eå
 
æ****** I M P L E M E N T   O P T I     F I L E S Y S T E M ******å
æ*****************************************************************å
 
PROGRAM FilSysImplement OBJECT IoSys WITH FilSysLocals;
 
procedure PutCrLf ( line: shortId );
  Var
      crlf: arrayÆ1..2Å of char;
begin
  crlfÆ1Å:=chr(13); crlfÆ2Å:=chr(10);
  PutText ( line, crlf );
end;
 
procedure InitFs ( termName: fullId );
  var used, kind: integer;
      line: lineType;
begin
  StopCheck(ObjDirRef.GetRef(out termRef; termName, out used, out kind));
  ClearText ( line );
  PutCrLf ( line );
  PutText ( line, 'OptiFs initialised  ');
  PutNL ( line );
  StopCheck (termIo(termRef,WriteSeq,line));
end;
 
 
PRIVATE Close
  (IN   fao : ownSet;
   IN   faoEnv : refFao);
 
 
æ*****   Assign   *****å
æ**********************å
 
ENTRY Assign
  æOUT ownedFao; IN fileName, IN ioRights, optional IN createMode, volumeå
  WITH RECORD
    t : ^^;
    faoEnv     : ^^ faoLocals;
    fs: ref;
  END;
 
  VAR
    nullSize, voidSize, size : sizeType;
    i, used: integer;
    line: lineType;
 
  BEGIN
æ#b#  printText ('-----Opti.Assign-----');  #e#å
 
  æ Allocate Fao Object å
  StopCheck( ClearSize (size));
  StopCheck( AddGen (size, refs(faoLocals)));
  StopCheck( AddEmbSeg (size, bytes(FaoData)));
  Check( allocRef.NewObj (OUT ownedFao; IN size, OUT i));
 
  æ Make Fao a general object with temporary manager å
  nullSize.user := 0;   nullSize.kernel := 0;
  voidSize.user := -1;  voidSize.kernel := -1;
  Check( DeclGen (ownedFao, FaoMan, faoEnv, refs(faoLocals), Close,
                    nullSize, voidSize, refs(FaoImplement),
                    bytes(FaoImplement), noControl,
                    addr(FaoImplement), nullSize, true));
  in
    æ Create Fao data segment å
    Check( NewSeg (faoEnv^^.Data, bytes(FaoData)));
    æ Copy code pointer å
    Check( Copy ( code, faoEnv^^.code ));
 
    in
      StopCheck(ObjDirRef.GetRef(out fs; filename, out used, out i));
    do begin
      Check(ObjDirRef.GetRef(out fs; '/versafs  ', out used, out i));
      used := 0;
    end;
    StopCheck(fs.Assign(out faoEnv^^.faoRef; filenameÆused+1..elements(filename)Å
                  , readright ));
 
    with faoEnv^^.Data^^ do begin
      FillBytes(' ', name );
      CopyBytes(fileNameÆused+1..elements(filename)Å, name );
      hitCount := 0;
      noHitCount := 0;
      for i := 1 to pageNo do with bufsÆiÅ do begin
        pos := -1;
        unreffed := 0;
      end;
 
      ClearText ( line );
      PutCrLf(line);
      PutText ( line, ' OptiFs open file  ' );
      PutText ( line, name );
      align ( line );
      PutNL ( line );
      in
        StopCheck(termIo(termRef,WriteSeq,line));
      do begin
        initFs ( defaultTerm );
        ClearText ( line );
        PutCrLf(line);
        PutText ( line, ' OptiFs open file  ' );
        PutText ( line, name );
        align ( line );
        PutNL ( line );
        StopCheck(termIo(termRef,WriteSeq,line));
      end;
    end; æ with å
  do begin
    Check(DelEnv(ownedFao,FaoMan));
    ObjReturn(GetException);
  end;
 
æ#b#  printText ('--end Opti.Assign-- ' );  #e#å
END;   æAssignå
 
 
æ$Eå
ENTRY InitFileScan                   æp.t. not implementedå
  æOUT scanObj; IN partialFileNameå
  WITH RECORD t : ^^; END;
BEGIN ObjReturn (MakeRes (Reject*EntryIllegal, Universal, entryA, 0)); END;
 
 
ENTRY RenameFile                     æp.t. not implementedå
  æ ; IN fileName, IN newFileNameå
  WITH RECORD t : ^^; END;
BEGIN ObjReturn (MakeRes (Reject*EntryIllegal, Universal, entryA, 0)); END;
 
 
ENTRY CreateLink                     æp.t. not implementedå
  æ ; IN fileName, IN newFileNameå
  WITH RECORD t : ^^; END;
BEGIN ObjReturn (MakeRes (Reject*EntryIllegal, Universal, entryA, 0)); END;
 
 
ENTRY DeleteLink                     æp.t. not impelmentedå
  æ ; IN fileNameå
  WITH RECORD T : ^^; END;
BEGIN ObjReturn (MakeRes (Reject*EntryIllegal, Universal, entryA, 0)); END;
 
 
ENTRY InitIpcSys      ænot VersaFså
  WITH RECORD t : ^^; END;
BEGIN ObjReturn (MakeRes (Reject*EntryIllegal, Universal, entryA, 0)); END;
 
 
ENTRY CreateFile      ænot VersaFså
  WITH RECORD t : ^^; END;
BEGIN ObjReturn (MakeRes (Reject*EntryIllegal, Universal, entryA, 0)); END;
 
 
ENTRY DeleteFile      ænot VersaFså
  WITH RECORD T : ^^; END;
BEGIN ObjReturn (MakeRes (Reject*EntryIllegal, Universal, entryA, 0)); END;
 
æ$Eå
 
 
ENTRY Include
  æ ; IN devName Æ, reaOnlyÅ å
  WITH RECORD
    t          : ^^;
  END;
BEGIN initFs ( devName ); END;
 
ENTRY Exclude
  æ ; IN deviceName Æ, abortAllowedÅ å
  WITH RECORD
    t      : ^^;
  END;
BEGIN ObjReturn (MakeRes (Reject*EntryIllegal, Universal, entryA, 0)); END;
 
æ****** OptiFs INIT ******å
æ*************************å
ENTRY OptiFsInit ( in term: ref ) with record t: ref end;
 
  var
    line: lineType;
    i: integer;
  begin
æ#b# printText ('----- OptiFs.INIT ----- '); #e#å
    Check( Copy ( term, termRef ) );
    ClearText ( line );
    PutCrLf(line);
    PutText ( line, 'OptiFs initialised  ');
    PutNL ( line );
    Check (termIo(termRef,WriteSeq,line));
  end;
 
æ*****   CLOSE   *****å
æ*********************å
 
PRIVATE Close
  æ fao, faoEnv å
  WITH RECORD
    t : ^^;
  END;
 
  var
    line: ThreeLineType;
    i: integer;
 
  BEGIN
æ#b#  printText ('-----Opti.Close-----');  #e#å
    with faoEnv^^.Data^^ do begin
      ClearText ( line );
      PutCrLf(line);
      putText ( line, 'OptiFs close file ' );
      putText ( line, name );
      align ( line );
      putNL ( line );
      with line = lineÆgetLength(line)+4..200Å do begin
        ClearText( line );
        PutText ( line, '  io count: ');
        PutInt  ( line, noHitCount + hitCount, 8 );
        PutText ( line, '   cache hit rate: ' );
        PutInt  ( line, hitCount*100 div (noHitCount+hitCount), 3 );
        PutText ( line, '%');
        PutNL ( line );
      end;
    end;
    Check(termIo(termRef,WriteSeq,line));
 
æ#b#  printText ('-- end Opti.Close --');  #e#å
  END;  æCloseå
 
 
 
 
OTHERWISE VersOther
  WITH RECORD t : ^^; END;
BEGIN
  Exception (MakeRes (Reject*EntryIllegal, Universal, entryA, 0));
END;  æotherwiseå
 
 
END;  æVersFilImplementå
 
 
 
 
INITIALIZE
  FilSysImplement 'optifs':
    allocRef 'allocate',
    objDirRef 'objdir'
 
END.
«eof»