------------------------------------------------
--------------------------------
--                                                                          --
--                           OCARINA COMPONENTS                             --
--                                                                          --
--                 G A I A . P R O C E S S O R . N O D E S                  --
--                                                                          --
--                                 B o d y                                  --
--                                                                          --
--                 Copyright (C) 2007, GET-Telecom Paris.                   --
--                                                                          --
-- Ocarina  is free software;  you  can  redistribute  it and/or  modify    --
-- it under terms of the GNU General Public License as published by the     --
-- Free Software Foundation; either version 2, or (at your option) any      --
-- later version. Ocarina is distributed  in  the  hope  that it will be    --
-- useful, but WITHOUT ANY WARRANTY;  without even the implied warranty of  --
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General --
-- Public License for more details. You should have received  a copy of the --
-- GNU General Public License distributed with Ocarina; see file COPYING.   --
-- If not, write to the Free Software Foundation, 51 Franklin Street, Fifth --
-- Floor, Boston, MA 02111-1301, USA.                                       --
--                                                                          --
-- As a special exception,  if other files  instantiate  generics from this --
-- unit, or you link  this unit with other files  to produce an executable, --
-- this  unit  does not  by itself cause  the resulting  executable to be   --
-- covered  by the  GNU  General  Public  License. This exception does not  --
-- however invalidate  any other reasons why the executable file might be   --
-- covered by the GNU Public License.                                       --
--                                                                          --
--                 Ocarina is maintained by the Ocarina team                --
--                       (ocarina-users@listes.enst.fr)                     --
--                                                                          --
------------------------------------------------------------------------------

pragma Style_Checks ("NM32766");

