CVS difference for ais/ai-00351.txt

Differences between 1.4 and version 1.5
Log of other versions for file ais/ai-00351.txt

--- ais/ai-00351.txt	2004/02/21 04:15:10	1.4
+++ ais/ai-00351.txt	2004/04/06 19:57:14	1.5
@@ -1,5 +1,9 @@
-!standard  9.06(19)                                     04-02-16  AI95-00351/03
+!standard  9.06(11)                                     04-03-26  AI95-00351/04
+!standard  9.06(24)
+!standard  9.06.01(01)
 !class amendment 03-09-22
+!status Amendment 200Y 04-03-26
+!status ARG Approved 9-0-0  04-03-07
 !status work item 03-09-22
 !status received 03-09-22
 !priority Medium
@@ -8,16 +12,16 @@
 
 !summary
 
-This proposal adds a number of useful operations on Calendar.Time.
+This proposal adds a number of useful operations for Calendar.Time.
 
 !problem
 
 Calendar.Time is missing a number of operations commonly needed by applications.
 
 First, there is no day-of-the-week function. It is often necessary to do a task
-on a particular day of the week (maintenance tasks in servers often are executed
-on Sundays when the load in minimal). Determining the day of the week for
-an Ada.Calendar.Time value is complex.
+on a particular day of the week (maintenance tasks in servers often are
+executed on Sundays when the load is minimal). Determining the day of the week
+for an Ada.Calendar.Time value is complex.
 
 Second, determining the Hour:Minutes:Seconds representation of a time value is
 not trivial. This representation is needed for most output of time values.
@@ -48,8 +52,10 @@
 
     subtype Year_Number is Integer range 1901 .. 2399;
 
-Add the following to 9.6:
+Add a new clause following 9.6:
 
+9.6.1 Formatting, Time Zones, and other operations for Time
+
 The following language-defined library packages exist:
 
 package Ada.Calendar.Time_Zones is
@@ -60,7 +66,7 @@
 
     Unknown_Zone_Error : exception;
 
-    function Local_Time_Offset (Date : in Time := Clock) return Time_Offset;
+    function UTC_Time_Offset (Date : in Time := Clock) return Time_Offset;
 
 end Ada.Calendar.Time_Zones;
 
@@ -76,10 +82,10 @@
 
     subtype Leap_Seconds_Count  is Integer range -999 .. 999;
 
-    procedure Difference (Left, Right : Time;
+    procedure Difference (Left, Right : in Time;
                           Days : out Day_Count;
                           Seconds : out Duration;
-			  Leap_Seconds : out Leap_Seconds_Count);
+                          Leap_Seconds : out Leap_Seconds_Count);
 
     function "+" (Left : Time; Right : Day_Count) return Time;
 
@@ -118,7 +124,7 @@
 
     function Second     (Date : in Time;
                          Time_Zone  : in Time_Zones.Time_Offset := 0)
-                            return Minute_Number;
+                            return Second_Number;
 
     function Sub_Second (Date : in Time;
                          Time_Zone  : in Time_Zones.Time_Offset := 0)
@@ -128,7 +134,7 @@
                          Minute : in Minute_Number;
                          Second : in Second_Number := 0;
                          Sub_Second : in Second_Duration := 0.0)
-	return Day_Duration;
+        return Day_Duration;
 
     procedure Split (Seconds    : in Day_Duration;
                      Hour       : out Hour_Number;
@@ -147,23 +153,23 @@
                      Sub_Second : out Second_Duration);
 
     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;
+                      Month      : Month_Number;
+                      Day        : Day_Number;
+                      Hour       : Hour_Number;
+                      Minute     : Minute_Number;
+                      Second     : Second_Number;
+                      Sub_Second : Second_Duration := 0.0;
                       Leap_Second: Boolean := False;
-                      Time_Zone  : in Time_Zones.Time_Offset := 0)
-			      return Time;
+                      Time_Zone  : Time_Zones.Time_Offset := 0)
+                              return Time;
 
     function Time_Of (Year       : Year_Number;
-	              Month      : Month_Number;
-  		      Day        : Day_Number;
-		      Seconds    : Day_Duration;
+                      Month      : Month_Number;
+                      Day        : Day_Number;
+                      Seconds    : Day_Duration;
                       Leap_Second: Boolean := False;
-                      Time_Zone  : in Time_Zones.Time_Offset := 0)
-			      return Time;
+                      Time_Zone  : Time_Zones.Time_Offset := 0)
+                              return Time;
 
     procedure Split (Date       : in Time;
                      Time_Zone  : in Time_Zones.Time_Offset := 0;
@@ -186,62 +192,73 @@
 
     -- Simple image and value:
     function Image (Date : Time;
-                    Include_Time_Fraction : in Boolean := False) return String;
+                    Include_Time_Fraction : Boolean := False) return String;
 
     function Value (Date : String) return Time;
 
     function Image (Elapsed_Time : Duration;
-                    Include_Time_Fraction : in Boolean := False) return String;
+                    Include_Time_Fraction : Boolean := False) return String;
 
     function Value (Elapsed_Time : String) return Duration;
 
 end Ada.Calendar.Formatting;
 
 Type Time_Offset represents the number of minutes difference between the
-mplementation-defined timezone used by Ada.Calendar and another timezone.
-Subtracting this value from a time value yields the time for the timezone.
+implementation-defined time zone used by Ada.Calendar and another time zone.
 
-function Local_Time_Offset (Date : in Time := Clock) return Time_Offset;
+function UTC_Time_Offset (Date : in Time := Clock) return Time_Offset;
     Returns, as a number of minutes, the difference between the
-    implementation-defined timezone of the values of Calendar, and UTC time,
-    at the time Date. If the timezone of the Calendar implementation is
+    implementation-defined time zone of Calendar, and UTC time,
+    at the time Date. If the time zone of the Calendar implementation is
     unknown, then Unknown_Zone_Error is raised.
 
     Notes: The time in the time zone known as Greenwich Mean Time (GMT)
     is generally equivalent to UTC time.
 
