doubled speed of clock format

1 files changed, 208 insertions, 274 deletions

diff --git a/library/clock.tcl b/library/clock.tcl
index dce89e6..95f7582 100644
--- a/library/clock.tcl
+++ b/library/clock.tcl
@@ -13,7 +13,7 @@
 # See the file "license.terms" for information on usage and redistribution
 # of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 #
-# RCS: @(#) $Id: clock.tcl,v 1.6 2004/09/27 14:31:20 kennykb Exp $
+# RCS: @(#) $Id: clock.tcl,v 1.7 2004/10/21 03:53:10 kennykb Exp $
 #
 #----------------------------------------------------------------------
 
@@ -79,7 +79,6 @@ namespace eval ::tcl::clock {
 
     # Import the message catalog commands that we use.
 
-    namespace import ::msgcat::mc
     namespace import ::msgcat::mcload
     namespace import ::msgcat::mclocale
 
@@ -267,17 +266,6 @@ namespace eval ::tcl::clock {
     }
     unset i j
 
-    # Julian day number of 0 January, 1 CE, in the proleptic Julian and
-    # Gregorian calendars.
-
-    variable JD0Jan1CEJul  1721423
-    variable JD0Jan1CEGreg 1721425
-    variable JD31Dec9999   5373484
-    
-    # Posix epoch, expressed as seconds from the Julian epoch
-
-    variable PosixEpochAsJulianSeconds 210866803200
-
     # Another epoch (Hi, Jeff!)
 
     variable Roddenberry 1946
@@ -291,19 +279,6 @@ namespace eval ::tcl::clock {
 
     variable FEB_28	       58
 
-    # Conversion factors
-
-    variable DaysPer400Yr  146097;	# Days per 400 year Gregorian cycle
-    variable DaysPerCentury 36524;	# Days per common Gregorian century
-    variable DaysPer4Yr      1461;	# Days per 4 year cycle
-    variable DaysPerYear      365;	# Days per common year
-    variable DaysPerWeek        7;
-    variable SecondsPerDay  86400;	# Seconds per day
-    variable SecondsPerHour  3600;	# Seconds per hour
-    variable SecondsPerMinute  60;	# Seconds per minute
-    variable MinutesPerHour    60;	# Minutes per hour
-    variable HoursPerDay       24;	# Hours per day
-
     # 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
@@ -606,11 +581,17 @@ namespace eval ::tcl::clock {
 					# values.
     variable McLoaded {};		# Dictionary whose keys are locales
 					# in which [mcload] has been executed
-					# and whose values are immaterial
+					# and whose values are second-level
+    					# dictionaries indexed by message
+    					# name and giving message text.
     # 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,
@@ -632,14 +613,6 @@ namespace eval ::tcl::clock {
 
 proc ::tcl::clock::format { args } {
 
-    variable SecondsPerDay
-    variable SecondsPerHour
-    variable SecondsPerMinute
-    variable MinutesPerHour
-    variable HoursPerDay
-    variable DaysPerYear
-    variable DaysPerWeek
-
     set format {}
 
     # Check the count of args
@@ -715,7 +688,7 @@ proc ::tcl::clock::format { args } {
 
 	# Map away the locale-dependent composite format groups
 
-	set format [LocalizeFormat $format]
+	set format [LocalizeFormat $locale $format]
 
 	# Convert the given time to local time.
 	
@@ -749,14 +722,12 @@ proc ::tcl::clock::format { args } {
 			    append retval %
 			}
 			a {		# Day of week, abbreviated
-			    set dow [expr { [dict get $date dayOfWeek]
-					    % $DaysPerWeek }]
+			    set dow [expr { [dict get $date dayOfWeek] % 7 }]
 			    append retval \
 				[lindex [mc DAYS_OF_WEEK_ABBREV] $dow]
 			}
 			A {		# Day of week, spelt out.
-			    set dow [expr { [dict get $date dayOfWeek]
-					    % $DaysPerWeek }]
+			    set dow [expr { [dict get $date dayOfWeek] % 7 }]
 			    append retval [lindex [mc DAYS_OF_WEEK_FULL] $dow]
 			}
 			b - h {		# Name of month, abbreviated.
@@ -801,16 +772,16 @@ proc ::tcl::clock::format { args } {
 			    append retval \
 				[::format %02d \
 				     [expr { [dict get $date localSeconds] 
-					     / $SecondsPerHour
-					     % $HoursPerDay }]]
+					     / 3600
+					     % 24 }]]
 			}
 			I {		# Hour AM/PM, with leading zero
 			    set hour12 \
 				[expr { ( ( ( [dict get $date localSeconds]
-					      % $SecondsPerDay )
-					    + $SecondsPerDay
-					    - $SecondsPerHour )
-					  / $SecondsPerHour )
+					      % 86400 )
+					    + 86400
+					    - 3600 )
+					  / 3600 )
 					% 12 + 1 }]
 			    append retval [::format %02d $hour12]
 			}
@@ -826,16 +797,16 @@ proc ::tcl::clock::format { args } {
 			    append retval \
 				[::format %2d \
 				     [expr { [dict get $date localSeconds] 
-					     / $SecondsPerHour
-					     % $HoursPerDay }]]
+					     / 3600
+					     % 24 }]]
 			}
 			l {		# Hour (12-11), no leading zero
 			    set hour12 \
 				[expr { ( ( ( [dict get $date localSeconds]
-					      % $SecondsPerDay )
-					    + $SecondsPerDay
-					    - $SecondsPerHour )
-					  / $SecondsPerHour )
+					      % 86400 )
+					    + 86400
+					    - 3600 )
+					  / 3600 )
 					% 12 + 1 }]
 			    append retval [::format %2d $hour12]
 			}
