| blob | 4e7df3130353e5a9ca96a15ed66748581c56c7c2 |
1 #----------------------------------------------------------------------
2 #
3 # clock.tcl --
4 #
5 # This file implements the portions of the [clock] ensemble that
6 # are coded in Tcl. Refer to the users' manual to see the description
7 # of the [clock] command and its subcommands.
8 #
9 #
10 #----------------------------------------------------------------------
11 #
12 # Copyright (c) 2004,2005,2006,2007 by Kevin B. Kenny
13 # See the file "license.terms" for information on usage and redistribution
14 # of this file, and for a DISCLAIMER OF ALL WARRANTIES.
15 #
16 # RCS: @(#) $Id: clock.tcl,v 1.47.2.9 2009/10/29 01:17:03 kennykb Exp $
17 #
18 #----------------------------------------------------------------------
20 # We must have message catalogs that support the root locale, and
21 # we need access to the Registry on Windows systems.
28 }
29 }
30 }
32 # Put the library directory into the namespace for the ensemble
33 # so that the library code can find message catalogs and time zone
34 # definition files.
39 #----------------------------------------------------------------------
40 #
41 # clock --
42 #
43 # Manipulate times.
44 #
45 # The 'clock' command manipulates time. Refer to the user documentation
46 # for the available subcommands and what they do.
47 #
48 #----------------------------------------------------------------------
52 # Export the subcommands
55 namespace export clicks
56 namespace export microseconds
57 namespace export milliseconds
59 namespace export seconds
60 namespace export add
62 # Import the message catalog commands that we use.
67 }
69 #----------------------------------------------------------------------
70 #
71 # ::tcl::clock::Initialize --
72 #
73 # Finish initializing the 'clock' subsystem
74 #
75 # Results:
76 # None.
77 #
78 # Side effects:
79 # Namespace variable in the 'clock' subsystem are initialized.
80 #
81 # The '::tcl::clock::Initialize' procedure initializes the namespace
82 # variables and root locale message catalog for the 'clock' subsystem.
83 # It is broken into a procedure rather than simply evaluated as a script
84 # so that it will be able to use local variables, avoiding the dangers
85 # of 'creative writing' as in Bug 1185933.
86 #
87 #----------------------------------------------------------------------
93 variable LibDir
95 # Define the Greenwich time zone
98 variable TZData
99 array unset TZData
102 }
106 }
109 }
110 InitTZData
112 # Define the message catalog for the root locale.
120 DAYS_OF_WEEK_ABBREV {
121 Sun Mon Tue Wed Thu Fri Sat
122 }
123 DAYS_OF_WEEK_FULL {
124 Sunday Monday Tuesday Wednesday Thursday Friday Saturday
125 }
126 GREGORIAN_CHANGE_DATE 2299161
129 LOCALE_ERAS {}
130 LOCALE_NUMERALS {
131 00 01 02 03 04 05 06 07 08 09
132 10 11 12 13 14 15 16 17 18 19
133 20 21 22 23 24 25 26 27 28 29
134 30 31 32 33 34 35 36 37 38 39
135 40 41 42 43 44 45 46 47 48 49
136 50 51 52 53 54 55 56 57 58 59
137 60 61 62 63 64 65 66 67 68 69
138 70 71 72 73 74 75 76 77 78 79
139 80 81 82 83 84 85 86 87 88 89
140 90 91 92 93 94 95 96 97 98 99
141 }
144 MONTHS_ABBREV {
145 Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec
146 }
147 MONTHS_FULL {
148 January February March
149 April May June
150 July August September
151 October November December
152 }
158 }
160 # Define a few Gregorian change dates for other locales. In most cases
161 # the change date follows a language, because a nation's colonies changed
162 # at the same time as the nation itself. In many cases, different
163 # national boundaries existed; the dominating rule is to follow the
164 # nation's capital.
166 # Italy, Spain, Portugal, Poland
173 # France, Austria
177 # For Belgium, we follow Southern Netherlands; Liege Diocese
178 # changed several weeks later.
183 # Austria
187 # Hungary
191 # Germany, Norway, Denmark (Catholic Germany changed earlier)
199 # Holland (Brabant, Gelderland, Flanders, Friesland, etc. changed
200 # at various times)
204 # Protestant Switzerland (Catholic cantons changed earlier)
210 # English speaking countries
214 # Sweden (had several changes onto and off of the Gregorian calendar)
218 # Russia
222 # Romania (Transylvania changed earler - perhaps de_RO should show
223 # the earlier date?)
227 # Greece
231 #------------------------------------------------------------------
232 #
233 # CONSTANTS
234 #
235 #------------------------------------------------------------------
237 # Paths at which binary time zone data for the Olson libraries
238 # are known to reside on various operating systems
246 } {
249 }
250 }
252 # Define the directories for time zone data and message catalogs.
257 # Number of days in the months, in common years and leap years.
268 }
272 }
274 # Another epoch (Hi, Jeff!)
278 # Integer ranges
283 # Day before Leap Day
287 # Translation table to map Windows TZI onto cities, so that
288 # the Olson rules can apply. In some cases the mapping is ambiguous,
289 # so it's wise to specify $::env(TCL_TZ) rather than simply depending
290 # on the system time zone.
292 # The keys are long lists of values obtained from the time zone
293 # information in the Registry. In order, the list elements are:
294 # Bias StandardBias DaylightBias
295 # StandardDate.wYear StandardDate.wMonth StandardDate.wDayOfWeek
296 # StandardDate.wDay StandardDate.wHour StandardDate.wMinute
297 # StandardDate.wSecond StandardDate.wMilliseconds
298 # DaylightDate.wYear DaylightDate.wMonth DaylightDate.wDayOfWeek
299 # DaylightDate.wDay DaylightDate.wHour DaylightDate.wMinute
300 # DaylightDate.wSecond DaylightDate.wMilliseconds
301 # The values are the names of time zones where those rules apply.
302 # There is considerable ambiguity in certain zones; an attempt has
303 # been made to make a reasonable guess, but this table needs to be
304 # taken with a grain of salt.
381 }]
383 # Groups of fields that specify the date, priorities, and
384 # code bursts that determine Julian Day Number given those groups.
385 # The code in [clock scan] will choose the highest priority
386 # (lowest numbered) set of fields that determines the date.
399 }
405 }
408 dict set date era CE
413 }
415 dict set date era CE
420 }
422 dict set date era CE
428 }
432 dict set date era CE
435 }
438 dict set date era CE
441 }
445 iso8601YearOfCentury iso8601Year]
446 dict set date era CE
449 }
456 }
462 }
468 }
475 }
482 }
487 }
488 }
490 # Groups of fields that specify time of day, priorities,
491 # and code that processes them
499 }
502 }
507 }
511 }
517 }
522 }
526 }
527 }
529 # Legacy time zones, used primarily for parsing RFC822 dates.
619 ]
621 # Caches
624 # names and whose values are pairs
625 # comprising regexes matching numerals
626 # in the given locales and dictionaries
627 # mapping the numerals to their numeric
628 # values.
630 # in which [mcload] has been executed
631 # and whose values are second-level
632 # dictionaries indexed by message
633 # name and giving message text.
634 # variable CachedSystemTimeZone; # If 'CachedSystemTimeZone' exists,
635 # it contains the value of the
636 # system time zone, as determined from
637 # the environment.
639 # names and whose values are 1 if
640 # the time zone is unknown and 0
641 # if it is known.
643 # and whose values are lists of quads
644 # comprising start time, UTC offset,
645 # Daylight Saving Time indicator, and
646 # time zone abbreviation.
648 # and locale to the name of a procedure
649 # that renders the given format
650 }
653 #----------------------------------------------------------------------
654 #
655 # clock format --
656 #
657 # Formats a count of seconds since the Posix Epoch as a time
658 # of day.
659 #
660 # The 'clock format' command formats times of day for output.
661 # Refer to the user documentation to see what it does.
662 #
663 #----------------------------------------------------------------------
667 variable FormatProc
668 variable TZData
674 # Get the data for time changes in the given zone
678 }
683 }
684 }
686 # Build a procedure to format the result. Cache the built procedure's
687 # name in the 'FormatProc' array to avoid losing its internal
688 # representation, which contains the name resolution.
697 }
701 }
703 #----------------------------------------------------------------------
704 #
705 # ParseClockFormatFormat --
706 #
707 # Builds and caches a procedure that formats a time value.
708 #
709 # Parameters:
710 # format -- Format string to use
711 # locale -- Locale in which the format string is to be interpreted
712 #
713 # Results:
714 # Returns the name of the newly-built procedure.
715 #
716 #----------------------------------------------------------------------
722 }
724 # Map away the locale-dependent composite format groups
726 EnterLocale $locale oldLocale
728 # Change locale if a fresh locale has been given on the command line.
732 ParseClockFormatFormat2 $format $locale $procName
736 # Restore the locale
739 mclocale $oldLocale
740 }
742 # Return either the error or the proc name
749 }
752 }
754 }
763 {
764 variable TZData
768 }]
777 {} {
779 set state percent
782 }
783 }
789 }
799 }
809 }
818 }
827 }
832 }
836 }
840 }
842 # alternative era
843 set state percentE
849 {
854 }
860 }
861 }
863 # week number
867 }
869 # week number
872 }
878 }
888 }
892 }
896 }
903 }
913 }
917 }
924 }
927 }
931 }
933 # alternative numerals
934 set state percentO
940 }
941 }
943 # converted to uppercase
952 }
963 }
967 }
971 }
973 # leading zero
978 }
981 }
985 }
987 # first Sunday of the year is the
988 # first day of week 01
994 }
995 incr dow
1000 }
1002 }
1006 }
1008 # 6-Saturday)
1012 }
1014 # Monday of the year is the first day
1015 # of week 01.
1022 }
1025 }
1030 }
1034 }
1036 # east (+) or west (-) of Greenwich
1040 }
1044 }
1047 }
1050 }
1051 }
1052 }
1056 E {
1064 }
1068 }
1076 }
1077 }
1080 }
1083 }
1084 }
1085 }
1090 # numerals
1095 }
1097 # numerals
1104 }
1106 # numerals
1116 }
1121 }
1123 # numerals
1130 }
1132 # numerals
1138 }
1140 # in alternative numerals
1145 }
1147 # in alternative numerals
1152 }
1154 # numerals
1159 }
1162 }
1163 }
1164 }
1165 }
1166 }
1168 # Clean up any improperly terminated groups
1171 percent {
1173 }
1174 percentE {
1176 }
1177 percentO {
1179 }
1180 }
1183 $preFormatCode
1185 "
1187 # puts [list $procName [info args $procName] [info body $procName]]
1190 }
1192 #----------------------------------------------------------------------
1193 #
1194 # clock scan --
1195 #
1196 # Inputs a count of seconds since the Posix Epoch as a time
1197 # of day.
1198 #
1199 # The 'clock format' command scans times of day on input.
1200 # Refer to the user documentation to see what it does.
1201 #
1202 #----------------------------------------------------------------------
1208 # Check the count of args
1214 "wrong \# args: should be\
1216 ?-base seconds?\
1217 ?-format string? ?-gmt boolean?\
1219 }
1221 # Set defaults
1227 set locale c
1230 # Pick up command line options.
1237 }
1240 }
1243 }
1246 }
1249 }
1254 must be -base, -format, -gmt, -locale or -timezone"
1255 }
1256 }
1257 }
1259 # Check options for validity
1264 "cannot use -gmt and -timezone in same call"
1265 }
1269 }
1276 }
1277 }
1280 # Perhaps someday we'll localize the legacy code. Right now,
1281 # it's not localized.
1285 "legacy \[clock scan\] does not support -locale"
1287 }
1289 }
1291 # Change locale if a fresh locale has been given on the command line.
1293 EnterLocale $locale oldLocale
1297 # Map away the locale-dependent composite format groups
1300 $scanner $string $base $timezone
1304 # Restore the locale
1307 mclocale $oldLocale
1308 }
1315 }
1318 }
1320 }
1322 #----------------------------------------------------------------------
1323 #
1324 # FreeScan --
1325 #
1326 # Scans a time in free format
1327 #
1328 # Parameters:
1329 # string - String containing the time to scan
1330 # base - Base time, expressed in seconds from the Epoch
1331 # timezone - Default time zone in which the time will be expressed
1332 # locale - (Unused) Name of the locale where the time will be scanned.
1333 #
1334 # Results:
1335 # Returns the date and time extracted from the string in seconds
1336 # from the epoch
1337 #
1338 #----------------------------------------------------------------------
1342 variable TZData
1344 # Get the data for time changes in the given zone
1349 }
1351 # Extract year, month and day from the base time for the
1352 # parser to use as defaults
1361 # Parse the date. The parser will return a list comprising
1362 # date, time, time zone, relative month/day/seconds, relative
1363 # weekday, ordinal month.
1373 }
1376 parseWeekday parseOrdinalMonth
1378 # If the caller supplied a date in the string, update the 'date' dict
1379 # with the value. If the caller didn't specify a time with the date,
1380 # default to midnight.
1383 lassign $parseDate y m d
1389 }
1390 }
1391 dict set date era CE
1397 }
1398 }
1400 # If the caller supplied a time zone in the string, it comes back
1401 # as a two-element list; the first element is the number of minutes
1402 # east of Greenwich, and the second is a Daylight Saving Time
1403 # indicator ( 1 == yes, 0 == no, -1 == unknown ). We make it into
1404 # a time zone indicator of +-hhmm.
1407 lassign $parseZone minEast dstFlag
1410 SetupTimeZone $timezone
1411 }
1414 # Assemble date, time, zone into seconds-from-epoch
1425 }
1435 # Do relative times
1438 lassign $parseRel relMonth relDay relSecond
1442 }
1444 # Do relative weekday
1448 lassign $parseWeekday dayOrdinal dayOfWeek
1450 dict set date2 era CE
1457 }
1470 }
1472 # Do relative month
1476 lassign $parseOrdinalMonth monthOrdinal monthNumber
1481 }
1487 }
1488 incr monthOrdinal
1489 }
1493 }
1496 }
1499 #----------------------------------------------------------------------
1500 #
1501 # ParseClockScanFormat --
1502 #
1503 # Parses a format string given to [clock scan -format]
1504 #
1505 # Parameters:
1506 # formatString - The format being parsed
1507 # locale - The current locale
1508 #
1509 # Results:
1510 # Constructs and returns a procedure that accepts the
1511 # string being scanned, the base time, and the time zone.
1512 # The procedure will either return the scanned time or
1513 # else throw an error that should be rethrown to the caller
1514 # of [clock scan]
1515 #
1516 # Side effects:
1517 # The given procedure is defined in the ::tcl::clock
1518 # namespace. Scan procedures are not deleted once installed.
1519 #
1520 # Why do we parse dates by defining a procedure to parse them?
1521 # The reason is that by doing so, we have one convenient place to
1522 # cache all the information: the regular expressions that match the
1523 # patterns (which will be compiled), the code that assembles the
1524 # date information, everything lands in one place. In this way,
1525 # when a given format is reused at run time, all the information
1526 # of how to apply it is available in a single place.
1527 #
1528 #----------------------------------------------------------------------
1532 # Check whether the format has been parsed previously, and return
1533 # the existing recognizer if it has.
1539 }
1541 variable DateParseActions
1542 variable TimeParseActions
1544 # Localize the %x, %X, etc. groups
1548 # Condense whitespace
1552 # Walk through the groups of the format string. In this loop, we
1553 # accumulate:
1554 # - a regular expression that matches the string,
1555 # - the count of capturing brackets in the regexp
1556 # - a set of code that post-processes the fields captured by the regexp,
1557 # - a dictionary whose keys are the names of fields that are present
1558 # in the format string.
1570 {} {
1578 }
1580 }
1581 }
1582 % {
1585 % {
1587 }
1588 { } {
1590 }
1599 incr i
1600 }
1608 }
1615 incr i
1618 }
1627 }
1634 }
1641 }
1644 }
1653 }
1666 }
1673 }
1680 }
1687 }
1694 }
1701 }
1708 }
1711 }
1714 }
1726 }
1729 incr captureCount
1736 }
1738 # This next case is insanely difficult,
1739 # because it's problematic to determine
1740 # whether the field is actually within
1741 # the range of a wide integer.
1746 }
1753 }
1756 }
1758 # 1=Mon, 6=Sat
1763 {
1769 "day of week is greater than 7"
1770 }
1772 }
1773 }
1775 # first Sunday of the year is the
1776 # first day of week 01. No scan rule
1777 # uses this group.
1779 }
1787 }
1789 # Monday of the year is the first day
1790 # of week 01. No scan rule uses this
1791 # group.
1793 }
1800 }
1812 }
1826 }
1829 }
1834 }
1836 }
1837 }
1838 }
1844 lassign $triple t symbol year
1846 }
1849 }
1850 E {
1854 dict set l b.c.e. BCE
1855 dict set l c.e. CE
1856 dict set l b.c. BCE
1857 dict set l a.d. CE
1866 }
1870 incr captureCount
1871 }
1876 }
1878 }
1879 }
1881 }
1892 }
1901 }
1910 }
1911 m {
1919 }
1920 M {
1928 }
1929 S {
1937 }
1944 {
1950 "day of week is greater than 7"
1951 }
1953 }
1954 }
1955 y {
1962 }
1967 }
1969 }
1970 }
1972 }
1973 }
1974 }
1976 # Clean up any unfinished format groups
1980 # Build the procedure
1987 }
1992 }
1999 # Get time zone if needed
2006 }
2007 }
2010 }
2011 }
2013 # Add code that gets Julian Day Number from the fields.
2017 # Get time of day
2021 # Assemble seconds, and convert local nominal time to UTC.
2028 "requested date too large to represent"
2029 }
2034 }
2039 }
2040 }
2042 # Return result
2048 # puts [list proc $procName [list string baseTime timeZone] $procBody]
2051 }
2053 #----------------------------------------------------------------------
2054 #
2055 # LocaleNumeralMatcher --
2056 #
2057 # Composes a regexp that captures the numerals in the given
2058 # locale, and a dictionary to map them to conventional numerals.
2059 #
2060 # Parameters:
2061 # locale - Name of the current locale
2062 #
2063 # Results:
2064 # Returns a two-element list comprising the regexp and the
2065 # dictionary.
2066 #
2067 # Side effects:
2068 # Caches the result.
2069 #
2070 #----------------------------------------------------------------------
2074 variable LocaleNumeralCache
2084 set sep |
2085 incr i
2086 }
2089 }
2091 }
2095 #----------------------------------------------------------------------
2096 #
2097 # UniquePrefixRegexp --
2098 #
2099 # Composes a regexp that performs unique-prefix matching. The
2100 # RE matches one of a supplied set of strings, or any unique
2101 # prefix thereof.
2102 #
2103 # Parameters:
2104 # data - List of alternating match-strings and values.
2105 # Match-strings with distinct values are considered
2106 # distinct.
2107 #
2108 # Results:
2109 # Returns a two-element list. The first is a regexp that
2110 # matches any unique prefix of any of the strings. The second
2111 # is a dictionary whose keys are match values from the regexp
2112 # and whose values are the corresponding values from 'data'.
2113 #
2114 # Side effects:
2115 # None.
2116 #
2117 #----------------------------------------------------------------------
2121 # The 'successors' dictionary will contain, for each string that
2122 # is a prefix of any key, all characters that may follow that
2123 # prefix. The 'prefixMapping' dictionary will have keys that
2124 # are prefixes of keys and values that correspond to the keys.
2129 # Walk the key-value pairs
2133 # Construct all prefixes of the key;
2141 # Put the prefixes in the 'prefixMapping' and 'successors'
2142 # dictionaries
2147 }
2148 }
2149 }
2151 # Identify those prefixes that designate unique values, and
2152 # those that are the full keys
2158 }
2159 }
2162 }
2164 # Construct the re.
2169 }
2171 #----------------------------------------------------------------------
2172 #
2173 # MakeUniquePrefixRegexp --
2174 #
2175 # Service procedure for 'UniquePrefixRegexp' that constructs
2176 # a regular expresison that matches the unique prefixes.
2177 #
2178 # Parameters:
2179 # successors - Dictionary whose keys are all prefixes
2180 # of keys passed to 'UniquePrefixRegexp' and whose
2181 # values are dictionaries whose keys are the characters
2182 # that may follow those prefixes.
2183 # uniquePrefixMapping - Dictionary whose keys are the unique
2184 # prefixes and whose values are not examined.
2185 # prefixString - Current prefix being processed.
2186 #
2187 # Results:
2188 # Returns a constructed regular expression that matches the set
2189 # of unique prefixes beginning with the 'prefixString'.
2190 #
2191 # Side effects:
2192 # None.
2193 #
2194 #----------------------------------------------------------------------
2197 uniquePrefixMapping
2198 prefixString } {
2200 # Get the characters that may follow the current prefix string
2205 }
2207 # If there is more than one successor character, or if the current
2208 # prefix is a unique prefix, surround the generated re with non-capturing
2209 # parentheses.
2215 }
2217 # Generate a regexp that matches the successors.
2226 set sep |
2227 }
2229 # If the current prefix is a unique prefix, make all following text
2230 # optional. Otherwise, if there is more than one successor character,
2231 # close the non-capturing parentheses.
2237 }
2240 }
2242 #----------------------------------------------------------------------
2243 #
2244 # MakeParseCodeFromFields --
2245 #
2246 # Composes Tcl code to extract the Julian Day Number from a
2247 # dictionary containing date fields.
2248 #
2249 # Parameters:
2250 # dateFields -- Dictionary whose keys are fields of the date,
2251 # and whose values are the rightmost positions
2252 # at which those fields appear.
2253 # parseActions -- List of triples: field set, priority, and
2254 # code to emit. Smaller priorities are better, and
2255 # the list must be in ascending order by priority
2256 #
2257 # Results:
2258 # Returns a burst of code that extracts the day number from the
2259 # given date.
2260 #
2261 # Side effects:
2262 # None.
2263 #
2264 #----------------------------------------------------------------------
2272 }
2276 # If we've found an answer that's better than any that follow,
2277 # quit now.
2280 break
2281 }
2283 # Accumulate the field positions that are used in the current
2284 # field grouping.
2287 set ok true
2291 break
2292 }
2294 }
2296 # Quit if we don't have a complete set of fields
2298 continue
2299 }
2301 # Determine whether the current answer is better than the last.
2310 break
2311 }
2314 break
2315 }
2316 }
2317 }
2319 continue
2320 }
2322 # Remember the best possibility for extracting date information
2328 }
2332 }
2334 #----------------------------------------------------------------------
2335 #
2336 # EnterLocale --
2337 #
2338 # Switch [mclocale] to a given locale if necessary
2339 #
2340 # Parameters:
2341 # locale -- Desired locale
2342 # oldLocaleVar -- Name of a variable in caller's scope that
2343 # tracks the previous locale name.
2344 #
2345 # Results:
2346 # Returns the locale that was previously current.
2347 #
2348 # Side effects:
2349 # Does [mclocale]. If necessary, uses [mcload] to load the
2350 # designated locale's files, and tracks that it has done so
2351 # in the 'McLoaded' variable.
2352 #
2353 #----------------------------------------------------------------------
2359 variable MsgDir
2360 variable McLoaded
2367 # On a non-windows platform, the 'system' locale is
2368 # the same as the 'current' locale
2370 set locale current
2373 # On a windows platform, the 'system' locale is
2374 # adapted from the 'current' locale by applying the
2375 # date and time formats from the Control Panel.
2376 # First, load the 'current' locale if it's not yet loaded
2379 mcload $MsgDir
2381 }
2383 # Make a new locale string for the system locale, and
2384 # get the Control Panel information
2388 LoadWindowsDateTimeFormats $locale
2390 }
2391 }
2392 }
2395 unset oldLocale
2397 unset oldLocale
2399 mclocale $locale
2400 }
2402 mcload $MsgDir
2404 }
2406 }
2408 #----------------------------------------------------------------------
2409 #
2410 # LoadWindowsDateTimeFormats --
2411 #
2412 # Load the date/time formats from the Control Panel in Windows
2413 # and convert them so that they're usable by Tcl.
2414 #
2415 # Parameters:
2416 # locale - Name of the locale in whose message catalog
2417 # the converted formats are to be stored.
2418 #
2419 # Results:
2420 # None.
2421 #
2422 # Side effects:
2423 # Updates the given message catalog with the locale strings.
2424 #
2425 # Presumes that on entry, [mclocale] is set to the current locale,
2426 # so that default strings can be obtained if the Registry query
2427 # fails.
2428 #
2429 #----------------------------------------------------------------------
2433 # Bail out if we can't find the Registry
2435 variable NoRegistry
2440 sShortDate
2446 dddd %A
2447 ddd %a
2448 dd %d
2449 d %e
2450 MMMM %B
2451 MMM %b
2452 MM %m
2453 M %N
2454 yyyy %Y
2455 yy %y
2456 y %y
2457 gg {}
2460 set quote '
2463 }
2464 }
2466 }
2470 sLongDate
2476 dddd %A
2477 ddd %a
2478 dd %d
2479 d %e
2480 MMMM %B
2481 MMM %b
2482 MM %m
2483 M %N
2484 yyyy %Y
2485 yy %y
2486 y %y
2487 gg {}
2490 set quote '
2493 }
2494 }
2496 }
2500 sTimeFormat
2506 HH %H
2507 H %k
2508 hh %I
2509 h %l
2510 mm %M
2511 m %M
2512 ss %S
2513 s %S
2514 tt %p
2515 t %p
2518 set quote '
2521 }
2522 }
2524 }
2528 }
2531 }
2533 return
2535 }
2537 #----------------------------------------------------------------------
2538 #
2539 # LocalizeFormat --
2540 #
2541 # Map away locale-dependent format groups in a clock format.
2542 #
2543 # Parameters:
2544 # locale -- Current [mclocale] locale, supplied to avoid
2545 # an extra call
2546 # format -- Format supplied to [clock scan] or [clock format]
2547 #
2548 # Results:
2549 # Returns the string with locale-dependent composite format
2550 # groups substituted out.
2551 #
2552 # Side effects:
2553 # None.
2554 #
2555 #----------------------------------------------------------------------
2559 variable McLoaded
2563 }
2566 # Handle locale-dependent format groups by mapping them out of the format
2567 # string. Note that the order of the [string map] operations is
2568 # significant because later formats can refer to later ones; for example
2569 # %c can refer to %X, which in turn can refer to %T.
2572 %% %%
2575 }
2590 }
2592 #----------------------------------------------------------------------
2593 #
2594 # FormatNumericTimeZone --
2595 #
2596 # Formats a time zone as +hhmmss
2597 #
2598 # Parameters:
2599 # z - Time zone in seconds east of Greenwich
2600 #
2601 # Results:
2602 # Returns the time zone formatted in a numeric form
2603 #
2604 # Side effects:
2605 # None.
2606 #
2607 #----------------------------------------------------------------------
2616 }
2623 }
2626 }
2628 #----------------------------------------------------------------------
2629 #
2630 # FormatStarDate --
2631 #
2632 # Formats a date as a StarDate.
2633 #
2634 # Parameters:
2635 # date - Dictionary containing 'year', 'dayOfYear', and
2636 # 'localSeconds' fields.
2637 #
2638 # Results:
2639 # Returns the given date formatted as a StarDate.
2640 #
2641 # Side effects:
2642 # None.
2643 #
2644 # Jeff Hobbs put this in to support an atrocious pun about Tcl being
2645 # "Enterprise ready." Now we're stuck with it.
2646 #
2647 #----------------------------------------------------------------------
2651 variable Roddenberry
2653 # Get day of year, zero based
2657 # Determine whether the year is a leap year
2661 # Convert day of year to a fractional year
2667 }
2669 # Put together the StarDate
2676 }
2678 #----------------------------------------------------------------------
2679 #
2680 # ParseStarDate --
2681 #
2682 # Parses a StarDate
2683 #
2684 # Parameters:
2685 # year - Year from the Roddenberry epoch
2686 # fractYear - Fraction of a year specifiying the day of year.
2687 # fractDay - Fraction of a day
2688 #
2689 # Results:
2690 # Returns a count of seconds from the Posix epoch.
2691 #
2692 # Side effects:
2693 # None.
2694 #
2695 # Jeff Hobbs put this in to support an atrocious pun about Tcl being
2696 # "Enterprise ready." Now we're stuck with it.
2697 #
2698 #----------------------------------------------------------------------
2702 variable Roddenberry
2704 # Build a tentative date from year and fraction.
2708 era CE \
2713 # Determine whether the given year is a leap year
2717 # Reconvert the fractional year according to whether the given
2718 # year is a leap year
2726 }
2727 dict unset date julianDay
2728 dict unset date gregorian
2735 }
2737 #----------------------------------------------------------------------
2738 #
2739 # ScanWide --
2740 #
2741 # Scans a wide integer from an input
2742 #
2743 # Parameters:
2744 # str - String containing a decimal wide integer
2745 #
2746 # Results:
2747 # Returns the string as a pure wide integer. Throws an error if
2748 # the string is misformatted or out of range.
2749 #
2750 #----------------------------------------------------------------------
2757 }
2760 "integer value too large to represent"
2761 }
2763 }
2765 #----------------------------------------------------------------------
2766 #
2767 # InterpretTwoDigitYear --
2768 #
2769 # Given a date that contains only the year of the century,
2770 # determines the target value of a two-digit year.
2771 #
2772 # Parameters:
2773 # date - Dictionary containing fields of the date.
2774 # baseTime - Base time relative to which the date is expressed.
2775 # twoDigitField - Name of the field that stores the two-digit year.
2776 # Default is 'yearOfCentury'
2777 # fourDigitField - Name of the field that will receive the four-digit
2778 # year. Default is 'year'
2779 #
2780 # Results:
2781 # Returns the dictionary augmented with the four-digit year, stored in
2782 # the given key.
2783 #
2784 # Side effects:
2785 # None.
2786 #
2787 # The current rule for interpreting a two-digit year is that the year
2788 # shall be between 1937 and 2037, thus staying within the range of a
2789 # 32-bit signed value for time. This rule may change to a sliding
2790 # window in future versions, so the 'baseTime' parameter (which is
2791 # currently ignored) is provided in the procedure signature.
2792 #
2793 #----------------------------------------------------------------------
2804 }
2807 }
2809 #----------------------------------------------------------------------
2810 #
2811 # AssignBaseYear --
2812 #
2813 # Places the number of the current year into a dictionary.
2814 #
2815 # Parameters:
2816 # date - Dictionary value to update
2817 # baseTime - Base time from which to extract the year, expressed
2818 # in seconds from the Posix epoch
2819 # timezone - the time zone in which the date is being scanned
2820 # changeover - the Julian Day on which the Gregorian calendar
2821 # was adopted in the target locale.
2822 #
2823 # Results:
2824 # Returns the dictionary with the current year assigned.
2825 #
2826 # Side effects:
2827 # None.
2828 #
2829 #----------------------------------------------------------------------
2833 variable TZData
2835 # Find the Julian Day Number corresponding to the base time, and
2836 # find the Gregorian year corresponding to that Julian Day.
2840 # Store the converted year
2847 }
2849 #----------------------------------------------------------------------
2850 #
2851 # AssignBaseIso8601Year --
2852 #
2853 # Determines the base year in the ISO8601 fiscal calendar.
2854 #
2855 # Parameters:
2856 # date - Dictionary containing the fields of the date that
2857 # is to be augmented with the base year.
2858 # baseTime - Base time expressed in seconds from the Posix epoch.
2859 # timeZone - Target time zone
2860 # changeover - Julian Day of adoption of the Gregorian calendar in
2861 # the target locale.
2862 #
2863 # Results:
2864 # Returns the given date with "iso8601Year" set to the
2865 # base year.
2866 #
2867 # Side effects:
2868 # None.
2869 #
2870 #----------------------------------------------------------------------
2874 variable TZData
2876 # Find the Julian Day Number corresponding to the base time
2880 # Calculate the ISO8601 date and transfer the year
2882 dict set date era CE
2885 }
2887 #----------------------------------------------------------------------
2888 #
2889 # AssignBaseMonth --
2890 #
2891 # Places the number of the current year and month into a
2892 # dictionary.
2893 #
2894 # Parameters:
2895 # date - Dictionary value to update
2896 # baseTime - Time from which the year and month are to be
2897 # obtained, expressed in seconds from the Posix epoch.
2898 # timezone - Name of the desired time zone
2899 # changeover - Julian Day on which the Gregorian calendar was adopted.
2900 #
2901 # Results:
2902 # Returns the dictionary with the base year and month assigned.
2903 #
2904 # Side effects:
2905 # None.
2906 #
2907 #----------------------------------------------------------------------
2911 variable TZData
2913 # Find the year and month corresponding to the base time
2921 }
2923 #----------------------------------------------------------------------
2924 #
2925 # AssignBaseWeek --
2926 #
2927 # Determines the base year and week in the ISO8601 fiscal calendar.
2928 #
2929 # Parameters:
2930 # date - Dictionary containing the fields of the date that
2931 # is to be augmented with the base year and week.
2932 # baseTime - Base time expressed in seconds from the Posix epoch.
2933 # changeover - Julian Day on which the Gregorian calendar was adopted
2934 # in the target locale.
2935 #
2936 # Results:
2937 # Returns the given date with "iso8601Year" set to the
2938 # base year and "iso8601Week" to the week number.
2939 #
2940 # Side effects:
2941 # None.
2942 #
2943 #----------------------------------------------------------------------
2947 variable TZData
2949 # Find the Julian Day Number corresponding to the base time
2953 # Calculate the ISO8601 date and transfer the year
2955 dict set date era CE
2959 }
2961 #----------------------------------------------------------------------
2962 #
2963 # AssignBaseJulianDay --
2964 #
2965 # Determines the base day for a time-of-day conversion.
2966 #
2967 # Parameters:
2968 # date - Dictionary that is to get the base day
2969 # baseTime - Base time expressed in seconds from the Posix epoch
2970 # changeover - Julian day on which the Gregorian calendar was
2971 # adpoted in the target locale.
2972 #
2973 # Results:
2974 # Returns the given dictionary augmented with a 'julianDay' field
2975 # that contains the base day.
2976 #
2977 # Side effects:
2978 # None.
2979 #
2980 #----------------------------------------------------------------------
2984 variable TZData
2986 # Find the Julian Day Number corresponding to the base time
2992 }
2994 #----------------------------------------------------------------------
2995 #
2996 # InterpretHMSP --
2997 #
2998 # Interprets a time in the form "hh:mm:ss am".
2999 #
3000 # Parameters:
3001 # date -- Dictionary containing "hourAMPM", "minute", "second"
3002 # and "amPmIndicator" fields.
3003 #
3004 # Results:
3005 # Returns the number of seconds from local midnight.
3006 #
3007 # Side effects:
3008 # None.
3009 #
3010 #----------------------------------------------------------------------
3017 }
3020 }
3024 }
3026 #----------------------------------------------------------------------
3027 #
3028 # InterpretHMS --
3029 #
3030 # Interprets a 24-hour time "hh:mm:ss"
3031 #
3032 # Parameters:
3033 # date -- Dictionary containing the "hour", "minute" and "second"
3034 # fields.
3035 #
3036 # Results:
3037 # Returns the given dictionary augmented with a "secondOfDay"
3038 # field containing the number of seconds from local midnight.
3039 #
3040 # Side effects:
3041 # None.
3042 #
3043 #----------------------------------------------------------------------
3051 }
3053 #----------------------------------------------------------------------
3054 #
3055 # GetSystemTimeZone --
3056 #
3057 # Determines the system time zone, which is the default for the
3058 # 'clock' command if no other zone is supplied.
3059 #
3060 # Parameters:
3061 # None.
3062 #
3063 # Results:
3064 # Returns the system time zone.
3065 #
3066 # Side effects:
3067 # Stores the sustem time zone in the 'CachedSystemTimeZone'
3068 # variable, since determining it may be an expensive process.
3069 #
3070 #----------------------------------------------------------------------
3074 variable CachedSystemTimeZone
3075 variable TimeZoneBad
3091 }
3095 }
3100 }
3102 }
3104 #----------------------------------------------------------------------
3105 #
3106 # ConvertLegacyTimeZone --
3107 #
3108 # Given an alphanumeric time zone identifier and the system
3109 # time zone, convert the alphanumeric identifier to an
3110 # unambiguous time zone.
3111 #
3112 # Parameters:
3113 # tzname - Name of the time zone to convert
3114 #
3115 # Results:
3116 # Returns a time zone name corresponding to tzname, but
3117 # in an unambiguous form, generally +hhmm.
3118 #
3119 # This procedure is implemented primarily to allow the parsing of
3120 # RFC822 date/time strings. Processing a time zone name on input
3121 # is not recommended practice, because there is considerable room
3122 # for ambiguity; for instance, is BST Brazilian Standard Time, or
3123 # British Summer Time?
3124 #
3125 #----------------------------------------------------------------------
3129 variable LegacyTimeZone
3137 }
3139 }
3141 #----------------------------------------------------------------------
3142 #
3143 # SetupTimeZone --
3144 #
3145 # Given the name or specification of a time zone, sets up
3146 # its in-memory data.
3147 #
3148 # Parameters:
3149 # tzname - Name of a time zone
3150 #
3151 # Results:
3152 # Unless the time zone is ':localtime', sets the TZData array
3153 # to contain the lookup table for local<->UTC conversion.
3154 # Returns an error if the time zone cannot be parsed.
3155 #
3156 #----------------------------------------------------------------------
3160 variable TZData
3163 variable MINWIDE
3166 # Nothing to do, we'll convert using the localtime function
3171 # Make a fixed offset
3178 }
3183 }
3187 }
3192 # Convert using a time zone file
3197 }]
3200 }]
3201 } {
3205 }
3209 # This looks like a POSIX time zone - try to process it
3214 }
3218 }
3222 # We couldn't parse this as a POSIX time zone. Try
3223 # again with a time zone file - this time without a colon
3229 }
3231 }
3232 }
3234 return
3235 }
3237 #----------------------------------------------------------------------
3238 #
3239 # GuessWindowsTimeZone --
3240 #
3241 # Determines the system time zone on windows.
3242 #
3243 # Parameters:
3244 # None.
3245 #
3246 # Results:
3247 # Returns a time zone specifier that corresponds to the system
3248 # time zone information found in the Registry.
3249 #
3250 # Bugs:
3251 # Fixed dates for DST change are unimplemented at present, because
3252 # no time zone information supplied with Windows actually uses
3253 # them!
3254 #
3255 # On a Windows system where neither $env(TCL_TZ) nor $env(TZ) is
3256 # specified, GuessWindowsTimeZone looks in the Registry for the
3257 # system time zone information. It then attempts to find an entry
3258 # in WinZoneInfo for a time zone that uses the same rules. If
3259 # it finds one, it returns it; otherwise, it constructs a Posix-style
3260 # time zone string and returns that.
3261 #
3262 #----------------------------------------------------------------------
3266 variable WinZoneInfo
3267 variable NoRegistry
3268 variable TimeZoneBad
3272 }
3274 # Dredge time zone information out of the registry
3289 }
3294 }
3295 }] } {
3297 # Missing values in the Registry - bail out
3300 }
3302 # Make up a Posix time zone specifier if we can't find one.
3303 # Check here that the tzdata file exists, in case we're running
3304 # in an environment (e.g. starpack) where tzdata is incomplete.
3305 # (Bug 1237907)
3311 }
3314 }
3317 bias stdBias dstBias \
3318 stdYear stdMonth stdDayOfWeek stdDayOfMonth \
3319 stdHour stdMinute stdSecond stdMillisec \
3320 dstYear dstMonth dstDayOfWeek dstDayOfMonth \
3321 dstHour dstMinute dstSecond dstMillisec
3331 }
3345 }
3353 # I have not been able to find any locale on which
3354 # Windows converts time zone on a fixed day of the year,
3355 # hence don't know how to interpret the fields.
3356 # If someone can inform me, I'd be glad to code it up.
3357 # For right now, we bail out in such a case.
3359 }
3366 # I have not been able to find any locale on which
3367 # Windows converts time zone on a fixed day of the year,
3368 # hence don't know how to interpret the fields.
3369 # If someone can inform me, I'd be glad to code it up.
3370 # For right now, we bail out in such a case.
3372 }
3376 }
3378 }
3382 }
3384 #----------------------------------------------------------------------
3385 #
3386 # LoadTimeZoneFile --
3387 #
3388 # Load the data file that specifies the conversion between a
3389 # given time zone and Greenwich.
3390 #
3391 # Parameters:
3392 # fileName -- Name of the file to load
3393 #
3394 # Results:
3395 # None.
3396 #
3397 # Side effects:
3398 # TZData(:fileName) contains the time zone data
3399 #
3400 #----------------------------------------------------------------------
3403 variable DataDir
3404 variable TZData
3407 return
3408 }
3410 # Since an unsafe interp uses the [clock] command in the master,
3411 # this code is security sensitive. Make sure that the path name
3412 # cannot escape the given directory.
3418 }
3421 }] } {
3425 }
3426 return
3427 }
3429 #----------------------------------------------------------------------
3430 #
3431 # LoadZoneinfoFile --
3432 #
3433 # Loads a binary time zone information file in Olson format.
3434 #
3435 # Parameters:
3436 # fileName - Relative path name of the file to load.
3437 #
3438 # Results:
3439 # Returns an empty result normally; returns an error if no
3440 # Olson file was found or the file was malformed in some way.
3441 #
3442 # Side effects:
3443 # TZData(:fileName) contains the time zone data
3444 #
3445 #----------------------------------------------------------------------
3449 variable ZoneinfoPaths
3451 # Since an unsafe interp uses the [clock] command in the master,
3452 # this code is security sensitive. Make sure that the path name
3453 # cannot escape the given directory.
3459 }
3463 break
3464 }
3465 unset fname
3466 }
3467 ReadZoneinfoFile $fileName $fname
3468 }
3470 #----------------------------------------------------------------------
3471 #
3472 # ReadZoneinfoFile --
3473 #
3474 # Loads a binary time zone information file in Olson format.
3475 #
3476 # Parameters:
3477 # fileName - Name of the time zone (relative path name of the
3478 # file).
3479 # fname - Absolute path name of the file.
3480 #
3481 # Results:
3482 # Returns an empty result normally; returns an error if no
3483 # Olson file was found or the file was malformed in some way.
3484 #
3485 # Side effects:
3486 # TZData(:fileName) contains the time zone data
3487 #
3488 #----------------------------------------------------------------------
3492 variable MINWIDE
3493 variable TZData
3496 }
3500 }
3502 # Suck in all the data from the file
3509 # The file begins with a magic number, sixteen reserved bytes,
3510 # and then six 4-byte integers giving counts of fileds in the file.
3513 magic version nIsGMT nIsStd nLeap nTime nType nChar
3516 set iformat I
3519 }
3522 }
3523 # Accept only Posix-style zoneinfo. Sorry, 'leaps' bigots.
3526 }
3528 # In a version 2 file, we use the second part of the file, which
3529 # contains 64-bit transition times.
3539 }]
3541 magic version nIsGMT nIsStd nLeap nTime nType nChar
3544 }
3545 set iformat W
3548 }
3550 # Next come ${nTime} transition times, followed by ${nTime} time type
3551 # codes. The type codes are unsigned 1-byte quantities. We insert an
3552 # arbitrary start time in front of the transitions.
3560 }
3563 # Next come ${nType} time type descriptions, each of which has an
3564 # offset (seconds east of GMT), a DST indicator, and an index into
3565 # the abbreviation text.
3571 }
3573 # Next come $nChar characters of time zone name abbreviations,
3574 # which are null-terminated.
3575 # We build them up into a dictionary indexed by character index,
3576 # because that's what's in the indices above.
3586 }
3588 # Package up a list of tuples, each of which contains transition time,
3589 # seconds east of Greenwich, DST flag and time zone abbreviation.
3596 }
3601 }
3603 # In a version 2 file, there is also a POSIX-style time zone description
3604 # at the very end of the file. To get to it, skip over
3605 # nLeap leap second values (8 bytes each),
3606 # nIsStd standard/DST indicators and nIsGMT UTC/local indicators.
3615 lassign $tuple t gmtoff isDst abbrev
3618 }
3619 }
3620 }
3621 }
3625 return
3626 }
3628 #----------------------------------------------------------------------
3629 #
3630 # ParsePosixTimeZone --
3631 #
3632 # Parses the TZ environment variable in Posix form
3633 #
3634 # Parameters:
3635 # tz Time zone specifier to be interpreted
3636 #
3637 # Results:
3638 # Returns a dictionary whose values contain the various pieces of
3639 # the time zone specification.
3640 #
3641 # Side effects:
3642 # None.
3643 #
3644 # Errors:
3645 # Throws an error if the syntax of the time zone is incorrect.
3646 #
3647 # The following keys are present in the dictionary:
3648 # stdName - Name of the time zone when Daylight Saving Time
3649 # is not in effect.
3650 # stdSignum - Sign (+, -, or empty) of the offset from Greenwich
3651 # to the given (non-DST) time zone. + and the empty
3652 # string denote zones west of Greenwich, - denotes east
3653 # of Greenwich; this is contrary to the ISO convention
3654 # but follows Posix.
3655 # stdHours - Hours part of the offset from Greenwich to the given
3656 # (non-DST) time zone.
3657 # stdMinutes - Minutes part of the offset from Greenwich to the
3658 # given (non-DST) time zone. Empty denotes zero.
3659 # stdSeconds - Seconds part of the offset from Greenwich to the
3660 # given (non-DST) time zone. Empty denotes zero.
3661 # dstName - Name of the time zone when DST is in effect, or the
3662 # empty string if the time zone does not observe Daylight
3663 # Saving Time.
3664 # dstSignum, dstHours, dstMinutes, dstSeconds -
3665 # Fields corresponding to stdSignum, stdHours, stdMinutes,
3666 # stdSeconds for the Daylight Saving Time version of the
3667 # time zone. If dstHours is empty, it is presumed to be 1.
3668 # startDayOfYear - The ordinal number of the day of the year on which
3669 # Daylight Saving Time begins. If this field is
3670 # empty, then DST begins on a given month-week-day,
3671 # as below.
3672 # startJ - The letter J, or an empty string. If a J is present in
3673 # this field, then startDayOfYear does not count February 29
3674 # even in leap years.
3675 # startMonth - The number of the month in which Daylight Saving Time
3676 # begins, supplied if startDayOfYear is empty. If both
3677 # startDayOfYear and startMonth are empty, then US rules
3678 # are presumed.
3679 # startWeekOfMonth - The number of the week in the month in which
3680 # Daylight Saving Time begins, in the range 1-5.
3681 # 5 denotes the last week of the month even in a
3682 # 4-week month.
3683 # startDayOfWeek - The number of the day of the week (Sunday=0,
3684 # Saturday=6) on which Daylight Saving Time begins.
3685 # startHours - The hours part of the time of day at which Daylight
3686 # Saving Time begins. An empty string is presumed to be 2.
3687 # startMinutes - The minutes part of the time of day at which DST begins.
3688 # An empty string is presumed zero.
3689 # startSeconds - The seconds part of the time of day at which DST begins.
3690 # An empty string is presumed zero.
3691 # endDayOfYear, endJ, endMonth, endWeekOfMonth, endDayOfWeek,
3692 # endHours, endMinutes, endSeconds -
3693 # Specify the end of DST in the same way that the start* fields
3694 # specify the beginning of DST.
3695 #
3696 # This procedure serves only to break the time specifier into fields.
3697 # No attempt is made to canonicalize the fields or supply default values.
3698 #
3699 #----------------------------------------------------------------------
3704 ^
3705 # 1 - Standard time zone name
3707 # 2 - Standard time zone offset, signum
3709 # 3 - Standard time zone offset, hours
3712 # 4 - Standard time zone offset, minutes
3715 # 5 - Standard time zone offset, seconds
3717 )?
3718 )?
3720 # 6 - DST time zone name
3724 # 7 - DST time zone offset, signum
3726 # 8 - DST time zone offset, hours
3729 # 9 - DST time zone offset, minutes
3732 # 10 - DST time zone offset, seconds
3734 )?
3735 )?
3736 )?
3738 ,
3740 # 11 - Optional J in n and Jn form 12 - Day of year
3742 | M
3743 # 13 - Month number 14 - Week of month 15 - Day of week
3747 )
3749 # 16 - Start time of DST - hours
3752 # 17 - Start time of DST - minutes
3755 # 18 - Start time of DST - seconds
3757 )?
3758 )?
3759 )?
3760 ,
3762 # 19 - Optional J in n and Jn form 20 - Day of year
3764 | M
3765 # 21 - Month number 22 - Week of month 23 - Day of week
3769 )
3771 # 24 - End time of DST - hours
3774 # 25 - End time of DST - minutes
3777 # 26 - End time of DST - seconds
3779 )?
3780 )?
3781 )?
3782 )?
3783 )?
3784 )?
3785 $
3795 # it's a good timezone
3805 }
3807 }
3809 #----------------------------------------------------------------------
3810 #
3811 # ProcessPosixTimeZone --
3812 #
3813 # Handle a Posix time zone after it's been broken out into
3814 # fields.
3815 #
3816 # Parameters:
3817 # z - Dictionary returned from 'ParsePosixTimeZone'
3818 #
3819 # Results:
3820 # Returns time zone information for the 'TZData' array.
3821 #
3822 # Side effects:
3823 # None.
3824 #
3825 #----------------------------------------------------------------------
3829 variable MINWIDE
3830 variable TZData
3832 # Determine the standard time zone name and seconds east of Greenwich
3837 }
3842 }
3848 }
3853 }
3859 # If there's no daylight zone, we're done
3864 }
3867 }
3869 # Determine the daylight name
3875 }
3884 }
3889 }
3893 }
3895 # Fill in defaults for European or US DST rules
3896 # US start time is the second Sunday in March
3897 # EU start time is the last Sunday in March
3898 # US end time is the first Sunday in November.
3899 # EU end time is the last Sunday in October
3904 # EU
3910 }
3912 # US
3915 }
3920 }
3924 # EU
3931 }
3933 # US
3937 }
3941 }
3943 # Put DST in effect in all years from 1916 to 2099.
3958 }
3959 }
3963 }
3965 #----------------------------------------------------------------------
3966 #
3967 # DeterminePosixDSTTime --
3968 #
3969 # Determines the time that Daylight Saving Time starts or ends
3970 # from a Posix time zone specification.
3971 #
3972 # Parameters:
3973 # z - Time zone data returned from ParsePosixTimeZone.
3974 # Missing fields are expected to be filled in with
3975 # default values.
3976 # bound - The word 'start' or 'end'
3977 # y - The year for which the transition time is to be determined.
3978 #
3979 # Results:
3980 # Returns the transition time as a count of seconds from
3981 # the epoch. The time is relative to the wall clock, not UTC.
3982 #
3983 #----------------------------------------------------------------------
3987 variable FEB_28
3989 # Determine the start or end day of DST
3995 # Time was specified as a day of the year
4000 incr doy
4001 }
4006 # Time was specified as a day of the week within a month
4013 }
4017 }
4028 }
4034 }
4040 }
4044 }
4046 #----------------------------------------------------------------------
4047 #
4048 # GetLocaleEra --
4049 #
4050 # Given local time expressed in seconds from the Posix epoch,
4051 # determine localized era and year within the era.
4052 #
4053 # Parameters:
4054 # date - Dictionary that must contain the keys, 'localSeconds',
4055 # whose value is expressed as the appropriate local time;
4056 # and 'year', whose value is the Gregorian year.
4057 # etable - Value of the LOCALE_ERAS key in the message catalogue
4058 # for the target locale.
4059 #
4060 # Results:
4061 # Returns the dictionary, augmented with the keys, 'localeEra'
4062 # and 'localeYear'.
4063 #
4064 #----------------------------------------------------------------------
4078 }
4081 }
4083 #----------------------------------------------------------------------
4084 #
4085 # GetJulianDayFromEraYearDay --
4086 #
4087 # Given a year, month and day on the Gregorian calendar, determines
4088 # the Julian Day Number beginning at noon on that date.
4089 #
4090 # Parameters:
4091 # date -- A dictionary in which the 'era', 'year', and
4092 # 'dayOfYear' slots are populated. The calendar in use
4093 # is determined by the date itself relative to:
4094 # changeover -- Julian day on which the Gregorian calendar was
4095 # adopted in the current locale.
4096 #
4097 # Results:
4098 # Returns the given dictionary augmented with a 'julianDay' key
4099 # whose value is the desired Julian Day Number, and a 'gregorian'
4100 # key that specifies whether the calendar is Gregorian (1) or
4101 # Julian (0).
4102 #
4103 # Side effects:
4104 # None.
4105 #
4106 # Bugs:
4107 # This code needs to be moved to the C layer.
4108 #
4109 #----------------------------------------------------------------------
4113 # Get absolute year number from the civil year
4116 BCE {
4118 }
4119 CE {
4121 }
4122 }
4125 # Try the Gregorian calendar first.
4135 # If the date is before the Gregorian change, use the Julian calendar.
4143 }
4147 }
4149 #----------------------------------------------------------------------
4150 #
4151 # GetJulianDayFromEraYearMonthWeekDay --
4152 #
4153 # Determines the Julian Day number corresponding to the nth
4154 # given day-of-the-week in a given month.
4155 #
4156 # Parameters:
4157 # date - Dictionary containing the keys, 'era', 'year', 'month'
4158 # 'weekOfMonth', 'dayOfWeek', and 'dayOfWeekInMonth'.
4159 # changeover - Julian Day of adoption of the Gregorian calendar
4160 #
4161 # Results:
4162 # Returns the given dictionary, augmented with a 'julianDay' key.
4163 #
4164 # Side effects:
4165 # None.
4166 #
4167 # Bugs:
4168 # This code needs to be moved to the C layer.
4169 #
4170 #----------------------------------------------------------------------
4174 # Come up with a reference day; either the zeroeth day of the
4175 # given month (dayOfWeekInMonth >= 0) or the seventh day of the
4176 # following month (dayOfWeekInMonth < 0)
4183 dict incr date2 month
4185 }
4193 }
4195 #----------------------------------------------------------------------
4196 #
4197 # IsGregorianLeapYear --
4198 #
4199 # Determines whether a given date represents a leap year in the
4200 # Gregorian calendar.
4201 #
4202 # Parameters:
4203 # date -- The date to test. The fields, 'era', 'year' and 'gregorian'
4204 # must be set.
4205 #
4206 # Results:
4207 # Returns 1 if the year is a leap year, 0 otherwise.
4208 #
4209 # Side effects:
4210 # None.
4211 #
4212 #----------------------------------------------------------------------
4217 BCE {
4219 }
4220 CE {
4222 }
4223 }
4234 }
4236 }
4238 #----------------------------------------------------------------------
4239 #
4240 # WeekdayOnOrBefore --
4241 #
4242 # Determine the nearest day of week (given by the 'weekday'
4243 # parameter, Sunday==0) on or before a given Julian Day.
4244 #
4245 # Parameters:
4246 # weekday -- Day of the week
4247 # j -- Julian Day number
4248 #
4249 # Results:
4250 # Returns the Julian Day Number of the desired date.
4251 #
4252 # Side effects:
4253 # None.
4254 #
4255 #----------------------------------------------------------------------
4262 }
4264 #----------------------------------------------------------------------
4265 #
4266 # BSearch --
4267 #
4268 # Service procedure that does binary search in several places
4269 # inside the 'clock' command.
4270 #
4271 # Parameters:
4272 # list - List of lists, sorted in ascending order by the
4273 # first elements
4274 # key - Value to search for
4275 #
4276 # Results:
4277 # Returns the index of the greatest element in $list that is less
4278 # than or equal to $key.
4279 #
4280 # Side effects:
4281 # None.
4282 #
4283 #----------------------------------------------------------------------
4289 }
4292 }
4299 # At this point, we know that
4300 # $k >= [lindex $list $l 0]
4301 # Either $u == [llength $list] or else $k < [lindex $list $u+1 0]
4302 # We find the midpoint of the interval {l,u} rounded UP, compare
4303 # against it, and set l or u to maintain the invariant. Note
4304 # that the interval shrinks at each step, guaranteeing convergence.
4311 }
4312 }
4315 }
4317 #----------------------------------------------------------------------
4318 #
4319 # clock add --
4320 #
4321 # Adds an offset to a given time.
4322 #
4323 # Syntax:
4324 # clock add clockval ?count unit?... ?-option value?
4325 #
4326 # Parameters:
4327 # clockval -- Starting time value
4328 # count -- Amount of a unit of time to add
4329 # unit -- Unit of time to add, must be one of:
4330 # years year months month weeks week
4331 # days day hours hour minutes minute
4332 # seconds second
4333 #
4334 # Options:
4335 # -gmt BOOLEAN
4336 # (Deprecated) Flag synonymous with '-timezone :GMT'
4337 # -timezone ZONE
4338 # Name of the time zone in which calculations are to be done.
4339 # -locale NAME
4340 # Name of the locale in which calculations are to be done.
4341 # Used to determine the Gregorian change date.
4342 #
4343 # Results:
4344 # Returns the given time adjusted by the given offset(s) in
4345 # order.
4346 #
4347 # Notes:
4348 # It is possible that adding a number of months or years will adjust
4349 # the day of the month as well. For instance, the time at
4350 # one month after 31 January is either 28 or 29 February, because
4351 # February has fewer than 31 days.
4352 #
4353 #----------------------------------------------------------------------
4361 "wrong \# args: should be\
4364 }
4367 }
4371 set locale c
4386 }
4389 }
4393 }
4398 must be -gmt, -locale or -timezone"
4399 }
4400 }
4401 }
4402 }
4404 # Check options for validity
4409 "cannot use -gmt and -timezone in same call"
4410 }
4414 }
4421 }
4422 }
4424 EnterLocale $locale oldLocale
4431 }
4443 }
4447 }
4452 }
4456 }
4460 }
4463 }
4466 }
4474 }
4475 }
4476 }
4479 # Restore the locale
4482 mclocale $oldLocale
4483 }
4488 }
4492 }
4494 }
4496 #----------------------------------------------------------------------
4497 #
4498 # AddMonths --
4499 #
4500 # Add a given number of months to a given clock value in a given
4501 # time zone.
4502 #
4503 # Parameters:
4504 # months - Number of months to add (may be negative)
4505 # clockval - Seconds since the epoch before the operation
4506 # timezone - Time zone in which the operation is to be performed
4507 #
4508 # Results:
4509 # Returns the new clock value as a number of seconds since
4510 # the epoch.
4511 #
4512 # Side effects:
4513 # None.
4514 #
4515 #----------------------------------------------------------------------
4519 variable DaysInRomanMonthInCommonYear
4520 variable DaysInRomanMonthInLeapYear
4521 variable TZData
4523 # Convert the time to year, month, day, and fraction of day.
4530 # Add the requisite number of months
4540 # If the date doesn't exist in the current month, repair it
4546 }
4549 }
4551 # Reconvert to a number of seconds
4565 }
4567 #----------------------------------------------------------------------
4568 #
4569 # AddDays --
4570 #
4571 # Add a given number of days to a given clock value in a given
4572 # time zone.
4573 #
4574 # Parameters:
4575 # days - Number of days to add (may be negative)
4576 # clockval - Seconds since the epoch before the operation
4577 # timezone - Time zone in which the operation is to be performed
4578 # changeover - Julian Day on which the Gregorian calendar was adopted
4579 # in the target locale.
4580 #
4581 # Results:
4582 # Returns the new clock value as a number of seconds since
4583 # the epoch.
4584 #
4585 # Side effects:
4586 # None.
4587 #
4588 #----------------------------------------------------------------------
4592 variable TZData
4594 # Convert the time to Julian Day
4601 # Add the requisite number of days
4605 # Reconvert to a number of seconds
4616 }
4618 #----------------------------------------------------------------------
4619 #
4620 # mc --
4621 #
4622 # Wrapper around ::msgcat::mc that caches the result according
4623 # to the locale.
4624 #
4625 # Parameters:
4626 # Accepts the name of the message to retrieve.
4627 #
4628 # Results:
4629 # Returns the message text.
4630 #
4631 # Side effects:
4632 # Caches the message text.
4633 #
4634 # Notes:
4635 # Only the single-argument version of [mc] is supported.
4636 #
4637 #----------------------------------------------------------------------
4640 variable McLoaded
4648 }
4649 }
4651 #----------------------------------------------------------------------
4652 #
4653 # ClearCaches --
4654 #
4655 # Clears all caches to reclaim the memory used in [clock]
4656 #
4657 # Parameters:
4658 # None.
4659 #
4660 # Results:
4661 # None.
4662 #
4663 # Side effects:
4664 # Caches are cleared.
4665 #
4666 #----------------------------------------------------------------------
4670 variable FormatProc
4671 variable LocaleNumeralCache
4672 variable McLoaded
4673 variable CachedSystemTimeZone
4674 variable TimeZoneBad
4678 }
4681 }
4688 InitTZData
4690 }