 @@ -1,26 +1,26 @@
-/*	$NetBSD: localtime.c,v 1.50 2010/12/17 23:11:57 christos Exp $	*/
+/*	$NetBSD: localtime.c,v 1.51 2011/01/06 02:41:34 christos Exp $	*/
 /*
 ** This file is in the public domain, so clarified as of
 ** 1996-06-05 by Arthur David Olson.
 */
 #include <sys/cdefs.h>
 #if defined(LIBC_SCCS) && !defined(lint)
 #if 0
 static char	elsieid[] = "@(#)localtime.c	8.9";
 #else
-__RCSID("$NetBSD: localtime.c,v 1.50 2010/12/17 23:11:57 christos Exp $");
+__RCSID("$NetBSD: localtime.c,v 1.51 2011/01/06 02:41:34 christos Exp $");
 #endif
 #endif /* LIBC_SCCS and not lint */
 /*
 ** Leap second handling from Bradley White.
 ** POSIX-style TZ environment variable handling from Guy Harris.
 */
 /*LINTLIBRARY*/
 #include "namespace.h"
 #include "private.h"
 #include "tzfile.h"
 @@ -1338,43 +1338,39 @@ localsub(const timezone_t sp, const time
 			--seconds;
 			tcycles = seconds / YEARSPERREPEAT / AVGSECSPERYEAR;
 			++tcycles;
 			icycles = tcycles;
 			if (tcycles - icycles >= 1 || icycles - tcycles >= 1)
 				return NULL;
 			seconds = (time_t) icycles;
 			seconds *= YEARSPERREPEAT;
 			seconds *= AVGSECSPERYEAR;
 			if (t < sp->ats[0])
 				newt += seconds;
 			else	newt -= seconds;
 			if (newt < sp->ats[0] ||
-				newt > sp->ats[sp->timecnt - 1]) {
+				newt > sp->ats[sp->timecnt - 1])
 					errno = EOVERFLOW;
 					return NULL;	/* "cannot happen" */
 			result = localsub(sp, &newt, offset, tmp);
 			if (result == tmp) {
 				time_t	newy;
 				newy = tmp->tm_year;
 				if (t < sp->ats[0])
 					newy -= (time_t)icycles * YEARSPERREPEAT;
 				else	newy += (time_t)icycles * YEARSPERREPEAT;
 				tmp->tm_year = (int)newy;
-				if (tmp->tm_year != newy) {
+				if (tmp->tm_year != newy)
 					errno = EOVERFLOW;
 					return NULL;
+			}
 			return result;
+	}
 	if (sp->timecnt == 0 || t < sp->ats[0]) {
 		i = 0;
 		while (sp->ttis[i].tt_isdst)
 			if (++i >= sp->typecnt) {
 				i = 0;
 				break;
+			}
 	} else {
 		int	lo = 1;
 		int	hi = sp->timecnt;
 @@ -1418,29 +1414,32 @@ localtime_r(const time_t * __restrict ti
 	return tmp;
+}
 struct tm *
 localtime(const time_t *const timep)
+{
 	return localtime_r(timep, &tm);
+}
 struct tm *
 localtime_rz(const timezone_t sp, const time_t * __restrict timep, struct tm *tmp)
+{
 	if (sp == NULL)
-		return gmtsub(NULL, timep, 0L, tmp);
+		tmp = gmtsub(NULL, timep, 0L, tmp);
 	else
-		return localsub(sp, timep, 0L, tmp);
+		tmp = localsub(sp, timep, 0L, tmp);
 	if (tmp == NULL)
 		errno = EOVERFLOW;
 	return tmp;
+}
 /*
 ** gmtsub is to gmtime as localsub is to localtime.
 */
 static struct tm *
 gmtsub(const timezone_t sp, const time_t * const timep, const long offset,
     struct tm *const tmp)
+{
 	struct tm *	result;
 #ifdef _REENTRANT
 	static mutex_t gmt_mutex = MUTEX_INITIALIZER;
 @@ -1557,37 +1556,33 @@ timesub(const timezone_t sp, const time_
+		}
+	}
 	y = EPOCH_YEAR;
 	tdays = *timep / SECSPERDAY;
 	rem = (long) (*timep - tdays * SECSPERDAY);
 	while (tdays < 0 || tdays >= year_lengths[isleap(y)]) {
 		int		newy;
 		time_t	tdelta;
 		int	idelta;
 		int	leapdays;
 		tdelta = tdays / DAYSPERLYEAR;
 		idelta = (int) tdelta;
-		if (tdelta - idelta >= 1 || idelta - tdelta >= 1) {
+		if (tdelta - idelta >= 1 || idelta - tdelta >= 1)
 			errno = EOVERFLOW;
 			return NULL;
 		if (idelta == 0)
 			idelta = (tdays < 0) ? -1 : 1;
 		newy = y;
-		if (increment_overflow(&newy, idelta)) {
+		if (increment_overflow(&newy, idelta))
 			errno = EOVERFLOW;
 			return NULL;
 		leapdays = leaps_thru_end_of(newy - 1) -
 			leaps_thru_end_of(y - 1);
 		tdays -= ((time_t) newy - y) * DAYSPERNYEAR;
 		tdays -= leapdays;
 		y = newy;
+	}
+	{
 		long	seconds;
 		seconds = tdays * SECSPERDAY + 0.5;
 		tdays = seconds / SECSPERDAY;
 		rem += (long) (seconds - tdays * SECSPERDAY);
+	}
 @@ -1595,44 +1590,38 @@ timesub(const timezone_t sp, const time_
 	** Given the range, we can now fearlessly cast...
 	*/
 	idays = (int) tdays;
 	rem += offset - corr;
 	while (rem < 0) {
 		rem += SECSPERDAY;
 		--idays;
+	}
 	while (rem >= SECSPERDAY) {
 		rem -= SECSPERDAY;
 		++idays;
+	}
 	while (idays < 0) {
-		if (increment_overflow(&y, -1)) {
+		if (increment_overflow(&y, -1))
 			errno = EOVERFLOW;
 			return NULL;
 		idays += year_lengths[isleap(y)];
+	}
 	while (idays >= year_lengths[isleap(y)]) {
 		idays -= year_lengths[isleap(y)];
-		if (increment_overflow(&y, 1)) {
+		if (increment_overflow(&y, 1))
 			errno = EOVERFLOW;
 			return NULL;
+	}
 	tmp->tm_year = y;
-	if (increment_overflow(&tmp->tm_year, -TM_YEAR_BASE)) {
+	if (increment_overflow(&tmp->tm_year, -TM_YEAR_BASE))
 		errno = EOVERFLOW;
 		return NULL;
 	tmp->tm_yday = idays;
 	/*
 	** The "extra" mods below avoid overflow problems.
 	*/
 	tmp->tm_wday = EPOCH_WDAY +
 		((y - EPOCH_YEAR) % DAYSPERWEEK) *
 		(DAYSPERNYEAR % DAYSPERWEEK) +
 		leaps_thru_end_of(y - 1) -
 		leaps_thru_end_of(EPOCH_YEAR - 1) +
 		idays;
 	tmp->tm_wday %= DAYSPERWEEK;
 	if (tmp->tm_wday < 0)
 		tmp->tm_wday += DAYSPERWEEK;
 @@ -1692,27 +1681,27 @@ ctime_rz(const timezone_t sp, const time
 	return asctime_r(rtm, buf);
+}
 /*
 ** Adapted from code provided by Robert Elz, who writes:
 **	The "best" way to do mktime I think is based on an idea of Bob
 **	Kridle's (so its said...) from a long time ago.
 **	It does a binary search of the time_t space. Since time_t's are
 **	just 32 bits, its a max of 32 iterations (even at 64 bits it
 **	would still be very reasonable).
 */
 #ifndef WRONG
-#define WRONG	(-1)
+#define WRONG	((time_t)-1)
 #endif /* !defined WRONG */
 /*
 ** Simplified normalize logic courtesy Paul Eggert.
 */
 static int
 increment_overflow(int *number, int delta)
+{
 	int	number0;
 	number0 = *number;
 	*number += delta;
 @@ -1933,29 +1922,31 @@ time2sub(const timezone_t sp, struct tm
 				** We have a match.
 				*/
 				t = newt;
 				goto label;
+			}
+		}
 		return WRONG;
+	}
 label:
 	newt = t + saved_seconds;
 	if ((newt < t) != (saved_seconds < 0))
 		return WRONG;
 	t = newt;
-	if ((*funcp)(sp, &t, offset, tmp))
+	if ((*funcp)(sp, &t, offset, tmp)) {
 		*okayp = TRUE;
-	return t;
+		return t;
 	} else
 		return WRONG;
+}
 static time_t
 time2(const timezone_t sp, struct tm *const tmp, subfun_t funcp,
     const long offset, int *const okayp)
+{
 	time_t	t;
 	/*
 	** First try without normalization of seconds
 	** (in case tm_sec contains a value associated with a leap second).
 	** If that fails, try with normalization of seconds.
 	*/
 @@ -2023,30 +2014,34 @@ time1(const timezone_t sp, struct tm *co
 			if (okay)
 				return t;
 			tmp->tm_sec -= (int)(sp->ttis[otheri].tt_gmtoff -
 					sp->ttis[samei].tt_gmtoff);
 			tmp->tm_isdst = !tmp->tm_isdst;
+		}
+	}
 	return WRONG;
+}
 time_t
 mktime_z(const timezone_t sp, struct tm *tmp)
+{
 	time_t t;
 	if (sp == NULL)
-		return time1(NULL, tmp, gmtsub, 0L);
+		t = time1(NULL, tmp, gmtsub, 0L);
 	else
-		return time1(sp, tmp, localsub, 0L);
+		t = time1(sp, tmp, localsub, 0L);
 	if (t == WRONG)
 		errno = EOVERFLOW;
 	return t;
+}
 time_t
 mktime(struct tm * const	tmp)
+{
 	time_t result;
 	rwlock_wrlock(&lcl_lock);
 	tzset_unlocked();
 	result = mktime_z(lclptr, tmp);
 	rwlock_unlock(&lcl_lock);
 	return result;
+}
 @@ -2061,35 +2056,45 @@ timelocal_z(const timezone_t sp, struct
 	return mktime_z(sp, tmp);
+}
 time_t
 timelocal(struct tm *const tmp)
+{
 	tmp->tm_isdst = -1;	/* in case it wasn't initialized */
 	return mktime(tmp);
+}
 time_t
 timegm(struct tm *const tmp)
+{
 	time_t t;
 	tmp->tm_isdst = 0;
-	return time1(gmtptr, tmp, gmtsub, 0L);
+	t = time1(gmtptr, tmp, gmtsub, 0L);
 	if (t == WRONG)
 		errno = EOVERFLOW;
 	return t;
+}
 time_t
 timeoff(struct tm *const tmp, const long offset)
+{
 	time_t t;
 	tmp->tm_isdst = 0;
-	return time1(gmtptr, tmp, gmtsub, offset);
+	t = time1(gmtptr, tmp, gmtsub, offset);
 	if (t == WRONG)
 		errno = EOVERFLOW;
 	return t;
+}
 #endif /* defined STD_INSPIRED */
 #ifdef CMUCS
 /*
 ** The following is supplied for compatibility with
 ** previous versions of the CMUCS runtime library.
 */
 long
 gtime(struct tm *const tmp)