time.h

Go to the documentation of this file.

/*--------------------------------------------------------------------------------
 * /
 * / apeNEXT time functions for nlcc
 * /
 * / $Id: time.h,v 1.15 2005/10/27 20:04:45 morinl Exp $
 * /
 * /
 * / ISO/IEC 9899:1999 (E) Standard
 * / Date and Time  <time.h>
 * /
 * /
 * /
 * / IMPLEMENTATION for APEnext: partly possible (time.h)
 * /-----------------------------------------------------------------------------*/

#ifndef _TIME_H
#define _TIME_H

#include <nlibc.h>
#include <stddef.h>

/*--------------------------------------------------------------------------------
 * /
 * / NULL will be defined in <stddef.h>
 * /
 * /-----------------------------------------------------------------------------*/
/* #define NULL */


/*---------------------------------------------------------------------------------
 * /
 * / CLOCKS_PER_SEC is usually defined as 1000000l
 * /
 * /-----------------------------------------------------------------------------*/
#define CLOCKS_PER_SEC 1000000l


/*---------------------------------------------------------------------------------
 * /
 * / size_t will be defined in <stddef.h>
 * /
 * /-----------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------------
 * /
 * / clock_t will be defined in <stddef.h>
 * /
 * /-----------------------------------------------------------------------------*/
#ifndef _CLOCK_T
#define _CLOCK_T

typedef unsigned clock_t;

#endif

/*--------------------------------------------------------------------------------
 * /
 * / time_t will be defined in <stddef.h>
 * /
 * /-----------------------------------------------------------------------------*/
#ifndef _TIME_T
#define _TIME_T

typedef unsigned time_t;

#endif

/*---------------------------------------------------------------------------------
 * /
 * / The tm structure holds the components of a caledar time 
 * / (broken down time)
 * /
 * / IMPLEMENTATION for APEnext: possible (struct tm)
 * /------------------------------------------------------------------------------*/
struct tm 
{
  int tm_sec;                   /* Seconds.     [0-60] (1 leap second) */
  int tm_min;                   /* Minutes.     [0-59] */
  int tm_hour;                  /* Hours.       [0-23] */
  int tm_mday;                  /* Day.         [1-31] */
  int tm_mon;                   /* Month.       [0-11] */
  int tm_year;                  /* Year - 1900.  */
  int tm_wday;                  /* Day of week. [0-6] */
  int tm_yday;                  /* Days in year.[0-365] */
  int tm_isdst;                 /* DST.         [-1/0/1]*/
};

/*---------------------------------------------------------------------------------
 * / 
 * / NAME
 * /         clock - Determine processor time
 * / 
 * / SYNOPSIS
 * /        #include <time.h>
 * / 
 * /       clock_t clock(void);
 * / 
 * / DESCRIPTION
 * /        The clock() function returns an approximation of processor 
 * /       time used by the program.
 * / 
 * / RETURN VALUE
 * /        The  value returned is the CPU time used so far as a clock_t; 
 * /       to get the number of seconds used, divide by CLOCKS_PER_SEC.  
 * /       If the processor time used is  not  available or its value 
 * /       cannot be represented, the function returns the value (clock_t)-1.
 * / 
 * / IMPLEMENTATION for APEnext: possible (clock)
 * / 
 * / ---------------------------------------------------------------------------*/
#ifndef __HAS_MAIN
extern clock_t clock(void);
#else
#if !defined(__cflow_processed) || defined(_uses_clock_time_h)
clock_t clock(void)
{
        return 0;
}
#endif
#endif // Has Main

/*--------------------------------------------------------------------------------
 * / 
 * / NAME
 * /        difftime - calculate time difference
 * / 
 * / SYNOPSIS
 * /        #include <time.h>
 * / 
 * /        double difftime(time_t time1, time_t time0);
 * / 
 * / DESCRIPTION
 * /        The  difftime() function returns the number of seconds 
 * /        elapsed between time time1 and time time0. The two times are 
 * /        specified in calendar time, which  represents  the  time
 * /        elapsed since 00:00:00 on January 1, 1970, Coordinated 
 * /        Universal Time (UTC).
 * / 
 * / IMPLEMENTATION for APEnext: possible (difftime)
 * / 
 * / ----------------------------------------------------------------------------*/
