CbC/CbC_gcc: gcc/ada/namet.ads comparison

comparison gcc/ada/namet.ads @ 131:84e7813d76e9

gcc-8.2

author	mir3636
date	Thu, 25 Oct 2018 07:37:49 +0900
parents	04ced10e8804
children	1830386684a0

comparison

equal deleted inserted replaced

-:04ced10e8804
+:84e7813d76e9
 --                                                                          --
 --                                N A M E T                                 --
 --                                                                          --
 --                                 S p e c                                  --
 --                                                                          --
---          Copyright (C) 1992-2017, Free Software Foundation, Inc.         --
+--          Copyright (C) 1992-2018, 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- --
 -- 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- --
 No_Name : constant Name_Id := Names_Low_Bound;
 --  The special Name_Id value No_Name is used in the parser to indicate
 --  a situation where no name is present (e.g. on a loop or block).
-Error_Name : constant Name_Id := Names_Low_Bound +  1;
+Error_Name : constant Name_Id := Names_Low_Bound + 1;
 --  The special Name_Id value Error_Name is used in the parser to
 --  indicate that some kind of error was encountered in scanning out
 --  the relevant name, so it does not have a representable label.
-subtype Error_Name_Or_No_Name is Name_Id range No_Name .. Error_Name;
---  Used to test for either error name or no name
 First_Name_Id : constant Name_Id := Names_Low_Bound + 2;
 --  Subscript of first entry in names table
+subtype Valid_Name_Id is Name_Id range First_Name_Id .. Name_Id'Last;
+--  All but No_Name and Error_Name
 ------------------------------
 -- Name_Id Membership Tests --
 ------------------------------
 function To_String (Buf : Bounded_String) return String;
 pragma Inline (To_String);
 function "+" (Buf : Bounded_String) return String renames To_String;
 function Name_Find
-(Buf : Bounded_String := Global_Name_Buffer) return Name_Id;
+(Buf : Bounded_String := Global_Name_Buffer) return Valid_Name_Id;
-function Name_Find (S : String) return Name_Id;
+function Name_Find (S : String) return Valid_Name_Id;
 --  Name_Find searches the names table to see if the string has already been
 --  stored. If so, the Id of the existing entry is returned. Otherwise a new
 --  entry is created with its Name_Table_Int fields set to zero/false. Note
 --  that it is permissible for Buf.Length to be zero to lookup the empty
 --  name string.
 function Name_Enter
-(Buf : Bounded_String := Global_Name_Buffer) return Name_Id;
+(Buf : Bounded_String := Global_Name_Buffer) return Valid_Name_Id;
-function Name_Enter (S : String) return Name_Id;
+function Name_Enter (S : String) return Valid_Name_Id;
 --  Name_Enter is similar to Name_Find. The difference is that it does not
 --  search the table for an existing match, and also subsequent Name_Find
 --  calls using the same name will not locate the entry created by this
 --  call. Thus multiple calls to Name_Enter with the same name will create
 --  multiple entries in the name table with different Name_Id values. This
 --  is useful in the case of created names, which are never expected to be
 --  looked up. Note: Name_Enter should never be used for one character
 --  names, since these are efficiently located without hashing by Name_Find
 --  in any case.
-function Name_Equals (N1 : Name_Id; N2 : Name_Id) return Boolean;
+function Name_Equals
+(N1 : Valid_Name_Id;
+N2 : Valid_Name_Id) return Boolean;
 --  Return whether N1 and N2 denote the same character sequence
-function Get_Name_String (Id : Name_Id) return String;
+function Get_Name_String (Id : Valid_Name_Id) return String;
 --  Returns the characters of Id as a String. The lower bound is 1.
 --  The following Append procedures ignore any characters that don't fit in
 --  Buf.
 --  Append S onto Buf
 procedure Append (Buf : in out Bounded_String; Buf2 : Bounded_String);
 --  Append Buf2 onto Buf
-procedure Append (Buf : in out Bounded_String; Id : Name_Id);
+procedure Append (Buf : in out Bounded_String; Id : Valid_Name_Id);
 --  Append the characters of Id onto Buf. It is an error to call this with
 --  one of the special name Id values (No_Name or Error_Name).