-    The implementation-defined timezone used for type Time may be, but need not
-    be, the local timezone. Local_Time_Offset always returns the difference
-    between the implementation-defined timezone of package Calendar. If
-    Local_Time_Offset does not raise Unknown_Zone_Error, UTC time can be
+    The implementation-defined time zone used for type Time may be, but need
+    not be, the local time zone. UTC_Time_Offset always returns the difference
+    relative to the implementation-defined time zone of package Calendar. If
+    UTC_Time_Offset does not raise Unknown_Zone_Error, UTC time can be
     safely calculated (within the accuracy of the underlying time-base).
 
     AARM Notes: The Date parameter is needed to take into account time
     differences caused by daylight-savings time and other time changes.
 
-    Other timezones can be supported with a child package.
+    Other time zones can be supported with a child package.
 
     The accuracy of this routine is not specified; the intent is that the
     facilities of the underlying target operating system are used to implement
     it.
 
-    Subtracting Duration(Local_Time_Zone*60) from Clock provides the UTC time.
-    In the US, for example, Time_Offset will generally be negative.
+    Calling Split on the results of subtracting Duration(UTC_Time_Offset*60)
+    from Clock provides the components (hours, minutes, and so on) of the UTC
+    time. In the US, for example, UTC_Time_Offset will generally be negative.
+
+    AARM Note
+    This is an illustration to help specify the value of
+    UTC_Time_Offset. A user should pass UTC_Time_Offset as the Time_Zone
+    parameter of Split, rather than trying to make the above calculation.
 
-procedure Difference (Left, Right : Time;
+procedure Difference (Left, Right : in Time;
                       Days : out Day_Count;
                       Seconds : out Duration;
-		      Leap_Seconds : out Leap_Seconds_Count);
+                      Leap_Seconds : out Leap_Seconds_Count);
     Returns the difference between Left and Right.
     Days is the number of days of difference, Seconds is the
     remainder seconds of difference, and Leap_Seconds is the number
     of leap seconds.
     If Left < Right, then Seconds <= 0.0, Days <= 0, and Leap_Seconds <= 0.
     Otherwise, all values are non-negative.
+    For the returned values, if Days = 0, then
+    If Days = 0, then Seconds + Duration(Leap_Seconds) =
+    Calendar."-" (Left, Right).
 
-    AARM Note: The number of days is calculated midnight-to-midnight.
+    AARM Notes: The number of days is calculated midnight-to-midnight.
     Leap_Seconds, if any, are not included in Seconds.
 
+    Leap_Seconds should be included in calculations using the operators
+    defined in Calendar, as is specified for "-" above.
+
 function "+" (Left : Time; Right : Day_Count) return Time;
 function "+" (Left : Day_Count; Right : Time) return Time;
     Add a number of days to a time value. Time_Error is raised
@@ -263,25 +280,26 @@
 function Hour       (Date : in Time;
                      Time_Zone  : in Time_Zones.Time_Offset := 0)
                         return Hour_Number;
-    Returns the hour for Date, as appropriate the specified timezone.
+    Returns the hour for Date, as appropriate for the specified time zone
+    offset.
 
 function Minute     (Date : in Time;
                      Time_Zone  : in Time_Zones.Time_Offset := 0)
                         return Minute_Number;
-    Returns the minute within the hour for Date, as appropriate to the
-    specified timezone.
+    Returns the minute within the hour for Date, as appropriate for the
+    specified time zone offset.
 
 function Second     (Date : in Time;
                      Time_Zone  : in Time_Zones.Time_Offset := 0)
-                        return Minute_Number;
-    Returns the second within the hour and minute for Date, as appropriate to
-    the specified timezone.
+                        return Second_Number;
+    Returns the second within the hour and minute for Date, as appropriate for
+    the specified time zone offset.
 
 function Sub_Second (Date : in Time;
                      Time_Zone  : in Time_Zones.Time_Offset := 0)
                         return Second_Duration;
     Returns the fraction of second for Date. (This has the same accuracy as
-    Day_Duration), as appropriate to the specified timezone.
+    Day_Duration), as appropriate to the specified time zone offset.
 
 function Seconds_Of (Hour : in Hour_Number;
                      Minute : in Minute_Number;
@@ -309,37 +327,37 @@
                  Second     : out Second_Number;
                  Sub_Second : out Second_Duration);
     Split Date into its constituent parts (Year, Month, Day, Hour, Minute,
-    Second, Sub_Second), relative to the specified timezone.
+    Second, Sub_Second), relative to the specified time zone offset.
 
 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;
+                  Month      : Month_Number;
+                  Day        : Day_Number;
+                  Hour       : Hour_Number;
+                  Minute     : Minute_Number;
+                  Second     : Second_Number;
+                  Sub_Second : Second_Duration := 0.0;
                   Leap_Second: Boolean := False;
-                  Time_Zone  : in Time_Zones.Time_Offset := 0)
-			  return Time;
+                  Time_Zone  : Time_Zones.Time_Offset := 0)
+                          return Time;
     Returns a Time built from the date and time values, relative to the
-    specified timezone. Time_Error is raised if Leap_Second is True,
+    specified time zone offset. Time_Error is raised if Leap_Second is True,
     and Hour, Minute, and Second are not appropriate for a Leap_Second.
 
-    AARM Note: A leap second always occurs as midnight, and is 23:59:60
-    UTC in ISO notation. So, if the timezone is UTC, if any of Hour /= 23,
+    AARM Note: A leap second always occurs at midnight UTC, and is 23:59:60
+    UTC in ISO notation. So, if the time zone is UTC, if any of Hour /= 23,
     Minute /= 59, or Second /= 59, then Time_Error should be raised.
     However, we do not say that, because other time zones will have different
     values where a leap second is allowed.
 
 function Time_Of (Year       : Year_Number;
-	          Month      : Month_Number;
-  		  Day        : Day_Number;
-		  Seconds    : Day_Duration;
+                  Month      : Month_Number;
+                  Day        : Day_Number;
+                  Seconds    : Day_Duration;
                   Leap_Second: Boolean := False;
-                  Time_Zone  : in Time_Zones.Time_Offset := 0)
-			  return Time;
+                  Time_Zone  : Time_Zones.Time_Offset := 0)
+                          return Time;
     Returns a Time built from the date and time values, relative to the
