The R13B03 release.OTP_R13B03

1 files changed, 459 insertions, 0 deletions

diff --git a/lib/stdlib/src/calendar.erl b/lib/stdlib/src/calendar.erl
new file mode 100644
index 0000000000..ddc0666f77
--- /dev/null
+++ b/lib/stdlib/src/calendar.erl
@@ -0,0 +1,459 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 1996-2009. All Rights Reserved.
+%% 
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%% 
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%% 
+%% %CopyrightEnd%
+%%
+-module(calendar).
+
+%% local and universal time, time conversions
+
+-export([date_to_gregorian_days/1, 
+	 date_to_gregorian_days/3,
+	 datetime_to_gregorian_seconds/1,
+	 day_of_the_week/1,
+	 day_of_the_week/3,
+	 gregorian_days_to_date/1,
+	 gregorian_seconds_to_datetime/1,
+	 is_leap_year/1,
+	 last_day_of_the_month/2,
+	 local_time/0, 
+	 local_time_to_universal_time/1, 
+	 local_time_to_universal_time/2, 
+	 local_time_to_universal_time_dst/1, 
+	 now_to_datetime/1,			% = now_to_universal_time/1
+	 now_to_local_time/1,
+	 now_to_universal_time/1,
+	 seconds_to_daystime/1,
+	 seconds_to_time/1,
+	 time_difference/2,
+	 time_to_seconds/1,
+	 universal_time/0,
+	 universal_time_to_local_time/1,
+	 valid_date/1,
+	 valid_date/3]).
+
+-deprecated([{local_time_to_universal_time,1}]).
+
+-define(SECONDS_PER_MINUTE, 60).
+-define(SECONDS_PER_HOUR, 3600).
+-define(SECONDS_PER_DAY, 86400).
+-define(DAYS_PER_YEAR, 365).
+-define(DAYS_PER_LEAP_YEAR, 366).
+-define(DAYS_PER_4YEARS, 1461).
+-define(DAYS_PER_100YEARS, 36524).
+-define(DAYS_PER_400YEARS, 146097).
+-define(DAYS_FROM_0_TO_1970, 719528).
+
+%%----------------------------------------------------------------------
+%% Types
+%%----------------------------------------------------------------------
+
+-type year()     :: non_neg_integer().
+-type year1970() :: 1970..10000.	% should probably be 1970..
+-type month()    :: 1..12.
+-type day()      :: 1..31.
+-type hour()     :: 0..23.
+-type minute()   :: 0..59.
+-type second()   :: 0..59.
+-type daynum()   :: 1..7.
+-type ldom()     :: 28 | 29 | 30 | 31. % last day of month
+
+-type t_now()    :: {non_neg_integer(),non_neg_integer(),non_neg_integer()}.
+
+-type t_date()         :: {year(),month(),day()}.
+-type t_time()         :: {hour(),minute(),second()}.
+-type t_datetime()     :: {t_date(),t_time()}.
+-type t_datetime1970() :: {{year1970(),month(),day()},t_time()}.
+
+%%----------------------------------------------------------------------
+
+%% All dates are according the the Gregorian calendar. In this module
+%% the Gregorian calendar is extended back to year 0 for convenience.
+%%
+%% A year Y is a leap year if and only if either
+%%
+%%        (1)    Y is divisible by 4, but not by 100, or
+%%        (2)    Y is divisible by 400.
+%%
+%% Hence, e.g. 1996 is a leap year, 1900 is not, but 2000 is.
+%%
+
+%%
+%% EXPORTS
+%%
+
+%% date_to_gregorian_days(Year, Month, Day) = Integer
+%% date_to_gregorian_days({Year, Month, Day}) = Integer
+%%
+%% Computes the total number of days starting from year 0,
+%% January 1st.
+%%
+%% df/2 catches the case Year<0
+-spec date_to_gregorian_days(year(),month(),day()) -> non_neg_integer().
+date_to_gregorian_days(Year, Month, Day) when is_integer(Day), Day > 0 ->
+    Last = last_day_of_the_month(Year, Month),
+    if
+	Day =< Last ->
+	    dy(Year) + dm(Month) + df(Year, Month) + Day - 1
+    end.
+
+-spec date_to_gregorian_days(t_date()) -> non_neg_integer().
+date_to_gregorian_days({Year, Month, Day}) ->
+    date_to_gregorian_days(Year, Month, Day).
+
+
+%% datetime_to_gregorian_seconds(DateTime) = Integer
+%%
+%% Computes the total number of seconds starting from year 0,
+%% January 1st.
+%%
+-spec datetime_to_gregorian_seconds(t_datetime()) -> non_neg_integer().
+datetime_to_gregorian_seconds({Date, Time}) ->
+    ?SECONDS_PER_DAY*date_to_gregorian_days(Date) +
+	time_to_seconds(Time).
+
+
+%% day_of_the_week(Year, Month, Day)
+%% day_of_the_week({Year, Month, Day})
+%%
+%% Returns: 1 | .. | 7. Monday = 1, Tuesday = 2, ..., Sunday = 7.
+%%
+-spec day_of_the_week(year(), month(), day()) -> daynum().
+day_of_the_week(Year, Month, Day) ->
+    (date_to_gregorian_days(Year, Month, Day) + 5) rem 7 + 1.
+
+-spec day_of_the_week(t_date()) -> daynum().
+day_of_the_week({Year, Month, Day}) ->
+    day_of_the_week(Year, Month, Day).
+
+
+%% gregorian_days_to_date(Days) = {Year, Month, Day}
+%%
+-spec gregorian_days_to_date(non_neg_integer()) -> t_date().
+gregorian_days_to_date(Days) ->
+    {Year, DayOfYear} = day_to_year(Days),
+    {Month, DayOfMonth} = year_day_to_date(Year, DayOfYear),
+    {Year, Month, DayOfMonth}.
+
+
+%% gregorian_seconds_to_datetime(Secs)
+%%
+-spec gregorian_seconds_to_datetime(non_neg_integer()) -> t_datetime().
+gregorian_seconds_to_datetime(Secs) when Secs >= 0 ->
+    Days = Secs div ?SECONDS_PER_DAY,
+    Rest = Secs rem ?SECONDS_PER_DAY,
+    {gregorian_days_to_date(Days), seconds_to_time(Rest)}.
+
+
+%% is_leap_year(Year) = true | false
+%%
+-spec is_leap_year(year()) -> boolean().
+is_leap_year(Y) when is_integer(Y), Y >= 0 ->
+    is_leap_year1(Y).
+
+-spec is_leap_year1(year()) -> boolean().
+is_leap_year1(Year) when Year rem 4 =:= 0, Year rem 100 > 0 ->
+    true;
+is_leap_year1(Year) when Year rem 400 =:= 0 ->
+    true;
+is_leap_year1(_) -> false.
+
+
+%% last_day_of_the_month(Year, Month)
+%%
+%% Returns the number of days in a month.
+%%
+-spec last_day_of_the_month(year(), month()) -> ldom().
+last_day_of_the_month(Y, M) when is_integer(Y), Y >= 0 ->
+    last_day_of_the_month1(Y, M).
+
+-spec last_day_of_the_month1(year(),month()) -> ldom().
+last_day_of_the_month1(_, 4) -> 30;
+last_day_of_the_month1(_, 6) -> 30;
+last_day_of_the_month1(_, 9) -> 30;
+last_day_of_the_month1(_,11) -> 30;
+last_day_of_the_month1(Y, 2) ->
+   case is_leap_year(Y) of
+      true -> 29;
+      _    -> 28
+   end;
+last_day_of_the_month1(_, M) when is_integer(M), M > 0, M < 13 ->
+    31.
+
+
+%% local_time()
+%%
+%% Returns: {date(), time()}, date() = {Y, M, D}, time() = {H, M, S}.
+-spec local_time() -> t_datetime().
+local_time() ->
+    erlang:localtime().
+
+
+%% local_time_to_universal_time(DateTime)
+%%
+-spec local_time_to_universal_time(t_datetime1970()) -> t_datetime1970().
+local_time_to_universal_time(DateTime) ->
+    erlang:localtime_to_universaltime(DateTime).
+
+-spec local_time_to_universal_time(t_datetime1970(),
+				   'true' | 'false' | 'undefined') ->
+       					t_datetime1970().
+local_time_to_universal_time(DateTime, IsDst) ->
+    erlang:localtime_to_universaltime(DateTime, IsDst).
+
+-spec local_time_to_universal_time_dst(t_datetime1970()) -> [t_datetime1970()].
+local_time_to_universal_time_dst(DateTime) ->
+    UtDst = erlang:localtime_to_universaltime(DateTime, true),
+    Ut    = erlang:localtime_to_universaltime(DateTime, false),
+    %% Reverse check the universal times
+    LtDst = erlang:universaltime_to_localtime(UtDst),
+    Lt    = erlang:universaltime_to_localtime(Ut),
+    %% Return the valid universal times
+    case {LtDst,Lt} of
+	{DateTime,DateTime} when UtDst =/= Ut ->
+	    [UtDst,Ut];
+	{DateTime,_} ->
+	    [UtDst];
+	{_,DateTime} ->
+	    [Ut];
+	{_,_} ->
+	    []
+    end.
+
+%% now_to_universal_time(Now)
+%% now_to_datetime(Now)
+%%
+%% Convert from now() to UTC.
+%%
+%% Args: Now = now(); now() = {MegaSec, Sec, MilliSec}, MegaSec = Sec
+%% = MilliSec = integer() 
+%% Returns: {date(), time()}, date() = {Y, M, D}, time() = {H, M, S}.
+%% 
+-spec now_to_datetime(t_now()) -> t_datetime1970().
+now_to_datetime({MSec, Sec, _uSec}) ->
+    Sec0 = MSec*1000000 + Sec + ?DAYS_FROM_0_TO_1970*?SECONDS_PER_DAY,
+    gregorian_seconds_to_datetime(Sec0).
+
+-spec now_to_universal_time(t_now()) -> t_datetime1970().
+now_to_universal_time(Now) ->
+    now_to_datetime(Now).
+
+
+%% now_to_local_time(Now)
+%%
+%% Args: Now = now()
+%%
+-spec now_to_local_time(t_now()) -> t_datetime1970().
+now_to_local_time({MSec, Sec, _uSec}) ->
+    erlang:universaltime_to_localtime(
+      now_to_universal_time({MSec, Sec, _uSec})).
+
+
+
+%% seconds_to_daystime(Secs) = {Days, {Hour, Minute, Second}}
+%%
+-spec seconds_to_daystime(integer()) -> {integer(), t_time()}.
+seconds_to_daystime(Secs) ->
+    Days0 = Secs div ?SECONDS_PER_DAY,
+    Secs0 = Secs rem ?SECONDS_PER_DAY,
+    if 
+	Secs0 < 0 ->
+	    {Days0 - 1, seconds_to_time(Secs0 + ?SECONDS_PER_DAY)};
+	true ->
+	    {Days0, seconds_to_time(Secs0)}
+    end.
+
+
+%%
+%% seconds_to_time(Secs)
+%%
+%% Wraps.
+%%
+-type secs_per_day() :: 0..?SECONDS_PER_DAY.
+-spec seconds_to_time(secs_per_day()) -> t_time().
+seconds_to_time(Secs) when Secs >= 0, Secs < ?SECONDS_PER_DAY ->
+    Secs0 = Secs rem ?SECONDS_PER_DAY,
+    Hour = Secs0 div ?SECONDS_PER_HOUR,
+    Secs1 = Secs0 rem ?SECONDS_PER_HOUR,
+    Minute =  Secs1 div ?SECONDS_PER_MINUTE,
+    Second =  Secs1 rem ?SECONDS_PER_MINUTE,
+    {Hour, Minute, Second}.
+
+%% time_difference(T1, T2) = Tdiff
+%%
+%% Returns the difference between two {Date, Time} structures.
+%%
+%% T1 = T2 = {Date, Time}, Tdiff = {Day, {Hour, Min, Sec}}, 
+%% Date = {Year, Month, Day}, Time = {Hour, Minute, Sec},
+%% Year = Month = Day = Hour = Minute = Sec = integer()
+%%
+-type timediff() :: {integer(), t_time()}.
+-spec time_difference(t_datetime(), t_datetime()) -> timediff().
+time_difference({{Y1, Mo1, D1}, {H1, Mi1, S1}}, 
+		{{Y2, Mo2, D2}, {H2, Mi2, S2}}) ->
+    Secs = datetime_to_gregorian_seconds({{Y2, Mo2, D2}, {H2, Mi2, S2}}) -
+	datetime_to_gregorian_seconds({{Y1, Mo1, D1}, {H1, Mi1, S1}}),
+    seconds_to_daystime(Secs).
+
+
+%%
+%% time_to_seconds(Time)
+%%
+-spec time_to_seconds(t_time()) -> secs_per_day().
+time_to_seconds({H, M, S}) when is_integer(H), is_integer(M), is_integer(S) ->
+    H * ?SECONDS_PER_HOUR +
+	M * ?SECONDS_PER_MINUTE + S.
+      
+
+%% universal_time()
+%%
+%% Returns: {date(), time()}, date() = {Y, M, D}, time() = {H, M, S}.
+-spec universal_time() -> t_datetime().
+universal_time() ->
+    erlang:universaltime().
+ 
+
+%% universal_time_to_local_time(DateTime)
+%%
+-spec universal_time_to_local_time(t_datetime()) -> t_datetime().
+universal_time_to_local_time(DateTime) ->
+    erlang:universaltime_to_localtime(DateTime).
+
+
+%% valid_date(Year, Month, Day) = true | false
+%% valid_date({Year, Month, Day}) = true | false
+%%
+-spec valid_date(integer(), integer(), integer()) -> boolean().
+valid_date(Y, M, D) when is_integer(Y), is_integer(M), is_integer(D) ->
+    valid_date1(Y, M, D).
+
+-spec valid_date1(integer(), integer(), integer()) -> boolean().
+valid_date1(Y, M, D) when Y >= 0, M > 0, M < 13, D > 0 ->
+    D =< last_day_of_the_month(Y, M);
+valid_date1(_, _, _) ->
+    false.
+
+-spec valid_date({integer(),integer(),integer()}) -> boolean().
+valid_date({Y, M, D}) ->
+    valid_date(Y, M, D).
+
+
+%%
+%%  LOCAL FUNCTIONS
+%%
+-type day_of_year() :: 0..365.
+
+%% day_to_year(DayOfEpoch) = {Year, DayOfYear}
+%%
+%% The idea here is to first guess a year, and then adjust. Although
+%% the implementation is recursive, at most 1 or 2 recursive steps
+%% are taken.
+%% If DayOfEpoch is very large, we need far more than 1 or 2 iterations,
+%% since we just subtract a yearful of days at a time until we're there.
+%%
+-spec day_to_year(non_neg_integer()) -> {year(), day_of_year()}.
+day_to_year(DayOfEpoch) when DayOfEpoch >= 0 ->
+    Y0 = DayOfEpoch div ?DAYS_PER_YEAR,
+    {Y1, D1} = dty(Y0, DayOfEpoch, dy(Y0)),
+    {Y1, DayOfEpoch - D1}.
+
+-spec dty(year(), non_neg_integer(), non_neg_integer()) ->
+		{year(), non_neg_integer()}.
+dty(Y, D1, D2) when D1 < D2 -> 
+    dty(Y-1, D1, dy(Y-1));
+dty(Y, _D1, D2) ->
+    {Y, D2}.
+
+%% year_day_to_date(Year, DayOfYear)  = {Month,  DayOfMonth}
+%%
+%% Note: 1 is the first day of the month. 
+%%
+-spec year_day_to_date(year(), day_of_year()) -> {month(), day()}.
+year_day_to_date(Year, DayOfYear) ->
+    ExtraDay = case is_leap_year(Year) of
+		   true ->
+		       1;
+		   false ->
+		       0
+	       end,
+    {Month, Day} = year_day_to_date2(ExtraDay, DayOfYear),
+    {Month, Day + 1}.
+  
+
+%% Note: 0 is the first day of the month 
+%% 
+-spec year_day_to_date2(0 | 1, day_of_year()) -> {month(), 0..30}.
+year_day_to_date2(_, Day) when Day < 31 ->
+    {1, Day}; 
+year_day_to_date2(E, Day) when 31 =< Day, Day < 59 + E ->
+    {2, Day - 31}; 
+year_day_to_date2(E, Day) when 59 + E =< Day, Day < 90 + E -> 
+    {3, Day - (59 + E)}; 
+year_day_to_date2(E, Day) when 90 + E =< Day, Day < 120 + E -> 
+    {4, Day - (90 + E)};
+year_day_to_date2(E, Day) when 120 + E =< Day, Day < 151 + E -> 
+    {5, Day - (120 + E)}; 
+year_day_to_date2(E, Day) when 151 + E =< Day, Day < 181 + E ->
+    {6, Day - (151 + E)};
+year_day_to_date2(E, Day) when 181 + E =< Day, Day < 212 + E -> 
+    {7, Day - (181 + E)}; 
+year_day_to_date2(E, Day) when 212 + E =< Day, Day < 243 + E ->
+    {8, Day - (212 + E)};
+year_day_to_date2(E, Day) when 243 + E =< Day, Day < 273 + E ->
+    {9, Day - (243 + E)};
+year_day_to_date2(E, Day) when 273 + E =< Day, Day < 304 + E ->
+    {10, Day - (273 + E)};
+year_day_to_date2(E, Day) when 304 + E =< Day, Day < 334 + E ->
+    {11, Day - (304 + E)};
+year_day_to_date2(E, Day) when 334 + E =< Day -> 
+    {12, Day - (334 + E)}.
+
+%% dy(Year)
+%%
+%% Days in previous years.
+%%
+-spec dy(integer()) -> non_neg_integer().
+dy(Y) when Y =< 0 -> 
+    0; 
+dy(Y) -> 
+    X = Y - 1, 
+    (X div 4) - (X div 100) + (X div 400) + 
+	X*?DAYS_PER_YEAR + ?DAYS_PER_LEAP_YEAR.
+
+%%  dm(Month)
+%%
+%%  Returns the total number of days in all months
+%%  preceeding Month, for an ordinary year.
+%%
+-spec dm(month()) ->
+	     0 | 31 | 59 | 90 | 120 | 151 | 181 | 212 | 243 | 273 | 304 | 334.
+dm(1) -> 0;    dm(2) ->  31;   dm(3) ->   59;   dm(4) ->  90;
+dm(5) -> 120;  dm(6) ->  151;  dm(7) ->  181;   dm(8) -> 212;
+dm(9) -> 243;  dm(10) -> 273;  dm(11) -> 304;  dm(12) -> 334.
+ 
+%%  df(Year, Month)
+%%
+%%  Accounts for an extra day in February if Year is
+%%  a leap year, and if Month > 2.
+%%
+-spec df(year(), month()) -> 0 | 1.
+df(_, Month) when Month < 3 ->
+    0;
+df(Year, _) ->
+    case is_leap_year(Year) of
+	true -> 1;
+	false  -> 0
+    end.