UNIX 6th Ed. - /usr/source/s4/ctime.c

   1: #
   2: /*
   3:  * This routine converts time as follows.
   4:  * The epoch is 0000 Jan 1 1970 GMT.
   5:  * The argument time is in seconds since then.
   6:  * The localtime(t) entry returns a pointer to an array
   7:  * containing
   8:  *  seconds (0-59)
   9:  *  minutes (0-59)
  10:  *  hours (0-23)
  11:  *  day of month (1-31)
  12:  *  month (0-11)
  13:  *  year-1970
  14:  *  weekday (0-6, Sun is 0)
  15:  *  day of the year
  16:  *  daylight savings flag
  17:  *
  18:  * The routine corrects for daylight saving
  19:  * time and will work in any time zone provided
  20:  * "timezone" is adjusted to the difference between
  21:  * Greenwich and local standard time (measured in seconds).
  22:  * In places like Michigan "daylight" must
  23:  * be initialized to 0 to prevent the conversion
  24:  * to daylight time.
  25:  * There is a table which accounts for the peculiarities
  26:  * undergone by daylight time in 1974-1975.
  27:  *
  28:  * The routine does not work
  29:  * in Saudi Arabia which runs on Solar time.
  30:  *
  31:  * asctime(tvec))
  32:  * where tvec is produced by localtime
  33:  * returns a ptr to a character string
  34:  * that has the ascii time in the form
  35:  *	Thu Jan 01 00:00:00 1970n0\\
  36:  *	01234567890123456789012345
  37:  *	0	  1	    2
  38:  *
  39:  * ctime(t) just calls localtime, then asctime.
  40:  */
  41: char    cbuf[26];
  42: int dmsize[12]
  43: {
  44:     31,
  45:     28,
  46:     31,
  47:     30,
  48:     31,
  49:     30,
  50:     31,
  51:     31,
  52:     30,
  53:     31,
  54:     30,
  55:     31
  56: };
  57: 
  58: int timezone    5*60*60;
  59: int tzname[]
  60: {
  61:     "EST",
  62:     "EDT",
  63: };
  64: int daylight 1; /* Allow daylight conversion */
  65: /*
  66:  * The following table is used for 1974 and 1975 and
  67:  * gives the day number of the first day after the Sunday of the
  68:  * change.
  69:  */
  70: struct {
  71:     int daylb;
  72:     int dayle;
  73: } daytab[] {
  74:     5,  333,    /* 1974: Jan 6 - last Sun. in Nov */
  75:     58, 303,    /* 1975: Last Sun. in Feb - last Sun in Oct */
  76: };
  77: 
  78: #define SEC 0
  79: #define MIN 1
  80: #define HOUR    2
  81: #define MDAY    3
  82: #define MON 4
  83: #define YEAR    5
  84: #define WDAY    6
  85: #define YDAY    7
  86: #define ISDAY   8
  87: 
  88: ctime(at)
  89: int *at;
  90: {
  91:     return(asctime(localtime(at)));
  92: }
  93: 
  94: localtime(tim)
  95: int tim[];
  96: {
  97:     register int *t, *ct, dayno;
  98:     int daylbegin, daylend;
  99:     int copyt[2];
 100: 
 101:     t = copyt;
 102:     t[0] = tim[0];
 103:     t[1] = tim[1];
 104:     dpadd(t, -timezone);
 105:     ct = gmtime(t);
 106:     dayno = ct[YDAY];
 107:     daylbegin = 119;    /* last Sun in Apr */
 108:     daylend = 303;      /* Last Sun in Oct */
 109:     if (ct[YEAR]==74 || ct[YEAR]==75) {
 110:         daylbegin = daytab[ct[YEAR]-74].daylb;
 111:         daylend = daytab[ct[YEAR]-74].dayle;
 112:     }
 113:     daylbegin = sunday(ct, daylbegin);
 114:     daylend = sunday(ct, daylend);
 115:     if (daylight &&
 116:         (dayno>daylbegin || (dayno==daylbegin && ct[HOUR]>=2)) &&
 117:         (dayno<daylend || (dayno==daylend && ct[HOUR]<1))) {
 118:         dpadd(t, 1*60*60);
 119:         ct = gmtime(t);
 120:         ct[ISDAY]++;
 121:     }
 122:     return(ct);
 123: }
 124: 
 125: /*
 126:  * The argument is a 0-origin day number.
 127:  * The value is the day number of the first
 128:  * Sunday on or after the day.
 129:  */
 130: sunday(at, ad)
 131: int *at;
 132: {
 133:     register int *t, d;
 134: 
 135:     t = at;
 136:     d = ad;
 137:     if (d >= 58)
 138:         d =+ dysize(t[YEAR]) - 365;
 139:     return(d - (d - t[YDAY] + t[WDAY] + 700) % 7);
 140: }
 141: 
 142: gmtime(tim)
 143: int tim[];
 144: {
 145:     register int d0, d1;
 146:     register *tp;
 147:     static xtime[9];
 148:     extern int ldivr;
 149: 
 150:     /*
 151: 	 * break initial number into
 152: 	 * multiples of 8 hours.
 153: 	 * (28800 = 60*60*8)
 154: 	 */
 155: 
 156:     d0 = ldiv(tim[0], tim[1], 28800);
 157:     d1 = ldivr;
 158:     tp = &xtime[0];
 159: 
 160:     /*
 161: 	 * generate hours:minutes:seconds
 162: 	 */
 163: 
 164:     *tp++ = d1%60;
 165:     d1 =/ 60;
 166:     *tp++ = d1%60;
 167:     d1 =/ 60;
 168:     d1 =+ (d0%3)*8;
 169:     d0 =/ 3;
 170:     *tp++ = d1;
 171: 
 172:     /*
 173: 	 * d0 is the day number.
 174: 	 * generate day of the week.
 175: 	 */
 176: 
 177:     xtime[WDAY] = (d0+4)%7;
 178: 
 179:     /*
 180: 	 * year number
 181: 	 */
 182:     for(d1=70; d0 >= dysize(d1); d1++)
 183:         d0 =- dysize(d1);
 184:     xtime[YEAR] = d1;
 185:     xtime[YDAY] = d0;
 186: 
 187:     /*
 188: 	 * generate month
 189: 	 */
 190: 
 191:     if (dysize(d1)==366)
 192:         dmsize[1] = 29;
 193:     for(d1=0; d0 >= dmsize[d1]; d1++)
 194:         d0 =- dmsize[d1];
 195:     dmsize[1] = 28;
 196:     *tp++ = d0+1;
 197:     *tp++ = d1;
 198:     xtime[ISDAY] = 0;
 199:     return(xtime);
 200: }
 201: 
 202: asctime(t)
 203: int *t;
 204: {
 205:     register char *cp, *ncp;
 206:     register int *tp;
 207: 
 208:     cp = cbuf;
 209:     for (ncp = "Day Mon 00 00:00:00 1900\n"; *cp++ = *ncp++;);
 210:     ncp = &"SunMonTueWedThuFriSat"[3*t[6]];
 211:     cp = cbuf;
 212:     *cp++ = *ncp++;
 213:     *cp++ = *ncp++;
 214:     *cp++ = *ncp++;
 215:     cp++;
 216:     tp = &t[4];
 217:     ncp = &"JanFebMarAprMayJunJulAugSepOctNovDec"[(*tp)*3];
 218:     *cp++ = *ncp++;
 219:     *cp++ = *ncp++;
 220:     *cp++ = *ncp++;
 221:     cp = ct_numb(cp, *--tp);
 222:     cp = ct_numb(cp, *--tp+100);
 223:     cp = ct_numb(cp, *--tp+100);
 224:     cp = ct_numb(cp, *--tp+100);
 225:     cp =+ 2;
 226:     cp = ct_numb(cp, t[YEAR]);
 227:     return(cbuf);
 228: }
 229: 
 230: dysize(y)
 231: {
 232:     if((y%4) == 0)
 233:         return(366);
 234:     return(365);
 235: }
 236: 
 237: ct_numb(acp, n)
 238: {
 239:     register char *cp;
 240: 
 241:     cp = acp;
 242:     cp++;
 243:     if (n>=10)
 244:         *cp++ = (n/10)%10 + '0';
 245:     else
 246:         *cp++ = ' ';
 247:     *cp++ = n%10 + '0';
 248:     return(cp);
 249: }

Defined functions

Defined variables

Defined macros