------------------------------------------------------------------------------
|
------------------------------------------------------------------------------
|
-- --
|
-- --
|
-- GNAT COMPILER COMPONENTS --
|
-- GNAT COMPILER COMPONENTS --
|
-- --
|
-- --
|
-- N L I S T S --
|
-- N L I S T S --
|
-- --
|
-- --
|
-- S p e c --
|
-- S p e c --
|
-- --
|
-- --
|
-- Copyright (C) 1992-2009, Free Software Foundation, Inc. --
|
-- Copyright (C) 1992-2009, Free Software Foundation, Inc. --
|
-- --
|
-- --
|
-- GNAT is free software; you can redistribute it and/or modify it under --
|
-- GNAT is free software; you can redistribute it and/or modify it under --
|
-- terms of the GNU General Public License as published by the Free Soft- --
|
-- terms of the GNU General Public License as published by the Free Soft- --
|
-- ware Foundation; either version 3, or (at your option) any later ver- --
|
-- ware Foundation; either version 3, or (at your option) any later ver- --
|
-- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
|
-- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
|
-- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
|
-- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
|
-- or FITNESS FOR A PARTICULAR PURPOSE. --
|
-- or FITNESS FOR A PARTICULAR PURPOSE. --
|
-- --
|
-- --
|
-- As a special exception under Section 7 of GPL version 3, you are granted --
|
-- As a special exception under Section 7 of GPL version 3, you are granted --
|
-- additional permissions described in the GCC Runtime Library Exception, --
|
-- additional permissions described in the GCC Runtime Library Exception, --
|
-- version 3.1, as published by the Free Software Foundation. --
|
-- version 3.1, as published by the Free Software Foundation. --
|
-- --
|
-- --
|
-- You should have received a copy of the GNU General Public License and --
|
-- You should have received a copy of the GNU General Public License and --
|
-- a copy of the GCC Runtime Library Exception along with this program; --
|
-- a copy of the GCC Runtime Library Exception along with this program; --
|
-- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see --
|
-- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see --
|
-- <http://www.gnu.org/licenses/>. --
|
-- <http://www.gnu.org/licenses/>. --
|
-- --
|
-- --
|
-- GNAT was originally developed by the GNAT team at New York University. --
|
-- GNAT was originally developed by the GNAT team at New York University. --
|
-- Extensive contributions were provided by Ada Core Technologies Inc. --
|
-- Extensive contributions were provided by Ada Core Technologies Inc. --
|
-- --
|
-- --
|
------------------------------------------------------------------------------
|
------------------------------------------------------------------------------
|
|
|
-- This package provides facilities for manipulating lists of nodes (see
|
-- This package provides facilities for manipulating lists of nodes (see
|
-- package Atree for format and implementation of tree nodes). The Link field
|
-- package Atree for format and implementation of tree nodes). The Link field
|
-- of the nodes is used as the forward pointer for these lists. See also
|
-- of the nodes is used as the forward pointer for these lists. See also
|
-- package Elists which provides another form of lists that are not threaded
|
-- package Elists which provides another form of lists that are not threaded
|
-- through the nodes (and therefore allow nodes to be on multiple lists).
|
-- through the nodes (and therefore allow nodes to be on multiple lists).
|
|
|
with System;
|
with System;
|
with Types; use Types;
|
with Types; use Types;
|
|
|
package Nlists is
|
package Nlists is
|
|
|
-- A node list is a list of nodes in a special format that means that
|
-- A node list is a list of nodes in a special format that means that
|
-- nodes can be on at most one such list. For each node list, a list
|
-- nodes can be on at most one such list. For each node list, a list
|
-- header is allocated in the lists table, and a List_Id value references
|
-- header is allocated in the lists table, and a List_Id value references
|
-- this header, which may be used to access the nodes in the list using
|
-- this header, which may be used to access the nodes in the list using
|
-- the set of routines that define this interface.
|
-- the set of routines that define this interface.
|
|
|
-- Note: node lists can contain either nodes or entities (extended nodes)
|
-- Note: node lists can contain either nodes or entities (extended nodes)
|
-- or a mixture of nodes and extended nodes.
|
-- or a mixture of nodes and extended nodes.
|
|
|
function Last_List_Id return List_Id;
|
function Last_List_Id return List_Id;
|
pragma Inline (Last_List_Id);
|
pragma Inline (Last_List_Id);
|
-- Returns Id of last allocated list header
|
-- Returns Id of last allocated list header
|
|
|
function Lists_Address return System.Address;
|
function Lists_Address return System.Address;
|
pragma Inline (Lists_Address);
|
pragma Inline (Lists_Address);
|
-- Return address of Lists table (used in Back_End for Gigi call)
|
-- Return address of Lists table (used in Back_End for Gigi call)
|
|
|
function Num_Lists return Nat;
|
function Num_Lists return Nat;
|
pragma Inline (Num_Lists);
|
pragma Inline (Num_Lists);
|
-- Number of currently allocated lists
|
-- Number of currently allocated lists
|
|
|
function New_List return List_Id;
|
function New_List return List_Id;
|
-- Creates a new empty node list. Typically this is used to initialize
|
-- Creates a new empty node list. Typically this is used to initialize
|
-- a field in some other node which points to a node list where the list
|
-- a field in some other node which points to a node list where the list
|
-- is then subsequently filled in using Append calls.
|
-- is then subsequently filled in using Append calls.
|
|
|
function Empty_List return List_Id renames New_List;
|
function Empty_List return List_Id renames New_List;
|
-- Used in contexts where an empty list (as opposed to an initially empty
|
-- Used in contexts where an empty list (as opposed to an initially empty
|
-- list to be filled in) is required.
|
-- list to be filled in) is required.
|
|
|
function New_List (Node : Node_Id) return List_Id;
|
function New_List (Node : Node_Id) return List_Id;
|
-- Build a new list initially containing the given node
|
-- Build a new list initially containing the given node
|
|
|
function New_List (Node1, Node2 : Node_Id) return List_Id;
|
function New_List (Node1, Node2 : Node_Id) return List_Id;
|
-- Build a new list initially containing the two given nodes
|
-- Build a new list initially containing the two given nodes
|
|
|
function New_List (Node1, Node2, Node3 : Node_Id) return List_Id;
|
function New_List (Node1, Node2, Node3 : Node_Id) return List_Id;
|
-- Build a new list initially containing the three given nodes
|
-- Build a new list initially containing the three given nodes
|
|
|
function New_List (Node1, Node2, Node3, Node4 : Node_Id) return List_Id;
|
function New_List (Node1, Node2, Node3, Node4 : Node_Id) return List_Id;
|
-- Build a new list initially containing the four given nodes
|
-- Build a new list initially containing the four given nodes
|
|
|
function New_List
|
function New_List
|
(Node1 : Node_Id;
|
(Node1 : Node_Id;
|
Node2 : Node_Id;
|
Node2 : Node_Id;
|
Node3 : Node_Id;
|
Node3 : Node_Id;
|
Node4 : Node_Id;
|
Node4 : Node_Id;
|
Node5 : Node_Id) return List_Id;
|
Node5 : Node_Id) return List_Id;
|
-- Build a new list initially containing the five given nodes
|
-- Build a new list initially containing the five given nodes
|
|
|
function New_List
|
function New_List
|
(Node1 : Node_Id;
|
(Node1 : Node_Id;
|
Node2 : Node_Id;
|
Node2 : Node_Id;
|
Node3 : Node_Id;
|
Node3 : Node_Id;
|
Node4 : Node_Id;
|
Node4 : Node_Id;
|
Node5 : Node_Id;
|
Node5 : Node_Id;
|
Node6 : Node_Id) return List_Id;
|
Node6 : Node_Id) return List_Id;
|
-- Build a new list initially containing the six given nodes
|
-- Build a new list initially containing the six given nodes
|
|
|
function New_Copy_List (List : List_Id) return List_Id;
|
function New_Copy_List (List : List_Id) return List_Id;
|
-- Creates a new list containing copies (made with Atree.New_Copy) of every
|
-- Creates a new list containing copies (made with Atree.New_Copy) of every
|
-- node in the original list. If the argument is No_List, then the returned
|
-- node in the original list. If the argument is No_List, then the returned
|
-- result is No_List. If the argument is an empty list, then the returned
|
-- result is No_List. If the argument is an empty list, then the returned
|
-- result is a new empty list.
|
-- result is a new empty list.
|
|
|
function New_Copy_List_Original (List : List_Id) return List_Id;
|
function New_Copy_List_Original (List : List_Id) return List_Id;
|
-- Same as New_Copy_List but copies only nodes coming from source
|
-- Same as New_Copy_List but copies only nodes coming from source
|
|
|
function First (List : List_Id) return Node_Id;
|
function First (List : List_Id) return Node_Id;
|
pragma Inline (First);
|
pragma Inline (First);
|
-- Obtains the first element of the given node list or, if the node list
|
-- Obtains the first element of the given node list or, if the node list
|
-- has no items or is equal to No_List, then Empty is returned.
|
-- has no items or is equal to No_List, then Empty is returned.
|
|
|
function First_Non_Pragma (List : List_Id) return Node_Id;
|
function First_Non_Pragma (List : List_Id) return Node_Id;
|
-- Used when dealing with a list that can contain pragmas to skip past
|
-- Used when dealing with a list that can contain pragmas to skip past
|
-- any initial pragmas and return the first element that is not a pragma.
|
-- any initial pragmas and return the first element that is not a pragma.
|
-- If the list is empty, or if it contains only pragmas, then Empty is
|
-- If the list is empty, or if it contains only pragmas, then Empty is
|
-- returned. It is an error to call First_Non_Pragma with a Node_Id value
|
-- returned. It is an error to call First_Non_Pragma with a Node_Id value
|
-- or No_List (No_List is not considered to be the same as an empty list).
|
-- or No_List (No_List is not considered to be the same as an empty list).
|
-- This function also skips N_Null nodes which can result from rewriting
|
-- This function also skips N_Null nodes which can result from rewriting
|
-- unrecognized or incorrect pragmas.
|
-- unrecognized or incorrect pragmas.
|
|
|
function Last (List : List_Id) return Node_Id;
|
function Last (List : List_Id) return Node_Id;
|
pragma Inline (Last);
|
pragma Inline (Last);
|
-- Obtains the last element of the given node list or, if the node list
|
-- Obtains the last element of the given node list or, if the node list
|
-- has no items, then Empty is returned. It is an error to call Last with
|
-- has no items, then Empty is returned. It is an error to call Last with
|
-- a Node_Id or No_List. (No_List is not considered to be the same as an
|
-- a Node_Id or No_List. (No_List is not considered to be the same as an
|
-- empty node list).
|
-- empty node list).
|
|
|
function Last_Non_Pragma (List : List_Id) return Node_Id;
|
function Last_Non_Pragma (List : List_Id) return Node_Id;
|
-- Obtains the last element of a given node list that is not a pragma.
|
-- Obtains the last element of a given node list that is not a pragma.
|
-- If the list is empty, or if it contains only pragmas, then Empty is
|
-- If the list is empty, or if it contains only pragmas, then Empty is
|
-- returned. It is an error to call Last_Non_Pragma with a Node_Id or
|
-- returned. It is an error to call Last_Non_Pragma with a Node_Id or
|
-- No_List. (No_List is not considered to be the same as an empty list).
|
-- No_List. (No_List is not considered to be the same as an empty list).
|
|
|
function List_Length (List : List_Id) return Nat;
|
function List_Length (List : List_Id) return Nat;
|
pragma Inline (List_Length);
|
pragma Inline (List_Length);
|
-- Returns number of items in the given list. It is an error to call
|
-- Returns number of items in the given list. It is an error to call
|
-- this function with No_List (No_List is not considered to be the same
|
-- this function with No_List (No_List is not considered to be the same
|
-- as an empty list).
|
-- as an empty list).
|
|
|
function Next (Node : Node_Id) return Node_Id;
|
function Next (Node : Node_Id) return Node_Id;
|
pragma Inline (Next);
|
pragma Inline (Next);
|
-- This function returns the next node on a node list, or Empty if Node is
|
-- This function returns the next node on a node list, or Empty if Node is
|
-- the last element of the node list. The argument must be a member of a
|
-- the last element of the node list. The argument must be a member of a
|
-- node list.
|
-- node list.
|
|
|
procedure Next (Node : in out Node_Id);
|
procedure Next (Node : in out Node_Id);
|
pragma Inline (Next);
|
pragma Inline (Next);
|
-- Equivalent to Node := Next (Node);
|
-- Equivalent to Node := Next (Node);
|
|
|
function Next_Non_Pragma (Node : Node_Id) return Node_Id;
|
function Next_Non_Pragma (Node : Node_Id) return Node_Id;
|
-- This function returns the next node on a node list, skipping past any
|
-- This function returns the next node on a node list, skipping past any
|
-- pragmas, or Empty if there is no non-pragma entry left. The argument
|
-- pragmas, or Empty if there is no non-pragma entry left. The argument
|
-- must be a member of a node list. This function also skips N_Null nodes
|
-- must be a member of a node list. This function also skips N_Null nodes
|
-- which can result from rewriting unrecognized or incorrect pragmas.
|
-- which can result from rewriting unrecognized or incorrect pragmas.
|
|
|
procedure Next_Non_Pragma (Node : in out Node_Id);
|
procedure Next_Non_Pragma (Node : in out Node_Id);
|
pragma Inline (Next_Non_Pragma);
|
pragma Inline (Next_Non_Pragma);
|
-- Equivalent to Node := Next_Non_Pragma (Node);
|
-- Equivalent to Node := Next_Non_Pragma (Node);
|
|
|
function Prev (Node : Node_Id) return Node_Id;
|
function Prev (Node : Node_Id) return Node_Id;
|
pragma Inline (Prev);
|
pragma Inline (Prev);
|
-- This function returns the previous node on a node list, or Empty
|
-- This function returns the previous node on a node list, or Empty
|
-- if Node is the first element of the node list. The argument must be
|
-- if Node is the first element of the node list. The argument must be
|
-- a member of a node list. Note: the implementation does maintain back
|
-- a member of a node list. Note: the implementation does maintain back
|
-- pointers, so this function executes quickly in constant time.
|
-- pointers, so this function executes quickly in constant time.
|
|
|
function Pick (List : List_Id; Index : Pos) return Node_Id;
|
function Pick (List : List_Id; Index : Pos) return Node_Id;
|
-- Given a list, picks out the Index'th entry (1 = first entry). The
|
-- Given a list, picks out the Index'th entry (1 = first entry). The
|
-- caller must ensure that Index is in range.
|
-- caller must ensure that Index is in range.
|
|
|
procedure Prev (Node : in out Node_Id);
|
procedure Prev (Node : in out Node_Id);
|
pragma Inline (Prev);
|
pragma Inline (Prev);
|
-- Equivalent to Node := Prev (Node);
|
-- Equivalent to Node := Prev (Node);
|
|
|
function Prev_Non_Pragma (Node : Node_Id) return Node_Id;
|
function Prev_Non_Pragma (Node : Node_Id) return Node_Id;
|
pragma Inline (Prev_Non_Pragma);
|
pragma Inline (Prev_Non_Pragma);
|
-- This function returns the previous node on a node list, skipping any
|
-- This function returns the previous node on a node list, skipping any
|
-- pragmas. If Node is the first element of the list, or if the only
|
-- pragmas. If Node is the first element of the list, or if the only
|
-- elements preceding it are pragmas, then Empty is returned. The
|
-- elements preceding it are pragmas, then Empty is returned. The
|
-- argument must be a member of a node list. Note: the implementation
|
-- argument must be a member of a node list. Note: the implementation
|
-- does maintain back pointers, so this function executes quickly in
|
-- does maintain back pointers, so this function executes quickly in
|
-- constant time.
|
-- constant time.
|
|
|
procedure Prev_Non_Pragma (Node : in out Node_Id);
|
procedure Prev_Non_Pragma (Node : in out Node_Id);
|
pragma Inline (Prev_Non_Pragma);
|
pragma Inline (Prev_Non_Pragma);
|
-- Equivalent to Node := Prev_Non_Pragma (Node);
|
-- Equivalent to Node := Prev_Non_Pragma (Node);
|
|
|
function Is_Empty_List (List : List_Id) return Boolean;
|
function Is_Empty_List (List : List_Id) return Boolean;
|
pragma Inline (Is_Empty_List);
|
pragma Inline (Is_Empty_List);
|
-- This function determines if a given list id references a node list that
|
-- This function determines if a given list id references a node list that
|
-- contains no items. No_List as an argument returns True.
|
-- contains no items. No_List as an argument returns True.
|
|
|
function Is_Non_Empty_List (List : List_Id) return Boolean;
|
function Is_Non_Empty_List (List : List_Id) return Boolean;
|
pragma Inline (Is_Non_Empty_List);
|
pragma Inline (Is_Non_Empty_List);
|
-- This function determines if a given list id references a node list that
|
-- This function determines if a given list id references a node list that
|
-- contains at least one item. No_List as an argument returns False.
|
-- contains at least one item. No_List as an argument returns False.
|
|
|
function Is_List_Member (Node : Node_Id) return Boolean;
|
function Is_List_Member (Node : Node_Id) return Boolean;
|
pragma Inline (Is_List_Member);
|
pragma Inline (Is_List_Member);
|
-- This function determines if a given node is a member of a node list.
|
-- This function determines if a given node is a member of a node list.
|
-- It is an error for Node to be Empty, or to be a node list.
|
-- It is an error for Node to be Empty, or to be a node list.
|
|
|
function List_Containing (Node : Node_Id) return List_Id;
|
function List_Containing (Node : Node_Id) return List_Id;
|
pragma Inline (List_Containing);
|
pragma Inline (List_Containing);
|
-- This function provides a pointer to the node list containing Node.
|
-- This function provides a pointer to the node list containing Node.
|
-- Node must be a member of a node list.
|
-- Node must be a member of a node list.
|
|
|
procedure Append (Node : Node_Id; To : List_Id);
|
procedure Append (Node : Node_Id; To : List_Id);
|
-- Appends Node at the end of node list To. Node must be a non-empty node
|
-- Appends Node at the end of node list To. Node must be a non-empty node
|
-- that is not already a member of a node list, and To must be a
|
-- that is not already a member of a node list, and To must be a
|
-- node list. An attempt to append an error node is ignored without
|
-- node list. An attempt to append an error node is ignored without
|
-- complaint and the list is unchanged.
|
-- complaint and the list is unchanged.
|
|
|
procedure Append_To (To : List_Id; Node : Node_Id);
|
procedure Append_To (To : List_Id; Node : Node_Id);
|
pragma Inline (Append_To);
|
pragma Inline (Append_To);
|
-- Like Append, but arguments are the other way round
|
-- Like Append, but arguments are the other way round
|
|
|
procedure Append_List (List : List_Id; To : List_Id);
|
procedure Append_List (List : List_Id; To : List_Id);
|
-- Appends node list List to the end of node list To. On return,
|
-- Appends node list List to the end of node list To. On return,
|
-- List is reset to be empty.
|
-- List is reset to be empty.
|
|
|
procedure Append_List_To (To : List_Id; List : List_Id);
|
procedure Append_List_To (To : List_Id; List : List_Id);
|
pragma Inline (Append_List_To);
|
pragma Inline (Append_List_To);
|
-- Like Append_List, but arguments are the other way round
|
-- Like Append_List, but arguments are the other way round
|
|
|
procedure Insert_After (After : Node_Id; Node : Node_Id);
|
procedure Insert_After (After : Node_Id; Node : Node_Id);
|
-- Insert Node, which must be a non-empty node that is not already a
|
-- Insert Node, which must be a non-empty node that is not already a
|
-- member of a node list, immediately past node After, which must be a
|
-- member of a node list, immediately past node After, which must be a
|
-- node that is currently a member of a node list. An attempt to insert
|
-- node that is currently a member of a node list. An attempt to insert
|
-- an error node is ignored without complaint (and the list is unchanged).
|
-- an error node is ignored without complaint (and the list is unchanged).
|
|
|
procedure Insert_List_After (After : Node_Id; List : List_Id);
|
procedure Insert_List_After (After : Node_Id; List : List_Id);
|
-- Inserts the entire contents of node list List immediately after node
|
-- Inserts the entire contents of node list List immediately after node
|
-- After, which must be a member of a node list. On return, the node list
|
-- After, which must be a member of a node list. On return, the node list
|
-- List is reset to be the empty node list.
|
-- List is reset to be the empty node list.
|
|
|
procedure Insert_Before (Before : Node_Id; Node : Node_Id);
|
procedure Insert_Before (Before : Node_Id; Node : Node_Id);
|
-- Insert Node, which must be a non-empty node that is not already a
|
-- Insert Node, which must be a non-empty node that is not already a
|
-- member of a node list, immediately before Before, which must be a node
|
-- member of a node list, immediately before Before, which must be a node
|
-- that is currently a member of a node list. An attempt to insert an
|
-- that is currently a member of a node list. An attempt to insert an
|
-- error node is ignored without complaint (and the list is unchanged).
|
-- error node is ignored without complaint (and the list is unchanged).
|
|
|
procedure Insert_List_Before (Before : Node_Id; List : List_Id);
|
procedure Insert_List_Before (Before : Node_Id; List : List_Id);
|
-- Inserts the entire contents of node list List immediately before node
|
-- Inserts the entire contents of node list List immediately before node
|
-- Before, which must be a member of a node list. On return, the node list
|
-- Before, which must be a member of a node list. On return, the node list
|
-- List is reset to be the empty node list.
|
-- List is reset to be the empty node list.
|
|
|
procedure Prepend (Node : Node_Id; To : List_Id);
|
procedure Prepend (Node : Node_Id; To : List_Id);
|
-- Prepends Node at the start of node list To. Node must be a non-empty
|
-- Prepends Node at the start of node list To. Node must be a non-empty
|
-- node that is not already a member of a node list, and To must be a
|
-- node that is not already a member of a node list, and To must be a
|
-- node list. An attempt to prepend an error node is ignored without
|
-- node list. An attempt to prepend an error node is ignored without
|
-- complaint and the list is unchanged.
|
-- complaint and the list is unchanged.
|
|
|
procedure Prepend_To (To : List_Id; Node : Node_Id);
|
procedure Prepend_To (To : List_Id; Node : Node_Id);
|
pragma Inline (Prepend_To);
|
pragma Inline (Prepend_To);
|
-- Like Prepend, but arguments are the other way round
|
-- Like Prepend, but arguments are the other way round
|
|
|
procedure Remove (Node : Node_Id);
|
procedure Remove (Node : Node_Id);
|
-- Removes Node, which must be a node that is a member of a node list,
|
-- Removes Node, which must be a node that is a member of a node list,
|
-- from this node list. The contents of Node are not otherwise affected.
|
-- from this node list. The contents of Node are not otherwise affected.
|
|
|
function Remove_Head (List : List_Id) return Node_Id;
|
function Remove_Head (List : List_Id) return Node_Id;
|
-- Removes the head element of a node list, and returns the node (whose
|
-- Removes the head element of a node list, and returns the node (whose
|
-- contents are not otherwise affected) as the result. If the node list
|
-- contents are not otherwise affected) as the result. If the node list
|
-- is empty, then Empty is returned.
|
-- is empty, then Empty is returned.
|
|
|
function Remove_Next (Node : Node_Id) return Node_Id;
|
function Remove_Next (Node : Node_Id) return Node_Id;
|
-- Removes the item immediately following the given node, and returns it
|
-- Removes the item immediately following the given node, and returns it
|
-- as the result. If Node is the last element of the list, then Empty is
|
-- as the result. If Node is the last element of the list, then Empty is
|
-- returned. Node must be a member of a list. Unlike Remove, Remove_Next
|
-- returned. Node must be a member of a list. Unlike Remove, Remove_Next
|
-- is fast and does not involve any list traversal.
|
-- is fast and does not involve any list traversal.
|
|
|
procedure Initialize;
|
procedure Initialize;
|
-- Called at the start of compilation of each new main source file to
|
-- Called at the start of compilation of each new main source file to
|
-- initialize the allocation of the list table. Note that Initialize
|
-- initialize the allocation of the list table. Note that Initialize
|
-- must not be called if Tree_Read is used.
|
-- must not be called if Tree_Read is used.
|
|
|
procedure Lock;
|
procedure Lock;
|
-- Called to lock tables before back end is called
|
-- Called to lock tables before back end is called
|
|
|
procedure Unlock;
|
procedure Unlock;
|
-- Unlock tables, in cases where the back end needs to modify them
|
-- Unlock tables, in cases where the back end needs to modify them
|
|
|
procedure Tree_Read;
|
procedure Tree_Read;
|
-- Initializes internal tables from current tree file using the relevant
|
-- Initializes internal tables from current tree file using the relevant
|
-- Table.Tree_Read routines. Note that Initialize should not be called if
|
-- Table.Tree_Read routines. Note that Initialize should not be called if
|
-- Tree_Read is used. Tree_Read includes all necessary initialization.
|
-- Tree_Read is used. Tree_Read includes all necessary initialization.
|
|
|
procedure Tree_Write;
|
procedure Tree_Write;
|
-- Writes out internal tables to current tree file using the relevant
|
-- Writes out internal tables to current tree file using the relevant
|
-- Table.Tree_Write routines.
|
-- Table.Tree_Write routines.
|
|
|
function Parent (List : List_Id) return Node_Id;
|
function Parent (List : List_Id) return Node_Id;
|
pragma Inline (Parent);
|
pragma Inline (Parent);
|
-- Node lists may have a parent in the same way as a node. The function
|
-- Node lists may have a parent in the same way as a node. The function
|
-- accesses the Parent value, which is either Empty when a list header
|
-- accesses the Parent value, which is either Empty when a list header
|
-- is first created, or the value that has been set by Set_Parent.
|
-- is first created, or the value that has been set by Set_Parent.
|
|
|
procedure Set_Parent (List : List_Id; Node : Node_Id);
|
procedure Set_Parent (List : List_Id; Node : Node_Id);
|
pragma Inline (Set_Parent);
|
pragma Inline (Set_Parent);
|
-- Sets the parent field of the given list to reference the given node
|
-- Sets the parent field of the given list to reference the given node
|
|
|
function No (List : List_Id) return Boolean;
|
function No (List : List_Id) return Boolean;
|
pragma Inline (No);
|
pragma Inline (No);
|
-- Tests given Id for equality with No_List. This allows notations like
|
-- Tests given Id for equality with No_List. This allows notations like
|
-- "if No (Statements)" as opposed to "if Statements = No_List".
|
-- "if No (Statements)" as opposed to "if Statements = No_List".
|
|
|
function Present (List : List_Id) return Boolean;
|
function Present (List : List_Id) return Boolean;
|
pragma Inline (Present);
|
pragma Inline (Present);
|
-- Tests given Id for inequality with No_List. This allows notations like
|
-- Tests given Id for inequality with No_List. This allows notations like
|
-- "if Present (Statements)" as opposed to "if Statements /= No_List".
|
-- "if Present (Statements)" as opposed to "if Statements /= No_List".
|
|
|
procedure Allocate_List_Tables (N : Node_Id);
|
procedure Allocate_List_Tables (N : Node_Id);
|
-- Called when nodes table is expanded to include node N. This call
|
-- Called when nodes table is expanded to include node N. This call
|
-- makes sure that list structures internal to Nlists are adjusted
|
-- makes sure that list structures internal to Nlists are adjusted
|
-- appropriately to reflect this increase in the size of the nodes table.
|
-- appropriately to reflect this increase in the size of the nodes table.
|
|
|
function Next_Node_Address return System.Address;
|
function Next_Node_Address return System.Address;
|
function Prev_Node_Address return System.Address;
|
function Prev_Node_Address return System.Address;
|
-- These functions return the addresses of the Next_Node and Prev_Node
|
-- These functions return the addresses of the Next_Node and Prev_Node
|
-- tables (used in Back_End for Gigi).
|
-- tables (used in Back_End for Gigi).
|
|
|
function p (U : Union_Id) return Node_Id;
|
function p (U : Union_Id) return Node_Id;
|
-- This function is intended for use from the debugger, it determines
|
-- This function is intended for use from the debugger, it determines
|
-- whether U is a Node_Id or List_Id, and calls the appropriate Parent
|
-- whether U is a Node_Id or List_Id, and calls the appropriate Parent
|
-- function and returns the parent Node in either case. This is shorter
|
-- function and returns the parent Node in either case. This is shorter
|
-- to type, and avoids the overloading problem of using Parent. It
|
-- to type, and avoids the overloading problem of using Parent. It
|
-- should NEVER be used except from the debugger. If p is called with
|
-- should NEVER be used except from the debugger. If p is called with
|
-- other than a node or list id value, it returns 99_999_999.
|
-- other than a node or list id value, it returns 99_999_999.
|
|
|
end Nlists;
|
end Nlists;
|
|
|