Fix [738bc50e93]: auto_execok doesn't recognise mklink on windows. Remove some unnecessary end-of-line spacing.

1 files changed, 84 insertions, 84 deletions

diff --git a/library/clock.tcl b/library/clock.tcl
index 1f83716..eb87251 100644
--- a/library/clock.tcl
+++ b/library/clock.tcl
@@ -43,7 +43,7 @@ namespace eval ::tcl::clock \
 # The 'clock' command manipulates time.  Refer to the user documentation
 # for the available subcommands and what they do.
 #
-#----------------------------------------------------------------------	
+#----------------------------------------------------------------------
 
 namespace eval ::tcl::clock {
 
@@ -189,7 +189,7 @@ proc ::tcl::clock::Initialize {} {
     # Germany, Norway, Denmark (Catholic Germany changed earlier)
 
     ::msgcat::mcset de_DE GREGORIAN_CHANGE_DATE 2342032
-    ::msgcat::mcset nb 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
@@ -225,7 +225,7 @@ proc ::tcl::clock::Initialize {} {
     # Greece
 
     ::msgcat::mcset el GREGORIAN_CHANGE_DATE 2423480
-    
+
     #------------------------------------------------------------------
     #
     #				CONSTANTS
@@ -378,7 +378,7 @@ proc ::tcl::clock::Initialize {} {
 	{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 
+    # 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.
@@ -670,7 +670,7 @@ proc ::tcl::clock::format { args } {
     set clockval [lindex $args 0]
 
     # Get the data for time changes in the given zone
-    
+
     if {$timezone eq ""} {
 	set timezone [GetSystemTimeZone]
     }
@@ -680,11 +680,11 @@ proc ::tcl::clock::format { args } {
 	    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)]} {
@@ -693,7 +693,7 @@ proc ::tcl::clock::format { args } {
 	set FormatProc($procName) \
 	    [ParseClockFormatFormat $procName $format $locale]
     }
-    
+
     return [$procName $clockval $timezone]
 
 }
@@ -720,7 +720,7 @@ proc ::tcl::clock::ParseClockFormatFormat {procName format locale} {
     }
 
     # Map away the locale-dependent composite format groups
-    
+
     EnterLocale $locale oldLocale
 
     # Change locale if a fresh locale has been given on the command line.
@@ -767,7 +767,7 @@ proc ::tcl::clock::ParseClockFormatFormat2 {format locale procName} {
     set formatString {}
     set substituents {}
     set state {}
-	
+
     set format [LocalizeFormat $locale $format]
 
     foreach char [split $format {}] {
@@ -794,7 +794,7 @@ proc ::tcl::clock::ParseClockFormatFormat2 {format locale procName} {
 				 { [lindex @DAYS_OF_WEEK_ABBREV@ \
 					[expr {[dict get $date dayOfWeek] \
 						   % 7}]]}]
-		    }			 
+		    }
 		    A {			# Day of week, spelt out.
 			append formatString %s
 			append substituents \
@@ -895,7 +895,7 @@ proc ::tcl::clock::ParseClockFormatFormat2 {format locale procName} {
 		    k {			# Hour (0-23), no leading zero
 			append formatString %2d
 			append substituents \
-			    { [expr { [dict get $date localSeconds] 
+			    { [expr { [dict get $date localSeconds]
 				      / 3600
 				      % 24 }]}
 		    }
@@ -916,7 +916,7 @@ proc ::tcl::clock::ParseClockFormatFormat2 {format locale procName} {
 		    M {			# Minute of the hour, leading zero
 			append formatString %02d
 			append substituents \
-			    { [expr { [dict get $date localSeconds] 
+			    { [expr { [dict get $date localSeconds]
 				      / 60
 				      % 60 }]}
 		    }
@@ -957,7 +957,7 @@ proc ::tcl::clock::ParseClockFormatFormat2 {format locale procName} {
 			    { [expr {(([dict get $date localSeconds]
 				       % 86400) < 43200) ?
 				     $am : $pm}]}
-			
+
 		    }
 		    Q {			# Hi, Jeff!
 			append formatString %s
@@ -967,11 +967,11 @@ proc ::tcl::clock::ParseClockFormatFormat2 {format locale procName} {
 			append formatString %s
 			append substituents { [dict get $date seconds]}
 		    }
-		    S {			# Second of the minute, with 
+		    S {			# Second of the minute, with
 			# leading zero
 			append formatString %02d
 			append substituents \
-			    { [expr { [dict get $date localSeconds] 
+			    { [expr { [dict get $date localSeconds]
 				      % 60 }]}
 		    }
 		    t {			# A literal tab character
@@ -992,7 +992,7 @@ proc ::tcl::clock::ParseClockFormatFormat2 {format locale procName} {
 			    }
 			    incr dow
 			    set UweekNumber \
-				[expr { ( [dict get $date dayOfYear] 
+				[expr { ( [dict get $date dayOfYear]
 					  - $dow + 7 )
 					/ 7 }]
 			}
@@ -1015,7 +1015,7 @@ proc ::tcl::clock::ParseClockFormatFormat2 {format locale procName} {
 			    set WweekNumber \
 				[expr { ( [dict get $date dayOfYear]
 					  - [dict get $date dayOfWeek]
-					  + 7 ) 
+					  + 7 )
 					/ 7 }]
 			}
 			append formatString %02d
@@ -1084,7 +1084,7 @@ proc ::tcl::clock::ParseClockFormatFormat2 {format locale procName} {
 	    percentO {			# Character following %O
 		set state {}
 		switch -exact -- $char {
-		    d - e {		# Day of the month in alternative 
+		    d - e {		# Day of the month in alternative
 			# numerals
 			append formatString %s
 			append substituents \
@@ -1096,7 +1096,7 @@ proc ::tcl::clock::ParseClockFormatFormat2 {format locale procName} {
 			append formatString %s
 			append substituents \
 			    { [lindex $localeNumerals \
-				   [expr { [dict get $date localSeconds] 
+				   [expr { [dict get $date localSeconds]
 					   / 3600
 					   % 24 }]]}
 		    }
@@ -1122,7 +1122,7 @@ proc ::tcl::clock::ParseClockFormatFormat2 {format locale procName} {
 			append formatString %s
 			append substituents \
 			    { [lindex $localeNumerals \
-				   [expr { [dict get $date localSeconds] 
+				   [expr { [dict get $date localSeconds]
 					   / 60
 					   % 60 }]]}
 		    }
@@ -1131,7 +1131,7 @@ proc ::tcl::clock::ParseClockFormatFormat2 {format locale procName} {
 			append formatString %s
 			append substituents \
 			    { [lindex $localeNumerals \
-				   [expr { [dict get $date localSeconds] 
+				   [expr { [dict get $date localSeconds]
 					   % 60 }]]}
 		    }
 		    u {			# Day of the week (Monday=1,Sunday=7)
@@ -1162,9 +1162,9 @@ proc ::tcl::clock::ParseClockFormatFormat2 {format locale procName} {
 	    }
 	}
     }
-	
+
     # Clean up any improperly terminated groups
-    
+
     switch -exact -- $state {
 	percent {
 	    append formatString %%
@@ -1263,7 +1263,7 @@ proc ::tcl::clock::scan { args } {
     }
     if { [catch { expr { wide($base) } } result] } {
 	return -code error \
-	    "expected integer but got \"$base\"" 
+	    "expected integer but got \"$base\""
     }
     if { ![string is boolean $gmt] } {
 	return -code error \
@@ -1340,7 +1340,7 @@ proc ::tcl::clock::FreeScan { string base timezone locale } {
     variable TZData
 
     # Get the data for time changes in the given zone
-    
+
     if {[catch {SetupTimeZone $timezone} retval opts]} {
 	dict unset opts -errorinfo
 	return -options $opts $retval
@@ -1353,7 +1353,7 @@ proc ::tcl::clock::FreeScan { string base timezone locale } {
 		  $base \
 		  $TZData($timezone) \
 		  2361222]
-    dict set date secondOfDay [expr { [dict get $date localSeconds] 
+    dict set date secondOfDay [expr { [dict get $date localSeconds]
 				      % 86400 }]
 
     # Parse the date.  The parser will return a list comprising
@@ -1400,7 +1400,7 @@ proc ::tcl::clock::FreeScan { string base timezone locale } {
     # 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 \
@@ -1414,9 +1414,9 @@ proc ::tcl::clock::FreeScan { string base timezone locale } {
     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 
+    } elseif { [llength $parseWeekday] != 0
+	       || [llength $parseOrdinalMonth] != 0
+	       || ( [llength $parseRel] != 0
 		    && ( [lindex $parseRel 0] != 0
 			 || [lindex $parseRel 1] != 0 ) ) } {
 	dict set date secondOfDay 0
@@ -1437,17 +1437,17 @@ proc ::tcl::clock::FreeScan { string base timezone locale } {
 	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] 
+			 [expr { [dict get $date2 julianDay]
 				 + 6 }]]
 	incr jdwkday [expr { 7 * $dayOrdinal }]
 	if { $dayOrdinal > 0 } {
@@ -1506,7 +1506,7 @@ proc ::tcl::clock::FreeScan { string base timezone locale } {
 #
 # Results:
 #	Constructs and returns a procedure that accepts the
-#	string being scanned, the base time, and the time zone.  
+#	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]
@@ -1776,7 +1776,7 @@ proc ::tcl::clock::ParseClockScanFormat {formatString locale} {
 			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 \[" \
@@ -1948,7 +1948,7 @@ proc ::tcl::clock::ParseClockScanFormat {formatString locale} {
 					"day of week is greater than 7"
 				}
 				dict set date dayOfWeek $dow
-			    }				
+			    }
 		    }
 		    y {
 			lassign [LocaleNumeralMatcher $locale] regex lookup
@@ -1996,7 +1996,7 @@ proc ::tcl::clock::ParseClockScanFormat {formatString locale} {
 
     # Get time zone if needed
 
-    if { ![dict exists $fieldSet seconds] 
+    if { ![dict exists $fieldSet seconds]
 	 && ![dict exists $fieldSet starDate] } {
 	if { [dict exists $fieldSet tzName] } {
 	    append procBody {
@@ -2018,7 +2018,7 @@ proc ::tcl::clock::ParseClockScanFormat {formatString locale} {
 
     # Assemble seconds, and convert local nominal time to UTC.
 
-    if { ![dict exists $fieldSet seconds] 
+    if { ![dict exists $fieldSet seconds]
          && ![dict exists $fieldSet starDate] } {
 	append procBody {
 	    if { [dict get $date julianDay] > 5373484 } {
@@ -2047,7 +2047,7 @@ proc ::tcl::clock::ParseClockScanFormat {formatString locale} {
 
     return $procName
 }
-	
+
 #----------------------------------------------------------------------
 #
 # LocaleNumeralMatcher --
@@ -2087,7 +2087,7 @@ proc ::tcl::clock::LocaleNumeralMatcher {l} {
     }
     return [dict get $LocaleNumeralCache $l]
 }
-	
+
 
 
 #----------------------------------------------------------------------
@@ -2128,7 +2128,7 @@ proc ::tcl::clock::UniquePrefixRegexp { data } {
 
     foreach { key value } $data {
 
-	# Construct all prefixes of the key; 
+	# Construct all prefixes of the key;
 
 	set prefix {}
 	foreach char [split $key {}] {
@@ -2191,7 +2191,7 @@ proc ::tcl::clock::UniquePrefixRegexp { data } {
 #
 #----------------------------------------------------------------------
 
-proc ::tcl::clock::MakeUniquePrefixRegexp { successors 
+proc ::tcl::clock::MakeUniquePrefixRegexp { successors
 					  uniquePrefixMapping
 					  prefixString } {
 
@@ -2322,7 +2322,7 @@ proc ::tcl::clock::MakeParseCodeFromFields { dateFields parseActions } {
 	set currPrio $prio
 	set currFieldPos $fPos
 	set currCodeBurst $parseAction
-	    
+
     }
 
     return $currCodeBurst
@@ -2401,7 +2401,7 @@ proc ::tcl::clock::EnterLocale { locale oldLocaleVar } {
 	dict set McLoaded $locale {}
     }
 
-}    
+}
 
 #----------------------------------------------------------------------
 #
@@ -2565,7 +2565,7 @@ proc ::tcl::clock::LocalizeFormat { locale 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
@@ -2582,7 +2582,7 @@ proc ::tcl::clock::LocalizeFormat { locale 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]
-				       
+
     dict set McLoaded $locale FORMAT $inFormat $format
     return $format
 }
@@ -2790,7 +2790,7 @@ proc ::tcl::clock::ScanWide { str } {
 #
 #----------------------------------------------------------------------
 
-proc ::tcl::clock::InterpretTwoDigitYear { date baseTime 
+proc ::tcl::clock::InterpretTwoDigitYear { date baseTime
 					   { twoDigitField yearOfCentury }
 					   { fourDigitField year } } {
 
@@ -2886,7 +2886,7 @@ proc ::tcl::clock::AssignBaseIso8601Year {date baseTime timeZone changeover} {
 #
 # AssignBaseMonth --
 #
-#	Places the number of the current year and month into a 
+#	Places the number of the current year and month into a
 #	dictionary.
 #
 # Parameters:
@@ -3191,10 +3191,10 @@ proc ::tcl::clock::SetupTimeZone { timezone } {
 	    set TZData($timezone) [list [list $MINWIDE $offset -1 $timezone]]
 
 	} elseif { [string index $timezone 0] eq {:} } {
-	    
+
 	    # Convert using a time zone file
 
-	    if { 
+	    if {
 		[catch {
 		    LoadTimeZoneFile [string range $timezone 1 end]
 		}]
@@ -3206,9 +3206,9 @@ proc ::tcl::clock::SetupTimeZone { timezone } {
 		    -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] } {
@@ -3255,7 +3255,7 @@ proc ::tcl::clock::SetupTimeZone { timezone } {
 #	no time zone information supplied with Windows actually uses
 #	them!
 #
-# On a Windows system where neither $env(TCL_TZ) nor $env(TZ) is 
+# 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
@@ -3378,7 +3378,7 @@ proc ::tcl::clock::GuessWindowsTimeZone {} {
 		: [::format %02d $stdSecond]
 	}
 	dict set WinZoneInfo $data $tzname
-    } 
+    }
 
     return [dict get $WinZoneInfo $data]
 
@@ -3533,10 +3533,10 @@ proc ::tcl::clock::ReadZoneinfoFile {fileName fname} {
 
     if {$version eq "2"} {
 	set seek [expr {44
-			+ 5 * $nTime 
-			+ 6 * $nType 
+			+ 5 * $nTime
+			+ 6 * $nType
 			+ 4 * $nLeap
-			+ $nIsStd 
+			+ $nIsStd
 			+ $nIsGMT
 			+ $nChar
 		    }]
@@ -3652,7 +3652,7 @@ proc ::tcl::clock::ReadZoneinfoFile {fileName fname} {
 # 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 
+#	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
@@ -3697,7 +3697,7 @@ proc ::tcl::clock::ReadZoneinfoFile {fileName fname} {
 #	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.
 #
@@ -3715,8 +3715,8 @@ proc ::tcl::clock::ParsePosixTimeZone { tz } {
 	([[:digit:]]{1,2})
 	(?:
 	    # 4 - Standard time zone offset, minutes
-	    : ([[:digit:]]{1,2}) 
-	    (?: 
+	    : ([[:digit:]]{1,2})
+	    (?:
 	        # 5 - Standard time zone offset, seconds
 		: ([[:digit:]]{1,2} )
 	    )?
@@ -3732,8 +3732,8 @@ proc ::tcl::clock::ParsePosixTimeZone { tz } {
 		    ([[:digit:]]{1,2})
 		    (?:
 			# 9 - DST time zone offset, minutes
-			: ([[:digit:]]{1,2}) 
-			(?: 
+			: ([[:digit:]]{1,2})
+			(?:
 		            # 10 - DST time zone offset, seconds
 			    : ([[:digit:]]{1,2})
 			)?
@@ -3746,8 +3746,8 @@ proc ::tcl::clock::ParsePosixTimeZone { tz } {
 		        ( J ? )	( [[:digit:]]+ )
                         | M
 			# 13 - Month number 14 - Week of month 15 - Day of week
-			( [[:digit:]] + ) 
-			[.] ( [[:digit:]] + ) 
+			( [[:digit:]] + )
+			[.] ( [[:digit:]] + )
 			[.] ( [[:digit:]] + )
 		    )
 		    (?:
@@ -3768,8 +3768,8 @@ proc ::tcl::clock::ParsePosixTimeZone { tz } {
 		        ( J ? )	( [[:digit:]]+ )
                         | M
 			# 21 - Month number 22 - Week of month 23 - Day of week
-			( [[:digit:]] + ) 
-			[.] ( [[:digit:]] + ) 
+			( [[:digit:]] + )
+			[.] ( [[:digit:]] + )
 			[.] ( [[:digit:]] + )
 		    )
 		    (?:
@@ -3845,14 +3845,14 @@ proc ::tcl::clock::ProcessPosixTimeZone { z } {
     } else {
 	set stdSignum -1
     }
-    set stdHours [lindex [::scan [dict get $z stdHours] %d] 0] 
+    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] 
+	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] 
+	set stdSeconds [lindex [::scan [dict get $z stdSeconds] %d] 0]
     } else {
 	set stdSeconds 0
     }
@@ -3881,14 +3881,14 @@ proc ::tcl::clock::ProcessPosixTimeZone { z } {
     if { [dict get $z dstHours] eq {} } {
 	set dstOffset [expr { 3600 + $stdOffset }]
     } else {
-	set dstHours [lindex [::scan [dict get $z dstHours] %d] 0] 
+	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] 
+	    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] 
+	    set dstSeconds [lindex [::scan [dict get $z dstSeconds] %d] 0]
 	} else {
 	    set dstSeconds 0
 	}
@@ -3903,7 +3903,7 @@ proc ::tcl::clock::ProcessPosixTimeZone { z } {
     # US end time is the first Sunday in November.
     # EU end time is the last Sunday in October
 
-    if { [dict get $z startDayOfYear] eq {} 
+    if { [dict get $z startDayOfYear] eq {}
 	 && [dict get $z startMonth] eq {} } {
 	if {($stdSignum * $stdHours>=0) && ($stdSignum * $stdHours<=12)} {
 	    # EU
@@ -3923,7 +3923,7 @@ proc ::tcl::clock::ProcessPosixTimeZone { z } {
 	dict set z startMinutes 0
 	dict set z startSeconds 0
     }
-    if { [dict get $z endDayOfYear] eq {} 
+    if { [dict get $z endDayOfYear] eq {}
 	 && [dict get $z endMonth] eq {} } {
 	if {($stdSignum * $stdHours>=0) && ($stdSignum * $stdHours<=12)} {
 	    # EU
@@ -3964,8 +3964,8 @@ proc ::tcl::clock::ProcessPosixTimeZone { z } {
     }
 
     return $data
-    
-}    
+
+}
 
 #----------------------------------------------------------------------
 #
@@ -4000,7 +4000,7 @@ proc ::tcl::clock::DeterminePosixDSTTime { z bound y } {
 	# Time was specified as a day of the year
 
 	if { [dict get $z ${bound}J] ne {}
-	     && [IsGregorianLeapYear $y] 
+	     && [IsGregorianLeapYear $y]
 	     && ( $doy > $FEB_28 ) } {
 	    incr doy
 	}
@@ -4078,7 +4078,7 @@ proc ::tcl::clock::GetLocaleEra { date etable } {
 	    [expr { [dict get $date year] % 100 }]
     } else {
 	dict set date localeEra [lindex $etable $index 1]
-	dict set date localeYear [expr { [dict get $date year] 
+	dict set date localeYear [expr { [dict get $date year]
 					 - [lindex $etable $index 2] }]
     }
     return $date
@@ -4136,7 +4136,7 @@ proc ::tcl::clock::GetJulianDayFromEraYearDay {date changeover} {
 		   + ( $ym1 / 4 )
 		   - ( $ym1 / 100 )
 		   + ( $ym1 / 400 ) }]
-    
+
     # If the date is before the Gregorian change, use the Julian calendar.
 
     if { $jd < $changeover } {
@@ -4219,7 +4219,7 @@ proc ::tcl::clock::GetJulianDayFromEraYearMonthWeekDay {date changeover} {
 proc ::tcl::clock::IsGregorianLeapYear { date } {
 
     switch -exact -- [dict get $date era] {
-	BCE { 
+	BCE {
 	    set year [expr { 1 - [dict get $date year]}]
 	}
 	CE {
@@ -4415,7 +4415,7 @@ proc ::tcl::clock::add { clockval args } {
     }
     if { [catch { expr { wide($clockval) } } result] } {
 	return -code error \
-	    "expected integer but got \"$clockval\"" 
+	    "expected integer but got \"$clockval\""
     }
     if { ![string is boolean $gmt] } {
 	return -code error \
@@ -4427,7 +4427,7 @@ proc ::tcl::clock::add { clockval args } {
     }
 
     EnterLocale $locale oldLocale
-    
+
     set changeover [mc GREGORIAN_CHANGE_DATE]
 
     if {[catch {SetupTimeZone $timezone} retval opts]} {