-- Auxiliary Hardware Functions
-- MESA Implementation Module

-- Anthony West, September 29, 1981  5:19 PM

-- This interface allows MESA programmers to access:

-- a) DES encryption and decryption hardware.
-- b) Random Number hardware.
-- c) Electronic Stable Storage hardware.
-- d) External Parallel I/O interface.

DIRECTORY
   AuxDefs,
   AltoDefs   USING[ BYTE ],
   InlineDefs USING[ LowHalf, BITSHIFT, BITXOR, BITAND ],
   IODefs     USING[ WriteString, WriteLine ],
   RandomCard USING[ Random ],
   TimeDefs   USING[ ReadClock ];

AuxImpl: PROGRAM
IMPORTS 
   InlineDefs,
   IODefs,
   RandomCard,
   TimeDefs
EXPORTS AuxDefs =
{
   ECBEncrypt: PUBLIC PROC [ encryptionKey:   AuxDefs.DESKEY,
                             numberOfBlocks:  CARDINAL,
                             from:            LONG POINTER,
                             to:              LONG POINTER ] =
   {
      NotImplementedYet["ECBEncrypt"];
   };

   ECBDecrypt: PUBLIC PROC [ decryptionKey:   AuxDefs.DESKEY,
                             numberOfBlocks:  CARDINAL,
                             from:            LONG POINTER,
                             to:              LONG POINTER ] =
   {
      NotImplementedYet["ECBDecrypt"];
   };

   CBCEncrypt: PUBLIC PROC [ encryptionKey:   AuxDefs.DESKEY,
                             initVector:      AuxDefs.DESVECTOR,
                             numberOfBlocks:  CARDINAL,
                             from:            LONG POINTER,
                             to:              LONG POINTER ] =
   {
      NotImplementedYet["CBCEncrypt"];
   };

   CBCDecrypt: PUBLIC PROC [ decryptionKey:   AuxDefs.DESKEY,
                             initVector:      AuxDefs.DESVECTOR,
                             numberOfBlocks:  CARDINAL,
                             from:            LONG POINTER,
                             to:              LONG POINTER ] =
   {
      NotImplementedYet["CBCDecrypt"];
   };

   GetRandomDESKey: PUBLIC PROC RETURNS [ key: AuxDefs.BLOCK ] =
   {
      i:      CARDINAL;
      j:      CARDINAL;
      b:      AuxDefs.BIT;
      parity: AuxDefs.BIT;

      FOR i IN [0..7]
      DO
         parity _ 0;

         FOR j IN [0..6]
         DO
            b      _ GetUnbiassedBit[];
            key[i] _ InlineDefs.BITSHIFT[key[i],1] + b;
            parity _ InlineDefs.BITXOR[parity, b];
         ENDLOOP;

         key[i] _ InlineDefs.BITSHIFT[key[i],1] + parity;
      ENDLOOP;
   };



   ----------------------------------------------------------------
   -- Random Numbers
   ----------------------------------------------------------------

   GetBiassedBit:   PUBLIC PROC RETURNS [ AuxDefs.BIT ] =
   {
      RETURN[ InlineDefs.BITAND[RandomCard.Random[],1] ];
   };

   GetUnbiassedBit: PUBLIC PROC RETURNS [ AuxDefs.BIT ] =
   {
      bitPair: CARDINAL;

      DO
         OPEN InlineDefs;

         bitPair _ BITSHIFT[GetBiassedBit[],1] + GetBiassedBit[];
         SELECT bitPair FROM
            0 => LOOP;
            1 => RETURN[0];
            2 => RETURN[1];
            3 => LOOP;
         ENDCASE;
      ENDLOOP;
   };

   GetRandom8: PUBLIC PROC RETURNS [ n: UNSPECIFIED ] =
   {
      i: CARDINAL _ 0;

      n _ 0;

      FOR i IN [0..7]
      DO
         n _ InlineDefs.BITSHIFT[n, 1] + GetUnbiassedBit[];
      ENDLOOP;
   };

   GetRandom16: PUBLIC PROC RETURNS [ n: UNSPECIFIED ] =
   {
      i: CARDINAL _ 0;

      n _ 0;

      FOR i IN [0..15]
      DO
         n _ InlineDefs.BITSHIFT[n, 1] + GetUnbiassedBit[];
      ENDLOOP;
   };

   GetRandom32: PUBLIC PROC RETURNS [ LONG UNSPECIFIED ] =
   {
      i:    CARDINAL _ 0;
      word: PACKED ARRAY[0..1] OF UNSPECIFIED;

      word[0] _ GetRandom16[];
      word[1] _ GetRandom16[];

      RETURN[ LOOPHOLE[word] ];
   };

   GetRandom64: PUBLIC PROC RETURNS [ AuxDefs.BLOCK ] =
   {
      i: CARDINAL _ 0;
      word: PACKED ARRAY[0..3] OF UNSPECIFIED;

      word[0] _ GetRandom16[];
      word[1] _ GetRandom16[];
      word[2] _ GetRandom16[];
      word[3] _ GetRandom16[];

      RETURN[ LOOPHOLE[word] ];
   };

   ----------------------------------------------------------------
   -- Electronic Stable Storage
   ----------------------------------------------------------------

   SSRead:  PUBLIC PROC [ address: CARDINAL ]
            RETURNS [ UNSPECIFIED ] =
   {
      NotImplementedYet["SSRead"];
      RETURN[0];
   };

   SSWrite: PUBLIC PROC [ address: CARDINAL,
                   data:    UNSPECIFIED ] =
   {
      NotImplementedYet["SSWrite"];
   };

   GetSSSize: PUBLIC PROC RETURNS [ CARDINAL ] = -- KWords
   {
      NotImplementedYet["GetSSSize"];
      RETURN[16];
   };

   ----------------------------------------------------------------
   -- External Parallel I/O
   ----------------------------------------------------------------

   ExtRead:  PUBLIC PROC [ Address: CARDINAL ]
             RETURNS [ UNSPECIFIED ] =
   {
      NotImplementedYet["ExtRead"];
      RETURN[0];
   };

   ExtWrite: PUBLIC PROC [ Address: CARDINAL,
                    data:    UNSPECIFIED ] =
   {
      NotImplementedYet["ExtWrite"];
   };

   ExtWait: PUBLIC PROC [ AuxDefs.CHANNEL ] =
   {
      NotImplementedYet["ExtWait"];
   }; 

   ExtPost: PUBLIC PROC [ AuxDefs.CHANNEL ] =
   {
      NotImplementedYet["ExtPost"];
   };  

   NotImplementedYet: PROC [ s: STRING ] =
   {
      IODefs.WriteString["Sorry, "];
      IODefs.WriteString[s];
      IODefs.WriteLine[" in module AuxImpl is not implemented yet!"];
   }; 

}.
(635)\f8