home *** CD-ROM | disk | FTP | other *** search
/ Power Programming / powerprogramming1994.iso / progtool / editor / tvx_edit.arc / TVX_IBM.C < prev    next >
Text File  |  1986-03-17  |  9KB  |  313 lines
  1. /* ------------------------- tvx_ibm.c -------------------------- */
  2. /*
  3.     This is the interface to the PC's ROM BIOS.  It could
  4.     be bypassed by using the ANSI.SYS driver, but that would
  5.     be SLOW!  This version is cii-c86 dependent, mainly using
  6.     the routine sysint, for example:
  7.           sysint(0x10, &rin, &rout);
  8.         int. number^     ^registers in and out
  9.     If possible, these calls should be replaced with direct
  10.     assembly language calls.  The overhead of sysint is high
  11.     and noticeably slows down screen update.
  12. */
  13.  
  14. #define FALSE 0
  15. #define TRUE 1
  16. /*    Interface to IBM ROM BIOS INT10 screen control.  Following
  17.     control codes are defined:
  18.  
  19.     ^@,0    ^A,1    ^B,2    ^C,3
  20.     other, erslin, erseos, inslin
  21.     ^D,4    ^E,5    ^F,6    ^G,7
  22.     undlon, undloff, dellin, bell
  23.     ^H,8    ^I,9    ^J,10    ^K,11
  24.     backsp,    tab, linefeed, boldon
  25.     ^L,12    ^M,13    ^N,14    ^O,15
  26.     boldoff, enter, reversoff, blinkoff
  27.     ^P,16    ^Q,17    ^R,18    ^S,19, ^T,20
  28.     reverson, blinkon, setxy, cursor1, initcursor
  29.  */
  30. #define m_normal 07    /* white on black */
  31. #define m_underline 01    /* normal, underlined */
  32. #define m_reverse 0x70
  33. #define m_dim 0xF7    /* dim display */
  34. #define m_bright 0x08    /* bright display */
  35. #define m_blink    0x80    /* blink for errors */
  36. #define m_noblink 0x7F
  37.  
  38.  
  39. /* ============================ dispch ============================== */
  40.   dispch(chin)
  41.   int chin;
  42.   {
  43.  
  44.     static int ch;
  45.     struct regval
  46.       {
  47.     unsigned int ax;
  48.     unsigned int bx;
  49.     unsigned int cx;
  50.     unsigned int dx;
  51.     unsigned int si;
  52.     unsigned int di;
  53.     unsigned int ds;
  54.     unsigned int es;
  55.       };
  56.     struct regval rin, rout;
  57.  
  58.     /* data structures for screen control */
  59.     static int ich;
  60.     static int maxcol = 79;        /*  max col, counting from 0 */
  61.     static int savechar;
  62.     static int initflg = FALSE;
  63.     static int curpage = 0;        /* current display page (internal) */
  64.     static int curmode = 7;        /* white on black */
  65.     static int curcol;            /* col and row, preserve this order */
  66.     static int currow;            /* so can load in one instruction */
  67.     static int curstate = 0;        /* 0: accepting chars
  68.                        1: waiting for row
  69.                        2: waiting for col */
  70.     static int rowpend = 0;        /* to save pending row */
  71.     static int initcursor;        /* initial cursor */
  72.     static int altcursor;
  73.     static int color;        /* mono or color */
  74.  
  75.     ch = chin & 0xff;
  76.  
  77.     if (!initflg)
  78.       {
  79.     rin.ax = 0x0F00;        /* ah is 15, get video state */
  80.     sysint(0x10, &rin, &rout);    /* int 10h */
  81.     maxcol = ((rout.ax >> 8) & 0xff) - 1;    /* make relative value (0-79) */
  82.       curpage = (rout.bx >> 8) & 0xff;    /* the active page */
  83.     rin.ax = 0x0300;        /* read cursor position */
  84.     sysint(0x10, &rin, &rout);    /* int 10h */
  85.     curcol = rout.dx & 0xff;    /* low order is col */
  86.     currow = (rout.dx >> 8) & 0xff;
  87.     sysint(0x11,&rin,&rout);    /* get system configuration */
  88.     color = (rout.ax & 0x30) != 0x30;
  89.     if (!color)
  90.       {
  91.         initcursor = 0x0c0d;    /* 12, 13 - avoids PC ROM bug! */
  92.         altcursor = 0x060d;        /* 6,13 for insert */
  93.       }
  94.     else
  95.       {
  96.         initcursor = 0x0607;    /* current cursor mode, color */
  97.         altcursor = 0x0307;        /* half block */
  98.       }
  99.     initflg = TRUE;
  100.       }
  101.  
  102.  
  103.     if (curstate != 0)        /* waiting for row or col? */
  104.       {
  105.     if (curstate == 1)
  106.       {
  107.         /* in state 1, so this is row */
  108.         rowpend = ch;        /* save pending row */
  109.         curstate = 2;        /* now in wait state */
  110.         return;
  111.       }
  112.     else        /* waiting for column */
  113.       {
  114.         ich = ch - ' ';    /* convert to absolute */
  115.         if (ich > maxcol)
  116.         ich = maxcol;
  117.         curcol = ich;    /* remember column */
  118.         rowpend -= ' ';    /* convert row */
  119.         if (rowpend > 24)
  120.         rowpend = 24;
  121.         currow = rowpend;
  122.         rin.dx = (currow << 8) | curcol;
  123.         rin.bx = curpage << 8;
  124.         rin.ax = 0x200;    /* 2 => set cursor */
  125.         sysint(0x10, &rin, &rout);    /* int 10h */
  126.         curstate = 0;
  127.         return;
  128.       }
  129.       }
  130.     else
  131.       {
  132.     if (ch >= ' ')
  133.         goto SHOWCHAR;    /* slight optimization */
  134.  
  135.     switch (ch)
  136.       {
  137.         case 1:        /* erase from cursor to end of line */
  138. erslin:
  139.         rin.cx = rin.dx = currow << 8;        /* set row */
  140.         rin.cx |= curcol;        /* set col */
  141.         rin.dx |= maxcol;        /* blank to max col */
  142.         rin.ax = 0x600;          /* scroll active page up, blank section */
  143.         rin.bx = curmode << 8;
  144.         sysint(0x10, &rin, &rout);    /* int 10h */
  145.         return;
  146.  
  147.         case 2:        /* erase from cursor to end of screen */
  148.         /* first, earase current row */
  149.         rin.cx = rin.dx = currow << 8;        /* set row */
  150.         rin.cx |= curcol;        /* set col */
  151.         rin.dx |= maxcol;        /* blank to max col */
  152.         rin.ax = 0x600;          /* scroll active page up, blank section */
  153.         rin.bx = curmode << 8;
  154.         sysint(0x10, &rin, &rout);    /* int 10h */
  155.         if (currow >= 24)    /* on bottom row now? */
  156.             return;
  157.         rin.cx = (currow + 1) << 8;     /* next row, col 0 */
  158.         rin.dx = 0x1800 | maxcol;
  159.         rin.ax = 0x0600;        /* 6: scroll 0: blank */
  160.         sysint(0x10, &rin, &rout);    /* int 10h */
  161.         return;
  162.  
  163.         case 3:        /* insert a blank line at cursor */
  164.         if (currow < 24)
  165.           {
  166.             rin.cx = (currow << 8);
  167.             rin.dx = 0x1800 | maxcol;    /* define window to scroll */
  168.             rin.bx = curmode << 8;
  169.             rin.ax = 0x0701;        /* one line, scroll down */
  170.             sysint(0x10, &rin, &rout);    /* int 10h */
  171.           }
  172.         curcol = 0;        /* home to line beginning */
  173.         rin.dx = currow << 8;    /* dh = currow, dl = 0 */
  174.         rin.bx = curpage << 8;
  175.         rin.ax = 0x0200;    /* reset cursor position */
  176.         sysint(0x10, &rin, &rout);    /* int 10h */
  177.         if (currow >= 24)    /* special case */
  178.             goto erslin;
  179.         return;
  180.  
  181.         case 4:        /* underline on */
  182.         curmode = (curmode & 0x88) | m_underline;
  183.         return;
  184.  
  185.         case 5:        /* underline off */
  186.         curmode = (curmode & 0x88) | m_normal;
  187.         return;
  188.  
  189.         case 6:            /*  kill line cursor is on */
  190.         rin.cx = currow << 8;    /* define window to scroll */
  191.         rin.dx = 0x1800 | maxcol;
  192.         rin.ax = 0x0601;        /* one line (al), scroll up (6) */
  193.         rin.bx = curmode << 8;
  194.         sysint(0x10, &rin, &rout);    /* int 10h */
  195.         curcol = 0 ;        /* home to line beginning */
  196.         rin.dx = currow << 8;
  197.         rin.bx = curpage << 8;
  198.         rin.ax = 0x0200;
  199.         sysint(0x10, &rin, &rout);    /* int 10h */
  200.         return;
  201.  
  202.         case 7:        /* bell */
  203.         bdos(2,ch);
  204.         return;
  205.  
  206.         case 8:        /* backspace */
  207.         if (curcol <= 0)
  208.             return;
  209.         --curcol;
  210.         rin.bx = curpage << 8;
  211.         rin.dx = (currow << 8) | curcol;
  212.         rin.ax = 0x0200;    /* set cursor pos */
  213.         sysint(0x10, &rin, &rout);    /* int 10h */
  214.         return;
  215.  
  216.         case 9:        /* tab */
  217.         ch = ' ';
  218.         goto SHOWCHAR;
  219.  
  220.         case 10:        /* line feed, scroll if bottom */
  221.         if (currow < 24)
  222.           {
  223.             rin.dx = (++currow << 8) | curcol;
  224.             rin.bx = curpage << 8;
  225.             rin.ax = 0x0200;        /* set cursor */
  226.             sysint(0x10, &rin, &rout);    /* int 10h */
  227.           }
  228.         else
  229.           {
  230.             /* need to scroll up */
  231.             rin.ax = 0x0601;    /* scroll up (6) 1 line (1) */
  232.             rin.cx = 0;        /* upper right */
  233.             rin.dx = 0x1800 | maxcol;
  234.             rin.bx = curmode << 8;
  235.             sysint(0x10, &rin, &rout);    /* int 10h */
  236.           }
  237.         return;
  238.  
  239.         case 11:        /* bold on */
  240.         curmode |= m_bright;
  241.         return;
  242.  
  243.         case 12:        /* bold off */
  244.         curmode &= m_dim;
  245.         return;
  246.  
  247.         case 13:        /* CR, include erase end of line */
  248.         if (curcol >= maxcol)
  249.             goto NOBLANK;
  250.         rin.cx = rin.dx = currow << 8;        /* set row */
  251.         rin.cx |= curcol;        /* set col */
  252.         rin.dx |= maxcol;        /* blank to max col */
  253.         rin.ax = 0x0600;    /* scroll up, blank section */
  254.         rin.bx = curmode << 8;
  255.         sysint(0x10, &rin, &rout);    /* int 10h */
  256. NOBLANK:
  257.         curcol = 0;
  258.             rin.dx = (currow << 8);
  259.         rin.bx = curpage << 8;
  260.         rin.ax = 0x0200;
  261.         sysint(0x10, &rin, &rout);    /* int 10h */
  262.         return;
  263.  
  264.         case 14:        /* reverse off */
  265.         curmode = (curmode & 0x88) | m_normal ;
  266.         return;
  267.  
  268.         case 15:        /* blink off */
  269.         curmode &= m_noblink;
  270.         return;
  271.  
  272.         case 16:        /* reverse on */
  273.         curmode = (curmode & 0x88) | m_reverse;
  274.         return;
  275.  
  276.         case 17:        /* blink on */
  277.         curmode |= m_blink;
  278.         return;
  279.  
  280.         case 18:        /* set xy */
  281.         curstate = 1;
  282.         return;
  283.  
  284.         case 19:            /* change cursor */
  285.         rin.ax = 0x0100;    /* set cursor type */
  286.         rin.cx = altcursor;    /* half block */
  287.         sysint(0x10, &rin, &rout);
  288.         return;
  289.  
  290.         case 20:            /* change cursor */
  291.         rin.ax = 0x0100;    /* set cursor type */
  292.         rin.cx = initcursor;    /* original */
  293.         sysint(0x10, &rin, &rout);
  294.         return;
  295.  
  296.  
  297.         default:        /* show char */
  298. SHOWCHAR:
  299.         if (curcol > maxcol)    /* update column */
  300.             return;
  301.         rin.ax = 0x0900 | ch;        /* display char */
  302.         rin.bx = (curpage << 8) | curmode;
  303.         rin.cx = 1;
  304.         sysint(0x10, &rin, &rout);    /* int 10h */
  305.         ++curcol;
  306.         rin.dx = (currow << 8) | curcol;
  307.         rin.ax = 0x0200;
  308.         sysint(0x10, &rin, &rout);    /* int 10h */
  309.         return;
  310.       }    /* end of switch */
  311.       }        /* end of else */
  312.   }
  313.