usr/src/cmd/mdb/common/libstand/ctime.c

   1 /*
   2  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
   3  * Use is subject to license terms.
   4  */
   5
   6 /*
   7  * Copyright (c) 1980 Regents of the University of California.
   8  * All rights reserved. The Berkeley software License Agreement
   9  * specifies the terms and conditions for redistribution.
  10  */
  11
  12 /*
  13  * This localtime is a modified version of offtime from libc, which does not
  14  * bother to figure out the time zone from the kernel, from environment
  15  * variables, or from Unix files.
  16  */
  17
  18 #include <sys/types.h>
  19 #include <sys/salib.h>
  20 #include <tzfile.h>
  21 #include <errno.h>
  22
  23 static int mon_lengths[2][MONS_PER_YEAR] = {
  24         31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31,
  25         31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
  26 };
  27
  28 static int year_lengths[2] = {
  29         DAYS_PER_NYEAR, DAYS_PER_LYEAR
  30 };
  31
  32 struct tm *
  33 localtime(const time_t *clock)
  34 {
  35         struct tm *tmp;
  36         long days;
  37         long rem;
  38         int y;
  39         int yleap;
  40         int *ip;
  41         static struct tm tm;
  42
  43         tmp = &tm;
  44         days = *clock / SECS_PER_DAY;
  45         rem = *clock % SECS_PER_DAY;
  46         while (rem < 0) {
  47                 rem += SECS_PER_DAY;
  48                 --days;
  49         }
  50         while (rem >= SECS_PER_DAY) {
  51                 rem -= SECS_PER_DAY;
  52                 ++days;
  53         }
  54         tmp->tm_hour = (int)(rem / SECS_PER_HOUR);
  55         rem = rem % SECS_PER_HOUR;
  56         tmp->tm_min = (int)(rem / SECS_PER_MIN);
  57         tmp->tm_sec = (int)(rem % SECS_PER_MIN);
  58         tmp->tm_wday = (int)((EPOCH_WDAY + days) % DAYS_PER_WEEK);
  59         if (tmp->tm_wday < 0)
  60                 tmp->tm_wday += DAYS_PER_WEEK;
  61         y = EPOCH_YEAR;
  62         if (days >= 0) {
  63                 for (;;) {
  64                         yleap = isleap(y);
  65                         if (days < (long)year_lengths[yleap])
  66                                 break;
  67                         if (++y > 9999) {
  68                                 errno = EOVERFLOW;
  69                                 return (NULL);
  70                         }
  71                         days = days - (long)year_lengths[yleap];
  72                 }
  73         } else {
  74                 do {
  75                         if (--y < 0) {
  76                                 errno = EOVERFLOW;
  77                                 return (NULL);
  78                         }
  79                         yleap = isleap(y);
  80                         days = days + (long)year_lengths[yleap];
  81                 } while (days < 0);
  82         }
  83         tmp->tm_year = y - TM_YEAR_BASE;
  84         tmp->tm_yday = (int)days;
  85         ip = mon_lengths[yleap];
  86         for (tmp->tm_mon = 0; days >= (long)ip[tmp->tm_mon]; ++(tmp->tm_mon))
  87                 days = days - (long)ip[tmp->tm_mon];
  88         tmp->tm_mday = (int)(days + 1);
  89         tmp->tm_isdst = 0;
  90
  91         return (tmp);
  92 }
  93
  94 /*
  95  * So is ctime...
  96  */
  97
  98 /*
  99  * This routine converts time as follows.
 100  * The epoch is 0000 Jan 1 1970 GMT.
 101  * The argument time is in seconds since then.
 102  * The localtime(t) entry returns a pointer to an array
 103  * containing
 104  *  seconds (0-59)
 105  *  minutes (0-59)
 106  *  hours (0-23)
 107  *  day of month (1-31)
 108  *  month (0-11)
 109  *  year-1970
 110  *  weekday (0-6, Sun is 0)
 111  *  day of the year
 112  *  daylight savings flag
 113  *
 114  * The routine corrects for daylight saving
 115  * time and will work in any time zone provided
 116  * "timezone" is adjusted to the difference between
 117  * Greenwich and local standard time (measured in seconds).
 118  * In places like Michigan "daylight" must
 119  * be initialized to 0 to prevent the conversion
 120  * to daylight time.
 121  * There is a table which accounts for the peculiarities
 122  * undergone by daylight time in 1974-1975.
 123  *
 124  * The routine does not work
 125  * in Saudi Arabia which runs on Solar time.
 126  *
 127  * asctime(tvec)
 128  * where tvec is produced by localtime
 129  * returns a ptr to a character string
 130  * that has the ascii time in the form
 131  *      Thu Jan 01 00:00:00 1970\n\0
 132  *      01234567890123456789012345
 133  *      0         1         2
 134  *
 135  * ctime(t) just calls localtime, then asctime.
 136  *
 137  * tzset() looks for an environment variable named
 138  * TZ.
 139  * If the variable is present, it will set the external
 140  * variables "timezone", "altzone", "daylight", and "tzname"
 141  * appropriately. It is called by localtime, and
 142  * may also be called explicitly by the user.
 143  */
 144
 145
 146
 147 #define dysize(A) (((A)%4)? 365: 366)
 148 #define CBUFSIZ 26
 149
 150 static char *ct_numb();
 151
 152 char *
 153 asctime_r(const struct tm *t, char *cbuf)
 154 {
 155         const char *Date = "Day Mon 00 00:00:00 1900\n";
 156         const char *Day  = "SunMonTueWedThuFriSat";
 157         const char *Month = "JanFebMarAprMayJunJulAugSepOctNovDec";
 158         const char *ncp;
 159         const int *tp;
 160         char *cp;
 161
 162         if (t == NULL)
 163                 return (NULL);
 164
 165         cp = cbuf;
 166         for (ncp = Date; *cp++ = *ncp++; /* */)
 167                 ;
 168         ncp = Day + (3*t->tm_wday);
 169         cp = cbuf;
 170         *cp++ = *ncp++;
 171         *cp++ = *ncp++;
 172         *cp++ = *ncp++;
 173         cp++;
 174         tp = &t->tm_mon;
 175         ncp = Month + ((*tp) * 3);
 176         *cp++ = *ncp++;
 177         *cp++ = *ncp++;
 178         *cp++ = *ncp++;
 179         cp = ct_numb(cp, *--tp);
 180         cp = ct_numb(cp, *--tp+100);
 181         cp = ct_numb(cp, *--tp+100);
 182         cp = ct_numb(cp, *--tp+100);
 183         if (t->tm_year > 9999) {
 184                 errno = EOVERFLOW;
 185                 return (NULL);
 186         } else {
 187                 uint_t hun = 19 + (t->tm_year / 100);
 188                 cp[1] = (hun / 10) + '0';
 189                 cp[2] = (hun % 10) + '0';
 190         }
 191         cp += 2;
 192         cp = ct_numb(cp, t->tm_year+100);
 193         return (cbuf);
 194 }
 195
 196 char *
 197 ctime(const time_t *t)
 198 {
 199         return (asctime(localtime(t)));
 200 }
 201
 202
 203 char *
 204 asctime(const struct tm *t)
 205 {
 206         static char cbuf[CBUFSIZ];
 207
 208         return (asctime_r(t, cbuf));
 209 }
 210
 211
 212 static char *
 213 ct_numb(char *cp, int n)
 214 {
 215         cp++;
 216         if (n >= 10)
 217                 *cp++ = (n/10)%10 + '0';
 218         else
 219                 *cp++ = ' ';            /* Pad with blanks */
 220         *cp++ = n%10 + '0';
 221         return (cp);
 222 }