--  This file has been generated automatically by `mknodes'. Do not
--  hand modify this file since your changes will be overridden.

with Gaia.Processor.Debug; use Gaia.Processor.Debug;

package body Gaia.Processor.Nodes is

   pragma Warnings (Off);
   use Entries;

   function Kind (N : Node_Id) return Node_Kind is
   begin
      return Table (Node_Id (N)).Kind;
   end Kind;

   procedure Set_Kind (N : Node_Id; V : Node_Kind) is
   begin
      Table (Node_Id (N)).Kind  := V;
   end Set_Kind;

   function Loc (N : Node_Id) return Location is
   begin
      return Table (Node_Id (N)).Loc;
   end Loc;

   procedure Set_Loc (N : Node_Id; V : Location) is
   begin
      Table (Node_Id (N)).Loc  := V;
   end Set_Loc;

   function Next_Node (N : Node_Id) return Node_Id is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Node_Id
        or else Table (Node_Id (N)).Kind = K_Identifier
        or else Table (Node_Id (N)).Kind = K_Gaia_Definition
        or else Table (Node_Id (N)).Kind = K_Scoped_Name
        or else Table (Node_Id (N)).Kind = K_Property
        or else Table (Node_Id (N)).Kind = K_Gaia_Scope_Definition
        or else Table (Node_Id (N)).Kind = K_Package_Name_Element
        or else Table (Node_Id (N)).Kind = K_Root_Node
        or else Table (Node_Id (N)).Kind = K_Distributed_Application
        or else Table (Node_Id (N)).Kind = K_Namespace
        or else Table (Node_Id (N)).Kind = K_Call_Sequence
        or else Table (Node_Id (N)).Kind = K_Subprogram
        or else Table (Node_Id (N)).Kind = K_Thread
        or else Table (Node_Id (N)).Kind = K_Process
        or else Table (Node_Id (N)).Kind = K_Parameter
        or else Table (Node_Id (N)).Kind = K_Parameter_Connection
        or else Table (Node_Id (N)).Kind = K_Thread_Reference
        or else Table (Node_Id (N)).Kind = K_Port
        or else Table (Node_Id (N)).Kind = K_Destination_Port
        or else Table (Node_Id (N)).Kind = K_Variable_Definition
        or else Table (Node_Id (N)).Kind = K_Subprogram_Call
        or else Table (Node_Id (N)).Kind = K_Subprogram_Reference
        or else Table (Node_Id (N)).Kind = K_Symbolic_Value
        or else Table (Node_Id (N)).Kind = K_Type_Definition);

      return Node_Id (Table (Node_Id (N)).L (4));
   end Next_Node;

   procedure Set_Next_Node (N : Node_Id; V : Node_Id) is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Node_Id
        or else Table (Node_Id (N)).Kind = K_Identifier
        or else Table (Node_Id (N)).Kind = K_Gaia_Definition
        or else Table (Node_Id (N)).Kind = K_Scoped_Name
        or else Table (Node_Id (N)).Kind = K_Property
        or else Table (Node_Id (N)).Kind = K_Gaia_Scope_Definition
        or else Table (Node_Id (N)).Kind = K_Package_Name_Element
        or else Table (Node_Id (N)).Kind = K_Root_Node
        or else Table (Node_Id (N)).Kind = K_Distributed_Application
        or else Table (Node_Id (N)).Kind = K_Namespace
        or else Table (Node_Id (N)).Kind = K_Call_Sequence
        or else Table (Node_Id (N)).Kind = K_Subprogram
        or else Table (Node_Id (N)).Kind = K_Thread
        or else Table (Node_Id (N)).Kind = K_Process
        or else Table (Node_Id (N)).Kind = K_Parameter
        or else Table (Node_Id (N)).Kind = K_Parameter_Connection
        or else Table (Node_Id (N)).Kind = K_Thread_Reference
        or else Table (Node_Id (N)).Kind = K_Port
        or else Table (Node_Id (N)).Kind = K_Destination_Port
        or else Table (Node_Id (N)).Kind = K_Variable_Definition
        or else Table (Node_Id (N)).Kind = K_Subprogram_Call
        or else Table (Node_Id (N)).Kind = K_Subprogram_Reference
        or else Table (Node_Id (N)).Kind = K_Symbolic_Value
        or else Table (Node_Id (N)).Kind = K_Type_Definition);

      Table (Node_Id (N)).L (4)  := Int (V);
   end Set_Next_Node;

   function First_Node (N : List_Id) return Node_Id is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_List_Id
        or else Table (Node_Id (N)).Kind = K_Declaration_List);

      return Node_Id (Table (Node_Id (N)).L (1));
   end First_Node;

   procedure Set_First_Node (N : List_Id; V : Node_Id) is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_List_Id
        or else Table (Node_Id (N)).Kind = K_Declaration_List);

      Table (Node_Id (N)).L (1)  := Int (V);
   end Set_First_Node;

   function Last_Node (N : List_Id) return Node_Id is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_List_Id
        or else Table (Node_Id (N)).Kind = K_Declaration_List);

      return Node_Id (Table (Node_Id (N)).L (2));
   end Last_Node;

   procedure Set_Last_Node (N : List_Id; V : Node_Id) is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_List_Id
        or else Table (Node_Id (N)).Kind = K_Declaration_List);

      Table (Node_Id (N)).L (2)  := Int (V);
   end Set_Last_Node;

   function Name (N : Node_Id) return Name_Id is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Identifier);

      return Name_Id (Table (Node_Id (N)).L (1));
   end Name;

   procedure Set_Name (N : Node_Id; V : Name_Id) is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Identifier);

      Table (Node_Id (N)).L (1)  := Int (V);
   end Set_Name;

   function Backend_Node (N : Node_Id) return Node_Id is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Identifier);

      return Node_Id (Table (Node_Id (N)).L (2));
   end Backend_Node;

   procedure Set_Backend_Node (N : Node_Id; V : Node_Id) is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Identifier);

      Table (Node_Id (N)).L (2)  := Int (V);
   end Set_Backend_Node;

   function Corresponding_Entity (N : Node_Id) return Node_Id is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Identifier);

      return Node_Id (Table (Node_Id (N)).L (3));
   end Corresponding_Entity;

   procedure Set_Corresponding_Entity (N : Node_Id; V : Node_Id) is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Identifier);

      Table (Node_Id (N)).L (3)  := Int (V);
   end Set_Corresponding_Entity;

   function Identifier (N : Node_Id) return Node_Id is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Gaia_Definition
        or else Table (Node_Id (N)).Kind = K_Scoped_Name
        or else Table (Node_Id (N)).Kind = K_Gaia_Scope_Definition
        or else Table (Node_Id (N)).Kind = K_Package_Name_Element
        or else Table (Node_Id (N)).Kind = K_Root_Node
        or else Table (Node_Id (N)).Kind = K_Distributed_Application
        or else Table (Node_Id (N)).Kind = K_Namespace
        or else Table (Node_Id (N)).Kind = K_Call_Sequence
        or else Table (Node_Id (N)).Kind = K_Subprogram
        or else Table (Node_Id (N)).Kind = K_Thread
        or else Table (Node_Id (N)).Kind = K_Process
        or else Table (Node_Id (N)).Kind = K_Parameter
        or else Table (Node_Id (N)).Kind = K_Parameter_Connection
        or else Table (Node_Id (N)).Kind = K_Thread_Reference
        or else Table (Node_Id (N)).Kind = K_Port
        or else Table (Node_Id (N)).Kind = K_Destination_Port
        or else Table (Node_Id (N)).Kind = K_Variable_Definition
        or else Table (Node_Id (N)).Kind = K_Subprogram_Call
        or else Table (Node_Id (N)).Kind = K_Subprogram_Reference
        or else Table (Node_Id (N)).Kind = K_Type_Definition);

      return Node_Id (Table (Node_Id (N)).L (5));
   end Identifier;

   procedure Set_Identifier (N : Node_Id; V : Node_Id) is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Gaia_Definition
        or else Table (Node_Id (N)).Kind = K_Scoped_Name
        or else Table (Node_Id (N)).Kind = K_Gaia_Scope_Definition
        or else Table (Node_Id (N)).Kind = K_Package_Name_Element
        or else Table (Node_Id (N)).Kind = K_Root_Node
        or else Table (Node_Id (N)).Kind = K_Distributed_Application
        or else Table (Node_Id (N)).Kind = K_Namespace
        or else Table (Node_Id (N)).Kind = K_Call_Sequence
        or else Table (Node_Id (N)).Kind = K_Subprogram
        or else Table (Node_Id (N)).Kind = K_Thread
        or else Table (Node_Id (N)).Kind = K_Process
        or else Table (Node_Id (N)).Kind = K_Parameter
        or else Table (Node_Id (N)).Kind = K_Parameter_Connection
        or else Table (Node_Id (N)).Kind = K_Thread_Reference
        or else Table (Node_Id (N)).Kind = K_Port
        or else Table (Node_Id (N)).Kind = K_Destination_Port
        or else Table (Node_Id (N)).Kind = K_Variable_Definition
        or else Table (Node_Id (N)).Kind = K_Subprogram_Call
        or else Table (Node_Id (N)).Kind = K_Subprogram_Reference
        or else Table (Node_Id (N)).Kind = K_Type_Definition);

      Table (Node_Id (N)).L (5)  := Int (V);
   end Set_Identifier;

   function Parent_Scoped_Name (N : Node_Id) return Node_Id is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Scoped_Name);

      return Node_Id (Table (Node_Id (N)).L (1));
   end Parent_Scoped_Name;

   procedure Set_Parent_Scoped_Name (N : Node_Id; V : Node_Id) is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Scoped_Name);

      Table (Node_Id (N)).L (1)  := Int (V);
   end Set_Parent_Scoped_Name;

   function Reference (N : Node_Id) return Node_Id is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Scoped_Name);

      return Node_Id (Table (Node_Id (N)).L (2));
   end Reference;

   procedure Set_Reference (N : Node_Id; V : Node_Id) is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Scoped_Name);

      Table (Node_Id (N)).L (2)  := Int (V);
   end Set_Reference;

   function Entity (N : Node_Id) return Name_Id is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Property);

      return Name_Id (Table (Node_Id (N)).L (1));
   end Entity;

   procedure Set_Entity (N : Node_Id; V : Name_Id) is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Property);

      Table (Node_Id (N)).L (1)  := Int (V);
   end Set_Entity;

   function Value (N : Node_Id) return Node_Id is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Property);

      return Node_Id (Table (Node_Id (N)).L (2));
   end Value;

   procedure Set_Value (N : Node_Id; V : Node_Id) is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Property);

      Table (Node_Id (N)).L (2)  := Int (V);
   end Set_Value;

   function Scoped_Name (N : Node_Id) return Node_Id is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Gaia_Scope_Definition
        or else Table (Node_Id (N)).Kind = K_Root_Node
        or else Table (Node_Id (N)).Kind = K_Namespace
        or else Table (Node_Id (N)).Kind = K_Call_Sequence
        or else Table (Node_Id (N)).Kind = K_Subprogram
        or else Table (Node_Id (N)).Kind = K_Thread
        or else Table (Node_Id (N)).Kind = K_Process
        or else Table (Node_Id (N)).Kind = K_Parameter
        or else Table (Node_Id (N)).Kind = K_Parameter_Connection
        or else Table (Node_Id (N)).Kind = K_Port
        or else Table (Node_Id (N)).Kind = K_Variable_Definition
        or else Table (Node_Id (N)).Kind = K_Subprogram_Call
        or else Table (Node_Id (N)).Kind = K_Type_Definition);

      return Node_Id (Table (Node_Id (N)).L (6));
   end Scoped_Name;

   procedure Set_Scoped_Name (N : Node_Id; V : Node_Id) is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Gaia_Scope_Definition
        or else Table (Node_Id (N)).Kind = K_Root_Node
        or else Table (Node_Id (N)).Kind = K_Namespace
        or else Table (Node_Id (N)).Kind = K_Call_Sequence
        or else Table (Node_Id (N)).Kind = K_Subprogram
        or else Table (Node_Id (N)).Kind = K_Thread
        or else Table (Node_Id (N)).Kind = K_Process
        or else Table (Node_Id (N)).Kind = K_Parameter
        or else Table (Node_Id (N)).Kind = K_Parameter_Connection
        or else Table (Node_Id (N)).Kind = K_Port
        or else Table (Node_Id (N)).Kind = K_Variable_Definition
        or else Table (Node_Id (N)).Kind = K_Subprogram_Call
        or else Table (Node_Id (N)).Kind = K_Type_Definition);

      Table (Node_Id (N)).L (6)  := Int (V);
   end Set_Scoped_Name;

   function Properties (N : Node_Id) return List_Id is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Gaia_Scope_Definition
        or else Table (Node_Id (N)).Kind = K_Root_Node
        or else Table (Node_Id (N)).Kind = K_Namespace
        or else Table (Node_Id (N)).Kind = K_Call_Sequence
        or else Table (Node_Id (N)).Kind = K_Subprogram
        or else Table (Node_Id (N)).Kind = K_Thread
        or else Table (Node_Id (N)).Kind = K_Process
        or else Table (Node_Id (N)).Kind = K_Parameter
        or else Table (Node_Id (N)).Kind = K_Parameter_Connection
        or else Table (Node_Id (N)).Kind = K_Port
        or else Table (Node_Id (N)).Kind = K_Variable_Definition
        or else Table (Node_Id (N)).Kind = K_Subprogram_Call
        or else Table (Node_Id (N)).Kind = K_Type_Definition);

      return List_Id (Table (Node_Id (N)).L (7));
   end Properties;

   procedure Set_Properties (N : Node_Id; V : List_Id) is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Gaia_Scope_Definition
        or else Table (Node_Id (N)).Kind = K_Root_Node
        or else Table (Node_Id (N)).Kind = K_Namespace
        or else Table (Node_Id (N)).Kind = K_Call_Sequence
        or else Table (Node_Id (N)).Kind = K_Subprogram
        or else Table (Node_Id (N)).Kind = K_Thread
        or else Table (Node_Id (N)).Kind = K_Process
        or else Table (Node_Id (N)).Kind = K_Parameter
        or else Table (Node_Id (N)).Kind = K_Parameter_Connection
        or else Table (Node_Id (N)).Kind = K_Port
        or else Table (Node_Id (N)).Kind = K_Variable_Definition
        or else Table (Node_Id (N)).Kind = K_Subprogram_Call
        or else Table (Node_Id (N)).Kind = K_Type_Definition);

      Table (Node_Id (N)).L (7)  := Int (V);
   end Set_Properties;

   function Namespaces (N : Node_Id) return List_Id is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Root_Node);

      return List_Id (Table (Node_Id (N)).L (2));
   end Namespaces;

   procedure Set_Namespaces (N : Node_Id; V : List_Id) is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Root_Node);

      Table (Node_Id (N)).L (2)  := Int (V);
   end Set_Namespaces;

   function Node_Location (N : Node_Id) return Name_Id is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Root_Node);

      return Name_Id (Table (Node_Id (N)).L (3));
   end Node_Location;

   procedure Set_Node_Location (N : Node_Id; V : Name_Id) is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Root_Node);

      Table (Node_Id (N)).L (3)  := Int (V);
   end Set_Node_Location;

   function Port_Number (N : Node_Id) return Value_Id is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Root_Node
        or else Table (Node_Id (N)).Kind = K_Destination_Port);

      return Value_Id (Table (Node_Id (N)).L (8));
   end Port_Number;

   procedure Set_Port_Number (N : Node_Id; V : Value_Id) is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Root_Node
        or else Table (Node_Id (N)).Kind = K_Destination_Port);

      Table (Node_Id (N)).L (8)  := Int (V);
   end Set_Port_Number;

   function Thread_Number (N : Node_Id) return Int is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Root_Node);

      return Int (Table (Node_Id (N)).L (9));
   end Thread_Number;

   procedure Set_Thread_Number (N : Node_Id; V : Int) is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Root_Node);

      Table (Node_Id (N)).L (9)  := Int (V);
   end Set_Thread_Number;

   function Priority_Managed (N : Node_Id) return Boolean is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Root_Node);

      return Boolean (Table (Node_Id (N)).B (1));
   end Priority_Managed;

   procedure Set_Priority_Managed (N : Node_Id; V : Boolean) is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Root_Node);

      Table (Node_Id (N)).B (1)  := Boolean (V);
   end Set_Priority_Managed;

   function Root_Nodes (N : Node_Id) return List_Id is
   begin
      pragma Assert
        (False or else Table (Node_Id (N)).Kind = K_Distributed_Application);

      return List_Id (Table (Node_Id (N)).L (1));
   end Root_Nodes;

   procedure Set_Root_Nodes (N : Node_Id; V : List_Id) is
   begin
      pragma Assert
        (False or else Table (Node_Id (N)).Kind = K_Distributed_Application);

      Table (Node_Id (N)).L (1)  := Int (V);
   end Set_Root_Nodes;

   function Protocol (N : Node_Id) return Name_Id is
   begin
      pragma Assert
        (False or else Table (Node_Id (N)).Kind = K_Distributed_Application);

      return Name_Id (Table (Node_Id (N)).L (2));
   end Protocol;

   procedure Set_Protocol (N : Node_Id; V : Name_Id) is
   begin
      pragma Assert
        (False or else Table (Node_Id (N)).Kind = K_Distributed_Application);

      Table (Node_Id (N)).L (2)  := Int (V);
   end Set_Protocol;

   function Public_Declarations (N : Node_Id) return List_Id is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Namespace);

      return List_Id (Table (Node_Id (N)).L (1));
   end Public_Declarations;

   procedure Set_Public_Declarations (N : Node_Id; V : List_Id) is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Namespace);

      Table (Node_Id (N)).L (1)  := Int (V);
   end Set_Public_Declarations;

   function Private_Declarations (N : Node_Id) return List_Id is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Namespace);

      return List_Id (Table (Node_Id (N)).L (2));
   end Private_Declarations;

   procedure Set_Private_Declarations (N : Node_Id; V : List_Id) is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Namespace);

      Table (Node_Id (N)).L (2)  := Int (V);
   end Set_Private_Declarations;

   function Statements (N : Node_Id) return List_Id is
   begin
      pragma Assert
        (False or else Table (Node_Id (N)).Kind = K_Call_Sequence);

      return List_Id (Table (Node_Id (N)).L (1));
   end Statements;

   procedure Set_Statements (N : Node_Id; V : List_Id) is
   begin
      pragma Assert
        (False or else Table (Node_Id (N)).Kind = K_Call_Sequence);

      Table (Node_Id (N)).L (1)  := Int (V);
   end Set_Statements;

   function Variables (N : Node_Id) return List_Id is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Subprogram
        or else Table (Node_Id (N)).Kind = K_Thread
        or else Table (Node_Id (N)).Kind = K_Process);

      return List_Id (Table (Node_Id (N)).L (2));
   end Variables;

   procedure Set_Variables (N : Node_Id; V : List_Id) is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Subprogram
        or else Table (Node_Id (N)).Kind = K_Thread
        or else Table (Node_Id (N)).Kind = K_Process);

      Table (Node_Id (N)).L (2)  := Int (V);
   end Set_Variables;

   function Parameters (N : Node_Id) return List_Id is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Subprogram
        or else Table (Node_Id (N)).Kind = K_Subprogram_Call);

      return List_Id (Table (Node_Id (N)).L (1));
   end Parameters;

   procedure Set_Parameters (N : Node_Id; V : List_Id) is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Subprogram
        or else Table (Node_Id (N)).Kind = K_Subprogram_Call);

      Table (Node_Id (N)).L (1)  := Int (V);
   end Set_Parameters;

   function Implemented_By (N : Node_Id) return Name_Id is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Subprogram);

      return Name_Id (Table (Node_Id (N)).L (3));
   end Implemented_By;

   procedure Set_Implemented_By (N : Node_Id; V : Name_Id) is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Subprogram);

      Table (Node_Id (N)).L (3)  := Int (V);
   end Set_Implemented_By;

   function Implementation_Language (N : Node_Id) return Name_Id is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Subprogram);

      return Name_Id (Table (Node_Id (N)).L (8));
   end Implementation_Language;

   procedure Set_Implementation_Language (N : Node_Id; V : Name_Id) is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Subprogram);

      Table (Node_Id (N)).L (8)  := Int (V);
   end Set_Implementation_Language;

   function Call_Sequences (N : Node_Id) return List_Id is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Subprogram
        or else Table (Node_Id (N)).Kind = K_Thread);

      return List_Id (Table (Node_Id (N)).L (9));
   end Call_Sequences;

   procedure Set_Call_Sequences (N : Node_Id; V : List_Id) is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Subprogram
        or else Table (Node_Id (N)).Kind = K_Thread);

      Table (Node_Id (N)).L (9)  := Int (V);
   end Set_Call_Sequences;

   function Connections (N : Node_Id) return List_Id is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Subprogram
        or else Table (Node_Id (N)).Kind = K_Thread
        or else Table (Node_Id (N)).Kind = K_Process);

      return List_Id (Table (Node_Id (N)).L (10));
   end Connections;

   procedure Set_Connections (N : Node_Id; V : List_Id) is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Subprogram
        or else Table (Node_Id (N)).Kind = K_Thread
        or else Table (Node_Id (N)).Kind = K_Process);

      Table (Node_Id (N)).L (10)  := Int (V);
   end Set_Connections;

   function Owner_Data (N : Node_Id) return Node_Id is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Subprogram);

      return Node_Id (Table (Node_Id (N)).L (11));
   end Owner_Data;

   procedure Set_Owner_Data (N : Node_Id; V : Node_Id) is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Subprogram);

      Table (Node_Id (N)).L (11)  := Int (V);
   end Set_Owner_Data;

   function Ports (N : Node_Id) return List_Id is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Thread
        or else Table (Node_Id (N)).Kind = K_Process);

      return List_Id (Table (Node_Id (N)).L (3));
   end Ports;

   procedure Set_Ports (N : Node_Id; V : List_Id) is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Thread
        or else Table (Node_Id (N)).Kind = K_Process);

      Table (Node_Id (N)).L (3)  := Int (V);
   end Set_Ports;

   function Period (N : Node_Id) return Value_Id is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Thread);

      return Value_Id (Table (Node_Id (N)).L (8));
   end Period;

   procedure Set_Period (N : Node_Id; V : Value_Id) is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Thread);

      Table (Node_Id (N)).L (8)  := Int (V);
   end Set_Period;

   function Priority (N : Node_Id) return Value_Id is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Thread);

      return Value_Id (Table (Node_Id (N)).L (11));
   end Priority;

   procedure Set_Priority (N : Node_Id; V : Value_Id) is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Thread);

      Table (Node_Id (N)).L (11)  := Int (V);
   end Set_Priority;

   function Storage_Size (N : Node_Id) return Value_Id is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Thread);

      return Value_Id (Table (Node_Id (N)).L (12));
   end Storage_Size;

   procedure Set_Storage_Size (N : Node_Id; V : Value_Id) is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Thread);

      Table (Node_Id (N)).L (12)  := Int (V);
   end Set_Storage_Size;

   function Access_Provided_By (N : Node_Id) return Node_Id is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Thread
        or else Table (Node_Id (N)).Kind = K_Variable_Definition
        or else Table (Node_Id (N)).Kind = K_Subprogram_Call);

      return Node_Id (Table (Node_Id (N)).L (13));
   end Access_Provided_By;

   procedure Set_Access_Provided_By (N : Node_Id; V : Node_Id) is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Thread
        or else Table (Node_Id (N)).Kind = K_Variable_Definition
        or else Table (Node_Id (N)).Kind = K_Subprogram_Call);

      Table (Node_Id (N)).L (13)  := Int (V);
   end Set_Access_Provided_By;

   function Unique (N : Node_Id) return Boolean is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Thread);

      return Boolean (Table (Node_Id (N)).B (1));
   end Unique;

   procedure Set_Unique (N : Node_Id; V : Boolean) is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Thread);

      Table (Node_Id (N)).B (1)  := Boolean (V);
   end Set_Unique;

   function Sources_Number (N : Node_Id) return Int is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Thread);

      return Int (Table (Node_Id (N)).L (14));
   end Sources_Number;

   procedure Set_Sources_Number (N : Node_Id; V : Int) is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Thread);

      Table (Node_Id (N)).L (14)  := Int (V);
   end Set_Sources_Number;

   function Threads (N : Node_Id) return List_Id is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Process);

      return List_Id (Table (Node_Id (N)).L (1));
   end Threads;

   procedure Set_Threads (N : Node_Id; V : List_Id) is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Process);

      Table (Node_Id (N)).L (1)  := Int (V);
   end Set_Threads;

   function Is_In (N : Node_Id) return Boolean is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Parameter
        or else Table (Node_Id (N)).Kind = K_Port);

      return Boolean (Table (Node_Id (N)).B (1));
   end Is_In;

   procedure Set_Is_In (N : Node_Id; V : Boolean) is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Parameter
        or else Table (Node_Id (N)).Kind = K_Port);

      Table (Node_Id (N)).B (1)  := Boolean (V);
   end Set_Is_In;

   function Is_Out (N : Node_Id) return Boolean is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Parameter
        or else Table (Node_Id (N)).Kind = K_Port);

      return Boolean (Table (Node_Id (N)).B (2));
   end Is_Out;

   procedure Set_Is_Out (N : Node_Id; V : Boolean) is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Parameter
        or else Table (Node_Id (N)).Kind = K_Port);

      Table (Node_Id (N)).B (2)  := Boolean (V);
   end Set_Is_Out;

   function Type_Spec (N : Node_Id) return Node_Id is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Parameter
        or else Table (Node_Id (N)).Kind = K_Port
        or else Table (Node_Id (N)).Kind = K_Variable_Definition);

      return Node_Id (Table (Node_Id (N)).L (8));
   end Type_Spec;

   procedure Set_Type_Spec (N : Node_Id; V : Node_Id) is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Parameter
        or else Table (Node_Id (N)).Kind = K_Port
        or else Table (Node_Id (N)).Kind = K_Variable_Definition);

      Table (Node_Id (N)).L (8)  := Int (V);
   end Set_Type_Spec;

   function Source (N : Node_Id) return Node_Id is
   begin
      pragma Assert
        (False or else Table (Node_Id (N)).Kind = K_Parameter_Connection);

      return Node_Id (Table (Node_Id (N)).L (1));
   end Source;

   procedure Set_Source (N : Node_Id; V : Node_Id) is
   begin
      pragma Assert
        (False or else Table (Node_Id (N)).Kind = K_Parameter_Connection);

      Table (Node_Id (N)).L (1)  := Int (V);
   end Set_Source;

   function Simple_Source (N : Node_Id) return Name_Id is
   begin
      pragma Assert
        (False or else Table (Node_Id (N)).Kind = K_Parameter_Connection);

      return Name_Id (Table (Node_Id (N)).L (2));
   end Simple_Source;

   procedure Set_Simple_Source (N : Node_Id; V : Name_Id) is
   begin
      pragma Assert
        (False or else Table (Node_Id (N)).Kind = K_Parameter_Connection);

      Table (Node_Id (N)).L (2)  := Int (V);
   end Set_Simple_Source;

   function Destination (N : Node_Id) return Node_Id is
   begin
      pragma Assert
        (False or else Table (Node_Id (N)).Kind = K_Parameter_Connection);

      return Node_Id (Table (Node_Id (N)).L (3));
   end Destination;

   procedure Set_Destination (N : Node_Id; V : Node_Id) is
   begin
      pragma Assert
        (False or else Table (Node_Id (N)).Kind = K_Parameter_Connection);

      Table (Node_Id (N)).L (3)  := Int (V);
   end Set_Destination;

   function Simple_Destination (N : Node_Id) return Name_Id is
   begin
      pragma Assert
        (False or else Table (Node_Id (N)).Kind = K_Parameter_Connection);

      return Name_Id (Table (Node_Id (N)).L (8));
   end Simple_Destination;

   procedure Set_Simple_Destination (N : Node_Id; V : Name_Id) is
   begin
      pragma Assert
        (False or else Table (Node_Id (N)).Kind = K_Parameter_Connection);

      Table (Node_Id (N)).L (8)  := Int (V);
   end Set_Simple_Destination;

   function Source_Subprogram_Call (N : Node_Id) return Node_Id is
   begin
      pragma Assert
        (False or else Table (Node_Id (N)).Kind = K_Parameter_Connection);

      return Node_Id (Table (Node_Id (N)).L (9));
   end Source_Subprogram_Call;

   procedure Set_Source_Subprogram_Call (N : Node_Id; V : Node_Id) is
   begin
      pragma Assert
        (False or else Table (Node_Id (N)).Kind = K_Parameter_Connection);

      Table (Node_Id (N)).L (9)  := Int (V);
   end Set_Source_Subprogram_Call;

   function Destination_Subprogram_Call (N : Node_Id) return Node_Id is
   begin
      pragma Assert
        (False or else Table (Node_Id (N)).Kind = K_Parameter_Connection);

      return Node_Id (Table (Node_Id (N)).L (10));
   end Destination_Subprogram_Call;

   procedure Set_Destination_Subprogram_Call (N : Node_Id; V : Node_Id) is
   begin
      pragma Assert
        (False or else Table (Node_Id (N)).Kind = K_Parameter_Connection);

      Table (Node_Id (N)).L (10)  := Int (V);
   end Set_Destination_Subprogram_Call;

   function Corresponding_Thread (N : Node_Id) return Node_Id is
   begin
      pragma Assert
        (False or else Table (Node_Id (N)).Kind = K_Thread_Reference);

      return Node_Id (Table (Node_Id (N)).L (1));
   end Corresponding_Thread;

   procedure Set_Corresponding_Thread (N : Node_Id; V : Node_Id) is
   begin
      pragma Assert
        (False or else Table (Node_Id (N)).Kind = K_Thread_Reference);

      Table (Node_Id (N)).L (1)  := Int (V);
   end Set_Corresponding_Thread;

   function Fifo_Size (N : Node_Id) return Value_Id is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Port);

      return Value_Id (Table (Node_Id (N)).L (9));
   end Fifo_Size;

   procedure Set_Fifo_Size (N : Node_Id; V : Value_Id) is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Port);

      Table (Node_Id (N)).L (9)  := Int (V);
   end Set_Fifo_Size;

   function Trigger (N : Node_Id) return Boolean is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Port);

      return Boolean (Table (Node_Id (N)).B (3));
   end Trigger;

   procedure Set_Trigger (N : Node_Id; V : Boolean) is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Port);

      Table (Node_Id (N)).B (3)  := Boolean (V);
   end Set_Trigger;

   function Destinations (N : Node_Id) return List_Id is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Port);

      return List_Id (Table (Node_Id (N)).L (10));
   end Destinations;

   procedure Set_Destinations (N : Node_Id; V : List_Id) is
   begin
      pragma Assert (False or else Table (Node_Id (N)).Kind = K_Port);

      Table (Node_Id (N)).L (10)  := Int (V);
   end Set_Destinations;

   function Frontend_Node (N : Node_Id) return Node_Id is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Destination_Port
        or else Table (Node_Id (N)).Kind = K_Type_Definition);

      return Node_Id (Table (Node_Id (N)).L (2));
   end Frontend_Node;

   procedure Set_Frontend_Node (N : Node_Id; V : Node_Id) is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Destination_Port
        or else Table (Node_Id (N)).Kind = K_Type_Definition);

      Table (Node_Id (N)).L (2)  := Int (V);
   end Set_Frontend_Node;

   function Thread_Location (N : Node_Id) return Name_Id is
   begin
      pragma Assert
        (False or else Table (Node_Id (N)).Kind = K_Destination_Port);

      return Name_Id (Table (Node_Id (N)).L (1));
   end Thread_Location;

   procedure Set_Thread_Location (N : Node_Id; V : Name_Id) is
   begin
      pragma Assert
        (False or else Table (Node_Id (N)).Kind = K_Destination_Port);

      Table (Node_Id (N)).L (1)  := Int (V);
   end Set_Thread_Location;

   function Thread_Name (N : Node_Id) return Name_Id is
   begin
      pragma Assert
        (False or else Table (Node_Id (N)).Kind = K_Destination_Port);

      return Name_Id (Table (Node_Id (N)).L (3));
   end Thread_Name;

   procedure Set_Thread_Name (N : Node_Id; V : Name_Id) is
   begin
      pragma Assert
        (False or else Table (Node_Id (N)).Kind = K_Destination_Port);

      Table (Node_Id (N)).L (3)  := Int (V);
   end Set_Thread_Name;

   function Process_Name (N : Node_Id) return Name_Id is
   begin
      pragma Assert
        (False or else Table (Node_Id (N)).Kind = K_Destination_Port);

      return Name_Id (Table (Node_Id (N)).L (6));
   end Process_Name;

   procedure Set_Process_Name (N : Node_Id; V : Name_Id) is
   begin
      pragma Assert
        (False or else Table (Node_Id (N)).Kind = K_Destination_Port);

      Table (Node_Id (N)).L (6)  := Int (V);
   end Set_Process_Name;

   function Call_Name (N : Node_Id) return Name_Id is
   begin
      pragma Assert
        (False or else Table (Node_Id (N)).Kind = K_Subprogram_Call);

      return Name_Id (Table (Node_Id (N)).L (2));
   end Call_Name;

   procedure Set_Call_Name (N : Node_Id; V : Name_Id) is
   begin
      pragma Assert
        (False or else Table (Node_Id (N)).Kind = K_Subprogram_Call);

      Table (Node_Id (N)).L (2)  := Int (V);
   end Set_Call_Name;

   function Corresponding_Subprogram (N : Node_Id) return Node_Id is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Subprogram_Call
        or else Table (Node_Id (N)).Kind = K_Subprogram_Reference);

      return Node_Id (Table (Node_Id (N)).L (3));
   end Corresponding_Subprogram;

   procedure Set_Corresponding_Subprogram (N : Node_Id; V : Node_Id) is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Subprogram_Call
        or else Table (Node_Id (N)).Kind = K_Subprogram_Reference);

      Table (Node_Id (N)).L (3)  := Int (V);
   end Set_Corresponding_Subprogram;

   function Value_Name (N : Node_Id) return Value_Id is
   begin
      pragma Assert
        (False or else Table (Node_Id (N)).Kind = K_Symbolic_Value);

      return Value_Id (Table (Node_Id (N)).L (1));
   end Value_Name;

   procedure Set_Value_Name (N : Node_Id; V : Value_Id) is
   begin
      pragma Assert
        (False or else Table (Node_Id (N)).Kind = K_Symbolic_Value);

      Table (Node_Id (N)).L (1)  := Int (V);
   end Set_Value_Name;

   function Subtypes (N : Node_Id) return List_Id is
   begin
      pragma Assert
        (False or else Table (Node_Id (N)).Kind = K_Type_Definition);

      return List_Id (Table (Node_Id (N)).L (3));
   end Subtypes;

   procedure Set_Subtypes (N : Node_Id; V : List_Id) is
   begin
      pragma Assert
        (False or else Table (Node_Id (N)).Kind = K_Type_Definition);

      Table (Node_Id (N)).L (3)  := Int (V);
   end Set_Subtypes;

   function Predefined_Simple_Type (N : Node_Id) return Byte is
   begin
      pragma Assert
        (False or else Table (Node_Id (N)).Kind = K_Type_Definition);

      return Byte (Table (Node_Id (N)).O (1));
   end Predefined_Simple_Type;

   procedure Set_Predefined_Simple_Type (N : Node_Id; V : Byte) is
   begin
      pragma Assert
        (False or else Table (Node_Id (N)).Kind = K_Type_Definition);

      Table (Node_Id (N)).O (1)  := Byte (V);
   end Set_Predefined_Simple_Type;

   function Maximal_Length (N : Node_Id) return Value_Id is
   begin
      pragma Assert
        (False or else Table (Node_Id (N)).Kind = K_Type_Definition);

      return Value_Id (Table (Node_Id (N)).L (8));
   end Maximal_Length;

   procedure Set_Maximal_Length (N : Node_Id; V : Value_Id) is
   begin
      pragma Assert
        (False or else Table (Node_Id (N)).Kind = K_Type_Definition);

      Table (Node_Id (N)).L (8)  := Int (V);
   end Set_Maximal_Length;

   function Symbolic_Values (N : Node_Id) return List_Id is
   begin
      pragma Assert
        (False or else Table (Node_Id (N)).Kind = K_Type_Definition);

      return List_Id (Table (Node_Id (N)).L (9));
   end Symbolic_Values;

   procedure Set_Symbolic_Values (N : Node_Id; V : List_Id) is
   begin
      pragma Assert
        (False or else Table (Node_Id (N)).Kind = K_Type_Definition);

      Table (Node_Id (N)).L (9)  := Int (V);
   end Set_Symbolic_Values;

   function Subprograms (N : Node_Id) return List_Id is
   begin
      pragma Assert
        (False or else Table (Node_Id (N)).Kind = K_Type_Definition);

      return List_Id (Table (Node_Id (N)).L (10));
   end Subprograms;

   procedure Set_Subprograms (N : Node_Id; V : List_Id) is
   begin
      pragma Assert
        (False or else Table (Node_Id (N)).Kind = K_Type_Definition);

      Table (Node_Id (N)).L (10)  := Int (V);
   end Set_Subprograms;

   function Access_Protocol (N : Node_Id) return Name_Id is
   begin
      pragma Assert
        (False or else Table (Node_Id (N)).Kind = K_Type_Definition);

      return Name_Id (Table (Node_Id (N)).L (11));
   end Access_Protocol;

   procedure Set_Access_Protocol (N : Node_Id; V : Name_Id) is
   begin
      pragma Assert
        (False or else Table (Node_Id (N)).Kind = K_Type_Definition);

      Table (Node_Id (N)).L (11)  := Int (V);
   end Set_Access_Protocol;

   function Updating_Policy (N : Node_Id) return Name_Id is
   begin
      pragma Assert
        (False or else Table (Node_Id (N)).Kind = K_Type_Definition);

      return Name_Id (Table (Node_Id (N)).L (12));
   end Updating_Policy;

   procedure Set_Updating_Policy (N : Node_Id; V : Name_Id) is
   begin
      pragma Assert
        (False or else Table (Node_Id (N)).Kind = K_Type_Definition);

      Table (Node_Id (N)).L (12)  := Int (V);
   end Set_Updating_Policy;

   procedure W_Node (N : Node_Id) is
   begin
      case Kind (N) is
      when K_Identifier =>
         W_Identifier (Node_Id (N));
      when K_Gaia_Definition =>
         W_Gaia_Definition (Node_Id (N));
      when K_Scoped_Name =>
         W_Scoped_Name (Node_Id (N));
      when K_Property =>
         W_Property (Node_Id (N));
      when K_Gaia_Scope_Definition =>
         W_Gaia_Scope_Definition (Node_Id (N));
      when K_Package_Name_Element =>
         W_Package_Name_Element (Node_Id (N));
      when K_Root_Node =>
         W_Root_Node (Node_Id (N));
      when K_Distributed_Application =>
         W_Distributed_Application (Node_Id (N));
      when K_Declaration_List =>
         W_Declaration_List (List_Id (N));
      when K_Namespace =>
         W_Namespace (Node_Id (N));
      when K_Call_Sequence =>
         W_Call_Sequence (Node_Id (N));
      when K_Subprogram =>
         W_Subprogram (Node_Id (N));
      when K_Thread =>
         W_Thread (Node_Id (N));
      when K_Process =>
         W_Process (Node_Id (N));
      when K_Parameter =>
         W_Parameter (Node_Id (N));
      when K_Parameter_Connection =>
         W_Parameter_Connection (Node_Id (N));
      when K_Thread_Reference =>
         W_Thread_Reference (Node_Id (N));
      when K_Port =>
         W_Port (Node_Id (N));
      when K_Destination_Port =>
         W_Destination_Port (Node_Id (N));
      when K_Variable_Definition =>
         W_Variable_Definition (Node_Id (N));
      when K_Subprogram_Call =>
         W_Subprogram_Call (Node_Id (N));
      when K_Subprogram_Reference =>
         W_Subprogram_Reference (Node_Id (N));
      when K_Symbolic_Value =>
         W_Symbolic_Value (Node_Id (N));
      when K_Type_Definition =>
         W_Type_Definition (Node_Id (N));
      when others =>
         null;
      end case;
   end W_Node;

   procedure W_Identifier (N : Node_Id) is
   begin
      W_Node_Header (Node_Id (N));
      W_Node_Attribute
        ("Next_Node",
         "Node_Id",
         Image (Next_Node (N)),
         Int (Next_Node (N)));
      W_Node_Attribute ("Name", "Name_Id", Image (Name (N)));
      W_Node_Attribute
        ("Backend_Node",
         "Node_Id",
         Image (Backend_Node (N)),
         Int (Backend_Node (N)));
      W_Node_Attribute
        ("Corresponding_Entity",
         "Node_Id",
         Image (Corresponding_Entity (N)),
         Int (Corresponding_Entity (N)));
   end W_Identifier;

   procedure W_Gaia_Definition (N : Node_Id) is
   begin
      W_Node_Header (Node_Id (N));
      W_Node_Attribute
        ("Next_Node",
         "Node_Id",
         Image (Next_Node (N)),
         Int (Next_Node (N)));
      W_Node_Attribute
        ("Identifier",
         "Node_Id",
         Image (Identifier (N)),
         Int (Identifier (N)));
   end W_Gaia_Definition;

   procedure W_Scoped_Name (N : Node_Id) is
   begin
      W_Node_Header (Node_Id (N));
      W_Node_Attribute
        ("Next_Node",
         "Node_Id",
         Image (Next_Node (N)),
         Int (Next_Node (N)));
      W_Node_Attribute
        ("Identifier",
         "Node_Id",
         Image (Identifier (N)),
         Int (Identifier (N)));
      W_Node_Attribute
        ("Parent_Scoped_Name",
         "Node_Id",
         Image (Parent_Scoped_Name (N)),
         Int (Parent_Scoped_Name (N)));
      W_Node_Attribute
        ("Reference",
         "Node_Id",
         Image (Reference (N)),
         Int (Reference (N)));
   end W_Scoped_Name;

   procedure W_Property (N : Node_Id) is
   begin
      W_Node_Header (Node_Id (N));
      W_Node_Attribute
        ("Next_Node",
         "Node_Id",
         Image (Next_Node (N)),
         Int (Next_Node (N)));
      W_Node_Attribute ("Entity", "Name_Id", Image (Entity (N)));
      W_Node_Attribute
        ("Value",
         "Node_Id",
         Image (Value (N)),
         Int (Value (N)));
   end W_Property;

   procedure W_Gaia_Scope_Definition (N : Node_Id) is
   begin
      W_Node_Header (Node_Id (N));
      W_Node_Attribute
        ("Next_Node",
         "Node_Id",
         Image (Next_Node (N)),
         Int (Next_Node (N)));
      W_Node_Attribute
        ("Identifier",
         "Node_Id",
         Image (Identifier (N)),
         Int (Identifier (N)));
      W_Node_Attribute
        ("Scoped_Name",
         "Node_Id",
         Image (Scoped_Name (N)),
         Int (Scoped_Name (N)));
      W_Node_Attribute
        ("Properties",
         "List_Id",
         Image (Properties (N)),
         Int (Properties (N)));
   end W_Gaia_Scope_Definition;

   procedure W_Package_Name_Element (N : Node_Id) is
   begin
      W_Node_Header (Node_Id (N));
      W_Node_Attribute
        ("Next_Node",
         "Node_Id",
         Image (Next_Node (N)),
         Int (Next_Node (N)));
      W_Node_Attribute
        ("Identifier",
         "Node_Id",
         Image (Identifier (N)),
         Int (Identifier (N)));
   end W_Package_Name_Element;

   procedure W_Root_Node (N : Node_Id) is
   begin
      W_Node_Header (Node_Id (N));
      W_Node_Attribute
        ("Next_Node",
         "Node_Id",
         Image (Next_Node (N)),
         Int (Next_Node (N)));
      W_Node_Attribute
        ("Identifier",
         "Node_Id",
         Image (Identifier (N)),
         Int (Identifier (N)));
      W_Node_Attribute
        ("Scoped_Name",
         "Node_Id",
         Image (Scoped_Name (N)),
         Int (Scoped_Name (N)));
      W_Node_Attribute
        ("Properties",
         "List_Id",
         Image (Properties (N)),
         Int (Properties (N)));
      W_Node_Attribute
        ("Namespaces",
         "List_Id",
         Image (Namespaces (N)),
         Int (Namespaces (N)));
      W_Node_Attribute
        ("Node_Location",
         "Name_Id",
         Image (Node_Location (N)));
      W_Node_Attribute ("Port_Number", "Value_Id", Image (Port_Number (N)));
      W_Node_Attribute ("Thread_Number", "Int", Image (Thread_Number (N)));
      W_Node_Attribute
        ("Priority_Managed",
         "Boolean",
         Image (Priority_Managed (N)));
   end W_Root_Node;

   procedure W_Distributed_Application (N : Node_Id) is
   begin
      W_Node_Header (Node_Id (N));
      W_Node_Attribute
        ("Next_Node",
         "Node_Id",
         Image (Next_Node (N)),
         Int (Next_Node (N)));
      W_Node_Attribute
        ("Identifier",
         "Node_Id",
         Image (Identifier (N)),
         Int (Identifier (N)));
      W_Node_Attribute
        ("Root_Nodes",
         "List_Id",
         Image (Root_Nodes (N)),
         Int (Root_Nodes (N)));
      W_Node_Attribute ("Protocol", "Name_Id", Image (Protocol (N)));
   end W_Distributed_Application;

   procedure W_Declaration_List (N : List_Id) is
   begin
      W_Node_Header (Node_Id (N));
      W_Node_Attribute
        ("First_Node",
         "Node_Id",
         Image (First_Node (N)),
         Int (First_Node (N)));
      W_Node_Attribute
        ("Last_Node",
         "Node_Id",
         Image (Last_Node (N)),
         Int (Last_Node (N)));
   end W_Declaration_List;

   procedure W_Namespace (N : Node_Id) is
   begin
      W_Node_Header (Node_Id (N));
      W_Node_Attribute
        ("Next_Node",
         "Node_Id",
         Image (Next_Node (N)),
         Int (Next_Node (N)));
      W_Node_Attribute
        ("Identifier",
         "Node_Id",
         Image (Identifier (N)),
         Int (Identifier (N)));
      W_Node_Attribute
        ("Scoped_Name",
         "Node_Id",
         Image (Scoped_Name (N)),
         Int (Scoped_Name (N)));
      W_Node_Attribute
        ("Properties",
         "List_Id",
         Image (Properties (N)),
         Int (Properties (N)));
      W_Node_Attribute
        ("Public_Declarations",
         "List_Id",
         Image (Public_Declarations (N)),
         Int (Public_Declarations (N)));
      W_Node_Attribute
        ("Private_Declarations",
         "List_Id",
         Image (Private_Declarations (N)),
         Int (Private_Declarations (N)));
   end W_Namespace;

   procedure W_Call_Sequence (N : Node_Id) is
   begin
      W_Node_Header (Node_Id (N));
      W_Node_Attribute
        ("Next_Node",
         "Node_Id",
         Image (Next_Node (N)),
         Int (Next_Node (N)));
      W_Node_Attribute
        ("Identifier",
         "Node_Id",
         Image (Identifier (N)),
         Int (Identifier (N)));
      W_Node_Attribute
        ("Scoped_Name",
         "Node_Id",
         Image (Scoped_Name (N)),
         Int (Scoped_Name (N)));
      W_Node_Attribute
        ("Properties",
         "List_Id",
         Image (Properties (N)),
         Int (Properties (N)));
      W_Node_Attribute
        ("Statements",
         "List_Id",
         Image (Statements (N)),
         Int (Statements (N)));
   end W_Call_Sequence;

   procedure W_Subprogram (N : Node_Id) is
   begin
      W_Node_Header (Node_Id (N));
      W_Node_Attribute
        ("Next_Node",
         "Node_Id",
         Image (Next_Node (N)),
         Int (Next_Node (N)));
      W_Node_Attribute
        ("Identifier",
         "Node_Id",
         Image (Identifier (N)),
         Int (Identifier (N)));
      W_Node_Attribute
        ("Scoped_Name",
         "Node_Id",
         Image (Scoped_Name (N)),
         Int (Scoped_Name (N)));
      W_Node_Attribute
        ("Properties",
         "List_Id",
         Image (Properties (N)),
         Int (Properties (N)));
      W_Node_Attribute
        ("Variables",
         "List_Id",
         Image (Variables (N)),
         Int (Variables (N)));
      W_Node_Attribute
        ("Parameters",
         "List_Id",
         Image (Parameters (N)),
         Int (Parameters (N)));
      W_Node_Attribute
        ("Implemented_By",
         "Name_Id",
         Image (Implemented_By (N)));
      W_Node_Attribute
        ("Implementation_Language",
         "Name_Id",
         Image (Implementation_Language (N)));
      W_Node_Attribute
        ("Call_Sequences",
         "List_Id",
         Image (Call_Sequences (N)),
         Int (Call_Sequences (N)));
      W_Node_Attribute
        ("Connections",
         "List_Id",
         Image (Connections (N)),
         Int (Connections (N)));
      W_Node_Attribute
        ("Owner_Data",
         "Node_Id",
         Image (Owner_Data (N)),
         Int (Owner_Data (N)));
   end W_Subprogram;

   procedure W_Thread (N : Node_Id) is
   begin
      W_Node_Header (Node_Id (N));
      W_Node_Attribute
        ("Next_Node",
         "Node_Id",
         Image (Next_Node (N)),
         Int (Next_Node (N)));
      W_Node_Attribute
        ("Identifier",
         "Node_Id",
         Image (Identifier (N)),
         Int (Identifier (N)));
      W_Node_Attribute
        ("Scoped_Name",
         "Node_Id",
         Image (Scoped_Name (N)),
         Int (Scoped_Name (N)));
      W_Node_Attribute
        ("Properties",
         "List_Id",
         Image (Properties (N)),
         Int (Properties (N)));
      W_Node_Attribute
        ("Variables",
         "List_Id",
         Image (Variables (N)),
         Int (Variables (N)));
      W_Node_Attribute
        ("Call_Sequences",
         "List_Id",
         Image (Call_Sequences (N)),
         Int (Call_Sequences (N)));
      W_Node_Attribute
        ("Connections",
         "List_Id",
         Image (Connections (N)),
         Int (Connections (N)));
      W_Node_Attribute
        ("Ports",
         "List_Id",
         Image (Ports (N)),
         Int (Ports (N)));
      W_Node_Attribute ("Period", "Value_Id", Image (Period (N)));
      W_Node_Attribute ("Priority", "Value_Id", Image (Priority (N)));
      W_Node_Attribute
        ("Storage_Size",
         "Value_Id",
         Image (Storage_Size (N)));
      W_Node_Attribute
        ("Access_Provided_By",
         "Node_Id",
         Image (Access_Provided_By (N)),
         Int (Access_Provided_By (N)));
      W_Node_Attribute ("Unique", "Boolean", Image (Unique (N)));
      W_Node_Attribute ("Sources_Number", "Int", Image (Sources_Number (N)));
   end W_Thread;

   procedure W_Process (N : Node_Id) is
   begin
      W_Node_Header (Node_Id (N));
      W_Node_Attribute
        ("Next_Node",
         "Node_Id",
         Image (Next_Node (N)),
         Int (Next_Node (N)));
      W_Node_Attribute
        ("Identifier",
         "Node_Id",
         Image (Identifier (N)),
         Int (Identifier (N)));
      W_Node_Attribute
        ("Scoped_Name",
         "Node_Id",
         Image (Scoped_Name (N)),
         Int (Scoped_Name (N)));
      W_Node_Attribute
        ("Properties",
         "List_Id",
         Image (Properties (N)),
         Int (Properties (N)));
      W_Node_Attribute
        ("Variables",
         "List_Id",
         Image (Variables (N)),
         Int (Variables (N)));
      W_Node_Attribute
        ("Connections",
         "List_Id",
         Image (Connections (N)),
         Int (Connections (N)));
      W_Node_Attribute
        ("Ports",
         "List_Id",
         Image (Ports (N)),
         Int (Ports (N)));
      W_Node_Attribute
        ("Threads",
         "List_Id",
         Image (Threads (N)),
         Int (Threads (N)));
   end W_Process;

   procedure W_Parameter (N : Node_Id) is
   begin
      W_Node_Header (Node_Id (N));
      W_Node_Attribute
        ("Next_Node",
         "Node_Id",
         Image (Next_Node (N)),
         Int (Next_Node (N)));
      W_Node_Attribute
        ("Identifier",
         "Node_Id",
         Image (Identifier (N)),
         Int (Identifier (N)));
      W_Node_Attribute
        ("Scoped_Name",
         "Node_Id",
         Image (Scoped_Name (N)),
         Int (Scoped_Name (N)));
      W_Node_Attribute
        ("Properties",
         "List_Id",
         Image (Properties (N)),
         Int (Properties (N)));
      W_Node_Attribute ("Is_In", "Boolean", Image (Is_In (N)));
      W_Node_Attribute ("Is_Out", "Boolean", Image (Is_Out (N)));
      W_Node_Attribute
        ("Type_Spec",
         "Node_Id",
         Image (Type_Spec (N)),
         Int (Type_Spec (N)));
   end W_Parameter;

   procedure W_Parameter_Connection (N : Node_Id) is
   begin
      W_Node_Header (Node_Id (N));
      W_Node_Attribute
        ("Next_Node",
         "Node_Id",
         Image (Next_Node (N)),
         Int (Next_Node (N)));
      W_Node_Attribute
        ("Identifier",
         "Node_Id",
         Image (Identifier (N)),
         Int (Identifier (N)));
      W_Node_Attribute
        ("Scoped_Name",
         "Node_Id",
         Image (Scoped_Name (N)),
         Int (Scoped_Name (N)));
      W_Node_Attribute
        ("Properties",
         "List_Id",
         Image (Properties (N)),
         Int (Properties (N)));
      W_Node_Attribute
        ("Source",
         "Node_Id",
         Image (Source (N)),
         Int (Source (N)));
      W_Node_Attribute
        ("Simple_Source",
         "Name_Id",
         Image (Simple_Source (N)));
      W_Node_Attribute
        ("Destination",
         "Node_Id",
         Image (Destination (N)),
         Int (Destination (N)));
      W_Node_Attribute
        ("Simple_Destination",
         "Name_Id",
         Image (Simple_Destination (N)));
      W_Node_Attribute
        ("Source_Subprogram_Call",
         "Node_Id",
         Image (Source_Subprogram_Call (N)),
         Int (Source_Subprogram_Call (N)));
      W_Node_Attribute
        ("Destination_Subprogram_Call",
         "Node_Id",
         Image (Destination_Subprogram_Call (N)),
         Int (Destination_Subprogram_Call (N)));
   end W_Parameter_Connection;

   procedure W_Thread_Reference (N : Node_Id) is
   begin
      W_Node_Header (Node_Id (N));
      W_Node_Attribute
        ("Next_Node",
         "Node_Id",
         Image (Next_Node (N)),
         Int (Next_Node (N)));
      W_Node_Attribute
        ("Identifier",
         "Node_Id",
         Image (Identifier (N)),
         Int (Identifier (N)));
      W_Node_Attribute
        ("Corresponding_Thread",
         "Node_Id",
         Image (Corresponding_Thread (N)),
         Int (Corresponding_Thread (N)));
   end W_Thread_Reference;

   procedure W_Port (N : Node_Id) is
   begin
      W_Node_Header (Node_Id (N));
      W_Node_Attribute
        ("Next_Node",
         "Node_Id",
         Image (Next_Node (N)),
         Int (Next_Node (N)));
      W_Node_Attribute
        ("Identifier",
         "Node_Id",
         Image (Identifier (N)),
         Int (Identifier (N)));
      W_Node_Attribute
        ("Scoped_Name",
         "Node_Id",
         Image (Scoped_Name (N)),
         Int (Scoped_Name (N)));
      W_Node_Attribute
        ("Properties",
         "List_Id",
         Image (Properties (N)),
         Int (Properties (N)));
      W_Node_Attribute ("Is_In", "Boolean", Image (Is_In (N)));
      W_Node_Attribute ("Is_Out", "Boolean", Image (Is_Out (N)));
      W_Node_Attribute
        ("Type_Spec",
         "Node_Id",
         Image (Type_Spec (N)),
         Int (Type_Spec (N)));
      W_Node_Attribute ("Fifo_Size", "Value_Id", Image (Fifo_Size (N)));
      W_Node_Attribute ("Trigger", "Boolean", Image (Trigger (N)));
      W_Node_Attribute
        ("Destinations",
         "List_Id",
         Image (Destinations (N)),
         Int (Destinations (N)));
   end W_Port;

   procedure W_Destination_Port (N : Node_Id) is
   begin
      W_Node_Header (Node_Id (N));
      W_Node_Attribute
        ("Next_Node",
         "Node_Id",
         Image (Next_Node (N)),
         Int (Next_Node (N)));
      W_Node_Attribute
        ("Identifier",
         "Node_Id",
         Image (Identifier (N)),
         Int (Identifier (N)));
      W_Node_Attribute ("Port_Number", "Value_Id", Image (Port_Number (N)));
      W_Node_Attribute
        ("Frontend_Node",
         "Node_Id",
         Image (Frontend_Node (N)),
         Int (Frontend_Node (N)));
      W_Node_Attribute
        ("Thread_Location",
         "Name_Id",
         Image (Thread_Location (N)));
      W_Node_Attribute ("Thread_Name", "Name_Id", Image (Thread_Name (N)));
      W_Node_Attribute ("Process_Name", "Name_Id", Image (Process_Name (N)));
   end W_Destination_Port;

   procedure W_Variable_Definition (N : Node_Id) is
   begin
      W_Node_Header (Node_Id (N));
      W_Node_Attribute
        ("Next_Node",
         "Node_Id",
         Image (Next_Node (N)),
         Int (Next_Node (N)));
      W_Node_Attribute
        ("Identifier",
         "Node_Id",
         Image (Identifier (N)),
         Int (Identifier (N)));
      W_Node_Attribute
        ("Scoped_Name",
         "Node_Id",
         Image (Scoped_Name (N)),
         Int (Scoped_Name (N)));
      W_Node_Attribute
        ("Properties",
         "List_Id",
         Image (Properties (N)),
         Int (Properties (N)));
      W_Node_Attribute
        ("Access_Provided_By",
         "Node_Id",
         Image (Access_Provided_By (N)),
         Int (Access_Provided_By (N)));
      W_Node_Attribute
        ("Type_Spec",
         "Node_Id",
         Image (Type_Spec (N)),
         Int (Type_Spec (N)));
   end W_Variable_Definition;

   procedure W_Subprogram_Call (N : Node_Id) is
   begin
      W_Node_Header (Node_Id (N));
      W_Node_Attribute
        ("Next_Node",
         "Node_Id",
         Image (Next_Node (N)),
         Int (Next_Node (N)));
      W_Node_Attribute
        ("Identifier",
         "Node_Id",
         Image (Identifier (N)),
         Int (Identifier (N)));
      W_Node_Attribute
        ("Scoped_Name",
         "Node_Id",
         Image (Scoped_Name (N)),
         Int (Scoped_Name (N)));
      W_Node_Attribute
        ("Properties",
         "List_Id",
         Image (Properties (N)),
         Int (Properties (N)));
      W_Node_Attribute
        ("Parameters",
         "List_Id",
         Image (Parameters (N)),
         Int (Parameters (N)));
      W_Node_Attribute
        ("Access_Provided_By",
         "Node_Id",
         Image (Access_Provided_By (N)),
         Int (Access_Provided_By (N)));
      W_Node_Attribute ("Call_Name", "Name_Id", Image (Call_Name (N)));
      W_Node_Attribute
        ("Corresponding_Subprogram",
         "Node_Id",
         Image (Corresponding_Subprogram (N)),
         Int (Corresponding_Subprogram (N)));
   end W_Subprogram_Call;

   procedure W_Subprogram_Reference (N : Node_Id) is
   begin
      W_Node_Header (Node_Id (N));
      W_Node_Attribute
        ("Next_Node",
         "Node_Id",
         Image (Next_Node (N)),
         Int (Next_Node (N)));
      W_Node_Attribute
        ("Identifier",
         "Node_Id",
         Image (Identifier (N)),
         Int (Identifier (N)));
      W_Node_Attribute
        ("Corresponding_Subprogram",
         "Node_Id",
         Image (Corresponding_Subprogram (N)),
         Int (Corresponding_Subprogram (N)));
   end W_Subprogram_Reference;

   procedure W_Symbolic_Value (N : Node_Id) is
   begin
      W_Node_Header (Node_Id (N));
      W_Node_Attribute
        ("Next_Node",
         "Node_Id",
         Image (Next_Node (N)),
         Int (Next_Node (N)));
      W_Node_Attribute ("Value_Name", "Value_Id", Image (Value_Name (N)));
   end W_Symbolic_Value;

   procedure W_Type_Definition (N : Node_Id) is
   begin
      W_Node_Header (Node_Id (N));
      W_Node_Attribute
        ("Next_Node",
         "Node_Id",
         Image (Next_Node (N)),
         Int (Next_Node (N)));
      W_Node_Attribute
        ("Identifier",
         "Node_Id",
         Image (Identifier (N)),
         Int (Identifier (N)));
      W_Node_Attribute
        ("Scoped_Name",
         "Node_Id",
         Image (Scoped_Name (N)),
         Int (Scoped_Name (N)));
      W_Node_Attribute
        ("Properties",
         "List_Id",
         Image (Properties (N)),
         Int (Properties (N)));
      W_Node_Attribute
        ("Frontend_Node",
         "Node_Id",
         Image (Frontend_Node (N)),
         Int (Frontend_Node (N)));
      W_Node_Attribute
        ("Subtypes",
         "List_Id",
         Image (Subtypes (N)),
         Int (Subtypes (N)));
      W_Node_Attribute
        ("Predefined_Simple_Type",
         "Byte",
         Image (Predefined_Simple_Type (N)));
      W_Node_Attribute
        ("Maximal_Length",
         "Value_Id",
         Image (Maximal_Length (N)));
      W_Node_Attribute
        ("Symbolic_Values",
         "List_Id",
         Image (Symbolic_Values (N)),
         Int (Symbolic_Values (N)));
      W_Node_Attribute
        ("Subprograms",
         "List_Id",
         Image (Subprograms (N)),
         Int (Subprograms (N)));
      W_Node_Attribute
        ("Access_Protocol",
         "Name_Id",
         Image (Access_Protocol (N)));
      W_Node_Attribute
        ("Updating_Policy",
         "Name_Id",
         Image (Updating_Policy (N)));
   end W_Type_Definition;

end Gaia.Processor.Nodes;