Return to getch.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / contrib / jove

Annotation of 43BSDReno/contrib/jove/getch.c, revision 1.1.1.1

1.1       root        1: /***************************************************************************
                      2:  * This program is Copyright (C) 1986, 1987, 1988 by Jonathan Payne.  JOVE *
                      3:  * is provided to you without charge, and with no warranty.  You may give  *
                      4:  * away copies of JOVE, including sources, provided that this notice is    *
                      5:  * included in all the files.                                              *
                      6:  ***************************************************************************/
                      7: 
                      8: #include "tune.h"
                      9: 
                     10: #ifdef MSDOS
                     11: 
                     12: #include <bios.h>
                     13: #include <dos.h>
                     14: 
                     15: #include "jove.h"
                     16: 
                     17: private void waitfun proto((void));
                     18: 
                     19: extern int UpdModLine;
                     20: #ifdef IBMPC
                     21: static char last = 0;
                     22: extern int specialkey;
                     23: #endif
                     24: 
                     25: getrawinchar()
                     26: {
                     27: #ifdef RAINBOW
                     28:        union REGS regs;
                     29: #endif /* RAINBOW */
                     30: #ifdef IBMPC
                     31:        unsigned scan;
                     32: 
                     33:        if (specialkey = last) {
                     34:                scan = last;
                     35:                last = 0;
                     36:                return scan;
                     37:        }
                     38: #endif /* IBMPC */
                     39: 
                     40:        while (!rawkey_ready())
                     41:                waitfun();
                     42: 
                     43: #ifdef IBMPC
                     44:        scan = _bios_keybrd(_KEYBRD_READ);
                     45:        if ((scan&0xff) == 0) {
                     46:                last = (char) (scan >> 8);
                     47:                return 0xff;
                     48:        }
                     49:        return scan&0xff;
                     50: #else /* IBMPC */
                     51: #ifdef RAINBOW
                     52: waitloop:
                     53:        regs.x.di = 2;
                     54:        int86(0x18, &regs, &regs);
                     55:        if (regs.h.al != 0)     /* should never happen, but who knows */
                     56:                return regs.h.al;
                     57:        else
                     58:                goto waitloop;
                     59: #else /* RAINBOW */
                     60:        return bdos(0x06, 0x00ff, 0xff) & 0xff;
                     61: #endif /* RAINBOW */
                     62: #endif /* IBMPC */
                     63: }
                     64: 
                     65: static int waiting = 0;
                     66: 
                     67: rawkey_ready()
                     68: {
                     69: #ifndef IBMPC
                     70:        union REGS regs;
                     71: #endif
                     72: 
                     73:        if (waiting)
                     74:                return 0;
                     75: #ifdef IBMPC
                     76:        if (last)
                     77:                return 1;
                     78: 
                     79:        return _bios_keybrd(_KEYBRD_READY);
                     80: #else /* IBMPC */
                     81: #ifdef RAINBOW
                     82:        regs.x.di = 4;
                     83:        int86(0x18, &regs, &regs);
                     84:        return regs.h.cl != 0;
                     85: #else /* RAINBOW */
                     86:        regs.h.ah = 0x44;               /* ioctl call */
                     87:        regs.x.bx = 0;                  /* stdin file handle */
                     88:        regs.h.al = 0x06;               /* get input status */
                     89:        intdos(&regs, &regs);
                     90:        return regs.h.al & 1;
                     91: #endif /* RAINBOW */
                     92: #endif /* IBMPC */
                     93: }
                     94: 
                     95: #ifdef IBMPC
                     96: static long timecount, lastcount = 0;
                     97: #else
                     98: static char lastmin = 0;
                     99: #endif
                    100: 
                    101: 
                    102: private void
                    103: waitfun()
                    104: {
                    105: #ifndef IBMPC
                    106:        struct dostime_t tc;
                    107: #endif
                    108: 
                    109:        if (UpdModLine) {
                    110:                waiting = 1;
                    111:                redisplay();
                    112:                waiting = 0;
                    113:                return;
                    114:        }
                    115: #ifdef IBMPC
                    116:        if (_bios_timeofday(_TIME_GETCLOCK, &timecount) ||  /* after midnight */
                    117:            (timecount > lastcount + 0x444) ) {
                    118:                lastcount = timecount;
                    119:                UpdModLine = 1;
                    120:        }
                    121: #else
                    122:        _dos_gettime(&tc);
                    123:        if (tc.minute != lastmin) {
                    124:                UpdModLine = 1;
                    125:                lastmin = tc.minute;
                    126:        }
                    127: #endif
                    128: }
                    129: 
                    130: #endif /* MSDOS */

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