Subversion Repositories openrisc

/* Convert a string representation of time to a time value.

   Copyright (C) 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.

   This file is part of the GNU C Library.

   Contributed by Mark Kettenis <kettenis@phys.uva.nl>, 1997.

   The GNU C Library is free software; you can redistribute it and/or

   modify it under the terms of the GNU Lesser General Public

   License as published by the Free Software Foundation; either

   version 2.1 of the License, or (at your option) any later version.

   The GNU C 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

   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public

   License along with the GNU C Library; if not, write to the Free

   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA

   02111-1307 USA.  */

/*

FUNCTION

<<getdate>>,<<getdate_r>>---convert a string representation of time to a time value

INDEX

        getdate

INDEX

        getdate_r

ANSI_SYNOPSIS

        #include <time.h>

        struct tm *getdate(const char *<[string]>);

        int getdate_r(const char *<[string]>, struct tm *<[res]>);

TRAD_SYNOPSIS

        #include <time.h>

        struct tm *getdate(<[string]>);

        const char *<[string]>;

        int getdate_r(<[string]>, <[res]>);

        const char *<[string]>;

        struct tm *<[res]>;

DESCRIPTION

<<getdate>> reads a file which is specified by the environment variable:

DATEMSK.  This file contains a number of formats valid for input to the

<<strptime>> function.  The input <[string]> is used as input to the format

strings and the first valid match that occurs is used.  The resultant

time struct is returned.  If an error occurs, the value <<getdate_err>> is

set to one of the following values.

     1  the DATEMSK environment variable is null or undefined,

     2  the template file cannot be opened for reading,

     3  failed to get file status information,

     4  the template file is not a regular file,

     5  an error is encountered while reading the template file,

     6  memory allication failed (not enough memory available),

     7  there is no line in the template that matches the input,

     8  invalid input specification

The <<getdate_r>> routine is similar, except that it returns the error

code and has the <[res]> time struct pointer passed in.  <<getdate>> is

non-reentrant.  Applications that wish to be reentrant should use

<<getdate_r>> instead of <<getdate>>.

RETURNS

<<getdate>> returns a pointer to the traditional time representation

(<<struct tm>>).  <<getdate_r>> returns 0 if successful, otherwise it

returns the error code.

PORTABILITY

<<getdate>> is defined by the Single Unix specification.

<<getdate_r>> is a reentrant extension.

<<getdate>> and <<getdate_r>> optionally require <<stat>> and <<access>>.

*/

/* Modified for newlib by Jeff Johnston, June 19/2002 */

#include <limits.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <time.h>

#include <unistd.h>

#include <sys/stat.h>

#if !defined(_ELIX_LEVEL) || _ELIX_LEVEL >= 2

# define STAT stat64

#else

# define STAT stat

#endif

#define TM_YEAR_BASE 1900

extern ssize_t __getline (char **, size_t *, FILE *);

/* Prototypes for local functions.  */

static int first_wday (int year, int mon, int wday);

static int check_mday (int year, int mon, int mday);

#define isleap(y) ((((y) % 4) == 0 && ((y) % 100) != 0) || ((y) % 400) == 0)

/* Error code is set to one of the following values to indicate an error.

     1  the DATEMSK environment variable is null or undefined,

     2  the template file cannot be opened for reading,

     3  failed to get file status information,

     4  the template file is not a regular file,

     5  an error is encountered while reading the template file,

     6  memory allication failed (not enough memory available),

     7  there is no line in the template that matches the input,

     8  invalid input specification Example: February 31 or a time is

        specified that can not be represented in a time_t (representing

        the time in seconds since 00:00:00 UTC, January 1, 1970) */

/* Returns the first weekday WDAY of month MON in the year YEAR.  */

static int

first_wday (int year, int mon, int wday)

{

  struct tm tm;

  if (wday == INT_MIN)

    return 1;

  memset (&tm, 0, sizeof (struct tm));

  tm.tm_year = year;

  tm.tm_mon = mon;

  tm.tm_mday = 1;

  mktime (&tm);

  return (1 + (wday - tm.tm_wday + 7) % 7);

}

/* Returns 1 if MDAY is a valid day of the month in month MON of year

   YEAR, and 0 if it is not.  */

static int

check_mday (int year, int mon, int mday)

{

  switch (mon)

    {

    case 0:

    case 2:

    case 4:

    case 6:

    case 7:

    case 9:

    case 11:

      if (mday >= 1 && mday <= 31)

        return 1;

      break;

    case 3:

    case 5:

    case 8:

    case 10:

      if (mday >= 1 && mday <= 30)

        return 1;

      break;

    case 1:

      if (mday >= 1 && mday <= (isleap (year) ? 29 : 28))

        return 1;

      break;

    }

  return 0;

}

int

getdate_r (const char *string, struct tm *tp)

