[thirdparty/gcc.git] / gcc / ada / par-load.adb

------------------------------------------------------------------------------
--                                                                          --
--                         GNAT COMPILER COMPONENTS                         --
--                                                                          --
--                             P A R . L O A D                              --
--                                                                          --
--                                 B o d y                                  --
--                                                                          --
--          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- --
-- ware  Foundation;  either version 2,  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 COPYING.  If not, write --
-- to  the Free Software Foundation,  59 Temple Place - Suite 330,  Boston, --
-- MA 02111-1307, USA.                                                      --
--                                                                          --
-- GNAT was originally developed  by the GNAT team at  New York University. --
-- Extensive contributions were provided by Ada Core Technologies Inc.      --
--                                                                          --
------------------------------------------------------------------------------

--  The Par.Load procedure loads all units that are definitely required before
--  it makes any sense at all to proceed with semantic analysis, including
--  with'ed units, corresponding specs for bodies, parents of child specs,
--  and parents of subunits. All these units are loaded and pointers installed
--  in the tree as described in the spec of package Lib.

with Fname;    use Fname;
with Fname.UF; use Fname.UF;
with Lib.Load; use Lib.Load;
with Uname;    use Uname;
with Namet;    use Namet;
with Casing;   use Casing;
with Opt;      use Opt;
with Osint;    use Osint;
with Sinput.L; use Sinput.L;
with Stylesw;  use Stylesw;
with Validsw;  use Validsw;

with GNAT.Spelling_Checker; use GNAT.Spelling_Checker;

separate (Par)
procedure Load is

   File_Name : File_Name_Type;
   --  Name of file for current unit, derived from unit name

   Cur_Unum : constant Unit_Number_Type := Current_Source_Unit;
   --  Unit number of unit that we just finished parsing. Note that we need
   --  to capture this, because Source_Unit will change as we parse new
   --  source files in the multiple main source file case.

   Curunit : constant Node_Id := Cunit (Cur_Unum);
   --  Compilation unit node for current compilation unit

   Loc : Source_Ptr := Sloc (Curunit);
   --  Source location for compilation unit node

   Save_Style_Check  : Boolean;
   Save_Style_Checks : Style_Check_Options;
   --  Save style check so it can be restored later

   Save_Validity_Check  : Boolean;
   Save_Validity_Checks : Validity_Check_Options;
   --  Save validity check so it can be restored later

   With_Cunit : Node_Id;
   --  Compilation unit node for withed unit

   Context_Node : Node_Id;
   --  Next node in context items list

   With_Node : Node_Id;
   --  N_With_Clause node

   Spec_Name : Unit_Name_Type;
   --  Unit name of required spec

   Body_Name : Unit_Name_Type;
   --  Unit name of corresponding body

   Unum : Unit_Number_Type;
   --  Unit number of loaded unit

   function Same_File_Name_Except_For_Case
     (Expected_File_Name : File_Name_Type;
      Actual_File_Name   : File_Name_Type)
      return               Boolean;
   --  Given an actual file name and an expected file name (the latter being
   --  derived from the unit name), determine if they are the same except for
   --  possibly different casing of letters.

   function Same_File_Name_Except_For_Case
     (Expected_File_Name : File_Name_Type;
      Actual_File_Name   : File_Name_Type)
      return               Boolean
   is
   begin
      Get_Name_String (Actual_File_Name);
      Canonical_Case_File_Name (Name_Buffer (1 .. Name_Len));

      declare
         Lower_Case_Actual_File_Name : String (1 .. Name_Len);

      begin
         Lower_Case_Actual_File_Name := Name_Buffer (1 .. Name_Len);
         Get_Name_String (Expected_File_Name);
         Canonical_Case_File_Name (Name_Buffer (1 .. Name_Len));
         return Lower_Case_Actual_File_Name = Name_Buffer (1 .. Name_Len);
      end;

   end Same_File_Name_Except_For_Case;

