home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / gnat-2.06-src.tgz / tar.out / fsf / gnat / ada / exp_pakd.ads < prev    next >
Text File  |  1996-09-28  |  8KB  |  169 lines

  1. ------------------------------------------------------------------------------
  2. --                                                                          --
  3. --                         GNAT COMPILER COMPONENTS                         --
  4. --                                                                          --
  5. --                             E X P _ P A K D                              --
  6. --                                                                          --
  7. --                                 S p e c                                  --
  8. --                                                                          --
  9. --                            $Revision: 1.5 $                              --
  10. --                                                                          --
  11. --        Copyright (c) 1992,1993,1994,1995 NYU, All Rights Reserved        --
  12. --                                                                          --
  13. -- GNAT is free software;  you can  redistribute it  and/or modify it under --
  14. -- terms of the  GNU General Public License as published  by the Free Soft- --
  15. -- ware  Foundation;  either version 2,  or (at your option) any later ver- --
  16. -- sion.  GNAT is distributed in the hope that it will be useful, but WITH- --
  17. -- OUT ANY WARRANTY;  without even the  implied warranty of MERCHANTABILITY --
  18. -- or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License --
  19. -- for  more details.  You should have  received  a copy of the GNU General --
  20. -- Public License  distributed with GNAT;  see file COPYING.  If not, write --
  21. -- to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. --
  22. --                                                                          --
  23. ------------------------------------------------------------------------------
  24.  
  25. --  Expand routines for manipulation of packed arrays
  26.  
  27. with Types; use Types;
  28.  
  29. package Exp_Pakd is
  30.  
  31.    -------------------------------------
  32.    -- Implementation of Packed Arrays --
  33.    -------------------------------------
  34.  
  35.    --  When a packed array (sub)type is frozen, we create a corresponding
  36.    --  type that will be used to hold the bits of the packed value, and
  37.    --  store the entity for this type in the Packed_Array_Type field of the
  38.    --  E_Array_Type or E_Array_Subtype entity for the packed array.
  39.  
  40.    --  This packed array type has the name xxxPn, where xxx is the name
  41.    --  of the packed type, and n is 1, 2, or 4 giving the number of bits
  42.    --  per component (note that we use 4 bits for a size of 3, as permitted
  43.    --  in the RM). The created declaration declares a type derived from one
  44.    --  of the types in package System.Unsigned_Types as follows:
  45.  
  46.    --    For an unconstrained array, we declare:
  47.  
  48.    --      type xxxPn is new Raw_Bits;
  49.  
  50.    --    For a constrained array with a static index type where the number
  51.    --    of bits does not exceed the size of Unsigned, we use:
  52.  
  53.    --       type xxxPn is new Unsigned range 0 .. 2 ** nbits - 1;
  54.  
  55.    --    For a constrained array with a static index type where the number
  56.    --    of bits is greater than the size of Unsigned, but does not exceed
  57.    --    the size of Long_Long_Unsigned, we use
  58.  
  59.    --       type xxxPn is new Long_Long_Unsigned range 0 .. 2 ** nbits - 1;
  60.  
  61.    --    For all other constrained arrays, we use
  62.  
  63.    --       type xxxPn is new Raw_Bits (0 .. m);
  64.  
  65.    --    where m is calculated (from the length of the original packed array)
  66.    --    to hold the required number of bits.
  67.  
  68.    --  When a variable of packed array type is allocated, gigi will allocate
  69.    --  the amount of space indicated by the corresponding packed array type.
  70.    --  However, we do NOT attempt to rewrite the types of any references or
  71.    --  to retype the variable itself, since this would cause all kinds of
  72.    --  semantic problems in the front end (remember that expansion proceeds
  73.    --  at the same time as analysis).
  74.  
  75.    --  For an indexed reference to a packed array, we simply convert the
  76.    --  reference to the appropriate equivalent reference to the object
  77.    --  of the packed array type (using unchecked conversion).
  78.  
  79.    --  In some cases (for internally generated types, and for the subtypes
  80.    --  for record fields that depend on a discriminant), the corresponding
  81.    --  packed type cannot be easily generated in advance. In these cases,
  82.    --  we generate the required subtype on the fly at the reference point.
  83.  
  84.    ---------------------------
  85.    -- Endian Considerations --
  86.    ---------------------------
  87.  
  88.    --  The standard does not specify the way in which bits are numbered in
  89.    --  a packed array. There are two reasonable rules for deciding this:
  90.  
  91.    --    Store the first bit at right end (low order) word. This means
  92.    --    that the scaled subscript can be used directly as a right shift
  93.    --    count (if we put bit 0 at the left end, then we need an extra
  94.    --    subtract to compute the shift count.
  95.  
  96.    --    Layout the bits so that if the packed boolean array is overlaid on
  97.    --    a record, using unchecked conversion, then bit 0 of the array is
  98.    --    the same as the bit numbered bit 0 in a record representation
  99.    --    clause applying to the record. For example:
  100.  
  101.    --       type Rec is record
  102.    --          C : Bits4;
  103.    --          D : Bits7;
  104.    --          E : Bits5;
  105.    --       end record;
  106.  
  107.    --       for Rec use record
  108.    --          C at 0 range  0  .. 3;
  109.    --          D at 0 range  4 .. 10;
  110.    --          E at 0 range 11 .. 15;
  111.    --       end record;
  112.  
  113.    --       type P16 is array (0 .. 15) of Boolean;
  114.    --       pragma Pack (P16);
  115.  
  116.    --    Now if we use unchecked conversion to convert a value of the record
  117.    --    type to the packed array type, according to this second criterion,
  118.    --    we would expect field D to occupy bits 4..10 of the Boolean array.
  119.  
  120.    --  Although not required, this correspondence seems a highly desirable
  121.    --  property, and is one that GNAT decides to guarantee. For a little
  122.    --  endian machine, we can also meet the first requirement, but for a
  123.    --  big endian machine, it will be necessary to store the first bit of
  124.    --  a Boolean array in the left end (most significant) bit of the word.
  125.    --  This may cost an extra instruction on some machines, but we consider
  126.    --  that a worthwhile price to pay for the consistency.
  127.  
  128.    -----------------
  129.    -- Subprograms --
  130.    -----------------
  131.  
  132.    procedure Expand_Packed_Array_Type
  133.      (Typ  : Entity_Id;
  134.       PAT  : out Entity_Id;
  135.       Decl : out Node_Id);
  136.    --  Typ is a array type or subtype to which pragma Pack applies. This
  137.    --  procedure creates a declaration for the corresponding representation
  138.    --  type or subtype and returns the entity for the type that is declared
  139.    --  in PAT, and the corresponding declaration in Decl. The caller is
  140.    --  responsible for installing this declaration in the tree, analyzing
  141.    --  it, and making sure that the type gets frozen.
  142.  
  143.    procedure Expand_Packed_Boolean_Operator (N : Node_Id);
  144.    --  N is an N_Op_And, N_Op_Or or N_Op_Xor node whose operand type is a
  145.    --  packed boolean array. This routine expands the appropriate operations
  146.    --  to carry out the logical operation on the packed arrays. It handles
  147.    --  both the modular and array representation cases.
  148.  
  149.    procedure Expand_Packed_Element_Get (N : Node_Id);
  150.    --  N is an N_Indexed_Component node that appears as an expression
  151.    --  whose value is needed (i.e. it is not the left hand side of an
  152.    --  assignment). This procedure rewrites the node, replacing it with
  153.    --  an appropriate reference to the corresponding packed array type.
  154.  
  155.    procedure Expand_Packed_Element_Set (N : Node_Id);
  156.    --  N is an N_Assignment_Statement node whose name is an indexed
  157.    --  component of a packed array. This procedure rewrites the entire
  158.    --  assignment statement with appropriate code to set the referenced
  159.    --  bits of the packed array type object.
  160.  
  161.    procedure Expand_Packed_Not (N : Node_Id);
  162.    --  N is an N_Op_Not node where the operand is packed array of Boolean
  163.    --  in standard representation (i.e. component size is one bit). This
  164.    --  procedure expands the corresponding not operation. Note that the
  165.    --  non-standard representation case is handled by using a loop through
  166.    --  elements generated by the normal non-packed circuitry.
  167.  
  168. end Exp_Pakd;
  169.