Try this tricky bit of stuff on your favorite compiler

Try this tricky bit of stuff on your favorite compiler

[Michael Feldman]

with UNCHECKED_CONVERSION;                                                     
 
with TEXT_IO;
procedure REPDEMO is                                                           
 

  type INT_32 is range -2**31..2**31-1;
  package MY_INT_IO is new TEXT_IO.INTEGER_IO(INT_32);

  type DIRECTION is (UP, DOWN, LEFT, RIGHT);                                   
 
  type D_ARRAY is ARRAY(1..4) of DIRECTION;                                    
 
  type PD_ARRAY is new D_ARRAY; pragma PACK(PD_ARRAY);                         
 
                                                                               
 
  function D_TO_INT is NEW UNCHECKED_CONVERSION                                
 
    (SOURCE => D_ARRAY,  TARGET => INT_32);
  function PD_TO_INT is NEW UNCHECKED_CONVERSION                               
 
    (SOURCE => PD_ARRAY, TARGET => INT_32);
                                                                               
 
  type NEWDIRECTION is new DIRECTION;                                          
 
  for NEWDIRECTION use (1,2,4,8);                                              
 
  type N_ARRAY is ARRAY(1..4) of NEWDIRECTION;                                 
 
  type PN_ARRAY is new N_ARRAY; pragma PACK(PN_ARRAY);                         
 
                                                                               
 
  function N_TO_INT is new UNCHECKED_CONVERSION                                
 
    (SOURCE => N_ARRAY,  TARGET => INT_32);
  function PN_TO_INT is new UNCHECKED_CONVERSION                               
 
    (SOURCE => PN_ARRAY, TARGET => INT_32);
                                                                               
 
  DIR: DIRECTION := UP;                                                        
 
  NEWDIR: DIRECTION := UP;                                                     
 
                                                                               
 
  D: D_ARRAY := (UP, DOWN, LEFT, RIGHT);                                       
 
  N: N_ARRAY;                                                                  
 
  PD: PD_ARRAY;                                                                
 
  PN: PN_ARRAY;                                                                
 
                                                                               
 
begin                                                                          
 
                                                                               
 
  N := (NEWDIRECTION(D(1)), NEWDIRECTION(D(2)),                                
 
        NEWDIRECTION(D(3)), NEWDIRECTION(D(4)));                               
 
  PD := PD_ARRAY(D);                                                           
 
  PN := PN_ARRAY(N);                                                           
 
                                                                               
 
  MY_INT_IO.PUT(D'SIZE); TEXT_IO.NEW_LINE;                                     
 
  MY_INT_IO.PUT(PD'SIZE); TEXT_IO.NEW_LINE;                                    
 
  MY_INT_IO.PUT(N'SIZE); TEXT_IO.NEW_LINE;                                     
 
  MY_INT_IO.PUT(PN'SIZE); TEXT_IO.NEW_LINE;                                    
 
  MY_INT_IO.PUT(DIR'SIZE); TEXT_IO.NEW_LINE;                                   
 
  MY_INT_IO.PUT(NEWDIR'SIZE); TEXT_IO.NEW_LINE;                                
 
                                                                               
 
  MY_INT_IO.PUT(ITEM => D_TO_INT(D),BASE=>16);                                 
 
  TEXT_IO.NEW_LINE;                                                            
 
  MY_INT_IO.PUT(ITEM => PD_TO_INT(PD),BASE=>16);                               
 
  TEXT_IO.NEW_LINE;                                                            
 
  MY_INT_IO.PUT(ITEM => N_TO_INT(N),BASE=>16);                                 
 
  TEXT_IO.NEW_LINE;                                                            
 
  MY_INT_IO.PUT(ITEM => PN_TO_INT(PN),BASE=>16);                               
 
  TEXT_IO.NEW_LINE;                                                            
 
                                                                               
 
end REPDEMO;