--  Start of processing for Load

begin
   --  Don't do any loads if we already had a fatal error

   if Fatal_Error (Cur_Unum) then
      return;
   end if;

   Save_Style_Check_Options (Save_Style_Checks);
   Save_Style_Check := Opt.Style_Check;

   Save_Validity_Check_Options (Save_Validity_Checks);
   Save_Validity_Check := Opt.Validity_Checks_On;

   --  If main unit, set Main_Unit_Entity (this will get overwritten if
   --  the main unit has a separate spec, that happens later on in Load)

   if Cur_Unum = Main_Unit then
      Main_Unit_Entity := Cunit_Entity (Main_Unit);
   end if;

   --  If we have no unit name, things are seriously messed up by previous
   --  errors, and we should not try to continue compilation.

   if Unit_Name (Cur_Unum) = No_Name then
      raise Unrecoverable_Error;
   end if;

   --  Next step, make sure that the unit name matches the file name
   --  and issue a warning message if not. We only output this for the
   --  main unit, since for other units it is more serious and is
   --  caught in a separate test below.

   File_Name :=
     Get_File_Name
       (Unit_Name (Cur_Unum),
        Subunit => Nkind (Unit (Cunit (Cur_Unum))) = N_Subunit);

   if Cur_Unum = Main_Unit
     and then File_Name /= Unit_File_Name (Cur_Unum)
     and then (File_Names_Case_Sensitive
                or not Same_File_Name_Except_For_Case
                         (File_Name, Unit_File_Name (Cur_Unum)))
   then
      Error_Msg_Name_1 := File_Name;
      Error_Msg
        ("?file name does not match unit name, should be{", Sloc (Curunit));
   end if;

   --  For units other than the main unit, the expected unit name is set and
   --  must be the same as the actual unit name, or we are in big trouble, and
   --  abandon the compilation since there are situations where this really
   --  gets us into bad trouble (e.g. some subunit situations).

   if Cur_Unum /= Main_Unit
     and then Expected_Unit (Cur_Unum) /= Unit_Name (Cur_Unum)
   then
      Loc := Error_Location (Cur_Unum);
      Error_Msg_Name_1 := Unit_File_Name (Cur_Unum);
      Get_Name_String (Error_Msg_Name_1);

      --  Check for predefined file case

      if Name_Len > 1
        and then Name_Buffer (2) = '-'
        and then (Name_Buffer (1) = 'a'
                    or else
                  Name_Buffer (1) = 's'
                    or else
                  Name_Buffer (1) = 'i'
                    or else
                  Name_Buffer (1) = 'g')
      then
         declare
            Expect_Name : constant Name_Id := Expected_Unit (Cur_Unum);
            Actual_Name : constant Name_Id := Unit_Name (Cur_Unum);

         begin
            Error_Msg_Name_1 := Expect_Name;
            Error_Msg ("% is not a predefined library unit!", Loc);

            --  In the predefined file case, we know the user did not
            --  construct their own package, but we got the wrong one.
            --  This means that the name supplied by the user crunched
            --  to something we recognized, but then the file did not
            --  contain the unit expected. Most likely this is due to
            --  a misspelling, e.g.

            --    with Ada.Calender;

            --  This crunches to a-calend, which indeed contains the unit
            --  Ada.Calendar, and we can diagnose the misspelling. This
            --  is a simple heuristic, but it catches many common cases
            --  of misspelling of predefined unit names without needing
            --  a full list of them.

            --  Before actually issinying the message, we will check that the
            --  unit name is indeed a plausible misspelling of the one we got.

            if Is_Bad_Spelling_Of
              (Found  => Get_Name_String (Expect_Name),
               Expect => Get_Name_String (Actual_Name))
            then
               Error_Msg_Name_1 := Actual_Name;
               Error_Msg ("possible misspelling of %!", Loc);
            end if;
         end;

      --  Non-predefined file name case. In this case we generate a message
      --  and then we quit, because we are in big trouble, and if we try
      --  to continue compilation, we get into some nasty situations
      --  (for example in some subunit cases).

      else
         Error_Msg ("file { does not contain expected unit!", Loc);
         Error_Msg_Unit_1 := Expected_Unit (Cur_Unum);
         Error_Msg ("expected unit $!", Loc);
         Error_Msg_Unit_1 := Unit_Name (Cur_Unum);
         Error_Msg ("found unit $!", Loc);
      end if;

      --  In both cases, remove the unit if it is the last unit (which it
      --  normally (always?) will be) so that it is out of the way later.

      Remove_Unit (Cur_Unum);
   end if;

   --  If current unit is a body, load its corresponding spec

   if Nkind (Unit (Curunit)) = N_Package_Body
     or else Nkind (Unit (Curunit)) = N_Subprogram_Body
   then
      Spec_Name := Get_Spec_Name (Unit_Name (Cur_Unum));
      Unum :=
        Load_Unit
          (Load_Name  => Spec_Name,
           Required   => False,
           Subunit    => False,
           Error_Node => Curunit,
           Corr_Body  => Cur_Unum);

      --  If we successfully load the unit, then set the spec pointer. Once
      --  again note that if the loaded unit has a fatal error, Load will
      --  have set our Fatal_Error flag to propagate this condition.

      if Unum /= No_Unit then
         Set_Library_Unit (Curunit, Cunit (Unum));

         --  If this is a separate spec for the main unit, then we reset
         --  Main_Unit_Entity to point to the entity for this separate spec

         if Cur_Unum = Main_Unit then
            Main_Unit_Entity := Cunit_Entity (Unum);
         end if;

      --  If we don't find the spec, then if we have a subprogram body, we
      --  are still OK, we just have a case of a body acting as its own spec

      elsif Nkind (Unit (Curunit)) = N_Subprogram_Body then
         Set_Acts_As_Spec (Curunit, True);
         Set_Library_Unit (Curunit, Curunit);

      --  Otherwise we do have an error, repeat the load request for the spec
      --  with Required set True to generate an appropriate error message.

      else
         Unum :=
           Load_Unit
             (Load_Name  => Spec_Name,
              Required   => True,
              Subunit    => False,
              Error_Node => Curunit);
         return;
      end if;

   --  If current unit is a child unit spec, load its parent

   elsif Nkind (Unit (Curunit)) = N_Package_Declaration
     or else Nkind (Unit (Curunit)) =  N_Subprogram_Declaration
     or else Nkind (Unit (Curunit)) in N_Generic_Declaration
     or else Nkind (Unit (Curunit)) in N_Generic_Instantiation
     or else Nkind (Unit (Curunit)) in N_Renaming_Declaration
   then
      --  Turn style and validity checks off for parent unit

      if not GNAT_Mode then
         Reset_Style_Check_Options;
         Reset_Validity_Check_Options;
      end if;

      Spec_Name := Get_Parent_Spec_Name (Unit_Name (Cur_Unum));

      if Spec_Name /= No_Name then
         Unum :=
           Load_Unit
             (Load_Name  => Spec_Name,
              Required   => True,
              Subunit    => False,
              Error_Node => Curunit);

         if Unum /= No_Unit then
            Set_Parent_Spec (Unit (Curunit), Cunit (Unum));
         end if;
      end if;

   --  If current unit is a subunit, then load its parent body

   elsif Nkind (Unit (Curunit)) = N_Subunit then
      Body_Name := Get_Parent_Body_Name (Unit_Name (Cur_Unum));
      Unum :=
        Load_Unit
          (Load_Name  => Body_Name,
           Required   => True,
           Subunit    => True,
           Error_Node => Name (Unit (Curunit)));

      if Unum /= No_Unit then
         Set_Library_Unit (Curunit, Cunit (Unum));
      end if;

   end if;

   --  Now we load with'ed units, with style/validity checks turned off

   if not GNAT_Mode then
      Reset_Style_Check_Options;
      Reset_Validity_Check_Options;
   end if;

   --  Loop through context items

   Context_Node := First (Context_Items (Curunit));
   while Present (Context_Node) loop

      if Nkind (Context_Node) = N_With_Clause then
         With_Node := Context_Node;
         Spec_Name := Get_Unit_Name (With_Node);

         Unum :=
           Load_Unit
             (Load_Name  => Spec_Name,
              Required   => False,
              Subunit    => False,
              Error_Node => With_Node,
              Renamings  => True);

         --  If we find the unit, then set spec pointer in the N_With_Clause
         --  to point to the compilation unit for the spec. Remember that
         --  the Load routine itself sets our Fatal_Error flag if the loaded
         --  unit gets a fatal error, so we don't need to worry about that.

         if Unum /= No_Unit then
            Set_Library_Unit (With_Node, Cunit (Unum));

         --  If the spec isn't found, then try finding the corresponding
         --  body, since it is possible that we have a subprogram body
         --  that is acting as a spec (since no spec is present).

         else
            Body_Name := Get_Body_Name (Spec_Name);
            Unum :=
              Load_Unit
                (Load_Name  => Body_Name,
                 Required   => False,
                 Subunit    => False,
                 Error_Node => With_Node,
                 Renamings  => True);

            --  If we got a subprogram body, then mark that we are using
            --  the body as a spec in the file table, and set the spec
            --  pointer in the N_With_Clause to point to the body entity.

            if Unum /= No_Unit
              and then Nkind (Unit (Cunit (Unum))) = N_Subprogram_Body
            then
               With_Cunit := Cunit (Unum);
               Set_Library_Unit (With_Node, With_Cunit);
               Set_Acts_As_Spec (With_Cunit, True);
               Set_Library_Unit (With_Cunit, With_Cunit);

            --  If we couldn't find the body, or if it wasn't a body spec
            --  then we are in trouble. We make one more call to Load to
            --  require the spec. We know it will fail of course, the
            --  purpose is to generate the required error message (we prefer
            --  that this message refer to the missing spec, not the body)

            else
               Unum :=
                 Load_Unit
                   (Load_Name  => Spec_Name,
                    Required   => True,
                    Subunit    => False,
                    Error_Node => With_Node,
                    Renamings  => True);

               --  Here we create a dummy package unit for the missing unit

               Unum := Create_Dummy_Package_Unit (With_Node, Spec_Name);
               Set_Library_Unit (With_Node, Cunit (Unum));
            end if;
         end if;
      end if;

      Next (Context_Node);
   end loop;

   --  Restore style/validity check mode for main unit

   Set_Style_Check_Options (Save_Style_Checks);
   Opt.Style_Check := Save_Style_Check;
   Set_Validity_Check_Options (Save_Validity_Checks);
   Opt.Validity_Checks_On := Save_Validity_Check;
