Fixed up compiler warnings.

[unix-history] / games / larn / nap.c

/* nap.c                 Larn is copyrighted 1986 by Noah Morgan. */
#include <signal.h>
#include <sys/types.h>
#ifdef SYSV
#include <sys/times.h>
#else
#ifdef BSD
#include <sys/timeb.h>
#endif BSD
#endif SYSV

/*
*      routine to take a nap for n milliseconds
*/
nap(x)
       register int x;
       {
       if (x<=0) return; /* eliminate chance for infinite loop */
       lflush();
       if (x > 999) sleep(x/1000); else napms(x);
       }

#ifdef NONAP
napms(x)        /* do nothing */
       int x;
       {
       }
#else NONAP
#ifdef SYSV
/*      napms - sleep for time milliseconds - uses times() */
/* this assumes that times returns a relative time in 60ths of a second */
/* this will do horrible things if your times() returns seconds! */
napms(time)
       int time;
       {
       long matchclock, times();
       struct tms stats;

       if (time<=0) time=1; /* eliminate chance for infinite loop */
       if ((matchclock = times(&stats)) == -1 || matchclock == 0)
               return; /* error, or BSD style times() */
       matchclock += (time / 17);              /*17 ms/tic is 1000 ms/sec / 60 tics/sec */

       while(matchclock < times(&stats))
               ;
       }

#else not SYSV
#ifdef BSD
#ifdef SIGVTALRM
/* This must be BSD 4.2!  */
#include <sys/time.h>
#define bit(_a) (1<<((_a)-1))

static  nullf()
   {
   }

/*      napms - sleep for time milliseconds - uses setitimer() */
napms(time)
       int time;
   {
   struct itimerval    timeout;
   int     (*oldhandler) ();
   int     oldsig;

       if (time <= 0) return;

   timerclear(&timeout.it_interval);
   timeout.it_value.tv_sec = time / 1000;
   timeout.it_value.tv_usec = (time % 1000) * 1000;

   oldsig = sigblock(bit(SIGALRM));
   setitimer(ITIMER_REAL, &timeout, (struct itimerval *)0);
   oldhandler = signal(SIGALRM, nullf);
   sigpause(oldsig);
   signal(SIGALRM, oldhandler);
   sigsetmask(oldsig);
   }

#else
/*      napms - sleep for time milliseconds - uses ftime() */

static napms(time)
       int time;
       {
       /* assumed to be BSD UNIX */
       struct timeb _gtime;
       time_t matchtime;
       unsigned short matchmilli;
       register struct timeb *tp = & _gtime;

       if (time <= 0) return;
       ftime(tp);
       matchmilli = tp->millitm + time;
       matchtime  = tp->time;
       while (matchmilli >= 1000)
               {
               ++matchtime;
               matchmilli -= 1000;
               }

       while(1)
               {
               ftime(tp);
               if ((tp->time > matchtime) ||
                       ((tp->time == matchtime) && (tp->millitm >= matchmilli)))
                       break;
               }
       }
#endif
#else not BSD
static napms(time) int time; {} /* do nothing, forget it */
#endif BSD
#endif SYSV
#endif NONAP