-procedure Append_Decoded (Buf : in out Bounded_String; Id : Name_Id);
+procedure Append_Decoded (Buf : in out Bounded_String; Id : Valid_Name_Id);
 --  Same as Append, except that the result is decoded, so that upper half
 --  characters and wide characters appear as originally found in the source
 --  program text, operators have their source forms (special characters and
 --  enclosed in quotes), and character literals appear surrounded by
 --  apostrophes.
 procedure Append_Decoded_With_Brackets
 (Buf : in out Bounded_String;
-Id  : Name_Id);
+Id  : Valid_Name_Id);
 --  Same as Append_Decoded, except that the brackets notation (Uhh
 --  replaced by ["hh"], Whhhh replaced by ["hhhh"], WWhhhhhhhh replaced by
 --  ["hhhhhhhh"]) is used for all non-lower half characters, regardless of
 --  how Opt.Wide_Character_Encoding_Method is set, and also in that
 --  characters in the range 16#80# .. 16#FF# are converted to brackets
 --  notation in all cases. This routine can be used when there is a
 --  requirement for a canonical representation not affected by the
 --  character set options (e.g. in the binder generation of symbols).
-procedure Append_Unqualified (Buf : in out Bounded_String; Id : Name_Id);
+procedure Append_Unqualified
+(Buf : in out Bounded_String; Id : Valid_Name_Id);
 --  Same as Append, except that qualification (as defined in unit
 --  Exp_Dbug) is removed (including both preceding __ delimited names, and
 --  also the suffixes used to indicate package body entities and to
 --  distinguish between overloaded entities). Note that names are not
 --  qualified until just before the call to gigi, so this routine is only
 --  includes all ASIS processing, since ASIS works on the tree written
 --  after gigi has been called.
 procedure Append_Unqualified_Decoded
 (Buf : in out Bounded_String;
-Id  : Name_Id);
+Id  : Valid_Name_Id);
 --  Same as Append_Unqualified, but decoded as for Append_Decoded
 procedure Append_Encoded (Buf : in out Bounded_String; C : Char_Code);
 --  Appends given character code at the end of Buf. Lower case letters and
 --  digits are stored unchanged. Other 8-bit characters are stored using the
 --  this location get moved beyond the inserted string.
 function Is_Internal_Name (Buf : Bounded_String) return Boolean;
 procedure Get_Last_Two_Chars
