OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [ada/] [a-calend.ads] - Blame information for rev 706

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 706 jeremybenn
------------------------------------------------------------------------------
2
--                                                                          --
3
--                         GNAT RUN-TIME COMPONENTS                         --
4
--                                                                          --
5
--                         A D A . C A L E N D A R                          --
6
--                                                                          --
7
--                                 S p e c                                  --
8
--                                                                          --
9
--          Copyright (C) 1992-2012, Free Software Foundation, Inc.         --
10
--                                                                          --
11
-- This specification is derived from the Ada Reference Manual for use with --
12
-- GNAT. The copyright notice above, and the license provisions that follow --
13
-- apply solely to the  contents of the part following the private keyword. --
14
--                                                                          --
15
-- GNAT is free software;  you can  redistribute it  and/or modify it under --
16
-- terms of the  GNU General Public License as published  by the Free Soft- --
17
-- ware  Foundation;  either version 3,  or (at your option) any later ver- --
18
-- sion.  GNAT is distributed in the hope that it will be useful, but WITH- --
19
-- OUT ANY WARRANTY;  without even the  implied warranty of MERCHANTABILITY --
20
-- or FITNESS FOR A PARTICULAR PURPOSE.                                     --
21
--                                                                          --
22
-- As a special exception under Section 7 of GPL version 3, you are granted --
23
-- additional permissions described in the GCC Runtime Library Exception,   --
24
-- version 3.1, as published by the Free Software Foundation.               --
25
--                                                                          --
26
-- You should have received a copy of the GNU General Public License and    --
27
-- a copy of the GCC Runtime Library Exception along with this program;     --
28
-- see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see    --
29
-- <http://www.gnu.org/licenses/>.                                          --
30
--                                                                          --
31
-- GNAT was originally developed  by the GNAT team at  New York University. --
32
-- Extensive contributions were provided by Ada Core Technologies Inc.      --
33
--                                                                          --
34
------------------------------------------------------------------------------
35
 
36
package Ada.Calendar is
37
 
38
   type Time is private;
39
 
40
   --  Declarations representing limits of allowed local time values. Note that
41
   --  these do NOT constrain the possible stored values of time which may well
42
   --  permit a larger range of times (this is explicitly allowed in Ada 95).
43
 
44
   subtype Year_Number  is Integer range 1901 .. 2399;
45
   subtype Month_Number is Integer range 1 .. 12;
46
   subtype Day_Number   is Integer range 1 .. 31;
47
 
48
   --  A Day_Duration value of 86_400.0 designates a new day
49
 
50
   subtype Day_Duration is Duration range 0.0 .. 86_400.0;
51
 
52
   function Clock return Time;
53
   --  The returned time value is the number of nanoseconds since the start
54
   --  of Ada time (1901-01-01 00:00:00.0 UTC). If leap seconds are enabled,
55
   --  the result will contain all elapsed leap seconds since the start of
56
   --  Ada time until now.
57
 
58
   function Year    (Date : Time) return Year_Number;
59
   function Month   (Date : Time) return Month_Number;
60
   function Day     (Date : Time) return Day_Number;
61
   function Seconds (Date : Time) return Day_Duration;
62
 
63
   procedure Split
64
     (Date    : Time;
65
      Year    : out Year_Number;
66
      Month   : out Month_Number;
67
      Day     : out Day_Number;
68
      Seconds : out Day_Duration);
69
   --  Break down a time value into its date components set in the current
70
   --  time zone. If Split is called on a time value created using Ada 2005
71
   --  Time_Of in some arbitrary time zone, the input value will always be
72
   --  interpreted as relative to the local time zone.
73
 
74
   function Time_Of
75
     (Year    : Year_Number;
76
      Month   : Month_Number;
77
      Day     : Day_Number;
78
      Seconds : Day_Duration := 0.0) return Time;
79
   --  GNAT Note: Normally when procedure Split is called on a Time value
80
   --  result of a call to function Time_Of, the out parameters of procedure
81
   --  Split are identical to the in parameters of function Time_Of. However,
82
   --  when a non-existent time of day is specified, the values for Seconds
83
   --  may or may not be different. This may happen when Daylight Saving Time
84
   --  (DST) is in effect, on the day when switching to DST, if Seconds
85
   --  specifies a time of day in the hour that does not exist. For example,
86
   --  in New York:
87
   --
