Merge 8.7

1 files changed, 437 insertions, 484 deletions

diff --git a/generic/tclClock.c b/generic/tclClock.c
index 026c47b..1845af0 100644
--- a/generic/tclClock.c
+++ b/generic/tclClock.c
@@ -89,38 +89,32 @@ static void		GetYearWeekDay(TclDateFields *, int);
 static void		GetGregorianEraYearDay(TclDateFields *, int);
 static void		GetMonthDay(TclDateFields *);
 static Tcl_WideInt	WeekdayOnOrBefore(int, Tcl_WideInt);
-static Tcl_ObjCmdProc ClockClicksObjCmd;
-static Tcl_ObjCmdProc ClockConvertlocaltoutcObjCmd;
-
+static Tcl_ObjCmdProc	ClockClicksObjCmd;
+static Tcl_ObjCmdProc	ClockConvertlocaltoutcObjCmd;
 static int		ClockGetDateFields(void *clientData,
 			    Tcl_Interp *interp, TclDateFields *fields,
 			    Tcl_Obj *timezoneObj, int changeover);
-static Tcl_ObjCmdProc ClockGetdatefieldsObjCmd;
-static Tcl_ObjCmdProc ClockGetjuliandayfromerayearmonthdayObjCmd;
-static Tcl_ObjCmdProc ClockGetjuliandayfromerayearweekdayObjCmd;
-static Tcl_ObjCmdProc ClockGetenvObjCmd;
-static Tcl_ObjCmdProc ClockMicrosecondsObjCmd;
-static Tcl_ObjCmdProc ClockMillisecondsObjCmd;
-static Tcl_ObjCmdProc ClockSecondsObjCmd;
-static Tcl_ObjCmdProc ClockFormatObjCmd;
-static Tcl_ObjCmdProc ClockScanObjCmd;
-static int		ClockScanCommit(
-			    DateInfo *info,
+static Tcl_ObjCmdProc	ClockGetdatefieldsObjCmd;
+static Tcl_ObjCmdProc	ClockGetjuliandayfromerayearmonthdayObjCmd;
+static Tcl_ObjCmdProc	ClockGetjuliandayfromerayearweekdayObjCmd;
+static Tcl_ObjCmdProc	ClockGetenvObjCmd;
+static Tcl_ObjCmdProc	ClockMicrosecondsObjCmd;
+static Tcl_ObjCmdProc	ClockMillisecondsObjCmd;
+static Tcl_ObjCmdProc	ClockSecondsObjCmd;
+static Tcl_ObjCmdProc	ClockFormatObjCmd;
+static Tcl_ObjCmdProc	ClockScanObjCmd;
+static int		ClockScanCommit(DateInfo *info,
 			    ClockFmtScnCmdArgs *opts);
-static int		ClockFreeScan(
-			    DateInfo *info,
+static int		ClockFreeScan(DateInfo *info,
 			    Tcl_Obj *strObj, ClockFmtScnCmdArgs *opts);
-static int		ClockCalcRelTime(
-			    DateInfo *info);
-static Tcl_ObjCmdProc ClockAddObjCmd;
-static int		ClockValidDate(
-			    DateInfo *,
+static int		ClockCalcRelTime(DateInfo *info);
+static Tcl_ObjCmdProc	ClockAddObjCmd;
+static int		ClockValidDate(DateInfo *,
 			    ClockFmtScnCmdArgs *, int stage);
 static struct tm *	ThreadSafeLocalTime(const time_t *);
 static size_t		TzsetIfNecessary(void);
 static void		ClockDeleteCmdProc(void *);
-
-static Tcl_ObjCmdProc ClockSafeCatchCmd;
+static Tcl_ObjCmdProc	ClockSafeCatchCmd;
 /*
  * Structure containing description of "native" clock commands to create.
  */
@@ -133,7 +127,7 @@ struct ClockCommand {
 				 * will always have the ClockClientData sent
 				 * to it, but may well ignore this data. */
     CompileProc *compileProc;	/* The compiler for the command. */
-    void *clientData;	/* Any clientData to give the command (if NULL
+    void *clientData;		/* Any clientData to give the command (if NULL
     				 * a reference to ClockClientData will be sent) */
 };
 
@@ -182,7 +176,7 @@ TclClockInit(
     char cmdName[50];		/* Buffer large enough to hold the string
 				 *::tcl::clock::GetJulianDayFromEraYearMonthDay
 				 * plus a terminating NUL. */
-    Command         *cmdPtr;
+    Command *cmdPtr;
     ClockClientData *data;
     int i;
 
@@ -266,7 +260,7 @@ TclClockInit(
 	cmdPtr->compileProc = clockCmdPtr->compileProc ?
 		clockCmdPtr->compileProc : TclCompileBasicMin0ArgCmd;
     }
-    cmdPtr = (Command *)Tcl_CreateObjCommand(interp,
+    cmdPtr = (Command *) Tcl_CreateObjCommand(interp,
 	    "::tcl::unsupported::clock::configure",
 	    ClockConfigureObjCmd, data, ClockDeleteCmdProc);
     data->refCount++;
@@ -419,51 +413,44 @@ SavePrevTimezoneObj(
 static Tcl_Obj *
 NormTimezoneObj(
     ClockClientData *dataPtr,	/* Client data containing literal pool */
-    Tcl_Obj	*timezoneObj,	/* Name of zone to find */
-    int		*loaded)	/* Used to recognized TZ was loaded */
+    Tcl_Obj *timezoneObj,	/* Name of zone to find */
+    int *loaded)		/* Used to recognized TZ was loaded */
 {
     const char *tz;
 
     *loaded = 1;
-    if ( timezoneObj == dataPtr->lastSetupTimeZoneUnnorm
-      && dataPtr->lastSetupTimeZone != NULL
-    ) {
+    if (timezoneObj == dataPtr->lastSetupTimeZoneUnnorm
+	    && dataPtr->lastSetupTimeZone != NULL) {
 	return dataPtr->lastSetupTimeZone;
     }
-    if ( timezoneObj == dataPtr->prevSetupTimeZoneUnnorm
-      && dataPtr->prevSetupTimeZone != NULL
-    ) {
+    if (timezoneObj == dataPtr->prevSetupTimeZoneUnnorm
+	    && dataPtr->prevSetupTimeZone != NULL) {
     	return dataPtr->prevSetupTimeZone;
     }
     if (timezoneObj == dataPtr->gmtSetupTimeZoneUnnorm
-      && dataPtr->gmtSetupTimeZone != NULL
-    ) {
+	    && dataPtr->gmtSetupTimeZone != NULL) {
 	return dataPtr->literals[LIT_GMT];
     }
-    if ( timezoneObj == dataPtr->lastSetupTimeZone
-      || timezoneObj == dataPtr->prevSetupTimeZone
-      || timezoneObj == dataPtr->gmtSetupTimeZone
-      || timezoneObj == dataPtr->systemTimeZone
-    ) {
+    if (timezoneObj == dataPtr->lastSetupTimeZone
+	    || timezoneObj == dataPtr->prevSetupTimeZone
+	    || timezoneObj == dataPtr->gmtSetupTimeZone
+	    || timezoneObj == dataPtr->systemTimeZone) {
 	return timezoneObj;
     }
 
     tz = TclGetString(timezoneObj);
-    if (dataPtr->lastSetupTimeZone != NULL &&
-	strcmp(tz, TclGetString(dataPtr->lastSetupTimeZone)) == 0
-    ) {
+    if (dataPtr->lastSetupTimeZone != NULL
+	    && strcmp(tz, TclGetString(dataPtr->lastSetupTimeZone)) == 0) {
 	TclSetObjRef(dataPtr->lastSetupTimeZoneUnnorm, timezoneObj);
 	return dataPtr->lastSetupTimeZone;
     }
-    if (dataPtr->prevSetupTimeZone != NULL &&
-	strcmp(tz, TclGetString(dataPtr->prevSetupTimeZone)) == 0
-    ) {
+    if (dataPtr->prevSetupTimeZone != NULL
+	    && strcmp(tz, TclGetString(dataPtr->prevSetupTimeZone)) == 0) {
 	TclSetObjRef(dataPtr->prevSetupTimeZoneUnnorm, timezoneObj);
 	return dataPtr->prevSetupTimeZone;
     }
-    if (dataPtr->systemTimeZone != NULL &&
-	strcmp(tz, TclGetString(dataPtr->systemTimeZone)) == 0
-    ) {
+    if (dataPtr->systemTimeZone != NULL
+	    && strcmp(tz, TclGetString(dataPtr->systemTimeZone)) == 0) {
 	return dataPtr->systemTimeZone;
     }
     if (strcmp(tz, Literals[LIT_GMT]) == 0) {
@@ -555,6 +542,7 @@ SavePrevLocaleObj(
     ClockClientData *dataPtr)	/* Client data containing literal pool */
 {
     Tcl_Obj *localeObj = dataPtr->lastUsedLocale;
+
     if (localeObj && localeObj != dataPtr->prevUsedLocale) {
 	TclSetObjRef(dataPtr->prevUsedLocaleUnnorm, dataPtr->lastUsedLocaleUnnorm);
 	TclSetObjRef(dataPtr->prevUsedLocale, localeObj);
@@ -583,97 +571,88 @@ static Tcl_Obj *
 NormLocaleObj(
     ClockClientData *dataPtr,	/* Client data containing literal pool */
     Tcl_Interp *interp,		/* Tcl interpreter */
-    Tcl_Obj    *localeObj,
-    Tcl_Obj   **mcDictObj)
+    Tcl_Obj *localeObj,
+    Tcl_Obj **mcDictObj)
 {
     const char *loc, *loc2;
-    if ( localeObj == NULL
-      || localeObj == dataPtr->literals[LIT_C]
-      || localeObj == dataPtr->defaultLocale
-    ) {
+
+    if (localeObj == NULL
+	    || localeObj == dataPtr->literals[LIT_C]
+	    || localeObj == dataPtr->defaultLocale) {
 	*mcDictObj = dataPtr->defaultLocaleDict;
 	return dataPtr->defaultLocale ?
-		    dataPtr->defaultLocale : dataPtr->literals[LIT_C];
+		dataPtr->defaultLocale : dataPtr->literals[LIT_C];
     }
-    if ( localeObj == dataPtr->currentLocale
-      || localeObj == dataPtr->literals[LIT_CURRENT]
-    ) {
+
+    if (localeObj == dataPtr->currentLocale
+	    || localeObj == dataPtr->literals[LIT_CURRENT]) {
 	if (dataPtr->currentLocale == NULL) {
 	    ClockGetCurrentLocale(dataPtr, interp);
 	}
 	*mcDictObj = dataPtr->currentLocaleDict;
 	return dataPtr->currentLocale;
     }
-    if ( localeObj == dataPtr->lastUsedLocale
-      || localeObj == dataPtr->lastUsedLocaleUnnorm
-    ) {
+
+    if (localeObj == dataPtr->lastUsedLocale
+	    || localeObj == dataPtr->lastUsedLocaleUnnorm) {
 	*mcDictObj = dataPtr->lastUsedLocaleDict;
 	return dataPtr->lastUsedLocale;
     }
-    if ( localeObj == dataPtr->prevUsedLocale
-      || localeObj == dataPtr->prevUsedLocaleUnnorm
-    ) {
+
+    if (localeObj == dataPtr->prevUsedLocale
+	    || localeObj == dataPtr->prevUsedLocaleUnnorm) {
 	*mcDictObj = dataPtr->prevUsedLocaleDict;
 	return dataPtr->prevUsedLocale;
     }
 
     loc = TclGetString(localeObj);
-    if ( dataPtr->currentLocale != NULL
-      && ( localeObj == dataPtr->currentLocale
-       || (localeObj->length == dataPtr->currentLocale->length
-	  && strcasecmp(loc, TclGetString(dataPtr->currentLocale)) == 0
-	)
-      )
-    ) {
+    if (dataPtr->currentLocale != NULL
+	    && (localeObj == dataPtr->currentLocale
+	    || (localeObj->length == dataPtr->currentLocale->length
+	    && strcasecmp(loc, TclGetString(dataPtr->currentLocale)) == 0))) {
 	*mcDictObj = dataPtr->currentLocaleDict;
 	return dataPtr->currentLocale;
     }
-    if ( dataPtr->lastUsedLocale != NULL
-      && ( localeObj == dataPtr->lastUsedLocale
-       || (localeObj->length == dataPtr->lastUsedLocale->length
-	  && strcasecmp(loc, TclGetString(dataPtr->lastUsedLocale)) == 0
-	)
-      )
-    ) {
+
+    if (dataPtr->lastUsedLocale != NULL
+	    && (localeObj == dataPtr->lastUsedLocale
+	    || (localeObj->length == dataPtr->lastUsedLocale->length
+	    && strcasecmp(loc, TclGetString(dataPtr->lastUsedLocale)) == 0))) {
 	*mcDictObj = dataPtr->lastUsedLocaleDict;
 	TclSetObjRef(dataPtr->lastUsedLocaleUnnorm, localeObj);
 	return dataPtr->lastUsedLocale;
     }
-    if ( dataPtr->prevUsedLocale != NULL
-      && ( localeObj == dataPtr->prevUsedLocale
-       || (localeObj->length == dataPtr->prevUsedLocale->length
-	  && strcasecmp(loc, TclGetString(dataPtr->prevUsedLocale)) == 0
-	)
-      )
-    ) {
+
+    if (dataPtr->prevUsedLocale != NULL
+	    && (localeObj == dataPtr->prevUsedLocale
+	    || (localeObj->length == dataPtr->prevUsedLocale->length
+	    && strcasecmp(loc, TclGetString(dataPtr->prevUsedLocale)) == 0))) {
 	*mcDictObj = dataPtr->prevUsedLocaleDict;
 	TclSetObjRef(dataPtr->prevUsedLocaleUnnorm, localeObj);
 	return dataPtr->prevUsedLocale;
     }
-    if (
-	 (localeObj->length == 1 /* C */
-	   && strcasecmp(loc, Literals[LIT_C]) == 0)
-      || (dataPtr->defaultLocale && (loc2 = TclGetString(dataPtr->defaultLocale))
-      	   && localeObj->length == dataPtr->defaultLocale->length
-	   && strcasecmp(loc, loc2) == 0)
-    ) {
+
+    if ((localeObj->length == 1 /* C */
+	    && strcasecmp(loc, Literals[LIT_C]) == 0)
+	    || (dataPtr->defaultLocale && (loc2 = TclGetString(dataPtr->defaultLocale))
+      	    && localeObj->length == dataPtr->defaultLocale->length
+	    && strcasecmp(loc, loc2) == 0)) {
 	*mcDictObj = dataPtr->defaultLocaleDict;
 	return dataPtr->defaultLocale ?
-		    dataPtr->defaultLocale : dataPtr->literals[LIT_C];
+		dataPtr->defaultLocale : dataPtr->literals[LIT_C];
     }
-    if ( localeObj->length == 7 /* current */
-      && strcasecmp(loc, Literals[LIT_CURRENT]) == 0
-    ) {
+
+    if (localeObj->length == 7 /* current */
+	    && strcasecmp(loc, Literals[LIT_CURRENT]) == 0) {
 	if (dataPtr->currentLocale == NULL) {
 	    ClockGetCurrentLocale(dataPtr, interp);
 	}
 	*mcDictObj = dataPtr->currentLocaleDict;
 	return dataPtr->currentLocale;
     }
-    if (
-	 (localeObj->length == 6 /* system */
-	   && strcasecmp(loc, Literals[LIT_SYSTEM]) == 0)
-    ) {
+
+    if ((localeObj->length == 6 /* system */
+	    && strcasecmp(loc, Literals[LIT_SYSTEM]) == 0)) {
 	SavePrevLocaleObj(dataPtr);
 	TclSetObjRef(dataPtr->lastUsedLocaleUnnorm, localeObj);
 	localeObj = ClockGetSystemLocale(dataPtr, interp);
@@ -681,6 +660,7 @@ NormLocaleObj(
 	*mcDictObj = NULL;
 	return localeObj;
     }
+
     *mcDictObj = NULL;
     return localeObj;
 }
@@ -703,7 +683,8 @@ NormLocaleObj(
  */
 
 Tcl_Obj *
-ClockMCDict(ClockFmtScnCmdArgs *opts)
+ClockMCDict(
+    ClockFmtScnCmdArgs *opts)
 {
     ClockClientData *dataPtr = (ClockClientData *)opts->clientData;
 
@@ -711,14 +692,13 @@ ClockMCDict(ClockFmtScnCmdArgs *opts)
     if (opts->mcDictObj == NULL) {
 
 	/* if locale was not yet used */
-	if ( !(opts->flags & CLF_LOCALE_USED) ) {
-
-	    opts->localeObj = NormLocaleObj((ClockClientData *)opts->clientData, opts->interp,
-		opts->localeObj, &opts->mcDictObj);
+	if (!(opts->flags & CLF_LOCALE_USED)) {
+	    opts->localeObj = NormLocaleObj((ClockClientData *) opts->clientData, opts->interp,
+		    opts->localeObj, &opts->mcDictObj);
 
 	    if (opts->localeObj == NULL) {
-		Tcl_SetObjResult(opts->interp,
-		    Tcl_NewStringObj("locale not specified and no default locale set", -1));
+		Tcl_SetObjResult(opts->interp, Tcl_NewStringObj(
+			"locale not specified and no default locale set", -1));
 		Tcl_SetErrorCode(opts->interp, "CLOCK", "badOption", (char *)NULL);
 		return NULL;
 	    }
@@ -727,10 +707,12 @@ ClockMCDict(ClockFmtScnCmdArgs *opts)
 	    /* check locale literals already available (on demand creation) */
 	    if (dataPtr->mcLiterals == NULL) {
 		int i;
-		dataPtr->mcLiterals = (Tcl_Obj **)Tcl_Alloc(MCLIT__END * sizeof(Tcl_Obj*));
+
+		dataPtr->mcLiterals = (Tcl_Obj **)
+			Tcl_Alloc(MCLIT__END * sizeof(Tcl_Obj*));
 		for (i = 0; i < MCLIT__END; ++i) {
 		    TclInitObjRef(dataPtr->mcLiterals[i],
-			Tcl_NewStringObj(MsgCtLiterals[i], -1));
+			    Tcl_NewStringObj(MsgCtLiterals[i], -1));
 		}
 	    }
 	}
@@ -744,7 +726,7 @@ ClockMCDict(ClockFmtScnCmdArgs *opts)
 		TclSetObjRef(dataPtr->mcDicts, Tcl_NewDictObj());
 	    }
 	    Tcl_DictObjGet(NULL, dataPtr->mcDicts,
-		opts->localeObj, &opts->mcDictObj);
+		    opts->localeObj, &opts->mcDictObj);
 
 	    if (opts->mcDictObj == NULL) {
 		/* get msgcat dictionary - ::tcl::clock::mcget locale */
@@ -766,21 +748,20 @@ ClockMCDict(ClockFmtScnCmdArgs *opts)
 	    if (opts->mcDictObj->refCount > ref) {
 		/* smart reference (shared dict as object with no ref-counter) */
 		opts->mcDictObj = TclDictObjSmartRef(opts->interp,
-		    opts->mcDictObj);
+			opts->mcDictObj);
 	    }
 
 	    /* create exactly one reference to catalog / make it searchable for future */
 	    Tcl_DictObjPut(NULL, dataPtr->mcDicts, opts->localeObj,
-		opts->mcDictObj);
+		    opts->mcDictObj);
 
-	    if ( opts->localeObj == dataPtr->literals[LIT_C]
-	      || opts->localeObj == dataPtr->defaultLocale
-	    ) {
+	    if (opts->localeObj == dataPtr->literals[LIT_C]
+		    || opts->localeObj == dataPtr->defaultLocale) {
 		dataPtr->defaultLocaleDict = opts->mcDictObj;
 	    }
-	    if ( opts->localeObj == dataPtr->currentLocale ) {
+	    if (opts->localeObj == dataPtr->currentLocale) {
 		dataPtr->currentLocaleDict = opts->mcDictObj;
-	    } else if ( opts->localeObj == dataPtr->lastUsedLocale ) {
+	    } else if (opts->localeObj == dataPtr->lastUsedLocale) {
 		dataPtr->lastUsedLocaleDict = opts->mcDictObj;
 	    } else {
 		SavePrevLocaleObj(dataPtr);
@@ -815,17 +796,17 @@ ClockMCGet(
     int mcKey)
 {
     ClockClientData *dataPtr = (ClockClientData *)opts->clientData;
-
     Tcl_Obj *valObj = NULL;
 
     if (opts->mcDictObj == NULL) {
 	ClockMCDict(opts);
-	if (opts->mcDictObj == NULL)
+	if (opts->mcDictObj == NULL) {
 	    return NULL;
+	}
     }
 
     Tcl_DictObjGet(opts->interp, opts->mcDictObj,
-	dataPtr->mcLiterals[mcKey], &valObj);
+	    dataPtr->mcLiterals[mcKey], &valObj);
 
     return valObj; /* or NULL in obscure case if Tcl_DictObjGet failed */
 }
@@ -851,13 +832,13 @@ ClockMCGetIdx(
     int mcKey)
 {
     ClockClientData *dataPtr = (ClockClientData *)opts->clientData;
-
     Tcl_Obj *valObj = NULL;
 
     if (opts->mcDictObj == NULL) {
 	ClockMCDict(opts);
-	if (opts->mcDictObj == NULL)
+	if (opts->mcDictObj == NULL) {
 	    return NULL;
+	}
     }
 
     /* try to get indices object */
@@ -866,11 +847,9 @@ ClockMCGetIdx(
     }
 
     if (Tcl_DictObjGet(NULL, opts->mcDictObj,
-	dataPtr->mcLitIdxs[mcKey], &valObj) != TCL_OK
-    ) {
+	    dataPtr->mcLitIdxs[mcKey], &valObj) != TCL_OK) {
 	return NULL;
     }
-
     return valObj;
 }
 
@@ -892,23 +871,26 @@ ClockMCGetIdx(
 int
 ClockMCSetIdx(
     ClockFmtScnCmdArgs *opts,
-    int mcKey, Tcl_Obj *valObj)
+    int mcKey,
+    Tcl_Obj *valObj)
 {
     ClockClientData *dataPtr = (ClockClientData *)opts->clientData;
 
     if (opts->mcDictObj == NULL) {
 	ClockMCDict(opts);
-	if (opts->mcDictObj == NULL)
+	if (opts->mcDictObj == NULL) {
 	    return TCL_ERROR;
+	}
     }
 
     /* if literal storage for indices not yet created */
     if (dataPtr->mcLitIdxs == NULL) {
 	int i;
+
 	dataPtr->mcLitIdxs = (Tcl_Obj **)Tcl_Alloc(MCLIT__END * sizeof(Tcl_Obj*));
 	for (i = 0; i < MCLIT__END; ++i) {
 	    TclInitObjRef(dataPtr->mcLitIdxs[i],
-		Tcl_NewStringObj(MsgCtLitIdxs[i], -1));
+		    Tcl_NewStringObj(MsgCtLitIdxs[i], -1));
 	}
     }
 
@@ -919,8 +901,8 @@ ClockMCSetIdx(
 static void
 TimezoneLoaded(
     ClockClientData *dataPtr,
-    Tcl_Obj	*timezoneObj,	/* Name of zone was loaded */
-    Tcl_Obj	*tzUnnormObj)	/* Name of zone was loaded */
+    Tcl_Obj *timezoneObj,	/* Name of zone was loaded */
+    Tcl_Obj *tzUnnormObj)	/* Name of zone was loaded */
 {
     /* don't overwrite last-setup with GMT (special case) */
     if (timezoneObj == dataPtr->literals[LIT_GMT]) {
@@ -962,13 +944,12 @@ TimezoneLoaded(
 
 static int
 ClockConfigureObjCmd(
-    void *clientData,  /* Client data containing literal pool */
-    Tcl_Interp *interp,	    /* Tcl interpreter */
-    int objc,		    /* Parameter count */
-    Tcl_Obj *const objv[])  /* Parameter vector */
+    void *clientData,		/* Client data containing literal pool */
+    Tcl_Interp *interp,		/* Tcl interpreter */
+    int objc,			/* Parameter count */
+    Tcl_Obj *const objv[])	/* Parameter vector */
 {
     ClockClientData *dataPtr = (ClockClientData *)clientData;
-
     static const char *const options[] = {
 	"-system-tz",	  "-setup-tz",	  "-default-locale",	"-current-locale",
 	"-clear",
@@ -989,15 +970,16 @@ ClockConfigureObjCmd(
 
     for (i = 1; i < objc; i++) {
 	if (Tcl_GetIndexFromObj(interp, objv[i++], options,
-	    "option", 0, &optionIndex) != TCL_OK) {
+		"option", 0, &optionIndex) != TCL_OK) {
 	    Tcl_SetErrorCode(interp, "CLOCK", "badOption",
-		    TclGetString(objv[i-1]), (char *)NULL);
+		    TclGetString(objv[i - 1]), (char *)NULL);
 	    return TCL_ERROR;
 	}
 	switch (optionIndex) {
 	case CLOCK_SYSTEM_TZ: {
 	    /* validate current tz-epoch */
 	    size_t lastTZEpoch = TzsetIfNecessary();
+
 	    if (i < objc) {
 		if (dataPtr->systemTimeZone != objv[i]) {
 		    TclSetObjRef(dataPtr->systemTimeZone, objv[i]);
@@ -1005,26 +987,25 @@ ClockConfigureObjCmd(
 		}
 		dataPtr->lastTZEpoch = lastTZEpoch;
 	    }
-	    if (i+1 >= objc && dataPtr->systemTimeZone != NULL
-			 && dataPtr->lastTZEpoch == lastTZEpoch) {
+	    if (i + 1 >= objc && dataPtr->systemTimeZone != NULL
+		    && dataPtr->lastTZEpoch == lastTZEpoch) {
 		Tcl_SetObjResult(interp, dataPtr->systemTimeZone);
 	    }
+	    break;
 	}
-	break;
 	case CLOCK_SETUP_TZ:
 	    if (i < objc) {
 		int loaded;
 		Tcl_Obj *timezoneObj = NormTimezoneObj(dataPtr, objv[i], &loaded);
+
 		if (!loaded) {
 		    TimezoneLoaded(dataPtr, timezoneObj, objv[i]);
 		}
 		Tcl_SetObjResult(interp, timezoneObj);
-	    }
-	    else
-	    if (i+1 >= objc && dataPtr->lastSetupTimeZone != NULL) {
+	    } else if (i + 1 >= objc && dataPtr->lastSetupTimeZone != NULL) {
 		Tcl_SetObjResult(interp, dataPtr->lastSetupTimeZone);
 	    }
-	break;
+	    break;
 	case CLOCK_DEFAULT_LOCALE:
 	    if (i < objc) {
 		if (dataPtr->defaultLocale != objv[i]) {
@@ -1032,11 +1013,11 @@ ClockConfigureObjCmd(
 		    dataPtr->defaultLocaleDict = NULL;
 		}
 	    }
-	    if (i+1 >= objc) {
+	    if (i + 1 >= objc) {
 		Tcl_SetObjResult(interp, dataPtr->defaultLocale ?
-		    dataPtr->defaultLocale : dataPtr->literals[LIT_C]);
+			dataPtr->defaultLocale : dataPtr->literals[LIT_C]);
 	    }
-	break;
+	    break;
 	case CLOCK_CURRENT_LOCALE:
 	    if (i < objc) {
 		if (dataPtr->currentLocale != objv[i]) {
@@ -1044,30 +1025,32 @@ ClockConfigureObjCmd(
 		    dataPtr->currentLocaleDict = NULL;
 		}
 	    }
-	    if (i+1 >= objc && dataPtr->currentLocale != NULL) {
+	    if (i + 1 >= objc && dataPtr->currentLocale != NULL) {
 		Tcl_SetObjResult(interp, dataPtr->currentLocale);
 	    }
-	break;
+	    break;
 	case CLOCK_YEAR_CENTURY:
 	    if (i < objc) {
 		int year;
+
 		if (TclGetIntFromObj(interp, objv[i], &year) != TCL_OK) {
 		    return TCL_ERROR;
 		}
 		dataPtr->currentYearCentury = year;
-		if (i+1 >= objc) {
+		if (i + 1 >= objc) {
 		    Tcl_SetObjResult(interp, objv[i]);
 		}
 		continue;
 	    }
-	    if (i+1 >= objc) {
+	    if (i + 1 >= objc) {
 		Tcl_SetObjResult(interp,
-		    Tcl_NewWideIntObj(dataPtr->currentYearCentury));
+			Tcl_NewWideIntObj(dataPtr->currentYearCentury));
 	    }
-	break;
+	    break;
 	case CLOCK_CENTURY_SWITCH:
 	    if (i < objc) {
 		int year;
+
 		if (TclGetIntFromObj(interp, objv[i], &year) != TCL_OK) {
 		    return TCL_ERROR;
 		}
@@ -1075,14 +1058,15 @@ ClockConfigureObjCmd(
 		Tcl_SetObjResult(interp, objv[i]);
 		continue;
 	    }
-	    if (i+1 >= objc) {
+	    if (i + 1 >= objc) {
 		Tcl_SetObjResult(interp,
-		    Tcl_NewWideIntObj(dataPtr->yearOfCenturySwitch));
+			Tcl_NewWideIntObj(dataPtr->yearOfCenturySwitch));
 	    }
-	break;
+	    break;
 	case CLOCK_MIN_YEAR:
 	    if (i < objc) {
 		int year;
+
 		if (TclGetIntFromObj(interp, objv[i], &year) != TCL_OK) {
 		    return TCL_ERROR;
 		}
@@ -1090,14 +1074,15 @@ ClockConfigureObjCmd(
 		Tcl_SetObjResult(interp, objv[i]);
 		continue;
 	    }
-	    if (i+1 >= objc) {
+	    if (i + 1 >= objc) {
 		Tcl_SetObjResult(interp,
-		    Tcl_NewWideIntObj(dataPtr->validMinYear));
+			Tcl_NewWideIntObj(dataPtr->validMinYear));
 	    }
-	break;
+	    break;
 	case CLOCK_MAX_YEAR:
 	    if (i < objc) {
 		int year;
+
 		if (TclGetIntFromObj(interp, objv[i], &year) != TCL_OK) {
 		    return TCL_ERROR;
 		}
@@ -1105,14 +1090,15 @@ ClockConfigureObjCmd(
 		Tcl_SetObjResult(interp, objv[i]);
 		continue;
 	    }
-	    if (i+1 >= objc) {
+	    if (i + 1 >= objc) {
 		Tcl_SetObjResult(interp,
-		    Tcl_NewWideIntObj(dataPtr->validMaxYear));
+			Tcl_NewWideIntObj(dataPtr->validMaxYear));
 	    }
-	break;
+	    break;
 	case CLOCK_MAX_JDN:
 	    if (i < objc) {
 		double jd;
+
 		if (Tcl_GetDoubleFromObj(interp, objv[i], &jd) != TCL_OK) {
 		    return TCL_ERROR;
 		}
@@ -1120,14 +1106,14 @@ ClockConfigureObjCmd(
 		Tcl_SetObjResult(interp, objv[i]);
 		continue;
 	    }
-	    if (i+1 >= objc) {
-		Tcl_SetObjResult(interp,
-		    Tcl_NewDoubleObj(dataPtr->maxJDN));
+	    if (i + 1 >= objc) {
+		Tcl_SetObjResult(interp, Tcl_NewDoubleObj(dataPtr->maxJDN));
 	    }
-	break;
+	    break;
 	case CLOCK_VALIDATE:
 	    if (i < objc) {
 		int val;
+
 		if (Tcl_GetBooleanFromObj(interp, objv[i], &val) != TCL_OK) {
 		    return TCL_ERROR;
 		}
@@ -1137,35 +1123,34 @@ ClockConfigureObjCmd(
 		    dataPtr->defFlags &= ~CLF_VALIDATE;
 		}
 	    }
-	    if (i+1 >= objc) {
+	    if (i + 1 >= objc) {
 		Tcl_SetObjResult(interp,
 			Tcl_NewBooleanObj(dataPtr->defFlags & CLF_VALIDATE));
 	    }
-	break;
+	    break;
 	case CLOCK_CLEAR_CACHE:
 	    ClockConfigureClear(dataPtr);
-	break;
-	case CLOCK_INIT_COMPLETE:
-	    {
-		/*
-		 * Init completed.
-		 * Compile clock ensemble (performance purposes).
-		 */
-		Tcl_Command token = Tcl_FindCommand(interp, "::clock",
+	    break;
+	case CLOCK_INIT_COMPLETE: {
+	    /*
+	     * Init completed.
+	     * Compile clock ensemble (performance purposes).
+	     */
+	    Tcl_Command token = Tcl_FindCommand(interp, "::clock",
 		    NULL, TCL_GLOBAL_ONLY);
-		if (!token) {
-		    return TCL_ERROR;
-		}
-		int ensFlags = 0;
-		if (Tcl_GetEnsembleFlags(interp, token, &ensFlags) != TCL_OK) {
-		    return TCL_ERROR;
-		}
-		ensFlags |= ENSEMBLE_COMPILE;
-		if (Tcl_SetEnsembleFlags(interp, token, ensFlags) != TCL_OK) {
-		    return TCL_ERROR;
-		}
+	    if (!token) {
+		return TCL_ERROR;
 	    }
-	break;
+	    int ensFlags = 0;
+	    if (Tcl_GetEnsembleFlags(interp, token, &ensFlags) != TCL_OK) {
+		return TCL_ERROR;
+	    }
+	    ensFlags |= ENSEMBLE_COMPILE;
+	    if (Tcl_SetEnsembleFlags(interp, token, ensFlags) != TCL_OK) {
+		return TCL_ERROR;
+	    }
+	    break;
+	}
 	}
     }
 
@@ -1190,7 +1175,7 @@ ClockConfigureObjCmd(
 
 static inline Tcl_Obj *
 ClockGetTZData(
-    void *clientData,	/* Opaque pointer to literal pool, etc. */
+    void *clientData,		/* Opaque pointer to literal pool, etc. */
     Tcl_Interp *interp,		/* Tcl interpreter */
     Tcl_Obj *timezoneObj)	/* Name of the timezone */
 {
@@ -1198,9 +1183,8 @@ ClockGetTZData(
     Tcl_Obj *ret, **out = NULL;
 
     /* if cached (if already setup this one) */
-    if ( timezoneObj == dataPtr->lastSetupTimeZone
-      || timezoneObj == dataPtr->lastSetupTimeZoneUnnorm
-    ) {
+    if (timezoneObj == dataPtr->lastSetupTimeZone
+	    || timezoneObj == dataPtr->lastSetupTimeZoneUnnorm) {
 	if (dataPtr->lastSetupTZData != NULL) {
 	    return dataPtr->lastSetupTZData;
 	}
@@ -1214,20 +1198,14 @@ ClockGetTZData(
 	    return dataPtr->systemSetupTZData;
 	}
 	out = &dataPtr->systemSetupTZData;
-    }
-    else
-    if ( timezoneObj == dataPtr->literals[LIT_GMT]
-      || timezoneObj == dataPtr->gmtSetupTimeZoneUnnorm
-    ) {
+    } else if (timezoneObj == dataPtr->literals[LIT_GMT]
+	    || timezoneObj == dataPtr->gmtSetupTimeZoneUnnorm) {
 	if (dataPtr->gmtSetupTZData != NULL) {
 	    return dataPtr->gmtSetupTZData;
 	}
 	out = &dataPtr->gmtSetupTZData;
-    }
-    else
-    if ( timezoneObj == dataPtr->prevSetupTimeZone
-      || timezoneObj == dataPtr->prevSetupTimeZoneUnnorm
-    ) {
+    } else if (timezoneObj == dataPtr->prevSetupTimeZone
+	    || timezoneObj == dataPtr->prevSetupTimeZoneUnnorm) {
 	if (dataPtr->prevSetupTZData != NULL) {
 	    return dataPtr->prevSetupTZData;
 	}
@@ -1235,14 +1213,12 @@ ClockGetTZData(
     }
 
     ret = Tcl_ObjGetVar2(interp, dataPtr->literals[LIT_TZDATA],
-	timezoneObj, TCL_LEAVE_ERR_MSG);
+	    timezoneObj, TCL_LEAVE_ERR_MSG);
 
     /* cache using corresponding slot and as last used */
     if (out != NULL) {
 	TclSetObjRef(*out, ret);
-    }
-    else
-    if (dataPtr->lastSetupTimeZone != timezoneObj) {
+    } else if (dataPtr->lastSetupTimeZone != timezoneObj) {
 	SavePrevTimezoneObj(dataPtr);
 	TclSetObjRef(dataPtr->lastSetupTimeZone, timezoneObj);
 	TclUnsetObjRef(dataPtr->lastSetupTimeZoneUnnorm);
@@ -1269,7 +1245,7 @@ ClockGetTZData(
 
 static Tcl_Obj *
 ClockGetSystemTimeZone(
-    void *clientData,	/* Opaque pointer to literal pool, etc. */
+    void *clientData,		/* Opaque pointer to literal pool, etc. */
     Tcl_Interp *interp)		/* Tcl interpreter */
 {
     ClockClientData *dataPtr = (ClockClientData *)clientData;
@@ -1308,7 +1284,7 @@ ClockGetSystemTimeZone(
 
 Tcl_Obj *
 ClockSetupTimeZone(
-    void *clientData,	/* Opaque pointer to literal pool, etc. */
+    void *clientData,		/* Opaque pointer to literal pool, etc. */
     Tcl_Interp *interp,		/* Tcl interpreter */
     Tcl_Obj *timezoneObj)
 {
@@ -1317,21 +1293,18 @@ ClockSetupTimeZone(
     Tcl_Obj *callargs[2];
 
     /* if cached (if already setup this one) */
-    if ( timezoneObj == dataPtr->literals[LIT_GMT]
-      && dataPtr->gmtSetupTZData != NULL
-    ) {
+    if (timezoneObj == dataPtr->literals[LIT_GMT]
+	    && dataPtr->gmtSetupTZData != NULL) {
 	return timezoneObj;
     }
-    if ( ( timezoneObj == dataPtr->lastSetupTimeZone
-	|| timezoneObj == dataPtr->lastSetupTimeZoneUnnorm
-      ) && dataPtr->lastSetupTimeZone != NULL
-    ) {
+    if ((timezoneObj == dataPtr->lastSetupTimeZone
+	    || timezoneObj == dataPtr->lastSetupTimeZoneUnnorm)
+	    && dataPtr->lastSetupTimeZone != NULL) {
 	return dataPtr->lastSetupTimeZone;
     }
-    if ( ( timezoneObj == dataPtr->prevSetupTimeZone
-	|| timezoneObj == dataPtr->prevSetupTimeZoneUnnorm
-      ) && dataPtr->prevSetupTimeZone != NULL
-    ) {
+    if ((timezoneObj == dataPtr->prevSetupTimeZone
+	    || timezoneObj == dataPtr->prevSetupTimeZoneUnnorm)
+	    && dataPtr->prevSetupTimeZone != NULL) {
 	return dataPtr->prevSetupTimeZone;
     }
 
@@ -1378,19 +1351,23 @@ ClockSetupTimeZone(
  */
 
 Tcl_Obj *
-ClockFormatNumericTimeZone(int z) {
-    char buf[12+1], *p;
+ClockFormatNumericTimeZone(
+    int z)
+{
+    char buf[12 + 1], *p;
 
-    if ( z < 0 ) {
+    if (z < 0) {
 	z = -z;
 	*buf = '-';
     } else {
 	*buf = '+';
     }
-    TclItoAw(buf+1, z / 3600, '0', 2);   z %= 3600;
-    p = TclItoAw(buf+3, z / 60, '0', 2); z %= 60;
+    TclItoAw(buf + 1, z / 3600, '0', 2);
+    z %= 3600;
+    p = TclItoAw(buf + 3, z / 60, '0', 2);
+    z %= 60;
     if (z != 0) {
-	p = TclItoAw(buf+5, z, '0', 2);
+	p = TclItoAw(buf + 5, z, '0', 2);
     }
     return Tcl_NewStringObj(buf, p - buf);
 }
@@ -1424,7 +1401,7 @@ ClockFormatNumericTimeZone(int z) {
 
 static int
 ClockConvertlocaltoutcObjCmd(
-    void *clientData,	/* Client data */
+    void *clientData,		/* Client data */
     Tcl_Interp *interp,		/* Tcl interpreter */
     int objc,			/* Parameter count */
     Tcl_Obj *const *objv)	/* Parameter vector */
@@ -1456,10 +1433,9 @@ ClockConvertlocaltoutcObjCmd(
 		"found in dictionary", -1));
 	return TCL_ERROR;
     }
-    if ((TclGetWideIntFromObj(interp, secondsObj,
-	    &fields.localSeconds) != TCL_OK)
-	|| (TclGetIntFromObj(interp, objv[3], &changeover) != TCL_OK)
-	|| ConvertLocalToUTC(clientData, interp, &fields, objv[2], changeover)) {
+    if ((TclGetWideIntFromObj(interp, secondsObj, &fields.localSeconds) != TCL_OK)
+	    || (TclGetIntFromObj(interp, objv[3], &changeover) != TCL_OK)
+	    || ConvertLocalToUTC(clientData, interp, &fields, objv[2], changeover)) {
 	return TCL_ERROR;
     }
 
@@ -1515,7 +1491,7 @@ ClockConvertlocaltoutcObjCmd(
 
 int
 ClockGetdatefieldsObjCmd(
-    void *clientData,	/* Opaque pointer to literal pool, etc. */
+    void *clientData,		/* Opaque pointer to literal pool, etc. */
     Tcl_Interp *interp,		/* Tcl interpreter */
     int objc,			/* Parameter count */
     Tcl_Obj *const *objv)	/* Parameter vector */
@@ -1554,7 +1530,7 @@ ClockGetdatefieldsObjCmd(
     /* Extract fields */
 
     if (ClockGetDateFields(clientData, interp, &fields, objv[2],
-	  changeover) != TCL_OK) {
+	    changeover) != TCL_OK) {
 	return TCL_ERROR;
     }
 
@@ -1612,7 +1588,7 @@ ClockGetdatefieldsObjCmd(
 
 int
 ClockGetDateFields(
-    void *clientData,	/* Client data of the interpreter */
+    void *clientData,		/* Client data of the interpreter */
     Tcl_Interp *interp,		/* Tcl interpreter */
     TclDateFields *fields,	/* Pointer to result fields, where
 				 * fields->seconds contains date to extract */
@@ -1709,7 +1685,7 @@ FetchIntField(
 
 static int
 ClockGetjuliandayfromerayearmonthdayObjCmd(
-    void *clientData,	/* Opaque pointer to literal pool, etc. */
+    void *clientData,		/* Opaque pointer to literal pool, etc. */
     Tcl_Interp *interp,		/* Tcl interpreter */
     int objc,			/* Parameter count */
     Tcl_Obj *const *objv)	/* Parameter vector */
@@ -1795,7 +1771,7 @@ ClockGetjuliandayfromerayearmonthdayObjCmd(
 
 static int
 ClockGetjuliandayfromerayearweekdayObjCmd(
-    void *clientData,	/* Opaque pointer to literal pool, etc. */
+    void *clientData,		/* Opaque pointer to literal pool, etc. */
     Tcl_Interp *interp,		/* Tcl interpreter */
     int objc,			/* Parameter count */
     Tcl_Obj *const *objv)	/* Parameter vector */
@@ -1878,7 +1854,7 @@ ClockGetjuliandayfromerayearweekdayObjCmd(
 
 static int
 ConvertLocalToUTC(
-    void *clientData,	/* Client data of the interpreter */
+    void *clientData,		/* Client data of the interpreter */
     Tcl_Interp *interp,		/* Tcl interpreter */
     TclDateFields *fields,	/* Fields of the time */
     Tcl_Obj *timezoneObj,	/* Time zone */
@@ -1886,7 +1862,7 @@ ConvertLocalToUTC(
 {
     ClockClientData *dataPtr = (ClockClientData *)clientData;
     Tcl_Obj *tzdata;		/* Time zone data */
-    Tcl_Size rowc;			/* Number of rows in tzdata */
+    Tcl_Size rowc;		/* Number of rows in tzdata */
     Tcl_Obj **rowv;		/* Pointers to the rows */
     Tcl_WideInt seconds;
     ClockLastTZOffs * ltzoc = NULL;
@@ -1909,9 +1885,8 @@ ConvertLocalToUTC(
 	    continue;
 	}
 	seconds = fields->localSeconds - ltzoc->tzOffset;
-	if ( seconds >= ltzoc->rangesVal[0]
-	  && seconds <  ltzoc->rangesVal[1]
-	) {
+	if (seconds >= ltzoc->rangesVal[0]
+		&& seconds < ltzoc->rangesVal[1]) {
 	    /* the same time zone and offset (UTC time inside the last minute) */
 	    fields->tzOffset = ltzoc->tzOffset;
 	    fields->seconds = seconds;
@@ -1945,21 +1920,19 @@ ConvertLocalToUTC(
      */
 
     if (rowc == 0) {
-
 	if (ConvertLocalToUTCUsingC(interp, fields, changeover) != TCL_OK) {
 	    return TCL_ERROR;
-	};
+	}
 
 	/* we cannot cache (ranges unknown yet) - todo: check later the DST-hole here */
 	return TCL_OK;
-
     } else {
 	Tcl_WideInt rangesVal[2];
 
 	if (ConvertLocalToUTCUsingTable(interp, fields, rowc, rowv,
 		rangesVal) != TCL_OK) {
 	    return TCL_ERROR;
-	};
+	}
 
 	seconds = fields->seconds;
 
@@ -1985,14 +1958,14 @@ ConvertLocalToUTC(
 
 
     /* check DST-hole: if retrieved seconds is out of range */
-    if ( ltzoc->rangesVal[0] > seconds || seconds >= ltzoc->rangesVal[1] ) {
+    if (ltzoc->rangesVal[0] > seconds || seconds >= ltzoc->rangesVal[1]) {
     dstHole:
-	#if 0
+#if 0
 	printf("given local-time is outside the time-zone (in DST-hole): "
 		"%d - offs %d => %d <= %d < %d\n",
 		(int)fields->localSeconds, fields->tzOffset,
 		(int)ltzoc->rangesVal[0], (int)seconds, (int)ltzoc->rangesVal[1]);
-	#endif
+#endif
 	/* because we don't know real TZ (we're outsize), just invalidate local
 	 * time (which could be verified in ClockValidDate later) */
 	fields->localSeconds = TCL_INV_SECONDS; /* not valid seconds */
@@ -2050,7 +2023,7 @@ ConvertLocalToUTCUsingTable(
     fields->seconds = fields->localSeconds;
     while (1) {
 	row = LookupLastTransition(interp, fields->seconds, rowc, rowv,
-		    rangesVal);
+		rangesVal);
 	if ((row == NULL)
 		|| TclListObjGetElements(interp, row, &cellc,
 		    &cellv) != TCL_OK
@@ -2060,7 +2033,7 @@ ConvertLocalToUTCUsingTable(
 	}
 	for (i = 0; i < nHave; ++i) {
 	    if (have[i].tzOffset == fields->tzOffset) {
-		goto found;
+		break;
 	    }
 	}
 	if (nHave == 8) {
@@ -2071,7 +2044,6 @@ ConvertLocalToUTCUsingTable(
 	fields->seconds = fields->localSeconds - fields->tzOffset;
     }
 
-  found:
     fields->tzOffset = have[i].tzOffset;
     fields->seconds = fields->localSeconds - fields->tzOffset;
     TclSetObjRef(fields->tzName, have[i].tzName);
@@ -2112,7 +2084,7 @@ ConvertLocalToUTCUsingC(
      */
 
     ClockExtractJDAndSODFromSeconds(fields->julianDay, secondOfDay,
-	fields->localSeconds);
+	    fields->localSeconds);
 
     GetGregorianEraYearDay(fields, changeover);
     GetMonthDay(fields);
@@ -2174,7 +2146,7 @@ ConvertLocalToUTCUsingC(
 
 int
 ConvertUTCToLocal(
-    void *clientData,	/* Client data of the interpreter */
+    void *clientData,		/* Client data of the interpreter */
     Tcl_Interp *interp,		/* Tcl interpreter */
     TclDateFields *fields,	/* Fields of the time */
     Tcl_Obj *timezoneObj,	/* Time zone */
@@ -2182,7 +2154,7 @@ ConvertUTCToLocal(
 {
     ClockClientData *dataPtr = (ClockClientData *)clientData;
     Tcl_Obj *tzdata;		/* Time zone data */
-    Tcl_Size rowc;			/* Number of rows in tzdata */
+    Tcl_Size rowc;		/* Number of rows in tzdata */
     Tcl_Obj **rowv;		/* Pointers to the rows */
     ClockLastTZOffs * ltzoc = NULL;
 
@@ -2192,9 +2164,10 @@ ConvertUTCToLocal(
 	fields->tzOffset = 0;
 	if (dataPtr->gmtTZName == NULL) {
 	    Tcl_Obj *tzName;
+
 	    tzdata = ClockGetTZData(clientData, interp, timezoneObj);
-	    if ( TclListObjGetElements(interp, tzdata, &rowc, &rowv) != TCL_OK
-	      || Tcl_ListObjIndex(interp, rowv[0], 3, &tzName) != TCL_OK) {
+	    if (TclListObjGetElements(interp, tzdata, &rowc, &rowv) != TCL_OK
+		    || Tcl_ListObjIndex(interp, rowv[0], 3, &tzName) != TCL_OK) {
 		return TCL_ERROR;
 	    }
 	    TclSetObjRef(dataPtr->gmtTZName, tzName);
@@ -2213,9 +2186,8 @@ ConvertUTCToLocal(
 	    ltzoc = NULL;
 	    continue;
 	}
-	if ( fields->seconds >= ltzoc->rangesVal[0]
-	  && fields->seconds <  ltzoc->rangesVal[1]
-	) {
+	if (fields->seconds >= ltzoc->rangesVal[0]
+		&& fields->seconds < ltzoc->rangesVal[1]) {
 	    /* the same time zone and offset (UTC time inside the last minute) */
 	    fields->tzOffset = ltzoc->tzOffset;
 	    fields->localSeconds = fields->seconds + fields->tzOffset;
@@ -2243,7 +2215,6 @@ ConvertUTCToLocal(
      */
 
     if (rowc == 0) {
-
 	if (ConvertUTCToLocalUsingC(interp, fields, changeover) != TCL_OK) {
 	    return TCL_ERROR;
 	}
@@ -2308,13 +2279,13 @@ static int
 ConvertUTCToLocalUsingTable(
     Tcl_Interp *interp,		/* Tcl interpreter */
     TclDateFields *fields,	/* Fields of the date */
-    Tcl_Size rowc,			/* Number of rows in the conversion table
+    Tcl_Size rowc,		/* Number of rows in the conversion table
 				 * (>= 1) */
     Tcl_Obj *const rowv[],	/* Rows of the conversion table */
     Tcl_WideInt *rangesVal)	/* Return bounds for time period */
 {
     Tcl_Obj *row;		/* Row containing the current information */
-    Tcl_Size cellc;			/* Count of cells in the row (must be 4) */
+    Tcl_Size cellc;		/* Count of cells in the row (must be 4) */
     Tcl_Obj **cellv;		/* Pointers to the cells */
 
     /*
@@ -2322,9 +2293,9 @@ ConvertUTCToLocalUsingTable(
      */
 
     row = LookupLastTransition(interp, fields->seconds, rowc, rowv, rangesVal);
-    if (row == NULL ||
-	    TclListObjGetElements(interp, row, &cellc, &cellv) != TCL_OK ||
-	    TclGetIntFromObj(interp, cellv[1], &fields->tzOffset) != TCL_OK) {
+    if (row == NULL
+	    || TclListObjGetElements(interp, row, &cellc, &cellv) != TCL_OK
+	    || TclGetIntFromObj(interp, cellv[1], &fields->tzOffset) != TCL_OK) {
 	return TCL_ERROR;
     }
 
@@ -2418,10 +2389,12 @@ ConvertUTCToLocalUsingC(
     } else {
 	*buffer = '+';
     }
-    TclItoAw(buffer+1, diff / 3600, '0', 2);   diff %= 3600;
-    p = TclItoAw(buffer+3, diff / 60, '0', 2); diff %= 60;
+    TclItoAw(buffer + 1, diff / 3600, '0', 2);
+    diff %= 3600;
+    p = TclItoAw(buffer + 3, diff / 60, '0', 2);
+    diff %= 60;
     if (diff != 0) {
-	p = TclItoAw(buffer+5, diff, '0', 2);
+	p = TclItoAw(buffer + 5, diff, '0', 2);
     }
     TclSetObjRef(fields->tzName, Tcl_NewStringObj(buffer, p - buffer));
     return TCL_OK;
@@ -2445,11 +2418,11 @@ Tcl_Obj *
 LookupLastTransition(
     Tcl_Interp *interp,		/* Interpreter for error messages */
     Tcl_WideInt tick,		/* Time from the epoch */
-    Tcl_Size rowc,			/* Number of rows of tzdata */
+    Tcl_Size rowc,		/* Number of rows of tzdata */
     Tcl_Obj *const *rowv,	/* Rows in tzdata */
     Tcl_WideInt *rangesVal)	/* Return bounds for time period */
 {
-	Tcl_Size l, u;
+    Tcl_Size l, u;
     Tcl_Obj *compObj;
     Tcl_WideInt compVal, fromVal = LLONG_MIN, toVal = LLONG_MAX;
 
@@ -2480,7 +2453,7 @@ LookupLastTransition(
      */
 
     l = 0;
-    u = rowc-1;
+    u = rowc - 1;
     while (l < u) {
 	Tcl_Size m = (l + u + 1) / 2;
 
@@ -2492,7 +2465,7 @@ LookupLastTransition(
 	    l = m;
 	    fromVal = compVal;
 	} else {
-	    u = m-1;
+	    u = m - 1;
 	    toVal = compVal;
 	}
     }
@@ -2722,7 +2695,7 @@ GetMonthDay(
     /* then do forwards backwards correction */
     while (1) {
 	if (day > dipm[month]) {
-	    if (month >= 11 || day <= dipm[month+1]) {
+	    if (month >= 11 || day <= dipm[month + 1]) {
 		break;
 	    }
 	    month++;
@@ -2734,7 +2707,7 @@ GetMonthDay(
 	}
     }
     day -= dipm[month];
-    fields->month = month+1;
+    fields->month = month + 1;
     fields->dayOfMonth = day;
 }
 
@@ -2845,7 +2818,7 @@ GetJulianDayFromEraYearMonthDay(
     fields->gregorian = 1;
     if (year < 1) {
 	fields->isBce = 1;
-	fields->year = 1-year;
+	fields->year = 1 - year;
     } else {
 	fields->isBce = 0;
 	fields->year = year;
@@ -2939,22 +2912,22 @@ GetJulianDayFromEraYearDay(
     /* Try the Gregorian calendar first. */
     fields->gregorian = 1;
     fields->julianDay =
-	1721425
-	+ fields->dayOfYear
-	+ ( 365 * ym1 )
-	+ ( ym1 / 4 )
-	- ( ym1 / 100 )
-	+ ( ym1 / 400 );
+	    1721425
+	    + fields->dayOfYear
+	    + (365 * ym1)
+	    + (ym1 / 4)
+	    - (ym1 / 100)
+	    + (ym1 / 400);
 
     /* If the date is before the Gregorian change, use the Julian calendar. */
 
-    if ( fields->julianDay < changeover ) {
+    if (fields->julianDay < changeover) {
 	fields->gregorian = 0;
 	fields->julianDay =
-	    1721423
-	    + fields->dayOfYear
-	    + ( 365 * ym1 )
-	    + ( ym1 / 4 );
+		1721423
+		+ fields->dayOfYear
+		+ (365 * ym1)
+		+ (ym1 / 4);
     }
 }
 /*
@@ -2980,13 +2953,13 @@ IsGregorianLeapYear(
     if (fields->isBce) {
 	year = 1 - year;
     }
-    if (year%4 != 0) {
+    if (year % 4 != 0) {
 	return 0;
     } else if (!(fields->gregorian)) {
 	return 1;
-    } else if (year%400 == 0) {
+    } else if (year % 400 == 0) {
 	return 1;
-    } else if (year%100 == 0) {
+    } else if (year % 100 == 0) {
 	return 0;
     } else {
 	return 1;
@@ -3107,7 +3080,7 @@ ThreadSafeLocalTime(
      * Get a thread-local buffer to hold the returned time.
      */
 
-    struct tm *tmPtr = (struct tm *)Tcl_GetThreadData(&tmKey, sizeof(struct tm));
+    struct tm *tmPtr = (struct tm *) Tcl_GetThreadData(&tmKey, sizeof(struct tm));
 #ifdef HAVE_LOCALTIME_R
     tmPtr = localtime_r(timePtr, tmPtr);
 #else
@@ -3307,10 +3280,10 @@ ClockParseFmtScnArgs(
 				 * (by scan or add) resp. clockval (by format) */
     int objc,			/* Parameter count */
     Tcl_Obj *const objv[],	/* Parameter vector */
-    int		flags,		/* Flags, differentiates between format, scan, add */
-    const char *syntax		/* Syntax of the current command */
-) {
-    Tcl_Interp	    *interp =  opts->interp;
+    int flags,			/* Flags, differentiates between format, scan, add */
+    const char *syntax)		/* Syntax of the current command */
+{
+    Tcl_Interp *interp = opts->interp;
     ClockClientData *dataPtr = (ClockClientData *)opts->clientData;
     int gmtFlag = 0;
     static const char *const options[] = {
@@ -3325,7 +3298,7 @@ ClockParseFmtScnArgs(
     int i, baseIdx;
     Tcl_WideInt baseVal;	/* Base time, expressed in seconds from the Epoch */
 
-    if ( flags & (CLC_SCN_ARGS) ) {
+    if (flags & CLC_SCN_ARGS) {
     	/* default flags (from configure) */
     	opts->flags |= dataPtr->defFlags & (CLF_VALIDATE);
     } else {
@@ -3342,25 +3315,25 @@ ClockParseFmtScnArgs(
 	/* bypass integers (offsets) by "clock add" */
 	if (flags & CLC_ADD_ARGS) {
 	    Tcl_WideInt num;
+
 	    if (TclGetWideIntFromObj(NULL, objv[i], &num) == TCL_OK) {
 		continue;
 	    }
 	}
 	/* get option */
 	if (Tcl_GetIndexFromObj(interp, objv[i], options,
-	    "option", 0, &optionIndex) != TCL_OK) {
+		"option", 0, &optionIndex) != TCL_OK) {
 	    goto badOptionMsg;
 	}
 	/* if already specified */
 	if (saw & (1 << optionIndex)) {
-	    if ( !(flags & CLC_SCN_ARGS)
-	       && optionIndex == CLC_ARGS_BASE) {
+	    if (!(flags & CLC_SCN_ARGS)
+		    && optionIndex == CLC_ARGS_BASE) {
 		goto badOptionMsg;
 	    }
 	    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
-		"bad option \"%s\": doubly present",
-		TclGetString(objv[i]))
-	    );
+		    "bad option \"%s\": doubly present",
+		    TclGetString(objv[i])));
 	    goto badOption;
 	}
 	switch (optionIndex) {
@@ -3368,28 +3341,29 @@ ClockParseFmtScnArgs(
 	    if (flags & CLC_ADD_ARGS) {
 		goto badOptionMsg;
 	    }
-	    opts->formatObj = objv[i+1];
+	    opts->formatObj = objv[i + 1];
 	    break;
 	case CLC_ARGS_GMT:
-	    if (Tcl_GetBooleanFromObj(interp, objv[i+1], &gmtFlag) != TCL_OK){
+	    if (Tcl_GetBooleanFromObj(interp, objv[i + 1], &gmtFlag) != TCL_OK){
 		return TCL_ERROR;
 	    }
 	    break;
 	case CLC_ARGS_LOCALE:
-	    opts->localeObj = objv[i+1];
+	    opts->localeObj = objv[i + 1];
 	    break;
 	case CLC_ARGS_TIMEZONE:
-	    opts->timezoneObj = objv[i+1];
+	    opts->timezoneObj = objv[i + 1];
 	    break;
 	case CLC_ARGS_BASE:
-	    opts->baseObj = objv[(baseIdx = i+1)];
+	    opts->baseObj = objv[(baseIdx = i + 1)];
 	    break;
 	case CLC_ARGS_VALIDATE:
-	    if ( !(flags & CLC_SCN_ARGS) ) {
+	    if (!(flags & CLC_SCN_ARGS)) {
 		goto badOptionMsg;
 	    } else {
 		int val;
-		if (Tcl_GetBooleanFromObj(interp, objv[i+1], &val) != TCL_OK) {
+
+		if (Tcl_GetBooleanFromObj(interp, objv[i + 1], &val) != TCL_OK) {
 		    return TCL_ERROR;
 		}
 		if (val) {
@@ -3415,13 +3389,10 @@ ClockParseFmtScnArgs(
     }
     if (gmtFlag) {
 	opts->timezoneObj = dataPtr->literals[LIT_GMT];
-    }
-    else
-    /* If time zone not specified use system time zone */
-    if ( opts->timezoneObj == NULL
-      || TclGetString(opts->timezoneObj) == NULL
-      || opts->timezoneObj->length == 0
-    ) {
+    } else if (opts->timezoneObj == NULL
+	    || TclGetString(opts->timezoneObj) == NULL
+	    || opts->timezoneObj->length == 0) {
+	/* If time zone not specified use system time zone */
 	opts->timezoneObj = ClockGetSystemTimeZone(opts->clientData, interp);
 	if (opts->timezoneObj == NULL) {
 	    return TCL_ERROR;
@@ -3439,20 +3410,18 @@ ClockParseFmtScnArgs(
 
     if (opts->baseObj != NULL) {
 	Tcl_Obj *baseObj = opts->baseObj;
-	/* bypass integer recognition if looks like option "-now" */
-	if (
-	    (baseObj->bytes && baseObj->length == 4 && *(baseObj->bytes+1) == 'n') ||
-	    TclGetWideIntFromObj(NULL, baseObj, &baseVal) != TCL_OK
-	) {
 
+	/* bypass integer recognition if looks like option "-now" */
+	if ((baseObj->bytes && baseObj->length == 4 && *(baseObj->bytes + 1) == 'n')
+		|| TclGetWideIntFromObj(NULL, baseObj, &baseVal) != TCL_OK) {
 	    /* we accept "-now" as current date-time */
 	    static const char *const nowOpts[] = {
 		"-now", NULL
 	    };
 	    int idx;
+
 	    if (Tcl_GetIndexFromObj(interp, baseObj, nowOpts, "seconds",
-		    TCL_EXACT, &idx) == TCL_OK
-	    ) {
+		    TCL_EXACT, &idx) == TCL_OK) {
 		goto baseNow;
 	    }
 
@@ -3473,22 +3442,18 @@ ClockParseFmtScnArgs(
 	 */
 
 	if (TclHasInternalRep(baseObj, &tclBignumType)
-	  || baseVal < TCL_MIN_SECONDS || baseVal > TCL_MAX_SECONDS
-	) {
-baseOverflow:
+		|| baseVal < TCL_MIN_SECONDS || baseVal > TCL_MAX_SECONDS) {
+	baseOverflow:
 	    Tcl_SetObjResult(interp, dataPtr->literals[LIT_INTEGER_VALUE_TOO_LARGE]);
 	    i = baseIdx;
 	    goto badOption;
 	}
-
     } else {
+	Tcl_Time now;
 
-baseNow:
-	{
-	    Tcl_Time now;
-	    Tcl_GetTime(&now);
-	    baseVal = (Tcl_WideInt) now.sec;
-	}
+    baseNow:
+	Tcl_GetTime(&now);
+	baseVal = (Tcl_WideInt) now.sec;
     }
 
     /*
@@ -3497,17 +3462,17 @@ baseNow:
      */
 
     /* check base fields already cached (by TZ, last-second cache) */
-    if ( dataPtr->lastBase.timezoneObj == opts->timezoneObj
-      && dataPtr->lastBase.date.seconds == baseVal
-      && (!(dataPtr->lastBase.date.flags & CLF_CTZ)
-	     || dataPtr->lastTZEpoch == TzsetIfNecessary())
-    ) {
+    if (dataPtr->lastBase.timezoneObj == opts->timezoneObj
+	    && dataPtr->lastBase.date.seconds == baseVal
+	    && (!(dataPtr->lastBase.date.flags & CLF_CTZ)
+	    || dataPtr->lastTZEpoch == TzsetIfNecessary())) {
 	memcpy(date, &dataPtr->lastBase.date, ClockCacheableDateFieldsSize);
     } else {
 	/* extact fields from base */
 	date->seconds = baseVal;
 	if (ClockGetDateFields(opts->clientData, interp, date, opts->timezoneObj,
-	      GREGORIAN_CHANGE_DATE) != TCL_OK) { /* TODO - GREGORIAN_CHANGE_DATE should be locale-dependent */
+	      GREGORIAN_CHANGE_DATE) != TCL_OK) {
+	    /* TODO - GREGORIAN_CHANGE_DATE should be locale-dependent */
 	    return TCL_ERROR;
 	}
 	/* cache last base */
@@ -3517,18 +3482,14 @@ baseNow:
 
     return TCL_OK;
 
-badOptionMsg:
-
+  badOptionMsg:
     Tcl_SetObjResult(interp, Tcl_ObjPrintf(
-	"bad option \"%s\": must be %s",
-	TclGetString(objv[i]), syntax)
-    );
-
-badOption:
+	    "bad option \"%s\": must be %s",
+	    TclGetString(objv[i]), syntax));
 
+  badOption:
     Tcl_SetErrorCode(interp, "CLOCK", "badOption",
 	    (i < objc) ? TclGetString(objv[i]) : (char *)NULL, (char *)NULL);
-
     return TCL_ERROR;
 }
 
@@ -3554,7 +3515,7 @@ badOption:
 
 int
 ClockFormatObjCmd(
-    void *clientData,	/* Client data containing literal pool */
+    void *clientData,		/* Client data containing literal pool */
     Tcl_Interp *interp,		/* Tcl interpreter */
     int objc,			/* Parameter count */
     Tcl_Obj *const objv[])	/* Parameter values */
@@ -3562,12 +3523,12 @@ ClockFormatObjCmd(
     ClockClientData *dataPtr = (ClockClientData *)clientData;
 
     static const char *syntax = "clock format clockval|-now "
-	"?-format string? "
-	"?-gmt boolean? "
-	"?-locale LOCALE? ?-timezone ZONE?";
+	    "?-format string? "
+	    "?-gmt boolean? "
+	    "?-locale LOCALE? ?-timezone ZONE?";
     int ret;
     ClockFmtScnCmdArgs opts;	/* Format, locale, timezone and base */
-    DateFormat	    dateFmt;	/* Common structure used for formatting */
+    DateFormat dateFmt;		/* Common structure used for formatting */
 
     /* even number of arguments */
     if ((objc & 1) == 1) {
@@ -3595,18 +3556,11 @@ ClockFormatObjCmd(
     }
 
     /* Use compiled version of Format - */
-
     ret = ClockFormat(&dateFmt, &opts);
 
-done:
-
+  done:
     TclUnsetObjRef(dateFmt.date.tzName);
-
-    if (ret != TCL_OK) {
-	return ret;
-    }
-
-    return TCL_OK;
+    return ret;
 }
 
 /*----------------------------------------------------------------------
@@ -3631,7 +3585,7 @@ done:
 
 int
 ClockScanObjCmd(
-    void *clientData,	/* Client data containing literal pool */
+    void *clientData,		/* Client data containing literal pool */
     Tcl_Interp *interp,		/* Tcl interpreter */
     int objc,			/* Parameter count */
     Tcl_Obj *const objv[])	/* Parameter values */
@@ -3643,8 +3597,8 @@ ClockScanObjCmd(
 	    "?-locale LOCALE? ?-timezone ZONE? ?-validate boolean?";
     int ret;
     ClockFmtScnCmdArgs opts;	/* Format, locale, timezone and base */
-    DateInfo	    yy;		/* Common structure used for parsing */
-    DateInfo	   *info = &yy;
+    DateInfo yy;		/* Common structure used for parsing */
+    DateInfo *info = &yy;
 
     /* even number of arguments */
     if ((objc & 1) == 1) {
@@ -3673,17 +3627,17 @@ ClockScanObjCmd(
     if (opts.formatObj == NULL) {
 	/* Use compiled version of FreeScan - */
 
-	/* [SB] TODO: Perhaps someday we'll localize the legacy code. Right now, it's not localized. */
+	/* [SB] TODO: Perhaps someday we'll localize the legacy code. Right now,
+	 * it's not localized. */
 	if (opts.localeObj != NULL) {
-	    Tcl_SetObjResult(interp,
-		Tcl_NewStringObj("legacy [clock scan] does not support -locale", -1));
+	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
+		    "legacy [clock scan] does not support -locale", -1));
 	    Tcl_SetErrorCode(interp, "CLOCK", "flagWithLegacyFormat", (char *)NULL);
 	    ret = TCL_ERROR;
 	    goto done;
 	}
 	ret = ClockFreeScan(&yy, objv[1], &opts);
-    }
-    else {
+    } else {
 	/* Use compiled version of Scan - */
 
 	ret = ClockScan(&yy, objv[1], &opts);
@@ -3698,9 +3652,8 @@ ClockScanObjCmd(
      * validate with stage 1 before local time conversion, otherwise it may
      * adjust date/time tokens to valid values
      */
-    if ( (opts.flags & CLF_VALIDATE_S1) &&
-	 info->flags & (CLF_ASSEMBLE_SECONDS|CLF_LOCALSEC)
-    ) {
+    if ((opts.flags & CLF_VALIDATE_S1)
+	    && info->flags & (CLF_ASSEMBLE_SECONDS|CLF_LOCALSEC)) {
 	ret = ClockValidDate(&yy, &opts, CLF_VALIDATE_S1);
 	if (ret != TCL_OK) {
 	    goto done;
@@ -3715,21 +3668,18 @@ ClockScanObjCmd(
     }
 
     /* Apply remaining validation rules, if expected */
-    if ( (opts.flags & CLF_VALIDATE) ) {
+    if ((opts.flags & CLF_VALIDATE)) {
 	ret = ClockValidDate(&yy, &opts, opts.flags & CLF_VALIDATE);
 	if (ret != TCL_OK) {
 	    goto done;
 	}
     }
 
-done:
-
+  done:
     TclUnsetObjRef(yy.date.tzName);
-
     if (ret != TCL_OK) {
 	return ret;
     }
-
     Tcl_SetObjResult(interp, Tcl_NewWideIntObj(yy.date.seconds));
     return TCL_OK;
 }
@@ -3751,19 +3701,16 @@ done:
 
 static int
 ClockScanCommit(
-    DateInfo  *info,	/* Clock scan info structure */
+    DateInfo *info,		/* Clock scan info structure */
     ClockFmtScnCmdArgs *opts)	/* Format, locale, timezone and base */
 {
     /* If needed assemble julianDay using year, month, etc. */
     if (info->flags & CLF_ASSEMBLE_JULIANDAY) {
 	if ((info->flags & CLF_ISO8601WEAK)) {
 	    GetJulianDayFromEraYearWeekDay(&yydate, GREGORIAN_CHANGE_DATE);
-	}
-	else
-	if ( !(info->flags & CLF_DAYOFYEAR) /* no day of year */
-	   || (info->flags & (CLF_DAYOFMONTH|CLF_MONTH)) /* yymmdd over yyddd */
-		== (CLF_DAYOFMONTH|CLF_MONTH)
-	) {
+	} else if (!(info->flags & CLF_DAYOFYEAR) /* no day of year */
+		|| (info->flags & (CLF_DAYOFMONTH|CLF_MONTH)) /* yymmdd over yyddd */
+		== (CLF_DAYOFMONTH|CLF_MONTH)) {
 	    GetJulianDayFromEraYearMonthDay(&yydate, GREGORIAN_CHANGE_DATE);
 	} else {
 	    GetJulianDayFromEraYearDay(&yydate, GREGORIAN_CHANGE_DATE);
@@ -3775,11 +3722,12 @@ ClockScanCommit(
     /* some overflow checks */
     if (info->flags & CLF_JULIANDAY) {
 	ClockClientData *dataPtr = (ClockClientData *)opts->clientData;
+
 	double curJDN = (double)yydate.julianDay
-	    + ((double)yySecondOfDay - SECONDS_PER_DAY/2) / SECONDS_PER_DAY;
+		+ ((double)yySecondOfDay - SECONDS_PER_DAY/2) / SECONDS_PER_DAY;
 	if (curJDN > dataPtr->maxJDN) {
 	    Tcl_SetObjResult(opts->interp, Tcl_NewStringObj(
-		"requested date too large to represent", -1));
+		    "requested date too large to represent", -1));
 	    Tcl_SetErrorCode(opts->interp, "CLOCK", "dateTooLarge", (char *)NULL);
 	    return TCL_ERROR;
 	}
@@ -3789,9 +3737,9 @@ ClockScanCommit(
 
     if (info->flags & (CLF_ASSEMBLE_SECONDS)) {
 	yydate.localSeconds =
-	    -210866803200LL
-	    + ( SECONDS_PER_DAY * yydate.julianDay )
-	    + ( yySecondOfDay % SECONDS_PER_DAY );
+		-210866803200LL
+		+ (SECONDS_PER_DAY * yydate.julianDay)
+		+ (yySecondOfDay % SECONDS_PER_DAY);
     }
 
     if (info->flags & (CLF_ASSEMBLE_SECONDS|CLF_LOCALSEC)) {
@@ -3804,7 +3752,6 @@ ClockScanCommit(
     /* Increment UTC seconds with relative time */
 
     yydate.seconds += yyRelSeconds;
-
     return TCL_OK;
 }
 
@@ -3825,7 +3772,7 @@ ClockScanCommit(
 
 static int
 ClockValidDate(
-    DateInfo  *info,	/* Clock scan info structure */
+    DateInfo *info,		/* Clock scan info structure */
     ClockFmtScnCmdArgs *opts,	/* Scan options */
     int stage)			/* Stage to validate (1, 2 or 3 for both) */
 {
@@ -3834,13 +3781,13 @@ ClockValidDate(
     int tempCpyFlg = 0;
     ClockClientData *dataPtr = (ClockClientData *)opts->clientData;
 
-    #if 0
+#if 0
     printf("yyMonth %d, yyDay %d, yyDayOfYear %d, yyHour %d, yyMinutes %d, yySeconds %d, "
-	   "yySecondOfDay %d, sec %d, daySec %d, tzOffset %d\n",
-	  yyMonth, yyDay, yydate.dayOfYear, yyHour, yyMinutes, yySeconds,
-	  yySecondOfDay, (int)yydate.localSeconds, (int)(yydate.localSeconds % SECONDS_PER_DAY),
-	  yydate.tzOffset);
-    #endif
+	    "yySecondOfDay %d, sec %d, daySec %d, tzOffset %d\n",
+	    yyMonth, yyDay, yydate.dayOfYear, yyHour, yyMinutes, yySeconds,
+	    yySecondOfDay, (int)yydate.localSeconds, (int)(yydate.localSeconds % SECONDS_PER_DAY),
+	    yydate.tzOffset);
+#endif
 
     if (!(stage & CLF_VALIDATE_S1) || !(opts->flags & CLF_VALIDATE_S1)) {
 	goto stage_2;
@@ -3850,15 +3797,19 @@ ClockValidDate(
     /* first year (used later in hath / daysInPriorMonths) */
     if ((info->flags & (CLF_YEAR|CLF_ISO8601YEAR))) {
 	if ((info->flags & CLF_ISO8601YEAR)) {
-	    if ( yydate.iso8601Year < dataPtr->validMinYear
-	      || yydate.iso8601Year > dataPtr->validMaxYear ) {
-		errMsg = "invalid iso year"; errCode = "iso year"; goto error;
+	    if (yydate.iso8601Year < dataPtr->validMinYear
+		    || yydate.iso8601Year > dataPtr->validMaxYear) {
+		errMsg = "invalid iso year";
+		errCode = "iso year";
+		goto error;
 	    }
 	}
 	if (info->flags & CLF_YEAR) {
-	    if ( yyYear < dataPtr->validMinYear
-	      || yyYear > dataPtr->validMaxYear ) {
-		errMsg = "invalid year"; errCode = "year"; goto error;
+	    if (yyYear < dataPtr->validMinYear
+		    || yyYear > dataPtr->validMaxYear) {
+		errMsg = "invalid year";
+		errCode = "year";
+		goto error;
 	    }
 	} else if ((info->flags & CLF_ISO8601YEAR)) {
 	    yyYear = yydate.iso8601Year; /* used to recognize leap */
@@ -3866,61 +3817,77 @@ ClockValidDate(
 	if ((info->flags & (CLF_ISO8601YEAR|CLF_YEAR))
 		== (CLF_ISO8601YEAR|CLF_YEAR)) {
 	    if (yyYear != yydate.iso8601Year) {
-		errMsg = "ambiguous year"; errCode = "year"; goto error;
+		errMsg = "ambiguous year";
+		errCode = "year";
+		goto error;
 	    }
 	}
     }
     /* and month (used later in hath) */
     if (info->flags & CLF_MONTH) {
-	if ( yyMonth < 1 || yyMonth > 12 ) {
-	    errMsg = "invalid month"; errCode = "month"; goto error;
+	if (yyMonth < 1 || yyMonth > 12) {
+	    errMsg = "invalid month";
+	    errCode = "month";
+	    goto error;
 	}
     }
     /* day of month */
     if (info->flags & (CLF_DAYOFMONTH|CLF_DAYOFWEEK)) {
-	if ( yyDay < 1 || yyDay > 31 ) {
-	    errMsg = "invalid day"; errCode = "day"; goto error;
-	}
-	else
-	if ( (info->flags & CLF_MONTH) ) {
+	if (yyDay < 1 || yyDay > 31) {
+	    errMsg = "invalid day";
+	    errCode = "day";
+	    goto error;
+	} else if ((info->flags & CLF_MONTH)) {
 	    const int *h = hath[IsGregorianLeapYear(&yydate)];
-	    if ( yyDay > h[yyMonth-1] ) {
-		errMsg = "invalid day"; goto error;
+
+	    if (yyDay > h[yyMonth - 1]) {
+		errMsg = "invalid day";
+		goto error;
 	    }
 	}
     }
     if (info->flags & CLF_DAYOFYEAR) {
-	if ( yydate.dayOfYear < 1
-	  || yydate.dayOfYear > daysInPriorMonths[IsGregorianLeapYear(&yydate)][12] ) {
-	    errMsg = "invalid day of year"; errCode = "day of year"; goto error;
+	if (yydate.dayOfYear < 1
+		|| yydate.dayOfYear > daysInPriorMonths[IsGregorianLeapYear(&yydate)][12]) {
+	    errMsg = "invalid day of year";
+	    errCode = "day of year";
+	    goto error;
 	}
     }
 
     /* mmdd !~ ddd */
     if ((info->flags & (CLF_DAYOFYEAR|CLF_DAYOFMONTH|CLF_MONTH))
-		== (CLF_DAYOFYEAR|CLF_DAYOFMONTH|CLF_MONTH)) {
+	    == (CLF_DAYOFYEAR|CLF_DAYOFMONTH|CLF_MONTH)) {
 	if (!tempCpyFlg) {
 	    memcpy(&temp, &yydate, sizeof(temp));
 	    tempCpyFlg = 1;
 	}
 	GetJulianDayFromEraYearDay(&temp, GREGORIAN_CHANGE_DATE);
 	if (temp.julianDay != yydate.julianDay) {
-	    errMsg = "ambiguous day"; errCode = "day"; goto error;
+	    errMsg = "ambiguous day";
+	    errCode = "day";
+	    goto error;
 	}
     }
 
     if (info->flags & CLF_TIME) {
 	/* hour */
-	if ( yyHour < 0 || yyHour > ((yyMeridian == MER24) ? 23 : 12) ) {
-	    errMsg = "invalid time (hour)"; errCode = "hour"; goto error;
+	if (yyHour < 0 || yyHour > ((yyMeridian == MER24) ? 23 : 12)) {
+	    errMsg = "invalid time (hour)";
+	    errCode = "hour";
+	    goto error;
 	}
 	/* minutes */
-	if ( yyMinutes < 0 || yyMinutes > 59 ) {
-	    errMsg = "invalid time (minutes)"; errCode = "minutes"; goto error;
+	if (yyMinutes < 0 || yyMinutes > 59) {
+	    errMsg = "invalid time (minutes)";
+	    errCode = "minutes";
+	    goto error;
 	}
 	/* oldscan could return secondOfDay (parsedTime) -1 by invalid time (ex.: 25:00:00) */
-	if ( yySeconds < 0 || yySeconds > 59 || yySecondOfDay <= -1 ) {
-	    errMsg = "invalid time"; errCode = "seconds"; goto error;
+	if (yySeconds < 0 || yySeconds > 59 || yySecondOfDay <= -1) {
+	    errMsg = "invalid time";
+	    errCode = "seconds";
+	    goto error;
 	}
     }
 
@@ -3944,9 +3911,10 @@ ClockValidDate(
 	 * should have valid localSeconds (was not invalidated to TCL_INV_SECONDS),
 	 * so if it was invalidated - invalid time, outside the time-zone (in DST-hole)
 	 */
-	if ( yydate.localSeconds == TCL_INV_SECONDS ) {
+	if (yydate.localSeconds == TCL_INV_SECONDS) {
 	    errMsg = "invalid time (does not exist in this time-zone)";
-	    errCode = "out-of-time"; goto error;
+	    errCode = "out-of-time";
+	    goto error;
 	}
     }
 
@@ -3958,15 +3926,17 @@ ClockValidDate(
 	}
 	GetYearWeekDay(&temp, GREGORIAN_CHANGE_DATE);
 	if (temp.dayOfWeek != yyDayOfWeek) {
-	    errMsg = "invalid day of week"; errCode = "day of week"; goto error;
+	    errMsg = "invalid day of week";
+	    errCode = "day of week";
+	    goto error;
 	}
     }
 
     return TCL_OK;
 
   error:
-    Tcl_SetObjResult(opts->interp,
-	Tcl_ObjPrintf("unable to convert input string: %s", errMsg));
+    Tcl_SetObjResult(opts->interp, Tcl_ObjPrintf(
+	    "unable to convert input string: %s", errMsg));
     Tcl_SetErrorCode(opts->interp, "CLOCK", "invInpStr", errCode, (char *)NULL);
     return TCL_ERROR;
 }
@@ -3988,13 +3958,13 @@ ClockValidDate(
 
 int
 ClockFreeScan(
-    DateInfo	       *info,	/* Date fields used for parsing & converting
+    DateInfo *info,		/* Date fields used for parsing & converting
 				 * simultaneously a yy-parse structure of the
 				 * TclClockFreeScan */
     Tcl_Obj *strObj,		/* String containing the time to scan */
     ClockFmtScnCmdArgs *opts)	/* Command options */
 {
-    Tcl_Interp	    *interp =  opts->interp;
+    Tcl_Interp *interp = opts->interp;
     ClockClientData *dataPtr = (ClockClientData *)opts->clientData;
 
     int ret = TCL_ERROR;
@@ -4011,9 +3981,10 @@ ClockFreeScan(
 
     if (TclClockFreeScan(interp, info) != TCL_OK) {
 	Tcl_Obj *msg;
+
 	TclNewObj(msg);
 	Tcl_AppendPrintfToObj(msg, "unable to convert date-time string \"%s\": %s",
-	    TclGetString(strObj), Tcl_GetString(Tcl_GetObjResult(interp)));
+		TclGetString(strObj), Tcl_GetString(Tcl_GetObjResult(interp)));
 	Tcl_SetObjResult(interp, msg);
 	goto done;
     }
@@ -4046,8 +4017,9 @@ ClockFreeScan(
 	    Tcl_Obj *tzObjStor = NULL;
 	    int minEast = -yyTimezone;
 	    int dstFlag = 1 - yyDSTmode;
+
 	    tzObjStor = ClockFormatNumericTimeZone(
-				60 * minEast + 3600 * dstFlag);
+		    60 * minEast + 3600 * dstFlag);
 	    Tcl_IncrRefCount(tzObjStor);
 
 	    opts->timezoneObj = ClockSetupTimeZone(dataPtr, interp, tzObjStor);
@@ -4056,7 +4028,7 @@ ClockFreeScan(
 	} else {
 	    /* simplest case - GMT / UTC */
 	    opts->timezoneObj = ClockSetupTimeZone(dataPtr, interp,
-		dataPtr->literals[LIT_GMT]);
+		    dataPtr->literals[LIT_GMT]);
 	}
 	if (opts->timezoneObj == NULL) {
 	    goto done;
@@ -4071,7 +4043,7 @@ ClockFreeScan(
      * For freescan apply validation rules (stage 1) before mixed with
      * relative time (otherwise always valid recalculated date & time).
      */
-    if ( (opts->flags & CLF_VALIDATE) ) {
+    if ((opts->flags & CLF_VALIDATE)) {
 	if (ClockValidDate(info, opts, CLF_VALIDATE_S1) != TCL_OK) {
 	    goto done;
 	}
@@ -4084,24 +4056,17 @@ ClockFreeScan(
     if ((info->flags & (CLF_TIME|CLF_HAVEDATE)) == CLF_HAVEDATE) {
 	yySecondOfDay = 0;
 	info->flags |= CLF_ASSEMBLE_SECONDS;
-    }
-    else
-    if (info->flags & CLF_TIME) {
+    } else if (info->flags & CLF_TIME) {
 	yySecondOfDay = ToSeconds(yyHour, yyMinutes,
-			    yySeconds, yyMeridian);
+		yySeconds, yyMeridian);
 	info->flags |= CLF_ASSEMBLE_SECONDS;
-    }
-    else
-    if ( (info->flags & (CLF_DAYOFWEEK|CLF_HAVEDATE)) == CLF_DAYOFWEEK
+    } else if ((info->flags & (CLF_DAYOFWEEK|CLF_HAVEDATE)) == CLF_DAYOFWEEK
 	    || (info->flags & CLF_ORDINALMONTH)
-	    || ( (info->flags & CLF_RELCONV)
-		&& ( yyRelMonth != 0
-		     || yyRelDay != 0 ) )
-    ) {
+	    || ((info->flags & CLF_RELCONV)
+	    && (yyRelMonth != 0 || yyRelDay != 0))) {
 	yySecondOfDay = 0;
 	info->flags |= CLF_ASSEMBLE_SECONDS;
-    }
-    else {
+    } else {
 	yySecondOfDay = yydate.localSeconds % SECONDS_PER_DAY;
     }
 
@@ -4113,8 +4078,7 @@ ClockFreeScan(
 
     /* Free scanning completed - date ready */
 
-done:
-
+  done:
     return ret;
 }
 
@@ -4134,19 +4098,16 @@ done:
  */
 int
 ClockCalcRelTime(
-    DateInfo	       *info)	/* Date fields used for converting */
+    DateInfo *info)		/* Date fields used for converting */
 {
-
     int prevDayOfWeek = yyDayOfWeek;	/* preserve unchanged day of week */
 
     /*
      * Because some calculations require in-between conversion of the
      * julian day, we can repeat this processing multiple times
      */
-repeat_rel:
-
+  repeat_rel:
     if (info->flags & CLF_RELCONV) {
-
 	/*
 	 * Relative conversion normally possible in UTC time only, because
 	 * of possible wrong local time increment if ignores in-between DST-hole.
@@ -4192,7 +4153,6 @@ repeat_rel:
 
 	/* add days (or other parts aligned to days) */
 	if (yyRelDay) {
-
 	    /* assemble julianDay using new year, month, etc. */
 	    if (info->flags & CLF_ASSEMBLE_JULIANDAY) {
 		GetJulianDayFromEraYearMonthDay(&yydate, GREGORIAN_CHANGE_DATE);
@@ -4202,7 +4162,6 @@ repeat_rel:
 
 	    /* julianDay was changed, on demand (lazy) extract year, month, etc. again */
 	    info->flags |= CLF_ASSEMBLE_DATE|CLF_ASSEMBLE_SECONDS;
-
 	    yyRelDay = 0;
 	}
 
@@ -4213,7 +4172,6 @@ repeat_rel:
 
 	    /* if seconds increment outside of current date, increment day */
 	    if (newSecs / SECONDS_PER_DAY != yySecondOfDay / SECONDS_PER_DAY) {
-
 		yyRelDay += newSecs / SECONDS_PER_DAY;
 		yySecondOfDay = 0;
 		yyRelSeconds = newSecs % SECONDS_PER_DAY;
@@ -4268,7 +4226,6 @@ repeat_rel:
      */
 
     if ((info->flags & (CLF_DAYOFWEEK|CLF_HAVEDATE)) == CLF_DAYOFWEEK) {
-
 	/* restore scanned day of week */
 	yyDayOfWeek = prevDayOfWeek;
 
@@ -4280,7 +4237,7 @@ repeat_rel:
 
 	yydate.isBce = 0;
 	yydate.julianDay = WeekdayOnOrBefore(yyDayOfWeek, yydate.julianDay + 6)
-		    + 7 * yyDayOrdinal;
+		+ 7 * yyDayOrdinal;
 	if (yyDayOrdinal > 0) {
 	    yydate.julianDay -= 7;
 	}
@@ -4325,6 +4282,7 @@ ClockWeekdaysOffs(
     /* resulting day of week */
     {
 	int day = (offs % 7);
+
 	/* compiler fix for negative offs - wrap (0, -1) -> (-1, 6) */
 	if (day < 0) {
 	    day = 7 + day;
@@ -4335,13 +4293,14 @@ ClockWeekdaysOffs(
     /* adjust if we start from a weekend */
     if (dayOfWeek > 5) {
 	int adj = 5 - dayOfWeek;
+
 	offs += adj;
 	resDayOfWeek += adj;
     }
 
     /* adjust if we end up on a weekend */
     if (resDayOfWeek > 5) {
-       offs += 2;
+	offs += 2;
     }
 
     return offs;
@@ -4392,19 +4351,19 @@ ClockWeekdaysOffs(
 
 int
 ClockAddObjCmd(
-    void *clientData,	/* Client data containing literal pool */
+    void *clientData,		/* Client data containing literal pool */
     Tcl_Interp *interp,		/* Tcl interpreter */
     int objc,			/* Parameter count */
     Tcl_Obj *const objv[])	/* Parameter values */
 {
     static const char *syntax = "clock add clockval|-now ?number units?..."
-	"?-gmt boolean? "
-	"?-locale LOCALE? ?-timezone ZONE?";
+	    "?-gmt boolean? "
+	    "?-locale LOCALE? ?-timezone ZONE?";
     ClockClientData *dataPtr = (ClockClientData *)clientData;
     int ret;
     ClockFmtScnCmdArgs opts;	/* Format, locale, timezone and base */
-    DateInfo	    yy;		/* Common structure used for parsing */
-    DateInfo	   *info = &yy;
+    DateInfo yy;		/* Common structure used for parsing */
+    DateInfo *info = &yy;
 
     /* add "week" to units also (because otherwise ambiguous) */
     static const char *const units[] = {
@@ -4459,14 +4418,13 @@ ClockAddObjCmd(
 	    continue;
 	}
 	/* get unit */
-	if (Tcl_GetIndexFromObj(interp, objv[i+1], units, "unit", 0,
+	if (Tcl_GetIndexFromObj(interp, objv[i + 1], units, "unit", 0,
 		&unitIndex) != TCL_OK) {
 	    goto done;
 	}
 	if (TclHasInternalRep(objv[i], &tclBignumType)
-	    || offs > (unitIndex < CLC_ADD_HOURS ? 0x7fffffff : TCL_MAX_SECONDS)
-	    || offs < (unitIndex < CLC_ADD_HOURS ? -0x7fffffff : TCL_MIN_SECONDS)
-	) {
+		|| offs > (unitIndex < CLC_ADD_HOURS ? 0x7fffffff : TCL_MAX_SECONDS)
+		|| offs < (unitIndex < CLC_ADD_HOURS ? -0x7fffffff : TCL_MIN_SECONDS)) {
 	    Tcl_SetObjResult(interp, dataPtr->literals[LIT_INTEGER_VALUE_TOO_LARGE]);
 	    goto done;
 	}
@@ -4480,15 +4438,13 @@ ClockAddObjCmd(
 	 * correct date info, because the date may be changed,
 	 * so refresh it now */
 
-	if ( (info->flags & CLF_RELCONV)
-	  && ( unitIndex == CLC_ADD_WEEKDAYS
-	    /* some months can be shorter as another */
-	    || yyRelMonth || yyRelDay
-	    /* day changed */
-	    || yySeconds + yyRelSeconds > SECONDS_PER_DAY
-	    || yySeconds + yyRelSeconds < 0
-	  )
-	) {
+	if ((info->flags & CLF_RELCONV)
+		&& (unitIndex == CLC_ADD_WEEKDAYS
+		/* some months can be shorter as another */
+		|| yyRelMonth || yyRelDay
+		/* day changed */
+		|| yySeconds + yyRelSeconds > SECONDS_PER_DAY
+		|| yySeconds + yyRelSeconds < 0)) {
 	    if (ClockCalcRelTime(info) != TCL_OK) {
 		goto done;
 	    }
@@ -4542,14 +4498,11 @@ ClockAddObjCmd(
 
     ret = ClockScanCommit(&yy, &opts);
 
-done:
-
+  done:
     TclUnsetObjRef(yy.date.tzName);
-
     if (ret != TCL_OK) {
 	return ret;
     }
-
     Tcl_SetObjResult(interp, Tcl_NewWideIntObj(yy.date.seconds));
     return TCL_OK;
 }
@@ -4633,7 +4586,7 @@ ClockSafeCatchCmd(
 	return Tcl_CatchObjCmd(NULL, interp, objc, objv);
     }
 
-    statePtr = (InterpState *)Tcl_SaveInterpState(interp, 0);
+    statePtr = (InterpState *) Tcl_SaveInterpState(interp, 0);
     if (!statePtr->errorInfo) {
 	/* todo: avoid traced get of errorInfo here */
 	TclInitObjRef(statePtr->errorInfo,