------------------------------------------------------------------------------
--                                                                          --
--                         GNAT COMPILER COMPONENTS                         --
--                                                                          --
--                               S N A M E S                                --
--                                                                          --
--                                 B o d y                                  --
--                                                                          --
--          Copyright (C) 1992-2021, 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- --
-- OUT 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 GNAT; see file COPYING3.  If not, go to --
-- http://www.gnu.org/licenses for a complete copy of the license.          --
--                                                                          --
-- GNAT was originally developed  by the GNAT team at  New York University. --
-- Extensive contributions were provided by Ada Core Technologies Inc.      --
--                                                                          --
------------------------------------------------------------------------------

with Debug; use Debug;
with Opt;   use Opt;
with Table;
with Types; use Types;

package body Snames is

   --  Table used to record convention identifiers

   type Convention_Id_Entry is record
      Name       : Name_Id;
      Convention : Convention_Id;
   end record;

   package Convention_Identifiers is new Table.Table (
     Table_Component_Type => Convention_Id_Entry,
     Table_Index_Type     => Int,
     Table_Low_Bound      => 1,
     Table_Initial        => 50,
     Table_Increment      => 200,
     Table_Name           => "Name_Convention_Identifiers");

   --  Table of names to be set by Initialize. Each name is terminated by a
   --  single #, and the end of the list is marked by a null entry, i.e. by
   --  two # marks in succession. Note that the table does not include the
   --  entries for a-z, since these are initialized by Namet itself.

   Preset_Names : constant String :=
