Subversion Repositories openrisc_2011-10-31

------------------------------------------------------------------------------

--                                                                          --

--                         GNAT COMPILER COMPONENTS                         --

--                                                                          --

--                                A T R E E                                 --

--                                                                          --

--                                 B o d y                                  --

--                                                                          --

--          Copyright (C) 1992-2009, Free Software Foundation, Inc.         --

--                                                                          --

-- GNAT is free software;  you can  redistribute it  and/or modify it under --

-- terms of the  GNU General Public License as published  by the Free Soft- --

-- ware  Foundation;  either version 3,  or (at your option) any later ver- --

-- sion.  GNAT is distributed in the hope that it will be useful, but WITH- --

-- OUT ANY WARRANTY;  without even the  implied warranty of MERCHANTABILITY --

-- or FITNESS FOR A PARTICULAR PURPOSE.                                     --

--                                                                          --

-- As a special exception under Section 7 of GPL version 3, you are granted --

-- additional permissions described in the GCC Runtime Library Exception,   --

-- version 3.1, as published by the Free Software Foundation.               --

--                                                                          --

-- You should have received a copy of the GNU General Public License and    --

-- a copy of the GCC Runtime Library Exception along with this program;     --

-- see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see    --

-- <http://www.gnu.org/licenses/>.                                          --

--                                                                          --

-- GNAT was originally developed  by the GNAT team at  New York University. --

-- Extensive contributions were provided by Ada Core Technologies Inc.      --

--                                                                          --

------------------------------------------------------------------------------

pragma Style_Checks (All_Checks);

--  Turn off subprogram ordering check for this package

--  WARNING: There is a C version of this package. Any changes to this source

--  file must be properly reflected in the file atree.h which is a C header

--  file containing equivalent definitions for use by gigi.

with Debug;   use Debug;

with Nlists;  use Nlists;

with Output;  use Output;

with Sinput;  use Sinput;

with Tree_IO; use Tree_IO;

