head	1.15;
access;
symbols;
locks; strict;
comment	@ * @;


1.15
date	92.12.15.00.20.22;	author jromine;	state Exp;
branches;
next	1.14;

1.14
date	92.05.19.21.24.56;	author jromine;	state Exp;
branches;
next	1.13;

1.13
date	92.05.19.21.24.42;	author jromine;	state Exp;
branches;
next	1.12;

1.12
date	92.05.15.17.56.29;	author jromine;	state Exp;
branches;
next	1.11;

1.11
date	92.02.07.00.45.31;	author jromine;	state Exp;
branches;
next	1.10;

1.10
date	92.02.07.00.27.17;	author jromine;	state Exp;
branches;
next	1.9;

1.9
date	92.02.05.23.45.46;	author jromine;	state Exp;
branches;
next	1.8;

1.8
date	92.02.05.22.39.47;	author jromine;	state Exp;
branches;
next	1.7;

1.7
date	90.04.09.13.23.19;	author sources;	state Exp;
branches;
next	1.6;

1.6
date	90.04.05.15.04.43;	author sources;	state Exp;
branches;
next	1.5;

1.5
date	90.02.22.18.14.11;	author sources;	state Exp;
branches;
next	1.4;

1.4
date	90.02.22.18.09.06;	author sources;	state Exp;
branches;
next	1.3;

1.3
date	90.02.22.14.34.23;	author sources;	state Exp;
branches;
next	1.2;

1.2
date	90.02.01.14.37.05;	author sources;	state Exp;
branches;
next	1.1;

1.1
date	90.02.01.14.36.51;	author sources;	state Exp;
branches;
next	;


desc
@@


1.15
log
@endif sugar
@
text
@/* dtime.c - routines to do ``ARPA-style'' time structures */
#ifndef	lint
static char ident[] = "@@(#)$Id: dtime.c,v 1.14 1992/05/19 21:24:56 jromine Exp jromine $";
#endif	/* lint */

/* LINTLIBRARY */


#include "tws.h"
#ifndef	INETONLY
#include "../h/strings.h"
#else	/* INETONLY */
#include "strings.h"
#endif	/* INETONLY */
#include <stdio.h>
#include <sys/types.h>
#if	!defined(SYS5) && !defined(ZONEINFO)
#include <sys/timeb.h>
#endif	/* !defined(SYS5) && !defined(ZONEINFO) */
#ifdef	_AIX
#include <sys/time.h>
#include <time.h>
#else
#ifdef	BSD42
#include <sys/time.h>
#else	/* BSD42 */
#include <time.h>
#endif	/* BSD42 */
#endif

#ifdef	SYS5
extern int  daylight;
extern long timezone;
extern char *tzname[];
#endif	/* SYS5 */

/*  */

#ifndef	abs
#define	abs(a)	(a >= 0 ? a : -a)
#endif

#define	dysize(y)	\
	(((y) % 4) ? 365 : (((y) % 100) ? 366 : (((y) % 400) ? 365 : 366)))

/*  */

char *tw_moty[] = {
    "Jan", "Feb", "Mar", "Apr", "May", "Jun",
    "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", NULL
};

char *tw_dotw[] = {
    "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", NULL
};

char *tw_ldotw[] = {
    "Sunday", "Monday", "Tuesday", "Wednesday",
    "Thursday", "Friday", "Saturday", NULL
};

/*  */

