MichaelAgarkov/CodeBlocksPortable
MichaelAgarkov/CodeBlocksPortable
Archived
1
1
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity
This repository has been archived on 2024-12-16. You can view files and clone it, but cannot push or open issues or pull requests.
CodeBlocksPortable/MinGW/lib/gcc/mingw32/6.3.0/adainclude/a-calend.adb

1579 lines
49 KiB
Ada
Raw Normal View History

My portable distribution of Code::Blocks
2024-07-04 16:52:56 +00:00
------------------------------------------------------------------------------
-- --
-- GNAT RUN-TIME COMPONENTS --
-- --
-- A D A . C A L E N D A R --
-- --
-- B o d y --
-- --
-- Copyright (C) 1992-2014, Free Software Foundation, Inc. --
-- --
-- GNAT is free software; you can redistribute it and/or modify it under --
-- terms of the GNU General Public License as published by the Free Soft- --
-- ware Foundation; either version 3, or (at your option) any later ver- --
-- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
-- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
-- or FITNESS FOR A PARTICULAR PURPOSE. --
-- --
-- As a special exception under Section 7 of GPL version 3, you are granted --
-- additional permissions described in the GCC Runtime Library Exception, --
-- version 3.1, as published by the Free Software Foundation. --
-- --
-- You should have received a copy of the GNU General Public License and --
-- a copy of the GCC Runtime Library Exception along with this program; --
-- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see --
-- <http://www.gnu.org/licenses/>. --
-- --
-- GNAT was originally developed by the GNAT team at New York University. --
-- Extensive contributions were provided by Ada Core Technologies Inc. --
-- --
------------------------------------------------------------------------------
with Ada.Unchecked_Conversion;
with Interfaces.C;
with System.OS_Primitives;
package body Ada.Calendar is
--------------------------
-- Implementation Notes --
--------------------------
-- In complex algorithms, some variables of type Ada.Calendar.Time carry
-- suffix _S or _N to denote units of seconds or nanoseconds.
--
-- Because time is measured in different units and from different origins
-- on various targets, a system independent model is incorporated into
-- Ada.Calendar. The idea behind the design is to encapsulate all target
-- dependent machinery in a single package, thus providing a uniform
-- interface to all existing and any potential children.
-- package Ada.Calendar
-- procedure Split (5 parameters) -------+
-- | Call from local routine
-- private |
-- package Formatting_Operations |
-- procedure Split (11 parameters) <--+
-- end Formatting_Operations |
-- end Ada.Calendar |
-- |
-- package Ada.Calendar.Formatting | Call from child routine
-- procedure Split (9 or 10 parameters) -+
-- end Ada.Calendar.Formatting
-- The behavior of the interfacing routines is controlled via various
-- flags. All new Ada 2005 types from children of Ada.Calendar are
-- emulated by a similar type. For instance, type Day_Number is replaced
-- by Integer in various routines. One ramification of this model is that
-- the caller site must perform validity checks on returned results.
-- The end result of this model is the lack of target specific files per
-- child of Ada.Calendar (e.g. a-calfor).
-----------------------
-- Local Subprograms --
-----------------------
procedure Check_Within_Time_Bounds (T : Time_Rep);
-- Ensure that a time representation value falls withing the bounds of Ada
-- time. Leap seconds support is taken into account.
procedure Cumulative_Leap_Seconds
(Start_Date : Time_Rep;
End_Date : Time_Rep;
Elapsed_Leaps : out Natural;
Next_Leap : out Time_Rep);
-- Elapsed_Leaps is the sum of the leap seconds that have occurred on or
-- after Start_Date and before (strictly before) End_Date. Next_Leap_Sec
-- represents the next leap second occurrence on or after End_Date. If
-- there are no leaps seconds after End_Date, End_Of_Time is returned.
-- End_Of_Time can be used as End_Date to count all the leap seconds that
-- have occurred on or after Start_Date.
--
-- Note: Any sub seconds of Start_Date and End_Date are discarded before
-- the calculations are done. For instance: if 113 seconds is a leap
-- second (it isn't) and 113.5 is input as an End_Date, the leap second
-- at 113 will not be counted in Leaps_Between, but it will be returned
-- as Next_Leap_Sec. Thus, if the caller wants to know if the End_Date is
-- a leap second, the comparison should be:
--
-- End_Date >= Next_Leap_Sec;
--
-- After_Last_Leap is designed so that this comparison works without
-- having to first check if Next_Leap_Sec is a valid leap second.
function Duration_To_Time_Rep is
new Ada.Unchecked_Conversion (Duration, Time_Rep);
-- Convert a duration value into a time representation value
function Time_Rep_To_Duration is
new Ada.Unchecked_Conversion (Time_Rep, Duration);
-- Convert a time representation value into a duration value
function UTC_Time_Offset
(Date : Time;
Is_Historic : Boolean) return Long_Integer;
-- This routine acts as an Ada wrapper around __gnat_localtime_tzoff which
-- in turn utilizes various OS-dependent mechanisms to calculate the time
-- zone offset of a date. Formal parameter Date represents an arbitrary
-- time stamp, either in the past, now, or in the future. If the flag
-- Is_Historic is set, this routine would try to calculate to the best of
-- the OS's abilities the time zone offset that was or will be in effect
-- on Date. If the flag is set to False, the routine returns the current
-- time zone with Date effectively set to Clock.
--
-- NOTE: Targets which support localtime_r will aways return a historic
-- time zone even if flag Is_Historic is set to False because this is how
-- localtime_r operates.
-----------------
-- Local Types --
-----------------
-- An integer time duration. The type is used whenever a positive elapsed
-- duration is needed, for instance when splitting a time value. Here is
-- how Time_Rep and Time_Dur are related:
-- 'First Ada_Low Ada_High 'Last
-- Time_Rep: +-------+------------------------+---------+
-- Time_Dur: +------------------------+---------+
-- 0 'Last
type Time_Dur is range 0 .. 2 ** 63 - 1;
--------------------------
-- Leap seconds control --
--------------------------
Flag : Integer;
pragma Import (C, Flag, "__gl_leap_seconds_support");
-- This imported value is used to determine whether the compilation had
-- binder flag "-y" present which enables leap seconds. A value of zero
-- signifies no leap seconds support while a value of one enables support.
Leap_Support : constant Boolean := (Flag = 1);
-- Flag to controls the usage of leap seconds in all Ada.Calendar routines
Leap_Seconds_Count : constant Natural := 25;
---------------------
-- Local Constants --
---------------------
Ada_Min_Year : constant Year_Number := Year_Number'First;
Secs_In_Four_Years : constant := (3 * 365 + 366) * Secs_In_Day;
Secs_In_Non_Leap_Year : constant := 365 * Secs_In_Day;
Nanos_In_Four_Years : constant := Secs_In_Four_Years * Nano;
-- Lower and upper bound of Ada time. The zero (0) value of type Time is
-- positioned at year 2150. Note that the lower and upper bound account
-- for the non-leap centennial years.
Ada_Low : constant Time_Rep := -(61 * 366 + 188 * 365) * Nanos_In_Day;
Ada_High : constant Time_Rep := (60 * 366 + 190 * 365) * Nanos_In_Day;
-- Even though the upper bound of time is 2399-12-31 23:59:59.999999999
-- 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;
-- 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;
Start_Of_Time : constant Time_Rep :=
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;
-- 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;
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
-- nanoseconds. Note that year 2100 is non-leap.
Cumulative_Days_Before_Month :
constant array (Month_Number) of Natural :=
(0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334);
-- The following table contains the hard time values of all existing leap
-- seconds. The values are produced by the utility program xleaps.adb. This
-- must be updated when additional leap second times are defined.
Leap_Second_Times : constant array (1 .. Leap_Seconds_Count) of Time_Rep :=
(-5601484800000000000,
-5585587199000000000,
-5554051198000000000,
-5522515197000000000,
-5490979196000000000,
-5459356795000000000,
-5427820794000000000,
-5396284793000000000,
-5364748792000000000,
-5317487991000000000,
-5285951990000000000,
-5254415989000000000,
-5191257588000000000,
-5112287987000000000,
-5049129586000000000,
-5017593585000000000,
-4970332784000000000,
-4938796783000000000,
-4907260782000000000,
-4859827181000000000,
-4812566380000000000,
-4765132779000000000,
-4544207978000000000,
-4449513577000000000,
-4339180776000000000);
---------
-- "+" --
---------
function "+" (Left : Time; Right : Duration) return Time is
pragma Unsuppress (Overflow_Check);
Left_N : constant Time_Rep := Time_Rep (Left);
begin
return Time (Left_N + Duration_To_Time_Rep (Right));
exception
when Constraint_Error =>
raise Time_Error;
end "+";
function "+" (Left : Duration; Right : Time) return Time is
begin
return Right + Left;
end "+";
---------
-- "-" --
---------
function "-" (Left : Time; Right : Duration) return Time is
pragma Unsuppress (Overflow_Check);
Left_N : constant Time_Rep := Time_Rep (Left);
begin
return Time (Left_N - Duration_To_Time_Rep (Right));
exception
when Constraint_Error =>
raise Time_Error;
end "-";
function "-" (Left : Time; Right : Time) return Duration is
pragma Unsuppress (Overflow_Check);
Dur_Low : constant Time_Rep := Duration_To_Time_Rep (Duration'First);
Dur_High : constant Time_Rep := Duration_To_Time_Rep (Duration'Last);
-- The bounds of type Duration expressed as time representations
Res_N : Time_Rep;
begin
Res_N := Time_Rep (Left) - Time_Rep (Right);
-- Due to the extended range of Ada time, "-" is capable of producing
-- results which may exceed the range of Duration. In order to prevent
-- the generation of bogus values by the Unchecked_Conversion, we apply
-- the following check.
if Res_N < Dur_Low or else Res_N > Dur_High then
raise Time_Error;
end if;
return Time_Rep_To_Duration (Res_N);
exception
when Constraint_Error =>
raise Time_Error;
end "-";
---------
-- "<" --
---------
function "<" (Left, Right : Time) return Boolean is
begin
return Time_Rep (Left) < Time_Rep (Right);
end "<";
----------
-- "<=" --
----------
function "<=" (Left, Right : Time) return Boolean is
begin
return Time_Rep (Left) <= Time_Rep (Right);
end "<=";
---------
-- ">" --
---------
function ">" (Left, Right : Time) return Boolean is
begin
return Time_Rep (Left) > Time_Rep (Right);
end ">";
----------
-- ">=" --
----------
function ">=" (Left, Right : Time) return Boolean is
begin
return Time_Rep (Left) >= Time_Rep (Right);
end ">=";
------------------------------
-- Check_Within_Time_Bounds --
------------------------------
procedure Check_Within_Time_Bounds (T : Time_Rep) is
begin
if Leap_Support then
if T < Ada_Low or else T > Ada_High_And_Leaps then
raise Time_Error;
end if;
else
if T < Ada_Low or else T > Ada_High then
raise Time_Error;
end if;
end if;
end Check_Within_Time_Bounds;
-----------
-- Clock --
-----------
function Clock return Time is
Elapsed_Leaps : Natural;
Next_Leap_N : Time_Rep;
-- The system clock returns the time in UTC since the Unix Epoch of
-- 1970-01-01 00:00:00.0. We perform an origin shift to the Ada Epoch
-- by adding the number of nanoseconds between the two origins.
Res_N : Time_Rep :=
Duration_To_Time_Rep (System.OS_Primitives.Clock) + Unix_Min;
begin
-- If the target supports leap seconds, determine the number of leap
-- seconds elapsed until this moment.
if Leap_Support then
Cumulative_Leap_Seconds
(Start_Of_Time, Res_N, Elapsed_Leaps, Next_Leap_N);
-- The system clock may fall exactly on a leap second
if Res_N >= Next_Leap_N then
Elapsed_Leaps := Elapsed_Leaps + 1;
end if;
-- The target does not support leap seconds
else
Elapsed_Leaps := 0;
end if;
Res_N := Res_N + Time_Rep (Elapsed_Leaps) * Nano;
return Time (Res_N);
end Clock;
-----------------------------
-- Cumulative_Leap_Seconds --
-----------------------------
procedure Cumulative_Leap_Seconds
(Start_Date : Time_Rep;
End_Date : Time_Rep;
Elapsed_Leaps : out Natural;
Next_Leap : out Time_Rep)
is
End_Index : Positive;
End_T : Time_Rep := End_Date;
Start_Index : Positive;
Start_T : Time_Rep := Start_Date;
begin
-- Both input dates must be normalized to UTC
pragma Assert (Leap_Support and then End_Date >= Start_Date);
Next_Leap := End_Of_Time;
-- Make sure that the end date does not exceed the upper bound
-- of Ada time.
if End_Date > Ada_High then
End_T := Ada_High;
end if;
-- Remove the sub seconds from both dates
Start_T := Start_T - (Start_T mod Nano);
End_T := End_T - (End_T mod Nano);
-- Some trivial cases:
-- Leap 1 . . . Leap N
-- ---+========+------+############+-------+========+-----
-- Start_T End_T Start_T End_T
if End_T < Leap_Second_Times (1) then
Elapsed_Leaps := 0;
Next_Leap := Leap_Second_Times (1);
return;
elsif Start_T > Leap_Second_Times (Leap_Seconds_Count) then
Elapsed_Leaps := 0;
Next_Leap := End_Of_Time;
return;
end if;
-- Perform the calculations only if the start date is within the leap
-- second occurrences table.
if Start_T <= Leap_Second_Times (Leap_Seconds_Count) then
-- 1 2 N - 1 N
-- +----+----+-- . . . --+-------+---+
-- | T1 | T2 | | N - 1 | N |
-- +----+----+-- . . . --+-------+---+
-- ^ ^
-- | Start_Index | End_Index
-- +-------------------+
-- Leaps_Between
-- The idea behind the algorithm is to iterate and find two
-- closest dates which are after Start_T and End_T. Their
-- corresponding index difference denotes the number of leap
-- seconds elapsed.
Start_Index := 1;
loop
exit when Leap_Second_Times (Start_Index) >= Start_T;
Start_Index := Start_Index + 1;
end loop;
End_Index := Start_Index;
loop
exit when End_Index > Leap_Seconds_Count
or else Leap_Second_Times (End_Index) >= End_T;
End_Index := End_Index + 1;
end loop;
if End_Index <= Leap_Seconds_Count then
Next_Leap := Leap_Second_Times (End_Index);
end if;
Elapsed_Leaps := End_Index - Start_Index;
else
Elapsed_Leaps := 0;
end if;
end Cumulative_Leap_Seconds;
---------
-- Day --
---------
function Day (Date : Time) return Day_Number is
D : Day_Number;
Y : Year_Number;
M : Month_Number;
S : Day_Duration;
pragma Unreferenced (Y, M, S);
begin
Split (Date, Y, M, D, S);
return D;
end Day;
-------------
-- Is_Leap --
-------------
function Is_Leap (Year : Year_Number) return Boolean is
begin
-- Leap centennial years
if Year mod 400 = 0 then
return True;
-- Non-leap centennial years
elsif Year mod 100 = 0 then
return False;
-- Regular years
else
return Year mod 4 = 0;
end if;
end Is_Leap;
-----------
-- Month --
-----------
function Month (Date : Time) return Month_Number is
Y : Year_Number;
M : Month_Number;
D : Day_Number;
S : Day_Duration;
pragma Unreferenced (Y, D, S);
begin
Split (Date, Y, M, D, S);
return M;
end Month;
-------------
-- Seconds --
-------------
function Seconds (Date : Time) return Day_Duration is
Y : Year_Number;
M : Month_Number;
D : Day_Number;
S : Day_Duration;
pragma Unreferenced (Y, M, D);
begin
Split (Date, Y, M, D, S);
return S;
end Seconds;
-----------
-- Split --
-----------
procedure Split
(Date : Time;
Year : out Year_Number;
Month : out Month_Number;
Day : out Day_Number;
Seconds : out Day_Duration)
is
H : Integer;
M : Integer;
Se : Integer;
Ss : Duration;
Le : Boolean;
pragma Unreferenced (H, M, Se, Ss, Le);
begin
-- Even though the input time zone is UTC (0), the flag Use_TZ will
-- ensure that Split picks up the local time zone.
Formatting_Operations.Split
(Date => Date,
Year => Year,
Month => Month,
Day => Day,
Day_Secs => Seconds,
Hour => H,
Minute => M,
Second => Se,
Sub_Sec => Ss,
Leap_Sec => Le,
Use_TZ => False,
Is_Historic => True,
Time_Zone => 0);
-- Validity checks
if not Year'Valid or else
not Month'Valid or else
not Day'Valid or else
not Seconds'Valid
then
raise Time_Error;
end if;
end Split;
-------------
-- Time_Of --
-------------
function Time_Of
(Year : Year_Number;
Month : Month_Number;
Day : Day_Number;
Seconds : Day_Duration := 0.0) return Time
is
-- The values in the following constants are irrelevant, they are just
-- placeholders; the choice of constructing a Day_Duration value is
-- controlled by the Use_Day_Secs flag.
H : constant Integer := 1;
M : constant Integer := 1;
Se : constant Integer := 1;
Ss : constant Duration := 0.1;
begin
-- Validity checks
if not Year'Valid or else
not Month'Valid or else
not Day'Valid or else
not Seconds'Valid
then
raise Time_Error;
end if;
-- Even though the input time zone is UTC (0), the flag Use_TZ will
-- ensure that Split picks up the local time zone.
return
Formatting_Operations.Time_Of
(Year => Year,
Month => Month,
Day => Day,
Day_Secs => Seconds,
Hour => H,
Minute => M,
Second => Se,
Sub_Sec => Ss,
Leap_Sec => False,
Use_Day_Secs => True,
Use_TZ => False,
Is_Historic => True,
Time_Zone => 0);
end Time_Of;
---------------------
-- UTC_Time_Offset --
---------------------
function UTC_Time_Offset
(Date : Time;
Is_Historic : Boolean) return Long_Integer
is
-- The following constants denote February 28 during non-leap centennial
-- years, the units are nanoseconds.
T_2100_2_28 : constant Time_Rep := Ada_Low +
(Time_Rep (49 * 366 + 150 * 365 + 59) * Secs_In_Day +
Time_Rep (Leap_Seconds_Count)) * Nano;
T_2200_2_28 : constant Time_Rep := Ada_Low +
(Time_Rep (73 * 366 + 226 * 365 + 59) * Secs_In_Day +
Time_Rep (Leap_Seconds_Count)) * Nano;
T_2300_2_28 : constant Time_Rep := Ada_Low +
(Time_Rep (97 * 366 + 302 * 365 + 59) * Secs_In_Day +
Time_Rep (Leap_Seconds_Count)) * Nano;
-- 56 years (14 leap years + 42 non-leap years) in nanoseconds:
Nanos_In_56_Years : constant := (14 * 366 + 42 * 365) * Nanos_In_Day;
type int_Pointer is access all Interfaces.C.int;
type long_Pointer is access all Interfaces.C.long;
type time_t is
range -(2 ** (Standard'Address_Size - Integer'(1))) ..
+(2 ** (Standard'Address_Size - Integer'(1)) - 1);
type time_t_Pointer is access all time_t;
procedure localtime_tzoff
(timer : time_t_Pointer;
is_historic : int_Pointer;
off : long_Pointer);
pragma Import (C, localtime_tzoff, "__gnat_localtime_tzoff");
-- This routine is a interfacing wrapper around the library function
-- __gnat_localtime_tzoff. Parameter 'timer' represents a Unix-based
-- time equivalent of the input date. If flag 'is_historic' is set, this
-- routine would try to calculate to the best of the OS's abilities the
-- time zone offset that was or will be in effect on 'timer'. If the
-- flag is set to False, the routine returns the current time zone
-- regardless of what 'timer' designates. Parameter 'off' captures the
-- UTC offset of 'timer'.
Adj_Cent : Integer;
Date_N : Time_Rep;
Flag : aliased Interfaces.C.int;
Offset : aliased Interfaces.C.long;
Secs_T : aliased time_t;
-- Start of processing for UTC_Time_Offset
begin
Date_N := Time_Rep (Date);
-- Dates which are 56 years apart fall on the same day, day light saving
-- and so on. Non-leap centennial years violate this rule by one day and
-- as a consequence, special adjustment is needed.
Adj_Cent :=
(if Date_N <= T_2100_2_28 then 0
elsif Date_N <= T_2200_2_28 then 1
elsif Date_N <= T_2300_2_28 then 2
else 3);
if Adj_Cent > 0 then
Date_N := Date_N - Time_Rep (Adj_Cent) * Nanos_In_Day;
end if;
-- Shift the date within bounds of Unix time
while Date_N < Unix_Min loop
Date_N := Date_N + Nanos_In_56_Years;
end loop;
while Date_N >= Unix_Max loop
Date_N := Date_N - Nanos_In_56_Years;
end loop;
-- Perform a shift in origins from Ada to Unix
Date_N := Date_N - Unix_Min;
-- Convert the date into seconds
Secs_T := time_t (Date_N / Nano);
-- Determine whether to treat the input date as historical or not. A
-- value of "0" signifies that the date is NOT historic.
Flag := (if Is_Historic then 1 else 0);
localtime_tzoff
(Secs_T'Unchecked_Access,
Flag'Unchecked_Access,
Offset'Unchecked_Access);
return Long_Integer (Offset);
end UTC_Time_Offset;
----------
-- Year --
----------
function Year (Date : Time) return Year_Number is
Y : Year_Number;
M : Month_Number;
D : Day_Number;
S : Day_Duration;
pragma Unreferenced (M, D, S);
begin
Split (Date, Y, M, D, S);
return Y;
end Year;
-- The following packages assume that Time is a signed 64 bit integer
-- type, the units are nanoseconds and the origin is the start of Ada
-- time (1901-01-01 00:00:00.0 UTC).
---------------------------
-- Arithmetic_Operations --
---------------------------
package body Arithmetic_Operations is
---------
-- Add --
---------
function Add (Date : Time; Days : Long_Integer) return Time is
pragma Unsuppress (Overflow_Check);
Date_N : constant Time_Rep := Time_Rep (Date);
begin
return Time (Date_N + Time_Rep (Days) * Nanos_In_Day);
exception
when Constraint_Error =>
raise Time_Error;
end Add;
----------------
-- Difference --
----------------
procedure Difference
(Left : Time;
Right : Time;
Days : out Long_Integer;
Seconds : out Duration;
Leap_Seconds : out Integer)
is
Res_Dur : Time_Dur;
Earlier : Time_Rep;
Elapsed_Leaps : Natural;
Later : Time_Rep;
Negate : Boolean := False;
Next_Leap_N : Time_Rep;
Sub_Secs : Duration;
Sub_Secs_Diff : Time_Rep;
begin
-- Both input time values are assumed to be in UTC
if Left >= Right then
Later := Time_Rep (Left);
Earlier := Time_Rep (Right);
else
Later := Time_Rep (Right);
Earlier := Time_Rep (Left);
Negate := True;
end if;
-- If the target supports leap seconds, process them
if Leap_Support then
Cumulative_Leap_Seconds
(Earlier, Later, Elapsed_Leaps, Next_Leap_N);
if Later >= Next_Leap_N then
Elapsed_Leaps := Elapsed_Leaps + 1;
end if;
-- The target does not support leap seconds
else
Elapsed_Leaps := 0;
end if;
-- Sub seconds processing. We add the resulting difference to one
-- of the input dates in order to account for any potential rounding
-- of the difference in the next step.
Sub_Secs_Diff := Later mod Nano - Earlier mod Nano;
Earlier := Earlier + Sub_Secs_Diff;
Sub_Secs := Duration (Sub_Secs_Diff) / Nano_F;
-- Difference processing. This operation should be able to calculate
-- the difference between opposite values which are close to the end
-- and start of Ada time. To accommodate the large range, we convert
-- to seconds. This action may potentially round the two values and
-- either add or drop a second. We compensate for this issue in the
-- previous step.
Res_Dur :=
Time_Dur (Later / Nano - Earlier / Nano) - Time_Dur (Elapsed_Leaps);
Days := Long_Integer (Res_Dur / Secs_In_Day);
Seconds := Duration (Res_Dur mod Secs_In_Day) + Sub_Secs;
Leap_Seconds := Integer (Elapsed_Leaps);
if Negate then
Days := -Days;
Seconds := -Seconds;
if Leap_Seconds /= 0 then
Leap_Seconds := -Leap_Seconds;
end if;
end if;
end Difference;
--------------
-- Subtract --
--------------
function Subtract (Date : Time; Days : Long_Integer) return Time is
pragma Unsuppress (Overflow_Check);
Date_N : constant Time_Rep := Time_Rep (Date);
begin
return Time (Date_N - Time_Rep (Days) * Nanos_In_Day);
exception
when Constraint_Error =>
raise Time_Error;
end Subtract;
end Arithmetic_Operations;
---------------------------
-- Conversion_Operations --
---------------------------
package body Conversion_Operations is
-----------------
-- To_Ada_Time --
-----------------
function To_Ada_Time (Unix_Time : Long_Integer) return Time is
pragma Unsuppress (Overflow_Check);
Unix_Rep : constant Time_Rep := Time_Rep (Unix_Time) * Nano;
begin
return Time (Unix_Rep - Epoch_Offset);
exception
when Constraint_Error =>
raise Time_Error;
end To_Ada_Time;
-----------------
-- To_Ada_Time --
-----------------
function To_Ada_Time
(tm_year : Integer;
tm_mon : Integer;
tm_day : Integer;
tm_hour : Integer;
tm_min : Integer;
tm_sec : Integer;
tm_isdst : Integer) return Time
is
pragma Unsuppress (Overflow_Check);
Year : Year_Number;
Month : Month_Number;
Day : Day_Number;
Second : Integer;
Leap : Boolean;
Result : Time_Rep;
begin
-- Input processing
Year := Year_Number (1900 + tm_year);
Month := Month_Number (1 + tm_mon);
Day := Day_Number (tm_day);
-- Step 1: Validity checks of input values
if not Year'Valid or else not Month'Valid or else not Day'Valid
or else tm_hour not in 0 .. 24
or else tm_min not in 0 .. 59
or else tm_sec not in 0 .. 60
or else tm_isdst not in -1 .. 1
then
raise Time_Error;
end if;
-- Step 2: Potential leap second
if tm_sec = 60 then
Leap := True;
Second := 59;
else
Leap := False;
Second := tm_sec;
end if;
-- Step 3: Calculate the time value
Result :=
Time_Rep
(Formatting_Operations.Time_Of
(Year => Year,
Month => Month,
Day => Day,
Day_Secs => 0.0, -- Time is given in h:m:s
Hour => tm_hour,
Minute => tm_min,
Second => Second,
Sub_Sec => 0.0, -- No precise sub second given
Leap_Sec => Leap,
Use_Day_Secs => False, -- Time is given in h:m:s
Use_TZ => True, -- Force usage of explicit time zone
Is_Historic => True,
Time_Zone => 0)); -- Place the value in UTC
-- Step 4: Daylight Savings Time
if tm_isdst = 1 then
Result := Result + Time_Rep (3_600) * Nano;
end if;
return Time (Result);
exception
when Constraint_Error =>
raise Time_Error;
end To_Ada_Time;
-----------------
-- To_Duration --
-----------------
function To_Duration
(tv_sec : Long_Integer;
tv_nsec : Long_Integer) return Duration
is
pragma Unsuppress (Overflow_Check);
begin
return Duration (tv_sec) + Duration (tv_nsec) / Nano_F;
end To_Duration;
------------------------
-- To_Struct_Timespec --
------------------------
procedure To_Struct_Timespec
(D : Duration;
tv_sec : out Long_Integer;
tv_nsec : out Long_Integer)
is
pragma Unsuppress (Overflow_Check);
Secs : Duration;
Nano_Secs : Duration;
begin
-- Seconds extraction, avoid potential rounding errors
Secs := D - 0.5;
tv_sec := Long_Integer (Secs);
-- Nanoseconds extraction
Nano_Secs := D - Duration (tv_sec);
tv_nsec := Long_Integer (Nano_Secs * Nano);
end To_Struct_Timespec;
------------------
-- To_Struct_Tm --
------------------
procedure To_Struct_Tm
(T : Time;
tm_year : out Integer;
tm_mon : out Integer;
tm_day : out Integer;
tm_hour : out Integer;
tm_min : out Integer;
tm_sec : out Integer)
is
pragma Unsuppress (Overflow_Check);
Year : Year_Number;
Month : Month_Number;
Second : Integer;
Day_Secs : Day_Duration;
Sub_Sec : Duration;
Leap_Sec : Boolean;
begin
-- Step 1: Split the input time
Formatting_Operations.Split
(Date => T,
Year => Year,
Month => Month,
Day => tm_day,
Day_Secs => Day_Secs,
Hour => tm_hour,
Minute => tm_min,
Second => Second,
Sub_Sec => Sub_Sec,
Leap_Sec => Leap_Sec,
Use_TZ => True,
Is_Historic => False,
Time_Zone => 0);
-- Step 2: Correct the year and month
tm_year := Year - 1900;
tm_mon := Month - 1;
-- Step 3: Handle leap second occurrences
tm_sec := (if Leap_Sec then 60 else Second);
end To_Struct_Tm;
------------------
-- To_Unix_Time --
------------------
function To_Unix_Time (Ada_Time : Time) return Long_Integer is
pragma Unsuppress (Overflow_Check);
Ada_Rep : constant Time_Rep := Time_Rep (Ada_Time);
begin
return Long_Integer ((Ada_Rep + Epoch_Offset) / Nano);
exception
when Constraint_Error =>
raise Time_Error;
end To_Unix_Time;
end Conversion_Operations;
----------------------
-- Delay_Operations --
----------------------
package body Delay_Operations is
-----------------
-- To_Duration --
-----------------
function To_Duration (Date : Time) return Duration is
pragma Unsuppress (Overflow_Check);
Safe_Ada_High : constant Time_Rep := Ada_High - Epoch_Offset;
-- This value represents a "safe" end of time. In order to perform a
-- proper conversion to Unix duration, we will have to shift origins
-- at one point. For very distant dates, this means an overflow check
-- failure. To prevent this, the function returns the "safe" end of
-- time (roughly 2219) which is still distant enough.
Elapsed_Leaps : Natural;
Next_Leap_N : Time_Rep;
Res_N : Time_Rep;
begin
Res_N := Time_Rep (Date);
-- Step 1: If the target supports leap seconds, remove any leap
-- seconds elapsed up to the input date.
if Leap_Support then
Cumulative_Leap_Seconds
(Start_Of_Time, Res_N, Elapsed_Leaps, Next_Leap_N);
-- The input time value may fall on a leap second occurrence
if Res_N >= Next_Leap_N then
Elapsed_Leaps := Elapsed_Leaps + 1;
end if;
-- The target does not support leap seconds
else
Elapsed_Leaps := 0;
end if;
Res_N := Res_N - Time_Rep (Elapsed_Leaps) * Nano;
-- Step 2: Perform a shift in origins to obtain a Unix equivalent of
-- the input. Guard against very large delay values such as the end
-- of time since the computation will overflow.
Res_N := (if Res_N > Safe_Ada_High then Safe_Ada_High
else Res_N + Epoch_Offset);
return Time_Rep_To_Duration (Res_N);
end To_Duration;
end Delay_Operations;
---------------------------
-- Formatting_Operations --
---------------------------
package body Formatting_Operations is
-----------------
-- Day_Of_Week --
-----------------
function Day_Of_Week (Date : Time) return Integer is
Date_N : constant Time_Rep := Time_Rep (Date);
Time_Zone : constant Long_Integer := UTC_Time_Offset (Date, True);
Ada_Low_N : Time_Rep;
Day_Count : Long_Integer;
Day_Dur : Time_Dur;
High_N : Time_Rep;
Low_N : Time_Rep;
begin
-- As declared, the Ada Epoch is set in UTC. For this calculation to
-- work properly, both the Epoch and the input date must be in the
-- same time zone. The following places the Epoch in the input date's
-- time zone.
Ada_Low_N := Ada_Low - Time_Rep (Time_Zone) * Nano;
if Date_N > Ada_Low_N then
High_N := Date_N;
Low_N := Ada_Low_N;
else
High_N := Ada_Low_N;
Low_N := Date_N;
end if;
-- Determine the elapsed seconds since the start of Ada time
Day_Dur := Time_Dur (High_N / Nano - Low_N / Nano);
-- Count the number of days since the start of Ada time. 1901-01-01
-- GMT was a Tuesday.
Day_Count := Long_Integer (Day_Dur / Secs_In_Day) + 1;
return Integer (Day_Count mod 7);
end Day_Of_Week;
-----------
-- Split --
-----------
procedure Split
(Date : Time;
Year : out Year_Number;
Month : out Month_Number;
Day : out Day_Number;
Day_Secs : out Day_Duration;
Hour : out Integer;
Minute : out Integer;
Second : out Integer;
Sub_Sec : out Duration;
Leap_Sec : out Boolean;
Use_TZ : Boolean;
Is_Historic : Boolean;
Time_Zone : Long_Integer)
is
-- The following constants represent the number of nanoseconds
-- elapsed since the start of Ada time to and including the non
-- leap centennial years.
Year_2101 : constant Time_Rep := Ada_Low +
Time_Rep (49 * 366 + 151 * 365) * Nanos_In_Day;
Year_2201 : constant Time_Rep := Ada_Low +
Time_Rep (73 * 366 + 227 * 365) * Nanos_In_Day;
Year_2301 : constant Time_Rep := Ada_Low +
Time_Rep (97 * 366 + 303 * 365) * Nanos_In_Day;
Date_Dur : Time_Dur;
Date_N : Time_Rep;
Day_Seconds : Natural;
Elapsed_Leaps : Natural;
Four_Year_Segs : Natural;
Hour_Seconds : Natural;
Is_Leap_Year : Boolean;
Next_Leap_N : Time_Rep;
Rem_Years : Natural;
Sub_Sec_N : Time_Rep;
Year_Day : Natural;
begin
Date_N := Time_Rep (Date);
-- Step 1: Leap seconds processing in UTC
if Leap_Support then
Cumulative_Leap_Seconds
(Start_Of_Time, Date_N, Elapsed_Leaps, Next_Leap_N);
Leap_Sec := Date_N >= Next_Leap_N;
if Leap_Sec then
Elapsed_Leaps := Elapsed_Leaps + 1;
end if;
-- The target does not support leap seconds
else
Elapsed_Leaps := 0;
Leap_Sec := False;
end if;
Date_N := Date_N - Time_Rep (Elapsed_Leaps) * Nano;
-- Step 2: Time zone processing. This action converts the input date
-- from GMT to the requested time zone. Applies from Ada 2005 on.
if Use_TZ then
if Time_Zone /= 0 then
Date_N := Date_N + Time_Rep (Time_Zone) * 60 * Nano;
end if;
-- Ada 83 and 95
else
declare
Off : constant Long_Integer :=
UTC_Time_Offset (Time (Date_N), Is_Historic);
begin
Date_N := Date_N + Time_Rep (Off) * Nano;
end;
end if;
-- Step 3: Non-leap centennial year adjustment in local time zone
-- In order for all divisions to work properly and to avoid more
-- complicated arithmetic, we add fake February 29s to dates which
-- occur after a non-leap centennial year.
if Date_N >= Year_2301 then
Date_N := Date_N + Time_Rep (3) * Nanos_In_Day;
elsif Date_N >= Year_2201 then
Date_N := Date_N + Time_Rep (2) * Nanos_In_Day;
elsif Date_N >= Year_2101 then
Date_N := Date_N + Time_Rep (1) * Nanos_In_Day;
end if;
-- Step 4: Sub second processing in local time zone
Sub_Sec_N := Date_N mod Nano;
Sub_Sec := Duration (Sub_Sec_N) / Nano_F;
Date_N := Date_N - Sub_Sec_N;
-- Convert Date_N into a time duration value, changing the units
-- to seconds.
Date_Dur := Time_Dur (Date_N / Nano - Ada_Low / Nano);
-- Step 5: Year processing in local time zone. Determine the number
-- of four year segments since the start of Ada time and the input
-- date.
Four_Year_Segs := Natural (Date_Dur / Secs_In_Four_Years);
if Four_Year_Segs > 0 then
Date_Dur := Date_Dur - Time_Dur (Four_Year_Segs) *
Secs_In_Four_Years;
end if;
-- Calculate the remaining non-leap years
Rem_Years := Natural (Date_Dur / Secs_In_Non_Leap_Year);
if Rem_Years > 3 then
Rem_Years := 3;
end if;
Date_Dur := Date_Dur - Time_Dur (Rem_Years) * Secs_In_Non_Leap_Year;
Year := Ada_Min_Year + Natural (4 * Four_Year_Segs + Rem_Years);
Is_Leap_Year := Is_Leap (Year);
-- Step 6: Month and day processing in local time zone
Year_Day := Natural (Date_Dur / Secs_In_Day) + 1;
Month := 1;
-- Processing for months after January
if Year_Day > 31 then
Month := 2;
Year_Day := Year_Day - 31;
-- Processing for a new month or a leap February
if Year_Day > 28
and then (not Is_Leap_Year or else Year_Day > 29)
then
Month := 3;
Year_Day := Year_Day - 28;
if Is_Leap_Year then
Year_Day := Year_Day - 1;
end if;
-- Remaining months
while Year_Day > Days_In_Month (Month) loop
Year_Day := Year_Day - Days_In_Month (Month);
Month := Month + 1;
end loop;
end if;
end if;
-- Step 7: Hour, minute, second and sub second processing in local
-- time zone.
Day := Day_Number (Year_Day);
Day_Seconds := Integer (Date_Dur mod Secs_In_Day);
Day_Secs := Duration (Day_Seconds) + Sub_Sec;
Hour := Day_Seconds / 3_600;
Hour_Seconds := Day_Seconds mod 3_600;
Minute := Hour_Seconds / 60;
Second := Hour_Seconds mod 60;
exception
when Constraint_Error =>
raise Time_Error;
end Split;
-------------
-- Time_Of --
-------------
function Time_Of
(Year : Year_Number;
Month : Month_Number;
Day : Day_Number;
Day_Secs : Day_Duration;
Hour : Integer;
Minute : Integer;
Second : Integer;
Sub_Sec : Duration;
Leap_Sec : Boolean;
Use_Day_Secs : Boolean;
Use_TZ : Boolean;
Is_Historic : Boolean;
Time_Zone : Long_Integer) return Time
is
Count : Integer;
Elapsed_Leaps : Natural;
Next_Leap_N : Time_Rep;
Res_N : Time_Rep;
Rounded_Res_N : Time_Rep;
begin
-- Step 1: Check whether the day, month and year form a valid date
if Day > Days_In_Month (Month)
and then (Day /= 29 or else Month /= 2 or else not Is_Leap (Year))
then
raise Time_Error;
end if;
-- Start accumulating nanoseconds from the low bound of Ada time
Res_N := Ada_Low;
-- Step 2: Year processing and centennial year adjustment. Determine
-- the number of four year segments since the start of Ada time and
-- the input date.
Count := (Year - Year_Number'First) / 4;
for Four_Year_Segments in 1 .. Count loop
Res_N := Res_N + Nanos_In_Four_Years;
end loop;
-- Note that non-leap centennial years are automatically considered
-- leap in the operation above. An adjustment of several days is
-- required to compensate for this.
if Year > 2300 then
Res_N := Res_N - Time_Rep (3) * Nanos_In_Day;
elsif Year > 2200 then
Res_N := Res_N - Time_Rep (2) * Nanos_In_Day;
elsif Year > 2100 then
Res_N := Res_N - Time_Rep (1) * Nanos_In_Day;
end if;
-- Add the remaining non-leap years
Count := (Year - Year_Number'First) mod 4;
Res_N := Res_N + Time_Rep (Count) * Secs_In_Non_Leap_Year * Nano;
-- Step 3: Day of month processing. Determine the number of days
-- since the start of the current year. Do not add the current
-- day since it has not elapsed yet.
Count := Cumulative_Days_Before_Month (Month) + Day - 1;
-- The input year is leap and we have passed February
if Is_Leap (Year)
and then Month > 2
then
Count := Count + 1;
end if;
Res_N := Res_N + Time_Rep (Count) * Nanos_In_Day;
-- Step 4: Hour, minute, second and sub second processing
if Use_Day_Secs then
Res_N := Res_N + Duration_To_Time_Rep (Day_Secs);
else
Res_N :=
Res_N + Time_Rep (Hour * 3_600 + Minute * 60 + Second) * Nano;
if Sub_Sec = 1.0 then
Res_N := Res_N + Time_Rep (1) * Nano;
else
Res_N := Res_N + Duration_To_Time_Rep (Sub_Sec);
end if;
end if;
-- At this point, the generated time value should be withing the
-- bounds of Ada time.
Check_Within_Time_Bounds (Res_N);
-- Step 4: Time zone processing. At this point we have built an
-- arbitrary time value which is not related to any time zone.
-- For simplicity, the time value is normalized to GMT, producing
-- a uniform representation which can be treated by arithmetic
-- operations for instance without any additional corrections.
if Use_TZ then
if Time_Zone /= 0 then
Res_N := Res_N - Time_Rep (Time_Zone) * 60 * Nano;
end if;
-- Ada 83 and 95
else
declare
Cur_Off : constant Long_Integer :=
UTC_Time_Offset (Time (Res_N), Is_Historic);
Cur_Res_N : constant Time_Rep :=
Res_N - Time_Rep (Cur_Off) * Nano;
Off : constant Long_Integer :=
UTC_Time_Offset (Time (Cur_Res_N), Is_Historic);
begin
Res_N := Res_N - Time_Rep (Off) * Nano;
end;
end if;
-- Step 5: Leap seconds processing in GMT
if Leap_Support then
Cumulative_Leap_Seconds
(Start_Of_Time, Res_N, Elapsed_Leaps, Next_Leap_N);
Res_N := Res_N + Time_Rep (Elapsed_Leaps) * Nano;
-- An Ada 2005 caller requesting an explicit leap second or an
-- Ada 95 caller accounting for an invisible leap second.
if Leap_Sec or else Res_N >= Next_Leap_N then
Res_N := Res_N + Time_Rep (1) * Nano;
end if;
-- Leap second validity check
Rounded_Res_N := Res_N - (Res_N mod Nano);
if Use_TZ
and then Leap_Sec
and then Rounded_Res_N /= Next_Leap_N
then
raise Time_Error;
end if;
end if;
return Time (Res_N);
end Time_Of;
end Formatting_Operations;
---------------------------
-- Time_Zones_Operations --
---------------------------
package body Time_Zones_Operations is
---------------------
-- UTC_Time_Offset --
---------------------
function UTC_Time_Offset (Date : Time) return Long_Integer is
begin
return UTC_Time_Offset (Date, True);
end UTC_Time_Offset;
end Time_Zones_Operations;
-- Start of elaboration code for Ada.Calendar
begin
System.OS_Primitives.Initialize;
end Ada.Calendar;
Reference in a new issue Copy permalink