88
   --    Time_Of (Year => 1998, Month => 4, Day => 5, Seconds => 10740.0)
89
   --
90
   --  will return a Time value T. If Split is called on T, the resulting
91
   --  Seconds may be 14340.0 (3:59:00) instead of 10740.0 (2:59:00 being
92
   --  a time that not exist).
93
 
94
   function "+" (Left : Time;     Right : Duration) return Time;
95
   function "+" (Left : Duration; Right : Time)     return Time;
96
   function "-" (Left : Time;     Right : Duration) return Time;
97
   function "-" (Left : Time;     Right : Time)     return Duration;
98
   --  The first three functions will raise Time_Error if the resulting time
99
   --  value is less than the start of Ada time in UTC or greater than the
100
   --  end of Ada time in UTC. The last function will raise Time_Error if the
101
   --  resulting difference cannot fit into a duration value.
102
 
103
   function "<"  (Left, Right : Time) return Boolean;
104
   function "<=" (Left, Right : Time) return Boolean;
105
   function ">"  (Left, Right : Time) return Boolean;
106
   function ">=" (Left, Right : Time) return Boolean;
107
 
108
   Time_Error : exception;
109
 
110
private
111
   pragma Inline (Clock);
112
 
113
   pragma Inline (Year);
114
   pragma Inline (Month);
115
   pragma Inline (Day);
116
 
117
   pragma Inline ("+");
118
   pragma Inline ("-");
119
 
120
   pragma Inline ("<");
121
   pragma Inline ("<=");
122
   pragma Inline (">");
123
   pragma Inline (">=");
124
 
125
   --  The units used in this version of Ada.Calendar are nanoseconds. The
126
   --  following constants provide values used in conversions of seconds or
127
   --  days to the underlying units.
128
 
129
   Nano         : constant := 1_000_000_000;
130
   Nano_F       : constant := 1_000_000_000.0;
131
   Nanos_In_Day : constant := 86_400_000_000_000;
132
   Secs_In_Day  : constant := 86_400;
133
 
134
   ----------------------------
135
   -- Implementation of Time --
136
   ----------------------------
137
 
138
   --  Time is represented as a signed 64 bit integer count of nanoseconds
139
   --  since the start of Ada time (1901-01-01 00:00:00.0 UTC). Time values
140
   --  produced by Time_Of are internally normalized to UTC regardless of their
141
   --  local time zone. This representation ensures correct handling of leap
142
   --  seconds as well as performing arithmetic. In Ada 95, Split and Time_Of
143
   --  will treat a time value as being in the local time zone, in Ada 2005,
144
   --  Split and Time_Of will treat a time value as being in the designated
145
   --  time zone by the formal parameter or in UTC by default. The size of the
146
   --  type is large enough to cover the Ada 2005 range of time (1901-01-01
147
   --  00:00:00.0 UTC - 2399-12-31-23:59:59.999999999 UTC).
148
 
149
   ------------------
150
   -- Leap Seconds --
151
   ------------------
152
 
153
   --  Due to Earth's slowdown, the astronomical time is not as precise as the
154
   --  International Atomic Time. To compensate for this inaccuracy, a single
155
   --  leap second is added after the last day of June or December. The count
156
   --  of seconds during those occurrences becomes:
157
 
158
   --    ... 58, 59, leap second 60, 0, 1, 2 ...
159
 
160
   --  Unlike leap days, leap seconds occur simultaneously around the world.
161
   --  In other words, if a leap second occurs at 23:59:60 UTC, it also occurs
162
   --  on 18:59:60 -5 the same day or 2:59:60 +2 on the next day.
163
 
164
   --  Leap seconds do not follow a formula. The International Earth Rotation
165
   --  and Reference System Service decides when to add one. Leap seconds are
166
   --  included in the representation of time in Ada 95 mode. As a result,
167
   --  the following two time values will differ by two seconds:
168
 
169
   --    1972-06-30 23:59:59.0
170
   --    1972-07-01 00:00:00.0
171
 
172
   --  When a new leap second is introduced, the following steps must be
173
   --  carried out:
174
 
175
   --     1) Increment Leap_Seconds_Count in a-calend.adb by one
176
   --     2) Increment LS_Count in xleaps.adb by one
177
   --     3) Add the new date to the aggregate of array LS_Dates in
178
   --        xleaps.adb