static struct zone {
    char   *std,
           *dst;
    int     shift;
}                   zones[] = {
			"GMT", "BST", 0,
                        "EST", "EDT", -5,
                        "CST", "CDT", -6,
                        "MST", "MDT", -7,
                        "PST", "PDT", -8,
#ifdef	notdef	/* RFC1123 specifies do not use military TZs */
                        "A", NULL, -1,
                        "B", NULL, -2,
                        "C", NULL, -3,
                        "D", NULL, -4,
                        "E", NULL, -5,
                        "F", NULL, -6,
                        "G", NULL, -7,
                        "H", NULL, -8,
                        "I", NULL, -9,
                        "K", NULL, -10,
                        "L", NULL, -11,
                        "M", NULL, -12,
                        "N", NULL, 1,
#ifndef	HUJI
                        "O", NULL, 2,
#else	/* HUJI */
			"JST", "JDT", 2,
#endif	/* HUJI */
                        "P", NULL, 3,
                        "Q", NULL, 4,
                        "R", NULL, 5,
                        "S", NULL, 6,
                        "T", NULL, 7,
                        "U", NULL, 8,
                        "V", NULL, 9,
                        "W", NULL, 10,
                        "X", NULL, 11,
                        "Y", NULL, 12,
#endif	/* notdef */

                        NULL
};

#define CENTURY 1900

long    time ();
struct tm *localtime ();

/*  */

char *dtimenow () {
    long    clock;

    (void) time (&clock);
    return dtime (&clock);
}


char   *dctime (tw)
register struct tws *tw;
{
    static char buffer[25];

    if (!tw)
	return NULL;

    (void) sprintf (buffer, "%.3s %.3s %02d %02d:%02d:%02d %.4d\n",
	    tw_dotw[tw -> tw_wday], tw_moty[tw -> tw_mon], tw -> tw_mday,
	    tw -> tw_hour, tw -> tw_min, tw -> tw_sec,
	    tw -> tw_year >= 100 ? tw -> tw_year : CENTURY + tw -> tw_year);

    return buffer;
}

/*  */

struct tws *dtwstime () {
    long    clock;

    (void) time (&clock);
    return dlocaltime (&clock);
}


struct tws *dlocaltime (clock)
register long   *clock;
{
    register struct tm *tm;
#if	!defined(SYS5) && !defined(ZONEINFO)
    struct timeb    tb;
#endif	/* !defined(SYS5) && !defined(ZONEINFO) */
    static struct tws   tw;

    if (!clock)
	return NULL;
    tw.tw_flags = TW_NULL;

    tm = localtime (clock);
    tw.tw_sec = tm -> tm_sec;
    tw.tw_min = tm -> tm_min;
    tw.tw_hour = tm -> tm_hour;
    tw.tw_mday = tm -> tm_mday;
    tw.tw_mon = tm -> tm_mon;
    tw.tw_year = tm -> tm_year + CENTURY;
    tw.tw_wday = tm -> tm_wday;
    tw.tw_yday = tm -> tm_yday;
    if (tm -> tm_isdst)
	tw.tw_flags |= TW_DST;
#if	defined(SYS5)
    tzset ();
    tw.tw_zone = -(timezone / 60);
#else	/* defined(SYS5) */
#if	defined(ZONEINFO)
    tw.tw_zone = tm->tm_gmtoff / 60;
    if (tm -> tm_isdst)			/* if DST is in effect */
	tw.tw_zone -= 60;		/* reset to normal offset */
#else	/* defined(ZONEINFO) */
    ftime (&tb);
    tw.tw_zone = -tb.timezone;
#endif	/* defined(ZONEINFO) */
#endif	/* defined(SYS5) */
    tw.tw_flags &= ~TW_SDAY, tw.tw_flags |= TW_SEXP;
    tw.tw_flags &= ~TW_SZONE, tw.tw_flags |= TW_SZEXP;
    tw.tw_clock = *clock;

    return (&tw);
}


