home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 15 / 15.iso / s / s196 / 2.img / IBMPC.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1991-08-13  |  3.5 KB  |  153 lines
  1. //         IBMPC.CPP
  2. //
  3. // Low-level functions addressing BIOS & PC Hardware
  4. //
  5. // Original code written by:  Al Stevens for the Aztec C compiler
  6. // Modified for Turbo C++ 2.0
  7. //
  8. // Compile to object using BCC or BCCX:
  9. // bccx -c ibmpc
  10. //
  11. // To use TASM remove the comment prior to the #pragma inline and compile.
  12. // This provides a good example where inline statements should be used.  The
  13. // best example is Al Steven's use of inline statements to quickly retrieve
  14. // system information on video retrace.
  15. //
  16.  
  17. // #pragma inline
  18. #include <dos.h>
  19. static union REGS rg;
  20.  
  21. //             position the cursor
  22.  
  23. void pascal  cursor(int x, int y)
  24. {
  25.     rg.x.ax = 0x0200;
  26.     rg.x.bx = 0;
  27.     rg.x.dx = ((y << 8) & 0xff00) + x;
  28.     int86(16, &rg, &rg);
  29. }
  30.  
  31. //              return the cursor position
  32. void pascal  curr_cursor(int *x, int *y)
  33. {
  34.     rg.x.ax = 0x0300;
  35.     rg.x.bx = 0;
  36.     int86(16, &rg, &rg);
  37.     *x = rg.h.dl;
  38.     *y = rg.h.dh;
  39. }
  40.  
  41. //             set cursor type
  42. void pascal  set_cursor_type(int t)
  43. {
  44.     rg.x.ax = 0x0100;
  45.     rg.x.bx = 0;
  46.     rg.x.cx = t;
  47.     int86(16, &rg, &rg);
  48. }
  49. char attrib = 7;
  50.  
  51. //               clear the screen
  52.  
  53. void pascal  clear_screen()
  54. {
  55.     cursor(0, 0);
  56.     rg.h.al = ' ';
  57.     rg.h.ah = 9;
  58.     rg.x.bx = attrib;
  59.     rg.x.cx = 2000;
  60.     int86(16, &rg, &rg);
  61. }
  62.  
  63. //             return the video mode
  64. int pascal  vmode()
  65. {
  66.     rg.h.ah = 15;
  67.     int86(16, &rg, &rg);
  68.     return rg.h.al;
  69. }
  70.  
  71. //          test for scroll lock
  72. int pascal   scroll_lock()
  73. {
  74.     rg.x.ax = 0x0200;
  75.     int86(0x16, &rg, &rg);
  76.     return rg.h.al & 0x10;
  77. }
  78. void (*helpfunc)();
  79. int helpkey = 0;
  80. int helping = 0;
  81.  
  82. //     insert a character and attribute into video RAM
  83.  
  84. void pascal  vpoke(unsigned vseg, unsigned adr, unsigned chr)
  85. {
  86.     if (vseg == 45056)            /* monochrome mode */
  87.         poke(vseg, adr, chr);
  88.     else    {
  89.         _DI = adr;        /* offset of video character */
  90.         _ES = vseg;        /* video segment */
  91.         asm cld;
  92.         _BX = chr;        /* the attribute and character */
  93.         _DX = 986;        /* video status port */
  94.                 //        wait for video retrace to start
  95.         do
  96.             asm in  al,dx;
  97.         while (_AL & 1);
  98.                 //        wait for video retrace to stop
  99.         do
  100.             asm in  al,dx;
  101.         while (!(_AL & 1));
  102.         _AL = _BL;
  103.         asm stosb;        /* store character */
  104.                 //        wait for video retrace to start
  105.         do
  106.             asm in  al,dx;
  107.         while (_AL & 1);
  108.                 //        wait for video retrace to stop
  109.         do
  110.             asm in  al,dx;
  111.         while (!(_AL & 1));
  112.         _AL = _BH;
  113.                 asm stosb;              // store attribute
  114.     }
  115. }
  116.  
  117. //      read a character and attribute from video RAM
  118. int pascal  vpeek(unsigned vseg, unsigned adr)
  119. {
  120.     int ch, at;
  121.  
  122.         if (vseg == 45056)                              // monochrome mode
  123.         return peek(vseg, adr);
  124.     asm push ds;
  125.         _DX = 986;                      // video status port
  126.         _DS = vseg;                     // video segment address
  127.         _SI = adr;                      // video character offset
  128.     asm cld;
  129.         //        wait for video retrace to start
  130.     do
  131.         asm in  al,dx;
  132.     while (_AL & 1);
  133.         //        wait for video retrace to stop
  134.     do
  135.         asm in  al,dx;
  136.     while (!(_AL & 1));
  137.     asm lodsb;            /* get the character */
  138.     _BL = _AL;
  139.         //        wait for video retrace to start
  140.     do
  141.         asm in  al,dx;
  142.     while (_AL & 1);
  143.         //        wait for video retrace to stop
  144.     do
  145.         asm in  al,dx;
  146.     while (!(_AL & 1));
  147.         asm lodsb;                      // get the attribute
  148.     _BH = _AL;
  149.     _AX = _BX;
  150.     asm pop ds;
  151.     return _AX;
  152. }
  153.