with Ada.Task_Identification;
package Ada.Asynchronous_Task_Control is
-pragma Preelaborate_05 (Asynchronous_Task_Control);
--- In accordance with Ada 2005 AI-362
+ pragma Preelaborate_05;
+ -- In accordance with Ada 2005 AI-362
pragma Unimplemented_Unit;
return Boolean is <>;
package Ada.Containers.Doubly_Linked_Lists is
- pragma Preelaborate (Doubly_Linked_Lists);
+ pragma Preelaborate;
type List is tagged private;
------------------------------------------------------------------------------
package Ada.Characters.Conversions is
-pragma Pure (Conversions);
+ pragma Pure;
function Is_Character (Item : Wide_Character) return Boolean;
function Is_String (Item : Wide_String) return Boolean;
------------------------------------------------------------------------------
package Ada.Characters.Handling is
-pragma Preelaborate (Handling);
-pragma Pure_05 (Handling);
--- In accordance with Ada 2005 AI-362
+ pragma Preelaborate;
+ pragma Pure_05;
+ -- In accordance with Ada 2005 AI-362
----------------------------------------
-- Character Classification Functions --
------------------------------------------------------------------------------
package Ada.Characters is
-pragma Pure (Characters);
+ pragma Pure;
end Ada.Characters;
------------------------------------------------------------------------------
package Ada.Characters.Latin_1 is
-pragma Pure (Latin_1);
+ pragma Pure;
------------------------
-- Control Characters --
-- --
------------------------------------------------------------------------------
--- This package provides definitions for Latin-9 (ISO-8859-9) analogous to
+-- This package provides definitions for Latin-9 (ISO-8859-15) analogous to
-- those defined in the standard package Ada.Characters.Latin_1 for Latin-1.
package Ada.Characters.Latin_9 is
-pragma Pure (Latin_9);
+ pragma Pure;
------------------------
-- Control Characters --
-- is in accordance with the implementation permission in RM (A.3.3(27)).
package Ada.Characters.Wide_Wide_Latin_1 is
-pragma Pure (Wide_Wide_Latin_1);
+ pragma Pure;
------------------------
-- Control Characters --
-- is in accordance with the implementation permission in RM (A.3.3(27)).
package Ada.Characters.Wide_Wide_Latin_9 is
-pragma Pure (Wide_Wide_Latin_9);
+ pragma Pure;
------------------------
-- Control Characters --
with Ada.Streams;
generic
-
type Element_Type (<>) is private;
with function "=" (Left, Right : Element_Type)
return Boolean is <>;
package Ada.Containers.Indefinite_Doubly_Linked_Lists is
- pragma Preelaborate (Indefinite_Doubly_Linked_Lists);
+ pragma Preelaborate;
type List is tagged private;
with function "=" (Left, Right : Element_Type) return Boolean is <>;
package Ada.Containers.Indefinite_Hashed_Maps is
- pragma Preelaborate (Indefinite_Hashed_Maps);
+ pragma Preelaborate;
type Map is tagged private;
type Cursor is private;
with Ada.Streams;
generic
-
type Key_Type (<>) is private;
type Element_Type (<>) is private;
with function "=" (Left, Right : Element_Type) return Boolean is <>;
package Ada.Containers.Indefinite_Ordered_Maps is
-pragma Preelaborate (Indefinite_Ordered_Maps);
+ pragma Preelaborate;
type Map is tagged private;
with function "=" (Left, Right : Element_Type) return Boolean is <>;
package Ada.Containers.Indefinite_Ordered_Multisets is
-pragma Preelaborate (Indefinite_Ordered_Multisets);
+ pragma Preelaborate;
type Set is tagged private;
with function "=" (Left, Right : Element_Type) return Boolean is <>;
package Ada.Containers.Hashed_Maps is
-pragma Preelaborate (Hashed_Maps);
+ pragma Preelaborate;
type Map is tagged private;
------------------------------------------------------------------------------
package Ada.Containers.Hash_Tables is
-pragma Preelaborate;
+ pragma Preelaborate;
generic
type Node_Type (<>) is limited private;
with function "=" (Left, Right : Element_Type) return Boolean is <>;
package Ada.Containers.Indefinite_Vectors is
-pragma Preelaborate (Indefinite_Vectors);
+ pragma Preelaborate;
subtype Extended_Index is Index_Type'Base
range Index_Type'First - 1 ..
-----------------------
procedure Initialize;
- -- Initialize the Remove_Count and Remove_Args variables.
+ -- Initialize the Remove_Count and Remove_Args variables
----------------
-- Initialize --
-- argument, Argument_Count will be 2, and Argument (2) will return C.
package Ada.Command_Line.Remove is
-pragma Preelaborate (Remove);
+ pragma Preelaborate;
procedure Remove_Argument (Number : in Positive);
-- Removes the argument identified by Number, which must be in the
-- --
-- S p e c --
-- --
--- Copyright (C) 1992-2002 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 --
------------------------------------------------------------------------------
package Ada.Command_Line is
-pragma Preelaborate (Command_Line);
+ pragma Preelaborate;
function Argument_Count return Natural;
-- If the external execution environment supports passing arguments to a
------------------------------------------------------------------------------
package Ada.Containers is
-pragma Pure (Containers);
+ pragma Pure;
type Hash_Type is mod 2**32;
type Count_Type is range 0 .. 2**31 - 1;
with function "=" (Left, Right : Element_Type) return Boolean is <>;
package Ada.Containers.Vectors is
-pragma Preelaborate (Vectors);
+ pragma Preelaborate;
subtype Extended_Index is Index_Type'Base
range Index_Type'First - 1 ..
with function "=" (Left, Right : Element_Type) return Boolean is <>;
package Ada.Containers.Ordered_Maps is
-pragma Preelaborate (Ordered_Maps);
+ pragma Preelaborate;
type Map is tagged private;
with function "=" (Left, Right : Element_Type) return Boolean is <>;
package Ada.Containers.Ordered_Multisets is
-pragma Preelaborate (Ordered_Multisets);
+ pragma Preelaborate;
type Set is tagged private;
------------------------------------------------------------------------------
package Ada.Containers.Prime_Numbers is
-pragma Pure (Prime_Numbers);
+ pragma Pure;
type Primes_Type is array (Positive range <>) of Hash_Type;
------------------------------------------------------------------------------
package Ada.Containers.Red_Black_Trees is
-pragma Pure (Red_Black_Trees);
+ pragma Pure;
type Color_Type is (Red, Black);
R : Node_Access) return Boolean;
package Ada.Containers.Red_Black_Trees.Generic_Keys is
-pragma Pure (Generic_Keys);
+ pragma Pure;
generic
with function New_Node return Node_Access;
with procedure Set_Color (Node : Node_Access; Color : Color_Type) is <>;
package Ada.Containers.Red_Black_Trees.Generic_Operations is
-pragma Pure;
+ pragma Pure;
function Min (Node : Node_Access) return Node_Access;
-- is in accordance with the implementation permission in RM (A.3.3(27)).
package Ada.Characters.Wide_Latin_1 is
-pragma Pure (Wide_Latin_1);
+ pragma Pure;
------------------------
-- Control Characters --
-- is in accordance with the implementation permission in RM (A.3.3(27)).
package Ada.Characters.Wide_Latin_9 is
-pragma Pure (Wide_Latin_9);
+ pragma Pure;
------------------------
-- Control Characters --
-- --
-- S p e c --
-- --
--- Copyright (C) 1992-1997 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 --
------------------------------------------------------------------------------
package Ada.Decimal is
-pragma Pure (Decimal);
+ pragma Pure;
-- The compiler makes a number of assumptions based on the following five
-- constants (e.g. there is an assumption that decimal values can always
with Ada.Task_Identification;
package Ada.Dynamic_Priorities is
-pragma Preelaborate_05 (Dynamic_Priorities);
--- In accordance with Ada 2005 AI-362
+ pragma Preelaborate_05;
+ -- In accordance with Ada 2005 AI-362
procedure Set_Priority
(Priority : System.Any_Priority;
procedure Unhandled_Exception;
pragma Export (C, Unhandled_Exception, "__gnat_unhandled_exception");
- -- Hook for GDB to support "break exception unhandled".
+ -- Hook for GDB to support "break exception unhandled"
-- For "break exception", GDB uses __gnat_raise_nodefer_with_msg, which
-- is not in this section because it fullfills other purposes than a mere
-- --
-- S p e c --
-- --
--- Copyright (C) 1992-1997, 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- --
------------------------------------------------------------------------------
with System.Finalization_Root;
+
package Ada.Finalization.List_Controller is
-pragma Elaborate_Body (List_Controller);
+ pragma Elaborate_Body;
package SFR renames System.Finalization_Root;
-- --
-- S p e c --
-- --
--- Copyright (C) 1992-1997 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 --
with System.Finalization_Root;
package Ada.Finalization is
-pragma Preelaborate (Finalization);
+ pragma Preelaborate;
type Controlled is abstract tagged private;
------------------------------------------------------------------------------
with System.Interrupts;
--- used for Ada_Interrupt_ID.
+-- used for Ada_Interrupt_ID
package Ada.Interrupts is
------------------------------------------------------------------------------
package Ada.IO_Exceptions is
-pragma Pure (IO_Exceptions);
+ pragma Pure;
Status_Error : exception;
Mode_Error : exception;
Result : Complex;
begin
- -- For very small argument, sin (x) = x.
+ -- For very small argument, sin (x) = x
if abs Re (X) < Square_Root_Epsilon and then
abs Im (X) < Square_Root_Epsilon
end if;
end if;
- if Im (X) < 0.0 then -- halve angle, Sqrt of magnitude
+ if Im (X) < 0.0 then -- halve angle, Sqrt of magnitude
R_Y := -R_Y;
end if;
return Compose_From_Cartesian (R_X, R_Y);
exception
when Constraint_Error =>
- -- Rescale and try again.
+ -- Rescale and try again
R := Modulus (Compose_From_Cartesian (Re (X / 4.0), Im (X / 4.0)));
R_X := 2.0 * Sqrt (0.5 * R + 0.5 * Re (X / 4.0));
use Complex_Types;
package Ada.Numerics.Generic_Complex_Elementary_Functions is
- pragma Pure (Ada.Numerics.Generic_Complex_Elementary_Functions);
+ pragma Pure;
function Sqrt (X : Complex) return Complex;
X := Left.Re * Right.Re - Left.Im * Right.Im;
Y := Left.Re * Right.Im + Left.Im * Right.Re;
- -- If either component overflows, try to scale.
+ -- If either component overflows, try to scale
if abs (X) > R'Last then
X := R'(4.0) * (R'(Left.Re / 2.0) * R'(Right.Re / 2.0)
elsif Im2 = 0.0 then
return abs (X.Re);
- -- in all other cases, the naive computation will do.
+ -- In all other cases, the naive computation will do
else
return R (Sqrt (Double (Re2 + Im2)));
-- --
-- S p e c --
-- --
--- Copyright (C) 1992-1997 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 --
type Real is digits <>;
package Ada.Numerics.Generic_Complex_Types is
-
-pragma Pure (Generic_Complex_Types);
+ pragma Pure;
type Complex is record
Re, Im : Real'Base;
type Float_Type is digits <>;
package Ada.Numerics.Generic_Elementary_Functions is
-pragma Pure (Generic_Elementary_Functions);
+ pragma Pure;
function Sqrt (X : Float_Type'Base) return Float_Type'Base;
function Log (X : Float_Type'Base) return Float_Type'Base;
Outs.FP := Flt (Outs.P);
Outs.Scl := (RstL - RstF + 1.0) / (Flt (Outs.P) * Flt (Outs.Q));
- -- Now do *some* sanity checks.
+ -- Now do *some* sanity checks
if Outs.Q < 31
or else Outs.X1 not in 2 .. Outs.P - 1
-- --
-- S p e c --
-- --
--- Copyright (C) 1992-2003 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 --
-- --
------------------------------------------------------------------------------
--- Note: the implementation used in this package was contributed by
--- Robert Eachus. It is based on the work of L. Blum, M. Blum, and
--- M. Shub, SIAM Journal of Computing, Vol 15. No 2, May 1986. The
--- particular choices for P and Q chosen here guarantee a period of
--- 562,085,314,430,582 (about 2**49), and the generated sequence has
--- excellent randomness properties. For further details, see the
--- paper "Fast Generation of Trustworthy Random Numbers", by Robert
--- Eachus, which describes both the algorithm and the efficient
+-- Note: the implementation used in this package was contributed by Robert
+-- Eachus. It is based on the work of L. Blum, M. Blum, and M. Shub, SIAM
+-- Journal of Computing, Vol 15. No 2, May 1986. The particular choices for P
+-- and Q chosen here guarantee a period of 562,085,314,430,582 (about 2**49),
+-- and the generated sequence has excellent randomness properties. For further
+-- details, see the paper "Fast Generation of Trustworthy Random Numbers", by
+-- Robert Eachus, which describes both the algorithm and the efficient
-- implementation approach used here.
with Interfaces;
package Ada.Numerics.Discrete_Random is
- -- The algorithm used here is reliable from a required statistical point
- -- of view only up to 48 bits. We try to behave reasonably in the case
- -- of larger types, but we can't guarantee the required properties.
- -- So generate a warning for these (slightly) dubious cases.
+ -- The algorithm used here is reliable from a required statistical point of
+ -- view only up to 48 bits. We try to behave reasonably in the case of
+ -- larger types, but we can't guarantee the required properties. So
+ -- generate a warning for these (slightly) dubious cases.
pragma Compile_Time_Warning
(Result_Subtype'Size > 48,
"statistical properties not guaranteed for size '> 48");
- -- Basic facilities.
+ -- Basic facilities
type Generator is limited private;
procedure Reset (Gen : Generator);
procedure Reset (Gen : Generator; Initiator : Integer);
- -- Advanced facilities.
+ -- Advanced facilities
type State is private;
X1 := 2 + Int (Initiator) mod (K1 - 3);
X2 := 2 + Int (Initiator) mod (K2 - 3);
- -- Eliminate effects of small Initiators.
+ -- Eliminate effects of small initiators
for J in 1 .. 5 loop
X1 := Square_Mod_N (X1, K1);
Outs.X := Euclid (Outs.P, Outs.Q);
Outs.Scl := 1.0 / (Flt (Outs.P) * Flt (Outs.Q));
- -- Now do *some* sanity checks.
+ -- Now do *some* sanity checks
if Outs.Q < 31 or else Outs.P < 31
or else Outs.X1 not in 2 .. Outs.P - 1
-- routines that take 80-bit arguments).
package Ada.Numerics.Aux is
-pragma Pure (Aux);
+ pragma Pure;
pragma Linker_Options ("-lm");
-- double (see file a-numaux.ads).
package Ada.Numerics.Aux is
-pragma Pure (Aux);
+ pragma Pure;
pragma Linker_Options ("-lm");
-- long double (see file 4onumaux.ads).
package Ada.Numerics.Aux is
-pragma Pure (Aux);
+ pragma Pure;
-- This version omits the pragma linker_options ("-lm") since there is
-- no libm.a library for VxWorks.
-- routines directly.
package Ada.Numerics.Aux is
-pragma Pure (Aux);
+ pragma Pure;
type Double is new Long_Long_Float;
-- routines that take 80-bit arguments).
package Ada.Numerics.Aux is
-pragma Pure (Aux);
+ pragma Pure;
pragma Linker_Options ("-lm");
------------------------------------------------------------------------------
package Ada.Numerics is
-pragma Pure (Numerics);
+ pragma Pure;
Argument_Error : exception;
with procedure Free (X : in out Node_Access);
package Ada.Containers.Red_Black_Trees.Generic_Set_Operations is
-pragma Pure (Generic_Set_Operations);
+ pragma Pure;
procedure Union (Target : in out Tree_Type; Source : Tree_Type);
T_Val := abs (T);
end if;
- -- Extract the integer part of T, truncating towards zero.
+ -- Extract the integer part of T, truncating towards zero
if T_Val < 0.5 then
SC := 0;
with Ada.Characters.Latin_1;
package Ada.Strings.Maps.Constants is
-pragma Preelaborate (Constants);
-pragma Pure_05 (Constants);
--- In accordance with Ada 2005 AI-362
+ pragma Preelaborate;
+ pragma Pure_05;
+ -- In accordance with Ada 2005 AI-362
Control_Set : constant Character_Set;
Graphic_Set : constant Character_Set;
type Element_Type is private;
package Ada.Storage_IO is
-pragma Preelaborate (Storage_IO);
+ pragma Preelaborate;
Buffer_Size : constant System.Storage_Elements.Storage_Count :=
System.Storage_Elements.Storage_Count
with Ada.Strings.Superbounded;
package Ada.Strings.Bounded is
-pragma Preelaborate (Bounded);
+ pragma Preelaborate;
generic
Max : Positive;
------------------------------------------------------------------------------
package Ada.Streams is
-pragma Pure (Streams);
+ pragma Pure;
type Root_Stream_Type is abstract tagged limited private;
with Ada.Strings.Maps;
package Ada.Strings.Fixed is
-pragma Preelaborate (Fixed);
+ pragma Preelaborate;
--------------------------------------------------------------
-- Copy Procedure for Strings of Possibly Different Lengths --
------------------------------------------------------------------------------
package Ada.Strings is
-pragma Pure (Strings);
+ pragma Pure;
Space : constant Character := ' ';
Wide_Space : constant Wide_Character := ' ';
with Ada.Characters.Latin_1;
package Ada.Strings.Maps is
-pragma Preelaborate (Maps);
-pragma Pure_05 (Maps);
--- In accordance with Ada 2005 AI-362
+ pragma Preelaborate;
+ pragma Pure_05;
+ -- In accordance with Ada 2005 AI-362
--------------------------------
-- Character Set Declarations --
with Ada.Strings.Maps;
private package Ada.Strings.Search is
-pragma Preelaborate (Search);
+ pragma Preelaborate;
function Index
(Source : String;
with Ada.Strings.Maps;
package Ada.Strings.Superbounded is
-pragma Preelaborate (Superbounded);
+ pragma Preelaborate;
type Super_String (Max_Length : Positive) is record
Current_Length : Natural := 0;
with Ada.Finalization;
package Ada.Strings.Unbounded is
-pragma Preelaborate (Unbounded);
+ pragma Preelaborate;
type Unbounded_String is private;
-- utilities (such as GNAT.SPITBOL.Patterns).
package Ada.Strings.Unbounded.Aux is
-pragma Preelaborate (Aux);
+ pragma Preelaborate;
procedure Get_String
(U : Unbounded_String;
with Ada.Strings.Wide_Superbounded;
package Ada.Strings.Wide_Bounded is
-pragma Preelaborate (Wide_Bounded);
+ pragma Preelaborate;
generic
Max : Positive;
with Ada.Strings.Wide_Maps;
package Ada.Strings.Wide_Fixed is
-pragma Preelaborate (Wide_Fixed);
+ pragma Preelaborate;
-------------------------------------------------------------------
-- Copy Procedure for Wide_Strings of Possibly Different Lengths --
with Ada.Finalization;
package Ada.Strings.Wide_Maps is
- pragma Preelaborate (Wide_Maps);
+ pragma Preelaborate;
-------------------------------------
-- Wide Character Set Declarations --
with Ada.Strings.Wide_Maps;
private package Ada.Strings.Wide_Search is
-pragma Preelaborate (Wide_Search);
+ pragma Preelaborate;
function Index
(Source : Wide_String;
with Ada.Strings.Wide_Maps;
package Ada.Strings.Wide_Superbounded is
-pragma Preelaborate (Wide_Superbounded);
+ pragma Preelaborate;
Wide_NUL : constant Wide_Character := Wide_Character'Val (0);
with Ada.Finalization;
package Ada.Strings.Wide_Unbounded is
-pragma Preelaborate (Wide_Unbounded);
+ pragma Preelaborate;
+
type Unbounded_Wide_String is private;
Null_Unbounded_Wide_String : constant Unbounded_Wide_String;
with Ada.Strings.Wide_Wide_Superbounded;
package Ada.Strings.Wide_Wide_Bounded is
-pragma Preelaborate (Wide_Wide_Bounded);
+ pragma Preelaborate;
generic
Max : Positive;
with Ada.Strings.Wide_Wide_Maps;
package Ada.Strings.Wide_Wide_Fixed is
-pragma Preelaborate (Wide_Wide_Fixed);
+ pragma Preelaborate;
------------------------------------------------------------------------
-- Copy Procedure for Wide_Wide_Strings of Possibly Different Lengths --
with Ada.Finalization;
package Ada.Strings.Wide_Wide_Maps is
- pragma Preelaborate (Wide_Wide_Maps);
+ pragma Preelaborate;
------------------------------------------
-- Wide_Wide_Character Set Declarations --
with Ada.Strings.Wide_Wide_Maps;
private package Ada.Strings.Wide_Wide_Search is
-pragma Preelaborate (Wide_Wide_Search);
+ pragma Preelaborate;
function Index
(Source : Wide_Wide_String;
with Ada.Strings.Wide_Wide_Maps;
package Ada.Strings.Wide_Wide_Superbounded is
-pragma Preelaborate (Wide_Wide_Superbounded);
+ pragma Preelaborate;
Wide_Wide_NUL : constant Wide_Wide_Character :=
Wide_Wide_Character'Val (0);
with Ada.Finalization;
package Ada.Strings.Wide_Wide_Unbounded is
-pragma Preelaborate (Wide_Wide_Unbounded);
+ pragma Preelaborate;
+
type Unbounded_Wide_Wide_String is private;
Null_Unbounded_Wide_Wide_String : constant Unbounded_Wide_Wide_String;
with Ada.Characters.Wide_Latin_1;
package Ada.Strings.Wide_Maps.Wide_Constants is
-pragma Preelaborate (Wide_Constants);
+ pragma Preelaborate;
Control_Set : constant Wide_Maps.Wide_Character_Set;
Graphic_Set : constant Wide_Maps.Wide_Character_Set;
-- utilities.
package Ada.Strings.Wide_Unbounded.Aux is
-pragma Preelaborate (Aux);
+ pragma Preelaborate;
procedure Get_Wide_String
(U : Unbounded_Wide_String;
-- other layered utilities.
package Ada.Strings.Wide_Wide_Unbounded.Aux is
-pragma Preelaborate (Aux);
+ pragma Preelaborate;
procedure Get_Wide_Wide_String
(U : Unbounded_Wide_Wide_String;
with System.File_Control_Block;
package Ada.Text_IO is
-pragma Elaborate_Body (Text_IO);
+ pragma Elaborate_Body;
type File_Type is limited private;
type File_Mode is (In_File, Out_File, Append_File);
-- available in Ada 95 mode, since it deals only with wide characters.
package Ada.Wide_Characters is
-pragma Pure (Wide_Characters);
+ pragma Pure;
end Ada.Wide_Characters;
------------------------------------------------------------------------------
package Ada.Wide_Wide_Characters is
-pragma Pure (Wide_Wide_Characters);
+ pragma Pure;
end Ada.Wide_Wide_Characters;
------------------------------------------------------------------------------
package Ada is
-pragma Pure (Ada);
+ pragma Pure;
end Ada;
-- --
-- S p e c --
-- --
--- 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- --
------------------------------------------------------------------------------
package Csets is
-pragma Elaborate_Body (Csets);
+ pragma Elaborate_Body;
-- This package contains character tables for the various character
-- sets that are supported for source representation. Character and
-- --
-- S p e c --
-- --
--- 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- --
-- --
------------------------------------------------------------------------------
-package Debug is
-pragma Preelaborate (Debug);
-
-- This package contains global flags used to control the inclusion
-- of debugging code in various phases of the compiler. Some of these
-- flags are also used by the binder and gnatmake.
+package Debug is
+ pragma Preelaborate;
+
-------------------------
-- Dynamic Debug Flags --
-------------------------
-- the bind. It is also a convenient parent for all DEC IO child packages.
package DEC is
-pragma Pure (DEC);
+ pragma Pure;
end DEC;
-- --
-- S p e c --
-- --
--- Copyright (C) 1996-2004 Ada Core Technologies, Inc. --
+-- Copyright (C) 1996-2005 Ada Core Technologies, 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- --
-- from an exception handler.
package GNAT.Current_Exception is
-pragma Pure (Current_Exception);
+ pragma Pure;
-----------------
-- Subprograms --
-- --
-- S p e c --
-- --
--- Copyright (C) 2000-2002 Ada Core Technologies, Inc. --
+-- Copyright (C) 2000-2005 Ada Core Technologies, 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- --
-- package allows for raising the standard predefined exceptions at least.
package GNAT.Exceptions is
-pragma Pure (Exceptions);
+ pragma Pure;
type Exception_Type is limited null record;
-- Type used to specify which exception to raise.
-- S p e c --
-- --
-- Copyright (C) 1986 by University of Toronto. --
--- Copyright (C) 1996-2005 Ada Core Technologies, Inc. --
+-- Copyright (C) 1996-2005, AdaCore --
-- --
-- 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- --
-- extensions that provide full (type 0) computational capabilities.
package GNAT.Regpat is
-pragma Preelaborate (Regpat);
+ pragma Preelaborate;
-- The grammar is the following:
-- Several versions of the Match subprogram are provided, with different
-- parameters and return results.
- -- See the description under each of these subprograms.
+ -- See the description under each of these subprograms
-- Here is a short example showing how to get the substring matched by
-- the first parenthesis pair.
Data : String;
Data_First : Integer := -1;
Data_Last : Positive := Positive'Last) return Boolean;
- -- Return True if Data matches using the given pattern matcher.
+ -- Return True if Data matches using the given pattern matcher
pragma Inline (Match);
-- All except the last one below
-- Match Data using the given pattern matcher and store result in Matches.
-- The expression matches if Matches (0) /= No_Match.
--
- -- At most Matches'Length parenthesis are returned.
+ -- At most Matches'Length parenthesis are returned
-----------
-- Debug --
Program_First : constant := 1;
- -- The "internal use only" fields in regexp are present to pass
- -- info from compile to execute that permits the execute phase
- -- to run lots faster on simple cases. They are:
+ -- The "internal use only" fields in regexp are present to pass info from
+ -- compile to execute that permits the execute phase to run lots faster on
+ -- simple cases. They are:
-- First character that must begin a match or ASCII.Nul
-- Anchored true iff match must start at beginning of line
-- Must_Have pointer to string that match must include or null
-- Must_Have_Length length of Must_Have string
- -- First and Anchored permit very fast decisions on suitable
- -- starting points for a match, cutting down the work a lot.
- -- Must_Have permits fast rejection of lines that cannot possibly
- -- match.
-
- -- The Must_Have tests are costly enough that Optimize
- -- supplies a Must_Have only if the r.e. contains something potentially
- -- expensive (at present, the only such thing detected is * or +
- -- at the start of the r.e., which can involve a lot of backup).
- -- The length is supplied because the test in Execute needs it
- -- and Optimize is computing it anyway.
+ -- First and Anchored permit very fast decisions on suitable starting
+ -- points for a match, cutting down the work a lot. Must_Have permits fast
+ -- rejection of lines that cannot possibly match.
+
+ -- The Must_Have tests are costly enough that Optimize supplies a Must_Have
+ -- only if the r.e. contains something potentially expensive (at present,
+ -- the only such thing detected is * or at the start of the r.e., which can
+ -- involve a lot of backup). The length is supplied because the test in
+ -- Execute needs it and Optimize is computing it anyway.
-- The initialization is meant to fail-safe in case the user of this
-- package tries to use an uninitialized matcher. This takes advantage
-- This package provides a utility routine for checking for bad spellings
package GNAT.Spelling_Checker is
-pragma Pure (Spelling_Checker);
+ pragma Pure;
function Is_Bad_Spelling_Of
(Found : String;
-- --
-- S p e c --
-- --
--- Copyright (C) 1997-2005 Ada Core Technologies, Inc. --
+-- Copyright (C) 1997-2005, AdaCore --
-- --
-- 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- --
with Interfaces; use Interfaces;
package GNAT.Spitbol is
-pragma Preelaborate (Spitbol);
+ pragma Preelaborate;
-- The Spitbol package relies heavily on the Unbounded_String package,
-- using the synonym VString for variable length string. The following
-- Any non-limited type can be used as the value type in the table
Null_Value : Value_Type;
- -- Value used to represent a value that is not present in the table.
+ -- Value used to represent a value that is not present in the table
with function Img (A : Value_Type) return String;
-- Used to provide image of value in Dump procedure
-- --
-- S p e c --
-- --
--- Copyright (C) 1998-2005 AdaCore --
+-- Copyright (C) 1998-2005, AdaCore --
-- --
-- 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- --
Table_Increment : Natural;
package GNAT.Table is
-pragma Elaborate_Body (Table);
+ pragma Elaborate_Body;
-- Table_Component_Type and Table_Index_Type specify the type of the
-- array, Table_Low_Bound is the lower bound. Index_type must be an
-- --
-- S p e c --
-- --
--- Copyright (C) 1998-2002 Ada Core Technologies, Inc. --
+-- Copyright (C) 1998-2005 Ada Core Technologies, 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- --
-- they have no effect (they do NOT cause the tasking runtime to be loaded).
package GNAT.Task_Lock is
-pragma Elaborate_Body (Task_Lock);
+ pragma Elaborate_Body;
procedure Lock;
pragma Inline (Lock);
with Ada.Exceptions; use Ada.Exceptions;
package GNAT.Traceback.Symbolic is
-pragma Elaborate_Body (Traceback.Symbolic);
+ pragma Elaborate_Body;
------------------------
-- Symbolic_Traceback --
-- --
-- S p e c --
-- --
--- 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- --
with Types; use Types;
package Get_Targ is
-pragma Preelaborate (Get_Targ);
+ pragma Preelaborate;
function Get_Bits_Per_Unit return Pos;
pragma Import (C, Get_Bits_Per_Unit, "get_target_bits_per_unit");
@c o
@c G N A T C O D I N G S T Y L E o
@c o
-@c Copyright (C) 1992-2004 Ada Core Technologies, Inc. o
+@c Copyright (C) 1992-2005 Ada Core Technologies, Inc. o
@c o
@c GNAT is free software; you can redistribute it and/or modify it under o
@c terms of the GNU General Public License as published by the Free Soft- o
@page
@vskip 0pt plus 1filll
-Copyright @copyright{} 1995-2003, Free Software Foundation
+Copyright @copyright{} 1995-2005, Free Software Foundation
Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.1
@item
After the file header comment, the context clause and unit specification
should be the first thing in a @syntax{program_unit}.
+
+@item
+Preelaborate, Pure and Elaborate_Body pragmas should be added right after the
+package name, indented an extra level and using the parameterless form:
+
+@smallexample @c adanocomment
+@group
+ package Preelaborate_Package is
+ pragma Preelaborate;
+ ...
+ end Preelaborate_Package;
+@end group
+@end smallexample
+
@end itemize
@c -------------------------------------------------------------------------
-- This is the parent package for a library of useful units provided with GNAT
package GNAT is
-pragma Pure (GNAT);
+ pragma Pure;
end GNAT;
with System.Parameters;
package Interfaces.C is
-pragma Pure (C);
+ pragma Pure;
-- Declaration's based on C's <limits.h>
-- --
-- S p e c --
-- --
--- Copyright (C) 1993-2004 Free Software Foundation, Inc. --
+-- Copyright (C) 1993-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 --
Default_Terminator : Element;
package Interfaces.C.Pointers is
-pragma Preelaborate (Pointers);
+ pragma Preelaborate;
type Pointer is access all Element;
-- Missing package comment ???
with Ada.Tags;
+
package Interfaces.CPP is
-pragma Elaborate_Body;
--- We have a dummy body to deal with bootstrap path issues
+ pragma Elaborate_Body;
+ -- We have a dummy body to deal with bootstrap path issues
subtype Vtable_Ptr is Ada.Tags.Tag;
-- --
-- S p e c --
-- --
--- Copyright (C) 1993-2004 Free Software Foundation, Inc. --
+-- Copyright (C) 1993-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 Interfaces.C.Strings is
-pragma Preelaborate (Strings);
+ pragma Preelaborate;
type char_array_access is access all char_array;
pragma Elaborate_All (Ada.Numerics.Generic_Complex_Types);
package Interfaces.Fortran is
-pragma Pure (Fortran);
+ pragma Pure;
type Fortran_Integer is new Integer;
type Real is new Float;
-- --
-- S p e c --
-- --
--- Copyright (C) 1993,1994,1995 Free Software Foundation, Inc. --
+-- Copyright (C) 1993-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- --
-- Definition of values for OS/2 error returns
package Interfaces.OS2Lib.Errors is
-pragma Preelaborate (Errors);
+ pragma Preelaborate;
NO_ERROR : constant := 0;
ERROR_INVALID_FUNCTION : constant := 1;
-- --
-- S p e c --
-- --
--- Copyright (C) 1993-1997 Free Software Foundation, Inc. --
+-- Copyright (C) 1993-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- --
with System;
package Interfaces.OS2Lib is
-pragma Preelaborate (OS2Lib);
+ pragma Preelaborate;
package IC renames Interfaces.C;
package ICS renames Interfaces.C.Strings;
type ULONG is new IC.unsigned_long;
type PULONG is access all ULONG;
- -- Coprocessor stack register element.
+ -- Coprocessor stack register element
type FPREG is record
losig : ULONG; -- Low 32-bits of the mantissa
-- --
-- S p e c --
-- --
--- Copyright (C) 1993-1998 Free Software Foundation, Inc. --
+-- Copyright (C) 1993-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- --
with Interfaces.OS2Lib.Threads;
package Interfaces.OS2Lib.Synchronization is
-pragma Preelaborate (Synchronization);
+ pragma Preelaborate;
package IC renames Interfaces.C;
package IOT renames Interfaces.OS2Lib.Threads;
with Interfaces.C;
package Interfaces.OS2Lib.Threads is
-pragma Preelaborate (Threads);
+ pragma Preelaborate;
package IC renames Interfaces.C;
with System.VxWorks;
package Interfaces.VxWorks is
- pragma Preelaborate (VxWorks);
+ pragma Preelaborate;
------------------------------------------------------------------------
-- Here is a complete example that shows how to handle the Interrupt 0x33
with System.VxWorks;
package Interfaces.VxWorks is
- pragma Preelaborate (VxWorks);
+ pragma Preelaborate;
------------------------------------------------------------------------
-- Here is a complete example that shows how to handle the Interrupt 0x14
-- --
-- S p e c --
-- --
--- Copyright (C) 2002-2003 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 --
-- floating-point formats are available.
package Interfaces is
-pragma Pure (Interfaces);
+ pragma Pure;
type Integer_8 is range -2 ** 7 .. 2 ** 7 - 1;
for Integer_8'Size use 8;
function Shift_Left
(Value : Unsigned_8;
- Amount : Natural)
- return Unsigned_8;
+ Amount : Natural) return Unsigned_8;
function Shift_Right
(Value : Unsigned_8;
- Amount : Natural)
- return Unsigned_8;
+ Amount : Natural) return Unsigned_8;
function Shift_Right_Arithmetic
(Value : Unsigned_8;
- Amount : Natural)
- return Unsigned_8;
+ Amount : Natural) return Unsigned_8;
function Rotate_Left
(Value : Unsigned_8;
- Amount : Natural)
- return Unsigned_8;
+ Amount : Natural) return Unsigned_8;
function Rotate_Right
(Value : Unsigned_8;
- Amount : Natural)
- return Unsigned_8;
+ Amount : Natural) return Unsigned_8;
function Shift_Left
(Value : Unsigned_16;
- Amount : Natural)
- return Unsigned_16;
+ Amount : Natural) return Unsigned_16;
function Shift_Right
(Value : Unsigned_16;
- Amount : Natural)
- return Unsigned_16;
+ Amount : Natural) return Unsigned_16;
function Shift_Right_Arithmetic
(Value : Unsigned_16;
- Amount : Natural)
- return Unsigned_16;
+ Amount : Natural) return Unsigned_16;
function Rotate_Left
(Value : Unsigned_16;
- Amount : Natural)
- return Unsigned_16;
+ Amount : Natural) return Unsigned_16;
function Rotate_Right
(Value : Unsigned_16;
- Amount : Natural)
- return Unsigned_16;
+ Amount : Natural) return Unsigned_16;
function Shift_Left
(Value : Unsigned_32;
- Amount : Natural)
- return Unsigned_32;
+ Amount : Natural) return Unsigned_32;
function Shift_Right
(Value : Unsigned_32;
- Amount : Natural)
- return Unsigned_32;
+ Amount : Natural) return Unsigned_32;
function Shift_Right_Arithmetic
(Value : Unsigned_32;
- Amount : Natural)
- return Unsigned_32;
+ Amount : Natural) return Unsigned_32;
function Rotate_Left
(Value : Unsigned_32;
- Amount : Natural)
- return Unsigned_32;
+ Amount : Natural) return Unsigned_32;
function Rotate_Right
(Value : Unsigned_32;
- Amount : Natural)
- return Unsigned_32;
+ Amount : Natural) return Unsigned_32;
function Shift_Left
(Value : Unsigned_64;
- Amount : Natural)
- return Unsigned_64;
+ Amount : Natural) return Unsigned_64;
function Shift_Right
(Value : Unsigned_64;
- Amount : Natural)
- return Unsigned_64;
+ Amount : Natural) return Unsigned_64;
function Shift_Right_Arithmetic
(Value : Unsigned_64;
- Amount : Natural)
- return Unsigned_64;
+ Amount : Natural) return Unsigned_64;
function Rotate_Left
(Value : Unsigned_64;
- Amount : Natural)
- return Unsigned_64;
+ Amount : Natural) return Unsigned_64;
function Rotate_Right
(Value : Unsigned_64;
- Amount : Natural)
- return Unsigned_64;
+ Amount : Natural) return Unsigned_64;
pragma Import (Intrinsic, Shift_Left);
pragma Import (Intrinsic, Shift_Right);
-- Floating point types. We use the digits value to define the IEEE
-- forms, otherwise a configuration pragma specifying VAX float can
-- default the digits to an illegal value for IEEE.
+
-- Note: it is harmless, and explicitly permitted, to include additional
-- types in interfaces, so it is not wrong to have IEEE_Extended_Float
-- defined even if the extended format is not available.
-- --
-- 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 --
--- apply solely to the implementation dependent additions to thie file. --
+-- apply solely to the implementation dependent sections of this file. --
-- --
-- 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- --
-- Assumes integer sizes of 8, 16, 32 and 64 are available, and that the
-- floating-point formats are IEEE compatible.
--- Note: There is a specialized version of this package for OpenVMS.
+-- Note: There is a specialized version of this package for OpenVMS
package Interfaces is
-pragma Pure (Interfaces);
+ pragma Pure;
type Integer_8 is range -2 ** 7 .. 2 ** 7 - 1;
for Integer_8'Size use 8;
function Shift_Left
(Value : Unsigned_16;
- Amount : Natural) return Unsigned_16;
+ Amount : Natural) return Unsigned_16;
function Shift_Right
(Value : Unsigned_16;
-- that the types Short_Float and Long_Float in Standard refer to the
-- 32-bit short and 64-bit long IEEE forms. Furthermore, if there is
-- an extended float, we assume that it is available as Long_Long_Float.
+
-- Note: it is harmless, and explicitly permitted, to include additional
-- types in interfaces, so it is not wrong to have IEEE_Extended_Float
-- defined even if the extended format is not available.
-- --
-- S p e c --
-- --
--- Copyright (C) 1992-2001 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- --
with Types; use Types;
package Output is
-pragma Elaborate_Body (Output);
+ pragma Elaborate_Body;
type Output_Proc is access procedure (S : String);
-- This type is used for the Set_Special_Output procedure. If this
-- --
-- S p e c --
-- --
--- Copyright (C) 2004 Free Software Foundation, Inc. --
+-- Copyright (C) 2004-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 --
-- operations may not be available if type Address is a signed integer.
package System.Address_Operations is
-pragma Pure (Address_Operations);
+ pragma Pure;
-- The semantics of the arithmetic operations are those that apply to
-- a modular type with the same length as Address, i.e. they provide
-- --
-- S p e c --
-- --
--- 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- --
with Interfaces;
package System.Arith_64 is
-pragma Pure (Arith_64);
+ pragma Pure;
subtype Int64 is Interfaces.Integer_64;
type Object (<>) is limited private;
package System.Address_To_Access_Conversions is
-pragma Preelaborate (Address_To_Access_Conversions);
-
-pragma Elaborate_Body;
--- This pragma Elaborate_Body is there to ensure the requirement of what is
--- at the moment a dummy null body. The reason this null body is there is
--- that we used to have a real body, and it causes bootstrap problems with
--- old compilers if we try to remove the corresponding file.
+ pragma Preelaborate;
+ pragma Elaborate_Body;
+ -- This pragma Elaborate_Body is there to ensure the requirement of what is
+ -- at the moment a dummy null body. The reason this null body is there is
+ -- that we used to have a real body, and it causes bootstrap problems with
+ -- old compilers if we try to remove the corresponding file.
pragma Compile_Time_Warning
(Object'Unconstrained_Array,
with System.Generic_Vector_Operations;
with System.Vectors.Boolean_Operations;
+
package System.Boolean_Array_Operations is
-pragma Pure (Boolean_Array_Operations);
+ pragma Pure;
+
type Boolean_Array is array (Integer range <>) of Boolean;
package Boolean_Operations renames System.Vectors.Boolean_Operations;
-- via GNAT.Case_Util, which imports all the entities from this package.
package System.Case_Util is
-pragma Pure (Case_Util);
+ pragma Pure;
-- Note: all the following functions handle the full Latin-1 set
-- --
-- S p e c --
-- --
--- Copyright (C) 2004,2005 Free Software Foundation, Inc. --
+-- Copyright (C) 2004-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- --
-- on 64 bit VMS. Note that routines that allocate memory remain 32bit.
with System.Parameters;
+
package System.CRTL is
-pragma Preelaborate (CRTL);
+ pragma Preelaborate;
subtype chars is System.Address;
-- Pointer to null-terminated array of characters
-- on non-VMS systems.
with System.Parameters;
+
package System.CRTL is
-pragma Preelaborate (CRTL);
+ pragma Preelaborate;
subtype chars is System.Address;
-- Pointer to null-terminated array of characters
-- --
-- S p e c --
-- --
--- Copyright (C) 1996-2003 Free Software Foundation, Inc. --
+-- Copyright (C) 1996-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- --
with System.Standard_Library;
package System.Exception_Table is
-pragma Elaborate_Body;
+ pragma Elaborate_Body;
package SSL renames System.Standard_Library;
-- Integer exponentiation (checks off)
package System.Exn_Int is
-pragma Pure (Exn_Int);
+ pragma Pure;
function Exn_Integer (Left : Integer; Right : Natural) return Integer;
-- Long_Long_Float exponentiation (checks off)
package System.Exn_LLF is
-pragma Pure (Exn_LLF);
+ pragma Pure;
function Exn_Long_Long_Float
(Left : Long_Long_Float;
-- Long_Long_Integer exponentiation (checks off)
package System.Exn_LLI is
-pragma Pure (Exn_LLI);
+ pragma Pure;
function Exn_Long_Long_Integer
(Left : Long_Long_Integer;
-- Integer exponentiation (checks on)
package System.Exp_Int is
-pragma Pure (Exp_Int);
+ pragma Pure;
function Exp_Integer
(Left : Integer;
-- Long_Long_Integer exponentiation
package System.Exp_LLI is
-pragma Pure (Exp_LLI);
+ pragma Pure;
function Exp_Long_Long_Integer
(Left : Long_Long_Integer;
with System.Unsigned_Types;
package System.Exp_LLU is
-pragma Pure (Exp_LLU);
+ pragma Pure;
function Exp_Long_Long_Unsigned
(Left : System.Unsigned_Types.Long_Long_Unsigned;
-- accounting for the modulus value which is passed as the second argument.
package System.Exp_Mod is
-pragma Pure (Exp_Mod);
+ pragma Pure;
function Exp_Modular
(Left : Integer;
with System.Unsigned_Types;
package System.Exp_Uns is
-pragma Pure (Exp_Uns);
+ pragma Pure;
function Exp_Unsigned
(Left : System.Unsigned_Types.Unsigned;
-- --
-- S p e c --
-- --
--- 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- --
with System.Fat_Gen;
package System.Fat_Flt is
-pragma Pure (Fat_Flt);
+ pragma Pure;
-- Note the only entity from this package that is acccessed by Rtsfind
-- is the name of the package instantiation. Entities within this package
-- --
-- S p e c --
-- --
--- 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- --
type T is digits <>;
package System.Fat_Gen is
-pragma Pure (Fat_Gen);
+ pragma Pure;
subtype UI is Integer;
-- The runtime representation of universal integer for the purposes of
-- --
-- S p e c --
-- --
--- 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- --
with System.Fat_Gen;
package System.Fat_LFlt is
-pragma Pure (Fat_LFlt);
+ pragma Pure;
-- Note the only entity from this package that is acccessed by Rtsfind
-- is the name of the package instantiation. Entities within this package
-- --
-- S p e c --
-- --
--- 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- --
with System.Fat_Gen;
package System.Fat_LLF is
-pragma Pure (Fat_LLF);
+ pragma Pure;
-- Note the only entity from this package that is acccessed by Rtsfind
-- is the name of the package instantiation. Entities within this package
-- --
-- S p e c --
-- --
--- 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- --
with System.Fat_Gen;
package System.Fat_SFlt is
-pragma Pure (Fat_SFlt);
+ pragma Pure;
-- Note the only entity from this package that is acccessed by Rtsfind
-- is the name of the package instantiation. Entities within this package
-- --
-- S p e c --
-- --
--- 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- --
with System.Finalization_Root;
package System.Finalization_Implementation is
-pragma Elaborate_Body (Finalization_Implementation);
+ pragma Elaborate_Body;
package SFR renames System.Finalization_Root;
-- --
-- S p e c --
-- --
--- 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- --
with Unchecked_Conversion;
package System.Finalization_Root is
-pragma Preelaborate (Finalization_Root);
+ pragma Preelaborate;
type Root_Controlled;
-- This package contains the routine used for the 'Fore attribute
package System.Fore is
-pragma Pure (Fore);
+ pragma Pure;
function Fore (Lo, Hi : Long_Long_Float) return Natural;
-- Compute Fore attribute value for a fixed-point type. The parameters
with System.Vectors;
with System.Storage_Elements;
+
generic
type Element is (<>);
type Index is (<>);
type Element_Array is array (Index range <>) of Element;
+
package System.Generic_Vector_Operations is
-pragma Pure (Generic_Vector_Operations);
+ pragma Pure;
generic
with function Element_Op (X, Y : Element) return Element;
-- complete control over allocation.
package System.HTable is
-pragma Preelaborate (HTable);
+ pragma Preelaborate;
-------------------
-- Simple_HTable --
with System.Unsigned_Types;
package System.Img_BIU is
-pragma Pure (Img_BIU);
+ pragma Pure;
procedure Set_Image_Based_Integer
(V : Integer;
-- Boolean'Image
package System.Img_Bool is
-pragma Pure (Img_Bool);
+ pragma Pure;
function Image_Boolean (V : Boolean) return String;
-- Computes Boolean'Image (V) and returns the result.
-- Character'Image
package System.Img_Char is
-pragma Pure (Img_Char);
+ pragma Pure;
function Image_Character (V : Character) return String;
-- Computes Character'Image (V) and returns the result
-- type does not exceed Integer'Size (also used for Text_IO.Decimal_IO output)
package System.Img_Dec is
-pragma Preelaborate (Img_Dec);
+ pragma Preelaborate;
function Image_Decimal
(V : Integer;
-- Special routines exist for the enumeration routines in these packages.
package System.Img_Enum is
-pragma Pure (Img_Enum);
+ pragma Pure;
function Image_Enumeration_8
(Pos : Natural;
-- operations required in Text_IO.Integer_IO for such types.
package System.Img_Int is
-pragma Pure (Img_Int);
+ pragma Pure;
function Image_Integer (V : Integer) return String;
-- Computes Integer'Image (V) and returns the result
with System.Unsigned_Types;
package System.Img_LLB is
-pragma Preelaborate (Img_LLB);
+ pragma Preelaborate;
procedure Set_Image_Based_Long_Long_Integer
(V : Long_Long_Integer;
-- type does exceeds Integer'Size (also used for Text_IO.Decimal_IO output)
package System.Img_LLD is
-pragma Preelaborate (Img_LLD);
+ pragma Preelaborate;
function Image_Long_Long_Decimal
(V : Long_Long_Integer;
-- operations required in Text_IO.Integer_IO for such types.
package System.Img_LLI is
-pragma Preelaborate (Img_LLI);
+ pragma Preelaborate;
function Image_Long_Long_Integer (V : Long_Long_Integer) return String;
-- Computes Long_Long_Integer'Image (V) and returns the result.
with System.Unsigned_Types;
package System.Img_LLU is
-pragma Pure (Img_LLU);
+ pragma Pure;
function Image_Long_Long_Unsigned
(V : System.Unsigned_Types.Long_Long_Unsigned)
with System.Unsigned_Types;
package System.Img_LLW is
-pragma Pure (Img_LLW);
+ pragma Pure;
procedure Set_Image_Width_Long_Long_Integer
(V : Long_Long_Integer;
-- Image for fixed and float types (also used for Float_IO/Fixed_IO output)
package System.Img_Real is
-pragma Preelaborate (Img_Real);
+ pragma Preelaborate;
function Image_Ordinary_Fixed_Point
(V : Long_Long_Float;
with System.Unsigned_Types;
package System.Img_Uns is
-pragma Pure (Img_Uns);
+ pragma Pure;
function Image_Unsigned
(V : System.Unsigned_Types.Unsigned)
-- Wide_[Wide_]Character'Image
package System.Img_WChar is
-pragma Pure (Img_WChar);
+ pragma Pure;
function Image_Wide_Character (V : Wide_Character) return String;
-- Computes Wide_Character'Image (V) and returns the computed result
with System.Unsigned_Types;
package System.Img_WIU is
-pragma Pure (Img_WIU);
+ pragma Pure;
procedure Set_Image_Width_Integer
(V : Integer;
-- --
-- S p e c --
-- --
--- Copyright (C) 1992-1998 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- --
-- for character, integer, string and a new line function
package System.IO is
-pragma Preelaborate (IO);
+ pragma Preelaborate;
procedure Put (X : Integer);
-- --
-- S p e c --
-- --
--- 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- --
-- for full details.
package System.Machine_Code is
-pragma Pure (Machine_Code);
+ pragma Pure;
type Asm_Input_Operand is private;
type Asm_Output_Operand is private;
-- fixed-point type with non-static bounds.
package System.Mantissa is
-pragma Pure (Mantissa);
+ pragma Pure;
function Mantissa_Value (First, Last : Integer) return Natural;
-- Compute Mantissa value from the given arguments, which are the First
-- --
-- S p e c --
-- --
--- Copyright (C) 2001-2003 Free Software Foundation, Inc. --
+-- Copyright (C) 2001-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 --
-- The above with is contrary to the intent ???
package System.Memory_Copy is
-pragma Preelaborate;
+ pragma Preelaborate;
procedure memcpy (S1 : Address; S2 : Address; N : System.CRTL.size_t)
renames System.CRTL.memcpy;
with Unchecked_Conversion;
package System.OS_Interface is
-pragma Preelaborate;
+ pragma Preelaborate;
pragma Linker_Options ("-mthreads");
-- Handing of packed arrays with Component_Size = 3
package System.Pack_03 is
-pragma Preelaborate (Pack_03);
+ pragma Preelaborate;
Bits : constant := 3;
-- Handling of packed arrays with Component_Size = 5
package System.Pack_05 is
-pragma Preelaborate (Pack_05);
+ pragma Preelaborate;
Bits : constant := 5;
-- Handling of packed arrays with Component_Size = 6
package System.Pack_06 is
-pragma Preelaborate (Pack_06);
+ pragma Preelaborate;
Bits : constant := 6;
-- Handling of packed arrays with Component_Size = 7
package System.Pack_07 is
-pragma Preelaborate (Pack_07);
+ pragma Preelaborate;
Bits : constant := 7;
-- Handling of packed arrays with Component_Size = 9
package System.Pack_09 is
-pragma Preelaborate (Pack_09);
+ pragma Preelaborate;
Bits : constant := 9;
-- Handling of packed arrays with Component_Size = 10
package System.Pack_10 is
-pragma Preelaborate (Pack_10);
+ pragma Preelaborate;
Bits : constant := 10;
-- Handling of packed arrays with Component_Size = 11
package System.Pack_11 is
-pragma Preelaborate (Pack_11);
+ pragma Preelaborate;
Bits : constant := 11;
-- Handling of packed arrays with Component_Size = 12
package System.Pack_12 is
-pragma Preelaborate (Pack_12);
+ pragma Preelaborate;
Bits : constant := 12;
-- Handling of packed arrays with Component_Size = 13
package System.Pack_13 is
-pragma Preelaborate (Pack_13);
+ pragma Preelaborate;
Bits : constant := 13;
-- Handing of packed arrays with Component_Size = 14
package System.Pack_14 is
-pragma Preelaborate (Pack_14);
+ pragma Preelaborate;
Bits : constant := 14;
-- Handling of packed arrays with Component_Size = 15
package System.Pack_15 is
-pragma Preelaborate (Pack_15);
+ pragma Preelaborate;
Bits : constant := 15;
-- Handling of packed arrays with Component_Size = 17
package System.Pack_17 is
-pragma Preelaborate (Pack_17);
+ pragma Preelaborate;
Bits : constant := 17;
-- Handling of packed arrays with Component_Size = 18
package System.Pack_18 is
-pragma Preelaborate (Pack_18);
+ pragma Preelaborate;
Bits : constant := 18;
-- Handling of packed arrays with Component_Size = 19
package System.Pack_19 is
-pragma Preelaborate (Pack_19);
+ pragma Preelaborate;
Bits : constant := 19;
-- Handling of packed arrays with Component_Size = 20
package System.Pack_20 is
-pragma Preelaborate (Pack_20);
+ pragma Preelaborate;
Bits : constant := 20;
-- Handling of packed arrays with Component_Size = 21
package System.Pack_21 is
-pragma Preelaborate (Pack_21);
+ pragma Preelaborate;
Bits : constant := 21;
-- Handling of packed arrays with Component_Size = 22
package System.Pack_22 is
-pragma Preelaborate (Pack_22);
+ pragma Preelaborate;
Bits : constant := 22;
-- Handling of packed arrays with Component_Size = 23
package System.Pack_23 is
-pragma Preelaborate (Pack_23);
+ pragma Preelaborate;
Bits : constant := 23;
-- Handling of packed arrays with Component_Size = 24
package System.Pack_24 is
-pragma Preelaborate (Pack_24);
+ pragma Preelaborate;
Bits : constant := 24;
-- Handling of packed arrays with Component_Size = 25
package System.Pack_25 is
-pragma Preelaborate (Pack_25);
+ pragma Preelaborate;
Bits : constant := 25;
-- Handling of packed arrays with Component_Size = 26
package System.Pack_26 is
-pragma Preelaborate (Pack_26);
+ pragma Preelaborate;
Bits : constant := 26;
-- Handling of packed arrays with Component_Size = 27
package System.Pack_27 is
-pragma Preelaborate (Pack_27);
+ pragma Preelaborate;
Bits : constant := 27;
-- Handling of packed arrays with Component_Size = 28
package System.Pack_28 is
-pragma Preelaborate (Pack_28);
+ pragma Preelaborate;
Bits : constant := 28;
-- Handling of packed arrays with Component_Size = 29
package System.Pack_29 is
-pragma Preelaborate (Pack_29);
+ pragma Preelaborate;
Bits : constant := 29;
-- Handling of packed arrays with Component_Size = 30
package System.Pack_30 is
-pragma Preelaborate (Pack_30);
+ pragma Preelaborate;
Bits : constant := 30;
-- Handling of packed arrays with Component_Size = 31
package System.Pack_31 is
-pragma Preelaborate (Pack_31);
+ pragma Preelaborate;
Bits : constant := 31;
-- Handling of packed arrays with Component_Size = 33
package System.Pack_33 is
-pragma Preelaborate (Pack_33);
+ pragma Preelaborate;
Bits : constant := 33;
-- Handling of packed arrays with Component_Size = 34
package System.Pack_34 is
-pragma Preelaborate (Pack_34);
+ pragma Preelaborate;
Bits : constant := 34;
-- Handling of packed arrays with Component_Size = 35
package System.Pack_35 is
-pragma Preelaborate (Pack_35);
+ pragma Preelaborate;
Bits : constant := 35;
-- Handling of packed arrays with Component_Size = 36
package System.Pack_36 is
-pragma Preelaborate (Pack_36);
+ pragma Preelaborate;
Bits : constant := 36;
-- Handling of packed arrays with Component_Size = 37
package System.Pack_37 is
-pragma Preelaborate (Pack_37);
+ pragma Preelaborate;
Bits : constant := 37;
-- Handling of packed arrays with Component_Size = 38
package System.Pack_38 is
-pragma Preelaborate (Pack_38);
+ pragma Preelaborate;
Bits : constant := 38;
-- Handling of packed arrays with Component_Size = 39
package System.Pack_39 is
-pragma Preelaborate (Pack_39);
+ pragma Preelaborate;
Bits : constant := 39;
-- Handling of packed arrays with Component_Size = 40
package System.Pack_40 is
-pragma Preelaborate (Pack_40);
+ pragma Preelaborate;
Bits : constant := 40;
-- Handling of packed arrays with Component_Size = 41
package System.Pack_41 is
-pragma Preelaborate (Pack_41);
+ pragma Preelaborate;
Bits : constant := 41;
-- Handling of packed arrays with Component_Size = 42
package System.Pack_42 is
-pragma Preelaborate (Pack_42);
+ pragma Preelaborate;
Bits : constant := 42;
-- Handling of packed arrays with Component_Size = 43
package System.Pack_43 is
-pragma Preelaborate (Pack_43);
+ pragma Preelaborate;
Bits : constant := 43;
-- Handling of packed arrays with Component_Size = 44
package System.Pack_44 is
-pragma Preelaborate (Pack_44);
+ pragma Preelaborate;
Bits : constant := 44;
-- Handling of packed arrays with Component_Size = 45
package System.Pack_45 is
-pragma Preelaborate (Pack_45);
+ pragma Preelaborate;
Bits : constant := 45;
-- Handling of packed arrays with Component_Size = 46
package System.Pack_46 is
-pragma Preelaborate (Pack_46);
+ pragma Preelaborate;
Bits : constant := 46;
-- Handling of packed arrays with Component_Size = 47
package System.Pack_47 is
-pragma Preelaborate (Pack_47);
+ pragma Preelaborate;
Bits : constant := 47;
-- Handling of packed arrays with Component_Size = 48
package System.Pack_48 is
-pragma Preelaborate (Pack_48);
+ pragma Preelaborate;
Bits : constant := 48;
-- Handling of packed arrays with Component_Size = 49
package System.Pack_49 is
-pragma Preelaborate (Pack_49);
+ pragma Preelaborate;
Bits : constant := 49;
-- Handling of packed arrays with Component_Size = 50
package System.Pack_50 is
-pragma Preelaborate (Pack_50);
+ pragma Preelaborate;
Bits : constant := 50;
-- Handling of packed arrays with Component_Size = 51
package System.Pack_51 is
-pragma Preelaborate (Pack_51);
+ pragma Preelaborate;
Bits : constant := 51;
-- Handling of packed arrays with Component_Size = 52
package System.Pack_52 is
-pragma Preelaborate (Pack_52);
+ pragma Preelaborate;
Bits : constant := 52;
-- Handling of packed arrays with Component_Size = 53
package System.Pack_53 is
-pragma Preelaborate (Pack_53);
+ pragma Preelaborate;
Bits : constant := 53;
-- Handling of packed arrays with Component_Size = 54
package System.Pack_54 is
-pragma Preelaborate (Pack_54);
+ pragma Preelaborate;
Bits : constant := 54;
-- Handling of packed arrays with Component_Size = 55
package System.Pack_55 is
-pragma Preelaborate (Pack_55);
+ pragma Preelaborate;
Bits : constant := 55;
-- Handling of packed arrays with Component_Size = 56
package System.Pack_56 is
-pragma Preelaborate (Pack_56);
+ pragma Preelaborate;
Bits : constant := 56;
-- Handling of packed arrays with Component_Size = 57
package System.Pack_57 is
-pragma Preelaborate (Pack_57);
+ pragma Preelaborate;
Bits : constant := 57;
-- Handling of packed arrays with Component_Size = 58
package System.Pack_58 is
-pragma Preelaborate (Pack_58);
+ pragma Preelaborate;
Bits : constant := 58;
-- Handling of packed arrays with Component_Size = 59
package System.Pack_59 is
-pragma Preelaborate (Pack_59);
+ pragma Preelaborate;
Bits : constant := 59;
-- Handling of packed arrays with Component_Size = 60
package System.Pack_60 is
-pragma Preelaborate (Pack_60);
+ pragma Preelaborate;
Bits : constant := 60;
-- Handling of packed arrays with Component_Size = 61
package System.Pack_61 is
-pragma Preelaborate (Pack_61);
+ pragma Preelaborate;
Bits : constant := 61;
-- Handling of packed arrays with Component_Size = 62
package System.Pack_62 is
-pragma Preelaborate (Pack_62);
+ pragma Preelaborate;
Bits : constant := 62;
-- Handling of packed arrays with Component_Size = 63
package System.Pack_63 is
-pragma Preelaborate (Pack_63);
+ pragma Preelaborate;
Bits : constant := 63;
-- otherwise the relinking and rebinding capability would be deactivated.
package System.Parameters is
-pragma Pure (Parameters);
+ pragma Pure;
---------------------------------------
-- Task And Stack Allocation Control --
-- otherwise the relinking and rebinding capability would be deactivated.
package System.Parameters is
-pragma Pure (Parameters);
+ pragma Pure;
---------------------------------------
-- Task And Stack Allocation Control --
-- otherwise the relinking and rebinding capability would be deactivated.
package System.Parameters is
-pragma Pure (Parameters);
+ pragma Pure;
---------------------------------------
-- Task And Stack Allocation Control --
-- otherwise the relinking and rebinding capability would be deactivated.
package System.Parameters is
-pragma Pure (Parameters);
+ pragma Pure;
---------------------------------------
-- Task And Stack Allocation Control --
-- otherwise the relinking and rebinding capability would be deactivated.
package System.Parameters is
-pragma Pure (Parameters);
+ pragma Pure;
---------------------------------------
-- Task And Stack Allocation Control --
-- otherwise the relinking and rebinding capability would be deactivated.
package System.Parameters is
-pragma Pure (Parameters);
+ pragma Pure;
---------------------------------------
-- Task And Stack Allocation Control --
-- --
-- S p e c --
-- --
--- Copyright (C) 1992-1994, 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- --
with System.Storage_Elements;
package System.Pool_Global is
-
-pragma Elaborate_Body;
--- Needed to ensure that library routines can execute allocators
+ pragma Elaborate_Body;
+ -- Needed to ensure that library routines can execute allocators
-- Allocation strategy:
-- --
-- S p e c --
-- --
--- Copyright (C) 1992-1998, 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- --
with System.Pool_Global;
package System.Pool_Local is
-
-pragma Elaborate_Body;
--- Needed to ensure that library routines can execute allocators
+ pragma Elaborate_Body;
+ -- Needed to ensure that library routines can execute allocators
----------------------------
-- Unbounded_Reclaim_Pool --
-- --
-- S p e c --
-- --
--- 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- --
with System.Storage_Elements;
package System.Pool_Size is
-
-pragma Elaborate_Body;
--- Needed to ensure that library routines can execute allocators
+ pragma Elaborate_Body;
+ -- Needed to ensure that library routines can execute allocators
------------------------
-- Stack_Bounded_Pool --
-- --
-- S p e c --
-- --
--- Copyright (C) 1992-1999 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- --
-- This package provides a powers of ten table used for real conversions
package System.Powten_Table is
-pragma Pure (Powten_Table);
+ pragma Pure;
Maxpow : constant := 22;
-- The number of entries in this table is chosen to include powers of ten
-- --
-- S p e c --
-- --
--- Copyright (C) 2000-2002 Ada Core Technologies, Inc. --
+-- Copyright (C) 2000-2005 Ada Core Technologies, 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- --
-- is for internal use only, it is not generally available to applications.
package System.Pure_Exceptions is
-pragma Pure (Pure_Exceptions);
+ pragma Pure;
type Exception_Type is limited null record;
-- Type used to specify which exception to raise
-- This package contains the function for concatenating three strings
package System.String_Ops_Concat_3 is
-pragma Pure (String_Ops_Concat_3);
+ pragma Pure;
function Str_Concat_3 (S1, S2, S3 : String) return String;
-- Concatenate three strings and return resulting string
-- This package contains the function for concatenating four strings
package System.String_Ops_Concat_4 is
-pragma Pure (String_Ops_Concat_4);
+ pragma Pure;
function Str_Concat_4 (S1, S2, S3, S4 : String) return String;
-- Concatenate four strings and return resulting string
-- This package contains the function for concatenating five strings
package System.String_Ops_Concat_5 is
-pragma Pure (String_Ops_Concat_5);
+ pragma Pure;
function Str_Concat_5 (S1, S2, S3, S4, S5 : String) return String;
-- Concatenate five strings and return resulting string
-- It is a good idea to avoid use clauses for this package!
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). 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
--- treated as non-pure by the back-end (see exp_ch6.adb). This is because
--- in many cases such a parameter is used to hide read/out access to objects,
--- and it would be unsafe to treat such functions as pure.
+ pragma Pure;
+ -- 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).
+
+ -- We also add the pragma Pure_Function to the operations in this package,
+ -- because otherwise functions with parameters derived from Address are
+ -- treated as non-pure by the back-end (see exp_ch6.adb). This is because
+ -- in many cases such a parameter is used to hide read/out access to
+ -- objects, and it would be unsafe to treat such functions as pure.
type Storage_Offset is range
-(2 ** (Integer'(Standard'Address_Size) - 1)) ..
-- --
-- S p e c --
-- --
--- Copyright (C) 1992-2002 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 --
with System.Storage_Elements;
package System.Storage_Pools is
- pragma Preelaborate (System.Storage_Pools);
+ pragma Preelaborate;
type Root_Storage_Pool is abstract
new Ada.Finalization.Limited_Controlled with private;
with Ada.Streams;
package System.Stream_Attributes is
-pragma Preelaborate (Stream_Attributes);
+ pragma Preelaborate;
pragma Suppress (Accessibility_Check, Stream_Attributes);
-- No need to check accessibility on arguments of subprograms
-- (other than runtime comparison, found in s-strcom.ads).
package System.String_Ops is
-pragma Pure (String_Ops);
+ pragma Pure;
function Str_Concat (X, Y : String) return String;
-- Concatenate two strings and return resulting string
-- used by the compiler in connection with packed array types.
package System.Unsigned_Types is
-pragma Pure (Unsigned_Types);
+ pragma Pure;
type Short_Short_Unsigned is mod 2 ** Short_Short_Integer'Size;
type Short_Unsigned is mod 2 ** Short_Integer'Size;
-- --
-- S p e c --
-- --
--- Copyright (C) 1992,1993,1994 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- --
------------------------------------------------------------------------------
package System.Val_Bool is
-pragma Pure (Val_Bool);
+ pragma Pure;
function Value_Boolean (Str : String) return Boolean;
-- Computes Boolean'Value (Str).
-- --
-- S p e c --
-- --
--- Copyright (C) 1992-2000 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- --
------------------------------------------------------------------------------
package System.Val_Char is
-pragma Pure (Val_Char);
+ pragma Pure;
function Value_Character (Str : String) return Character;
-- Computes Character'Value (Str).
-- --
-- S p e c --
-- --
--- Copyright (C) 1992,1993,1994,1995,1996 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- --
-- Decimal_IO, and the Value attribute for such decimal types.
package System.Val_Dec is
-pragma Pure (Val_Dec);
+ pragma Pure;
function Scan_Decimal
(Str : String;
-- --
-- S p e c --
-- --
--- Copyright (C) 1992-2000, 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- --
-- details of the format of constructed image tables.
package System.Val_Enum is
-pragma Pure (Val_Enum);
+ pragma Pure;
function Value_Enumeration_8
(Names : String;
-- in Text_IO.Integer_IO, and the Value attribute.
package System.Val_Int is
-pragma Pure (Val_Int);
+ pragma Pure;
function Scan_Integer
(Str : String;
-- --
-- S p e c --
-- --
--- Copyright (C) 1992,1993,1994,1995,1996 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- --
-- Decimal_IO, and the Value attribute for such decimal types.
package System.Val_LLD is
-pragma Pure (Val_LLD);
+ pragma Pure;
function Scan_Long_Long_Decimal
(Str : String;
-- values for use in Text_IO.Integer_IO, and the Value attribute.
package System.Val_LLI is
-pragma Pure (Val_LLI);
+ pragma Pure;
function Scan_Long_Long_Integer
(Str : String;
with System.Unsigned_Types;
package System.Val_LLU is
-pragma Pure (Val_LLU);
+ pragma Pure;
function Scan_Long_Long_Unsigned
(Str : String;
------------------------------------------------------------------------------
package System.Val_Real is
-pragma Pure (Val_Real);
+ pragma Pure;
function Scan_Real
(Str : String;
-- --
-- S p e c --
-- --
--- Copyright (C) 1992,1993,1994,1995,1996 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- --
with System.Unsigned_Types;
package System.Val_Uns is
-pragma Pure (Val_Uns);
+ pragma Pure;
function Scan_Unsigned
(Str : String;
-- --
-- S p e c --
-- --
--- Copyright (C) 1992,1993,1994,1995,1996 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- --
-- This package provides some common utilities used by the s-valxxx files
package System.Val_Util is
-pragma Pure (Val_Util);
+ pragma Pure;
procedure Normalize_String
(S : in out String;
-- Processing for Wide_[Wide_]Value attribute
package System.Val_WChar is
-pragma Pure (Val_WChar);
+ pragma Pure;
function Value_Wide_Character
(Str : String) return Wide_Character;
-- This package contains functions for runtime operations on boolean vectors
package System.Vectors.Boolean_Operations is
-pragma Pure (Boolean_Operations);
+ pragma Pure;
-- Although in general the boolean operations on arrays of booleans are
-- identical to operations on arrays of unsigned words of the same size,
-- direct processor support for them.
package System.Vectors is
-pragma Pure (Vectors);
+ pragma Pure;
type Vector is mod 2**System.Word_Size;
for Vector'Alignment use Integer'Min
with System.Unsigned_Types;
package System.Version_Control is
-
- pragma Pure (Version_Control);
+ pragma Pure;
subtype Version_String is String (1 .. 8);
-- Eight character string returned by Get_version_String;
with Interfaces.C;
package System.VxWorks is
- pragma Preelaborate (System.VxWorks);
+ pragma Preelaborate;
package IC renames Interfaces.C;
with Interfaces.C;
package System.VxWorks is
- pragma Preelaborate (System.VxWorks);
+ pragma Preelaborate;
package IC renames Interfaces.C;
with Interfaces.C;
package System.VxWorks is
- pragma Preelaborate (System.VxWorks);
+ pragma Preelaborate;
package IC renames Interfaces.C;
with Interfaces.C;
package System.VxWorks is
- pragma Preelaborate (System.VxWorks);
+ pragma Preelaborate;
package IC renames Interfaces.C;
with Interfaces;
package System.VxWorks is
- pragma Preelaborate (System.VxWorks);
+ pragma Preelaborate;
-- Floating point context record. SPARCV9 version
-- This is the x86 VxWorks version of this package
package System.VxWorks is
- pragma Preelaborate (System.VxWorks);
+ pragma Preelaborate;
-- Floating point context record. x86 version
with System.WCh_Con;
package System.WCh_Cnv is
- pragma Pure (WCh_Cnv);
+ pragma Pure;
type UTF_32_Code is range 0 .. 16#7FFF_FFFF#;
for UTF_32_Code'Size use 32;
-- an appropriate WITH, and the interface can be expected to remain stable.
package System.WCh_Con is
-pragma Pure (WCh_Con);
+ pragma Pure;
-------------------------------------
-- Wide_Character Encoding Methods --
-- JIS codes and the two external forms we support (EUC and Shift-JIS)
package System.WCh_JIS is
-pragma Pure (WCh_JIS);
+ pragma Pure;
function EUC_To_JIS (EUC1, EUC2 : Character) return Wide_Character;
-- Given the two bytes of a EUC representation, return the
with System.WCh_Con;
package System.WCh_StW is
-pragma Pure (WCh_StW);
+ pragma Pure;
function String_To_Wide_String
(S : String;
with System.WCh_Con;
package System.WCh_WtS is
-pragma Pure (WCh_WtS);
+ pragma Pure;
function Wide_String_To_String
(S : Wide_String;
-- This package contains the routine used for Boolean'Width
package System.Wid_Bool is
-pragma Pure (Wid_Bool);
+ pragma Pure;
function Width_Boolean (Lo, Hi : Boolean) return Natural;
-- Compute Width attribute for non-static type derived from Boolean.
-- This package contains the routine used for Character'Width
package System.Wid_Char is
-pragma Pure (Wid_Char);
+ pragma Pure;
function Width_Character (Lo, Hi : Character) return Natural;
-- Compute Width attribute for non-static type derived from Character.
-- This package contains the routine used for Enumeration_Type'Width
package System.Wid_Enum is
-pragma Pure (Wid_Enum);
+ pragma Pure;
function Width_Enumeration_8
(Names : String;
-- --
------------------------------------------------------------------------------
--- This package contains the routine used for WIdth attribute for all
+-- This package contains the routine used for Width attribute for all
-- non-static signed integer subtypes. Note we only have one routine,
-- since this seems a fairly marginal function.
package System.Wid_LLI is
-pragma Pure (Wid_LLI);
+ pragma Pure;
function Width_Long_Long_Integer
(Lo, Hi : Long_Long_Integer)
-- --
------------------------------------------------------------------------------
--- This package contains the routine used for WIdth attribute for all
+-- This package contains the routine used for Width attribute for all
-- non-static unsigned integer (modular integer) subtypes. Note we only
-- have one routine, since this seems a fairly marginal function.
with System.Unsigned_Types;
package System.Wid_LLU is
-pragma Pure (Wid_LLU);
+ pragma Pure;
function Width_Long_Long_Unsigned
(Lo, Hi : System.Unsigned_Types.Long_Long_Unsigned)
-- This package contains the routines used for Wide_[Wide_]Character'Width
package System.Wid_WChar is
-pragma Pure (Wid_WChar);
+ pragma Pure;
function Width_Wide_Character
(Lo, Hi : Wide_Character) return Natural;
-- This package contains the routine used for Character'Wide_[Wide_]Width
package System.WWd_Char is
-pragma Pure (WWd_Char);
+ pragma Pure;
function Wide_Width_Character (Lo, Hi : Character) return Natural;
-- Compute Wide_Width attribute for non-static type derived from
with System.WCh_Con;
package System.WWd_Enum is
-pragma Pure (WWd_Enum);
+ pragma Pure;
function Wide_Width_Enumeration_8
(Names : String;
-- This package contains routines for [Wide_]Wide_Character'[Wide_]Wide_Width
package System.Wwd_WChar is
-pragma Pure (Wwd_WChar);
+ pragma Pure;
function Wide_Width_Wide_Character
(Lo, Hi : Wide_Character) return Natural;
------------------------------------------------------------------------------
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.1(15). In Ada 2005, this is
--- Pure in any case (AI-362).
+ pragma Pure;
+ -- 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.1(15). In Ada 2005, this is
--- Pure in any case (AI-362).
+ pragma Pure;
+ -- 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.1(15). In Ada 2005, this is
--- Pure in any case (AI-362).
+ pragma Pure;
+ -- 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.1(15). In Ada 2005, this is
--- Pure in any case (AI-362).
+ pragma Pure;
+ -- 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.1(15). In Ada 2005, this is
--- Pure in any case (AI-362).
+ pragma Pure;
+ -- 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.1(15). In Ada 2005, this is
--- Pure in any case (AI-362).
+ pragma Pure;
+ -- 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.1(15). In Ada 2005, this is
--- Pure in any case (AI-362).
+ pragma Pure;
+ -- 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.1(15). In Ada 2005, this is
--- Pure in any case (AI-362).
+ pragma Pure;
+ -- 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.1(15). In Ada 2005, this is
--- Pure in any case (AI-362).
+ pragma Pure;
+ -- 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.1(15). In Ada 2005, this is
--- Pure in any case (AI-362).
+ pragma Pure;
+ -- 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.1(15). In Ada 2005, this is
--- Pure in any case (AI-362).
+ pragma Pure;
+ -- 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.1(15). In Ada 2005, this is
--- Pure in any case (AI-362).
+ pragma Pure;
+ -- 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.1(15). In Ada 2005, this is
--- Pure in any case (AI-362).
+ pragma Pure;
+ -- 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.1(15). In Ada 2005, this is
--- Pure in any case (AI-362).
+ pragma Pure;
+ -- 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.1(15). In Ada 2005, this is
--- Pure in any case (AI-362).
+ pragma Pure;
+ -- 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.1(15). In Ada 2005, this is
--- Pure in any case (AI-362).
+ pragma Pure;
+ -- 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.1(15). In Ada 2005, this is
--- Pure in any case (AI-362).
+ pragma Pure;
+ -- 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.1(15). In Ada 2005, this is
--- Pure in any case (AI-362).
+ pragma Pure;
+ -- 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.1(15). In Ada 2005, this is
--- Pure in any case (AI-362).
+ pragma Pure;
+ -- 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.1(15). In Ada 2005, this is
--- Pure in any case (AI-362).
+ pragma Pure;
+ -- 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.1(15). In Ada 2005, this is
--- Pure in any case (AI-362).
+ pragma Pure;
+ -- 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.1(15). In Ada 2005, this is
--- Pure in any case (AI-362).
+ pragma Pure;
+ -- 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.1(15). In Ada 2005, this is
--- Pure in any case (AI-362).
+ pragma Pure;
+ -- 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.1(15). In Ada 2005, this is
--- Pure in any case (AI-362).
+ pragma Pure;
+ -- 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.1(15). In Ada 2005, this is
--- Pure in any case (AI-362).
+ pragma Pure;
+ -- 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.1(15). In Ada 2005, this is
--- Pure in any case (AI-362).
+ pragma Pure;
+ -- 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.1(15). In Ada 2005, this is
--- Pure in any case (AI-362).
+ pragma Pure;
+ -- 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.1(15). In Ada 2005, this is
--- Pure in any case (AI-362).
+ pragma Pure;
+ -- 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.1(15). In Ada 2005, this is
--- Pure in any case (AI-362).
+ pragma Pure;
+ -- 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.1(15). In Ada 2005, this is
--- Pure in any case (AI-362).
+ pragma Pure;
+ -- 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.1(15). In Ada 2005, this is
--- Pure in any case (AI-362).
+ pragma Pure;
+ -- 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;
-- S p e c --
-- (Compiler Version) --
-- --
--- 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 --
-- about most System parameters, this generic version works fine.
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.1(15). In Ada 2005, this is
--- Pure in any case (AI-362).
+ pragma Pure;
+ -- 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;
-- --
-- S p e c --
-- --
--- 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- --
with Types; use Types;
package Table is
-pragma Elaborate_Body (Table);
+ pragma Elaborate_Body;
generic
type Table_Component_Type is private;
-- --
------------------------------------------------------------------------------
-with Unchecked_Deallocation;
-
-package Types is
-pragma Preelaborate (Types);
-
-- This package contains host independent type definitions which are used
-- in more than one unit in the compiler. They are gathered here for easy
-- reference, though in some cases the full description is found in the
-- dependencies would have to be dealt with.
-- WARNING: There is a C version of this package. Any changes to this
--- source file must be properly reflected in the C header file a-types.h
+-- source file must be properly reflected in the C header file types.h
-- Note: the declarations in this package reflect an expectation that the
-- host machine has an efficient integer base type with a range at least
-- 32 bits 2s-complement. If there are any machines for which this is not
-- a correct assumption, a significant number of changes will be required!
+with Unchecked_Deallocation;
+
+package Types is
+ pragma Preelaborate;
+
-------------------------------
-- General Use Integer Types --
-------------------------------
projects / gcc.git / commitdiff