const char *      format,		/* format of output string */    const struct tm * tptr		/* broken-down time */    )    {    return (strftime_r (s, n, format, tptr, __loctime));    }/********************************************************************************* strftime_r - format time into a string (POSIX)** Re-entrant version of strftime().** RETURNS:*/LOCAL size_t strftime_r    (    char *            bufHd,		/* string array */    size_t            bufMaxSz,		/* maximum size of array */    const char *      fmtHd,		/* format of output string */    const struct tm * tmptr, 		/* broken-down time */    TIMELOCALE *      timeInfo		/* locale information */    )    {    const char *      fmt = fmtHd;    char *            buffer = bufHd;    char              addOn[MaxBufferSize];    int               bufLen = 0;    int               bufszNow = 0;        FOREVER       	{       	while ((*fmt != '%') && (bufszNow != bufMaxSz) && (*fmt != EOS))	    {    	    bufszNow++; 	    *buffer++ = *fmt++;	    }       	if (bufszNow == bufMaxSz) 	    break;       	if (*fmt++ != EOS)	    {	    __generateTime (addOn, tmptr, timeInfo, &bufLen, fmt);	    if (bufLen >= 0)	        {	        if (bufMaxSz > (bufszNow + bufLen))	            {	            memcpy (buffer, addOn, bufLen);	 	    bufszNow += bufLen;		    buffer += bufLen;		    fmt++;		    } /* endif */	        else 		    {		    memcpy (buffer, addOn, bufMaxSz - bufszNow);		    buffer += (bufMaxSz - bufszNow);		    bufszNow = bufMaxSz;		    break;		    }		}		    else 	        { /* process format strings */		*(addOn + abs (bufLen)) = EOS; 		/* This is recursive - but should recurse ONCE only */	        bufLen = (int) strftime_r (buffer, 					   bufMaxSz - bufszNow, 					   addOn, 					   tmptr, 					   timeInfo);	        buffer += bufLen;	        bufszNow += bufLen;	        fmt++;	        } /* endif */		     }	 else break;         } /* end forever */    *buffer = EOS;    return (bufszNow);    }/********************************************************************************* __generateTime - generate a string representing the format indicator.** Internal routine** RETURNS:* NOMANUAL*/LOCAL void __generateTime    (    char *            addOn,	/* string buffer */    const struct tm * tmptr, 	/* broken-down time */    TIMELOCALE *      timeInfo,	/* locale information */    int *             pnum,	/* position number for strftime string */    const char *      fmt	/* format to be decoded */    )    {    switch (*fmt)     	{        case 'a':	/* day */    	    __getDay (addOn, tmptr->tm_wday, ABBR, timeInfo, pnum);     	    break;        case 'A':	/* day */    	    __getDay (addOn, tmptr->tm_wday, FULL, timeInfo, pnum);     	    break;        case 'b':	/* month */    	    __getMonth (addOn, tmptr->tm_mon, ABBR, timeInfo, pnum);     	    break;        case 'B':	/* month */    	    __getMonth (addOn, tmptr->tm_mon, FULL, timeInfo, pnum);    	    break;        case 'c': 	/* date and time */    	    __getLocale (addOn, DATETIME, tmptr, timeInfo, pnum);    	    *pnum = -*pnum;    	    break;        case 'd': 	/* day of month */    	    __intToStr (addOn, tmptr->tm_mday, *pnum = 2);     	    break;        case 'H':	/* hour */    	    __intToStr (addOn, tmptr->tm_hour, *pnum = 2);     	    break;        case 'I':	/* hour */    	    __intToStr (addOn, tmptr->tm_hour % 12, *pnum = 2);     	    break;        case 'j':	/* day of year */    	    __intToStr (addOn, tmptr->tm_yday + 1, *pnum = 3);     	    break;        case 'm':	/* month */    	    __intToStr (addOn, tmptr->tm_mon + 1, *pnum = 2);     	    break;        case 'M':	/* minute */    	    __intToStr (addOn, tmptr->tm_min, *pnum = 2);     	    break;        case 'p':	/* AP/PM */    	    __getLocale (addOn, AMPM, tmptr, timeInfo, pnum);    	    break;        case 'S':	/* second */    	    __intToStr (addOn, tmptr->tm_sec, *pnum = 2);        	    break;        case 'U':	/* week number */            __intToStr (addOn, 			__weekOfYear(TM_SUNDAY, tmptr->tm_wday, tmptr->tm_yday),			*pnum = 2);    	    break;        case 'w':	/* weekday */    	    __intToStr (addOn, tmptr->tm_wday, *pnum = 1);     	    break;        case 'W':	/* week number */    	    __intToStr (addOn,     		        __weekOfYear(TM_MONDAY, tmptr->tm_wday, tmptr->tm_yday),     	                *pnum = 2);    	    break;        case 'x':	/* date */    	    __getLocale (addOn, DATE, tmptr, timeInfo, pnum);    	    *pnum = -*pnum;    	    break;        case 'X':	/* time */    	    __getLocale (addOn, TIMEO, tmptr, timeInfo, pnum);       	    *pnum = -*pnum;    	    break;        case 'y':	/* year */    	    __intToStr (addOn, (tmptr->tm_year % CENTURY), *pnum = 2);    	    break;        case 'Y':	/* year */    	    __intToStr (addOn, (tmptr->tm_year + TM_YEAR_BASE), *pnum = 4);    	    break;        case 'Z':	/* zone */    	    __getLocale (addOn, ZONE, tmptr, timeInfo, pnum);    	    break;        case '%':	/* % */    	    memcpy (addOn, CHAR_FROM_CONST ("%"), 1); 	    *pnum = 1;     	    break;        default:    	    *pnum = 0;    	    break;    	}    }/********************************************************************************* __weekOfYear - calulate week of year given julian day and week day.** Internal routine* The <start> determins whether the week starts on Sunday or Monday.** RETURNS:	week of year * NOMANUAL*/LOCAL int __weekOfYear    (    int start,  /* either TM_SUNDAY or TM_MONDAY */    int wday,   /* days since sunday */    int yday    /* days since Jan 1 */    )    {    wday = (wday - start + DAYSPERWEEK) % DAYSPERWEEK;    return ((yday - wday + 12) / DAYSPERWEEK - 1);    }/********************************************************************************* __getLocale - determine locale information given an indicator or the*		   type of information needed.** Internal routine** RETURNS: void* NOMANUAL*/LOCAL void __getLocale    (    char *	      buffer,		/* buffer for the string */    int               desc, 		/* descriptor */    const struct tm * tmptr, 		/* broken-down time */    TIMELOCALE *      timeInfo,		/* locale information */    int *             size		/* size of array returned */    )    {    char *	      p = NULL;    char 	      zoneBuf [sizeof (ZONEBUFFER)];    switch(desc)    	{        case DATETIME:    	    p = timeInfo->_Format [DATETIME];             break;        case DATE:    	    p = timeInfo->_Format [DATE];             break;        case TIMEO:    	    p = timeInfo->_Format [TIMEO];             break;        case AMPM:    	    p = timeInfo->_Ampm [(tmptr->tm_hour <= 12) ? 0 : 1];            break;        case ZONE:    	    (void) __getZoneInfo (zoneBuf, NAME, timeInfo);	    p = zoneBuf;            break;    	}    *size = strlen (p);    strcpy(buffer, p);    }/********************************************************************************* __intToStr - convert an integer into a string of <sz> size with leading *		  zeroes if neccessary.** Internal routine** RETURNS: void* NOMANUAL*/LOCAL void __intToStr    (    char * buffer,	/* buffer for return string */    int    number,	/* the number to be converted */    int    size		/* size of the string, maximum length of 4 */    )    {    if (number < 0) 	number = 0;    for (buffer += size; 0 <= --size; number /= 10)	{	*--buffer = number % 10 + '0';	}    }/********************************************************************************* __getDay - determine the locale representation of the day of the week** RETURNS: void* NOMANUAL*/LOCAL void __getDay    (    char *       buffer,	/* buffer for return string */    int          index, 	/* integer representation of day of the week */    int          abbr,		/* abbrievation or full spelling */    TIMELOCALE * timeInfo,	/* locale information */    int *        size		/* size of the string returned */    )    {    char *       dayStr;    index += (abbr == ABBR) ? 0 : DAYSPERWEEK;    *size = strlen (dayStr = timeInfo->_Days [index]);    strcpy (buffer, dayStr);    }/********************************************************************************* __getMonth - determine the locale representation of the month of the year ** RETURNS: void* NOMANUAL*/LOCAL void __getMonth    (    char *       buffer,	/* buffer for return string */    int          index, 	/* integer representation of month of year */    int          abbr,		/* abbrievation or full spelling */    TIMELOCALE * timeInfo,	/* locale information */    int *        size		/* size of the string returned */    )    {    char *       monStr;    index += (abbr == ABBR) ? 0 : MONSPERYEAR;    *size = strlen (monStr = timeInfo->_Months [index]);    strcpy (buffer, monStr);    }/********************************************************************************  __getDstInfo - determins whether day light savings is in effect.** TIMEZONE is of the form *     <name of zone>::<time in minutes from UTC>:<daylight start>:<daylight end>**	daylight information is expressed as mmddhh ie. month:day:hour**	e.g. UTC::0:040102:100102** RETURNS: FALSE if not on, TRUE otherwise.* NOMANUAL*/int __getDstInfo	    (    struct tm *  timeNow,     TIMELOCALE * timeInfo    )    {    char *       start = NULL;    char *       end = NULL;    char *       dummy = NULL;    char *       envInfo = NULL;    char *       last = "";    int          monStart = 0;    int          monEnd   = 0;    int          dayStart = 0;    int          dayEnd   = 0;    int          hrStart  = 0;    int          hrEnd    = 0;    char         numstr [2];    char         buffer [sizeof (ZONEBUFFER)];    /* Is daylight saving in effect? '0' NO; '>0' YES; '<0' don't know */    /* commented out (SPR #2521)    if (timeNow->tm_isdst != -1)         return (FALSE);    */    /* Is dst information stored in environmental variables */    if ((envInfo = getenv("TIMEZONE")) != NULL)     	{	strcpy (buffer, envInfo);    	dummy = strtok_r (buffer, ":", &last); 			/* next */    	dummy = strtok_r (NULL, ":", &last);   			/* next */    	/* commented out (SPR #2521) *//*     	dummy = strtok_r (NULL, ":", &last);   			/@ next */    	start = strtok_r (NULL, ":", &last); 			/* start time */    	end = strtok_r (NULL, ":", &last);   			/* end time */    	}    else    	{    	/* Is dst information stored in the locale tables */    	start = timeInfo->_Isdst[DSTON];    	end = timeInfo->_Isdst[DSTOFF];    	if ((strcmp (start,"") == 0) || (strcmp (end,"") == 0))    	    return (FALSE);    	}    if ((start == NULL) || (end == NULL))         return (FALSE);    /* analyze the dst information of the form 'mmddhh' */    monStart = (atoi (strncpy (numstr, start, 2))) - 1;       	/*start month */    monEnd = atoi (strncpy (numstr, end, 2)) - 1;           	/* end month */    if ((timeNow->tm_mon < monStart) || (timeNow->tm_mon > monEnd))     	return (FALSE);    if ((timeNow->tm_mon == monStart) || (timeNow->tm_mon == monEnd))    	{    	dayStart = atoi (strncpy (numstr, start+2, 2)); 	/* start day */    	dayEnd = atoi (strncpy (numstr, end+2, 2));     	/* end day */    	if (((timeNow->tm_mon == monStart) && (timeNow->tm_mday < dayStart)) ||     	    ((timeNow->tm_mon == monEnd) && (timeNow->tm_mday > dayEnd)))     	    return (FALSE);    	if (((timeNow->tm_mon == monStart) && (timeNow->tm_mday == dayStart)) ||    	    ((timeNow->tm_mon == monEnd) && (timeNow->tm_mday == dayEnd)))     	    {    	    hrStart = atoi (strncpy (numstr, start+4, 2)); 	/* hour */    	    hrEnd = atoi (strncpy (numstr, end+4, 2));     	/* hour */    	    return ((((timeNow->tm_mon==monStart) &&    		     (timeNow->tm_mday==dayStart) &&    		     (timeNow->tm_hour < hrStart)) ||    		    ((timeNow->tm_mon == monEnd) &&    		     (timeNow->tm_mday==dayEnd) &&    		     (timeNow->tm_hour > hrEnd)))    		   ? FALSE : TRUE);    	    }    	}    return (TRUE);    }/********************************************************************************  __getZoneInfo - determins in minutes the time difference from UTC.** If the environment variable TIMEZONE is set then the information is* retrieved from this variable, otherwise from the locale information.** RETURNS: time in minutes from UTC.* NOMANUAL*/void __getZoneInfo    (    char *       buffer,    int          option, 	/* determine which part of zone information */    TIMELOCALE * timeInfo	/* locale information */    )    {    char *       envInfo;    char *       limitStartPtr;    char *       limitEndPtr;    /* Time zone information from the environment variable */    envInfo = getenv ("TIMEZONE");     if ((envInfo != NULL) && (strcmp (envInfo, "") != 0))     	{	limitEndPtr = strpbrk (envInfo, ":");	if (option == NAME)	    {	    strcpy (buffer, envInfo);	    *(buffer + (limitEndPtr - envInfo)) = EOS;	    return;	    }	limitStartPtr = limitEndPtr + 1;	limitEndPtr = strpbrk (limitStartPtr, ":"); 	if (option == NAME2)	    {	    strcpy (buffer, limitStartPtr);	    *(buffer + (limitEndPtr - limitStartPtr)) = EOS;	    return;	    }	limitStartPtr = limitEndPtr + 1;	limitEndPtr = strpbrk (limitStartPtr, ":"); 	if (option == TIMEOFFSET)	    {	    strcpy (buffer, limitStartPtr);	    if (limitEndPtr != NULL)	        *(buffer + (limitEndPtr - limitStartPtr)) = EOS;	    return;	    }    	}    else	{        /* Time zone information from the locale table */        if (strcmp (timeInfo->_Zone [option], "") != 0)	    strcpy(buffer,timeInfo->_Zone [option]);        else	             *buffer = EOS;        }    }/* time.c - time file for time *//* Copyright 1992-1993 Wind River Systems, Inc. *//*modification history--------------------01c,05feb93,jdi  documentation cleanup for 5.1.01b,20sep92,smb  documentation additions01a,25jul92,smb  written.*//*  DESCRIPTION    INCLUDE FILE: time.h   SEE ALSO: American National Standard X3.159-1989 NOMANUAL*/#include "vxWorks.h"#include "time.h"#include "timers.h"/****************************************************************************** time - determine the current calendar time (ANSI)** This routine returns the implementation's best approximation of current* calendar time in seconds.  If <timer> is non-NULL, the return value is* also copied to the location <timer> points to.** INTERNAL* Uses the POSIX clockLib functions.* Does this return the number of seconds since the BOARD was booted?** INCLUDE FILES: time.h** RETURNS:* The current calendar time in seconds, or ERROR (-1) if the calendar time* is not available.** SEE ALSO: clock_gettime()*/ time_t time    (    time_t *timer	/* calendar time in seconds */    )    {    struct timespec tp;    if (clock_gettime (CLOCK_REALTIME, &tp) == 0)	{	if (timer != NULL)	    *timer = (time_t) tp.tv_sec;	return (time_t) (tp.tv_sec);	}    else	return (time_t) (ERROR);    }