Dynamic discrimants in variant records?

[Vinzent Hoefler <ada.rocks@jlfencey.com>]

Hi,

I got the following question for a type with discrimants. Following an
excerpt from the current source (more a case study than anything
useful yet) with a representation of a memory mapped hardware
register:

|   --  type for a programmable address region register
|   type Programmable_Address_Region (
|       Target : Window_Target := Window_Disabled;
|       Pg_Sz  : Page_Size     := Four_Ki_Byte) is
|   record
|      case Target is
|         when Window_Disabled =>
|            null;
|         when GP_Bus_IO | PCI_Bus =>
|            IO_Attr       : Chip_Select_Signal;
|            Sz_St_Addr_IO : IO_Page;
|         when GP_Bus_Memory | Boot_CS | Rom_CS_1 | Rom_CS_2 | SD_Ram =>
|            Mem_Attr : Memory_Attribute;
|
|            case Pg_Sz is
|               when Four_Ki_Byte =>
|                  Sz_St_Addr_4K  : Mem_Page_4K;
|               when Sixty_Four_Ki_Byte =>
|                  Sz_St_Addr_64K : Mem_Page_64K;
|            end case;
|      end case;
|   end record;

Well, so far so good, I can perfectly define a corresponding type
statically. Deciding which of the registers to use for what region of
memory statically is probably quite ok for most real world cases, but
I really would like to have a little bit more flexibility.

As mentioned, the actual (global) variables of this type are memory
mapped registers, so the problem occurs when I want to change a region
register dynamically (from a 4K granularity to a 64K for instance). In
Ada this would be equivalent to just change some of the discrimants
(those are really some bits in the register) and so changing the
interpretation of the record.

AFAICS this is not allowed in Ada, once a variable of a specific type
is declared I cannot change its discriminants anymore. Is there any
nice Ada-ish way around this?

Or IOW, how would someone do that what I want in the most efficient
way? Declaring an appropriate type each time and use an unchecked
conversion to apply it to the "real" memory mapped register?


Vinzent.

-- 
There are two ways of constructing a software design. One way is to make
it so simple that there are obviously no deficiencies. And the other is
to make it so complicated that there are no obvious deficiencies.
  -- T. Hoare