-    specified timezone. Time_Error is raised if Leap_Second is True,
+    specified time zone offset. Time_Error is raised if Leap_Second is True,
     and Seconds is not appropriate for a Leap_Second.
 
 procedure Split (Date       : in Time;
@@ -353,8 +371,8 @@
                  Sub_Second : out Second_Duration;
                  Leap_Second: out Boolean);
     Split Date into its constituent parts (Year, Month, Day, Hour, Minute,
-    Second, Sub_Second), relative to the specified timezone. Leap_Second is
-    true if Date identifies a leap second.
+    Second, Sub_Second), relative to the specified time zone offset.
+    Leap_Second is true if Date identifies a leap second.
 
 procedure Split (Date       : in Time;
                  Time_Zone  : in Time_Zones.Time_Offset := 0;
@@ -364,47 +382,39 @@
                  Seconds    : out Day_Duration;
                  Leap_Second: out Boolean);
     Split Date into its constituent parts (Year, Month, Day, Seconds), relative
-    to the specified timezone. Leap_Second is true if Date identifies a leap
-    second.
+    to the specified time zone offset. Leap_Second is true if Date identifies
+    a leap second.
 
 function Image (Date : Time;
-                Include_Time_Fraction : in Boolean := False) return String;
+                Include_Time_Fraction : Boolean := False) return String;
     Returns a string form of the Date.
     The format is "Year-Month-Day Hour:Minute:Second", where each value
-    other than Year is a 2 digit form of the value of the functions
+    other than Year is a 2-digit form of the value of the functions
     defined in Calendar and Calendar.Formatting, including a leading '0',
-    if needed. Year is a 4 digit value.
+    if needed. Year is a 4-digit value.
     If Include_Time_Fraction is True, Sub_Seconds*100 is suffixed to the
-    string as a 2 digit value following a '.'.
+    string as a 2-digit value following a '.'.
 
     AARM Note: The Image provides a string in ISO 8601 format, the
     international standard time format. Alternative representations allowed
     in ISO 8601 are not supported here.
 
-    ISO 8601 allows 24:0:0 for midnight; and a seconds value of 60 for
+    ISO 8601 allows 24:00:00 for midnight; and a seconds value of 60 for
     leap seconds. These are not allowed here (the routines mentioned above
     cannot produce those results).
 
 function Value (Date : String) return Time;
-    Returns a Time value for the image given as Date. The string should be
-    formatted as described for Image. Constraint_Error is raised if the
-    function cannot interpret the given string as a Time value.
-
-    AARM Note: We do not require that the given string is in exactly the
-    form returned by Image, as that would complicate the definition and
-    implementation for no value. For instance, the absence of leading zeros
-    shouldn't prevent that string from being decoded. If the implementation
-    has access to a complete ISO 8601 decoding routine, we certainly want to
-    let it be used. But we do require that any string that Image can produce
-    be convertible here without raising Constraint_Error.
+    Returns a Time value for the image given as Date.
+    Constraint_Error is raised if the string is not formatted as described for
+    Image, or the function cannot interpret the given string as a Time value.
 
 function Image (Elapsed_Time : Duration;
-                Include_Time_Fraction : in Boolean := False) return String;
+                Include_Time_Fraction : Boolean := False) return String;
     Returns a string form of the Elapsed_Time.
     The format is "Hours:Minute:Second", where each value
-    is a 2 digit form of the value, including a leading '0', if needed.
-    If Include_Time_Fraction is True, and Sub_Seconds*100 is suffixed to the
-    string as a 2 digit value following a '.'.
+    is a 2-digit form of the value, including a leading '0', if needed.
+    If Include_Time_Fraction is True, Sub_Seconds*100 is suffixed to the
+    string as a 2-digit value following a '.'.
 
     AARM Note: This cannot be implemented (directly) by calling
     Ada.Calendar.Formatting.Split, since it may be out of the range of
@@ -412,9 +422,10 @@
     Hour_Number.
 
 function Value (Elapsed_Time : String) return Duration;
-    Returns a Duration value for the image given as Elapsed_Time. The string
-    should be formatted as described for Image. Constraint_Error is raised
-    if the function cannot interpret the given string as a Duration value.
+    Returns a Duration value for the image given as Elapsed_Time.
+    Constraint_Error is raised if the string is not formatted as described for
+    Image, or the function cannot interpret the given string as a Duration
+    value.
 
 Implementation Advice
 
@@ -505,16 +516,21 @@
 
 
 Ada 95 defines the results of Time_Of and Split relative to an
-"implementation-defined timezone". We extend this by providing a Time_Offset
-type, and providing a function to return the offset of the
-"implementation-defined timezone" to UTC time. We also provide defaulted
-parameters to Split and Time_Of so that a specified timezone can be used
+"implementation-defined timezone" (9.6(24)). We extend this by providing a
+Time_Offset type, and providing a function to return the offset of the
+"implementation-defined time zone" to UTC time. We also provide defaulted
+parameters to Split and Time_Of so that a specified time zone can be used
 with those routines.