#if !defined(__cflow_processed) || defined(_uses_difftime_time_h)
inline double difftime(time_t time1, time_t time0)
{
        return (double)(time1-time0);
}
#endif

/*--------------------------------------------------------------------------------
 * /
 * / NAME
 * /        mktime - transforms broken-down time to calendar time
 * / 
 * / SYNOPSIS
 * /        #include <time.h>
 * / 
 * /        time_t mktime(struct tm *timeptr);
 * / 
 * / DESCRIPTION
 * /       The mktime() function converts a broken-down time structure, 
 * /       expressed as  local  time, to  calendar  time  representation.  
 * /       The function ignores the specified contents of the structure 
 * /       members tm_wday and tm_yday and recomputes them from the other 
 * /       information in the broken-down time structure.  If structure 
 * /       members are outside their legal interval, they will be normalized 
 * /       (so that, e.g., 40 October is changed into 9 November). 
 * /       Calling mktime() also sets the external variable tzname with 
 * /       information about the current time zone.  If the specified 
 * /       broken-down time cannot be represented  as  calendar  time 
 * /       (seconds  since the epoch), mktime() returns a value of 
 * /       (time_t)(-1) and does not alter the tm_wday and tm_yday members 
 * /       of the broken-down time structure.
 * / 
 * / 
 * / IMPLEMENTATION for APEnext: possible (mktime)
 * /  
 * / ---------------------------------------------------------------------------*/
#ifndef __HAS_MAIN
extern time_t mktime(struct tm *timeptr);
#else
#if !defined(__cflow_processed) || defined(_uses_mktime_time_h)
time_t mktime(struct tm *timeptr)
{
        return 0;
}
#endif
#endif // Has Main

/*--------------------------------------------------------------------------------
 * / 
 * / NAME
 * /        time - get time in seconds
 * / 
 * / SYNOPSIS
 * /        #include <time.h>
 * / 
 * /        time_t time(time_t *t);
 * / 
 * / DESCRIPTION
 * /        time returns the time since the Epoch (00:00:00 UTC, January 1, 1970),
 * /        measured in seconds.
 * / 
 * /        If t is non-NULL, the return value is also stored in the 
 * /       memory pointed to by t.
 * / 
 * / RETURN VALUE
 * /       On success, the value of time in seconds  since  the  Epoch  
 * /       is  returned.   On  error,
 * /       ((time_t)-1) is returned, and errno is set appropriately.
 * / 
 * / ERRORS
 * /        EFAULT t points outside your accessible address space.
 * / 
 * /  
 * / IMPLEMENTATION for APEnext: possible (?) (time)
 * / 
 * / ---------------------------------------------------------------------------*/
#ifndef __HAS_MAIN
extern time_t time(time_t *timer);
#else
#if !defined(__cflow_processed) || defined(_uses_time_time_h)
time_t time(time_t *timer)
{
        return 0;
}
#endif
#endif // Has Main

/*-------------------------------------------------------------------------------
 * / 
 * / NAME
 * /       asctime - transforms broken-down time to a string
 * /  
 * / SYNOPSIS
 * /       #include <time.h>
 * /
 * /       char *asctime(const struct tm *timeptr);
 * /
 * / DESCRIPTION
 * /       The asctime() function converts the broken-down time value 
 * /       timeptr into a  string  with the  same  format as ctime().  
 * /       The return value points to a statically allocated string 
 * /       which might be overwritten by subsequent calls to any of 
 * /       the date and time functions.
 * /
 * / IMPLEMENTATION for APEnext: possible if strings are implemented (asctime)
 * / 
 * / ---------------------------------------------------------------------------*/
#ifndef __HAS_MAIN
extern char *asctime(const struct tm *timeptr);
#else
#if !defined(__cflow_processed) || defined(_uses_asctime_time_h)
char *asctime(const struct tm *timeptr)
{
        return NULL;
}
#endif
#endif // Has Main