@@ -847,8 +818,8 @@ proc ::tcl::clock::format { args } {
 			    append retval \
 				[::format %02d \
 				     [expr { [dict get $date localSeconds] 
-					     / $SecondsPerMinute
-					     % $MinutesPerHour }]]
+					     / 60
+					     % 60 }]]
 			}
 			n {		# A literal newline
 			    append retval \n
@@ -864,8 +835,8 @@ proc ::tcl::clock::format { args } {
 			p {		# Localized 'AM' or 'PM' indicator
 					# converted to uppercase
 			    set tod [expr { [dict get $date localSeconds] 
-					    % $SecondsPerDay }]
-			    if { $tod >= ( $SecondsPerDay / 2 ) } {
+					    % 86400 }]
+			    if { $tod >= ( 86400 / 2 ) } {
 				append retval [string toupper [mc PM]]
 			    } else {
 				append retval [string toupper [mc AM]]
@@ -873,8 +844,8 @@ proc ::tcl::clock::format { args } {
 			}
 			P {		# Localized 'AM' or 'PM' indicator
 			    set tod [expr { [dict get $date localSeconds] 
-					    % $SecondsPerDay }]
-			    if { $tod >= ( $SecondsPerDay / 2 ) } {
+					    % 86400 }]
+			    if { $tod >= ( 86400 / 2 ) } {
 				append retval [mc PM]
 			    } else {
 				append retval [mc AM]
@@ -891,7 +862,7 @@ proc ::tcl::clock::format { args } {
 			    append retval \
 				[::format %02d \
 				     [expr { [dict get $date localSeconds] 
-					     % $SecondsPerMinute }]]
+					     % 60 }]]
 			}
 			t {		# A literal tab character
 			    append retval \t
@@ -903,15 +874,14 @@ proc ::tcl::clock::format { args } {
 					# first Sunday of the year is the
 					# first day of week 01
 			    set dow [dict get $date dayOfWeek]
-			    if { $dow == $DaysPerWeek } {
+			    if { $dow == 7 } {
 				set dow 0
 			    }
 			    incr dow
 			    set weekNumber \
-				[expr { ( [dict get $date dayOfYear]
-					  - $dow
-					  + $DaysPerWeek )
-					/ $DaysPerWeek }]
+				[expr { ( [dict get $date dayOfYear] 
+					  - $dow + 7 )
+					/ 7 }]
 			    append retval [::format %02d $weekNumber]
 			}
 			V {		# The ISO8601 week number
@@ -921,8 +891,7 @@ proc ::tcl::clock::format { args } {
 			w {		# Day of the week (0-Sunday,
 					# 6-Saturday)
 			    append retval \
-				[expr { [dict get $date dayOfWeek]
-					% $DaysPerWeek }]
+				[expr { [dict get $date dayOfWeek] % 7 }]
 			}
 			W {		# Week of the year (00-53). The first
 					# Monday of the year is the first day
@@ -930,8 +899,8 @@ proc ::tcl::clock::format { args } {
 			    set weekNumber \
 				[expr { ( [dict get $date dayOfYear]
 					  - [dict get $date dayOfWeek]
-					  + $DaysPerWeek ) 
-					/ $DaysPerWeek }]
+					  + 7 ) 
+					/ 7 }]
 			    append retval [::format %02d $weekNumber]
 			}
 			y {		# The two-digit year of the century
@@ -990,18 +959,18 @@ proc ::tcl::clock::format { args } {
 			H - k {		# Hour of the day in alternative
 					# numerals
 			    set hour [expr { [dict get $date localSeconds] 
-					     / $SecondsPerHour
-					     % $HoursPerDay }]
+					     / 3600
+					     % 24 }]
 			    append retval [lindex [mc LOCALE_NUMERALS] $hour]
 			}
 			I - l {		# Hour (12-11) AM/PM in alternative
 					# numerals
 			    set hour12 \
 				[expr { ( ( ( [dict get $date localSeconds]
-					      % $SecondsPerDay )
-					    + $SecondsPerDay
-					    - $SecondsPerHour )
-					  / $SecondsPerHour )
+					      % 86400 )
+					    + 86400
+					    - 3600 )
+					  / 3600 )
 					% 12 + 1 }]
 			    append retval [lindex [mc LOCALE_NUMERALS] $hour12]
 			}
@@ -1013,14 +982,14 @@ proc ::tcl::clock::format { args } {
 			M {		# Minute of the hour in alternative
 					# numerals
 			    set minute [expr { [dict get $date localSeconds] 
-					       / $SecondsPerMinute
-					       % $MinutesPerHour }]
+					       / 60
+					       % 60 }]
 			    append retval [lindex [mc LOCALE_NUMERALS] $minute]
 			}
 			S {		# Second of the minute in alternative
 					# numerals
 			    set second [expr { [dict get $date localSeconds] 
-					       % $SecondsPerMinute }]
+					       % 60 }]
 			    append retval [lindex [mc LOCALE_NUMERALS] $second]
 			}
 			u {		# Day of the week (Monday=1,Sunday=7)
@@ -1034,8 +1003,7 @@ proc ::tcl::clock::format { args } {
 			    append retval \
 				[lindex \
 				     [mc LOCALE_NUMERALS] \
-				     [expr { [dict get $date dayOfWeek]
-					     % $DaysPerWeek }]]
+				     [expr { [dict get $date dayOfWeek] % 7 }]]
 			}
 			y {		# Year of the century in alternative
 					# numerals
@@ -1204,7 +1172,7 @@ proc ::tcl::clock::scan { args } {
 
 	# Map away the locale-dependent composite format groups
 
-	set format [LocalizeFormat $format]
+	set format [LocalizeFormat $locale $format]
 	set scanner [ParseClockScanFormat $format]
 	$scanner $string $base $timezone
 
@@ -1250,10 +1218,6 @@ proc ::tcl::clock::scan { args } {
 
 proc ::tcl::clock::FreeScan { string base timezone locale } {
 
-    variable SecondsPerDay
-    variable DaysPerWeek
-    variable PosixEpochAsJulianSeconds
-
     # Extract year, month and day from the base time for the
     # parser to use as defaults
 
@@ -1264,7 +1228,7 @@ proc ::tcl::clock::FreeScan { string base timezone locale } {
 				 [dict create seconds $base] \
 				 $timezone]]]]
     dict set date secondOfDay [expr { [dict get $date localSeconds] 
-				      % $SecondsPerDay }]
+				      % 86400 }]
 
     # Parse the date.  The parser will return a list comprising
     # date, time, time zone, relative month/day/seconds, relative
@@ -1325,9 +1289,8 @@ proc ::tcl::clock::FreeScan { string base timezone locale } {
 	dict set date secondOfDay $parseTime
     }
     dict set date localSeconds \
