a-catizo.adb, [...]: Minor reformatting.
2012-10-01 Arnaud Charlet <charlet@adacore.com> * a-catizo.adb, a-stwiun.adb, a-cdlili.adb, a-cihama.adb, a-direct.adb, a-coinve.adb, a-calend.adb, a-ciorse.adb, a-coorma.adb, a-cfdlli.adb, a-stzunb-shared.adb, a-cfhase.adb, bindgen.adb, ceinfo.adb, a-tags.adb, einfo.adb, checks.adb, eval_fat.adb, a-cborma.adb, a-stwifi.adb, a-tifiio.adb, a-textio.adb, a-cidlli.adb, a-strunb-shared.adb, a-cimutr.adb, a-calcon.adb, a-exexpr-gcc.adb, a-ciormu.adb, a-stzunb.adb, a-stzsea.adb, a-ngelfu.adb, a-stzfix.adb, a-cihase.adb, a-cohama.adb, a-exetim-posix.adb, a-dirval-vms.adb, a-caldel-vms.adb, a-coorse.adb, errout.adb, a-except.adb, butil.adb, a-dirval-mingw.adb, a-cforma.adb, a-except-2005.adb, a-wtedit.adb, cstand.adb, a-stwiun-shared.adb, a-cbhama.adb, a-direio.adb, clean.adb, a-cborse.adb, back_end.adb, binde.adb, a-exexda.adb, a-comutr.adb, a-ciorma.adb, a-cobove.adb, a-coormu.adb, a-teioed.adb, a-convec.adb, a-wtenau.adb, exp_aggr.adb, a-ztedit.adb, a-cohase.adb, a-exetim-mingw.adb, bcheck.adb, a-dynpri.adb, a-cfhama.adb, a-calfor.adb, a-cbdlli.adb, a-crdlli.adb, a-cbmutr.adb, a-sequio.adb, a-ngcoar.adb, a-cforse.adb, a-strunb.adb, a-calend-vms.adb, a-clrefi.adb, a-cofove.adb, a-ztenau.adb, a-strfix.adb, a-cbhase.adb, a-stzsup.adb: Minor reformatting. From-SVN: r191905
This commit is contained in:
Arnaud Charlet
Arnaud Charlet
parent
cf427f02bb
commit
15f0f591b8
|
|
@ -1,3 +1,26 @@
|
|||
2012-10-01 Arnaud Charlet <charlet@adacore.com>
|
||||
|
||||
* a-catizo.adb, a-stwiun.adb, a-cdlili.adb, a-cihama.adb, a-direct.adb,
|
||||
a-coinve.adb, a-calend.adb, a-ciorse.adb, a-coorma.adb, a-cfdlli.adb,
|
||||
a-stzunb-shared.adb, a-cfhase.adb, bindgen.adb, ceinfo.adb, a-tags.adb,
|
||||
einfo.adb, checks.adb, eval_fat.adb, a-cborma.adb, a-stwifi.adb,
|
||||
a-tifiio.adb, a-textio.adb, a-cidlli.adb, a-strunb-shared.adb,
|
||||
a-cimutr.adb, a-calcon.adb, a-exexpr-gcc.adb, a-ciormu.adb,
|
||||
a-stzunb.adb, a-stzsea.adb, a-ngelfu.adb, a-stzfix.adb,
|
||||
a-cihase.adb, a-cohama.adb, a-exetim-posix.adb, a-dirval-vms.adb,
|
||||
a-caldel-vms.adb, a-coorse.adb, errout.adb,
|
||||
a-except.adb, butil.adb, a-dirval-mingw.adb, a-cforma.adb,
|
||||
a-except-2005.adb, a-wtedit.adb, cstand.adb, a-stwiun-shared.adb,
|
||||
a-cbhama.adb, a-direio.adb, clean.adb, a-cborse.adb, back_end.adb,
|
||||
binde.adb, a-exexda.adb, a-comutr.adb, a-ciorma.adb, a-cobove.adb,
|
||||
a-coormu.adb, a-teioed.adb, a-convec.adb, a-wtenau.adb, exp_aggr.adb,
|
||||
a-ztedit.adb, a-cohase.adb, a-exetim-mingw.adb, bcheck.adb,
|
||||
a-dynpri.adb, a-cfhama.adb, a-calfor.adb, a-cbdlli.adb,
|
||||
a-crdlli.adb, a-cbmutr.adb, a-sequio.adb, a-ngcoar.adb, a-cforse.adb,
|
||||
a-strunb.adb, a-calend-vms.adb, a-clrefi.adb, a-cofove.adb,
|
||||
a-ztenau.adb, a-strfix.adb, a-cbhase.adb, a-stzsup.adb: Minor
|
||||
reformatting.
|
||||
|
||||
2012-10-01 Vincent Pucci <pucci@adacore.com>
|
||||
|
||||
* s-gearop.adb (Vector_Matrix_Product): Dimensions check fixed. Index
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
-- --
|
||||
-- B o d y --
|
||||
-- --
|
||||
-- Copyright (C) 2008-2009 Free Software Foundation, Inc. --
|
||||
-- Copyright (C) 2008-2012, 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- --
|
||||
|
|
@ -140,7 +140,7 @@ package body Ada.Calendar.Conversions is
|
|||
|
||||
function To_Unix_Time (Ada_Time : Time) return long is
|
||||
Val : constant Long_Integer :=
|
||||
Conversion_Operations.To_Unix_Time (Ada_Time);
|
||||
Conversion_Operations.To_Unix_Time (Ada_Time);
|
||||
begin
|
||||
return long (Val);
|
||||
end To_Unix_Time;
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
-- B o d y --
|
||||
-- --
|
||||
-- Copyright (C) 1991-1994, Florida State University --
|
||||
-- Copyright (C) 1995-2010, AdaCore --
|
||||
-- Copyright (C) 1995-2012, 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- --
|
||||
|
|
@ -78,7 +78,7 @@ package body Ada.Calendar.Delays is
|
|||
-- cause overflow.
|
||||
|
||||
Safe_T : constant Time :=
|
||||
(if T > Safe_Ada_High then Safe_Ada_High else T);
|
||||
(if T > Safe_Ada_High then Safe_Ada_High else T);
|
||||
|
||||
begin
|
||||
return OSP.To_Duration (OSP.OS_Time (Safe_T), OSP.Absolute_Calendar);
|
||||
|
|
|
|||
|
|
@ -141,7 +141,7 @@ package body Ada.Calendar is
|
|||
-- UTC, it must be increased to include all leap seconds.
|
||||
|
||||
Ada_High_And_Leaps : constant OS_Time :=
|
||||
Ada_High + OS_Time (Leap_Seconds_Count) * Mili;
|
||||
Ada_High + OS_Time (Leap_Seconds_Count) * Mili;
|
||||
|
||||
-- Two constants used in the calculations of elapsed leap seconds.
|
||||
-- End_Of_Time is later than Ada_High in time zone -28. Start_Of_Time
|
||||
|
|
@ -221,9 +221,9 @@ package body Ada.Calendar is
|
|||
-- The bound of type Duration expressed as time
|
||||
|
||||
Dur_High : constant OS_Time :=
|
||||
OS_Time (To_Relative_Time (Duration'Last));
|
||||
OS_Time (To_Relative_Time (Duration'Last));
|
||||
Dur_Low : constant OS_Time :=
|
||||
OS_Time (To_Relative_Time (Duration'First));
|
||||
OS_Time (To_Relative_Time (Duration'First));
|
||||
|
||||
Res_M : OS_Time;
|
||||
|
||||
|
|
|
|||
|
|
@ -177,29 +177,29 @@ package body Ada.Calendar is
|
|||
-- UTC, it must be increased to include all leap seconds.
|
||||
|
||||
Ada_High_And_Leaps : constant Time_Rep :=
|
||||
Ada_High + Time_Rep (Leap_Seconds_Count) * Nano;
|
||||
Ada_High + Time_Rep (Leap_Seconds_Count) * Nano;
|
||||
|
||||
-- Two constants used in the calculations of elapsed leap seconds.
|
||||
-- End_Of_Time is later than Ada_High in time zone -28. Start_Of_Time
|
||||
-- is earlier than Ada_Low in time zone +28.
|
||||
|
||||
End_Of_Time : constant Time_Rep :=
|
||||
Ada_High + Time_Rep (3) * Nanos_In_Day;
|
||||
Ada_High + Time_Rep (3) * Nanos_In_Day;
|
||||
Start_Of_Time : constant Time_Rep :=
|
||||
Ada_Low - Time_Rep (3) * Nanos_In_Day;
|
||||
Ada_Low - Time_Rep (3) * Nanos_In_Day;
|
||||
|
||||
-- The Unix lower time bound expressed as nanoseconds since the start of
|
||||
-- Ada time in UTC.
|
||||
|
||||
Unix_Min : constant Time_Rep :=
|
||||
Ada_Low + Time_Rep (17 * 366 + 52 * 365) * Nanos_In_Day;
|
||||
Ada_Low + Time_Rep (17 * 366 + 52 * 365) * Nanos_In_Day;
|
||||
|
||||
-- The Unix upper time bound expressed as nanoseconds since the start of
|
||||
-- Ada time in UTC.
|
||||
|
||||
Unix_Max : constant Time_Rep :=
|
||||
Ada_Low + Time_Rep (34 * 366 + 102 * 365) * Nanos_In_Day +
|
||||
Time_Rep (Leap_Seconds_Count) * Nano;
|
||||
Ada_Low + Time_Rep (34 * 366 + 102 * 365) * Nanos_In_Day +
|
||||
Time_Rep (Leap_Seconds_Count) * Nano;
|
||||
|
||||
Epoch_Offset : constant Time_Rep := (136 * 365 + 44 * 366) * Nanos_In_Day;
|
||||
-- The difference between 2150-1-1 UTC and 1970-1-1 UTC expressed in
|
||||
|
|
@ -367,7 +367,7 @@ package body Ada.Calendar is
|
|||
-- by adding the number of nanoseconds between the two origins.
|
||||
|
||||
Res_N : Time_Rep :=
|
||||
Duration_To_Time_Rep (System.OS_Primitives.Clock) + Unix_Min;
|
||||
Duration_To_Time_Rep (System.OS_Primitives.Clock) + Unix_Min;
|
||||
|
||||
begin
|
||||
-- If the target supports leap seconds, determine the number of leap
|
||||
|
|
@ -1283,7 +1283,7 @@ package body Ada.Calendar is
|
|||
else
|
||||
declare
|
||||
Off : constant Long_Integer :=
|
||||
UTC_Time_Offset (Time (Date_N), Is_Historic);
|
||||
UTC_Time_Offset (Time (Date_N), Is_Historic);
|
||||
|
||||
begin
|
||||
Date_N := Date_N + Time_Rep (Off) * Nano;
|
||||
|
|
@ -1506,11 +1506,11 @@ package body Ada.Calendar is
|
|||
else
|
||||
declare
|
||||
Cur_Off : constant Long_Integer :=
|
||||
UTC_Time_Offset (Time (Res_N), Is_Historic);
|
||||
UTC_Time_Offset (Time (Res_N), Is_Historic);
|
||||
Cur_Res_N : constant Time_Rep :=
|
||||
Res_N - Time_Rep (Cur_Off) * Nano;
|
||||
Res_N - Time_Rep (Cur_Off) * Nano;
|
||||
Off : constant Long_Integer :=
|
||||
UTC_Time_Offset (Time (Cur_Res_N), Is_Historic);
|
||||
UTC_Time_Offset (Time (Cur_Res_N), Is_Historic);
|
||||
|
||||
begin
|
||||
Res_N := Res_N - Time_Rep (Off) * Nano;
|
||||
|
|
|
|||
|
|
@ -213,7 +213,7 @@ package body Ada.Calendar.Formatting is
|
|||
|
||||
Result : String := "0000-00-00 00:00:00.00";
|
||||
Last : constant Positive :=
|
||||
Result'Last - (if Include_Time_Fraction then 0 else 3);
|
||||
Result'Last - (if Include_Time_Fraction then 0 else 3);
|
||||
|
||||
begin
|
||||
Split (Date, Year, Month, Day,
|
||||
|
|
|
|||
|
|
@ -44,7 +44,7 @@ package body Ada.Calendar.Time_Zones is
|
|||
|
||||
function UTC_Time_Offset (Date : Time := Clock) return Time_Offset is
|
||||
Offset_L : constant Long_Integer :=
|
||||
Time_Zones_Operations.UTC_Time_Offset (Date);
|
||||
Time_Zones_Operations.UTC_Time_Offset (Date);
|
||||
Offset : Time_Offset;
|
||||
|
||||
begin
|
||||
|
|
|
|||
|
|
@ -902,7 +902,7 @@ package body Ada.Containers.Bounded_Doubly_Linked_Lists is
|
|||
|
||||
procedure Sort (Front, Back : Count_Type) is
|
||||
Pivot : constant Count_Type :=
|
||||
(if Front = 0 then Container.First else N (Front).Next);
|
||||
(if Front = 0 then Container.First else N (Front).Next);
|
||||
begin
|
||||
if Pivot /= Back then
|
||||
Partition (Pivot, Back);
|
||||
|
|
@ -1160,9 +1160,9 @@ package body Ada.Containers.Bounded_Doubly_Linked_Lists is
|
|||
-- for a reverse iterator, Container.Last is the beginning.
|
||||
|
||||
return It : constant Iterator :=
|
||||
Iterator'(Limited_Controlled with
|
||||
Container => Container'Unrestricted_Access,
|
||||
Node => 0)
|
||||
Iterator'(Limited_Controlled with
|
||||
Container => Container'Unrestricted_Access,
|
||||
Node => 0)
|
||||
do
|
||||
B := B + 1;
|
||||
end return;
|
||||
|
|
@ -1209,9 +1209,9 @@ package body Ada.Containers.Bounded_Doubly_Linked_Lists is
|
|||
-- is a forward or reverse iteration.
|
||||
|
||||
return It : constant Iterator :=
|
||||
Iterator'(Limited_Controlled with
|
||||
Container => Container'Unrestricted_Access,
|
||||
Node => Start.Node)
|
||||
Iterator'(Limited_Controlled with
|
||||
Container => Container'Unrestricted_Access,
|
||||
Node => Start.Node)
|
||||
do
|
||||
B := B + 1;
|
||||
end return;
|
||||
|
|
|
|||
|
|
@ -739,8 +739,8 @@ package body Ada.Containers.Bounded_Hashed_Maps is
|
|||
|
||||
begin
|
||||
return It : constant Iterator :=
|
||||
(Limited_Controlled with
|
||||
Container => Container'Unrestricted_Access)
|
||||
(Limited_Controlled with
|
||||
Container => Container'Unrestricted_Access)
|
||||
do
|
||||
B := B + 1;
|
||||
end return;
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
-- --
|
||||
-- B o d y --
|
||||
-- --
|
||||
-- Copyright (C) 2004-2011, Free Software Foundation, Inc. --
|
||||
-- Copyright (C) 2004-2012, 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- --
|
||||
|
|
@ -129,7 +129,7 @@ package body Ada.Containers.Bounded_Hashed_Sets is
|
|||
L_Node : Node_Type) return Boolean
|
||||
is
|
||||
R_Index : constant Hash_Type :=
|
||||
Element_Keys.Index (R_HT, L_Node.Element);
|
||||
Element_Keys.Index (R_HT, L_Node.Element);
|
||||
|
||||
R_Node : Count_Type := R_HT.Buckets (R_Index);
|
||||
|
||||
|
|
@ -480,7 +480,7 @@ package body Ada.Containers.Bounded_Hashed_Sets is
|
|||
L_Node : Node_Type) return Boolean
|
||||
is
|
||||
R_Index : constant Hash_Type :=
|
||||
Element_Keys.Index (R_HT, L_Node.Element);
|
||||
Element_Keys.Index (R_HT, L_Node.Element);
|
||||
|
||||
R_Node : Count_Type := R_HT.Buckets (R_Index);
|
||||
|
||||
|
|
@ -959,8 +959,8 @@ package body Ada.Containers.Bounded_Hashed_Sets is
|
|||
begin
|
||||
B := B + 1;
|
||||
return It : constant Iterator :=
|
||||
Iterator'(Limited_Controlled with
|
||||
Container => Container'Unrestricted_Access);
|
||||
Iterator'(Limited_Controlled with
|
||||
Container => Container'Unrestricted_Access);
|
||||
end Iterate;
|
||||
|
||||
------------
|
||||
|
|
@ -1180,8 +1180,7 @@ package body Ada.Containers.Bounded_Hashed_Sets is
|
|||
(Container : in out Set;
|
||||
New_Item : Element_Type)
|
||||
is
|
||||
Node : constant Count_Type :=
|
||||
Element_Keys.Find (Container, New_Item);
|
||||
Node : constant Count_Type := Element_Keys.Find (Container, New_Item);
|
||||
|
||||
begin
|
||||
if Node = 0 then
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
-- --
|
||||
-- B o d y --
|
||||
-- --
|
||||
-- Copyright (C) 2011, Free Software Foundation, Inc. --
|
||||
-- Copyright (C) 2011-2012, 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- --
|
||||
|
|
@ -1903,9 +1903,9 @@ package body Ada.Containers.Bounded_Multiway_Trees is
|
|||
end if;
|
||||
|
||||
return It : constant Child_Iterator :=
|
||||
Child_Iterator'(Limited_Controlled with
|
||||
Container => C,
|
||||
Subtree => Parent.Node)
|
||||
Child_Iterator'(Limited_Controlled with
|
||||
Container => C,
|
||||
Subtree => Parent.Node)
|
||||
do
|
||||
B := B + 1;
|
||||
end return;
|
||||
|
|
@ -1931,9 +1931,9 @@ package body Ada.Containers.Bounded_Multiway_Trees is
|
|||
B : Natural renames Position.Container.Busy;
|
||||
begin
|
||||
return It : constant Subtree_Iterator :=
|
||||
(Limited_Controlled with
|
||||
Container => Position.Container,
|
||||
Subtree => Position.Node)
|
||||
(Limited_Controlled with
|
||||
Container => Position.Container,
|
||||
Subtree => Position.Node)
|
||||
do
|
||||
B := B + 1;
|
||||
end return;
|
||||
|
|
|
|||
|
|
@ -980,9 +980,9 @@ package body Ada.Containers.Bounded_Ordered_Maps is
|
|||
-- for a reverse iterator, Container.Last is the beginning.
|
||||
|
||||
return It : constant Iterator :=
|
||||
(Limited_Controlled with
|
||||
Container => Container'Unrestricted_Access,
|
||||
Node => 0)
|
||||
(Limited_Controlled with
|
||||
Container => Container'Unrestricted_Access,
|
||||
Node => 0)
|
||||
do
|
||||
B := B + 1;
|
||||
end return;
|
||||
|
|
@ -1029,9 +1029,9 @@ package body Ada.Containers.Bounded_Ordered_Maps is
|
|||
-- is a forward or reverse iteration.)
|
||||
|
||||
return It : constant Iterator :=
|
||||
(Limited_Controlled with
|
||||
Container => Container'Unrestricted_Access,
|
||||
Node => Start.Node)
|
||||
(Limited_Controlled with
|
||||
Container => Container'Unrestricted_Access,
|
||||
Node => Start.Node)
|
||||
do
|
||||
B := B + 1;
|
||||
end return;
|
||||
|
|
@ -1174,7 +1174,7 @@ package body Ada.Containers.Bounded_Ordered_Maps is
|
|||
M : Map renames Position.Container.all;
|
||||
|
||||
Node : constant Count_Type :=
|
||||
Tree_Operations.Next (M, Position.Node);
|
||||
Tree_Operations.Next (M, Position.Node);
|
||||
|
||||
begin
|
||||
if Node = 0 then
|
||||
|
|
@ -1233,7 +1233,7 @@ package body Ada.Containers.Bounded_Ordered_Maps is
|
|||
M : Map renames Position.Container.all;
|
||||
|
||||
Node : constant Count_Type :=
|
||||
Tree_Operations.Previous (M, Position.Node);
|
||||
Tree_Operations.Previous (M, Position.Node);
|
||||
|
||||
begin
|
||||
if Node = 0 then
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
-- --
|
||||
-- B o d y --
|
||||
-- --
|
||||
-- Copyright (C) 2004-2011, Free Software Foundation, Inc. --
|
||||
-- Copyright (C) 2004-2012, 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- --
|
||||
|
|
@ -378,7 +378,7 @@ package body Ada.Containers.Bounded_Ordered_Sets is
|
|||
|
||||
function Ceiling (Container : Set; Item : Element_Type) return Cursor is
|
||||
Node : constant Count_Type :=
|
||||
Element_Keys.Ceiling (Container, Item);
|
||||
Element_Keys.Ceiling (Container, Item);
|
||||
begin
|
||||
return (if Node = 0 then No_Element
|
||||
else Cursor'(Container'Unrestricted_Access, Node));
|
||||
|
|
@ -720,7 +720,7 @@ package body Ada.Containers.Bounded_Ordered_Sets is
|
|||
|
||||
function Ceiling (Container : Set; Key : Key_Type) return Cursor is
|
||||
Node : constant Count_Type :=
|
||||
Key_Keys.Ceiling (Container, Key);
|
||||
Key_Keys.Ceiling (Container, Key);
|
||||
begin
|
||||
return (if Node = 0 then No_Element
|
||||
else Cursor'(Container'Unrestricted_Access, Node));
|
||||
|
|
@ -1334,9 +1334,9 @@ package body Ada.Containers.Bounded_Ordered_Sets is
|
|||
-- for a reverse iterator, Container.Last is the beginning.
|
||||
|
||||
return It : constant Iterator :=
|
||||
Iterator'(Limited_Controlled with
|
||||
Container => Container'Unrestricted_Access,
|
||||
Node => 0)
|
||||
Iterator'(Limited_Controlled with
|
||||
Container => Container'Unrestricted_Access,
|
||||
Node => 0)
|
||||
do
|
||||
B := B + 1;
|
||||
end return;
|
||||
|
|
@ -1382,9 +1382,9 @@ package body Ada.Containers.Bounded_Ordered_Sets is
|
|||
-- is a forward or reverse iteration.)
|
||||
|
||||
return It : constant Iterator :=
|
||||
Iterator'(Limited_Controlled with
|
||||
Container => Container'Unrestricted_Access,
|
||||
Node => Start.Node)
|
||||
Iterator'(Limited_Controlled with
|
||||
Container => Container'Unrestricted_Access,
|
||||
Node => Start.Node)
|
||||
do
|
||||
B := B + 1;
|
||||
end return;
|
||||
|
|
@ -1487,7 +1487,7 @@ package body Ada.Containers.Bounded_Ordered_Sets is
|
|||
|
||||
declare
|
||||
Node : constant Count_Type :=
|
||||
Tree_Operations.Next (Position.Container.all, Position.Node);
|
||||
Tree_Operations.Next (Position.Container.all, Position.Node);
|
||||
|
||||
begin
|
||||
if Node = 0 then
|
||||
|
|
@ -1548,9 +1548,7 @@ package body Ada.Containers.Bounded_Ordered_Sets is
|
|||
|
||||
declare
|
||||
Node : constant Count_Type :=
|
||||
Tree_Operations.Previous
|
||||
(Position.Container.all,
|
||||
Position.Node);
|
||||
Tree_Operations.Previous (Position.Container.all, Position.Node);
|
||||
begin
|
||||
return (if Node = 0 then No_Element
|
||||
else Cursor'(Position.Container, Node));
|
||||
|
|
|
|||
|
|
@ -264,9 +264,8 @@ package body Ada.Containers.Doubly_Linked_Lists is
|
|||
L : Natural renames C.Lock;
|
||||
begin
|
||||
return R : constant Constant_Reference_Type :=
|
||||
(Element => Position.Node.Element'Access,
|
||||
Control =>
|
||||
(Controlled with Container'Unrestricted_Access))
|
||||
(Element => Position.Node.Element'Access,
|
||||
Control => (Controlled with Container'Unrestricted_Access))
|
||||
do
|
||||
B := B + 1;
|
||||
L := L + 1;
|
||||
|
|
@ -750,7 +749,7 @@ package body Ada.Containers.Doubly_Linked_Lists is
|
|||
|
||||
procedure Sort (Front, Back : Node_Access) is
|
||||
Pivot : constant Node_Access :=
|
||||
(if Front = null then Container.First else Front.Next);
|
||||
(if Front = null then Container.First else Front.Next);
|
||||
begin
|
||||
if Pivot /= Back then
|
||||
Partition (Pivot, Back);
|
||||
|
|
@ -997,9 +996,9 @@ package body Ada.Containers.Doubly_Linked_Lists is
|
|||
-- for a reverse iterator, Container.Last is the beginning.
|
||||
|
||||
return It : constant Iterator :=
|
||||
Iterator'(Limited_Controlled with
|
||||
Container => Container'Unrestricted_Access,
|
||||
Node => null)
|
||||
Iterator'(Limited_Controlled with
|
||||
Container => Container'Unrestricted_Access,
|
||||
Node => null)
|
||||
do
|
||||
B := B + 1;
|
||||
end return;
|
||||
|
|
@ -1044,9 +1043,9 @@ package body Ada.Containers.Doubly_Linked_Lists is
|
|||
-- is a forward or reverse iteration.
|
||||
|
||||
return It : constant Iterator :=
|
||||
Iterator'(Limited_Controlled with
|
||||
Container => Container'Unrestricted_Access,
|
||||
Node => Start.Node)
|
||||
Iterator'(Limited_Controlled with
|
||||
Container => Container'Unrestricted_Access,
|
||||
Node => Start.Node)
|
||||
do
|
||||
B := B + 1;
|
||||
end return;
|
||||
|
|
@ -1385,8 +1384,8 @@ package body Ada.Containers.Doubly_Linked_Lists is
|
|||
L : Natural renames C.Lock;
|
||||
begin
|
||||
return R : constant Reference_Type :=
|
||||
(Element => Position.Node.Element'Access,
|
||||
Control => (Controlled with Position.Container))
|
||||
(Element => Position.Node.Element'Access,
|
||||
Control => (Controlled with Position.Container))
|
||||
do
|
||||
B := B + 1;
|
||||
L := L + 1;
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
-- --
|
||||
-- B o d y --
|
||||
-- --
|
||||
-- Copyright (C) 2010-2011, Free Software Foundation, Inc. --
|
||||
-- Copyright (C) 2010-2012, 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- --
|
||||
|
|
@ -989,9 +989,9 @@ package body Ada.Containers.Formal_Doubly_Linked_Lists is
|
|||
-- for a reverse iterator, Container.Last is the beginning.
|
||||
|
||||
return It : constant Iterator :=
|
||||
Iterator'(Ada.Finalization.Limited_Controlled with
|
||||
Container => Container'Unrestricted_Access,
|
||||
Node => 0)
|
||||
Iterator'(Ada.Finalization.Limited_Controlled with
|
||||
Container => Container'Unrestricted_Access,
|
||||
Node => 0)
|
||||
do
|
||||
B := B + 1;
|
||||
end return;
|
||||
|
|
@ -1029,9 +1029,9 @@ package body Ada.Containers.Formal_Doubly_Linked_Lists is
|
|||
-- is a forward or reverse iteration.
|
||||
|
||||
return It : constant Iterator :=
|
||||
Iterator'(Ada.Finalization.Limited_Controlled with
|
||||
Container => Container'Unrestricted_Access,
|
||||
Node => Start.Node)
|
||||
Iterator'(Ada.Finalization.Limited_Controlled with
|
||||
Container => Container'Unrestricted_Access,
|
||||
Node => Start.Node)
|
||||
do
|
||||
B := B + 1;
|
||||
end return;
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
-- --
|
||||
-- B o d y --
|
||||
-- --
|
||||
-- Copyright (C) 2010-2011, Free Software Foundation, Inc. --
|
||||
-- Copyright (C) 2010-2012, 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- --
|
||||
|
|
@ -202,7 +202,7 @@ package body Ada.Containers.Formal_Hashed_Maps is
|
|||
Capacity : Count_Type := 0) return Map
|
||||
is
|
||||
C : constant Count_Type :=
|
||||
Count_Type'Max (Capacity, Source.Capacity);
|
||||
Count_Type'Max (Capacity, Source.Capacity);
|
||||
H : Hash_Type;
|
||||
N : Count_Type;
|
||||
Target : Map (C, Source.Modulus);
|
||||
|
|
@ -407,8 +407,7 @@ package body Ada.Containers.Formal_Hashed_Maps is
|
|||
----------
|
||||
|
||||
function Find (Container : Map; Key : Key_Type) return Cursor is
|
||||
Node : constant Count_Type :=
|
||||
Key_Ops.Find (Container, Key);
|
||||
Node : constant Count_Type := Key_Ops.Find (Container, Key);
|
||||
|
||||
begin
|
||||
if Node = 0 then
|
||||
|
|
@ -700,7 +699,7 @@ package body Ada.Containers.Formal_Hashed_Maps is
|
|||
function Left (Container : Map; Position : Cursor) return Map is
|
||||
Curs : Cursor;
|
||||
C : Map (Container.Capacity, Container.Modulus) :=
|
||||
Copy (Container, Container.Capacity);
|
||||
Copy (Container, Container.Capacity);
|
||||
Node : Count_Type;
|
||||
|
||||
begin
|
||||
|
|
@ -1026,7 +1025,7 @@ package body Ada.Containers.Formal_Hashed_Maps is
|
|||
function Right (Container : Map; Position : Cursor) return Map is
|
||||
Curs : Cursor := First (Container);
|
||||
C : Map (Container.Capacity, Container.Modulus) :=
|
||||
Copy (Container, Container.Capacity);
|
||||
Copy (Container, Container.Capacity);
|
||||
Node : Count_Type;
|
||||
|
||||
begin
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
-- --
|
||||
-- B o d y --
|
||||
-- --
|
||||
-- Copyright (C) 2010-2011, Free Software Foundation, Inc. --
|
||||
-- Copyright (C) 2010-2012, 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- --
|
||||
|
|
@ -226,7 +226,7 @@ package body Ada.Containers.Formal_Hashed_Sets is
|
|||
Capacity : Count_Type := 0) return Set
|
||||
is
|
||||
C : constant Count_Type :=
|
||||
Count_Type'Max (Capacity, Source.Capacity);
|
||||
Count_Type'Max (Capacity, Source.Capacity);
|
||||
H : Hash_Type;
|
||||
N : Count_Type;
|
||||
Target : Set (C, Source.Modulus);
|
||||
|
|
@ -470,7 +470,7 @@ package body Ada.Containers.Formal_Hashed_Sets is
|
|||
L_Node : Node_Type) return Boolean
|
||||
is
|
||||
R_Index : constant Hash_Type :=
|
||||
Element_Keys.Index (R_HT, L_Node.Element);
|
||||
Element_Keys.Index (R_HT, L_Node.Element);
|
||||
R_Node : Count_Type := R_HT.Buckets (R_Index);
|
||||
RN : Nodes_Type renames R_HT.Nodes;
|
||||
|
||||
|
|
@ -979,7 +979,7 @@ package body Ada.Containers.Formal_Hashed_Sets is
|
|||
function Left (Container : Set; Position : Cursor) return Set is
|
||||
Curs : Cursor := Position;
|
||||
C : Set (Container.Capacity, Container.Modulus) :=
|
||||
Copy (Container, Container.Capacity);
|
||||
Copy (Container, Container.Capacity);
|
||||
Node : Count_Type;
|
||||
|
||||
begin
|
||||
|
|
@ -1280,7 +1280,7 @@ package body Ada.Containers.Formal_Hashed_Sets is
|
|||
function Right (Container : Set; Position : Cursor) return Set is
|
||||
Curs : Cursor := First (Container);
|
||||
C : Set (Container.Capacity, Container.Modulus) :=
|
||||
Copy (Container, Container.Capacity);
|
||||
Copy (Container, Container.Capacity);
|
||||
Node : Count_Type;
|
||||
|
||||
begin
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
-- --
|
||||
-- B o d y --
|
||||
-- --
|
||||
-- Copyright (C) 2010-2011, Free Software Foundation, Inc. --
|
||||
-- Copyright (C) 2010-2012, 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- --
|
||||
|
|
@ -1003,7 +1003,7 @@ package body Ada.Containers.Formal_Ordered_Maps is
|
|||
|
||||
declare
|
||||
Node : constant Count_Type :=
|
||||
Tree_Operations.Previous (Container, Position.Node);
|
||||
Tree_Operations.Previous (Container, Position.Node);
|
||||
|
||||
begin
|
||||
if Node = 0 then
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
-- --
|
||||
-- B o d y --
|
||||
-- --
|
||||
-- Copyright (C) 2010-2011, Free Software Foundation, Inc. --
|
||||
-- Copyright (C) 2010-2012, 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- --
|
||||
|
|
@ -1336,7 +1336,7 @@ package body Ada.Containers.Formal_Ordered_Sets is
|
|||
|
||||
declare
|
||||
Node : constant Count_Type :=
|
||||
Tree_Operations.Previous (Container, Position.Node);
|
||||
Tree_Operations.Previous (Container, Position.Node);
|
||||
begin
|
||||
return (if Node = 0 then No_Element else (Node => Node));
|
||||
end;
|
||||
|
|
|
|||
|
|
@ -291,8 +291,8 @@ package body Ada.Containers.Indefinite_Doubly_Linked_Lists is
|
|||
L : Natural renames C.Lock;
|
||||
begin
|
||||
return R : constant Constant_Reference_Type :=
|
||||
(Element => Position.Node.Element.all'Access,
|
||||
Control => (Controlled with Position.Container))
|
||||
(Element => Position.Node.Element.all'Access,
|
||||
Control => (Controlled with Position.Container))
|
||||
do
|
||||
B := B + 1;
|
||||
L := L + 1;
|
||||
|
|
@ -801,7 +801,7 @@ package body Ada.Containers.Indefinite_Doubly_Linked_Lists is
|
|||
|
||||
procedure Sort (Front, Back : Node_Access) is
|
||||
Pivot : constant Node_Access :=
|
||||
(if Front = null then Container.First else Front.Next);
|
||||
(if Front = null then Container.First else Front.Next);
|
||||
begin
|
||||
if Pivot /= Back then
|
||||
Partition (Pivot, Back);
|
||||
|
|
@ -1041,9 +1041,9 @@ package body Ada.Containers.Indefinite_Doubly_Linked_Lists is
|
|||
-- for a reverse iterator, Container.Last is the beginning.
|
||||
|
||||
return It : constant Iterator :=
|
||||
Iterator'(Limited_Controlled with
|
||||
Container => Container'Unrestricted_Access,
|
||||
Node => null)
|
||||
Iterator'(Limited_Controlled with
|
||||
Container => Container'Unrestricted_Access,
|
||||
Node => null)
|
||||
do
|
||||
B := B + 1;
|
||||
end return;
|
||||
|
|
@ -1090,9 +1090,9 @@ package body Ada.Containers.Indefinite_Doubly_Linked_Lists is
|
|||
-- is a forward or reverse iteration.
|
||||
|
||||
return It : constant Iterator :=
|
||||
Iterator'(Limited_Controlled with
|
||||
Container => Container'Unrestricted_Access,
|
||||
Node => Start.Node)
|
||||
Iterator'(Limited_Controlled with
|
||||
Container => Container'Unrestricted_Access,
|
||||
Node => Start.Node)
|
||||
do
|
||||
B := B + 1;
|
||||
end return;
|
||||
|
|
@ -1345,7 +1345,7 @@ package body Ada.Containers.Indefinite_Doubly_Linked_Lists is
|
|||
|
||||
declare
|
||||
Element : Element_Access :=
|
||||
new Element_Type'(Element_Type'Input (Stream));
|
||||
new Element_Type'(Element_Type'Input (Stream));
|
||||
begin
|
||||
Dst := new Node_Type'(Element, null, null);
|
||||
exception
|
||||
|
|
@ -1361,7 +1361,7 @@ package body Ada.Containers.Indefinite_Doubly_Linked_Lists is
|
|||
while Item.Length < N loop
|
||||
declare
|
||||
Element : Element_Access :=
|
||||
new Element_Type'(Element_Type'Input (Stream));
|
||||
new Element_Type'(Element_Type'Input (Stream));
|
||||
begin
|
||||
Dst := new Node_Type'(Element, Next => null, Prev => Item.Last);
|
||||
exception
|
||||
|
|
@ -1430,8 +1430,8 @@ package body Ada.Containers.Indefinite_Doubly_Linked_Lists is
|
|||
L : Natural renames C.Lock;
|
||||
begin
|
||||
return R : constant Reference_Type :=
|
||||
(Element => Position.Node.Element.all'Access,
|
||||
Control => (Controlled with Position.Container))
|
||||
(Element => Position.Node.Element.all'Access,
|
||||
Control => (Controlled with Position.Container))
|
||||
do
|
||||
B := B + 1;
|
||||
L := L + 1;
|
||||
|
|
|
|||
|
|
@ -239,9 +239,8 @@ package body Ada.Containers.Indefinite_Hashed_Maps is
|
|||
L : Natural renames HT.Lock;
|
||||
begin
|
||||
return R : constant Constant_Reference_Type :=
|
||||
(Element => Position.Node.Element.all'Access,
|
||||
Control =>
|
||||
(Controlled with Container'Unrestricted_Access))
|
||||
(Element => Position.Node.Element.all'Access,
|
||||
Control => (Controlled with Container'Unrestricted_Access))
|
||||
do
|
||||
B := B + 1;
|
||||
L := L + 1;
|
||||
|
|
@ -271,9 +270,8 @@ package body Ada.Containers.Indefinite_Hashed_Maps is
|
|||
L : Natural renames HT.Lock;
|
||||
begin
|
||||
return R : constant Constant_Reference_Type :=
|
||||
(Element => Node.Element.all'Access,
|
||||
Control =>
|
||||
(Controlled with Container'Unrestricted_Access))
|
||||
(Element => Node.Element.all'Access,
|
||||
Control => (Controlled with Container'Unrestricted_Access))
|
||||
do
|
||||
B := B + 1;
|
||||
L := L + 1;
|
||||
|
|
@ -851,8 +849,7 @@ package body Ada.Containers.Indefinite_Hashed_Maps is
|
|||
B : Natural renames Container'Unrestricted_Access.all.HT.Busy;
|
||||
begin
|
||||
return It : constant Iterator :=
|
||||
(Limited_Controlled with
|
||||
Container => Container'Unrestricted_Access)
|
||||
(Limited_Controlled with Container => Container'Unrestricted_Access)
|
||||
do
|
||||
B := B + 1;
|
||||
end return;
|
||||
|
|
@ -1110,8 +1107,8 @@ package body Ada.Containers.Indefinite_Hashed_Maps is
|
|||
L : Natural renames HT.Lock;
|
||||
begin
|
||||
return R : constant Reference_Type :=
|
||||
(Element => Position.Node.Element.all'Access,
|
||||
Control => (Controlled with Position.Container))
|
||||
(Element => Position.Node.Element.all'Access,
|
||||
Control => (Controlled with Position.Container))
|
||||
do
|
||||
B := B + 1;
|
||||
L := L + 1;
|
||||
|
|
@ -1141,9 +1138,8 @@ package body Ada.Containers.Indefinite_Hashed_Maps is
|
|||
L : Natural renames HT.Lock;
|
||||
begin
|
||||
return R : constant Reference_Type :=
|
||||
(Element => Node.Element.all'Access,
|
||||
Control =>
|
||||
(Controlled with Container'Unrestricted_Access))
|
||||
(Element => Node.Element.all'Access,
|
||||
Control => (Controlled with Container'Unrestricted_Access))
|
||||
do
|
||||
B := B + 1;
|
||||
L := L + 1;
|
||||
|
|
|
|||
|
|
@ -255,9 +255,8 @@ package body Ada.Containers.Indefinite_Hashed_Sets is
|
|||
L : Natural renames HT.Lock;
|
||||
begin
|
||||
return R : constant Constant_Reference_Type :=
|
||||
(Element => Position.Node.Element.all'Access,
|
||||
Control =>
|
||||
(Controlled with Container'Unrestricted_Access))
|
||||
(Element => Position.Node.Element.all'Access,
|
||||
Control => (Controlled with Container'Unrestricted_Access))
|
||||
do
|
||||
B := B + 1;
|
||||
L := L + 1;
|
||||
|
|
@ -683,7 +682,7 @@ package body Ada.Containers.Indefinite_Hashed_Sets is
|
|||
L_Node : Node_Access) return Boolean
|
||||
is
|
||||
R_Index : constant Hash_Type :=
|
||||
Element_Keys.Index (R_HT, L_Node.Element.all);
|
||||
Element_Keys.Index (R_HT, L_Node.Element.all);
|
||||
|
||||
R_Node : Node_Access := R_HT.Buckets (R_Index);
|
||||
|
||||
|
|
@ -710,7 +709,7 @@ package body Ada.Containers.Indefinite_Hashed_Sets is
|
|||
L_Node : Node_Access) return Boolean
|
||||
is
|
||||
R_Index : constant Hash_Type :=
|
||||
Element_Keys.Index (R_HT, L_Node.Element.all);
|
||||
Element_Keys.Index (R_HT, L_Node.Element.all);
|
||||
|
||||
R_Node : Node_Access := R_HT.Buckets (R_Index);
|
||||
|
||||
|
|
@ -1119,8 +1118,8 @@ package body Ada.Containers.Indefinite_Hashed_Sets is
|
|||
B : Natural renames Container'Unrestricted_Access.all.HT.Busy;
|
||||
begin
|
||||
return It : constant Iterator :=
|
||||
Iterator'(Limited_Controlled with
|
||||
Container => Container'Unrestricted_Access)
|
||||
Iterator'(Limited_Controlled with
|
||||
Container => Container'Unrestricted_Access)
|
||||
do
|
||||
B := B + 1;
|
||||
end return;
|
||||
|
|
@ -1322,7 +1321,7 @@ package body Ada.Containers.Indefinite_Hashed_Sets is
|
|||
New_Item : Element_Type)
|
||||
is
|
||||
Node : constant Node_Access :=
|
||||
Element_Keys.Find (Container.HT, New_Item);
|
||||
Element_Keys.Find (Container.HT, New_Item);
|
||||
|
||||
X : Element_Access;
|
||||
pragma Warnings (Off, X);
|
||||
|
|
@ -1566,7 +1565,7 @@ package body Ada.Containers.Indefinite_Hashed_Sets is
|
|||
|
||||
declare
|
||||
Size : constant Hash_Type :=
|
||||
Prime_Numbers.To_Prime (Left.Length + Right.Length);
|
||||
Prime_Numbers.To_Prime (Left.Length + Right.Length);
|
||||
begin
|
||||
Buckets := HT_Ops.New_Buckets (Length => Size);
|
||||
end;
|
||||
|
|
@ -1768,7 +1767,7 @@ package body Ada.Containers.Indefinite_Hashed_Sets is
|
|||
|
||||
declare
|
||||
Size : constant Hash_Type :=
|
||||
Prime_Numbers.To_Prime (Left.Length + Right.Length);
|
||||
Prime_Numbers.To_Prime (Left.Length + Right.Length);
|
||||
begin
|
||||
Buckets := HT_Ops.New_Buckets (Length => Size);
|
||||
end;
|
||||
|
|
@ -1990,7 +1989,7 @@ package body Ada.Containers.Indefinite_Hashed_Sets is
|
|||
Key : Key_Type) return Constant_Reference_Type
|
||||
is
|
||||
Node : constant Node_Access :=
|
||||
Key_Keys.Find (Container.HT, Key);
|
||||
Key_Keys.Find (Container.HT, Key);
|
||||
|
||||
begin
|
||||
if Node = null then
|
||||
|
|
@ -2007,9 +2006,8 @@ package body Ada.Containers.Indefinite_Hashed_Sets is
|
|||
L : Natural renames HT.Lock;
|
||||
begin
|
||||
return R : constant Constant_Reference_Type :=
|
||||
(Element => Node.Element.all'Access,
|
||||
Control =>
|
||||
(Controlled with Container'Unrestricted_Access))
|
||||
(Element => Node.Element.all'Access,
|
||||
Control => (Controlled with Container'Unrestricted_Access))
|
||||
do
|
||||
B := B + 1;
|
||||
L := L + 1;
|
||||
|
|
@ -2176,7 +2174,7 @@ package body Ada.Containers.Indefinite_Hashed_Sets is
|
|||
Key : Key_Type) return Reference_Type
|
||||
is
|
||||
Node : constant Node_Access :=
|
||||
Key_Keys.Find (Container.HT, Key);
|
||||
Key_Keys.Find (Container.HT, Key);
|
||||
|
||||
begin
|
||||
if Node = null then
|
||||
|
|
@ -2204,7 +2202,7 @@ package body Ada.Containers.Indefinite_Hashed_Sets is
|
|||
New_Item : Element_Type)
|
||||
is
|
||||
Node : constant Node_Access :=
|
||||
Key_Keys.Find (Container.HT, Key);
|
||||
Key_Keys.Find (Container.HT, Key);
|
||||
|
||||
begin
|
||||
if Node = null then
|
||||
|
|
|
|||
|
|
@ -504,9 +504,8 @@ package body Ada.Containers.Indefinite_Multiway_Trees is
|
|||
L : Natural renames C.Lock;
|
||||
begin
|
||||
return R : constant Constant_Reference_Type :=
|
||||
(Element => Position.Node.Element.all'Access,
|
||||
Control =>
|
||||
(Controlled with Container'Unrestricted_Access))
|
||||
(Element => Position.Node.Element.all'Access,
|
||||
Control => (Controlled with Container'Unrestricted_Access))
|
||||
do
|
||||
B := B + 1;
|
||||
L := L + 1;
|
||||
|
|
@ -1049,7 +1048,7 @@ package body Ada.Containers.Indefinite_Multiway_Trees is
|
|||
Item : Element_Type) return Cursor
|
||||
is
|
||||
N : constant Tree_Node_Access :=
|
||||
Find_In_Children (Root_Node (Container), Item);
|
||||
Find_In_Children (Root_Node (Container), Item);
|
||||
|
||||
begin
|
||||
if N = null then
|
||||
|
|
@ -1534,9 +1533,9 @@ package body Ada.Containers.Indefinite_Multiway_Trees is
|
|||
end if;
|
||||
|
||||
return It : constant Child_Iterator :=
|
||||
Child_Iterator'(Limited_Controlled with
|
||||
Container => C,
|
||||
Subtree => Parent.Node)
|
||||
Child_Iterator'(Limited_Controlled with
|
||||
Container => C,
|
||||
Subtree => Parent.Node)
|
||||
do
|
||||
B := B + 1;
|
||||
end return;
|
||||
|
|
@ -1562,9 +1561,9 @@ package body Ada.Containers.Indefinite_Multiway_Trees is
|
|||
B : Natural renames Position.Container.Busy;
|
||||
begin
|
||||
return It : constant Subtree_Iterator :=
|
||||
(Limited_Controlled with
|
||||
Container => Position.Container,
|
||||
Subtree => Position.Node)
|
||||
(Limited_Controlled with
|
||||
Container => Position.Container,
|
||||
Subtree => Position.Node)
|
||||
do
|
||||
B := B + 1;
|
||||
end return;
|
||||
|
|
@ -2023,13 +2022,11 @@ package body Ada.Containers.Indefinite_Multiway_Trees is
|
|||
(Parent : Tree_Node_Access) return Tree_Node_Access
|
||||
is
|
||||
Element : constant Element_Access :=
|
||||
new Element_Type'(Element_Type'Input (Stream));
|
||||
new Element_Type'(Element_Type'Input (Stream));
|
||||
|
||||
Subtree : constant Tree_Node_Access :=
|
||||
new Tree_Node_Type'
|
||||
(Parent => Parent,
|
||||
Element => Element,
|
||||
others => <>);
|
||||
new Tree_Node_Type'
|
||||
(Parent => Parent, Element => Element, others => <>);
|
||||
|
||||
begin
|
||||
Read_Count := Read_Count + 1;
|
||||
|
|
@ -2126,8 +2123,8 @@ package body Ada.Containers.Indefinite_Multiway_Trees is
|
|||
L : Natural renames C.Lock;
|
||||
begin
|
||||
return R : constant Reference_Type :=
|
||||
(Element => Position.Node.Element.all'Access,
|
||||
Control => (Controlled with Position.Container))
|
||||
(Element => Position.Node.Element.all'Access,
|
||||
Control => (Controlled with Position.Container))
|
||||
do
|
||||
B := B + 1;
|
||||
L := L + 1;
|
||||
|
|
|
|||
|
|
@ -399,9 +399,8 @@ package body Ada.Containers.Indefinite_Ordered_Maps is
|
|||
L : Natural renames T.Lock;
|
||||
begin
|
||||
return R : constant Constant_Reference_Type :=
|
||||
(Element => Position.Node.Element.all'Access,
|
||||
Control =>
|
||||
(Controlled with Container'Unrestricted_Access))
|
||||
(Element => Position.Node.Element.all'Access,
|
||||
Control => (Controlled with Container'Unrestricted_Access))
|
||||
do
|
||||
B := B + 1;
|
||||
L := L + 1;
|
||||
|
|
@ -430,9 +429,8 @@ package body Ada.Containers.Indefinite_Ordered_Maps is
|
|||
L : Natural renames T.Lock;
|
||||
begin
|
||||
return R : constant Constant_Reference_Type :=
|
||||
(Element => Node.Element.all'Access,
|
||||
Control =>
|
||||
(Controlled with Container'Unrestricted_Access))
|
||||
(Element => Node.Element.all'Access,
|
||||
Control => (Controlled with Container'Unrestricted_Access))
|
||||
do
|
||||
B := B + 1;
|
||||
L := L + 1;
|
||||
|
|
@ -1014,9 +1012,9 @@ package body Ada.Containers.Indefinite_Ordered_Maps is
|
|||
-- for a reverse iterator, Container.Last is the beginning.
|
||||
|
||||
return It : constant Iterator :=
|
||||
(Limited_Controlled with
|
||||
Container => Container'Unrestricted_Access,
|
||||
Node => null)
|
||||
(Limited_Controlled with
|
||||
Container => Container'Unrestricted_Access,
|
||||
Node => null)
|
||||
do
|
||||
B := B + 1;
|
||||
end return;
|
||||
|
|
@ -1064,9 +1062,9 @@ package body Ada.Containers.Indefinite_Ordered_Maps is
|
|||
-- is a forward or reverse iteration.
|
||||
|
||||
return It : constant Iterator :=
|
||||
(Limited_Controlled with
|
||||
Container => Container'Unrestricted_Access,
|
||||
Node => Start.Node)
|
||||
(Limited_Controlled with
|
||||
Container => Container'Unrestricted_Access,
|
||||
Node => Start.Node)
|
||||
do
|
||||
B := B + 1;
|
||||
end return;
|
||||
|
|
@ -1204,7 +1202,7 @@ package body Ada.Containers.Indefinite_Ordered_Maps is
|
|||
|
||||
declare
|
||||
Node : constant Node_Access :=
|
||||
Tree_Operations.Next (Position.Node);
|
||||
Tree_Operations.Next (Position.Node);
|
||||
begin
|
||||
return (if Node = null then No_Element
|
||||
else Cursor'(Position.Container, Node));
|
||||
|
|
@ -1260,7 +1258,7 @@ package body Ada.Containers.Indefinite_Ordered_Maps is
|
|||
|
||||
declare
|
||||
Node : constant Node_Access :=
|
||||
Tree_Operations.Previous (Position.Node);
|
||||
Tree_Operations.Previous (Position.Node);
|
||||
begin
|
||||
return (if Node = null then No_Element
|
||||
else Cursor'(Position.Container, Node));
|
||||
|
|
@ -1437,8 +1435,8 @@ package body Ada.Containers.Indefinite_Ordered_Maps is
|
|||
L : Natural renames T.Lock;
|
||||
begin
|
||||
return R : constant Reference_Type :=
|
||||
(Element => Position.Node.Element.all'Access,
|
||||
Control => (Controlled with Position.Container))
|
||||
(Element => Position.Node.Element.all'Access,
|
||||
Control => (Controlled with Position.Container))
|
||||
do
|
||||
B := B + 1;
|
||||
L := L + 1;
|
||||
|
|
@ -1467,9 +1465,8 @@ package body Ada.Containers.Indefinite_Ordered_Maps is
|
|||
L : Natural renames T.Lock;
|
||||
begin
|
||||
return R : constant Reference_Type :=
|
||||
(Element => Node.Element.all'Access,
|
||||
Control =>
|
||||
(Controlled with Container'Unrestricted_Access))
|
||||
(Element => Node.Element.all'Access,
|
||||
Control => (Controlled with Container'Unrestricted_Access))
|
||||
do
|
||||
B := B + 1;
|
||||
L := L + 1;
|
||||
|
|
@ -1486,8 +1483,7 @@ package body Ada.Containers.Indefinite_Ordered_Maps is
|
|||
Key : Key_Type;
|
||||
New_Item : Element_Type)
|
||||
is
|
||||
Node : constant Node_Access :=
|
||||
Key_Ops.Find (Container.Tree, Key);
|
||||
Node : constant Node_Access := Key_Ops.Find (Container.Tree, Key);
|
||||
|
||||
K : Key_Access;
|
||||
E : Element_Access;
|
||||
|
|
|
|||
|
|
@ -340,7 +340,7 @@ package body Ada.Containers.Indefinite_Ordered_Multisets is
|
|||
|
||||
function Ceiling (Container : Set; Item : Element_Type) return Cursor is
|
||||
Node : constant Node_Access :=
|
||||
Element_Keys.Ceiling (Container.Tree, Item);
|
||||
Element_Keys.Ceiling (Container.Tree, Item);
|
||||
|
||||
begin
|
||||
if Node = null then
|
||||
|
|
@ -503,8 +503,7 @@ package body Ada.Containers.Indefinite_Ordered_Multisets is
|
|||
end Difference;
|
||||
|
||||
function Difference (Left, Right : Set) return Set is
|
||||
Tree : constant Tree_Type :=
|
||||
Set_Ops.Difference (Left.Tree, Right.Tree);
|
||||
Tree : constant Tree_Type := Set_Ops.Difference (Left.Tree, Right.Tree);
|
||||
begin
|
||||
return Set'(Controlled with Tree);
|
||||
end Difference;
|
||||
|
|
@ -601,8 +600,7 @@ package body Ada.Containers.Indefinite_Ordered_Multisets is
|
|||
----------
|
||||
|
||||
function Find (Container : Set; Item : Element_Type) return Cursor is
|
||||
Node : constant Node_Access :=
|
||||
Element_Keys.Find (Container.Tree, Item);
|
||||
Node : constant Node_Access := Element_Keys.Find (Container.Tree, Item);
|
||||
|
||||
begin
|
||||
if Node = null then
|
||||
|
|
@ -677,8 +675,7 @@ package body Ada.Containers.Indefinite_Ordered_Multisets is
|
|||
-----------
|
||||
|
||||
function Floor (Container : Set; Item : Element_Type) return Cursor is
|
||||
Node : constant Node_Access :=
|
||||
Element_Keys.Floor (Container.Tree, Item);
|
||||
Node : constant Node_Access := Element_Keys.Floor (Container.Tree, Item);
|
||||
|
||||
begin
|
||||
if Node = null then
|
||||
|
|
@ -753,8 +750,7 @@ package body Ada.Containers.Indefinite_Ordered_Multisets is
|
|||
-------------
|
||||
|
||||
function Ceiling (Container : Set; Key : Key_Type) return Cursor is
|
||||
Node : constant Node_Access :=
|
||||
Key_Keys.Ceiling (Container.Tree, Key);
|
||||
Node : constant Node_Access := Key_Keys.Ceiling (Container.Tree, Key);
|
||||
|
||||
begin
|
||||
if Node = null then
|
||||
|
|
@ -803,8 +799,7 @@ package body Ada.Containers.Indefinite_Ordered_Multisets is
|
|||
-------------
|
||||
|
||||
function Element (Container : Set; Key : Key_Type) return Element_Type is
|
||||
Node : constant Node_Access :=
|
||||
Key_Keys.Find (Container.Tree, Key);
|
||||
Node : constant Node_Access := Key_Keys.Find (Container.Tree, Key);
|
||||
|
||||
begin
|
||||
if Node = null then
|
||||
|
|
@ -1259,7 +1254,7 @@ package body Ada.Containers.Indefinite_Ordered_Multisets is
|
|||
|
||||
function Intersection (Left, Right : Set) return Set is
|
||||
Tree : constant Tree_Type :=
|
||||
Set_Ops.Intersection (Left.Tree, Right.Tree);
|
||||
Set_Ops.Intersection (Left.Tree, Right.Tree);
|
||||
begin
|
||||
return Set'(Controlled with Tree);
|
||||
end Intersection;
|
||||
|
|
|
|||
|
|
@ -359,7 +359,7 @@ package body Ada.Containers.Indefinite_Ordered_Sets is
|
|||
|
||||
function Ceiling (Container : Set; Item : Element_Type) return Cursor is
|
||||
Node : constant Node_Access :=
|
||||
Element_Keys.Ceiling (Container.Tree, Item);
|
||||
Element_Keys.Ceiling (Container.Tree, Item);
|
||||
begin
|
||||
return (if Node = null then No_Element
|
||||
else Cursor'(Container'Unrestricted_Access, Node));
|
||||
|
|
@ -418,9 +418,8 @@ package body Ada.Containers.Indefinite_Ordered_Sets is
|
|||
L : Natural renames Tree.Lock;
|
||||
begin
|
||||
return R : constant Constant_Reference_Type :=
|
||||
(Element => Position.Node.Element.all'Access,
|
||||
Control =>
|
||||
(Controlled with Container'Unrestricted_Access))
|
||||
(Element => Position.Node.Element.all'Access,
|
||||
Control => (Controlled with Container'Unrestricted_Access))
|
||||
do
|
||||
B := B + 1;
|
||||
L := L + 1;
|
||||
|
|
@ -494,8 +493,7 @@ package body Ada.Containers.Indefinite_Ordered_Sets is
|
|||
end Delete;
|
||||
|
||||
procedure Delete (Container : in out Set; Item : Element_Type) is
|
||||
X : Node_Access :=
|
||||
Element_Keys.Find (Container.Tree, Item);
|
||||
X : Node_Access := Element_Keys.Find (Container.Tree, Item);
|
||||
|
||||
begin
|
||||
if X = null then
|
||||
|
|
@ -620,8 +618,7 @@ package body Ada.Containers.Indefinite_Ordered_Sets is
|
|||
-------------
|
||||
|
||||
procedure Exclude (Container : in out Set; Item : Element_Type) is
|
||||
X : Node_Access :=
|
||||
Element_Keys.Find (Container.Tree, Item);
|
||||
X : Node_Access := Element_Keys.Find (Container.Tree, Item);
|
||||
begin
|
||||
if X /= null then
|
||||
Tree_Operations.Delete_Node_Sans_Free (Container.Tree, X);
|
||||
|
|
@ -665,8 +662,7 @@ package body Ada.Containers.Indefinite_Ordered_Sets is
|
|||
----------
|
||||
|
||||
function Find (Container : Set; Item : Element_Type) return Cursor is
|
||||
Node : constant Node_Access :=
|
||||
Element_Keys.Find (Container.Tree, Item);
|
||||
Node : constant Node_Access := Element_Keys.Find (Container.Tree, Item);
|
||||
begin
|
||||
if Node = null then
|
||||
return No_Element;
|
||||
|
|
@ -726,8 +722,7 @@ package body Ada.Containers.Indefinite_Ordered_Sets is
|
|||
-----------
|
||||
|
||||
function Floor (Container : Set; Item : Element_Type) return Cursor is
|
||||
Node : constant Node_Access :=
|
||||
Element_Keys.Floor (Container.Tree, Item);
|
||||
Node : constant Node_Access := Element_Keys.Floor (Container.Tree, Item);
|
||||
begin
|
||||
return (if Node = null then No_Element
|
||||
else Cursor'(Container'Unrestricted_Access, Node));
|
||||
|
|
@ -798,8 +793,7 @@ package body Ada.Containers.Indefinite_Ordered_Sets is
|
|||
-------------
|
||||
|
||||
function Ceiling (Container : Set; Key : Key_Type) return Cursor is
|
||||
Node : constant Node_Access :=
|
||||
Key_Keys.Ceiling (Container.Tree, Key);
|
||||
Node : constant Node_Access := Key_Keys.Ceiling (Container.Tree, Key);
|
||||
begin
|
||||
return (if Node = null then No_Element
|
||||
else Cursor'(Container'Unrestricted_Access, Node));
|
||||
|
|
@ -813,8 +807,7 @@ package body Ada.Containers.Indefinite_Ordered_Sets is
|
|||
(Container : aliased Set;
|
||||
Key : Key_Type) return Constant_Reference_Type
|
||||
is
|
||||
Node : constant Node_Access :=
|
||||
Key_Keys.Find (Container.Tree, Key);
|
||||
Node : constant Node_Access := Key_Keys.Find (Container.Tree, Key);
|
||||
|
||||
begin
|
||||
if Node = null then
|
||||
|
|
@ -831,9 +824,8 @@ package body Ada.Containers.Indefinite_Ordered_Sets is
|
|||
L : Natural renames Tree.Lock;
|
||||
begin
|
||||
return R : constant Constant_Reference_Type :=
|
||||
(Element => Node.Element.all'Access,
|
||||
Control =>
|
||||
(Controlled with Container'Unrestricted_Access))
|
||||
(Element => Node.Element.all'Access,
|
||||
Control => (Controlled with Container'Unrestricted_Access))
|
||||
do
|
||||
B := B + 1;
|
||||
L := L + 1;
|
||||
|
|
@ -871,8 +863,7 @@ package body Ada.Containers.Indefinite_Ordered_Sets is
|
|||
-------------
|
||||
|
||||
function Element (Container : Set; Key : Key_Type) return Element_Type is
|
||||
Node : constant Node_Access :=
|
||||
Key_Keys.Find (Container.Tree, Key);
|
||||
Node : constant Node_Access := Key_Keys.Find (Container.Tree, Key);
|
||||
begin
|
||||
if Node = null then
|
||||
raise Constraint_Error with "key not in set";
|
||||
|
|
@ -912,8 +903,7 @@ package body Ada.Containers.Indefinite_Ordered_Sets is
|
|||
----------
|
||||
|
||||
function Find (Container : Set; Key : Key_Type) return Cursor is
|
||||
Node : constant Node_Access :=
|
||||
Key_Keys.Find (Container.Tree, Key);
|
||||
Node : constant Node_Access := Key_Keys.Find (Container.Tree, Key);
|
||||
begin
|
||||
return (if Node = null then No_Element
|
||||
else Cursor'(Container'Unrestricted_Access, Node));
|
||||
|
|
@ -924,8 +914,7 @@ package body Ada.Containers.Indefinite_Ordered_Sets is
|
|||
-----------
|
||||
|
||||
function Floor (Container : Set; Key : Key_Type) return Cursor is
|
||||
Node : constant Node_Access :=
|
||||
Key_Keys.Floor (Container.Tree, Key);
|
||||
Node : constant Node_Access := Key_Keys.Floor (Container.Tree, Key);
|
||||
begin
|
||||
return (if Node = null then No_Element
|
||||
else Cursor'(Container'Unrestricted_Access, Node));
|
||||
|
|
@ -1046,8 +1035,7 @@ package body Ada.Containers.Indefinite_Ordered_Sets is
|
|||
(Container : aliased in out Set;
|
||||
Key : Key_Type) return Reference_Type
|
||||
is
|
||||
Node : constant Node_Access :=
|
||||
Key_Keys.Find (Container.Tree, Key);
|
||||
Node : constant Node_Access := Key_Keys.Find (Container.Tree, Key);
|
||||
|
||||
begin
|
||||
if Node = null then
|
||||
|
|
@ -1309,8 +1297,7 @@ package body Ada.Containers.Indefinite_Ordered_Sets is
|
|||
--------------
|
||||
|
||||
function New_Node return Node_Access is
|
||||
Element : Element_Access :=
|
||||
new Element_Type'(Src_Node.Element.all);
|
||||
Element : Element_Access := new Element_Type'(Src_Node.Element.all);
|
||||
Node : Node_Access;
|
||||
|
||||
begin
|
||||
|
|
@ -1348,7 +1335,7 @@ package body Ada.Containers.Indefinite_Ordered_Sets is
|
|||
|
||||
function Intersection (Left, Right : Set) return Set is
|
||||
Tree : constant Tree_Type :=
|
||||
Set_Ops.Intersection (Left.Tree, Right.Tree);
|
||||
Set_Ops.Intersection (Left.Tree, Right.Tree);
|
||||
begin
|
||||
return Set'(Controlled with Tree);
|
||||
end Intersection;
|
||||
|
|
@ -1466,9 +1453,9 @@ package body Ada.Containers.Indefinite_Ordered_Sets is
|
|||
-- for a reverse iterator, Container.Last is the beginning.
|
||||
|
||||
return It : constant Iterator :=
|
||||
Iterator'(Limited_Controlled with
|
||||
Container => Container'Unrestricted_Access,
|
||||
Node => null)
|
||||
Iterator'(Limited_Controlled with
|
||||
Container => Container'Unrestricted_Access,
|
||||
Node => null)
|
||||
do
|
||||
B := B + 1;
|
||||
end return;
|
||||
|
|
@ -1516,9 +1503,9 @@ package body Ada.Containers.Indefinite_Ordered_Sets is
|
|||
-- a forward or reverse iteration.
|
||||
|
||||
return It : constant Iterator :=
|
||||
(Limited_Controlled with
|
||||
Container => Container'Unrestricted_Access,
|
||||
Node => Start.Node)
|
||||
(Limited_Controlled with
|
||||
Container => Container'Unrestricted_Access,
|
||||
Node => Start.Node)
|
||||
do
|
||||
B := B + 1;
|
||||
end return;
|
||||
|
|
@ -1622,8 +1609,7 @@ package body Ada.Containers.Indefinite_Ordered_Sets is
|
|||
"bad cursor in Next");
|
||||
|
||||
declare
|
||||
Node : constant Node_Access :=
|
||||
Tree_Operations.Next (Position.Node);
|
||||
Node : constant Node_Access := Tree_Operations.Next (Position.Node);
|
||||
begin
|
||||
return (if Node = null then No_Element
|
||||
else Cursor'(Position.Container, Node));
|
||||
|
|
@ -1689,7 +1675,7 @@ package body Ada.Containers.Indefinite_Ordered_Sets is
|
|||
|
||||
declare
|
||||
Node : constant Node_Access :=
|
||||
Tree_Operations.Previous (Position.Node);
|
||||
Tree_Operations.Previous (Position.Node);
|
||||
begin
|
||||
return (if Node = null then No_Element
|
||||
else Cursor'(Position.Container, Node));
|
||||
|
|
@ -1819,7 +1805,7 @@ package body Ada.Containers.Indefinite_Ordered_Sets is
|
|||
|
||||
procedure Replace (Container : in out Set; New_Item : Element_Type) is
|
||||
Node : constant Node_Access :=
|
||||
Element_Keys.Find (Container.Tree, New_Item);
|
||||
Element_Keys.Find (Container.Tree, New_Item);
|
||||
|
||||
X : Element_Access;
|
||||
pragma Warnings (Off, X);
|
||||
|
|
@ -2097,7 +2083,7 @@ package body Ada.Containers.Indefinite_Ordered_Sets is
|
|||
|
||||
function Symmetric_Difference (Left, Right : Set) return Set is
|
||||
Tree : constant Tree_Type :=
|
||||
Set_Ops.Symmetric_Difference (Left.Tree, Right.Tree);
|
||||
Set_Ops.Symmetric_Difference (Left.Tree, Right.Tree);
|
||||
begin
|
||||
return Set'(Controlled with Tree);
|
||||
end Symmetric_Difference;
|
||||
|
|
@ -2126,8 +2112,7 @@ package body Ada.Containers.Indefinite_Ordered_Sets is
|
|||
end Union;
|
||||
|
||||
function Union (Left, Right : Set) return Set is
|
||||
Tree : constant Tree_Type :=
|
||||
Set_Ops.Union (Left.Tree, Right.Tree);
|
||||
Tree : constant Tree_Type := Set_Ops.Union (Left.Tree, Right.Tree);
|
||||
begin
|
||||
return Set'(Controlled with Tree);
|
||||
end Union;
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
-- --
|
||||
-- B o d y --
|
||||
-- --
|
||||
-- Copyright (C) 2007-2009, Free Software Foundation, Inc. --
|
||||
-- Copyright (C) 2007-2012, 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- --
|
||||
|
|
@ -87,7 +87,7 @@ package body Ada.Command_Line.Response_File is
|
|||
if Last_Arg = Arguments'Last then
|
||||
declare
|
||||
New_Arguments : constant Argument_List_Access :=
|
||||
new Argument_List (1 .. Arguments'Last * 2);
|
||||
new Argument_List (1 .. Arguments'Last * 2);
|
||||
begin
|
||||
New_Arguments (Arguments'Range) := Arguments.all;
|
||||
Arguments.all := (others => null);
|
||||
|
|
@ -421,10 +421,9 @@ package body Ada.Command_Line.Response_File is
|
|||
|
||||
declare
|
||||
Inc_File_Name : constant String :=
|
||||
Arguments (Arg)
|
||||
(2 .. Arguments (Arg)'Last);
|
||||
Arguments (Arg) (2 .. Arguments (Arg)'Last);
|
||||
Current_Arguments : constant Argument_List :=
|
||||
Arguments (1 .. Last_Arg);
|
||||
Arguments (1 .. Last_Arg);
|
||||
begin
|
||||
Recurse (Inc_File_Name);
|
||||
|
||||
|
|
@ -433,10 +432,10 @@ package body Ada.Command_Line.Response_File is
|
|||
|
||||
declare
|
||||
New_Arguments : constant Argument_List :=
|
||||
Arguments (1 .. Last_Arg);
|
||||
Arguments (1 .. Last_Arg);
|
||||
New_Last_Arg : constant Positive :=
|
||||
Current_Arguments'Length +
|
||||
New_Arguments'Length - 1;
|
||||
Current_Arguments'Length +
|
||||
New_Arguments'Length - 1;
|
||||
|
||||
begin
|
||||
-- Grow Arguments if it is not large enough
|
||||
|
|
|
|||
|
|
@ -1728,9 +1728,9 @@ package body Ada.Containers.Bounded_Vectors is
|
|||
-- for a reverse iterator, Container.Last is the beginning.
|
||||
|
||||
return It : constant Iterator :=
|
||||
(Limited_Controlled with
|
||||
Container => V,
|
||||
Index => No_Index)
|
||||
(Limited_Controlled with
|
||||
Container => V,
|
||||
Index => No_Index)
|
||||
do
|
||||
B := B + 1;
|
||||
end return;
|
||||
|
|
@ -1781,9 +1781,9 @@ package body Ada.Containers.Bounded_Vectors is
|
|||
-- a forward or reverse iteration.
|
||||
|
||||
return It : constant Iterator :=
|
||||
(Limited_Controlled with
|
||||
Container => V,
|
||||
Index => Start.Index)
|
||||
(Limited_Controlled with
|
||||
Container => V,
|
||||
Index => Start.Index)
|
||||
do
|
||||
B := B + 1;
|
||||
end return;
|
||||
|
|
@ -2319,7 +2319,7 @@ package body Ada.Containers.Bounded_Vectors is
|
|||
Index : Index_Type := Index_Type'Last) return Extended_Index
|
||||
is
|
||||
Last : constant Index_Type'Base :=
|
||||
Index_Type'Min (Container.Last, Index);
|
||||
Index_Type'Min (Container.Last, Index);
|
||||
|
||||
begin
|
||||
for Indx in reverse Index_Type'First .. Last loop
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
-- --
|
||||
-- B o d y --
|
||||
-- --
|
||||
-- Copyright (C) 2010-2011, Free Software Foundation, Inc. --
|
||||
-- Copyright (C) 2010-2012, 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- --
|
||||
|
|
@ -53,7 +53,7 @@ package body Ada.Containers.Formal_Vectors is
|
|||
|
||||
declare
|
||||
E : constant Elements_Array (1 .. Length (Right)) :=
|
||||
Right.Elements (1 .. RN);
|
||||
Right.Elements (1 .. RN);
|
||||
begin
|
||||
return (Length (Right), E, Last => Right.Last, others => <>);
|
||||
end;
|
||||
|
|
@ -62,7 +62,7 @@ package body Ada.Containers.Formal_Vectors is
|
|||
if RN = 0 then
|
||||
declare
|
||||
E : constant Elements_Array (1 .. Length (Left)) :=
|
||||
Left.Elements (1 .. LN);
|
||||
Left.Elements (1 .. LN);
|
||||
begin
|
||||
return (Length (Left), E, Last => Left.Last, others => <>);
|
||||
end;
|
||||
|
|
@ -370,7 +370,7 @@ package body Ada.Containers.Formal_Vectors is
|
|||
|
||||
New_Last_As_Int : constant Int'Base := Old_Last_As_Int - N;
|
||||
New_Last : constant Index_Type :=
|
||||
Index_Type (New_Last_As_Int);
|
||||
Index_Type (New_Last_As_Int);
|
||||
|
||||
KK : constant Int := New_Last_As_Int - Int (No_Index);
|
||||
K : constant Count_Type := Count_Type (KK);
|
||||
|
|
@ -867,7 +867,7 @@ package body Ada.Containers.Formal_Vectors is
|
|||
|
||||
declare
|
||||
Dst_Last_As_Int : constant Int'Base :=
|
||||
Int (Before) + Int (N) - 1 - Int (No_Index);
|
||||
Int (Before) + Int (N) - 1 - Int (No_Index);
|
||||
|
||||
Dst_Last : constant Count_Type := Count_Type (Dst_Last_As_Int);
|
||||
|
||||
|
|
@ -902,7 +902,7 @@ package body Ada.Containers.Formal_Vectors is
|
|||
Container.Elements (Dst_Last + 1 .. Length (Container));
|
||||
|
||||
Index_As_Int : constant Int'Base :=
|
||||
Dst_Last_As_Int - Src'Length + 1;
|
||||
Dst_Last_As_Int - Src'Length + 1;
|
||||
|
||||
Index : constant Count_Type := Count_Type (Index_As_Int);
|
||||
|
||||
|
|
@ -1775,7 +1775,7 @@ package body Ada.Containers.Formal_Vectors is
|
|||
|
||||
declare
|
||||
Last_As_Int : constant Int'Base :=
|
||||
Int (Index_Type'First) + Int (Length) - 1;
|
||||
Int (Index_Type'First) + Int (Length) - 1;
|
||||
begin
|
||||
Container.Last := Index_Type'Base (Last_As_Int);
|
||||
end;
|
||||
|
|
|
|||
|
|
@ -231,8 +231,8 @@ package body Ada.Containers.Hashed_Maps is
|
|||
L : Natural renames HT.Lock;
|
||||
begin
|
||||
return R : constant Constant_Reference_Type :=
|
||||
(Element => Position.Node.Element'Access,
|
||||
Control => (Controlled with Position.Container))
|
||||
(Element => Position.Node.Element'Access,
|
||||
Control => (Controlled with Position.Container))
|
||||
do
|
||||
B := B + 1;
|
||||
L := L + 1;
|
||||
|
|
@ -257,9 +257,8 @@ package body Ada.Containers.Hashed_Maps is
|
|||
L : Natural renames HT.Lock;
|
||||
begin
|
||||
return R : constant Constant_Reference_Type :=
|
||||
(Element => Node.Element'Access,
|
||||
Control =>
|
||||
(Controlled with Container'Unrestricted_Access))
|
||||
(Element => Node.Element'Access,
|
||||
Control => (Controlled with Container'Unrestricted_Access))
|
||||
do
|
||||
B := B + 1;
|
||||
L := L + 1;
|
||||
|
|
@ -312,9 +311,9 @@ package body Ada.Containers.Hashed_Maps is
|
|||
(Source : Node_Access) return Node_Access
|
||||
is
|
||||
Target : constant Node_Access :=
|
||||
new Node_Type'(Key => Source.Key,
|
||||
Element => Source.Element,
|
||||
Next => null);
|
||||
new Node_Type'(Key => Source.Key,
|
||||
Element => Source.Element,
|
||||
Next => null);
|
||||
begin
|
||||
return Target;
|
||||
end Copy_Node;
|
||||
|
|
@ -774,8 +773,7 @@ package body Ada.Containers.Hashed_Maps is
|
|||
B : Natural renames Container'Unrestricted_Access.all.HT.Busy;
|
||||
begin
|
||||
return It : constant Iterator :=
|
||||
(Limited_Controlled with
|
||||
Container => Container'Unrestricted_Access)
|
||||
(Limited_Controlled with Container => Container'Unrestricted_Access)
|
||||
do
|
||||
B := B + 1;
|
||||
end return;
|
||||
|
|
@ -981,8 +979,8 @@ package body Ada.Containers.Hashed_Maps is
|
|||
L : Natural renames HT.Lock;
|
||||
begin
|
||||
return R : constant Reference_Type :=
|
||||
(Element => Position.Node.Element'Access,
|
||||
Control => (Controlled with Position.Container))
|
||||
(Element => Position.Node.Element'Access,
|
||||
Control => (Controlled with Position.Container))
|
||||
do
|
||||
B := B + 1;
|
||||
L := L + 1;
|
||||
|
|
@ -1007,9 +1005,8 @@ package body Ada.Containers.Hashed_Maps is
|
|||
L : Natural renames HT.Lock;
|
||||
begin
|
||||
return R : constant Reference_Type :=
|
||||
(Element => Node.Element'Access,
|
||||
Control =>
|
||||
(Controlled with Container'Unrestricted_Access))
|
||||
(Element => Node.Element'Access,
|
||||
Control => (Controlled with Container'Unrestricted_Access))
|
||||
do
|
||||
B := B + 1;
|
||||
L := L + 1;
|
||||
|
|
|
|||
|
|
@ -238,9 +238,8 @@ package body Ada.Containers.Hashed_Sets is
|
|||
L : Natural renames HT.Lock;
|
||||
begin
|
||||
return R : constant Constant_Reference_Type :=
|
||||
(Element => Position.Node.Element'Access,
|
||||
Control =>
|
||||
(Controlled with Container'Unrestricted_Access))
|
||||
(Element => Position.Node.Element'Access,
|
||||
Control => (Controlled with Container'Unrestricted_Access))
|
||||
do
|
||||
B := B + 1;
|
||||
L := L + 1;
|
||||
|
|
@ -442,7 +441,7 @@ package body Ada.Containers.Hashed_Sets is
|
|||
if not Is_In (Right.HT, L_Node) then
|
||||
declare
|
||||
J : constant Hash_Type :=
|
||||
Hash (L_Node.Element) mod Buckets'Length;
|
||||
Hash (L_Node.Element) mod Buckets'Length;
|
||||
|
||||
Bucket : Node_Access renames Buckets (J);
|
||||
|
||||
|
|
@ -618,7 +617,7 @@ package body Ada.Containers.Hashed_Sets is
|
|||
L_Node : Node_Access) return Boolean
|
||||
is
|
||||
R_Index : constant Hash_Type :=
|
||||
Element_Keys.Index (R_HT, L_Node.Element);
|
||||
Element_Keys.Index (R_HT, L_Node.Element);
|
||||
|
||||
R_Node : Node_Access := R_HT.Buckets (R_Index);
|
||||
|
||||
|
|
@ -645,7 +644,7 @@ package body Ada.Containers.Hashed_Sets is
|
|||
L_Node : Node_Access) return Boolean
|
||||
is
|
||||
R_Index : constant Hash_Type :=
|
||||
Element_Keys.Index (R_HT, L_Node.Element);
|
||||
Element_Keys.Index (R_HT, L_Node.Element);
|
||||
|
||||
R_Node : Node_Access := R_HT.Buckets (R_Index);
|
||||
|
||||
|
|
@ -891,7 +890,7 @@ package body Ada.Containers.Hashed_Sets is
|
|||
if Is_In (Right.HT, L_Node) then
|
||||
declare
|
||||
J : constant Hash_Type :=
|
||||
Hash (L_Node.Element) mod Buckets'Length;
|
||||
Hash (L_Node.Element) mod Buckets'Length;
|
||||
|
||||
Bucket : Node_Access renames Buckets (J);
|
||||
|
||||
|
|
@ -1201,7 +1200,7 @@ package body Ada.Containers.Hashed_Sets is
|
|||
New_Item : Element_Type)
|
||||
is
|
||||
Node : constant Node_Access :=
|
||||
Element_Keys.Find (Container.HT, New_Item);
|
||||
Element_Keys.Find (Container.HT, New_Item);
|
||||
|
||||
begin
|
||||
if Node = null then
|
||||
|
|
@ -1396,7 +1395,7 @@ package body Ada.Containers.Hashed_Sets is
|
|||
|
||||
declare
|
||||
Size : constant Hash_Type :=
|
||||
Prime_Numbers.To_Prime (Left.Length + Right.Length);
|
||||
Prime_Numbers.To_Prime (Left.Length + Right.Length);
|
||||
begin
|
||||
Buckets := HT_Ops.New_Buckets (Length => Size);
|
||||
end;
|
||||
|
|
@ -1520,7 +1519,7 @@ package body Ada.Containers.Hashed_Sets is
|
|||
|
||||
function New_Node (Next : Node_Access) return Node_Access is
|
||||
Node : constant Node_Access :=
|
||||
new Node_Type'(Src_Node.Element, Next);
|
||||
new Node_Type'(Src_Node.Element, Next);
|
||||
begin
|
||||
return Node;
|
||||
end New_Node;
|
||||
|
|
@ -1577,7 +1576,7 @@ package body Ada.Containers.Hashed_Sets is
|
|||
|
||||
declare
|
||||
Size : constant Hash_Type :=
|
||||
Prime_Numbers.To_Prime (Left.Length + Right.Length);
|
||||
Prime_Numbers.To_Prime (Left.Length + Right.Length);
|
||||
begin
|
||||
Buckets := HT_Ops.New_Buckets (Length => Size);
|
||||
end;
|
||||
|
|
@ -1594,7 +1593,7 @@ package body Ada.Containers.Hashed_Sets is
|
|||
|
||||
procedure Process (L_Node : Node_Access) is
|
||||
J : constant Hash_Type :=
|
||||
Hash (L_Node.Element) mod Buckets'Length;
|
||||
Hash (L_Node.Element) mod Buckets'Length;
|
||||
|
||||
begin
|
||||
Buckets (J) := new Node_Type'(L_Node.Element, Buckets (J));
|
||||
|
|
@ -1624,7 +1623,7 @@ package body Ada.Containers.Hashed_Sets is
|
|||
|
||||
procedure Process (Src_Node : Node_Access) is
|
||||
J : constant Hash_Type :=
|
||||
Hash (Src_Node.Element) mod Buckets'Length;
|
||||
Hash (Src_Node.Element) mod Buckets'Length;
|
||||
|
||||
Tgt_Node : Node_Access := Buckets (J);
|
||||
|
||||
|
|
@ -1781,8 +1780,7 @@ package body Ada.Containers.Hashed_Sets is
|
|||
(Container : aliased Set;
|
||||
Key : Key_Type) return Constant_Reference_Type
|
||||
is
|
||||
Node : constant Node_Access :=
|
||||
Key_Keys.Find (Container.HT, Key);
|
||||
Node : constant Node_Access := Key_Keys.Find (Container.HT, Key);
|
||||
|
||||
begin
|
||||
if Node = null then
|
||||
|
|
@ -1795,9 +1793,8 @@ package body Ada.Containers.Hashed_Sets is
|
|||
L : Natural renames HT.Lock;
|
||||
begin
|
||||
return R : constant Constant_Reference_Type :=
|
||||
(Element => Node.Element'Access,
|
||||
Control =>
|
||||
(Controlled with Container'Unrestricted_Access))
|
||||
(Element => Node.Element'Access,
|
||||
Control => (Controlled with Container'Unrestricted_Access))
|
||||
do
|
||||
B := B + 1;
|
||||
L := L + 1;
|
||||
|
|
@ -1889,8 +1886,7 @@ package body Ada.Containers.Hashed_Sets is
|
|||
(Container : Set;
|
||||
Key : Key_Type) return Cursor
|
||||
is
|
||||
Node : constant Node_Access :=
|
||||
Key_Keys.Find (Container.HT, Key);
|
||||
Node : constant Node_Access := Key_Keys.Find (Container.HT, Key);
|
||||
|
||||
begin
|
||||
if Node = null then
|
||||
|
|
@ -1961,8 +1957,7 @@ package body Ada.Containers.Hashed_Sets is
|
|||
(Container : aliased in out Set;
|
||||
Key : Key_Type) return Reference_Type
|
||||
is
|
||||
Node : constant Node_Access :=
|
||||
Key_Keys.Find (Container.HT, Key);
|
||||
Node : constant Node_Access := Key_Keys.Find (Container.HT, Key);
|
||||
|
||||
begin
|
||||
if Node = null then
|
||||
|
|
@ -1985,8 +1980,7 @@ package body Ada.Containers.Hashed_Sets is
|
|||
Key : Key_Type;
|
||||
New_Item : Element_Type)
|
||||
is
|
||||
Node : constant Node_Access :=
|
||||
Key_Keys.Find (Container.HT, Key);
|
||||
Node : constant Node_Access := Key_Keys.Find (Container.HT, Key);
|
||||
|
||||
begin
|
||||
if Node = null then
|
||||
|
|
|
|||
|
|
@ -90,8 +90,7 @@ package body Ada.Containers.Indefinite_Vectors is
|
|||
RE : Elements_Array renames
|
||||
Right.Elements.EA (Index_Type'First .. Right.Last);
|
||||
|
||||
Elements : Elements_Access :=
|
||||
new Elements_Type (Right.Last);
|
||||
Elements : Elements_Access := new Elements_Type (Right.Last);
|
||||
|
||||
begin
|
||||
-- Elements of an indefinite vector are allocated, so we cannot
|
||||
|
|
@ -126,8 +125,7 @@ package body Ada.Containers.Indefinite_Vectors is
|
|||
LE : Elements_Array renames
|
||||
Left.Elements.EA (Index_Type'First .. Left.Last);
|
||||
|
||||
Elements : Elements_Access :=
|
||||
new Elements_Type (Left.Last);
|
||||
Elements : Elements_Access := new Elements_Type (Left.Last);
|
||||
|
||||
begin
|
||||
-- Elements of an indefinite vector are allocated, so we cannot
|
||||
|
|
@ -348,8 +346,7 @@ package body Ada.Containers.Indefinite_Vectors is
|
|||
LE : Elements_Array renames
|
||||
Left.Elements.EA (Index_Type'First .. Left.Last);
|
||||
|
||||
Elements : Elements_Access :=
|
||||
new Elements_Type (Last);
|
||||
Elements : Elements_Access := new Elements_Type (Last);
|
||||
|
||||
begin
|
||||
for I in LE'Range loop
|
||||
|
|
@ -433,8 +430,7 @@ package body Ada.Containers.Indefinite_Vectors is
|
|||
RE : Elements_Array renames
|
||||
Right.Elements.EA (Index_Type'First .. Right.Last);
|
||||
|
||||
Elements : Elements_Access :=
|
||||
new Elements_Type (Last);
|
||||
Elements : Elements_Access := new Elements_Type (Last);
|
||||
|
||||
I : Index_Type'Base := Index_Type'First;
|
||||
|
||||
|
|
@ -717,9 +713,8 @@ package body Ada.Containers.Indefinite_Vectors is
|
|||
L : Natural renames C.Lock;
|
||||
begin
|
||||
return R : constant Constant_Reference_Type :=
|
||||
(Element => E.all'Access,
|
||||
Control =>
|
||||
(Controlled with Container'Unrestricted_Access))
|
||||
(Element => E.all'Access,
|
||||
Control => (Controlled with Container'Unrestricted_Access))
|
||||
do
|
||||
B := B + 1;
|
||||
L := L + 1;
|
||||
|
|
@ -750,9 +745,8 @@ package body Ada.Containers.Indefinite_Vectors is
|
|||
L : Natural renames C.Lock;
|
||||
begin
|
||||
return R : constant Constant_Reference_Type :=
|
||||
(Element => E.all'Access,
|
||||
Control =>
|
||||
(Controlled with Container'Unrestricted_Access))
|
||||
(Element => E.all'Access,
|
||||
Control => (Controlled with Container'Unrestricted_Access))
|
||||
do
|
||||
B := B + 1;
|
||||
L := L + 1;
|
||||
|
|
@ -1138,7 +1132,7 @@ package body Ada.Containers.Indefinite_Vectors is
|
|||
|
||||
declare
|
||||
EA : constant Element_Access :=
|
||||
Position.Container.Elements.EA (Position.Index);
|
||||
Position.Container.Elements.EA (Position.Index);
|
||||
|
||||
begin
|
||||
if EA = null then
|
||||
|
|
@ -1287,7 +1281,7 @@ package body Ada.Containers.Indefinite_Vectors is
|
|||
|
||||
declare
|
||||
EA : constant Element_Access :=
|
||||
Container.Elements.EA (Index_Type'First);
|
||||
Container.Elements.EA (Index_Type'First);
|
||||
|
||||
begin
|
||||
if EA = null then
|
||||
|
|
@ -2708,9 +2702,9 @@ package body Ada.Containers.Indefinite_Vectors is
|
|||
-- for a reverse iterator, Container.Last is the beginning.
|
||||
|
||||
return It : constant Iterator :=
|
||||
(Limited_Controlled with
|
||||
Container => V,
|
||||
Index => No_Index)
|
||||
(Limited_Controlled with
|
||||
Container => V,
|
||||
Index => No_Index)
|
||||
do
|
||||
B := B + 1;
|
||||
end return;
|
||||
|
|
@ -2761,9 +2755,9 @@ package body Ada.Containers.Indefinite_Vectors is
|
|||
-- is a forward or reverse iteration.
|
||||
|
||||
return It : constant Iterator :=
|
||||
(Limited_Controlled with
|
||||
Container => V,
|
||||
Index => Start.Index)
|
||||
(Limited_Controlled with
|
||||
Container => V,
|
||||
Index => Start.Index)
|
||||
do
|
||||
B := B + 1;
|
||||
end return;
|
||||
|
|
@ -2816,7 +2810,7 @@ package body Ada.Containers.Indefinite_Vectors is
|
|||
|
||||
declare
|
||||
EA : constant Element_Access :=
|
||||
Container.Elements.EA (Container.Last);
|
||||
Container.Elements.EA (Container.Last);
|
||||
|
||||
begin
|
||||
if EA = null then
|
||||
|
|
@ -3155,8 +3149,8 @@ package body Ada.Containers.Indefinite_Vectors is
|
|||
L : Natural renames C.Lock;
|
||||
begin
|
||||
return R : constant Reference_Type :=
|
||||
(Element => E.all'Access,
|
||||
Control => (Controlled with Position.Container))
|
||||
(Element => E.all'Access,
|
||||
Control => (Controlled with Position.Container))
|
||||
do
|
||||
B := B + 1;
|
||||
L := L + 1;
|
||||
|
|
@ -3187,9 +3181,8 @@ package body Ada.Containers.Indefinite_Vectors is
|
|||
L : Natural renames C.Lock;
|
||||
begin
|
||||
return R : constant Reference_Type :=
|
||||
(Element => E.all'Access,
|
||||
Control =>
|
||||
(Controlled with Container'Unrestricted_Access))
|
||||
(Element => E.all'Access,
|
||||
Control => (Controlled with Container'Unrestricted_Access))
|
||||
do
|
||||
B := B + 1;
|
||||
L := L + 1;
|
||||
|
|
@ -3652,7 +3645,7 @@ package body Ada.Containers.Indefinite_Vectors is
|
|||
Index : Index_Type := Index_Type'Last) return Extended_Index
|
||||
is
|
||||
Last : constant Index_Type'Base :=
|
||||
(if Index > Container.Last then Container.Last else Index);
|
||||
(if Index > Container.Last then Container.Last else Index);
|
||||
begin
|
||||
for Indx in reverse Index_Type'First .. Last loop
|
||||
if Container.Elements.EA (Indx) /= null
|
||||
|
|
|
|||
|
|
@ -484,9 +484,8 @@ package body Ada.Containers.Multiway_Trees is
|
|||
L : Natural renames C.Lock;
|
||||
begin
|
||||
return R : constant Constant_Reference_Type :=
|
||||
(Element => Position.Node.Element'Access,
|
||||
Control =>
|
||||
(Controlled with Container'Unrestricted_Access))
|
||||
(Element => Position.Node.Element'Access,
|
||||
Control => (Controlled with Container'Unrestricted_Access))
|
||||
do
|
||||
B := B + 1;
|
||||
L := L + 1;
|
||||
|
|
@ -1009,7 +1008,7 @@ package body Ada.Containers.Multiway_Trees is
|
|||
Item : Element_Type) return Cursor
|
||||
is
|
||||
N : constant Tree_Node_Access :=
|
||||
Find_In_Children (Root_Node (Container), Item);
|
||||
Find_In_Children (Root_Node (Container), Item);
|
||||
begin
|
||||
if N = null then
|
||||
return No_Element;
|
||||
|
|
@ -1537,9 +1536,9 @@ package body Ada.Containers.Multiway_Trees is
|
|||
end if;
|
||||
|
||||
return It : constant Child_Iterator :=
|
||||
(Limited_Controlled with
|
||||
Container => C,
|
||||
Subtree => Parent.Node)
|
||||
(Limited_Controlled with
|
||||
Container => C,
|
||||
Subtree => Parent.Node)
|
||||
do
|
||||
B := B + 1;
|
||||
end return;
|
||||
|
|
@ -1565,9 +1564,9 @@ package body Ada.Containers.Multiway_Trees is
|
|||
B : Natural renames Position.Container.Busy;
|
||||
begin
|
||||
return It : constant Subtree_Iterator :=
|
||||
(Limited_Controlled with
|
||||
Container => Position.Container,
|
||||
Subtree => Position.Node)
|
||||
(Limited_Controlled with
|
||||
Container => Position.Container,
|
||||
Subtree => Position.Node)
|
||||
do
|
||||
B := B + 1;
|
||||
end return;
|
||||
|
|
@ -2006,10 +2005,10 @@ package body Ada.Containers.Multiway_Trees is
|
|||
(Parent : Tree_Node_Access) return Tree_Node_Access
|
||||
is
|
||||
Subtree : constant Tree_Node_Access :=
|
||||
new Tree_Node_Type'
|
||||
(Parent => Parent,
|
||||
Element => Element_Type'Input (Stream),
|
||||
others => <>);
|
||||
new Tree_Node_Type'
|
||||
(Parent => Parent,
|
||||
Element => Element_Type'Input (Stream),
|
||||
others => <>);
|
||||
|
||||
begin
|
||||
Read_Count := Read_Count + 1;
|
||||
|
|
@ -2102,8 +2101,8 @@ package body Ada.Containers.Multiway_Trees is
|
|||
L : Natural renames C.Lock;
|
||||
begin
|
||||
return R : constant Reference_Type :=
|
||||
(Element => Position.Node.Element'Access,
|
||||
Control => (Controlled with Position.Container))
|
||||
(Element => Position.Node.Element'Access,
|
||||
Control => (Controlled with Position.Container))
|
||||
do
|
||||
B := B + 1;
|
||||
L := L + 1;
|
||||
|
|
|
|||
|
|
@ -85,10 +85,10 @@ package body Ada.Containers.Vectors is
|
|||
|
||||
declare
|
||||
RE : Elements_Array renames
|
||||
Right.Elements.EA (Index_Type'First .. Right.Last);
|
||||
Right.Elements.EA (Index_Type'First .. Right.Last);
|
||||
|
||||
Elements : constant Elements_Access :=
|
||||
new Elements_Type'(Right.Last, RE);
|
||||
new Elements_Type'(Right.Last, RE);
|
||||
|
||||
begin
|
||||
return (Controlled with Elements, Right.Last, 0, 0);
|
||||
|
|
@ -101,7 +101,7 @@ package body Ada.Containers.Vectors is
|
|||
Left.Elements.EA (Index_Type'First .. Left.Last);
|
||||
|
||||
Elements : constant Elements_Access :=
|
||||
new Elements_Type'(Left.Last, LE);
|
||||
new Elements_Type'(Left.Last, LE);
|
||||
|
||||
begin
|
||||
return (Controlled with Elements, Left.Last, 0, 0);
|
||||
|
|
@ -198,13 +198,13 @@ package body Ada.Containers.Vectors is
|
|||
|
||||
declare
|
||||
LE : Elements_Array renames
|
||||
Left.Elements.EA (Index_Type'First .. Left.Last);
|
||||
Left.Elements.EA (Index_Type'First .. Left.Last);
|
||||
|
||||
RE : Elements_Array renames
|
||||
Right.Elements.EA (Index_Type'First .. Right.Last);
|
||||
Right.Elements.EA (Index_Type'First .. Right.Last);
|
||||
|
||||
Elements : constant Elements_Access :=
|
||||
new Elements_Type'(Last, LE & RE);
|
||||
new Elements_Type'(Last, LE & RE);
|
||||
|
||||
begin
|
||||
return (Controlled with Elements, Last, 0, 0);
|
||||
|
|
@ -223,9 +223,9 @@ package body Ada.Containers.Vectors is
|
|||
if Left.Is_Empty then
|
||||
declare
|
||||
Elements : constant Elements_Access :=
|
||||
new Elements_Type'
|
||||
(Last => Index_Type'First,
|
||||
EA => (others => Right));
|
||||
new Elements_Type'
|
||||
(Last => Index_Type'First,
|
||||
EA => (others => Right));
|
||||
|
||||
begin
|
||||
return (Controlled with Elements, Index_Type'First, 0, 0);
|
||||
|
|
@ -253,7 +253,7 @@ package body Ada.Containers.Vectors is
|
|||
Left.Elements.EA (Index_Type'First .. Left.Last);
|
||||
|
||||
Elements : constant Elements_Access :=
|
||||
new Elements_Type'(Last => Last, EA => LE & Right);
|
||||
new Elements_Type'(Last => Last, EA => LE & Right);
|
||||
|
||||
begin
|
||||
return (Controlled with Elements, Last, 0, 0);
|
||||
|
|
@ -272,9 +272,9 @@ package body Ada.Containers.Vectors is
|
|||
if Right.Is_Empty then
|
||||
declare
|
||||
Elements : constant Elements_Access :=
|
||||
new Elements_Type'
|
||||
(Last => Index_Type'First,
|
||||
EA => (others => Left));
|
||||
new Elements_Type'
|
||||
(Last => Index_Type'First,
|
||||
EA => (others => Left));
|
||||
|
||||
begin
|
||||
return (Controlled with Elements, Index_Type'First, 0, 0);
|
||||
|
|
@ -302,9 +302,9 @@ package body Ada.Containers.Vectors is
|
|||
Right.Elements.EA (Index_Type'First .. Right.Last);
|
||||
|
||||
Elements : constant Elements_Access :=
|
||||
new Elements_Type'
|
||||
(Last => Last,
|
||||
EA => Left & RE);
|
||||
new Elements_Type'
|
||||
(Last => Last,
|
||||
EA => Left & RE);
|
||||
|
||||
begin
|
||||
return (Controlled with Elements, Last, 0, 0);
|
||||
|
|
@ -332,9 +332,9 @@ package body Ada.Containers.Vectors is
|
|||
Last : constant Index_Type := Index_Type'First + 1;
|
||||
|
||||
Elements : constant Elements_Access :=
|
||||
new Elements_Type'
|
||||
(Last => Last,
|
||||
EA => (Left, Right));
|
||||
new Elements_Type'
|
||||
(Last => Last,
|
||||
EA => (Left, Right));
|
||||
|
||||
begin
|
||||
return (Controlled with Elements, Last, 0, 0);
|
||||
|
|
@ -519,10 +519,8 @@ package body Ada.Containers.Vectors is
|
|||
L : Natural renames C.Lock;
|
||||
begin
|
||||
return R : constant Constant_Reference_Type :=
|
||||
(Element =>
|
||||
Container.Elements.EA (Position.Index)'Access,
|
||||
Control =>
|
||||
(Controlled with Container'Unrestricted_Access))
|
||||
(Element => Container.Elements.EA (Position.Index)'Access,
|
||||
Control => (Controlled with Container'Unrestricted_Access))
|
||||
do
|
||||
B := B + 1;
|
||||
L := L + 1;
|
||||
|
|
@ -544,9 +542,8 @@ package body Ada.Containers.Vectors is
|
|||
L : Natural renames C.Lock;
|
||||
begin
|
||||
return R : constant Constant_Reference_Type :=
|
||||
(Element => Container.Elements.EA (Index)'Access,
|
||||
Control =>
|
||||
(Controlled with Container'Unrestricted_Access))
|
||||
(Element => Container.Elements.EA (Index)'Access,
|
||||
Control => (Controlled with Container'Unrestricted_Access))
|
||||
do
|
||||
B := B + 1;
|
||||
L := L + 1;
|
||||
|
|
@ -2253,9 +2250,9 @@ package body Ada.Containers.Vectors is
|
|||
-- for a reverse iterator, Container.Last is the beginning.
|
||||
|
||||
return It : constant Iterator :=
|
||||
(Limited_Controlled with
|
||||
Container => V,
|
||||
Index => No_Index)
|
||||
(Limited_Controlled with
|
||||
Container => V,
|
||||
Index => No_Index)
|
||||
do
|
||||
B := B + 1;
|
||||
end return;
|
||||
|
|
@ -2306,9 +2303,9 @@ package body Ada.Containers.Vectors is
|
|||
-- is a forward or reverse iteration.
|
||||
|
||||
return It : constant Iterator :=
|
||||
(Limited_Controlled with
|
||||
Container => V,
|
||||
Index => Start.Index)
|
||||
(Limited_Controlled with
|
||||
Container => V,
|
||||
Index => Start.Index)
|
||||
do
|
||||
B := B + 1;
|
||||
end return;
|
||||
|
|
@ -2664,9 +2661,8 @@ package body Ada.Containers.Vectors is
|
|||
L : Natural renames C.Lock;
|
||||
begin
|
||||
return R : constant Reference_Type :=
|
||||
(Element =>
|
||||
Container.Elements.EA (Position.Index)'Access,
|
||||
Control => (Controlled with Position.Container))
|
||||
(Element => Container.Elements.EA (Position.Index)'Access,
|
||||
Control => (Controlled with Position.Container))
|
||||
do
|
||||
B := B + 1;
|
||||
L := L + 1;
|
||||
|
|
@ -2688,9 +2684,8 @@ package body Ada.Containers.Vectors is
|
|||
L : Natural renames C.Lock;
|
||||
begin
|
||||
return R : constant Reference_Type :=
|
||||
(Element => Container.Elements.EA (Index)'Access,
|
||||
Control =>
|
||||
(Controlled with Container'Unrestricted_Access))
|
||||
(Element => Container.Elements.EA (Index)'Access,
|
||||
Control => (Controlled with Container'Unrestricted_Access))
|
||||
do
|
||||
B := B + 1;
|
||||
L := L + 1;
|
||||
|
|
@ -3150,7 +3145,7 @@ package body Ada.Containers.Vectors is
|
|||
Index : Index_Type := Index_Type'Last) return Extended_Index
|
||||
is
|
||||
Last : constant Index_Type'Base :=
|
||||
Index_Type'Min (Container.Last, Index);
|
||||
Index_Type'Min (Container.Last, Index);
|
||||
|
||||
begin
|
||||
for Indx in reverse Index_Type'First .. Last loop
|
||||
|
|
|
|||
|
|
@ -360,8 +360,8 @@ package body Ada.Containers.Ordered_Maps is
|
|||
L : Natural renames T.Lock;
|
||||
begin
|
||||
return R : constant Constant_Reference_Type :=
|
||||
(Element => Position.Node.Element'Access,
|
||||
Control => (Controlled with Position.Container))
|
||||
(Element => Position.Node.Element'Access,
|
||||
Control => (Controlled with Position.Container))
|
||||
do
|
||||
B := B + 1;
|
||||
L := L + 1;
|
||||
|
|
@ -386,9 +386,8 @@ package body Ada.Containers.Ordered_Maps is
|
|||
L : Natural renames T.Lock;
|
||||
begin
|
||||
return R : constant Constant_Reference_Type :=
|
||||
(Element => Node.Element'Access,
|
||||
Control =>
|
||||
(Controlled with Container'Unrestricted_Access))
|
||||
(Element => Node.Element'Access,
|
||||
Control => (Controlled with Container'Unrestricted_Access))
|
||||
do
|
||||
B := B + 1;
|
||||
L := L + 1;
|
||||
|
|
@ -422,12 +421,12 @@ package body Ada.Containers.Ordered_Maps is
|
|||
|
||||
function Copy_Node (Source : Node_Access) return Node_Access is
|
||||
Target : constant Node_Access :=
|
||||
new Node_Type'(Color => Source.Color,
|
||||
Key => Source.Key,
|
||||
Element => Source.Element,
|
||||
Parent => null,
|
||||
Left => null,
|
||||
Right => null);
|
||||
new Node_Type'(Color => Source.Color,
|
||||
Key => Source.Key,
|
||||
Element => Source.Element,
|
||||
Parent => null,
|
||||
Left => null,
|
||||
Right => null);
|
||||
begin
|
||||
return Target;
|
||||
end Copy_Node;
|
||||
|
|
@ -946,9 +945,9 @@ package body Ada.Containers.Ordered_Maps is
|
|||
-- for a reverse iterator, Container.Last is the beginning.
|
||||
|
||||
return It : constant Iterator :=
|
||||
(Limited_Controlled with
|
||||
Container => Container'Unrestricted_Access,
|
||||
Node => null)
|
||||
(Limited_Controlled with
|
||||
Container => Container'Unrestricted_Access,
|
||||
Node => null)
|
||||
do
|
||||
B := B + 1;
|
||||
end return;
|
||||
|
|
@ -994,9 +993,9 @@ package body Ada.Containers.Ordered_Maps is
|
|||
-- is a forward or reverse iteration.
|
||||
|
||||
return It : constant Iterator :=
|
||||
(Limited_Controlled with
|
||||
Container => Container'Unrestricted_Access,
|
||||
Node => Start.Node)
|
||||
(Limited_Controlled with
|
||||
Container => Container'Unrestricted_Access,
|
||||
Node => Start.Node)
|
||||
do
|
||||
B := B + 1;
|
||||
end return;
|
||||
|
|
@ -1132,8 +1131,7 @@ package body Ada.Containers.Ordered_Maps is
|
|||
"Position cursor of Next is bad");
|
||||
|
||||
declare
|
||||
Node : constant Node_Access :=
|
||||
Tree_Operations.Next (Position.Node);
|
||||
Node : constant Node_Access := Tree_Operations.Next (Position.Node);
|
||||
|
||||
begin
|
||||
if Node = null then
|
||||
|
|
@ -1190,7 +1188,7 @@ package body Ada.Containers.Ordered_Maps is
|
|||
|
||||
declare
|
||||
Node : constant Node_Access :=
|
||||
Tree_Operations.Previous (Position.Node);
|
||||
Tree_Operations.Previous (Position.Node);
|
||||
|
||||
begin
|
||||
if Node = null then
|
||||
|
|
@ -1355,8 +1353,8 @@ package body Ada.Containers.Ordered_Maps is
|
|||
L : Natural renames T.Lock;
|
||||
begin
|
||||
return R : constant Reference_Type :=
|
||||
(Element => Position.Node.Element'Access,
|
||||
Control => (Controlled with Position.Container))
|
||||
(Element => Position.Node.Element'Access,
|
||||
Control => (Controlled with Position.Container))
|
||||
do
|
||||
B := B + 1;
|
||||
L := L + 1;
|
||||
|
|
@ -1381,9 +1379,8 @@ package body Ada.Containers.Ordered_Maps is
|
|||
L : Natural renames T.Lock;
|
||||
begin
|
||||
return R : constant Reference_Type :=
|
||||
(Element => Node.Element'Access,
|
||||
Control =>
|
||||
(Controlled with Container'Unrestricted_Access))
|
||||
(Element => Node.Element'Access,
|
||||
Control => (Controlled with Container'Unrestricted_Access))
|
||||
do
|
||||
B := B + 1;
|
||||
L := L + 1;
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
-- --
|
||||
-- B o d y --
|
||||
-- --
|
||||
-- Copyright (C) 2004-2011, Free Software Foundation, Inc. --
|
||||
-- Copyright (C) 2004-2012, 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- --
|
||||
|
|
@ -308,7 +308,7 @@ package body Ada.Containers.Ordered_Multisets is
|
|||
|
||||
function Ceiling (Container : Set; Item : Element_Type) return Cursor is
|
||||
Node : constant Node_Access :=
|
||||
Element_Keys.Ceiling (Container.Tree, Item);
|
||||
Element_Keys.Ceiling (Container.Tree, Item);
|
||||
|
||||
begin
|
||||
if Node = null then
|
||||
|
|
@ -365,11 +365,11 @@ package body Ada.Containers.Ordered_Multisets is
|
|||
|
||||
function Copy_Node (Source : Node_Access) return Node_Access is
|
||||
Target : constant Node_Access :=
|
||||
new Node_Type'(Parent => null,
|
||||
Left => null,
|
||||
Right => null,
|
||||
Color => Source.Color,
|
||||
Element => Source.Element);
|
||||
new Node_Type'(Parent => null,
|
||||
Left => null,
|
||||
Right => null,
|
||||
Color => Source.Color,
|
||||
Element => Source.Element);
|
||||
begin
|
||||
return Target;
|
||||
end Copy_Node;
|
||||
|
|
@ -464,7 +464,7 @@ package body Ada.Containers.Ordered_Multisets is
|
|||
|
||||
function Difference (Left, Right : Set) return Set is
|
||||
Tree : constant Tree_Type :=
|
||||
Set_Ops.Difference (Left.Tree, Right.Tree);
|
||||
Set_Ops.Difference (Left.Tree, Right.Tree);
|
||||
begin
|
||||
return Set'(Controlled with Tree);
|
||||
end Difference;
|
||||
|
|
@ -568,7 +568,7 @@ package body Ada.Containers.Ordered_Multisets is
|
|||
|
||||
function Find (Container : Set; Item : Element_Type) return Cursor is
|
||||
Node : constant Node_Access :=
|
||||
Element_Keys.Find (Container.Tree, Item);
|
||||
Element_Keys.Find (Container.Tree, Item);
|
||||
|
||||
begin
|
||||
if Node = null then
|
||||
|
|
@ -632,7 +632,7 @@ package body Ada.Containers.Ordered_Multisets is
|
|||
|
||||
function Floor (Container : Set; Item : Element_Type) return Cursor is
|
||||
Node : constant Node_Access :=
|
||||
Element_Keys.Floor (Container.Tree, Item);
|
||||
Element_Keys.Floor (Container.Tree, Item);
|
||||
|
||||
begin
|
||||
if Node = null then
|
||||
|
|
@ -697,7 +697,7 @@ package body Ada.Containers.Ordered_Multisets is
|
|||
|
||||
function Ceiling (Container : Set; Key : Key_Type) return Cursor is
|
||||
Node : constant Node_Access :=
|
||||
Key_Keys.Ceiling (Container.Tree, Key);
|
||||
Key_Keys.Ceiling (Container.Tree, Key);
|
||||
|
||||
begin
|
||||
if Node = null then
|
||||
|
|
@ -746,8 +746,7 @@ package body Ada.Containers.Ordered_Multisets is
|
|||
-------------
|
||||
|
||||
function Element (Container : Set; Key : Key_Type) return Element_Type is
|
||||
Node : constant Node_Access :=
|
||||
Key_Keys.Find (Container.Tree, Key);
|
||||
Node : constant Node_Access := Key_Keys.Find (Container.Tree, Key);
|
||||
begin
|
||||
if Node = null then
|
||||
raise Constraint_Error with "key not in set";
|
||||
|
|
@ -795,8 +794,7 @@ package body Ada.Containers.Ordered_Multisets is
|
|||
----------
|
||||
|
||||
function Find (Container : Set; Key : Key_Type) return Cursor is
|
||||
Node : constant Node_Access :=
|
||||
Key_Keys.Find (Container.Tree, Key);
|
||||
Node : constant Node_Access := Key_Keys.Find (Container.Tree, Key);
|
||||
|
||||
begin
|
||||
if Node = null then
|
||||
|
|
@ -811,8 +809,7 @@ package body Ada.Containers.Ordered_Multisets is
|
|||
-----------
|
||||
|
||||
function Floor (Container : Set; Key : Key_Type) return Cursor is
|
||||
Node : constant Node_Access :=
|
||||
Key_Keys.Floor (Container.Tree, Key);
|
||||
Node : constant Node_Access := Key_Keys.Floor (Container.Tree, Key);
|
||||
|
||||
begin
|
||||
if Node = null then
|
||||
|
|
@ -1099,11 +1096,11 @@ package body Ada.Containers.Ordered_Multisets is
|
|||
|
||||
function New_Node return Node_Access is
|
||||
Node : constant Node_Access :=
|
||||
new Node_Type'(Parent => null,
|
||||
Left => null,
|
||||
Right => null,
|
||||
Color => Red_Black_Trees.Red,
|
||||
Element => New_Item);
|
||||
new Node_Type'(Parent => null,
|
||||
Left => null,
|
||||
Right => null,
|
||||
Color => Red_Black_Trees.Red,
|
||||
Element => New_Item);
|
||||
begin
|
||||
return Node;
|
||||
end New_Node;
|
||||
|
|
@ -1144,11 +1141,11 @@ package body Ada.Containers.Ordered_Multisets is
|
|||
|
||||
function New_Node return Node_Access is
|
||||
Node : constant Node_Access :=
|
||||
new Node_Type'(Parent => null,
|
||||
Left => null,
|
||||
Right => null,
|
||||
Color => Red,
|
||||
Element => Src_Node.Element);
|
||||
new Node_Type'(Parent => null,
|
||||
Left => null,
|
||||
Right => null,
|
||||
Color => Red,
|
||||
Element => Src_Node.Element);
|
||||
begin
|
||||
return Node;
|
||||
end New_Node;
|
||||
|
|
@ -1174,7 +1171,7 @@ package body Ada.Containers.Ordered_Multisets is
|
|||
|
||||
function Intersection (Left, Right : Set) return Set is
|
||||
Tree : constant Tree_Type :=
|
||||
Set_Ops.Intersection (Left.Tree, Right.Tree);
|
||||
Set_Ops.Intersection (Left.Tree, Right.Tree);
|
||||
begin
|
||||
return Set'(Controlled with Tree);
|
||||
end Intersection;
|
||||
|
|
@ -1385,7 +1382,7 @@ package body Ada.Containers.Ordered_Multisets is
|
|||
-- a forward or reverse iteration.
|
||||
|
||||
return It : constant Iterator :=
|
||||
(Limited_Controlled with S, Start.Node)
|
||||
(Limited_Controlled with S, Start.Node)
|
||||
do
|
||||
B := B + 1;
|
||||
end return;
|
||||
|
|
@ -1489,8 +1486,7 @@ package body Ada.Containers.Ordered_Multisets is
|
|||
"bad cursor in Next");
|
||||
|
||||
declare
|
||||
Node : constant Node_Access :=
|
||||
Tree_Operations.Next (Position.Node);
|
||||
Node : constant Node_Access := Tree_Operations.Next (Position.Node);
|
||||
begin
|
||||
if Node = null then
|
||||
return No_Element;
|
||||
|
|
@ -1553,7 +1549,7 @@ package body Ada.Containers.Ordered_Multisets is
|
|||
|
||||
declare
|
||||
Node : constant Node_Access :=
|
||||
Tree_Operations.Previous (Position.Node);
|
||||
Tree_Operations.Previous (Position.Node);
|
||||
begin
|
||||
return (if Node = null then No_Element
|
||||
else Cursor'(Position.Container, Node));
|
||||
|
|
@ -1884,7 +1880,7 @@ package body Ada.Containers.Ordered_Multisets is
|
|||
|
||||
function Symmetric_Difference (Left, Right : Set) return Set is
|
||||
Tree : constant Tree_Type :=
|
||||
Set_Ops.Symmetric_Difference (Left.Tree, Right.Tree);
|
||||
Set_Ops.Symmetric_Difference (Left.Tree, Right.Tree);
|
||||
begin
|
||||
return Set'(Controlled with Tree);
|
||||
end Symmetric_Difference;
|
||||
|
|
@ -1912,8 +1908,7 @@ package body Ada.Containers.Ordered_Multisets is
|
|||
end Union;
|
||||
|
||||
function Union (Left, Right : Set) return Set is
|
||||
Tree : constant Tree_Type :=
|
||||
Set_Ops.Union (Left.Tree, Right.Tree);
|
||||
Tree : constant Tree_Type := Set_Ops.Union (Left.Tree, Right.Tree);
|
||||
begin
|
||||
return Set'(Controlled with Tree);
|
||||
end Union;
|
||||
|
|
|
|||
|
|
@ -319,7 +319,7 @@ package body Ada.Containers.Ordered_Sets is
|
|||
|
||||
function Ceiling (Container : Set; Item : Element_Type) return Cursor is
|
||||
Node : constant Node_Access :=
|
||||
Element_Keys.Ceiling (Container.Tree, Item);
|
||||
Element_Keys.Ceiling (Container.Tree, Item);
|
||||
begin
|
||||
return (if Node = null then No_Element
|
||||
else Cursor'(Container'Unrestricted_Access, Node));
|
||||
|
|
@ -373,9 +373,8 @@ package body Ada.Containers.Ordered_Sets is
|
|||
L : Natural renames Tree.Lock;
|
||||
begin
|
||||
return R : constant Constant_Reference_Type :=
|
||||
(Element => Position.Node.Element'Access,
|
||||
Control =>
|
||||
(Controlled with Container'Unrestricted_Access))
|
||||
(Element => Position.Node.Element'Access,
|
||||
Control => (Controlled with Container'Unrestricted_Access))
|
||||
do
|
||||
B := B + 1;
|
||||
L := L + 1;
|
||||
|
|
@ -412,11 +411,11 @@ package body Ada.Containers.Ordered_Sets is
|
|||
|
||||
function Copy_Node (Source : Node_Access) return Node_Access is
|
||||
Target : constant Node_Access :=
|
||||
new Node_Type'(Parent => null,
|
||||
Left => null,
|
||||
Right => null,
|
||||
Color => Source.Color,
|
||||
Element => Source.Element);
|
||||
new Node_Type'(Parent => null,
|
||||
Left => null,
|
||||
Right => null,
|
||||
Color => Source.Color,
|
||||
Element => Source.Element);
|
||||
begin
|
||||
return Target;
|
||||
end Copy_Node;
|
||||
|
|
@ -493,8 +492,7 @@ package body Ada.Containers.Ordered_Sets is
|
|||
end Difference;
|
||||
|
||||
function Difference (Left, Right : Set) return Set is
|
||||
Tree : constant Tree_Type :=
|
||||
Set_Ops.Difference (Left.Tree, Right.Tree);
|
||||
Tree : constant Tree_Type := Set_Ops.Difference (Left.Tree, Right.Tree);
|
||||
begin
|
||||
return Set'(Controlled with Tree);
|
||||
end Difference;
|
||||
|
|
@ -602,8 +600,7 @@ package body Ada.Containers.Ordered_Sets is
|
|||
----------
|
||||
|
||||
function Find (Container : Set; Item : Element_Type) return Cursor is
|
||||
Node : constant Node_Access :=
|
||||
Element_Keys.Find (Container.Tree, Item);
|
||||
Node : constant Node_Access := Element_Keys.Find (Container.Tree, Item);
|
||||
begin
|
||||
return (if Node = null then No_Element
|
||||
else Cursor'(Container'Unrestricted_Access, Node));
|
||||
|
|
@ -660,8 +657,7 @@ package body Ada.Containers.Ordered_Sets is
|
|||
-----------
|
||||
|
||||
function Floor (Container : Set; Item : Element_Type) return Cursor is
|
||||
Node : constant Node_Access :=
|
||||
Element_Keys.Floor (Container.Tree, Item);
|
||||
Node : constant Node_Access := Element_Keys.Floor (Container.Tree, Item);
|
||||
begin
|
||||
return (if Node = null then No_Element
|
||||
else Cursor'(Container'Unrestricted_Access, Node));
|
||||
|
|
@ -719,8 +715,7 @@ package body Ada.Containers.Ordered_Sets is
|
|||
-------------
|
||||
|
||||
function Ceiling (Container : Set; Key : Key_Type) return Cursor is
|
||||
Node : constant Node_Access :=
|
||||
Key_Keys.Ceiling (Container.Tree, Key);
|
||||
Node : constant Node_Access := Key_Keys.Ceiling (Container.Tree, Key);
|
||||
begin
|
||||
return (if Node = null then No_Element
|
||||
else Cursor'(Container'Unrestricted_Access, Node));
|
||||
|
|
@ -734,8 +729,7 @@ package body Ada.Containers.Ordered_Sets is
|
|||
(Container : aliased Set;
|
||||
Key : Key_Type) return Constant_Reference_Type
|
||||
is
|
||||
Node : constant Node_Access :=
|
||||
Key_Keys.Find (Container.Tree, Key);
|
||||
Node : constant Node_Access := Key_Keys.Find (Container.Tree, Key);
|
||||
|
||||
begin
|
||||
if Node = null then
|
||||
|
|
@ -748,9 +742,8 @@ package body Ada.Containers.Ordered_Sets is
|
|||
L : Natural renames Tree.Lock;
|
||||
begin
|
||||
return R : constant Constant_Reference_Type :=
|
||||
(Element => Node.Element'Access,
|
||||
Control =>
|
||||
(Controlled with Container'Unrestricted_Access))
|
||||
(Element => Node.Element'Access,
|
||||
Control => (Controlled with Container'Unrestricted_Access))
|
||||
do
|
||||
B := B + 1;
|
||||
L := L + 1;
|
||||
|
|
@ -788,8 +781,7 @@ package body Ada.Containers.Ordered_Sets is
|
|||
-------------
|
||||
|
||||
function Element (Container : Set; Key : Key_Type) return Element_Type is
|
||||
Node : constant Node_Access :=
|
||||
Key_Keys.Find (Container.Tree, Key);
|
||||
Node : constant Node_Access := Key_Keys.Find (Container.Tree, Key);
|
||||
|
||||
begin
|
||||
if Node = null then
|
||||
|
|
@ -929,8 +921,7 @@ package body Ada.Containers.Ordered_Sets is
|
|||
(Container : aliased in out Set;
|
||||
Key : Key_Type) return Reference_Type
|
||||
is
|
||||
Node : constant Node_Access :=
|
||||
Key_Keys.Find (Container.Tree, Key);
|
||||
Node : constant Node_Access := Key_Keys.Find (Container.Tree, Key);
|
||||
|
||||
begin
|
||||
if Node = null then
|
||||
|
|
@ -1215,7 +1206,7 @@ package body Ada.Containers.Ordered_Sets is
|
|||
|
||||
function Intersection (Left, Right : Set) return Set is
|
||||
Tree : constant Tree_Type :=
|
||||
Set_Ops.Intersection (Left.Tree, Right.Tree);
|
||||
Set_Ops.Intersection (Left.Tree, Right.Tree);
|
||||
begin
|
||||
return Set'(Controlled with Tree);
|
||||
end Intersection;
|
||||
|
|
@ -1343,9 +1334,9 @@ package body Ada.Containers.Ordered_Sets is
|
|||
B := B + 1;
|
||||
|
||||
return It : constant Iterator :=
|
||||
Iterator'(Limited_Controlled with
|
||||
Container => Container'Unrestricted_Access,
|
||||
Node => null);
|
||||
Iterator'(Limited_Controlled with
|
||||
Container => Container'Unrestricted_Access,
|
||||
Node => null);
|
||||
end Iterate;
|
||||
|
||||
function Iterate (Container : Set; Start : Cursor)
|
||||
|
|
@ -1390,9 +1381,9 @@ package body Ada.Containers.Ordered_Sets is
|
|||
B := B + 1;
|
||||
|
||||
return It : constant Iterator :=
|
||||
Iterator'(Limited_Controlled with
|
||||
Container => Container'Unrestricted_Access,
|
||||
Node => Start.Node);
|
||||
Iterator'(Limited_Controlled with
|
||||
Container => Container'Unrestricted_Access,
|
||||
Node => Start.Node);
|
||||
end Iterate;
|
||||
|
||||
----------
|
||||
|
|
@ -1485,7 +1476,7 @@ package body Ada.Containers.Ordered_Sets is
|
|||
|
||||
declare
|
||||
Node : constant Node_Access :=
|
||||
Tree_Operations.Next (Position.Node);
|
||||
Tree_Operations.Next (Position.Node);
|
||||
begin
|
||||
return (if Node = null then No_Element
|
||||
else Cursor'(Position.Container, Node));
|
||||
|
|
@ -1544,7 +1535,7 @@ package body Ada.Containers.Ordered_Sets is
|
|||
|
||||
declare
|
||||
Node : constant Node_Access :=
|
||||
Tree_Operations.Previous (Position.Node);
|
||||
Tree_Operations.Previous (Position.Node);
|
||||
begin
|
||||
return (if Node = null then No_Element
|
||||
else Cursor'(Position.Container, Node));
|
||||
|
|
@ -1670,7 +1661,7 @@ package body Ada.Containers.Ordered_Sets is
|
|||
|
||||
procedure Replace (Container : in out Set; New_Item : Element_Type) is
|
||||
Node : constant Node_Access :=
|
||||
Element_Keys.Find (Container.Tree, New_Item);
|
||||
Element_Keys.Find (Container.Tree, New_Item);
|
||||
|
||||
begin
|
||||
if Node = null then
|
||||
|
|
@ -1899,7 +1890,7 @@ package body Ada.Containers.Ordered_Sets is
|
|||
|
||||
function Symmetric_Difference (Left, Right : Set) return Set is
|
||||
Tree : constant Tree_Type :=
|
||||
Set_Ops.Symmetric_Difference (Left.Tree, Right.Tree);
|
||||
Set_Ops.Symmetric_Difference (Left.Tree, Right.Tree);
|
||||
begin
|
||||
return Set'(Controlled with Tree);
|
||||
end Symmetric_Difference;
|
||||
|
|
@ -1929,7 +1920,7 @@ package body Ada.Containers.Ordered_Sets is
|
|||
|
||||
function Union (Left, Right : Set) return Set is
|
||||
Tree : constant Tree_Type :=
|
||||
Set_Ops.Union (Left.Tree, Right.Tree);
|
||||
Set_Ops.Union (Left.Tree, Right.Tree);
|
||||
begin
|
||||
return Set'(Controlled with Tree);
|
||||
end Union;
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
-- --
|
||||
-- B o d y --
|
||||
-- --
|
||||
-- Copyright (C) 2004-2009, Free Software Foundation, Inc. --
|
||||
-- Copyright (C) 2004-2012, 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- --
|
||||
|
|
@ -562,7 +562,7 @@ package body Ada.Containers.Restricted_Doubly_Linked_Lists is
|
|||
|
||||
procedure Sort (Front, Back : Count_Type) is
|
||||
Pivot : constant Count_Type :=
|
||||
(if Front = 0 then Container.First else N (Front).Next);
|
||||
(if Front = 0 then Container.First else N (Front).Next);
|
||||
begin
|
||||
if Pivot /= Back then
|
||||
Partition (Pivot, Back);
|
||||
|
|
|
|||
|
|
@ -216,8 +216,7 @@ package body Ada.Directories is
|
|||
|
||||
Norm : constant String := Normalize_Pathname (Name);
|
||||
Last_DS : constant Natural :=
|
||||
Strings.Fixed.Index
|
||||
(Name, Dir_Seps, Going => Strings.Backward);
|
||||
Strings.Fixed.Index (Name, Dir_Seps, Going => Strings.Backward);
|
||||
|
||||
begin
|
||||
if Last_DS = 0 then
|
||||
|
|
@ -755,7 +754,7 @@ package body Ada.Directories is
|
|||
Target => Path_String_Access);
|
||||
|
||||
Path_Access : constant Path_String_Access :=
|
||||
Address_To_Access (Filename_Addr);
|
||||
Address_To_Access (Filename_Addr);
|
||||
|
||||
begin
|
||||
Last := Filename_Len;
|
||||
|
|
@ -767,9 +766,7 @@ package body Ada.Directories is
|
|||
if Match (Name (1 .. Last), Search.Value.Pattern) then
|
||||
declare
|
||||
Full_Name : constant String :=
|
||||
Compose
|
||||
(To_String
|
||||
(Search.Value.Name), Name (1 .. Last));
|
||||
Compose (To_String (Search.Value.Name), Name (1 .. Last));
|
||||
Found : Boolean := False;
|
||||
|
||||
begin
|
||||
|
|
@ -1159,8 +1156,7 @@ package body Ada.Directories is
|
|||
|
||||
function Simple_Name_Internal (Path : String) return String is
|
||||
Cut_Start : Natural :=
|
||||
Strings.Fixed.Index
|
||||
(Path, Dir_Seps, Going => Strings.Backward);
|
||||
Strings.Fixed.Index (Path, Dir_Seps, Going => Strings.Backward);
|
||||
Cut_End : Natural;
|
||||
|
||||
begin
|
||||
|
|
@ -1176,7 +1172,7 @@ package body Ada.Directories is
|
|||
BN : constant String := Path (Cut_Start .. Cut_End);
|
||||
|
||||
Has_Drive_Letter : constant Boolean :=
|
||||
OS_Lib.Path_Separator /= ':';
|
||||
OS_Lib.Path_Separator /= ':';
|
||||
-- If Path separator is not ':' then we are on a DOS based OS
|
||||
-- where this character is used as a drive letter separator.
|
||||
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
-- --
|
||||
-- B o d y --
|
||||
-- --
|
||||
-- Copyright (C) 1992-2009, Free Software Foundation, Inc. --
|
||||
-- Copyright (C) 1992-2012, 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- --
|
||||
|
|
@ -48,7 +48,7 @@ use type System.Direct_IO.Count;
|
|||
package body Ada.Direct_IO is
|
||||
|
||||
Zeroes : constant System.Storage_Elements.Storage_Array :=
|
||||
(1 .. System.Storage_Elements.Storage_Offset (Bytes) => 0);
|
||||
(1 .. System.Storage_Elements.Storage_Offset (Bytes) => 0);
|
||||
-- Buffer used to fill out partial records
|
||||
|
||||
package FCB renames System.File_Control_Block;
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
-- B o d y --
|
||||
-- (Windows Version) --
|
||||
-- --
|
||||
-- Copyright (C) 2004-2009, Free Software Foundation, Inc. --
|
||||
-- Copyright (C) 2004-2012, 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- --
|
||||
|
|
@ -37,11 +37,11 @@ with Ada.Characters.Latin_1; use Ada.Characters.Latin_1;
|
|||
package body Ada.Directories.Validity is
|
||||
|
||||
Invalid_Character : constant array (Character) of Boolean :=
|
||||
(NUL .. US | '\' => True,
|
||||
'/' | ':' | '*' | '?' => True,
|
||||
'"' | '<' | '>' | '|' => True,
|
||||
DEL .. NBSP => True,
|
||||
others => False);
|
||||
(NUL .. US | '\' => True,
|
||||
'/' | ':' | '*' | '?' => True,
|
||||
'"' | '<' | '>' | '|' => True,
|
||||
DEL .. NBSP => True,
|
||||
others => False);
|
||||
|
||||
---------------------------------
|
||||
-- Is_Path_Name_Case_Sensitive --
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
-- B o d y --
|
||||
-- (VMS Version) --
|
||||
-- --
|
||||
-- Copyright (C) 2004-2009, Free Software Foundation, Inc. --
|
||||
-- Copyright (C) 2004-2012, 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- --
|
||||
|
|
@ -38,11 +38,11 @@ package body Ada.Directories.Validity is
|
|||
Max_Path_Length : constant := 1_024;
|
||||
|
||||
Invalid_Character : constant array (Character) of Boolean :=
|
||||
('a' .. 'z' => False,
|
||||
'A' .. 'Z' => False,
|
||||
'0' .. '9' => False,
|
||||
'_' | '$' | '-' | '.' => False,
|
||||
others => True);
|
||||
('a' .. 'z' => False,
|
||||
'A' .. 'Z' => False,
|
||||
'0' .. '9' => False,
|
||||
'_' | '$' | '-' | '.' => False,
|
||||
others => True);
|
||||
|
||||
---------------------------------
|
||||
-- Is_Path_Name_Case_Sensitive --
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
-- --
|
||||
-- B o d y --
|
||||
-- --
|
||||
-- Copyright (C) 1992-2009, Free Software Foundation, Inc. --
|
||||
-- Copyright (C) 1992-2012, Free Software Foundation, Inc. --
|
||||
-- --
|
||||
-- GNARL 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- --
|
||||
|
|
@ -82,7 +82,7 @@ package body Ada.Dynamic_Priorities is
|
|||
procedure Set_Priority
|
||||
(Priority : System.Any_Priority;
|
||||
T : Ada.Task_Identification.Task_Id :=
|
||||
Ada.Task_Identification.Current_Task)
|
||||
Ada.Task_Identification.Current_Task)
|
||||
is
|
||||
Target : constant Task_Id := Convert_Ids (T);
|
||||
Error_Message : constant String := "Trying to set the priority of a ";
|
||||
|
|
|
|||
|
|
@ -1009,10 +1009,10 @@ package body Ada.Exceptions is
|
|||
Prefix : constant String := "adjust/finalize raised ";
|
||||
Orig_Msg : constant String := Exception_Message (X);
|
||||
Orig_Prefix_Length : constant Natural :=
|
||||
Integer'Min (Prefix'Length, Orig_Msg'Length);
|
||||
Integer'Min (Prefix'Length, Orig_Msg'Length);
|
||||
Orig_Prefix : String renames Orig_Msg
|
||||
(Orig_Msg'First ..
|
||||
Orig_Msg'First + Orig_Prefix_Length - 1);
|
||||
(Orig_Msg'First ..
|
||||
Orig_Msg'First + Orig_Prefix_Length - 1);
|
||||
begin
|
||||
-- Message already has the proper prefix, just re-raise
|
||||
|
||||
|
|
@ -1446,9 +1446,9 @@ package body Ada.Exceptions is
|
|||
(File : System.Address; Line, Column, Index, First, Last : Integer)
|
||||
is
|
||||
Msg : constant String :=
|
||||
Rmsg_05 (Rmsg_05'First .. Rmsg_05'Last - 1) & ASCII.LF &
|
||||
"index " & Image (Index) & " not in " & Image (First) &
|
||||
".." & Image (Last) & ASCII.NUL;
|
||||
Rmsg_05 (Rmsg_05'First .. Rmsg_05'Last - 1) & ASCII.LF &
|
||||
"index " & Image (Index) & " not in " & Image (First) &
|
||||
".." & Image (Last) & ASCII.NUL;
|
||||
begin
|
||||
Raise_Constraint_Error_Msg (File, Line, Column, Msg'Address);
|
||||
end Rcheck_CE_Index_Check_Ext;
|
||||
|
|
@ -1457,9 +1457,9 @@ package body Ada.Exceptions is
|
|||
(File : System.Address; Line, Column, Index, First, Last : Integer)
|
||||
is
|
||||
Msg : constant String :=
|
||||
Rmsg_06 (Rmsg_06'First .. Rmsg_06'Last - 1) & ASCII.LF &
|
||||
"value " & Image (Index) & " not in " & Image (First) &
|
||||
".." & Image (Last) & ASCII.NUL;
|
||||
Rmsg_06 (Rmsg_06'First .. Rmsg_06'Last - 1) & ASCII.LF &
|
||||
"value " & Image (Index) & " not in " & Image (First) &
|
||||
".." & Image (Last) & ASCII.NUL;
|
||||
begin
|
||||
Raise_Constraint_Error_Msg (File, Line, Column, Msg'Address);
|
||||
end Rcheck_CE_Invalid_Data_Ext;
|
||||
|
|
@ -1468,9 +1468,9 @@ package body Ada.Exceptions is
|
|||
(File : System.Address; Line, Column, Index, First, Last : Integer)
|
||||
is
|
||||
Msg : constant String :=
|
||||
Rmsg_12 (Rmsg_12'First .. Rmsg_12'Last - 1) & ASCII.LF &
|
||||
"value " & Image (Index) & " not in " & Image (First) &
|
||||
".." & Image (Last) & ASCII.NUL;
|
||||
Rmsg_12 (Rmsg_12'First .. Rmsg_12'Last - 1) & ASCII.LF &
|
||||
"value " & Image (Index) & " not in " & Image (First) &
|
||||
".." & Image (Last) & ASCII.NUL;
|
||||
begin
|
||||
Raise_Constraint_Error_Msg (File, Line, Column, Msg'Address);
|
||||
end Rcheck_CE_Range_Check_Ext;
|
||||
|
|
|
|||
|
|
@ -1026,10 +1026,9 @@ package body Ada.Exceptions is
|
|||
Prefix : constant String := "adjust/finalize raised ";
|
||||
Orig_Msg : constant String := Exception_Message (X);
|
||||
Orig_Prefix_Length : constant Natural :=
|
||||
Integer'Min (Prefix'Length, Orig_Msg'Length);
|
||||
Integer'Min (Prefix'Length, Orig_Msg'Length);
|
||||
Orig_Prefix : String renames Orig_Msg
|
||||
(Orig_Msg'First ..
|
||||
Orig_Msg'First + Orig_Prefix_Length - 1);
|
||||
(Orig_Msg'First .. Orig_Msg'First + Orig_Prefix_Length - 1);
|
||||
begin
|
||||
-- Message already has proper prefix, just re-reraise
|
||||
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
-- --
|
||||
-- B o d y --
|
||||
-- --
|
||||
-- Copyright (C) 2007-2011, Free Software Foundation, Inc. --
|
||||
-- Copyright (C) 2007-2012, 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- --
|
||||
|
|
@ -91,7 +91,7 @@ package body Ada.Execution_Time is
|
|||
|
||||
function Clock
|
||||
(T : Ada.Task_Identification.Task_Id :=
|
||||
Ada.Task_Identification.Current_Task) return CPU_Time
|
||||
Ada.Task_Identification.Current_Task) return CPU_Time
|
||||
is
|
||||
Hundreds_Nano_In_Sec : constant Long_Long_Float := 1.0E7;
|
||||
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
-- --
|
||||
-- B o d y --
|
||||
-- --
|
||||
-- Copyright (C) 2007-2011, Free Software Foundation, Inc. --
|
||||
-- Copyright (C) 2007-2012, 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- --
|
||||
|
|
@ -95,8 +95,7 @@ package body Ada.Execution_Time is
|
|||
|
||||
function Clock
|
||||
(T : Ada.Task_Identification.Task_Id :=
|
||||
Ada.Task_Identification.Current_Task)
|
||||
return CPU_Time
|
||||
Ada.Task_Identification.Current_Task) return CPU_Time
|
||||
is
|
||||
TS : aliased timespec;
|
||||
Result : Interfaces.C.int;
|
||||
|
|
|
|||
|
|
@ -220,7 +220,7 @@ package body Exception_Data is
|
|||
N : Integer_Address;
|
||||
|
||||
H : constant array (Integer range 0 .. 15) of Character :=
|
||||
"0123456789abcdef";
|
||||
"0123456789abcdef";
|
||||
begin
|
||||
P := S'Last;
|
||||
N := To_Integer (A);
|
||||
|
|
@ -659,7 +659,7 @@ package body Exception_Data is
|
|||
Message : String)
|
||||
is
|
||||
Len : constant Natural :=
|
||||
Natural'Min (Message'Length, Exception_Msg_Max_Length);
|
||||
Natural'Min (Message'Length, Exception_Msg_Max_Length);
|
||||
First : constant Integer := Message'First;
|
||||
begin
|
||||
Excep.Exception_Raised := False;
|
||||
|
|
@ -689,7 +689,7 @@ package body Exception_Data is
|
|||
-- call become inoffensive.
|
||||
|
||||
Wrapper : constant Traceback_Decorator_Wrapper_Call :=
|
||||
Traceback_Decorator_Wrapper;
|
||||
Traceback_Decorator_Wrapper;
|
||||
|
||||
begin
|
||||
if Wrapper = null then
|
||||
|
|
|
|||
|
|
@ -356,7 +356,7 @@ package body Exception_Propagation is
|
|||
|
||||
declare
|
||||
GNAT_Occurrence : constant GNAT_GCC_Exception_Access :=
|
||||
To_GNAT_GCC_Exception (GCC_Exception);
|
||||
To_GNAT_GCC_Exception (GCC_Exception);
|
||||
begin
|
||||
Excep.all := GNAT_Occurrence.Occurrence;
|
||||
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
-- --
|
||||
-- B o d y --
|
||||
-- --
|
||||
-- Copyright (C) 2006-2011, Free Software Foundation, Inc. --
|
||||
-- Copyright (C) 2006-2012, 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- --
|
||||
|
|
@ -1073,7 +1073,7 @@ package body Ada.Numerics.Generic_Complex_Arrays is
|
|||
for K in 1 .. N loop
|
||||
declare
|
||||
C : constant Complex :=
|
||||
(A (A'First (1) + (J - 1), A'First (2) + (K - 1)));
|
||||
(A (A'First (1) + (J - 1), A'First (2) + (K - 1)));
|
||||
begin
|
||||
M (J, K) := Re (C);
|
||||
M (J + N, K + N) := Re (C);
|
||||
|
|
@ -1120,7 +1120,7 @@ package body Ada.Numerics.Generic_Complex_Arrays is
|
|||
for K in 1 .. N loop
|
||||
declare
|
||||
C : constant Complex :=
|
||||
(A (A'First (1) + (J - 1), A'First (2) + (K - 1)));
|
||||
(A (A'First (1) + (J - 1), A'First (2) + (K - 1)));
|
||||
begin
|
||||
M (J, K) := Re (C);
|
||||
M (J + N, K + N) := Re (C);
|
||||
|
|
|
|||
|
|
@ -971,7 +971,7 @@ package body Ada.Numerics.Generic_Elementary_Functions is
|
|||
G : constant Float_Type'Base := Y * Y;
|
||||
|
||||
Float_Type_Digits_15_Or_More : constant Boolean :=
|
||||
Float_Type'Digits > 14;
|
||||
Float_Type'Digits > 14;
|
||||
|
||||
begin
|
||||
if X < Half_Log_Epsilon then
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
-- --
|
||||
-- B o d y --
|
||||
-- --
|
||||
-- Copyright (C) 1992-2009, Free Software Foundation, Inc. --
|
||||
-- Copyright (C) 1992-2012, 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- --
|
||||
|
|
@ -182,7 +182,7 @@ package body Ada.Sequential_IO is
|
|||
then
|
||||
declare
|
||||
RsizS : constant SSE.Storage_Offset :=
|
||||
SSE.Storage_Offset (Rsiz - 1);
|
||||
SSE.Storage_Offset (Rsiz - 1);
|
||||
|
||||
type SA is new SSE.Storage_Array (0 .. RsizS);
|
||||
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
-- --
|
||||
-- B o d y --
|
||||
-- --
|
||||
-- Copyright (C) 1992-2010, Free Software Foundation, Inc. --
|
||||
-- Copyright (C) 1992-2012, 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- --
|
||||
|
|
@ -434,9 +434,9 @@ package body Ada.Strings.Fixed is
|
|||
|
||||
declare
|
||||
Result_Length : constant Natural :=
|
||||
Integer'Max
|
||||
(Source'Length,
|
||||
Position - Source'First + New_Item'Length);
|
||||
Integer'Max
|
||||
(Source'Length,
|
||||
Position - Source'First + New_Item'Length);
|
||||
|
||||
Result : String (1 .. Result_Length);
|
||||
Front : constant Integer := Position - Source'First;
|
||||
|
|
@ -482,15 +482,15 @@ package body Ada.Strings.Fixed is
|
|||
if High >= Low then
|
||||
declare
|
||||
Front_Len : constant Integer :=
|
||||
Integer'Max (0, Low - Source'First);
|
||||
Integer'Max (0, Low - Source'First);
|
||||
-- Length of prefix of Source copied to result
|
||||
|
||||
Back_Len : constant Integer :=
|
||||
Integer'Max (0, Source'Last - High);
|
||||
Integer'Max (0, Source'Last - High);
|
||||
-- Length of suffix of Source copied to result
|
||||
|
||||
Result_Length : constant Integer :=
|
||||
Front_Len + By'Length + Back_Len;
|
||||
Front_Len + By'Length + Back_Len;
|
||||
-- Length of result
|
||||
|
||||
Result : String (1 .. Result_Length);
|
||||
|
|
|
|||
|
|
@ -486,7 +486,7 @@ package body Ada.Strings.Unbounded is
|
|||
|
||||
function Aligned_Max_Length (Max_Length : Natural) return Natural is
|
||||
Static_Size : constant Natural :=
|
||||
Empty_Shared_String'Size / Standard'Storage_Unit;
|
||||
Empty_Shared_String'Size / Standard'Storage_Unit;
|
||||
-- Total size of all static components
|
||||
|
||||
begin
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
-- --
|
||||
-- B o d y --
|
||||
-- --
|
||||
-- Copyright (C) 1992-2010, Free Software Foundation, Inc. --
|
||||
-- Copyright (C) 1992-2012, 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- --
|
||||
|
|
@ -785,14 +785,13 @@ package body Ada.Strings.Unbounded is
|
|||
if Chunk_Size > S_Length - Source.Last then
|
||||
declare
|
||||
New_Size : constant Positive :=
|
||||
S_Length + Chunk_Size + (S_Length / Growth_Factor);
|
||||
S_Length + Chunk_Size + (S_Length / Growth_Factor);
|
||||
|
||||
New_Rounded_Up_Size : constant Positive :=
|
||||
((New_Size - 1) / Min_Mul_Alloc + 1) *
|
||||
Min_Mul_Alloc;
|
||||
((New_Size - 1) / Min_Mul_Alloc + 1) * Min_Mul_Alloc;
|
||||
|
||||
Tmp : constant String_Access :=
|
||||
new String (1 .. New_Rounded_Up_Size);
|
||||
new String (1 .. New_Rounded_Up_Size);
|
||||
|
||||
begin
|
||||
Tmp (1 .. Source.Last) := Source.Reference (1 .. Source.Last);
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
-- --
|
||||
-- B o d y --
|
||||
-- --
|
||||
-- Copyright (C) 1992-2010, Free Software Foundation, Inc. --
|
||||
-- Copyright (C) 1992-2012, 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- --
|
||||
|
|
@ -411,9 +411,9 @@ package body Ada.Strings.Wide_Fixed is
|
|||
else
|
||||
declare
|
||||
Result_Length : constant Natural :=
|
||||
Natural'Max
|
||||
(Source'Length,
|
||||
Position - Source'First + New_Item'Length);
|
||||
Natural'Max
|
||||
(Source'Length,
|
||||
Position - Source'First + New_Item'Length);
|
||||
|
||||
Result : Wide_String (1 .. Result_Length);
|
||||
|
||||
|
|
@ -455,15 +455,14 @@ package body Ada.Strings.Wide_Fixed is
|
|||
if High >= Low then
|
||||
declare
|
||||
Front_Len : constant Integer :=
|
||||
Integer'Max (0, Low - Source'First);
|
||||
Integer'Max (0, Low - Source'First);
|
||||
-- Length of prefix of Source copied to result
|
||||
|
||||
Back_Len : constant Integer :=
|
||||
Integer'Max (0, Source'Last - High);
|
||||
Back_Len : constant Integer := Integer'Max (0, Source'Last - High);
|
||||
-- Length of suffix of Source copied to result
|
||||
|
||||
Result_Length : constant Integer :=
|
||||
Front_Len + By'Length + Back_Len;
|
||||
Front_Len + By'Length + Back_Len;
|
||||
-- Length of result
|
||||
|
||||
Result : Wide_String (1 .. Result_Length);
|
||||
|
|
@ -622,7 +621,7 @@ package body Ada.Strings.Wide_Fixed is
|
|||
else
|
||||
declare
|
||||
Result : constant Wide_String (1 .. High - Low + 1) :=
|
||||
Source (Low .. High);
|
||||
Source (Low .. High);
|
||||
|
||||
begin
|
||||
return Result;
|
||||
|
|
|
|||
|
|
@ -486,11 +486,11 @@ package body Ada.Strings.Wide_Unbounded is
|
|||
|
||||
function Aligned_Max_Length (Max_Length : Natural) return Natural is
|
||||
Static_Size : constant Natural :=
|
||||
Empty_Shared_Wide_String'Size / Standard'Storage_Unit;
|
||||
Empty_Shared_Wide_String'Size / Standard'Storage_Unit;
|
||||
-- Total size of all static components
|
||||
|
||||
Element_Size : constant Natural :=
|
||||
Wide_Character'Size / Standard'Storage_Unit;
|
||||
Wide_Character'Size / Standard'Storage_Unit;
|
||||
|
||||
begin
|
||||
return
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
-- --
|
||||
-- B o d y --
|
||||
-- --
|
||||
-- Copyright (C) 1992-2010, Free Software Foundation, Inc. --
|
||||
-- Copyright (C) 1992-2012, 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- --
|
||||
|
|
@ -802,14 +802,13 @@ package body Ada.Strings.Wide_Unbounded is
|
|||
if Chunk_Size > S_Length - Source.Last then
|
||||
declare
|
||||
New_Size : constant Positive :=
|
||||
S_Length + Chunk_Size + (S_Length / Growth_Factor);
|
||||
S_Length + Chunk_Size + (S_Length / Growth_Factor);
|
||||
|
||||
New_Rounded_Up_Size : constant Positive :=
|
||||
((New_Size - 1) / Min_Mul_Alloc + 1) *
|
||||
Min_Mul_Alloc;
|
||||
((New_Size - 1) / Min_Mul_Alloc + 1) * Min_Mul_Alloc;
|
||||
|
||||
Tmp : constant Wide_String_Access :=
|
||||
new Wide_String (1 .. New_Rounded_Up_Size);
|
||||
new Wide_String (1 .. New_Rounded_Up_Size);
|
||||
|
||||
begin
|
||||
Tmp (1 .. Source.Last) := Source.Reference (1 .. Source.Last);
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
-- --
|
||||
-- B o d y --
|
||||
-- --
|
||||
-- Copyright (C) 1992-2010, Free Software Foundation, Inc. --
|
||||
-- Copyright (C) 1992-2012, 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- --
|
||||
|
|
@ -43,7 +43,7 @@ package body Ada.Strings.Wide_Wide_Fixed is
|
|||
Pattern : Wide_Wide_String;
|
||||
Going : Direction := Forward;
|
||||
Mapping : Wide_Wide_Maps.Wide_Wide_Character_Mapping :=
|
||||
Wide_Wide_Maps.Identity)
|
||||
Wide_Wide_Maps.Identity)
|
||||
return Natural
|
||||
renames Ada.Strings.Wide_Wide_Search.Index;
|
||||
|
||||
|
|
@ -68,7 +68,7 @@ package body Ada.Strings.Wide_Wide_Fixed is
|
|||
From : Positive;
|
||||
Going : Direction := Forward;
|
||||
Mapping : Wide_Wide_Maps.Wide_Wide_Character_Mapping :=
|
||||
Wide_Wide_Maps.Identity)
|
||||
Wide_Wide_Maps.Identity)
|
||||
return Natural
|
||||
renames Ada.Strings.Wide_Wide_Search.Index;
|
||||
|
||||
|
|
@ -104,7 +104,7 @@ package body Ada.Strings.Wide_Wide_Fixed is
|
|||
(Source : Wide_Wide_String;
|
||||
Pattern : Wide_Wide_String;
|
||||
Mapping : Wide_Wide_Maps.Wide_Wide_Character_Mapping :=
|
||||
Wide_Wide_Maps.Identity)
|
||||
Wide_Wide_Maps.Identity)
|
||||
return Natural
|
||||
renames Ada.Strings.Wide_Wide_Search.Count;
|
||||
|
||||
|
|
@ -413,9 +413,9 @@ package body Ada.Strings.Wide_Wide_Fixed is
|
|||
else
|
||||
declare
|
||||
Result_Length : constant Natural :=
|
||||
Natural'Max
|
||||
(Source'Length,
|
||||
Position - Source'First + New_Item'Length);
|
||||
Natural'Max
|
||||
(Source'Length,
|
||||
Position - Source'First + New_Item'Length);
|
||||
|
||||
Result : Wide_Wide_String (1 .. Result_Length);
|
||||
|
||||
|
|
@ -457,15 +457,15 @@ package body Ada.Strings.Wide_Wide_Fixed is
|
|||
if High >= Low then
|
||||
declare
|
||||
Front_Len : constant Integer :=
|
||||
Integer'Max (0, Low - Source'First);
|
||||
Integer'Max (0, Low - Source'First);
|
||||
-- Length of prefix of Source copied to result
|
||||
|
||||
Back_Len : constant Integer :=
|
||||
Integer'Max (0, Source'Last - High);
|
||||
Integer'Max (0, Source'Last - High);
|
||||
-- Length of suffix of Source copied to result
|
||||
|
||||
Result_Length : constant Integer :=
|
||||
Front_Len + By'Length + Back_Len;
|
||||
Front_Len + By'Length + Back_Len;
|
||||
-- Length of result
|
||||
|
||||
Result : Wide_Wide_String (1 .. Result_Length);
|
||||
|
|
@ -626,7 +626,7 @@ package body Ada.Strings.Wide_Wide_Fixed is
|
|||
else
|
||||
declare
|
||||
Result : constant Wide_Wide_String (1 .. High - Low + 1) :=
|
||||
Source (Low .. High);
|
||||
Source (Low .. High);
|
||||
|
||||
begin
|
||||
return Result;
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
-- --
|
||||
-- B o d y --
|
||||
-- --
|
||||
-- Copyright (C) 1992-2010, Free Software Foundation, Inc. --
|
||||
-- Copyright (C) 1992-2012, 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- --
|
||||
|
|
@ -71,8 +71,7 @@ package body Ada.Strings.Wide_Wide_Search is
|
|||
(Source : Wide_Wide_String;
|
||||
Pattern : Wide_Wide_String;
|
||||
Mapping : Wide_Wide_Maps.Wide_Wide_Character_Mapping :=
|
||||
Wide_Wide_Maps.Identity)
|
||||
return Natural
|
||||
Wide_Wide_Maps.Identity) return Natural
|
||||
is
|
||||
PL1 : constant Integer := Pattern'Length - 1;
|
||||
Num : Natural;
|
||||
|
|
@ -267,8 +266,7 @@ package body Ada.Strings.Wide_Wide_Search is
|
|||
Pattern : Wide_Wide_String;
|
||||
Going : Direction := Forward;
|
||||
Mapping : Wide_Wide_Maps.Wide_Wide_Character_Mapping :=
|
||||
Wide_Wide_Maps.Identity)
|
||||
return Natural
|
||||
Wide_Wide_Maps.Identity) return Natural
|
||||
is
|
||||
PL1 : constant Integer := Pattern'Length - 1;
|
||||
Cur : Natural;
|
||||
|
|
@ -479,8 +477,7 @@ package body Ada.Strings.Wide_Wide_Search is
|
|||
From : Positive;
|
||||
Going : Direction := Forward;
|
||||
Mapping : Wide_Wide_Maps.Wide_Wide_Character_Mapping :=
|
||||
Wide_Wide_Maps.Identity)
|
||||
return Natural
|
||||
Wide_Wide_Maps.Identity) return Natural
|
||||
is
|
||||
begin
|
||||
if Going = Forward then
|
||||
|
|
|
|||
|
|
@ -698,8 +698,7 @@ package body Ada.Strings.Wide_Wide_Superbounded is
|
|||
(Source : Super_String;
|
||||
Pattern : Wide_Wide_String;
|
||||
Mapping : Wide_Wide_Maps.Wide_Wide_Character_Mapping :=
|
||||
Wide_Wide_Maps.Identity)
|
||||
return Natural
|
||||
Wide_Wide_Maps.Identity) return Natural
|
||||
is
|
||||
begin
|
||||
return
|
||||
|
|
@ -939,8 +938,7 @@ package body Ada.Strings.Wide_Wide_Superbounded is
|
|||
Pattern : Wide_Wide_String;
|
||||
Going : Strings.Direction := Strings.Forward;
|
||||
Mapping : Wide_Wide_Maps.Wide_Wide_Character_Mapping :=
|
||||
Wide_Wide_Maps.Identity)
|
||||
return Natural
|
||||
Wide_Wide_Maps.Identity) return Natural
|
||||
is
|
||||
begin
|
||||
return Wide_Wide_Search.Index
|
||||
|
|
@ -976,8 +974,7 @@ package body Ada.Strings.Wide_Wide_Superbounded is
|
|||
From : Positive;
|
||||
Going : Direction := Forward;
|
||||
Mapping : Wide_Wide_Maps.Wide_Wide_Character_Mapping :=
|
||||
Wide_Wide_Maps.Identity)
|
||||
return Natural
|
||||
Wide_Wide_Maps.Identity) return Natural
|
||||
is
|
||||
begin
|
||||
return Wide_Wide_Search.Index
|
||||
|
|
|
|||
|
|
@ -486,12 +486,11 @@ package body Ada.Strings.Wide_Wide_Unbounded is
|
|||
|
||||
function Aligned_Max_Length (Max_Length : Natural) return Natural is
|
||||
Static_Size : constant Natural :=
|
||||
Empty_Shared_Wide_Wide_String'Size
|
||||
/ Standard'Storage_Unit;
|
||||
Empty_Shared_Wide_Wide_String'Size / Standard'Storage_Unit;
|
||||
-- Total size of all static components
|
||||
|
||||
Element_Size : constant Natural :=
|
||||
Wide_Wide_Character'Size / Standard'Storage_Unit;
|
||||
Wide_Wide_Character'Size / Standard'Storage_Unit;
|
||||
|
||||
begin
|
||||
return
|
||||
|
|
@ -645,8 +644,7 @@ package body Ada.Strings.Wide_Wide_Unbounded is
|
|||
(Source : Unbounded_Wide_Wide_String;
|
||||
Pattern : Wide_Wide_String;
|
||||
Mapping : Wide_Wide_Maps.Wide_Wide_Character_Mapping :=
|
||||
Wide_Wide_Maps.Identity)
|
||||
return Natural
|
||||
Wide_Wide_Maps.Identity) return Natural
|
||||
is
|
||||
SR : constant Shared_Wide_Wide_String_Access := Source.Reference;
|
||||
begin
|
||||
|
|
@ -975,8 +973,7 @@ package body Ada.Strings.Wide_Wide_Unbounded is
|
|||
Pattern : Wide_Wide_String;
|
||||
Going : Strings.Direction := Strings.Forward;
|
||||
Mapping : Wide_Wide_Maps.Wide_Wide_Character_Mapping :=
|
||||
Wide_Wide_Maps.Identity)
|
||||
return Natural
|
||||
Wide_Wide_Maps.Identity) return Natural
|
||||
is
|
||||
SR : constant Shared_Wide_Wide_String_Access := Source.Reference;
|
||||
begin
|
||||
|
|
@ -1014,8 +1011,7 @@ package body Ada.Strings.Wide_Wide_Unbounded is
|
|||
From : Positive;
|
||||
Going : Direction := Forward;
|
||||
Mapping : Wide_Wide_Maps.Wide_Wide_Character_Mapping :=
|
||||
Wide_Wide_Maps.Identity)
|
||||
return Natural
|
||||
Wide_Wide_Maps.Identity) return Natural
|
||||
is
|
||||
SR : constant Shared_Wide_Wide_String_Access := Source.Reference;
|
||||
begin
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
-- --
|
||||
-- B o d y --
|
||||
-- --
|
||||
-- Copyright (C) 1992-2010, Free Software Foundation, Inc. --
|
||||
-- Copyright (C) 1992-2012, 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- --
|
||||
|
|
@ -404,8 +404,7 @@ package body Ada.Strings.Wide_Wide_Unbounded is
|
|||
(Source : Unbounded_Wide_Wide_String;
|
||||
Pattern : Wide_Wide_String;
|
||||
Mapping : Wide_Wide_Maps.Wide_Wide_Character_Mapping :=
|
||||
Wide_Wide_Maps.Identity)
|
||||
return Natural
|
||||
Wide_Wide_Maps.Identity) return Natural
|
||||
is
|
||||
begin
|
||||
return
|
||||
|
|
@ -596,8 +595,7 @@ package body Ada.Strings.Wide_Wide_Unbounded is
|
|||
Pattern : Wide_Wide_String;
|
||||
Going : Strings.Direction := Strings.Forward;
|
||||
Mapping : Wide_Wide_Maps.Wide_Wide_Character_Mapping :=
|
||||
Wide_Wide_Maps.Identity)
|
||||
return Natural
|
||||
Wide_Wide_Maps.Identity) return Natural
|
||||
is
|
||||
begin
|
||||
return
|
||||
|
|
@ -635,8 +633,7 @@ package body Ada.Strings.Wide_Wide_Unbounded is
|
|||
From : Positive;
|
||||
Going : Direction := Forward;
|
||||
Mapping : Wide_Wide_Maps.Wide_Wide_Character_Mapping :=
|
||||
Wide_Wide_Maps.Identity)
|
||||
return Natural
|
||||
Wide_Wide_Maps.Identity) return Natural
|
||||
is
|
||||
begin
|
||||
return
|
||||
|
|
@ -813,14 +810,13 @@ package body Ada.Strings.Wide_Wide_Unbounded is
|
|||
if Chunk_Size > S_Length - Source.Last then
|
||||
declare
|
||||
New_Size : constant Positive :=
|
||||
S_Length + Chunk_Size + (S_Length / Growth_Factor);
|
||||
S_Length + Chunk_Size + (S_Length / Growth_Factor);
|
||||
|
||||
New_Rounded_Up_Size : constant Positive :=
|
||||
((New_Size - 1) / Min_Mul_Alloc + 1) *
|
||||
Min_Mul_Alloc;
|
||||
((New_Size - 1) / Min_Mul_Alloc + 1) * Min_Mul_Alloc;
|
||||
|
||||
Tmp : constant Wide_Wide_String_Access :=
|
||||
new Wide_Wide_String (1 .. New_Rounded_Up_Size);
|
||||
new Wide_Wide_String (1 .. New_Rounded_Up_Size);
|
||||
|
||||
begin
|
||||
Tmp (1 .. Source.Last) := Source.Reference (1 .. Source.Last);
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
-- --
|
||||
-- B o d y --
|
||||
-- --
|
||||
-- Copyright (C) 1992-2011, Free Software Foundation, Inc. --
|
||||
-- Copyright (C) 1992-2012, 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- --
|
||||
|
|
@ -139,13 +139,13 @@ package body Ada.Tags is
|
|||
|
||||
function CW_Membership (Obj_Tag : Tag; Typ_Tag : Tag) return Boolean is
|
||||
Obj_TSD_Ptr : constant Addr_Ptr :=
|
||||
To_Addr_Ptr (To_Address (Obj_Tag) - DT_Typeinfo_Ptr_Size);
|
||||
To_Addr_Ptr (To_Address (Obj_Tag) - DT_Typeinfo_Ptr_Size);
|
||||
Typ_TSD_Ptr : constant Addr_Ptr :=
|
||||
To_Addr_Ptr (To_Address (Typ_Tag) - DT_Typeinfo_Ptr_Size);
|
||||
To_Addr_Ptr (To_Address (Typ_Tag) - DT_Typeinfo_Ptr_Size);
|
||||
Obj_TSD : constant Type_Specific_Data_Ptr :=
|
||||
To_Type_Specific_Data_Ptr (Obj_TSD_Ptr.all);
|
||||
To_Type_Specific_Data_Ptr (Obj_TSD_Ptr.all);
|
||||
Typ_TSD : constant Type_Specific_Data_Ptr :=
|
||||
To_Type_Specific_Data_Ptr (Typ_TSD_Ptr.all);
|
||||
To_Type_Specific_Data_Ptr (Typ_TSD_Ptr.all);
|
||||
Pos : constant Integer := Obj_TSD.Idepth - Typ_TSD.Idepth;
|
||||
begin
|
||||
return Pos >= 0 and then Obj_TSD.Tags_Table (Pos) = Typ_Tag;
|
||||
|
|
@ -157,9 +157,9 @@ package body Ada.Tags is
|
|||
|
||||
function Get_External_Tag (T : Tag) return System.Address is
|
||||
TSD_Ptr : constant Addr_Ptr :=
|
||||
To_Addr_Ptr (To_Address (T) - DT_Typeinfo_Ptr_Size);
|
||||
To_Addr_Ptr (To_Address (T) - DT_Typeinfo_Ptr_Size);
|
||||
TSD : constant Type_Specific_Data_Ptr :=
|
||||
To_Type_Specific_Data_Ptr (TSD_Ptr.all);
|
||||
To_Type_Specific_Data_Ptr (TSD_Ptr.all);
|
||||
begin
|
||||
return To_Address (TSD.External_Tag);
|
||||
end Get_External_Tag;
|
||||
|
|
@ -179,7 +179,7 @@ package body Ada.Tags is
|
|||
|
||||
function OSD (T : Tag) return Object_Specific_Data_Ptr is
|
||||
OSD_Ptr : constant Addr_Ptr :=
|
||||
To_Addr_Ptr (To_Address (T) - DT_Typeinfo_Ptr_Size);
|
||||
To_Addr_Ptr (To_Address (T) - DT_Typeinfo_Ptr_Size);
|
||||
begin
|
||||
return To_Object_Specific_Data_Ptr (OSD_Ptr.all);
|
||||
end OSD;
|
||||
|
|
@ -190,9 +190,9 @@ package body Ada.Tags is
|
|||
|
||||
function SSD (T : Tag) return Select_Specific_Data_Ptr is
|
||||
TSD_Ptr : constant Addr_Ptr :=
|
||||
To_Addr_Ptr (To_Address (T) - DT_Typeinfo_Ptr_Size);
|
||||
To_Addr_Ptr (To_Address (T) - DT_Typeinfo_Ptr_Size);
|
||||
TSD : constant Type_Specific_Data_Ptr :=
|
||||
To_Type_Specific_Data_Ptr (TSD_Ptr.all);
|
||||
To_Type_Specific_Data_Ptr (TSD_Ptr.all);
|
||||
begin
|
||||
return TSD.SSD;
|
||||
end SSD;
|
||||
|
|
@ -260,9 +260,9 @@ package body Ada.Tags is
|
|||
|
||||
function Get_HT_Link (T : Tag) return Tag is
|
||||
TSD_Ptr : constant Addr_Ptr :=
|
||||
To_Addr_Ptr (To_Address (T) - DT_Typeinfo_Ptr_Size);
|
||||
To_Addr_Ptr (To_Address (T) - DT_Typeinfo_Ptr_Size);
|
||||
TSD : constant Type_Specific_Data_Ptr :=
|
||||
To_Type_Specific_Data_Ptr (TSD_Ptr.all);
|
||||
To_Type_Specific_Data_Ptr (TSD_Ptr.all);
|
||||
begin
|
||||
return TSD.HT_Link.all;
|
||||
end Get_HT_Link;
|
||||
|
|
@ -285,9 +285,9 @@ package body Ada.Tags is
|
|||
|
||||
procedure Set_HT_Link (T : Tag; Next : Tag) is
|
||||
TSD_Ptr : constant Addr_Ptr :=
|
||||
To_Addr_Ptr (To_Address (T) - DT_Typeinfo_Ptr_Size);
|
||||
To_Addr_Ptr (To_Address (T) - DT_Typeinfo_Ptr_Size);
|
||||
TSD : constant Type_Specific_Data_Ptr :=
|
||||
To_Type_Specific_Data_Ptr (TSD_Ptr.all);
|
||||
To_Type_Specific_Data_Ptr (TSD_Ptr.all);
|
||||
begin
|
||||
TSD.HT_Link.all := Next;
|
||||
end Set_HT_Link;
|
||||
|
|
@ -419,7 +419,7 @@ package body Ada.Tags is
|
|||
|
||||
function DT (T : Tag) return Dispatch_Table_Ptr is
|
||||
Offset : constant SSE.Storage_Offset :=
|
||||
To_Dispatch_Table_Ptr (T).Prims_Ptr'Position;
|
||||
To_Dispatch_Table_Ptr (T).Prims_Ptr'Position;
|
||||
begin
|
||||
return To_Dispatch_Table_Ptr (To_Address (T) - Offset);
|
||||
end DT;
|
||||
|
|
@ -562,9 +562,9 @@ package body Ada.Tags is
|
|||
|
||||
function Interface_Ancestor_Tags (T : Tag) return Tag_Array is
|
||||
TSD_Ptr : constant Addr_Ptr :=
|
||||
To_Addr_Ptr (To_Address (T) - DT_Typeinfo_Ptr_Size);
|
||||
To_Addr_Ptr (To_Address (T) - DT_Typeinfo_Ptr_Size);
|
||||
TSD : constant Type_Specific_Data_Ptr :=
|
||||
To_Type_Specific_Data_Ptr (TSD_Ptr.all);
|
||||
To_Type_Specific_Data_Ptr (TSD_Ptr.all);
|
||||
Iface_Table : constant Interface_Data_Ptr := TSD.Interfaces_Table;
|
||||
|
||||
begin
|
||||
|
|
@ -612,7 +612,7 @@ package body Ada.Tags is
|
|||
then
|
||||
declare
|
||||
Addr_First : constant Natural :=
|
||||
External'First + Internal_Tag_Header'Length;
|
||||
External'First + Internal_Tag_Header'Length;
|
||||
Addr_Last : Natural;
|
||||
Addr : Integer_Address;
|
||||
|
||||
|
|
@ -718,14 +718,13 @@ package body Ada.Tags is
|
|||
Ancestor : Tag) return Boolean
|
||||
is
|
||||
D_TSD_Ptr : constant Addr_Ptr :=
|
||||
To_Addr_Ptr (To_Address (Descendant)
|
||||
- DT_Typeinfo_Ptr_Size);
|
||||
To_Addr_Ptr (To_Address (Descendant) - DT_Typeinfo_Ptr_Size);
|
||||
A_TSD_Ptr : constant Addr_Ptr :=
|
||||
To_Addr_Ptr (To_Address (Ancestor) - DT_Typeinfo_Ptr_Size);
|
||||
To_Addr_Ptr (To_Address (Ancestor) - DT_Typeinfo_Ptr_Size);
|
||||
D_TSD : constant Type_Specific_Data_Ptr :=
|
||||
To_Type_Specific_Data_Ptr (D_TSD_Ptr.all);
|
||||
To_Type_Specific_Data_Ptr (D_TSD_Ptr.all);
|
||||
A_TSD : constant Type_Specific_Data_Ptr :=
|
||||
To_Type_Specific_Data_Ptr (A_TSD_Ptr.all);
|
||||
To_Type_Specific_Data_Ptr (A_TSD_Ptr.all);
|
||||
|
||||
begin
|
||||
return CW_Membership (Descendant, Ancestor)
|
||||
|
|
@ -782,9 +781,9 @@ package body Ada.Tags is
|
|||
|
||||
function Needs_Finalization (T : Tag) return Boolean is
|
||||
TSD_Ptr : constant Addr_Ptr :=
|
||||
To_Addr_Ptr (To_Address (T) - DT_Typeinfo_Ptr_Size);
|
||||
To_Addr_Ptr (To_Address (T) - DT_Typeinfo_Ptr_Size);
|
||||
TSD : constant Type_Specific_Data_Ptr :=
|
||||
To_Type_Specific_Data_Ptr (TSD_Ptr.all);
|
||||
To_Type_Specific_Data_Ptr (TSD_Ptr.all);
|
||||
begin
|
||||
return TSD.Needs_Finalization;
|
||||
end Needs_Finalization;
|
||||
|
|
@ -802,17 +801,16 @@ package body Ada.Tags is
|
|||
-- ancestor tags.
|
||||
|
||||
TSD_Ptr : constant Addr_Ptr :=
|
||||
To_Addr_Ptr (To_Address (T) - DT_Typeinfo_Ptr_Size);
|
||||
To_Addr_Ptr (To_Address (T) - DT_Typeinfo_Ptr_Size);
|
||||
TSD : constant Type_Specific_Data_Ptr :=
|
||||
To_Type_Specific_Data_Ptr (TSD_Ptr.all);
|
||||
To_Type_Specific_Data_Ptr (TSD_Ptr.all);
|
||||
-- Pointer to the TSD
|
||||
|
||||
Parent_Tag : constant Tag := TSD.Tags_Table (Parent_Slot);
|
||||
Parent_TSD_Ptr : constant Addr_Ptr :=
|
||||
To_Addr_Ptr (To_Address (Parent_Tag)
|
||||
- DT_Typeinfo_Ptr_Size);
|
||||
To_Addr_Ptr (To_Address (Parent_Tag) - DT_Typeinfo_Ptr_Size);
|
||||
Parent_TSD : constant Type_Specific_Data_Ptr :=
|
||||
To_Type_Specific_Data_Ptr (Parent_TSD_Ptr.all);
|
||||
To_Type_Specific_Data_Ptr (Parent_TSD_Ptr.all);
|
||||
|
||||
begin
|
||||
-- Here we compute the size of the _parent field of the object
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
-- --
|
||||
-- B o d y --
|
||||
-- --
|
||||
-- Copyright (C) 1992-2009, Free Software Foundation, Inc. --
|
||||
-- Copyright (C) 1992-2012, 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- --
|
||||
|
|
@ -932,7 +932,7 @@ package body Ada.Text_IO.Editing is
|
|||
|
||||
function Pic_String (Pic : Picture) return String is
|
||||
Temp : String (1 .. Pic.Contents.Picture.Length) :=
|
||||
Pic.Contents.Picture.Expanded;
|
||||
Pic.Contents.Picture.Expanded;
|
||||
begin
|
||||
for J in Temp'Range loop
|
||||
if Temp (J) = 'b' then
|
||||
|
|
|
|||
|
|
@ -2118,8 +2118,7 @@ package body Ada.Text_IO is
|
|||
end Has_Translated_Characters;
|
||||
|
||||
Needs_Binary_Write : constant Boolean :=
|
||||
text_translation_required
|
||||
and then Has_Translated_Characters;
|
||||
text_translation_required and then Has_Translated_Characters;
|
||||
|
||||
-- Start of processing for Write
|
||||
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
-- --
|
||||
-- B o d y --
|
||||
-- --
|
||||
-- Copyright (C) 1992-2010, Free Software Foundation, Inc. --
|
||||
-- Copyright (C) 1992-2012, 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- --
|
||||
|
|
@ -290,10 +290,9 @@ package body Ada.Text_IO.Fixed_IO is
|
|||
and then Num'Small * 10.0**Scale < 10.0);
|
||||
|
||||
Exact : constant Boolean :=
|
||||
Float'Floor (Num'Small) = Float'Ceiling (Num'Small)
|
||||
or else Float'Floor (1.0 / Num'Small) =
|
||||
Float'Ceiling (1.0 / Num'Small)
|
||||
or else Num'Small >= 10.0**Max_Digits;
|
||||
Float'Floor (Num'Small) = Float'Ceiling (Num'Small)
|
||||
or else Float'Floor (1.0 / Num'Small) = Float'Ceiling (1.0 / Num'Small)
|
||||
or else Num'Small >= 10.0**Max_Digits;
|
||||
-- True iff a numerator and denominator can be calculated such that
|
||||
-- their ratio exactly represents the small of Num.
|
||||
|
||||
|
|
@ -387,11 +386,11 @@ package body Ada.Text_IO.Fixed_IO is
|
|||
Exp : Field := Default_Exp)
|
||||
is
|
||||
Fore : constant Integer :=
|
||||
To'Length
|
||||
- 1 -- Decimal point
|
||||
- Field'Max (1, Aft) -- Decimal part
|
||||
- Boolean'Pos (Exp /= 0) -- Exponent indicator
|
||||
- Exp; -- Exponent
|
||||
To'Length
|
||||
- 1 -- Decimal point
|
||||
- Field'Max (1, Aft) -- Decimal part
|
||||
- Boolean'Pos (Exp /= 0) -- Exponent indicator
|
||||
- Exp; -- Exponent
|
||||
|
||||
Last : Natural;
|
||||
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
-- --
|
||||
-- B o d y --
|
||||
-- --
|
||||
-- Copyright (C) 1992-2009, Free Software Foundation, Inc. --
|
||||
-- Copyright (C) 1992-2012, 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- --
|
||||
|
|
@ -1090,7 +1090,7 @@ package body Ada.Wide_Text_IO.Editing is
|
|||
|
||||
function Pic_String (Pic : Picture) return String is
|
||||
Temp : String (1 .. Pic.Contents.Picture.Length) :=
|
||||
Pic.Contents.Picture.Expanded;
|
||||
Pic.Contents.Picture.Expanded;
|
||||
begin
|
||||
for J in Temp'Range loop
|
||||
if Temp (J) = 'b' then
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
-- --
|
||||
-- B o d y --
|
||||
-- --
|
||||
-- Copyright (C) 1992-2009, Free Software Foundation, Inc. --
|
||||
-- Copyright (C) 1992-2012, 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- --
|
||||
|
|
@ -152,7 +152,7 @@ package body Ada.Wide_Text_IO.Enumeration_Aux is
|
|||
Set : Type_Set)
|
||||
is
|
||||
Actual_Width : constant Integer :=
|
||||
Integer'Max (Integer (Width), Item'Length);
|
||||
Integer'Max (Integer (Width), Item'Length);
|
||||
|
||||
begin
|
||||
Check_On_One_Line (TFT (File), Actual_Width);
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
-- --
|
||||
-- B o d y --
|
||||
-- --
|
||||
-- Copyright (C) 1992-2009, Free Software Foundation, Inc. --
|
||||
-- Copyright (C) 1992-2012, 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- --
|
||||
|
|
@ -1091,7 +1091,7 @@ package body Ada.Wide_Wide_Text_IO.Editing is
|
|||
|
||||
function Pic_String (Pic : Picture) return String is
|
||||
Temp : String (1 .. Pic.Contents.Picture.Length) :=
|
||||
Pic.Contents.Picture.Expanded;
|
||||
Pic.Contents.Picture.Expanded;
|
||||
begin
|
||||
for J in Temp'Range loop
|
||||
if Temp (J) = 'b' then
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
-- --
|
||||
-- B o d y --
|
||||
-- --
|
||||
-- Copyright (C) 1992-2009, Free Software Foundation, Inc. --
|
||||
-- Copyright (C) 1992-2012, 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- --
|
||||
|
|
@ -153,7 +153,7 @@ package body Ada.Wide_Wide_Text_IO.Enumeration_Aux is
|
|||
Set : Type_Set)
|
||||
is
|
||||
Actual_Width : constant Integer :=
|
||||
Integer'Max (Integer (Width), Item'Length);
|
||||
Integer'Max (Integer (Width), Item'Length);
|
||||
|
||||
begin
|
||||
Check_On_One_Line (TFT (File), Actual_Width);
|
||||
|
|
|
|||
|
|
@ -274,7 +274,7 @@ package body Back_End is
|
|||
Argv_Ptr : constant Big_String_Ptr := save_argv (Arg);
|
||||
Argv_Len : constant Nat := Len_Arg (Arg);
|
||||
Argv : constant String :=
|
||||
Argv_Ptr (1 .. Natural (Argv_Len));
|
||||
Argv_Ptr (1 .. Natural (Argv_Len));
|
||||
begin
|
||||
Args (Positive (Arg)) := new String'(Argv);
|
||||
end;
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
-- --
|
||||
-- B o d y --
|
||||
-- --
|
||||
-- Copyright (C) 1992-2010, Free Software Foundation, Inc. --
|
||||
-- Copyright (C) 1992-2012, 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- --
|
||||
|
|
@ -280,7 +280,7 @@ package body Bcheck is
|
|||
|
||||
Check_Policy : declare
|
||||
Policy : constant Character :=
|
||||
ALIs.Table (A1).Task_Dispatching_Policy;
|
||||
ALIs.Table (A1).Task_Dispatching_Policy;
|
||||
|
||||
begin
|
||||
for A2 in A1 + 1 .. ALIs.Last loop
|
||||
|
|
@ -337,10 +337,10 @@ package body Bcheck is
|
|||
end record;
|
||||
|
||||
PSD_Table : array (0 .. Max_Prio) of Specific_Dispatching_Entry :=
|
||||
(others => Specific_Dispatching_Entry'
|
||||
(Dispatching_Policy => ' ',
|
||||
Afile => No_ALI_Id,
|
||||
Loc => 0));
|
||||
(others => Specific_Dispatching_Entry'
|
||||
(Dispatching_Policy => ' ',
|
||||
Afile => No_ALI_Id,
|
||||
Loc => 0));
|
||||
-- Array containing an entry per priority containing the location
|
||||
-- where there is a Priority_Specific_Dispatching pragma that
|
||||
-- applies to the priority.
|
||||
|
|
@ -943,9 +943,7 @@ package body Bcheck is
|
|||
|
||||
for ND in No_Deps.First .. No_Deps.Last loop
|
||||
declare
|
||||
ND_Unit : constant Name_Id :=
|
||||
No_Deps.Table (ND).No_Dep_Unit;
|
||||
|
||||
ND_Unit : constant Name_Id := No_Deps.Table (ND).No_Dep_Unit;
|
||||
begin
|
||||
for J in ALIs.First .. ALIs.Last loop
|
||||
declare
|
||||
|
|
@ -1019,7 +1017,7 @@ package body Bcheck is
|
|||
if AFN /= No_File then
|
||||
declare
|
||||
WAI : constant ALI_Id :=
|
||||
ALI_Id (Get_Name_Table_Info (AFN));
|
||||
ALI_Id (Get_Name_Table_Info (AFN));
|
||||
WTE : ALIs_Record renames ALIs.Table (WAI);
|
||||
|
||||
begin
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
-- --
|
||||
-- B o d y --
|
||||
-- --
|
||||
-- Copyright (C) 1992-2010, Free Software Foundation, Inc. --
|
||||
-- Copyright (C) 1992-2012, 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- --
|
||||
|
|
@ -427,8 +427,8 @@ package body Binde is
|
|||
elsif Is_Waiting_Body (U1) and then Is_Waiting_Body (U2) then
|
||||
declare
|
||||
Result : constant Boolean :=
|
||||
UNR.Table (Corresponding_Spec (U1)).Elab_Position >
|
||||
UNR.Table (Corresponding_Spec (U2)).Elab_Position;
|
||||
UNR.Table (Corresponding_Spec (U1)).Elab_Position >
|
||||
UNR.Table (Corresponding_Spec (U2)).Elab_Position;
|
||||
begin
|
||||
if Debug_Flag_B then
|
||||
if Result then
|
||||
|
|
@ -483,8 +483,8 @@ package body Binde is
|
|||
then
|
||||
declare
|
||||
Result : constant Boolean :=
|
||||
UNR.Table (Corresponding_Body (U1)).Num_Pred <
|
||||
UNR.Table (Corresponding_Body (U2)).Num_Pred;
|
||||
UNR.Table (Corresponding_Body (U1)).Num_Pred <
|
||||
UNR.Table (Corresponding_Body (U2)).Num_Pred;
|
||||
begin
|
||||
if Debug_Flag_B then
|
||||
if Result then
|
||||
|
|
@ -902,8 +902,7 @@ package body Binde is
|
|||
then
|
||||
declare
|
||||
Info : constant Int :=
|
||||
Get_Name_Table_Info
|
||||
(Withs.Table (W).Uname);
|
||||
Get_Name_Table_Info (Withs.Table (W).Uname);
|
||||
|
||||
begin
|
||||
-- If the unit is unknown, for some unknown reason, fail
|
||||
|
|
@ -913,11 +912,10 @@ package body Binde is
|
|||
if Info = 0 or else Unit_Id (Info) = No_Unit_Id then
|
||||
declare
|
||||
Withed : String :=
|
||||
Get_Name_String (Withs.Table (W).Uname);
|
||||
Get_Name_String (Withs.Table (W).Uname);
|
||||
Last_Withed : Natural := Withed'Last;
|
||||
Withing : String :=
|
||||
Get_Name_String
|
||||
(Units.Table (Before).Uname);
|
||||
Get_Name_String (Units.Table (Before).Uname);
|
||||
Last_Withing : Natural := Withing'Last;
|
||||
Spec_Body : String := " (Spec)";
|
||||
|
||||
|
|
@ -1520,8 +1518,8 @@ package body Binde is
|
|||
elsif Is_Waiting_Body (U1) and then Is_Waiting_Body (U2) then
|
||||
declare
|
||||
Result : constant Boolean :=
|
||||
UNR.Table (Corresponding_Spec (U1)).Elab_Position <
|
||||
UNR.Table (Corresponding_Spec (U2)).Elab_Position;
|
||||
UNR.Table (Corresponding_Spec (U1)).Elab_Position <
|
||||
UNR.Table (Corresponding_Spec (U2)).Elab_Position;
|
||||
begin
|
||||
if Debug_Flag_B then
|
||||
if Result then
|
||||
|
|
@ -1580,8 +1578,8 @@ package body Binde is
|
|||
then
|
||||
declare
|
||||
Result : constant Boolean :=
|
||||
UNR.Table (Corresponding_Body (U1)).Num_Pred >=
|
||||
UNR.Table (Corresponding_Body (U2)).Num_Pred;
|
||||
UNR.Table (Corresponding_Body (U1)).Num_Pred >=
|
||||
UNR.Table (Corresponding_Body (U2)).Num_Pred;
|
||||
begin
|
||||
if Debug_Flag_B then
|
||||
if Result then
|
||||
|
|
|
|||
|
|
@ -2135,8 +2135,7 @@ package body Bindgen is
|
|||
-- function Get_Ada_Main_Name for details on the form of the name.
|
||||
|
||||
Needs_Library_Finalization : constant Boolean :=
|
||||
not Configurable_Run_Time_On_Target
|
||||
and then Has_Finalizer;
|
||||
not Configurable_Run_Time_On_Target and then Has_Finalizer;
|
||||
-- For restricted run-time libraries (ZFP and Ravenscar) tasks are
|
||||
-- non-terminating, so we do not want finalization.
|
||||
|
||||
|
|
@ -2658,7 +2657,7 @@ package body Bindgen is
|
|||
function Get_Ada_Main_Name return String is
|
||||
Suffix : constant String := "_00";
|
||||
Name : String (1 .. Opt.Ada_Main_Name.all'Length + Suffix'Length) :=
|
||||
Opt.Ada_Main_Name.all & Suffix;
|
||||
Opt.Ada_Main_Name.all & Suffix;
|
||||
Nlen : Natural;
|
||||
|
||||
begin
|
||||
|
|
@ -2945,9 +2944,9 @@ package body Bindgen is
|
|||
loop
|
||||
declare
|
||||
Inum : constant Int :=
|
||||
Interrupt_States.Table (K).Interrupt_Id;
|
||||
Interrupt_States.Table (K).Interrupt_Id;
|
||||
Stat : constant Character :=
|
||||
Interrupt_States.Table (K).Interrupt_State;
|
||||
Interrupt_States.Table (K).Interrupt_State;
|
||||
|
||||
begin
|
||||
while IS_Pragma_Settings.Last < Inum loop
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
-- --
|
||||
-- B o d y --
|
||||
-- --
|
||||
-- Copyright (C) 1992-2007, Free Software Foundation, Inc. --
|
||||
-- Copyright (C) 1992-2012, 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- --
|
||||
|
|
@ -119,7 +119,7 @@ package body Butil is
|
|||
|
||||
declare
|
||||
U1_Name : constant String (1 .. Name_Len) :=
|
||||
Name_Buffer (1 .. Name_Len);
|
||||
Name_Buffer (1 .. Name_Len);
|
||||
Min_Length : Natural;
|
||||
|
||||
begin
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
-- --
|
||||
-- B o d y --
|
||||
-- --
|
||||
-- Copyright (C) 1998-2010, Free Software Foundation, Inc. --
|
||||
-- Copyright (C) 1998-2012, 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- --
|
||||
|
|
@ -61,11 +61,11 @@ procedure CEinfo is
|
|||
Fnam : constant Pattern := (UC & Break (' ')) * Fieldnm;
|
||||
|
||||
Field_Def : constant Pattern :=
|
||||
"-- " & Fnam & " (" & Break (')') * Accessfunc;
|
||||
"-- " & Fnam & " (" & Break (')') * Accessfunc;
|
||||
|
||||
Field_Ref : constant Pattern :=
|
||||
" -- " & Fnam & Break ('(') & Len (1) &
|
||||
Break (')') * Accessfunc;
|
||||
" -- " & Fnam & Break ('(') & Len (1) &
|
||||
Break (')') * Accessfunc;
|
||||
|
||||
Field_Com : constant Pattern := " -- " & Fnam & Span (' ') &
|
||||
(Break (' ') or Rest) * Accessfunc;
|
||||
|
|
|
|||
|
|
@ -397,9 +397,8 @@ package body Checks is
|
|||
Internal_Static_Sloc : constant Source_Ptr := Static_Sloc;
|
||||
|
||||
Checks_On : constant Boolean :=
|
||||
(not Index_Checks_Suppressed (Suppress_Typ))
|
||||
or else
|
||||
(not Range_Checks_Suppressed (Suppress_Typ));
|
||||
(not Index_Checks_Suppressed (Suppress_Typ))
|
||||
or else (not Range_Checks_Suppressed (Suppress_Typ));
|
||||
|
||||
begin
|
||||
-- For now we just return if Checks_On is false, however this should
|
||||
|
|
@ -792,7 +791,7 @@ package body Checks is
|
|||
then
|
||||
declare
|
||||
Target_Type : constant Entity_Id :=
|
||||
Base_Type (Entity (Subtype_Mark (Parent (N))));
|
||||
Base_Type (Entity (Subtype_Mark (Parent (N))));
|
||||
|
||||
Llo, Lhi : Uint;
|
||||
Rlo, Rhi : Uint;
|
||||
|
|
@ -1279,7 +1278,7 @@ package body Checks is
|
|||
then
|
||||
declare
|
||||
Alloc_Typ : constant Entity_Id :=
|
||||
Entity (Expression (Original_Node (N)));
|
||||
Entity (Expression (Original_Node (N)));
|
||||
|
||||
begin
|
||||
if Alloc_Typ = T_Typ
|
||||
|
|
@ -1341,8 +1340,7 @@ package body Checks is
|
|||
then
|
||||
declare
|
||||
Type_Def : constant Node_Id :=
|
||||
Type_Definition
|
||||
(Original_Node (Parent (T_Typ)));
|
||||
Type_Definition (Original_Node (Parent (T_Typ)));
|
||||
begin
|
||||
if Nkind (Type_Def) = N_Derived_Type_Definition
|
||||
and then Is_Entity_Name (Subtype_Indication (Type_Def))
|
||||
|
|
@ -1576,7 +1574,7 @@ package body Checks is
|
|||
Loc : constant Source_Ptr := Sloc (Ck_Node);
|
||||
Expr_Type : constant Entity_Id := Base_Type (Etype (Ck_Node));
|
||||
Target_Base : constant Entity_Id :=
|
||||
Implementation_Base_Type (Target_Typ);
|
||||
Implementation_Base_Type (Target_Typ);
|
||||
|
||||
Par : constant Node_Id := Parent (Ck_Node);
|
||||
pragma Assert (Nkind (Par) = N_Type_Conversion);
|
||||
|
|
@ -1584,9 +1582,9 @@ package body Checks is
|
|||
|
||||
Truncate : constant Boolean := Float_Truncate (Par);
|
||||
Max_Bound : constant Uint :=
|
||||
UI_Expon
|
||||
(Machine_Radix_Value (Expr_Type),
|
||||
Machine_Mantissa_Value (Expr_Type) - 1) - 1;
|
||||
UI_Expon
|
||||
(Machine_Radix_Value (Expr_Type),
|
||||
Machine_Mantissa_Value (Expr_Type) - 1) - 1;
|
||||
|
||||
-- Largest bound, so bound plus or minus half is a machine number of F
|
||||
|
||||
|
|
@ -2394,9 +2392,8 @@ package body Checks is
|
|||
|
||||
Loc : constant Source_Ptr := Sloc (Ck_Node);
|
||||
Checks_On : constant Boolean :=
|
||||
(not Index_Checks_Suppressed (Target_Typ))
|
||||
or else
|
||||
(not Length_Checks_Suppressed (Target_Typ));
|
||||
(not Index_Checks_Suppressed (Target_Typ))
|
||||
or else (not Length_Checks_Suppressed (Target_Typ));
|
||||
|
||||
begin
|
||||
if not Full_Expander_Active then
|
||||
|
|
@ -2502,9 +2499,8 @@ package body Checks is
|
|||
|
||||
Loc : constant Source_Ptr := Sloc (Ck_Node);
|
||||
Checks_On : constant Boolean :=
|
||||
(not Index_Checks_Suppressed (Target_Typ))
|
||||
or else
|
||||
(not Range_Checks_Suppressed (Target_Typ));
|
||||
(not Index_Checks_Suppressed (Target_Typ))
|
||||
or else (not Range_Checks_Suppressed (Target_Typ));
|
||||
|
||||
begin
|
||||
if not Full_Expander_Active or else not Checks_On then
|
||||
|
|
@ -2657,8 +2653,8 @@ package body Checks is
|
|||
-- fixed point values must be read as integral values.
|
||||
|
||||
Float_To_Int : constant Boolean :=
|
||||
Is_Floating_Point_Type (Expr_Type)
|
||||
and then Is_Integer_Type (Target_Type);
|
||||
Is_Floating_Point_Type (Expr_Type)
|
||||
and then Is_Integer_Type (Target_Type);
|
||||
|
||||
begin
|
||||
if not Overflow_Checks_Suppressed (Target_Base)
|
||||
|
|
@ -2714,7 +2710,7 @@ package body Checks is
|
|||
|
||||
New_Constraints : constant Elist_Id := New_Elmt_List;
|
||||
Old_Constraints : constant Elist_Id :=
|
||||
Discriminant_Constraint (Expr_Type);
|
||||
Discriminant_Constraint (Expr_Type);
|
||||
|
||||
begin
|
||||
Constraint := First_Elmt (Stored_Constraint (Target_Type));
|
||||
|
|
@ -4799,11 +4795,11 @@ package body Checks is
|
|||
Sel : constant Node_Id := Selector_Name (N);
|
||||
|
||||
Orig_Comp : constant Entity_Id :=
|
||||
Original_Record_Component (Entity (Sel));
|
||||
Original_Record_Component (Entity (Sel));
|
||||
-- The original component to be checked
|
||||
|
||||
Discr_Fct : constant Entity_Id :=
|
||||
Discriminant_Checking_Func (Orig_Comp);
|
||||
Discriminant_Checking_Func (Orig_Comp);
|
||||
-- The discriminant checking function
|
||||
|
||||
Discr : Entity_Id;
|
||||
|
|
@ -5596,9 +5592,8 @@ package body Checks is
|
|||
|
||||
Check_Node : Node_Id;
|
||||
Checks_On : constant Boolean :=
|
||||
(not Index_Checks_Suppressed (Suppress_Typ))
|
||||
or else
|
||||
(not Range_Checks_Suppressed (Suppress_Typ));
|
||||
(not Index_Checks_Suppressed (Suppress_Typ))
|
||||
or else (not Range_Checks_Suppressed (Suppress_Typ));
|
||||
|
||||
begin
|
||||
-- For now we just return if Checks_On is false, however this should be
|
||||
|
|
@ -7361,8 +7356,8 @@ package body Checks is
|
|||
|
||||
Out_Of_Range : Boolean;
|
||||
Static_Bounds : constant Boolean :=
|
||||
Compile_Time_Known_Value (LB)
|
||||
and Compile_Time_Known_Value (UB);
|
||||
Compile_Time_Known_Value (LB)
|
||||
and Compile_Time_Known_Value (UB);
|
||||
|
||||
begin
|
||||
-- Following range tests should use Sem_Eval routine ???
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
-- --
|
||||
-- B o d y --
|
||||
-- --
|
||||
-- Copyright (C) 2003-2011, Free Software Foundation, Inc. --
|
||||
-- Copyright (C) 2003-2012, 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- --
|
||||
|
|
@ -73,7 +73,7 @@ package body Clean is
|
|||
-- Changed to "b__" for VMS in the body of the package.
|
||||
|
||||
Project_Tree : constant Project_Tree_Ref :=
|
||||
new Project_Tree_Data (Is_Root_Tree => True);
|
||||
new Project_Tree_Data (Is_Root_Tree => True);
|
||||
-- The project tree
|
||||
|
||||
Object_Directory_Path : String_Access := null;
|
||||
|
|
@ -319,7 +319,7 @@ package body Clean is
|
|||
-- The name of the archive dependency file for this project
|
||||
|
||||
Obj_Dir : constant String :=
|
||||
Get_Name_String (Project.Object_Directory.Display_Name);
|
||||
Get_Name_String (Project.Object_Directory.Display_Name);
|
||||
|
||||
begin
|
||||
Change_Dir (Obj_Dir);
|
||||
|
|
@ -463,7 +463,7 @@ package body Clean is
|
|||
|
||||
declare
|
||||
Obj_Dir : constant String :=
|
||||
Dir_Name (Get_Name_String (Full_Lib_File));
|
||||
Dir_Name (Get_Name_String (Full_Lib_File));
|
||||
Obj : constant String := Object_File_Name (Lib_File);
|
||||
Adt : constant String := Tree_File_Name (Lib_File);
|
||||
Asm : constant String := Assembly_File_Name (Lib_File);
|
||||
|
|
@ -489,9 +489,9 @@ package body Clean is
|
|||
for J in 1 .. Sources.Last loop
|
||||
declare
|
||||
Deb : constant String :=
|
||||
Debug_File_Name (Sources.Table (J));
|
||||
Debug_File_Name (Sources.Table (J));
|
||||
Rep : constant String :=
|
||||
Repinfo_File_Name (Sources.Table (J));
|
||||
Repinfo_File_Name (Sources.Table (J));
|
||||
|
||||
begin
|
||||
if Is_Regular_File (Obj_Dir & Dir_Separator & Deb) then
|
||||
|
|
@ -513,9 +513,9 @@ package body Clean is
|
|||
if not Compile_Only then
|
||||
declare
|
||||
Source : constant File_Name_Type :=
|
||||
Strip_Suffix (Main_Lib_File);
|
||||
Strip_Suffix (Main_Lib_File);
|
||||
Executable : constant String :=
|
||||
Get_Name_String (Executable_Name (Source));
|
||||
Get_Name_String (Executable_Name (Source));
|
||||
begin
|
||||
if Is_Regular_File (Executable) then
|
||||
Delete ("", Executable);
|
||||
|
|
@ -548,7 +548,7 @@ package body Clean is
|
|||
then
|
||||
declare
|
||||
Directory : constant String :=
|
||||
Get_Name_String (Project.Library_Src_Dir.Display_Name);
|
||||
Get_Name_String (Project.Library_Src_Dir.Display_Name);
|
||||
|
||||
begin
|
||||
Change_Dir (Directory);
|
||||
|
|
@ -631,9 +631,9 @@ package body Clean is
|
|||
|
||||
Lib_Filename : constant String := Get_Name_String (Project.Library_Name);
|
||||
DLL_Name : String :=
|
||||
DLL_Prefix & Lib_Filename & "." & DLL_Ext;
|
||||
DLL_Prefix & Lib_Filename & "." & DLL_Ext;
|
||||
Archive_Name : String :=
|
||||
"lib" & Lib_Filename & "." & Archive_Ext;
|
||||
"lib" & Lib_Filename & "." & Archive_Ext;
|
||||
Direc : Dir_Type;
|
||||
|
||||
Name : String (1 .. 200);
|
||||
|
|
@ -656,11 +656,9 @@ package body Clean is
|
|||
|
||||
declare
|
||||
Lib_Directory : constant String :=
|
||||
Get_Name_String
|
||||
(Project.Library_Dir.Display_Name);
|
||||
Get_Name_String (Project.Library_Dir.Display_Name);
|
||||
Lib_ALI_Directory : constant String :=
|
||||
Get_Name_String
|
||||
(Project.Library_ALI_Dir.Display_Name);
|
||||
Get_Name_String (Project.Library_ALI_Dir.Display_Name);
|
||||
|
||||
begin
|
||||
Canonical_Case_File_Name (Archive_Name);
|
||||
|
|
@ -863,8 +861,7 @@ package body Clean is
|
|||
if Project.Object_Directory /= No_Path_Information then
|
||||
declare
|
||||
Obj_Dir : constant String :=
|
||||
Get_Name_String
|
||||
(Project.Object_Directory.Display_Name);
|
||||
Get_Name_String (Project.Object_Directory.Display_Name);
|
||||
|
||||
begin
|
||||
Change_Dir (Obj_Dir);
|
||||
|
|
@ -933,17 +930,17 @@ package body Clean is
|
|||
|
||||
declare
|
||||
Asm : constant String :=
|
||||
Assembly_File_Name (Lib_File);
|
||||
Assembly_File_Name (Lib_File);
|
||||
ALI : constant String :=
|
||||
ALI_File_Name (Lib_File);
|
||||
ALI_File_Name (Lib_File);
|
||||
Obj : constant String :=
|
||||
Object_File_Name (Lib_File);
|
||||
Object_File_Name (Lib_File);
|
||||
Adt : constant String :=
|
||||
Tree_File_Name (Lib_File);
|
||||
Tree_File_Name (Lib_File);
|
||||
Deb : constant String :=
|
||||
Debug_File_Name (File_Name1);
|
||||
Debug_File_Name (File_Name1);
|
||||
Rep : constant String :=
|
||||
Repinfo_File_Name (File_Name1);
|
||||
Repinfo_File_Name (File_Name1);
|
||||
Del : Boolean := True;
|
||||
|
||||
begin
|
||||
|
|
@ -1010,9 +1007,9 @@ package body Clean is
|
|||
if File_Name2 /= No_File then
|
||||
declare
|
||||
Deb : constant String :=
|
||||
Debug_File_Name (File_Name2);
|
||||
Debug_File_Name (File_Name2);
|
||||
Rep : constant String :=
|
||||
Repinfo_File_Name (File_Name2);
|
||||
Repinfo_File_Name (File_Name2);
|
||||
|
||||
begin
|
||||
if Is_Regular_File (Deb) then
|
||||
|
|
@ -1155,7 +1152,7 @@ package body Clean is
|
|||
then
|
||||
declare
|
||||
Exec_Dir : constant String :=
|
||||
Get_Name_String (Project.Exec_Directory.Display_Name);
|
||||
Get_Name_String (Project.Exec_Directory.Display_Name);
|
||||
|
||||
begin
|
||||
Change_Dir (Exec_Dir);
|
||||
|
|
@ -1173,7 +1170,7 @@ package body Clean is
|
|||
|
||||
declare
|
||||
Exec_File_Name : constant String :=
|
||||
Get_Name_String (Executable);
|
||||
Get_Name_String (Executable);
|
||||
|
||||
begin
|
||||
if Is_Absolute_Path (Name => Exec_File_Name) then
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
-- --
|
||||
-- B o d y --
|
||||
-- --
|
||||
-- Copyright (C) 1992-2011, Free Software Foundation, Inc. --
|
||||
-- Copyright (C) 1992-2012, 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- --
|
||||
|
|
@ -505,13 +505,12 @@ package body CStand is
|
|||
|
||||
procedure Pack_String_Type (String_Type : Entity_Id) is
|
||||
Prag : constant Node_Id :=
|
||||
Make_Pragma (Stloc,
|
||||
Chars => Name_Pack,
|
||||
Pragma_Argument_Associations =>
|
||||
New_List (
|
||||
Make_Pragma_Argument_Association (Stloc,
|
||||
Expression =>
|
||||
New_Occurrence_Of (String_Type, Stloc))));
|
||||
Make_Pragma (Stloc,
|
||||
Chars => Name_Pack,
|
||||
Pragma_Argument_Associations =>
|
||||
New_List (
|
||||
Make_Pragma_Argument_Association (Stloc,
|
||||
Expression => New_Occurrence_Of (String_Type, Stloc))));
|
||||
begin
|
||||
Append (Prag, Decl_S);
|
||||
Record_Rep_Item (String_Type, Prag);
|
||||
|
|
|
|||
|
|
@ -6214,25 +6214,25 @@ package body Einfo is
|
|||
-- Global flag table allowing rapid computation of this function
|
||||
|
||||
Entity_Is_Base_Type : constant array (Entity_Kind) of Boolean :=
|
||||
(E_Enumeration_Subtype |
|
||||
E_Incomplete_Type |
|
||||
E_Signed_Integer_Subtype |
|
||||
E_Modular_Integer_Subtype |
|
||||
E_Floating_Point_Subtype |
|
||||
E_Ordinary_Fixed_Point_Subtype |
|
||||
E_Decimal_Fixed_Point_Subtype |
|
||||
E_Array_Subtype |
|
||||
E_String_Subtype |
|
||||
E_Record_Subtype |
|
||||
E_Private_Subtype |
|
||||
E_Record_Subtype_With_Private |
|
||||
E_Limited_Private_Subtype |
|
||||
E_Access_Subtype |
|
||||
E_Protected_Subtype |
|
||||
E_Task_Subtype |
|
||||
E_String_Literal_Subtype |
|
||||
E_Class_Wide_Subtype => False,
|
||||
others => True);
|
||||
(E_Enumeration_Subtype |
|
||||
E_Incomplete_Type |
|
||||
E_Signed_Integer_Subtype |
|
||||
E_Modular_Integer_Subtype |
|
||||
E_Floating_Point_Subtype |
|
||||
E_Ordinary_Fixed_Point_Subtype |
|
||||
E_Decimal_Fixed_Point_Subtype |
|
||||
E_Array_Subtype |
|
||||
E_String_Subtype |
|
||||
E_Record_Subtype |
|
||||
E_Private_Subtype |
|
||||
E_Record_Subtype_With_Private |
|
||||
E_Limited_Private_Subtype |
|
||||
E_Access_Subtype |
|
||||
E_Protected_Subtype |
|
||||
E_Task_Subtype |
|
||||
E_String_Literal_Subtype |
|
||||
E_Class_Wide_Subtype => False,
|
||||
others => True);
|
||||
|
||||
function Is_Base_Type (Id : E) return Boolean is
|
||||
begin
|
||||
|
|
|
|||
|
|
@ -2445,7 +2445,7 @@ package body Errout is
|
|||
if Sloc (Error_Msg_Node_1) > Standard_Location then
|
||||
declare
|
||||
Iloc : constant Source_Ptr :=
|
||||
Instantiation_Location (Sloc (Error_Msg_Node_1));
|
||||
Instantiation_Location (Sloc (Error_Msg_Node_1));
|
||||
|
||||
begin
|
||||
if Iloc /= No_Location
|
||||
|
|
@ -2938,7 +2938,7 @@ package body Errout is
|
|||
if Is_Itype (Ent) then
|
||||
declare
|
||||
Assoc : constant Node_Id :=
|
||||
Associated_Node_For_Itype (Ent);
|
||||
Associated_Node_For_Itype (Ent);
|
||||
|
||||
begin
|
||||
if Nkind (Assoc) in N_Subprogram_Specification then
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
-- --
|
||||
-- B o d y --
|
||||
-- --
|
||||
-- Copyright (C) 1992-2010, Free Software Foundation, Inc. --
|
||||
-- Copyright (C) 1992-2012, 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- --
|
||||
|
|
@ -41,7 +41,7 @@ package body Eval_Fat is
|
|||
type Radix_Power_Table is array (Int range 1 .. 4) of Int;
|
||||
|
||||
Radix_Powers : constant Radix_Power_Table :=
|
||||
(Radix ** 1, Radix ** 2, Radix ** 3, Radix ** 4);
|
||||
(Radix ** 1, Radix ** 2, Radix ** 3, Radix ** 4);
|
||||
|
||||
-----------------------
|
||||
-- Local Subprograms --
|
||||
|
|
@ -188,7 +188,7 @@ package body Eval_Fat is
|
|||
-- True iff Fraction is even
|
||||
|
||||
Most_Significant_Digit : constant UI :=
|
||||
Radix ** (Machine_Mantissa_Value (RT) - 1);
|
||||
Radix ** (Machine_Mantissa_Value (RT) - 1);
|
||||
|
||||
Uintp_Mark : Uintp.Save_Mark;
|
||||
-- The code is divided into blocks that systematically release
|
||||
|
|
|
|||
|
|
@ -321,17 +321,13 @@ package body Exp_Aggr is
|
|||
-- components.
|
||||
|
||||
Max_Aggr_Size : constant Nat :=
|
||||
5000 + (2 ** 24 - 5000) *
|
||||
Boolean'Pos
|
||||
(Restriction_Active (No_Elaboration_Code)
|
||||
or else
|
||||
Restriction_Active (No_Implicit_Loops)
|
||||
or else
|
||||
Is_Two_Dim_Packed_Array (Typ)
|
||||
or else
|
||||
((Ekind (Current_Scope) = E_Package
|
||||
and then
|
||||
Static_Elaboration_Desired (Current_Scope))));
|
||||
5000 + (2 ** 24 - 5000) *
|
||||
Boolean'Pos
|
||||
(Restriction_Active (No_Elaboration_Code)
|
||||
or else Restriction_Active (No_Implicit_Loops)
|
||||
or else Is_Two_Dim_Packed_Array (Typ)
|
||||
or else ((Ekind (Current_Scope) = E_Package
|
||||
and then Static_Elaboration_Desired (Current_Scope))));
|
||||
|
||||
function Component_Count (T : Entity_Id) return Int;
|
||||
-- The limit is applied to the total number of components that the
|
||||
|
|
@ -363,9 +359,9 @@ package body Exp_Aggr is
|
|||
elsif Is_Array_Type (T) then
|
||||
declare
|
||||
Lo : constant Node_Id :=
|
||||
Type_Low_Bound (Etype (First_Index (T)));
|
||||
Type_Low_Bound (Etype (First_Index (T)));
|
||||
Hi : constant Node_Id :=
|
||||
Type_High_Bound (Etype (First_Index (T)));
|
||||
Type_High_Bound (Etype (First_Index (T)));
|
||||
|
||||
Siz : constant Int := Component_Count (Component_Type (T));
|
||||
|
||||
|
|
@ -423,9 +419,8 @@ package body Exp_Aggr is
|
|||
then
|
||||
declare
|
||||
Index_Type : constant Entity_Id :=
|
||||
Etype
|
||||
(First_Index
|
||||
(Etype (Defining_Identifier (Parent (N)))));
|
||||
Etype
|
||||
(First_Index (Etype (Defining_Identifier (Parent (N)))));
|
||||
Indx : Node_Id;
|
||||
|
||||
begin
|
||||
|
|
@ -2526,8 +2521,7 @@ package body Exp_Aggr is
|
|||
and then CPP_Num_Prims (Typ) > 0
|
||||
then
|
||||
Invoke_Constructor : declare
|
||||
CPP_Parent : constant Entity_Id :=
|
||||
Enclosing_CPP_Parent (Typ);
|
||||
CPP_Parent : constant Entity_Id := Enclosing_CPP_Parent (Typ);
|
||||
|
||||
procedure Invoke_IC_Proc (T : Entity_Id);
|
||||
-- Recursive routine used to climb to parents. Required because
|
||||
|
|
@ -2720,19 +2714,18 @@ package body Exp_Aggr is
|
|||
SubE : constant Entity_Id := Make_Temporary (Loc, 'T');
|
||||
|
||||
SubD : constant Node_Id :=
|
||||
Make_Subtype_Declaration (Loc,
|
||||
Defining_Identifier => SubE,
|
||||
Subtype_Indication =>
|
||||
Make_Subtype_Indication (Loc,
|
||||
Subtype_Mark =>
|
||||
New_Reference_To
|
||||
(Etype (Comp_Type), Loc),
|
||||
Constraint =>
|
||||
Make_Index_Or_Discriminant_Constraint
|
||||
(Loc,
|
||||
Constraints => New_List (
|
||||
New_Copy_Tree
|
||||
(Aggregate_Bounds (Expr_Q))))));
|
||||
Make_Subtype_Declaration (Loc,
|
||||
Defining_Identifier => SubE,
|
||||
Subtype_Indication =>
|
||||
Make_Subtype_Indication (Loc,
|
||||
Subtype_Mark =>
|
||||
New_Reference_To (Etype (Comp_Type), Loc),
|
||||
Constraint =>
|
||||
Make_Index_Or_Discriminant_Constraint
|
||||
(Loc,
|
||||
Constraints => New_List (
|
||||
New_Copy_Tree
|
||||
(Aggregate_Bounds (Expr_Q))))));
|
||||
|
||||
-- Create a temporary array of the above subtype which
|
||||
-- will be used to capture the aggregate assignments.
|
||||
|
|
@ -2740,10 +2733,9 @@ package body Exp_Aggr is
|
|||
TmpE : constant Entity_Id := Make_Temporary (Loc, 'A', N);
|
||||
|
||||
TmpD : constant Node_Id :=
|
||||
Make_Object_Declaration (Loc,
|
||||
Defining_Identifier => TmpE,
|
||||
Object_Definition =>
|
||||
New_Reference_To (SubE, Loc));
|
||||
Make_Object_Declaration (Loc,
|
||||
Defining_Identifier => TmpE,
|
||||
Object_Definition => New_Reference_To (SubE, Loc));
|
||||
|
||||
begin
|
||||
Set_No_Initialization (TmpD);
|
||||
|
|
@ -2964,9 +2956,8 @@ package body Exp_Aggr is
|
|||
Temp : constant Entity_Id := Defining_Identifier (Decl);
|
||||
|
||||
Occ : constant Node_Id :=
|
||||
Unchecked_Convert_To (Typ,
|
||||
Make_Explicit_Dereference (Loc,
|
||||
New_Reference_To (Temp, Loc)));
|
||||
Unchecked_Convert_To (Typ,
|
||||
Make_Explicit_Dereference (Loc, New_Reference_To (Temp, Loc)));
|
||||
|
||||
begin
|
||||
if Is_Array_Type (Typ) then
|
||||
|
|
@ -3549,7 +3540,7 @@ package body Exp_Aggr is
|
|||
|
||||
declare
|
||||
P : constant Entity_Id :=
|
||||
Cunit_Entity (Current_Sem_Unit);
|
||||
Cunit_Entity (Current_Sem_Unit);
|
||||
|
||||
begin
|
||||
-- Check if duplication OK and if so continue
|
||||
|
|
@ -3848,7 +3839,7 @@ package body Exp_Aggr is
|
|||
-- possible, provided other conditions are met on the LHS.
|
||||
|
||||
Others_Present : array (1 .. Aggr_Dimension) of Boolean :=
|
||||
(others => False);
|
||||
(others => False);
|
||||
-- If Others_Present (J) is True, then there is an others choice
|
||||
-- in one of the sub-aggregates of N at dimension J.
|
||||
|
||||
|
|
@ -5793,11 +5784,10 @@ package body Exp_Aggr is
|
|||
elsif Tagged_Type_Expansion then
|
||||
declare
|
||||
Tag_Name : constant Node_Id :=
|
||||
New_Occurrence_Of
|
||||
(First_Tag_Component (Typ), Loc);
|
||||
New_Occurrence_Of (First_Tag_Component (Typ), Loc);
|
||||
Typ_Tag : constant Entity_Id := RTE (RE_Tag);
|
||||
Conv_Node : constant Node_Id :=
|
||||
Unchecked_Convert_To (Typ_Tag, Tag_Value);
|
||||
Unchecked_Convert_To (Typ_Tag, Tag_Value);
|
||||
|
||||
begin
|
||||
Set_Etype (Conv_Node, Typ_Tag);
|
||||
|
|
|
|||
Loading…
Reference in New Issue