* java-tree.h (push_labeled_block, pop_labeled_block): Remove.

[pf3gnuchains/gcc-fork.git] / gcc / ada / nlists.h

diff --git a/gcc/ada/nlists.h b/gcc/ada/nlists.h
index 2080fea..7ac62a7 100644 (file)
--- a/gcc/ada/nlists.h
+++ b/gcc/ada/nlists.h
@@ -6,9 +6,7 @@
  *                                                                          *
  *                              C Header File                               *
  *                                                                          *
- *                            $Revision: 1.1 $
- *                                                                          *
- *          Copyright (C) 1992-2001, Free Software Foundation, Inc.         *
+ *          Copyright (C) 1992-2003, Free Software Foundation, Inc.         *
  *                                                                          *
  * GNAT is free software;  you can  redistribute it  and/or modify it under *
  * terms of the  GNU General Public License as published  by the Free Soft- *
@@ -18,11 +16,11 @@
  * 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 GNAT;  see file COPYING.  If not, write *
- * to  the Free Software Foundation,  59 Temple Place - Suite 330,  Boston, *
- * MA 02111-1307, USA.                                                      *
+ * to  the  Free Software Foundation,  51  Franklin  Street,  Fifth  Floor, *
+ * Boston, MA 02110-1301, USA.                                              *
  *                                                                          *
  * GNAT was originally developed  by the GNAT team at  New York University. *
- * It is now maintained by Ada Core Technologies Inc (http://www.gnat.com). *
+ * Extensive contributions were provided by Ada Core Technologies Inc.      *
  *                                                                          *
  ****************************************************************************/
 
@@ -45,100 +43,89 @@ struct List_Header
 
 /* The list headers are stored in an array.  The pointer to this array is
    passed as a parameter to gigi and stored in the global variable
-   List_Headers_Ptr after adjusting it by subtracting List_First_Entry,
-   so that List_Id values can be used as subscripts.   */
+   List_Headers_Ptr.  */
 
 extern struct List_Header *List_Headers_Ptr;
 
-/* The previous and next links for lists are held in two arrays, Next_Node
-   and Prev_Node.  The pointers to these arrays are passed as parameters
-   to gigi and stored in the global variables Prev_Node_Ptr and Next_Node_Ptr
-   after adjusting them by subtracting First_Node_Id so that Node_Id values
-   can be used as subscripts.  */
+/* The previous and next links for lists are held in two arrays, Next_Node and
+   Prev_Node.  The pointers to these arrays are passed as parameters to gigi
+   and stored in the global variables Prev_Node_Ptr and Next_Node_Ptr.  */
 
 extern Node_Id *Next_Node_Ptr;
 extern Node_Id *Prev_Node_Ptr;
 
 /* Node List Access Functions */
 
-static Node_Id First PARAMS ((List_Id));
+static Node_Id First (List_Id);
 
 INLINE Node_Id
-First (List)
-     List_Id List;
+First (List_Id List)
 {
-  return List_Headers_Ptr [List].first;
+  return List_Headers_Ptr[List - First_List_Id].first;
 }
 
 #define First_Non_Pragma nlists__first_non_pragma
-extern Node_Id First_Non_Pragma PARAMS((Node_Id));
+extern Node_Id First_Non_Pragma (Node_Id);
 
-static Node_Id Last PARAMS ((List_Id));
+static Node_Id Last (List_Id);
 
 INLINE Node_Id
-Last (List)
-     List_Id List;
+Last (List_Id List)
 {
-  return List_Headers_Ptr [List].last;
+  return List_Headers_Ptr[List - First_List_Id].last;
 }
 
 #define First_Non_Pragma nlists__first_non_pragma
-extern Node_Id First_Non_Pragma PARAMS((List_Id));
+extern Node_Id First_Non_Pragma (List_Id);
 
-static Node_Id Next PARAMS ((Node_Id));
+static Node_Id Next (Node_Id);
 
 INLINE Node_Id
-Next (Node)
-     Node_Id Node;
+Next (Node_Id Node)
 {
-  return Next_Node_Ptr [Node];
+  return Next_Node_Ptr[Node - First_Node_Id];
 }
 
 #define Next_Non_Pragma nlists__next_non_pragma
-extern Node_Id Next_Non_Pragma PARAMS((List_Id));
+extern Node_Id Next_Non_Pragma (List_Id);
 
-static Node_Id Prev PARAMS ((Node_Id));
+static Node_Id Prev (Node_Id);
 
 INLINE Node_Id
-Prev (Node)
-     Node_Id Node;
+Prev (Node_Id Node)
 {
-  return Prev_Node_Ptr [Node];
+  return Prev_Node_Ptr[Node - First_Node_Id];
 }
 
 
 #define Prev_Non_Pragma nlists__prev_non_pragma
-extern Node_Id Prev_Non_Pragma PARAMS((Node_Id));
+extern Node_Id Prev_Non_Pragma         (Node_Id);
 
-static Boolean Is_Empty_List           PARAMS ((List_Id));
-static Boolean Is_Non_Empty_List       PARAMS ((List_Id));
-static Boolean Is_List_Member          PARAMS ((Node_Id));
-static List_Id List_Containing         PARAMS ((Node_Id));
+static Boolean Is_Empty_List           (List_Id);
+static Boolean Is_Non_Empty_List       (List_Id);
+static Boolean Is_List_Member          (Node_Id);
+static List_Id List_Containing         (Node_Id);
 
 INLINE Boolean
-Is_Empty_List (Id)
-     List_Id Id;
+Is_Empty_List (List_Id Id)
 {
   return (First (Id) == Empty);
 }
 
 INLINE Boolean
-Is_Non_Empty_List (Id)
-     List_Id Id;
+Is_Non_Empty_List (List_Id Id)
 {
   return (Present (Id) && First (Id) != Empty);
 }
 
 INLINE Boolean
-Is_List_Member (Node)
-     Node_Id Node;
+Is_List_Member (Node_Id Node)
 {
-  return Nodes_Ptr [Node].U.K.in_list;
+  return Nodes_Ptr[Node - First_Node_Id].U.K.in_list;
 }
 
 INLINE List_Id
-List_Containing (Node)
-     Node_Id Node;
+List_Containing (Node_Id Node)
 {
-  return Nodes_Ptr [Node].V.NX.link;
+  return Nodes_Ptr[Node - First_Node_Id].V.NX.link;
 }