Re: Creating several types from a base type and conversion

[Shark8 <onewingedshark@gmail.com>]

On Saturday, January 18, 2020 at 5:49:17 AM UTC-7, Ken Roberts wrote:
> 
> The concept is emulating a 30-bit computer from olden days.
Then allow me to suggest you do that, instead:

   Type Word is range 0..2**30-1
    with Size => 30;

this allows you to also do something like this:
  Function Convert( Data : Integer ) return Word
    with Inline, Pre => Data in Integer(Word'First)..Integer(Word'Last);
  Function Convert( Data : Word ) return Integer
    with Inline;
  -- ...
  Function Convert( Data : Integer ) return Word is  ( Word(Data)    );
  Function Convert( Data : Word ) return Integer is  ( Integer(Data) );

> 
> It was my understanding that a boolean array would be better than an
> integer in order to do some of the bit manipulations that the old
> computer was designed for.
That might be true; though If you're going that route you may want to number the array indices 1..30.

> 
> One example:
> 
> ADD LP : L[Y*(Q)]+(A) -> A
> 
> Take the logical product of Y and Q register, then add A register,
> place results in A register.
> 
> (LP being boolean AND of 2 registers)
> 
> I think I tried doing tagged records and subtypes, but kept getting
> errors like 'Bits already mapped' when trying to extend the BaseWord
> (30 bit) into a data word ( 2 separate 15-bit fields) and instruction
> word (5 separate bit-mapped fields) while still being able to easily
> convert between BaseWord and others (think pulling next instruction from memory array, then pulling data from arbitrary location in memory array).
Hm, you *could* make the programs a stream and use the stream read/write attributes. -- Though this *might* be a bit of a bear to debug, it does have the advantage that you could "dump the bits to the stream" and let the Read attribute/function take care of interpreting the data.

> 
> Functionally, it would be relatively easy to just ignore the hardware
> aspect of the emulation, but I'm trying to set it up so I can emulate
> the hardware later as a learning tool to how this old computer
> actually did things (like 1's complement subtractive addition). The
> real fun will be programming the timing (1MHz clock split into 4
> phases, with interesting interrupt handling).
Hm, this is interesting... it sounds like it would make a really good Ada/VHDL combined-language project. (But I have no idea how hard that would be compared to just simulating things pure-Ada.)

> 
> I know - _very_ ambitious project for a beginner in the language (not
> to programming), but I figure might as well have an interesting
> project to work on while learning rather than the basic "Hello World"
> style that seems to be prevalent.
Yes. I would tend to agree.
Allow me to suggest that you could leverage the power of enumerations for the instruction-set.

Then you could build your instruction-stream off that; eg:
  -- Ultra-simplified:
  Type OP_CODE is (ADD, DIV, EXMPL); -- SUB, MUL, WTVR.
  
  Type Register_Code is (R1, R2, AD, SB)
   with Size => 4; -- Four bit register-code; single-trace active.
  For  Register_Code use (
   R1 => 2#0001#,
   R2 => 2#0010#,
   AD => 2#0100#,
   SB => 2#1000#
  );
  
  Type Instruction( Op : Opcode ) is record
   case Op is
    When ADD   => Val_1, Val_2 : Word; -- two Word-size operands.
    When DIV   => Val_1, Val_2 : Word;
    When EXMPL => Register  : Register_Code;
    -- other operations
   end case;
  end record
  with Static_Predicate => -- NOTE: YOU CAN ENFORCE INSTRUCTION VALIDITY.
   (Case Instruction.Op is
     When Add => True, -- All values are good.
     When Div => Instruction.Val_2 /= 0 or else raise Program_Error with "Invalid bitstream",
     When EXMPL => Instruction.Register /= AD
   );

The above is a simplified version of something I played around with a few years ago: https://github.com/OneWingedShark/Lamman/blob/master/src/ghost_cpu.ads

IOW, don't be afraid to logically model things a bit more than the bit-twiddling would suggest. Also Bill Findlay's KDF9 emulator is probably a really good resource in using Ada to emulate old hardware. (I think there was an Ada implementation of the WWII Enigma machine or something similar someone built, but I can't remember *who*.)