home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / dos / screen / tty / tty.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1992-03-11  |  3.9 KB  |  321 lines
  1. //    Written by Chris Sokol
  2.  
  3. #include <string.h>
  4. #include "tty.h"
  5.  
  6. int    TTY::Avail()
  7. {
  8.     return TTYAvail(handle);
  9. }
  10.  
  11. int    TTY::Baud(ulong br)
  12. {
  13.     int    bs;
  14.  
  15.     if (br == 300)
  16.         bs = TTY300;
  17.     else if (br == 1200)
  18.         bs = TTY1200;
  19.     else if (br == 2400)
  20.         bs = TTY2400;
  21.     else if (br == 4800)
  22.         bs = TTY4800;
  23.     else if (br == 9600)
  24.         bs = TTY9600;
  25.     else if (br == 19200)
  26.         bs = TTY19200;
  27.     else if (br == 38400)
  28.         bs = TTY38400;
  29.     else if (br == 57600)
  30.         bs = TTY57600;
  31.     else if (br == 115200)
  32.         bs = TTY115200;
  33.     else
  34.         return 0;
  35.  
  36.     error = TTYPut(handle, TTYtxbaud << 8 + bs);
  37.  
  38.     return !error;
  39. }
  40.  
  41. int    TTY::Bits(uint bits)
  42. {
  43.     if (bits < 5 || bits > 8)
  44.         return 0;
  45.  
  46.     linctl &= 0xfc;
  47.     linctl |= bits - 5;
  48.  
  49.     outlinc = 1;
  50.  
  51.     return 1;
  52. }
  53.  
  54. int    TTY::Brk(int on)
  55. {
  56.     if (on)
  57.         linctl |= 0x40;
  58.     else
  59.         linctl &= 0xbf;
  60.  
  61.     outlinc = 1;
  62.  
  63.     return 1;
  64. }
  65.  
  66. int    TTY::CTS()
  67. {
  68.     return !!(mdmstat & 0x10);
  69. }
  70.  
  71. int    TTY::Done()
  72. {
  73.     return TTYDone(handle);
  74. }
  75.  
  76. int    TTY::DSR()
  77. {
  78.     return !!(mdmstat & 0x20);
  79. }
  80.  
  81. int    TTY::DTR(int on)
  82. {
  83.     if (on)
  84.         mdmctl |= 1;
  85.     else
  86.         mdmctl &= 0xfe;
  87.  
  88.     outmdmc = 1;
  89.  
  90.     return 1;
  91. }
  92.  
  93. int    TTY::Error()
  94. {
  95.     int    err = error;
  96.  
  97.     error = 0;
  98.     return err;
  99. }
  100.  
  101. void    TTY::FlushCtl()
  102. {
  103.     if (outlinc)
  104.         if (!TTYPut(handle, TTYtxlinc << 8 | linctl))
  105.             outlinc = 0;
  106.  
  107.     if (outmdmc)
  108.         if (!TTYPut(handle, TTYtxmdmc << 8 | mdmctl))
  109.             outmdmc = 0;
  110. }
  111.  
  112. uint    TTY::Get()
  113. {
  114.     uint    d;
  115.  
  116.     d = TTYGet(handle);
  117.  
  118.     switch (d / 256)
  119.         {
  120.         case TTYrxlins:
  121.             linstat = d & 0xff;
  122.             break;
  123.  
  124.         case TTYrxmdms:
  125.             mdmstat = d & 0xff;
  126.             break;
  127.         }
  128.  
  129.     return d;
  130. }
  131.  
  132. int    TTY::Opened()
  133. {
  134.     return (handle >= 0);
  135. }
  136.  
  137. int    TTY::Prty(char p)
  138. {
  139.     uchar    pbits;
  140.  
  141.     switch (p)
  142.         {
  143.         case '-':
  144.             pbits = 0;
  145.             break;
  146.  
  147.         case 'e':
  148.             pbits = 0x18;
  149.             break;
  150.  
  151.         case 'm':
  152.             pbits = 0x38;
  153.             break;
  154.  
  155.         case 'o':
  156.             pbits = 0x08;
  157.             break;
  158.  
  159.         case 's':
  160.             pbits = 0x28;
  161.             break;
  162.  
  163.         default:
  164.             return 0;
  165.         }
  166.  
  167.     linctl &= 0xc7;
  168.     linctl |= pbits;
  169.  
  170.     outlinc = 1;
  171.  
  172.     return 1;
  173. }
  174.  
  175. int    TTY::Put(uchar c)
  176. {
  177.     if (outmdmc || outlinc)
  178.         FlushCtl();
  179.  
  180.     error = TTYPut(handle, TTYtxchar << 8 | c);
  181.  
  182.     return !error;
  183. }
  184.  
  185. int    TTY::RING()
  186. {
  187.     return !!(mdmstat & 0x40);
  188. }
  189.  
  190. int    TTY::RLSD()
  191. {
  192.     return !!(mdmstat & 0x80);
  193. }
  194.  
  195. int    TTY::RTS(int on)
  196. {
  197.     if (on)
  198.         mdmctl |= 0x02;
  199.     else
  200.         mdmctl &= 0xfd;
  201.  
  202.     outmdmc = 1;
  203.  
  204.     return 1;
  205. }
  206.  
  207. int    TTY::Stop(uint bits)
  208. {
  209.     if (!bits || bits > 2)
  210.         return 0;
  211.  
  212.     if (bits == 2)
  213.         linctl |= 0x04;
  214.     else
  215.         linctl &= 0xfb;
  216.  
  217.     outlinc = 1;
  218.  
  219.     return 1;
  220. }
  221.  
  222. TTY::TTY(char *name, uint rxl, uint txl)
  223. {
  224.     char    pname[11];
  225.     int    io, irq, type;
  226.  
  227.     strncpy(pname, name, 10);
  228.     pname[10] = 0;
  229.  
  230.     strupr(pname);
  231.  
  232.     if (!strcmp(pname, "COM1"))
  233.         {
  234.         io        = 0x3f8;
  235.         irq    = 4;
  236.         type    = TTYnorm;
  237.         }
  238.     else if (!strcmp(pname, "COM2"))
  239.         {
  240.         io        = 0x2f8;
  241.         irq    = 3;
  242.         type    = TTYnorm;
  243.         }
  244.     else if (!strcmp(pname, "COM3"))
  245.         {
  246.         io        = 0x3e8;
  247.         irq    = 4;
  248.         type    = TTYnorm;
  249.         }
  250.     else if (!strcmp(pname, "COM4"))
  251.         {
  252.         io        = 0x2e8;
  253.         irq    = 3;
  254.         type    = TTYnorm;
  255.         }
  256.     else if (!memcmp(pname, "VER", 3))
  257.         {
  258.         int    pnum;
  259.  
  260.         if (pname[3] >= '0' && pname[3] <= '7')
  261.             pnum = pname[3] - '0';
  262.         else
  263.             {
  264.             error = TTYbadtype;
  265.             handle = -1;
  266.  
  267.             return;
  268.             }
  269.  
  270.         io        = 0x280;
  271.         irq    = 15;
  272.         type    = TTYv8at0 + pnum;
  273.         }
  274.  
  275.     linctl    = 3;
  276.     linstat    = 0;
  277.     mdmctl    = 9;
  278.     mdmstat    = 0;
  279.     outlinc    = 0;
  280.     outmdmc    = 0;
  281.     rxbuf        = new uint[rxl];
  282.     rxlen        = rxl;
  283.     txbuf        = new uint[txl];
  284.     txlen        = txl;
  285.  
  286.     error = TTYOpen(io, irq, type, rxbuf, rxlen, txbuf, txlen);
  287.  
  288.     if (error >= 0)
  289.         {
  290.         handle = error;
  291.         error = 0;
  292.         }
  293.     else
  294.         handle = -1;
  295. }
  296.  
  297. TTY::~TTY()
  298. {
  299.     if (handle >= 0)
  300.         {
  301.         TTYClose(handle);
  302.  
  303.         delete rxbuf;
  304.         delete txbuf;
  305.         }
  306. }
  307.  
  308. int    TTY::WaitCTS(int ena)
  309. {
  310.     error = TTYPut(handle, (TTYtxhwfc << 8) | !!ena);
  311.  
  312.     return !error;
  313. }
  314.  
  315. int    TTY::XOnOff(int ena)
  316. {
  317.     error = TTYPut(handle, (TTYtxxofc << 8) | !!ena);
  318.  
  319.     return !error;
  320. }
  321.