Re: C/C++ programmer giving Ada95 a chance -- writing an emulator.

[Jim Rogers <jrogers@omnitech.com>]

In article <38E05E84.BB5507FC@gmx.net>,
> jross wrote:
>
> My first question is how do you define and write a dispatching
> mechanism as you would in C++ using function pointers in a table for
> execution speed efficiency, like this:
>
> ---------------------------------
> -- the .h file
> ---------------------------------
>
> class TACpu : public TCpu
> {
> ? define registers and much stuff (not shown)
>
> struct OpStruct // define the op code jump table structure
> {
> char Byte; // the opcode byte for reference only
> void (TACpu::*Func)(); // executes opcode
> };
>
> static OpStruct OpTable[]; // the table in the .cpp file
>
> void Op_U(); // undefined
> void Op_00(); // functions that execute the opcodes
> void Op_01();
> void Op_02();
> void Op_03();
> // ? thru Op_FF
> };
>
> ---------------------------------
> -- in the .cpp file
> ---------------------------------
>
> TACpu::OpStruct TACpu::OpTable[] = { // opcode table
> { 0x00, Op_00 },
> { 0x01, Op_01 },
> { 0x02, Op_U },
> { 0x03, Op_03 },
> // ? thru Op_FF
> };
>
> ... the Op_xx functions would go here
>
> now the code for calling the opcodes
>
> IR = Core[PA++]; // get the opcode, advance the program address
> (this->*OpTable[IR].Func)(); // execute it
>
> ----------------
>
> This is very efficient C++ code (could have been just as easy in plain
> old C without the class encapsulation?) How would you do this in Ada
> without using a Case Statement?
>
There are some differences in the Ada approach and the C++ approach.
What you are asking is if Ada can be C++. The answer is that Ada is
only moderately good at being C++.

Some differences:
  Ada does not have an equivalent of a ++ operator.

 All your C++ functions would be implemented as Ada procedures.

 You can build a similar table of access to procedures in Ada. This
 would not be what Ada describes as a dispatching operation. Ada uses
 the term dispatching to refer to what in C++ would be calling a
 virtual function through the vtbl.

The Ada specification for the procedures and access types would look
something like:

   type Proc_Ptr is access procedure;

   type OpCode is range 16#00#..16#FF#;

   type Opcode_Table is array(OpCode) of Proc_Ptr;

   procedure Op_00;

   procedure Op_01;

   procedure Op_02;
   ...

   OpTable : Opcode_Table := (
     16#00# => Op_00'Access,
     16#02# => Op_01'Access,
     16#03# => Op_02'Access,
     ... );

  IR : OpCode;
  function Core(Item : in System.Address) return OpCode;

Now get the opcode, advance the program address, execute the opcode

  IR := Core(PA);
  PA := PA + 1;

  OpTable(IR).all;

--
Jim Rogers
Colorado Springs, Colorado USA


Sent via Deja.com http://www.deja.com/
Before you buy.