-	[expr { -$::tcl::clock::PosixEpochAsJulianSeconds
-		+ ( $::tcl::clock::SecondsPerDay 
-		    * wide([dict get $date julianDay]) )
+	[expr { -210866803200
+		+ ( 86400 * wide([dict get $date julianDay]) )
 		+ [dict get $date secondOfDay] }]
     set date [ConvertLocalToUTC $date[set date {}]]
     set seconds [dict get $date seconds]
@@ -1357,17 +1320,17 @@ proc ::tcl::clock::FreeScan { string base timezone locale } {
 	dict set date2 era CE
 	set jdwkday [WeekdayOnOrBefore $dayOfWeek \
 			 [expr { [dict get $date2 julianDay] 
-				 + $DaysPerWeek - 1}]]
-	incr jdwkday [expr { $DaysPerWeek * $dayOrdinal }]
+				 + 6 }]]
+	incr jdwkday [expr { 7 * $dayOrdinal }]
 	if { $dayOrdinal > 0 } {
-	    incr jdwkday [expr {- $DaysPerWeek }]
+	    incr jdwkday -7
 	}
 	dict set date2 secondOfDay \
-	    [expr { [dict get $date2 localSeconds] % $SecondsPerDay }]
+	    [expr { [dict get $date2 localSeconds] % 86400 }]
 	dict set date2 julianDay $jdwkday
 	dict set date2 localSeconds \
