ansitime.c

vxworks libc库源代码

    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 additions
01a,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);
    }