end Load;
Commit	Line	Data
19235870 RK	1	------------------------------------------------------------------------------
	2	-- --
	3	-- GNAT COMPILER COMPONENTS --
	4	-- --
	5	-- P A R . L O A D --
	6	-- --
	7	-- B o d y --
	8	-- --
6c1e24d3	9	-- Copyright (C) 1992-2003 Free Software Foundation, Inc. --
19235870 RK	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 2, 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 COPYING. If not, write --
	19	-- to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, --
	20	-- MA 02111-1307, USA. --
	21	-- --
	22	-- GNAT was originally developed by the GNAT team at New York University. --
71ff80dc	23	-- Extensive contributions were provided by Ada Core Technologies Inc. --
19235870 RK	24	-- --
	25	------------------------------------------------------------------------------
	26
	27	-- The Par.Load procedure loads all units that are definitely required before
	28	-- it makes any sense at all to proceed with semantic analysis, including
	29	-- with'ed units, corresponding specs for bodies, parents of child specs,
	30	-- and parents of subunits. All these units are loaded and pointers installed
	31	-- in the tree as described in the spec of package Lib.
	32
	33	with Fname; use Fname;
	34	with Fname.UF; use Fname.UF;
	35	with Lib.Load; use Lib.Load;
	36	with Uname; use Uname;
	37	with Namet; use Namet;
	38	with Casing; use Casing;
	39	with Opt; use Opt;
	40	with Osint; use Osint;
	41	with Sinput.L; use Sinput.L;
	42	with Stylesw; use Stylesw;
	43	with Validsw; use Validsw;
	44