{

  FILE *fp;

  char *line;

  size_t len;

  char *datemsk;

  char *result = NULL;

  time_t timer;

  struct tm tm;

  struct STAT st;

  int mday_ok = 0;

  datemsk = getenv ("DATEMSK");

  if (datemsk == NULL || *datemsk == '\0')

    return 1;

  if (STAT (datemsk, &st) < 0)

    return 3;

  if (!S_ISREG (st.st_mode))

    return 4;

  if (access (datemsk, R_OK) < 0)

    return 2;

  /* Open the template file.  */

  fp = fopen (datemsk, "r");

  if (fp == NULL)

    return 2;

  line = NULL;

  len = 0;

  do

    {

      ssize_t n;

      n = __getline (&line, &len, fp);

      if (n < 0)

        break;

      if (line[n - 1] == '\n')

        line[n - 1] = '\0';

      /* Do the conversion.  */

      tp->tm_year = tp->tm_mon = tp->tm_mday = tp->tm_wday = INT_MIN;

      tp->tm_hour = tp->tm_sec = tp->tm_min = INT_MIN;

      tp->tm_isdst = -1;

      result = strptime (string, line, tp);

      if (result && *result == '\0')

        break;

    }

  while (!__sfeof (fp));

  /* Free the buffer.  */

  free (line);

  /* Check for errors. */

  if (__sferror (fp))

    {

      fclose (fp);

      return 5;

    }

  /* Close template file.  */

  fclose (fp);

  if (result == NULL || *result != '\0')

    return 7;

  /* Get current time.  */

  time (&timer);

  localtime_r (&timer, &tm);

  /* If only the weekday is given, today is assumed if the given day

     is equal to the current day and next week if it is less.  */

  if (tp->tm_wday >= 0 && tp->tm_wday <= 6 && tp->tm_year == INT_MIN

      && tp->tm_mon == INT_MIN && tp->tm_mday == INT_MIN)

    {

      tp->tm_year = tm.tm_year;

      tp->tm_mon = tm.tm_mon;

      tp->tm_mday = tm.tm_mday + (tp->tm_wday - tm.tm_wday + 7) % 7;

      mday_ok = 1;

    }

  /* If only the month is given, the current month is assumed if the

     given month is equal to the current month and next year if it is

     less and no year is given (the first day of month is assumed if

     no day is given.  */

  if (tp->tm_mon >= 0 && tp->tm_mon <= 11 && tp->tm_mday == INT_MIN)

    {

      if (tp->tm_year == INT_MIN)

        tp->tm_year = tm.tm_year + (((tp->tm_mon - tm.tm_mon) < 0) ? 1 : 0);

      tp->tm_mday = first_wday (tp->tm_year, tp->tm_mon, tp->tm_wday);

      mday_ok = 1;

    }

  /* If no hour, minute and second are given the current hour, minute

     and second are assumed.  */

  if (tp->tm_hour == INT_MIN && tp->tm_min == INT_MIN && tp->tm_sec == INT_MIN)

    {

      tp->tm_hour = tm.tm_hour;

      tp->tm_min = tm.tm_min;

      tp->tm_sec = tm.tm_sec;

    }

  /* If no date is given, today is assumed if the given hour is

     greater than the current hour and tomorrow is assumed if

     it is less.  */

  if (tp->tm_hour >= 0 && tp->tm_hour <= 23

      && tp->tm_year == INT_MIN && tp->tm_mon == INT_MIN

      && tp->tm_mday == INT_MIN && tp->tm_wday == INT_MIN)

    {

      tp->tm_year = tm.tm_year;

      tp->tm_mon = tm.tm_mon;

      tp->tm_mday = tm.tm_mday + ((tp->tm_hour - tm.tm_hour) < 0 ? 1 : 0);

      mday_ok = 1;

    }

  /* Fill in the gaps.  */

  if (tp->tm_year == INT_MIN)

    tp->tm_year = tm.tm_year;

  if (tp->tm_hour == INT_MIN)

    tp->tm_hour = 0;

  if (tp->tm_min == INT_MIN)

    tp->tm_min = 0;

  if (tp->tm_sec == INT_MIN)

    tp->tm_sec = 0;

  /* Check if the day of month is within range, and if the time can be

     represented in a time_t.  We make use of the fact that the mktime

     call normalizes the struct tm.  */

  if ((!mday_ok && !check_mday (TM_YEAR_BASE + tp->tm_year, tp->tm_mon,

                                tp->tm_mday))

      || mktime (tp) == (time_t) -1)

    return 8;

  return 0;

}

#ifndef _REENT_ONLY

struct tm *

getdate (const char *string)

{

  /* Buffer returned by getdate.  */

  static struct tm tmbuf;

  int errval = getdate_r (string, &tmbuf);

  if (errval != 0)

    {

      getdate_err = errval;

      return NULL;

    }

  return &tmbuf;

}

#endif /* _REENT_ONLY */