------------------------------------------------------------------------------ -- -- -- GNAT RUN-TIME COMPONENTS -- -- -- -- G N A T . C A L E N D A R -- -- -- -- B o d y -- -- -- -- Copyright (C) 1999-2018, 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- -- -- 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 -- -- . -- -- -- -- GNAT was originally developed by the GNAT team at New York University. -- -- Extensive contributions were provided by Ada Core Technologies Inc. -- -- -- ------------------------------------------------------------------------------ with Interfaces.C.Extensions; package body GNAT.Calendar is use Ada.Calendar; use Interfaces; ----------------- -- Day_In_Year -- ----------------- function Day_In_Year (Date : Time) return Day_In_Year_Number is Year : Year_Number; Month : Month_Number; Day : Day_Number; Day_Secs : Day_Duration; pragma Unreferenced (Day_Secs); begin Split (Date, Year, Month, Day, Day_Secs); return Julian_Day (Year, Month, Day) - Julian_Day (Year, 1, 1) + 1; end Day_In_Year; ----------------- -- Day_Of_Week -- ----------------- function Day_Of_Week (Date : Time) return Day_Name is Year : Year_Number; Month : Month_Number; Day : Day_Number; Day_Secs : Day_Duration; pragma Unreferenced (Day_Secs); begin Split (Date, Year, Month, Day, Day_Secs); return Day_Name'Val ((Julian_Day (Year, Month, Day)) mod 7); end Day_Of_Week; ---------- -- Hour -- ---------- function Hour (Date : Time) return Hour_Number is Year : Year_Number; Month : Month_Number; Day : Day_Number; Hour : Hour_Number; Minute : Minute_Number; Second : Second_Number; Sub_Second : Second_Duration; pragma Unreferenced (Year, Month, Day, Minute, Second, Sub_Second); begin Split (Date, Year, Month, Day, Hour, Minute, Second, Sub_Second); return Hour; end Hour; ---------------- -- Julian_Day -- ---------------- -- Julian_Day is used to by Day_Of_Week and Day_In_Year. Note that this -- implementation is not expensive. function Julian_Day (Year : Year_Number; Month : Month_Number; Day : Day_Number) return Integer is Internal_Year : Integer; Internal_Month : Integer; Internal_Day : Integer; Julian_Date : Integer; C : Integer; Ya : Integer; begin Internal_Year := Integer (Year); Internal_Month := Integer (Month); Internal_Day := Integer (Day); if Internal_Month > 2 then Internal_Month := Internal_Month - 3; else Internal_Month := Internal_Month + 9; Internal_Year := Internal_Year - 1; end if; C := Internal_Year / 100; Ya := Internal_Year - (100 * C); Julian_Date := (146_097 * C) / 4 + (1_461 * Ya) / 4 + (153 * Internal_Month + 2) / 5 + Internal_Day + 1_721_119; return Julian_Date; end Julian_Day; ------------ -- Minute -- ------------ function Minute (Date : Time) return Minute_Number is Year : Year_Number; Month : Month_Number; Day : Day_Number; Hour : Hour_Number; Minute : Minute_Number; Second : Second_Number; Sub_Second : Second_Duration; pragma Unreferenced (Year, Month, Day, Hour, Second, Sub_Second); begin Split (Date, Year, Month, Day, Hour, Minute, Second, Sub_Second); return Minute; end Minute; ------------ -- Second -- ------------ function Second (Date : Time) return Second_Number is Year : Year_Number; Month : Month_Number; Day : Day_Number; Hour : Hour_Number; Minute : Minute_Number; Second : Second_Number; Sub_Second : Second_Duration; pragma Unreferenced (Year, Month, Day, Hour, Minute, Sub_Second); begin Split (Date, Year, Month, Day, Hour, Minute, Second, Sub_Second); return Second; end Second; ----------- -- Split -- ----------- procedure Split (Date : Time; Year : out Year_Number; Month : out Month_Number; Day : out Day_Number; Hour : out Hour_Number; Minute : out Minute_Number; Second : out Second_Number; Sub_Second : out Second_Duration) is Day_Secs : Day_Duration; Secs : Natural; begin Split (Date, Year, Month, Day, Day_Secs); Secs := (if Day_Secs = 0.0 then 0 else Natural (Day_Secs - 0.5)); Sub_Second := Second_Duration (Day_Secs - Day_Duration (Secs)); Hour := Hour_Number (Secs / 3_600); Secs := Secs mod 3_600; Minute := Minute_Number (Secs / 60); Second := Second_Number (Secs mod 60); end Split; --------------------- -- Split_At_Locale -- --------------------- procedure Split_At_Locale (Date : Time; Year : out Year_Number; Month : out Month_Number; Day : out Day_Number; Hour : out Hour_Number; Minute : out Minute_Number; Second : out Second_Number; Sub_Second : out Second_Duration) is procedure Ada_Calendar_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); pragma Import (Ada, Ada_Calendar_Split, "__gnat_split"); Ds : Day_Duration; Le : Boolean; pragma Unreferenced (Ds, 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. Ada_Calendar_Split (Date => Date, Year => Year, Month => Month, Day => Day, Day_Secs => Ds, Hour => Hour, Minute => Minute, Second => Second, Sub_Sec => Sub_Second, Leap_Sec => Le, Use_TZ => False, Is_Historic => False, Time_Zone => 0); end Split_At_Locale; ---------------- -- Sub_Second -- ---------------- function Sub_Second (Date : Time) return Second_Duration is Year : Year_Number; Month : Month_Number; Day : Day_Number; Hour : Hour_Number; Minute : Minute_Number; Second : Second_Number; Sub_Second : Second_Duration; pragma Unreferenced (Year, Month, Day, Hour, Minute, Second); begin Split (Date, Year, Month, Day, Hour, Minute, Second, Sub_Second); return Sub_Second; end Sub_Second; ------------- -- Time_Of -- ------------- function Time_Of (Year : Year_Number; Month : Month_Number; Day : Day_Number; Hour : Hour_Number; Minute : Minute_Number; Second : Second_Number; Sub_Second : Second_Duration := 0.0) return Time is Day_Secs : constant Day_Duration := Day_Duration (Hour * 3_600) + Day_Duration (Minute * 60) + Day_Duration (Second) + Sub_Second; begin return Time_Of (Year, Month, Day, Day_Secs); end Time_Of; ----------------------- -- Time_Of_At_Locale -- ----------------------- function Time_Of_At_Locale (Year : Year_Number; Month : Month_Number; Day : Day_Number; Hour : Hour_Number; Minute : Minute_Number; Second : Second_Number; Sub_Second : Second_Duration := 0.0) return Time is function Ada_Calendar_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; pragma Import (Ada, Ada_Calendar_Time_Of, "__gnat_time_of"); begin -- Even though the input time zone is UTC (0), the flag Use_TZ will -- ensure that Split picks up the local time zone. return Ada_Calendar_Time_Of (Year => Year, Month => Month, Day => Day, Day_Secs => 0.0, Hour => Hour, Minute => Minute, Second => Second, Sub_Sec => Sub_Second, Leap_Sec => False, Use_Day_Secs => False, Use_TZ => False, Is_Historic => False, Time_Zone => 0); end Time_Of_At_Locale; ----------------- -- To_Duration -- ----------------- function To_Duration (T : not null access timeval) return Duration is procedure timeval_to_duration (T : not null access timeval; sec : not null access C.Extensions.long_long; usec : not null access C.long); pragma Import (C, timeval_to_duration, "__gnat_timeval_to_duration"); Micro : constant := 10**6; sec : aliased C.Extensions.long_long; usec : aliased C.long; begin timeval_to_duration (T, sec'Access, usec'Access); return Duration (sec) + Duration (usec) / Micro; end To_Duration; ---------------- -- To_Timeval -- ---------------- function To_Timeval (D : Duration) return timeval is procedure duration_to_timeval (Sec : C.Extensions.long_long; Usec : C.long; T : not null access timeval); pragma Import (C, duration_to_timeval, "__gnat_duration_to_timeval"); Micro : constant := 10**6; Result : aliased timeval; sec : C.Extensions.long_long; usec : C.long; begin if D = 0.0 then sec := 0; usec := 0; else sec := C.Extensions.long_long (D - 0.5); usec := C.long ((D - Duration (sec)) * Micro - 0.5); end if; duration_to_timeval (sec, usec, Result'Access); return Result; end To_Timeval; ------------------ -- Week_In_Year -- ------------------ function Week_In_Year (Date : Time) return Week_In_Year_Number is Year : Year_Number; Week : Week_In_Year_Number; pragma Unreferenced (Year); begin Year_Week_In_Year (Date, Year, Week); return Week; end Week_In_Year; ----------------------- -- Year_Week_In_Year -- ----------------------- procedure Year_Week_In_Year (Date : Time; Year : out Year_Number; Week : out Week_In_Year_Number) is Month : Month_Number; Day : Day_Number; Hour : Hour_Number; Minute : Minute_Number; Second : Second_Number; Sub_Second : Second_Duration; Jan_1 : Day_Name; Shift : Week_In_Year_Number; Start_Week : Week_In_Year_Number; pragma Unreferenced (Hour, Minute, Second, Sub_Second); function Is_Leap (Year : Year_Number) return Boolean; -- Return True if Year denotes a leap year. Leap centennial years are -- properly handled. function Jan_1_Day_Of_Week (Jan_1 : Day_Name; Year : Year_Number; Last_Year : Boolean := False; Next_Year : Boolean := False) return Day_Name; -- Given the weekday of January 1 in Year, determine the weekday on -- which January 1 fell last year or will fall next year as set by -- the two flags. This routine does not call Time_Of or Split. function Last_Year_Has_53_Weeks (Jan_1 : Day_Name; Year : Year_Number) return Boolean; -- Given the weekday of January 1 in Year, determine whether last year -- has 53 weeks. A False value implies that the year has 52 weeks. ------------- -- Is_Leap -- ------------- function Is_Leap (Year : Year_Number) return Boolean is begin if Year mod 400 = 0 then return True; elsif Year mod 100 = 0 then return False; else return Year mod 4 = 0; end if; end Is_Leap; ----------------------- -- Jan_1_Day_Of_Week -- ----------------------- function Jan_1_Day_Of_Week (Jan_1 : Day_Name; Year : Year_Number; Last_Year : Boolean := False; Next_Year : Boolean := False) return Day_Name is Shift : Integer := 0; begin if Last_Year then Shift := (if Is_Leap (Year - 1) then -2 else -1); elsif Next_Year then Shift := (if Is_Leap (Year) then 2 else 1); end if; return Day_Name'Val ((Day_Name'Pos (Jan_1) + Shift) mod 7); end Jan_1_Day_Of_Week; ---------------------------- -- Last_Year_Has_53_Weeks -- ---------------------------- function Last_Year_Has_53_Weeks (Jan_1 : Day_Name; Year : Year_Number) return Boolean is Last_Jan_1 : constant Day_Name := Jan_1_Day_Of_Week (Jan_1, Year, Last_Year => True); begin -- These two cases are illustrated in the table below return Last_Jan_1 = Thursday or else (Last_Jan_1 = Wednesday and then Is_Leap (Year - 1)); end Last_Year_Has_53_Weeks; -- Start of processing for Week_In_Year begin Split (Date, Year, Month, Day, Hour, Minute, Second, Sub_Second); -- According to ISO 8601, the first week of year Y is the week that -- contains the first Thursday in year Y. The following table contains -- all possible combinations of years and weekdays along with examples. -- +-------+------+-------+---------+ -- | Jan 1 | Leap | Weeks | Example | -- +-------+------+-------+---------+ -- | Mon | No | 52 | 2007 | -- +-------+------+-------+---------+ -- | Mon | Yes | 52 | 1996 | -- +-------+------+-------+---------+ -- | Tue | No | 52 | 2002 | -- +-------+------+-------+---------+ -- | Tue | Yes | 52 | 1980 | -- +-------+------+-------+---------+ -- | Wed | No | 52 | 2003 | -- +-------+------#########---------+ -- | Wed | Yes # 53 # 1992 | -- +-------+------#-------#---------+ -- | Thu | No # 53 # 1998 | -- +-------+------#-------#---------+ -- | Thu | Yes # 53 # 2004 | -- +-------+------#########---------+ -- | Fri | No | 52 | 1999 | -- +-------+------+-------+---------+ -- | Fri | Yes | 52 | 1988 | -- +-------+------+-------+---------+ -- | Sat | No | 52 | 1994 | -- +-------+------+-------+---------+ -- | Sat | Yes | 52 | 1972 | -- +-------+------+-------+---------+ -- | Sun | No | 52 | 1995 | -- +-------+------+-------+---------+ -- | Sun | Yes | 52 | 1956 | -- +-------+------+-------+---------+ -- A small optimization, the input date is January 1. Note that this -- is a key day since it determines the number of weeks and is used -- when special casing the first week of January and the last week of -- December. Jan_1 := Day_Of_Week (if Day = 1 and then Month = 1 then Date else (Time_Of (Year, 1, 1, 0.0))); -- Special cases for January if Month = 1 then -- Special case 1: January 1, 2 and 3. These three days may belong -- to last year's last week which can be week number 52 or 53. -- +-----+-----+-----+=====+-----+-----+-----+ -- | Mon | Tue | Wed # Thu # Fri | Sat | Sun | -- +-----+-----+-----+-----+-----+-----+-----+ -- | 26 | 27 | 28 # 29 # 30 | 31 | 1 | -- +-----+-----+-----+-----+-----+-----+-----+ -- | 27 | 28 | 29 # 30 # 31 | 1 | 2 | -- +-----+-----+-----+-----+-----+-----+-----+ -- | 28 | 29 | 30 # 31 # 1 | 2 | 3 | -- +-----+-----+-----+=====+-----+-----+-----+ if (Day = 1 and then Jan_1 in Friday .. Sunday) or else (Day = 2 and then Jan_1 in Friday .. Saturday) or else (Day = 3 and then Jan_1 = Friday) then Week := (if Last_Year_Has_53_Weeks (Jan_1, Year) then 53 else 52); -- January 1, 2 and 3 belong to the previous year Year := Year - 1; return; -- Special case 2: January 1, 2, 3, 4, 5, 6 and 7 of the first week -- +-----+-----+-----+=====+-----+-----+-----+ -- | Mon | Tue | Wed # Thu # Fri | Sat | Sun | -- +-----+-----+-----+-----+-----+-----+-----+ -- | 29 | 30 | 31 # 1 # 2 | 3 | 4 | -- +-----+-----+-----+-----+-----+-----+-----+ -- | 30 | 31 | 1 # 2 # 3 | 4 | 5 | -- +-----+-----+-----+-----+-----+-----+-----+ -- | 31 | 1 | 2 # 3 # 4 | 5 | 6 | -- +-----+-----+-----+-----+-----+-----+-----+ -- | 1 | 2 | 3 # 4 # 5 | 6 | 7 | -- +-----+-----+-----+=====+-----+-----+-----+ elsif (Day <= 4 and then Jan_1 in Monday .. Thursday) or else (Day = 5 and then Jan_1 in Monday .. Wednesday) or else (Day = 6 and then Jan_1 in Monday .. Tuesday) or else (Day = 7 and then Jan_1 = Monday) then Week := 1; return; end if; -- Month other than 1 -- Special case 3: December 29, 30 and 31. These days may belong to -- next year's first week. -- +-----+-----+-----+=====+-----+-----+-----+ -- | Mon | Tue | Wed # Thu # Fri | Sat | Sun | -- +-----+-----+-----+-----+-----+-----+-----+ -- | 29 | 30 | 31 # 1 # 2 | 3 | 4 | -- +-----+-----+-----+-----+-----+-----+-----+ -- | 30 | 31 | 1 # 2 # 3 | 4 | 5 | -- +-----+-----+-----+-----+-----+-----+-----+ -- | 31 | 1 | 2 # 3 # 4 | 5 | 6 | -- +-----+-----+-----+=====+-----+-----+-----+ elsif Month = 12 and then Day > 28 then declare Next_Jan_1 : constant Day_Name := Jan_1_Day_Of_Week (Jan_1, Year, Next_Year => True); begin if (Day = 29 and then Next_Jan_1 = Thursday) or else (Day = 30 and then Next_Jan_1 in Wednesday .. Thursday) or else (Day = 31 and then Next_Jan_1 in Tuesday .. Thursday) then Year := Year + 1; Week := 1; return; end if; end; end if; -- Determine the week from which to start counting. If January 1 does -- not belong to the first week of the input year, then the next week -- is the first week. Start_Week := (if Jan_1 in Friday .. Sunday then 1 else 2); -- At this point all special combinations have been accounted for and -- the proper start week has been found. Since January 1 may not fall -- on a Monday, shift 7 - Day_Name'Pos (Jan_1). This action ensures an -- origin which falls on Monday. Shift := 7 - Day_Name'Pos (Jan_1); Week := Start_Week + (Day_In_Year (Date) - Shift - 1) / 7; end Year_Week_In_Year; end GNAT.Calendar;