+
+(Research has shown the the use of "timezone" in the Ada 95 Standard is
+incorrect. For instance, see http://aa.usno.navy.mil/faq/docs/us_tzones.html,
+a page of the US Naval Observatory, which is charged with timekeeping in the
+US. Therefore, we've use "time zone" for this AI and also correct 9.6(24).)
 
-Supporting more timezones other than local and UTC is much more difficult. An
+Supporting more time zones other than local and UTC is much more difficult. An
 implementation can add such support with child packages.
 
-We expect the timezone functions will use the underlying operating system
+We expect the time zone functions will use the underlying operating system
 facilities. If those are inaccurate (say determining the starting date of
 daylight savings time in 1960 in Italy), we do not expect the Ada
 implementation to try to correct them.
@@ -526,9 +542,384 @@
 and dates in the distant past aren't usually interesting. The change in range
 is purposely kept small, so that we are not requiring a lot of extra bits
 in representations of Ada.Calendar.Time.
+
+!corrigendum 9.06(11)
+
+@drepl
+@xcode<  @b<subtype> Year_Number  @b<is> Integer @b<range> 1901 .. 2099;
+  @b<subtype> Month_Number @b<is> Integer @b<range> 1 .. 12;
+  @b<subtype> Day_Number   @b<is> Integer @b<range> 1 .. 31;
+  @b<subtype> Day_Duration @b<is> Duration @b<range> 0.0 .. 86_400.0;>
+@dby
+@xcode<  @b<subtype> Year_Number  @b<is> Integer @b<range> 1901 .. 2399;
+  @b<subtype> Month_Number @b<is> Integer @b<range> 1 .. 12;
+  @b<subtype> Day_Number   @b<is> Integer @b<range> 1 .. 31;
+  @b<subtype> Day_Duration @b<is> Duration @b<range> 0.0 .. 86_400.0;>
+
+!corrigendum 9.06(24)
+
+@drepl
+The functions Year, Month, Day, and Seconds return the corresponding values for
+a given value of the type Time, as appropriate to an implementation-defined
+timezone; the procedure Split returns all four corresponding values.
+Conversely, the function Time_Of combines a year number, a month number, a day
+number, and a duration, into a value of type Time. The operators "+" and "-"
+for addition and subtraction of times and durations, and the relational
+operators for times, have the conventional meaning.
+@dby
+The functions Year, Month, Day, and Seconds return the corresponding values for
+a given value of the type Time, as appropriate to an implementation-defined
+time zone; the procedure Split returns all four corresponding values.
+Conversely, the function Time_Of combines a year number, a month number, a day
+number, and a duration, into a value of type Time. The operators "+" and "-"
+for addition and subtraction of times and durations, and the relational
+operators for times, have the conventional meaning.
+
+!corrigendum 9.06.01(01)
+
+@dinsc
+
+@i<@s8<Static Semantics>>
+
+The following language-defined library packages exist:
+
+@xcode<@b<package> Ada.Calendar.Time_Zones @b<is>
+
+    -- @ft<@i<Time zone manipulation:>>
+
+    @b<type> Time_Offset @b<is range> -1440 .. 1440;
+
+    Unknown_Zone_Error : @b<exception>;
+
+    @b<function> UTC_Time_Offset (Date : @b<in> Time := Clock) @b<return> Time_Offset;
+
+@b<end> Ada.Calendar.Time_Zones;
+
+
+@b<package> Ada.Calendar.Arithmetic @b<is>
+
+    -- @ft<@i<Arithmetic on days:>>
+
+    @b<type> Day_Count @b<is range>
+      -366*(1+Year_Number'last - Year_Number'first)
+      ..
+      366*(1+Year_Number'last - Year_Number'first);
+
+    @b<subtype> Leap_Seconds_Count @b<is> Integer @b<range> -999 .. 999;
+
+    @b<procedure> Difference (Left, Right : @b<in> Time;
+                          Days : @b<out> Day_Count;
+                          Seconds : @b<out> Duration;
+                          Leap_Seconds : @b<out> Leap_Seconds_Count);
+
+    @b<function> "+" (Left : Time; Right : Day_Count) @b<return> Time;
+
+    @b<function> "+" (Left : Day_Count; Right : Time) @b<return> Time;
+
+    @b<function> "-" (Left : Time; Right : Day_Count) @b<return> Time;
+
+    @b<function> "-" (Left, Right : Time) @b<return> Day_Count;
+
+@b<end> Ada.Calendar.Arithmetic;
+
+@b<with> Ada.Calendar.Arithmetic, Ada.Calendar.Time_Zones;
+@b<package> Ada.Calendar.Formatting @b<is>
+
+    -- @ft<@i<Day of the week:>>
+
+    @b<type> Day_Name @b<is> (Monday, Tuesday, Wednesday, Thursday,
+        Friday, Saturday, Sunday);
+
+    @b<function> Day_of_Week (Date : Time) @b<return> Day_Name;
 
---!corrigendum 9.06(00)
+    -- @ft<@i<Hours:Minutes:Seconds access:>>
 
+    @b<subtype> Hour_Number         @b<is> Natural @b<range> 0 .. 23;
+    @b<subtype> Minute_Number       @b<is> Natural @b<range> 0 .. 59;
+    @b<subtype> Second_Number       @b<is> Natural @b<range> 0 .. 59;
+    @b<subtype> Second_Duration     @b<is> Day_Duration @b<range> 0.0 .. 1.0;
+
+    @b<function> Hour       (Date : @b<in> Time;
+                         Time_Zone  : @b<in> Time_Zones.Time_Offset := 0)
+                            @b<return> Hour_Number;
+
+    @b<function> Minute     (Date : @b<in> Time;
+                         Time_Zone  : @b<in> Time_Zones.Time_Offset := 0)
+                            @b<return> Minute_Number;
+
+    @b<function> Second     (Date : @b<in> Time;
+                         Time_Zone  : @b<in> Time_Zones.Time_Offset := 0)
+                            @b<return> Second_Number;
+
+    @b<function> Sub_Second (Date : @b<in> Time;
+                         Time_Zone  : @b<in> Time_Zones.Time_Offset := 0)
+                            @b<return> Second_Duration;
+
+    @b<function> Seconds_Of (Hour : @b<in> Hour_Number;
+                         Minute : @b<in> Minute_Number;
+                         Second : @b<in> Second_Number := 0;
+                         Sub_Second : @b<in> Second_Duration := 0.0)
+        @b<return> Day_Duration;
+
+    @b<procedure> Split (Seconds    : @b<in> Day_Duration;
+                     Hour       : @b<out> Hour_Number;
+                     Minute     : @b<out> Minute_Number;
+                     Second     : @b<out> Second_Number;
+                     Sub_Second : @b<out> Second_Duration);
+
+    @b<procedure> Split (Date       : @b<in> Time;
+                     Time_Zone  : @b<in> Time_Zones.Time_Offset := 0;
+                     Year       : @b<out> Year_Number;
+                     Month      : @b<out> Month_Number;
+                     Day        : @b<out> Day_Number;
+                     Hour       : @b<out> Hour_Number;
+                     Minute     : @b<out> Minute_Number;
+                     Second     : @b<out> Second_Number;
+                     Sub_Second : @b<out> Second_Duration);
+
+    @b<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;
+                      Leap_Second: Boolean := False;
+                      Time_Zone  : Time_Zones.Time_Offset := 0)
+                              @b<return> Time;
+
+    @b<function> Time_Of (Year       : Year_Number;
+                      Month      : Month_Number;
+                      Day        : Day_Number;
+                      Seconds    : Day_Duration;
+                      Leap_Second: Boolean := False;
+                      Time_Zone  : Time_Zones.Time_Offset := 0)
+                              @b<return> Time;
+
+    @b<procedure> Split (Date       : @b<in> Time;
+                     Time_Zone  : @b<in> Time_Zones.Time_Offset := 0;
+                     Year       : @b<out> Year_Number;
+                     Month      : @b<out> Month_Number;
+                     Day        : @b<out> Day_Number;
+                     Hour       : @b<out> Hour_Number;
+                     Minute     : @b<out> Minute_Number;
+                     Second     : @b<out> Second_Number;
+                     Sub_Second : @b<out> Second_Duration;
+                     Leap_Second: @b<out> Boolean);
+
+    @b<procedure> Split (Date       : @b<in> Time;
+                     Time_Zone  : @b<in> Time_Zones.Time_Offset := 0;
+                     Year       : @b<out> Year_Number;
+                     Month      : @b<out> Month_Number;
+                     Day        : @b<out> Day_Number;
+                     Seconds    : @b<out> Day_Duration;
+                     Leap_Second: @b<out> Boolean);
+
+    -- @ft<@i<Simple image and value:>>
+    @b<function> Image (Date : Time;
+                    Include_Time_Fraction : Boolean := False) @b<return> String;
+
+    @b<function> Value (Date : String) @b<return> Time;
+
+    @b<function> Image (Elapsed_Time : Duration;
+                    Include_Time_Fraction : Boolean := False) @b<return> String;
+
+    @b<function> Value (Elapsed_Time : String) @b<return> Duration;
+
+@b<end> Ada.Calendar.Formatting;>
+
+Type Time_Offset represents the number of minutes difference between the
+implementation-defined time zone used by Ada.Calendar and another time zone.
+
+@xcode<@b<function> UTC_Time_Offset (Date : @b<in> Time := Clock) @b<return> Time_Offset;>
+@xindent<Returns, as a number of minutes, the difference between the
+implementation-defined time zone of Calendar, and UTC time,
+at the time Date. If the time zone of the Calendar implementation is
+unknown, then Unknown_Zone_Error is raised.>
+
+@xcode<@b<procedure> Difference (Left, Right : @b<in> Time;
+                      Days : @b<out> Day_Count;
+                      Seconds : @b<out> Duration;
+                      Leap_Seconds : @b<out> Leap_Seconds_Count);>
+@xindent<Returns the difference between Left and Right.
+Days is the number of days of difference, Seconds is the
+remainder seconds of difference, and Leap_Seconds is the number
+of leap seconds.
+If Left < Right, then Seconds <= 0.0, Days <= 0, and Leap_Seconds <= 0.
+Otherwise, all values are non-negative.
+For the returned values, if Days = 0, then
+If Days = 0, then Seconds + Duration(Leap_Seconds) =
+Calendar."-" (Left, Right).>
+
+@xcode<@b<function> "+" (Left : Time; Right : Day_Count) @b<return> Time;
+@b<function> "+" (Left : Day_Count; Right : Time) @b<return> Time;>
+@xindent<Add a number of days to a time value. Time_Error is raised
+if the result is not representable as a value of type Time.>
+
+@xcode<@b<function> "-" (Left : Time; Right : Day_Count) @b<return> Time;>
+@xindent<Subtract a number of days from a time value. Time_Error is raised
+if the result is not representable as a value of type Time.>
+
+@xcode<@b<function> "-" (Left, Right : Time) @b<return> Day_Count;>
+@xindent<Subtract two time values, and @b<return> the number of days between
+them. This is the same value that Difference would return in Days.>
+
+@xcode<@b<function> Day_of_Week (Date : Time) @b<return> Day_Name;>
+@xindent<Returns the day of the week for Time. This is based on the Year,
+Month, and Day values of Time.>
+
+@xcode<@b<function> Hour       (Date : @b<in> Time;
+                     Time_Zone  : @b<in> Time_Zones.Time_Offset := 0)
+                        @b<return> Hour_Number;>
+@xindent<Returns the hour for Date, as appropriate for the specified time zone
+offset.>
+
+@xcode<@b<function> Minute     (Date : @b<in> Time;
+                     Time_Zone  : @b<in> Time_Zones.Time_Offset := 0)
+                        @b<return> Minute_Number;>
+@xindent<Returns the minute within the hour for Date, as appropriate for the
+specified time zone offset.>
+
+@xcode<@b<function> Second     (Date : @b<in> Time;
+                     Time_Zone  : @b<in> Time_Zones.Time_Offset := 0)
+                        @b<return> Second_Number;>
+@xindent<Returns the second within the hour and minute for Date, as appropriate
+for the specified time zone offset.>
+
+@xcode<@b<function> Sub_Second (Date : @b<in> Time;
+                     Time_Zone  : @b<in> Time_Zones.Time_Offset := 0)
+                        @b<return> Second_Duration;>
+@xindent<Returns the fraction of second for Date. (This has the same accuracy
+as Day_Duration), as appropriate to the specified time zone offset.>
+
+@xcode<@b<function> Seconds_Of (Hour : @b<in> Hour_Number;
+                     Minute : @b<in> Minute_Number;
+                     Second : @b<in> Second_Number := 0;
+                     Sub_Second : @b<in> Second_Duration := 0.0)
+    @b<return> Day_Duration;>
+@xindent<Returns a Day_Duration value for the Hour:Minute:Second.Sub_Second.
+This value can be used @b<in> Calendar.Time_Of as well as the argument to
+Calendar."+" and Calendar."-".>
+
+@xcode<@b<procedure> Split (Seconds : @b<in> Day_Duration;
+                 Hour : @b<out> Hour_Number;
+                 Minute : @b<out> Minute_Number;
+                 Second : @b<out> Second_Number;
+                 Sub_Second : @b<out> Second_Duration);>
+@xindent<Split Seconds into Hour:Minute:Second.Sub_Second.>
+
+@xcode<@b<procedure> Split (Date       : @b<in> Time;
+                 Time_Zone  : @b<in> Time_Zones.Time_Offset := 0;
+                 Year       : @b<out> Year_Number;
+                 Month      : @b<out> Month_Number;
+                 Day        : @b<out> Day_Number;
+                 Hour       : @b<out> Hour_Number;
+                 Minute     : @b<out> Minute_Number;
+                 Second     : @b<out> Second_Number;
+                 Sub_Second : @b<out> Second_Duration);>
+@xindent<Split Date into its constituent parts (Year, Month, Day, Hour, Minute,
+Second, Sub_Second), relative to the specified time zone offset.>
+
+@xcode<@b<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;
+                  Leap_Second: Boolean := False;
+                  Time_Zone  : Time_Zones.Time_Offset := 0)
+                          @b<return> Time;>
+@xindent<Returns a Time built from the date and time values, relative to the
+specified time zone offset. Time_Error is raised if Leap_Second is True,
+and Hour, Minute, and Second are not appropriate for a Leap_Second.>
+
+@xcode<@b<function> Time_Of (Year       : Year_Number;
+                  Month      : Month_Number;
+                  Day        : Day_Number;
+                  Seconds    : Day_Duration;
+                  Leap_Second: Boolean := False;
+                  Time_Zone  : Time_Zones.Time_Offset := 0)
+                          @b<return> Time;>
+@xindent<Returns a Time built from the date and time values, relative to the
+specified time zone offset. Time_Error is raised if Leap_Second is True,
+and Seconds is not appropriate for a Leap_Second.>
+
+@xcode<@b<procedure> Split (Date       : @b<in> Time;
+                 Time_Zone  : @b<in> Time_Zones.Time_Offset := 0;
+                 Year       : @b<out> Year_Number;
+                 Month      : @b<out> Month_Number;
+                 Day        : @b<out> Day_Number;
+                 Hour       : @b<out> Hour_Number;
+                 Minute     : @b<out> Minute_Number;
+                 Second     : @b<out> Second_Number;
+                 Sub_Second : @b<out> Second_Duration;
+                 Leap_Second: @b<out> Boolean);>
+@xindent<Split Date into its constituent parts (Year, Month, Day, Hour, Minute,
+Second, Sub_Second), relative to the specified time zone offset.
+Leap_Second is true if Date identifies a leap second.>
+
+@xcode<@b<procedure> Split (Date       : @b<in> Time;
+                 Time_Zone  : @b<in> Time_Zones.Time_Offset := 0;
+                 Year       : @b<out> Year_Number;
+                 Month      : @b<out> Month_Number;
+                 Day        : @b<out> Day_Number;
+                 Seconds    : @b<out> Day_Duration;
+                 Leap_Second: @b<out> Boolean);>
+@xindent<Split Date into its constituent parts (Year, Month, Day, Seconds),
+relative to the specified time zone offset. Leap_Second is true if Date
+identifies a leap second.>
+
+@xcode<@b<function> Image (Date : Time;
+                Include_Time_Fraction : Boolean := False) @b<return> String;>
+@xindent<Returns a string form of the Date.
+The format is "Year-Month-Day Hour:Minute:Second", where each value
+other than Year is a 2-digit form of the value of the functions
+defined in Calendar and Calendar.Formatting, including a leading '0',
+if needed. Year is a 4-digit value.
+If Include_Time_Fraction is True, Sub_Seconds*100 is suffixed to the
+string as a 2-digit value following a '.'.>
+
+@xcode<@b<function> Value (Date : String) @b<return> Time;>
+@xindent<Returns a Time value for the image given as Date.
+Constraint_Error is raised if the string is not formatted as described for
+Image, or the function cannot interpret the given string as a Time value.>
+
+@xcode<@b<function> Image (Elapsed_Time : Duration;
+                Include_Time_Fraction : Boolean := False) @b<return> String;>
+@xindent<Returns a string form of the Elapsed_Time.
+The format is "Hours:Minute:Second", where each value
+is a 2-digit form of the value, including a leading '0', if needed.
+If Include_Time_Fraction is True, Sub_Seconds*100 is suffixed to the
+string as a 2-digit value following a '.'.>
+
+@xcode<@b<function> Value (Elapsed_Time : String) @b<return> Duration;>
+@xindent<Returns a Duration value for the image given as Elapsed_Time.
+Constraint_Error is raised if the string is not formatted as described for
+Image, or the function cannot interpret the given string as a Duration
+value.>
+
+@i<@s8<Implementation Advice>>
+
+An implementation should support leap seconds if the target system supports
+them. If leap seconds are not supported, functions returning leap seconds
+should return zero, and Time_Of should raise Time_Error if Leap_Second is true.
+
+@xindent<@s9<NOTES@hr
+36 The time in the time zone known as Greenwich Mean Time (GMT)
+is generally equivalent to UTC time.>>
+
+@xindent<@s9<37 The implementation-defined time zone used for type Time may be, but need
+not be, the local time zone. UTC_Time_Offset always returns the difference
+relative to the implementation-defined time zone of package Calendar. If
+UTC_Time_Offset does not raise Unknown_Zone_Error, UTC time can be
+safely calculated (within the accuracy of the underlying time-base).>>
+
+@xindent<@s9<38 Calling Split on the results of subtracting Duration(UTC_Time_Offset*60)
+from Clock provides the components (hours, minutes, and so on) of the UTC
+time. In the US, for example, UTC_Time_Offset will generally be negative.>>
+
+
 !ACATS test
 
 Test(s) need to be constructed.
