home *** CD-ROM | disk | FTP | other *** search
/ The Fred Fish Collection 1.5 / ffcollection-1-5-1992-11.iso / ff_disks / 100-199 / ff197.lzh / Stevie / dos.c < prev    next >
C/C++ Source or Header  |  1989-03-28  |  4KB  |  239 lines
  1. static char     RCSid[] =
  2. "$Header: dos.c,v 1.1 88/05/03 14:22:16 tony Exp $";
  3.  
  4. /*
  5.  * DOS System-dependent routines.
  6.  *
  7.  * System-specific code for MS-DOS. This has been tested with
  8.  * MSDOS 3.3 on an AT. Also, the console driver "nansi.sys" is
  9.  * required.
  10.  *
  11.  * $Log:    dos.c,v $
  12.  * Revision 1.1  88/05/03  14:22:16  tony
  13.  * Initial revision
  14.  * 
  15.  *
  16.  */
  17.  
  18. #include "stevie.h"
  19.  
  20. /*
  21.  * inchar() - get a character from the keyboard
  22.  */
  23. int
  24. inchar()
  25. {
  26.     int             c;
  27.  
  28.     for (;; beep()) {        /* loop until we get a valid character */
  29.  
  30.     flushbuf();        /* flush any pending output */
  31.  
  32.     switch (c = getch()) {
  33.       case 0x1e:
  34.         return K_CGRAVE;
  35.       case 0:        /* special key */
  36.         if (State != NORMAL) {
  37.         c = getch();    /* throw away next char */
  38.         continue;    /* and loop for another char */
  39.         }
  40.         switch (c = getch()) {
  41.           case 0x50:
  42.         return K_DARROW;
  43.           case 0x48:
  44.         return K_UARROW;
  45.           case 0x4b:
  46.         return K_LARROW;
  47.           case 0x4d:
  48.         return K_RARROW;
  49.           case 0x52:
  50.         return K_INSERT;
  51.           case 0x47:
  52.         stuffReadbuff("1G");
  53.         return -1;
  54.           case 0x4f:
  55.         stuffReadbuff("G");
  56.         return -1;
  57.           case 0x51:
  58.         stuffReadbuff(mkstr(CTRL('F')));
  59.         return -1;
  60.           case 0x49:
  61.         stuffReadbuff(mkstr(CTRL('B')));
  62.         return -1;
  63.         /*
  64.          * Hard-code some useful function key macros. 
  65.          */
  66.           case 0x3b:    /* F1 */
  67.         stuffReadbuff(":p\n");
  68.         return -1;
  69.           case 0x54:    /* SF1 */
  70.         stuffReadbuff(":p!\n");
  71.         return -1;
  72.           case 0x3c:    /* F2 */
  73.         stuffReadbuff(":n\n");
  74.         return -1;
  75.           case 0x55:    /* SF2 */
  76.         stuffReadbuff(":n!\n");
  77.         return -1;
  78.           case 0x3d:    /* F3 */
  79.         stuffReadbuff(":e #\n");
  80.         return -1;
  81.           case 0x3e:    /* F4 */
  82.         stuffReadbuff(":rew\n");
  83.         return -1;
  84.           case 0x57:    /* SF4 */
  85.         stuffReadbuff(":rew!\n");
  86.         return -1;
  87.           case 0x3f:    /* F5 */
  88.         stuffReadbuff("[[");
  89.         return -1;
  90.           case 0x40:    /* F6 */
  91.         stuffReadbuff("]]");
  92.         return -1;
  93.           case 0x41:    /* F7 */
  94.         stuffReadbuff("<<");
  95.         return -1;
  96.           case 0x42:    /* F8 */
  97.         stuffReadbuff(">>");
  98.         return -1;
  99.           case 0x43:    /* F9 */
  100.         stuffReadbuff(":x\n");
  101.         return -1;
  102.           case 0x44:    /* F10 */
  103.         stuffReadbuff(":help\n");
  104.         return -1;
  105.           default:
  106.         break;
  107.         }
  108.         break;
  109.  
  110.       default:
  111.         return c;
  112.     }
  113.     }
  114. }
  115.  
  116. #define    BSIZE    2048
  117. static char     outbuf[BSIZE];
  118. static int      bpos = 0;
  119.  
  120. flushbuf()
  121. {
  122.     if (bpos != 0)
  123.     write(1, outbuf, bpos);
  124.     bpos = 0;
  125. }
  126.  
  127. /*
  128.  * Macro to output a character. Used within this file for speed.
  129.  */
  130. #define    outone(c)    outbuf[bpos++] = c; if (bpos >= BSIZE) flushbuf()
  131.  
  132. /*
  133.  * Function version for use outside this file.
  134.  */
  135. void
  136. outchar(c)
  137.     register char   c;
  138. {
  139.     outbuf[bpos++] = c;
  140.     if (bpos >= BSIZE)
  141.     flushbuf();
  142. }
  143.  
  144. static char     cell[2] = {0, 7};
  145.  
  146. /*
  147.  * outstr(s) - write a string to the console
  148.  */
  149. void
  150. outstr(s)
  151.     register char  *s;
  152. {
  153.     while (*s) {
  154.     outone(*s++);
  155.     }
  156. }
  157.  
  158. void
  159. beep()
  160. {
  161.     if (RedrawingDisabled)
  162.     return;
  163.  
  164.     outone('\007');
  165. }
  166.  
  167. void
  168. sleep(n)
  169.     int             n;
  170. {
  171.     /*
  172.      * Should do something reasonable here. 
  173.      */
  174. }
  175.  
  176. void
  177. delay()
  178. {
  179.     long            l;
  180.  
  181.     flushbuf();
  182.     /*
  183.      * Should do something better here... 
  184.      */
  185.     for (l = 0; l < 5000; l++);
  186. }
  187.  
  188. void
  189. windinit()
  190. {
  191.     Columns = 80;
  192.     P(P_LI) = Rows = 25;
  193. }
  194.  
  195. void
  196. windexit(r)
  197.     int             r;
  198. {
  199.     flushbuf();
  200.     exit(r);
  201. }
  202.  
  203. void
  204. windgoto(r, c)
  205.     register int    r, c;
  206. {
  207.     r += 1;
  208.     c += 1;
  209.  
  210.     /*
  211.      * Check for overflow once, to save time. 
  212.      */
  213.     if (bpos + 8 >= BSIZE)
  214.     flushbuf();
  215.  
  216.     outbuf[bpos++] = '\033';
  217.     outbuf[bpos++] = '[';
  218.     if (r >= 10)
  219.     outbuf[bpos++] = r / 10 + '0';
  220.     outbuf[bpos++] = r % 10 + '0';
  221.     outbuf[bpos++] = ';';
  222.     if (c >= 10)
  223.     outbuf[bpos++] = c / 10 + '0';
  224.     outbuf[bpos++] = c % 10 + '0';
  225.     outbuf[bpos++] = 'H';
  226. }
  227.  
  228. FILE           *
  229. fopenb(fname, mode)
  230.     char           *fname;
  231.     char           *mode;
  232. {
  233.     FILE           *fopen();
  234.     char            modestr[16];
  235.  
  236.     sprintf(modestr, "%sb", mode);
  237.     return fopen(fname, modestr);
  238. }
  239.