-(N  : Name_Id;
+(N  : Valid_Name_Id;
 C1 : out Character;
 C2 : out Character);
 --  Obtains last two characters of a name. C1 is last but one character and
 --  C2 is last character. If name is less than two characters long then both
 --  C1 and C2 are set to ASCII.NUL on return.
-function Get_Name_Table_Boolean1 (Id : Name_Id) return Boolean;
+function Get_Name_Table_Boolean1 (Id : Valid_Name_Id) return Boolean;
-function Get_Name_Table_Boolean2 (Id : Name_Id) return Boolean;
+function Get_Name_Table_Boolean2 (Id : Valid_Name_Id) return Boolean;
-function Get_Name_Table_Boolean3 (Id : Name_Id) return Boolean;
+function Get_Name_Table_Boolean3 (Id : Valid_Name_Id) return Boolean;
 --  Fetches the Boolean values associated with the given name
-function Get_Name_Table_Byte (Id : Name_Id) return Byte;
+function Get_Name_Table_Byte (Id : Valid_Name_Id) return Byte;
 pragma Inline (Get_Name_Table_Byte);
 --  Fetches the Byte value associated with the given name
-function Get_Name_Table_Int (Id : Name_Id) return Int;
+function Get_Name_Table_Int (Id : Valid_Name_Id) return Int;
 pragma Inline (Get_Name_Table_Int);
 --  Fetches the Int value associated with the given name
-procedure Set_Name_Table_Boolean1 (Id : Name_Id; Val : Boolean);
+procedure Set_Name_Table_Boolean1 (Id : Valid_Name_Id; Val : Boolean);
-procedure Set_Name_Table_Boolean2 (Id : Name_Id; Val : Boolean);
+procedure Set_Name_Table_Boolean2 (Id : Valid_Name_Id; Val : Boolean);
-procedure Set_Name_Table_Boolean3 (Id : Name_Id; Val : Boolean);
+procedure Set_Name_Table_Boolean3 (Id : Valid_Name_Id; Val : Boolean);
 --  Sets the Boolean value associated with the given name
-procedure Set_Name_Table_Byte (Id : Name_Id; Val : Byte);
+procedure Set_Name_Table_Byte (Id : Valid_Name_Id; Val : Byte);
 pragma Inline (Set_Name_Table_Byte);
 --  Sets the Byte value associated with the given name
-procedure Set_Name_Table_Int (Id : Name_Id; Val : Int);
+procedure Set_Name_Table_Int (Id : Valid_Name_Id; Val : Int);
 pragma Inline (Set_Name_Table_Int);
 --  Sets the Int value associated with the given name
-function Is_Internal_Name (Id : Name_Id) return Boolean;
+function Is_Internal_Name (Id : Valid_Name_Id) return Boolean;
 --  Returns True if the name is an internal name, i.e. contains a character
 --  for which Is_OK_Internal_Letter is true, or if the name starts or ends
 --  with an underscore.
 --
 --  Note: if the name is qualified (has a double underscore), then only the
 --  suffix of an internally generated name, i.e. it is an upper case letter
 --  other than one of the ones used for encoding source names (currently the
 --  set of reserved letters is O, Q, U, W) and also returns False for the
 --  letter X, which is reserved for debug output (see Exp_Dbug).
-function Is_Operator_Name (Id : Name_Id) return Boolean;
+function Is_Operator_Name (Id : Valid_Name_Id) return Boolean;
 --  Returns True if name given is of the form of an operator (that is, it
 --  starts with an upper case O).
 function Is_Valid_Name (Id : Name_Id) return Boolean;
 --  True if Id is a valid name - points to a valid entry in the Name_Entries
 --  table.
-function Length_Of_Name (Id : Name_Id) return Nat;
+function Length_Of_Name (Id : Valid_Name_Id) return Nat;
 pragma Inline (Length_Of_Name);
 --  Returns length of given name in characters. This is the length of the
 --  encoded name, as stored in the names table.
 procedure Initialize;
 procedure Tree_Write;
 --  Writes out internal tables to current tree file using the relevant
 --  Table.Tree_Write routines.
-procedure Write_Name (Id : Name_Id);
+procedure Write_Name (Id : Valid_Name_Id);
 --  Write_Name writes the characters of the specified name using the
 --  standard output procedures in package Output. The name is written
 --  in encoded form (i.e. including Uhh, Whhh, Qx, _op as they appear in
 --  the name table). If Id is Error_Name, or No_Name, no text is output.
-procedure Write_Name_Decoded (Id : Name_Id);
+procedure Write_Name_Decoded (Id : Valid_Name_Id);
 --  Like Write_Name, except that the name written is the decoded name, as
 --  described for Append_Decoded.
 function Name_Entries_Count return Nat;
 --  Return current number of entries in the names table
 procedure Add_Nat_To_Name_Buffer (V : Nat);
 procedure Add_Str_To_Name_Buffer (S : String);
-procedure Get_Decoded_Name_String (Id : Name_Id);
+procedure Get_Decoded_Name_String (Id : Valid_Name_Id);
-procedure Get_Decoded_Name_String_With_Brackets (Id : Name_Id);
+procedure Get_Decoded_Name_String_With_Brackets (Id : Valid_Name_Id);
-procedure Get_Name_String (Id : Name_Id);
+procedure Get_Name_String (Id : Valid_Name_Id);
-procedure Get_Name_String_And_Append (Id : Name_Id);
+procedure Get_Name_String_And_Append (Id : Valid_Name_Id);
-procedure Get_Unqualified_Decoded_Name_String (Id : Name_Id);
+procedure Get_Unqualified_Decoded_Name_String (Id : Valid_Name_Id);
-procedure Get_Unqualified_Name_String (Id : Name_Id);
+procedure Get_Unqualified_Name_String (Id : Valid_Name_Id);
 procedure Insert_Str_In_Name_Buffer (S : String; Index : Positive);
 function Is_Internal_Name return Boolean;
 end record;
 for Name_Entry'Size use 16 * 8;
 --  This ensures that we did not leave out any fields
---  This is the table that is referenced by Name_Id entries.
+--  This is the table that is referenced by Valid_Name_Id entries.
 --  It contains one entry for each unique name in the table.
 package Name_Entries is new Table.Table (
 Table_Component_Type => Name_Entry,
-Table_Index_Type     => Name_Id'Base,
+Table_Index_Type     => Valid_Name_Id'Base,
 Table_Low_Bound      => First_Name_Id,
 Table_Initial        => Alloc.Names_Initial,
 Table_Increment      => Alloc.Names_Increment,
 Table_Name           => "Name_Entries");

Mercurial > hg > CbC > CbC_gcc

comparison gcc/ada/namet.ads @ 131:84e7813d76e9