struct tws *dgmtime (clock)
register long   *clock;
{
    register struct tm *tm;
    static struct tws   tw;

    if (!clock)
	return NULL;
    tw.tw_flags = TW_NULL;

    tm = gmtime (clock);
    tw.tw_sec = tm -> tm_sec;
    tw.tw_min = tm -> tm_min;
    tw.tw_hour = tm -> tm_hour;
    tw.tw_mday = tm -> tm_mday;
    tw.tw_mon = tm -> tm_mon;
    tw.tw_year = tm -> tm_year + CENTURY;
    tw.tw_wday = tm -> tm_wday;
    tw.tw_yday = tm -> tm_yday;
    if (tm -> tm_isdst)
	tw.tw_flags |= TW_DST;
    tw.tw_zone = 0;
    tw.tw_flags &= ~TW_SDAY, tw.tw_flags |= TW_SEXP;
    tw.tw_flags &= ~TW_SZONE, tw.tw_flags |= TW_SZEXP;
    tw.tw_clock = *clock;

    return (&tw);
}

/*  */

char   *dasctime (tw, flags)
register struct tws *tw;
int	flags;
{
    char buffer[80];
    static char result[80];

    if (!tw)
	return NULL;

    /* Display timezone if known */
    if ((tw->tw_flags & TW_SZONE) == TW_SZNIL)
	    result[0] = '\0';
    else
	    (void) sprintf(result, " %s",
		dtimezone(tw -> tw_zone, tw->tw_flags | flags));
    (void) sprintf(buffer, "%02d %s %0*d %02d:%02d:%02d%s",
	    tw->tw_mday, tw_moty[tw->tw_mon],
	    tw -> tw_year < 100 ? 2 : 4, tw -> tw_year,
	    tw->tw_hour, tw->tw_min, tw->tw_sec, result);

    if ((tw -> tw_flags & TW_SDAY) == TW_SEXP)
	(void) sprintf (result, "%s, %s", tw_dotw[tw -> tw_wday], buffer);
    else
	if ((tw -> tw_flags & TW_SDAY) == TW_SNIL)
	    (void) strcpy (result, buffer);
	else
	    (void) sprintf (result, "%s (%s)", buffer, tw_dotw[tw -> tw_wday]);

    return result;
}

/*  */

char   *dtimezone (offset, flags)
register int     offset,
		 flags;
{
    register int    hours,
                    mins;
    register struct zone *z;
    static char buffer[10];

    if (offset < 0) {
	mins = -((-offset) % 60);
	hours = -((-offset) / 60);
    }
    else {
	mins = offset % 60;
	hours = offset / 60;
    }

    if (!(flags & TW_ZONE) && mins == 0)
#if	defined(SYS5) && defined(TZNAME)
    {
	tzset();
	return ((flags & TW_DST) ? tzname[1] : tzname[0]);
    }
#else
	for (z = zones; z -> std; z++)
	    if (z -> shift == hours)
		return (z -> dst && (flags & TW_DST) ? z -> dst : z -> std);
#endif

#if	defined(DSTXXX)
    if (flags & TW_DST)
	hours += 1;
#endif	/* defined(DSTXXX) */
    (void) sprintf (buffer, "%s%02d%02d",
	    offset < 0 ? "-" : "+", abs (hours), abs (mins));
    return buffer;
}

/*  */

void twscopy (tb, tw)
register struct tws *tb,
		    *tw;
{
#ifdef	notdef
    tb -> tw_sec = tw -> tw_sec;
    tb -> tw_min = tw -> tw_min;
    tb -> tw_hour = tw -> tw_hour;
    tb -> tw_mday = tw -> tw_mday;
    tb -> tw_mon = tw -> tw_mon;
    tb -> tw_year = tw -> tw_year;
    tb -> tw_wday = tw -> tw_wday;
    tb -> tw_yday = tw -> tw_yday;
    tb -> tw_zone = tw -> tw_zone;
    tb -> tw_clock = tw -> tw_clock;
    tb -> tw_flags = tw -> tw_flags;
#else	/* not notdef */
    *tb = *tw;
#endif	/* not notdef */
}


int     twsort (tw1, tw2)
register struct tws *tw1,
		    *tw2;
{
    register long   c1,
                    c2;

    if (tw1 -> tw_clock == 0L)
	(void) twclock (tw1);
    if (tw2 -> tw_clock == 0L)
	(void) twclock (tw2);

    return ((c1 = tw1 -> tw_clock) > (c2 = tw2 -> tw_clock) ? 1
	    : c1 == c2 ? 0 : -1);
}

