| blob | 32911b3a242b97d11c44ee00dc6392f6d6a69973 |
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 #----------------------------------------------------------------------
18 # We must have message catalogs that support the root locale, and
19 # we need access to the Registry on Windows systems.
26 }
27 }
28 }
30 # Put the library directory into the namespace for the ensemble
31 # so that the library code can find message catalogs and time zone
32 # definition files.
37 #----------------------------------------------------------------------
38 #
39 # clock --
40 #
41 # Manipulate times.
42 #
43 # The 'clock' command manipulates time. Refer to the user documentation
44 # for the available subcommands and what they do.
45 #
46 #----------------------------------------------------------------------
50 # Export the subcommands
53 namespace export clicks
54 namespace export microseconds
55 namespace export milliseconds
57 namespace export seconds
58 namespace export add
60 # Import the message catalog commands that we use.
65 }
67 #----------------------------------------------------------------------
68 #
69 # ::tcl::clock::Initialize --
70 #
71 # Finish initializing the 'clock' subsystem
72 #
73 # Results:
74 # None.
75 #
76 # Side effects:
77 # Namespace variable in the 'clock' subsystem are initialized.
78 #
79 # The '::tcl::clock::Initialize' procedure initializes the namespace
80 # variables and root locale message catalog for the 'clock' subsystem.
81 # It is broken into a procedure rather than simply evaluated as a script
82 # so that it will be able to use local variables, avoiding the dangers
83 # of 'creative writing' as in Bug 1185933.
84 #
85 #----------------------------------------------------------------------
91 variable LibDir
93 # Define the Greenwich time zone
96 variable TZData
97 array unset TZData
100 }
104 }
107 }
108 InitTZData
110 # Define the message catalog for the root locale.
118 DAYS_OF_WEEK_ABBREV {
119 Sun Mon Tue Wed Thu Fri Sat
120 }
121 DAYS_OF_WEEK_FULL {
122 Sunday Monday Tuesday Wednesday Thursday Friday Saturday
123 }
124 GREGORIAN_CHANGE_DATE 2299161
127 LOCALE_ERAS {}
128 LOCALE_NUMERALS {
129 00 01 02 03 04 05 06 07 08 09
130 10 11 12 13 14 15 16 17 18 19
131 20 21 22 23 24 25 26 27 28 29
132 30 31 32 33 34 35 36 37 38 39
133 40 41 42 43 44 45 46 47 48 49
134 50 51 52 53 54 55 56 57 58 59
135 60 61 62 63 64 65 66 67 68 69
136 70 71 72 73 74 75 76 77 78 79
137 80 81 82 83 84 85 86 87 88 89
138 90 91 92 93 94 95 96 97 98 99
139 }
142 MONTHS_ABBREV {
143 Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec
144 }
145 MONTHS_FULL {
146 January February March
147 April May June
148 July August September
149 October November December
150 }
156 }
158 # Define a few Gregorian change dates for other locales. In most cases
159 # the change date follows a language, because a nation's colonies changed
160 # at the same time as the nation itself. In many cases, different
161 # national boundaries existed; the dominating rule is to follow the
162 # nation's capital.
164 # Italy, Spain, Portugal, Poland
171 # France, Austria
175 # For Belgium, we follow Southern Netherlands; Liege Diocese
176 # changed several weeks later.
181 # Austria
185 # Hungary
189 # Germany, Norway, Denmark (Catholic Germany changed earlier)
197 # Holland (Brabant, Gelderland, Flanders, Friesland, etc. changed
198 # at various times)
202 # Protestant Switzerland (Catholic cantons changed earlier)
208 # English speaking countries
212 # Sweden (had several changes onto and off of the Gregorian calendar)
216 # Russia
220 # Romania (Transylvania changed earler - perhaps de_RO should show
221 # the earlier date?)
225 # Greece
229 #------------------------------------------------------------------
230 #
231 # CONSTANTS
232 #
233 #------------------------------------------------------------------
235 # Paths at which binary time zone data for the Olson libraries
236 # are known to reside on various operating systems
244 } {
247 }
248 }
250 # Define the directories for time zone data and message catalogs.
255 # Number of days in the months, in common years and leap years.
266 }
270 }
272 # Another epoch (Hi, Jeff!)
276 # Integer ranges
281 # Day before Leap Day
285 # Translation table to map Windows TZI onto cities, so that
286 # the Olson rules can apply. In some cases the mapping is ambiguous,
287 # so it's wise to specify $::env(TCL_TZ) rather than simply depending
288 # on the system time zone.
290 # The keys are long lists of values obtained from the time zone
291 # information in the Registry. In order, the list elements are:
292 # Bias StandardBias DaylightBias
293 # StandardDate.wYear StandardDate.wMonth StandardDate.wDayOfWeek
294 # StandardDate.wDay StandardDate.wHour StandardDate.wMinute
295 # StandardDate.wSecond StandardDate.wMilliseconds
296 # DaylightDate.wYear DaylightDate.wMonth DaylightDate.wDayOfWeek
297 # DaylightDate.wDay DaylightDate.wHour DaylightDate.wMinute
298 # DaylightDate.wSecond DaylightDate.wMilliseconds
299 # The values are the names of time zones where those rules apply.
300 # There is considerable ambiguity in certain zones; an attempt has
301 # been made to make a reasonable guess, but this table needs to be
302 # taken with a grain of salt.
379 }]
381 # Groups of fields that specify the date, priorities, and
382 # code bursts that determine Julian Day Number given those groups.
383 # The code in [clock scan] will choose the highest priority
384 # (lowest numbered) set of fields that determines the date.
397 }
403 }
406 dict set date era CE
411 }
413 dict set date era CE
418 }
420 dict set date era CE
426 }
430 dict set date era CE
433 }
436 dict set date era CE
439 }
443 iso8601YearOfCentury iso8601Year]
444 dict set date era CE
447 }
454 }
460 }
466 }
473 }
480 }
485 }
486 }
488 # Groups of fields that specify time of day, priorities,
489 # and code that processes them
497 }
500 }
505 }
509 }
515 }
520 }
524 }
525 }
527 # Legacy time zones, used primarily for parsing RFC822 dates.
617 ]
619 # Caches
622 # names and whose values are pairs
623 # comprising regexes matching numerals
624 # in the given locales and dictionaries
625 # mapping the numerals to their numeric
626 # values.
628 # in which [mcload] has been executed
629 # and whose values are second-level
630 # dictionaries indexed by message
631 # name and giving message text.
632 # variable CachedSystemTimeZone; # If 'CachedSystemTimeZone' exists,
633 # it contains the value of the
634 # system time zone, as determined from
635 # the environment.
637 # names and whose values are 1 if
638 # the time zone is unknown and 0
639 # if it is known.
641 # and whose values are lists of quads
642 # comprising start time, UTC offset,
643 # Daylight Saving Time indicator, and
644 # time zone abbreviation.
646 # and locale to the name of a procedure
647 # that renders the given format
648 }
651 #----------------------------------------------------------------------
652 #
653 # clock format --
654 #
655 # Formats a count of seconds since the Posix Epoch as a time
656 # of day.
657 #
658 # The 'clock format' command formats times of day for output.
659 # Refer to the user documentation to see what it does.
660 #
661 #----------------------------------------------------------------------
665 variable FormatProc
666 variable TZData
672 # Get the data for time changes in the given zone
676 }
681 }
682 }
684 # Build a procedure to format the result. Cache the built procedure's
685 # name in the 'FormatProc' array to avoid losing its internal
686 # representation, which contains the name resolution.
695 }
699 }
701 #----------------------------------------------------------------------
702 #
703 # ParseClockFormatFormat --
704 #
705 # Builds and caches a procedure that formats a time value.
706 #
707 # Parameters:
708 # format -- Format string to use
709 # locale -- Locale in which the format string is to be interpreted
710 #
711 # Results:
712 # Returns the name of the newly-built procedure.
713 #
714 #----------------------------------------------------------------------
720 }
722 # Map away the locale-dependent composite format groups
724 EnterLocale $locale oldLocale
726 # Change locale if a fresh locale has been given on the command line.
730 ParseClockFormatFormat2 $format $locale $procName
734 # Restore the locale
737 mclocale $oldLocale
738 }
740 # Return either the error or the proc name
747 }
750 }
752 }
761 {
762 variable TZData
766 }]
775 {} {
777 set state percent
780 }
781 }
787 }
797 }
807 }
816 }
825 }
830 }
834 }
838 }
840 # alternative era
841 set state percentE
847 {
852 }
858 }
859 }
861 # week number
865 }
867 # week number
870 }
876 }
886 }
890 }
894 }
901 }
911 }
915 }
922 }
925 }
929 }
931 # alternative numerals
932 set state percentO
938 }
939 }
941 # converted to uppercase
950 }
961 }
965 }
969 }
971 # leading zero
976 }
979 }
983 }
985 # first Sunday of the year is the
986 # first day of week 01
992 }
993 incr dow
998 }
1000 }
1004 }
1006 # 6-Saturday)
1010 }
1012 # Monday of the year is the first day
1013 # of week 01.
1020 }
1023 }
1028 }
1032 }
1034 # east (+) or west (-) of Greenwich
1038 }
1042 }
1045 }
1048 }
1049 }
1050 }
1054 E {
1062 }
1066 }
1074 }
1075 }
1078 }
1081 }
1082 }
1083 }
1088 # numerals
1093 }
1095 # numerals
1102 }
1104 # numerals
1114 }
1119 }
1121 # numerals
1128 }
1130 # numerals
1136 }
1138 # in alternative numerals
1143 }
1145 # in alternative numerals
1150 }
1152 # numerals
1157 }
1160 }
1161 }
1162 }
1163 }
1164 }
1166 # Clean up any improperly terminated groups
1169 percent {
1171 }
1172 percentE {
1174 }
1175 percentO {
1177 }
1178 }
1181 $preFormatCode
1183 "
1185 # puts [list $procName [info args $procName] [info body $procName]]
1188 }
1190 #----------------------------------------------------------------------
1191 #
1192 # clock scan --
1193 #
1194 # Inputs a count of seconds since the Posix Epoch as a time
1195 # of day.
1196 #
1197 # The 'clock format' command scans times of day on input.
1198 # Refer to the user documentation to see what it does.
1199 #
1200 #----------------------------------------------------------------------
1206 # Check the count of args
1212 "wrong \# args: should be\
1214 ?-base seconds?\
1215 ?-format string? ?-gmt boolean?\
1217 }
1219 # Set defaults
1225 set locale c
1228 # Pick up command line options.
1235 }
1238 }
1241 }
1244 }
1247 }
1252 must be -base, -format, -gmt, -locale or -timezone"
1253 }
1254 }
1255 }
1257 # Check options for validity
1262 "cannot use -gmt and -timezone in same call"
1263 }
1267 }
1274 }
1275 }
1278 # Perhaps someday we'll localize the legacy code. Right now,
1279 # it's not localized.
1283 "legacy \[clock scan\] does not support -locale"
1285 }
1287 }
1289 # Change locale if a fresh locale has been given on the command line.
1291 EnterLocale $locale oldLocale
1295 # Map away the locale-dependent composite format groups
1298 $scanner $string $base $timezone
1302 # Restore the locale
1305 mclocale $oldLocale
1306 }
1313 }
1316 }
1318 }
1320 #----------------------------------------------------------------------
1321 #
1322 # FreeScan --
1323 #
1324 # Scans a time in free format
1325 #
1326 # Parameters:
1327 # string - String containing the time to scan
1328 # base - Base time, expressed in seconds from the Epoch
1329 # timezone - Default time zone in which the time will be expressed
1330 # locale - (Unused) Name of the locale where the time will be scanned.
1331 #
1332 # Results:
1333 # Returns the date and time extracted from the string in seconds
1334 # from the epoch
1335 #
1336 #----------------------------------------------------------------------
1340 variable TZData
1342 # Get the data for time changes in the given zone
1347 }
1349 # Extract year, month and day from the base time for the
1350 # parser to use as defaults
1359 # Parse the date. The parser will return a list comprising
1360 # date, time, time zone, relative month/day/seconds, relative
1361 # weekday, ordinal month.
1371 }
1374 parseWeekday parseOrdinalMonth
1376 # If the caller supplied a date in the string, update the 'date' dict
1377 # with the value. If the caller didn't specify a time with the date,
1378 # default to midnight.
1381 lassign $parseDate y m d
1387 }
1388 }
1389 dict set date era CE
1395 }
1396 }
1398 # If the caller supplied a time zone in the string, it comes back
1399 # as a two-element list; the first element is the number of minutes
1400 # east of Greenwich, and the second is a Daylight Saving Time
1401 # indicator ( 1 == yes, 0 == no, -1 == unknown ). We make it into
1402 # a time zone indicator of +-hhmm.
1405 lassign $parseZone minEast dstFlag
1408 SetupTimeZone $timezone
1409 }
1412 # Assemble date, time, zone into seconds-from-epoch
1423 }
1433 # Do relative times
1436 lassign $parseRel relMonth relDay relSecond
1440 }
1442 # Do relative weekday
1446 lassign $parseWeekday dayOrdinal dayOfWeek
1448 dict set date2 era CE
1455 }
1468 }
1470 # Do relative month
1474 lassign $parseOrdinalMonth monthOrdinal monthNumber
1479 }
1485 }
1486 incr monthOrdinal
1487 }
1491 }
1494 }
1497 #----------------------------------------------------------------------
1498 #
1499 # ParseClockScanFormat --
1500 #
1501 # Parses a format string given to [clock scan -format]
1502 #
1503 # Parameters:
1504 # formatString - The format being parsed
1505 # locale - The current locale
1506 #
1507 # Results:
1508 # Constructs and returns a procedure that accepts the
1509 # string being scanned, the base time, and the time zone.
1510 # The procedure will either return the scanned time or
1511 # else throw an error that should be rethrown to the caller
1512 # of [clock scan]
1513 #
1514 # Side effects:
1515 # The given procedure is defined in the ::tcl::clock
1516 # namespace. Scan procedures are not deleted once installed.
1517 #
1518 # Why do we parse dates by defining a procedure to parse them?
1519 # The reason is that by doing so, we have one convenient place to
1520 # cache all the information: the regular expressions that match the
1521 # patterns (which will be compiled), the code that assembles the
1522 # date information, everything lands in one place. In this way,
1523 # when a given format is reused at run time, all the information
1524 # of how to apply it is available in a single place.
1525 #
1526 #----------------------------------------------------------------------
1530 # Check whether the format has been parsed previously, and return
1531 # the existing recognizer if it has.
1537 }
1539 variable DateParseActions
1540 variable TimeParseActions
1542 # Localize the %x, %X, etc. groups
1546 # Condense whitespace
1550 # Walk through the groups of the format string. In this loop, we
1551 # accumulate:
1552 # - a regular expression that matches the string,
1553 # - the count of capturing brackets in the regexp
1554 # - a set of code that post-processes the fields captured by the regexp,
1555 # - a dictionary whose keys are the names of fields that are present
1556 # in the format string.
1568 {} {
1576 }
1578 }
1579 }
1580 % {
1583 % {
1585 }
1586 { } {
1588 }
1597 incr i
1598 }
1606 }
1613 incr i
1616 }
1625 }
1632 }
1639 }
1642 }
1651 }
1664 }
1671 }
1678 }
1685 }
1692 }
1699 }
1706 }
1709 }
1712 }
1724 }
1727 incr captureCount
1734 }
1736 # This next case is insanely difficult,
1737 # because it's problematic to determine
1738 # whether the field is actually within
1739 # the range of a wide integer.
1744 }
1751 }
1754 }
1756 # 1=Mon, 6=Sat
1761 {
1767 "day of week is greater than 7"
1768 }
1770 }
1771 }
1773 # first Sunday of the year is the
1774 # first day of week 01. No scan rule
1775 # uses this group.
1777 }
1785 }
1787 # Monday of the year is the first day
1788 # of week 01. No scan rule uses this
1789 # group.
1791 }
1798 }
1810 }
1824 }
1827 }
1832 }
1834 }
1835 }
1836 }
1842 lassign $triple t symbol year
1844 }
1847 }
1848 E {
1852 dict set l b.c.e. BCE
1853 dict set l c.e. CE
1854 dict set l b.c. BCE
1855 dict set l a.d. CE
1864 }
1868 incr captureCount
1869 }
1874 }
1876 }
1877 }
1879 }
1890 }
1899 }
1908 }
1909 m {
1917 }
1918 M {
1926 }
1927 S {
1935 }
1942 {
1948 "day of week is greater than 7"
1949 }
1951 }
1952 }
1953 y {
1960 }
1965 }
1967 }
1968 }
1970 }
1971 }
1972 }
1974 # Clean up any unfinished format groups
1978 # Build the procedure
1985 }
1990 }
1997 # Get time zone if needed
2004 }
2005 }
2008 }
2009 }
2011 # Add code that gets Julian Day Number from the fields.
2015 # Get time of day
2019 # Assemble seconds, and convert local nominal time to UTC.
2026 "requested date too large to represent"
2027 }
2032 }
2037 }
2038 }
2040 # Return result
2046 # puts [list proc $procName [list string baseTime timeZone] $procBody]
2049 }
2051 #----------------------------------------------------------------------
2052 #
2053 # LocaleNumeralMatcher --
2054 #
2055 # Composes a regexp that captures the numerals in the given
2056 # locale, and a dictionary to map them to conventional numerals.
2057 #
2058 # Parameters:
2059 # locale - Name of the current locale
2060 #
2061 # Results:
2062 # Returns a two-element list comprising the regexp and the
2063 # dictionary.
2064 #
2065 # Side effects:
2066 # Caches the result.
2067 #
2068 #----------------------------------------------------------------------
2072 variable LocaleNumeralCache
2082 set sep |
2083 incr i
2084 }
2087 }
2089 }
2093 #----------------------------------------------------------------------
2094 #
2095 # UniquePrefixRegexp --
2096 #
2097 # Composes a regexp that performs unique-prefix matching. The
2098 # RE matches one of a supplied set of strings, or any unique
2099 # prefix thereof.
2100 #
2101 # Parameters:
2102 # data - List of alternating match-strings and values.
2103 # Match-strings with distinct values are considered
2104 # distinct.
2105 #
2106 # Results:
2107 # Returns a two-element list. The first is a regexp that
2108 # matches any unique prefix of any of the strings. The second
2109 # is a dictionary whose keys are match values from the regexp
2110 # and whose values are the corresponding values from 'data'.
2111 #
2112 # Side effects:
2113 # None.
2114 #
2115 #----------------------------------------------------------------------
2119 # The 'successors' dictionary will contain, for each string that
2120 # is a prefix of any key, all characters that may follow that
2121 # prefix. The 'prefixMapping' dictionary will have keys that
2122 # are prefixes of keys and values that correspond to the keys.
2127 # Walk the key-value pairs
2131 # Construct all prefixes of the key;
2139 # Put the prefixes in the 'prefixMapping' and 'successors'
2140 # dictionaries
2145 }
2146 }
2147 }
2149 # Identify those prefixes that designate unique values, and
2150 # those that are the full keys
2156 }
2157 }
2160 }
2162 # Construct the re.
2167 }
2169 #----------------------------------------------------------------------
2170 #
2171 # MakeUniquePrefixRegexp --
2172 #
2173 # Service procedure for 'UniquePrefixRegexp' that constructs
2174 # a regular expresison that matches the unique prefixes.
2175 #
2176 # Parameters:
2177 # successors - Dictionary whose keys are all prefixes
2178 # of keys passed to 'UniquePrefixRegexp' and whose
2179 # values are dictionaries whose keys are the characters
2180 # that may follow those prefixes.
2181 # uniquePrefixMapping - Dictionary whose keys are the unique
2182 # prefixes and whose values are not examined.
2183 # prefixString - Current prefix being processed.
2184 #
2185 # Results:
2186 # Returns a constructed regular expression that matches the set
2187 # of unique prefixes beginning with the 'prefixString'.
2188 #
2189 # Side effects:
2190 # None.
2191 #
2192 #----------------------------------------------------------------------
2195 uniquePrefixMapping
2196 prefixString } {
2198 # Get the characters that may follow the current prefix string
2203 }
2205 # If there is more than one successor character, or if the current
2206 # prefix is a unique prefix, surround the generated re with non-capturing
2207 # parentheses.
2213 }
2215 # Generate a regexp that matches the successors.
2224 set sep |
2225 }
2227 # If the current prefix is a unique prefix, make all following text
2228 # optional. Otherwise, if there is more than one successor character,
2229 # close the non-capturing parentheses.
2235 }
2238 }
2240 #----------------------------------------------------------------------
2241 #
2242 # MakeParseCodeFromFields --
2243 #
2244 # Composes Tcl code to extract the Julian Day Number from a
2245 # dictionary containing date fields.
2246 #
2247 # Parameters:
2248 # dateFields -- Dictionary whose keys are fields of the date,
2249 # and whose values are the rightmost positions
2250 # at which those fields appear.
2251 # parseActions -- List of triples: field set, priority, and
2252 # code to emit. Smaller priorities are better, and
2253 # the list must be in ascending order by priority
2254 #
2255 # Results:
2256 # Returns a burst of code that extracts the day number from the
2257 # given date.
2258 #
2259 # Side effects:
2260 # None.
2261 #
2262 #----------------------------------------------------------------------
2270 }
2274 # If we've found an answer that's better than any that follow,
2275 # quit now.
2278 break
2279 }
2281 # Accumulate the field positions that are used in the current
2282 # field grouping.
2285 set ok true
2289 break
2290 }
2292 }
2294 # Quit if we don't have a complete set of fields
2296 continue
2297 }
2299 # Determine whether the current answer is better than the last.
2308 break
2309 }
2312 break
2313 }
2314 }
2315 }
2317 continue
2318 }
2320 # Remember the best possibility for extracting date information
2326 }
2330 }
2332 #----------------------------------------------------------------------
2333 #
2334 # EnterLocale --
2335 #
2336 # Switch [mclocale] to a given locale if necessary
2337 #
2338 # Parameters:
2339 # locale -- Desired locale
2340 # oldLocaleVar -- Name of a variable in caller's scope that
2341 # tracks the previous locale name.
2342 #
2343 # Results:
2344 # Returns the locale that was previously current.
2345 #
2346 # Side effects:
2347 # Does [mclocale]. If necessary, uses [mcload] to load the
2348 # designated locale's files, and tracks that it has done so
2349 # in the 'McLoaded' variable.
2350 #
2351 #----------------------------------------------------------------------
2357 variable MsgDir
2358 variable McLoaded
2365 # On a non-windows platform, the 'system' locale is
2366 # the same as the 'current' locale
2368 set locale current
2371 # On a windows platform, the 'system' locale is
2372 # adapted from the 'current' locale by applying the
2373 # date and time formats from the Control Panel.
2374 # First, load the 'current' locale if it's not yet loaded
2377 mcload $MsgDir
2379 }
2381 # Make a new locale string for the system locale, and
2382 # get the Control Panel information
2386 LoadWindowsDateTimeFormats $locale
2388 }
2389 }
2390 }
2393 unset oldLocale
2395 unset oldLocale
2397 mclocale $locale
2398 }
2400 mcload $MsgDir
2402 }
2404 }
2406 #----------------------------------------------------------------------
2407 #
2408 # LoadWindowsDateTimeFormats --
2409 #
2410 # Load the date/time formats from the Control Panel in Windows
2411 # and convert them so that they're usable by Tcl.
2412 #
2413 # Parameters:
2414 # locale - Name of the locale in whose message catalog
2415 # the converted formats are to be stored.
2416 #
2417 # Results:
2418 # None.
2419 #
2420 # Side effects:
2421 # Updates the given message catalog with the locale strings.
2422 #
2423 # Presumes that on entry, [mclocale] is set to the current locale,
2424 # so that default strings can be obtained if the Registry query
2425 # fails.
2426 #
2427 #----------------------------------------------------------------------
2431 # Bail out if we can't find the Registry
2433 variable NoRegistry
2438 sShortDate
2444 dddd %A
2445 ddd %a
2446 dd %d
2447 d %e
2448 MMMM %B
2449 MMM %b
2450 MM %m
2451 M %N
2452 yyyy %Y
2453 yy %y
2454 y %y
2455 gg {}
2458 set quote '
2461 }
2462 }
2464 }
2468 sLongDate
2474 dddd %A
2475 ddd %a
2476 dd %d
2477 d %e
2478 MMMM %B
2479 MMM %b
2480 MM %m
2481 M %N
2482 yyyy %Y
2483 yy %y
2484 y %y
2485 gg {}
2488 set quote '
2491 }
2492 }
2494 }
2498 sTimeFormat
2504 HH %H
2505 H %k
2506 hh %I
2507 h %l
2508 mm %M
2509 m %M
2510 ss %S
2511 s %S
2512 tt %p
2513 t %p
2516 set quote '
2519 }
2520 }
2522 }
2526 }
2529 }
2531 return
2533 }
2535 #----------------------------------------------------------------------
2536 #
2537 # LocalizeFormat --
2538 #
2539 # Map away locale-dependent format groups in a clock format.
2540 #
2541 # Parameters:
2542 # locale -- Current [mclocale] locale, supplied to avoid
2543 # an extra call
2544 # format -- Format supplied to [clock scan] or [clock format]
2545 #
2546 # Results:
2547 # Returns the string with locale-dependent composite format
2548 # groups substituted out.
2549 #
2550 # Side effects:
2551 # None.
2552 #
2553 #----------------------------------------------------------------------
2557 variable McLoaded
2561 }
2564 # Handle locale-dependent format groups by mapping them out of the format
2565 # string. Note that the order of the [string map] operations is
2566 # significant because later formats can refer to later ones; for example
2567 # %c can refer to %X, which in turn can refer to %T.
2570 %% %%
2573 }
2588 }
2590 #----------------------------------------------------------------------
2591 #
2592 # FormatNumericTimeZone --
2593 #
2594 # Formats a time zone as +hhmmss
2595 #
2596 # Parameters:
2597 # z - Time zone in seconds east of Greenwich
2598 #
2599 # Results:
2600 # Returns the time zone formatted in a numeric form
2601 #
2602 # Side effects:
2603 # None.
2604 #
2605 #----------------------------------------------------------------------
2614 }
2621 }
2624 }
2626 #----------------------------------------------------------------------
2627 #
2628 # FormatStarDate --
2629 #
2630 # Formats a date as a StarDate.
2631 #
2632 # Parameters:
2633 # date - Dictionary containing 'year', 'dayOfYear', and
2634 # 'localSeconds' fields.
2635 #
2636 # Results:
2637 # Returns the given date formatted as a StarDate.
2638 #
2639 # Side effects:
2640 # None.
2641 #
2642 # Jeff Hobbs put this in to support an atrocious pun about Tcl being
2643 # "Enterprise ready." Now we're stuck with it.
2644 #
2645 #----------------------------------------------------------------------
2649 variable Roddenberry
2651 # Get day of year, zero based
2655 # Determine whether the year is a leap year
2659 # Convert day of year to a fractional year
2665 }
2667 # Put together the StarDate
2674 }
2676 #----------------------------------------------------------------------
2677 #
2678 # ParseStarDate --
2679 #
2680 # Parses a StarDate
2681 #
2682 # Parameters:
2683 # year - Year from the Roddenberry epoch
2684 # fractYear - Fraction of a year specifiying the day of year.
2685 # fractDay - Fraction of a day
2686 #
2687 # Results:
2688 # Returns a count of seconds from the Posix epoch.
2689 #
2690 # Side effects:
2691 # None.
2692 #
2693 # Jeff Hobbs put this in to support an atrocious pun about Tcl being
2694 # "Enterprise ready." Now we're stuck with it.
2695 #
2696 #----------------------------------------------------------------------
2700 variable Roddenberry
2702 # Build a tentative date from year and fraction.
2706 era CE \
2711 # Determine whether the given year is a leap year
2715 # Reconvert the fractional year according to whether the given
2716 # year is a leap year
2724 }
2725 dict unset date julianDay
2726 dict unset date gregorian
2733 }
2735 #----------------------------------------------------------------------
2736 #
2737 # ScanWide --
2738 #
2739 # Scans a wide integer from an input
2740 #
2741 # Parameters:
2742 # str - String containing a decimal wide integer
2743 #
2744 # Results:
2745 # Returns the string as a pure wide integer. Throws an error if
2746 # the string is misformatted or out of range.
2747 #
2748 #----------------------------------------------------------------------
2755 }
2758 "integer value too large to represent"
2759 }
2761 }
2763 #----------------------------------------------------------------------
2764 #
2765 # InterpretTwoDigitYear --
2766 #
2767 # Given a date that contains only the year of the century,
2768 # determines the target value of a two-digit year.
2769 #
2770 # Parameters:
2771 # date - Dictionary containing fields of the date.
2772 # baseTime - Base time relative to which the date is expressed.
2773 # twoDigitField - Name of the field that stores the two-digit year.
2774 # Default is 'yearOfCentury'
2775 # fourDigitField - Name of the field that will receive the four-digit
2776 # year. Default is 'year'
2777 #
2778 # Results:
2779 # Returns the dictionary augmented with the four-digit year, stored in
2780 # the given key.
2781 #
2782 # Side effects:
2783 # None.
2784 #
2785 # The current rule for interpreting a two-digit year is that the year
2786 # shall be between 1937 and 2037, thus staying within the range of a
2787 # 32-bit signed value for time. This rule may change to a sliding
2788 # window in future versions, so the 'baseTime' parameter (which is
2789 # currently ignored) is provided in the procedure signature.
2790 #
2791 #----------------------------------------------------------------------
2802 }
2805 }
2807 #----------------------------------------------------------------------
2808 #
2809 # AssignBaseYear --
2810 #
2811 # Places the number of the current year into a dictionary.
2812 #
2813 # Parameters:
2814 # date - Dictionary value to update
2815 # baseTime - Base time from which to extract the year, expressed
2816 # in seconds from the Posix epoch
2817 # timezone - the time zone in which the date is being scanned
2818 # changeover - the Julian Day on which the Gregorian calendar
2819 # was adopted in the target locale.
2820 #
2821 # Results:
2822 # Returns the dictionary with the current year assigned.
2823 #
2824 # Side effects:
2825 # None.
2826 #
2827 #----------------------------------------------------------------------
2831 variable TZData
2833 # Find the Julian Day Number corresponding to the base time, and
2834 # find the Gregorian year corresponding to that Julian Day.
2838 # Store the converted year
2845 }
2847 #----------------------------------------------------------------------
2848 #
2849 # AssignBaseIso8601Year --
2850 #
2851 # Determines the base year in the ISO8601 fiscal calendar.
2852 #
2853 # Parameters:
2854 # date - Dictionary containing the fields of the date that
2855 # is to be augmented with the base year.
2856 # baseTime - Base time expressed in seconds from the Posix epoch.
2857 # timeZone - Target time zone
2858 # changeover - Julian Day of adoption of the Gregorian calendar in
2859 # the target locale.
2860 #
2861 # Results:
2862 # Returns the given date with "iso8601Year" set to the
2863 # base year.
2864 #
2865 # Side effects:
2866 # None.
2867 #
2868 #----------------------------------------------------------------------
2872 variable TZData
2874 # Find the Julian Day Number corresponding to the base time
2878 # Calculate the ISO8601 date and transfer the year
2880 dict set date era CE
2883 }
2885 #----------------------------------------------------------------------
2886 #
2887 # AssignBaseMonth --
2888 #
2889 # Places the number of the current year and month into a
2890 # dictionary.
2891 #
2892 # Parameters:
2893 # date - Dictionary value to update
2894 # baseTime - Time from which the year and month are to be
2895 # obtained, expressed in seconds from the Posix epoch.
2896 # timezone - Name of the desired time zone
2897 # changeover - Julian Day on which the Gregorian calendar was adopted.
2898 #
2899 # Results:
2900 # Returns the dictionary with the base year and month assigned.
2901 #
2902 # Side effects:
2903 # None.
2904 #
2905 #----------------------------------------------------------------------
2909 variable TZData
2911 # Find the year and month corresponding to the base time
2919 }
2921 #----------------------------------------------------------------------
2922 #
2923 # AssignBaseWeek --
2924 #
2925 # Determines the base year and week in the ISO8601 fiscal calendar.
2926 #
2927 # Parameters:
2928 # date - Dictionary containing the fields of the date that
2929 # is to be augmented with the base year and week.
2930 # baseTime - Base time expressed in seconds from the Posix epoch.
2931 # changeover - Julian Day on which the Gregorian calendar was adopted
2932 # in the target locale.
2933 #
2934 # Results:
2935 # Returns the given date with "iso8601Year" set to the
2936 # base year and "iso8601Week" to the week number.
2937 #
2938 # Side effects:
2939 # None.
2940 #
2941 #----------------------------------------------------------------------
2945 variable TZData
2947 # Find the Julian Day Number corresponding to the base time
2951 # Calculate the ISO8601 date and transfer the year
2953 dict set date era CE
2957 }
2959 #----------------------------------------------------------------------
2960 #
2961 # AssignBaseJulianDay --
2962 #
2963 # Determines the base day for a time-of-day conversion.
2964 #
2965 # Parameters:
2966 # date - Dictionary that is to get the base day
2967 # baseTime - Base time expressed in seconds from the Posix epoch
2968 # changeover - Julian day on which the Gregorian calendar was
2969 # adpoted in the target locale.
2970 #
2971 # Results:
2972 # Returns the given dictionary augmented with a 'julianDay' field
2973 # that contains the base day.
2974 #
2975 # Side effects:
2976 # None.
2977 #
2978 #----------------------------------------------------------------------
2982 variable TZData
2984 # Find the Julian Day Number corresponding to the base time
2990 }
2992 #----------------------------------------------------------------------
2993 #
2994 # InterpretHMSP --
2995 #
2996 # Interprets a time in the form "hh:mm:ss am".
2997 #
2998 # Parameters:
2999 # date -- Dictionary containing "hourAMPM", "minute", "second"
3000 # and "amPmIndicator" fields.
3001 #
3002 # Results:
3003 # Returns the number of seconds from local midnight.
3004 #
3005 # Side effects:
3006 # None.
3007 #
3008 #----------------------------------------------------------------------
3015 }
3018 }
3022 }
3024 #----------------------------------------------------------------------
3025 #
3026 # InterpretHMS --
3027 #
3028 # Interprets a 24-hour time "hh:mm:ss"
3029 #
3030 # Parameters:
3031 # date -- Dictionary containing the "hour", "minute" and "second"
3032 # fields.
3033 #
3034 # Results:
3035 # Returns the given dictionary augmented with a "secondOfDay"
3036 # field containing the number of seconds from local midnight.
3037 #
3038 # Side effects:
3039 # None.
3040 #
3041 #----------------------------------------------------------------------
3049 }
3051 #----------------------------------------------------------------------
3052 #
3053 # GetSystemTimeZone --
3054 #
3055 # Determines the system time zone, which is the default for the
3056 # 'clock' command if no other zone is supplied.
3057 #
3058 # Parameters:
3059 # None.
3060 #
3061 # Results:
3062 # Returns the system time zone.
3063 #
3064 # Side effects:
3065 # Stores the sustem time zone in the 'CachedSystemTimeZone'
3066 # variable, since determining it may be an expensive process.
3067 #
3068 #----------------------------------------------------------------------
3072 variable CachedSystemTimeZone
3073 variable TimeZoneBad
3079 }
3081 # Cache the time zone only if it was detected by one of the
3082 # expensive methods.
3093 }
3095 }
3098 }
3103 }
3105 }
3107 #----------------------------------------------------------------------
3108 #
3109 # ConvertLegacyTimeZone --
3110 #
3111 # Given an alphanumeric time zone identifier and the system
3112 # time zone, convert the alphanumeric identifier to an
3113 # unambiguous time zone.
3114 #
3115 # Parameters:
3116 # tzname - Name of the time zone to convert
3117 #
3118 # Results:
3119 # Returns a time zone name corresponding to tzname, but
3120 # in an unambiguous form, generally +hhmm.
3121 #
3122 # This procedure is implemented primarily to allow the parsing of
3123 # RFC822 date/time strings. Processing a time zone name on input
3124 # is not recommended practice, because there is considerable room
3125 # for ambiguity; for instance, is BST Brazilian Standard Time, or
3126 # British Summer Time?
3127 #
3128 #----------------------------------------------------------------------
3132 variable LegacyTimeZone
3140 }
3142 }
3144 #----------------------------------------------------------------------
3145 #
3146 # SetupTimeZone --
3147 #
3148 # Given the name or specification of a time zone, sets up
3149 # its in-memory data.
3150 #
3151 # Parameters:
3152 # tzname - Name of a time zone
3153 #
3154 # Results:
3155 # Unless the time zone is ':localtime', sets the TZData array
3156 # to contain the lookup table for local<->UTC conversion.
3157 # Returns an error if the time zone cannot be parsed.
3158 #
3159 #----------------------------------------------------------------------
3163 variable TZData
3166 variable MINWIDE
3169 # Nothing to do, we'll convert using the localtime function
3174 # Make a fixed offset
3181 }
3186 }
3190 }
3195 # Convert using a time zone file
3200 }]
3203 }]
3204 } {
3208 }
3212 # This looks like a POSIX time zone - try to process it
3217 }
3221 }
3225 # We couldn't parse this as a POSIX time zone. Try
3226 # again with a time zone file - this time without a colon
3232 }
3234 }
3235 }
3237 return
3238 }
3240 #----------------------------------------------------------------------
3241 #
3242 # GuessWindowsTimeZone --
3243 #
3244 # Determines the system time zone on windows.
3245 #
3246 # Parameters:
3247 # None.
3248 #
3249 # Results:
3250 # Returns a time zone specifier that corresponds to the system
3251 # time zone information found in the Registry.
3252 #
3253 # Bugs:
3254 # Fixed dates for DST change are unimplemented at present, because
3255 # no time zone information supplied with Windows actually uses
3256 # them!
3257 #
3258 # On a Windows system where neither $env(TCL_TZ) nor $env(TZ) is
3259 # specified, GuessWindowsTimeZone looks in the Registry for the
3260 # system time zone information. It then attempts to find an entry
3261 # in WinZoneInfo for a time zone that uses the same rules. If
3262 # it finds one, it returns it; otherwise, it constructs a Posix-style
3263 # time zone string and returns that.
3264 #
3265 #----------------------------------------------------------------------
3269 variable WinZoneInfo
3270 variable NoRegistry
3271 variable TimeZoneBad
3275 }
3277 # Dredge time zone information out of the registry
3292 }
3297 }
3298 }] } {
3300 # Missing values in the Registry - bail out
3303 }
3305 # Make up a Posix time zone specifier if we can't find one.
3306 # Check here that the tzdata file exists, in case we're running
3307 # in an environment (e.g. starpack) where tzdata is incomplete.
3308 # (Bug 1237907)
3314 }
3317 }
3320 bias stdBias dstBias \
3321 stdYear stdMonth stdDayOfWeek stdDayOfMonth \
3322 stdHour stdMinute stdSecond stdMillisec \
3323 dstYear dstMonth dstDayOfWeek dstDayOfMonth \
3324 dstHour dstMinute dstSecond dstMillisec
3334 }
3348 }
3356 # I have not been able to find any locale on which
3357 # Windows converts time zone on a fixed day of the year,
3358 # hence don't know how to interpret the fields.
3359 # If someone can inform me, I'd be glad to code it up.
3360 # For right now, we bail out in such a case.
3362 }
3369 # I have not been able to find any locale on which
3370 # Windows converts time zone on a fixed day of the year,
3371 # hence don't know how to interpret the fields.
3372 # If someone can inform me, I'd be glad to code it up.
3373 # For right now, we bail out in such a case.
3375 }
3379 }
3381 }
3385 }
3387 #----------------------------------------------------------------------
3388 #
3389 # LoadTimeZoneFile --
3390 #
3391 # Load the data file that specifies the conversion between a
3392 # given time zone and Greenwich.
3393 #
3394 # Parameters:
3395 # fileName -- Name of the file to load
3396 #
3397 # Results:
3398 # None.
3399 #
3400 # Side effects:
3401 # TZData(:fileName) contains the time zone data
3402 #
3403 #----------------------------------------------------------------------
3406 variable DataDir
3407 variable TZData
3410 return
3411 }
3413 # Since an unsafe interp uses the [clock] command in the master,
3414 # this code is security sensitive. Make sure that the path name
3415 # cannot escape the given directory.
3421 }
3424 }] } {
3428 }
3429 return
3430 }
3432 #----------------------------------------------------------------------
3433 #
3434 # LoadZoneinfoFile --
3435 #
3436 # Loads a binary time zone information file in Olson format.
3437 #
3438 # Parameters:
3439 # fileName - Relative path name of the file to load.
3440 #
3441 # Results:
3442 # Returns an empty result normally; returns an error if no
3443 # Olson file was found or the file was malformed in some way.
3444 #
3445 # Side effects:
3446 # TZData(:fileName) contains the time zone data
3447 #
3448 #----------------------------------------------------------------------
3452 variable ZoneinfoPaths
3454 # Since an unsafe interp uses the [clock] command in the master,
3455 # this code is security sensitive. Make sure that the path name
3456 # cannot escape the given directory.
3462 }
3466 break
3467 }
3468 unset fname
3469 }
3470 ReadZoneinfoFile $fileName $fname
3471 }
3473 #----------------------------------------------------------------------
3474 #
3475 # ReadZoneinfoFile --
3476 #
3477 # Loads a binary time zone information file in Olson format.
3478 #
3479 # Parameters:
3480 # fileName - Name of the time zone (relative path name of the
3481 # file).
3482 # fname - Absolute path name of the file.
3483 #
3484 # Results:
3485 # Returns an empty result normally; returns an error if no
3486 # Olson file was found or the file was malformed in some way.
3487 #
3488 # Side effects:
3489 # TZData(:fileName) contains the time zone data
3490 #
3491 #----------------------------------------------------------------------
3495 variable MINWIDE
3496 variable TZData
3499 }
3503 }
3505 # Suck in all the data from the file
3512 # The file begins with a magic number, sixteen reserved bytes,
3513 # and then six 4-byte integers giving counts of fileds in the file.
3516 magic version nIsGMT nIsStd nLeap nTime nType nChar
3519 set iformat I
3522 }
3525 }
3526 # Accept only Posix-style zoneinfo. Sorry, 'leaps' bigots.
3529 }
3531 # In a version 2 file, we use the second part of the file, which
3532 # contains 64-bit transition times.
3542 }]
3544 magic version nIsGMT nIsStd nLeap nTime nType nChar
3547 }
3548 set iformat W
3551 }
3553 # Next come ${nTime} transition times, followed by ${nTime} time type
3554 # codes. The type codes are unsigned 1-byte quantities. We insert an
3555 # arbitrary start time in front of the transitions.
3563 }
3566 # Next come ${nType} time type descriptions, each of which has an
3567 # offset (seconds east of GMT), a DST indicator, and an index into
3568 # the abbreviation text.
3574 }
3576 # Next come $nChar characters of time zone name abbreviations,
3577 # which are null-terminated.
3578 # We build them up into a dictionary indexed by character index,
3579 # because that's what's in the indices above.
3589 incr i
3590 }
3591 }
3593 # Package up a list of tuples, each of which contains transition time,
3594 # seconds east of Greenwich, DST flag and time zone abbreviation.
3601 }
3606 }
3608 # In a version 2 file, there is also a POSIX-style time zone description
3609 # at the very end of the file. To get to it, skip over
3610 # nLeap leap second values (8 bytes each),
3611 # nIsStd standard/DST indicators and nIsGMT UTC/local indicators.
3620 lassign $tuple t gmtoff isDst abbrev
3623 }
3624 }
3625 }
3626 }
3630 return
3631 }
3633 #----------------------------------------------------------------------
3634 #
3635 # ParsePosixTimeZone --
3636 #
3637 # Parses the TZ environment variable in Posix form
3638 #
3639 # Parameters:
3640 # tz Time zone specifier to be interpreted
3641 #
3642 # Results:
3643 # Returns a dictionary whose values contain the various pieces of
3644 # the time zone specification.
3645 #
3646 # Side effects:
3647 # None.
3648 #
3649 # Errors:
3650 # Throws an error if the syntax of the time zone is incorrect.
3651 #
3652 # The following keys are present in the dictionary:
3653 # stdName - Name of the time zone when Daylight Saving Time
3654 # is not in effect.
3655 # stdSignum - Sign (+, -, or empty) of the offset from Greenwich
3656 # to the given (non-DST) time zone. + and the empty
3657 # string denote zones west of Greenwich, - denotes east
3658 # of Greenwich; this is contrary to the ISO convention
3659 # but follows Posix.
3660 # stdHours - Hours part of the offset from Greenwich to the given
3661 # (non-DST) time zone.
3662 # stdMinutes - Minutes part of the offset from Greenwich to the
3663 # given (non-DST) time zone. Empty denotes zero.
3664 # stdSeconds - Seconds part of the offset from Greenwich to the
3665 # given (non-DST) time zone. Empty denotes zero.
3666 # dstName - Name of the time zone when DST is in effect, or the
3667 # empty string if the time zone does not observe Daylight
3668 # Saving Time.
3669 # dstSignum, dstHours, dstMinutes, dstSeconds -
3670 # Fields corresponding to stdSignum, stdHours, stdMinutes,
3671 # stdSeconds for the Daylight Saving Time version of the
3672 # time zone. If dstHours is empty, it is presumed to be 1.
3673 # startDayOfYear - The ordinal number of the day of the year on which
3674 # Daylight Saving Time begins. If this field is
3675 # empty, then DST begins on a given month-week-day,
3676 # as below.
3677 # startJ - The letter J, or an empty string. If a J is present in
3678 # this field, then startDayOfYear does not count February 29
3679 # even in leap years.
3680 # startMonth - The number of the month in which Daylight Saving Time
3681 # begins, supplied if startDayOfYear is empty. If both
3682 # startDayOfYear and startMonth are empty, then US rules
3683 # are presumed.
3684 # startWeekOfMonth - The number of the week in the month in which
3685 # Daylight Saving Time begins, in the range 1-5.
3686 # 5 denotes the last week of the month even in a
3687 # 4-week month.
3688 # startDayOfWeek - The number of the day of the week (Sunday=0,
3689 # Saturday=6) on which Daylight Saving Time begins.
3690 # startHours - The hours part of the time of day at which Daylight
3691 # Saving Time begins. An empty string is presumed to be 2.
3692 # startMinutes - The minutes part of the time of day at which DST begins.
3693 # An empty string is presumed zero.
3694 # startSeconds - The seconds part of the time of day at which DST begins.
3695 # An empty string is presumed zero.
3696 # endDayOfYear, endJ, endMonth, endWeekOfMonth, endDayOfWeek,
3697 # endHours, endMinutes, endSeconds -
3698 # Specify the end of DST in the same way that the start* fields
3699 # specify the beginning of DST.
3700 #
3701 # This procedure serves only to break the time specifier into fields.
3702 # No attempt is made to canonicalize the fields or supply default values.
3703 #
3704 #----------------------------------------------------------------------
3709 ^
3710 # 1 - Standard time zone name
3712 # 2 - Standard time zone offset, signum
3714 # 3 - Standard time zone offset, hours
3717 # 4 - Standard time zone offset, minutes
3720 # 5 - Standard time zone offset, seconds
3722 )?
3723 )?
3725 # 6 - DST time zone name
3729 # 7 - DST time zone offset, signum
3731 # 8 - DST time zone offset, hours
3734 # 9 - DST time zone offset, minutes
3737 # 10 - DST time zone offset, seconds
3739 )?
3740 )?
3741 )?
3743 ,
3745 # 11 - Optional J in n and Jn form 12 - Day of year
3747 | M
3748 # 13 - Month number 14 - Week of month 15 - Day of week
3752 )
3754 # 16 - Start time of DST - hours
3757 # 17 - Start time of DST - minutes
3760 # 18 - Start time of DST - seconds
3762 )?
3763 )?
3764 )?
3765 ,
3767 # 19 - Optional J in n and Jn form 20 - Day of year
3769 | M
3770 # 21 - Month number 22 - Week of month 23 - Day of week
3774 )
3776 # 24 - End time of DST - hours
3779 # 25 - End time of DST - minutes
3782 # 26 - End time of DST - seconds
3784 )?
3785 )?
3786 )?
3787 )?
3788 )?
3789 )?
3790 $
3800 # it's a good timezone
3810 }
3812 }
3814 #----------------------------------------------------------------------
3815 #
3816 # ProcessPosixTimeZone --
3817 #
3818 # Handle a Posix time zone after it's been broken out into
3819 # fields.
3820 #
3821 # Parameters:
3822 # z - Dictionary returned from 'ParsePosixTimeZone'
3823 #
3824 # Results:
3825 # Returns time zone information for the 'TZData' array.
3826 #
3827 # Side effects:
3828 # None.
3829 #
3830 #----------------------------------------------------------------------
3834 variable MINWIDE
3835 variable TZData
3837 # Determine the standard time zone name and seconds east of Greenwich
3842 }
3847 }
3853 }
3858 }
3864 # If there's no daylight zone, we're done
3869 }
3872 }
3874 # Determine the daylight name
3880 }
3889 }
3894 }
3898 }
3900 # Fill in defaults for European or US DST rules
3901 # US start time is the second Sunday in March
3902 # EU start time is the last Sunday in March
3903 # US end time is the first Sunday in November.
3904 # EU end time is the last Sunday in October
3909 # EU
3915 }
3917 # US
3920 }
3925 }
3929 # EU
3936 }
3938 # US
3942 }
3946 }
3948 # Put DST in effect in all years from 1916 to 2099.
3963 }
3964 }
3968 }
3970 #----------------------------------------------------------------------
3971 #
3972 # DeterminePosixDSTTime --
3973 #
3974 # Determines the time that Daylight Saving Time starts or ends
3975 # from a Posix time zone specification.
3976 #
3977 # Parameters:
3978 # z - Time zone data returned from ParsePosixTimeZone.
3979 # Missing fields are expected to be filled in with
3980 # default values.
3981 # bound - The word 'start' or 'end'
3982 # y - The year for which the transition time is to be determined.
3983 #
3984 # Results:
3985 # Returns the transition time as a count of seconds from
3986 # the epoch. The time is relative to the wall clock, not UTC.
3987 #
3988 #----------------------------------------------------------------------
3992 variable FEB_28
3994 # Determine the start or end day of DST
4000 # Time was specified as a day of the year
4005 incr doy
4006 }
4011 # Time was specified as a day of the week within a month
4018 }
4022 }
4033 }
4039 }
4045 }
4049 }
4051 #----------------------------------------------------------------------
4052 #
4053 # GetLocaleEra --
4054 #
4055 # Given local time expressed in seconds from the Posix epoch,
4056 # determine localized era and year within the era.
4057 #
4058 # Parameters:
4059 # date - Dictionary that must contain the keys, 'localSeconds',
4060 # whose value is expressed as the appropriate local time;
4061 # and 'year', whose value is the Gregorian year.
4062 # etable - Value of the LOCALE_ERAS key in the message catalogue
4063 # for the target locale.
4064 #
4065 # Results:
4066 # Returns the dictionary, augmented with the keys, 'localeEra'
4067 # and 'localeYear'.
4068 #
4069 #----------------------------------------------------------------------
4083 }
4086 }
4088 #----------------------------------------------------------------------
4089 #
4090 # GetJulianDayFromEraYearDay --
4091 #
4092 # Given a year, month and day on the Gregorian calendar, determines
4093 # the Julian Day Number beginning at noon on that date.
4094 #
4095 # Parameters:
4096 # date -- A dictionary in which the 'era', 'year', and
4097 # 'dayOfYear' slots are populated. The calendar in use
4098 # is determined by the date itself relative to:
4099 # changeover -- Julian day on which the Gregorian calendar was
4100 # adopted in the current locale.
4101 #
4102 # Results:
4103 # Returns the given dictionary augmented with a 'julianDay' key
4104 # whose value is the desired Julian Day Number, and a 'gregorian'
4105 # key that specifies whether the calendar is Gregorian (1) or
4106 # Julian (0).
4107 #
4108 # Side effects:
4109 # None.
4110 #
4111 # Bugs:
4112 # This code needs to be moved to the C layer.
4113 #
4114 #----------------------------------------------------------------------
4118 # Get absolute year number from the civil year
4121 BCE {
4123 }
4124 CE {
4126 }
4127 }
4130 # Try the Gregorian calendar first.
4140 # If the date is before the Gregorian change, use the Julian calendar.
4148 }
4152 }
4154 #----------------------------------------------------------------------
4155 #
4156 # GetJulianDayFromEraYearMonthWeekDay --
4157 #
4158 # Determines the Julian Day number corresponding to the nth
4159 # given day-of-the-week in a given month.
4160 #
4161 # Parameters:
4162 # date - Dictionary containing the keys, 'era', 'year', 'month'
4163 # 'weekOfMonth', 'dayOfWeek', and 'dayOfWeekInMonth'.
4164 # changeover - Julian Day of adoption of the Gregorian calendar
4165 #
4166 # Results:
4167 # Returns the given dictionary, augmented with a 'julianDay' key.
4168 #
4169 # Side effects:
4170 # None.
4171 #
4172 # Bugs:
4173 # This code needs to be moved to the C layer.
4174 #
4175 #----------------------------------------------------------------------
4179 # Come up with a reference day; either the zeroeth day of the
4180 # given month (dayOfWeekInMonth >= 0) or the seventh day of the
4181 # following month (dayOfWeekInMonth < 0)
4188 dict incr date2 month
4190 }
4198 }
4200 #----------------------------------------------------------------------
4201 #
4202 # IsGregorianLeapYear --
4203 #
4204 # Determines whether a given date represents a leap year in the
4205 # Gregorian calendar.
4206 #
4207 # Parameters:
4208 # date -- The date to test. The fields, 'era', 'year' and 'gregorian'
4209 # must be set.
4210 #
4211 # Results:
4212 # Returns 1 if the year is a leap year, 0 otherwise.
4213 #
4214 # Side effects:
4215 # None.
4216 #
4217 #----------------------------------------------------------------------
4222 BCE {
4224 }
4225 CE {
4227 }
4228 }
4239 }
4241 }
4243 #----------------------------------------------------------------------
4244 #
4245 # WeekdayOnOrBefore --
4246 #
4247 # Determine the nearest day of week (given by the 'weekday'
4248 # parameter, Sunday==0) on or before a given Julian Day.
4249 #
4250 # Parameters:
4251 # weekday -- Day of the week
4252 # j -- Julian Day number
4253 #
4254 # Results:
4255 # Returns the Julian Day Number of the desired date.
4256 #
4257 # Side effects:
4258 # None.
4259 #
4260 #----------------------------------------------------------------------
4267 }
4269 #----------------------------------------------------------------------
4270 #
4271 # BSearch --
4272 #
4273 # Service procedure that does binary search in several places
4274 # inside the 'clock' command.
4275 #
4276 # Parameters:
4277 # list - List of lists, sorted in ascending order by the
4278 # first elements
4279 # key - Value to search for
4280 #
4281 # Results:
4282 # Returns the index of the greatest element in $list that is less
4283 # than or equal to $key.
4284 #
4285 # Side effects:
4286 # None.
4287 #
4288 #----------------------------------------------------------------------
4294 }
4297 }
4304 # At this point, we know that
4305 # $k >= [lindex $list $l 0]
4306 # Either $u == [llength $list] or else $k < [lindex $list $u+1 0]
4307 # We find the midpoint of the interval {l,u} rounded UP, compare
4308 # against it, and set l or u to maintain the invariant. Note
4309 # that the interval shrinks at each step, guaranteeing convergence.
4316 }
4317 }
4320 }
4322 #----------------------------------------------------------------------
4323 #
4324 # clock add --
4325 #
4326 # Adds an offset to a given time.
4327 #
4328 # Syntax:
4329 # clock add clockval ?count unit?... ?-option value?
4330 #
4331 # Parameters:
4332 # clockval -- Starting time value
4333 # count -- Amount of a unit of time to add
4334 # unit -- Unit of time to add, must be one of:
4335 # years year months month weeks week
4336 # days day hours hour minutes minute
4337 # seconds second
4338 #
4339 # Options:
4340 # -gmt BOOLEAN
4341 # (Deprecated) Flag synonymous with '-timezone :GMT'
4342 # -timezone ZONE
4343 # Name of the time zone in which calculations are to be done.
4344 # -locale NAME
4345 # Name of the locale in which calculations are to be done.
4346 # Used to determine the Gregorian change date.
4347 #
4348 # Results:
4349 # Returns the given time adjusted by the given offset(s) in
4350 # order.
4351 #
4352 # Notes:
4353 # It is possible that adding a number of months or years will adjust
4354 # the day of the month as well. For instance, the time at
4355 # one month after 31 January is either 28 or 29 February, because
4356 # February has fewer than 31 days.
4357 #
4358 #----------------------------------------------------------------------
4366 "wrong \# args: should be\
4369 }
4372 }
4376 set locale c
4391 }
4394 }
4398 }
4403 must be -gmt, -locale or -timezone"
4404 }
4405 }
4406 }
4407 }
4409 # Check options for validity
4414 "cannot use -gmt and -timezone in same call"
4415 }
4419 }
4426 }
4427 }
4429 EnterLocale $locale oldLocale
4436 }
4448 }
4452 }
4457 }
4461 }
4465 }
4468 }
4471 }
4479 }
4480 }
4481 }
4484 # Restore the locale
4487 mclocale $oldLocale
4488 }
4493 }
4497 }
4499 }
4501 #----------------------------------------------------------------------
4502 #
4503 # AddMonths --
4504 #
4505 # Add a given number of months to a given clock value in a given
4506 # time zone.
4507 #
4508 # Parameters:
4509 # months - Number of months to add (may be negative)
4510 # clockval - Seconds since the epoch before the operation
4511 # timezone - Time zone in which the operation is to be performed
4512 #
4513 # Results:
4514 # Returns the new clock value as a number of seconds since
4515 # the epoch.
4516 #
4517 # Side effects:
4518 # None.
4519 #
4520 #----------------------------------------------------------------------
4524 variable DaysInRomanMonthInCommonYear
4525 variable DaysInRomanMonthInLeapYear
4526 variable TZData
4528 # Convert the time to year, month, day, and fraction of day.
4535 # Add the requisite number of months
4545 # If the date doesn't exist in the current month, repair it
4551 }
4554 }
4556 # Reconvert to a number of seconds
4570 }
4572 #----------------------------------------------------------------------
4573 #
4574 # AddDays --
4575 #
4576 # Add a given number of days to a given clock value in a given
4577 # time zone.
4578 #
4579 # Parameters:
4580 # days - Number of days to add (may be negative)
4581 # clockval - Seconds since the epoch before the operation
4582 # timezone - Time zone in which the operation is to be performed
4583 # changeover - Julian Day on which the Gregorian calendar was adopted
4584 # in the target locale.
4585 #
4586 # Results:
4587 # Returns the new clock value as a number of seconds since
4588 # the epoch.
4589 #
4590 # Side effects:
4591 # None.
4592 #
4593 #----------------------------------------------------------------------
4597 variable TZData
4599 # Convert the time to Julian Day
4606 # Add the requisite number of days
4610 # Reconvert to a number of seconds
4621 }
4623 #----------------------------------------------------------------------
4624 #
4625 # mc --
4626 #
4627 # Wrapper around ::msgcat::mc that caches the result according
4628 # to the locale.
4629 #
4630 # Parameters:
4631 # Accepts the name of the message to retrieve.
4632 #
4633 # Results:
4634 # Returns the message text.
4635 #
4636 # Side effects:
4637 # Caches the message text.
4638 #
4639 # Notes:
4640 # Only the single-argument version of [mc] is supported.
4641 #
4642 #----------------------------------------------------------------------
4645 variable McLoaded
4653 }
4654 }
4656 #----------------------------------------------------------------------
4657 #
4658 # ClearCaches --
4659 #
4660 # Clears all caches to reclaim the memory used in [clock]
4661 #
4662 # Parameters:
4663 # None.
4664 #
4665 # Results:
4666 # None.
4667 #
4668 # Side effects:
4669 # Caches are cleared.
4670 #
4671 #----------------------------------------------------------------------
4675 variable FormatProc
4676 variable LocaleNumeralCache
4677 variable McLoaded
4678 variable CachedSystemTimeZone
4679 variable TimeZoneBad
4683 }
4686 }
4693 InitTZData
4695 }