home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / INFO / C / PC_8250.ZIP / _kb.c next >
Encoding:
C/C++ Source or Header  |  1991-02-07  |  5.0 KB  |  282 lines
  1. /*
  2.  *                               _KB.C
  3.  *
  4.  *                        Keyboard i/o Handler
  5.  *
  6.  *                           Written for the
  7.  *
  8.  *                              Datalight
  9.  *                           Microsoft V 5.x
  10.  *                                TurboC
  11.  *                                  &
  12.  *                               Zortech
  13.  *
  14.  *                             C Compilers
  15.  *
  16.  *            Copyright (c) John Birchfield 1987, 1988, 1989
  17.  */
  18. /*
  19.  * If we use the Microsoft Compiler, we need to bind in MSC.OBJ
  20.  * which contains the function _kbhit ().
  21.  */
  22.  
  23. #include <dos.h>
  24.  
  25. /*
  26.  *    defines for the bits returned in regs.x.cflag and by int86 () ...
  27.  */
  28.  
  29. #define ZERO_BIT       0x040
  30. #define CARRY_BIT          1
  31. #define SIGN_BIT       0x080
  32. #define DIRECTION_FLAG 0x400
  33. #define OVERFLOW_BIT   0x800
  34.  
  35. static union REGS regs;
  36.  
  37.  
  38. /*
  39.  *    The following Translate Table is used to convert the PC scan
  40.  *    codes into something of use.  The translated values are defined in
  41.  *    the file "scr_iokb.h".
  42.  */
  43.  
  44. #include "_kb.h"
  45. static struct xlate_tbl
  46. {
  47.     int     in, out;
  48. }       cvt[] =
  49.  
  50. {
  51.     {
  52.                 72, up_char
  53.     }      ,
  54.     {
  55.                 80, down_char
  56.     }      ,
  57.     {
  58.                 75, left_char
  59.     }      ,
  60.     {
  61.                 77, right_char
  62.     }      ,
  63.     {
  64.                 115, ctl_lft_char
  65.     }      ,
  66.     {
  67.                 116, ctl_rt_char
  68.     }      ,
  69.     {
  70.                 71, home_char
  71.     }      ,
  72.     {
  73.                 79, end_char
  74.     }      ,
  75.     {
  76.                 119, ctl_home_char
  77.     }      ,
  78.     {
  79.                 117, ctl_end_char
  80.     }      ,
  81.     {
  82.                 73, pageup_char
  83.     }      ,
  84.     {
  85.                 81, pagedown_char
  86.     }      ,
  87.     {
  88.                 132, ctl_pu_char
  89.     }      ,
  90.     {
  91.                 118, ctl_pd_char
  92.     }      ,
  93.     {
  94.                 82, Ins_char
  95.     }      ,
  96.     {
  97.                 83, Del_char
  98.     }      ,
  99.  
  100.     /* Straight Ahead Function Keys */
  101.     {
  102.                 59, M1
  103.     }      ,
  104.     {
  105.                 60, M2
  106.     }      ,
  107.     {
  108.                 61, M3
  109.     }      ,
  110.     {
  111.                 62, M4
  112.     }      ,
  113.     {
  114.                 63, M5
  115.     }      ,
  116.     {
  117.                 64, M6
  118.     }      ,
  119.     {
  120.                 65, M7
  121.     }      ,
  122.     {
  123.                 66, M8
  124.     }      ,
  125.     {
  126.                 67, M9
  127.     }      ,
  128.     {
  129.                 68, M10
  130.     }      ,
  131.  
  132.     /* Shifted Function Keys */
  133.     {
  134.                 104, M11
  135.     }      ,
  136.     {
  137.                 105, M12
  138.     }      ,
  139.     {
  140.                 106, M13
  141.     }      ,
  142.     {
  143.                 107, M14
  144.     }      ,
  145.     {
  146.                 108, M15
  147.     }      ,
  148.     {
  149.                 109, M16
  150.     }      ,
  151.     {
  152.                 110, M17
  153.     }      ,
  154.     {
  155.                 111, M18
  156.     }      ,
  157.     {
  158.                 112, M19
  159.     }      ,
  160.     {
  161.                 113, M20
  162.     }      ,
  163.  
  164.     /* Alt Function Keys */
  165.     {
  166.                 84, M21
  167.     }      ,
  168.     {
  169.                 85, M22
  170.     }      ,
  171.     {
  172.                 86, M23
  173.     }      ,
  174.     {
  175.                 87, M24
  176.     }      ,
  177.     {
  178.                 88, M25
  179.     }      ,
  180.     {
  181.                 89, M26
  182.     }      ,
  183.     {
  184.                 90, M27
  185.     }      ,
  186.     {
  187.                 91, M28
  188.     }      ,
  189.     {
  190.                 92, M29
  191.     }      ,
  192.     {
  193.                 93, M30
  194.     }      ,
  195.  
  196.     /* Ctrl Function Keys */
  197.     {
  198.                 94, M31
  199.     }      ,
  200.     {
  201.                 95, M32
  202.     }      ,
  203.     {
  204.                 96, M33
  205.     }      ,
  206.     {
  207.                 97, M34
  208.     }      ,
  209.     {
  210.                 98, M35
  211.     }      ,
  212.     {
  213.                 99, M36
  214.     }      ,
  215.     {
  216.                 100, M37
  217.     }      ,
  218.     {
  219.                 101, M38
  220.     }      ,
  221.     {
  222.                 102, M39
  223.     }      ,
  224.     {
  225.                 103, M40
  226.     }      ,
  227.  
  228.     {
  229.                 0, 255
  230.     }
  231. };
  232.  
  233.  
  234.  
  235.  
  236. /*
  237.  *    _KB can tell if the Keyboard has been touched.  If it has, he returns
  238.  *        the value of the key pressed.  If the Control Key or one of the
  239.  *        Numeric or Function Keys is pressed that value is returned
  240.  *        from a look-up table.
  241.  *
  242.  *    Usage: if ((ch=_kb ())!=-1) we_have_a_char=TRUE;
  243.  */
  244.  
  245.  
  246. int 
  247. _kb ()
  248. {
  249.     int     ix, flag;
  250. #if (defined (DLC))
  251. # if (defined (__ZTC__))
  252.     if (kbhit ())
  253. # else
  254.     regs.h.ah = 1;
  255.     if ((int86 (0x16, ®s, ®s) & ZERO_BIT) == 0)
  256. # endif 
  257.     {
  258. #else
  259. # if (defined (__TURBOC__))
  260.     regs.h.ah = 1;
  261.     int86 (0x16, ®s, ®s);
  262.     if ((regs.x.flags & ZERO_BIT) == 0)
  263.     {
  264. # else
  265.     if (_kbhit ())
  266.     {
  267. # endif
  268. #endif
  269.         regs.h.ah = 0;
  270.         int86 (0x16, ®s, ®s);
  271.         if (regs.h.al == 0)
  272.         {
  273.             for (ix = 0; cvt[ix].in; ix++)
  274.                 if (cvt[ix].in == regs.h.ah)
  275.                     break;
  276.             return (cvt[ix].out);
  277.         }
  278.         return ((int) regs.h.al);
  279.     }
  280.     return (-1);
  281. }
  282.