-	    [expr { -$PosixEpochAsJulianSeconds
-		    + ( $SecondsPerDay * wide([dict get $date2 julianDay]) )
+	    [expr { -210866803200
+		    + ( 86400 * wide([dict get $date2 julianDay]) )
 		    + [dict get $date secondOfDay] }]
 	dict set date2 tzname $timezone
 	set date2 [ConvertLocalToUTC $date2[set date2 {}]]
@@ -1660,8 +1623,8 @@ proc ::tcl::clock::ParseClockScanFormat { formatString } {
 			    { %d dow} \n \
 			    {
 				if { $dow == 0 } {
-				    set dow $DaysPerWeek
-				} elseif { $dow > $DaysPerWeek } {
+				    set dow 7
+				} elseif { $dow > 7 } {
 				    return -code error \
 					-errorcode [list CLOCK badDayOfWeek] \
 					"day of week is greater than 7"
@@ -1825,8 +1788,8 @@ proc ::tcl::clock::ParseClockScanFormat { formatString } {
 			    { $field} [incr captureCount] \] \n \
 			    {
 				if { $dow == 0 } {
-				    set dow $DaysPerWeek
-				} elseif { $dow > $DaysPerWeek } {
+				    set dow 7
+				} elseif { $dow > 7 } {
 				    return -code error \
 					-errorcode [list CLOCK badDayOfWeek] \
 					"day of week is greater than 7"
@@ -1861,9 +1824,7 @@ proc ::tcl::clock::ParseClockScanFormat { formatString } {
 
     # Build the procedure
 
-    set procBody {
-	variable ::tcl::clock::DaysPerWeek
-    }
+    set procBody {}
     append procBody "if \{ !\[ regexp -nocase [list $re] \$string ->"
     for { set i 1 } { $i <= $captureCount } { incr i } {
 	append procBody " " field $i
@@ -1891,14 +1852,13 @@ proc ::tcl::clock::ParseClockScanFormat { formatString } {
     if { ![dict exists $fieldSet seconds] 
          && ![dict exists $fieldSet starDate] } {
 	append procBody {
-	    if { [dict get $date julianDay] > $::tcl::clock::JD31Dec9999 } {
+	    if { [dict get $date julianDay] > 5373484 } {
 		return -code error -errorcode [list CLOCK dateTooLarge] \
 		    "requested date too large to represent"
 	    }
 	    dict set date localSeconds \
-		[expr { -$::tcl::clock::PosixEpochAsJulianSeconds
-			+ ( $::tcl::clock::SecondsPerDay 
-			    * wide([dict get $date julianDay]) )
+		[expr { -210866803200
+			+ ( 86400 * wide([dict get $date julianDay]) )
 			+ [dict get $date secondOfDay] }]
 	}
     }
@@ -2413,6 +2373,8 @@ proc ::tcl::clock::LoadWindowsDateTimeFormats { locale } {
 #	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:
@@ -2424,7 +2386,14 @@ proc ::tcl::clock::LoadWindowsDateTimeFormats { locale } {
 #
 #----------------------------------------------------------------------
 
-proc ::tcl::clock::LocalizeFormat { format } {
+proc ::tcl::clock::LocalizeFormat { locale format } {
+
+    variable McLoaded
+
+    if { [dict exists $McLoaded $locale FORMAT $format] } {
+	return [dict get $McLoaded $locale FORMAT $format]
+    }
+    set inFormat $format
 
     # Handle locale-dependent format groups by mapping them out of
     # the input string.  Note that the order of the [string map]
@@ -2444,6 +2413,8 @@ proc ::tcl::clock::LocalizeFormat { format } {
     set format [string map [list %D %m/%d/%Y \
 				%EY [mc LOCALE_YEAR_FORMAT]\
 				%+ {%a %b %e %H:%M:%S %Z %Y}] $format]
+
+    dict set McLoaded $locale FORMAT $format $inFormat
     return $format
 }
 
@@ -2466,19 +2437,16 @@ proc ::tcl::clock::LocalizeFormat { format } {
 
 proc ::tcl::clock::FormatNumericTimeZone { z } {
 
-    variable SecondsPerHour
-    variable SecondsPerMinute
-
     if { $z < 0 } {
 	set z [expr { - $z }]
 	set retval -
     } else {
 	set retval +
     }
-    append retval [::format %02d [expr { $z / $SecondsPerHour }]]
-    set z [expr { $z % $SecondsPerHour }]
-    append retval [::format %02d [expr { $z / $SecondsPerMinute }]]
-    set z [expr { $z % $SecondsPerMinute }]
+    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]
     }
@@ -2510,8 +2478,6 @@ proc ::tcl::clock::FormatNumericTimeZone { z } {
 
 proc ::tcl::clock::FormatStarDate { date } {
 
-    variable DaysPerYear
-    variable SecondsPerDay
     variable Roddenberry
 
     # Get day of year, zero based
@@ -2529,9 +2495,9 @@ proc ::tcl::clock::FormatStarDate { date } {
     # Convert day of year to a fractional year
 
     if { $lp } {
-	set fractYear [expr { 1000 * $doy / ( $DaysPerYear + 1 ) }]
+	set fractYear [expr { 1000 * $doy / 366 }]
     } else {
-	set fractYear [expr { 1000 * $doy / $DaysPerYear }]
+	set fractYear [expr { 1000 * $doy / 365 }]
     }
 
     # Put together the StarDate
@@ -2539,8 +2505,8 @@ proc ::tcl::clock::FormatStarDate { date } {
     return [::format "Stardate %02d%03d.%1d" \
 		[expr { [dict get $date year] - $Roddenberry }] \
 		$fractYear \
-		[expr { [dict get $date localSeconds] % $SecondsPerDay
-			/ ( $SecondsPerDay / 10 ) }]]
+		[expr { [dict get $date localSeconds] % 86400
+			/ ( 86400 / 10 ) }]]
 }
 
 #----------------------------------------------------------------------
@@ -2568,16 +2534,13 @@ proc ::tcl::clock::FormatStarDate { date } {
 proc ::tcl::clock::ParseStarDate { year fractYear fractDay } {
 
     variable Roddenberry
-    variable DaysPerYear
-    variable SecondsPerDay
-    variable PosixEpochAsJulianSeconds
 
     # Build a tentative date from year and fraction.
 
     set date [dict create \
 		  era CE \
 		  year [expr { $year + $Roddenberry }] \
-		  dayOfYear [expr { $fractYear * $DaysPerYear / 1000 + 1 }]]
+		  dayOfYear [expr { $fractYear * 365 / 1000 + 1 }]]
     set date [GetJulianDayFromGregorianEraYearDay $date[set date {}]]
 
     # Determine whether the given year is a leap year
@@ -2593,18 +2556,18 @@ proc ::tcl::clock::ParseStarDate { year fractYear fractDay } {
 
     if { $lp } {
 	dict set date dayOfYear \
-	    [expr { $fractYear * ( $DaysPerYear + 1 ) / 1000 + 1 }]
+	    [expr { $fractYear * 366 / 1000 + 1 }]
     } else {
 	dict set date dayOfYear \
-	    [expr { $fractYear * $DaysPerYear / 1000 + 1 }]
+	    [expr { $fractYear * 365 / 1000 + 1 }]
     }
     dict unset date julianDay
     dict unset date gregorian
     set date [GetJulianDayFromGregorianEraYearDay $date[set date {}]]
 
-    return [expr { $SecondsPerDay * [dict get $date julianDay]
-		   - $PosixEpochAsJulianSeconds
-		   + ( $SecondsPerDay / 10 ) * $fractDay }]
+    return [expr { 86400 * [dict get $date julianDay]
+		   - 210866803200
+		   + ( 86400 / 10 ) * $fractDay }]
 
 }
 
@@ -2701,9 +2664,6 @@ proc ::tcl::clock::InterpretTwoDigitYear { date baseTime
 
 proc ::tcl::clock::AssignBaseYear { date baseTime timeZone } {
 
-    variable PosixEpochAsJulianSeconds
-    variable SecondsPerDay
-
     # Find the Julian Day Number corresponding to the base time, and
     # find the Gregorian year corresponding to that Julian Day.
 
@@ -2742,8 +2702,6 @@ proc ::tcl::clock::AssignBaseYear { date baseTime timeZone } {
 #----------------------------------------------------------------------
 
 proc ::tcl::clock::AssignBaseIso8601Year { date baseTime timeZone } {
-    variable PosixEpochAsJulianSeconds
-    variable SecondsPerDay
 
     # Find the Julian Day Number corresponding to the base time
 
@@ -2781,9 +2739,6 @@ proc ::tcl::clock::AssignBaseIso8601Year { date baseTime timeZone } {
 
 proc ::tcl::clock::AssignBaseMonth { date baseTime timeZone } {
 
-    variable PosixEpochAsJulianSeconds
-    variable SecondsPerDay
-
     # Find the Julian Day Number corresponding to the base time
 
     set date2 [dict create seconds $baseTime]
@@ -2822,8 +2777,6 @@ proc ::tcl::clock::AssignBaseMonth { date baseTime timeZone } {
 #----------------------------------------------------------------------
 
 proc ::tcl::clock::AssignBaseWeek { date baseTime timeZone } {
-    variable PosixEpochAsJulianSeconds
-    variable SecondsPerDay
 
     # Find the Julian Day Number corresponding to the base time
 
@@ -2861,9 +2814,6 @@ proc ::tcl::clock::AssignBaseWeek { date baseTime timeZone } {
 
 proc ::tcl::clock::AssignBaseJulianDay { date baseTime timeZone } {
 
-    variable PosixEpochAsJulianSeconds
-    variable SecondsPerDay
-
     # Find the Julian Day Number corresponding to the base time
 
     set date2 [dict create seconds $baseTime]
@@ -2927,11 +2877,8 @@ proc ::tcl::clock::InterpretHMSP { date } {
 
 proc ::tcl::clock::InterpretHMS { date } {
 
-    variable SecondsPerMinute
-    variable MinutesPerHour
-
-    return [expr { ( [dict get $date hour] * $MinutesPerHour
-		     + [dict get $date minute] ) * $SecondsPerMinute
+    return [expr { ( [dict get $date hour] * 60
+		     + [dict get $date minute] ) * 60
 		   + [dict get $date second] }]
 
 }
@@ -2958,25 +2905,32 @@ proc ::tcl::clock::InterpretHMS { date } {
 proc ::tcl::clock::GetSystemTimeZone {} {
 
     variable CachedSystemTimeZone
+    variable TimeZoneBad
 
-    if { [info exists ::env(TCL_TZ)] } {
-	set timezone $::env(TCL_TZ)
-    } elseif { [info exists ::env(TZ)] } {
-	set timezone $::env(TZ)
-    } elseif { $::tcl_platform(platform) eq {windows} } {
+    if { ![catch {getenv TCL_TZ} result] } {
+	set timezone $result
+    } elseif { ![catch {getenv TZ} result] } {
+	set timezone $result
+    } else {
 	if { [info exists CachedSystemTimeZone] } {
 	    set timezone $CachedSystemTimeZone
 	} else {
-	    set timezone [GuessWindowsTimeZone]
+	    if { $::tcl_platform(platform) eq {windows} } {
+		set timezone [GuessWindowsTimeZone]
+	    } else {
+		set timezone :localtime
+	    }
 	    set CachedSystemTimeZone $timezone
 	}
-    } else {
-	set timezone :localtime
     }
-    if { [catch {SetupTimeZone $timezone}] } {
-	set timezone :localtime
+    if { ![dict exists $TimeZoneBad $timezone] } {
+	dict set TimeZoneBad $timezone [catch {SetupTimeZone $timezone}]
+    }
+    if { [dict get $TimeZoneBad $timezone] } {
+	return ::localtime
+    } else {
+	return $timezone
     }
-    return $timezone
 
 }
 
@@ -3112,11 +3066,6 @@ proc ::tcl::clock::ConvertLocalToUTC { date } {
 
 proc ::tcl::clock::ConvertLocalToUTCViaC { localSeconds } {
 
-    variable SecondsPerHour
-    variable SecondsPerMinute
-    variable MinutesPerHour
-    variable HoursPerDay
-
     set date [dict create localSeconds $localSeconds]
     set date [GetJulianDay $date[set date {}]]
     set date [GetGregorianEraYearDay $date[set date {}]]
@@ -3126,9 +3075,9 @@ proc ::tcl::clock::ConvertLocalToUTCViaC { localSeconds } {
 	     [dict get $date year] \
 	     [dict get $date month] \
 	     [dict get $date dayOfMonth] \
-	     [expr { $localSeconds / $SecondsPerHour % $HoursPerDay }] \
-	     [expr { $localSeconds / $SecondsPerMinute % $MinutesPerHour }] \
-	     [expr { $localSeconds % $SecondsPerMinute }]]
+	     [expr { $localSeconds / 3600 % 24 }] \
+	     [expr { $localSeconds / 60 % 60 }] \
+	     [expr { $localSeconds % 60 }]]
     return $retval
 }
 
@@ -3205,12 +3154,6 @@ proc ::tcl::clock::ConvertUTCToLocal { date timezone } {
 
 proc ::tcl::clock::ConvertUTCToLocalViaC { date } {
 
-    variable PosixEpochAsJulianSeconds
-    variable SecondsPerMinute
-    variable SecondsPerHour
-    variable MinutesPerHour
-    variable HoursPerDay
-
     # Get y-m-d-h-m-s from the C library
 
     set gmtSeconds [dict get $date seconds]
@@ -3230,13 +3173,13 @@ proc ::tcl::clock::ConvertUTCToLocalViaC { date } {
     # Reconvert to seconds from the epoch in local time.
 
     set localSeconds [expr { ( ( ( wide([dict get $date2 julianDay]) 
-				   * $HoursPerDay
+				   * 24
 				   + wide([dict get $date2 hour]) ) 
-				 * $MinutesPerHour
+				 * 60
 				 + wide([dict get $date2 minute]) )
-			       * $SecondsPerMinute
+			       * 60
 			       + wide([dict get $date2 second]) )
-			     - $PosixEpochAsJulianSeconds }]
+			     - 210866803200 }]
  
     # Determine the name and offset of the timezone
 
@@ -3248,10 +3191,10 @@ proc ::tcl::clock::ConvertUTCToLocalViaC { date } {
 	set signum +
 	set delta $diff
     }
-    set hh [::format %02d [expr { $delta / $SecondsPerHour }]]
-    set mm [::format %02d [expr { ($delta / $SecondsPerMinute )
-				  % $MinutesPerHour }]]
-    set ss [::format %02d [expr { $delta % $SecondsPerMinute }]]
+    set hh [::format %02d [expr { $delta / 3600 }]]
+    set mm [::format %02d [expr { ($delta / 60 )
+				  % 60 }]]
+    set ss [::format %02d [expr { $delta % 60 }]]
 
     set zoneName $signum$hh$mm
     if { $ss ne {00} } {
@@ -3287,11 +3230,9 @@ proc ::tcl::clock::ConvertUTCToLocalViaC { date } {
 proc ::tcl::clock::SetupTimeZone { timezone } {
 
     variable TZData
-    variable MinutesPerHour
-    variable SecondsPerMinute
-    variable MINWIDE
 
     if {! [info exists TZData($timezone)] } {
+	variable MINWIDE
 	if { $timezone eq {:localtime} } {
 
 	    # Nothing to do, we'll convert using the localtime function
@@ -3308,8 +3249,8 @@ proc ::tcl::clock::SetupTimeZone { timezone } {
 	    } else {
 		::scan $ss %d ss
 	    }
-	    set offset [expr { ( $hh * $MinutesPerHour
-				 + $mm ) * $SecondsPerMinute
+	    set offset [expr { ( $hh * 60
+				 + $mm ) * 60
 			       + $ss }]
 	    if { $s eq {-} } {
 		set offset [expr { - $offset }]
@@ -3394,9 +3335,6 @@ proc ::tcl::clock::SetupTimeZone { timezone } {
 proc ::tcl::clock::GuessWindowsTimeZone {} {
 
     variable WinZoneInfo
-    variable SecondsPerHour
-    variable SecondsPerMinute
-    variable MinutesPerHour
     variable NoRegistry
 
     if { [info exists NoRegistry] } {
@@ -3408,11 +3346,11 @@ proc ::tcl::clock::GuessWindowsTimeZone {} {
     if { [catch {
 	set rpath HKEY_LOCAL_MACHINE\\System\\CurrentControlSet\\Control\\TimeZoneInformation
 	set data [list \
-		      [expr { -$SecondsPerMinute
+		      [expr { -60
 			      * [registry get $rpath Bias] }] \
-		      [expr { -$SecondsPerMinute \
+		      [expr { -60
 				  * [registry get $rpath StandardBias] }] \
-		      [expr { -$SecondsPerMinute \
+		      [expr { -60 \
 				  * [registry get $rpath DaylightBias] }]]
 	set stdtzi [registry get $rpath StandardStart]
 	foreach ind {0 2 14 4 6 8 10 12} {
@@ -3449,10 +3387,9 @@ proc ::tcl::clock::GuessWindowsTimeZone {} {
 	} else {
 	    set stdSignum -
 	}
-	set hh [::format %02d [expr { $stdDelta / $SecondsPerHour }]]
-	set mm [::format %02d [expr { ($stdDelta / $SecondsPerMinute )
-				      % $MinutesPerHour }]]
-	set ss [::format %02d [expr { $stdDelta % $SecondsPerMinute }]]
+	set hh [::format %02d [expr { $stdDelta / 3600 }]]
+	set mm [::format %02d [expr { ($stdDelta / 60 ) % 60 }]]
+	set ss [::format %02d [expr { $stdDelta % 60 }]]
 	append tzname < $stdSignum $hh $mm > $stdSignum $hh : $mm : $ss
 	if { $stdMonth >= 0 } {
 	    if { $dstDelta <= 0 } {
@@ -3461,10 +3398,9 @@ proc ::tcl::clock::GuessWindowsTimeZone {} {
 	    } else {
 		set dstSignum -
 	    }
-	    set hh [::format %02d [expr { $dstDelta / $SecondsPerHour }]]
-	    set mm [::format %02d [expr { ($dstDelta / $SecondsPerMinute )
-					   % $MinutesPerHour }]]
-	    set ss [::format %02d [expr { $dstDelta % $SecondsPerMinute }]]
+	    set hh [::format %02d [expr { $dstDelta / 3600 }]]
+	    set mm [::format %02d [expr { ($dstDelta / 60 ) % 60 }]]
+	    set ss [::format %02d [expr { $dstDelta % 60 }]]
 	    append tzname < $dstSignum $hh $mm > $dstSignum $hh : $mm : $ss
 	    if { $dstYear == 0 } {
 		append tzname ,M $dstMonth . $dstDayOfMonth . $dstDayOfWeek
@@ -3875,8 +3811,6 @@ proc ::tcl::clock::ParsePosixTimeZone { tz } {
 proc ::tcl::clock::ProcessPosixTimeZone { z } {
 
     variable MINWIDE
-    variable SecondsPerMinute
-    variable MinutesPerHour
     variable TZData
 
     # Determine the standard time zone name and seconds east of Greenwich
@@ -3901,8 +3835,8 @@ proc ::tcl::clock::ProcessPosixTimeZone { z } {
     } else {
 	set stdSeconds 0
     }
-    set stdOffset [expr { ( ( $stdHours * $MinutesPerHour + $stdMinutes )
-			    * $SecondsPerMinute + $stdSeconds )
+    set stdOffset [expr { ( ( $stdHours * 60 + $stdMinutes )
+			    * 60 + $stdSeconds )
 			  * $stdSignum }]
     set data [list [list $MINWIDE $stdOffset 0 $stdName]]
 
@@ -3937,8 +3871,8 @@ proc ::tcl::clock::ProcessPosixTimeZone { z } {
 	} else {
 	    set dstSeconds 0
 	}
-	set dstOffset [expr { ( ( $dstHours * $MinutesPerHour + $dstMinutes )
-				* $SecondsPerMinute + $dstSeconds )
+	set dstOffset [expr { ( ( $dstHours * 60 + $dstMinutes )
+				* 60 + $dstSeconds )
 			      * $dstSignum }]
     }
 
@@ -4008,10 +3942,6 @@ proc ::tcl::clock::ProcessPosixTimeZone { z } {
 proc ::tcl::clock::DeterminePosixDSTTime { z bound y } {
 
     variable FEB_28
-    variable PosixEpochAsJulianSeconds
-    variable SecondsPerDay
-    variable SecondsPerMinute
-    variable MinutesPerHour
 
     # Determine the start or end day of DST
 
@@ -4044,8 +3974,8 @@ proc ::tcl::clock::DeterminePosixDSTTime { z bound y } {
     }
 
     set jd [dict get $date julianDay]
-    set seconds [expr { wide($jd) * wide($SecondsPerDay)
-			- wide($PosixEpochAsJulianSeconds) }]
+    set seconds [expr { wide($jd) * wide(86400)
+			- wide(210866803200) }]
 
     set h [dict get $z ${bound}Hours]
     if { $h eq {} } {
@@ -4065,7 +3995,7 @@ proc ::tcl::clock::DeterminePosixDSTTime { z bound y } {
     } else {
 	set s [lindex [::scan $s %d] 0]
     }
-    set tod [expr { ( $h * $MinutesPerHour + $m ) * $SecondsPerMinute + $s }]
+    set tod [expr { ( $h * 60 + $m ) * 60 + $s }]
     return [expr { $seconds + $tod }]
 
 }
@@ -4127,14 +4057,11 @@ proc ::tcl::clock::GetLocaleEra { date } {
 
 proc ::tcl::clock::GetJulianDay { date } {
 
-    variable PosixEpochAsJulianSeconds
-    variable SecondsPerDay
-
     set secs [dict get $date localSeconds]
 
     return [dict set date julianDay \
-		[expr { ( $secs + $PosixEpochAsJulianSeconds )
-			/ $SecondsPerDay }]]
+		[expr { ( $secs + 210866803200 )
+			/ 86400 }]]
 
 }
 
@@ -4160,13 +4087,6 @@ proc ::tcl::clock::GetJulianDay { date } {
 
 proc ::tcl::clock::GetGregorianEraYearDay { date } {
 
-    variable JD0Jan1CEGreg
-    variable JD0Jan1CEJul
-    variable DaysPer400Yr
-    variable DaysPerCentury
-    variable DaysPer4Yr
-    variable DaysPerYear
-
     set jday [dict get $date julianDay]
 
     set changeover [mc GREGORIAN_CHANGE_DATE]
@@ -4179,22 +4099,22 @@ proc ::tcl::clock::GetGregorianEraYearDay { date } {
 
 	# Calculate number of days since 1 January, 1 CE
 
-	set day [expr { $jday - $JD0Jan1CEGreg - 1 }]
+	set day [expr { $jday - 1721425 - 1 }]
 
 	# Calculate number of 400 year cycles
 
 	set year 1
-	set n [expr { $day / $DaysPer400Yr }]
+	set n [expr { $day / 146097 }]
 	incr year [expr { 400 * $n }]
-	set day [expr { $day % $DaysPer400Yr }]
+	set day [expr { $day % 146097 }]
 
 	# Calculate number of centuries in the current cycle
 
-	set n [expr { $day / $DaysPerCentury }]
-	set day [expr { $day % $DaysPerCentury }]
+	set n [expr { $day / 36524 }]
+	set day [expr { $day % 36524 }]
 	if { $n > 3 } {
-	    set n 3			;# 31 December 2000, for instance
-	    incr day $DaysPerCentury    ;# is last day of 400 year cycle
+	    set n 3		     ;  # 31 December 2000, for instance
+	    incr day 36524	     ;	# is last day of 400 year cycle
         }
 	incr year [expr { 100 * $n }]
 
@@ -4206,7 +4126,7 @@ proc ::tcl::clock::GetGregorianEraYearDay { date } {
 
 	# Calculate days since 0 January, 1 CE Julian
 
-	set day [expr { $jday - $JD0Jan1CEJul - 1 }]
+	set day [expr { $jday - 1721423 - 1 }]
 	set year 1
 	
     }
@@ -4214,17 +4134,17 @@ proc ::tcl::clock::GetGregorianEraYearDay { date } {
     # Calculate number of 4-year cycles in current century (or in
     # the Common Era, if the calendar is Julian)
 
-    set n [expr { $day / $DaysPer4Yr }]
-    set day [expr { $day % $DaysPer4Yr }]
+    set n [expr { $day / 1461 }]
+    set day [expr { $day % 1461 }]
     incr year [expr { 4 * $n }]
 
     # Calculate number of years in current 4-year cycle
 
-    set n [expr { $day / $DaysPerYear }]
-    set day [expr { $day % $DaysPerYear }]
+    set n [expr { $day / 365 }]
+    set day [expr { $day % 365 }]
     if { $n > 3 } {
 	set n 3				;# 31 December in a leap year
-	incr day $DaysPerYear
+	incr day 365
     }
     incr year $n
 
@@ -4327,8 +4247,6 @@ proc ::tcl::clock::GetMonthDay { date } {
 proc ::tcl::clock::GetYearWeekDay { date 
 				    { keys { iso8601Year iso8601Week dayOfWeek } } } {
 
-    variable DaysPerWeek
-
     set daysInFirstWeek 4
     set firstDayOfWeek 1
 
@@ -4383,10 +4301,10 @@ proc ::tcl::clock::GetYearWeekDay { date
     
     set fiscalYear [dict get $date1 fiscalYear]
     set dayOfFiscalYear [expr { $j - $startOfFiscalYear }]
-    set weekOfFiscalYear [expr { ( $dayOfFiscalYear / $DaysPerWeek ) + 1 }]
-    set dayOfWeek [expr { ( $dayOfFiscalYear + 1 ) % $DaysPerWeek }]
+    set weekOfFiscalYear [expr { ( $dayOfFiscalYear / 7 ) + 1 }]
+    set dayOfWeek [expr { ( $dayOfFiscalYear + 1 ) % 7 }]
     if { $dayOfWeek < $firstDayOfWeek } {
-	incr dayOfWeek $DaysPerWeek
+	incr dayOfWeek 7
     }
     
     # Store the fiscal year, week, and day in the given slots in the
@@ -4433,8 +4351,6 @@ proc ::tcl::clock::GetJulianDayFromEraYearWeekDay {
     { keys { iso8601Year iso8601Week dayOfWeek } }
 } {
 
-    variable DaysPerWeek
-
     foreach var { fiscalYear fiscalWeek dayOfWeek } key $keys {
 	set $var [dict get $date $key]
     }
@@ -4456,7 +4372,7 @@ proc ::tcl::clock::GetJulianDayFromEraYearWeekDay {
 
     dict set date julianDay \
 	[expr { $jd
-		+ ( $DaysPerWeek * ( $fiscalWeek - 1 ) )
+		+ ( 7 * ( $fiscalWeek - 1 ) )
 	        + $dayOfWeek - $firstDayOfWeek }]
 
     return $date
@@ -4489,8 +4405,6 @@ proc ::tcl::clock::GetJulianDayFromEraYearWeekDay {
 
 proc ::tcl::clock::GetJulianDayFromEraYearMonthDay { date } {
 
-    variable JD0Jan1CEJul
-    variable JD0Jan1CEGreg
     variable DaysInPriorMonthsInCommonYear
     variable DaysInPriorMonthsInLeapYear
 
@@ -4509,7 +4423,7 @@ proc ::tcl::clock::GetJulianDayFromEraYearMonthDay { date } {
     # Try the Gregorian calendar first.
 
     dict set date gregorian 1
-    set jd [expr { $JD0Jan1CEGreg
+    set jd [expr { 1721425
 		   + [dict get $date dayOfMonth]
 		   + ( [IsGregorianLeapYear $date] ?
 		       [lindex $DaysInPriorMonthsInLeapYear \
@@ -4526,7 +4440,7 @@ proc ::tcl::clock::GetJulianDayFromEraYearMonthDay { date } {
     if { $jd < [mc GREGORIAN_CHANGE_DATE] } {
 
 	dict set date gregorian 0
-	set jd [expr { $JD0Jan1CEJul
+	set jd [expr { 1721423
 		       + [dict get $date dayOfMonth]
 		       + ( ( $year % 4 == 0 ) ?
 		       [lindex $DaysInPriorMonthsInLeapYear \
@@ -4568,8 +4482,6 @@ proc ::tcl::clock::GetJulianDayFromEraYearMonthDay { date } {
 
 proc ::tcl::clock::GetJulianDayFromEraYearDay { date } {
 
-    variable JD0Jan1CEJul
-    variable JD0Jan1CEGreg
     variable DaysInPriorMonthsInCommonYear
     variable DaysInPriorMonthsInLeapYear
 
@@ -4588,7 +4500,7 @@ proc ::tcl::clock::GetJulianDayFromEraYearDay { date } {
     # Try the Gregorian calendar first.
 
     dict set date gregorian 1
-    set jd [expr { $JD0Jan1CEGreg
+    set jd [expr { 1721425
 		   + [dict get $date dayOfYear]
 		   + ( 365 * $ym1 )
 		   + ( $ym1 / 4 )
@@ -4599,7 +4511,7 @@ proc ::tcl::clock::GetJulianDayFromEraYearDay { date } {
 
     if { $jd < [mc GREGORIAN_CHANGE_DATE] } {
 	dict set date gregorian 0
-	set jd [expr { $JD0Jan1CEJul
+	set jd [expr { 1721423
 		       + [dict get $date dayOfYear]
 		       + ( 365 * $ym1 )
 		       + ( $ym1 / 4 ) }]
@@ -4630,8 +4542,6 @@ proc ::tcl::clock::GetJulianDayFromEraYearDay { date } {
 
 proc ::tcl::clock::GetJulianDayFromEraYearMonthWeekDay { date } {
 
-    variable DaysPerWeek
-
     # 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)
@@ -4642,12 +4552,12 @@ proc ::tcl::clock::GetJulianDayFromEraYearMonthWeekDay { date } {
 	dict set date2 dayOfMonth 0
     } else {
 	dict incr date2 month
-	dict set date2 dayOfMonth $DaysPerWeek
+	dict set date2 dayOfMonth 7
     }
     set date2 [GetJulianDayFromEraYearMonthDay $date2[set date2 {}]]
     set wd0 [WeekdayOnOrBefore [dict get $date dayOfWeek] \
 		 [dict get $date2 julianDay]]
-    dict set date julianDay [expr { $wd0 + $DaysPerWeek * $week }]
+    dict set date julianDay [expr { $wd0 + 7 * $week }]
     return $date
 
 }
@@ -4716,10 +4626,8 @@ proc ::tcl::clock::IsGregorianLeapYear { date } {
 
 proc ::tcl::clock::WeekdayOnOrBefore { weekday j } {
 
-    variable DaysPerWeek
-
-    set k [expr { ( $weekday + 6 )  % $DaysPerWeek }]
-    return [expr { $j - ( $j - $k ) % $DaysPerWeek }]
+    set k [expr { ( $weekday + 6 )  % 7 }]
+    return [expr { $j - ( $j - $k ) % 7 }]
 
 }
 
@@ -4813,8 +4721,6 @@ proc ::tcl::clock::BSearch { list key } {
 
 proc ::tcl::clock::add { clockval args } {
 
-    variable DaysPerWeek
-
     if { [llength $args] % 2 != 0 } {
 	return -code error \
 	    -errorcode [list CLOCK wrongNumArgs] \
@@ -4899,7 +4805,7 @@ proc ::tcl::clock::add { clockval args } {
 		}
 
 		weeks - week {
-		    set clockval [AddDays [expr { $DaysPerWeek * $quantity }] \
+		    set clockval [AddDays [expr { 7 * $quantity }] \
 				      $clockval $timezone]
 		}
 		days - day {
@@ -4970,8 +4876,6 @@ proc ::tcl::clock::AddMonths { months clockval timezone } {
 
     variable DaysInRomanMonthInCommonYear
     variable DaysInRomanMonthInLeapYear
-    variable PosixEpochAsJulianSeconds
-    variable SecondsPerDay
 
     # Convert the time to year, month, day, and fraction of day.
 
@@ -4982,7 +4886,7 @@ proc ::tcl::clock::AddMonths { months clockval timezone } {
 				 [dict create seconds $clockval] \
 				 $timezone]]]]
     dict set date secondOfDay [expr { [dict get $date localSeconds]
-				      % $SecondsPerDay }]
+				      % 86400 }]
     dict set date tzName $timezone
 
     # Add the requisite number of months
@@ -5011,8 +4915,8 @@ proc ::tcl::clock::AddMonths { months clockval timezone } {
     set date [GetJulianDayFromEraYearMonthDay \
 		  $date[set date {}]]
     dict set date localSeconds \
-	[expr { -$PosixEpochAsJulianSeconds
-		+ ( $SecondsPerDay * wide([dict get $date julianDay]) )
+	[expr { -210866803200
+		+ ( 86400 * wide([dict get $date julianDay]) )
 		+ [dict get $date secondOfDay] }]
     set date [ConvertLocalToUTC $date[set date {}]]
 
@@ -5043,9 +4947,6 @@ proc ::tcl::clock::AddMonths { months clockval timezone } {
 
 proc ::tcl::clock::AddDays { days clockval timezone } {
 
-    variable PosixEpochAsJulianSeconds
-    variable SecondsPerDay
-
     # Convert the time to Julian Day
 
     set date [GetJulianDay \
@@ -5053,7 +4954,7 @@ proc ::tcl::clock::AddDays { days clockval timezone } {
 		       [dict create seconds $clockval] \
 		       $timezone]]
     dict set date secondOfDay [expr { [dict get $date localSeconds]
-				      % $SecondsPerDay }]
+				      % 86400 }]
     dict set date tzName $timezone
 
     # Add the requisite number of days
@@ -5063,8 +4964,8 @@ proc ::tcl::clock::AddDays { days clockval timezone } {
     # Reconvert to a number of seconds
 
     dict set date localSeconds \
-	[expr { -$PosixEpochAsJulianSeconds
-		+ ( $SecondsPerDay * wide([dict get $date julianDay]) )
+	[expr { -210866803200
+		+ ( 86400 * wide([dict get $date julianDay]) )
 		+ [dict get $date secondOfDay] }]
     set date [ConvertLocalToUTC $date[set date {}]]
 
@@ -5074,6 +4975,39 @@ proc ::tcl::clock::AddDays { days clockval timezone } {
 
 #----------------------------------------------------------------------
 #
+# mc --
+#
+#	Wrapper around ::msgcat::mc that caches the result according
+#	to the locale.
+#
+# Parameters:
+#	Accepts the name of the message to retrieve.
+#
+# Results:
+#	Returns the message text.
+#
+# Side effects:
+#	Caches the message text.
+#
+# Notes:
+#	Only the single-argument version of [mc] is supported.
+#
+#----------------------------------------------------------------------
+
+proc ::tcl::clock::mc { name } {
+    variable McLoaded
+    set Locale [mclocale]
+    if { [dict exists $McLoaded $Locale $name] } {
+	return [dict get $McLoaded $Locale $name]
+    } else {
+	set val [::msgcat::mc $name]
+	dict set McLoaded $Locale $name $val
+	return $val
+    }
+}
+
+#----------------------------------------------------------------------
+#
 # ClearCaches --
 #
 #	Clears all caches to reclaim the memory used in [clock]