home *** CD-ROM | disk | FTP | other *** search
/ The Unsorted BBS Collection / thegreatunsorted.tar / thegreatunsorted / programming / pascal_programming / yasync.pas < prev    next >
Pascal/Delphi Source File  |  2001-02-10  |  39KB  |  1,074 lines
  1. {$R-,S-,I-,D+,T+,F-,V+,B-,N-,L+ }
  2. Unit YAsync; { Version 1.4 }
  3.  
  4. Interface
  5.  
  6. Uses Dos, Crt;
  7.  
  8. Const
  9.   YasyncVersion = 14; { Current version * 10 }
  10.   MaxPorts = 4;       { Maximum number of ports supported }
  11.   DefaultBufferSize = 2048; { Default size of receive & transmit buffers }
  12.   BaudRateDividend : LongInt = 115200; { Used to compute baud rate divisor }
  13.   TimeoutMilliseconds : LongInt = 1000; { Retry Send until timeout ms }
  14.   BreakMiliseconds : Word = 300; { Duration of break signal }
  15.  
  16.   { These constants define the bits for the Line Status Register }
  17.   LSRRcvReady = $01;  { Received data ready }
  18.   LSROverrun  = $02;  { OverRun error }
  19.   LSRParity   = $04;  { Parity error }
  20.   LSRFrame    = $08;  { Framing error }
  21.   LSRBreak    = $10;  { Break detected }
  22.   LSRXhReady  = $20;  { Transmit hold register empty }
  23.   LSRXsReady  = $40;  { Transmit shift register empty }
  24.   LSRTimeout  = $80;  { Time out (software implemented) }
  25.  
  26.   { These constants define the bits for the Modem Status Register }
  27.   MSRctsDelta = $01;  { Clear To Send changed }
  28.   MSRdsrDelta = $02;  { DataSet Ready changed }
  29.   MSRriDelta  = $04;  { Ring Indicate changed }
  30.   MSRcdDelta  = $08;  { Carrier Detect changed }
  31.   MSRcts      = $10;  { Clear To Send }
  32.   MSRdsr      = $20;  { DataSet Ready }
  33.   MSRri       = $40;  { Ring Indicate }
  34.   MSRcd       = $80;  { Carrier Detect }
  35.  
  36. Type
  37.   AsyncBuffer = Array[0..32767] Of Byte;
  38.   {
  39.     Note, AsyncBuffer is for the buffer pointer declarations below.  The actual
  40.     buffer size is specified in Async_Control.
  41.   }
  42.   Async_Control = Record
  43.   {
  44.     This record contains control information used to manage the activity of
  45.     a port.  Certain fields may be altered before calling OpenPort.  These
  46.     are marked with an "*" in the comments.  For instance...
  47.  
  48.       With AsyncPort[2] Do Begin
  49.     ReceiveSize := 10000;
  50.     TransmitSize := 8000;
  51.     WaitForXon := True;
  52.     XoHand := True;
  53.     XoTransparent := False;
  54.       End;
  55.       OpenPort(2, 9600, 7, 1, 'E');
  56.  
  57.     ...sets buffer sizes and Xon/Xoff handshaking for COM2 and opens COM2 at
  58.     9600 bps, 7 bits, 1 stop bit, even parity.  Fields not marked with "*"
  59.     in comments are used internally by YAsync; do not alter these fields.
  60.     Do not alter any fields while a port is open.
  61.   }
  62.     PortOpen : Boolean;       { True if port is currently open }
  63.     VectorIndex : Byte;       { Index to interrupt vector save area }
  64.  
  65.     IrqNumber : Byte;         { *IRQ number }
  66.     IntNumber : Byte;         { *Interrupt number }
  67.     BasePort : Word;          { *Base I/O port for UART }
  68.     {
  69.       The IRQ, Interrupt and base port numbers are set to default values during
  70.       initialization.  The defaults (see implementation Const's for details)
  71.       should be appropriate for most systems, but they may be reset if
  72.       necessary before calling OpenPort.
  73.     }
  74.     LineStatus : Byte;        { Line status register for ErrorRoutine,
  75.                   Decode with LSRxxx constants above }
  76.     ModemStatus : Byte;       { Modem status register for ModemRoutine,
  77.                   Decode with MSRxxx constants above }
  78.     UserData : Word;          { This field is unused by YAsync routines }
  79.  
  80.     WaitForXon : Boolean;     { *Inhibit transmit between Xoff and Xon }
  81.     WaitForCts : Boolean;     { *Inhibit transmit if not Cts }
  82.     WaitForDsr : Boolean;     { *Inhibit transmit if not Dsr }
  83.     WaitForCd  : Boolean;     { *Inhibit transmit if not Cd }
  84.     XoHand : Boolean;         { *Handshake receive buffer with Xon/Xoff }
  85.     RtsHand : Boolean;        { *Handshake receive buffer with Rts }
  86.     DtrHand : Boolean;        { *Handshake receive buffer with Cts }
  87.     XoTransparent : Boolean;  { *Pass Xon/Xoff through to data stream }
  88.     {
  89.       If XoTransparent is False, Xon and Xoff characters are not placed in
  90.       the receive buffer (they will still have their handshaking effect if
  91.       WaitForXon is True).  The defaults are:
  92.     WaitForXon = False
  93.     WaitForCts = False
  94.     WaitForDsr = False
  95.     WaitForCd = False
  96.     XoHand = False
  97.     RtsHand = True
  98.     DtrHand = False
  99.     XoTransparent = True
  100.     }
  101.     TransmitEnabled : Boolean;{ If False, transmit is inhibited }
  102.     SenderEnabled : Boolean;  { Handshake signal was sent to sender }
  103.     AwaitingXon : Boolean;    { True if waiting for Xon }
  104.     AwaitingCts : Boolean;    { True if waiting for Cts }
  105.     AwaitingDsr : Boolean;    { True if waiting for Dsr }
  106.     AwaitingCd  : Boolean;    { True if waiting for Cd }
  107.     AwaitingCh  : Boolean;    { True if waiting for character to transmit }
  108.     StreamInsert : Byte;      { Character to be forced into output stream }
  109.  
  110.     ErrorRoutine : Pointer;   { *Pointer to routine for line status interrupt }
  111.     ModemRoutine : Pointer;   { *Pointer to routine for modem status intrpt }
  112.     {
  113.       These routines must be declared as Far-calls ($F+) at the global level
  114.       with a one-Word value parameter, the port number.  Do NOT declare
  115.       them as "Interrupt" type procedures.  These routines, though not
  116.       "Interrupt" type routines, are called from the interrupt service routine,
  117.       therefore they should follow the same rules as an ISR - no DOS services,
  118.       reentrant, etc.  ErrorRoutine should examine LineStatus to determine the
  119.       cause of the error; ModemRoutine should examine ModemStatus.
  120.     }
  121.     ReceiveBuffer : ^AsyncBuffer;  { *Receive buffer }
  122.     ReceiveSize : Word;            { *0..32767 }
  123.     ReceiveHead : Word;
  124.     ReceiveTail : Word;
  125.     TransmitBuffer : ^AsyncBuffer; { *Transmit buffer }
  126.     TransmitSize : Word;           { *0..32767 }
  127.     TransmitHead : Word;
  128.     TransmitTail : Word;
  129.     ReleaseReceive : Boolean; { YAsync obtained receive buffer, must release }
  130.     ReleaseTransmit : Boolean;{ Ditto, transmit buffer }
  131.     {
  132.       Buffers are allocated from the heap if the corresponding pointer is Nil
  133.       when OpenPort is called.  You may allocate a buffer yourself and place
  134.       its address in ReceiveBuffer or TransmitBuffer, and its size in
  135.       ReceiveSize or TransmitSize.  Alternatively, you may change the size of
  136.       the automatically allocated buffer by changing ReceiveSize or
  137.       TransmitSize before calling OpenPort.
  138.     }
  139.   End;
  140.  
  141.   SetOfChar = Set of Char; { Used by LineReadPort below }
  142.  
  143. Var
  144.   AsyncPort: Array[1..MaxPorts] Of Async_Control;
  145.   PortOpenError : Byte;  { Error code from open routine..
  146.                0 Normal, open successful
  147.                1 Port number out of range (1..4)
  148.                2 Baud rate out of range (50..115200)
  149.                3 Word length out of range (5..8)
  150.                4 Stop bits out of range (1..2)
  151.                5 Invalid parity (N,E,O,1,0)
  152.                6 Buffer size invalid (2..32767)
  153.                7 Insufficient heap space for buffers
  154.                8 UART not responding
  155.                9 Program bug - should never happen
  156.              }
  157.  
  158. function cdetect(comport:word) : boolean;
  159.  
  160. Function OpenPort(ComPort : Word;     { Com port number, 1..4 }
  161.           BaudRate : LongInt; { BPS, 50..115200 }
  162.           WordLength : Word;  { 5..8 bits }
  163.           StopBits : Word;    { 1..2 stop bits }
  164.           Parity : Char      { N,E,O,1,0 }
  165.           ) : Boolean;        { Return True if open successful }
  166. { Prepare port for communications.  Baud rate may be any number from
  167.   50..115200; the actual steady-state baud rate that can be maintained without
  168.   overruns depends on the cpu speed in response to interrupts.  A 4.77 Mhz,
  169.   8088 XT can handle up to about 10000.  If WordLength is 5 and StopBits is 2,
  170.   the actual stop bits used will be 1.5.  If OpenPort fails, it returns False
  171.   and places an error code in PortOpenError above. }
  172.  
  173. function ringing(comport:word) : boolean;
  174. Procedure ClosePort(ComPort : Word);
  175. { Close async port, reset interrupts and release buffers.  If buffered output
  176.   is in progress, ClosePort will wait for its completion.  ClosePort turns
  177.   off the DTR and RTS modem control signals. }
  178.  
  179. Procedure ClearTransmitBuffer(ComPort : Word);
  180. { Discard all unsent characters in the transmit buffer. }
  181.  
  182. Procedure ClearReceiveBuffer(ComPort : Word);
  183. { Discard all unread characters in the receive buffer. }
  184.  
  185. Function ReceiveBufferUsed(ComPort : Word) : Word;
  186. { Returns the number of receive buffer bytes in use }
  187.  
  188. Function TransmitBufferUsed(ComPort : Word) : Word;
  189. { Returns the number of transmit buffer bytes in use }
  190.  
  191. Function SendPort(ComPort : Word; Ch : Char ) : Boolean;
  192. { Send a character (or place it in transmit buffer).  Return True if
  193.   successful.  This rouine will wait up to TimeoutMilliseconds for buffer
  194.   space to become available. }
  195.  
  196. Function BlockSendPort(ComPort : Word; Var Block; BlkLen : Word) : Word;
  197. { Move a block of characters to the buffer and return the number of characters
  198.   inserted in buffer.  This function does not wait for buffer space to become
  199.   available - it always returns immediately. }
  200.  
  201. Function BlockSendPortWait(ComPort : Word; Var Block; BlkLen : Word) : Word;
  202. { Send a block of characters; return the number of characters sent.  This
  203.   function will wait TimeoutMilliseconds between characters sent if not enough
  204.   buffer space is available.  As soon as the remainder of the message will
  205.   fit in the buffer, this routine returns (maybe immediately if the entire
  206.   message fits). Otherwise, if TimeoutMilliseconds elapses without a single
  207.   character being transmitted (may happen if handshaking is asserted), this
  208.   routine signals a timeout error and returns the number of bytes
  209.   successfully loaded into the buffer. }
  210.  
  211. Function PortReady(ComPort : Word) : Boolean;
  212. { Returns True if a character is waiting in the receive buffer or RBR. }
  213.  
  214. Function ReadPort(ComPort : Word; Var Ch) : Boolean;
  215. { Returns received character from buffer, returns False if none ready. }
  216.  
  217. Function BlockReadPort(ComPort : Word; Var Block; BlkLen : Word) : Word;
  218. { Read a block of characters from the port and return number of characters
  219.   read.  This function does not wait for characters to appear in the buffer;
  220.   it transfers any characters which might be present, up to BlkLen, and returns
  221.   the number of characters transferred.}
  222.  
  223. Function BlockReadPortDelim(ComPort : Word; Var Block; BlkLen : Word;
  224.   Delim : SetOfChar) : Word;
  225. { Read a block of characters from the port and return number of characters
  226.   read.  This function reads characters from the port until either: 1. BlkLen
  227.   characters have been read; 2. A character appearing in Delim has been read
  228.   (The Delim character appears in the buffer and is included in the count); or
  229.   3. TimeoutMilliseconds has elapsed since the last character received
  230.   (LSRTimeout bit set in LineStatus and ErrorRoutine called if present). }
  231.  
  232. Procedure SendBreak(ComPort : Word);
  233. { Send break signal for BreakMiliseconds.  If buffered output is in progress,
  234.   SendBreak will wait for its completion before sending the break signal. }
  235.  
  236. Procedure SetDTR(ComPort : Word; Dtr : Boolean);
  237. { Set DTR on/off - WARNING: When DtrHand is True, DTR is turned off
  238.   by the interrupt handler when the receive buffer exceeds 75% full, and
  239.   turned back on by ReadPort when the receive buffer falls below 50% full.
  240.   Use of this procedure may interfere with automatic DTR handshaking. }
  241.  
  242. Procedure SetRTS(ComPort : Word; Rts : Boolean);
  243. { Set RTS on/off - WARNING: This signal is also controlled by the state of the
  244.   receive buffer when RtsHand is True.  Use of this procedure may interfere
  245.   with automatic RTS handshaking.}
  246.  
  247. Procedure SetLoop(ComPort : Word; Loop : Boolean);
  248. { Set LoopBack on/off - WARNING: Setting LoopBack on disables interrupts
  249.   from the 8250 UART! (It apparently disconnects OUT2 from the PC bus.) }
  250.  
  251. Implementation
  252.  
  253. Const
  254.   { These are the offsets from BasePort of the 8250 control registers }
  255.   DLL = 0; { Divisor Latch Least-significant-byte (LCR bit $80 on) }
  256.   DLM = 1; { Divisor Latch Most-significant-byte (LCR bit $80 on) }
  257.   RBR = 0; { Receiver Buffer Register (read) }
  258.   THR = 0; { Transmitter Holding Register (write) }
  259.   IER = 1; { Interrupt Enable Register }
  260.   IIR = 2; { Interrupt Identification Register (read only) }
  261.   LCR = 3; { Line Control Register }
  262.   MCR = 4; { Modem Control Register }
  263.   LSR = 5; { Line Status Register }
  264.   MSR = 6; { Modem Status Register }
  265.  
  266.   { These constants define the bits for the Modem Control Register }
  267.   MCRloop     = $10; { Loopback mode }
  268.   MCRout2     = $08; { Out2, must be on for interrupts }
  269.   MCRout1     = $04; { Out1 ? }
  270.   MCRrts      = $02; { Request to send }
  271.   MCRdtr      = $01; { Data terminal ready }
  272.  
  273.   { These are the default base ports, IRQs and interrupts }
  274.   BasePorts : Array[1..MaxPorts] Of Word = ($03F8,$02F8,$03E8,$02E8);
  275.   IRQs : Array[1..MaxPorts] Of Byte = (4,3,4,3);
  276.   Interrupts : Array[1..MaxPorts] Of Byte = (12,11,12,11);
  277.  
  278.   XOn  = 17; {^Q, DC1, XOn }
  279.   XOff = 19; {^S, DC3, XOff }
  280.  
  281. Type
  282.   VectorType = Record
  283.     UseCount : Byte;  { Number of ports using this interrupt vector }
  284.     IntrptNo : Byte;  { Interrupt number for this vector }
  285.     Vector : Pointer; { Old value of vector }
  286.     NextPort : Word;  { Next port to process }
  287.     PortList : Array[0..MaxPorts] Of Word; { Open ports using this vector }
  288.   End;
  289.  
  290. Var
  291.   FormerExitProc : Pointer; { Save area for ExitProc pointer }
  292.   VectorSave : Array[1..MaxPorts] Of VectorType;
  293.  
  294. Procedure CallFar(ComPort : Word; proc : Pointer);
  295. { Call proc, reentrant far call, works even when @proc is in a record.
  296.   Far proc may only be declared globally. }
  297. InLine($5B/          { pop bx   ; save @proc in cx:bx }
  298.        $59/          { pop cx }
  299.        $0E/          { push cs  ; set up return address }
  300.        $E8/$00/$00/  { call $ }
  301.        $58/          { pop ax }
  302.        $05/$08/$00/  { add ax,8 }
  303.        $50/          { push ax }
  304.        $51/          { push cx  ; restore @proc to stack }
  305.        $53/          { push bx }
  306.        $CB);         { retf     ; go to proc }
  307.  
  308. Procedure DisableInterrupts;
  309. { Disable 80x86/8 interrupts }
  310. Inline($FA);
  311.  
  312. Procedure EnableInterrupts;
  313. { Enable 80x86/8 interrupts }
  314. Inline($FB);
  315.  
  316. Function ReceiveBufferUsed(ComPort : Word) : Word;
  317. { Return number of receive buffer bytes used }
  318. Begin { ReceiveBufferUsed }
  319.   With AsyncPort[ComPort] Do Begin
  320.     DisableInterrupts;
  321.     If ReceiveHead < ReceiveTail Then
  322.       ReceiveBufferUsed := (ReceiveSize-ReceiveTail)+ReceiveHead
  323.     Else ReceiveBufferUsed := ReceiveHead-ReceiveTail;
  324.     EnableInterrupts;
  325.   End;
  326. End;  { ReceiveBufferUsed }
  327.  
  328. Function TransmitBufferUsed(ComPort : Word) : Word;
  329. { Return number of transmit buffer bytes used }
  330. Begin { TransmitBufferUsed }
  331.   With AsyncPort[ComPort] Do Begin
  332.     DisableInterrupts;
  333.     If TransmitHead < TransmitTail Then
  334.       TransmitBufferUsed := (TransmitSize-TransmitTail)+TransmitHead
  335.     Else TransmitBufferUsed := TransmitHead-TransmitTail;
  336.     EnableInterrupts;
  337.   End;
  338. End;  { TransmitBufferUsed }
  339.  
  340. Procedure SetDTR(ComPort : Word; Dtr : Boolean);
  341. { Set DTR on/off }
  342. Begin { SetDTR }
  343.   With AsyncPort[ComPort] Do Begin
  344.     If Dtr Then
  345.       Port[BasePort+MCR] := Port[BasePort+MCR] Or MCRdtr
  346.     Else
  347.       Port[BasePort+MCR] := Port[BasePort+MCR] And Not MCRdtr;
  348.   End;
  349. End;  { SetDTR }
  350.  
  351. Procedure SetRTS(ComPort : Word; Rts : Boolean);
  352. { Set RTS on/off }
  353. Begin { SetRTS }
  354.   With AsyncPort[ComPort] Do Begin
  355.     If Rts Then
  356.       Port[BasePort+MCR] := Port[BasePort+MCR] Or MCRrts
  357.     Else
  358.       Port[BasePort+MCR] := Port[BasePort+MCR] And Not MCRrts;
  359.   End;
  360. End;  { SetRTS }
  361.  
  362. Procedure EnableTransmit(ComPort : Word);
  363. { Enable buffered transmit, restart interrupt if necessary }
  364. Begin { EnableTransmit }
  365.   With AsyncPort[ComPort] Do Begin
  366.     TransmitEnabled := True;
  367.     DisableInterrupts;
  368.     If (TransmitHead <> TransmitTail) And AwaitingCh Then Begin
  369.       Port[BasePort+THR] := TransmitBuffer^[TransmitTail];
  370.       TransmitTail := Succ(TransmitTail);
  371.       If TransmitTail = TransmitSize Then TransmitTail := 0;
  372.     End;
  373.     EnableInterrupts;
  374.   End;
  375. End;  { EnableTransmit }
  376.  
  377. Procedure EnableSender(ComPort : Word);
  378. { Enable sender via handshaking signal }
  379. Begin { EnableSender }
  380.   With AsyncPort[ComPort] Do Begin
  381.     If Not SenderEnabled Then Begin
  382.       If XoHand Then Begin
  383.         DisableInterrupts;
  384.     If AwaitingCh Then Port[BasePort+THR] := XOn
  385.         Else StreamInsert := XOn;
  386.         EnableInterrupts;
  387.       End;
  388.       If DtrHand Then SetDtr(ComPort, True);
  389.       If RtsHand Then SetRts(ComPort, True);
  390.       SenderEnabled := True;
  391.     End;
  392.   End;
  393. End;  { EnableSender }
  394.  
  395. Procedure DisableSender(ComPort : Word);
  396. { Disable sender via handshaking signal }
  397. Begin { DisableSender }
  398.   With AsyncPort[ComPort] Do Begin
  399.     If SenderEnabled Then Begin
  400.       If XoHand Then Begin
  401.         DisableInterrupts;
  402.         If AwaitingCh Then Port[BasePort+THR] := XOff
  403.     Else StreamInsert := XOff;
  404.         EnableInterrupts;
  405.       End;
  406.       If DtrHand Then SetDtr(ComPort, False);
  407.       If RtsHand Then SetRts(ComPort, False);
  408.       SenderEnabled := False;
  409.     End;
  410.   End;
  411. End;  { DisableSender }
  412.  
  413. Procedure ClearTransmitBuffer(ComPort : Word);
  414. { Discard all unsent characters in the transmit buffer. }
  415. Begin { ClearTransmitBuffer }
  416.   With AsyncPort[ComPort] Do Begin
  417.     DisableInterrupts;
  418.     TransmitHead := 0;
  419.     TransmitTail := 0;
  420.     EnableInterrupts;
  421.   End;
  422. End;  { ClearTransmitBuffer }
  423.  
  424. Procedure ClearReceiveBuffer(ComPort : Word);
  425. { Discard all unsent characters in the receive buffer. }
  426. Begin { ClearReceiveBuffer }
  427.   With AsyncPort[ComPort] Do Begin
  428.     DisableInterrupts;
  429.     ReceiveHead := 0;
  430.     ReceiveTail := 0;
  431.     EnableInterrupts;
  432.     EnableSender(ComPort);
  433.   End;
  434. End;  { ClearReceiveBuffer }
  435.  
  436. Procedure AsyncISR(VectorNo : Word);
  437. { General Interrupt Handler (called by specific interrupt procs below) }
  438. Var
  439.   i, Next, ComPort : Word;
  440.   work : Byte;
  441.   done : Boolean;
  442. Begin { AsyncISR }
  443.   EnableInterrupts;
  444.   With VectorSave[VectorNo] Do Begin
  445.     Inc(NextPort);
  446.     If NextPort > UseCount then NextPort := 1;
  447.     i := NextPort;
  448.     Repeat
  449.       ComPort := PortList[i];
  450.       With AsyncPort[ComPort] Do Begin
  451.         done := False;
  452.         Repeat
  453.           Case Port[BasePort+IIR] Of
  454.             $06 : Begin { Received character error or break }
  455.           LineStatus := Port[BasePort+LSR];
  456.               If (LineStatus And LSRBreak) <> 0 Then Begin
  457.                 LineStatus := LineStatus And Not LSRFrame;
  458.                 work := Port[BasePort+RBR];
  459.               End;
  460.           If ErrorRoutine <> Nil Then CallFar(ComPort, ErrorRoutine);
  461.             End;
  462.             $04 : Begin { Received data ready }
  463.               work := Port[BasePort+RBR];
  464.               If XoTransparent Or ((work <> XOff) And (work <> XOn)) Then Begin
  465.                 next := Succ(ReceiveHead);
  466.                 If next = ReceiveSize Then next := 0;
  467.                 If next = ReceiveTail Then Begin
  468.                   LineStatus := LSROverrun;
  469.                   If ErrorRoutine <> Nil Then CallFar(ComPort, ErrorRoutine);
  470.                 End Else Begin
  471.                   ReceiveBuffer^[ReceiveHead] := work;
  472.                   ReceiveHead := next;
  473.                 End;
  474.         If (XoHand Or RtsHand Or DtrHand) And SenderEnabled Then Begin
  475.                   If ReceiveHead < ReceiveTail Then
  476.                     next := (ReceiveSize-ReceiveTail)+ReceiveHead
  477.                   Else next := ReceiveHead-ReceiveTail;
  478.                   If next > (ReceiveSize - (ReceiveSize Shr 2)) Then
  479.             DisableSender(ComPort);
  480.                 End;
  481.               End;
  482.               If WaitForXon Then Begin
  483.                 Case work Of
  484.                   XOff : Begin
  485.                     TransmitEnabled := False;
  486.                     AwaitingXon := True;
  487.                   End;
  488.                   XOn : Begin
  489.                     AwaitingXon := False;
  490.                     If Not (AwaitingCts Or AwaitingDsr Or AwaitingCd) Then
  491.                       EnableTransmit(ComPort);
  492.                   End;
  493.         End;
  494.               End;
  495.             End;
  496.             $02 : Begin { Transmit holding register empty }
  497.               If StreamInsert > 0 Then Begin
  498.         Port[BasePort+THR] := StreamInsert;
  499.                 StreamInsert := 0;
  500.               End Else If (TransmitHead <> TransmitTail) And TransmitEnabled
  501.               Then Begin
  502.                 Port[BasePort+THR] := TransmitBuffer^[TransmitTail];
  503.                 Inc(TransmitTail);
  504.                 If TransmitTail = TransmitSize Then TransmitTail := 0;
  505.               End Else AwaitingCh := True;
  506.             End;
  507.             $00 : Begin { Modem status change }
  508.               ModemStatus := Port[BasePort+MSR];
  509.               AwaitingCts := WaitForCts And ((ModemStatus And MSRcts) = 0);
  510.               AwaitingDsr := WaitForDsr And ((ModemStatus And MSRdsr) = 0);
  511.               AwaitingCd := WaitForCd And ((ModemStatus And MSRcd) = 0);
  512.           If (AwaitingCts Or AwaitingDsr Or AwaitingCd Or AwaitingXon)
  513.                 Then TransmitEnabled := False
  514.                 Else If Not TransmitEnabled Then EnableTransmit(ComPort);
  515.               If ModemRoutine <> Nil Then CallFar(ComPort, ModemRoutine);
  516.             End;
  517.         Else done := True;
  518.           End;
  519.         Until done;
  520.       End;
  521.       Inc(i);
  522.       If i > UseCount Then i := 1;
  523.     Until i = NextPort;
  524.   End;
  525.   DisableInterrupts;
  526.   Port[$20] := $20; { Non-specific EOI to 8259 }
  527. End;  { AsyncISR }
  528.  
  529. { One of these should exist for each element of VectorSave above. }
  530. { These are are the actual interrupt routines referenced in OpenPort below }
  531. Procedure AsyncISR1; Interrupt; Begin AsyncISR(1); End;
  532. Procedure AsyncISR2; Interrupt; Begin AsyncISR(2); End;
  533. Procedure AsyncISR3; Interrupt; Begin AsyncISR(3); End;
  534. Procedure AsyncISR4; Interrupt; Begin AsyncISR(4); End;
  535.  
  536. Procedure ClosePort(ComPort : Word);
  537. { Release async port }
  538. Var
  539.   Timer : LongInt;
  540.   i, LastTail : Word;
  541. Begin { ClosePort }
  542.   With AsyncPort[ComPort] Do Begin
  543.     If PortOpen Then Begin
  544.       { Allow transmit buffer to empty }
  545.       Timer := TimeoutMilliseconds;
  546.       LastTail := TransmitTail;
  547.       While (TransmitHead <> TransmitTail) And (Timer > 0) Do Begin
  548.         Dec(Timer);
  549.         Delay(1);
  550.     If LastTail <> TransmitTail Then Begin
  551.           LastTail := TransmitTail;
  552.           Timer := TimeoutMilliseconds;
  553.         End;
  554.       End;
  555.       If Timer = 0 Then Begin
  556.         LineStatus := LSRTimeout;
  557.         If ErrorRoutine <> Nil Then CallFar(ComPort, ErrorRoutine);
  558.       End;
  559.  
  560.       Port[BasePort+IER] := 0; { Disable 8250 interrupts }
  561.       Port[BasePort+MCR] := 0; { All modem signals off }
  562.       With VectorSave[VectorIndex] Do Begin
  563.         i := 0;
  564.         Repeat Inc(i) Until (i >= UseCount) Or (PortList[i] = ComPort);
  565.         PortList[i] := PortList[UseCount];
  566.         Dec(UseCount);
  567.         If UseCount = 0 Then Begin { No more ports using this irq }
  568.           Port[$21] := Port[$21] Or (1 Shl IrqNumber);
  569.       SetIntVec(IntrptNo, Vector);
  570.         End;
  571.       End;
  572.       { Free buffers }
  573.       If ReleaseReceive Then Begin
  574.     FreeMem(ReceiveBuffer, ReceiveSize);
  575.         ReceiveBuffer := Nil;
  576.       End;
  577.       If ReleaseTransmit Then Begin
  578.         FreeMem(TransmitBuffer, TransmitSize);
  579.         TransmitBuffer := Nil;
  580.       End;
  581.       PortOpen := False;
  582.     End;
  583.   End;
  584. End;  { ClosePort }
  585.  
  586. Function OpenPort(ComPort : Word;     { Com port number, 1..4 }
  587.                   BaudRate : LongInt; { BPS, 50..115200 }
  588.           WordLength : Word;  { 5..8 bits }
  589.                   StopBits : Word;    { 1..2 stop bits }
  590.                   Parity : Char       { N,E,O,1,0 }
  591.                   ) : Boolean;        { Return True if open successful }
  592. { Prepare port for communications }
  593. Var
  594.   BaudDivisor : Word;
  595.   Work, FreeSave : Byte;
  596. Begin { OpenPort }
  597.   If (ComPort < 1) Or (ComPort > MaxPorts) Then PortOpenError := 1
  598.   Else With AsyncPort[ComPort] Do Begin
  599.     If PortOpen Then ClosePort(ComPort) Else Begin { Precautionary... }
  600.       Port[BasePort+IER] := 0; { disable 8250 interrupts }
  601.       Port[BasePort+MCR] := 0; { all modem control signals off }
  602.     End;
  603.     PortOpenError := 0;
  604.     Parity := UpCase(Parity);
  605.  
  606.     If (BaudRate < 50) Or (BaudRate > 115200) Then PortOpenError := 2
  607.     Else If (WordLength < 5) Or (WordLength > 8) Then PortOpenError := 3
  608.     Else If (StopBits < 1) Or (StopBits > 2) Then PortOpenError := 4
  609.     Else If Not (Parity In ['N','E','O','1','0']) Then PortOpenError := 5
  610.     Else If (ReceiveSize < 2 ) Or (ReceiveSize > 32767)
  611.          Or (TransmitSize < 2) Or (TransmitSize > 32767)
  612.     Then PortOpenError := 6 Else Begin
  613.       ReleaseReceive := False;
  614.       ReleaseTransmit := False;
  615.       If ReceiveBuffer = Nil Then Begin
  616.         If MaxAvail < ReceiveSize Then PortOpenError := 7 Else Begin
  617.           GetMem(ReceiveBuffer, ReceiveSize);
  618.           ReleaseReceive := True;
  619.         End;
  620.       End;
  621.       If TransmitBuffer = Nil Then Begin
  622.         If MaxAvail < TransmitSize Then PortOpenError := 7 Else
  623.           ReleaseTransmit := True;
  624.       End;
  625.       If ReleaseReceive Then Begin
  626.     FreeMem(ReceiveBuffer, ReceiveSize);
  627.         ReceiveBuffer := Nil;
  628.       End;
  629.     End;
  630.  
  631.     If (PortOpenError = 0) And ((Port[BasePort+IIR] And $F8) <> 0) Then
  632.       PortOpenError := 8;
  633.  
  634.     If PortOpenError = 0 Then Begin
  635.       { Get buffers }
  636.       If ReceiveBuffer = Nil Then GetMem(ReceiveBuffer, ReceiveSize);
  637.       ReceiveHead := 0;
  638.       ReceiveTail := 0;
  639.       If TransmitBuffer = Nil Then GetMem(TransmitBuffer, TransmitSize);
  640.       TransmitHead := 0;
  641.       TransmitTail := 0;
  642.  
  643.       { Set baud rate }
  644.       BaudDivisor := BaudRateDividend Div BaudRate;
  645.       Port[BasePort+LCR] := $80;
  646.       Port[BasePort+DLM] := Hi(BaudDivisor);
  647.       Port[BasePort+DLL] := Lo(BaudDivisor);
  648.  
  649.       { Set Word Length, Stop Bits, Parity }
  650.       Work := WordLength - 5;
  651.       If StopBits = 2 Then Work := Work Or $04;
  652.       Case Parity Of
  653.         'N' : ;
  654.         'O' : Work := Work Or $08;
  655.         'E' : Work := Work Or $18;
  656.         '1' : Work := Work Or $28;
  657.         '0' : Work := Work Or $38;
  658.       End;
  659.       Port[BasePort+LCR] := Work;
  660.  
  661.       { Read registers to reset pending conditions }
  662.       LineStatus := Port[BasePort+LSR];
  663.       ModemStatus := Port[BasePort+MSR];
  664.       Work := Port[BasePort+RBR];
  665.  
  666.       AwaitingXon := False;
  667.       AwaitingCh := True;
  668.       SenderEnabled := True;
  669.  
  670.       { Set interrupts }
  671.       FreeSave := 0;
  672.       VectorIndex := 1;
  673.       While (VectorIndex <= MaxPorts)
  674.       And
  675.       (
  676.         (VectorSave[VectorIndex].UseCount = 0)
  677.         Or
  678.         (VectorSave[VectorIndex].IntrptNo <> IntNumber)
  679.       ) Do Begin
  680.         If (FreeSave = 0) And (VectorSave[VectorIndex].UseCount = 0) Then
  681.           FreeSave := VectorIndex;
  682.         Inc(VectorIndex);
  683.       End;
  684.       If VectorIndex <= MaxPorts Then With VectorSave[VectorIndex] Do Begin
  685.         DisableInterrupts;
  686.         Inc(UseCount);
  687.         PortList[UseCount] := ComPort;
  688.       End
  689.       Else If FreeSave = 0 Then PortOpenError := 9 { This should never happen }
  690.       Else With VectorSave[FreeSave] Do Begin { Save old vector }
  691.         VectorIndex := FreeSave;
  692.         UseCount := 1;
  693.         PortList[1] := ComPort;
  694.         IntrptNo := IntNumber;
  695.         GetIntVec(IntrptNo, Vector);
  696.         Case VectorIndex Of
  697.           1 : SetIntVec(IntrptNo, @AsyncISR1);
  698.           2 : SetIntVec(IntrptNo, @AsyncISR2);
  699.           3 : SetIntVec(IntrptNo, @AsyncISR3);
  700.           4 : SetIntVec(IntrptNo, @AsyncISR4);
  701.           Else PortOpenError := 9; { This shouldn't happen }
  702.     End;
  703.         Port[$21] := Port[$21] And Not (1 Shl IrqNumber);
  704.       End;
  705.       PortOpen := True;
  706.       Port[BasePort+MCR] := MCRout2+MCRrts+MCRdtr;
  707.       Port[BasePort+IER] := $0F; { Enable 8250 interrupts }
  708.       EnableInterrupts;
  709.       AwaitingCts := WaitForCts And ((ModemStatus And MSRcts) = 0);
  710.       AwaitingDsr := WaitForDsr And ((ModemStatus And MSRdsr) = 0);
  711.       AwaitingCd := WaitForCd And ((ModemStatus And MSRcd) = 0);
  712.       TransmitEnabled := Not (AwaitingCts Or AwaitingDsr Or AwaitingCd);
  713.     End;
  714.     OpenPort := PortOpen And (PortOpenError = 0);
  715.   End;
  716. End;  { OpenPort }
  717.  
  718. Function SendPort(ComPort : Word; Ch : Char ) : Boolean;
  719. { Send a character (or place in transmit buffer).  Return true if successful }
  720. Var
  721.   Timer : LongInt;
  722.   next : Word;
  723. Begin { SendPort }
  724.   With AsyncPort[ComPort] Do Begin
  725.     SendPort := False;
  726.     Timer := TimeoutMilliseconds;
  727.     next := Succ(TransmitHead);
  728.     If next = TransmitSize Then next := 0;
  729.     While (next = TransmitTail) And (Timer > 0) Do Begin
  730.       Delay(1);
  731.       Dec(Timer);
  732.     End;
  733.     If Timer > 0 Then Begin
  734.       DisableInterrupts;
  735.       If TransmitEnabled And AwaitingCh Then Begin
  736.         Port[BasePort+THR] := Ord(Ch);
  737.         AwaitingCh := False;
  738.       End Else Begin
  739.         TransmitBuffer^[TransmitHead] := Ord(Ch);
  740.     TransmitHead := next;
  741.       End;
  742.       EnableInterrupts;
  743.       SendPort := True;
  744.     End Else Begin
  745.       LineStatus := LSRTimeout;
  746.       If ErrorRoutine <> Nil Then CallFar(ComPort, ErrorRoutine);
  747.     End;
  748.   End;
  749. End;  { SendPort }
  750.  
  751. Function BlockSendPort(ComPort : Word; Var Block; BlkLen : Word) : Word;
  752. { Move a block of characters to the buffer; returns number of characters
  753.   inserted in buffer.  This function does not wait for buffer space to become
  754.   available - it always returns immediately. }
  755. Var
  756.   next, first, second, len : Word;
  757.   blk : AsyncBuffer Absolute Block;
  758. Begin { BlockSendPort }
  759.   With AsyncPort[ComPort] Do Begin
  760.     BlockSendPort := 0;
  761.     If BlkLen > 0 Then Begin
  762.       DisableInterrupts;
  763.       If TransmitTail > TransmitHead Then Begin
  764.     first := TransmitTail - TransmitHead - 1;
  765.         second := 0;
  766.       End Else Begin
  767.         first := TransmitSize - TransmitHead;
  768.         second := TransmitTail;
  769.         If TransmitTail = 0 Then Dec(first) Else Dec(second);
  770.       End;
  771.       EnableInterrupts;
  772.       len := BlkLen;
  773.       next := TransmitHead;
  774.       If first > 0 Then Begin
  775.         If first > len Then first := len;
  776.         Move(Blk, TransmitBuffer^[TransmitHead], first);
  777.         len := len - first;
  778.     next := TransmitHead + first;
  779.         If next >= TransmitSize Then next := 0;
  780.       End;
  781.       If (len > 0) And (second > 0) Then Begin
  782.         If second > len Then second := len;
  783.     Move(Blk[first], TransmitBuffer^, second);
  784.         len := len - second;
  785.         next := second;
  786.       End;
  787.       TransmitHead := next;
  788.       BlockSendPort := BlkLen - len;
  789.       If TransmitEnabled Then Begin { JumpStart the interrupt }
  790.         DisableInterrupts;
  791.         If AwaitingCh And (TransmitHead <> TransmitTail) Then Begin
  792.           Port[BasePort+THR] := TransmitBuffer^[TransmitTail];
  793.           TransmitTail := Succ(TransmitTail);
  794.           If TransmitTail = TransmitSize Then TransmitTail := 0;
  795.           AwaitingCh := False;
  796.         End;
  797.     EnableInterrupts;
  798.       End;
  799.     End;
  800.   End;
  801. End;  { BlockSendPort }
  802.  
  803. Function BlockSendPortWait(ComPort : Word; Var Block; BlkLen : Word) : Word;
  804. { Send a block of characters; return the number of characters sent.  This
  805.   function will wait TimeoutMilliseconds between characters sent if not enough
  806.   buffer space is available. }
  807. Var
  808.   Blk : AsyncBuffer Absolute Block;
  809.   i, j : Word;
  810.   Timer : LongInt;
  811. Begin { BlockSendPortWait }
  812.   With AsyncPort[ComPort] Do Begin
  813.     BlockSendPortWait := 0;
  814.     Timer := TimeoutMilliseconds;
  815.     i := 0;
  816.     While (BlkLen > 0) And (Timer > 0) Do Begin
  817.       j := BlockSendPort(ComPort, Blk[i], BlkLen);
  818.       If j > 0 Then Begin
  819.         i := i + j;
  820.         BlkLen := BlkLen - j;
  821.     Timer := TimeoutMilliseconds;
  822.       End Else Begin
  823.         Dec(Timer);
  824.         Delay(1);
  825.       End;
  826.     End;
  827.     If Timer = 0 Then Begin
  828.       LineStatus := LSRTimeout;
  829.       If ErrorRoutine <> Nil Then CallFar(ComPort, ErrorRoutine);
  830.     End;
  831.   End;
  832. End;  { BlockSendPortWait }
  833.  
  834. Function PortReady(ComPort : Word) : Boolean;
  835. { Returns True if character waiting in receive buffer or RBR }
  836. Begin { PortReady }
  837.   With AsyncPort[ComPort] Do Begin
  838.     PortReady := ReceiveHead <> ReceiveTail;
  839.   End;
  840. End;  { PortReady }
  841.  
  842. Function ReadPort(ComPort : Word; Var Ch) : Boolean;
  843. { Returns received character from buffer }
  844. Var
  845.   bufused : Word;
  846.   Rch : Byte Absolute Ch;
  847. Begin { ReadPort }
  848.   With AsyncPort[ComPort] Do Begin
  849.     If ReceiveHead = ReceiveTail Then ReadPort := False Else Begin
  850.       Rch := ReceiveBuffer^[ReceiveTail];
  851.       DisableInterrupts;
  852.       Inc(ReceiveTail);
  853.       If ReceiveTail = ReceiveSize Then ReceiveTail := 0;
  854.       EnableInterrupts;
  855.       ReadPort := True;
  856.     End;
  857.     If Not SenderEnabled And (XoHand Or RtsHand Or DtrHand) Then Begin
  858.       DisableInterrupts;
  859.       If ReceiveHead < ReceiveTail Then
  860.         bufused := (ReceiveSize-ReceiveTail)+ReceiveHead
  861.       Else bufused := ReceiveHead-ReceiveTail;
  862.       EnableInterrupts;
  863.       If bufused < (ReceiveSize Shr 1) Then EnableSender(ComPort);
  864.     End;
  865.   End;
  866. End;  { ReadPort }
  867.  
  868. Function BlockReadPort(ComPort : Word; Var Block; BlkLen : Word) : Word;
  869. { Read a block of characters from the port and return number of characters
  870.   read.  This function does not wait for characters to appear in the buffer;
  871.   it transfers any characters which might be present, up to BlkLen, and returns
  872.   the number transferred.}
  873. Var
  874.   Blk : AsyncBuffer Absolute Block;
  875.   first, second, len, bufused, i : Word;
  876. Begin { BlockReadPort }
  877.   With AsyncPort[ComPort] Do Begin
  878.     DisableInterrupts;
  879.     If ReceiveHead < ReceiveTail Then Begin
  880.       first := ReceiveSize - ReceiveTail;
  881.       second := ReceiveHead;
  882.     End Else Begin
  883.       first := ReceiveHead - ReceiveTail;
  884.       second := 0;
  885.     End;
  886.     EnableInterrupts;
  887.     i := 0;
  888.     len := first;
  889.     If len > BlkLen Then len := BlkLen;
  890.     If len > 0 Then Begin
  891.       Move(ReceiveBuffer^[ReceiveTail], Blk, len);
  892.       BlkLen := BlkLen - len;
  893.       i := i + len;
  894.       DisableInterrupts;
  895.       ReceiveTail := ReceiveTail + len;
  896.       If ReceiveTail = ReceiveSize Then ReceiveTail := 0;
  897.       EnableInterrupts;
  898.     End;
  899.     If BlkLen > 0 Then Begin
  900.       len := second;
  901.       If len > BlkLen Then len := BlkLen;
  902.       If len > 0 Then Begin
  903.         Move(ReceiveBuffer^, Blk[i], len);
  904.         i := i + len;
  905.         DisableInterrupts;
  906.         ReceiveTail := ReceiveTail + len;
  907.         EnableInterrupts;
  908.       End;
  909.     End;
  910.     BlockReadPort := i;
  911.     If Not SenderEnabled And (XoHand Or RtsHand Or DtrHand) Then Begin
  912.       DisableInterrupts;
  913.       If ReceiveHead < ReceiveTail Then
  914.         bufused := (ReceiveSize-ReceiveTail)+ReceiveHead
  915.       Else bufused := ReceiveHead-ReceiveTail;
  916.       EnableInterrupts;
  917.       If bufused < (ReceiveSize Shr 1) Then EnableSender(ComPort);
  918.     End;
  919.   End;
  920. End;  { BlockReadPort }
  921.  
  922. Function BlockReadPortDelim(ComPort : Word; Var Block; BlkLen : Word;
  923.   Delim : SetOfChar) : Word;
  924. { Read a block of characters from the port and return number of characters
  925.   read.  This function reads characters from the port until either: 1. BlkLen
  926.   characters have been read; 2. A character appearing in Delim has been read
  927.   (The Delim character appears in the buffer and is included in the count); or
  928.   3. TimeoutMilliseconds has elapsed since the last character received
  929.   (LSRTimeout bit set in LineStatus and ErrorRoutine called if present). }
  930. Var
  931.   Blk : AsyncBuffer Absolute Block;
  932.   Timer : LongInt;
  933.   i : Word;
  934.   ch : Byte;
  935. Begin { BlockReadPortDelim }
  936.   With AsyncPort[ComPort] Do Begin
  937.     i := 0;
  938.     Timer := TimeoutMilliseconds;
  939.     If BlkLen > 0 Then Repeat
  940.       If ReadPort(ComPort, ch) Then Begin
  941.         Blk[i] := Ch;
  942.         Inc(i);
  943.         Timer := TimeoutMilliseconds;
  944.       End Else Begin
  945.         Dec(Timer);
  946.         Delay(1);
  947.       End;
  948.     Until (i >= BlkLen) Or (Timer = 0) Or (Chr(ch) In Delim);
  949.     If Timer = 0 Then Begin
  950.       LineStatus := LSRTimeout;
  951.       If ErrorRoutine <> Nil Then CallFar(ComPort, ErrorRoutine);
  952.     End;
  953.   End;
  954. End;  { BlockReadPortDelim }
  955.  
  956. Procedure SetLoop(ComPort : Word; Loop : Boolean);
  957. { Set LoopBack on/off }
  958. Begin { SetLoop }
  959.   With AsyncPort[ComPort] Do Begin
  960.     If Loop Then
  961.       Port[BasePort+MCR] := Port[BasePort+MCR] Or MCRloop
  962.     Else
  963.       Port[BasePort+MCR] := Port[BasePort+MCR] And Not MCRloop;
  964.   End;
  965. End;  { SetLoop }
  966.  
  967. Procedure SendBreak(ComPort : Word);
  968. { Send break signal }
  969. Var
  970.   Timer : LongInt;
  971.   LastTail : Word;
  972. Begin { SendBreak }
  973.   With AsyncPort[ComPort] Do Begin
  974.     If TransmitSize > 0 Then Begin { Allow transmit buffer to empty }
  975.       Timer := TimeoutMilliseconds;
  976.       LastTail := TransmitTail;
  977.       While (TransmitHead <> TransmitTail) And (Timer > 0) Do Begin
  978.         Dec(Timer);
  979.         Delay(1);
  980.         If LastTail <> TransmitTail Then Begin
  981.           LastTail := TransmitTail;
  982.           Timer := TimeoutMilliseconds;
  983.         End;
  984.       End;
  985.       If Timer = 0 Then Begin
  986.         LineStatus := LSRTimeout;
  987.     If ErrorRoutine <> Nil Then CallFar(ComPort, ErrorRoutine);
  988.       End;
  989.     End;
  990.     Port[BasePort+LCR] := Port[BasePort+LCR] Or $40; { Turn on break }
  991.     Delay(BreakMiliseconds);
  992.     Port[BasePort+LCR] := Port[BasePort+LCR] And $BF; { Turn off break }
  993.   End;
  994. End;  { SendBreak }
  995.  
  996. {$F+} Procedure AsyncExit; {$F-}
  997. { Exit procedure, close ports }
  998. Var
  999.   i : Word;
  1000. Begin { AsyncExit }
  1001.   For i := 1 To MaxPorts Do ClosePort(i);
  1002.   ExitProc := FormerExitProc;
  1003. End;  { AsyncExit }
  1004.  
  1005. Procedure InitializeAsync;
  1006. { Initialize data areas and install exit proc }
  1007. Var
  1008.   i : Word;
  1009. Begin { InitializeAsync }
  1010.   For i := 1 To MaxPorts Do Begin
  1011.     With AsyncPort[i] Do Begin
  1012.       PortOpen := False;
  1013.       IrqNumber := IRQs[i];
  1014.       IntNumber := Interrupts[i];
  1015.       VectorIndex := 0;
  1016.       BasePort := BasePorts[i];
  1017.       LineStatus := 0;
  1018.       ModemStatus := 0;
  1019.       UserData := 0;
  1020.       WaitForXon := False;
  1021.       WaitForCts := False;
  1022.       WaitForDsr := False;
  1023.       WaitForCd := False;
  1024.       RtsHand := True;
  1025.       DtrHand := False;
  1026.       XoHand := False;
  1027.       XoTransparent := True;
  1028.       TransmitEnabled := True;
  1029.       AwaitingXon := False;
  1030.       AwaitingCts := False;
  1031.       AwaitingDsr := False;
  1032.       AwaitingCd := False;
  1033.       AwaitingCh := True;
  1034.       SenderEnabled := True;
  1035.       StreamInsert := 0;
  1036.       ErrorRoutine := Nil;
  1037.       ModemRoutine := Nil;
  1038.       ReceiveBuffer := Nil;
  1039.       ReceiveSize := DefaultBufferSize;
  1040.       ReceiveHead := 0;
  1041.       ReceiveTail := 0;
  1042.       TransmitBuffer := Nil;
  1043.       TransmitSize := DefaultBufferSize;
  1044.       TransmitHead := 0;
  1045.       TransmitTail := 0;
  1046.       ReleaseReceive := True;
  1047.       ReleaseTransmit := True;
  1048.     End;
  1049.     With VectorSave[i] Do Begin
  1050.       UseCount := 0;
  1051.       IntrptNo := 0;
  1052.       Vector := Nil;
  1053.       NextPort := 1;
  1054.     End;
  1055.   End;
  1056.   PortOpenError := 0;
  1057.   FormerExitProc := ExitProc;
  1058.   ExitProc := @AsyncExit;
  1059. End;  { InitializeAsync }
  1060.  
  1061. FUNCTION  CDetect(comport:word):boolean;
  1062. BEGIN
  1063.   cdetect := (port[asyncport[comport].baseport + 6] AND $0080)<> 0;
  1064. END;
  1065.  
  1066. Function Ringing(comport:word) : boolean;
  1067. begin
  1068.    ringing :=  port[asyncport[comport].baseport+6] and $40 = $40;
  1069. end;
  1070.  
  1071. Begin { Initialization }
  1072.   InitializeAsync;
  1073. End.  { Unit }
  1074.