home *** CD-ROM | disk | FTP | other *** search
/ The C Users' Group Library 1994 August / wc-cdrom-cusersgrouplibrary-1994-08.iso / listings / v_08_07 / 8n07086a < prev    next >
Text File  |  1990-06-19  |  3KB  |  180 lines
  1. #include <dos.h>
  2. #include <conio.h>
  3.  
  4. void show_char();
  5. int     poll_kb();
  6. int  readch();
  7. int  push_kb();
  8. int  kb_count();
  9. int  kb_peek();
  10. void kb_clear();
  11.  
  12. /* testing the KB functions */
  13. void main(void)
  14.     {
  15.     int x, y;
  16.     for(x = 0; x < 12; x++)     /* Put some characters into the */
  17.         push_kb(1,32 + x);  /* buffer. For most applications */
  18.                                     /* the scan codes abre not important */
  19.                     /* but for extended char it must have */
  20.                                     /* the scan code and 0 for the char */
  21.     push_kb(59,0);
  22.  
  23.     printf("\n%d key(s) in the buffer. \n\n",kb_count());
  24.     printf("Key number %d is '%c' \n\n", 5, kb_peek(5));
  25.     printf("Key number %d is '%c' \n\n", 7, kb_peek(7));
  26.  
  27.     show_char();
  28.     }
  29.  
  30.  
  31.  
  32. void show_char(void)     /* This is just a test function */
  33.     {
  34.     int c;
  35.     while((c = readch()) != 59 << 8)     /* 27 = ESC */
  36.         {
  37.         putch(c);
  38.         printf(" the code for this is %d \n",c);
  39.         }
  40.     putch(c);
  41.     printf(" the code for this is %d \n",c);
  42.  
  43.     }
  44.  
  45.  
  46.  
  47.  
  48. int poll_kb(void)   /* returns 0 if the buffer is empty */
  49.            {   /* else ascii code or scan codes * 256 for extended */
  50.     int head, tail;
  51.     unsigned int code;
  52.  
  53.     head = peek(0x40, 0x1A);
  54.     tail = peek(0x40, 0x1C);
  55.  
  56.     if(head == tail)
  57.         return(0);
  58.  
  59.     code = (peek(0x40,head) & 0xFF);
  60.     if(code == 0)
  61.         code = (peek(0x40,head) & 0xFF00);        /* extended char */
  62.  
  63.     if(head < 60)
  64.         poke(0x40,0x1A,(head += 2));
  65.     else
  66.         poke(0x40,0x1A,(head = 30));
  67.  
  68.     return(code);
  69.     }
  70.  
  71.  
  72.  
  73. int readch(void)   /* keep checking buffer until something is */
  74.     {          /* there can also be done with "kbhit()" */
  75.     int code;
  76.     while((code = poll_kb()) == 0)
  77.         {    /* can run any fast function here */
  78.         }
  79.     return(code);
  80.     }
  81.  
  82.  
  83.  
  84. /* key = the key code      ascii = asc code */
  85. int push_kb(int key, int ascii)
  86.     {
  87.     unsigned int code;
  88.     int head, tail;
  89.  
  90.  
  91.     head = peek(0x40, 0x1A);
  92.     tail = peek(0x40, 0x1C);
  93.  
  94.     code = (key << 8) + ascii;
  95.     poke(0x40,tail,code);
  96.  
  97.     if(tail < 60)
  98.         {
  99.         tail += 2;
  100.         if(tail == head)
  101.             return(0);
  102.         poke(0x40,0x1C,tail);
  103.         }
  104.     else
  105.         {
  106.         tail = 30;
  107.         if(tail == head)
  108.             return(0);
  109.         poke(0x40,0x1C,tail);
  110.         }
  111.     return(1);
  112.     }
  113.  
  114.  
  115.  
  116.  
  117.  
  118. int kb_count(void)
  119.     {
  120.     int head, tail;
  121.     int count;
  122.  
  123.     head = peek(0x40, 0x1A);
  124.     tail = peek(0x40, 0x1C);
  125.  
  126.     if(head == tail)    /* buffer is empty */
  127.         return(0);
  128.  
  129.     if(head > tail)     /* adjust for the roll over */
  130.         tail += 32;
  131.     count = (tail - head) / 2;
  132.  
  133.     return(count);
  134.     }
  135.  
  136.  
  137.  
  138.  /* "kb_peek" will return the ascii code of */
  139.  /* the number of keys back specified.      */
  140.  /* If it is an extended char the scan code */
  141.  /* will be left shifted 8 and returned     */
  142. int kb_peek(int key_number)      
  143.     {                 
  144.     int head, tail, code;
  145.     /* see if key_number of items are in the buffer */
  146.     if(key_number > kb_count())
  147.         return(0);
  148.  
  149.     head = peek(0x40, 0x1A);
  150.     tail = peek(0x40, 0x1C);
  151.  
  152.     /* advance the desired number of words */
  153.     head += (key_number - 1) * 2;    
  154.     if(head > 60)
  155.         head -= 32;      /* if head needs to wrap around */
  156.  
  157.     code = (peek(0x40,head) & 0xFF);
  158.     if(code == 0)
  159.         code = (peek(0x40,head) & 0xFF00);   
  160.         /* extended scan sent instead of ascii */
  161.  
  162.     return(code);
  163.     }
  164.  
  165.  
  166.  
  167.  
  168.  
  169.  
  170. void kb_clear(void)  /* empty buffer data */
  171.     {
  172.     int head, tail;
  173.  
  174.     head = peek(0x40, 0x1A);
  175.     tail = peek(0x40, 0x1C);
  176.  
  177.     poke(0x40,0x1C,head);   /* set tail = head */
  178.     }
  179.  
  180.