gcc/ada/nlists.ads

   1 ------------------------------------------------------------------------------
   2 --                                                                          --
   3 --                         GNAT COMPILER COMPONENTS                         --
   4 --                                                                          --
   5 --                               N L I S T S                                --
   6 --                                                                          --
   7 --                                 S p e c                                  --
   8 --                                                                          --
   9 --          Copyright (C) 1992-2024, Free Software Foundation, Inc.         --
  10 --                                                                          --
  11 -- GNAT is free software;  you can  redistribute it  and/or modify it under --
  12 -- terms of the  GNU General Public License as published  by the Free Soft- --
  13 -- ware  Foundation;  either version 3,  or (at your option) any later ver- --
  14 -- sion.  GNAT is distributed in the hope that it will be useful, but WITH- --
  15 -- OUT ANY WARRANTY;  without even the  implied warranty of MERCHANTABILITY --
  16 -- or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License --
  17 -- for  more details.  You should have  received  a copy of the GNU General --
  18 -- Public License  distributed with GNAT; see file COPYING3.  If not, go to --
  19 -- http://www.gnu.org/licenses for a complete copy of the license.          --
  20 --                                                                          --
  21 -- GNAT was originally developed  by the GNAT team at  New York University. --
  22 -- Extensive contributions were provided by Ada Core Technologies Inc.      --
  23 --                                                                          --
  24 ------------------------------------------------------------------------------
  25
  26 --  This package provides facilities for manipulating lists of nodes (see
  27 --  package Atree for format and implementation of tree nodes). The Link field
  28 --  of the nodes is used as the forward pointer for these lists. See also
  29 --  package Elists which provides another form of lists that are not threaded
  30 --  through the nodes (and therefore allow nodes to be on multiple lists).
  31
  32 --  WARNING: There is a C version of this package. Any changes to this
  33 --  source file must be properly reflected in the C header file nlists.h
  34
  35 with System;
  36 with Types; use Types;
  37
  38 package Nlists is
  39
  40    --  A node list is a list of nodes in a special format that means that
  41    --  nodes can be on at most one such list. For each node list, a list
  42    --  header is allocated in the lists table, and a List_Id value references
  43    --  this header, which may be used to access the nodes in the list using
  44    --  the set of routines that define this interface.
  45
  46    function In_Same_List (N1, N2 : Node_Or_Entity_Id) return Boolean;
  47    pragma Inline (In_Same_List);
  48    --  Equivalent to List_Containing (N1) = List_Containing (N2)
  49
  50    function Last_List_Id return List_Id;
  51    pragma Inline (Last_List_Id);
  52    --  Returns Id of last allocated list header
  53
  54    function Lists_Address return System.Address;
  55    pragma Inline (Lists_Address);
  56    --  Return address of Lists table (used in Back_End for Gigi call)
  57
  58    function Num_Lists return Nat;
  59    pragma Inline (Num_Lists);
  60    --  Number of currently allocated lists
  61
  62    function New_List return List_Id;
  63    --  Creates a new empty node list. Typically this is used to initialize
  64    --  a field in some other node which points to a node list where the list
  65    --  is then subsequently filled in using Append calls.
  66
  67    function Empty_List return List_Id renames New_List;
  68    --  Used in contexts where an empty list (as opposed to an initially empty
  69    --  list to be filled in) is required.
  70
  71    function New_List
  72      (Node : Node_Or_Entity_Id) return List_Id;
  73    --  Build a new list initially containing the given node
  74
  75    function New_List
  76      (Node1 : Node_Or_Entity_Id;
  77       Node2 : Node_Or_Entity_Id) return List_Id;
  78    --  Build a new list initially containing the two given nodes
  79
  80    function New_List
  81      (Node1 : Node_Or_Entity_Id;
  82       Node2 : Node_Or_Entity_Id;
  83       Node3 : Node_Or_Entity_Id) return List_Id;
  84    --  Build a new list initially containing the three given nodes
  85
  86    function New_List
  87      (Node1 : Node_Or_Entity_Id;
  88       Node2 : Node_Or_Entity_Id;
  89       Node3 : Node_Or_Entity_Id;
  90       Node4 : Node_Or_Entity_Id) return List_Id;
  91
  92    function New_List
  93      (Node1 : Node_Or_Entity_Id;
  94       Node2 : Node_Or_Entity_Id;
  95       Node3 : Node_Or_Entity_Id;
  96       Node4 : Node_Or_Entity_Id;
  97       Node5 : Node_Or_Entity_Id) return List_Id;
  98    --  Build a new list initially containing the five given nodes
  99
 100    function New_List
 101      (Node1 : Node_Or_Entity_Id;
 102       Node2 : Node_Or_Entity_Id;
 103       Node3 : Node_Or_Entity_Id;
 104       Node4 : Node_Or_Entity_Id;
 105       Node5 : Node_Or_Entity_Id;
 106       Node6 : Node_Or_Entity_Id) return List_Id;
 107    --  Build a new list initially containing the six given nodes
 108
 109    function New_Copy_List (List : List_Id) return List_Id;
 110    --  Creates a new list containing copies (made with Atree.New_Copy) of every
 111    --  node in the original list. If the argument is No_List, then the returned
 112    --  result is No_List. If the argument is an empty list, then the returned
 113    --  result is a new empty list.
 114
 115    function New_Copy_List_Original (List : List_Id) return List_Id;
 116    --  Same as New_Copy_List but copies only nodes coming from source
 117
 118    function First (List : List_Id) return Node_Or_Entity_Id;
 119    pragma Inline (First);
 120    --  Obtains the first element of the given node list or, if the node list
 121    --  has no items or is equal to No_List, then Empty is returned.
 122
 123    function First_Non_Pragma (List : List_Id) return Node_Or_Entity_Id;
 124    --  Used when dealing with a list that can contain pragmas to skip past
 125    --  any initial pragmas and return the first element that is not a pragma.
 126    --  If the list is empty, or if it contains only pragmas, then Empty is
 127    --  returned. It is an error to call this with List = No_List. This function
 128    --  also skips N_Null nodes, which can result from rewriting incorrect
 129    --  pragmas.
 130
 131    function Last (List : List_Id) return Node_Or_Entity_Id;
 132    pragma Inline (Last);
 133    --  Obtains the last element of the given node list or, if the node list
 134    --  has no items, then Empty is returned. It is an error to call Last with
 135    --  a Node_Id or No_List. (No_List is not considered to be the same as an
 136    --  empty node list).
 137
 138    function Last_Non_Pragma (List : List_Id) return Node_Or_Entity_Id;
 139    --  Obtains the last element of a given node list that is not a pragma.
 140    --  If the list is empty, or if it contains only pragmas, then Empty is
 141    --  returned. It is an error to call this with List = No_List.
 142    --  Unlike First_Non_Pragma, this does not skip N_Null nodes.
 143
 144    function List_Length (List : List_Id) return Nat;
 145    --  Returns number of items in the given list. If called on No_List it
 146    --  returns 0, even though No_List is not considered to be the same as an
 147    --  empty list.
 148
 149    function Next (Node : Node_Or_Entity_Id) return Node_Or_Entity_Id;
 150    pragma Inline (Next);
 151    --  This function returns the next node on a node list, or Empty if Node is
 152    --  the last element of the node list. The argument must be a member of a
 153    --  node list.
 154
 155    procedure Next (Node : in out Node_Or_Entity_Id);
 156    pragma Inline (Next);
 157    --  Equivalent to Node := Next (Node);
 158
 159    function Next_Non_Pragma
 160      (Node : Node_Or_Entity_Id) return Node_Or_Entity_Id;
 161    --  This function returns the next node on a node list, skipping past any
 162    --  pragmas, or Empty if there is no non-pragma entry left. The argument
 163    --  must be a member of a node list. This function also skips N_Null nodes,
 164    --  which can result from rewriting incorrect pragmas.
 165
 166    procedure Next_Non_Pragma (Node : in out Node_Or_Entity_Id);
 167    pragma Inline (Next_Non_Pragma);
 168    --  Equivalent to Node := Next_Non_Pragma (Node);
 169
 170    function Prev (Node : Node_Or_Entity_Id) return Node_Or_Entity_Id;
 171    pragma Inline (Prev);
 172    --  This function returns the previous node on a node list, or Empty
 173    --  if Node is the first element of the node list. The argument must be
 174    --  a member of a node list. Note: the implementation does maintain back
 175    --  pointers, so this function executes quickly in constant time.
 176
 177    function Pick (List : List_Id; Index : Pos) return Node_Or_Entity_Id;
 178    --  Given a list, picks out the Index'th entry (1 = first entry). The
 179    --  caller must ensure that Index is in range.
 180
 181    procedure Prev (Node : in out Node_Or_Entity_Id);
 182    pragma Inline (Prev);
 183    --  Equivalent to Node := Prev (Node);
 184
 185    function Prev_Non_Pragma
 186      (Node : Node_Or_Entity_Id) return Node_Or_Entity_Id;
 187    pragma Inline (Prev_Non_Pragma);
 188    --  This function returns the previous node on a node list, skipping any
 189    --  pragmas. If Node is the first element of the list, or if the only
 190    --  elements preceding it are pragmas, then Empty is returned. The
 191    --  argument must be a member of a node list. Note: the implementation
 192    --  maintains back pointers, so this function executes quickly in constant
 193    --  time. Unlike Next_Non_Pragma, this does not skip N_Null nodes.
 194
 195    procedure Prev_Non_Pragma (Node : in out Node_Or_Entity_Id);
 196    pragma Inline (Prev_Non_Pragma);
 197    --  Equivalent to Node := Prev_Non_Pragma (Node);
 198
 199    function Is_Empty_List (List : List_Id) return Boolean;
 200    pragma Inline (Is_Empty_List);
 201    --  This function determines if a given list id references a node list that
 202    --  contains no items. No_List as an argument returns True.
 203
 204    function Is_Non_Empty_List (List : List_Id) return Boolean;
 205    pragma Inline (Is_Non_Empty_List);
 206    --  This function determines if a given list id references a node list that
 207    --  contains at least one item. No_List as an argument returns False.
 208
 209    function Is_List_Member (Node : Node_Or_Entity_Id) return Boolean;
 210    pragma Inline (Is_List_Member);
 211    --  This function determines if a given node is a member of a node list.
 212    --  It is an error for Node to be Empty, or to be a node list.
 213
 214    function List_Containing (Node : Node_Or_Entity_Id) return List_Id;
 215    pragma Inline (List_Containing);
 216    --  This function provides a pointer to the node list containing Node.
 217    --  Node must be a member of a node list.
 218
 219    procedure Append (Node : Node_Or_Entity_Id; To : List_Id);
 220    --  Appends Node at the end of node list To. Node must be a non-empty node
 221    --  that is not already a member of a node list, and To must be a node list.
 222    --  An attempt to append an error node is ignored without complaint and the
 223    --  list is unchanged.
 224
 225    procedure Append_New (Node : Node_Or_Entity_Id; To : in out List_Id);
 226    pragma Inline (Append_New);
 227    --  Appends Node at the end of node list To. If To is non-existent list, a
 228    --  list is created. Node must be a non-empty node that is not already a
 229    --  member of a node list, and To must be a node list.
 230
 231    procedure Append_New_To (To : in out List_Id; Node : Node_Or_Entity_Id);
 232    pragma Inline (Append_New_To);
 233    --  Like Append_New, but the arguments are in reverse order
 234
 235    procedure Append_To (To : List_Id; Node : Node_Or_Entity_Id);
 236    pragma Inline (Append_To);
 237    --  Like Append, but arguments are the other way round
 238
 239    procedure Append_List (List : List_Id; To : List_Id);
 240    --  Appends node list List to the end of node list To. On return,
 241    --  List is reset to be empty.
 242
 243    procedure Append_List_To (To : List_Id; List : List_Id);
 244    pragma Inline (Append_List_To);
 245    --  Like Append_List, but arguments are the other way round
 246
 247    procedure Insert_After
 248      (After : Node_Or_Entity_Id;
 249       Node  : Node_Or_Entity_Id);
 250    --  Insert Node, which must be a non-empty node that is not already a
 251    --  member of a node list, immediately past node After, which must be a
 252    --  node that is currently a member of a node list. An attempt to insert
 253    --  an error node is ignored without complaint (and the list is unchanged).
 254
 255    procedure Insert_List_After
 256      (After : Node_Or_Entity_Id;
 257       List  : List_Id);
 258    --  Inserts the entire contents of node list List immediately after node
 259    --  After, which must be a member of a node list. On return, the node list
 260    --  List is reset to be the empty node list.
 261
 262    procedure Insert_Before
 263      (Before : Node_Or_Entity_Id;
 264       Node   : Node_Or_Entity_Id);
 265    --  Insert Node, which must be a non-empty node that is not already a
 266    --  member of a node list, immediately before Before, which must be a node
 267    --  that is currently a member of a node list. An attempt to insert an
 268    --  error node is ignored without complaint (and the list is unchanged).
 269
 270    procedure Insert_List_Before
 271      (Before : Node_Or_Entity_Id;
 272       List   : List_Id);
 273    --  Inserts the entire contents of node list List immediately before node
 274    --  Before, which must be a member of a node list. On return, the node list
 275    --  List is reset to be the empty node list.
 276
 277    procedure Prepend
 278      (Node : Node_Or_Entity_Id;
 279       To   : List_Id);
 280    --  Prepends Node at the start of node list To. Node must be a non-empty
 281    --  node that is not already a member of a node list, and To must be a
 282    --  node list. An attempt to prepend an error node is ignored without
 283    --  complaint and the list is unchanged.
 284
 285    procedure Prepend_List
 286      (List : List_Id;
 287       To   : List_Id);
 288    --  Prepends node list List to the start of node list To. On return,
 289    --  List is reset to be empty.
 290
 291    procedure Prepend_List_To
 292      (To   : List_Id;
 293       List : List_Id);
 294    pragma Inline (Prepend_List_To);
 295    --  Like Prepend_List, but arguments are the other way round
 296
 297    procedure Prepend_New (Node : Node_Or_Entity_Id; To : in out List_Id);
 298    pragma Inline (Prepend_New);
 299    --  Prepends Node at the end of node list To. If To is non-existent list, a
 300    --  list is created. Node must be a non-empty node that is not already a
 301    --  member of a node list, and To must be a node list.
 302
 303    procedure Prepend_New_To (To : in out List_Id; Node : Node_Or_Entity_Id);
 304    pragma Inline (Prepend_New_To);
 305    --  Like Prepend_New, but the arguments are in reverse order
 306
 307    procedure Prepend_To
 308      (To   : List_Id;
 309       Node : Node_Or_Entity_Id);
 310    pragma Inline (Prepend_To);
 311    --  Like Prepend, but arguments are the other way round
 312
 313    procedure Remove (Node : Node_Or_Entity_Id);
 314    --  Removes Node, which must be a node that is a member of a node list,
 315    --  from this node list. The contents of Node are not otherwise affected.
 316
 317    function Remove_Head (List : List_Id) return Node_Or_Entity_Id;
 318    --  Removes the head element of a node list, and returns the node (whose
 319    --  contents are not otherwise affected) as the result. If the node list
 320    --  is empty, then Empty is returned.
 321
 322    function Remove_Next (Node : Node_Or_Entity_Id) return Node_Or_Entity_Id;
 323    --  Removes the item immediately following the given node, and returns it
 324    --  as the result. If Node is the last element of the list, then Empty is
 325    --  returned. Node must be a member of a list. Unlike Remove, Remove_Next
 326    --  is fast and does not involve any list traversal.
 327
 328    procedure Initialize;
 329    --  Called at the start of compilation of each new main source file to
 330    --  initialize the allocation of the list table.
 331
 332    procedure Lock;
 333    --  Called to lock tables before back end is called
 334
 335    procedure Lock_Lists;
 336    --  Called to lock list contents when assertions are enabled. Without
 337    --  assertions calling this subprogram has no effect. The initial state
 338    --  of the lock is unlocked.
 339
 340    procedure Unlock;
 341    --  Unlock tables, in cases where the back end needs to modify them
 342
 343    procedure Unlock_Lists;
 344    --  Called to unlock list contents when assertions are enabled; if
 345    --  assertions are not enabled calling this subprogram has no effect.
 346
 347    function List_Parent (List : List_Id) return Node_Or_Entity_Id;
 348    pragma Inline (List_Parent);
 349    function Parent (List : List_Id) return Node_Or_Entity_Id
 350      renames List_Parent;
 351    pragma Inline (Parent);
 352    --  Node lists may have a parent in the same way as a node. The function
 353    --  accesses the Parent value, which is either Empty when a list header
 354    --  is first created, or the value that has been set by Set_Parent.
 355    --  Parent has the same name as the one in Atree; List_Parent can be used
 356    --  more easily in the debugger.
 357
 358    procedure Set_List_Parent (List : List_Id; Node : Node_Or_Entity_Id);
 359    pragma Inline (Set_List_Parent);
 360    procedure Set_Parent (List : List_Id; Node : Node_Or_Entity_Id)
 361      renames Set_List_Parent;
 362    pragma Inline (Set_Parent);
 363    --  Sets the parent field of the given list to reference the given node
 364
 365    function No (List : List_Id) return Boolean;
 366    pragma Inline (No);
 367    --  Tests given Id for equality with No_List. This allows notations like
 368    --  "if No (Statements)" as opposed to "if Statements = No_List". Note that
 369    --  an empty list gives False for this test, as opposed to Is_Empty_List
 370    --  which gives True either for No_List or for an empty list.
 371
 372    function Present (List : List_Id) return Boolean;
 373    pragma Inline (Present);
 374    --  Tests given Id for inequality with No_List. This allows notations like
 375    --  "if Present (Statements)" as opposed to "if Statements /= No_List".
 376
 377    procedure Allocate_List_Tables (N : Node_Or_Entity_Id);
 378    pragma Inline (Allocate_List_Tables);
 379    --  Called when nodes table is expanded to include node N. This call
 380    --  makes sure that list structures internal to Nlists are adjusted
 381    --  appropriately to reflect this increase in the size of the nodes table.
 382
 383    function Next_Node_Address return System.Address;
 384    function Prev_Node_Address return System.Address;
 385    --  These functions return the addresses of the Next_Node and Prev_Node
 386    --  tables (used in Back_End for Gigi).
 387
 388 end Nlists;