@@ -1729,17 +2120,17 @@
     type Name_List is array (Calendar.Month_Number) of Unbounded_String; -- Used to provide month names
 
     Default_Short_Name : constant Name_List := (01 => To_Unbounded_String ("Jan"),
-						02 => To_Unbounded_String ("Feb"),
+                                                02 => To_Unbounded_String ("Feb"),
                                                 03 => To_Unbounded_String ("Mar"),
-						04 => To_Unbounded_String ("Apr"),
+                                                04 => To_Unbounded_String ("Apr"),
                                                 05 => To_Unbounded_String ("May"),
-						06 => To_Unbounded_String ("Jun"),
+                                                06 => To_Unbounded_String ("Jun"),
                                                 07 => To_Unbounded_String ("Jul"),
-						08 => To_Unbounded_String ("Aug"),
+                                                08 => To_Unbounded_String ("Aug"),
                                                 09 => To_Unbounded_String ("Sep"),
-						10 => To_Unbounded_String ("Oct"),
+                                                10 => To_Unbounded_String ("Oct"),
                                                 11 => To_Unbounded_String ("Nov"),
-						12 => To_Unbounded_String ("Dec") );
+                                                12 => To_Unbounded_String ("Dec") );
                                                 -- Default "short" month names
 
     Default_Long_Name  : constant Name_List := (01 => To_Unbounded_String ("January"),
@@ -2653,7 +3044,7 @@
 Or the display of the day of the week in output:
     type Day_Abbreviations_Type is array (Days_of_Week) of String (1..3);
     Day_Abbreviations : constant Day_Abbreviations_Type :=
-	   (Sunday => "Sun", Monday => "Mon", Tuesday => "Tue", Wednesday => "Wed",
+           (Sunday => "Sun", Monday => "Mon", Tuesday => "Tue", Wednesday => "Wed",
           Thursday => "Thu", Friday => "Fri", Saturday => "Sat");
 
     Put (Day_Abbreviations (Day_of_Week (A_Time));
@@ -3937,6 +4328,333 @@
 
 Ah, ok, it is defined in ACF, so this needs to be added to ACA's
 context clause in the AI.
+
+****************************************************************
+
+From: Tucker Taft
+Sent: Wednesday, March 31, 2004  5:53 PM
+
+Here are some editorial comments on AI-351
+regarding timezone terminology.  My goal is to
+be sure we don't presume that the time values have
+any timezone information built into them.  It is
+only Split and Time-Of and friends that necessarily
+care about time zones.
+
+> Type Time_Offset represents the number of minutes difference between the
+> mplementation-defined timezone used by Ada.Calendar and another timezone.
+> Subtracting this value from a time value yields the time for the timezone.
+
+The second sentence should probably be deleted, or replaced with:
+
+   Given the time of day as implied by the Seconds value returned
+   by Calendar.Split, this value gives the number of minutes
+   that would be subtracted from this time to produce a time
+   in the timezone of interest.
+
+>
+> function Local_Time_Offset (Date : in Time := Clock) return Time_Offset;
+
+I believe we have suggested that this be named UTC_Time_Offset
+(or GMT_Time_Offset).
+
+>     Returns, as a number of minutes, the difference between the
+>     implementation-defined timezone of the values of Calendar, and UTC time,
+>     at the time Date.
+
+I would delete "of the values" in the above sentence.
+
+> ... If the timezone of the Calendar implementation is
+>     unknown, then Unknown_Zone_Error is raised.
+>
+>     Notes: The time in the time zone known as Greenwich Mean Time (GMT)
+>     is generally equivalent to UTC time.
+>
+>     The implementation-defined timezone used for type Time may be, but need not
+>     be, the local timezone. Local_Time_Offset always returns the difference
+>     between the implementation-defined timezone of package Calendar.
+
+"between" should be "relative to".
+
+
+
+> ... If
+>     Local_Time_Offset does not raise Unknown_Zone_Error, UTC time can be
+>     safely calculated (within the accuracy of the underlying time-base).
+>
+>     AARM Notes: The Date parameter is needed to take into account time
+>     differences caused by daylight-savings time and other time changes.
+>
+>     Other timezones can be supported with a child package.
+>
+>     The accuracy of this routine is not specified; the intent is that the
+>     facilities of the underlying target operating system are used to implement
+>     it.
+>
+>     Subtracting Duration(Local_Time_Zone*60) from Clock provides the UTC time.
+>     In the US, for example, Time_Offset will generally be negative.
+
+This should be in terms of Seconds returned by Split.  E.g.:
+
+    Subtracting Duration(UTC_Time_Zone*60) from the Seconds value
+    returned by Calendar.Split (modulo 86_400.0) would give the
+    number of seconds since midnight for the UTC timezone.
+
+Otherwise, the wording looks OK (presuming comments from the
+ARG meeting are incorporated).
+
+****************************************************************
+
+From: Randy Brukardt
+Sent: Thursday, April  1, 2004  5:13 PM
+
+Tucker wrote:
+
+> Here are some editorial comments on AI-351
+> regarding timezone terminology.
+
+John's research proves that it is "time zone", not "timezone". I added a
+correction to the existing Standard's wording for that as part of this AI.
+
+> My goal is to
+> be sure we don't presume that the time values have
+> any timezone information built into them.  It is
+> only Split and Time-Of and friends that necessarily
+> care about time zones.
+
+Most of these changes were made by the meeting minutes. I've used the wording
+proposed there if there is a difference. Comments are welcome.
+
+> > Type Time_Offset represents the number of minutes difference between the
+> > mplementation-defined timezone used by Ada.Calendar and another timezone.
+> > Subtracting this value from a time value yields the time for the timezone.
+>
+> The second sentence should probably be deleted, or replaced with:
+>
+>    Given the time of day as implied by the Seconds value returned
+>    by Calendar.Split, this value gives the number of minutes
+>    that would be subtracted from this time to produce a time
+>    in the timezone of interest.
+
+The minutes deleted the second sentence. It's said better later anyway.
+
+> > function Local_Time_Offset (Date : in Time := Clock) return Time_Offset;
+>
+> I believe we have suggested that this be named UTC_Time_Offset
+> (or GMT_Time_Offset).
+
+The minutes say UTC_Time_Offset.
+
+> >     Returns, as a number of minutes, the difference between the
+> >     implementation-defined timezone of the values of Calendar, and UTC time,
+> >     at the time Date.
+>
+> I would delete "of the values" in the above sentence.
+
+OK.
+
+> > ... If the timezone of the Calendar implementation is
+> >     unknown, then Unknown_Zone_Error is raised.
+> >
+> >     Notes: The time in the time zone known as Greenwich Mean Time (GMT)
+> >     is generally equivalent to UTC time.
+> >
+> >     The implementation-defined timezone used for type Time may be, but need not
+> >     be, the local timezone. Local_Time_Offset always returns the difference
+> >     between the implementation-defined timezone of package Calendar.
+>
+> "between" should be "relative to".
+
+OK.
+
+...
+> >     Subtracting Duration(Local_Time_Zone*60) from Clock provides the UTC time.
+> >     In the US, for example, Time_Offset will generally be negative.
+>
+> This should be in terms of Seconds returned by Split.  E.g.:
+>
+>     Subtracting Duration(UTC_Time_Zone*60) from the Seconds value
+>     returned by Calendar.Split (modulo 86_400.0) would give the
+>     number of seconds since midnight for the UTC timezone.
+
+The minutes said:
+
+"Calling Split on the results of subtracting Duration(Local_Time_Zone*60) from
+Clock provides the hours/minutes/seconds of the UTC time."
+
+That's not really correct, as the day, month, and even year can change as a
+result of the time zone calculation. So I replaced the above with:
+
+"Calling Split on the results of subtracting Duration(UTC_Time_Offset*60) from
+Clock provides the components of the UTC time."
+
+I worried that any of these wording sounds like something the user is supposed
+to do, so I also added the following AARM Note:
+
+AARM Note
+This is an illustration to help specify the value of
+UTC_Time_Offset. A user should pass UTC_Time_Offset as the Time_Zone
+parameter of Split, rather than trying to make the above calculation.
+
+Something on this line could be a regular note (as it is really aimed at
+users), although that suffers from placement at the bottom of the section
+rather that right here where it is needed.
+
+> Otherwise, the wording looks OK (presuming comments from the
+> ARG meeting are incorporated).
+
+Good. Most of the comments from the meeting were related to this issue; and I'd
+already made all of them (related to this issue or not). (The new version of
+this AI, and the other 20 or so approved or killed at the meeting, will be
+available as soon as the minutes are completed.)
+
+****************************************************************
+
+From: Tucker Taft
+Sent: Thursday, April  1, 2004  9:14 PM
+
+> ...
+> The minutes said:
+>
+> "Calling Split on the results of subtracting Duration(Local_Time_Zone*60)
+> from Clock provides the hours/minutes/seconds of the UTC time."
+>
+> That's not really correct, as the day, month, and even year can change as a
+> result of the time zone calculation. So I replaced the above with:
+>
+> "Calling Split on the results of subtracting Duration(UTC_Time_Offset*60)
+> from Clock provides the components of the UTC time."
+
+I don't particularly like this wording, since it still implies that
+the time-offset has something to do with changes to a value
+of type Time, and that is not correct for the "Unix" model.
+All timezones have the same value of type Time at a given
+instant.  The only difference is the result returned
+by Split.  I would rather have it expressed in terms of
+values returned by Split, which is correct for either model.
+
+> I worried that any of these wording sounds like something the user is
+> supposed to do, so I also added the following AARM Note:
+>
+> AARM Note
+> This is an illustration to help specify the value of
+> UTC_Time_Offset. A user should pass UTC_Time_Offset as the Time_Zone
+> parameter of Split, rather than trying to make the above calculation.
+
+But even with this, there is an implication that this is
+what the implementation would do, and that's misleading
+for the "Unix" model.
+
+****************************************************************
+
+From: Randy Brukardt
+Sent: Thursday, April  1, 2004  10:10 PM
+
+> I don't particularly like this wording, since it still implies that
+> the time-offset has something to do with changes to a value
+> of type Time, ...
+
+Of course. A Time_Offset is a number of minutes. Nothing more and nothing
+less. It would be odd, to say the least, if you couldn't subtract a number
+of minutes from a Time and get a result!
+
+> ... and that is not correct for the "Unix" model.
+
+I'm fairly confident that *any* Time model allows arithmetic.
+
+> All timezones have the same value of type Time at a given instant.
+> The only difference is the result returned
+> by Split.  I would rather have it expressed in terms of
+> values returned by Split, which is correct for either model.
+
+We agreed that a value of type Time does not of itself contain time zone
+information. The only difference is whether you consider a Time value to
+belong to a specific time zone. That's irrelevant to all of the operations
+in Calendar and in these packages - it's a user's choice. The rewording that
+we agreed to was to insure that we didn't say that a value of Time was in a
+particular time zone (which I agree is nonsense in either model that's been
+discussed), and that was accomplished by only talking about the results of
+Split.
+
+My wording only talks about the result of Split, and doesn't require any
+other knowledge to understand. I dislike your wording because you need a PHD
+to figure out what it means. (I don't have one, and I haven't been able to
+figure it out!) If you only talk about the seconds, you have the possibility
+of ending up with negative seconds, or more than one days worth of seconds,
+and that's confusing at best -- and it really doesn't tell you what the UTC
+time is. Users want to know Hours and Minutes (and Days and Years), not some
+number of seconds. Finally, your wording is in terms of the "old" Split, and
+I doubt many people will use that when something better is available here
+(the number of seconds since midnight is one of the least convenient
+definitions of time possible).
+
+> > I worried that any of these wording sounds like something the user is
+> > supposed to do, so I also added the following AARM Note:
+> >
+> > AARM Note
+> > This is an illustration to help specify the value of
+> > UTC_Time_Offset. A user should pass UTC_Time_Offset as the Time_Zone
+> > parameter of Split, rather than trying to make the above calculation.
+>
+> But even with this, there is an implication that this is
+> what the implementation would do, and that's misleading
+> for the "Unix" model.
+
+You're claiming again that your model can't do arithmetic.
+
+In any case, I think that an implementation does have to do the subtraction
+somewhere (or something like it). There is nothing stopping a user from
+using "25" as a Time_Offset, and the results of Split had better reflect
+that. That subtraction would be inside of Split, but it still has to be made
+somewhere (if you're using a system call to implement this, it could do the
+subtraction -- but *something* has to do it).
+
+Finally, I really don't understand why this matters. I cannot think of any
+semantic difference between any of the models discussed - they all give the
+same results from Split in all cases. The wording would be clearer if we
+simply choose a model and stuck to it. Other models can be used for
+implementation, and that's fine (and expected, in fact), but to try to bend
+the wording to fit a number of implementation models at once seems
+misguided.
+
+****************************************************************
+
+From: Randy Brukardt
+Sent: Monday, April  5, 2004  9:18 PM
+
+Here's an easy (I hope) question.
+
+In AI-351, we said that we'd add these packages to 9.6.
+
+Having looked at this, I don't think that's a good idea. The packages are
+formatted as a large batch of "static semantics" (following the format of much
+of Annex A). However, the existing 9.6 has a lot of it's definition in "dynamic
+semantics". Inserting the new packages in the middle would split the
+specification of Calendar and its definition (and that of Time, etc.) by many
+pages.
+
+One could rewrite all of the new stuff into the format of 9.6, but that doesn't
+really help, because it would split the Implementation Requirements,
+Permissions, and Advice for Calendar far from the rest of the material. And
+such a rewrite would mean starting over vis-a-vis discussing the AI. (I don't
+want to go there!)
+
+So I've concluded it would be better to put the new packages into a separate
+subclause (or sunclauses) following 9.6. That brings up two questions.
+  -- Should this be one subclause or three? (There are three packages).
+  -- What should the title of the subclause?
+
+For now, I've used one clause:
+  9.6.1  Formatting, Time Zones, and other operations for Time
+
+Suggestions welcome.
+
+****************************************************************
+
+From: Tucker Taft
+Sent: Tuesday, April  6, 2004  8:11 AM
+
+I like your suggestion of just having one additional subclause.
 
 ****************************************************************
 

Questions? Ask the ACAA Technical Agent