Return to rtim.c CVS log

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

Annotation of 43BSDReno/games/dungeon/rtim.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * Interface routines for dungeon.
                      3:  * These routines are for functions expected by the game
                      4:  * that are not available in the Unix/f77 library.
                      5:  */
                      6: 
                      7: #ifdef SYSV
                      8: #include <stdio.h>
                      9: #endif
                     10: 
                     11: #include <sys/types.h>
                     12: 
                     13: #ifdef SYSV
                     14: #include <time.h>
                     15: #else
                     16: #include <sys/timeb.h>
                     17: #include <sys/time.h>
                     18: #endif
                     19: 
                     20: /* routine to get time in hours minutes and seconds */
                     21: 
                     22: long time();
                     23: struct tm *localtime();
                     24: struct tm *tmptr;
                     25: long timebuf;
                     26: 
                     27: itime_(hrptr,minptr,secptr)
                     28: 
                     29: int *hrptr,*minptr,*secptr;
                     30: {
                     31: 
                     32:        time(&timebuf);
                     33:        tmptr = localtime(&timebuf);
                     34:        
                     35:        *hrptr  = tmptr->tm_hour;
                     36:        *minptr = tmptr->tm_min;
                     37:        *secptr = tmptr->tm_sec;
                     38: 
                     39:        return;
                     40: }
                     41: 
                     42: #ifdef SYSV
                     43: /* idate - return day (1-31), month (1-12) and year (AD) */
                     44: /*     by Dave Newkirk, ihnp4!ihlpm!dcn */
                     45: 
                     46: idate_( date )
                     47: long date[];
                     48: {
                     49:        struct tm *t, *localtime();
                     50:        long time(), *tloc, loc;
                     51: 
                     52:        tloc = &loc;                    /* get pointer to time in seconds */
                     53:        time(tloc);
                     54:        t = localtime(tloc);            /* get time structure filled in */
                     55:        date[0] = t->tm_mday;
                     56:        date[1] = t->tm_mon + 1;
                     57:        date[2] = t->tm_year + 1900;
                     58: 
                     59: } /* end idate */
                     60: #endif
                     61: 
                     62: /* random number initializer */
                     63: inirnd_(seedptr)
                     64: 
                     65: int *seedptr;
                     66: {
                     67: int seed;
                     68: 
                     69:        seed = *seedptr;
                     70:        srand(seed);
                     71:        return;
                     72: }
                     73: 
                     74: /*  random number generator */
                     75: rnd_(maxval)
                     76: 
                     77: int *maxval;
                     78: {
                     79: /* note: returned random number ranges from 0 to maxval */
                     80: 
                     81: int rndval;
                     82: 
                     83:        rndval = rand();
                     84: 
                     85:        rndval = rndval % *maxval;
                     86: 
                     87:        return(rndval);
                     88: }
                     89: 
                     90: #ifdef SYSV
                     91: /* thanks to Dave Newkirk, ihnp4!ihlpm!dcn for the following routines */
                     92: 
                     93: /* getuid - fortran callable getuid */
                     94: 
                     95: int
                     96: getuid_()
                     97: {
                     98:        return (int)getuid();
                     99: }
                    100: 
                    101: /* unbuf - make output completely unbuffered */
                    102: 
                    103: unbuf_()
                    104: {
                    105:        void setbuf();
                    106: 
                    107:        setbuf(stdout, NULL);
                    108: }
                    109: #endif

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