a-cgaaso$(objext) \
a-cgarso$(objext) \
a-cgcaso$(objext) \
+ a-chacon$(objext) \
a-chahan$(objext) \
a-charac$(objext) \
a-chlat1$(objext) \
a-suteio$(objext) \
a-swmwco$(objext) \
a-swunau$(objext) \
- a-swunha$(objext) \
+ a-swuwha$(objext) \
a-swuwti$(objext) \
a-szmzco$(objext) \
a-szunau$(objext) \
- a-szunha$(objext) \
+ a-szuzha$(objext) \
a-szuzti$(objext) \
a-tags$(objext) \
a-tgdico$(objext) \
a-tiunio$(objext) \
a-unccon$(objext) \
a-uncdea$(objext) \
+ a-wichun$(objext) \
+ a-widcha$(objext) \
a-witeio$(objext) \
a-wtcoau$(objext) \
a-wtcoio$(objext) \
a-wtmoio$(objext) \
a-wttest$(objext) \
a-wwunio$(objext) \
+ a-zchara$(objext) \
+ a-zchuni$(objext) \
a-ztcoau$(objext) \
a-ztcoio$(objext) \
a-ztcstr$(objext) \
--- /dev/null
+------------------------------------------------------------------------------
+-- --
+-- GNAT RUN-TIME COMPONENTS --
+-- --
+-- A D A . C H A R A C T E R S . H A N D L I N G --
+-- --
+-- B o d y --
+-- --
+-- Copyright (C) 2005 Free Software Foundation, Inc. --
+-- --
+-- This specification is derived from the Ada Reference Manual for use with --
+-- GNAT. The copyright notice above, and the license provisions that follow --
+-- apply solely to the contents of the part following the private keyword. --
+-- --
+-- 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. --
+-- --
+-- As a special exception, if other files instantiate generics from this --
+-- unit, or you link this unit with other files to produce an executable, --
+-- this unit does not by itself cause the resulting executable to be --
+-- covered by the GNU General Public License. This exception does not --
+-- however invalidate any other reasons why the executable file might be --
+-- covered by the GNU Public License. --
+-- --
+-- GNAT was originally developed by the GNAT team at New York University. --
+-- Extensive contributions were provided by Ada Core Technologies Inc. --
+-- --
+------------------------------------------------------------------------------
+
+package body Ada.Characters.Conversions is
+
+ ------------------
+ -- Is_Character --
+ ------------------
+
+ function Is_Character (Item : Wide_Character) return Boolean is
+ begin
+ return Wide_Character'Pos (Item) < 256;
+ end Is_Character;
+
+ function Is_Character (Item : Wide_Wide_Character) return Boolean is
+ begin
+ return Wide_Wide_Character'Pos (Item) < 256;
+ end Is_Character;
+
+ ---------------
+ -- Is_String --
+ ---------------
+
+ function Is_String (Item : Wide_String) return Boolean is
+ begin
+ for J in Item'Range loop
+ if Wide_Character'Pos (Item (J)) >= 256 then
+ return False;
+ end if;
+ end loop;
+
+ return True;
+ end Is_String;
+
+ function Is_String (Item : Wide_Wide_String) return Boolean is
+ begin
+ for J in Item'Range loop
+ if Wide_Wide_Character'Pos (Item (J)) >= 256 then
+ return False;
+ end if;
+ end loop;
+
+ return True;
+ end Is_String;
+
+ -----------------------
+ -- Is_Wide_Character --
+ -----------------------
+
+ function Is_Wide_Character (Item : Wide_Wide_Character) return Boolean is
+ begin
+ return Wide_Wide_Character'Pos (Item) < 2**16;
+ end Is_Wide_Character;
+
+ --------------------
+ -- Is_Wide_String --
+ --------------------
+
+ function Is_Wide_String (Item : Wide_Wide_String) return Boolean is
+ begin
+ for J in Item'Range loop
+ if Wide_Wide_Character'Pos (Item (J)) >= 2**16 then
+ return False;
+ end if;
+ end loop;
+
+ return True;
+ end Is_Wide_String;
+
+ ------------------
+ -- To_Character --
+ ------------------
+
+ function To_Character
+ (Item : Wide_Character;
+ Substitute : Character := ' ') return Character
+ is
+ begin
+ if Is_Character (Item) then
+ return Character'Val (Wide_Character'Pos (Item));
+ else
+ return Substitute;
+ end if;
+ end To_Character;
+
+ function To_Character
+ (Item : Wide_Wide_Character;
+ Substitute : Character := ' ') return Character
+ is
+ begin
+ if Is_Character (Item) then
+ return Character'Val (Wide_Wide_Character'Pos (Item));
+ else
+ return Substitute;
+ end if;
+ end To_Character;
+
+ ---------------
+ -- To_String --
+ ---------------
+
+ function To_String
+ (Item : Wide_String;
+ Substitute : Character := ' ') return String
+ is
+ Result : String (1 .. Item'Length);
+
+ begin
+ for J in Item'Range loop
+ Result (J - (Item'First - 1)) := To_Character (Item (J), Substitute);
+ end loop;
+
+ return Result;
+ end To_String;
+
+ function To_String
+ (Item : Wide_Wide_String;
+ Substitute : Character := ' ') return String
+ is
+ Result : String (1 .. Item'Length);
+
+ begin
+ for J in Item'Range loop
+ Result (J - (Item'First - 1)) := To_Character (Item (J), Substitute);
+ end loop;
+
+ return Result;
+ end To_String;
+
+ -----------------------
+ -- To_Wide_Character --
+ -----------------------
+
+ function To_Wide_Character
+ (Item : Character) return Wide_Character
+ is
+ begin
+ return Wide_Character'Val (Character'Pos (Item));
+ end To_Wide_Character;
+
+ function To_Wide_Character
+ (Item : Wide_Wide_Character;
+ Substitute : Wide_Character := ' ') return Wide_Character
+ is
+ begin
+ if Wide_Wide_Character'Pos (Item) < 2**16 then
+ return Wide_Character'Val (Wide_Wide_Character'Pos (Item));
+ else
+ return Substitute;
+ end if;
+ end To_Wide_Character;
+
+ --------------------
+ -- To_Wide_String --
+ --------------------
+
+ function To_Wide_String
+ (Item : String) return Wide_String
+ is
+ Result : Wide_String (1 .. Item'Length);
+
+ begin
+ for J in Item'Range loop
+ Result (J - (Item'First - 1)) := To_Wide_Character (Item (J));
+ end loop;
+
+ return Result;
+ end To_Wide_String;
+
+ function To_Wide_String
+ (Item : Wide_Wide_String;
+ Substitute : Wide_Character := ' ') return Wide_String
+ is
+ Result : Wide_String (1 .. Item'Length);
+
+ begin
+ for J in Item'Range loop
+ Result (J - (Item'First - 1)) :=
+ To_Wide_Character (Item (J), Substitute);
+ end loop;
+
+ return Result;
+ end To_Wide_String;
+
+ ----------------------------
+ -- To_Wide_Wide_Character --
+ ----------------------------
+
+ function To_Wide_Wide_Character
+ (Item : Character) return Wide_Wide_Character
+ is
+ begin
+ return Wide_Wide_Character'Val (Character'Pos (Item));
+ end To_Wide_Wide_Character;
+
+ function To_Wide_Wide_Character
+ (Item : Wide_Character) return Wide_Wide_Character
+ is
+ begin
+ return Wide_Wide_Character'Val (Wide_Character'Pos (Item));
+ end To_Wide_Wide_Character;
+
+ -------------------------
+ -- To_Wide_Wide_String --
+ -------------------------
+
+ function To_Wide_Wide_String
+ (Item : String) return Wide_Wide_String
+ is
+ Result : Wide_Wide_String (1 .. Item'Length);
+
+ begin
+ for J in Item'Range loop
+ Result (J - (Item'First - 1)) := To_Wide_Wide_Character (Item (J));
+ end loop;
+
+ return Result;
+ end To_Wide_Wide_String;
+
+ function To_Wide_Wide_String
+ (Item : Wide_String) return Wide_Wide_String
+ is
+ Result : Wide_Wide_String (1 .. Item'Length);
+
+ begin
+ for J in Item'Range loop
+ Result (J - (Item'First - 1)) := To_Wide_Wide_Character (Item (J));
+ end loop;
+
+ return Result;
+ end To_Wide_Wide_String;
+
+end Ada.Characters.Conversions;
--- /dev/null
+------------------------------------------------------------------------------
+-- --
+-- GNAT RUN-TIME COMPONENTS --
+-- --
+-- A D A . C H A R A C T E R S . H A N D L I N G --
+-- --
+-- S p e c --
+-- --
+-- Copyright (C) 2005 Free Software Foundation, Inc. --
+-- --
+-- This specification is derived from the Ada Reference Manual for use with --
+-- GNAT. The copyright notice above, and the license provisions that follow --
+-- apply solely to the contents of the part following the private keyword. --
+-- --
+-- 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. --
+-- --
+-- As a special exception, if other files instantiate generics from this --
+-- unit, or you link this unit with other files to produce an executable, --
+-- this unit does not by itself cause the resulting executable to be --
+-- covered by the GNU General Public License. This exception does not --
+-- however invalidate any other reasons why the executable file might be --
+-- covered by the GNU Public License. --
+-- --
+-- GNAT was originally developed by the GNAT team at New York University. --
+-- Extensive contributions were provided by Ada Core Technologies Inc. --
+-- --
+------------------------------------------------------------------------------
+
+package Ada.Characters.Conversions is
+pragma Pure (Conversions);
+
+ function Is_Character (Item : Wide_Character) return Boolean;
+ function Is_String (Item : Wide_String) return Boolean;
+ function Is_Character (Item : Wide_Wide_Character) return Boolean;
+ function Is_String (Item : Wide_Wide_String) return Boolean;
+
+ function Is_Wide_Character (Item : Wide_Wide_Character) return Boolean;
+ function Is_Wide_String (Item : Wide_Wide_String) return Boolean;
+
+ function To_Wide_Character (Item : Character) return Wide_Character;
+ function To_Wide_String (Item : String) return Wide_String;
+
+ function To_Wide_Wide_Character
+ (Item : Character) return Wide_Wide_Character;
+
+ function To_Wide_Wide_String
+ (Item : String) return Wide_Wide_String;
+
+ function To_Wide_Wide_Character
+ (Item : Wide_Character) return Wide_Wide_Character;
+
+ function To_Wide_Wide_String
+ (Item : Wide_String) return Wide_Wide_String;
+
+ function To_Character
+ (Item : Wide_Character;
+ Substitute : Character := ' ') return Character;
+
+ function To_String
+ (Item : Wide_String;
+ Substitute : Character := ' ') return String;
+
+ function To_Character
+ (Item : Wide_Wide_Character;
+ Substitute : Character := ' ') return Character;
+
+ function To_String
+ (Item : Wide_Wide_String;
+ Substitute : Character := ' ') return String;
+
+ function To_Wide_Character
+ (Item : Wide_Wide_Character;
+ Substitute : Wide_Character := ' ') return Wide_Character;
+
+ function To_Wide_String
+ (Item : Wide_Wide_String;
+ Substitute : Wide_Character := ' ') return Wide_String;
+
+end Ada.Characters.Conversions;
return Wide_Character'Pos (Item) < 256;
end Is_Character;
- function Is_Character (Item : Wide_Wide_Character) return Boolean is
- begin
- return Wide_Wide_Character'Pos (Item) < 256;
- end Is_Character;
-
----------------
-- Is_Control --
----------------
return True;
end Is_String;
- function Is_String (Item : Wide_Wide_String) return Boolean is
- begin
- for J in Item'Range loop
- if Wide_Wide_Character'Pos (Item (J)) >= 256 then
- return False;
- end if;
- end loop;
-
- return True;
- end Is_String;
-
--------------
-- Is_Upper --
--------------
return (Char_Map (Item) and Upper) /= 0;
end Is_Upper;
- -----------------------
- -- Is_Wide_Character --
- -----------------------
-
- function Is_Wide_Character (Item : Wide_Wide_Character) return Boolean is
- begin
- return Wide_Wide_Character'Pos (Item) < 2**16;
- end Is_Wide_Character;
-
- --------------------
- -- Is_Wide_String --
- --------------------
-
- function Is_Wide_String (Item : Wide_Wide_String) return Boolean is
- begin
- for J in Item'Range loop
- if Wide_Wide_Character'Pos (Item (J)) >= 2**16 then
- return False;
- end if;
- end loop;
-
- return True;
- end Is_Wide_String;
-
--------------
-- To_Basic --
--------------
end if;
end To_Character;
- function To_Character
- (Item : Wide_Wide_Character;
- Substitute : Character := ' ') return Character
- is
- begin
- if Is_Character (Item) then
- return Character'Val (Wide_Wide_Character'Pos (Item));
- else
- return Substitute;
- end if;
- end To_Character;
-
----------------
-- To_ISO_646 --
----------------
return Result;
end To_String;
- function To_String
- (Item : Wide_Wide_String;
- Substitute : Character := ' ') return String
- is
- Result : String (1 .. Item'Length);
-
- begin
- for J in Item'Range loop
- Result (J - (Item'First - 1)) := To_Character (Item (J), Substitute);
- end loop;
-
- return Result;
- end To_String;
-
--------------
-- To_Upper --
--------------
return Wide_Character'Val (Character'Pos (Item));
end To_Wide_Character;
- function To_Wide_Character
- (Item : Wide_Wide_Character;
- Substitute : Wide_Character := ' ') return Wide_Character
- is
- begin
- if Wide_Wide_Character'Pos (Item) < 2**16 then
- return Wide_Character'Val (Wide_Wide_Character'Pos (Item));
- else
- return Substitute;
- end if;
- end To_Wide_Character;
-
--------------------
-- To_Wide_String --
--------------------
return Result;
end To_Wide_String;
- function To_Wide_String
- (Item : Wide_Wide_String;
- Substitute : Wide_Character := ' ') return Wide_String
- is
- Result : Wide_String (1 .. Item'Length);
-
- begin
- for J in Item'Range loop
- Result (J - (Item'First - 1)) :=
- To_Wide_Character (Item (J), Substitute);
- end loop;
-
- return Result;
- end To_Wide_String;
-
- ----------------------------
- -- To_Wide_Wide_Character --
- ----------------------------
-
- function To_Wide_Wide_Character
- (Item : Character) return Wide_Wide_Character
- is
- begin
- return Wide_Wide_Character'Val (Character'Pos (Item));
- end To_Wide_Wide_Character;
-
- function To_Wide_Wide_Character
- (Item : Wide_Character) return Wide_Wide_Character
- is
- begin
- return Wide_Wide_Character'Val (Wide_Character'Pos (Item));
- end To_Wide_Wide_Character;
-
- -------------------------
- -- To_Wide_Wide_String --
- -------------------------
-
- function To_Wide_Wide_String
- (Item : String) return Wide_Wide_String
- is
- Result : Wide_Wide_String (1 .. Item'Length);
-
- begin
- for J in Item'Range loop
- Result (J - (Item'First - 1)) := To_Wide_Wide_Character (Item (J));
- end loop;
-
- return Result;
- end To_Wide_Wide_String;
-
- function To_Wide_Wide_String
- (Item : Wide_String) return Wide_Wide_String
- is
- Result : Wide_Wide_String (1 .. Item'Length);
-
- begin
- for J in Item'Range loop
- Result (J - (Item'First - 1)) := To_Wide_Wide_Character (Item (J));
- end loop;
-
- return Result;
- end To_Wide_Wide_String;
-
end Ada.Characters.Handling;
-- --
------------------------------------------------------------------------------
-
package Ada.Characters.Handling is
pragma Preelaborate (Handling);
+pragma Pure_05 (Handling);
+-- In accordance with Ada 2005 AI-362
----------------------------------------
-- Character Classification Functions --
-- Classifications of Wide_Character and Characters --
------------------------------------------------------
- function Is_Character (Item : Wide_Character) return Boolean;
- function Is_Character (Item : Wide_Wide_Character) return Boolean;
- function Is_String (Item : Wide_String) return Boolean;
- function Is_String (Item : Wide_Wide_String) return Boolean;
- function Is_Wide_Character (Item : Wide_Wide_Character) return Boolean;
- function Is_Wide_String (Item : Wide_Wide_String) return Boolean;
+ -- Ada 2005 AI 395: these functions are moved to Ada.Characters.Conversions
+ -- and are considered obsolete in Ada.Characters.Handling. We deal with
+ -- this by using the special Ada_05 form of pragma Obsolescent which is
+ -- only active in Ada_05 mode.
- ---------------------------------------------------------------------------
- -- Conversions between Wide_Wide_Character, Wide_Character and Character --
- ---------------------------------------------------------------------------
+ function Is_Character (Item : Wide_Character) return Boolean;
+ pragma Obsolescent
+ ("(Ada 2005) use Ada.Characters.Conversions.Is_Character", Ada_05);
- function To_Character
- (Item : Wide_Character;
- Substitute : Character := ' ') return Character;
+ function Is_String (Item : Wide_String) return Boolean;
+ pragma Obsolescent
+ ("(Ada 2005) use Ada.Characters.Conversions.Is_String", Ada_05);
+
+ ------------------------------------------------------
+ -- Conversions between Wide_Character and Character --
+ ------------------------------------------------------
+
+ -- Ada 2005 AI 395: these functions are moved to Ada.Characters.Conversions
+ -- and are considered obsolete in Ada.Characters.Handling. We deal with
+ -- this by using the special Ada_05 form of pragma Obsolescent which is
+ -- only active in Ada_05 mode.
function To_Character
- (Item : Wide_Wide_Character;
- Substitute : Character := ' ') return Character;
+ (Item : Wide_Character;
+ Substitute : Character := ' ') return Character;
+ pragma Obsolescent
+ ("(Ada 2005) use Ada.Characters.Conversions.To_Character", Ada_05);
function To_String
(Item : Wide_String;
- Substitute : Character := ' ') return String;
-
- function To_String
- (Item : Wide_Wide_String;
- Substitute : Character := ' ') return String;
+ Substitute : Character := ' ') return String;
+ pragma Obsolescent
+ ("(Ada 2005) use Ada.Characters.Conversions.To_String", Ada_05);
function To_Wide_Character
- (Item : Character) return Wide_Character;
- function To_Wide_Character
- (Item : Wide_Wide_Character;
- Substitute : Wide_Character := ' ') return Wide_Character;
+ (Item : Character) return Wide_Character;
+ pragma Obsolescent
+ ("(Ada 2005) use Ada.Characters.Conversions.To_Wide_Character", Ada_05);
function To_Wide_String
- (Item : String) return Wide_String;
- function To_Wide_String
- (Item : Wide_Wide_String;
- Substitute : Wide_Character := ' ') return Wide_String;
-
- function To_Wide_Wide_Character
- (Item : Character) return Wide_Wide_Character;
- function To_Wide_Wide_Character
- (Item : Wide_Character) return Wide_Wide_Character;
-
- function To_Wide_Wide_String
- (Item : String) return Wide_Wide_String;
- function To_Wide_Wide_String
- (Item : Wide_String) return Wide_Wide_String;
+ (Item : String)return Wide_String;
+ pragma Obsolescent
+ ("(Ada 2005) use Ada.Characters.Conversions.To_Wide_String", Ada_05);
private
pragma Inline (Is_Control);
pragma Inline (Is_Character);
pragma Inline (To_Character);
pragma Inline (To_Wide_Character);
- pragma Inline (To_Wide_Wide_Character);
end Ada.Characters.Handling;
-- --
-- B o d y --
-- --
--- Copyright (C) 1992-2003 Free Software Foundation, Inc. --
+-- Copyright (C) 1992-2005 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- --
-- --
------------------------------------------------------------------------------
+pragma Warnings (Off);
+-- Allow withing of non-Preelaborated units in Ada 2005 mode where this
+-- package will be categorized as Preelaborate. See AI-362 for details.
+-- It is safe in the context of the run-time to violate the rules!
+
with System.Traceback;
+pragma Warnings (On);
+
separate (Ada.Exceptions)
procedure Call_Chain (Excep : EOA) is
-- occurrences.
begin
-
if Exception_Tracebacks /= 0 and Excep.Num_Tracebacks = 0 then
-- If Exception_Tracebacks = 0 then the program was not
-- --
-- B o d y --
-- --
--- Copyright (C) 1992-2003 Free Software Foundation, Inc. --
+-- Copyright (C) 1992-2005 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- --
-- --
------------------------------------------------------------------------------
+pragma Warnings (Off);
+-- Allow withing of non-Preelaborated units in Ada 2005 mode where this
+-- package will be categorized as Preelaborate. See AI-362 for details.
+-- It is safe in the context of the run-time to violate the rules!
+
with System.Exception_Table; use System.Exception_Table;
with System.Storage_Elements; use System.Storage_Elements;
+pragma Warnings (On);
+
separate (Ada.Exceptions)
package body Stream_Attributes is
package Ada.Strings.Maps is
pragma Preelaborate (Maps);
+pragma Pure_05 (Maps);
+-- In accordance with Ada 2005 AI-362
--------------------------------
-- Character Set Declarations --
-- --
-- B o d y --
-- --
--- Copyright (C) 1992-2004 Free Software Foundation, Inc. --
+-- Copyright (C) 1992-2005 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- --
-- --
------------------------------------------------------------------------------
+pragma Warnings (Off);
+-- Allow withing of non-Preelaborated units in Ada 2005 mode where this
+-- package will be categorized as Preelaborate. See AI-362 for details.
+-- It is safe in the context of the run-time to violate the rules!
+
with System.Address_Image;
-- used for the function itself
with Unchecked_Conversion;
+pragma Warnings (Off);
+
package body Ada.Task_Identification is
-----------------------
-- --
-- S p e c --
-- --
--- Copyright (C) 1992-2004 Free Software Foundation, Inc. --
+-- Copyright (C) 1992-2005 Free Software Foundation, Inc. --
-- --
-- This specification is derived from the Ada Reference Manual for use with --
-- GNAT. The copyright notice above, and the license provisions that follow --
-- --
------------------------------------------------------------------------------
+pragma Warnings (Off);
+-- Allow withing of non-Preelaborated units in Ada 2005 mode where this
+-- package will be categorized as Preelaborate. See AI-362 for details.
+-- It is safe in the context of the run-time to violate the rules!
+
with System;
with System.Tasking;
+pragma Warnings (On);
+
package Ada.Task_Identification is
+pragma Preelaborate_05 (Task_Identification);
+-- In accordance with Ada 2005 AI-362
type Task_Id is private;
type Task_Id is new System.Tasking.Task_Id;
+ pragma Warnings (Off);
+ -- Allow non-static constant in Ada 2005 mode where this package will be
+ -- categorized as Preelaborate. See AI-362 for details. It is safe in the
+ -- context of the run-time to violate the rules!
+
Null_Task_Id : constant Task_Id := Task_Id (System.Tasking.Null_Task);
+ pragma Warnings (On);
+
end Ada.Task_Identification;
-- --
------------------------------------------------------------------------------
+pragma Warnings (Off);
+-- Turn of categorization warnings
+
generic
type T (<>) is abstract tagged limited private;
type Parameters (<>) is limited private;
function Ada.Tags.Generic_Dispatching_Constructor
(The_Tag : Tag; Params : access Parameters) return T'Class;
-
--- pragma Preelaborate (Generic_Dispatching_Constructor);
--- Commented out temporarily because various other predefined units do not
--- yet have proper categorization as specified by AI-362 (such as Ada.Tags,
--- Ada.Exceptions, etc.).
-
+pragma Preelaborate_05 (Generic_Dispatching_Constructor);
pragma Import (Intrinsic, Generic_Dispatching_Constructor);
+-- Note: the reason that we use Preelaborate_05 here is so that this will
+-- compile fine during the normal build procedures. In Ada 2005 mode (which
+-- is required for this package anyway), this will be treated as Preelaborate
+-- so everything will be fine.
------------------------------------------------------------------------------
-- --
--- GNAT RUNTIME COMPONENTS --
+-- GNAT RUN-TIME COMPONENTS --
-- --
-- A D A . W I D E _ W I D E _ T E X T _ I O . E N U M E R A T I O N _ A U X--
-- --
------------------------------------------------------------------------------
with Ada.Wide_Wide_Text_IO.Generic_Aux; use Ada.Wide_Wide_Text_IO.Generic_Aux;
+with Ada.Characters.Conversions; use Ada.Characters.Conversions;
with Ada.Characters.Handling; use Ada.Characters.Handling;
with Interfaces.C_Streams; use Interfaces.C_Streams;
with System.WCh_Con; use System.WCh_Con;
"a-tiocst", -- Ada.Text_IO.C_Streams
"a-wtcstr", -- Ada.Wide_Text_IO.C_Streams
+ -- Note: strictly the next two should be Ada 2005 units, but it seems
+ -- harmless (and useful) to make then available in Ada 95 mode, since
+ -- they only deal with Wide_Character, not Wide_Wide_Character.
+
+ "a-wichun", -- Ada.Wide_Characters.Unicode
+ "a-widcha", -- Ada.Wide_Characters
+
---------------------------
-- GNAT Special IO Units --
---------------------------
"a-cgaaso", -- Ada.Containers.Generic_Anonymous_Array_Sort
"a-cgarso", -- Ada.Containers.Generic_Array_Sort
"a-cgcaso", -- Ada.Containers.Generic_Constrained_Array_Sort
+ "a-chacon", -- Ada.Characters.Conversions
"a-chtgke", -- Ada.Containers.Hash_Tables.Generic_Keys
"a-chtgop", -- Ada.Containers.Hash_Tables.Generic_Operations
"a-cidlli", -- Ada.Containers.Indefinite_Doubly_Linked_Lists
"a-stzhas", -- Ada.Strings.Wide_Wide_Hash
"a-stzmap", -- Ada.Strings.Wide_Wide_Maps
"a-stzunb", -- Ada.Strings.Wide_Wide_Unbounded
- "a-swunha", -- Ada.Strings.Wide_Unbounded.Hash
+ "a-swuwha", -- Ada.Strings.Wide_Unbounded.Wide_Hash
"a-szmzco", -- Ada.Strings.Wide_Wide_Maps.Wide_Wide_Constants;
- "a-szunha", -- Ada.Strings.Wide_Wide_Unbounded.Hash
+ "a-szuzha", -- Ada.Strings.Wide_Wide_Unbounded.Wide_Wide_Hash
"a-tgdico", -- Ada.Tags.Generic_Dispatching_Constructor;
"a-tiunio", -- Ada.Text_IO.Unbounded_IO;
+ "a-wichun", -- Ada.Wide_Characters.Unicode
"a-wwunio", -- Ada.Wide_Text_IO.Wide_Unbounded_IO;
+ "a-zchara", -- Ada.Wide_Wide_Characters
"a-zttest", -- Ada.Wide_Wide_Text_IO.Text_Streams
"a-ztexio", -- Ada.Wide_Wide_Text_IO
"a-zzunio", -- Ada.Wide_Wide_Text_IO.Wide_Wide_Unbounded_IO
"a-chzla1", -- Ada.Characters.Wide_Wide_Latin_1
"a-chzla9", -- Ada.Characters.Wide_Wide_Latin_9
"a-szuzti", -- Ada.Strings.Wide_Wide_Unbounded.Wide_Wide_Text_IO
+ "a-zchuni", -- Ada.Wide_Wide_Characters.Unicode
---------------------------
-- GNAT Special IO Units --
when Pragma_Ada_83 =>
Ada_Version := Ada_83;
+ Ada_Version_Explicit := Ada_Version;
------------
-- Ada_95 --
when Pragma_Ada_95 =>
Ada_Version := Ada_95;
+ Ada_Version_Explicit := Ada_Version;
------------
-- Ada_05 --
when Pragma_Ada_05 =>
if Arg_Count = 0 then
Ada_Version := Ada_05;
+ Ada_Version_Explicit := Ada_Version;
end if;
-----------
Ada_Version := Ada_Version_Type'Min (Ada_Version, Ada_95);
end if;
+ Ada_Version_Explicit := Ada_Version;
+
----------------
-- List (2.8) --
----------------
-- entirely in Sem_Prag, and no further checking is done by Par.
when Pragma_Abort_Defer |
+ Pragma_Assertion_Policy |
Pragma_AST_Entry |
Pragma_All_Calls_Remote |
Pragma_Annotate |
Pragma_Pack |
Pragma_Passive |
Pragma_Polling |
- Pragma_Persistent_Data |
- Pragma_Persistent_Object |
+ Pragma_Persistent_BSS |
Pragma_Preelaborate |
+ Pragma_Preelaborate_05 |
Pragma_Priority |
Pragma_Profile |
Pragma_Profile_Warnings |
Pragma_Propagate_Exceptions |
Pragma_Psect_Object |
Pragma_Pure |
+ Pragma_Pure_05 |
Pragma_Pure_Function |
Pragma_Queuing_Policy |
Pragma_Remote_Call_Interface |
-- --
-- S p e c --
-- --
--- Copyright (C) 2002-2004 Free Software Foundation, Inc. --
+-- Copyright (C) 2002-2005 Free Software Foundation, Inc. --
-- --
-- This specification is derived from the Ada Reference Manual for use with --
-- GNAT. The copyright notice above, and the license provisions that follow --
package System.Storage_Elements is
pragma Pure (Storage_Elements);
-- Note that we take advantage of the implementation permission to make
--- this unit Pure instead of Preelaborable; see RM 13.7.1(15).
+-- this unit Pure instead of Preelaborable; see RM 13.7.1(15). In Ada 2005,
+-- this is Pure in any case (AI-362).
-- We also add the pragma Pure_Function to the operations in this package,
-- because otherwise functions with parameters derived from Address are
-- --
-- B o d y --
-- --
--- Copyright (C) 1992-2004, Free Software Foundation, Inc. --
+-- Copyright (C) 1992-2005, 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- --
S_New_Nodes_OK : constant Int := New_Nodes_OK;
S_Outer_Gen_Scope : constant Entity_Id := Outer_Generic_Scope;
S_Sem_Unit : constant Unit_Number_Type := Current_Sem_Unit;
-
+ S_GNAT_Mode : constant Boolean := GNAT_Mode;
Generic_Main : constant Boolean :=
Nkind (Unit (Cunit (Main_Unit)))
in N_Generic_Declaration;
Compiler_State := Analyzing;
Current_Sem_Unit := Get_Cunit_Unit_Number (Comp_Unit);
+ -- Compile predefined units with GNAT_Mode set to True, to properly
+ -- process the categorization stuff. However, do not set set GNAT_Mode
+ -- to True for the renamings units (Text_IO, IO_Exceptions, Direct_IO,
+ -- Sequential_IO) as this would prevent pragma System_Extend to be
+ -- taken into account, for example when Text_IO is renaming DEC.Text_IO.
+
+ -- Cleaner might be to do the kludge at the point of excluding the
+ -- pragma (do not exclude for renamings ???)
+
+ GNAT_Mode :=
+ GNAT_Mode
+ or else Is_Predefined_File_Name
+ (Unit_File_Name (Current_Sem_Unit),
+ Renamings_Included => False);
+
if Generic_Main then
Expander_Mode_Save_And_Set (False);
else
Inside_A_Generic := S_Inside_A_Generic;
New_Nodes_OK := S_New_Nodes_OK;
Outer_Generic_Scope := S_Outer_Gen_Scope;
+ GNAT_Mode := S_GNAT_Mode;
Restore_Opt_Config_Switches (Save_Config_Switches);
Expander_Mode_Restore;
with Fname; use Fname;
with Lib; use Lib;
with Nlists; use Nlists;
+with Opt; use Opt;
with Sem; use Sem;
with Sem_Eval; use Sem_Eval;
with Sem_Util; use Sem_Util;
With_Category := Get_Categorization (Depended_Entity);
if With_Category > Unit_Category then
-
if (Unit_Category = Remote_Types
- or else Unit_Category = Remote_Call_Interface)
+ or else Unit_Category = Remote_Call_Interface)
and then In_Package_Body (Unit_Entity)
then
null;
+ -- Subunit error case. In GNAT mode, this is only a warning to allow
+ -- it to be judiciously turned off. Otherwise it is a real error.
+
elsif Is_Subunit then
- Error_Msg_NE ("subunit cannot depend on&"
- & " (parent has wrong categorization)", N, Depended_Entity);
+ if GNAT_Mode then
+ Error_Msg_NE
+ ("?subunit cannot depend on& " &
+ "(parent has wrong categorization)", N, Depended_Entity);
+ else
+ Error_Msg_NE
+ ("subunit cannot depend on& " &
+ "(parent has wrong categorization)", N, Depended_Entity);
+ end if;
+
+ -- Normal error case. In GNAT mode, this is only a warning to allow
+ -- it to be judiciously turned off. Otherwise it is a real error.
+
else
- Error_Msg_NE ("current unit cannot depend on&"
- & " (wrong categorization)", N, Depended_Entity);
+ if GNAT_Mode then
+ Error_Msg_NE
+ ("?current unit cannot depend on& " &
+ "(wrong categorization)", N, Depended_Entity);
+ else
+ Error_Msg_NE
+ ("current unit cannot depend on& " &
+ "(wrong categorization)", N, Depended_Entity);
+ end if;
end if;
end if;
begin
case Nkind (Def) is
+
+ -- Access to subprogram case
+
when N_Access_To_Subprogram_Definition =>
-- A pure library_item must not contain the declaration of a
-- named access type, except within a subprogram, generic
-- subprogram, task unit, or protected unit (RM 10.2.1(16)).
- if Comes_From_Source (T)
- and then In_Pure_Unit
- and then not In_Subprogram_Task_Protected_Unit
+ -- This test is skipped in Ada 2005 (see AI-366)
+
+ if Ada_Version < Ada_05
+ and then Comes_From_Source (T)
+ and then In_Pure_Unit
+ and then not In_Subprogram_Task_Protected_Unit
then
Error_Msg_N ("named access type not allowed in pure unit", T);
end if;
- when N_Access_To_Object_Definition =>
+ -- Access to object case
+ when N_Access_To_Object_Definition =>
if Comes_From_Source (T)
and then In_Pure_Unit
and then not In_Subprogram_Task_Protected_Unit
then
- Error_Msg_N
- ("named access type not allowed in pure unit", T);
+ -- We can't give the message yet, since the type is not frozen
+ -- and in Ada 2005 mode, access types are allowed in pure units
+ -- if the type has no storage pool (see AI-366). So we set a
+ -- flag which will be checked at freeze time.
+
+ Set_Is_Pure_Unit_Access_Type (T);
end if;
-- Check for RCI or RT unit type declaration. It should not
Validate_SP_Access_Object_Type_Decl (T);
- when others => null;
+ when others =>
+ null;
end case;
-- Set categorization flag from package on entity as well, to allow
if Nkind (Item) /= N_Label
and then Nkind (Item) /= N_Null_Statement
then
- Error_Msg_N
- ("statements not allowed in preelaborated unit", Item);
+ -- In GNAT mode, this is a warning, allowing the run-time
+ -- to judiciously bypass this error condition.
+
+ if GNAT_Mode then
+ Error_Msg_N
+ ("?statements not allowed in preelaborated unit", Item);
+ else
+ Error_Msg_N
+ ("statements not allowed in preelaborated unit", Item);
+ end if;
+
exit;
end if;
-- Profile must exist, otherwise not primitive operation
Param_Spec := First (Profile);
-
while Present (Param_Spec) loop
-- Now find out if this parameter is a controlling parameter
-- entity is inside an RCI unit.
Set_Is_Remote_Call_Interface (T);
-
end Validate_Remote_Access_Object_Type_Declaration;
-----------------------------------------------
E : Entity_Id;
begin
- -- This subprogram enforces the checks in (RM E.2.2(8)) for
- -- certain uses of class-wide limited private types.
+ -- This subprogram enforces the checks in (RM E.2.2(8)) for certain uses
+ -- of class-wide limited private types.
-- Storage_Pool and Storage_Size are not defined for such types
--
-- The expected type of allocator must not not be such a type.
- -- The actual parameter of generic instantiation must not
- -- be such a type if the formal parameter is of an access type.
+ -- The actual parameter of generic instantiation must not be such a
+ -- type if the formal parameter is of an access type.
-- On entry, there are five cases
- -- 1. called from sem_attr Analyze_Attribute where attribute
- -- name is either Storage_Pool or Storage_Size.
+ -- 1. called from sem_attr Analyze_Attribute where attribute name is
+ -- either Storage_Pool or Storage_Size.
-- 2. called from exp_ch4 Expand_N_Allocator
return;
end if;
- -- This subprogram also enforces the checks in E.2.2(13).
- -- A value of such type must not be dereferenced unless as a
- -- controlling operand of a dispatching call.
+ -- This subprogram also enforces the checks in E.2.2(13). A value of
+ -- such type must not be dereferenced unless as controlling operand of a
+ -- dispatching call.
elsif K = N_Explicit_Dereference
and then (Comes_From_Source (N)
end if;
-- If we are just within a procedure or function call and the
- -- dereference has not been analyzed, return because this
- -- procedure will be called again from sem_res Resolve_Actuals.
+ -- dereference has not been analyzed, return because this procedure
+ -- will be called again from sem_res Resolve_Actuals.
if Is_Actual_Parameter (N)
and then not Analyzed (N)
return;
end if;
- -- The following is to let the compiler generated tags check
- -- pass through without error message. This is a bit kludgy
- -- isn't there some better way of making this exclusion ???
+ -- The following is to let the compiler generated tags check pass
+ -- through without error message. This is a bit kludgy isn't there
+ -- some better way of making this exclusion ???
if (PK = N_Selected_Component
and then Present (Parent (Parent (N)))
E : constant Entity_Id := Etype (Expression (N));
begin
- -- This test is required in the case where a conversion appears
- -- inside a normal package, it does not necessarily have to be
- -- inside an RCI, Remote_Types unit (RM E.2.2(9,12)).
+ -- This test is required in the case where a conversion appears inside a
+ -- normal package, it does not necessarily have to be inside an RCI,
+ -- Remote_Types unit (RM E.2.2(9,12)).
if Is_Remote_Access_To_Subprogram_Type (E)
and then not Is_Remote_Access_To_Subprogram_Type (S)
-- Return true if the protected type designated by T has
-- entry declarations.
+ ----------------------------
+ -- Has_Entry_Declarations --
+ ----------------------------
+
function Has_Entry_Declarations (E : Entity_Id) return Boolean is
Ety : Entity_Id;
function Is_Primary (N : Node_Id) return Boolean;
-- Determine whether node is syntactically a primary in an expression.
+ ----------------
+ -- Is_Primary --
+ ----------------
+
function Is_Primary (N : Node_Id) return Boolean is
K : constant Node_Kind := Nkind (Parent (N));
begin
case K is
-
when N_Op | N_In | N_Not_In =>
return True;
then
return;
- -- Filter out cases where primary is default in a component
- -- declaration, discriminant specification, or actual in a record
- -- type initialization call.
+ -- Filter out cases where primary is default in a component declaration,
+ -- discriminant specification, or actual in a record type initialization
+ -- call.
-- Initialization call of internal types.
-- We take the view that a constant defined in another preelaborated
-- unit is preelaborable, even though it may have a private type and
-- thus appear non-static in a client. This must be the intent of
- -- the language, but currently is an RM gap.
+ -- the language, but currently is an RM gap ???
elsif Ekind (Entity (N)) = E_Constant
and then not Is_Static_Expression (N)
(Renamed_Object (E))))))
then
null;
+
+ -- This is the error case
+
else
- Flag_Non_Static_Expr
- ("non-static constant in preelaborated unit", N);
+ -- In GNAT mode, this is just a warning, to allow it to be
+ -- judiciously turned off. Otherwise it is a real error.
+
+ if GNAT_Mode then
+ Error_Msg_N
+ ("?non-static constant in preelaborated unit", N);
+ else
+ Flag_Non_Static_Expr
+ ("non-static constant in preelaborated unit", N);
+ end if;
+
end if;
end if;
end if;
and then In_Preelaborated_Unit
and then not In_Inlined_Body
then
- Error_Msg_N
- ("non-static call not allowed in preelaborated unit", N);
+ -- This is a warning in -gnatg mode allowing such calls to
+ -- be used in the predefined library with appropriate care.
+
+ if GNAT_Mode then
+ Error_Msg_N
+ ("?non-static call not allowed in preelaborated unit", N);
+ else
+ Error_Msg_N
+ ("non-static call not allowed in preelaborated unit", N);
+ end if;
+
return;
end if;
package System is
pragma Pure (System);
--- Note that we take advantage of the implementation permission to
--- make this unit Pure instead of Preelaborable, see RM 13.7(36)
+-- Note that we take advantage of the implementation permission to make this
+-- unit Pure instead of Preelaborable; see RM 13.7.1(15). In Ada 2005, this is
+-- Pure in any case (AI-362).
type Name is (SYSTEM_NAME_GNAT);
System_Name : constant Name := SYSTEM_NAME_GNAT;
package System is
pragma Pure (System);
--- Note that we take advantage of the implementation permission to
--- make this unit Pure instead of Preelaborable, see RM 13.7(36)
+-- Note that we take advantage of the implementation permission to make this
+-- unit Pure instead of Preelaborable; see RM 13.7.1(15). In Ada 2005, this is
+-- Pure in any case (AI-362).
type Name is (SYSTEM_NAME_GNAT);
System_Name : constant Name := SYSTEM_NAME_GNAT;
package System is
pragma Pure (System);
--- Note that we take advantage of the implementation permission to
--- make this unit Pure instead of Preelaborable, see RM 13.7(36)
+-- Note that we take advantage of the implementation permission to make this
+-- unit Pure instead of Preelaborable; see RM 13.7.1(15). In Ada 2005, this is
+-- Pure in any case (AI-362).
type Name is (SYSTEM_NAME_GNAT);
System_Name : constant Name := SYSTEM_NAME_GNAT;
package System is
pragma Pure (System);
--- Note that we take advantage of the implementation permission to
--- make this unit Pure instead of Preelaborable, see RM 13.7(36)
+-- Note that we take advantage of the implementation permission to make this
+-- unit Pure instead of Preelaborable; see RM 13.7.1(15). In Ada 2005, this is
+-- Pure in any case (AI-362).
type Name is (SYSTEM_NAME_GNAT);
System_Name : constant Name := SYSTEM_NAME_GNAT;
package System is
pragma Pure (System);
--- Note that we take advantage of the implementation permission to
--- make this unit Pure instead of Preelaborable, see RM 13.7(36)
+-- Note that we take advantage of the implementation permission to make this
+-- unit Pure instead of Preelaborable; see RM 13.7.1(15). In Ada 2005, this is
+-- Pure in any case (AI-362).
type Name is (SYSTEM_NAME_GNAT);
System_Name : constant Name := SYSTEM_NAME_GNAT;
package System is
pragma Pure (System);
--- Note that we take advantage of the implementation permission to
--- make this unit Pure instead of Preelaborable, see RM 13.7(36)
+-- Note that we take advantage of the implementation permission to make this
+-- unit Pure instead of Preelaborable; see RM 13.7.1(15). In Ada 2005, this is
+-- Pure in any case (AI-362).
type Name is (SYSTEM_NAME_GNAT);
System_Name : constant Name := SYSTEM_NAME_GNAT;
package System is
pragma Pure (System);
--- Note that we take advantage of the implementation permission to
--- make this unit Pure instead of Preelaborable, see RM 13.7(36)
+-- Note that we take advantage of the implementation permission to make this
+-- unit Pure instead of Preelaborable; see RM 13.7.1(15). In Ada 2005, this is
+-- Pure in any case (AI-362).
type Name is (SYSTEM_NAME_GNAT);
System_Name : constant Name := SYSTEM_NAME_GNAT;
package System is
pragma Pure (System);
--- Note that we take advantage of the implementation permission to
--- make this unit Pure instead of Preelaborable, see RM 13.7(36)
+-- Note that we take advantage of the implementation permission to make this
+-- unit Pure instead of Preelaborable; see RM 13.7.1(15). In Ada 2005, this is
+-- Pure in any case (AI-362).
type Name is (SYSTEM_NAME_GNAT);
System_Name : constant Name := SYSTEM_NAME_GNAT;
package System is
pragma Pure (System);
--- Note that we take advantage of the implementation permission to
--- make this unit Pure instead of Preelaborable, see RM 13.7(36)
+-- Note that we take advantage of the implementation permission to make this
+-- unit Pure instead of Preelaborable; see RM 13.7.1(15). In Ada 2005, this is
+-- Pure in any case (AI-362).
type Name is (SYSTEM_NAME_GNAT);
System_Name : constant Name := SYSTEM_NAME_GNAT;
package System is
pragma Pure (System);
--- Note that we take advantage of the implementation permission to
--- make this unit Pure instead of Preelaborable, see RM 13.7(36)
+-- Note that we take advantage of the implementation permission to make this
+-- unit Pure instead of Preelaborable; see RM 13.7.1(15). In Ada 2005, this is
+-- Pure in any case (AI-362).
type Name is (SYSTEM_NAME_GNAT);
System_Name : constant Name := SYSTEM_NAME_GNAT;
package System is
pragma Pure (System);
--- Note that we take advantage of the implementation permission to
--- make this unit Pure instead of Preelaborable, see RM 13.7(36)
+-- Note that we take advantage of the implementation permission to make this
+-- unit Pure instead of Preelaborable; see RM 13.7.1(15). In Ada 2005, this is
+-- Pure in any case (AI-362).
type Name is (SYSTEM_NAME_GNAT);
System_Name : constant Name := SYSTEM_NAME_GNAT;
package System is
pragma Pure (System);
--- Note that we take advantage of the implementation permission to
--- make this unit Pure instead of Preelaborable, see RM 13.7(36)
+-- Note that we take advantage of the implementation permission to make this
+-- unit Pure instead of Preelaborable; see RM 13.7.1(15). In Ada 2005, this is
+-- Pure in any case (AI-362).
type Name is (SYSTEM_NAME_GNAT);
System_Name : constant Name := SYSTEM_NAME_GNAT;
package System is
pragma Pure (System);
--- Note that we take advantage of the implementation permission to
--- make this unit Pure instead of Preelaborable, see RM 13.7(36)
+-- Note that we take advantage of the implementation permission to make this
+-- unit Pure instead of Preelaborable; see RM 13.7.1(15). In Ada 2005, this is
+-- Pure in any case (AI-362).
type Name is (SYSTEM_NAME_GNAT);
System_Name : constant Name := SYSTEM_NAME_GNAT;
package System is
pragma Pure (System);
--- Note that we take advantage of the implementation permission to
--- make this unit Pure instead of Preelaborable, see RM 13.7(36)
+-- Note that we take advantage of the implementation permission to make this
+-- unit Pure instead of Preelaborable; see RM 13.7.1(15). In Ada 2005, this is
+-- Pure in any case (AI-362).
type Name is (SYSTEM_NAME_GNAT);
System_Name : constant Name := SYSTEM_NAME_GNAT;
package System is
pragma Pure (System);
--- Note that we take advantage of the implementation permission to
--- make this unit Pure instead of Preelaborable, see RM 13.7(36)
+-- Note that we take advantage of the implementation permission to make this
+-- unit Pure instead of Preelaborable; see RM 13.7.1(15). In Ada 2005, this is
+-- Pure in any case (AI-362).
type Name is (SYSTEM_NAME_GNAT);
System_Name : constant Name := SYSTEM_NAME_GNAT;
package System is
pragma Pure (System);
--- Note that we take advantage of the implementation permission to
--- make this unit Pure instead of Preelaborable, see RM 13.7(36)
+-- Note that we take advantage of the implementation permission to make this
+-- unit Pure instead of Preelaborable; see RM 13.7.1(15). In Ada 2005, this is
+-- Pure in any case (AI-362).
type Name is (SYSTEM_NAME_GNAT);
System_Name : constant Name := SYSTEM_NAME_GNAT;
package System is
pragma Pure (System);
--- Note that we take advantage of the implementation permission to
--- make this unit Pure instead of Preelaborable, see RM 13.7(36)
+-- Note that we take advantage of the implementation permission to make this
+-- unit Pure instead of Preelaborable; see RM 13.7.1(15). In Ada 2005, this is
+-- Pure in any case (AI-362).
type Name is (SYSTEM_NAME_GNAT);
System_Name : constant Name := SYSTEM_NAME_GNAT;
package System is
pragma Pure (System);
--- Note that we take advantage of the implementation permission to
--- make this unit Pure instead of Preelaborable, see RM 13.7(36)
+-- Note that we take advantage of the implementation permission to make this
+-- unit Pure instead of Preelaborable; see RM 13.7.1(15). In Ada 2005, this is
+-- Pure in any case (AI-362).
type Name is (SYSTEM_NAME_GNAT);
System_Name : constant Name := SYSTEM_NAME_GNAT;
package System is
pragma Pure (System);
--- Note that we take advantage of the implementation permission to
--- make this unit Pure instead of Preelaborable, see RM 13.7(36)
+-- Note that we take advantage of the implementation permission to make this
+-- unit Pure instead of Preelaborable; see RM 13.7.1(15). In Ada 2005, this is
+-- Pure in any case (AI-362).
type Name is (SYSTEM_NAME_GNAT);
System_Name : constant Name := SYSTEM_NAME_GNAT;
package System is
pragma Pure (System);
--- Note that we take advantage of the implementation permission to
--- make this unit Pure instead of Preelaborable, see RM 13.7(36)
+-- Note that we take advantage of the implementation permission to make this
+-- unit Pure instead of Preelaborable; see RM 13.7.1(15). In Ada 2005, this is
+-- Pure in any case (AI-362).
type Name is (SYSTEM_NAME_GNAT);
System_Name : constant Name := SYSTEM_NAME_GNAT;
package System is
pragma Pure (System);
--- Note that we take advantage of the implementation permission to
--- make this unit Pure instead of Preelaborable, see RM 13.7(36)
+-- Note that we take advantage of the implementation permission to make this
+-- unit Pure instead of Preelaborable; see RM 13.7.1(15). In Ada 2005, this is
+-- Pure in any case (AI-362).
type Name is (SYSTEM_NAME_GNAT);
System_Name : constant Name := SYSTEM_NAME_GNAT;
package System is
pragma Pure (System);
--- Note that we take advantage of the implementation permission to
--- make this unit Pure instead of Preelaborable, see RM 13.7(36)
+-- Note that we take advantage of the implementation permission to make this
+-- unit Pure instead of Preelaborable; see RM 13.7.1(15). In Ada 2005, this is
+-- Pure in any case (AI-362).
type Name is (SYSTEM_NAME_GNAT);
System_Name : constant Name := SYSTEM_NAME_GNAT;
package System is
pragma Pure (System);
--- Note that we take advantage of the implementation permission to
--- make this unit Pure instead of Preelaborable, see RM 13.7(36)
+-- Note that we take advantage of the implementation permission to make this
+-- unit Pure instead of Preelaborable; see RM 13.7.1(15). In Ada 2005, this is
+-- Pure in any case (AI-362).
type Name is (SYSTEM_NAME_GNAT);
System_Name : constant Name := SYSTEM_NAME_GNAT;
package System is
pragma Pure (System);
--- Note that we take advantage of the implementation permission to
--- make this unit Pure instead of Preelaborable, see RM 13.7(36)
+-- Note that we take advantage of the implementation permission to make this
+-- unit Pure instead of Preelaborable; see RM 13.7.1(15). In Ada 2005, this is
+-- Pure in any case (AI-362).
type Name is (SYSTEM_NAME_GNAT);
System_Name : constant Name := SYSTEM_NAME_GNAT;
package System is
pragma Pure (System);
--- Note that we take advantage of the implementation permission to
--- make this unit Pure instead of Preelaborable, see RM 13.7(36)
+-- Note that we take advantage of the implementation permission to make this
+-- unit Pure instead of Preelaborable; see RM 13.7.1(15). In Ada 2005, this is
+-- Pure in any case (AI-362).
type Name is (SYSTEM_NAME_GNAT);
System_Name : constant Name := SYSTEM_NAME_GNAT;
package System is
pragma Pure (System);
--- Note that we take advantage of the implementation permission to
--- make this unit Pure instead of Preelaborable, see RM 13.7(36)
+-- Note that we take advantage of the implementation permission to make this
+-- unit Pure instead of Preelaborable; see RM 13.7.1(15). In Ada 2005, this is
+-- Pure in any case (AI-362).
type Name is (SYSTEM_NAME_GNAT);
System_Name : constant Name := SYSTEM_NAME_GNAT;
package System is
pragma Pure (System);
--- Note that we take advantage of the implementation permission to
--- make this unit Pure instead of Preelaborable, see RM 13.7(36)
+-- Note that we take advantage of the implementation permission to make this
+-- unit Pure instead of Preelaborable; see RM 13.7.1(15). In Ada 2005, this is
+-- Pure in any case (AI-362).
type Name is (SYSTEM_NAME_GNAT);
System_Name : constant Name := SYSTEM_NAME_GNAT;
package System is
pragma Pure (System);
--- Note that we take advantage of the implementation permission to
--- make this unit Pure instead of Preelaborable, see RM 13.7(36)
+-- Note that we take advantage of the implementation permission to make this
+-- unit Pure instead of Preelaborable; see RM 13.7.1(15). In Ada 2005, this is
+-- Pure in any case (AI-362).
type Name is (SYSTEM_NAME_GNAT);
System_Name : constant Name := SYSTEM_NAME_GNAT;
package System is
pragma Pure (System);
--- Note that we take advantage of the implementation permission to
--- make this unit Pure instead of Preelaborable, see RM 13.7(36)
+-- Note that we take advantage of the implementation permission to make this
+-- unit Pure instead of Preelaborable; see RM 13.7.1(15). In Ada 2005, this is
+-- Pure in any case (AI-362).
type Name is (SYSTEM_NAME_GNAT);
System_Name : constant Name := SYSTEM_NAME_GNAT;
package System is
pragma Pure (System);
--- Note that we take advantage of the implementation permission to
--- make this unit Pure instead of Preelaborable, see RM 13.7(36)
+-- Note that we take advantage of the implementation permission to make this
+-- unit Pure instead of Preelaborable; see RM 13.7.1(15). In Ada 2005, this is
+-- Pure in any case (AI-362).
type Name is (SYSTEM_NAME_GNAT);
System_Name : constant Name := SYSTEM_NAME_GNAT;
package System is
pragma Pure (System);
--- Note that we take advantage of the implementation permission to
--- make this unit Pure instead of Preelaborable, see RM 13.7(36)
+-- Note that we take advantage of the implementation permission to make this
+-- unit Pure instead of Preelaborable; see RM 13.7.1(15). In Ada 2005, this is
+-- Pure in any case (AI-362).
type Name is (SYSTEM_NAME_GNAT);
System_Name : constant Name := SYSTEM_NAME_GNAT;
package System is
pragma Pure (System);
--- Note that we take advantage of the implementation permission to
--- make this unit Pure instead of Preelaborable, see RM 13.7(36)
+-- Note that we take advantage of the implementation permission to make this
+-- unit Pure instead of Preelaborable; see RM 13.7.1(15). In Ada 2005, this is
+-- Pure in any case (AI-362).
type Name is (SYSTEM_NAME_GNAT);
System_Name : constant Name := SYSTEM_NAME_GNAT;
projects / gcc.git / commitdiff