Commit the new time stuff, even though I haven't made it threadsafe yet.

At least people can play with it.  Also, fix a buglet in setenv.c.

1 files changed, 1864 insertions, 0 deletions

diff --git a/libc/misc/time/time.c b/libc/misc/time/time.c
new file mode 100644
index 000000000..4371a9cfd
--- /dev/null
+++ b/libc/misc/time/time.c
@@ -0,0 +1,1864 @@
+/*  Copyright (C) 2002     Manuel Novoa III
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/*  ATTENTION!   ATTENTION!   ATTENTION!   ATTENTION!   ATTENTION!
+ *
+ *  Besides uClibc, I'm using this code in my libc for elks, which is
+ *  a 16-bit environment with a fairly limited compiler.  It would make
+ *  things much easier for me if this file isn't modified unnecessarily.
+ *  In particular, please put any new or replacement functions somewhere
+ *  else, and modify the makefile to use your version instead.
+ *  Thanks.  Manuel
+ *
+ *  ATTENTION!   ATTENTION!   ATTENTION!   ATTENTION!   ATTENTION! */
+
+/* June 15, 2002     Initial Notes:
+ *
+ * Note: It is assumed throught that time_t is either long or unsigned long.
+ *       Similarly, clock_t is assumed to be long int.
+ *
+ * Warning: Assumptions are made about the layout of struct tm!  It is
+ *    assumed that the initial fields of struct tm are (in order):
+ *    tm_sec, tm_min, tm_hour, tm_mday, tm_mon, tm_year, tm_wday, tm_yday
+ *
+ * Reached the inital goal of supporting the ANSI/ISO C99 time functions
+ * as well as SUSv3's strptime.  All timezone info is obtained from the
+ * TZ env variable.
+ *
+ * Differences from glibc worth noting:
+ *
+ * Leap seconds are not considered here.
+ *
+ * glibc stores additional timezone info the struct tm, whereas we don't.
+ *
+ * Alternate digits and era handling are not currently implemented.
+ * The modifiers are accepted, and tested for validity with the following
+ * specifier, but are ignored otherwise.
+ *
+ * strftime does not implement glibc extension modifiers or widths for
+ *     conversion specifiers.  However it does implement the glibc
+ *     extension specifiers %l, %k, and %s.  It also recognizes %P, but
+ *     treats it as a synonym for %p; i.e. doesn't convert to lower case.
+ *
+ * strptime implements the glibc extension specifiers.  However, it follows
+ *     SUSv3 in requiring at least one non-alphanumeric char between
+ *     conversion specifiers.  Also, strptime only sets struct tm fields
+ *     for which format specifiers appear and does not try to infer other
+ *     fields (such as wday) as glibc's version does.
+ *
+ * TODO - Since glibc's %l and %k can space-pad their output in strftime,
+ *     it might be reasonable to eat whitespace first for those specifiers.
+ *     This could be done by pushing " %I" and " %H" respectively so that
+ *     leading whitespace is consumed.  This is really only an issue if %l
+ *     or %k occurs at the start of the format string.
+ *
+ * TODO - Implement getdate? tzfile? struct tm extensions?
+ *
+ * TODO - Rework _time_mktime to remove the dependency on long long.
+ *
+ * TODO - Make tzset and _time_tzinfo refs threadsafe.
+ */
+
+#define _GNU_SOURCE
+#define _STDIO_UTILITY
+#include <stdio.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <string.h>
+#include <time.h>
+#include <limits.h>
+#include <assert.h>
+#include <errno.h>
+#include <ctype.h>
+#include <langinfo.h>
+#include <locale.h>
+
+#ifndef __isleap
+#define __isleap(y) ( !((y) % 4) && ( ((y) % 100) || !((y) % 400) ) )
+#endif
+
+#ifndef TZNAME_MAX
+#define TZNAME_MAX _POSIX_TZNAME_MAX
+#endif
+
+/* TODO - This stuff belongs in some include/bits/ file. */
+#ifndef __BCC__
+#undef CLK_TCK
+#if (TARGET_ARCH == alpha) || (TARGET_ARCH == ia64)
+#define CLK_TCK     1024
+#else
+#define CLK_TCK     100
+#endif
+#endif
+
+/* The era code is currently unfinished. */
+/*  #define ENABLE_ERA_CODE */
+
+extern struct tm __time_tm;
+
+typedef struct {
+	long gmt_offset;
+	long dst_offset;
+	short day;					/* for J or normal */
+	short week;
+	short month;
+	short rule_type;			/* J, M, \0 */
+	char tzname[TZNAME_MAX+1];
+} rule_struct;
+
+extern rule_struct _time_tzinfo[2];
+
+extern struct tm *_time_t2tm(const time_t *__restrict timer,
+							 int offset, struct tm *__restrict result);
+
+extern time_t _time_mktime(struct tm *timeptr, int store_on_success);
+
+/**********************************************************************/
+#ifdef L_asctime
+
+static char __time_str[26];
+
+char *asctime(const struct tm *__restrict ptm)
+{
+	return asctime_r(ptm, __time_str);
+}
+
+#endif
+/**********************************************************************/
+#ifdef L_asctime_r
+
+/* Strictly speaking, this implementation isn't correct.  ANSI/ISO specifies
+ * that the implementation of asctime() be equivalent to
+ *
+ *   char *asctime(const struct tm *timeptr)
+ *   {
+ *       static char wday_name[7][3] = {
+ *           "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
+ *       };
+ *       static char mon_name[12][3] = {
+ *           "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+ *           "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" 
+ *       };
+ *       static char result[26];
+ *   
+ *       sprintf(result, "%.3s %.3s%3d %.2d:%.2d:%.2d %d\n",
+ *           wday_name[timeptr->tm_wday],                   
+ *           mon_name[timeptr->tm_mon],
+ *           timeptr->tm_mday, timeptr->tm_hour,
+ *           timeptr->tm_min, timeptr->tm_sec,  
+ *           1900 + timeptr->tm_year);        
+ *       return result;
+ *   }
+ *
+ * but the above is either inherently unsafe, or carries with it the implicit
+ * assumption that all fields of timeptr fall within their usual ranges, and
+ * that the tm_year value falls in the range [-2899,8099] to avoid overflowing
+ * the static buffer.
+ *
+ * If we take the implicit assumption as given, then the implementation below
+ * is still incorrect for tm_year values < -900, as there will be either
+ * 0-padding and/or a missing negative sign for the year conversion .  But given
+ * the ususal use of asctime(), I think it isn't unreasonable to restrict correct
+ * operation to the domain of years between 1000 and 9999.
+ */
+
+/* This is generally a good thing, but if you're _sure_ any data passed will be
+ * in range, you can #undef this. */
+#define SAFE_ASCTIME_R		1
+
+static const unsigned char at_data[] = {
+	'S', 'u', 'n', 'M', 'o', 'n', 'T', 'u', 'e', 'W', 'e', 'd',
+	'T', 'h', 'u', 'F', 'r', 'i', 'S', 'a', 't',
+
+	'J', 'a', 'n', 'F', 'e', 'b', 'M', 'a', 'r', 'A', 'p', 'r',
+	'M', 'a', 'y', 'J', 'u', 'n', 'J', 'u', 'l', 'A', 'u', 'g',
+	'S', 'e', 'p', 'O', 'c', 't', 'N', 'o', 'v', 'D', 'e', 'c', 
+
+#ifdef SAFE_ASCTIME_R
+	'?', '?', '?', 
+#endif
+	' ', '?', '?', '?',
+	' ', '0',
+	offsetof(struct tm, tm_mday),
+	' ', '0',
+	offsetof(struct tm, tm_hour),
+	':', '0',
+	offsetof(struct tm, tm_min),
+	':', '0',
+	offsetof(struct tm, tm_sec),
+	' ', '?', '?', '?', '?', '\n', 0
+};
+
+char *asctime_r(register const struct tm *__restrict ptm,
+				register char *__restrict buffer)
+{
+	int tmp;
+
+	assert(ptm);
+	assert(buffer);
+
+#ifdef SAFE_ASCTIME_R
+	memcpy(buffer, at_data + 3*(7 + 12), sizeof(at_data) - 3*(7 + 12));
+
+	if (((unsigned int)(ptm->tm_wday)) <= 6) {
+		memcpy(buffer, at_data + 3 * ptm->tm_wday, 3);
+	}
+
+	if (((unsigned int)(ptm->tm_mon)) <= 11) {
+		memcpy(buffer + 4, at_data + 3*7 + 3 * ptm->tm_mon, 3);
+	}
+#else
+	assert(((unsigned int)(ptm->tm_wday)) <= 6);
+	assert(((unsigned int)(ptm->tm_mon)) <= 11);
+
+	memcpy(buffer, at_data + 3*(7 + 12) - 3, sizeof(at_data) + 3 - 3*(7 + 12));
+
+	memcpy(buffer, at_data + 3 * ptm->tm_wday, 3);
+	memcpy(buffer + 4, at_data + 3*7 + 3 * ptm->tm_mon, 3);
+#endif
+
+#ifdef SAFE_ASCTIME_R
+	buffer += 19;
+	tmp = ptm->tm_year + 1900;
+	if (((unsigned int) tmp) < 10000) {
+		buffer += 4;
+		do {
+			*buffer = '0' + (tmp % 10);
+			tmp /= 10;
+		} while (*--buffer == '?');
+	}
+#else  /* SAFE_ASCTIME_R */
+	buffer += 23;
+	tmp = ptm->tm_year + 1900;
+	assert( ((unsigned int) tmp) < 10000 );
+	do {
+		*buffer = '0' + (tmp % 10);
+		tmp /= 10;
+	} while (*--buffer == '?');
+#endif /* SAFE_ASCTIME_R */
+
+	do {
+		--buffer;
+		tmp = *((int *)(((const char *) ptm) + (int) *buffer));
+#ifdef SAFE_ASCTIME_R
+		if (((unsigned int) tmp) >= 100) { /* Just check 2 digit non-neg. */
+			buffer[-1] = *buffer = '?';
+		} else
+#else  /* SAFE_ASCTIME_R */
+		assert(((unsigned int) tmp) < 100); /* Just check 2 digit non-neg. */
+#endif /* SAFE_ASCTIME_R */
+		{
+			*buffer = '0' + (tmp % 10);
+#ifdef __BCC__
+			buffer[-1] = '0' + (tmp/10);
+#else  /* __BCC__ */
+			buffer[-1] += (tmp/10);
+#endif /* __BCC__ */
+		}
+	} while ((buffer -= 2)[-2] == '0');
+
+	if (*++buffer == '0') {		/* Space-pad day of month. */
+		*buffer = ' ';
+	}
+
+	return buffer - 8;
+}
+
+#endif
+/**********************************************************************/
+#ifdef L_clock
+
+#include <sys/times.h>
+
+/* Note: According to glibc...
+ *    CAE XSH, Issue 4, Version 2: <time.h>
+ *    The value of CLOCKS_PER_SEC is required to be 1 million on all
+ *    XSI-conformant systems.
+ */
+
+#ifndef __BCC__
+#if CLOCKS_PER_SEC != 1000000L
+#error unexpected value for CLOCKS_PER_SEC!
+#endif
+#endif
+
+clock_t clock(void)
+{
+	struct tms xtms;
+	unsigned long t;
+
+	times(&xtms);
+	t = ((unsigned long) xtms.tms_utime) + xtms.tms_stime;
+#if (CLK_TCK == CLOCKS_PER_SEC)
+	return (t <= LONG_MAX) ? t : -1;
+#elif (CLK_TCK == 1) || (CLK_TCK == 10) || (CLK_TCK == 100) || (CLK_TCK == 1000)
+	return (t <= (LONG_MAX / (CLOCKS_PER_SEC/CLK_TCK)))
+		? t * (CLOCKS_PER_SEC/CLK_TCK)
+		: -1;
+#elif (CLK_TCK == 1024)
+	return (t <= ((LONG_MAX / CLOCKS_PER_SEC) * CLK_TCK
+				  + ((LONG_MAX % CLOCKS_PER_SEC) * CLK_TCK) / CLOCKS_PER_SEC))
+		? ((t >> 10) * CLOCKS_PER_SEC) + (((t & 1023) * CLOCKS_PER_SEC) >> 10)
+		: -1;
+#else
+#error fix for CLK_TCK
+#endif
+}
+
+#endif
+/**********************************************************************/
+#ifdef L_ctime
+
+char *ctime(const time_t *clock)
+{
+	/* ANSI/ISO/SUSv3 say that ctime is equivalent to the following. */
+	return asctime(localtime(clock));
+}
+
+#endif
+/**********************************************************************/
+#ifdef L_ctime_r
+
+char *ctime_r(const time_t *clock, char *buf)
+{
+	struct tm xtms;
+
+	return asctime_r(localtime_r(clock, &xtms), buf);
+}
+
+#endif
+/**********************************************************************/
+#ifdef L_difftime
+
+#include <float.h>
+
+#if FLT_RADIX != 2
+#error difftime implementation assumptions violated for you arch!
+#endif
+
+double difftime(time_t time1, time_t time0)
+{
+#if (LONG_MAX >> DBL_MANT_DIG) == 0
+
+	/* time_t fits in the mantissa of a double. */
+	return ((double) time1) - time0;
+
+#elif ((LONG_MAX >> DBL_MANT_DIG) >> DBL_MANT_DIG) == 0
+
+	/* time_t can overflow the mantissa of a double. */
+	time_t t1, t0, d;
+
+	d = ((time_t) 1) << DBL_MANT_DIG;
+	t1 = time1 / d;
+	time1 -= (t1 * d);
+	t0 = time0 / d;
+	time0 -= (t0*d);
+
+	/* Since FLT_RADIX==2 and d is a power of 2, the only possible
+	 * rounding error in the expression below would occur from the
+	 * addition. */
+	return (((double) t1) - t0) * d + (((double) time1) - time0);
+
+#else
+#error difftime needs special implementation on your arch.
+#endif
+}
+
+#endif
+/**********************************************************************/
+#ifdef L_gmtime
+
+struct tm *gmtime(const time_t *timer)
+{
+	register struct tm *ptm = &__time_tm;
+
+	_time_t2tm(timer, 0, ptm); /* Can return NULL... */
+
+	return ptm;
+}
+
+#endif
+/**********************************************************************/
+#ifdef L_gmtime_r
+
+struct tm *gmtime_r(const time_t *__restrict timer,
+					struct tm *__restrict result)
+{
+	return _time_t2tm(timer, 0, result);
+}
+
+#endif
+/**********************************************************************/
+#ifdef L_localtime
+
+struct tm *localtime(const time_t *timer)
+{
+	register struct tm *ptm = &__time_tm;
+
+	tzset();
+
+	localtime_r(timer, ptm);	/* Can return NULL... */
+
+	return ptm;
+}
+
+#endif
+/**********************************************************************/
+#ifdef L_localtime_r
+
+static const unsigned char day_cor[] = { /* non-leap */
+	31, 31, 34, 34, 35, 35, 36, 36, 36, 37, 37, 38, 38
+/* 	 0,  0,  3,  3,  4,  4,  5,  5,  5,  6,  6,  7,  7 */
+/*	    31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 */
+};
+
+static int tm_isdst(register const struct tm *__restrict ptm)
+{
+	register rule_struct *r = _time_tzinfo;
+	long sec;
+	int i, isdst, isleap, day, day0, monlen, mday, oday;
+
+	isdst = 0;
+	if (r[1].tzname[0] != 0) {
+		/* First, get the current seconds offset from the start of the year.
+		 * Fields of ptm are assumed to be in their normal ranges. */
+		sec = ptm->tm_sec
+			+ 60 * (ptm->tm_min
+					+ 60 * (long)(ptm->tm_hour
+								  + 24 * ptm->tm_yday));
+		/* Do some prep work. */
+		i = (ptm->tm_year % 400) + 1900; /* Make sure we don't overflow. */
+		isleap = __isleap(i);
+		--i;
+		day0 = (1
+				+ i				/* Normal years increment 1 wday. */
+				+ (i/4)
+				- (i/100)
+				+ (i/400) ) % 7;
+		i = 0;
+		do {
+			day = r->day;		/* Common for 'J' and # case. */
+			if (r->rule_type == 'J') {
+				if (!isleap || (day < (31+29))) {
+					--day;
+				}
+			} else if (r->rule_type == 'M') {
+				/* Find 0-based day number for 1st of the month. */
+				day = 31*r->month - day_cor[r->month -1];
+				if (isleap && (day >= 59)) {
+					++day;
+				}
+				monlen = 31 + day_cor[r->month -1] - day_cor[r->month];
+				if (isleap && (r->month > 1)) {
+					++monlen;
+				}
+				/* Wweekday (0 is Sunday) of 1st of the month
+				 * is (day0 + day) % 7. */
+				if ((mday = r->day - ((day0 + day) % 7)) >= 0) {
+					mday -= 7;	/* Back up into prev month since r->week>0. */
+				}
+				if ((mday += 7 * r->week) >= monlen) {
+					mday -= 7;
+				}
+				/* So, 0-based day number is... */
+				day += mday;
+			}
+
+			if (i != 0) {
+				/* Adjust sec since dst->std change time is in dst. */
+				sec += (r[-1].gmt_offset - r->gmt_offset);
+				if (oday > day) {
+					++isdst;	/* Year starts in dst. */
+				}
+			}
+			oday = day;
+
+			/* Now convert day to seconds and add offset and compare. */
+			if (sec >= (day * 86400L) + r->dst_offset) {
+				++isdst;
+			}
+			++r;
+		} while (++i < 2);
+	}
+	return (isdst & 1);
+}
+
+struct tm *localtime_r(register const time_t *__restrict timer,
+					   register struct tm *__restrict result)
+{
+	time_t x[1];
+	long offset;
+	int days, dst;
+
+	dst = 0;
+	do {
+		days = -7;
+		offset = 604800L - _time_tzinfo[dst].gmt_offset;
+		if (*timer > (LONG_MAX - 604800L)) {
+			days = -days;
+			offset = -offset;
+		}
+		*x = *timer + offset;
+
+		_time_t2tm(x, days, result);
+		
+		if (dst) {
+			result->tm_isdst = dst;
+			break;
+		}
+		++dst;
+	} while ((result->tm_isdst = tm_isdst(result)) != 0);
+
+	return result;
+}
+
+#endif
+/**********************************************************************/
+#ifdef L_mktime
+
+time_t mktime(struct tm *timeptr)
+{
+	return  _time_mktime(timeptr, 1);
+}
+
+#endif
+/**********************************************************************/
+#ifdef L_strftime
+
+#define NO_E_MOD		0x80
+#define NO_O_MOD		0x40
+
+#define ILLEGAL_SPEC	0x3f
+
+#define INT_SPEC		0x00	/* must be 0x00!! */
+#define STRING_SPEC		0x10	/* must be 0x10!! */
+#define CALC_SPEC		0x20
+#define STACKED_SPEC	0x30
+
+#define MASK_SPEC		0x30
+
+/* Compatibility:
+ *
+ * No alternate digit (%O?) handling.  Always uses 0-9.
+ * Alternate locale format (%E?) handling is broken for nontrivial ERAs.
+ * glibc's %P is currently faked by %p.  This means it doesn't do lower case.
+ * glibc's %k, %l, and %s are handled.
+ * glibc apparently allows (and ignores) extraneous 'E' and 'O' modifiers,
+ *   while they are flagged as illegal conversions here.
+ */
+
+/* Warning: Assumes ASCII values! (as do lots of other things in the lib...) */
+static const unsigned char spec[] = {
+	/* A */		0x03 |  STRING_SPEC | NO_E_MOD | NO_O_MOD,
+	/* B */		0x04 |  STRING_SPEC | NO_E_MOD | NO_O_MOD,
+	/* C */		0x0a |     INT_SPEC            | NO_O_MOD,
+	/* D */		0x02 | STACKED_SPEC | NO_E_MOD | NO_O_MOD,
+	/* E */		       ILLEGAL_SPEC | NO_E_MOD | NO_O_MOD,
+	/* F */		0x03 | STACKED_SPEC | NO_E_MOD | NO_O_MOD,
+	/* G */		0x03 |    CALC_SPEC | NO_E_MOD | NO_O_MOD,
+	/* H */		0x0b |     INT_SPEC | NO_E_MOD,
+	/* I */		0x0c |     INT_SPEC | NO_E_MOD,
+	/* J */		       ILLEGAL_SPEC | NO_E_MOD | NO_O_MOD,
+	/* K */		       ILLEGAL_SPEC | NO_E_MOD | NO_O_MOD,
+	/* L */		       ILLEGAL_SPEC | NO_E_MOD | NO_O_MOD,
+	/* M */		0x0d |     INT_SPEC | NO_E_MOD,
+	/* N */		       ILLEGAL_SPEC | NO_E_MOD | NO_O_MOD,
+	/* O */		       ILLEGAL_SPEC | NO_E_MOD | NO_O_MOD,
+	/* P */		0x05 |  STRING_SPEC | NO_E_MOD | NO_O_MOD, /* glibc ; use %p */
+	/* Q */		       ILLEGAL_SPEC | NO_E_MOD | NO_O_MOD,
+	/* R */		0x04 | STACKED_SPEC | NO_E_MOD | NO_O_MOD,
+	/* S */		0x0e |     INT_SPEC | NO_E_MOD,
+	/* T */		0x05 | STACKED_SPEC | NO_E_MOD | NO_O_MOD,
+	/* U */		0x04 |    CALC_SPEC | NO_E_MOD,
+	/* V */		0x05 |    CALC_SPEC | NO_E_MOD,
+	/* W */		0x06 |    CALC_SPEC | NO_E_MOD,
+	/* X */		0x0a | STACKED_SPEC            | NO_O_MOD,
+	/* Y */		0x0f |     INT_SPEC            | NO_O_MOD,
+	/* Z */		0x01 |    CALC_SPEC | NO_E_MOD | NO_O_MOD,
+	'?',						/* 26 */
+	'?',						/* 27 */
+	'?',						/* 28 */
+	'?',						/* 29 */
+	0,							/* 30 */
+	0,							/* 31 */
+	/* a */		0x00 |  STRING_SPEC | NO_E_MOD | NO_O_MOD,
+	/* b */		0x01 |  STRING_SPEC | NO_E_MOD | NO_O_MOD,
+	/* c */		0x08 | STACKED_SPEC            | NO_O_MOD,
+	/* d */		0x00 |     INT_SPEC | NO_E_MOD,
+	/* e */		0x01 |     INT_SPEC | NO_E_MOD,
+	/* f */		       ILLEGAL_SPEC | NO_E_MOD | NO_O_MOD,
+	/* g */		0x02 |    CALC_SPEC | NO_E_MOD | NO_O_MOD,
+	/* h */		0x01 |  STRING_SPEC | NO_E_MOD | NO_O_MOD, /* same as b */
+	/* i */		       ILLEGAL_SPEC | NO_E_MOD | NO_O_MOD,
+	/* j */		0x08 |     INT_SPEC | NO_E_MOD | NO_O_MOD,
+	/* k */		0x03 |     INT_SPEC | NO_E_MOD | NO_O_MOD, /* glibc */
+	/* l */		0x04 |     INT_SPEC | NO_E_MOD | NO_O_MOD, /* glibc */
+	/* m */		0x05 |     INT_SPEC | NO_E_MOD,
+	/* n */		0x00 | STACKED_SPEC | NO_E_MOD | NO_O_MOD,
+	/* o */		       ILLEGAL_SPEC | NO_E_MOD | NO_O_MOD,
+	/* p */		0x02 |  STRING_SPEC | NO_E_MOD | NO_O_MOD,
+	/* q */		       ILLEGAL_SPEC | NO_E_MOD | NO_O_MOD,
+	/* r */		0x0b | STACKED_SPEC | NO_E_MOD | NO_O_MOD,
+	/* s */		0x07 |    CALC_SPEC | NO_E_MOD | NO_O_MOD, /* glibc */
+	/* t */		0x01 | STACKED_SPEC | NO_E_MOD | NO_O_MOD,
+	/* u */		0x07 |     INT_SPEC | NO_E_MOD,
+	/* v */		       ILLEGAL_SPEC | NO_E_MOD | NO_O_MOD,
+	/* w */		0x02 |     INT_SPEC | NO_E_MOD,
+	/* x */		0x09 | STACKED_SPEC            | NO_O_MOD,
+	/* y */		0x09 |     INT_SPEC,
+	/* z */		0x00 |    CALC_SPEC | NO_E_MOD | NO_O_MOD,
+
+
+	/* WARNING!!! These are dependent on the layout of struct tm!!! */
+#define FIELD_MAX (26+6+26)
+	60 /* 61? */, 59, 23, 31, 11, 0 /* 9999 */, 6, 0 /* 365 */,
+
+#define TP_OFFSETS (FIELD_MAX+8)
+	3, /* d */
+	3, /* e */
+	6, /* w */
+	2, /* k */
+	2, /* l */
+	4, /* m */
+	0, /* CURRENTLY UNUSED */
+	/* NOTE: u,j,y order must be preserved as 6,7,5 seq is used in the code! */
+#define CALC_OFFSETS (TP_OFFSETS + 7)
+	6, /* u */
+	7, /* j */
+	5, /* y */
+	5, /* C */
+	2, /* H */
+	2, /* I */
+	1, /* M */
+	0, /* S */
+	5, /* Y */
+	6, /* a */
+	4, /* b, h */
+	2, /* p */
+	6, /* A */
+	4, /* B */
+	2, /* P */
+
+#define TP_CODES (TP_OFFSETS + 16 + 6)
+	2 | 16, /* d */
+	2, /* e */
+	0 | 16, /* w */
+	2, /* k */
+	2 | 32 | 0, /* l */
+	2 | 16 | 1, /* m */
+	0, /* CURRENTLY UNUSED */
+	0 | 16 | 8 , /* u */
+	4 | 16 | 1, /* j */
+	2 | 128 | 32 | 16 , /* y */
+	2 | 128 | 64 | 32 | 16 , /* C */
+	2 | 16, /* H */
+	2 | 32 | 16 | 0, /* I */
+	2 | 16, /* M */
+	2 | 16, /* S */
+	6 | 16, /* Y */
+	2, /* a */
+	2, /* b, h */
+	2 | 64, /* p */
+	2, /* A */
+	2, /* B */
+	2 | 64, /* P */
+
+#define STRINGS_NL_ITEM_START (TP_CODES + 16 + 6)
+	_NL_ITEM_INDEX(ABDAY_1),	/* a */
+	_NL_ITEM_INDEX(ABMON_1),	/* b, h */
+	_NL_ITEM_INDEX(AM_STR),		/* p */
+	_NL_ITEM_INDEX(DAY_1),		/* A */
+	_NL_ITEM_INDEX(MON_1),		/* B */
+	_NL_ITEM_INDEX(AM_STR),		/* P -- wrong! need lower case */
+
+#define STACKED_STRINGS_START (STRINGS_NL_ITEM_START+6)
+	6, 7, 8, 16, 24, 29,		/* 6 - offsets from offset-count to strings */
+	'\n', 0,					/* 2 */
+	'\t', 0,					/* 2 */
+	'%', 'm', '/', '%', 'd', '/', '%', 'y', 0, /* 9 - %D */
+	'%', 'Y', '-', '%', 'm', '-', '%', 'd', 0, /* 9 - %F (glibc extension) */
+	'%', 'H', ':', '%', 'M', 0,	/* 6 - %R*/
+	'%', 'H', ':', '%', 'M', ':', '%', 'S', 0, /* 9 - %T */
+
+#define STACKED_STRINGS_NL_ITEM_START (STACKED_STRINGS_START + 43)
+	_NL_ITEM_INDEX(D_T_FMT),	/* c */
+	_NL_ITEM_INDEX(D_FMT),		/* x */
+	_NL_ITEM_INDEX(T_FMT),		/* X */
+	_NL_ITEM_INDEX(T_FMT_AMPM), /* r */
+#ifdef ENABLE_ERA_CODE
+	_NL_ITEM_INDEX(ERA_D_T_FMT), /* Ec */
+	_NL_ITEM_INDEX(ERA_D_FMT),	/* Ex */
+	_NL_ITEM_INDEX(ERA_T_FMT),	/* EX */
+#endif
+};
+
+static int load_field(int k, const struct tm *__restrict timeptr)
+{
+	int r;
+	int r_max;
+
+	r = ((int *) timeptr)[k];
+
+	r_max = spec[FIELD_MAX + k];
+
+	if (k == 7) {
+		r_max = 365;
+	} else if (k == 5) {
+		r += 1900;
+		r_max = 9999;
+	}
+
+	if ((((unsigned int) r) > r_max) || ((k == 3) && !r)) {
+		r = -1;
+	}
+
+	return r;
+}
+
+#define MAX_PUSH 4
+
+size_t strftime(char *__restrict s, size_t maxsize,
+				const char *__restrict format,
+				const struct tm *__restrict timeptr)
+{
+	long tzo;
+	register const char *p;
+	register const char *o;
+	const rule_struct *rsp;
+	const char *stack[MAX_PUSH];
+	size_t count;
+	size_t o_count;
+	int field_val, i, j, lvl;
+	int x[3];			/* wday, yday, year */
+	int isofm, days;
+	char buf[__UIM_BUFLEN_LONG];
+	unsigned char mod;
+	unsigned char code;
+
+	tzset();					/* We'll, let's get this out of the way. */
+
+	lvl = 0;
+	p = format;
+	count = maxsize;
+
+ LOOP:
+	if (!count) {
+		return 0;
+	}
+	if (!*p) {
+		if (lvl == 0) {
+			*s = 0;				/* nul-terminate */
+			return maxsize - count;
+		}
+		p = stack[--lvl];
+		goto LOOP;
+	}
+
+	o_count = 1;
+	if ((*(o = p) == '%') && (*++p != '%')) {
+		o_count = 2;
+		mod = ILLEGAL_SPEC;
+		if ((*p == 'O') || (*p == 'E')) { /* modifier */
+			mod |= ((*p == 'O') ? NO_O_MOD : NO_E_MOD);
+			++o_count;
+			++p;
+		}
+		if ((((unsigned char)(((*p) | 0x20) - 'a')) >= 26)
+			|| (((code = spec[(int)(*p - 'A')]) & mod) >= ILLEGAL_SPEC)
+			) {
+			if (!*p) {
+				--p;
+				--o_count;
+			}
+			goto OUTPUT;
+		}
+		code &= ILLEGAL_SPEC;	/* modifiers are preserved in mod var. */
+
+		if ((code & MASK_SPEC) == STACKED_SPEC) {
+			if (lvl == MAX_PUSH) {
+				goto OUTPUT;	/* Stack full so treat as illegal spec. */
+			}
+			stack[lvl++] = ++p;
+			if ((code &= 0xf) < 8) {
+				p = ((const char *) spec) + STACKED_STRINGS_START + code;
+				p += *((unsigned char *)p);
+				goto LOOP;
+			}
+			p = ((const char *) spec) + STACKED_STRINGS_NL_ITEM_START
+				+ (code & 7);
+#ifdef ENABLE_ERA_CODE
+			if ((mod & NO_E_MOD) /* Actually, this means E modifier present. */
+				&& (*(o = nl_langinfo(_NL_ITEM(LC_TIME,
+											   (int)(((unsigned char *)p)[4]))
+									  )))
+				) {
+				p = o;
+				goto LOOP;
+			}
+#endif
+			p = nl_langinfo(_NL_ITEM(LC_TIME,
+									 (int)(*((unsigned char *)p))));
+			goto LOOP;
+		}
+
+		o = spec + 26;		/* set to "????" */
+		if ((code & MASK_SPEC) == CALC_SPEC) {
+
+			if (*p == 's') {
+				time_t t;
+
+				/* Use a cast to silence the warning since *timeptr won't
+				 * be changed. */
+				if ((t = _time_mktime((struct tm *) timeptr, 0))
+					== ((time_t) -1)
+					) {
+					o_count = 1;
+					goto OUTPUT;
+				}
+#ifdef TIME_T_IS_UNSIGNED
+				o = _uintmaxtostr(buf + sizeof(buf) - 1,
+								  (uintmax_t) t,
+								  10, __UIM_DECIMAL);
+#else
+				o = _uintmaxtostr(buf + sizeof(buf) - 1,
+								  (uintmax_t) t,
+								  -10, __UIM_DECIMAL);
+#endif
+				o_count = sizeof(buf);
+				goto OUTPUT;
+			} else if (((*p) | 0x20) == 'z') { /* 'z' or 'Z' */
+
+				if (timeptr->tm_isdst < 0) {
+					/* SUSv3 specifies this behavior for 'z', but we'll also
+					 * treat it as "no timezone info" for 'Z' too. */
+					o_count = 0;
+					goto OUTPUT;
+				}
+
+				rsp = _time_tzinfo;
+				if (timeptr->tm_isdst > 0) {
+					++rsp;
+				}
+
+				if (*p == 'Z') {
+					o = rsp->tzname;
+					assert(o != NULL);
+#if 0
+					if (!o) {	/* PARANOIA */
+						o = spec+30; /* empty string */
+					}
+#endif
+					o_count = SIZE_MAX;
+					goto OUTPUT;
+				} else {		/* z */
+					*s = '+';
+					if ((tzo = -rsp->gmt_offset) < 0) {
+						tzo = -tzo;
+						*s = '-';
+					}
+					++s;
+					--count;
+
+					i = tzo / 60;
+					field_val = ((i / 60) * 100) + (i % 60);
+			
+					i = 16 + 6;	/* 0-fill, width = 4 */
+				}
+			} else {
+				/* TODO: don't need year for U, W */
+				for (i=0 ; i < 3 ; i++) {
+					if ((x[i] = load_field(spec[CALC_OFFSETS+i],timeptr)) < 0) {
+						goto OUTPUT;
+					}
+				}
+
+				i = 16 + 2;		/* 0-fill, width = 2 */
+
+				if ((*p == 'U') || (*p == 'W')) {
+					field_val = ((x[1] - x[0]) + 7);
+					if (*p == 'W') {
+						++field_val;
+					}
+					field_val /= 7;
+					if ((*p == 'W') && !x[0]) {
+						--field_val;
+					}
+				} else {	/* ((*p == 'g') || (*p == 'G') || (*p == 'V')) */
+				ISO_LOOP:
+					isofm = (((x[1] - x[0]) + 11) % 7) - 3;	/* [-3,3] */
+
+					if (x[1] < isofm) {	/* belongs to previous year */
+						--x[2];
+						x[1] += 365 + __isleap(x[2]);
+						goto ISO_LOOP;
+					}
+
+					field_val = ((x[1] - isofm) / 7) + 1; /* week # */
+					days = 365 + __isleap(x[2]);
+					isofm = ((isofm + 7*53 + 3 - days)) %7 + days - 3; /* next year */
+					if (x[1] >= isofm) { /* next year */
+						x[1] -= days;
+						++x[2];
+						goto ISO_LOOP;
+					}
+
+					if (*p != 'V') { /* need year */
+						field_val = x[2]; /* TODO: what if x[2] now 10000 ?? */
+						if (*p == 'g') {
+							field_val %= 100;
+						} else {
+							i = 16 + 6;	/* 0-fill, width = 4 */
+						}
+					}
+				}
+			}
+		} else {
+			i = TP_OFFSETS + (code & 0x1f);
+			if ((field_val = load_field(spec[i],timeptr)) < 0) {
+				goto OUTPUT;
+			}
+
+			i = spec[i+(TP_CODES - TP_OFFSETS)];
+
+			j = (i & 128) ? 100: 12;
+			if (i & 64) {
+				field_val /= j;;
+			}
+			if (i & 32) {
+				field_val %= j;
+				if (((i&128) + field_val) == 0) { /* mod 12? == 0 */
+					field_val = j; /* set to 12 */
+				}
+			}
+			field_val += (i & 1);
+			if ((i & 8) && !field_val) {
+				field_val += 7;
+			}
+		}
+		
+		if ((code & MASK_SPEC) == STRING_SPEC) {
+			o_count = SIZE_MAX;
+			field_val += spec[STRINGS_NL_ITEM_START + (code & 0xf)];
+			o = nl_langinfo(_NL_ITEM(LC_TIME, field_val));
+		} else {
+			o_count = ((i >> 1) & 3) + 1;
+			o = buf + o_count;
+			do {
+				*(char *)(--o) = '0' + (field_val % 10);
+				field_val /= 10;
+			} while (o > buf);
+			if (*buf == '0') {
+				*buf = ' ' + (i & 16);
+			}
+		}
+	}
+
+ OUTPUT:
+	++p;
+	while (o_count && count && *o) {
+		*s++ = *o++;
+		--o_count;
+		--count;
+	}
+	goto LOOP;
+}
+
+#endif
+/**********************************************************************/
+#ifdef L_strptime
+
+/* TODO:
+ * 1) %l and %k are space-padded, so "%l" by itself fails while " %l" succeeds.
+ *    Both work for glibc.  So, should we always strip spaces?
+ * 2) %Z
+ */
+
+/* Notes:
+ * There are several differences between this strptime and glibc's strptime.
+ * 1) glibc strips leading space before numeric conversions.
+ * 2) glibc will read fields without whitespace in between.  SUSv3 states
+ *    that you must have whitespace between conversion operators.  Besides,
+ *    how do you know how long a number should be if there are leading 0s?
+ * 3) glibc attempts to compute some the struct tm fields based on the
+ *    data retrieved; tm_wday in particular.  I don't as I consider it
+ *     another glibc attempt at mind-reading...
+ */
+
+#define NO_E_MOD		0x80
+#define NO_O_MOD		0x40
+
+#define ILLEGAL_SPEC	0x3f
+
+#define INT_SPEC		0x00	/* must be 0x00!! */
+#define STRING_SPEC		0x10	/* must be 0x10!! */
+#define CALC_SPEC		0x20
+#define STACKED_SPEC	0x30
+
+#define MASK_SPEC		0x30
+
+/* Warning: Assumes ASCII values! (as do lots of other things in the lib...) */
+static const unsigned char spec[] = {
+	/* A */		0x02 |  STRING_SPEC | NO_E_MOD | NO_O_MOD,
+	/* B */		0x01 |  STRING_SPEC | NO_E_MOD | NO_O_MOD,
+	/* C */		0x08 |     INT_SPEC            | NO_O_MOD,
+	/* D */		0x01 | STACKED_SPEC | NO_E_MOD | NO_O_MOD,
+	/* E */		       ILLEGAL_SPEC | NO_E_MOD | NO_O_MOD,
+	/* F */		0x02 | STACKED_SPEC | NO_E_MOD | NO_O_MOD, /* glibc */
+	/* G */		0x0f |     INT_SPEC | NO_E_MOD | NO_O_MOD, /* glibc */
+	/* H */		0x06 |     INT_SPEC | NO_E_MOD,
+	/* I */		0x07 |     INT_SPEC | NO_E_MOD,
+	/* J */		       ILLEGAL_SPEC | NO_E_MOD | NO_O_MOD,
+	/* K */		       ILLEGAL_SPEC | NO_E_MOD | NO_O_MOD,
+	/* L */		       ILLEGAL_SPEC | NO_E_MOD | NO_O_MOD,
+	/* M */		0x04 |     INT_SPEC | NO_E_MOD,
+	/* N */		       ILLEGAL_SPEC | NO_E_MOD | NO_O_MOD,
+	/* O */		       ILLEGAL_SPEC | NO_E_MOD | NO_O_MOD,
+	/* P */		0x00 |  STRING_SPEC | NO_E_MOD | NO_O_MOD, /* glibc */
+	/* Q */		       ILLEGAL_SPEC | NO_E_MOD | NO_O_MOD,
+	/* R */		0x03 | STACKED_SPEC | NO_E_MOD | NO_O_MOD,
+	/* S */		0x05 |     INT_SPEC | NO_E_MOD,
+	/* T */		0x04 | STACKED_SPEC | NO_E_MOD | NO_O_MOD,
+	/* U */		0x0c |     INT_SPEC | NO_E_MOD,
+	/* V */		0x0d |     INT_SPEC | NO_E_MOD | NO_O_MOD, /* glibc */
+	/* W */		0x0c |     INT_SPEC | NO_E_MOD,
+	/* X */		0x0a | STACKED_SPEC            | NO_O_MOD,
+	/* Y */		0x0a |     INT_SPEC            | NO_O_MOD,
+	/* Z */		0x02 |    CALC_SPEC | NO_E_MOD | NO_O_MOD, /* glibc */
+
+	/* WARNING! This assumes orderings:
+	 *    AM,PM
+	 *    ABDAY_1-ABDAY-7,DAY_1-DAY_7
+	 *    ABMON_1-ABMON_12,MON_1-MON12
+	 * Also, there are exactly 6 bytes between 'Z' and 'a'.
+	 */
+#define STRINGS_NL_ITEM_START (26)
+	_NL_ITEM_INDEX(AM_STR),		/* p (P) */
+	_NL_ITEM_INDEX(ABMON_1),	/* B, b */
+	_NL_ITEM_INDEX(ABDAY_1),	/* A, a */
+	2,
+	24,
+	14,
+
+	/* a */		0x02 |  STRING_SPEC | NO_E_MOD | NO_O_MOD,
+	/* b */		0x01 |  STRING_SPEC | NO_E_MOD | NO_O_MOD,
+	/* c */		0x08 | STACKED_SPEC            | NO_O_MOD,
+	/* d */		0x00 |     INT_SPEC | NO_E_MOD,
+	/* e */		0x00 |     INT_SPEC | NO_E_MOD,
+	/* f */		       ILLEGAL_SPEC | NO_E_MOD | NO_O_MOD,
+	/* g */		0x0e |     INT_SPEC | NO_E_MOD | NO_O_MOD, /* glibc */
+	/* h */		0x01 |  STRING_SPEC | NO_E_MOD | NO_O_MOD,
+	/* i */		       ILLEGAL_SPEC | NO_E_MOD | NO_O_MOD,
+	/* j */		0x01 |     INT_SPEC | NO_E_MOD | NO_O_MOD,
+	/* k */		0x06 |     INT_SPEC | NO_E_MOD,            /* glibc */
+	/* l */		0x07 |     INT_SPEC | NO_E_MOD,            /* glibc */
+	/* m */		0x02 |     INT_SPEC | NO_E_MOD,
+	/* n */		0x00 | STACKED_SPEC | NO_E_MOD | NO_O_MOD,
+	/* o */		       ILLEGAL_SPEC | NO_E_MOD | NO_O_MOD,
+	/* p */		0x00 |  STRING_SPEC | NO_E_MOD | NO_O_MOD,
+	/* q */		       ILLEGAL_SPEC | NO_E_MOD | NO_O_MOD,
+	/* r */		0x0b | STACKED_SPEC | NO_E_MOD | NO_O_MOD,
+	/* s */		0x00 |    CALC_SPEC | NO_E_MOD | NO_O_MOD, /* glibc */
+	/* t */		0x00 | STACKED_SPEC | NO_E_MOD | NO_O_MOD,
+	/* u */		0x0b |     INT_SPEC | NO_E_MOD | NO_O_MOD, /* glibc */
+	/* v */		       ILLEGAL_SPEC | NO_E_MOD | NO_O_MOD,
+	/* w */		0x03 |     INT_SPEC | NO_E_MOD,
+	/* x */		0x09 | STACKED_SPEC            | NO_O_MOD,
+	/* y */		0x09 |     INT_SPEC,
+	/* z */		0x01 |    CALC_SPEC | NO_E_MOD | NO_O_MOD, /* glibc */
+
+#define INT_FIELD_START (26+6+26)
+	/* (field #) << 3  + lower bound (0|1) + correction 0:none, 2:-1, 4:-1900
+	 * followed by upper bound prior to correction with 1=>366 and 2=>9999. */
+	/* d, e */	(3 << 3) + 1 + 0, 31,
+	/* j */		(7 << 3) + 1 + 2, /* 366 */ 1,
+	/* m */		(4 << 3) + 1 + 2, 12,
+	/* w */		(6 << 3) + 0 + 0, 6,
+	/* M */		(1 << 3) + 0 + 0, 59,
+	/* S */		0        + 0 + 0, 60,
+	/* H (k) */	(2 << 3) + 0 + 0, 23,
+	/* I (l) */	(9 << 3) + 1 + 0, 12, /* goes with 8 -- am/pm */
+	/* C */		(10<< 3) + 0 + 0, 99,
+	/* y */		(11<< 3) + 0 + 0, 99,
+	/* Y */		(5 << 3) + 0 + 4, /* 9999 */ 2,
+	/* u */		(6 << 3) + 1 + 0, 7,
+	/* The following are processed and range-checked, but ignored otherwise. */
+	/* U, W */	(12<< 3) + 0 + 0, 53,
+	/* V */		(12<< 3) + 1 + 0, 53,
+	/* g */		(12<< 3) + 0 + 0, 99,
+	/* G */		(12<< 3) + 0 /*+ 4*/, /* 9999 */ 2, /* Note: -1 or 10000? */
+
+#define STACKED_STRINGS_START (INT_FIELD_START+32)
+	5, 6, 14, 22, 27,			/* 5 - offsets from offset-count to strings */
+	' ', 0,						/* 2 - %n or %t */
+	'%', 'm', '/', '%', 'd', '/', '%', 'y', 0, /* 9 - %D */
+	'%', 'Y', '-', '%', 'm', '-', '%', 'd', 0, /* 9 - %F (glibc extension) */
+	'%', 'H', ':', '%', 'M', 0,	/* 6 - %R*/
+	'%', 'H', ':', '%', 'M', ':', '%', 'S', 0, /* 9 - %T */
+
+#define STACKED_STRINGS_NL_ITEM_START (STACKED_STRINGS_START + 40)
+	_NL_ITEM_INDEX(D_T_FMT),	/* c */
+	_NL_ITEM_INDEX(D_FMT),		/* x */
+	_NL_ITEM_INDEX(T_FMT),		/* X */
+	_NL_ITEM_INDEX(T_FMT_AMPM), /* r */
+#ifdef ENABLE_ERA_CODE
+	_NL_ITEM_INDEX(ERA_D_T_FMT), /* Ec */
+	_NL_ITEM_INDEX(ERA_D_FMT),	/* Ex */
+	_NL_ITEM_INDEX(ERA_T_FMT),	/* EX */
+#endif
+};
+
+#define MAX_PUSH 4
+
+char *strptime(const char *__restrict buf, const char *__restrict format,
+			   struct tm *__restrict tm)
+{
+	register const char *p;
+	char *o;
+	const char *stack[MAX_PUSH];
+	int i, j, lvl;
+	int fields[13];
+	unsigned char mod;
+	unsigned char code;
+
+	i = 0;
+	do {
+		fields[i] = INT_MIN;
+	} while (++i < 13);
+
+	lvl = 0;
+	p = format;
+
+ LOOP:
+	if (!*p) {
+		if (lvl == 0) {			/* Done. */
+			if (fields[6] == 7) { /* Cleanup for %u here since just once. */
+				fields[6] = 0;	/* Don't use mod in case unset. */
+			}
+
+			i = 0;
+			do {				/* Store the values into tm. */
+				((int *) tm)[i] = fields[i];
+			} while (++i < 8);
+
+			return (char *) buf; /* Success. */
+		}
+		p = stack[--lvl];
+		goto LOOP;
+	}
+
+	if ((*p == '%') && (*++p != '%')) {
+		mod = ILLEGAL_SPEC;
+		if ((*p == 'O') || (*p == 'E')) { /* Modifier? */
+			mod |= ((*p == 'O') ? NO_O_MOD : NO_E_MOD);
+			++p;
+		}
+
+		if (!*p
+			|| (((unsigned char)(((*p) | 0x20) - 'a')) >= 26)
+			|| (((code = spec[(int)(*p - 'A')]) & mod) >= ILLEGAL_SPEC)
+			) {
+			return NULL;		/* Illegal spec. */
+		}
+
+		if ((code & MASK_SPEC) == STACKED_SPEC) {
+			if (lvl == MAX_PUSH) {
+				return NULL;	/* Stack full so treat as illegal spec. */
+			}
+			stack[lvl++] = ++p;
+			if ((code &= 0xf) < 8) {
+				p = ((const char *) spec) + STACKED_STRINGS_START + code;
+				p += *((unsigned char *)p);
+				goto LOOP;
+			}
+
+			p = ((const char *) spec) + STACKED_STRINGS_NL_ITEM_START
+				+ (code & 7);
+#ifdef ENABLE_ERA_CODE
+			if ((mod & NO_E_MOD) /* Actually, this means E modifier present. */
+				&& (*(o = nl_langinfo(_NL_ITEM(LC_TIME,
+											   (int)(((unsigned char *)p)[4]))
+									  )))
+				) {
+				p = o;
+				goto LOOP;
+			}
+#endif
+			p = nl_langinfo(_NL_ITEM(LC_TIME,
+									 (int)(*((unsigned char *)p))));
+			goto LOOP;
+		}
+
+		++p;
+
+		if ((code & MASK_SPEC) == STRING_SPEC) {
+			code &= 0xf;
+			j = spec[STRINGS_NL_ITEM_START + 3 + code];
+			i = _NL_ITEM(LC_TIME, spec[STRINGS_NL_ITEM_START + code]);
+			/* Go backwards to check full names before abreviations. */
+			do {
+				--j;
+				o = nl_langinfo(i+j);
+				if (!strncasecmp(buf,o,strlen(o)) && *o) { /* Found a match. */
+					do {
+						++buf;
+					} while (*++o);
+					if (!code) { /* am/pm */
+						fields[8] = j * 12;
+						if (fields[9] >= 0) { /* We have a previous %I or %l. */
+							fields[2] = fields[9] + fields[8];
+						}
+					} else {	/* day (4) or month (6) */
+						fields[2 + (code << 1)]
+							= j % (spec[STRINGS_NL_ITEM_START + 3 + code] >> 1);
+					}
+					goto LOOP;
+				}
+			} while (j);
+			return NULL;		/* Failed to match. */
+		}
+
+		if ((code & MASK_SPEC) == CALC_SPEC) {
+			if ((code &= 0xf) < 1) { /* s or z*/
+				time_t t;
+
+				o = (char *) buf;
+				i = errno;
+				__set_errno(0);
+				if (!isspace(*buf)) { /* Signal an error if whitespace. */
+#ifdef TIME_T_IS_UNSIGNED
+					t = strtoul(buf, &o, 10);
+#else
+					t = strtol(buf, &o, 10);
+#endif
+				}
+				if ((o == buf) || errno) { /* Not a number or overflow. */
+					return NULL;
+				}
+				__set_errno(i);	/* Restore errno. */
+				buf = o;
+
+				if (!code) {	/* s */
+					localtime_r(&t, tm); /* TODO: check for failure? */
+					i = 0;
+					do {		/* Now copy values from tm to fields. */
+						 fields[i] = ((int *) tm)[i];
+					} while (++i < 8);
+				}
+			}
+			/* TODO: glibc treats %Z as a nop.  For now, do the same. */
+			goto LOOP;
+		}
+
+		assert((code & MASK_SPEC) == INT_SPEC);
+		{
+			register const unsigned char *x;
+			code &= 0xf;
+			x = spec + INT_FIELD_START + (code << 1);
+			if ((j = x[1]) < 3) { /* upper bound (inclusive) */
+				j = ((j==1) ? 366 : 9999);
+			}
+			i = -1;
+			while (isdigit(*buf)) {
+				if (i < 0) {
+					i = 0;
+				}
+				if ((i = 10*i + (*buf - '0')) > j) { /* Overflow. */
+					return NULL;
+				}
+				++buf;
+			}
+			if (i < (*x & 1)) {	/* This catches no-digit case too. */
+				return NULL;
+			}
+			if (*x & 2) {
+				--i;
+			}
+			if (*x & 4) {
+				i -= 1900;
+			}
+
+			if (*x == (9 << 3) + 1 + 0) { /* %I or %l */
+				if (i == 12) {
+					i = 0;
+				}
+				if (fields[8] >= 0) { /* We have a previous %p or %P. */
+					fields[2] = i + fields[8];
+				}
+			}
+
+			fields[(*x) >> 3] = i;
+
+			if (((unsigned char)(*x - (10<< 3) + 0 + 0)) <= 8) { /* %C or %y */
+				if ((j = fields[10]) < 0) {	/* No %C, so i must be %y data. */
+					if (i <= 68) { /* Map [0-68] to 2000+i */
+						i += 100;
+					}
+				} else {		/* Have %C data, but what about %y? */
+					if ((i = fields[11]) < 0) {	/* No %y data. */
+						i = 0;	/* Treat %y val as 0 following glibc's example. */
+					}
+					i += 100*(j - 19);
+				}
+				fields[5] = i;
+			}
+		}
+		goto LOOP;
+	} else if (isspace(*p)) {
+		++p;
+		while (isspace(*buf)) {
+			++buf;
+		}
+		goto LOOP;
+	} else if (*buf++ == *p++) {
+		goto LOOP;
+	}
+	return NULL;
+}
+
+#endif
+/**********************************************************************/
+#ifdef L_time
+
+#ifndef __BCC__
+#error The uClibc version of time is in sysdeps/linux/common.
+#endif
+
+time_t time(register time_t *tloc)
+{
+	struct timeval tv;
+	register struct timeval *p = &tv;
+
+	gettimeofday(p, NULL);		/* This should never fail... */
+
+	if (tloc) {
+		*tloc = p->tv_sec;
+	}
+
+	return p->tv_sec;
+}
+
+#endif
+/**********************************************************************/
+#ifdef L_tzset
+
+static const char vals[] = {
+	'T', 'Z', 0,				/* 3 */
+	'U', 'T', 'C', 0,			/* 4 */
+	25, 60, 60, 1,				/* 4 */
+	'.', 1,						/* M */
+	5, '.', 1,
+	6,  0,  0,					/* Note: overloaded for non-M non-J case... */
+	0, 1, 0,					/* J */
+	',', 'M',      '4', '.', '1', '.', '0',
+	',', 'M', '1', '0', '.', '5', '.', '0', 0
+};
+
+#define TZ    vals
+#define UTC   (vals + 3)
+#define RANGE (vals + 7)
+#define RULE  (vals + 11 - 1)
+#define DEFAULT_RULES (vals + 22)
+
+/* Initialize to UTC. */
+int daylight = 0;
+long timezone = 0;
+char *tzname[2] = { (char *) UTC, (char *) (UTC-1) };
+
+rule_struct _time_tzinfo[2];
+
+static const char *getoffset(register const char *e, long *pn)
+{
+	register const char *s = RANGE-1;
+	long n;
+	int f;
+
+	n = 0;
+	f = -1;
+	do {
+		++s;
+		if (isdigit(*e)) {
+			f = *e++ - '0';
+		}
+		if (isdigit(*e)) {
+			f = 10 * f + (*e++ - '0');
+		}
+		if (((unsigned int)f) >= *s) {
+			return NULL;
+		}
+		n = (*s) * n + f;
+		f = 0;
+		if (*e == ':') {
+			++e;
+			--f;
+		}
+	} while (*s > 1);
+
+	*pn = n;
+	return e;
+}
+
+static const char *getnumber(register const char *e, int *pn)
+{
+#ifdef __BCC__
+	/* bcc can optimize the counter if it thinks it is a pointer... */
+	register const char *n = (const char *) 3;
+	int f;
+
+	f = 0;
+	while (n && isdigit(*e)) {
+		f = 10 * f + (*e++ - '0');
+		--n;
+	}
+
+	*pn = f;
+	return (n == (const char *) 3) ? NULL : e;
+#else  /* __BCC__ */
+	int n, f;
+
+	n = 3;
+	f = 0;
+	while (n && isdigit(*e)) {
+		f = 10 * f + (*e++ - '0');
+		--n;
+	}
+
+	*pn = f;
+	return (n == 3) ? NULL : e;
+#endif /* __BCC__ */
+}
+
+void tzset(void)
+{
+	register const char *e;
+	register char *s;
+	long off;
+	short *p;
+	rule_struct new_rules[2];
+	int n, count, f;
+	char c;
+
+	if (!(e = getenv(TZ)) || !*e) { /* Not set or set to empty string. */
+	ILLEGAL:					/* TODO: Clean up the following... */
+		s = _time_tzinfo[0].tzname;
+		*s = 'U';
+		*++s = 'T';
+		*++s = 'C';
+		*++s =
+		*_time_tzinfo[1].tzname = 0;
+		_time_tzinfo[0].gmt_offset = 0;
+		goto DONE;
+	}
+
+
+	if (*e == ':') {			/* Ignore leading ':'. */
+		++e;
+	}
+	
+	count = 0;
+	new_rules[1].tzname[0] = 0;
+ LOOP:
+	/* Get std or dst name. */
+	c = 0;
+	if (*e == '<') {
+		++e;
+		c = '>';
+	}
+
+	s = new_rules[count].tzname;
+	n = 0;
+	while (*e
+		   && (isalpha(*e)
+			   || (c && (isdigit(*e) || (*e == '+') || (*e == '-'))))
+		   ) {
+		*s++ = *e++;
+		if (++n > TZNAME_MAX) {
+			goto ILLEGAL;
+		}
+	}
+	*s = 0;
+
+	if ((n < 3)					/* Check for minimum length. */
+		|| (c && (*e++ != c))	/* Match any quoting '<'. */
+		) {
+		goto ILLEGAL;
+	}
+
+	/* Get offset */
+	s = (char *) e;
+	if ((*e != '-') && (*e != '+')) {
+		if (count && !isdigit(*e)) {
+			off -= 3600;		/* Default to 1 hour ahead of std. */
+			goto SKIP_OFFSET;
+		}
+		--e;
+	}
+
+	++e;
+	if (!(e = getoffset(e, &off))) {
+		goto ILLEGAL;
+	}
+
+	if (*s == '-') {
+		off = -off;				/* Save off in case needed for dst default. */
+	}
+ SKIP_OFFSET:
+	new_rules[count].gmt_offset = off;
+
+	if (!count) {
+		if (*e) {
+			++count;
+			goto LOOP;
+		}
+	} else {					/* OK, we have dst, so get some rules. */
+		count = 0;
+		if (!*e) {				/* No rules so default to US rules. */
+			e = DEFAULT_RULES;
+		}
+
+		do {
+			if (*e++ != ',') {
+				goto ILLEGAL;
+			}
+
+			n = 365;
+			s = (char *) RULE;
+			if ((c = *e++) == 'M') {
+				n = 12;
+			} else if (c == 'J') {
+				s += 8;
+			} else {
+				--e;
+				c = 0;
+				s += 6;
+			}
+
+			*(p = &new_rules[count].rule_type) = c;
+			if (c != 'M') {
+				p -= 2;
+			}
+
+			do {
+				++s;
+				if (!(e = getnumber(e, &f))
+					|| (((unsigned int)(f - s[1])) > n)
+					|| (*s && (*e++ != *s))
+					) {
+					goto ILLEGAL;
+				}
+				*--p = f;
+			} while ((n = *(s += 2)) > 0);
+
+			off = 2 * 60 * 60;	/* Default to 2:00:00 */
+			if (*e == '/') {
+				++e;
+				if (!(e = getoffset(e, &off))) {
+					goto ILLEGAL;
+				}
+			}
+			new_rules[count].dst_offset = off;
+		} while (++count < 2);
+
+		if (*e) {
+			goto ILLEGAL;
+		}
+	}
+
+	memcpy(_time_tzinfo, new_rules, sizeof(new_rules));
+ DONE:
+	tzname[0] = _time_tzinfo[0].tzname;
+	tzname[1] = _time_tzinfo[1].tzname;
+	daylight = !!new_rules[1].tzname[0];
+	timezone = new_rules[0].gmt_offset;
+}
+
+#endif
+/**********************************************************************/
+/*  #ifdef L_utime */
+
+/* utime is a syscall in both linux and elks. */
+/*  int utime(const char *path, const struct utimbuf *times) */
+
+/*  #endif */
+/**********************************************************************/
+/* Non-SUSv3 */
+/**********************************************************************/
+#ifdef L_utimes
+
+#ifndef __BCC__
+#error The uClibc version of utimes is in sysdeps/linux/common.
+#endif
+
+#include <utime.h>
+#include <sys/time.h>
+
+int utimes(const char *filename, register const struct timeval *tvp)
+{
+	register struct utimbuf *p = NULL;
+	struct utimbuf utb;
+
+	if (tvp) {
+		p = &utb;
+		p->actime = tvp[0].tv_sec;
+		p->modtime = tvp[1].tv_sec;
+	}
+	return utime(filename, p);
+}
+
+#endif
+/**********************************************************************/
+#ifdef L__time_t2tm
+
+static const uint16_t vals[] = {
+	60, 60, 24, 7 /* special */, 36524, 1461, 365, 0
+};
+
+static const unsigned char days[] = {
+	31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, /* non-leap */
+	    29,
+};
+
+/* Notes:
+ * If time_t is 32 bits, then no overflow is possible.
+ * It time_t is > 32 bits, this needs to be adjusted to deal with overflow.
+ */
+
+/* Note: offset is the correction in _days_ to *timer! */
+
+struct tm *_time_t2tm(const time_t *__restrict timer,
+					  int offset, struct tm *__restrict result)
+{
+	register int *p;
+	time_t t1, t, v;
+	int wday;
+
+	{
+		register const uint16_t *vp;
+		t = *timer;
+		p = (int *) result;
+		p[7] = 0;
+		vp = vals;
+		do {
+			if ((v = *vp) == 7) {
+				/* Overflow checking, assuming time_t is long int... */
+#if (LONG_MAX > INT_MAX) && (LONG_MAX > 2147483647L)
+#if (INT_MAX == 2147483647L) && (LONG_MAX == 9223372036854775807L)
+				/* Valid range for t is [-784223472856L, 784223421720L].
+				 * Outside of this range, the tm_year field will overflow. */
+				if (((unsigned long)(t + offset- -784223472856L))
+					> (784223421720L - -784223472856L)
+					) {
+					return NULL;
+				}
+#else
+#error overflow conditions unknown
+#endif
+#endif
+
+				/* We have days since the epoch, so caluclate the weekday. */
+#if defined(__BCC__) && TIME_T_IS_UNSIGNED
+				wday = (t + 4) % (*vp);	/* t is unsigned */
+#else
+				wday = ((int)((t % (*vp)) + 11)) % ((int)(*vp)); /* help bcc */
+#endif
+				/* Set divisor to days in 400 years.  Be kind to bcc... */
+				v = ((time_t)(vp[1])) << 2;
+				++v;
+				/* Change to days since 1/1/1601 so that for 32 bit time_t
+				 * values, we'll have t >= 0.  This should be changed for
+				 * archs with larger time_t types. 
+				 * Also, correct for offset since a multiple of 7. */
+
+				/* TODO: Does this still work on archs with time_t > 32 bits? */
+				t += (135140L - 366) + offset; /* 146097 - (365*30 + 7) -366 */
+			}
+#if defined(__BCC__) && TIME_T_IS_UNSIGNED
+			t -= ((t1 = t / v) * v);
+#else
+			if ((t -= ((t1 = t / v) * v)) < 0) {
+				t += v;
+				--t1;
+			}
+#endif
+
+			if ((*vp == 7) && (t == v-1)) {
+				--t;			/* Correct for 400th year leap case */
+				++p[4];			/* Stash the extra day... */
+			}
+
+#if defined(__BCC__) && 0
+			*p = t1;
+			if (v <= 60) {
+				*p = t;
+				t = t1;
+			}
+			++p;
+#else
+			if (v <= 60) {
+				*p++ = t;
+				t = t1;
+			} else {
+				*p++ = t1;
+			}
+#endif
+		} while (*++vp);
+	}
+
+	if (p[-1] == 4) {
+		--p[-1];
+		t = 365;
+	}
+
+
+	*p += ((int) t);			/* result[7] .. tm_yday */
+
+	p -= 2;						/* at result[5] */
+
+#if (LONG_MAX > INT_MAX) && (LONG_MAX > 2147483647L)
+	/* Protect against overflow.  TODO: Unecessary if int arith wraps? */
+	*p = ((((p[-2]<<2) + p[-1])*25 + p[0])<< 2) + (p[1] - 299); /* tm_year */
+#else
+	*p = ((((p[-2]<<2) + p[-1])*25 + p[0])<< 2) + p[1] - 299; /* tm_year */
+#endif
+
+	p[1] = wday;				/* result[6] .. tm_wday */
+
+	{
+		register const unsigned char *d = days;
+
+		wday = 1900 + *p;
+		if (__isleap(wday)) {
+			d += 11;
+		}
+
+		wday = p[2] + 1;		/* result[7] .. tm_yday */
+		*--p = 0;				/* at result[4] .. tm_mon */
+		while (wday > *d) {
+			wday -= *d;
+			if (*d == 29) {
+				d -= 11;		/* Backup to non-leap Feb. */
+			}
+			++d;
+			++*p;				/* Increment tm_mon. */
+		}
+		p[-1] = wday;			/* result[3] .. tm_mday */
+	}
+	/* TODO -- should this be 0? */
+	p[4] = 0;					/* result[8] .. tm_isdst */
+
+	return result;
+}
+
+#endif
+/**********************************************************************/
+#ifdef L___time_tm
+
+struct tm __time_tm;	/* Global shared by gmtime() and localtime(). */
+
+#endif
+/**********************************************************************/
+#ifdef L__time_mktime
+
+static const unsigned char vals[] = {
+	31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, /* non-leap */
+	    29,
+};
+
+time_t _time_mktime(struct tm *timeptr, int store_on_success)
+{
+#ifdef __BCC__
+	long days, secs;
+#else
+	long long secs;
+#endif
+	time_t t;
+	struct tm x;
+	/* 0:sec  1:min  2:hour  3:mday  4:mon  5:year  6:wday  7:yday  8:isdst */
+	register int *p = (int *) &x;
+	register const unsigned char *s;
+	int d;
+
+	tzset();
+
+	memcpy(p, timeptr, sizeof(struct tm));
+
+	d = 400;
+	p[5] = (p[5] - ((p[6] = p[5]/d) * d)) + (p[7] = p[4]/12);
+	if ((p[4] -= 12 * p[7]) < 0) {
+		p[4] += 12;
+		--p[5];
+	}
+
+	s = vals;
+	d = (p[5] += 1900);			/* Correct year.  Now between 1900 and 2300. */
+	if (__isleap(d)) {
+		s += 11;
+	}
+	
+	p[7] = 0;
+	d = p[4];
+	while (d) {
+		p[7] += *s;
+		if (*s == 29) {
+			s -= 11;			/* Backup to non-leap Feb. */
+		}
+		++s;
+		--d;
+	}
+
+#ifdef __BCC__
+	/* TODO - check */
+	d = p[5] - 1;
+	days = -719163L + d*365 + ((d/4) - (d/100) + (d/400) + p[3] + p[7]);
+	secs = p[0] + 60*( p[1] + 60*((long)(p[2])) );
+
+	if (secs < 0) {
+		secs += 120009600L;
+		days -= 1389;
+	}
+	if ( ((unsigned long)(days + secs/86400L)) > 49710L) {
+		return -1;
+	}
+	secs += (days * 86400L);
+#else
+	d = p[5] - 1;
+	d = -719163L + d*365 + (d/4) - (d/100) + (d/400);
+	secs = p[0]
+		+ _time_tzinfo[timeptr->tm_isdst > 0].gmt_offset
+		+ 60*( p[1]
+			   + 60*(p[2]
+					 + 24*(((146073L * ((long long)(p[6])) + d)
+							+ p[3]) + p[7])));
+	if (((unsigned long long)(secs - LONG_MIN))
+		> (((unsigned long long)LONG_MAX) - LONG_MIN)
+		) {
+		return -1;
+	}
+#endif
+
+	t = secs;
+
+	localtime_r(&t, (struct tm *)p);
+
+	if (store_on_success) {
+		memcpy(timeptr, p, sizeof(struct tm));
+	}
+
+	return t;
+}
+
+#endif
+/**********************************************************************/