6c1e24d3 AC	45	with GNAT.Spelling_Checker; use GNAT.Spelling_Checker;
6c1e24d3 AC	46
19235870 RK	47	separate (Par)
	48	procedure Load is
	49
	50	File_Name : File_Name_Type;
	51	-- Name of file for current unit, derived from unit name
	52
fbf5a39b	53	Cur_Unum : constant Unit_Number_Type := Current_Source_Unit;
19235870 RK	54	-- Unit number of unit that we just finished parsing. Note that we need
	55	-- to capture this, because Source_Unit will change as we parse new
	56	-- source files in the multiple main source file case.
	57
	58	Curunit : constant Node_Id := Cunit (Cur_Unum);
	59	-- Compilation unit node for current compilation unit
	60
	61	Loc : Source_Ptr := Sloc (Curunit);
	62	-- Source location for compilation unit node
	63
	64	Save_Style_Check : Boolean;
	65	Save_Style_Checks : Style_Check_Options;
	66	-- Save style check so it can be restored later
	67
	68	Save_Validity_Check : Boolean;
	69	Save_Validity_Checks : Validity_Check_Options;
	70	-- Save validity check so it can be restored later
	71
	72	With_Cunit : Node_Id;
	73	-- Compilation unit node for withed unit
	74
	75	Context_Node : Node_Id;
	76	-- Next node in context items list
	77
	78	With_Node : Node_Id;
	79	-- N_With_Clause node
	80
	81	Spec_Name : Unit_Name_Type;
	82	-- Unit name of required spec
	83
	84	Body_Name : Unit_Name_Type;
	85	-- Unit name of corresponding body
	86
	87	Unum : Unit_Number_Type;
	88	-- Unit number of loaded unit
	89
	90	function Same_File_Name_Except_For_Case
	91	(Expected_File_Name : File_Name_Type;
	92	Actual_File_Name : File_Name_Type)
	93	return Boolean;
	94	-- Given an actual file name and an expected file name (the latter being
	95	-- derived from the unit name), determine if they are the same except for
	96	-- possibly different casing of letters.
	97
	98	function Same_File_Name_Except_For_Case
	99	(Expected_File_Name : File_Name_Type;
	100	Actual_File_Name : File_Name_Type)
	101	return Boolean
	102	is
	103	begin
	104	Get_Name_String (Actual_File_Name);
	105	Canonical_Case_File_Name (Name_Buffer (1 .. Name_Len));
	106
	107	declare
	108	Lower_Case_Actual_File_Name : String (1 .. Name_Len);
	109
	110	begin
	111	Lower_Case_Actual_File_Name := Name_Buffer (1 .. Name_Len);
	112	Get_Name_String (Expected_File_Name);
	113	Canonical_Case_File_Name (Name_Buffer (1 .. Name_Len));
	114	return Lower_Case_Actual_File_Name = Name_Buffer (1 .. Name_Len);
	115	end;
	116
	117	end Same_File_Name_Except_For_Case;