/*--------------------------------------------------------------------------------
 * / 
 * / NAME
 * /       ctime - transforms calendar time into a string
 * /  
 * / SYNOPSIS
 * /       #include <time.h>
 * /
 * /       char *ctime(const time_t *timer)
 * /
 * / DESCRIPTION
 * /       The ctime() function converts the calendar time timep into a 
 * /       string of the form   "Wed Jun 30 21:49:08 1993\n"
 * /
 * /       The  abbreviations  for  the  days  of  the week are `Sun', 
 * /       `Mon', `Tue', `Wed', `Thu', `Fri', and `Sat'.  The abbreviations 
 * /       for the months are  `Jan',  `Feb',  `Mar',  `Apr', `May', `Jun', 
 * /       `Jul', `Aug', `Sep', `Oct', `Nov', and `Dec'.  The return value 
 * /       points to  a statically allocated string which might be 
 * /       overwritten by subsequent calls to any  of the  date and time 
 * /       functions.  The function also sets the external variable tzname 
 * /       with information about the current time zone.
 * /
 * /
 * / IMPLEMENTATION for APEnext: possible if strings are implemented (ctime)
 * / 
 * / ---------------------------------------------------------------------------*/
#ifndef __HAS_MAIN
extern char *ctime(const time_t *timer);
#else
#if !defined(__cflow_processed) || defined(_uses_ctime_time_h)
char *ctime(const time_t *timer)
{
        return NULL;
}
#endif
#endif // Has Main

/*--------------------------------------------------------------------------------
 * / 
 * / NAME
 * /       gmtime - transforms calendar time to broken-down time
 * /  
 * / SYNOPSIS
 * /       #include <time.h>
 * / 
 * /        struct tm *gmtime(const time_t *timep);
 * /
 * / DESCRIPTION
 * /       The gmtime() function converts the calendar time timep to 
 * /       broken-down time
 * /       representation, expressed in Coordinated Universal Time (UTC).
 * / 
 * / IMPLEMENTATION for APEnext: possible (gmtime)
 * / 
 * / ---------------------------------------------------------------------------*/
#ifndef __HAS_MAIN
extern struct tm *gmtime(const time_t *timer);
#else
#if !defined(__cflow_processed) || defined(_uses_gmtime_time_h)
struct tm *gmtime(const time_t *timer)
{
        return NULL;
}
#endif
#endif // Has Main

/*-------------------------------------------------------------------------------
 * / 
 * / NAME
 * /       localtime - transforms calendar time to broken time relative 
 * /       to specified time zone
 * / 
 * / SYNOPSIS
 * /        #include <time.h>
 * / 
 * /        struct tm *localtime(const time_t *timep);
 * / 
 * / DESCRIPTION
 * /       The  localtime()  function  converts the calendar time timep 
 * /       to broken-time representation, expressed relative to the user's 
 * /       specified time zone.    The  function  sets  the external  
 * /       variables  tzname with information about the current time zone, 
 * /       timezone with the difference between Coordinated Universal Time 
 * /       (UTC) and local standard time in seconds,  and  daylight  to  
 * /       a  non-zero  value if standard US daylight savings time rules
 * /        apply.
 * / 
 * / IMPLEMENTATION for APEnext: possible (localtime)
 * / 
 * / ---------------------------------------------------------------------------*/
#ifndef __HAS_MAIN
extern struct tm *localtime(const time_t *timer);
#else
#if !defined(__cflow_processed) || defined(_uses_localtime_time_h)
struct tm *localtime(const time_t *timer)
{
        return NULL;
}
#endif
#endif // Has Main

/*--------------------------------------------------------------------------------
 * / 
 * / NAME
 * /        strftime - format date and time
 * / 
 * / SYNOPSIS
 * /        #include <time.h>
 * / 
 * /        size_t strftime(char *s, size_t max, const char *format,
 * /                            const struct tm *tm);
 * / 
 * / DESCRIPTION
 * /       The  strftime() function formats the broken-down time tm according 
 * /       to the format specification format and places the result in the 
 * /       character array s of size max.
 * / 
 * / IMPLEMENTATION for APEnext: possible if strings are implemented (strftime)
 * / 
 * / ----------------------------------------------------------------------------*/
#ifndef __HAS_MAIN
extern size_t strftime(char * restrict s, size_t maxsize, const char * restrict format);
#else
#if !defined(__cflow_processed) || defined(_uses_strftime_time_h)
size_t strftime(char * restrict s, size_t maxsize, const char * restrict format,
                const struct tm * restrict timeptr)
{
        return 0;
}
#endif
#endif // Has Main

#endif /* ifndef _TIME_H  */

---