-----------------------------------------------------------
---------------------
--                                                                          --
--                           OCARINA COMPONENTS                             --
--                                                                          --
--                        G A I A . P N . 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.Pn.Debug; use Gaia.Pn.Debug;

package body Gaia.Pn.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_Pn_Definition
        or else Table (Node_Id (N)).Kind = K_Scoped_Name
        or else Table (Node_Id (N)).Kind = K_Encapsulate_List_Node
        or else Table (Node_Id (N)).Kind = K_Pn_Scope_Definition
        or else Table (Node_Id (N)).Kind = K_Position
        or else Table (Node_Id (N)).Kind = K_Token
        or else Table (Node_Id (N)).Kind = K_Guard
        or else Table (Node_Id (N)).Kind = K_Place_Declaration
        or else Table (Node_Id (N)).Kind = K_Transition_Declaration
        or else Table (Node_Id (N)).Kind = K_Connect_Statement
        or else Table (Node_Id (N)).Kind = K_Place_Fusion
        or else Table (Node_Id (N)).Kind = K_Transition_Fusion
        or else Table (Node_Id (N)).Kind = K_Loop_Declaration
        or else Table (Node_Id (N)).Kind = K_Fifo_Extremities
        or else Table (Node_Id (N)).Kind = K_Symbolic_Value
        or else Table (Node_Id (N)).Kind = K_Color_Variable
        or else Table (Node_Id (N)).Kind = K_Color_Declaration
        or else Table (Node_Id (N)).Kind = K_Colored_Token
        or else Table (Node_Id (N)).Kind = K_Include_Call
        or else Table (Node_Id (N)).Kind = K_Container
        or else Table (Node_Id (N)).Kind = K_Fonctionnal_Entity
        or else Table (Node_Id (N)).Kind = K_Thread_Box
        or else Table (Node_Id (N)).Kind = K_Root_Node
        or else Table (Node_Id (N)).Kind = K_Subprogram_Declaration);

      return Node_Id (Table (Node_Id (N)).L (2));
   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_Pn_Definition
        or else Table (Node_Id (N)).Kind = K_Scoped_Name
        or else Table (Node_Id (N)).Kind = K_Encapsulate_List_Node
        or else Table (Node_Id (N)).Kind = K_Pn_Scope_Definition
        or else Table (Node_Id (N)).Kind = K_Position
        or else Table (Node_Id (N)).Kind = K_Token
        or else Table (Node_Id (N)).Kind = K_Guard
        or else Table (Node_Id (N)).Kind = K_Place_Declaration
        or else Table (Node_Id (N)).Kind = K_Transition_Declaration
        or else Table (Node_Id (N)).Kind = K_Connect_Statement
        or else Table (Node_Id (N)).Kind = K_Place_Fusion
        or else Table (Node_Id (N)).Kind = K_Transition_Fusion
        or else Table (Node_Id (N)).Kind = K_Loop_Declaration
        or else Table (Node_Id (N)).Kind = K_Fifo_Extremities
        or else Table (Node_Id (N)).Kind = K_Symbolic_Value
        or else Table (Node_Id (N)).Kind = K_Color_Variable
        or else Table (Node_Id (N)).Kind = K_Color_Declaration
        or else Table (Node_Id (N)).Kind = K_Colored_Token
        or else Table (Node_Id (N)).Kind = K_Include_Call
        or else Table (Node_Id (N)).Kind = K_Container
        or else Table (Node_Id (N)).Kind = K_Fonctionnal_Entity
        or else Table (Node_Id (N)).Kind = K_Thread_Box
        or else Table (Node_Id (N)).Kind = K_Root_Node
        or else Table (Node_Id (N)).Kind = K_Subprogram_Declaration);

      Table (Node_Id (N)).L (2)  := 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);

      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);

      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);

      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);

      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 Gaia_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 (3));
   end Gaia_Node;

   procedure Set_Gaia_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 (3)  := Int (V);
   end Set_Gaia_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 (4));
   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 (4)  := 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_Pn_Definition
        or else Table (Node_Id (N)).Kind = K_Scoped_Name
        or else Table (Node_Id (N)).Kind = K_Pn_Scope_Definition
        or else Table (Node_Id (N)).Kind = K_Place_Declaration
        or else Table (Node_Id (N)).Kind = K_Transition_Declaration
        or else Table (Node_Id (N)).Kind = K_Color_Variable
        or else Table (Node_Id (N)).Kind = K_Color_Declaration
        or else Table (Node_Id (N)).Kind = K_Colored_Token
        or else Table (Node_Id (N)).Kind = K_Container
        or else Table (Node_Id (N)).Kind = K_Fonctionnal_Entity
        or else Table (Node_Id (N)).Kind = K_Thread_Box
        or else Table (Node_Id (N)).Kind = K_Root_Node);

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

   procedure Set_Identifier (N : Node_Id; V : Node_Id) is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Pn_Definition
        or else Table (Node_Id (N)).Kind = K_Scoped_Name
        or else Table (Node_Id (N)).Kind = K_Pn_Scope_Definition
        or else Table (Node_Id (N)).Kind = K_Place_Declaration
        or else Table (Node_Id (N)).Kind = K_Transition_Declaration
        or else Table (Node_Id (N)).Kind = K_Color_Variable
        or else Table (Node_Id (N)).Kind = K_Color_Declaration
        or else Table (Node_Id (N)).Kind = K_Colored_Token
        or else Table (Node_Id (N)).Kind = K_Container
        or else Table (Node_Id (N)).Kind = K_Fonctionnal_Entity
        or else Table (Node_Id (N)).Kind = K_Thread_Box
        or else Table (Node_Id (N)).Kind = K_Root_Node);

      Table (Node_Id (N)).L (1)  := 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 (3));
   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 (3)  := 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 (4));
   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 (4)  := Int (V);
   end Set_Reference;

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

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

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

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

   function Scoped_Name (N : Node_Id) return Node_Id is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Pn_Scope_Definition
        or else Table (Node_Id (N)).Kind = K_Place_Declaration
        or else Table (Node_Id (N)).Kind = K_Transition_Declaration
        or else Table (Node_Id (N)).Kind = K_Color_Variable
        or else Table (Node_Id (N)).Kind = K_Color_Declaration
        or else Table (Node_Id (N)).Kind = K_Colored_Token
        or else Table (Node_Id (N)).Kind = K_Container
        or else Table (Node_Id (N)).Kind = K_Fonctionnal_Entity
        or else Table (Node_Id (N)).Kind = K_Thread_Box
        or else Table (Node_Id (N)).Kind = K_Root_Node);

      return Node_Id (Table (Node_Id (N)).L (3));
   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_Pn_Scope_Definition
        or else Table (Node_Id (N)).Kind = K_Place_Declaration
        or else Table (Node_Id (N)).Kind = K_Transition_Declaration
        or else Table (Node_Id (N)).Kind = K_Color_Variable
        or else Table (Node_Id (N)).Kind = K_Color_Declaration
        or else Table (Node_Id (N)).Kind = K_Colored_Token
        or else Table (Node_Id (N)).Kind = K_Container
        or else Table (Node_Id (N)).Kind = K_Fonctionnal_Entity
        or else Table (Node_Id (N)).Kind = K_Thread_Box
        or else Table (Node_Id (N)).Kind = K_Root_Node);

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

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

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

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

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

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

      return Value_Id (Table (Node_Id (N)).L (3));
   end Y_Value;

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

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

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

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

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

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

   function Color (N : Node_Id) return Node_Id is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Token
        or else Table (Node_Id (N)).Kind = K_Guard);

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

   procedure Set_Color (N : Node_Id; V : Node_Id) is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Token
        or else Table (Node_Id (N)).Kind = K_Guard);

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

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

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

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

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

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

      return Value_Id (Table (Node_Id (N)).L (5));
   end Operator;

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

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

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

      return List_Id (Table (Node_Id (N)).L (4));
   end Tokens;

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

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

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

      return List_Id (Table (Node_Id (N)).L (5));
   end Domains;

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

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

   function Position (N : Node_Id) return Node_Id is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Place_Declaration
        or else Table (Node_Id (N)).Kind = K_Transition_Declaration);

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

   procedure Set_Position (N : Node_Id; V : Node_Id) is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Place_Declaration
        or else Table (Node_Id (N)).Kind = K_Transition_Declaration);

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

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

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

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

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

   function First_Reference (N : Node_Id) return Node_Id is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Connect_Statement
        or else Table (Node_Id (N)).Kind = K_Place_Fusion
        or else Table (Node_Id (N)).Kind = K_Transition_Fusion);

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

   procedure Set_First_Reference (N : Node_Id; V : Node_Id) is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Connect_Statement
        or else Table (Node_Id (N)).Kind = K_Place_Fusion
        or else Table (Node_Id (N)).Kind = K_Transition_Fusion);

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

   function Second_Reference (N : Node_Id) return Node_Id is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Connect_Statement
        or else Table (Node_Id (N)).Kind = K_Place_Fusion
        or else Table (Node_Id (N)).Kind = K_Transition_Fusion);

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

   procedure Set_Second_Reference (N : Node_Id; V : Node_Id) is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Connect_Statement
        or else Table (Node_Id (N)).Kind = K_Place_Fusion
        or else Table (Node_Id (N)).Kind = K_Transition_Fusion);

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

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

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

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

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

   function New_Scoped_Name (N : Node_Id) return Node_Id is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Place_Fusion
        or else Table (Node_Id (N)).Kind = K_Transition_Fusion);

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

   procedure Set_New_Scoped_Name (N : Node_Id; V : Node_Id) is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Place_Fusion
        or else Table (Node_Id (N)).Kind = K_Transition_Fusion);

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

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

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

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

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

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

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

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

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

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

      return List_Id (Table (Node_Id (N)).L (4));
   end Transition_Declarations;

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

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

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

      return List_Id (Table (Node_Id (N)).L (5));
   end Connection_to_Locals;

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

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

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

      return List_Id (Table (Node_Id (N)).L (6));
   end Connection_to_Externs;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      return List_Id (Table (Node_Id (N)).L (6));
   end Refered_Nodes;

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

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

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

      return Value_Id (Table (Node_Id (N)).L (7));
   end Thread_Color;

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

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

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

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

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

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

   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 Color_Variable (N : Node_Id) return Node_Id is
   begin
      pragma Assert
        (False or else Table (Node_Id (N)).Kind = K_Color_Declaration);

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

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

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

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

      return List_Id (Table (Node_Id (N)).L (5));
   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_Color_Declaration);

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

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

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

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

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

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

      return Value_Id (Table (Node_Id (N)).L (5));
   end Number;

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

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

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

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

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

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

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

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

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

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

   function Include_Call (N : Node_Id) return Node_Id is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Container
        or else Table (Node_Id (N)).Kind = K_Fonctionnal_Entity
        or else Table (Node_Id (N)).Kind = K_Thread_Box
        or else Table (Node_Id (N)).Kind = K_Root_Node);

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

   procedure Set_Include_Call (N : Node_Id; V : Node_Id) is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Container
        or else Table (Node_Id (N)).Kind = K_Fonctionnal_Entity
        or else Table (Node_Id (N)).Kind = K_Thread_Box
        or else Table (Node_Id (N)).Kind = K_Root_Node);

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

   function Length (N : Node_Id) return Value_Id is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Container
        or else Table (Node_Id (N)).Kind = K_Fonctionnal_Entity
        or else Table (Node_Id (N)).Kind = K_Thread_Box
        or else Table (Node_Id (N)).Kind = K_Root_Node);

      return Value_Id (Table (Node_Id (N)).L (5));
   end Length;

   procedure Set_Length (N : Node_Id; V : Value_Id) is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Container
        or else Table (Node_Id (N)).Kind = K_Fonctionnal_Entity
        or else Table (Node_Id (N)).Kind = K_Thread_Box
        or else Table (Node_Id (N)).Kind = K_Root_Node);

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

   function Width (N : Node_Id) return Value_Id is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Container
        or else Table (Node_Id (N)).Kind = K_Fonctionnal_Entity
        or else Table (Node_Id (N)).Kind = K_Thread_Box
        or else Table (Node_Id (N)).Kind = K_Root_Node);

      return Value_Id (Table (Node_Id (N)).L (6));
   end Width;

   procedure Set_Width (N : Node_Id; V : Value_Id) is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Container
        or else Table (Node_Id (N)).Kind = K_Fonctionnal_Entity
        or else Table (Node_Id (N)).Kind = K_Thread_Box
        or else Table (Node_Id (N)).Kind = K_Root_Node);

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

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

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

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

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

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

      return List_Id (Table (Node_Id (N)).L (8));
   end Transitions;

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

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

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

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

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

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

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

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

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

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

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

      return List_Id (Table (Node_Id (N)).L (11));
   end Places_Fusions;

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

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

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

      return List_Id (Table (Node_Id (N)).L (12));
   end Transitions_Fusions;

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

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

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

      return List_Id (Table (Node_Id (N)).L (13));
   end Sub_Components;

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

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

   function Begin_Node (N : Node_Id) return Node_Id is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Fonctionnal_Entity
        or else Table (Node_Id (N)).Kind = K_Thread_Box);

      return Node_Id (Table (Node_Id (N)).L (14));
   end Begin_Node;

   procedure Set_Begin_Node (N : Node_Id; V : Node_Id) is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Fonctionnal_Entity
        or else Table (Node_Id (N)).Kind = K_Thread_Box);

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

   function End_Node (N : Node_Id) return Node_Id is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Fonctionnal_Entity
        or else Table (Node_Id (N)).Kind = K_Thread_Box);

      return Node_Id (Table (Node_Id (N)).L (15));
   end End_Node;

   procedure Set_End_Node (N : Node_Id; V : Node_Id) is
   begin
      pragma Assert
        (False
        or else Table (Node_Id (N)).Kind = K_Fonctionnal_Entity
        or else Table (Node_Id (N)).Kind = K_Thread_Box);

      Table (Node_Id (N)).L (15)  := Int (V);
   end Set_End_Node;

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

      return Node_Id (Table (Node_Id (N)).L (16));
   end Reset_Transition;

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

      Table (Node_Id (N)).L (16)  := Int (V);
   end Set_Reset_Transition;

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

      return Node_Id (Table (Node_Id (N)).L (17));
   end Ack_Receiver_Transition;

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

      Table (Node_Id (N)).L (17)  := Int (V);
   end Set_Ack_Receiver_Transition;

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

      return Node_Id (Table (Node_Id (N)).L (18));
   end Ack_Receiver_Link;

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

      Table (Node_Id (N)).L (18)  := Int (V);
   end Set_Ack_Receiver_Link;

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

      return Value_Id (Table (Node_Id (N)).L (19));
   end Color_Value;

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

      Table (Node_Id (N)).L (19)  := Int (V);
   end Set_Color_Value;

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

      return List_Id (Table (Node_Id (N)).L (20));
   end Fifos;

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

      Table (Node_Id (N)).L (20)  := Int (V);
   end Set_Fifos;

   function Directory_Name (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 (14));
   end Directory_Name;

   procedure Set_Directory_Name (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 (14)  := Int (V);
   end Set_Directory_Name;

   function File_Name (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 (15));
   end File_Name;

   procedure Set_File_Name (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 (15)  := Int (V);
   end Set_File_Name;

   function Color_Declarations (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 (16));
   end Color_Declarations;

   procedure Set_Color_Declarations (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 (16)  := Int (V);
   end Set_Color_Declarations;

   procedure W_Node (N : Node_Id) is
   begin
      case Kind (N) is
      when K_Identifier =>
         W_Identifier (Node_Id (N));
      when K_Pn_Definition =>
         W_Pn_Definition (Node_Id (N));
      when K_Scoped_Name =>
         W_Scoped_Name (Node_Id (N));
      when K_Encapsulate_List_Node =>
         W_Encapsulate_List_Node (Node_Id (N));
      when K_Pn_Scope_Definition =>
         W_Pn_Scope_Definition (Node_Id (N));
      when K_Position =>
         W_Position (Node_Id (N));
      when K_Token =>
         W_Token (Node_Id (N));
      when K_Guard =>
         W_Guard (Node_Id (N));
      when K_Place_Declaration =>
         W_Place_Declaration (Node_Id (N));
      when K_Transition_Declaration =>
         W_Transition_Declaration (Node_Id (N));
      when K_Connect_Statement =>
         W_Connect_Statement (Node_Id (N));
      when K_Place_Fusion =>
         W_Place_Fusion (Node_Id (N));
      when K_Transition_Fusion =>
         W_Transition_Fusion (Node_Id (N));
      when K_Loop_Declaration =>
         W_Loop_Declaration (Node_Id (N));
      when K_Fifo_Extremities =>
         W_Fifo_Extremities (Node_Id (N));
      when K_Symbolic_Value =>
         W_Symbolic_Value (Node_Id (N));
      when K_Color_Variable =>
         W_Color_Variable (Node_Id (N));
      when K_Color_Declaration =>
         W_Color_Declaration (Node_Id (N));
      when K_Colored_Token =>
         W_Colored_Token (Node_Id (N));
      when K_Include_Call =>
         W_Include_Call (Node_Id (N));
      when K_Container =>
         W_Container (Node_Id (N));
      when K_Fonctionnal_Entity =>
         W_Fonctionnal_Entity (Node_Id (N));
      when K_Thread_Box =>
         W_Thread_Box (Node_Id (N));
      when K_Root_Node =>
         W_Root_Node (Node_Id (N));
      when K_Subprogram_Declaration =>
         W_Subprogram_Declaration (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
        ("Gaia_Node",
         "Node_Id",
         Image (Gaia_Node (N)),
         Int (Gaia_Node (N)));
      W_Node_Attribute
        ("Corresponding_Entity",
         "Node_Id",
         Image (Corresponding_Entity (N)),
         Int (Corresponding_Entity (N)));
   end W_Identifier;

   procedure W_Pn_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_Pn_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_Encapsulate_List_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
        ("Refered_Node",
         "Node_Id",
         Image (Refered_Node (N)),
         Int (Refered_Node (N)));
   end W_Encapsulate_List_Node;

   procedure W_Pn_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)));
   end W_Pn_Scope_Definition;

   procedure W_Position (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 ("X_Value", "Value_Id", Image (X_Value (N)));
      W_Node_Attribute ("Y_Value", "Value_Id", Image (Y_Value (N)));
   end W_Position;

   procedure W_Token (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", "Value_Id", Image (Value (N)));
      W_Node_Attribute
        ("Color",
         "Node_Id",
         Image (Color (N)),
         Int (Color (N)));
   end W_Token;

   procedure W_Guard (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", "Value_Id", Image (Value (N)));
      W_Node_Attribute
        ("Color",
         "Node_Id",
         Image (Color (N)),
         Int (Color (N)));
      W_Node_Attribute
        ("Variable",
         "Node_Id",
         Image (Variable (N)),
         Int (Variable (N)));
      W_Node_Attribute ("Operator", "Value_Id", Image (Operator (N)));
   end W_Guard;

   procedure W_Place_Declaration (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
        ("Tokens",
         "List_Id",
         Image (Tokens (N)),
         Int (Tokens (N)));
      W_Node_Attribute
        ("Domains",
         "List_Id",
         Image (Domains (N)),
         Int (Domains (N)));
      W_Node_Attribute
        ("Position",
         "Node_Id",
         Image (Position (N)),
         Int (Position (N)));
   end W_Place_Declaration;

   procedure W_Transition_Declaration (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
        ("Position",
         "Node_Id",
         Image (Position (N)),
         Int (Position (N)));
      W_Node_Attribute
        ("Guard",
         "Node_Id",
         Image (Guard (N)),
         Int (Guard (N)));
   end W_Transition_Declaration;

   procedure W_Connect_Statement (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
        ("Domains",
         "List_Id",
         Image (Domains (N)),
         Int (Domains (N)));
      W_Node_Attribute
        ("First_Reference",
         "Node_Id",
         Image (First_Reference (N)),
         Int (First_Reference (N)));
      W_Node_Attribute
        ("Second_Reference",
         "Node_Id",
         Image (Second_Reference (N)),
         Int (Second_Reference (N)));
      W_Node_Attribute
        ("Is_Link_Place_To_Transition",
         "Boolean",
         Image (Is_Link_Place_To_Transition (N)));
   end W_Connect_Statement;

   procedure W_Place_Fusion (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
        ("First_Reference",
         "Node_Id",
         Image (First_Reference (N)),
         Int (First_Reference (N)));
      W_Node_Attribute
        ("Second_Reference",
         "Node_Id",
         Image (Second_Reference (N)),
         Int (Second_Reference (N)));
      W_Node_Attribute
        ("New_Scoped_Name",
         "Node_Id",
         Image (New_Scoped_Name (N)),
         Int (New_Scoped_Name (N)));
   end W_Place_Fusion;

   procedure W_Transition_Fusion (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
        ("First_Reference",
         "Node_Id",
         Image (First_Reference (N)),
         Int (First_Reference (N)));
      W_Node_Attribute
        ("Second_Reference",
         "Node_Id",
         Image (Second_Reference (N)),
         Int (Second_Reference (N)));
      W_Node_Attribute
        ("New_Scoped_Name",
         "Node_Id",
         Image (New_Scoped_Name (N)),
         Int (New_Scoped_Name (N)));
   end W_Transition_Fusion;

   procedure W_Loop_Declaration (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
        ("Iteration_Nb",
         "Value_Id",
         Image (Iteration_Nb (N)));
      W_Node_Attribute
        ("Place_Declarations",
         "List_Id",
         Image (Place_Declarations (N)),
         Int (Place_Declarations (N)));
      W_Node_Attribute
        ("Transition_Declarations",
         "List_Id",
         Image (Transition_Declarations (N)),
         Int (Transition_Declarations (N)));
      W_Node_Attribute
        ("Connection_to_Locals",
         "List_Id",
         Image (Connection_to_Locals (N)),
         Int (Connection_to_Locals (N)));
      W_Node_Attribute
        ("Connection_to_Externs",
         "List_Id",
         Image (Connection_to_Externs (N)),
         Int (Connection_to_Externs (N)));
      W_Node_Attribute
        ("Connection_Local",
         "List_Id",
         Image (Connection_Local (N)),
         Int (Connection_Local (N)));
   end W_Loop_Declaration;

   procedure W_Fifo_Extremities (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
        ("Pop_Transition",
         "Node_Id",
         Image (Pop_Transition (N)),
         Int (Pop_Transition (N)));
      W_Node_Attribute
        ("Push_Transition",
         "Node_Id",
         Image (Push_Transition (N)),
         Int (Push_Transition (N)));
      W_Node_Attribute
        ("Port_Reference",
         "Node_Id",
         Image (Port_Reference (N)),
         Int (Port_Reference (N)));
      W_Node_Attribute
        ("Ack_Place",
         "Node_Id",
         Image (Ack_Place (N)),
         Int (Ack_Place (N)));
      W_Node_Attribute
        ("Refered_Nodes",
         "List_Id",
         Image (Refered_Nodes (N)),
         Int (Refered_Nodes (N)));
      W_Node_Attribute
        ("Thread_Color",
         "Value_Id",
         Image (Thread_Color (N)));
      W_Node_Attribute
        ("Thread_Reference",
         "Node_Id",
         Image (Thread_Reference (N)),
         Int (Thread_Reference (N)));
   end W_Fifo_Extremities;

   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_Color_Variable (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)));
   end W_Color_Variable;

   procedure W_Color_Declaration (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
        ("Color_Variable",
         "Node_Id",
         Image (Color_Variable (N)),
         Int (Color_Variable (N)));
      W_Node_Attribute
        ("Symbolic_Values",
         "List_Id",
         Image (Symbolic_Values (N)),
         Int (Symbolic_Values (N)));
   end W_Color_Declaration;

   procedure W_Colored_Token (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
        ("Color_Declaration",
         "Node_Id",
         Image (Color_Declaration (N)),
         Int (Color_Declaration (N)));
      W_Node_Attribute ("Number", "Value_Id", Image (Number (N)));
   end W_Colored_Token;

   procedure W_Include_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
        ("Namespace_Scoped_Name",
         "Node_Id",
         Image (Namespace_Scoped_Name (N)),
         Int (Namespace_Scoped_Name (N)));
      W_Node_Attribute
        ("Subprogram_Scoped_Name",
         "Node_Id",
         Image (Subprogram_Scoped_Name (N)),
         Int (Subprogram_Scoped_Name (N)));
   end W_Include_Call;

   procedure W_Container (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
        ("Include_Call",
         "Node_Id",
         Image (Include_Call (N)),
         Int (Include_Call (N)));
      W_Node_Attribute ("Length", "Value_Id", Image (Length (N)));
      W_Node_Attribute ("Width", "Value_Id", Image (Width (N)));
      W_Node_Attribute
        ("Places",
         "List_Id",
         Image (Places (N)),
         Int (Places (N)));
      W_Node_Attribute
        ("Transitions",
         "List_Id",
         Image (Transitions (N)),
         Int (Transitions (N)));
      W_Node_Attribute
        ("Connections",
         "List_Id",
         Image (Connections (N)),
         Int (Connections (N)));
      W_Node_Attribute
        ("Loop_Declarations",
         "List_Id",
         Image (Loop_Declarations (N)),
         Int (Loop_Declarations (N)));
      W_Node_Attribute
        ("Places_Fusions",
         "List_Id",
         Image (Places_Fusions (N)),
         Int (Places_Fusions (N)));
      W_Node_Attribute
        ("Transitions_Fusions",
         "List_Id",
         Image (Transitions_Fusions (N)),
         Int (Transitions_Fusions (N)));
      W_Node_Attribute
        ("Sub_Components",
         "List_Id",
         Image (Sub_Components (N)),
         Int (Sub_Components (N)));
   end W_Container;

   procedure W_Fonctionnal_Entity (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
        ("Include_Call",
         "Node_Id",
         Image (Include_Call (N)),
         Int (Include_Call (N)));
      W_Node_Attribute ("Length", "Value_Id", Image (Length (N)));
      W_Node_Attribute ("Width", "Value_Id", Image (Width (N)));
      W_Node_Attribute
        ("Places",
         "List_Id",
         Image (Places (N)),
         Int (Places (N)));
      W_Node_Attribute
        ("Transitions",
         "List_Id",
         Image (Transitions (N)),
         Int (Transitions (N)));
      W_Node_Attribute
        ("Connections",
         "List_Id",
         Image (Connections (N)),
         Int (Connections (N)));
      W_Node_Attribute
        ("Loop_Declarations",
         "List_Id",
         Image (Loop_Declarations (N)),
         Int (Loop_Declarations (N)));
      W_Node_Attribute
        ("Places_Fusions",
         "List_Id",
         Image (Places_Fusions (N)),
         Int (Places_Fusions (N)));
      W_Node_Attribute
        ("Transitions_Fusions",
         "List_Id",
         Image (Transitions_Fusions (N)),
         Int (Transitions_Fusions (N)));
      W_Node_Attribute
        ("Sub_Components",
         "List_Id",
         Image (Sub_Components (N)),
         Int (Sub_Components (N)));
      W_Node_Attribute
        ("Begin_Node",
         "Node_Id",
         Image (Begin_Node (N)),
         Int (Begin_Node (N)));
      W_Node_Attribute
        ("End_Node",
         "Node_Id",
         Image (End_Node (N)),
         Int (End_Node (N)));
   end W_Fonctionnal_Entity;

   procedure W_Thread_Box (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
        ("Include_Call",
         "Node_Id",
         Image (Include_Call (N)),
         Int (Include_Call (N)));
      W_Node_Attribute ("Length", "Value_Id", Image (Length (N)));
      W_Node_Attribute ("Width", "Value_Id", Image (Width (N)));
      W_Node_Attribute
        ("Places",
         "List_Id",
         Image (Places (N)),
         Int (Places (N)));
      W_Node_Attribute
        ("Transitions",
         "List_Id",
         Image (Transitions (N)),
         Int (Transitions (N)));
      W_Node_Attribute
        ("Connections",
         "List_Id",
         Image (Connections (N)),
         Int (Connections (N)));
      W_Node_Attribute
        ("Loop_Declarations",
         "List_Id",
         Image (Loop_Declarations (N)),
         Int (Loop_Declarations (N)));
      W_Node_Attribute
        ("Places_Fusions",
         "List_Id",
         Image (Places_Fusions (N)),
         Int (Places_Fusions (N)));
      W_Node_Attribute
        ("Transitions_Fusions",
         "List_Id",
         Image (Transitions_Fusions (N)),
         Int (Transitions_Fusions (N)));
      W_Node_Attribute
        ("Sub_Components",
         "List_Id",
         Image (Sub_Components (N)),
         Int (Sub_Components (N)));
      W_Node_Attribute
        ("Begin_Node",
         "Node_Id",
         Image (Begin_Node (N)),
         Int (Begin_Node (N)));
      W_Node_Attribute
        ("End_Node",
         "Node_Id",
         Image (End_Node (N)),
         Int (End_Node (N)));
      W_Node_Attribute
        ("Reset_Transition",
         "Node_Id",
         Image (Reset_Transition (N)),
         Int (Reset_Transition (N)));
      W_Node_Attribute
        ("Ack_Receiver_Transition",
         "Node_Id",
         Image (Ack_Receiver_Transition (N)),
         Int (Ack_Receiver_Transition (N)));
      W_Node_Attribute
        ("Ack_Receiver_Link",
         "Node_Id",
         Image (Ack_Receiver_Link (N)),
         Int (Ack_Receiver_Link (N)));
      W_Node_Attribute ("Color_Value", "Value_Id", Image (Color_Value (N)));
      W_Node_Attribute
        ("Fifos",
         "List_Id",
         Image (Fifos (N)),
         Int (Fifos (N)));
   end W_Thread_Box;

   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
        ("Include_Call",
         "Node_Id",
         Image (Include_Call (N)),
         Int (Include_Call (N)));
      W_Node_Attribute ("Length", "Value_Id", Image (Length (N)));
      W_Node_Attribute ("Width", "Value_Id", Image (Width (N)));
      W_Node_Attribute
        ("Places",
         "List_Id",
         Image (Places (N)),
         Int (Places (N)));
      W_Node_Attribute
        ("Transitions",
         "List_Id",
         Image (Transitions (N)),
         Int (Transitions (N)));
      W_Node_Attribute
        ("Connections",
         "List_Id",
         Image (Connections (N)),
         Int (Connections (N)));
      W_Node_Attribute
        ("Loop_Declarations",
         "List_Id",
         Image (Loop_Declarations (N)),
         Int (Loop_Declarations (N)));
      W_Node_Attribute
        ("Places_Fusions",
         "List_Id",
         Image (Places_Fusions (N)),
         Int (Places_Fusions (N)));
      W_Node_Attribute
        ("Transitions_Fusions",
         "List_Id",
         Image (Transitions_Fusions (N)),
         Int (Transitions_Fusions (N)));
      W_Node_Attribute
        ("Sub_Components",
         "List_Id",
         Image (Sub_Components (N)),
         Int (Sub_Components (N)));
      W_Node_Attribute
        ("Directory_Name",
         "Name_Id",
         Image (Directory_Name (N)));
      W_Node_Attribute ("File_Name", "Name_Id", Image (File_Name (N)));
      W_Node_Attribute
        ("Color_Declarations",
         "List_Id",
         Image (Color_Declarations (N)),
         Int (Color_Declarations (N)));
   end W_Root_Node;

   procedure W_Subprogram_Declaration (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)));
   end W_Subprogram_Declaration;

end Gaia.Pn.Nodes;