179
   --     4) Compile and execute xleaps
180
   --     5) Replace the values of Leap_Second_Times in a-calend.adb with the
181
   --        aggregate generated by xleaps
182
 
183
   --  The algorithms that build the actual leap second values and discover
184
   --  how many leap seconds have occurred between two dates do not need any
185
   --  modification.
186
 
187
   ------------------------------
188
   -- Non-leap Centennial Years --
189
   ------------------------------
190
 
191
   --  Over the range of Ada time, centennial years 2100, 2200 and 2300 are
192
   --  non-leap. As a consequence, seven non-leap years occur over the period
193
   --  of year - 4 to year + 4. Internally, routines Split and Time_Of add or
194
   --  subtract a "fake" February 29 to facilitate the arithmetic involved.
195
 
196
   ------------------------------------
197
   -- Time Zones and UTC_Time_Offset --
198
   ------------------------------------
199
 
200
   --  The implementation-defined time zone of Ada.Calendar routines is the
201
   --  local time zone. The term "local time zone" can be interpreted in two
202
   --  different ways - either the offset from UTC of the "now" or the offset
203
   --  from UTC of some input date.
204
 
205
   --  For efficency reasons, Split and Time_Of take the first approach. Since
206
   --  the Ada Reference Manual does not mandate that Split and Time_Of should
207
   --  be concious of historic time zones, this interpretation is acceptable
208
   --  and efficent in terms of performance. Split and Time_Of localize their
209
   --  respective input regardless of whether it represent a past or a future
210
   --  date.
211
 
212
   --  UTC_Time_Offset on the other hand must be knowledgeable of historic time
213
   --  zones. To achieve this, the implementation relies on various operating
214
   --  system routines. Note that not all operating systems support time zones.
215
   --  UTC_Time_Offset calculates the offset from UTC as it occurred or will
216
   --  occur on the input date relative to the local time zone. Example:
217
 
218
   --     Date         Offset    Reason
219
   --     2012-01-11   -300
220
   --     2011-03-12   -300
221
   --     2011-03-14   -240      Daylight savings is in effect
222
 
223
   ------------------------
224
   -- Local Declarations --
225
   ------------------------
226
 
227
   type Time_Rep is range -2 ** 63 .. +2 ** 63 - 1;
228
   type Time is new Time_Rep;
229
   --  The underlying type of Time has been chosen to be a 64 bit signed
230
   --  integer number since it allows for easier processing of sub seconds
231
   --  and arithmetic.
232
 
233
   Days_In_Month : constant array (Month_Number) of Day_Number :=
234
                     (31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31);
235
   --  Days in month for non-leap year, leap year case is adjusted in code
236
 
237
   Invalid_Time_Zone_Offset : Long_Integer;
238
   pragma Import (C, Invalid_Time_Zone_Offset, "__gnat_invalid_tzoff");
239
 
240
   function Is_Leap (Year : Year_Number) return Boolean;
241
   --  Determine whether a given year is leap
242
 
243
   ----------------------------------------------------------
244
   -- Target-Independent Interface to Children of Calendar --
245
   ----------------------------------------------------------
246
 
247
   --  The following packages provide a target-independent interface to the
248
   --  children of Calendar - Arithmetic, Conversions, Delays, Formatting and
249
   --  Time_Zones.
250
 
251
   ---------------------------
252
   -- Arithmetic_Operations --
253
   ---------------------------
254
 
255
   package Arithmetic_Operations is
256
 
257
      function Add (Date : Time; Days : Long_Integer) return Time;
258
      --  Add a certain number of days to a time value
259
 
260
      procedure Difference
261
        (Left         : Time;
262
         Right        : Time;
263
         Days         : out Long_Integer;
264
         Seconds      : out Duration;
265
         Leap_Seconds : out Integer);
266
      --  Calculate the difference between two time values in terms of days,
267
      --  seconds and leap seconds elapsed. The leap seconds are not included
268
      --  in the seconds returned. If Left is greater than Right, the returned
269
      --  values are positive, negative otherwise.
270
 
271
      function Subtract (Date : Time; Days : Long_Integer) return Time;
272
      --  Subtract a certain number of days from a time value
273
 
274
   end Arithmetic_Operations;
275
 
276
   ---------------------------
277
   -- Conversion_Operations --
278
   ---------------------------
279
 
280
   package Conversion_Operations is