package body Atree is

   ---------------

   -- Debugging --

   ---------------

   --  Suppose you find that node 12345 is messed up. You might want to find

   --  the code that created that node. There are two ways to do this:

   --  One way is to set a conditional breakpoint on New_Node_Debugging_Output

   --  (nickname "nnd"):

   --     break nnd if n = 12345

   --  and run gnat1 again from the beginning.

   --  The other way is to set a breakpoint near the beginning (e.g. on

   --  gnat1drv), and run. Then set Watch_Node (nickname "ww") to 12345 in gdb:

   --     ww := 12345

   --  and set a breakpoint on New_Node_Breakpoint (nickname "nn"). Continue.

   --  Either way, gnat1 will stop when node 12345 is created

   --  The second method is faster

   ww : Node_Id'Base := Node_Id'First - 1;

   pragma Export (Ada, ww); --  trick the optimizer

   Watch_Node : Node_Id'Base renames ww;

   --  Node to "watch"; that is, whenever a node is created, we check if it is

   --  equal to Watch_Node, and if so, call New_Node_Breakpoint. You have

   --  presumably set a breakpoint on New_Node_Breakpoint. Note that the

   --  initial value of Node_Id'First - 1 ensures that by default, no node

   --  will be equal to Watch_Node.

   procedure nn;

   pragma Export (Ada, nn);

   procedure New_Node_Breakpoint renames nn;

   --  This doesn't do anything interesting; it's just for setting breakpoint

   --  on as explained above.

   procedure nnd (N : Node_Id);

   pragma Export (Ada, nnd);

   procedure New_Node_Debugging_Output (N : Node_Id) renames nnd;

   --  For debugging. If debugging is turned on, New_Node and New_Entity call

   --  this. If debug flag N is turned on, this prints out the new node.

   --

   --  If Node = Watch_Node, this prints out the new node and calls

   --  New_Node_Breakpoint. Otherwise, does nothing.

   -----------------------------

   -- Local Objects and Types --

   -----------------------------

   Node_Count : Nat;

   --  Count allocated nodes for Num_Nodes function

   use Unchecked_Access;

   --  We are allowed to see these from within our own body!

   use Atree_Private_Part;

   --  We are also allowed to see our private data structures!

   --  Functions used to store Entity_Kind value in Nkind field

   --  The following declarations are used to store flags 65-72 in the

   --  Nkind field of the third component of an extended (entity) node.

   type Flag_Byte is record

      Flag65 : Boolean;

      Flag66 : Boolean;

      Flag67 : Boolean;

      Flag68 : Boolean;

      Flag69 : Boolean;

      Flag70 : Boolean;

      Flag71 : Boolean;

      Flag72 : Boolean;

   end record;

   pragma Pack (Flag_Byte);

   for Flag_Byte'Size use 8;

   type Flag_Byte_Ptr is access all Flag_Byte;

   type Node_Kind_Ptr is access all Node_Kind;

   function To_Flag_Byte is new

     Unchecked_Conversion (Node_Kind, Flag_Byte);

   function To_Flag_Byte_Ptr is new

     Unchecked_Conversion (Node_Kind_Ptr, Flag_Byte_Ptr);

   --  The following declarations are used to store flags 73-96 and the

   --  Convention field in the Field12 field of the third component of an

   --  extended (Entity) node.

   type Flag_Word is record

      Flag73 : Boolean;

      Flag74 : Boolean;

      Flag75 : Boolean;

      Flag76 : Boolean;

      Flag77 : Boolean;

      Flag78 : Boolean;

      Flag79 : Boolean;

      Flag80 : Boolean;

      Flag81 : Boolean;

      Flag82 : Boolean;

      Flag83 : Boolean;

      Flag84 : Boolean;

      Flag85 : Boolean;

      Flag86 : Boolean;

      Flag87 : Boolean;

      Flag88 : Boolean;

      Flag89 : Boolean;

      Flag90 : Boolean;

      Flag91 : Boolean;

      Flag92 : Boolean;

      Flag93 : Boolean;

      Flag94 : Boolean;

      Flag95 : Boolean;

      Flag96 : Boolean;

      Convention : Convention_Id;

   end record;

   pragma Pack (Flag_Word);

   for Flag_Word'Size use 32;

   for Flag_Word'Alignment use 4;

   type Flag_Word_Ptr is access all Flag_Word;

   type Union_Id_Ptr  is access all Union_Id;

   function To_Flag_Word is new

     Unchecked_Conversion (Union_Id, Flag_Word);

   function To_Flag_Word_Ptr is new

     Unchecked_Conversion (Union_Id_Ptr, Flag_Word_Ptr);

   --  The following declarations are used to store flags 97-128 in the

   --  Field12 field of the fourth component of an extended (entity) node.

   type Flag_Word2 is record

      Flag97  : Boolean;

      Flag98  : Boolean;

      Flag99  : Boolean;

      Flag100 : Boolean;

      Flag101 : Boolean;

      Flag102 : Boolean;

      Flag103 : Boolean;

      Flag104 : Boolean;

      Flag105 : Boolean;

      Flag106 : Boolean;

      Flag107 : Boolean;

      Flag108 : Boolean;

      Flag109 : Boolean;

      Flag110 : Boolean;

      Flag111 : Boolean;

      Flag112 : Boolean;

      Flag113 : Boolean;

      Flag114 : Boolean;

      Flag115 : Boolean;

      Flag116 : Boolean;

      Flag117 : Boolean;

      Flag118 : Boolean;

      Flag119 : Boolean;

      Flag120 : Boolean;

      Flag121 : Boolean;

      Flag122 : Boolean;

      Flag123 : Boolean;

      Flag124 : Boolean;

      Flag125 : Boolean;

      Flag126 : Boolean;

      Flag127 : Boolean;

      Flag128 : Boolean;

   end record;

   pragma Pack (Flag_Word2);

   for Flag_Word2'Size use 32;

   for Flag_Word2'Alignment use 4;

   type Flag_Word2_Ptr is access all Flag_Word2;

   function To_Flag_Word2 is new

     Unchecked_Conversion (Union_Id, Flag_Word2);

   function To_Flag_Word2_Ptr is new

     Unchecked_Conversion (Union_Id_Ptr, Flag_Word2_Ptr);

   --  The following declarations are used to store flags 152-183 in the

   --  Field11 field of the fourth component of an extended (entity) node.

   type Flag_Word3 is record

      Flag152 : Boolean;

      Flag153 : Boolean;

      Flag154 : Boolean;

      Flag155 : Boolean;

      Flag156 : Boolean;

      Flag157 : Boolean;

      Flag158 : Boolean;

      Flag159 : Boolean;

      Flag160 : Boolean;

      Flag161 : Boolean;

      Flag162 : Boolean;

      Flag163 : Boolean;

      Flag164 : Boolean;

      Flag165 : Boolean;

      Flag166 : Boolean;

      Flag167 : Boolean;

      Flag168 : Boolean;

      Flag169 : Boolean;

      Flag170 : Boolean;

      Flag171 : Boolean;

      Flag172 : Boolean;

      Flag173 : Boolean;

      Flag174 : Boolean;

      Flag175 : Boolean;

      Flag176 : Boolean;

      Flag177 : Boolean;

      Flag178 : Boolean;

      Flag179 : Boolean;

      Flag180 : Boolean;

      Flag181 : Boolean;

      Flag182 : Boolean;

      Flag183 : Boolean;

   end record;

   pragma Pack (Flag_Word3);

   for Flag_Word3'Size use 32;

   for Flag_Word3'Alignment use 4;

   type Flag_Word3_Ptr is access all Flag_Word3;

   function To_Flag_Word3 is new

     Unchecked_Conversion (Union_Id, Flag_Word3);

   function To_Flag_Word3_Ptr is new

     Unchecked_Conversion (Union_Id_Ptr, Flag_Word3_Ptr);

   --  The following declarations are used to store flags 184-215 in the

   --  Field11 field of the fifth component of an extended (entity) node.

   type Flag_Word4 is record

      Flag184 : Boolean;

      Flag185 : Boolean;

      Flag186 : Boolean;

      Flag187 : Boolean;

      Flag188 : Boolean;

      Flag189 : Boolean;

      Flag190 : Boolean;

      Flag191 : Boolean;

      Flag192 : Boolean;

      Flag193 : Boolean;

      Flag194 : Boolean;

      Flag195 : Boolean;

      Flag196 : Boolean;

      Flag197 : Boolean;

      Flag198 : Boolean;

      Flag199 : Boolean;

      Flag200 : Boolean;

      Flag201 : Boolean;

      Flag202 : Boolean;

      Flag203 : Boolean;

      Flag204 : Boolean;

      Flag205 : Boolean;

      Flag206 : Boolean;

      Flag207 : Boolean;

      Flag208 : Boolean;

      Flag209 : Boolean;

      Flag210 : Boolean;

      Flag211 : Boolean;

      Flag212 : Boolean;

      Flag213 : Boolean;

      Flag214 : Boolean;

      Flag215 : Boolean;

   end record;

   pragma Pack (Flag_Word4);

   for Flag_Word4'Size use 32;

   for Flag_Word4'Alignment use 4;

   type Flag_Word4_Ptr is access all Flag_Word4;

   function To_Flag_Word4 is new

     Unchecked_Conversion (Union_Id, Flag_Word4);

   function To_Flag_Word4_Ptr is new

     Unchecked_Conversion (Union_Id_Ptr, Flag_Word4_Ptr);

   --  The following declarations are used to store flags 216-247 in the

   --  Field12 field of the fifth component of an extended (entity) node.

   type Flag_Word5 is record

      Flag216 : Boolean;

      Flag217 : Boolean;

      Flag218 : Boolean;

      Flag219 : Boolean;

      Flag220 : Boolean;

      Flag221 : Boolean;

      Flag222 : Boolean;

      Flag223 : Boolean;

      Flag224 : Boolean;

      Flag225 : Boolean;

      Flag226 : Boolean;

      Flag227 : Boolean;

      Flag228 : Boolean;

      Flag229 : Boolean;

      Flag230 : Boolean;

      Flag231 : Boolean;

      Flag232 : Boolean;

      Flag233 : Boolean;

      Flag234 : Boolean;

      Flag235 : Boolean;

      Flag236 : Boolean;

      Flag237 : Boolean;

      Flag238 : Boolean;

      Flag239 : Boolean;

      Flag240 : Boolean;

      Flag241 : Boolean;

      Flag242 : Boolean;

      Flag243 : Boolean;

      Flag244 : Boolean;

      Flag245 : Boolean;

      Flag246 : Boolean;

      Flag247 : Boolean;

   end record;

   pragma Pack (Flag_Word5);

   for Flag_Word5'Size use 32;

   for Flag_Word5'Alignment use 4;

   type Flag_Word5_Ptr is access all Flag_Word5;

   function To_Flag_Word5 is new

     Unchecked_Conversion (Union_Id, Flag_Word5);

   function To_Flag_Word5_Ptr is new

     Unchecked_Conversion (Union_Id_Ptr, Flag_Word5_Ptr);

   --------------------------------------------------

   -- Implementation of Tree Substitution Routines --

   --------------------------------------------------

   --  A separate table keeps track of the mapping between rewritten nodes

   --  and their corresponding original tree nodes. Rewrite makes an entry

   --  in this table for use by Original_Node. By default, if no call is

   --  Rewrite, the entry in this table points to the original unwritten node.

   --  Note: eventually, this should be a field in the Node directly, but

   --  for now we do not want to disturb the efficiency of a power of 2

   --  for the node size

   package Orig_Nodes is new Table.Table (

      Table_Component_Type => Node_Id,

      Table_Index_Type     => Node_Id'Base,

      Table_Low_Bound      => First_Node_Id,

      Table_Initial        => Alloc.Orig_Nodes_Initial,

      Table_Increment      => Alloc.Orig_Nodes_Increment,

      Table_Name           => "Orig_Nodes");

   --------------------------

   -- Paren_Count Handling --

   --------------------------

   --  As noted in the spec, the paren count in a sub-expression node has

   --  four possible values 0,1,2, and 3. The value 3 really means 3 or more,

   --  and we use an auxiliary serially scanned table to record the actual

   --  count. A serial search is fine, only pathological programs will use

   --  entries in this table. Normal programs won't use it at all.

   type Paren_Count_Entry is record

      Nod   : Node_Id;

      --  The node to which this count applies

      Count : Nat range 3 .. Nat'Last;

      --  The count of parentheses, which will be in the indicated range

   end record;

   package Paren_Counts is new Table.Table (

     Table_Component_Type => Paren_Count_Entry,

     Table_Index_Type     => Int,

     Table_Low_Bound      => 0,

     Table_Initial        => 10,

     Table_Increment      => 200,

     Table_Name           => "Paren_Counts");

   -----------------------

   -- Local Subprograms --

   -----------------------

   procedure Fix_Parents (Ref_Node, Fix_Node : Node_Id);

   --  Fixup parent pointers for the syntactic children of Fix_Node after

   --  a copy, setting them to Fix_Node when they pointed to Ref_Node.

   function Allocate_Initialize_Node

     (Src            : Node_Id;

      With_Extension : Boolean) return Node_Id;

   --  Allocate a new node or node extension. If Src is not empty,

   --  the information for the newly-allocated node is copied from it.

   ------------------------------

   -- Allocate_Initialize_Node --

   ------------------------------

   function Allocate_Initialize_Node

     (Src            : Node_Id;

      With_Extension : Boolean) return Node_Id

   is

      New_Id : Node_Id     := Src;

      Nod    : Node_Record := Default_Node;

      Ext1   : Node_Record := Default_Node_Extension;

      Ext2   : Node_Record := Default_Node_Extension;

      Ext3   : Node_Record := Default_Node_Extension;

      Ext4   : Node_Record := Default_Node_Extension;

   begin

      if Present (Src) then

         Nod := Nodes.Table (Src);

         if Has_Extension (Src) then

            Ext1 := Nodes.Table (Src + 1);

            Ext2 := Nodes.Table (Src + 2);

            Ext3 := Nodes.Table (Src + 3);

            Ext4 := Nodes.Table (Src + 4);

         end if;

      end if;

      if not (Present (Src)

               and then not Has_Extension (Src)

               and then With_Extension

               and then Src = Nodes.Last)

      then

         --  We are allocating a new node, or extending a node

         --  other than Nodes.Last.

         Nodes.Append (Nod);

         New_Id := Nodes.Last;

         Orig_Nodes.Append (New_Id);

         Node_Count := Node_Count + 1;

      end if;

      --  Specifically copy Paren_Count to deal with creating new table entry

      --  if the parentheses count is at the maximum possible value already.

      if Present (Src) and then Nkind (Src) in N_Subexpr then

         Set_Paren_Count (New_Id, Paren_Count (Src));

      end if;

      --  Set extension nodes if required

      if With_Extension then

         Nodes.Append (Ext1);

         Nodes.Append (Ext2);

         Nodes.Append (Ext3);

         Nodes.Append (Ext4);

      end if;

      Orig_Nodes.Set_Last (Nodes.Last);

      Allocate_List_Tables (Nodes.Last);

      return New_Id;

   end Allocate_Initialize_Node;

   --------------

   -- Analyzed --

   --------------

   function Analyzed (N : Node_Id) return Boolean is

   begin

      pragma Assert (N <= Nodes.Last);

      return Nodes.Table (N).Analyzed;

   end Analyzed;

   --------------------------

   -- Basic_Set_Convention --

   --------------------------

   procedure Basic_Set_Convention  (E : Entity_Id; Val : Convention_Id) is

   begin

      pragma Assert (Nkind (E) in N_Entity);

      To_Flag_Word_Ptr

        (Union_Id_Ptr'

          (Nodes.Table (E + 2).Field12'Unrestricted_Access)).Convention := Val;

   end Basic_Set_Convention;

   -----------------

   -- Change_Node --

   -----------------

   procedure Change_Node (N : Node_Id; New_Node_Kind : Node_Kind) is

      Save_Sloc    : constant Source_Ptr := Sloc (N);

      Save_In_List : constant Boolean    := Nodes.Table (N).In_List;

      Save_Link    : constant Union_Id   := Nodes.Table (N).Link;

      Save_CFS     : constant Boolean    := Nodes.Table (N).Comes_From_Source;

      Save_Posted  : constant Boolean    := Nodes.Table (N).Error_Posted;

      Par_Count    : Nat                 := 0;

   begin

      if Nkind (N) in N_Subexpr then

         Par_Count := Paren_Count (N);

      end if;

      Nodes.Table (N)                   := Default_Node;

      Nodes.Table (N).Sloc              := Save_Sloc;

      Nodes.Table (N).In_List           := Save_In_List;

      Nodes.Table (N).Link              := Save_Link;

      Nodes.Table (N).Comes_From_Source := Save_CFS;

      Nodes.Table (N).Nkind             := New_Node_Kind;

      Nodes.Table (N).Error_Posted      := Save_Posted;

      if New_Node_Kind in N_Subexpr then

         Set_Paren_Count (N, Par_Count);

      end if;

   end Change_Node;

   -----------------------

   -- Comes_From_Source --

   -----------------------

   function Comes_From_Source (N : Node_Id) return Boolean is

   begin

      pragma Assert (N <= Nodes.Last);

      return Nodes.Table (N).Comes_From_Source;

   end Comes_From_Source;

   ----------------

   -- Convention --

   ----------------

   function Convention (E : Entity_Id) return Convention_Id is

   begin

      pragma Assert (Nkind (E) in N_Entity);

      return To_Flag_Word (Nodes.Table (E + 2).Field12).Convention;

   end Convention;

   ---------------

   -- Copy_Node --

   ---------------

   procedure Copy_Node (Source : Node_Id; Destination : Node_Id) is

      Save_In_List : constant Boolean  := Nodes.Table (Destination).In_List;

      Save_Link    : constant Union_Id := Nodes.Table (Destination).Link;

   begin

      Nodes.Table (Destination)         := Nodes.Table (Source);

      Nodes.Table (Destination).In_List := Save_In_List;

      Nodes.Table (Destination).Link    := Save_Link;

      --  Specifically set Paren_Count to make sure auxiliary table entry

      --  gets correctly made if the parentheses count is at the max value.

      if Nkind (Destination) in N_Subexpr then

         Set_Paren_Count (Destination, Paren_Count (Source));

      end if;

      --  Deal with copying extension nodes if present

      if Has_Extension (Source) then

         pragma Assert (Has_Extension (Destination));

         Nodes.Table (Destination + 1) := Nodes.Table (Source + 1);

         Nodes.Table (Destination + 2) := Nodes.Table (Source + 2);

         Nodes.Table (Destination + 3) := Nodes.Table (Source + 3);

         Nodes.Table (Destination + 4) := Nodes.Table (Source + 4);

      else

         pragma Assert (not Has_Extension (Source));

         null;

      end if;

   end Copy_Node;

   ------------------------

   -- Copy_Separate_Tree --

   ------------------------

   function Copy_Separate_Tree (Source : Node_Id) return Node_Id is

      New_Id  : Node_Id;

      function Copy_Entity (E : Entity_Id) return Entity_Id;

      --  Copy Entity, copying only the Ekind and Chars fields

      function Copy_List (List : List_Id) return List_Id;

      --  Copy list

      function Possible_Copy (Field : Union_Id) return Union_Id;

      --  Given a field, returns a copy of the node or list if its parent

      --  is the current source node, and otherwise returns the input

      -----------------

      -- Copy_Entity --

      -----------------

      function Copy_Entity (E : Entity_Id) return Entity_Id is

         New_Ent : Entity_Id;

      begin

         case N_Entity (Nkind (E)) is

            when N_Defining_Identifier =>

               New_Ent := New_Entity (N_Defining_Identifier, Sloc (E));

            when N_Defining_Character_Literal =>

               New_Ent := New_Entity (N_Defining_Character_Literal, Sloc (E));

            when N_Defining_Operator_Symbol =>

               New_Ent := New_Entity (N_Defining_Operator_Symbol, Sloc (E));

         end case;

         Set_Chars (New_Ent, Chars (E));

         return New_Ent;

      end Copy_Entity;

      ---------------

      -- Copy_List --

      ---------------

      function Copy_List (List : List_Id) return List_Id is

         NL : List_Id;

         E  : Node_Id;

      begin

         if List = No_List then

            return No_List;

         else

            NL := New_List;

            E := First (List);

            while Present (E) loop

               if Has_Extension (E) then

                  Append (Copy_Entity (E), NL);

               else

                  Append (Copy_Separate_Tree (E), NL);

               end if;

               Next (E);

            end loop;

            return NL;

         end if;

      end Copy_List;

      -------------------

      -- Possible_Copy --

      -------------------

      function Possible_Copy (Field : Union_Id) return Union_Id is

         New_N : Union_Id;

      begin

         if Field in Node_Range then

            New_N := Union_Id (Copy_Separate_Tree (Node_Id (Field)));

            if Parent (Node_Id (Field)) = Source then

               Set_Parent (Node_Id (New_N), New_Id);

            end if;

            return New_N;

         elsif Field in List_Range then

            New_N := Union_Id (Copy_List (List_Id (Field)));

            if Parent (List_Id (Field)) = Source then

               Set_Parent (List_Id (New_N), New_Id);

            end if;

            return New_N;

         else

            return Field;

         end if;

      end Possible_Copy;

   --  Start of processing for Copy_Separate_Tree

   begin

      if Source <= Empty_Or_Error then

         return Source;

      elsif Has_Extension (Source) then

         return Copy_Entity (Source);

      else

         New_Id := New_Copy (Source);

         --  Recursively copy descendents

         Set_Field1 (New_Id, Possible_Copy (Field1 (New_Id)));

         Set_Field2 (New_Id, Possible_Copy (Field2 (New_Id)));

         Set_Field3 (New_Id, Possible_Copy (Field3 (New_Id)));

         Set_Field4 (New_Id, Possible_Copy (Field4 (New_Id)));

         Set_Field5 (New_Id, Possible_Copy (Field5 (New_Id)));

         --  Set Entity field to Empty

         --  Why is this done??? and why is it always right to do it???

         if Nkind (New_Id) in N_Has_Entity

           or else Nkind (New_Id) = N_Freeze_Entity

         then

            Set_Entity (New_Id, Empty);

         end if;

         --  All done, return copied node

         return New_Id;

      end if;

   end Copy_Separate_Tree;

   -----------

   -- Ekind --

   -----------

   function Ekind (E : Entity_Id) return Entity_Kind is

   begin

      pragma Assert (Nkind (E) in N_Entity);

      return N_To_E (Nodes.Table (E + 1).Nkind);

   end Ekind;

   ------------------

   -- Error_Posted --

   ------------------

   function Error_Posted (N : Node_Id) return Boolean is

   begin

      pragma Assert (N <= Nodes.Last);

      return Nodes.Table (N).Error_Posted;

   end Error_Posted;

   -----------------------

   -- Exchange_Entities --

   -----------------------

   procedure Exchange_Entities (E1 : Entity_Id; E2 : Entity_Id) is

      Temp_Ent : Node_Record;

   begin

      pragma Assert (Has_Extension (E1)

        and then Has_Extension (E2)

        and then not Nodes.Table (E1).In_List

        and then not Nodes.Table (E2).In_List);

      --  Exchange the contents of the two entities