| blob | 915ec0fe059c5ede09ad2d2016037ea62d113b19 |
1 ------------------------------------------------------------------------------
2 -- --
3 -- GNAT COMPILER COMPONENTS --
4 -- --
5 -- I M P U N I T --
6 -- --
7 -- B o d y --
8 -- --
9 -- Copyright (C) 2000-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 ------------------------------------------------------------------------------
35 -- Note: this package body is used by GNAT Studio and GNATBench to supply a
36 -- list of entries for help on available library routines.
44 -- 8 character name of unit
47 -- True if unit is RM defined. False for any unit that is implementation
48 -- defined (and thus not with'able in No_Implementation_Units mode).
55 -- Short hand for RM_Defined values in lists below
57 ------------------
58 -- Ada 95 Units --
59 ------------------
61 -- The following is a giant string list containing the names of all non-
62 -- implementation internal files, i.e. the complete list of files for
63 -- internal units which a program may legitimately WITH when operating in
64 -- either Ada 95 or Ada 2005 mode.
66 -- Note that this list should match the list of units documented in the
67 -- "GNAT Library" section of the GNAT Reference Manual. A unit listed here
68 -- must either be documented in that section or described in the Ada RM.
72 ------------------------------------------------------
73 -- Ada Hierarchy Units from Ada-95 Reference Manual --
74 ------------------------------------------------------
134 -------------------------------------------------
135 -- RM Required Additions to Ada for GNAT Types --
136 -------------------------------------------------
138 -- Note: Long versions are considered RM defined, but not the Long Long,
139 -- Short, or Short_Short versions.
167 -----------------------------------
168 -- GNAT Defined Additions to Ada --
169 -----------------------------------
190 -- Note: strictly the next two should be Ada 2005 units, but it seems
191 -- harmless (and useful) to make then available in Ada 95 mode, since
192 -- they only deal with Wide_Character, not Wide_Wide_Character.
197 -- Note: strictly the following should be Ada 2012 units, but it seems
198 -- harmless (and useful) to make then available in Ada 95 mode, since
199 -- they do not deal with Wide_Wide_Character.
207 ---------------------------
208 -- GNAT Special IO Units --
209 ---------------------------
211 -- As further explained elsewhere (see Sem_Ch10), the internal packages of
212 -- Text_IO and Wide_Text_IO are actually implemented as separate children,
213 -- but this fact is intended to be hidden from the user completely. Any
214 -- attempt to WITH one of these units will be diagnosed as an error later
215 -- on, but for now we do not consider these internal implementation units
216 -- (if we did, then we would get a junk warning which would be confusing
217 -- and unnecessary, given that we generate a clear error message).
232 ------------------------
233 -- GNAT Library Units --
234 ------------------------
342 -----------------------------------------------------
343 -- Interface Hierarchy Units from Reference Manual --
344 -----------------------------------------------------
352 ------------------------------------------
353 -- GNAT Defined Additions to Interfaces --
354 ------------------------------------------
367 --------------------------------------------------
368 -- System Hierarchy Units from Reference Manual --
369 --------------------------------------------------
377 --------------------------------------
378 -- GNAT Defined Additions to System --
379 --------------------------------------
409 -- The following are strictly speaking Ada 2012 units, but we are allowed
410 -- to add children to system, so we consider them to be implementation
411 -- defined additions to System in earlier versions of Ada.
416 --------------------
417 -- Ada 2005 Units --
418 --------------------
420 -- The following units should be used only in Ada 05 mode
424 --------------------------------------------------------
425 -- Ada Hierarchy Units from Ada 2005 Reference Manual --
426 --------------------------------------------------------
497 ------------------------------------------------------
498 -- RM Required Additions to Ada 2005 for GNAT Types --
499 ------------------------------------------------------
501 -- Note: Long versions are considered RM defined, but not the Long Long,
502 -- Short, or Short_Short versions.
520 ----------------------------------------
521 -- GNAT Defined Additions to Ada 2005 --
522 ----------------------------------------
534 -- Note: strictly the following should be Ada 2012 units, but it seems
535 -- harmless (and useful) to make then available in Ada 2005 mode.
553 ---------------------------
554 -- GNAT Special IO Units --
555 ---------------------------
557 -- See Ada 95 section for further information. These packages are for the
558 -- implementation of the Wide_Wide_Text_IO generic packages.
567 ------------------------
568 -- GNAT Library Units --
569 ------------------------
574 --------------------
575 -- Ada 2012 Units --
576 --------------------
578 -- The following units should be used only in Ada 2012 mode
604 ----------------------------------------
605 -- GNAT Defined Additions to Ada 2012 --
606 ----------------------------------------
612 --------------------
613 -- Ada 2022 Units --
614 --------------------
616 -- The following units should be used only in Ada 2022 mode
634 ----------------------------------------
635 -- GNAT Defined Additions to Ada 2022 --
636 ----------------------------------------
641 );
643 -----------------------
644 -- Alternative Units --
645 -----------------------
647 -- For some implementation units, there is a unit in the GNAT library
648 -- that has identical functionality that is usable. If we have such a
649 -- case we record the appropriate Unit name in Error_Msg_String.
656 -- Array of alternative unit names
669 -- Array giving mapping
674 ("htable", Shtable'Access),
675 ("os_lib", Sos_lib'Access),
676 ("regexp", Sregexp'Access),
677 ("regpat", Sregpat'Access),
678 ("string", Sstring'Access),
679 ("stusta", Sstusta'Access),
680 ("tasloc", Stasloc'Access),
681 ("utf_32", Sutf_32'Access));
683 ----------------------
684 -- Get_Kind_Of_File --
685 ----------------------
687 function Get_Kind_Of_File (File : String) return Kind_Of_Unit is
688 pragma Assert (File'First = 1);
690 Buffer : String (1 .. 9);
692 begin
693 Error_Msg_Strlen := 0;
695 -- Ada/System/Interfaces are all Ada 95 units
697 if File = "ada.ads"
698 or else File = "interfac.ads"
699 or else File = "system.ads"
700 then
701 return Ada_95_Unit;
702 end if;
704 -- Not predefined if file name does not start with a- g- s- i-
706 if File'Length < 3
708 or else
713 then
714 return Not_Predefined_Unit;
715 end if;
717 -- If length of file name is greater than 12, not predefined. The value
718 -- 12 here is an 8 char name with extension .ads. The exception of 13 is
719 -- for the implementation units of the 128-bit types under System.
721 if File'Length > 12
723 then
724 return Not_Predefined_Unit;
725 end if;
727 -- Not predefined if file name does not end in .ads. This can happen
728 -- when non-standard file names are being used.
730 if Name_Buffer (Name_Len - 3 .. Name_Len) /= ".ads" then
731 return Not_Predefined_Unit;
732 end if;
734 -- Otherwise normalize file name to 8 characters
736 Buffer (1 .. File'Length - 4) := File (1 .. File'Length - 4);
738 for J in File'Length - 3 .. 8 loop
740 end loop;
742 -- See if name is in 95 list
744 for J in Non_Imp_File_Names_95'Range loop
745 if Buffer (1 .. 8) = Non_Imp_File_Names_95 (J).Fname then
746 return Ada_95_Unit;
747 end if;
748 end loop;
750 -- See if name is in 2005 list
752 for J in Non_Imp_File_Names_05'Range loop
753 if Buffer (1 .. 8) = Non_Imp_File_Names_05 (J).Fname then
754 return Ada_2005_Unit;
755 end if;
756 end loop;
758 -- See if name is in 2012 list
760 for J in Non_Imp_File_Names_12'Range loop
761 if Buffer (1 .. 8) = Non_Imp_File_Names_12 (J).Fname then
762 return Ada_2012_Unit;
763 end if;
764 end loop;
766 -- See if name is in 2022 list
768 for J in Non_Imp_File_Names_22'Range loop
769 if Buffer (1 .. 8) = Non_Imp_File_Names_22 (J).Fname then
770 return Ada_2022_Unit;
771 end if;
772 end loop;
774 -- Only remaining special possibilities are children of System.RPC and
775 -- System.Garlic and special files of the form System.Aux...
777 if File (1 .. 5) = "s-aux"
778 or else File (1 .. 5) = "s-gar"
779 or else File (1 .. 5) = "s-rpc"
780 then
781 return Ada_95_Unit;
782 end if;
784 -- All tests failed, this is definitely an implementation unit. See if
785 -- we have an alternative name.
787 if File'Length in 11 .. 12
788 and then File (1 .. 2) = "s-"
789 and then File (File'Last - 3 .. File'Last) = ".ads"
790 then
791 for J in Map_Array'Range loop
792 if (File'Length = 12 and then
793 File (3 .. 8) = Map_Array (J).Fname)
794 or else
795 (File'Length = 11 and then
796 File (3 .. 7) = Map_Array (J).Fname (1 .. 5))
797 then
798 Error_Msg_Strlen := Map_Array (J).Aname'Length;
799 Error_Msg_String (1 .. Error_Msg_Strlen) :=
800 Map_Array (J).Aname.all;
801 end if;
802 end loop;
803 end if;
805 return Implementation_Unit;
806 end Get_Kind_Of_File;
808 ----------------------
809 -- Get_Kind_Of_Unit --
810 ----------------------
812 function Get_Kind_Of_Unit (U : Unit_Number_Type) return Kind_Of_Unit is
813 begin
814 Get_Name_String (Unit_File_Name (U));
815 return Get_Kind_Of_File (Name_Buffer (1 .. Name_Len));
816 end Get_Kind_Of_Unit;
818 -------------------
819 -- Is_Known_Unit --
820 -------------------
822 function Is_Known_Unit (Nam : Node_Id) return Boolean is
823 Unam : Unit_Name_Type;
824 Fnam : File_Name_Type;
826 begin
827 -- If selector is not an identifier (e.g. it is a character literal or
828 -- some junk from a previous error), then definitely not a known unit.
830 if Nkind (Selector_Name (Nam)) /= N_Identifier then
831 return False;
832 end if;
834 -- Otherwise get corresponding file name
836 Unam := Get_Unit_Name (Nam);
837 Fnam := Get_File_Name (Unam, Subunit => False);
838 Get_Name_String (Fnam);
840 Error_Msg_Strlen := 0;
842 -- Ada/System/Interfaces are all Ada 95 units
844 if (Name_Len = 7 and then Name_Buffer (1 .. 7) = "ada.ads")
845 or else
846 (Name_Len = 10 and then Name_Buffer (1 .. 10) = "system.ads")
847 or else
848 (Name_Len = 12 and then Name_Buffer (1 .. 12) = "interfac.ads")
849 then
850 return True;
851 end if;
853 -- Remove extension from file name
855 if Name_Buffer (Name_Len - 3 .. Name_Len) = ".adb"
856 or else
857 Name_Buffer (Name_Len - 3 .. Name_Len) = ".ads"
858 then
859 Name_Len := Name_Len - 4;
860 else
861 return False;
862 end if;
864 -- Pad name to 8 characters
866 while Name_Len < 8 loop
867 Name_Len := Name_Len + 1;
869 end loop;
871 -- If length more than 8, definitely not a match
873 if Name_Len /= 8 then
874 return False;
875 end if;
877 -- If length is 8, search our tables
879 for J in Non_Imp_File_Names_95'Range loop
880 if Name_Buffer (1 .. 8) = Non_Imp_File_Names_95 (J).Fname then
881 return True;
882 end if;
883 end loop;
885 for J in Non_Imp_File_Names_05'Range loop
886 if Name_Buffer (1 .. 8) = Non_Imp_File_Names_05 (J).Fname then
887 return True;
888 end if;
889 end loop;
891 for J in Non_Imp_File_Names_12'Range loop
892 if Name_Buffer (1 .. 8) = Non_Imp_File_Names_12 (J).Fname then
893 return True;
894 end if;
895 end loop;
897 -- If not found, not known
899 return False;
901 -- A safety guard, if we get an exception during this processing then it
902 -- is most likely the result of a previous error, or a peculiar case we
903 -- have not thought of. Since this routine is only used for error message
904 -- refinement, we will just return False.
906 exception
907 when others =>
908 return False;
909 end Is_Known_Unit;
911 ---------------------------
912 -- Not_Impl_Defined_Unit --
913 ---------------------------
915 function Not_Impl_Defined_Unit (U : Unit_Number_Type) return Boolean is
916 Fname : constant File_Name_Type := Unit_File_Name (U);
918 begin
919 Error_Msg_Strlen := 0;
920 Get_Name_String (Fname);
922 -- Ada/System/Interfaces are all RM-defined Ada 95 units
924 if (Name_Len = 7 and then Name_Buffer (1 .. 7) = "ada.ads")
925 or else
926 (Name_Len = 10 and then Name_Buffer (1 .. 10) = "system.ads")
927 or else
928 (Name_Len = 12 and then Name_Buffer (1 .. 12) = "interfac.ads")
929 then
930 return True;
931 end if;
933 -- Implementation defined if unit in the gnat hierarchy
935 if (Name_Len = 8 and then Name_Buffer (1 .. 8) = "gnat.ads")
936 or else (Name_Len > 2 and then Name_Buffer (1 .. 2) = "g-")
937 then
938 return False;
939 end if;
941 -- Not implementation defined if file name does not start with a- s- i-
943 if Name_Len < 3
946 and then
948 and then
950 then
951 return True;
952 end if;
954 -- If length of file name is greater than 12, not predefined. The value
955 -- 12 here is an 8 char name with extension .ads. The exception of 13 is
956 -- for the implementation units of the 128-bit types under System.
958 if Name_Len > 12
960 then
961 return True;
962 end if;
964 -- Not impl-defined if file name does not end in .ads. This can happen
965 -- when non-standard file names are being used.
967 if Name_Buffer (Name_Len - 3 .. Name_Len) /= ".ads" then
968 return True;
969 end if;
971 -- Otherwise normalize file name to 8 characters
973 Name_Len := Name_Len - 4;
974 while Name_Len < 8 loop
975 Name_Len := Name_Len + 1;
977 end loop;
979 -- Check our lists of names, if we find a match, return corresponding
980 -- indication of whether the file is RM defined, respecting the RM
981 -- version in which it is defined.
983 for J in Non_Imp_File_Names_95'Range loop
984 if Name_Buffer (1 .. 8) = Non_Imp_File_Names_95 (J).Fname then
985 return Non_Imp_File_Names_95 (J).RMdef;
986 end if;
987 end loop;
989 for J in Non_Imp_File_Names_05'Range loop
990 if Name_Buffer (1 .. 8) = Non_Imp_File_Names_05 (J).Fname then
991 return Non_Imp_File_Names_05 (J).RMdef
992 and then Ada_Version >= Ada_2005;
993 end if;
994 end loop;
996 for J in Non_Imp_File_Names_12'Range loop
997 if Name_Buffer (1 .. 8) = Non_Imp_File_Names_12 (J).Fname then
998 return Non_Imp_File_Names_12 (J).RMdef
999 and then Ada_Version >= Ada_2012;
1000 end if;
1001 end loop;
1003 -- If unit is in System, Ada or Interfaces hierarchies and did not match
1004 -- any entry in the list, means it is an internal implementation defined
1005 -- unit which the restriction should definition forbid.
1007 return True;
1008 end Not_Impl_Defined_Unit;
1010 end Impunit;