281
 
282
      function To_Ada_Time (Unix_Time : Long_Integer) return Time;
283
      --  Unix to Ada Epoch conversion
284
 
285
      function To_Ada_Time
286
        (tm_year  : Integer;
287
         tm_mon   : Integer;
288
         tm_day   : Integer;
289
         tm_hour  : Integer;
290
         tm_min   : Integer;
291
         tm_sec   : Integer;
292
         tm_isdst : Integer) return Time;
293
      --  Struct tm to Ada Epoch conversion
294
 
295
      function To_Duration
296
        (tv_sec  : Long_Integer;
297
         tv_nsec : Long_Integer) return Duration;
298
      --  Struct timespec to Duration conversion
299
 
300
      procedure To_Struct_Timespec
301
        (D       : Duration;
302
         tv_sec  : out Long_Integer;
303
         tv_nsec : out Long_Integer);
304
      --  Duration to struct timespec conversion
305
 
306
      procedure To_Struct_Tm
307
        (T       : Time;
308
         tm_year : out Integer;
309
         tm_mon  : out Integer;
310
         tm_day  : out Integer;
311
         tm_hour : out Integer;
312
         tm_min  : out Integer;
313
         tm_sec  : out Integer);
314
      --  Time to struct tm conversion
315
 
316
      function To_Unix_Time (Ada_Time : Time) return Long_Integer;
317
      --  Ada to Unix Epoch conversion
318
 
319
   end Conversion_Operations;
320
 
321
   ----------------------
322
   -- Delay_Operations --
323
   ----------------------
324
 
325
   package Delay_Operations is
326
 
327
      function To_Duration (Date : Time) return Duration;
328
      --  Given a time value in nanoseconds since 1901, convert it into a
329
      --  duration value giving the number of nanoseconds since the Unix Epoch.
330
 
331
   end Delay_Operations;
332
 
333
   ---------------------------
334
   -- Formatting_Operations --
335
   ---------------------------
336
 
337
   package Formatting_Operations is
338
 
339
      function Day_Of_Week (Date : Time) return Integer;
340
      --  Determine which day of week Date falls on. The returned values are
341
      --  within the range of 0 .. 6 (Monday .. Sunday).
342
 
343
      procedure Split
344
        (Date      : Time;
345
         Year      : out Year_Number;
346
         Month     : out Month_Number;
347
         Day       : out Day_Number;
348
         Day_Secs  : out Day_Duration;
349
         Hour      : out Integer;
350
         Minute    : out Integer;
351
         Second    : out Integer;
352
         Sub_Sec   : out Duration;
353
         Leap_Sec  : out Boolean;
354
         Is_Ada_05 : Boolean;
355
         Time_Zone : Long_Integer);
356
      --  Split a time value into its components. Set Is_Ada_05 to use the
357
      --  local time zone (the value in Time_Zone is ignored) when splitting
358
      --  a time value.
359
 
360
      function Time_Of
361
        (Year         : Year_Number;
362
         Month        : Month_Number;
363
         Day          : Day_Number;
364
         Day_Secs     : Day_Duration;
365
         Hour         : Integer;
366
         Minute       : Integer;
367
         Second       : Integer;
368
         Sub_Sec      : Duration;
369
         Leap_Sec     : Boolean := False;
370
         Use_Day_Secs : Boolean := False;
371
         Is_Ada_05    : Boolean := False;
372
         Time_Zone    : Long_Integer := 0) return Time;
373
      --  Given all the components of a date, return the corresponding time
374
      --  value. Set Use_Day_Secs to use the value in Day_Secs, otherwise the
375
      --  day duration will be calculated from Hour, Minute, Second and Sub_
376
      --  Sec. Set Is_Ada_05 to use the local time zone (the value in formal
377
      --  Time_Zone is ignored) when building a time value and to verify the
378
      --  validity of a requested leap second.
379
 
380
   end Formatting_Operations;
381
 
382
   ---------------------------
383
   -- Time_Zones_Operations --
384
   ---------------------------
385
 
386
   package Time_Zones_Operations is
387
 
388
      function UTC_Time_Offset (Date : Time) return Long_Integer;
389
      --  Return (in seconds) the difference between the local time zone and
390
      --  UTC time at a specific historic date.
391
 
392
   end Time_Zones_Operations;
393
 
394
end Ada.Calendar;

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.