Return to nap.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / games / larn

Annotation of 43BSDReno/games/larn/nap.c, revision 1.1

1.1     ! root        1: /* nap.c                Larn is copyrighted 1986 by Noah Morgan. */
        !             2: #include <signal.h>
        !             3: #include <sys/types.h>
        !             4: #ifdef SYSV
        !             5: #include <sys/times.h>
        !             6: #else
        !             7: #ifdef BSD
        !             8: #include <sys/timeb.h>
        !             9: #endif BSD
        !            10: #endif SYSV
        !            11: 
        !            12: /*
        !            13:  *     routine to take a nap for n milliseconds
        !            14:  */
        !            15: nap(x)
        !            16:        register int x;
        !            17:        {
        !            18:        if (x<=0) return; /* eliminate chance for infinite loop */
        !            19:        lflush();
        !            20:        if (x > 999) sleep(x/1000); else napms(x);
        !            21:        }
        !            22: 
        !            23: #ifdef NONAP
        !            24: napms(x)       /* do nothing */
        !            25:        int x;
        !            26:        {
        !            27:        }
        !            28: #else NONAP
        !            29: #ifdef SYSV
        !            30: /*     napms - sleep for time milliseconds - uses times() */
        !            31: /* this assumes that times returns a relative time in 60ths of a second */
        !            32: /* this will do horrible things if your times() returns seconds! */
        !            33: napms(time)
        !            34:        int time;
        !            35:        {
        !            36:        long matchclock, times();
        !            37:        struct tms stats;
        !            38: 
        !            39:        if (time<=0) time=1; /* eliminate chance for infinite loop */
        !            40:        if ((matchclock = times(&stats)) == -1 || matchclock == 0)
        !            41:                return; /* error, or BSD style times() */
        !            42:        matchclock += (time / 17);              /*17 ms/tic is 1000 ms/sec / 60 tics/sec */
        !            43: 
        !            44:        while(matchclock < times(&stats))
        !            45:                ;
        !            46:        }
        !            47: 
        !            48: #else not SYSV
        !            49: #ifdef BSD
        !            50: #ifdef SIGVTALRM
        !            51: /* This must be BSD 4.2!  */
        !            52: #include <sys/time.h>
        !            53: #define bit(_a) (1<<((_a)-1))
        !            54: 
        !            55: static  nullf()
        !            56:     {
        !            57:     }
        !            58: 
        !            59: /*     napms - sleep for time milliseconds - uses setitimer() */
        !            60: napms(time)
        !            61:        int time;
        !            62:     {
        !            63:     struct itimerval    timeout;
        !            64:     int     (*oldhandler) ();
        !            65:     int     oldsig;
        !            66: 
        !            67:        if (time <= 0) return;
        !            68: 
        !            69:     timerclear(&timeout.it_interval);
        !            70:     timeout.it_value.tv_sec = time / 1000;
        !            71:     timeout.it_value.tv_usec = (time % 1000) * 1000;
        !            72: 
        !            73:     oldsig = sigblock(bit(SIGALRM));
        !            74:     setitimer(ITIMER_REAL, &timeout, (struct itimerval *)0);
        !            75:     oldhandler = signal(SIGALRM, nullf);
        !            76:     sigpause(oldsig);
        !            77:     signal(SIGALRM, oldhandler);
        !            78:     sigsetmask(oldsig);
        !            79:     }
        !            80: 
        !            81: #else
        !            82: /*     napms - sleep for time milliseconds - uses ftime() */
        !            83: 
        !            84: static napms(time)
        !            85:        int time;
        !            86:        {
        !            87:        /* assumed to be BSD UNIX */
        !            88:        struct timeb _gtime;
        !            89:        time_t matchtime;
        !            90:        unsigned short matchmilli;
        !            91:        register struct timeb *tp = & _gtime;
        !            92: 
        !            93:        if (time <= 0) return;
        !            94:        ftime(tp);
        !            95:        matchmilli = tp->millitm + time;
        !            96:        matchtime  = tp->time;
        !            97:        while (matchmilli >= 1000)
        !            98:                {
        !            99:                ++matchtime;
        !           100:                matchmilli -= 1000;
        !           101:                }
        !           102: 
        !           103:        while(1)
        !           104:                {
        !           105:                ftime(tp);
        !           106:                if ((tp->time > matchtime) ||
        !           107:                        ((tp->time == matchtime) && (tp->millitm >= matchmilli)))
        !           108:                        break;
        !           109:                }
        !           110:        }
        !           111: #endif
        !           112: #else not BSD
        !           113: static napms(time) int time; {}        /* do nothing, forget it */
        !           114: #endif BSD
        !           115: #endif SYSV
        !           116: #endif NONAP

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.