118
119	-- Start of processing for Load
120
121	begin
122	-- Don't do any loads if we already had a fatal error
123
124	if Fatal_Error (Cur_Unum) then
125	return;
126	end if;
127
128	Save_Style_Check_Options (Save_Style_Checks);
129	Save_Style_Check := Opt.Style_Check;
130
131	Save_Validity_Check_Options (Save_Validity_Checks);
132	Save_Validity_Check := Opt.Validity_Checks_On;
133
134	-- If main unit, set Main_Unit_Entity (this will get overwritten if
135	-- the main unit has a separate spec, that happens later on in Load)
136
137	if Cur_Unum = Main_Unit then
138	Main_Unit_Entity := Cunit_Entity (Main_Unit);
139	end if;
140
141	-- If we have no unit name, things are seriously messed up by previous
142	-- errors, and we should not try to continue compilation.
143
144	if Unit_Name (Cur_Unum) = No_Name then
145	raise Unrecoverable_Error;
146	end if;
147
148	-- Next step, make sure that the unit name matches the file name
149	-- and issue a warning message if not. We only output this for the
150	-- main unit, since for other units it is more serious and is
151	-- caught in a separate test below.
152
153	File_Name :=
154	Get_File_Name
155	(Unit_Name (Cur_Unum),
156	Subunit => Nkind (Unit (Cunit (Cur_Unum))) = N_Subunit);
157
158	if Cur_Unum = Main_Unit
159	and then File_Name /= Unit_File_Name (Cur_Unum)
160	and then (File_Names_Case_Sensitive
161	or not Same_File_Name_Except_For_Case
162	(File_Name, Unit_File_Name (Cur_Unum)))
163	then
164	Error_Msg_Name_1 := File_Name;
165	Error_Msg
166	("?file name does not match unit name, should be{", Sloc (Curunit));
167	end if;
168
169	-- For units other than the main unit, the expected unit name is set and
170	-- must be the same as the actual unit name, or we are in big trouble, and
171	-- abandon the compilation since there are situations where this really
172	-- gets us into bad trouble (e.g. some subunit situations).
173
174	if Cur_Unum /= Main_Unit
175	and then Expected_Unit (Cur_Unum) /= Unit_Name (Cur_Unum)
176	then
177	Loc := Error_Location (Cur_Unum);
178	Error_Msg_Name_1 := Unit_File_Name (Cur_Unum);
179	Get_Name_String (Error_Msg_Name_1);
180
181	-- Check for predefined file case
182
183	if Name_Len > 1
184	and then Name_Buffer (2) = '-'
185	and then (Name_Buffer (1) = 'a'
186	or else
187	Name_Buffer (1) = 's'
188	or else
189	Name_Buffer (1) = 'i'
190	or else
191	Name_Buffer (1) = 'g')
192	then
6c1e24d3 AC	193	declare
	194	Expect_Name : constant Name_Id := Expected_Unit (Cur_Unum);
	195	Actual_Name : constant Name_Id := Unit_Name (Cur_Unum);
	196
	197	begin
	198	Error_Msg_Name_1 := Expect_Name;
	199	Error_Msg ("% is not a predefined library unit!", Loc);
	200
	201	-- In the predefined file case, we know the user did not
	202	-- construct their own package, but we got the wrong one.
	203	-- This means that the name supplied by the user crunched
	204	-- to something we recognized, but then the file did not
	205	-- contain the unit expected. Most likely this is due to
	206	-- a misspelling, e.g.
	207
	208	-- with Ada.Calender;
	209
	210	-- This crunches to a-calend, which indeed contains the unit
	211	-- Ada.Calendar, and we can diagnose the misspelling. This
	212	-- is a simple heuristic, but it catches many common cases
	213	-- of misspelling of predefined unit names without needing
	214	-- a full list of them.
	215
	216	-- Before actually issinying the message, we will check that the
	217	-- unit name is indeed a plausible misspelling of the one we got.
	218
	219	if Is_Bad_Spelling_Of
	220	(Found => Get_Name_String (Expect_Name),
	221	Expect => Get_Name_String (Actual_Name))
	222	then
	223	Error_Msg_Name_1 := Actual_Name;
	224	Error_Msg ("possible misspelling of %!", Loc);
	225	end if;
	226	end;
	227
	228	-- Non-predefined file name case. In this case we generate a message
	229	-- and then we quit, because we are in big trouble, and if we try
	230	-- to continue compilation, we get into some nasty situations
	231	-- (for example in some subunit cases).
