home *** CD-ROM | disk | FTP | other *** search
/ Black Box 4 / BlackBox.cdr / progc / xdev_118.arj / XEDIT.LZH / XEDIT4.C < prev    next >
C/C++ Source or Header  |  1992-04-01  |  6KB  |  339 lines
  1.  
  2. /* Low-level functions addressing BIOS & PC Hardware */
  3.  
  4. #include <dos.h>
  5. #include <stdlib.h>
  6. #include "keys.h"
  7.  
  8. #pragma inline
  9.  
  10. static union REGS rg;
  11. static int mtask=0;
  12.  
  13. #define DVID    1
  14. #define DDOSID  2
  15. #define MOSID   3
  16. #define TVID    4
  17.  
  18. void pascal set_mtask (void);
  19. int  pascal is_dv (void);
  20. int  pascal is_ddos (void);
  21. int  pascal is_mos (void);
  22. int  pascal is_tv (void);
  23. void pascal pause_dv (void);
  24. void pascal pause_ddos (void);
  25. void pascal pause_tv (void);
  26. void pascal pause_mos (void);
  27.  
  28. #ifdef USECLOCK
  29.     extern void pascal print_clock(void);
  30. #endif
  31.  
  32.  
  33.  
  34.  
  35.  
  36. /* Position cursor */
  37.  
  38. void pascal cursor (int x, int y) {
  39.  
  40.   _AX = 0x0200;
  41.   _BX = 0;
  42.   _DX = ((y << 8) & 0xff00) + x;
  43.   geninterrupt(16);
  44.   /*
  45.   rg.x.ax = 0x0200;
  46.   rg.x.bx = 0;
  47.   rg.x.dx = (( y << 8) & 0xff00) + x;
  48.   int86 (16,&rg,&rg);
  49.   */
  50. }
  51.  
  52. /* Return cursor position */
  53.  
  54. void pascal curr_cursor (int *x,int *y) {
  55.  
  56.   _AX = 0x0300;
  57.   _BX = 0;
  58.   geninterrupt(16);
  59.   *x = _DL;
  60.   *y = _DH;
  61. }
  62.  
  63. /* Set cursor type */
  64.  
  65. void pascal set_cursor_type (int t) {
  66.  
  67.   _AX = 0x0100;
  68.   _BX = 0;
  69.   _CX = t;
  70.   geninterrupt(16);
  71. }
  72.  
  73. char attrib = 7;
  74.  
  75. /* Clear screen */
  76.  
  77. void pascal clear_screen () {
  78.  
  79.   cursor (0,0);
  80.   _AL = ' ';
  81.   _AH = 9;
  82.   _BX = attrib;
  83.   _CX = 2000;
  84.   geninterrupt(16);
  85. }
  86.  
  87. /* Return video mode */
  88.  
  89. int pascal vmode () {
  90.  
  91.   _AH = 15;
  92.   geninterrupt(16);
  93.   return _AL;
  94. }
  95.  
  96. /* Test for scroll lock */
  97.  
  98. int pascal scroll_lock () {
  99.  
  100.   _AX = 0x0200;
  101.   geninterrupt(0x16);
  102.   return _AL & 0x10;
  103. }
  104.  
  105. void (*helpfunc)();
  106. int helpkey=0;
  107. int helping=0;
  108.  
  109. /* check for keyboard press */
  110.  
  111. int pascal kb_hit () {
  112.  
  113.     _AH = 0x0b;
  114.     geninterrupt(0x21);
  115.     if(!_AL) {
  116. #ifdef USECLOCK
  117.         print_clock();
  118. #endif
  119.         switch(mtask) {
  120.             case DVID:      pause_dv();
  121.                             break;
  122.             case DDOSID:    pause_ddos();
  123.                             break;
  124.             case TVID:      pause_tv();
  125.                             break;
  126.             case MOSID:     pause_mos();
  127.                             break;
  128.         }
  129.         geninterrupt(0x28);     /* scheduler interrupt */
  130.         return 0;
  131.     }
  132.     return 1;
  133. }
  134.  
  135. /* Get a keyboard character */
  136.  
  137. int pascal get_char () {
  138.  
  139.   int c;
  140.  
  141.   while(1) {
  142.     _AH = 0x0b;
  143.     geninterrupt(0x21);
  144.     if (!_AL) {
  145. #ifdef USECLOCK
  146.       print_clock();
  147. #endif
  148.         switch(mtask) {
  149.             case DVID:      pause_dv();
  150.                             break;
  151.             case DDOSID:    pause_ddos();
  152.                             break;
  153.             case TVID:      pause_tv();
  154.                             break;
  155.             case MOSID:     pause_mos();
  156.                             break;
  157.         }
  158.         geninterrupt(0x28); /* scheduler interrupt */
  159.       continue;
  160.     }
  161.     rg.h.ah=0;
  162.     int86(0x16,&rg,&rg);
  163.     if (rg.h.al == 0) c=rg.h.ah | 128;
  164.     else c=rg.h.al;
  165.  
  166.     /* handle special keys */
  167.  
  168.     if (c==helpkey && helpfunc) {
  169.        if (!helping) {
  170.          helping=1;
  171.          (*helpfunc)();
  172.          helping=0;
  173.          continue;
  174.        }
  175.      }
  176.  
  177.      break;
  178.    }
  179.    return c;
  180. }
  181.  
  182.  
  183. void pascal vpoke (unsigned vseg, unsigned adr, unsigned chr) {
  184.  
  185.     if (vseg == 45056U)
  186.         poke(vseg,adr,chr);
  187.     else {
  188.         _DI=adr;
  189.         _ES=vseg;
  190.         asm cld;
  191.         _BX=chr;
  192.         _DX=986;
  193.  
  194.         do
  195.             asm in al,dx;
  196.         while (_AL & 1);
  197.  
  198.         do
  199.             asm in al,dx;
  200.         while (!(_AL & 1));
  201.         _AL = _BL;
  202.         asm stosb;
  203.  
  204.         do
  205.             asm in al,dx;
  206.         while (_AL & 1);
  207.  
  208.         do
  209.             asm in al,dx;
  210.         while(!(_AL & 1));
  211.         _AL = _BH;
  212.         asm stosb;
  213.     }
  214. }
  215.  
  216. int pascal vpeek (unsigned vseg, unsigned adr) {
  217.  
  218.     if (vseg == 45056U)
  219.         return peek(vseg,adr);
  220.     asm push ds;
  221.     _DX=986;
  222.     _DS=vseg;
  223.     _SI=adr;
  224.     asm cld;
  225.  
  226.     do
  227.         asm in al,dx;
  228.     while(_AL & 1);
  229.  
  230.     do
  231.         asm in al,dx;
  232.     while(!(_AL & 1));
  233.     asm lodsb;
  234.     _BL = _AL;
  235.  
  236.     do
  237.         asm in al,dx;
  238.     while(_AL & 1);
  239.  
  240.     do
  241.         asm in al,dx;
  242.     while(!(_AL & 1));
  243.     asm lodsb;
  244.     _BH=_AL;
  245.     _AX=_BX;
  246.     asm pop ds;
  247.     return _AX;
  248. }
  249.  
  250.  
  251. void pascal set_mtask (void) {
  252.  
  253.     if(is_dv()) mtask=DVID;
  254.     else if(is_ddos()) mtask=DDOSID;
  255.     else if(is_mos()) mtask=MOSID;
  256.     else if(is_tv()) mtask=TVID;
  257. }
  258.  
  259.  
  260. int pascal is_dv (void) {
  261.  
  262.     rg.x.cx=0x4445;
  263.     rg.x.dx=0x5351;
  264.     rg.x.ax=0x2b01;
  265.     int86(0x21,&rg,&rg);
  266.     if(rg.h.al==0xff) return 0;
  267.     return rg.x.bx;
  268. }
  269.  
  270.  
  271. int pascal is_ddos (void) {
  272.  
  273.     rg.h.ah=0xe4;
  274.     int86(0x21,&rg,&rg);
  275.     if(rg.h.al==1 || rg.h.al==2) return 1;
  276.     return 0;
  277. }
  278.  
  279.  
  280. int pascal is_mos (void) {
  281.  
  282.     int temp;
  283.  
  284.     rg.h.ah=0x30;
  285.     int86(0x21,&rg,&rg);
  286.     temp=rg.x.ax;
  287.     rg.x.ax=0x3000;
  288.     rg.x.bx=0x3000;
  289.     rg.x.cx=0x3000;
  290.     rg.x.dx=0x3000;
  291.     int86(0x21,&rg,&rg);
  292.     if(rg.x.ax==temp) return temp;
  293.     return 0;
  294. }
  295.  
  296.  
  297. int pascal is_tv (void) {
  298.  
  299.     rg.x.ax=0x1022;
  300.     rg.x.bx=0;
  301.     int86(0x15,&rg,&rg);
  302.     if(!rg.x.bx) return 0;
  303.     return rg.x.bx;
  304. }
  305.  
  306.  
  307. void pascal pause_dv (void) {
  308.  
  309.     _AX = 0x0101a;
  310.     geninterrupt(0x15);
  311.     _AX = 0x1000;
  312.     geninterrupt(0x15);
  313.     _AX = 0x1025;
  314.     geninterrupt(0x15);
  315. }
  316.  
  317.  
  318. void pascal pause_ddos (void) {
  319.  
  320.     geninterrupt(0xf4);
  321. }
  322.  
  323.  
  324. void pascal pause_tv (void) {
  325.  
  326.     _AX = 0x1000;
  327.     geninterrupt(0x15);
  328. }
  329.  
  330.  
  331. void pascal pause_mos (void) {
  332.  
  333.     _AX = 0x0703;
  334.     _BX = 0x03;
  335.     _CX = 0;
  336.     _DX = 0;
  337.     geninterrupt(0x38);
  338. }
  339.