You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4547 lines
126 KiB
4547 lines
126 KiB
#----------------------------------------------------------------------
|
|
#
|
|
# clock.tcl --
|
|
#
|
|
# This file implements the portions of the [clock] ensemble that are
|
|
# coded in Tcl. Refer to the users' manual to see the description of
|
|
# the [clock] command and its subcommands.
|
|
#
|
|
#
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# Copyright (c) 2004,2005,2006,2007 by Kevin B. Kenny
|
|
# See the file "license.terms" for information on usage and redistribution
|
|
# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
|
|
#
|
|
#----------------------------------------------------------------------
|
|
|
|
# We must have message catalogs that support the root locale, and we need
|
|
# access to the Registry on Windows systems.
|
|
|
|
uplevel \#0 {
|
|
package require msgcat 1.6
|
|
if { $::tcl_platform(platform) eq {windows} } {
|
|
if { [catch { package require registry 1.1 }] } {
|
|
namespace eval ::tcl::clock [list variable NoRegistry {}]
|
|
}
|
|
}
|
|
}
|
|
|
|
# Put the library directory into the namespace for the ensemble so that the
|
|
# library code can find message catalogs and time zone definition files.
|
|
|
|
namespace eval ::tcl::clock \
|
|
[list variable LibDir [file dirname [info script]]]
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# clock --
|
|
#
|
|
# Manipulate times.
|
|
#
|
|
# The 'clock' command manipulates time. Refer to the user documentation for
|
|
# the available subcommands and what they do.
|
|
#
|
|
#----------------------------------------------------------------------
|
|
|
|
namespace eval ::tcl::clock {
|
|
|
|
# Export the subcommands
|
|
|
|
namespace export format
|
|
namespace export clicks
|
|
namespace export microseconds
|
|
namespace export milliseconds
|
|
namespace export scan
|
|
namespace export seconds
|
|
namespace export add
|
|
|
|
# Import the message catalog commands that we use.
|
|
|
|
namespace import ::msgcat::mcload
|
|
namespace import ::msgcat::mclocale
|
|
namespace import ::msgcat::mc
|
|
namespace import ::msgcat::mcpackagelocale
|
|
|
|
}
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# ::tcl::clock::Initialize --
|
|
#
|
|
# Finish initializing the 'clock' subsystem
|
|
#
|
|
# Results:
|
|
# None.
|
|
#
|
|
# Side effects:
|
|
# Namespace variable in the 'clock' subsystem are initialized.
|
|
#
|
|
# The '::tcl::clock::Initialize' procedure initializes the namespace variables
|
|
# and root locale message catalog for the 'clock' subsystem. It is broken
|
|
# into a procedure rather than simply evaluated as a script so that it will be
|
|
# able to use local variables, avoiding the dangers of 'creative writing' as
|
|
# in Bug 1185933.
|
|
#
|
|
#----------------------------------------------------------------------
|
|
|
|
proc ::tcl::clock::Initialize {} {
|
|
|
|
rename ::tcl::clock::Initialize {}
|
|
|
|
variable LibDir
|
|
|
|
# Define the Greenwich time zone
|
|
|
|
proc InitTZData {} {
|
|
variable TZData
|
|
array unset TZData
|
|
set TZData(:Etc/GMT) {
|
|
{-9223372036854775808 0 0 GMT}
|
|
}
|
|
set TZData(:GMT) $TZData(:Etc/GMT)
|
|
set TZData(:Etc/UTC) {
|
|
{-9223372036854775808 0 0 UTC}
|
|
}
|
|
set TZData(:UTC) $TZData(:Etc/UTC)
|
|
set TZData(:localtime) {}
|
|
}
|
|
InitTZData
|
|
|
|
mcpackagelocale set {}
|
|
::msgcat::mcpackageconfig set mcfolder [file join $LibDir msgs]
|
|
::msgcat::mcpackageconfig set unknowncmd ""
|
|
::msgcat::mcpackageconfig set changecmd ChangeCurrentLocale
|
|
|
|
# Define the message catalog for the root locale.
|
|
|
|
::msgcat::mcmset {} {
|
|
AM {am}
|
|
BCE {B.C.E.}
|
|
CE {C.E.}
|
|
DATE_FORMAT {%m/%d/%Y}
|
|
DATE_TIME_FORMAT {%a %b %e %H:%M:%S %Y}
|
|
DAYS_OF_WEEK_ABBREV {
|
|
Sun Mon Tue Wed Thu Fri Sat
|
|
}
|
|
DAYS_OF_WEEK_FULL {
|
|
Sunday Monday Tuesday Wednesday Thursday Friday Saturday
|
|
}
|
|
GREGORIAN_CHANGE_DATE 2299161
|
|
LOCALE_DATE_FORMAT {%m/%d/%Y}
|
|
LOCALE_DATE_TIME_FORMAT {%a %b %e %H:%M:%S %Y}
|
|
LOCALE_ERAS {}
|
|
LOCALE_NUMERALS {
|
|
00 01 02 03 04 05 06 07 08 09
|
|
10 11 12 13 14 15 16 17 18 19
|
|
20 21 22 23 24 25 26 27 28 29
|
|
30 31 32 33 34 35 36 37 38 39
|
|
40 41 42 43 44 45 46 47 48 49
|
|
50 51 52 53 54 55 56 57 58 59
|
|
60 61 62 63 64 65 66 67 68 69
|
|
70 71 72 73 74 75 76 77 78 79
|
|
80 81 82 83 84 85 86 87 88 89
|
|
90 91 92 93 94 95 96 97 98 99
|
|
}
|
|
LOCALE_TIME_FORMAT {%H:%M:%S}
|
|
LOCALE_YEAR_FORMAT {%EC%Ey}
|
|
MONTHS_ABBREV {
|
|
Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec
|
|
}
|
|
MONTHS_FULL {
|
|
January February March
|
|
April May June
|
|
July August September
|
|
October November December
|
|
}
|
|
PM {pm}
|
|
TIME_FORMAT {%H:%M:%S}
|
|
TIME_FORMAT_12 {%I:%M:%S %P}
|
|
TIME_FORMAT_24 {%H:%M}
|
|
TIME_FORMAT_24_SECS {%H:%M:%S}
|
|
}
|
|
|
|
# Define a few Gregorian change dates for other locales. In most cases
|
|
# the change date follows a language, because a nation's colonies changed
|
|
# at the same time as the nation itself. In many cases, different
|
|
# national boundaries existed; the dominating rule is to follow the
|
|
# nation's capital.
|
|
|
|
# Italy, Spain, Portugal, Poland
|
|
|
|
::msgcat::mcset it GREGORIAN_CHANGE_DATE 2299161
|
|
::msgcat::mcset es GREGORIAN_CHANGE_DATE 2299161
|
|
::msgcat::mcset pt GREGORIAN_CHANGE_DATE 2299161
|
|
::msgcat::mcset pl GREGORIAN_CHANGE_DATE 2299161
|
|
|
|
# France, Austria
|
|
|
|
::msgcat::mcset fr GREGORIAN_CHANGE_DATE 2299227
|
|
|
|
# For Belgium, we follow Southern Netherlands; Liege Diocese changed
|
|
# several weeks later.
|
|
|
|
::msgcat::mcset fr_BE GREGORIAN_CHANGE_DATE 2299238
|
|
::msgcat::mcset nl_BE GREGORIAN_CHANGE_DATE 2299238
|
|
|
|
# Austria
|
|
|
|
::msgcat::mcset de_AT GREGORIAN_CHANGE_DATE 2299527
|
|
|
|
# Hungary
|
|
|
|
::msgcat::mcset hu GREGORIAN_CHANGE_DATE 2301004
|
|
|
|
# Germany, Norway, Denmark (Catholic Germany changed earlier)
|
|
|
|
::msgcat::mcset de_DE GREGORIAN_CHANGE_DATE 2342032
|
|
::msgcat::mcset nb GREGORIAN_CHANGE_DATE 2342032
|
|
::msgcat::mcset nn GREGORIAN_CHANGE_DATE 2342032
|
|
::msgcat::mcset no GREGORIAN_CHANGE_DATE 2342032
|
|
::msgcat::mcset da GREGORIAN_CHANGE_DATE 2342032
|
|
|
|
# Holland (Brabant, Gelderland, Flanders, Friesland, etc. changed at
|
|
# various times)
|
|
|
|
::msgcat::mcset nl GREGORIAN_CHANGE_DATE 2342165
|
|
|
|
# Protestant Switzerland (Catholic cantons changed earlier)
|
|
|
|
::msgcat::mcset fr_CH GREGORIAN_CHANGE_DATE 2361342
|
|
::msgcat::mcset it_CH GREGORIAN_CHANGE_DATE 2361342
|
|
::msgcat::mcset de_CH GREGORIAN_CHANGE_DATE 2361342
|
|
|
|
# English speaking countries
|
|
|
|
::msgcat::mcset en GREGORIAN_CHANGE_DATE 2361222
|
|
|
|
# Sweden (had several changes onto and off of the Gregorian calendar)
|
|
|
|
::msgcat::mcset sv GREGORIAN_CHANGE_DATE 2361390
|
|
|
|
# Russia
|
|
|
|
::msgcat::mcset ru GREGORIAN_CHANGE_DATE 2421639
|
|
|
|
# Romania (Transylvania changed earler - perhaps de_RO should show the
|
|
# earlier date?)
|
|
|
|
::msgcat::mcset ro GREGORIAN_CHANGE_DATE 2422063
|
|
|
|
# Greece
|
|
|
|
::msgcat::mcset el GREGORIAN_CHANGE_DATE 2423480
|
|
|
|
#------------------------------------------------------------------
|
|
#
|
|
# CONSTANTS
|
|
#
|
|
#------------------------------------------------------------------
|
|
|
|
# Paths at which binary time zone data for the Olson libraries are known
|
|
# to reside on various operating systems
|
|
|
|
variable ZoneinfoPaths {}
|
|
foreach path {
|
|
/usr/share/zoneinfo
|
|
/usr/share/lib/zoneinfo
|
|
/usr/lib/zoneinfo
|
|
/usr/local/etc/zoneinfo
|
|
} {
|
|
if { [file isdirectory $path] } {
|
|
lappend ZoneinfoPaths $path
|
|
}
|
|
}
|
|
|
|
# Define the directories for time zone data and message catalogs.
|
|
|
|
variable DataDir [file join $LibDir tzdata]
|
|
|
|
# Number of days in the months, in common years and leap years.
|
|
|
|
variable DaysInRomanMonthInCommonYear \
|
|
{ 31 28 31 30 31 30 31 31 30 31 30 31 }
|
|
variable DaysInRomanMonthInLeapYear \
|
|
{ 31 29 31 30 31 30 31 31 30 31 30 31 }
|
|
variable DaysInPriorMonthsInCommonYear [list 0]
|
|
variable DaysInPriorMonthsInLeapYear [list 0]
|
|
set i 0
|
|
foreach j $DaysInRomanMonthInCommonYear {
|
|
lappend DaysInPriorMonthsInCommonYear [incr i $j]
|
|
}
|
|
set i 0
|
|
foreach j $DaysInRomanMonthInLeapYear {
|
|
lappend DaysInPriorMonthsInLeapYear [incr i $j]
|
|
}
|
|
|
|
# Another epoch (Hi, Jeff!)
|
|
|
|
variable Roddenberry 1946
|
|
|
|
# Integer ranges
|
|
|
|
variable MINWIDE -9223372036854775808
|
|
variable MAXWIDE 9223372036854775807
|
|
|
|
# Day before Leap Day
|
|
|
|
variable FEB_28 58
|
|
|
|
# Translation table to map Windows TZI onto cities, so that the Olson
|
|
# rules can apply. In some cases the mapping is ambiguous, so it's wise
|
|
# to specify $::env(TCL_TZ) rather than simply depending on the system
|
|
# time zone.
|
|
|
|
# The keys are long lists of values obtained from the time zone
|
|
# information in the Registry. In order, the list elements are:
|
|
# Bias StandardBias DaylightBias
|
|
# StandardDate.wYear StandardDate.wMonth StandardDate.wDayOfWeek
|
|
# StandardDate.wDay StandardDate.wHour StandardDate.wMinute
|
|
# StandardDate.wSecond StandardDate.wMilliseconds
|
|
# DaylightDate.wYear DaylightDate.wMonth DaylightDate.wDayOfWeek
|
|
# DaylightDate.wDay DaylightDate.wHour DaylightDate.wMinute
|
|
# DaylightDate.wSecond DaylightDate.wMilliseconds
|
|
# The values are the names of time zones where those rules apply. There
|
|
# is considerable ambiguity in certain zones; an attempt has been made to
|
|
# make a reasonable guess, but this table needs to be taken with a grain
|
|
# of salt.
|
|
|
|
variable WinZoneInfo [dict create {*}{
|
|
{-43200 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :Pacific/Kwajalein
|
|
{-39600 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :Pacific/Midway
|
|
{-36000 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :Pacific/Honolulu
|
|
{-32400 0 3600 0 11 0 1 2 0 0 0 0 3 0 2 2 0 0 0} :America/Anchorage
|
|
{-28800 0 3600 0 11 0 1 2 0 0 0 0 3 0 2 2 0 0 0} :America/Los_Angeles
|
|
{-28800 0 3600 0 10 0 5 2 0 0 0 0 4 0 1 2 0 0 0} :America/Tijuana
|
|
{-25200 0 3600 0 11 0 1 2 0 0 0 0 3 0 2 2 0 0 0} :America/Denver
|
|
{-25200 0 3600 0 10 0 5 2 0 0 0 0 4 0 1 2 0 0 0} :America/Chihuahua
|
|
{-25200 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :America/Phoenix
|
|
{-21600 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :America/Regina
|
|
{-21600 0 3600 0 11 0 1 2 0 0 0 0 3 0 2 2 0 0 0} :America/Chicago
|
|
{-21600 0 3600 0 10 0 5 2 0 0 0 0 4 0 1 2 0 0 0} :America/Mexico_City
|
|
{-18000 0 3600 0 11 0 1 2 0 0 0 0 3 0 2 2 0 0 0} :America/New_York
|
|
{-18000 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :America/Indianapolis
|
|
{-14400 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :America/Caracas
|
|
{-14400 0 3600 0 3 6 2 23 59 59 999 0 10 6 2 23 59 59 999}
|
|
:America/Santiago
|
|
{-14400 0 3600 0 2 0 5 2 0 0 0 0 11 0 1 2 0 0 0} :America/Manaus
|
|
{-14400 0 3600 0 11 0 1 2 0 0 0 0 3 0 2 2 0 0 0} :America/Halifax
|
|
{-12600 0 3600 0 10 0 5 2 0 0 0 0 4 0 1 2 0 0 0} :America/St_Johns
|
|
{-10800 0 3600 0 2 0 2 2 0 0 0 0 10 0 3 2 0 0 0} :America/Sao_Paulo
|
|
{-10800 0 3600 0 10 0 5 2 0 0 0 0 4 0 1 2 0 0 0} :America/Godthab
|
|
{-10800 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :America/Buenos_Aires
|
|
{-10800 0 3600 0 2 0 5 2 0 0 0 0 11 0 1 2 0 0 0} :America/Bahia
|
|
{-10800 0 3600 0 3 0 2 2 0 0 0 0 10 0 1 2 0 0 0} :America/Montevideo
|
|
{-7200 0 3600 0 9 0 5 2 0 0 0 0 3 0 5 2 0 0 0} :America/Noronha
|
|
{-3600 0 3600 0 10 0 5 3 0 0 0 0 3 0 5 2 0 0 0} :Atlantic/Azores
|
|
{-3600 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :Atlantic/Cape_Verde
|
|
{0 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :UTC
|
|
{0 0 3600 0 10 0 5 2 0 0 0 0 3 0 5 1 0 0 0} :Europe/London
|
|
{3600 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :Africa/Kinshasa
|
|
{3600 0 3600 0 10 0 5 3 0 0 0 0 3 0 5 2 0 0 0} :CET
|
|
{7200 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :Africa/Harare
|
|
{7200 0 3600 0 9 4 5 23 59 59 0 0 4 4 5 23 59 59 0}
|
|
:Africa/Cairo
|
|
{7200 0 3600 0 10 0 5 4 0 0 0 0 3 0 5 3 0 0 0} :Europe/Helsinki
|
|
{7200 0 3600 0 9 0 3 2 0 0 0 0 3 5 5 2 0 0 0} :Asia/Jerusalem
|
|
{7200 0 3600 0 9 0 5 1 0 0 0 0 3 0 5 0 0 0 0} :Europe/Bucharest
|
|
{7200 0 3600 0 10 0 5 3 0 0 0 0 3 0 5 2 0 0 0} :Europe/Athens
|
|
{7200 0 3600 0 9 5 5 1 0 0 0 0 3 4 5 0 0 0 0} :Asia/Amman
|
|
{7200 0 3600 0 10 6 5 23 59 59 999 0 3 0 5 0 0 0 0}
|
|
:Asia/Beirut
|
|
{7200 0 -3600 0 4 0 1 2 0 0 0 0 9 0 1 2 0 0 0} :Africa/Windhoek
|
|
{10800 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :Asia/Riyadh
|
|
{10800 0 3600 0 10 0 1 4 0 0 0 0 4 0 1 3 0 0 0} :Asia/Baghdad
|
|
{10800 0 3600 0 10 0 5 3 0 0 0 0 3 0 5 2 0 0 0} :Europe/Moscow
|
|
{12600 0 3600 0 9 2 4 2 0 0 0 0 3 0 1 2 0 0 0} :Asia/Tehran
|
|
{14400 0 3600 0 10 0 5 5 0 0 0 0 3 0 5 4 0 0 0} :Asia/Baku
|
|
{14400 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :Asia/Muscat
|
|
{14400 0 3600 0 10 0 5 3 0 0 0 0 3 0 5 2 0 0 0} :Asia/Tbilisi
|
|
{16200 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :Asia/Kabul
|
|
{18000 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :Asia/Karachi
|
|
{18000 0 3600 0 10 0 5 3 0 0 0 0 3 0 5 2 0 0 0} :Asia/Yekaterinburg
|
|
{19800 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :Asia/Calcutta
|
|
{20700 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :Asia/Katmandu
|
|
{21600 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :Asia/Dhaka
|
|
{21600 0 3600 0 10 0 5 3 0 0 0 0 3 0 5 2 0 0 0} :Asia/Novosibirsk
|
|
{23400 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :Asia/Rangoon
|
|
{25200 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :Asia/Bangkok
|
|
{25200 0 3600 0 10 0 5 3 0 0 0 0 3 0 5 2 0 0 0} :Asia/Krasnoyarsk
|
|
{28800 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :Asia/Chongqing
|
|
{28800 0 3600 0 10 0 5 3 0 0 0 0 3 0 5 2 0 0 0} :Asia/Irkutsk
|
|
{32400 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :Asia/Tokyo
|
|
{32400 0 3600 0 10 0 5 3 0 0 0 0 3 0 5 2 0 0 0} :Asia/Yakutsk
|
|
{34200 0 3600 0 3 0 5 3 0 0 0 0 10 0 5 2 0 0 0} :Australia/Adelaide
|
|
{34200 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :Australia/Darwin
|
|
{36000 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :Australia/Brisbane
|
|
{36000 0 3600 0 10 0 5 3 0 0 0 0 3 0 5 2 0 0 0} :Asia/Vladivostok
|
|
{36000 0 3600 0 3 0 5 3 0 0 0 0 10 0 1 2 0 0 0} :Australia/Hobart
|
|
{36000 0 3600 0 3 0 5 3 0 0 0 0 10 0 5 2 0 0 0} :Australia/Sydney
|
|
{39600 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :Pacific/Noumea
|
|
{43200 0 3600 0 3 0 3 3 0 0 0 0 10 0 1 2 0 0 0} :Pacific/Auckland
|
|
{43200 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :Pacific/Fiji
|
|
{46800 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :Pacific/Tongatapu
|
|
}]
|
|
|
|
# Groups of fields that specify the date, priorities, and code bursts that
|
|
# determine Julian Day Number given those groups. The code in [clock
|
|
# scan] will choose the highest priority (lowest numbered) set of fields
|
|
# that determines the date.
|
|
|
|
variable DateParseActions {
|
|
|
|
{ seconds } 0 {}
|
|
|
|
{ julianDay } 1 {}
|
|
|
|
{ era century yearOfCentury month dayOfMonth } 2 {
|
|
dict set date year [expr { 100 * [dict get $date century]
|
|
+ [dict get $date yearOfCentury] }]
|
|
set date [GetJulianDayFromEraYearMonthDay $date[set date {}] \
|
|
$changeover]
|
|
}
|
|
{ era century yearOfCentury dayOfYear } 2 {
|
|
dict set date year [expr { 100 * [dict get $date century]
|
|
+ [dict get $date yearOfCentury] }]
|
|
set date [GetJulianDayFromEraYearDay $date[set date {}] \
|
|
$changeover]
|
|
}
|
|
|
|
{ century yearOfCentury month dayOfMonth } 3 {
|
|
dict set date era CE
|
|
dict set date year [expr { 100 * [dict get $date century]
|
|
+ [dict get $date yearOfCentury] }]
|
|
set date [GetJulianDayFromEraYearMonthDay $date[set date {}] \
|
|
$changeover]
|
|
}
|
|
{ century yearOfCentury dayOfYear } 3 {
|
|
dict set date era CE
|
|
dict set date year [expr { 100 * [dict get $date century]
|
|
+ [dict get $date yearOfCentury] }]
|
|
set date [GetJulianDayFromEraYearDay $date[set date {}] \
|
|
$changeover]
|
|
}
|
|
{ iso8601Century iso8601YearOfCentury iso8601Week dayOfWeek } 3 {
|
|
dict set date era CE
|
|
dict set date iso8601Year \
|
|
[expr { 100 * [dict get $date iso8601Century]
|
|
+ [dict get $date iso8601YearOfCentury] }]
|
|
set date [GetJulianDayFromEraYearWeekDay $date[set date {}] \
|
|
$changeover]
|
|
}
|
|
|
|
{ yearOfCentury month dayOfMonth } 4 {
|
|
set date [InterpretTwoDigitYear $date[set date {}] $baseTime]
|
|
dict set date era CE
|
|
set date [GetJulianDayFromEraYearMonthDay $date[set date {}] \
|
|
$changeover]
|
|
}
|
|
{ yearOfCentury dayOfYear } 4 {
|
|
set date [InterpretTwoDigitYear $date[set date {}] $baseTime]
|
|
dict set date era CE
|
|
set date [GetJulianDayFromEraYearDay $date[set date {}] \
|
|
$changeover]
|
|
}
|
|
{ iso8601YearOfCentury iso8601Week dayOfWeek } 4 {
|
|
set date [InterpretTwoDigitYear \
|
|
$date[set date {}] $baseTime \
|
|
iso8601YearOfCentury iso8601Year]
|
|
dict set date era CE
|
|
set date [GetJulianDayFromEraYearWeekDay $date[set date {}] \
|
|
$changeover]
|
|
}
|
|
|
|
{ month dayOfMonth } 5 {
|
|
set date [AssignBaseYear $date[set date {}] \
|
|
$baseTime $timeZone $changeover]
|
|
set date [GetJulianDayFromEraYearMonthDay $date[set date {}] \
|
|
$changeover]
|
|
}
|
|
{ dayOfYear } 5 {
|
|
set date [AssignBaseYear $date[set date {}] \
|
|
$baseTime $timeZone $changeover]
|
|
set date [GetJulianDayFromEraYearDay $date[set date {}] \
|
|
$changeover]
|
|
}
|
|
{ iso8601Week dayOfWeek } 5 {
|
|
set date [AssignBaseIso8601Year $date[set date {}] \
|
|
$baseTime $timeZone $changeover]
|
|
set date [GetJulianDayFromEraYearWeekDay $date[set date {}] \
|
|
$changeover]
|
|
}
|
|
|
|
{ dayOfMonth } 6 {
|
|
set date [AssignBaseMonth $date[set date {}] \
|
|
$baseTime $timeZone $changeover]
|
|
set date [GetJulianDayFromEraYearMonthDay $date[set date {}] \
|
|
$changeover]
|
|
}
|
|
|
|
{ dayOfWeek } 7 {
|
|
set date [AssignBaseWeek $date[set date {}] \
|
|
$baseTime $timeZone $changeover]
|
|
set date [GetJulianDayFromEraYearWeekDay $date[set date {}] \
|
|
$changeover]
|
|
}
|
|
|
|
{} 8 {
|
|
set date [AssignBaseJulianDay $date[set date {}] \
|
|
$baseTime $timeZone $changeover]
|
|
}
|
|
}
|
|
|
|
# Groups of fields that specify time of day, priorities, and code that
|
|
# processes them
|
|
|
|
variable TimeParseActions {
|
|
|
|
seconds 1 {}
|
|
|
|
{ hourAMPM minute second amPmIndicator } 2 {
|
|
dict set date secondOfDay [InterpretHMSP $date]
|
|
}
|
|
{ hour minute second } 2 {
|
|
dict set date secondOfDay [InterpretHMS $date]
|
|
}
|
|
|
|
{ hourAMPM minute amPmIndicator } 3 {
|
|
dict set date second 0
|
|
dict set date secondOfDay [InterpretHMSP $date]
|
|
}
|
|
{ hour minute } 3 {
|
|
dict set date second 0
|
|
dict set date secondOfDay [InterpretHMS $date]
|
|
}
|
|
|
|
{ hourAMPM amPmIndicator } 4 {
|
|
dict set date minute 0
|
|
dict set date second 0
|
|
dict set date secondOfDay [InterpretHMSP $date]
|
|
}
|
|
{ hour } 4 {
|
|
dict set date minute 0
|
|
dict set date second 0
|
|
dict set date secondOfDay [InterpretHMS $date]
|
|
}
|
|
|
|
{ } 5 {
|
|
dict set date secondOfDay 0
|
|
}
|
|
}
|
|
|
|
# Legacy time zones, used primarily for parsing RFC822 dates.
|
|
|
|
variable LegacyTimeZone [dict create \
|
|
gmt +0000 \
|
|
ut +0000 \
|
|
utc +0000 \
|
|
bst +0100 \
|
|
wet +0000 \
|
|
wat -0100 \
|
|
at -0200 \
|
|
nft -0330 \
|
|
nst -0330 \
|
|
ndt -0230 \
|
|
ast -0400 \
|
|
adt -0300 \
|
|
est -0500 \
|
|
edt -0400 \
|
|
cst -0600 \
|
|
cdt -0500 \
|
|
mst -0700 \
|
|
mdt -0600 \
|
|
pst -0800 \
|
|
pdt -0700 \
|
|
yst -0900 \
|
|
ydt -0800 \
|
|
hst -1000 \
|
|
hdt -0900 \
|
|
cat -1000 \
|
|
ahst -1000 \
|
|
nt -1100 \
|
|
idlw -1200 \
|
|
cet +0100 \
|
|
cest +0200 \
|
|
met +0100 \
|
|
mewt +0100 \
|
|
mest +0200 \
|
|
swt +0100 \
|
|
sst +0200 \
|
|
fwt +0100 \
|
|
fst +0200 \
|
|
eet +0200 \
|
|
eest +0300 \
|
|
bt +0300 \
|
|
it +0330 \
|
|
zp4 +0400 \
|
|
zp5 +0500 \
|
|
ist +0530 \
|
|
zp6 +0600 \
|
|
wast +0700 \
|
|
wadt +0800 \
|
|
jt +0730 \
|
|
cct +0800 \
|
|
jst +0900 \
|
|
kst +0900 \
|
|
cast +0930 \
|
|
jdt +1000 \
|
|
kdt +1000 \
|
|
cadt +1030 \
|
|
east +1000 \
|
|
eadt +1030 \
|
|
gst +1000 \
|
|
nzt +1200 \
|
|
nzst +1200 \
|
|
nzdt +1300 \
|
|
idle +1200 \
|
|
a +0100 \
|
|
b +0200 \
|
|
c +0300 \
|
|
d +0400 \
|
|
e +0500 \
|
|
f +0600 \
|
|
g +0700 \
|
|
h +0800 \
|
|
i +0900 \
|
|
k +1000 \
|
|
l +1100 \
|
|
m +1200 \
|
|
n -0100 \
|
|
o -0200 \
|
|
p -0300 \
|
|
q -0400 \
|
|
r -0500 \
|
|
s -0600 \
|
|
t -0700 \
|
|
u -0800 \
|
|
v -0900 \
|
|
w -1000 \
|
|
x -1100 \
|
|
y -1200 \
|
|
z +0000 \
|
|
]
|
|
|
|
# Caches
|
|
|
|
variable LocaleNumeralCache {}; # Dictionary whose keys are locale
|
|
# names and whose values are pairs
|
|
# comprising regexes matching numerals
|
|
# in the given locales and dictionaries
|
|
# mapping the numerals to their numeric
|
|
# values.
|
|
# variable CachedSystemTimeZone; # If 'CachedSystemTimeZone' exists,
|
|
# it contains the value of the
|
|
# system time zone, as determined from
|
|
# the environment.
|
|
variable TimeZoneBad {}; # Dictionary whose keys are time zone
|
|
# names and whose values are 1 if
|
|
# the time zone is unknown and 0
|
|
# if it is known.
|
|
variable TZData; # Array whose keys are time zone names
|
|
# and whose values are lists of quads
|
|
# comprising start time, UTC offset,
|
|
# Daylight Saving Time indicator, and
|
|
# time zone abbreviation.
|
|
variable FormatProc; # Array mapping format group
|
|
# and locale to the name of a procedure
|
|
# that renders the given format
|
|
}
|
|
::tcl::clock::Initialize
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# clock format --
|
|
#
|
|
# Formats a count of seconds since the Posix Epoch as a time of day.
|
|
#
|
|
# The 'clock format' command formats times of day for output. Refer to the
|
|
# user documentation to see what it does.
|
|
#
|
|
#----------------------------------------------------------------------
|
|
|
|
proc ::tcl::clock::format { args } {
|
|
|
|
variable FormatProc
|
|
variable TZData
|
|
|
|
lassign [ParseFormatArgs {*}$args] format locale timezone
|
|
set locale [string tolower $locale]
|
|
set clockval [lindex $args 0]
|
|
|
|
# Get the data for time changes in the given zone
|
|
|
|
if {$timezone eq ""} {
|
|
set timezone [GetSystemTimeZone]
|
|
}
|
|
if {![info exists TZData($timezone)]} {
|
|
if {[catch {SetupTimeZone $timezone} retval opts]} {
|
|
dict unset opts -errorinfo
|
|
return -options $opts $retval
|
|
}
|
|
}
|
|
|
|
# Build a procedure to format the result. Cache the built procedure's name
|
|
# in the 'FormatProc' array to avoid losing its internal representation,
|
|
# which contains the name resolution.
|
|
|
|
set procName formatproc'$format'$locale
|
|
set procName [namespace current]::[string map {: {\:} \\ {\\}} $procName]
|
|
if {[info exists FormatProc($procName)]} {
|
|
set procName $FormatProc($procName)
|
|
} else {
|
|
set FormatProc($procName) \
|
|
[ParseClockFormatFormat $procName $format $locale]
|
|
}
|
|
|
|
return [$procName $clockval $timezone]
|
|
|
|
}
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# ParseClockFormatFormat --
|
|
#
|
|
# Builds and caches a procedure that formats a time value.
|
|
#
|
|
# Parameters:
|
|
# format -- Format string to use
|
|
# locale -- Locale in which the format string is to be interpreted
|
|
#
|
|
# Results:
|
|
# Returns the name of the newly-built procedure.
|
|
#
|
|
#----------------------------------------------------------------------
|
|
|
|
proc ::tcl::clock::ParseClockFormatFormat {procName format locale} {
|
|
|
|
if {[namespace which $procName] ne {}} {
|
|
return $procName
|
|
}
|
|
|
|
# Map away the locale-dependent composite format groups
|
|
|
|
EnterLocale $locale
|
|
|
|
# Change locale if a fresh locale has been given on the command line.
|
|
|
|
try {
|
|
return [ParseClockFormatFormat2 $format $locale $procName]
|
|
} trap CLOCK {result opts} {
|
|
dict unset opts -errorinfo
|
|
return -options $opts $result
|
|
}
|
|
}
|
|
|
|
proc ::tcl::clock::ParseClockFormatFormat2 {format locale procName} {
|
|
set didLocaleEra 0
|
|
set didLocaleNumerals 0
|
|
set preFormatCode \
|
|
[string map [list @GREGORIAN_CHANGE_DATE@ \
|
|
[mc GREGORIAN_CHANGE_DATE]] \
|
|
{
|
|
variable TZData
|
|
set date [GetDateFields $clockval \
|
|
$TZData($timezone) \
|
|
@GREGORIAN_CHANGE_DATE@]
|
|
}]
|
|
set formatString {}
|
|
set substituents {}
|
|
set state {}
|
|
|
|
set format [LocalizeFormat $locale $format]
|
|
|
|
foreach char [split $format {}] {
|
|
switch -exact -- $state {
|
|
{} {
|
|
if { [string equal % $char] } {
|
|
set state percent
|
|
} else {
|
|
append formatString $char
|
|
}
|
|
}
|
|
percent { # Character following a '%' character
|
|
set state {}
|
|
switch -exact -- $char {
|
|
% { # A literal character, '%'
|
|
append formatString %%
|
|
}
|
|
a { # Day of week, abbreviated
|
|
append formatString %s
|
|
append substituents \
|
|
[string map \
|
|
[list @DAYS_OF_WEEK_ABBREV@ \
|
|
[list [mc DAYS_OF_WEEK_ABBREV]]] \
|
|
{ [lindex @DAYS_OF_WEEK_ABBREV@ \
|
|
[expr {[dict get $date dayOfWeek] \
|
|
% 7}]]}]
|
|
}
|
|
A { # Day of week, spelt out.
|
|
append formatString %s
|
|
append substituents \
|
|
[string map \
|
|
[list @DAYS_OF_WEEK_FULL@ \
|
|
[list [mc DAYS_OF_WEEK_FULL]]] \
|
|
{ [lindex @DAYS_OF_WEEK_FULL@ \
|
|
[expr {[dict get $date dayOfWeek] \
|
|
% 7}]]}]
|
|
}
|
|
b - h { # Name of month, abbreviated.
|
|
append formatString %s
|
|
append substituents \
|
|
[string map \
|
|
[list @MONTHS_ABBREV@ \
|
|
[list [mc MONTHS_ABBREV]]] \
|
|
{ [lindex @MONTHS_ABBREV@ \
|
|
[expr {[dict get $date month]-1}]]}]
|
|
}
|
|
B { # Name of month, spelt out
|
|
append formatString %s
|
|
append substituents \
|
|
[string map \
|
|
[list @MONTHS_FULL@ \
|
|
[list [mc MONTHS_FULL]]] \
|
|
{ [lindex @MONTHS_FULL@ \
|
|
[expr {[dict get $date month]-1}]]}]
|
|
}
|
|
C { # Century number
|
|
append formatString %02d
|
|
append substituents \
|
|
{ [expr {[dict get $date year] / 100}]}
|
|
}
|
|
d { # Day of month, with leading zero
|
|
append formatString %02d
|
|
append substituents { [dict get $date dayOfMonth]}
|
|
}
|
|
e { # Day of month, without leading zero
|
|
append formatString %2d
|
|
append substituents { [dict get $date dayOfMonth]}
|
|
}
|
|
E { # Format group in a locale-dependent
|
|
# alternative era
|
|
set state percentE
|
|
if {!$didLocaleEra} {
|
|
append preFormatCode \
|
|
[string map \
|
|
[list @LOCALE_ERAS@ \
|
|
[list [mc LOCALE_ERAS]]] \
|
|
{
|
|
set date [GetLocaleEra \
|
|
$date[set date {}] \
|
|
@LOCALE_ERAS@]}] \n
|
|
set didLocaleEra 1
|
|
}
|
|
if {!$didLocaleNumerals} {
|
|
append preFormatCode \
|
|
[list set localeNumerals \
|
|
[mc LOCALE_NUMERALS]] \n
|
|
set didLocaleNumerals 1
|
|
}
|
|
}
|
|
g { # Two-digit year relative to ISO8601
|
|
# week number
|
|
append formatString %02d
|
|
append substituents \
|
|
{ [expr { [dict get $date iso8601Year] % 100 }]}
|
|
}
|
|
G { # Four-digit year relative to ISO8601
|
|
# week number
|
|
append formatString %02d
|
|
append substituents { [dict get $date iso8601Year]}
|
|
}
|
|
H { # Hour in the 24-hour day, leading zero
|
|
append formatString %02d
|
|
append substituents \
|
|
{ [expr { [dict get $date localSeconds] \
|
|
/ 3600 % 24}]}
|
|
}
|
|
I { # Hour AM/PM, with leading zero
|
|
append formatString %02d
|
|
append substituents \
|
|
{ [expr { ( ( ( [dict get $date localSeconds] \
|
|
% 86400 ) \
|
|
+ 86400 \
|
|
- 3600 ) \
|
|
/ 3600 ) \
|
|
% 12 + 1 }] }
|
|
}
|
|
j { # Day of year (001-366)
|
|
append formatString %03d
|
|
append substituents { [dict get $date dayOfYear]}
|
|
}
|
|
J { # Julian Day Number
|
|
append formatString %07ld
|
|
append substituents { [dict get $date julianDay]}
|
|
}
|
|
k { # Hour (0-23), no leading zero
|
|
append formatString %2d
|
|
append substituents \
|
|
{ [expr { [dict get $date localSeconds]
|
|
/ 3600
|
|
% 24 }]}
|
|
}
|
|
l { # Hour (12-11), no leading zero
|
|
append formatString %2d
|
|
append substituents \
|
|
{ [expr { ( ( ( [dict get $date localSeconds]
|
|
% 86400 )
|
|
+ 86400
|
|
- 3600 )
|
|
/ 3600 )
|
|
% 12 + 1 }]}
|
|
}
|
|
m { # Month number, leading zero
|
|
append formatString %02d
|
|
append substituents { [dict get $date month]}
|
|
}
|
|
M { # Minute of the hour, leading zero
|
|
append formatString %02d
|
|
append substituents \
|
|
{ [expr { [dict get $date localSeconds]
|
|
/ 60
|
|
% 60 }]}
|
|
}
|
|
n { # A literal newline
|
|
append formatString \n
|
|
}
|
|
N { # Month number, no leading zero
|
|
append formatString %2d
|
|
append substituents { [dict get $date month]}
|
|
}
|
|
O { # A format group in the locale's
|
|
# alternative numerals
|
|
set state percentO
|
|
if {!$didLocaleNumerals} {
|
|
append preFormatCode \
|
|
[list set localeNumerals \
|
|
[mc LOCALE_NUMERALS]] \n
|
|
set didLocaleNumerals 1
|
|
}
|
|
}
|
|
p { # Localized 'AM' or 'PM' indicator
|
|
# converted to uppercase
|
|
append formatString %s
|
|
append preFormatCode \
|
|
[list set AM [string toupper [mc AM]]] \n \
|
|
[list set PM [string toupper [mc PM]]] \n
|
|
append substituents \
|
|
{ [expr {(([dict get $date localSeconds]
|
|
% 86400) < 43200) ?
|
|
$AM : $PM}]}
|
|
}
|
|
P { # Localized 'AM' or 'PM' indicator
|
|
append formatString %s
|
|
append preFormatCode \
|
|
[list set am [mc AM]] \n \
|
|
[list set pm [mc PM]] \n
|
|
append substituents \
|
|
{ [expr {(([dict get $date localSeconds]
|
|
% 86400) < 43200) ?
|
|
$am : $pm}]}
|
|
|
|
}
|
|
Q { # Hi, Jeff!
|
|
append formatString %s
|
|
append substituents { [FormatStarDate $date]}
|
|
}
|
|
s { # Seconds from the Posix Epoch
|
|
append formatString %s
|
|
append substituents { [dict get $date seconds]}
|
|
}
|
|
S { # Second of the minute, with
|
|
# leading zero
|
|
append formatString %02d
|
|
append substituents \
|
|
{ [expr { [dict get $date localSeconds]
|
|
% 60 }]}
|
|
}
|
|
t { # A literal tab character
|
|
append formatString \t
|
|
}
|
|
u { # Day of the week (1-Monday, 7-Sunday)
|
|
append formatString %1d
|
|
append substituents { [dict get $date dayOfWeek]}
|
|
}
|
|
U { # Week of the year (00-53). The
|
|
# first Sunday of the year is the
|
|
# first day of week 01
|
|
append formatString %02d
|
|
append preFormatCode {
|
|
set dow [dict get $date dayOfWeek]
|
|
if { $dow == 7 } {
|
|
set dow 0
|
|
}
|
|
incr dow
|
|
set UweekNumber \
|
|
[expr { ( [dict get $date dayOfYear]
|
|
- $dow + 7 )
|
|
/ 7 }]
|
|
}
|
|
append substituents { $UweekNumber}
|
|
}
|
|
V { # The ISO8601 week number
|
|
append formatString %02d
|
|
append substituents { [dict get $date iso8601Week]}
|
|
}
|
|
w { # Day of the week (0-Sunday,
|
|
# 6-Saturday)
|
|
append formatString %1d
|
|
append substituents \
|
|
{ [expr { [dict get $date dayOfWeek] % 7 }]}
|
|
}
|
|
W { # Week of the year (00-53). The first
|
|
# Monday of the year is the first day
|
|
# of week 01.
|
|
append preFormatCode {
|
|
set WweekNumber \
|
|
[expr { ( [dict get $date dayOfYear]
|
|
- [dict get $date dayOfWeek]
|
|
+ 7 )
|
|
/ 7 }]
|
|
}
|
|
append formatString %02d
|
|
append substituents { $WweekNumber}
|
|
}
|
|
y { # The two-digit year of the century
|
|
append formatString %02d
|
|
append substituents \
|
|
{ [expr { [dict get $date year] % 100 }]}
|
|
}
|
|
Y { # The four-digit year
|
|
append formatString %04d
|
|
append substituents { [dict get $date year]}
|
|
}
|
|
z { # The time zone as hours and minutes
|
|
# east (+) or west (-) of Greenwich
|
|
append formatString %s
|
|
append substituents { [FormatNumericTimeZone \
|
|
[dict get $date tzOffset]]}
|
|
}
|
|
Z { # The name of the time zone
|
|
append formatString %s
|
|
append substituents { [dict get $date tzName]}
|
|
}
|
|
% { # A literal percent character
|
|
append formatString %%
|
|
}
|
|
default { # An unknown escape sequence
|
|
append formatString %% $char
|
|
}
|
|
}
|
|
}
|
|
percentE { # Character following %E
|
|
set state {}
|
|
switch -exact -- $char {
|
|
E {
|
|
append formatString %s
|
|
append substituents { } \
|
|
[string map \
|
|
[list @BCE@ [list [mc BCE]] \
|
|
@CE@ [list [mc CE]]] \
|
|
{[dict get {BCE @BCE@ CE @CE@} \
|
|
[dict get $date era]]}]
|
|
}
|
|
C { # Locale-dependent era
|
|
append formatString %s
|
|
append substituents { [dict get $date localeEra]}
|
|
}
|
|
y { # Locale-dependent year of the era
|
|
append preFormatCode {
|
|
set y [dict get $date localeYear]
|
|
if { $y >= 0 && $y < 100 } {
|
|
set Eyear [lindex $localeNumerals $y]
|
|
} else {
|
|
set Eyear $y
|
|
}
|
|
}
|
|
append formatString %s
|
|
append substituents { $Eyear}
|
|
}
|
|
default { # Unknown %E format group
|
|
append formatString %%E $char
|
|
}
|
|
}
|
|
}
|
|
percentO { # Character following %O
|
|
set state {}
|
|
switch -exact -- $char {
|
|
d - e { # Day of the month in alternative
|
|
# numerals
|
|
append formatString %s
|
|
append substituents \
|
|
{ [lindex $localeNumerals \
|
|
[dict get $date dayOfMonth]]}
|
|
}
|
|
H - k { # Hour of the day in alternative
|
|
# numerals
|
|
append formatString %s
|
|
append substituents \
|
|
{ [lindex $localeNumerals \
|
|
[expr { [dict get $date localSeconds]
|
|
/ 3600
|
|
% 24 }]]}
|
|
}
|
|
I - l { # Hour (12-11) AM/PM in alternative
|
|
# numerals
|
|
append formatString %s
|
|
append substituents \
|
|
{ [lindex $localeNumerals \
|
|
[expr { ( ( ( [dict get $date localSeconds]
|
|
% 86400 )
|
|
+ 86400
|
|
- 3600 )
|
|
/ 3600 )
|
|
% 12 + 1 }]]}
|
|
}
|
|
m { # Month number in alternative numerals
|
|
append formatString %s
|
|
append substituents \
|
|
{ [lindex $localeNumerals [dict get $date month]]}
|
|
}
|
|
M { # Minute of the hour in alternative
|
|
# numerals
|
|
append formatString %s
|
|
append substituents \
|
|
{ [lindex $localeNumerals \
|
|
[expr { [dict get $date localSeconds]
|
|
/ 60
|
|
% 60 }]]}
|
|
}
|
|
S { # Second of the minute in alternative
|
|
# numerals
|
|
append formatString %s
|
|
append substituents \
|
|
{ [lindex $localeNumerals \
|
|
[expr { [dict get $date localSeconds]
|
|
% 60 }]]}
|
|
}
|
|
u { # Day of the week (Monday=1,Sunday=7)
|
|
# in alternative numerals
|
|
append formatString %s
|
|
append substituents \
|
|
{ [lindex $localeNumerals \
|
|
[dict get $date dayOfWeek]]}
|
|
}
|
|
w { # Day of the week (Sunday=0,Saturday=6)
|
|
# in alternative numerals
|
|
append formatString %s
|
|
append substituents \
|
|
{ [lindex $localeNumerals \
|
|
[expr { [dict get $date dayOfWeek] % 7 }]]}
|
|
}
|
|
y { # Year of the century in alternative
|
|
# numerals
|
|
append formatString %s
|
|
append substituents \
|
|
{ [lindex $localeNumerals \
|
|
[expr { [dict get $date year] % 100 }]]}
|
|
}
|
|
default { # Unknown format group
|
|
append formatString %%O $char
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
# Clean up any improperly terminated groups
|
|
|
|
switch -exact -- $state {
|
|
percent {
|
|
append formatString %%
|
|
}
|
|
percentE {
|
|
append retval %%E
|
|
}
|
|
percentO {
|
|
append retval %%O
|
|
}
|
|
}
|
|
|
|
proc $procName {clockval timezone} "
|
|
$preFormatCode
|
|
return \[::format [list $formatString] $substituents\]
|
|
"
|
|
|
|
# puts [list $procName [info args $procName] [info body $procName]]
|
|
|
|
return $procName
|
|
}
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# clock scan --
|
|
#
|
|
# Inputs a count of seconds since the Posix Epoch as a time of day.
|
|
#
|
|
# The 'clock format' command scans times of day on input. Refer to the user
|
|
# documentation to see what it does.
|
|
#
|
|
#----------------------------------------------------------------------
|
|
|
|
proc ::tcl::clock::scan { args } {
|
|
|
|
set format {}
|
|
|
|
# Check the count of args
|
|
|
|
if { [llength $args] < 1 || [llength $args] % 2 != 1 } {
|
|
set cmdName "clock scan"
|
|
return -code error \
|
|
-errorcode [list CLOCK wrongNumArgs] \
|
|
"wrong \# args: should be\
|
|
\"$cmdName string\
|
|
?-base seconds?\
|
|
?-format string? ?-gmt boolean?\
|
|
?-locale LOCALE? ?-timezone ZONE?\""
|
|
}
|
|
|
|
# Set defaults
|
|
|
|
set base [clock seconds]
|
|
set string [lindex $args 0]
|
|
set format {}
|
|
set gmt 0
|
|
set locale c
|
|
set timezone [GetSystemTimeZone]
|
|
|
|
# Pick up command line options.
|
|
|
|
foreach { flag value } [lreplace $args 0 0] {
|
|
set saw($flag) {}
|
|
switch -exact -- $flag {
|
|
-b - -ba - -bas - -base {
|
|
set base $value
|
|
}
|
|
-f - -fo - -for - -form - -forma - -format {
|
|
set format $value
|
|
}
|
|
-g - -gm - -gmt {
|
|
set gmt $value
|
|
}
|
|
-l - -lo - -loc - -loca - -local - -locale {
|
|
set locale [string tolower $value]
|
|
}
|
|
-t - -ti - -tim - -time - -timez - -timezo - -timezon - -timezone {
|
|
set timezone $value
|
|
}
|
|
default {
|
|
return -code error \
|
|
-errorcode [list CLOCK badOption $flag] \
|
|
"bad option \"$flag\",\
|
|
must be -base, -format, -gmt, -locale or -timezone"
|
|
}
|
|
}
|
|
}
|
|
|
|
# Check options for validity
|
|
|
|
if { [info exists saw(-gmt)] && [info exists saw(-timezone)] } {
|
|
return -code error \
|
|
-errorcode [list CLOCK gmtWithTimezone] \
|
|
"cannot use -gmt and -timezone in same call"
|
|
}
|
|
if { [catch { expr { wide($base) } } result] } {
|
|
return -code error "expected integer but got \"$base\""
|
|
}
|
|
if { ![string is boolean -strict $gmt] } {
|
|
return -code error "expected boolean value but got \"$gmt\""
|
|
} elseif { $gmt } {
|
|
set timezone :GMT
|
|
}
|
|
|
|
if { ![info exists saw(-format)] } {
|
|
# Perhaps someday we'll localize the legacy code. Right now, it's not
|
|
# localized.
|
|
if { [info exists saw(-locale)] } {
|
|
return -code error \
|
|
-errorcode [list CLOCK flagWithLegacyFormat] \
|
|
"legacy \[clock scan\] does not support -locale"
|
|
|
|
}
|
|
return [FreeScan $string $base $timezone $locale]
|
|
}
|
|
|
|
# Change locale if a fresh locale has been given on the command line.
|
|
|
|
EnterLocale $locale
|
|
|
|
try {
|
|
# Map away the locale-dependent composite format groups
|
|
|
|
set scanner [ParseClockScanFormat $format $locale]
|
|
return [$scanner $string $base $timezone]
|
|
} trap CLOCK {result opts} {
|
|
# Conceal location of generation of expected errors
|
|
dict unset opts -errorinfo
|
|
return -options $opts $result
|
|
}
|
|
}
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# FreeScan --
|
|
#
|
|
# Scans a time in free format
|
|
#
|
|
# Parameters:
|
|
# string - String containing the time to scan
|
|
# base - Base time, expressed in seconds from the Epoch
|
|
# timezone - Default time zone in which the time will be expressed
|
|
# locale - (Unused) Name of the locale where the time will be scanned.
|
|
#
|
|
# Results:
|
|
# Returns the date and time extracted from the string in seconds from
|
|
# the epoch
|
|
#
|
|
#----------------------------------------------------------------------
|
|
|
|
proc ::tcl::clock::FreeScan { string base timezone locale } {
|
|
|
|
variable TZData
|
|
|
|
# Get the data for time changes in the given zone
|
|
|
|
try {
|
|
SetupTimeZone $timezone
|
|
} on error {retval opts} {
|
|
dict unset opts -errorinfo
|
|
return -options $opts $retval
|
|
}
|
|
|
|
# Extract year, month and day from the base time for the parser to use as
|
|
# defaults
|
|
|
|
set date [GetDateFields $base $TZData($timezone) 2361222]
|
|
dict set date secondOfDay [expr {
|
|
[dict get $date localSeconds] % 86400
|
|
}]
|
|
|
|
# Parse the date. The parser will return a list comprising date, time,
|
|
# time zone, relative month/day/seconds, relative weekday, ordinal month.
|
|
|
|
try {
|
|
set scanned [Oldscan $string \
|
|
[dict get $date year] \
|
|
[dict get $date month] \
|
|
[dict get $date dayOfMonth]]
|
|
lassign $scanned \
|
|
parseDate parseTime parseZone parseRel \
|
|
parseWeekday parseOrdinalMonth
|
|
} on error message {
|
|
return -code error \
|
|
"unable to convert date-time string \"$string\": $message"
|
|
}
|
|
|
|
# If the caller supplied a date in the string, update the 'date' dict with
|
|
# the value. If the caller didn't specify a time with the date, default to
|
|
# midnight.
|
|
|
|
if { [llength $parseDate] > 0 } {
|
|
lassign $parseDate y m d
|
|
if { $y < 100 } {
|
|
if { $y >= 39 } {
|
|
incr y 1900
|
|
} else {
|
|
incr y 2000
|
|
}
|
|
}
|
|
dict set date era CE
|
|
dict set date year $y
|
|
dict set date month $m
|
|
dict set date dayOfMonth $d
|
|
if { $parseTime eq {} } {
|
|
set parseTime 0
|
|
}
|
|
}
|
|
|
|
# If the caller supplied a time zone in the string, it comes back as a
|
|
# two-element list; the first element is the number of minutes east of
|
|
# Greenwich, and the second is a Daylight Saving Time indicator (1 == yes,
|
|
# 0 == no, -1 == unknown). We make it into a time zone indicator of
|
|
# +-hhmm.
|
|
|
|
if { [llength $parseZone] > 0 } {
|
|
lassign $parseZone minEast dstFlag
|
|
set timezone [FormatNumericTimeZone \
|
|
[expr { 60 * $minEast + 3600 * $dstFlag }]]
|
|
SetupTimeZone $timezone
|
|
}
|
|
dict set date tzName $timezone
|
|
|
|
# Assemble date, time, zone into seconds-from-epoch
|
|
|
|
set date [GetJulianDayFromEraYearMonthDay $date[set date {}] 2361222]
|
|
if { $parseTime ne {} } {
|
|
dict set date secondOfDay $parseTime
|
|
} elseif { [llength $parseWeekday] != 0
|
|
|| [llength $parseOrdinalMonth] != 0
|
|
|| ( [llength $parseRel] != 0
|
|
&& ( [lindex $parseRel 0] != 0
|
|
|| [lindex $parseRel 1] != 0 ) ) } {
|
|
dict set date secondOfDay 0
|
|
}
|
|
|
|
dict set date localSeconds [expr {
|
|
-210866803200
|
|
+ ( 86400 * wide([dict get $date julianDay]) )
|
|
+ [dict get $date secondOfDay]
|
|
}]
|
|
dict set date tzName $timezone
|
|
set date [ConvertLocalToUTC $date[set date {}] $TZData($timezone) 2361222]
|
|
set seconds [dict get $date seconds]
|
|
|
|
# Do relative times
|
|
|
|
if { [llength $parseRel] > 0 } {
|
|
lassign $parseRel relMonth relDay relSecond
|
|
set seconds [add $seconds \
|
|
$relMonth months $relDay days $relSecond seconds \
|
|
-timezone $timezone -locale $locale]
|
|
}
|
|
|
|
# Do relative weekday
|
|
|
|
if { [llength $parseWeekday] > 0 } {
|
|
lassign $parseWeekday dayOrdinal dayOfWeek
|
|
set date2 [GetDateFields $seconds $TZData($timezone) 2361222]
|
|
dict set date2 era CE
|
|
set jdwkday [WeekdayOnOrBefore $dayOfWeek [expr {
|
|
[dict get $date2 julianDay] + 6
|
|
}]]
|
|
incr jdwkday [expr { 7 * $dayOrdinal }]
|
|
if { $dayOrdinal > 0 } {
|
|
incr jdwkday -7
|
|
}
|
|
dict set date2 secondOfDay \
|
|
[expr { [dict get $date2 localSeconds] % 86400 }]
|
|
dict set date2 julianDay $jdwkday
|
|
dict set date2 localSeconds [expr {
|
|
-210866803200
|
|
+ ( 86400 * wide([dict get $date2 julianDay]) )
|
|
+ [dict get $date secondOfDay]
|
|
}]
|
|
dict set date2 tzName $timezone
|
|
set date2 [ConvertLocalToUTC $date2[set date2 {}] $TZData($timezone) \
|
|
2361222]
|
|
set seconds [dict get $date2 seconds]
|
|
|
|
}
|
|
|
|
# Do relative month
|
|
|
|
if { [llength $parseOrdinalMonth] > 0 } {
|
|
lassign $parseOrdinalMonth monthOrdinal monthNumber
|
|
if { $monthOrdinal > 0 } {
|
|
set monthDiff [expr { $monthNumber - [dict get $date month] }]
|
|
if { $monthDiff <= 0 } {
|
|
incr monthDiff 12
|
|
}
|
|
incr monthOrdinal -1
|
|
} else {
|
|
set monthDiff [expr { [dict get $date month] - $monthNumber }]
|
|
if { $monthDiff >= 0 } {
|
|
incr monthDiff -12
|
|
}
|
|
incr monthOrdinal
|
|
}
|
|
set seconds [add $seconds $monthOrdinal years $monthDiff months \
|
|
-timezone $timezone -locale $locale]
|
|
}
|
|
|
|
return $seconds
|
|
}
|
|
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# ParseClockScanFormat --
|
|
#
|
|
# Parses a format string given to [clock scan -format]
|
|
#
|
|
# Parameters:
|
|
# formatString - The format being parsed
|
|
# locale - The current locale
|
|
#
|
|
# Results:
|
|
# Constructs and returns a procedure that accepts the string being
|
|
# scanned, the base time, and the time zone. The procedure will either
|
|
# return the scanned time or else throw an error that should be rethrown
|
|
# to the caller of [clock scan]
|
|
#
|
|
# Side effects:
|
|
# The given procedure is defined in the ::tcl::clock namespace. Scan
|
|
# procedures are not deleted once installed.
|
|
#
|
|
# Why do we parse dates by defining a procedure to parse them? The reason is
|
|
# that by doing so, we have one convenient place to cache all the information:
|
|
# the regular expressions that match the patterns (which will be compiled),
|
|
# the code that assembles the date information, everything lands in one place.
|
|
# In this way, when a given format is reused at run time, all the information
|
|
# of how to apply it is available in a single place.
|
|
#
|
|
#----------------------------------------------------------------------
|
|
|
|
proc ::tcl::clock::ParseClockScanFormat {formatString locale} {
|
|
# Check whether the format has been parsed previously, and return the
|
|
# existing recognizer if it has.
|
|
|
|
set procName scanproc'$formatString'$locale
|
|
set procName [namespace current]::[string map {: {\:} \\ {\\}} $procName]
|
|
if { [namespace which $procName] != {} } {
|
|
return $procName
|
|
}
|
|
|
|
variable DateParseActions
|
|
variable TimeParseActions
|
|
|
|
# Localize the %x, %X, etc. groups
|
|
|
|
set formatString [LocalizeFormat $locale $formatString]
|
|
|
|
# Condense whitespace
|
|
|
|
regsub -all {[[:space:]]+} $formatString { } formatString
|
|
|
|
# Walk through the groups of the format string. In this loop, we
|
|
# accumulate:
|
|
# - a regular expression that matches the string,
|
|
# - the count of capturing brackets in the regexp
|
|
# - a set of code that post-processes the fields captured by the regexp,
|
|
# - a dictionary whose keys are the names of fields that are present
|
|
# in the format string.
|
|
|
|
set re {^[[:space:]]*}
|
|
set captureCount 0
|
|
set postcode {}
|
|
set fieldSet [dict create]
|
|
set fieldCount 0
|
|
set postSep {}
|
|
set state {}
|
|
|
|
foreach c [split $formatString {}] {
|
|
switch -exact -- $state {
|
|
{} {
|
|
if { $c eq "%" } {
|
|
set state %
|
|
} elseif { $c eq " " } {
|
|
append re {[[:space:]]+}
|
|
} else {
|
|
if { ! [string is alnum $c] } {
|
|
append re "\\"
|
|
}
|
|
append re $c
|
|
}
|
|
}
|
|
% {
|
|
set state {}
|
|
switch -exact -- $c {
|
|
% {
|
|
append re %
|
|
}
|
|
{ } {
|
|
append re "\[\[:space:\]\]*"
|
|
}
|
|
a - A { # Day of week, in words
|
|
set l {}
|
|
foreach \
|
|
i {7 1 2 3 4 5 6} \
|
|
abr [mc DAYS_OF_WEEK_ABBREV] \
|
|
full [mc DAYS_OF_WEEK_FULL] {
|
|
dict set l [string tolower $abr] $i
|
|
dict set l [string tolower $full] $i
|
|
incr i
|
|
}
|
|
lassign [UniquePrefixRegexp $l] regex lookup
|
|
append re ( $regex )
|
|
dict set fieldSet dayOfWeek [incr fieldCount]
|
|
append postcode "dict set date dayOfWeek \[" \
|
|
"dict get " [list $lookup] " " \
|
|
\[ {string tolower $field} [incr captureCount] \] \
|
|
"\]\n"
|
|
}
|
|
b - B - h { # Name of month
|
|
set i 0
|
|
set l {}
|
|
foreach \
|
|
abr [mc MONTHS_ABBREV] \
|
|
full [mc MONTHS_FULL] {
|
|
incr i
|
|
dict set l [string tolower $abr] $i
|
|
dict set l [string tolower $full] $i
|
|
}
|
|
lassign [UniquePrefixRegexp $l] regex lookup
|
|
append re ( $regex )
|
|
dict set fieldSet month [incr fieldCount]
|
|
append postcode "dict set date month \[" \
|
|
"dict get " [list $lookup] \
|
|
" " \[ {string tolower $field} \
|
|
[incr captureCount] \] \
|
|
"\]\n"
|
|
}
|
|
C { # Gregorian century
|
|
append re \\s*(\\d\\d?)
|
|
dict set fieldSet century [incr fieldCount]
|
|
append postcode "dict set date century \[" \
|
|
"::scan \$field" [incr captureCount] " %d" \
|
|
"\]\n"
|
|
}
|
|
d - e { # Day of month
|
|
append re \\s*(\\d\\d?)
|
|
dict set fieldSet dayOfMonth [incr fieldCount]
|
|
append postcode "dict set date dayOfMonth \[" \
|
|
"::scan \$field" [incr captureCount] " %d" \
|
|
"\]\n"
|
|
}
|
|
E { # Prefix for locale-specific codes
|
|
set state %E
|
|
}
|
|
g { # ISO8601 2-digit year
|
|
append re \\s*(\\d\\d)
|
|
dict set fieldSet iso8601YearOfCentury \
|
|
[incr fieldCount]
|
|
append postcode \
|
|
"dict set date iso8601YearOfCentury \[" \
|
|
"::scan \$field" [incr captureCount] " %d" \
|
|
"\]\n"
|
|
}
|
|
G { # ISO8601 4-digit year
|
|
append re \\s*(\\d\\d)(\\d\\d)
|
|
dict set fieldSet iso8601Century [incr fieldCount]
|
|
dict set fieldSet iso8601YearOfCentury \
|
|
[incr fieldCount]
|
|
append postcode \
|
|
"dict set date iso8601Century \[" \
|
|
"::scan \$field" [incr captureCount] " %d" \
|
|
"\]\n" \
|
|
"dict set date iso8601YearOfCentury \[" \
|
|
"::scan \$field" [incr captureCount] " %d" \
|
|
"\]\n"
|
|
}
|
|
H - k { # Hour of day
|
|
append re \\s*(\\d\\d?)
|
|
dict set fieldSet hour [incr fieldCount]
|
|
append postcode "dict set date hour \[" \
|
|
"::scan \$field" [incr captureCount] " %d" \
|
|
"\]\n"
|
|
}
|
|
I - l { # Hour, AM/PM
|
|
append re \\s*(\\d\\d?)
|
|
dict set fieldSet hourAMPM [incr fieldCount]
|
|
append postcode "dict set date hourAMPM \[" \
|
|
"::scan \$field" [incr captureCount] " %d" \
|
|
"\]\n"
|
|
}
|
|
j { # Day of year
|
|
append re \\s*(\\d\\d?\\d?)
|
|
dict set fieldSet dayOfYear [incr fieldCount]
|
|
append postcode "dict set date dayOfYear \[" \
|
|
"::scan \$field" [incr captureCount] " %d" \
|
|
"\]\n"
|
|
}
|
|
J { # Julian Day Number
|
|
append re \\s*(\\d+)
|
|
dict set fieldSet julianDay [incr fieldCount]
|
|
append postcode "dict set date julianDay \[" \
|
|
"::scan \$field" [incr captureCount] " %ld" \
|
|
"\]\n"
|
|
}
|
|
m - N { # Month number
|
|
append re \\s*(\\d\\d?)
|
|
dict set fieldSet month [incr fieldCount]
|
|
append postcode "dict set date month \[" \
|
|
"::scan \$field" [incr captureCount] " %d" \
|
|
"\]\n"
|
|
}
|
|
M { # Minute
|
|
append re \\s*(\\d\\d?)
|
|
dict set fieldSet minute [incr fieldCount]
|
|
append postcode "dict set date minute \[" \
|
|
"::scan \$field" [incr captureCount] " %d" \
|
|
"\]\n"
|
|
}
|
|
n { # Literal newline
|
|
append re \\n
|
|
}
|
|
O { # Prefix for locale numerics
|
|
set state %O
|
|
}
|
|
p - P { # AM/PM indicator
|
|
set l [list [string tolower [mc AM]] 0 \
|
|
[string tolower [mc PM]] 1]
|
|
lassign [UniquePrefixRegexp $l] regex lookup
|
|
append re ( $regex )
|
|
dict set fieldSet amPmIndicator [incr fieldCount]
|
|
append postcode "dict set date amPmIndicator \[" \
|
|
"dict get " [list $lookup] " \[string tolower " \
|
|
"\$field" \
|
|
[incr captureCount] \
|
|
"\]\]\n"
|
|
}
|
|
Q { # Hi, Jeff!
|
|
append re {Stardate\s+([-+]?\d+)(\d\d\d)[.](\d)}
|
|
incr captureCount
|
|
dict set fieldSet seconds [incr fieldCount]
|
|
append postcode {dict set date seconds } \[ \
|
|
{ParseStarDate $field} [incr captureCount] \
|
|
{ $field} [incr captureCount] \
|
|
{ $field} [incr captureCount] \
|
|
\] \n
|
|
}
|
|
s { # Seconds from Posix Epoch
|
|
# This next case is insanely difficult, because it's
|
|
# problematic to determine whether the field is
|
|
# actually within the range of a wide integer.
|
|
append re {\s*([-+]?\d+)}
|
|
dict set fieldSet seconds [incr fieldCount]
|
|
append postcode {dict set date seconds } \[ \
|
|
{ScanWide $field} [incr captureCount] \] \n
|
|
}
|
|
S { # Second
|
|
append re \\s*(\\d\\d?)
|
|
dict set fieldSet second [incr fieldCount]
|
|
append postcode "dict set date second \[" \
|
|
"::scan \$field" [incr captureCount] " %d" \
|
|
"\]\n"
|
|
}
|
|
t { # Literal tab character
|
|
append re \\t
|
|
}
|
|
u - w { # Day number within week, 0 or 7 == Sun
|
|
# 1=Mon, 6=Sat
|
|
append re \\s*(\\d)
|
|
dict set fieldSet dayOfWeek [incr fieldCount]
|
|
append postcode {::scan $field} [incr captureCount] \
|
|
{ %d dow} \n \
|
|
{
|
|
if { $dow == 0 } {
|
|
set dow 7
|
|
} elseif { $dow > 7 } {
|
|
return -code error \
|
|
-errorcode [list CLOCK badDayOfWeek] \
|
|
"day of week is greater than 7"
|
|
}
|
|
dict set date dayOfWeek $dow
|
|
}
|
|
}
|
|
U { # Week of year. The first Sunday of
|
|
# the year is the first day of week
|
|
# 01. No scan rule uses this group.
|
|
append re \\s*\\d\\d?
|
|
}
|
|
V { # Week of ISO8601 year
|
|
|
|
append re \\s*(\\d\\d?)
|
|
dict set fieldSet iso8601Week [incr fieldCount]
|
|
append postcode "dict set date iso8601Week \[" \
|
|
"::scan \$field" [incr captureCount] " %d" \
|
|
"\]\n"
|
|
}
|
|
W { # Week of the year (00-53). The first
|
|
# Monday of the year is the first day
|
|
# of week 01. No scan rule uses this
|
|
# group.
|
|
append re \\s*\\d\\d?
|
|
}
|
|
y { # Two-digit Gregorian year
|
|
append re \\s*(\\d\\d?)
|
|
dict set fieldSet yearOfCentury [incr fieldCount]
|
|
append postcode "dict set date yearOfCentury \[" \
|
|
"::scan \$field" [incr captureCount] " %d" \
|
|
"\]\n"
|
|
}
|
|
Y { # 4-digit Gregorian year
|
|
append re \\s*(\\d\\d)(\\d\\d)
|
|
dict set fieldSet century [incr fieldCount]
|
|
dict set fieldSet yearOfCentury [incr fieldCount]
|
|
append postcode \
|
|
"dict set date century \[" \
|
|
"::scan \$field" [incr captureCount] " %d" \
|
|
"\]\n" \
|
|
"dict set date yearOfCentury \[" \
|
|
"::scan \$field" [incr captureCount] " %d" \
|
|
"\]\n"
|
|
}
|
|
z - Z { # Time zone name
|
|
append re {(?:([-+]\d\d(?::?\d\d(?::?\d\d)?)?)|([[:alnum:]]{1,4}))}
|
|
dict set fieldSet tzName [incr fieldCount]
|
|
append postcode \
|
|
{if } \{ { $field} [incr captureCount] \
|
|
{ ne "" } \} { } \{ \n \
|
|
{dict set date tzName $field} \
|
|
$captureCount \n \
|
|
\} { else } \{ \n \
|
|
{dict set date tzName } \[ \
|
|
{ConvertLegacyTimeZone $field} \
|
|
[incr captureCount] \] \n \
|
|
\} \n \
|
|
}
|
|
% { # Literal percent character
|
|
append re %
|
|
}
|
|
default {
|
|
append re %
|
|
if { ! [string is alnum $c] } {
|
|
append re \\
|
|
}
|
|
append re $c
|
|
}
|
|
}
|
|
}
|
|
%E {
|
|
switch -exact -- $c {
|
|
C { # Locale-dependent era
|
|
set d {}
|
|
foreach triple [mc LOCALE_ERAS] {
|
|
lassign $triple t symbol year
|
|
dict set d [string tolower $symbol] $year
|
|
}
|
|
lassign [UniquePrefixRegexp $d] regex lookup
|
|
append re (?: $regex )
|
|
}
|
|
E {
|
|
set l {}
|
|
dict set l [string tolower [mc BCE]] BCE
|
|
dict set l [string tolower [mc CE]] CE
|
|
dict set l b.c.e. BCE
|
|
dict set l c.e. CE
|
|
dict set l b.c. BCE
|
|
dict set l a.d. CE
|
|
lassign [UniquePrefixRegexp $l] regex lookup
|
|
append re ( $regex )
|
|
dict set fieldSet era [incr fieldCount]
|
|
append postcode "dict set date era \["\
|
|
"dict get " [list $lookup] \
|
|
{ } \[ {string tolower $field} \
|
|
[incr captureCount] \] \
|
|
"\]\n"
|
|
}
|
|
y { # Locale-dependent year of the era
|
|
lassign [LocaleNumeralMatcher $locale] regex lookup
|
|
append re $regex
|
|
incr captureCount
|
|
}
|
|
default {
|
|
append re %E
|
|
if { ! [string is alnum $c] } {
|
|
append re \\
|
|
}
|
|
append re $c
|
|
}
|
|
}
|
|
set state {}
|
|
}
|
|
%O {
|
|
switch -exact -- $c {
|
|
d - e {
|
|
lassign [LocaleNumeralMatcher $locale] regex lookup
|
|
append re $regex
|
|
dict set fieldSet dayOfMonth [incr fieldCount]
|
|
append postcode "dict set date dayOfMonth \[" \
|
|
"dict get " [list $lookup] " \$field" \
|
|
[incr captureCount] \
|
|
"\]\n"
|
|
}
|
|
H - k {
|
|
lassign [LocaleNumeralMatcher $locale] regex lookup
|
|
append re $regex
|
|
dict set fieldSet hour [incr fieldCount]
|
|
append postcode "dict set date hour \[" \
|
|
"dict get " [list $lookup] " \$field" \
|
|
[incr captureCount] \
|
|
"\]\n"
|
|
}
|
|
I - l {
|
|
lassign [LocaleNumeralMatcher $locale] regex lookup
|
|
append re $regex
|
|
dict set fieldSet hourAMPM [incr fieldCount]
|
|
append postcode "dict set date hourAMPM \[" \
|
|
"dict get " [list $lookup] " \$field" \
|
|
[incr captureCount] \
|
|
"\]\n"
|
|
}
|
|
m {
|
|
lassign [LocaleNumeralMatcher $locale] regex lookup
|
|
append re $regex
|
|
dict set fieldSet month [incr fieldCount]
|
|
append postcode "dict set date month \[" \
|
|
"dict get " [list $lookup] " \$field" \
|
|
[incr captureCount] \
|
|
"\]\n"
|
|
}
|
|
M {
|
|
lassign [LocaleNumeralMatcher $locale] regex lookup
|
|
append re $regex
|
|
dict set fieldSet minute [incr fieldCount]
|
|
append postcode "dict set date minute \[" \
|
|
"dict get " [list $lookup] " \$field" \
|
|
[incr captureCount] \
|
|
"\]\n"
|
|
}
|
|
S {
|
|
lassign [LocaleNumeralMatcher $locale] regex lookup
|
|
append re $regex
|
|
dict set fieldSet second [incr fieldCount]
|
|
append postcode "dict set date second \[" \
|
|
"dict get " [list $lookup] " \$field" \
|
|
[incr captureCount] \
|
|
"\]\n"
|
|
}
|
|
u - w {
|
|
lassign [LocaleNumeralMatcher $locale] regex lookup
|
|
append re $regex
|
|
dict set fieldSet dayOfWeek [incr fieldCount]
|
|
append postcode "set dow \[dict get " [list $lookup] \
|
|
{ $field} [incr captureCount] \] \n \
|
|
{
|
|
if { $dow == 0 } {
|
|
set dow 7
|
|
} elseif { $dow > 7 } {
|
|
return -code error \
|
|
-errorcode [list CLOCK badDayOfWeek] \
|
|
"day of week is greater than 7"
|
|
}
|
|
dict set date dayOfWeek $dow
|
|
}
|
|
}
|
|
y {
|
|
lassign [LocaleNumeralMatcher $locale] regex lookup
|
|
append re $regex
|
|
dict set fieldSet yearOfCentury [incr fieldCount]
|
|
append postcode {dict set date yearOfCentury } \[ \
|
|
{dict get } [list $lookup] { $field} \
|
|
[incr captureCount] \] \n
|
|
}
|
|
default {
|
|
append re %O
|
|
if { ! [string is alnum $c] } {
|
|
append re \\
|
|
}
|
|
append re $c
|
|
}
|
|
}
|
|
set state {}
|
|
}
|
|
}
|
|
}
|
|
|
|
# Clean up any unfinished format groups
|
|
|
|
append re $state \\s*\$
|
|
|
|
# Build the procedure
|
|
|
|
set procBody {}
|
|
append procBody "variable ::tcl::clock::TZData" \n
|
|
append procBody "if \{ !\[ regexp -nocase [list $re] \$string ->"
|
|
for { set i 1 } { $i <= $captureCount } { incr i } {
|
|
append procBody " " field $i
|
|
}
|
|
append procBody "\] \} \{" \n
|
|
append procBody {
|
|
return -code error -errorcode [list CLOCK badInputString] \
|
|
{input string does not match supplied format}
|
|
}
|
|
append procBody \}\n
|
|
append procBody "set date \[dict create\]" \n
|
|
append procBody {dict set date tzName $timeZone} \n
|
|
append procBody $postcode
|
|
append procBody [list set changeover [mc GREGORIAN_CHANGE_DATE]] \n
|
|
|
|
# Set up the time zone before doing anything with a default base date
|
|
# that might need a timezone to interpret it.
|
|
|
|
if { ![dict exists $fieldSet seconds]
|
|
&& ![dict exists $fieldSet starDate] } {
|
|
if { [dict exists $fieldSet tzName] } {
|
|
append procBody {
|
|
set timeZone [dict get $date tzName]
|
|
}
|
|
}
|
|
append procBody {
|
|
::tcl::clock::SetupTimeZone $timeZone
|
|
}
|
|
}
|
|
|
|
# Add code that gets Julian Day Number from the fields.
|
|
|
|
append procBody [MakeParseCodeFromFields $fieldSet $DateParseActions]
|
|
|
|
# Get time of day
|
|
|
|
append procBody [MakeParseCodeFromFields $fieldSet $TimeParseActions]
|
|
|
|
# Assemble seconds from the Julian day and second of the day.
|
|
# Convert to local time unless epoch seconds or stardate are
|
|
# being processed - they're always absolute
|
|
|
|
if { ![dict exists $fieldSet seconds]
|
|
&& ![dict exists $fieldSet starDate] } {
|
|
append procBody {
|
|
if { [dict get $date julianDay] > 5373484 } {
|
|
return -code error -errorcode [list CLOCK dateTooLarge] \
|
|
"requested date too large to represent"
|
|
}
|
|
dict set date localSeconds [expr {
|
|
-210866803200
|
|
+ ( 86400 * wide([dict get $date julianDay]) )
|
|
+ [dict get $date secondOfDay]
|
|
}]
|
|
}
|
|
|
|
# Finally, convert the date to local time
|
|
|
|
append procBody {
|
|
set date [::tcl::clock::ConvertLocalToUTC $date[set date {}] \
|
|
$TZData($timeZone) $changeover]
|
|
}
|
|
}
|
|
|
|
# Return result
|
|
|
|
append procBody {return [dict get $date seconds]} \n
|
|
|
|
proc $procName { string baseTime timeZone } $procBody
|
|
|
|
# puts [list proc $procName [list string baseTime timeZone] $procBody]
|
|
|
|
return $procName
|
|
}
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# LocaleNumeralMatcher --
|
|
#
|
|
# Composes a regexp that captures the numerals in the given locale, and
|
|
# a dictionary to map them to conventional numerals.
|
|
#
|
|
# Parameters:
|
|
# locale - Name of the current locale
|
|
#
|
|
# Results:
|
|
# Returns a two-element list comprising the regexp and the dictionary.
|
|
#
|
|
# Side effects:
|
|
# Caches the result.
|
|
#
|
|
#----------------------------------------------------------------------
|
|
|
|
proc ::tcl::clock::LocaleNumeralMatcher {l} {
|
|
variable LocaleNumeralCache
|
|
|
|
if { ![dict exists $LocaleNumeralCache $l] } {
|
|
set d {}
|
|
set i 0
|
|
set sep \(
|
|
foreach n [mc LOCALE_NUMERALS] {
|
|
dict set d $n $i
|
|
regsub -all {[^[:alnum:]]} $n \\\\& subex
|
|
append re $sep $subex
|
|
set sep |
|
|
incr i
|
|
}
|
|
append re \)
|
|
dict set LocaleNumeralCache $l [list $re $d]
|
|
}
|
|
return [dict get $LocaleNumeralCache $l]
|
|
}
|
|
|
|
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# UniquePrefixRegexp --
|
|
#
|
|
# Composes a regexp that performs unique-prefix matching. The RE
|
|
# matches one of a supplied set of strings, or any unique prefix
|
|
# thereof.
|
|
#
|
|
# Parameters:
|
|
# data - List of alternating match-strings and values.
|
|
# Match-strings with distinct values are considered
|
|
# distinct.
|
|
#
|
|
# Results:
|
|
# Returns a two-element list. The first is a regexp that matches any
|
|
# unique prefix of any of the strings. The second is a dictionary whose
|
|
# keys are match values from the regexp and whose values are the
|
|
# corresponding values from 'data'.
|
|
#
|
|
# Side effects:
|
|
# None.
|
|
#
|
|
#----------------------------------------------------------------------
|
|
|
|
proc ::tcl::clock::UniquePrefixRegexp { data } {
|
|
# The 'successors' dictionary will contain, for each string that is a
|
|
# prefix of any key, all characters that may follow that prefix. The
|
|
# 'prefixMapping' dictionary will have keys that are prefixes of keys and
|
|
# values that correspond to the keys.
|
|
|
|
set prefixMapping [dict create]
|
|
set successors [dict create {} {}]
|
|
|
|
# Walk the key-value pairs
|
|
|
|
foreach { key value } $data {
|
|
# Construct all prefixes of the key;
|
|
|
|
set prefix {}
|
|
foreach char [split $key {}] {
|
|
set oldPrefix $prefix
|
|
dict set successors $oldPrefix $char {}
|
|
append prefix $char
|
|
|
|
# Put the prefixes in the 'prefixMapping' and 'successors'
|
|
# dictionaries
|
|
|
|
dict lappend prefixMapping $prefix $value
|
|
if { ![dict exists $successors $prefix] } {
|
|
dict set successors $prefix {}
|
|
}
|
|
}
|
|
}
|
|
|
|
# Identify those prefixes that designate unique values, and those that are
|
|
# the full keys
|
|
|
|
set uniquePrefixMapping {}
|
|
dict for { key valueList } $prefixMapping {
|
|
if { [llength $valueList] == 1 } {
|
|
dict set uniquePrefixMapping $key [lindex $valueList 0]
|
|
}
|
|
}
|
|
foreach { key value } $data {
|
|
dict set uniquePrefixMapping $key $value
|
|
}
|
|
|
|
# Construct the re.
|
|
|
|
return [list \
|
|
[MakeUniquePrefixRegexp $successors $uniquePrefixMapping {}] \
|
|
$uniquePrefixMapping]
|
|
}
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# MakeUniquePrefixRegexp --
|
|
#
|
|
# Service procedure for 'UniquePrefixRegexp' that constructs a regular
|
|
# expresison that matches the unique prefixes.
|
|
#
|
|
# Parameters:
|
|
# successors - Dictionary whose keys are all prefixes
|
|
# of keys passed to 'UniquePrefixRegexp' and whose
|
|
# values are dictionaries whose keys are the characters
|
|
# that may follow those prefixes.
|
|
# uniquePrefixMapping - Dictionary whose keys are the unique
|
|
# prefixes and whose values are not examined.
|
|
# prefixString - Current prefix being processed.
|
|
#
|
|
# Results:
|
|
# Returns a constructed regular expression that matches the set of
|
|
# unique prefixes beginning with the 'prefixString'.
|
|
#
|
|
# Side effects:
|
|
# None.
|
|
#
|
|
#----------------------------------------------------------------------
|
|
|
|
proc ::tcl::clock::MakeUniquePrefixRegexp { successors
|
|
uniquePrefixMapping
|
|
prefixString } {
|
|
|
|
# Get the characters that may follow the current prefix string
|
|
|
|
set schars [lsort -ascii [dict keys [dict get $successors $prefixString]]]
|
|
if { [llength $schars] == 0 } {
|
|
return {}
|
|
}
|
|
|
|
# If there is more than one successor character, or if the current prefix
|
|
# is a unique prefix, surround the generated re with non-capturing
|
|
# parentheses.
|
|
|
|
set re {}
|
|
if {
|
|
[dict exists $uniquePrefixMapping $prefixString]
|
|
|| [llength $schars] > 1
|
|
} then {
|
|
append re "(?:"
|
|
}
|
|
|
|
# Generate a regexp that matches the successors.
|
|
|
|
set sep ""
|
|
foreach { c } $schars {
|
|
set nextPrefix $prefixString$c
|
|
regsub -all {[^[:alnum:]]} $c \\\\& rechar
|
|
append re $sep $rechar \
|
|
[MakeUniquePrefixRegexp \
|
|
$successors $uniquePrefixMapping $nextPrefix]
|
|
set sep |
|
|
}
|
|
|
|
# If the current prefix is a unique prefix, make all following text
|
|
# optional. Otherwise, if there is more than one successor character,
|
|
# close the non-capturing parentheses.
|
|
|
|
if { [dict exists $uniquePrefixMapping $prefixString] } {
|
|
append re ")?"
|
|
} elseif { [llength $schars] > 1 } {
|
|
append re ")"
|
|
}
|
|
|
|
return $re
|
|
}
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# MakeParseCodeFromFields --
|
|
#
|
|
# Composes Tcl code to extract the Julian Day Number from a dictionary
|
|
# containing date fields.
|
|
#
|
|
# Parameters:
|
|
# dateFields -- Dictionary whose keys are fields of the date,
|
|
# and whose values are the rightmost positions
|
|
# at which those fields appear.
|
|
# parseActions -- List of triples: field set, priority, and
|
|
# code to emit. Smaller priorities are better, and
|
|
# the list must be in ascending order by priority
|
|
#
|
|
# Results:
|
|
# Returns a burst of code that extracts the day number from the given
|
|
# date.
|
|
#
|
|
# Side effects:
|
|
# None.
|
|
#
|
|
#----------------------------------------------------------------------
|
|
|
|
proc ::tcl::clock::MakeParseCodeFromFields { dateFields parseActions } {
|
|
|
|
set currPrio 999
|
|
set currFieldPos [list]
|
|
set currCodeBurst {
|
|
error "in ::tcl::clock::MakeParseCodeFromFields: can't happen"
|
|
}
|
|
|
|
foreach { fieldSet prio parseAction } $parseActions {
|
|
# If we've found an answer that's better than any that follow, quit
|
|
# now.
|
|
|
|
if { $prio > $currPrio } {
|
|
break
|
|
}
|
|
|
|
# Accumulate the field positions that are used in the current field
|
|
# grouping.
|
|
|
|
set fieldPos [list]
|
|
set ok true
|
|
foreach field $fieldSet {
|
|
if { ! [dict exists $dateFields $field] } {
|
|
set ok 0
|
|
break
|
|
}
|
|
lappend fieldPos [dict get $dateFields $field]
|
|
}
|
|
|
|
# Quit if we don't have a complete set of fields
|
|
if { !$ok } {
|
|
continue
|
|
}
|
|
|
|
# Determine whether the current answer is better than the last.
|
|
|
|
set fPos [lsort -integer -decreasing $fieldPos]
|
|
|
|
if { $prio == $currPrio } {
|
|
foreach currPos $currFieldPos newPos $fPos {
|
|
if {
|
|
![string is integer $newPos]
|
|
|| ![string is integer $currPos]
|
|
|| $newPos > $currPos
|
|
} then {
|
|
break
|
|
}
|
|
if { $newPos < $currPos } {
|
|
set ok 0
|
|
break
|
|
}
|
|
}
|
|
}
|
|
if { !$ok } {
|
|
continue
|
|
}
|
|
|
|
# Remember the best possibility for extracting date information
|
|
|
|
set currPrio $prio
|
|
set currFieldPos $fPos
|
|
set currCodeBurst $parseAction
|
|
}
|
|
|
|
return $currCodeBurst
|
|
}
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# EnterLocale --
|
|
#
|
|
# Switch [mclocale] to a given locale if necessary
|
|
#
|
|
# Parameters:
|
|
# locale -- Desired locale
|
|
#
|
|
# Results:
|
|
# Returns the locale that was previously current.
|
|
#
|
|
# Side effects:
|
|
# Does [mclocale]. If necessary, loades the designated locale's files.
|
|
#
|
|
#----------------------------------------------------------------------
|
|
|
|
proc ::tcl::clock::EnterLocale { locale } {
|
|
if { $locale eq {system} } {
|
|
if { $::tcl_platform(platform) ne {windows} } {
|
|
# On a non-windows platform, the 'system' locale is the same as
|
|
# the 'current' locale
|
|
|
|
set locale current
|
|
} else {
|
|
# On a windows platform, the 'system' locale is adapted from the
|
|
# 'current' locale by applying the date and time formats from the
|
|
# Control Panel. First, load the 'current' locale if it's not yet
|
|
# loaded
|
|
|
|
mcpackagelocale set [mclocale]
|
|
|
|
# Make a new locale string for the system locale, and get the
|
|
# Control Panel information
|
|
|
|
set locale [mclocale]_windows
|
|
if { ! [mcpackagelocale present $locale] } {
|
|
LoadWindowsDateTimeFormats $locale
|
|
}
|
|
}
|
|
}
|
|
if { $locale eq {current}} {
|
|
set locale [mclocale]
|
|
}
|
|
# Eventually load the locale
|
|
mcpackagelocale set $locale
|
|
}
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# LoadWindowsDateTimeFormats --
|
|
#
|
|
# Load the date/time formats from the Control Panel in Windows and
|
|
# convert them so that they're usable by Tcl.
|
|
#
|
|
# Parameters:
|
|
# locale - Name of the locale in whose message catalog
|
|
# the converted formats are to be stored.
|
|
#
|
|
# Results:
|
|
# None.
|
|
#
|
|
# Side effects:
|
|
# Updates the given message catalog with the locale strings.
|
|
#
|
|
# Presumes that on entry, [mclocale] is set to the current locale, so that
|
|
# default strings can be obtained if the Registry query fails.
|
|
#
|
|
#----------------------------------------------------------------------
|
|
|
|
proc ::tcl::clock::LoadWindowsDateTimeFormats { locale } {
|
|
# Bail out if we can't find the Registry
|
|
|
|
variable NoRegistry
|
|
if { [info exists NoRegistry] } return
|
|
|
|
if { ![catch {
|
|
registry get "HKEY_CURRENT_USER\\Control Panel\\International" \
|
|
sShortDate
|
|
} string] } {
|
|
set quote {}
|
|
set datefmt {}
|
|
foreach { unquoted quoted } [split $string '] {
|
|
append datefmt $quote [string map {
|
|
dddd %A
|
|
ddd %a
|
|
dd %d
|
|
d %e
|
|
MMMM %B
|
|
MMM %b
|
|
MM %m
|
|
M %N
|
|
yyyy %Y
|
|
yy %y
|
|
y %y
|
|
gg {}
|
|
} $unquoted]
|
|
if { $quoted eq {} } {
|
|
set quote '
|
|
} else {
|
|
set quote $quoted
|
|
}
|
|
}
|
|
::msgcat::mcset $locale DATE_FORMAT $datefmt
|
|
}
|
|
|
|
if { ![catch {
|
|
registry get "HKEY_CURRENT_USER\\Control Panel\\International" \
|
|
sLongDate
|
|
} string] } {
|
|
set quote {}
|
|
set ldatefmt {}
|
|
foreach { unquoted quoted } [split $string '] {
|
|
append ldatefmt $quote [string map {
|
|
dddd %A
|
|
ddd %a
|
|
dd %d
|
|
d %e
|
|
MMMM %B
|
|
MMM %b
|
|
MM %m
|
|
M %N
|
|
yyyy %Y
|
|
yy %y
|
|
y %y
|
|
gg {}
|
|
} $unquoted]
|
|
if { $quoted eq {} } {
|
|
set quote '
|
|
} else {
|
|
set quote $quoted
|
|
}
|
|
}
|
|
::msgcat::mcset $locale LOCALE_DATE_FORMAT $ldatefmt
|
|
}
|
|
|
|
if { ![catch {
|
|
registry get "HKEY_CURRENT_USER\\Control Panel\\International" \
|
|
sTimeFormat
|
|
} string] } {
|
|
set quote {}
|
|
set timefmt {}
|
|
foreach { unquoted quoted } [split $string '] {
|
|
append timefmt $quote [string map {
|
|
HH %H
|
|
H %k
|
|
hh %I
|
|
h %l
|
|
mm %M
|
|
m %M
|
|
ss %S
|
|
s %S
|
|
tt %p
|
|
t %p
|
|
} $unquoted]
|
|
if { $quoted eq {} } {
|
|
set quote '
|
|
} else {
|
|
set quote $quoted
|
|
}
|
|
}
|
|
::msgcat::mcset $locale TIME_FORMAT $timefmt
|
|
}
|
|
|
|
catch {
|
|
::msgcat::mcset $locale DATE_TIME_FORMAT "$datefmt $timefmt"
|
|
}
|
|
catch {
|
|
::msgcat::mcset $locale LOCALE_DATE_TIME_FORMAT "$ldatefmt $timefmt"
|
|
}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# LocalizeFormat --
|
|
#
|
|
# Map away locale-dependent format groups in a clock format.
|
|
#
|
|
# Parameters:
|
|
# locale -- Current [mclocale] locale, supplied to avoid
|
|
# an extra call
|
|
# format -- Format supplied to [clock scan] or [clock format]
|
|
#
|
|
# Results:
|
|
# Returns the string with locale-dependent composite format groups
|
|
# substituted out.
|
|
#
|
|
# Side effects:
|
|
# None.
|
|
#
|
|
#----------------------------------------------------------------------
|
|
|
|
proc ::tcl::clock::LocalizeFormat { locale format } {
|
|
|
|
# message catalog key to cache this format
|
|
set key FORMAT_$format
|
|
|
|
if { [::msgcat::mcexists -exactlocale -exactnamespace $key] } {
|
|
return [mc $key]
|
|
}
|
|
# Handle locale-dependent format groups by mapping them out of the format
|
|
# string. Note that the order of the [string map] operations is
|
|
# significant because later formats can refer to later ones; for example
|
|
# %c can refer to %X, which in turn can refer to %T.
|
|
|
|
set list {
|
|
%% %%
|
|
%D %m/%d/%Y
|
|
%+ {%a %b %e %H:%M:%S %Z %Y}
|
|
}
|
|
lappend list %EY [string map $list [mc LOCALE_YEAR_FORMAT]]
|
|
lappend list %T [string map $list [mc TIME_FORMAT_24_SECS]]
|
|
lappend list %R [string map $list [mc TIME_FORMAT_24]]
|
|
lappend list %r [string map $list [mc TIME_FORMAT_12]]
|
|
lappend list %X [string map $list [mc TIME_FORMAT]]
|
|
lappend list %EX [string map $list [mc LOCALE_TIME_FORMAT]]
|
|
lappend list %x [string map $list [mc DATE_FORMAT]]
|
|
lappend list %Ex [string map $list [mc LOCALE_DATE_FORMAT]]
|
|
lappend list %c [string map $list [mc DATE_TIME_FORMAT]]
|
|
lappend list %Ec [string map $list [mc LOCALE_DATE_TIME_FORMAT]]
|
|
set format [string map $list $format]
|
|
|
|
::msgcat::mcset $locale $key $format
|
|
return $format
|
|
}
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# FormatNumericTimeZone --
|
|
#
|
|
# Formats a time zone as +hhmmss
|
|
#
|
|
# Parameters:
|
|
# z - Time zone in seconds east of Greenwich
|
|
#
|
|
# Results:
|
|
# Returns the time zone formatted in a numeric form
|
|
#
|
|
# Side effects:
|
|
# None.
|
|
#
|
|
#----------------------------------------------------------------------
|
|
|
|
proc ::tcl::clock::FormatNumericTimeZone { z } {
|
|
if { $z < 0 } {
|
|
set z [expr { - $z }]
|
|
set retval -
|
|
} else {
|
|
set retval +
|
|
}
|
|
append retval [::format %02d [expr { $z / 3600 }]]
|
|
set z [expr { $z % 3600 }]
|
|
append retval [::format %02d [expr { $z / 60 }]]
|
|
set z [expr { $z % 60 }]
|
|
if { $z != 0 } {
|
|
append retval [::format %02d $z]
|
|
}
|
|
return $retval
|
|
}
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# FormatStarDate --
|
|
#
|
|
# Formats a date as a StarDate.
|
|
#
|
|
# Parameters:
|
|
# date - Dictionary containing 'year', 'dayOfYear', and
|
|
# 'localSeconds' fields.
|
|
#
|
|
# Results:
|
|
# Returns the given date formatted as a StarDate.
|
|
#
|
|
# Side effects:
|
|
# None.
|
|
#
|
|
# Jeff Hobbs put this in to support an atrocious pun about Tcl being
|
|
# "Enterprise ready." Now we're stuck with it.
|
|
#
|
|
#----------------------------------------------------------------------
|
|
|
|
proc ::tcl::clock::FormatStarDate { date } {
|
|
variable Roddenberry
|
|
|
|
# Get day of year, zero based
|
|
|
|
set doy [expr { [dict get $date dayOfYear] - 1 }]
|
|
|
|
# Determine whether the year is a leap year
|
|
|
|
set lp [IsGregorianLeapYear $date]
|
|
|
|
# Convert day of year to a fractional year
|
|
|
|
if { $lp } {
|
|
set fractYear [expr { 1000 * $doy / 366 }]
|
|
} else {
|
|
set fractYear [expr { 1000 * $doy / 365 }]
|
|
}
|
|
|
|
# Put together the StarDate
|
|
|
|
return [::format "Stardate %02d%03d.%1d" \
|
|
[expr { [dict get $date year] - $Roddenberry }] \
|
|
$fractYear \
|
|
[expr { [dict get $date localSeconds] % 86400
|
|
/ ( 86400 / 10 ) }]]
|
|
}
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# ParseStarDate --
|
|
#
|
|
# Parses a StarDate
|
|
#
|
|
# Parameters:
|
|
# year - Year from the Roddenberry epoch
|
|
# fractYear - Fraction of a year specifiying the day of year.
|
|
# fractDay - Fraction of a day
|
|
#
|
|
# Results:
|
|
# Returns a count of seconds from the Posix epoch.
|
|
#
|
|
# Side effects:
|
|
# None.
|
|
#
|
|
# Jeff Hobbs put this in to support an atrocious pun about Tcl being
|
|
# "Enterprise ready." Now we're stuck with it.
|
|
#
|
|
#----------------------------------------------------------------------
|
|
|
|
proc ::tcl::clock::ParseStarDate { year fractYear fractDay } {
|
|
variable Roddenberry
|
|
|
|
# Build a tentative date from year and fraction.
|
|
|
|
set date [dict create \
|
|
gregorian 1 \
|
|
era CE \
|
|
year [expr { $year + $Roddenberry }] \
|
|
dayOfYear [expr { $fractYear * 365 / 1000 + 1 }]]
|
|
set date [GetJulianDayFromGregorianEraYearDay $date[set date {}]]
|
|
|
|
# Determine whether the given year is a leap year
|
|
|
|
set lp [IsGregorianLeapYear $date]
|
|
|
|
# Reconvert the fractional year according to whether the given year is a
|
|
# leap year
|
|
|
|
if { $lp } {
|
|
dict set date dayOfYear \
|
|
[expr { $fractYear * 366 / 1000 + 1 }]
|
|
} else {
|
|
dict set date dayOfYear \
|
|
[expr { $fractYear * 365 / 1000 + 1 }]
|
|
}
|
|
dict unset date julianDay
|
|
dict unset date gregorian
|
|
set date [GetJulianDayFromGregorianEraYearDay $date[set date {}]]
|
|
|
|
return [expr {
|
|
86400 * [dict get $date julianDay]
|
|
- 210866803200
|
|
+ ( 86400 / 10 ) * $fractDay
|
|
}]
|
|
}
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# ScanWide --
|
|
#
|
|
# Scans a wide integer from an input
|
|
#
|
|
# Parameters:
|
|
# str - String containing a decimal wide integer
|
|
#
|
|
# Results:
|
|
# Returns the string as a pure wide integer. Throws an error if the
|
|
# string is misformatted or out of range.
|
|
#
|
|
#----------------------------------------------------------------------
|
|
|
|
proc ::tcl::clock::ScanWide { str } {
|
|
set count [::scan $str {%ld %c} result junk]
|
|
if { $count != 1 } {
|
|
return -code error -errorcode [list CLOCK notAnInteger $str] \
|
|
"\"$str\" is not an integer"
|
|
}
|
|
if { [incr result 0] != $str } {
|
|
return -code error -errorcode [list CLOCK integervalueTooLarge] \
|
|
"integer value too large to represent"
|
|
}
|
|
return $result
|
|
}
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# InterpretTwoDigitYear --
|
|
#
|
|
# Given a date that contains only the year of the century, determines
|
|
# the target value of a two-digit year.
|
|
#
|
|
# Parameters:
|
|
# date - Dictionary containing fields of the date.
|
|
# baseTime - Base time relative to which the date is expressed.
|
|
# twoDigitField - Name of the field that stores the two-digit year.
|
|
# Default is 'yearOfCentury'
|
|
# fourDigitField - Name of the field that will receive the four-digit
|
|
# year. Default is 'year'
|
|
#
|
|
# Results:
|
|
# Returns the dictionary augmented with the four-digit year, stored in
|
|
# the given key.
|
|
#
|
|
# Side effects:
|
|
# None.
|
|
#
|
|
# The current rule for interpreting a two-digit year is that the year shall be
|
|
# between 1937 and 2037, thus staying within the range of a 32-bit signed
|
|
# value for time. This rule may change to a sliding window in future
|
|
# versions, so the 'baseTime' parameter (which is currently ignored) is
|
|
# provided in the procedure signature.
|
|
#
|
|
#----------------------------------------------------------------------
|
|
|
|
proc ::tcl::clock::InterpretTwoDigitYear { date baseTime
|
|
{ twoDigitField yearOfCentury }
|
|
{ fourDigitField year } } {
|
|
set yr [dict get $date $twoDigitField]
|
|
if { $yr <= 37 } {
|
|
dict set date $fourDigitField [expr { $yr + 2000 }]
|
|
} else {
|
|
dict set date $fourDigitField [expr { $yr + 1900 }]
|
|
}
|
|
return $date
|
|
}
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# AssignBaseYear --
|
|
#
|
|
# Places the number of the current year into a dictionary.
|
|
#
|
|
# Parameters:
|
|
# date - Dictionary value to update
|
|
# baseTime - Base time from which to extract the year, expressed
|
|
# in seconds from the Posix epoch
|
|
# timezone - the time zone in which the date is being scanned
|
|
# changeover - the Julian Day on which the Gregorian calendar
|
|
# was adopted in the target locale.
|
|
#
|
|
# Results:
|
|
# Returns the dictionary with the current year assigned.
|
|
#
|
|
# Side effects:
|
|
# None.
|
|
#
|
|
#----------------------------------------------------------------------
|
|
|
|
proc ::tcl::clock::AssignBaseYear { date baseTime timezone changeover } {
|
|
variable TZData
|
|
|
|
# Find the Julian Day Number corresponding to the base time, and
|
|
# find the Gregorian year corresponding to that Julian Day.
|
|
|
|
set date2 [GetDateFields $baseTime $TZData($timezone) $changeover]
|
|
|
|
# Store the converted year
|
|
|
|
dict set date era [dict get $date2 era]
|
|
dict set date year [dict get $date2 year]
|
|
|
|
return $date
|
|
}
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# AssignBaseIso8601Year --
|
|
#
|
|
# Determines the base year in the ISO8601 fiscal calendar.
|
|
#
|
|
# Parameters:
|
|
# date - Dictionary containing the fields of the date that
|
|
# is to be augmented with the base year.
|
|
# baseTime - Base time expressed in seconds from the Posix epoch.
|
|
# timeZone - Target time zone
|
|
# changeover - Julian Day of adoption of the Gregorian calendar in
|
|
# the target locale.
|
|
#
|
|
# Results:
|
|
# Returns the given date with "iso8601Year" set to the
|
|
# base year.
|
|
#
|
|
# Side effects:
|
|
# None.
|
|
#
|
|
#----------------------------------------------------------------------
|
|
|
|
proc ::tcl::clock::AssignBaseIso8601Year {date baseTime timeZone changeover} {
|
|
variable TZData
|
|
|
|
# Find the Julian Day Number corresponding to the base time
|
|
|
|
set date2 [GetDateFields $baseTime $TZData($timeZone) $changeover]
|
|
|
|
# Calculate the ISO8601 date and transfer the year
|
|
|
|
dict set date era CE
|
|
dict set date iso8601Year [dict get $date2 iso8601Year]
|
|
return $date
|
|
}
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# AssignBaseMonth --
|
|
#
|
|
# Places the number of the current year and month into a
|
|
# dictionary.
|
|
#
|
|
# Parameters:
|
|
# date - Dictionary value to update
|
|
# baseTime - Time from which the year and month are to be
|
|
# obtained, expressed in seconds from the Posix epoch.
|
|
# timezone - Name of the desired time zone
|
|
# changeover - Julian Day on which the Gregorian calendar was adopted.
|
|
#
|
|
# Results:
|
|
# Returns the dictionary with the base year and month assigned.
|
|
#
|
|
# Side effects:
|
|
# None.
|
|
#
|
|
#----------------------------------------------------------------------
|
|
|
|
proc ::tcl::clock::AssignBaseMonth {date baseTime timezone changeover} {
|
|
variable TZData
|
|
|
|
# Find the year and month corresponding to the base time
|
|
|
|
set date2 [GetDateFields $baseTime $TZData($timezone) $changeover]
|
|
dict set date era [dict get $date2 era]
|
|
dict set date year [dict get $date2 year]
|
|
dict set date month [dict get $date2 month]
|
|
return $date
|
|
}
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# AssignBaseWeek --
|
|
#
|
|
# Determines the base year and week in the ISO8601 fiscal calendar.
|
|
#
|
|
# Parameters:
|
|
# date - Dictionary containing the fields of the date that
|
|
# is to be augmented with the base year and week.
|
|
# baseTime - Base time expressed in seconds from the Posix epoch.
|
|
# changeover - Julian Day on which the Gregorian calendar was adopted
|
|
# in the target locale.
|
|
#
|
|
# Results:
|
|
# Returns the given date with "iso8601Year" set to the
|
|
# base year and "iso8601Week" to the week number.
|
|
#
|
|
# Side effects:
|
|
# None.
|
|
#
|
|
#----------------------------------------------------------------------
|
|
|
|
proc ::tcl::clock::AssignBaseWeek {date baseTime timeZone changeover} {
|
|
variable TZData
|
|
|
|
# Find the Julian Day Number corresponding to the base time
|
|
|
|
set date2 [GetDateFields $baseTime $TZData($timeZone) $changeover]
|
|
|
|
# Calculate the ISO8601 date and transfer the year
|
|
|
|
dict set date era CE
|
|
dict set date iso8601Year [dict get $date2 iso8601Year]
|
|
dict set date iso8601Week [dict get $date2 iso8601Week]
|
|
return $date
|
|
}
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# AssignBaseJulianDay --
|
|
#
|
|
# Determines the base day for a time-of-day conversion.
|
|
#
|
|
# Parameters:
|
|
# date - Dictionary that is to get the base day
|
|
# baseTime - Base time expressed in seconds from the Posix epoch
|
|
# changeover - Julian day on which the Gregorian calendar was
|
|
# adpoted in the target locale.
|
|
#
|
|
# Results:
|
|
# Returns the given dictionary augmented with a 'julianDay' field
|
|
# that contains the base day.
|
|
#
|
|
# Side effects:
|
|
# None.
|
|
#
|
|
#----------------------------------------------------------------------
|
|
|
|
proc ::tcl::clock::AssignBaseJulianDay { date baseTime timeZone changeover } {
|
|
variable TZData
|
|
|
|
# Find the Julian Day Number corresponding to the base time
|
|
|
|
set date2 [GetDateFields $baseTime $TZData($timeZone) $changeover]
|
|
dict set date julianDay [dict get $date2 julianDay]
|
|
|
|
return $date
|
|
}
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# InterpretHMSP --
|
|
#
|
|
# Interprets a time in the form "hh:mm:ss am".
|
|
#
|
|
# Parameters:
|
|
# date -- Dictionary containing "hourAMPM", "minute", "second"
|
|
# and "amPmIndicator" fields.
|
|
#
|
|
# Results:
|
|
# Returns the number of seconds from local midnight.
|
|
#
|
|
# Side effects:
|
|
# None.
|
|
#
|
|
#----------------------------------------------------------------------
|
|
|
|
proc ::tcl::clock::InterpretHMSP { date } {
|
|
set hr [dict get $date hourAMPM]
|
|
if { $hr == 12 } {
|
|
set hr 0
|
|
}
|
|
if { [dict get $date amPmIndicator] } {
|
|
incr hr 12
|
|
}
|
|
dict set date hour $hr
|
|
return [InterpretHMS $date[set date {}]]
|
|
}
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# InterpretHMS --
|
|
#
|
|
# Interprets a 24-hour time "hh:mm:ss"
|
|
#
|
|
# Parameters:
|
|
# date -- Dictionary containing the "hour", "minute" and "second"
|
|
# fields.
|
|
#
|
|
# Results:
|
|
# Returns the given dictionary augmented with a "secondOfDay"
|
|
# field containing the number of seconds from local midnight.
|
|
#
|
|
# Side effects:
|
|
# None.
|
|
#
|
|
#----------------------------------------------------------------------
|
|
|
|
proc ::tcl::clock::InterpretHMS { date } {
|
|
return [expr {
|
|
( [dict get $date hour] * 60
|
|
+ [dict get $date minute] ) * 60
|
|
+ [dict get $date second]
|
|
}]
|
|
}
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# GetSystemTimeZone --
|
|
#
|
|
# Determines the system time zone, which is the default for the
|
|
# 'clock' command if no other zone is supplied.
|
|
#
|
|
# Parameters:
|
|
# None.
|
|
#
|
|
# Results:
|
|
# Returns the system time zone.
|
|
#
|
|
# Side effects:
|
|
# Stores the sustem time zone in the 'CachedSystemTimeZone'
|
|
# variable, since determining it may be an expensive process.
|
|
#
|
|
#----------------------------------------------------------------------
|
|
|
|
proc ::tcl::clock::GetSystemTimeZone {} {
|
|
variable CachedSystemTimeZone
|
|
variable TimeZoneBad
|
|
|
|
if {[set result [getenv TCL_TZ]] ne {}} {
|
|
set timezone $result
|
|
} elseif {[set result [getenv TZ]] ne {}} {
|
|
set timezone $result
|
|
}
|
|
if {![info exists timezone]} {
|
|
# Cache the time zone only if it was detected by one of the
|
|
# expensive methods.
|
|
if { [info exists CachedSystemTimeZone] } {
|
|
set timezone $CachedSystemTimeZone
|
|
} elseif { $::tcl_platform(platform) eq {windows} } {
|
|
set timezone [GuessWindowsTimeZone]
|
|
} elseif { [file exists /etc/localtime]
|
|
&& ![catch {ReadZoneinfoFile \
|
|
Tcl/Localtime /etc/localtime}] } {
|
|
set timezone :Tcl/Localtime
|
|
} else {
|
|
set timezone :localtime
|
|
}
|
|
set CachedSystemTimeZone $timezone
|
|
}
|
|
if { ![dict exists $TimeZoneBad $timezone] } {
|
|
dict set TimeZoneBad $timezone [catch {SetupTimeZone $timezone}]
|
|
}
|
|
if { [dict get $TimeZoneBad $timezone] } {
|
|
return :localtime
|
|
} else {
|
|
return $timezone
|
|
}
|
|
}
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# ConvertLegacyTimeZone --
|
|
#
|
|
# Given an alphanumeric time zone identifier and the system time zone,
|
|
# convert the alphanumeric identifier to an unambiguous time zone.
|
|
#
|
|
# Parameters:
|
|
# tzname - Name of the time zone to convert
|
|
#
|
|
# Results:
|
|
# Returns a time zone name corresponding to tzname, but in an
|
|
# unambiguous form, generally +hhmm.
|
|
#
|
|
# This procedure is implemented primarily to allow the parsing of RFC822
|
|
# date/time strings. Processing a time zone name on input is not recommended
|
|
# practice, because there is considerable room for ambiguity; for instance, is
|
|
# BST Brazilian Standard Time, or British Summer Time?
|
|
#
|
|
#----------------------------------------------------------------------
|
|
|
|
proc ::tcl::clock::ConvertLegacyTimeZone { tzname } {
|
|
variable LegacyTimeZone
|
|
|
|
set tzname [string tolower $tzname]
|
|
if { ![dict exists $LegacyTimeZone $tzname] } {
|
|
return -code error -errorcode [list CLOCK badTZName $tzname] \
|
|
"time zone \"$tzname\" not found"
|
|
}
|
|
return [dict get $LegacyTimeZone $tzname]
|
|
}
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# SetupTimeZone --
|
|
#
|
|
# Given the name or specification of a time zone, sets up its in-memory
|
|
# data.
|
|
#
|
|
# Parameters:
|
|
# tzname - Name of a time zone
|
|
#
|
|
# Results:
|
|
# Unless the time zone is ':localtime', sets the TZData array to contain
|
|
# the lookup table for local<->UTC conversion. Returns an error if the
|
|
# time zone cannot be parsed.
|
|
#
|
|
#----------------------------------------------------------------------
|
|
|
|
proc ::tcl::clock::SetupTimeZone { timezone } {
|
|
variable TZData
|
|
|
|
if {! [info exists TZData($timezone)] } {
|
|
variable MINWIDE
|
|
if { $timezone eq {:localtime} } {
|
|
# Nothing to do, we'll convert using the localtime function
|
|
|
|
} elseif {
|
|
[regexp {^([-+])(\d\d)(?::?(\d\d)(?::?(\d\d))?)?} $timezone \
|
|
-> s hh mm ss]
|
|
} then {
|
|
# Make a fixed offset
|
|
|
|
::scan $hh %d hh
|
|
if { $mm eq {} } {
|
|
set mm 0
|
|
} else {
|
|
::scan $mm %d mm
|
|
}
|
|
if { $ss eq {} } {
|
|
set ss 0
|
|
} else {
|
|
::scan $ss %d ss
|
|
}
|
|
set offset [expr { ( $hh * 60 + $mm ) * 60 + $ss }]
|
|
if { $s eq {-} } {
|
|
set offset [expr { - $offset }]
|
|
}
|
|
set TZData($timezone) [list [list $MINWIDE $offset -1 $timezone]]
|
|
|
|
} elseif { [string index $timezone 0] eq {:} } {
|
|
# Convert using a time zone file
|
|
|
|
if {
|
|
[catch {
|
|
LoadTimeZoneFile [string range $timezone 1 end]
|
|
}] && [catch {
|
|
LoadZoneinfoFile [string range $timezone 1 end]
|
|
}]
|
|
} then {
|
|
return -code error \
|
|
-errorcode [list CLOCK badTimeZone $timezone] \
|
|
"time zone \"$timezone\" not found"
|
|
}
|
|
} elseif { ![catch {ParsePosixTimeZone $timezone} tzfields] } {
|
|
# This looks like a POSIX time zone - try to process it
|
|
|
|
if { [catch {ProcessPosixTimeZone $tzfields} data opts] } {
|
|
if { [lindex [dict get $opts -errorcode] 0] eq {CLOCK} } {
|
|
dict unset opts -errorinfo
|
|
}
|
|
return -options $opts $data
|
|
} else {
|
|
set TZData($timezone) $data
|
|
}
|
|
|
|
} else {
|
|
# We couldn't parse this as a POSIX time zone. Try again with a
|
|
# time zone file - this time without a colon
|
|
|
|
if { [catch { LoadTimeZoneFile $timezone }]
|
|
&& [catch { LoadZoneinfoFile $timezone } - opts] } {
|
|
dict unset opts -errorinfo
|
|
return -options $opts "time zone $timezone not found"
|
|
}
|
|
set TZData($timezone) $TZData(:$timezone)
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# GuessWindowsTimeZone --
|
|
#
|
|
# Determines the system time zone on windows.
|
|
#
|
|
# Parameters:
|
|
# None.
|
|
#
|
|
# Results:
|
|
# Returns a time zone specifier that corresponds to the system time zone
|
|
# information found in the Registry.
|
|
#
|
|
# Bugs:
|
|
# Fixed dates for DST change are unimplemented at present, because no
|
|
# time zone information supplied with Windows actually uses them!
|
|
#
|
|
# On a Windows system where neither $env(TCL_TZ) nor $env(TZ) is specified,
|
|
# GuessWindowsTimeZone looks in the Registry for the system time zone
|
|
# information. It then attempts to find an entry in WinZoneInfo for a time
|
|
# zone that uses the same rules. If it finds one, it returns it; otherwise,
|
|
# it constructs a Posix-style time zone string and returns that.
|
|
#
|
|
#----------------------------------------------------------------------
|
|
|
|
proc ::tcl::clock::GuessWindowsTimeZone {} {
|
|
variable WinZoneInfo
|
|
variable NoRegistry
|
|
variable TimeZoneBad
|
|
|
|
if { [info exists NoRegistry] } {
|
|
return :localtime
|
|
}
|
|
|
|
# Dredge time zone information out of the registry
|
|
|
|
if { [catch {
|
|
set rpath HKEY_LOCAL_MACHINE\\System\\CurrentControlSet\\Control\\TimeZoneInformation
|
|
set data [list \
|
|
[expr { -60
|
|
* [registry get $rpath Bias] }] \
|
|
[expr { -60
|
|
* [registry get $rpath StandardBias] }] \
|
|
[expr { -60 \
|
|
* [registry get $rpath DaylightBias] }]]
|
|
set stdtzi [registry get $rpath StandardStart]
|
|
foreach ind {0 2 14 4 6 8 10 12} {
|
|
binary scan $stdtzi @${ind}s val
|
|
lappend data $val
|
|
}
|
|
set daytzi [registry get $rpath DaylightStart]
|
|
foreach ind {0 2 14 4 6 8 10 12} {
|
|
binary scan $daytzi @${ind}s val
|
|
lappend data $val
|
|
}
|
|
}] } {
|
|
# Missing values in the Registry - bail out
|
|
|
|
return :localtime
|
|
}
|
|
|
|
# Make up a Posix time zone specifier if we can't find one. Check here
|
|
# that the tzdata file exists, in case we're running in an environment
|
|
# (e.g. starpack) where tzdata is incomplete. (Bug 1237907)
|
|
|
|
if { [dict exists $WinZoneInfo $data] } {
|
|
set tzname [dict get $WinZoneInfo $data]
|
|
if { ! [dict exists $TimeZoneBad $tzname] } {
|
|
dict set TimeZoneBad $tzname [catch {SetupTimeZone $tzname}]
|
|
}
|
|
} else {
|
|
set tzname {}
|
|
}
|
|
if { $tzname eq {} || [dict get $TimeZoneBad $tzname] } {
|
|
lassign $data \
|
|
bias stdBias dstBias \
|
|
stdYear stdMonth stdDayOfWeek stdDayOfMonth \
|
|
stdHour stdMinute stdSecond stdMillisec \
|
|
dstYear dstMonth dstDayOfWeek dstDayOfMonth \
|
|
dstHour dstMinute dstSecond dstMillisec
|
|
set stdDelta [expr { $bias + $stdBias }]
|
|
set dstDelta [expr { $bias + $dstBias }]
|
|
if { $stdDelta <= 0 } {
|
|
set stdSignum +
|
|
set stdDelta [expr { - $stdDelta }]
|
|
set dispStdSignum -
|
|
} else {
|
|
set stdSignum -
|
|
set dispStdSignum +
|
|
}
|
|
set hh [::format %02d [expr { $stdDelta / 3600 }]]
|
|
set mm [::format %02d [expr { ($stdDelta / 60 ) % 60 }]]
|
|
set ss [::format %02d [expr { $stdDelta % 60 }]]
|
|
set tzname {}
|
|
append tzname < $dispStdSignum $hh $mm > $stdSignum $hh : $mm : $ss
|
|
if { $stdMonth >= 0 } {
|
|
if { $dstDelta <= 0 } {
|
|
set dstSignum +
|
|
set dstDelta [expr { - $dstDelta }]
|
|
set dispDstSignum -
|
|
} else {
|
|
set dstSignum -
|
|
set dispDstSignum +
|
|
}
|
|
set hh [::format %02d [expr { $dstDelta / 3600 }]]
|
|
set mm [::format %02d [expr { ($dstDelta / 60 ) % 60 }]]
|
|
set ss [::format %02d [expr { $dstDelta % 60 }]]
|
|
append tzname < $dispDstSignum $hh $mm > $dstSignum $hh : $mm : $ss
|
|
if { $dstYear == 0 } {
|
|
append tzname ,M $dstMonth . $dstDayOfMonth . $dstDayOfWeek
|
|
} else {
|
|
# I have not been able to find any locale on which Windows
|
|
# converts time zone on a fixed day of the year, hence don't
|
|
# know how to interpret the fields. If someone can inform me,
|
|
# I'd be glad to code it up. For right now, we bail out in
|
|
# such a case.
|
|
return :localtime
|
|
}
|
|
append tzname / [::format %02d $dstHour] \
|
|
: [::format %02d $dstMinute] \
|
|
: [::format %02d $dstSecond]
|
|
if { $stdYear == 0 } {
|
|
append tzname ,M $stdMonth . $stdDayOfMonth . $stdDayOfWeek
|
|
} else {
|
|
# I have not been able to find any locale on which Windows
|
|
# converts time zone on a fixed day of the year, hence don't
|
|
# know how to interpret the fields. If someone can inform me,
|
|
# I'd be glad to code it up. For right now, we bail out in
|
|
# such a case.
|
|
return :localtime
|
|
}
|
|
append tzname / [::format %02d $stdHour] \
|
|
: [::format %02d $stdMinute] \
|
|
: [::format %02d $stdSecond]
|
|
}
|
|
dict set WinZoneInfo $data $tzname
|
|
}
|
|
|
|
return [dict get $WinZoneInfo $data]
|
|
}
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# LoadTimeZoneFile --
|
|
#
|
|
# Load the data file that specifies the conversion between a
|
|
# given time zone and Greenwich.
|
|
#
|
|
# Parameters:
|
|
# fileName -- Name of the file to load
|
|
#
|
|
# Results:
|
|
# None.
|
|
#
|
|
# Side effects:
|
|
# TZData(:fileName) contains the time zone data
|
|
#
|
|
#----------------------------------------------------------------------
|
|
|
|
proc ::tcl::clock::LoadTimeZoneFile { fileName } {
|
|
variable DataDir
|
|
variable TZData
|
|
|
|
if { [info exists TZData($fileName)] } {
|
|
return
|
|
}
|
|
|
|
# Since an unsafe interp uses the [clock] command in the master, this code
|
|
# is security sensitive. Make sure that the path name cannot escape the
|
|
# given directory.
|
|
|
|
if { ![regexp {^[[.-.][:alpha:]_]+(?:/[[.-.][:alpha:]_]+)*$} $fileName] } {
|
|
return -code error \
|
|
-errorcode [list CLOCK badTimeZone $:fileName] \
|
|
"time zone \":$fileName\" not valid"
|
|
}
|
|
try {
|
|
source -encoding utf-8 [file join $DataDir $fileName]
|
|
} on error {} {
|
|
return -code error \
|
|
-errorcode [list CLOCK badTimeZone :$fileName] \
|
|
"time zone \":$fileName\" not found"
|
|
}
|
|
return
|
|
}
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# LoadZoneinfoFile --
|
|
#
|
|
# Loads a binary time zone information file in Olson format.
|
|
#
|
|
# Parameters:
|
|
# fileName - Relative path name of the file to load.
|
|
#
|
|
# Results:
|
|
# Returns an empty result normally; returns an error if no Olson file
|
|
# was found or the file was malformed in some way.
|
|
#
|
|
# Side effects:
|
|
# TZData(:fileName) contains the time zone data
|
|
#
|
|
#----------------------------------------------------------------------
|
|
|
|
proc ::tcl::clock::LoadZoneinfoFile { fileName } {
|
|
variable ZoneinfoPaths
|
|
|
|
# Since an unsafe interp uses the [clock] command in the master, this code
|
|
# is security sensitive. Make sure that the path name cannot escape the
|
|
# given directory.
|
|
|
|
if { ![regexp {^[[.-.][:alpha:]_]+(?:/[[.-.][:alpha:]_]+)*$} $fileName] } {
|
|
return -code error \
|
|
-errorcode [list CLOCK badTimeZone $:fileName] \
|
|
"time zone \":$fileName\" not valid"
|
|
}
|
|
foreach d $ZoneinfoPaths {
|
|
set fname [file join $d $fileName]
|
|
if { [file readable $fname] && [file isfile $fname] } {
|
|
break
|
|
}
|
|
unset fname
|
|
}
|
|
ReadZoneinfoFile $fileName $fname
|
|
}
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# ReadZoneinfoFile --
|
|
#
|
|
# Loads a binary time zone information file in Olson format.
|
|
#
|
|
# Parameters:
|
|
# fileName - Name of the time zone (relative path name of the
|
|
# file).
|
|
# fname - Absolute path name of the file.
|
|
#
|
|
# Results:
|
|
# Returns an empty result normally; returns an error if no Olson file
|
|
# was found or the file was malformed in some way.
|
|
#
|
|
# Side effects:
|
|
# TZData(:fileName) contains the time zone data
|
|
#
|
|
#----------------------------------------------------------------------
|
|
|
|
proc ::tcl::clock::ReadZoneinfoFile {fileName fname} {
|
|
variable MINWIDE
|
|
variable TZData
|
|
if { ![file exists $fname] } {
|
|
return -code error "$fileName not found"
|
|
}
|
|
|
|
if { [file size $fname] > 262144 } {
|
|
return -code error "$fileName too big"
|
|
}
|
|
|
|
# Suck in all the data from the file
|
|
|
|
set f [open $fname r]
|
|
fconfigure $f -translation binary
|
|
set d [read $f]
|
|
close $f
|
|
|
|
# The file begins with a magic number, sixteen reserved bytes, and then
|
|
# six 4-byte integers giving counts of fileds in the file.
|
|
|
|
binary scan $d a4a1x15IIIIII \
|
|
magic version nIsGMT nIsStd nLeap nTime nType nChar
|
|
set seek 44
|
|
set ilen 4
|
|
set iformat I
|
|
if { $magic != {TZif} } {
|
|
return -code error "$fileName not a time zone information file"
|
|
}
|
|
if { $nType > 255 } {
|
|
return -code error "$fileName contains too many time types"
|
|
}
|
|
# Accept only Posix-style zoneinfo. Sorry, 'leaps' bigots.
|
|
if { $nLeap != 0 } {
|
|
return -code error "$fileName contains leap seconds"
|
|
}
|
|
|
|
# In a version 2 file, we use the second part of the file, which contains
|
|
# 64-bit transition times.
|
|
|
|
if {$version eq "2"} {
|
|
set seek [expr {
|
|
44
|
|
+ 5 * $nTime
|
|
+ 6 * $nType
|
|
+ 4 * $nLeap
|
|
+ $nIsStd
|
|
+ $nIsGMT
|
|
+ $nChar
|
|
}]
|
|
binary scan $d @${seek}a4a1x15IIIIII \
|
|
magic version nIsGMT nIsStd nLeap nTime nType nChar
|
|
if {$magic ne {TZif}} {
|
|
return -code error "seek address $seek miscomputed, magic = $magic"
|
|
}
|
|
set iformat W
|
|
set ilen 8
|
|
incr seek 44
|
|
}
|
|
|
|
# Next come ${nTime} transition times, followed by ${nTime} time type
|
|
# codes. The type codes are unsigned 1-byte quantities. We insert an
|
|
# arbitrary start time in front of the transitions.
|
|
|
|
binary scan $d @${seek}${iformat}${nTime}c${nTime} times tempCodes
|
|
incr seek [expr { ($ilen + 1) * $nTime }]
|
|
set times [linsert $times 0 $MINWIDE]
|
|
set codes {}
|
|
foreach c $tempCodes {
|
|
lappend codes [expr { $c & 0xff }]
|
|
}
|
|
set codes [linsert $codes 0 0]
|
|
|
|
# Next come ${nType} time type descriptions, each of which has an offset
|
|
# (seconds east of GMT), a DST indicator, and an index into the
|
|
# abbreviation text.
|
|
|
|
for { set i 0 } { $i < $nType } { incr i } {
|
|
binary scan $d @${seek}Icc gmtOff isDst abbrInd
|
|
lappend types [list $gmtOff $isDst $abbrInd]
|
|
incr seek 6
|
|
}
|
|
|
|
# Next come $nChar characters of time zone name abbreviations, which are
|
|
# null-terminated.
|
|
# We build them up into a dictionary indexed by character index, because
|
|
# that's what's in the indices above.
|
|
|
|
binary scan $d @${seek}a${nChar} abbrs
|
|
incr seek ${nChar}
|
|
set abbrList [split $abbrs \0]
|
|
set i 0
|
|
set abbrevs {}
|
|
foreach a $abbrList {
|
|
for {set j 0} {$j <= [string length $a]} {incr j} {
|
|
dict set abbrevs $i [string range $a $j end]
|
|
incr i
|
|
}
|
|
}
|
|
|
|
# Package up a list of tuples, each of which contains transition time,
|
|
# seconds east of Greenwich, DST flag and time zone abbreviation.
|
|
|
|
set r {}
|
|
set lastTime $MINWIDE
|
|
foreach t $times c $codes {
|
|
if { $t < $lastTime } {
|
|
return -code error "$fileName has times out of order"
|
|
}
|
|
set lastTime $t
|
|
lassign [lindex $types $c] gmtoff isDst abbrInd
|
|
set abbrev [dict get $abbrevs $abbrInd]
|
|
lappend r [list $t $gmtoff $isDst $abbrev]
|
|
}
|
|
|
|
# In a version 2 file, there is also a POSIX-style time zone description
|
|
# at the very end of the file. To get to it, skip over nLeap leap second
|
|
# values (8 bytes each),
|
|
# nIsStd standard/DST indicators and nIsGMT UTC/local indicators.
|
|
|
|
if {$version eq {2}} {
|
|
set seek [expr {$seek + 8 * $nLeap + $nIsStd + $nIsGMT + 1}]
|
|
set last [string first \n $d $seek]
|
|
set posix [string range $d $seek [expr {$last-1}]]
|
|
if {[llength $posix] > 0} {
|
|
set posixFields [ParsePosixTimeZone $posix]
|
|
foreach tuple [ProcessPosixTimeZone $posixFields] {
|
|
lassign $tuple t gmtoff isDst abbrev
|
|
if {$t > $lastTime} {
|
|
lappend r $tuple
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
set TZData(:$fileName) $r
|
|
|
|
return
|
|
}
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# ParsePosixTimeZone --
|
|
#
|
|
# Parses the TZ environment variable in Posix form
|
|
#
|
|
# Parameters:
|
|
# tz Time zone specifier to be interpreted
|
|
#
|
|
# Results:
|
|
# Returns a dictionary whose values contain the various pieces of the
|
|
# time zone specification.
|
|
#
|
|
# Side effects:
|
|
# None.
|
|
#
|
|
# Errors:
|
|
# Throws an error if the syntax of the time zone is incorrect.
|
|
#
|
|
# The following keys are present in the dictionary:
|
|
# stdName - Name of the time zone when Daylight Saving Time
|
|
# is not in effect.
|
|
# stdSignum - Sign (+, -, or empty) of the offset from Greenwich
|
|
# to the given (non-DST) time zone. + and the empty
|
|
# string denote zones west of Greenwich, - denotes east
|
|
# of Greenwich; this is contrary to the ISO convention
|
|
# but follows Posix.
|
|
# stdHours - Hours part of the offset from Greenwich to the given
|
|
# (non-DST) time zone.
|
|
# stdMinutes - Minutes part of the offset from Greenwich to the
|
|
# given (non-DST) time zone. Empty denotes zero.
|
|
# stdSeconds - Seconds part of the offset from Greenwich to the
|
|
# given (non-DST) time zone. Empty denotes zero.
|
|
# dstName - Name of the time zone when DST is in effect, or the
|
|
# empty string if the time zone does not observe Daylight
|
|
# Saving Time.
|
|
# dstSignum, dstHours, dstMinutes, dstSeconds -
|
|
# Fields corresponding to stdSignum, stdHours, stdMinutes,
|
|
# stdSeconds for the Daylight Saving Time version of the
|
|
# time zone. If dstHours is empty, it is presumed to be 1.
|
|
# startDayOfYear - The ordinal number of the day of the year on which
|
|
# Daylight Saving Time begins. If this field is
|
|
# empty, then DST begins on a given month-week-day,
|
|
# as below.
|
|
# startJ - The letter J, or an empty string. If a J is present in
|
|
# this field, then startDayOfYear does not count February 29
|
|
# even in leap years.
|
|
# startMonth - The number of the month in which Daylight Saving Time
|
|
# begins, supplied if startDayOfYear is empty. If both
|
|
# startDayOfYear and startMonth are empty, then US rules
|
|
# are presumed.
|
|
# startWeekOfMonth - The number of the week in the month in which
|
|
# Daylight Saving Time begins, in the range 1-5.
|
|
# 5 denotes the last week of the month even in a
|
|
# 4-week month.
|
|
# startDayOfWeek - The number of the day of the week (Sunday=0,
|
|
# Saturday=6) on which Daylight Saving Time begins.
|
|
# startHours - The hours part of the time of day at which Daylight
|
|
# Saving Time begins. An empty string is presumed to be 2.
|
|
# startMinutes - The minutes part of the time of day at which DST begins.
|
|
# An empty string is presumed zero.
|
|
# startSeconds - The seconds part of the time of day at which DST begins.
|
|
# An empty string is presumed zero.
|
|
# endDayOfYear, endJ, endMonth, endWeekOfMonth, endDayOfWeek,
|
|
# endHours, endMinutes, endSeconds -
|
|
# Specify the end of DST in the same way that the start* fields
|
|
# specify the beginning of DST.
|
|
#
|
|
# This procedure serves only to break the time specifier into fields. No
|
|
# attempt is made to canonicalize the fields or supply default values.
|
|
#
|
|
#----------------------------------------------------------------------
|
|
|
|
proc ::tcl::clock::ParsePosixTimeZone { tz } {
|
|
if {[regexp -expanded -nocase -- {
|
|
^
|
|
# 1 - Standard time zone name
|
|
([[:alpha:]]+ | <[-+[:alnum:]]+>)
|
|
# 2 - Standard time zone offset, signum
|
|
([-+]?)
|
|
# 3 - Standard time zone offset, hours
|
|
([[:digit:]]{1,2})
|
|
(?:
|
|
# 4 - Standard time zone offset, minutes
|
|
: ([[:digit:]]{1,2})
|
|
(?:
|
|
# 5 - Standard time zone offset, seconds
|
|
: ([[:digit:]]{1,2} )
|
|
)?
|
|
)?
|
|
(?:
|
|
# 6 - DST time zone name
|
|
([[:alpha:]]+ | <[-+[:alnum:]]+>)
|
|
(?:
|
|
(?:
|
|
# 7 - DST time zone offset, signum
|
|
([-+]?)
|
|
# 8 - DST time zone offset, hours
|
|
([[:digit:]]{1,2})
|
|
(?:
|
|
# 9 - DST time zone offset, minutes
|
|
: ([[:digit:]]{1,2})
|
|
(?:
|
|
# 10 - DST time zone offset, seconds
|
|
: ([[:digit:]]{1,2})
|
|
)?
|
|
)?
|
|
)?
|
|
(?:
|
|
,
|
|
(?:
|
|
# 11 - Optional J in n and Jn form 12 - Day of year
|
|
( J ? ) ( [[:digit:]]+ )
|
|
| M
|
|
# 13 - Month number 14 - Week of month 15 - Day of week
|
|
( [[:digit:]] + )
|
|
[.] ( [[:digit:]] + )
|
|
[.] ( [[:digit:]] + )
|
|
)
|
|
(?:
|
|
# 16 - Start time of DST - hours
|
|
/ ( [[:digit:]]{1,2} )
|
|
(?:
|
|
# 17 - Start time of DST - minutes
|
|
: ( [[:digit:]]{1,2} )
|
|
(?:
|
|
# 18 - Start time of DST - seconds
|
|
: ( [[:digit:]]{1,2} )
|
|
)?
|
|
)?
|
|
)?
|
|
,
|
|
(?:
|
|
# 19 - Optional J in n and Jn form 20 - Day of year
|
|
( J ? ) ( [[:digit:]]+ )
|
|
| M
|
|
# 21 - Month number 22 - Week of month 23 - Day of week
|
|
( [[:digit:]] + )
|
|
[.] ( [[:digit:]] + )
|
|
[.] ( [[:digit:]] + )
|
|
)
|
|
(?:
|
|
# 24 - End time of DST - hours
|
|
/ ( [[:digit:]]{1,2} )
|
|
(?:
|
|
# 25 - End time of DST - minutes
|
|
: ( [[:digit:]]{1,2} )
|
|
(?:
|
|
# 26 - End time of DST - seconds
|
|
: ( [[:digit:]]{1,2} )
|
|
)?
|
|
)?
|
|
)?
|
|
)?
|
|
)?
|
|
)?
|
|
$
|
|
} $tz -> x(stdName) x(stdSignum) x(stdHours) x(stdMinutes) x(stdSeconds) \
|
|
x(dstName) x(dstSignum) x(dstHours) x(dstMinutes) x(dstSeconds) \
|
|
x(startJ) x(startDayOfYear) \
|
|
x(startMonth) x(startWeekOfMonth) x(startDayOfWeek) \
|
|
x(startHours) x(startMinutes) x(startSeconds) \
|
|
x(endJ) x(endDayOfYear) \
|
|
x(endMonth) x(endWeekOfMonth) x(endDayOfWeek) \
|
|
x(endHours) x(endMinutes) x(endSeconds)] } {
|
|
# it's a good timezone
|
|
|
|
return [array get x]
|
|
}
|
|
|
|
return -code error\
|
|
-errorcode [list CLOCK badTimeZone $tz] \
|
|
"unable to parse time zone specification \"$tz\""
|
|
}
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# ProcessPosixTimeZone --
|
|
#
|
|
# Handle a Posix time zone after it's been broken out into fields.
|
|
#
|
|
# Parameters:
|
|
# z - Dictionary returned from 'ParsePosixTimeZone'
|
|
#
|
|
# Results:
|
|
# Returns time zone information for the 'TZData' array.
|
|
#
|
|
# Side effects:
|
|
# None.
|
|
#
|
|
#----------------------------------------------------------------------
|
|
|
|
proc ::tcl::clock::ProcessPosixTimeZone { z } {
|
|
variable MINWIDE
|
|
variable TZData
|
|
|
|
# Determine the standard time zone name and seconds east of Greenwich
|
|
|
|
set stdName [dict get $z stdName]
|
|
if { [string index $stdName 0] eq {<} } {
|
|
set stdName [string range $stdName 1 end-1]
|
|
}
|
|
if { [dict get $z stdSignum] eq {-} } {
|
|
set stdSignum +1
|
|
} else {
|
|
set stdSignum -1
|
|
}
|
|
set stdHours [lindex [::scan [dict get $z stdHours] %d] 0]
|
|
if { [dict get $z stdMinutes] ne {} } {
|
|
set stdMinutes [lindex [::scan [dict get $z stdMinutes] %d] 0]
|
|
} else {
|
|
set stdMinutes 0
|
|
}
|
|
if { [dict get $z stdSeconds] ne {} } {
|
|
set stdSeconds [lindex [::scan [dict get $z stdSeconds] %d] 0]
|
|
} else {
|
|
set stdSeconds 0
|
|
}
|
|
set stdOffset [expr {
|
|
(($stdHours * 60 + $stdMinutes) * 60 + $stdSeconds) * $stdSignum
|
|
}]
|
|
set data [list [list $MINWIDE $stdOffset 0 $stdName]]
|
|
|
|
# If there's no daylight zone, we're done
|
|
|
|
set dstName [dict get $z dstName]
|
|
if { $dstName eq {} } {
|
|
return $data
|
|
}
|
|
if { [string index $dstName 0] eq {<} } {
|
|
set dstName [string range $dstName 1 end-1]
|
|
}
|
|
|
|
# Determine the daylight name
|
|
|
|
if { [dict get $z dstSignum] eq {-} } {
|
|
set dstSignum +1
|
|
} else {
|
|
set dstSignum -1
|
|
}
|
|
if { [dict get $z dstHours] eq {} } {
|
|
set dstOffset [expr { 3600 + $stdOffset }]
|
|
} else {
|
|
set dstHours [lindex [::scan [dict get $z dstHours] %d] 0]
|
|
if { [dict get $z dstMinutes] ne {} } {
|
|
set dstMinutes [lindex [::scan [dict get $z dstMinutes] %d] 0]
|
|
} else {
|
|
set dstMinutes 0
|
|
}
|
|
if { [dict get $z dstSeconds] ne {} } {
|
|
set dstSeconds [lindex [::scan [dict get $z dstSeconds] %d] 0]
|
|
} else {
|
|
set dstSeconds 0
|
|
}
|
|
set dstOffset [expr {
|
|
(($dstHours*60 + $dstMinutes) * 60 + $dstSeconds) * $dstSignum
|
|
}]
|
|
}
|
|
|
|
# Fill in defaults for European or US DST rules
|
|
# US start time is the second Sunday in March
|
|
# EU start time is the last Sunday in March
|
|
# US end time is the first Sunday in November.
|
|
# EU end time is the last Sunday in October
|
|
|
|
if {
|
|
[dict get $z startDayOfYear] eq {}
|
|
&& [dict get $z startMonth] eq {}
|
|
} then {
|
|
if {($stdSignum * $stdHours>=0) && ($stdSignum * $stdHours<=12)} {
|
|
# EU
|
|
dict set z startWeekOfMonth 5
|
|
if {$stdHours>2} {
|
|
dict set z startHours 2
|
|
} else {
|
|
dict set z startHours [expr {$stdHours+1}]
|
|
}
|
|
} else {
|
|
# US
|
|
dict set z startWeekOfMonth 2
|
|
dict set z startHours 2
|
|
}
|
|
dict set z startMonth 3
|
|
dict set z startDayOfWeek 0
|
|
dict set z startMinutes 0
|
|
dict set z startSeconds 0
|
|
}
|
|
if {
|
|
[dict get $z endDayOfYear] eq {}
|
|
&& [dict get $z endMonth] eq {}
|
|
} then {
|
|
if {($stdSignum * $stdHours>=0) && ($stdSignum * $stdHours<=12)} {
|
|
# EU
|
|
dict set z endMonth 10
|
|
dict set z endWeekOfMonth 5
|
|
if {$stdHours>2} {
|
|
dict set z endHours 3
|
|
} else {
|
|
dict set z endHours [expr {$stdHours+2}]
|
|
}
|
|
} else {
|
|
# US
|
|
dict set z endMonth 11
|
|
dict set z endWeekOfMonth 1
|
|
dict set z endHours 2
|
|
}
|
|
dict set z endDayOfWeek 0
|
|
dict set z endMinutes 0
|
|
dict set z endSeconds 0
|
|
}
|
|
|
|
# Put DST in effect in all years from 1916 to 2099.
|
|
|
|
for { set y 1916 } { $y < 2100 } { incr y } {
|
|
set startTime [DeterminePosixDSTTime $z start $y]
|
|
incr startTime [expr { - wide($stdOffset) }]
|
|
set endTime [DeterminePosixDSTTime $z end $y]
|
|
incr endTime [expr { - wide($dstOffset) }]
|
|
if { $startTime < $endTime } {
|
|
lappend data \
|
|
[list $startTime $dstOffset 1 $dstName] \
|
|
[list $endTime $stdOffset 0 $stdName]
|
|
} else {
|
|
lappend data \
|
|
[list $endTime $stdOffset 0 $stdName] \
|
|
[list $startTime $dstOffset 1 $dstName]
|
|
}
|
|
}
|
|
|
|
return $data
|
|
}
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# DeterminePosixDSTTime --
|
|
#
|
|
# Determines the time that Daylight Saving Time starts or ends from a
|
|
# Posix time zone specification.
|
|
#
|
|
# Parameters:
|
|
# z - Time zone data returned from ParsePosixTimeZone.
|
|
# Missing fields are expected to be filled in with
|
|
# default values.
|
|
# bound - The word 'start' or 'end'
|
|
# y - The year for which the transition time is to be determined.
|
|
#
|
|
# Results:
|
|
# Returns the transition time as a count of seconds from the epoch. The
|
|
# time is relative to the wall clock, not UTC.
|
|
#
|
|
#----------------------------------------------------------------------
|
|
|
|
proc ::tcl::clock::DeterminePosixDSTTime { z bound y } {
|
|
|
|
variable FEB_28
|
|
|
|
# Determine the start or end day of DST
|
|
|
|
set date [dict create era CE year $y]
|
|
set doy [dict get $z ${bound}DayOfYear]
|
|
if { $doy ne {} } {
|
|
|
|
# Time was specified as a day of the year
|
|
|
|
if { [dict get $z ${bound}J] ne {}
|
|
&& [IsGregorianLeapYear $y]
|
|
&& ( $doy > $FEB_28 ) } {
|
|
incr doy
|
|
}
|
|
dict set date dayOfYear $doy
|
|
set date [GetJulianDayFromEraYearDay $date[set date {}] 2361222]
|
|
} else {
|
|
# Time was specified as a day of the week within a month
|
|
|
|
dict set date month [dict get $z ${bound}Month]
|
|
dict set date dayOfWeek [dict get $z ${bound}DayOfWeek]
|
|
set dowim [dict get $z ${bound}WeekOfMonth]
|
|
if { $dowim >= 5 } {
|
|
set dowim -1
|
|
}
|
|
dict set date dayOfWeekInMonth $dowim
|
|
set date [GetJulianDayFromEraYearMonthWeekDay $date[set date {}] 2361222]
|
|
|
|
}
|
|
|
|
set jd [dict get $date julianDay]
|
|
set seconds [expr {
|
|
wide($jd) * wide(86400) - wide(210866803200)
|
|
}]
|
|
|
|
set h [dict get $z ${bound}Hours]
|
|
if { $h eq {} } {
|
|
set h 2
|
|
} else {
|
|
set h [lindex [::scan $h %d] 0]
|
|
}
|
|
set m [dict get $z ${bound}Minutes]
|
|
if { $m eq {} } {
|
|
set m 0
|
|
} else {
|
|
set m [lindex [::scan $m %d] 0]
|
|
}
|
|
set s [dict get $z ${bound}Seconds]
|
|
if { $s eq {} } {
|
|
set s 0
|
|
} else {
|
|
set s [lindex [::scan $s %d] 0]
|
|
}
|
|
set tod [expr { ( $h * 60 + $m ) * 60 + $s }]
|
|
return [expr { $seconds + $tod }]
|
|
}
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# GetLocaleEra --
|
|
#
|
|
# Given local time expressed in seconds from the Posix epoch,
|
|
# determine localized era and year within the era.
|
|
#
|
|
# Parameters:
|
|
# date - Dictionary that must contain the keys, 'localSeconds',
|
|
# whose value is expressed as the appropriate local time;
|
|
# and 'year', whose value is the Gregorian year.
|
|
# etable - Value of the LOCALE_ERAS key in the message catalogue
|
|
# for the target locale.
|
|
#
|
|
# Results:
|
|
# Returns the dictionary, augmented with the keys, 'localeEra' and
|
|
# 'localeYear'.
|
|
#
|
|
#----------------------------------------------------------------------
|
|
|
|
proc ::tcl::clock::GetLocaleEra { date etable } {
|
|
set index [BSearch $etable [dict get $date localSeconds]]
|
|
if { $index < 0} {
|
|
dict set date localeEra \
|
|
[::format %02d [expr { [dict get $date year] / 100 }]]
|
|
dict set date localeYear [expr {
|
|
[dict get $date year] % 100
|
|
}]
|
|
} else {
|
|
dict set date localeEra [lindex $etable $index 1]
|
|
dict set date localeYear [expr {
|
|
[dict get $date year] - [lindex $etable $index 2]
|
|
}]
|
|
}
|
|
return $date
|
|
}
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# GetJulianDayFromEraYearDay --
|
|
#
|
|
# Given a year, month and day on the Gregorian calendar, determines
|
|
# the Julian Day Number beginning at noon on that date.
|
|
#
|
|
# Parameters:
|
|
# date -- A dictionary in which the 'era', 'year', and
|
|
# 'dayOfYear' slots are populated. The calendar in use
|
|
# is determined by the date itself relative to:
|
|
# changeover -- Julian day on which the Gregorian calendar was
|
|
# adopted in the current locale.
|
|
#
|
|
# Results:
|
|
# Returns the given dictionary augmented with a 'julianDay' key whose
|
|
# value is the desired Julian Day Number, and a 'gregorian' key that
|
|
# specifies whether the calendar is Gregorian (1) or Julian (0).
|
|
#
|
|
# Side effects:
|
|
# None.
|
|
#
|
|
# Bugs:
|
|
# This code needs to be moved to the C layer.
|
|
#
|
|
#----------------------------------------------------------------------
|
|
|
|
proc ::tcl::clock::GetJulianDayFromEraYearDay {date changeover} {
|
|
# Get absolute year number from the civil year
|
|
|
|
switch -exact -- [dict get $date era] {
|
|
BCE {
|
|
set year [expr { 1 - [dict get $date year] }]
|
|
}
|
|
CE {
|
|
set year [dict get $date year]
|
|
}
|
|
}
|
|
set ym1 [expr { $year - 1 }]
|
|
|
|
# Try the Gregorian calendar first.
|
|
|
|
dict set date gregorian 1
|
|
set jd [expr {
|
|
1721425
|
|
+ [dict get $date dayOfYear]
|
|
+ ( 365 * $ym1 )
|
|
+ ( $ym1 / 4 )
|
|
- ( $ym1 / 100 )
|
|
+ ( $ym1 / 400 )
|
|
}]
|
|
|
|
# If the date is before the Gregorian change, use the Julian calendar.
|
|
|
|
if { $jd < $changeover } {
|
|
dict set date gregorian 0
|
|
set jd [expr {
|
|
1721423
|
|
+ [dict get $date dayOfYear]
|
|
+ ( 365 * $ym1 )
|
|
+ ( $ym1 / 4 )
|
|
}]
|
|
}
|
|
|
|
dict set date julianDay $jd
|
|
return $date
|
|
}
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# GetJulianDayFromEraYearMonthWeekDay --
|
|
#
|
|
# Determines the Julian Day number corresponding to the nth given
|
|
# day-of-the-week in a given month.
|
|
#
|
|
# Parameters:
|
|
# date - Dictionary containing the keys, 'era', 'year', 'month'
|
|
# 'weekOfMonth', 'dayOfWeek', and 'dayOfWeekInMonth'.
|
|
# changeover - Julian Day of adoption of the Gregorian calendar
|
|
#
|
|
# Results:
|
|
# Returns the given dictionary, augmented with a 'julianDay' key.
|
|
#
|
|
# Side effects:
|
|
# None.
|
|
#
|
|
# Bugs:
|
|
# This code needs to be moved to the C layer.
|
|
#
|
|
#----------------------------------------------------------------------
|
|
|
|
proc ::tcl::clock::GetJulianDayFromEraYearMonthWeekDay {date changeover} {
|
|
# Come up with a reference day; either the zeroeth day of the given month
|
|
# (dayOfWeekInMonth >= 0) or the seventh day of the following month
|
|
# (dayOfWeekInMonth < 0)
|
|
|
|
set date2 $date
|
|
set week [dict get $date dayOfWeekInMonth]
|
|
if { $week >= 0 } {
|
|
dict set date2 dayOfMonth 0
|
|
} else {
|
|
dict incr date2 month
|
|
dict set date2 dayOfMonth 7
|
|
}
|
|
set date2 [GetJulianDayFromEraYearMonthDay $date2[set date2 {}] \
|
|
$changeover]
|
|
set wd0 [WeekdayOnOrBefore [dict get $date dayOfWeek] \
|
|
[dict get $date2 julianDay]]
|
|
dict set date julianDay [expr { $wd0 + 7 * $week }]
|
|
return $date
|
|
}
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# IsGregorianLeapYear --
|
|
#
|
|
# Determines whether a given date represents a leap year in the
|
|
# Gregorian calendar.
|
|
#
|
|
# Parameters:
|
|
# date -- The date to test. The fields, 'era', 'year' and 'gregorian'
|
|
# must be set.
|
|
#
|
|
# Results:
|
|
# Returns 1 if the year is a leap year, 0 otherwise.
|
|
#
|
|
# Side effects:
|
|
# None.
|
|
#
|
|
#----------------------------------------------------------------------
|
|
|
|
proc ::tcl::clock::IsGregorianLeapYear { date } {
|
|
switch -exact -- [dict get $date era] {
|
|
BCE {
|
|
set year [expr { 1 - [dict get $date year]}]
|
|
}
|
|
CE {
|
|
set year [dict get $date year]
|
|
}
|
|
}
|
|
if { $year % 4 != 0 } {
|
|
return 0
|
|
} elseif { ![dict get $date gregorian] } {
|
|
return 1
|
|
} elseif { $year % 400 == 0 } {
|
|
return 1
|
|
} elseif { $year % 100 == 0 } {
|
|
return 0
|
|
} else {
|
|
return 1
|
|
}
|
|
}
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# WeekdayOnOrBefore --
|
|
#
|
|
# Determine the nearest day of week (given by the 'weekday' parameter,
|
|
# Sunday==0) on or before a given Julian Day.
|
|
#
|
|
# Parameters:
|
|
# weekday -- Day of the week
|
|
# j -- Julian Day number
|
|
#
|
|
# Results:
|
|
# Returns the Julian Day Number of the desired date.
|
|
#
|
|
# Side effects:
|
|
# None.
|
|
#
|
|
#----------------------------------------------------------------------
|
|
|
|
proc ::tcl::clock::WeekdayOnOrBefore { weekday j } {
|
|
set k [expr { ( $weekday + 6 ) % 7 }]
|
|
return [expr { $j - ( $j - $k ) % 7 }]
|
|
}
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# BSearch --
|
|
#
|
|
# Service procedure that does binary search in several places inside the
|
|
# 'clock' command.
|
|
#
|
|
# Parameters:
|
|
# list - List of lists, sorted in ascending order by the
|
|
# first elements
|
|
# key - Value to search for
|
|
#
|
|
# Results:
|
|
# Returns the index of the greatest element in $list that is less than
|
|
# or equal to $key.
|
|
#
|
|
# Side effects:
|
|
# None.
|
|
#
|
|
#----------------------------------------------------------------------
|
|
|
|
proc ::tcl::clock::BSearch { list key } {
|
|
if {[llength $list] == 0} {
|
|
return -1
|
|
}
|
|
if { $key < [lindex $list 0 0] } {
|
|
return -1
|
|
}
|
|
|
|
set l 0
|
|
set u [expr { [llength $list] - 1 }]
|
|
|
|
while { $l < $u } {
|
|
# At this point, we know that
|
|
# $k >= [lindex $list $l 0]
|
|
# Either $u == [llength $list] or else $k < [lindex $list $u+1 0]
|
|
# We find the midpoint of the interval {l,u} rounded UP, compare
|
|
# against it, and set l or u to maintain the invariant. Note that the
|
|
# interval shrinks at each step, guaranteeing convergence.
|
|
|
|
set m [expr { ( $l + $u + 1 ) / 2 }]
|
|
if { $key >= [lindex $list $m 0] } {
|
|
set l $m
|
|
} else {
|
|
set u [expr { $m - 1 }]
|
|
}
|
|
}
|
|
|
|
return $l
|
|
}
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# clock add --
|
|
#
|
|
# Adds an offset to a given time.
|
|
#
|
|
# Syntax:
|
|
# clock add clockval ?count unit?... ?-option value?
|
|
#
|
|
# Parameters:
|
|
# clockval -- Starting time value
|
|
# count -- Amount of a unit of time to add
|
|
# unit -- Unit of time to add, must be one of:
|
|
# years year months month weeks week
|
|
# days day hours hour minutes minute
|
|
# seconds second
|
|
#
|
|
# Options:
|
|
# -gmt BOOLEAN
|
|
# (Deprecated) Flag synonymous with '-timezone :GMT'
|
|
# -timezone ZONE
|
|
# Name of the time zone in which calculations are to be done.
|
|
# -locale NAME
|
|
# Name of the locale in which calculations are to be done.
|
|
# Used to determine the Gregorian change date.
|
|
#
|
|
# Results:
|
|
# Returns the given time adjusted by the given offset(s) in
|
|
# order.
|
|
#
|
|
# Notes:
|
|
# It is possible that adding a number of months or years will adjust the
|
|
# day of the month as well. For instance, the time at one month after
|
|
# 31 January is either 28 or 29 February, because February has fewer
|
|
# than 31 days.
|
|
#
|
|
#----------------------------------------------------------------------
|
|
|
|
proc ::tcl::clock::add { clockval args } {
|
|
if { [llength $args] % 2 != 0 } {
|
|
set cmdName "clock add"
|
|
return -code error \
|
|
-errorcode [list CLOCK wrongNumArgs] \
|
|
"wrong \# args: should be\
|
|
\"$cmdName clockval ?number units?...\
|
|
?-gmt boolean? ?-locale LOCALE? ?-timezone ZONE?\""
|
|
}
|
|
if { [catch { expr {wide($clockval)} } result] } {
|
|
return -code error $result
|
|
}
|
|
|
|
set offsets {}
|
|
set gmt 0
|
|
set locale c
|
|
set timezone [GetSystemTimeZone]
|
|
|
|
foreach { a b } $args {
|
|
if { [string is integer -strict $a] } {
|
|
lappend offsets $a $b
|
|
} else {
|
|
switch -exact -- $a {
|
|
-g - -gm - -gmt {
|
|
set gmt $b
|
|
}
|
|
-l - -lo - -loc - -loca - -local - -locale {
|
|
set locale [string tolower $b]
|
|
}
|
|
-t - -ti - -tim - -time - -timez - -timezo - -timezon -
|
|
-timezone {
|
|
set timezone $b
|
|
}
|
|
default {
|
|
throw [list CLOCK badOption $a] \
|
|
"bad option \"$a\",\
|
|
must be -gmt, -locale or -timezone"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
# Check options for validity
|
|
|
|
if { [info exists saw(-gmt)] && [info exists saw(-timezone)] } {
|
|
return -code error \
|
|
-errorcode [list CLOCK gmtWithTimezone] \
|
|
"cannot use -gmt and -timezone in same call"
|
|
}
|
|
if { [catch { expr { wide($clockval) } } result] } {
|
|
return -code error "expected integer but got \"$clockval\""
|
|
}
|
|
if { ![string is boolean -strict $gmt] } {
|
|
return -code error "expected boolean value but got \"$gmt\""
|
|
} elseif { $gmt } {
|
|
set timezone :GMT
|
|
}
|
|
|
|
EnterLocale $locale
|
|
|
|
set changeover [mc GREGORIAN_CHANGE_DATE]
|
|
|
|
if {[catch {SetupTimeZone $timezone} retval opts]} {
|
|
dict unset opts -errorinfo
|
|
return -options $opts $retval
|
|
}
|
|
|
|
try {
|
|
foreach { quantity unit } $offsets {
|
|
switch -exact -- $unit {
|
|
years - year {
|
|
set clockval [AddMonths [expr { 12 * $quantity }] \
|
|
$clockval $timezone $changeover]
|
|
}
|
|
months - month {
|
|
set clockval [AddMonths $quantity $clockval $timezone \
|
|
$changeover]
|
|
}
|
|
|
|
weeks - week {
|
|
set clockval [AddDays [expr { 7 * $quantity }] \
|
|
$clockval $timezone $changeover]
|
|
}
|
|
days - day {
|
|
set clockval [AddDays $quantity $clockval $timezone \
|
|
$changeover]
|
|
}
|
|
|
|
hours - hour {
|
|
set clockval [expr { 3600 * $quantity + $clockval }]
|
|
}
|
|
minutes - minute {
|
|
set clockval [expr { 60 * $quantity + $clockval }]
|
|
}
|
|
seconds - second {
|
|
set clockval [expr { $quantity + $clockval }]
|
|
}
|
|
|
|
default {
|
|
throw [list CLOCK badUnit $unit] \
|
|
"unknown unit \"$unit\", must be \
|
|
years, months, weeks, days, hours, minutes or seconds"
|
|
}
|
|
}
|
|
}
|
|
return $clockval
|
|
} trap CLOCK {result opts} {
|
|
# Conceal the innards of [clock] when it's an expected error
|
|
dict unset opts -errorinfo
|
|
return -options $opts $result
|
|
}
|
|
}
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# AddMonths --
|
|
#
|
|
# Add a given number of months to a given clock value in a given
|
|
# time zone.
|
|
#
|
|
# Parameters:
|
|
# months - Number of months to add (may be negative)
|
|
# clockval - Seconds since the epoch before the operation
|
|
# timezone - Time zone in which the operation is to be performed
|
|
#
|
|
# Results:
|
|
# Returns the new clock value as a number of seconds since
|
|
# the epoch.
|
|
#
|
|
# Side effects:
|
|
# None.
|
|
#
|
|
#----------------------------------------------------------------------
|
|
|
|
proc ::tcl::clock::AddMonths { months clockval timezone changeover } {
|
|
variable DaysInRomanMonthInCommonYear
|
|
variable DaysInRomanMonthInLeapYear
|
|
variable TZData
|
|
|
|
# Convert the time to year, month, day, and fraction of day.
|
|
|
|
set date [GetDateFields $clockval $TZData($timezone) $changeover]
|
|
dict set date secondOfDay [expr {
|
|
[dict get $date localSeconds] % 86400
|
|
}]
|
|
dict set date tzName $timezone
|
|
|
|
# Add the requisite number of months
|
|
|
|
set m [dict get $date month]
|
|
incr m $months
|
|
incr m -1
|
|
set delta [expr { $m / 12 }]
|
|
set mm [expr { $m % 12 }]
|
|
dict set date month [expr { $mm + 1 }]
|
|
dict incr date year $delta
|
|
|
|
# If the date doesn't exist in the current month, repair it
|
|
|
|
if { [IsGregorianLeapYear $date] } {
|
|
set hath [lindex $DaysInRomanMonthInLeapYear $mm]
|
|
} else {
|
|
set hath [lindex $DaysInRomanMonthInCommonYear $mm]
|
|
}
|
|
if { [dict get $date dayOfMonth] > $hath } {
|
|
dict set date dayOfMonth $hath
|
|
}
|
|
|
|
# Reconvert to a number of seconds
|
|
|
|
set date [GetJulianDayFromEraYearMonthDay \
|
|
$date[set date {}]\
|
|
$changeover]
|
|
dict set date localSeconds [expr {
|
|
-210866803200
|
|
+ ( 86400 * wide([dict get $date julianDay]) )
|
|
+ [dict get $date secondOfDay]
|
|
}]
|
|
set date [ConvertLocalToUTC $date[set date {}] $TZData($timezone) \
|
|
$changeover]
|
|
|
|
return [dict get $date seconds]
|
|
|
|
}
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# AddDays --
|
|
#
|
|
# Add a given number of days to a given clock value in a given time
|
|
# zone.
|
|
#
|
|
# Parameters:
|
|
# days - Number of days to add (may be negative)
|
|
# clockval - Seconds since the epoch before the operation
|
|
# timezone - Time zone in which the operation is to be performed
|
|
# changeover - Julian Day on which the Gregorian calendar was adopted
|
|
# in the target locale.
|
|
#
|
|
# Results:
|
|
# Returns the new clock value as a number of seconds since the epoch.
|
|
#
|
|
# Side effects:
|
|
# None.
|
|
#
|
|
#----------------------------------------------------------------------
|
|
|
|
proc ::tcl::clock::AddDays { days clockval timezone changeover } {
|
|
variable TZData
|
|
|
|
# Convert the time to Julian Day
|
|
|
|
set date [GetDateFields $clockval $TZData($timezone) $changeover]
|
|
dict set date secondOfDay [expr {
|
|
[dict get $date localSeconds] % 86400
|
|
}]
|
|
dict set date tzName $timezone
|
|
|
|
# Add the requisite number of days
|
|
|
|
dict incr date julianDay $days
|
|
|
|
# Reconvert to a number of seconds
|
|
|
|
dict set date localSeconds [expr {
|
|
-210866803200
|
|
+ ( 86400 * wide([dict get $date julianDay]) )
|
|
+ [dict get $date secondOfDay]
|
|
}]
|
|
set date [ConvertLocalToUTC $date[set date {}] $TZData($timezone) \
|
|
$changeover]
|
|
|
|
return [dict get $date seconds]
|
|
|
|
}
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# ChangeCurrentLocale --
|
|
#
|
|
# The global locale was changed within msgcat.
|
|
# Clears the buffered parse functions of the current locale.
|
|
#
|
|
# Parameters:
|
|
# loclist (ignored)
|
|
#
|
|
# Results:
|
|
# None.
|
|
#
|
|
# Side effects:
|
|
# Buffered parse functions are cleared.
|
|
#
|
|
#----------------------------------------------------------------------
|
|
|
|
proc ::tcl::clock::ChangeCurrentLocale {args} {
|
|
variable FormatProc
|
|
variable LocaleNumeralCache
|
|
variable CachedSystemTimeZone
|
|
variable TimeZoneBad
|
|
|
|
foreach p [info procs [namespace current]::scanproc'*'current] {
|
|
rename $p {}
|
|
}
|
|
foreach p [info procs [namespace current]::formatproc'*'current] {
|
|
rename $p {}
|
|
}
|
|
|
|
catch {array unset FormatProc *'current}
|
|
set LocaleNumeralCache {}
|
|
}
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# ClearCaches --
|
|
#
|
|
# Clears all caches to reclaim the memory used in [clock]
|
|
#
|
|
# Parameters:
|
|
# None.
|
|
#
|
|
# Results:
|
|
# None.
|
|
#
|
|
# Side effects:
|
|
# Caches are cleared.
|
|
#
|
|
#----------------------------------------------------------------------
|
|
|
|
proc ::tcl::clock::ClearCaches {} {
|
|
variable FormatProc
|
|
variable LocaleNumeralCache
|
|
variable CachedSystemTimeZone
|
|
variable TimeZoneBad
|
|
|
|
foreach p [info procs [namespace current]::scanproc'*] {
|
|
rename $p {}
|
|
}
|
|
foreach p [info procs [namespace current]::formatproc'*] {
|
|
rename $p {}
|
|
}
|
|
|
|
catch {unset FormatProc}
|
|
set LocaleNumeralCache {}
|
|
catch {unset CachedSystemTimeZone}
|
|
set TimeZoneBad {}
|
|
InitTZData
|
|
}
|
|
|