19235870 RK	232
	233	else
	234	Error_Msg ("file { does not contain expected unit!", Loc);
	235	Error_Msg_Unit_1 := Expected_Unit (Cur_Unum);
	236	Error_Msg ("expected unit $!", Loc);
	237	Error_Msg_Unit_1 := Unit_Name (Cur_Unum);
	238	Error_Msg ("found unit $!", Loc);
	239	end if;
	240
6c1e24d3 AC	241	-- In both cases, remove the unit if it is the last unit (which it
	242	-- normally (always?) will be) so that it is out of the way later.
	243
	244	Remove_Unit (Cur_Unum);
19235870 RK	245	end if;
	246
	247	-- If current unit is a body, load its corresponding spec
	248
	249	if Nkind (Unit (Curunit)) = N_Package_Body
	250	or else Nkind (Unit (Curunit)) = N_Subprogram_Body
	251	then
	252	Spec_Name := Get_Spec_Name (Unit_Name (Cur_Unum));
	253	Unum :=
	254	Load_Unit
	255	(Load_Name => Spec_Name,
	256	Required => False,
	257	Subunit => False,
	258	Error_Node => Curunit,
	259	Corr_Body => Cur_Unum);
	260
	261	-- If we successfully load the unit, then set the spec pointer. Once
	262	-- again note that if the loaded unit has a fatal error, Load will
	263	-- have set our Fatal_Error flag to propagate this condition.
	264
	265	if Unum /= No_Unit then
	266	Set_Library_Unit (Curunit, Cunit (Unum));
	267
	268	-- If this is a separate spec for the main unit, then we reset
	269	-- Main_Unit_Entity to point to the entity for this separate spec
	270
	271	if Cur_Unum = Main_Unit then
	272	Main_Unit_Entity := Cunit_Entity (Unum);
	273	end if;
	274
	275	-- If we don't find the spec, then if we have a subprogram body, we
	276	-- are still OK, we just have a case of a body acting as its own spec
	277
	278	elsif Nkind (Unit (Curunit)) = N_Subprogram_Body then
	279	Set_Acts_As_Spec (Curunit, True);
	280	Set_Library_Unit (Curunit, Curunit);
	281
	282	-- Otherwise we do have an error, repeat the load request for the spec
	283	-- with Required set True to generate an appropriate error message.
	284
	285	else
	286	Unum :=
	287	Load_Unit
	288	(Load_Name => Spec_Name,
	289	Required => True,
	290	Subunit => False,
	291	Error_Node => Curunit);
	292	return;
	293	end if;
	294
	295	-- If current unit is a child unit spec, load its parent
	296
	297	elsif Nkind (Unit (Curunit)) = N_Package_Declaration
	298	or else Nkind (Unit (Curunit)) = N_Subprogram_Declaration
	299	or else Nkind (Unit (Curunit)) in N_Generic_Declaration
	300	or else Nkind (Unit (Curunit)) in N_Generic_Instantiation
	301	or else Nkind (Unit (Curunit)) in N_Renaming_Declaration
	302	then
	303	-- Turn style and validity checks off for parent unit
	304
	305	if not GNAT_Mode then
	306	Reset_Style_Check_Options;
	307	Reset_Validity_Check_Options;
	308	end if;