!! TEMPLATE INSERTION POINT
     "#";

   ---------------------
   -- Generated Names --
   ---------------------

   --  This section lists the various cases of generated names which are
   --  built from existing names by adding unique leading and/or trailing
   --  upper case letters. In some cases these names are built recursively,
   --  in particular names built from types may be built from types which
   --  themselves have generated names. In this list, xxx represents an
   --  existing name to which identifying letters are prepended or appended,
   --  and a trailing n represents a serial number in an external name that
   --  has some semantic significance (e.g. the n'th index type of an array).

   --    xxxA    access type for formal xxx in entry param record   (Exp_Ch9)
   --    xxxB    tag table for tagged type xxx                      (Exp_Ch3)
   --    xxxB    task body procedure for task xxx                   (Exp_Ch9)
   --    xxxD    dispatch table for tagged type xxx                 (Exp_Ch3)
   --    xxxD    discriminal for discriminant xxx                   (Sem_Ch3)
   --    xxxDn   n'th discr check function for rec type xxx         (Exp_Ch3)
   --    xxxE    elaboration boolean flag for task xxx              (Exp_Ch9)
   --    xxxE    dispatch table pointer type for tagged type xxx    (Exp_Ch3)
   --    xxxE    parameters for accept body for entry xxx           (Exp_Ch9)
   --    xxxFn   n'th primitive of a tagged type (named xxx)        (Exp_Ch3)
   --    xxxJ    tag table type index for tagged type xxx           (Exp_Ch3)
   --    xxxM    master Id value for access type xxx                (Exp_Ch3)
   --    xxxP    tag table pointer type for tagged type xxx         (Exp_Ch3)
   --    xxxP    parameter record type for entry xxx                (Exp_Ch9)
   --    xxxPA   access to parameter record type for entry xxx      (Exp_Ch9)
   --    xxxPn   pointer type for n'th primitive of tagged type xxx (Exp_Ch3)
   --    xxxR    dispatch table pointer for tagged type xxx         (Exp_Ch3)
   --    xxxT    tag table type for tagged type xxx                 (Exp_Ch3)
   --    xxxT    literal table for enumeration type xxx             (Sem_Ch3)
   --    xxxV    type for task value record for task xxx            (Exp_Ch9)
   --    xxxX    entry index constant                               (Exp_Ch9)
   --    xxxY    dispatch table type for tagged type xxx            (Exp_Ch3)
   --    xxxZ    size variable for task xxx                         (Exp_Ch9)

   --  TSS names

   --    xxxDA   deep adjust routine for type xxx                   (Exp_TSS)
   --    xxxDF   deep finalize routine for type xxx                 (Exp_TSS)
   --    xxxDI   deep initialize routine for type xxx               (Exp_TSS)
   --    xxxEQ   composite equality routine for record type xxx     (Exp_TSS)
   --    xxxFD   finalize address routine for type xxx              (Exp_TSS)
   --    xxxFA   PolyORB/DSA From_Any converter for type xxx        (Exp_TSS)
   --    xxxIP   initialization procedure for type xxx              (Exp_TSS)
   --    xxxIC   init C++ dispatch tables procedure for type xxx    (Exp_TSS)
   --    xxxRA   RAS type access routine for type xxx               (Exp_TSS)
   --    xxxRD   RAS type dereference routine for type xxx          (Exp_TSS)
   --    xxxRP   Rep to Pos conversion for enumeration type xxx     (Exp_TSS)
   --    xxxSA   array/slice assignment for controlled comp. arrays (Exp_TSS)
   --    xxxSI   stream input attribute subprogram for type xxx     (Exp_TSS)
   --    xxxSO   stream output attribute subprogram for type xxx    (Exp_TSS)
   --    xxxSR   stream read attribute subprogram for type xxx      (Exp_TSS)
   --    xxxSW   stream write attribute subprogram for type xxx     (Exp_TSS)
   --    xxxPI   Put_Image attribute subprogram for type xxx        (Exp_TSS)
   --    xxxTA   PolyORB/DSA To_Any converter for type xxx          (Exp_TSS)
   --    xxxTC   PolyORB/DSA Typecode for type xxx                  (Exp_TSS)

   --  Implicit type names

   --    TxxxT   type of literal table for enumeration type xxx     (Sem_Ch3)

   --  (Note: this list is not complete or accurate ???)

   ----------------------
   -- Get_Attribute_Id --
   ----------------------

   function Get_Attribute_Id (N : Name_Id) return Attribute_Id is
   begin
      if N = Name_CPU then
         return Attribute_CPU;
      elsif N = Name_Dispatching_Domain then
         return Attribute_Dispatching_Domain;
      elsif N = Name_Interrupt_Priority then
         return Attribute_Interrupt_Priority;
      else
         return Attribute_Id'Val (N - First_Attribute_Name);
      end if;
   end Get_Attribute_Id;

   -----------------------
   -- Get_Convention_Id --
   -----------------------

   function Get_Convention_Id (N : Name_Id) return Convention_Id is
   begin
      case N is
         when Name_Ada                   => return Convention_Ada;
         when Name_Ada_Pass_By_Copy      => return Convention_Ada_Pass_By_Copy;
         when Name_Ada_Pass_By_Reference => return
                                              Convention_Ada_Pass_By_Reference;
         when Name_Assembler             => return Convention_Assembler;
         when Name_C                     => return Convention_C;
         when Name_C_Variadic_0          => return Convention_C_Variadic_0;
         when Name_C_Variadic_1          => return Convention_C_Variadic_1;
         when Name_C_Variadic_2          => return Convention_C_Variadic_2;
         when Name_C_Variadic_3          => return Convention_C_Variadic_3;
         when Name_C_Variadic_4          => return Convention_C_Variadic_4;
         when Name_C_Variadic_5          => return Convention_C_Variadic_5;
         when Name_C_Variadic_6          => return Convention_C_Variadic_6;
         when Name_C_Variadic_7          => return Convention_C_Variadic_7;
         when Name_C_Variadic_8          => return Convention_C_Variadic_8;
         when Name_C_Variadic_9          => return Convention_C_Variadic_9;
         when Name_C_Variadic_10         => return Convention_C_Variadic_10;
         when Name_C_Variadic_11         => return Convention_C_Variadic_11;
         when Name_C_Variadic_12         => return Convention_C_Variadic_12;
         when Name_C_Variadic_13         => return Convention_C_Variadic_13;
         when Name_C_Variadic_14         => return Convention_C_Variadic_14;
         when Name_C_Variadic_15         => return Convention_C_Variadic_15;
         when Name_C_Variadic_16         => return Convention_C_Variadic_16;
         when Name_COBOL                 => return Convention_COBOL;
         when Name_CPP                   => return Convention_CPP;
         when Name_Fortran               => return Convention_Fortran;
         when Name_Intrinsic             => return Convention_Intrinsic;
         when Name_Stdcall               => return Convention_Stdcall;
         when Name_Stubbed               => return Convention_Stubbed;

         --  If no direct match, then we must have a convention
         --  identifier pragma that has specified this name.

         when others                     =>
            for J in 1 .. Convention_Identifiers.Last loop
               if N = Convention_Identifiers.Table (J).Name then
                  return Convention_Identifiers.Table (J).Convention;
               end if;
            end loop;

            raise Program_Error;
      end case;
   end Get_Convention_Id;

   -------------------------
   -- Get_Convention_Name --
   -------------------------

   function Get_Convention_Name (C : Convention_Id) return Name_Id is
   begin
      case C is
         when Convention_Ada                   => return Name_Ada;
         when Convention_Ada_Pass_By_Copy      => return Name_Ada_Pass_By_Copy;
         when Convention_Ada_Pass_By_Reference =>
            return Name_Ada_Pass_By_Reference;
         when Convention_Assembler             => return Name_Assembler;
         when Convention_C                     => return Name_C;
         when Convention_C_Variadic_0          => return Name_C_Variadic_0;
         when Convention_C_Variadic_1          => return Name_C_Variadic_1;
         when Convention_C_Variadic_2          => return Name_C_Variadic_2;
         when Convention_C_Variadic_3          => return Name_C_Variadic_3;
         when Convention_C_Variadic_4          => return Name_C_Variadic_4;
         when Convention_C_Variadic_5          => return Name_C_Variadic_5;
         when Convention_C_Variadic_6          => return Name_C_Variadic_6;
         when Convention_C_Variadic_7          => return Name_C_Variadic_7;
         when Convention_C_Variadic_8          => return Name_C_Variadic_8;
         when Convention_C_Variadic_9          => return Name_C_Variadic_9;
         when Convention_C_Variadic_10         => return Name_C_Variadic_10;
         when Convention_C_Variadic_11         => return Name_C_Variadic_11;
         when Convention_C_Variadic_12         => return Name_C_Variadic_12;
         when Convention_C_Variadic_13         => return Name_C_Variadic_13;
         when Convention_C_Variadic_14         => return Name_C_Variadic_14;
         when Convention_C_Variadic_15         => return Name_C_Variadic_15;
         when Convention_C_Variadic_16         => return Name_C_Variadic_16;
         when Convention_COBOL                 => return Name_COBOL;
         when Convention_CPP                   => return Name_CPP;
         when Convention_Entry                 => return Name_Entry;
         when Convention_Fortran               => return Name_Fortran;
         when Convention_Intrinsic             => return Name_Intrinsic;
         when Convention_Protected             => return Name_Protected;
         when Convention_Stdcall               => return Name_Stdcall;
         when Convention_Stubbed               => return Name_Stubbed;
      end case;
   end Get_Convention_Name;

   ---------------------------
   -- Get_Locking_Policy_Id --
   ---------------------------

   function Get_Locking_Policy_Id (N : Name_Id) return Locking_Policy_Id is
   begin
      return Locking_Policy_Id'Val (N - First_Locking_Policy_Name);
   end Get_Locking_Policy_Id;

   -------------------
   -- Get_Pragma_Id --
   -------------------

   function Get_Pragma_Id (N : Name_Id) return Pragma_Id is
   begin
      case N is
         when Name_CPU                              =>
            return Pragma_CPU;
         when Name_Default_Scalar_Storage_Order     =>
            return Pragma_Default_Scalar_Storage_Order;
         when Name_Dispatching_Domain               =>
            return Pragma_Dispatching_Domain;
         when Name_Fast_Math                        =>
            return Pragma_Fast_Math;
         when Name_Interface                        =>
            return Pragma_Interface;
         when Name_Interrupt_Priority               =>
            return Pragma_Interrupt_Priority;
         when Name_Preelaborable_Initialization     =>
            return Pragma_Preelaborable_Initialization;
         when Name_Priority                         =>
            return Pragma_Priority;
         when Name_Secondary_Stack_Size             =>
            return Pragma_Secondary_Stack_Size;
         when Name_Storage_Size                     =>
            return Pragma_Storage_Size;
         when Name_Storage_Unit                     =>
            return Pragma_Storage_Unit;
         when First_Pragma_Name .. Last_Pragma_Name =>
            return Pragma_Id'Val (N - First_Pragma_Name);
         when others                                =>
            return Unknown_Pragma;
      end case;
   end Get_Pragma_Id;

   ---------------------------
   -- Get_Queuing_Policy_Id --
   ---------------------------

   function Get_Queuing_Policy_Id (N : Name_Id) return Queuing_Policy_Id is
   begin
      return Queuing_Policy_Id'Val (N - First_Queuing_Policy_Name);
   end Get_Queuing_Policy_Id;

   ------------------------------------
   -- Get_Task_Dispatching_Policy_Id --
   ------------------------------------

   function Get_Task_Dispatching_Policy_Id
     (N : Name_Id) return Task_Dispatching_Policy_Id
   is
   begin
      return Task_Dispatching_Policy_Id'Val
        (N - First_Task_Dispatching_Policy_Name);
   end Get_Task_Dispatching_Policy_Id;

   ----------------
   -- Initialize --
   ----------------

   procedure Initialize is
      P_Index      : Natural;
      Discard_Name : Name_Id;

   begin
      P_Index := Preset_Names'First;
      loop
         Name_Len := 0;
         while Preset_Names (P_Index) /= '#' loop
            Name_Len := Name_Len + 1;
            Name_Buffer (Name_Len) := Preset_Names (P_Index);
            P_Index := P_Index + 1;
         end loop;

         --  We do the Name_Find call to enter the name into the table, but
         --  we don't need to do anything with the result, since we already
         --  initialized all the preset names to have the right value (we
         --  are depending on the order of the names and Preset_Names).

         Discard_Name := Name_Find;
         P_Index := P_Index + 1;
         exit when Preset_Names (P_Index) = '#';
      end loop;

      --  Make sure that number of names in standard table is correct. If this
      --  check fails, run utility program XSNAMES to construct a new properly
      --  matching version of the body.

      pragma Assert (Discard_Name = Last_Predefined_Name);

      --  Initialize the convention identifiers table with the standard set of
      --  synonyms that we recognize for conventions.

      Convention_Identifiers.Init;

      Convention_Identifiers.Append ((Name_Asm,         Convention_Assembler));
      Convention_Identifiers.Append ((Name_Assembly,    Convention_Assembler));

      Convention_Identifiers.Append ((Name_Default,     Convention_C));
      Convention_Identifiers.Append ((Name_External,    Convention_C));

      Convention_Identifiers.Append ((Name_C_Plus_Plus, Convention_CPP));

      Convention_Identifiers.Append ((Name_DLL,         Convention_Stdcall));
      Convention_Identifiers.Append ((Name_Win32,       Convention_Stdcall));
   end Initialize;

   -----------------------
   -- Is_Attribute_Name --
   -----------------------

   function Is_Attribute_Name (N : Name_Id) return Boolean is
   begin
      --  Don't consider Name_Elab_Subp_Body to be a valid attribute name
      --  unless we are working in CodePeer mode.

      return N in First_Attribute_Name .. Last_Attribute_Name
        and then (CodePeer_Mode or else N /= Name_Elab_Subp_Body);
   end Is_Attribute_Name;

   ----------------------------------
   -- Is_Configuration_Pragma_Name --
   ----------------------------------

   function Is_Configuration_Pragma_Name (N : Name_Id) return Boolean is
   begin
      return N in Configuration_Pragma_Names
        or else N = Name_Default_Scalar_Storage_Order
        or else N = Name_Fast_Math;
   end Is_Configuration_Pragma_Name;

   ------------------------
   -- Is_Convention_Name --
   ------------------------

   function Is_Convention_Name (N : Name_Id) return Boolean is
   begin
      --  Check if this is one of the standard conventions

      if N in First_Convention_Name .. Last_Convention_Name
        or else N = Name_C
      then
         return True;

      --  Otherwise check if it is in convention identifier table

      else
         for J in 1 .. Convention_Identifiers.Last loop
            if N = Convention_Identifiers.Table (J).Name then
               return True;
            end if;
         end loop;

         return False;
      end if;
   end Is_Convention_Name;

   ------------------------------
   -- Is_Entity_Attribute_Name --
   ------------------------------

   function Is_Entity_Attribute_Name (N : Name_Id) return Boolean is
   begin
      return N in First_Entity_Attribute_Name .. Last_Entity_Attribute_Name;
   end Is_Entity_Attribute_Name;

   --------------------------------
   -- Is_Function_Attribute_Name --
   --------------------------------

   function Is_Function_Attribute_Name (N : Name_Id) return Boolean is
   begin
      return N in
        First_Renamable_Function_Attribute ..
          Last_Renamable_Function_Attribute;
   end Is_Function_Attribute_Name;

   ---------------------
   -- Is_Keyword_Name --
   ---------------------

   function Is_Keyword_Name (N : Name_Id) return Boolean is
   begin
      return Get_Name_Table_Byte (N) /= 0
        and then (Ada_Version >= Ada_95
                   or else N not in Ada_95_Reserved_Words)
        and then (Ada_Version >= Ada_2005
                   or else N not in Ada_2005_Reserved_Words
                   or else (Debug_Flag_Dot_DD and then N = Name_Overriding))
                   --  Accept 'overriding' keywords if -gnatd.D is used,
                   --  for compatibility with Ada 95 compilers implementing
                   --  only this Ada 2005 extension.
        and then (Ada_Version >= Ada_2012
                   or else N not in Ada_2012_Reserved_Words);
   end Is_Keyword_Name;

   --------------------------------
   -- Is_Internal_Attribute_Name --
   --------------------------------

   function Is_Internal_Attribute_Name (N : Name_Id) return Boolean is
   begin
      return
        N in First_Internal_Attribute_Name .. Last_Internal_Attribute_Name;
   end Is_Internal_Attribute_Name;

   ----------------------------
   -- Is_Locking_Policy_Name --
   ----------------------------

   function Is_Locking_Policy_Name (N : Name_Id) return Boolean is
   begin
      return N in First_Locking_Policy_Name .. Last_Locking_Policy_Name;
   end Is_Locking_Policy_Name;

   ------------------------------------------
   -- Is_Partition_Elaboration_Policy_Name --
   ------------------------------------------

   function Is_Partition_Elaboration_Policy_Name
     (N : Name_Id) return Boolean
   is
   begin
      return N in First_Partition_Elaboration_Policy_Name ..
                  Last_Partition_Elaboration_Policy_Name;
   end Is_Partition_Elaboration_Policy_Name;

   -----------------------------
   -- Is_Operator_Symbol_Name --
   -----------------------------

   function Is_Operator_Symbol_Name (N : Name_Id) return Boolean is
   begin
      return N in First_Operator_Name .. Last_Operator_Name;
   end Is_Operator_Symbol_Name;

   --------------------
   -- Is_Pragma_Name --
   --------------------

   function Is_Pragma_Name (N : Name_Id) return Boolean is
   begin
      return N in First_Pragma_Name .. Last_Pragma_Name
        or else N = Name_CPU
        or else N = Name_Default_Scalar_Storage_Order
        or else N = Name_Dispatching_Domain
        or else N = Name_Fast_Math
        or else N = Name_Interface
        or else N = Name_Interrupt_Priority
        or else N = Name_Preelaborable_Initialization
        or else N = Name_Priority
        or else N = Name_Secondary_Stack_Size
        or else N = Name_Storage_Size
        or else N = Name_Storage_Unit;
   end Is_Pragma_Name;

   ---------------------------------
   -- Is_Procedure_Attribute_Name --
   ---------------------------------

   function Is_Procedure_Attribute_Name (N : Name_Id) return Boolean is
   begin
      return N in First_Procedure_Attribute .. Last_Procedure_Attribute;
   end Is_Procedure_Attribute_Name;

   ----------------------------
   -- Is_Queuing_Policy_Name --
   ----------------------------

   function Is_Queuing_Policy_Name (N : Name_Id) return Boolean is
   begin
      return N in First_Queuing_Policy_Name .. Last_Queuing_Policy_Name;
   end Is_Queuing_Policy_Name;

   -------------------------------------
   -- Is_Task_Dispatching_Policy_Name --
   -------------------------------------

   function Is_Task_Dispatching_Policy_Name (N : Name_Id) return Boolean is
   begin
      return N in First_Task_Dispatching_Policy_Name ..
                  Last_Task_Dispatching_Policy_Name;
   end Is_Task_Dispatching_Policy_Name;

   ----------------------------
   -- Is_Type_Attribute_Name --
   ----------------------------

   function Is_Type_Attribute_Name (N : Name_Id) return Boolean is
   begin
      return N in First_Type_Attribute_Name .. Last_Type_Attribute_Name;
   end Is_Type_Attribute_Name;

   ----------------------------------
   -- Record_Convention_Identifier --
   ----------------------------------

   procedure Record_Convention_Identifier
     (Id         : Name_Id;
      Convention : Convention_Id)
   is
   begin
      Convention_Identifiers.Append ((Id, Convention));
   end Record_Convention_Identifier;

end Snames;