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 / freeze.ads < prev    next >
Text File  |  1996-09-28  |  9KB  |  166 lines
  1. ------------------------------------------------------------------------------
  2. --                                                                          --
  3. --                         GNAT COMPILER COMPONENTS                         --
  4. --                                                                          --
  5. --                               F R E E Z E                                --
  6. --                                                                          --
  7. --                                 S p e c                                  --
  8. --                                                                          --
  9. --                            $Revision: 1.7 $                              --
  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. with Types; use Types;
  26.  
  27. package Freeze is
  28.  
  29.    --------------------------
  30.    -- Handling of Freezing --
  31.    --------------------------
  32.  
  33.    --  In the formal Ada semantics, freezing of entities occurs at a well
  34.    --  defined point, described in (RM 13.14). The model in GNAT of freezing
  35.    --  is that a Freeze_Entity node is generated at the point where an entity
  36.    --  is frozen, and the entity contains a pointer (Freeze_Node) to this
  37.    --  generated freeze node.
  38.  
  39.    --  The freeze node is processed in the expander to generate associated
  40.    --  data and subprograms (e.g. an initialization procedure) which must
  41.    --  be delayed until the type is frozen and its representation can be
  42.    --  fully determined. Subsequently the freeze node is used by Gigi to
  43.    --  determine the point at which it should elaborate the corresponding
  44.    --  entity (this elaboration also requires the representation of the
  45.    --  entity to be fully determinable). The freeze node is also used to
  46.    --  provide additional diagnostic information (pinpointing the freeze
  47.    --  point), when order of freezing errors are detected.
  48.  
  49.    --  If we were fully faithful to the Ada model, we would generate freeze
  50.    --  nodes for all entities, but that is a bit heavy so we optimize (that
  51.    --  is the nice word) or cut corners (which is a bit more honest). For
  52.    --  many entities, we do not need to delay the freeze and instead can
  53.    --  freeze them at the point of declaration. The conditions for this
  54.    --  early freezing being permissible are as follows:
  55.  
  56.    --    There is no associated expander activity that needs to be delayed
  57.  
  58.    --    Gigi can fully elaborate the entity at the point of occurrence (or,
  59.    --    equivalently, no real elaboration is required for the entity).
  60.  
  61.    --  In order for these conditions to be met (especially the second), it
  62.    --  must be the case that all representation characteristics of the entity
  63.    --  can be determined at declaration time.
  64.  
  65.    --  The following indicates how freezing is handled for all entity kinds:
  66.  
  67.    --    Types
  68.  
  69.    --      All declared types have freeze nodes, as well as anonymous base
  70.    --      types created for type declarations where the defining identifier
  71.    --      is a first subtype of the anonymous type.
  72.  
  73.    --    Subtypes
  74.  
  75.    --      All first subtypes have freeze nodes. Other subtypes need freeze
  76.    --      nodes if the corresponding base type has not yet been frozen. If
  77.    --      the base type has been frozen, then there is no need for a freeze
  78.    --      node, since no rep clauses can appear for the subtype in any case.
  79.  
  80.    --    Implicit types and subtypes
  81.  
  82.    --      As noted above, implicit base types always have freeze nodes. Other
  83.    --      implicit types and subtypes typically do not require freeze nodes,
  84.    --      because there is no possibility of delaying any information about
  85.    --      their representation.
  86.  
  87.    --    Subprograms
  88.    --
  89.    --      Are frozen at the point of declaration unless one or more of the
  90.    --      formal types or return type themselves have delayed freezing and
  91.    --      are not yet frozen. This includes the case of a formal access type
  92.    --      where the designated type is not frozen. Note that we are talking
  93.    --      about subprogram specs here (subprogram body entities have no
  94.    --      relevance), and in any case, subprogram bodies freeze everything.
  95.  
  96.    --    Objects with dynamic address clauses
  97.    --
  98.    --      These have a delayed freeze. Gigi will generate code to evaluate
  99.    --      the initialization expression if present and store it in a temp.
  100.    --      The actual object is created at the point of the freeze, and if
  101.    --      neccessary initialized by copying the value of this temporary.
  102.  
  103.    --    Formal Parameters
  104.    --
  105.    --      Are frozen when the associated subprogram is frozen, so there is
  106.    --      never any need for them to have delayed freezing.
  107.  
  108.    --    Other Objects
  109.    --
  110.    --      Are always frozen at the point of declaration
  111.  
  112.    --    All Other Entities
  113.  
  114.    --      Are always frozen at the point of declaration
  115.  
  116.    --  The flag Has_Delayed_Freeze is used for to indicate that delayed
  117.    --  freezing is required. Usually the associated freeze node is allocated
  118.    --  at the freezing point. One special exception occurs with anonymous
  119.    --  base types, where the freeze node is preallocated at the point of
  120.    --  declaration, so that the First_Subtype_Link field can be set.
  121.  
  122.    -----------------
  123.    -- Subprograms --
  124.    -----------------
  125.  
  126.    procedure Check_Compile_Time_Size (T : Entity_Id);
  127.    --  Check whether the size of a type is known to the back-end, and set
  128.    --  the entity flag accordingly. Note that the size can be known even if
  129.    --  the context is not static in the Ada sense. The flag serves to determine
  130.    --  whether the secondary stack must be used to return a value of the type.
  131.  
  132.    function Freeze_Entity (E : Entity_Id; Loc : Source_Ptr) return List_Id;
  133.    --  Freeze an entity, and return Freeze nodes, to be inserted at the
  134.    --  point of call. Loc is a source location which corresponds to the
  135.    --  freeze point. This is used in placing warning messages in the
  136.    --  situation where it appears that a type has been frozen too early,
  137.    --  e.g. when a primitive operation is declared after the freezing
  138.    --  point of its tagged type.
  139.  
  140.    procedure Freeze_All (From : Entity_Id; After : in out Node_Id);
  141.    --  Before a non-instance body, or at the end of a declarative part
  142.    --  freeze all entities therein that are not yet frozen. Calls itself
  143.    --  recursively to catch types in inner packages that were not frozen
  144.    --  at the inner level because they were not yet completely defined.
  145.    --  This routine also analyzes and freezes default parameter expressions
  146.    --  in subprogram specifications (this has to be delayed until all the
  147.    --  types are frozen). The resulting freeze nodes are inserted just
  148.    --  after node After (which is a list node) and analyzed. On return,
  149.    --  'After' is updated to point to the last node inserted (or is returned
  150.    --  unchanged if no nodes were inserted). 'From' is the last entity frozen
  151.    --  in the scope. It is used to prevent a quadratic traversal over already
  152.    --  frozen entities.
  153.  
  154.    procedure Freeze_Before (N : Node_Id; T : Entity_Id);
  155.    --  Freeze T then Insert the generated Freeze nodes before the node N.
  156.  
  157.    procedure Freeze_Expression (N : Node_Id);
  158.    --  Freezes the required entities when the Expression N causes freezing.
  159.    --  The node N here is either a subexpression node (a "real" expression)
  160.    --  or a subtype mark, or a subtype indication. The latter two cases are
  161.    --  not really expressions, but they can appear within expressions and
  162.    --  so need to be similarly treated. Freeze_Expression takes care of
  163.    --  determining the proper insertion point for generated freeze actions.
  164.  
  165. end Freeze;
  166.