/*  */

/* This routine is based on the gtime() routine written by Steven Shafer
   (sas) at CMU.  It was forwarded to MTR by Jay Lepreau at Utah-CS.
 */

static int  dmsize[] = {
    31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
};


long	twclock (tw)
register struct	tws *tw;
{
    register int    i,
                    sec,
                    min,
                    hour,
                    mday,
                    mon,
                    year;
    register long   result;

    if (tw -> tw_clock != 0L)
	return tw -> tw_clock;

    if ((sec = tw -> tw_sec) < 0 || sec > 59
	    || (min = tw -> tw_min) < 0 || min > 59
	    || (hour = tw -> tw_hour) < 0 || hour > 23
	    || (mday = tw -> tw_mday) < 1 || mday > 31
	    || (mon = tw -> tw_mon + 1) < 1 || mon > 12)
	return (tw -> tw_clock = -1L);
    year = tw -> tw_year;

    result = 0L;
    if (year < 100)
	year += CENTURY;
    for (i = 1970; i < year; i++)
	result += dysize (i);
    if (dysize (year) == 366 && mon >= 3)
	result++;
    while (--mon)
	result += dmsize[mon - 1];
    result += mday - 1;
    result = 24 * result + hour;
    result = 60 * result + min;
    result = 60 * result + sec;
    result -= 60 * tw -> tw_zone;
    if (tw -> tw_flags & TW_DST)
	result -= 60 * 60;

    return (tw -> tw_clock = result);
}

/*  */

/*
 *    Simple calculation of day of the week.  Algorithm used is Zeller's
 *    congruence.  Currently, we assume if tw -> tw_year < 100
 *    then the century is CENTURY.
 */

set_dotw (tw)
register struct tws *tw;
{
    register int    month,
                    day,
                    year,
                    century;

    month = tw -> tw_mon - 1;
    day = tw -> tw_mday;
    year = tw -> tw_year % 100;
    century = tw -> tw_year >= 100 ? tw -> tw_year / 100 : (CENTURY / 100);

    if (month <= 0) {
	month += 12;
	if (--year < 0) {
	    year += 100;
	    century--;
	}
    }

    tw -> tw_wday =
	((26 * month - 2) / 10 + day + year + year / 4
	    - 3 * century / 4 + 1) % 7;

    tw -> tw_flags &= ~TW_SDAY, tw -> tw_flags |= TW_SIMP;
}
@


1.14
log
@AIX
@
text
@d3 2
a4 2
static char ident[] = "@@(#)$Id: dtime.c,v 1.13 1992/05/19 21:24:42 jromine Exp jromine $";
#endif	lint
d12 1
a12 1
#else	INETONLY
d14 1
a14 1
#endif	INETONLY
d26 1
a26 1
#else	BSD42
d28 1
a28 1
#endif	BSD42
d35 1
a35 1
#endif	SYS5
d90 1
a90 1
#else	HUJI
d92 1
a92 1
#endif	HUJI
d103 1
a103 1
#endif	notdef
d292 1
a292 1
#endif	defined(DSTXXX)
d316 1
a316 1
#else	not notdef
d318 1
a318 1
#endif	not notdef
@


1.13
log
@AIX
@
text
@d3 1
a3 1
static char ident[] = "@@(#)$Id: dtime.c,v 1.12 1992/05/15 17:56:29 jromine Exp jromine $";
d39 1
d41 1
@


1.12
log
@fix problem with ZONEINFO on Suns.
@
text
@d3 1
a3 1
static char ident[] = "@@(#)$Id: dtime.c,v 1.11 1992/02/07 00:45:31 jromine Exp jromine $";
d20 4
d29 1
@