309
310	Spec_Name := Get_Parent_Spec_Name (Unit_Name (Cur_Unum));
311
312	if Spec_Name /= No_Name then
313	Unum :=
314	Load_Unit
315	(Load_Name => Spec_Name,
316	Required => True,
317	Subunit => False,
318	Error_Node => Curunit);
319
320	if Unum /= No_Unit then
321	Set_Parent_Spec (Unit (Curunit), Cunit (Unum));
322	end if;
323	end if;
324
325	-- If current unit is a subunit, then load its parent body
326
327	elsif Nkind (Unit (Curunit)) = N_Subunit then
328	Body_Name := Get_Parent_Body_Name (Unit_Name (Cur_Unum));
329	Unum :=
330	Load_Unit
331	(Load_Name => Body_Name,
332	Required => True,
333	Subunit => True,
334	Error_Node => Name (Unit (Curunit)));
335
336	if Unum /= No_Unit then
337	Set_Library_Unit (Curunit, Cunit (Unum));
338	end if;
339
340	end if;
341
342	-- Now we load with'ed units, with style/validity checks turned off
343
344	if not GNAT_Mode then
345	Reset_Style_Check_Options;
346	Reset_Validity_Check_Options;
347	end if;
348
349	-- Loop through context items
350
351	Context_Node := First (Context_Items (Curunit));
352	while Present (Context_Node) loop
353
354	if Nkind (Context_Node) = N_With_Clause then
355	With_Node := Context_Node;
356	Spec_Name := Get_Unit_Name (With_Node);
357
358	Unum :=
359	Load_Unit
360	(Load_Name => Spec_Name,
361	Required => False,
362	Subunit => False,
363	Error_Node => With_Node,
364	Renamings => True);
365
366	-- If we find the unit, then set spec pointer in the N_With_Clause
367	-- to point to the compilation unit for the spec. Remember that
368	-- the Load routine itself sets our Fatal_Error flag if the loaded
369	-- unit gets a fatal error, so we don't need to worry about that.
370
371	if Unum /= No_Unit then
372	Set_Library_Unit (With_Node, Cunit (Unum));
373
374	-- If the spec isn't found, then try finding the corresponding
375	-- body, since it is possible that we have a subprogram body
376	-- that is acting as a spec (since no spec is present).
377
378	else
379	Body_Name := Get_Body_Name (Spec_Name);
380	Unum :=
381	Load_Unit
382	(Load_Name => Body_Name,
383	Required => False,
384	Subunit => False,
385	Error_Node => With_Node,
386	Renamings => True);
387
388	-- If we got a subprogram body, then mark that we are using
389	-- the body as a spec in the file table, and set the spec
390	-- pointer in the N_With_Clause to point to the body entity.
391
392	if Unum /= No_Unit
393	and then Nkind (Unit (Cunit (Unum))) = N_Subprogram_Body
394	then
395	With_Cunit := Cunit (Unum);
396	Set_Library_Unit (With_Node, With_Cunit);
397	Set_Acts_As_Spec (With_Cunit, True);
398	Set_Library_Unit (With_Cunit, With_Cunit);
399
400	-- If we couldn't find the body, or if it wasn't a body spec
401	-- then we are in trouble. We make one more call to Load to
402	-- require the spec. We know it will fail of course, the
403	-- purpose is to generate the required error message (we prefer
404	-- that this message refer to the missing spec, not the body)
405
406	else
407	Unum :=
408	Load_Unit
409	(Load_Name => Spec_Name,
410	Required => True,
411	Subunit => False,
412	Error_Node => With_Node,
413	Renamings => True);
414
415	-- Here we create a dummy package unit for the missing unit
416
417	Unum := Create_Dummy_Package_Unit (With_Node, Spec_Name);
418	Set_Library_Unit (With_Node, Cunit (Unum));
419	end if;
420	end if;
421	end if;
422
423	Next (Context_Node);
424	end loop;
425
426	-- Restore style/validity check mode for main unit
427
428	Set_Style_Check_Options (Save_Style_Checks);
429	Opt.Style_Check := Save_Style_Check;
430	Set_Validity_Check_Options (Save_Validity_Checks);
431	Opt.Validity_Checks_On := Save_Validity_Check;
432	end Load;