1.11
log
@4 digit years
@
text
@d3 1
a3 1
static char ident[] = "@@(#)$Id: dtime.c,v 1.10 1992/02/07 00:27:17 jromine Exp jromine $";
d172 2
d282 1
a282 1
#if	defined(DSTXXX) && !defined(ZONEINFO)
d285 1
a285 1
#endif	defined(DSTXXX) && !defined(ZONEINFO)
@


1.10
log
@fixes
@
text
@d3 1
a3 1
static char ident[] = "@@(#)$Id: dtime.c,v 1.9 1992/02/05 23:45:46 jromine Exp jromine $";
d161 1
a161 1
    tw.tw_year = tm -> tm_year;
d201 1
a201 1
    tw.tw_year = tm -> tm_year;
@


1.9
log
@fix 4 digit dates
@
text
@d3 1
a3 1
static char ident[] = "@@(#)$Id: dtime.c,v 1.8 1992/02/05 22:39:47 jromine Exp jromine $";
d232 1
a232 1
    (void) sprintf(buffer, "%02d %s %04d %02d:%02d:%02d%s",
d234 1
a234 1
	    tw -> tw_year >= 100 ? tw -> tw_year : CENTURY + tw -> tw_year,
d364 2
a365 1
    year += CENTURY;
@


1.8
log
@start using 4 digit dates
@
text
@d3 1
a3 1
static char ident[] = "@@(#)$Id: dtime.c,v 1.7 1990/04/09 13:23:19 sources Exp jromine $";
d233 2
a234 1
	    tw->tw_mday, tw_moty[tw->tw_mon], tw->tw_year,
@


1.7
log
@*** empty log message ***
@
text
@d3 1
a3 1
static char ident[] = "@@(#)$Id: dtime.c,v 1.6 90/04/05 15:04:43 sources Exp Locker: sources $";
d101 1
a101 1
#define CENTURY 19
d127 1
a127 1
	    tw -> tw_year >= 100 ? tw -> tw_year : 1900 + tw -> tw_year);
d232 1
a232 1
    (void) sprintf(buffer, "%02d %s %02d %02d:%02d:%02d%s",
d363 1
a363 1
    year += 1900;
d400 1
a400 1
    century = tw -> tw_year >= 100 ? tw -> tw_year / 100 : CENTURY;
@


1.6
log
@add ID
@
text
@d3 1
a3 1
static char ident[] = "@@(#)$Id:$";
d17 1
a17 1
#ifndef  SYS5
d19 4
a22 2
#endif   not SYS5
#ifndef	BSD42
a23 2
#else	BSD42
#include <sys/time.h>
d146 1
a146 1
#ifndef	SYS5
d148 1
a148 1
#endif	not SYS5
d166 7
a172 1
#ifndef  SYS5
d175 2
a176 4
#else   SYS5
    tzset ();
    tw.tw_zone = -(timezone / 60);
#endif  SYS5
d279 1
a279 1
#ifdef	DSTXXX
d282 1
a282 1
#endif	DSTXXX
@


1.5
log
@ignore military timezones per RFC1123
@
text
@d2 3
@


1.4
log
@Fixes from Van Jacobson
@
text
@d64 1
d93 1
@


1.3
log
@SYS5 stuff?
@
text
@d169 1
d199 1
d211 2
a212 2
    static char buffer[80],
                result[80];
d217 9
a225 4
    (void) sprintf (buffer, "%02d %s %02d %02d:%02d:%02d %s",
	    tw -> tw_mday, tw_moty[tw -> tw_mon], tw -> tw_year,
	    tw -> tw_hour, tw -> tw_min, tw -> tw_sec,
	    dtimezone (tw -> tw_zone, tw -> tw_flags | flags));
@


1.2
log
@add MDT
@
text
@d252 6
d261 1
@


1.1
log
@Initial revision
@
text
@d62 1
a62 1
                        "MST", NULL, -7,
@