[Back to COMM SWAG index] [Back to Main SWAG index] [Original]

    {
     *  Interface unit for the X00 device driver. This unit supports all
     *  comm fossil calls needed to do most communication tasks.
     *
     *  Author  Gordon Tackett
     *  Date    01-31-91
     *
     *  $Revision:   1.0  $
    }

    {$IFDEF LOCAL}

    Program X00;

    {$ELSE}

    Unit X00;

    Interface

    {$ENDIF}

    Uses Dos;

    Type

      {
      * Driver Information Block.
      *    This record holds all of the current settings from the
      *    X00 driver after a call to funciton $1B
      }
      DvrInfo = Record
          Size  : Word;
          Spec  : byte;
          Rev   : Byte;
          ID    : Pointer;
          Ibuf  : Word;
          Iavl  : Word;
          OBuf  : Word;
          Oavl  : Word;
          Width : Byte;
          Height: Byte;
          Baud  : Byte;
        End;

      {
      * Timer Fuctions & Pointers
      *    This procedure type is used to define a pointer the the procedure
      *    that may be sent to the X00 driver for calling during a timer
      *    tick. These procedures must be declared far
      }
      TimerFunction = Procedure;
      TimerFunctionPtr = ^TimerFunction;

      {
      *  X00 Driver object
      *    This is the main object for this module. It has all the interface
      *    routines and data needed to call all the major functions of the
      *    X00 device driver.
      }
      X00Dvr = Object
        Port        : Word;
        Baud        : Word;
        Size        : Word;
        Parity      : Char;
        Stops       : Word;
        Status      : Word;
        MaxFuncs    : Word;
        RevLevel    : Word;
        CtrlCFlags  : Byte;
        CurInfo     : DvrInfo;

        Constructor Init(Prt,Bd,Sz : Word; Prty : Char; StpBts : Word);
        Function    GetLastStatus : Word;
        Function    GetInfoSize : Word;
        Function    GetInfoSpec : Word;
        Function    GetInfoRev  : Word;
        Function    GetInfoId   : Pointer;
        Function    GetInfoIbuf : Word;
        Function    GetInfoIavl : Word;
        Function    GetInfoOBuf : Word;
        Function    GetInfoOAvl : Word;
        Function    GetInfoCrtW : Word;
        Function    GetInfoCrtH : Word;
        Function    GetInfoBaud : Word;
        Function    GetPort     : Word;
        Function    GetBaud     : Word;
        Function    GetSize     : Word;
        Function    GetParity   : Char;
        Function    GetStops    : Word;
        Function    GetMaxFuncs : Word;
        Function    GetRevLevel : Word;

        Procedure   SetBaud(Bd,Sz : Word; Prty : Char; StpBts : Word);
        Procedure   TxChar(Ch : Char);
        Function    RxChar : Char;
        Function    GetStatus : Word;
        Procedure   InitFossil;
        Procedure   DeinitFossil;
        Procedure   DropDTR;
        Procedure   RaseDTR;
        Procedure   SystemTimerParams(Var TicksPerSec,MsPerTick : Word);
        Procedure   FlushBuffer;
        Procedure   PurgeOutputBuffer;
        Procedure   PurgeInputBuffer;
        Procedure   TxCharNoWait(Ch : Char);
        Function    RXPeekChar(Var Ch : Char) : Boolean;
        Function    KBPeekChar(Var Ch : Word) : Boolean;
        Function    KBRead : Word;
        Procedure   FlowControl(XONCTS : Byte);
        Procedure   CtrlCChkOn;
        Procedure   CtrlCChkOff;
        Procedure   XmitOff;
        Procedure   XmitOn;
        Procedure   GotoXY(X,Y : Word);
        Procedure   GetCursorLoc(Var X,Y : Word);
        Procedure   AnsiWriteChar(Ch : Char);
        Procedure   EnableWatchDog;
        Procedure   DisableWatchDog;
        Procedure   WriteChar(Ch : Char);
        Function    InsertTimerFunction(TF : TimerFunctionPtr) : Boolean;
        Function    DeleteTimerFunction(TF : TimerFunctionPtr) : Boolean;
        Procedure   Reboot(Tp : Boolean);
        Procedure   RecvBuffer(Buffer : Pointer; Var Sz : Word);
        Procedure   SendBuffer(Buffer : Pointer; Sz : Word);
        Procedure   StopBreak;
        Procedure   GetInfo;
        {7e}
        {7f}
      End;

    Const
      OutputBuffEmpty    = $4000;
      OutputBuffNotFull  = $2000;
      InputBuffOverrun   = $0200;
      CharInInputBuff    = $0100;
      CarrierDetect      = $0080;
      TxXonXoff          = $01;
      TXCts              = $02;
      RxXonXoff          = $03;

    Var
      Comm1 : X00Dvr;
      Comm2 : X00Dvr;

    {$IFNDEF LOCAL}

    Implementation

    {$ENDIF}

    Var
      Regs : Registers; { register structure used in X00 calls}

    Const
      CommVect = $14;          {X00 interrupt vector}

    {
    *  Init - set up object and init port.
    * This routine will clear unused bytes to 0 and will init the
    * X00 fossil driver to the baud,size,parity,and stops as needed
    * by the user application.
    -----------------------------------------------------------------------------}
    Constructor X00Dvr.Init(Prt,Bd,Sz : Word; Prty : Char; StpBts : Word);
      Begin
        Port := Prt;
        CtrlCFlags := 0;
        InitFossil;
        If MaxFuncs = 0 Then
            Exit;
        SetBaud(Bd,Sz,Prty,StpBts);
      End;

    {
    * Get Last Status
    *
    * Interface function to get a copy of the status word storied in the
    * object body.
    -----------------------------------------------------------------------------}
    Function X00Dvr.GetLastStatus : Word;
      Begin
        GetLastStatus := Status;
      End;

    {
    * Get Information Size
    *
    * Interface function to get a copy of the word size from the info block.
    -----------------------------------------------------------------------------}
    Function X00Dvr.GetInfoSize : Word;
      Begin
        GetInfoSize := CurInfo.Size;
      End;

    {
    * Get Information Specification
    *
    * Interface function to get a copy of the fossil interface spec supported
    * by this driver.
    -----------------------------------------------------------------------------}
    Function X00Dvr.GetInfoSpec : Word;
      Begin
        GetInfoSpec := CurInfo.Spec;
      End;

    {
    * Get Information Revision
    *
    * Interface function to get a copy of the fossil document revision supported
    * by this driver.
    -----------------------------------------------------------------------------}
    Function X00Dvr.GetInfoRev : Word;
      Begin
        GetInfoRev := CurInfo.Rev;
      End;

    {
    * Get Information ID
    *
    * Interface function to get a copy of the pointer to the ascii
    * string containing the name of the driver.
    -----------------------------------------------------------------------------}
    Function X00Dvr.GetInfoId : Pointer;
      Begin
        GetInfoId := CurInfo.Id;
      End;

    {
    * Get Information Input Buffer Size
    *
    * Interface function to get a copy of the size of the input buffer
    * in bytes.
    -----------------------------------------------------------------------------}
    Function X00Dvr.GetInfoIbuf : Word;
      Begin
        GetInfoIBuf := CurInfo.IBuf;
      End;

    {
    * Get Information Input Buffer Avaliable
    *
    * Interface function to get a copy of the amount of input buffer that is
    * avaliable for use.
    -----------------------------------------------------------------------------}
    Function X00Dvr.GetInfoIavl : Word;
      Begin
        GetInfoIavl := CurInfo.Iavl;
      End;

    {
    * Get Information Output Buffer Size
    *
    * Interface function to get a copy of the size of the output buffer
    * in bytes.
    -----------------------------------------------------------------------------}
    Function X00Dvr.GetInfoOBuf : Word;
      Begin
        GetInfoOBuf := CurInfo.OBuf;
      End;

    {
    * Get Information Output Buffer Avaliable
    *
    * Interface function to get a copy of the amount of Output buffer that is
    * avaliable for use.
    -----------------------------------------------------------------------------}
    Function X00Dvr.GetInfoOAvl : Word;
      Begin
        GetInfoOAvl := CurInfo.OAvl;
      End;

    {
    * Get Information Current CRT Width
    *
    * Interface function to get a copy of the width of the CRT
    -----------------------------------------------------------------------------}
    Function X00Dvr.GetInfoCrtW : Word;
      Begin
        GetInfoCrtW := CurInfo.Width;
      End;

    {
    * Get Information Current CRT Height
    *
    * Interface funciton to get a copy of the height of the CRT
    -----------------------------------------------------------------------------}
    Function X00Dvr.GetInfoCrtH : Word;
      Begin
        GetInfoCrtH := CurInfo.Height;
      End;

    {
    * Get Information Current Baud Rate
    *
    * Interface function to get a copy of the current baud rate as returned
    * in the curinfo structure.
    -----------------------------------------------------------------------------}
    Function X00Dvr.GetInfoBaud : Word;
      Begin
        GetInfoBaud := CurInfo.Baud;
      End;

    {
    * Get the port number
    *
    * Interface function to return the port number that was used to call
    * the constructor Init. Once this constructor is called the port value
    * can't be changed.
    -----------------------------------------------------------------------------}
    Function X00Dvr.GetPort : Word;
      Begin
        GetPort := Port;
      End;

    {
    * Get the Baud Rate
    *
    * Interface function that is used to get the last baud rate sent to
    * this object from an application. This may not be the current correct
    * baud rate.
    -----------------------------------------------------------------------------}
    Function X00Dvr.GetBaud : Word;
      Begin
        GetBaud := Baud;
      End;

    {
    * Get the Word Size
    *
    * Interface function that is used to get the last word size sent to
    * this object from an application. This is always correct
    -----------------------------------------------------------------------------}
    Function X00Dvr.GetSize : Word;
      Begin
        GetSize := Size;
      End;

    {
    * Get the Parity
    *
    * Interface function that is used to get the last parity value that was
    * sent to this object from an application. this is always correct.
    -----------------------------------------------------------------------------}
    Function X00Dvr.GetParity : Char;
      Begin
        GetParity := Parity;
      End;

    {
    * Get Stop Bits
    *
    * Interface function that is used to get the last number of stop bits
    * that was sent to this object from an application. This is always correct.
    -----------------------------------------------------------------------------}
    Function X00Dvr.GetStops : Word;
      Begin
        GetStops := Stops;
      End;

    {
    * Get Maximum Function
    *
    * Interface function to return the maximum functions supported
    * by this fossil driver.
    -----------------------------------------------------------------------------}
    Function X00Dvr.GetMaxFuncs : Word;
      Begin
        GetMaxFuncs := MaxFuncs;
      End;

    {
    * Get Fossil Rev
    *
    * Interface function to return the revision level of the fossil
    * that is in use.
    -----------------------------------------------------------------------------}
    Function X00Dvr.GetRevLevel : Word;
      Begin
        GetRevLevel := RevLevel;
      End;

    {
    * Set Baud Rate
    *
    * BaudRate code in AL:
    * Bits [7:5] 000 = 19200, 001 = 38400, 010 = 300, 011 = 600, 100 = 1200,
    * 101 = 2400, 110 = 4800, 111 = 9600. Parity: [4:3] 00 or 10 = none,
    * 01 = odd, 11 = even. StopBits: [2:2] 0 = 1, 1 = 2
    * CharLength: 5 bits plus value [1:0] Support for [4:0] = 00011 required of
    * driver, others optional
    -----------------------------------------------------------------------------}
    Procedure X00Dvr.SetBaud(Bd,Sz : Word; Prty : Char; StpBts : Word);
      Var
        Bits : Word;
      Begin
        Baud := Bd;
        Size := Sz;
        Parity := Prty;
        Stops := StpBts;

        Regs.Dx := Port;

        Case Baud of
            300 : Bits := 2;
            600 : Bits := 3;
           1200 : Bits := 4;
           2400 : Bits := 5;
           4800 : Bits := 6;
           9600 : Bits := 7;
          19200 : Bits := 0;
          38400 : Bits := 1;
        Else
          Exit;
        End;

        Bits := Bits Shl 2;
        If Parity = 'E' Then
          Bits := Bits + 3
        Else if Parity = 'O' Then

    {  c¾îºD‘B6´= Bits + 1;}

        Bits := Bits Shl 1;
        If Stops = 2 then
          Bits := Bits + 1;
        Bits := Bits Shl 2;
        Case Size Of
          6 : Bits := Bits + 1;
          7 : Bits := Bits + 2;
          8 : Bits := Bits + 3;
        Else
          Bits := Bits + 3;
        End;

        Regs.Al := Bits;
        Regs.Ah := $00;
        Intr(CommVect,Regs);
        Status := Regs.AX;
      End;

    {
    * Transmit Character
    *
    * Character is queued for transmission. If there is room in the transmitter
    * buffer when this call is made, the character will be stored and control
    * returned to caller. If the buffer is full, the driver will wait for room.
    * This can be dangerous when used in combination with flow control (see
    * Function 0Fh)
    -----------------------------------------------------------------------------}
    Procedure X00Dvr.TxChar(Ch : Char);
      Begin
        Regs.al := Ord(Ch);
        Regs.Ah := $01;
        Regs.Dx := Port;
        Intr(CommVect,Regs);
        Status := Regs.AX;
      End;

    {
    * Receive Character
    *
    * The next character in the input ring buffer is returned to the caller. If
    * none available, the driver will wait for input.
    -----------------------------------------------------------------------------}
    Function  X00Dvr.RxChar : Char;
      Begin
        Regs.Dx := Port;
        Regs.Ah := $02;
        Intr(CommVect,Regs);
        RxChar := Char(Regs.Al);
      End;

    {
    * Get Status
    *
    * Bits are:
    * AH[6:6] 1 = Output buffer empty
    * AH[5:5] 1 = Output buffer not full
    * AH[1:1] 1 = Input buffer overrun
    * AH[0:0] 1 = Characters in input buffer
    * AL[7:7] 1 = Carrier Detect signal
    * AL[3:3] 1 = Always (never 0)
    -----------------------------------------------------------------------------}
    Function  X00Dvr.GetStatus : Word;
      Begin
        Regs.Dx := Port;
        REgs.Ah := $03;
        Intr(CommVect,Regs);
        GetStatus := Regs.Ax;
        Status := Regs.AX;
      End;

    {
    * Init Fossil Driver
    *
    * Required before I/O can take place on comm port.  When DX = 00FFh,  then
    * any initialization needed to make the keyboard/display available for FOSSIL
    * use should be performed.  BX = 4F50h signals that ES:CX points to a flag
    * byte in the application that the driver should increment when its
    * keyboard routines detect a Ctl-C.
    -----------------------------------------------------------------------------}
    Procedure X00Dvr.InitFossil;
      Begin
        Regs.Dx := Port;
        Regs.Ah := $04;
        Regs.Bx := 0;
        Intr(CommVect,Regs);
        If Regs.Ax <> $1954 Then
          Begin
            MaxFuncs := 0;
            RevLevel := 0;
          End
        Else
          Begin
            MaxFuncs := Regs.Bl;
            RevLevel := Regs.Bh;
          End;
      End;

    {
    * De-Init Fossil Driver
    *
    * Disengages driver from comm port. Should be done when operations on the
    * port are complete.  IF DX = 00FFh, then the initialization that was
    * performed when FOSSIL function 04h with DX = 00FFh should be undone.
    -----------------------------------------------------------------------------}
    Procedure X00Dvr.DeinitFossil;
      Begin
        If MaxFuncs < $05 Then
            Exit;
        Regs.Dx := Port;
        Regs.Ah := $05;
        Intr(CommVect,Regs);
      End;

    {
    * Drop Dtr Line
    *
    * Used to control Data Terminal Ready signal line on com port. This line
    * usually has some effect on modem operation (most modems will drop
    * carrier if DTR is lowered, for example).
    -----------------------------------------------------------------------------}
    Procedure X00Dvr.DropDTR;
      Begin
        If MaxFuncs < $06 Then
            Exit;
        Regs.Dx := Port;
        Regs.Ah := $06;
        Regs.Al := 0;
        Intr(CommVect,Regs);
      End;

    {
    * Rase Dtr Line
    *
    * Used to control Data Terminal Ready signal line on com port. This line
    * usually has some effect on modem operation (most modems will drop
    * carrier if DTR is lowered, for example).
    -----------------------------------------------------------------------------}
    Procedure X00Dvr.RaseDTR;
      Begin
        If MaxFuncs < $06 Then
            Exit;
        Regs.Dx := Port;
        Regs.Ah := $06;
        Regs.Al := 1;
        Intr(CommVect,Regs);
      End;

    {
    * Get System Timming Parameters
    *
    * Returns statistics needed to do some critical timing in any MS-DOS system.
    * The interrupt number in AL can be used to intercept a timer interrupt
    * that happens (AH) times per second. DX is essentially 1000/AH. Function
    * 16h is the preferred way to install timer tick code. AH and DX should
    * be accurate for the 16h timer tick.
    -----------------------------------------------------------------------------}
    Procedure X00Dvr.SystemTimerParams(Var TicksPerSec,MsPerTick : Word);
      Begin
        If MaxFuncs < $07 Then
            Exit;
        Regs.Ah := $07;
        Intr(CommVect,Regs);
        TicksPerSec := Regs.Ah;
        MsPerTick := Regs.Dx;
      End;

    {
    * Flush Output Buffer
    *
    * This is used to wait for all output to complete. If flow control is active
    * it is possible for this code never to return control to the caller. (See
    * function 0Fh)
    -----------------------------------------------------------------------------}
    Procedure X00Dvr.FlushBuffer;
      Begin
        If MaxFuncs < $08 Then
            Exit;
        Regs.Dx := Port;
        Regs.Ah := $08;
        Intr(CommVect,Regs);
      End;

    {
    * Purge Output Buffer
    *
    * Zero the output buffer. Returns to the caller immediately. Characters
    * that have not been transmitted yet are lost.
    -----------------------------------------------------------------------------}
    Procedure X00Dvr.PurgeOutputBuffer;
      Begin
        If MaxFuncs < $09 Then
            Exit;
        Regs.Dx := Port;
        Regs.Ah := $09;
        Intr(CommVect,Regs);
      End;

    {
    * Purge Input Buffer
    *
    * Zeroes the input buffer. If any flow control restraint has been employed
    * (dropping RTS or transmitting XOFF) the port will be "released" (by doing
    * the reverse, raising RTS or sending XON). Returns to caller immediately.
    -----------------------------------------------------------------------------}
    Procedure X00Dvr.PurgeInputBuffer;
      Begin
        If MaxFuncs < $0A Then
            Exit;
        Regs.Dx := Port;
        Regs.Ah := $0A;
        Intr(CommVect,Regs);
      End;

    {
    * Transmit Character without wait
    *
    * Character is queued for transmission. If there is room in the transmitter
    * buffer when this call is made, the character will be stored and control
    * returned to caller with AX=1. If the buffer is full, control is returned
    * to caller with AX=0. This allows the application to make its own decisions
    * on how to deal with "buffer full".
    -----------------------------------------------------------------------------}
    Procedure X00Dvr.TxCharNoWait(Ch : Char);
      Begin
        Repeat
        If MaxFuncs < $0B Then
            Exit;
          Regs.Dx := Port;
          Regs.Ah := $0B;
          Regs.Al := Ord(Ch);
          Intr(CommVect,Regs);
        Until (Regs.Ax <> 0);
      End;

    {
    * Keyboard Peek Character
    *
    * The next character in the input ring buffer is returned to the caller. If
    * none available, the driver returns a value of FFFFH. This "read" does not
    * actually remove a character from the input buffer!
    -----------------------------------------------------------------------------}
    Function  X00Dvr.RXPeekChar(Var Ch : Char) : Boolean;
      Begin
        If MaxFuncs < $0C Then
          c¾îºD‘B6Q|   Regs.DX := Port;
        Regs.AH := $0C;
        Intr(CommVect,Regs);
        Ch := Char(Regs.AL);
        If Regs.AX = $FFFF Then
            RxPeekChar := False
        Else
            RxPeekChar := True;
      End;

    {
    * Keyboard Peek Character
    *
    * The next character in the keyboard buffer is returned to the caller. If
    * none available, the driver returns a value of FFFFH. This "read" does not
    * actually remove a character from the input buffer! For function keys, IBM
    * PC scan codes must be returned.
    -----------------------------------------------------------------------------}
    Function  X00Dvr.KBPeekChar(Var Ch : Word) : Boolean;
      Begin
        If MaxFuncs < $0D Then
            Exit;
        Regs.DX := Port;
        Regs.AH := $0D;
        Intr(CommVect,Regs);
        Ch := Regs.AX;
        If Regs.AX = $FFFF Then
            KBPeekChar := False
        Else
            KBPeekChar := True;
      End;

    {
    * Keyboard Read Character
    *
    * Return the next character from the keyboard buffer. Wait for a keystroke
    * if the buffer is empty. For function keys, IBM PC scan codes are required.
    -----------------------------------------------------------------------------}
    Function X00Dvr.KBRead : Word;
      Begin
        If MaxFuncs < $0E Then
            Exit;
        Regs.AH := $0E;
        Intr(CommVect,Regs);
        KBRead := Regs.AX;
      End;

    {
    * Flow Control
    *
    * AL[0:0] 1= enables remote to restrain FOSSIL transmitter using XON/XOFF;
    * AL[1:1] 1= enables modem restraint of FOSSIL transmitter using CTS and
    *            FOSSIL restraint of modem using RTS
    * AL[3:3] 1= enables FOSSIL to restrain remote using XON/XOFF.
    -----------------------------------------------------------------------------}
    Procedure X00Dvr.FlowControl(XONCTS : Byte);
      Begin
        If MaxFuncs < $0F Then
            Exit;
        Regs.Dx := Port;
        Regs.Ah := $0F;
        Regs.Al := XonCTS;
        Intr(CommVect,Regs);
      End;

    {
    * Ctrl C Checking On
    *
    * AL[0:0] 1 = enable/disable CtlC/CtlK check (driver will set internal flag
    *             which is returned by this function when it detects a CtlC/CtlK).
    * AL[1:1] 1 = stop transmitter
    *         0 = release previous stop
    *             This is used primarily for programs that can't trust XON/XOFF
    *             at FOSSIL level (such as BBS software).
    -----------------------------------------------------------------------------}
    Procedure X00Dvr.CtrlCChkOn;
      Begin
        If MaxFuncs < $10 Then
            Exit;
        Regs.Dx := Port;
        Regs.AH := $10;
        CtrlCFlags := CtrlCFlags Or 1;
        Regs.AL := CtrlCFlags;
        Intr(CommVect,Regs);
      End;

    {
    * Ctrl C Checking Off
    *
    * AL[0:0] 1 = enable/disable CtlC/CtlK check (driver will set internal flag
    *             which is returned by this function when it detects a CtlC/CtlK).
    * AL[1:1] 1 = stop transmitter
    *         0 = release previous stop
    *             This is used primarily for programs that can't trust XON/XOFF
    *             at FOSSIL level (such as BBS software).
    -----------------------------------------------------------------------------}
    Procedure X00Dvr.CtrlCChkOff;
      Begin
        If MaxFuncs < $10 Then
            Exit;
        Regs.Dx := Port;
        Regs.AH := $10;
        CtrlCFlags := CtrlCFlags And Not 1;
        Regs.AL := CtrlCFlags;
        Intr(CommVect,Regs);
      End;

    {
    * Transmitter On
    *
    * AL[0:0] 1 = enable/disable CtlC/CtlK check (driver will set internal flag
    *             which is returned by this function when it detects a CtlC/CtlK).
    * AL[1:1] 1 = stop transmitter
    *         0 = release previous stop
    *             This is used primarily for programs that can't trust XON/XOFF
    *             at FOSSIL level (such as BBS software).
    -----------------------------------------------------------------------------}
    Procedure X00Dvr.XmitOn;
      Begin
        If MaxFuncs < $10 Then
            Exit;
        Regs.Dx := Port;
        Regs.AH := $10;
        CtrlCFlags := CtrlCFlags And Not 2;
        Regs.AL := CtrlCFlags;
        Intr(CommVect,Regs);
      End;

    --- FD 1.99c
     * Origin: If you clone around you'll end up talking to yourself! (1:105/324.1)

    Ä Turbo Pascal ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ PASCAL Ä
    Msg  : 351 of 400
    From : Gordon Tackett                      1:105/324.1          01 Apr 91  10:44
    To   : Roland Frederic                     2:292/500.0
    Subj : BBS Program in TP. Part 5 of 5
    ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
    {
    * Transmitter Off
    *
    * AL[0:0] 1 = enable/disable CtlC/CtlK check (driver will set internal flag
    *             which is returned by this function when it detects a CtlC/CtlK).
    * AL[1:1] 1 = stop transmitter
    *         0 = release previous stop
    *             This is used primarily for programs that can't trust XON/XOFF
    *             at FOSSIL level (such as BBS software).
    -----------------------------------------------------------------------------}
    Procedure X00Dvr.XmitOff;
      Begin
        If MaxFuncs < $10 Then
            Exit;
        Regs.Dx := Port;
        Regs.AH := $10;
        CtrlCFlags := CtrlCFlags Or 2;
        Regs.AL := CtrlCFlags;
        Intr(CommVect,Regs);
      End;

    {
    * Goto XY
    *
    * Identical to IBM PC BIOS INT 10h, subfunction 02h. FOSSIL should do
    * sanity checks but software should not assume that that is the case.
    -----------------------------------------------------------------------------}
    Procedure  X00Dvr.GotoXY(X,Y : Word);
      Begin
        If MaxFuncs < $11 Then
            Exit;
        Regs.Dh := Lo(Y-1);
        Regs.Dl := Lo(X-1);
        Regs.AH := $11;
        Intr(CommVect,Regs);
      End;

    {
    * Get Cursor Location
    *
    * Identical to IBM PC BIOS INT 10h, subfunction 03h.
    -----------------------------------------------------------------------------}
    Procedure  X00Dvr.GetCursorLoc(Var X,Y : Word);
      Begin
        If MaxFuncs < $12 Then
            Exit;
        Regs.AH := $12;
        Intr(CommVect,Regs);
        Y := Regs.Dh + 1;
        X := Regs.Dl + 1;
      End;

    {
    * Ansi Write Character
    *
    * ANSI processing is a requirement of this call. It therefore should not be
    * considered re-entrant, since DOS might be used (via ANSI.SYS)
    -----------------------------------------------------------------------------}
    Procedure X00Dvr.AnsiWriteChar(Ch : Char);
      Begin
        If MaxFuncs < $13 Then
            Exit;
        Regs.Al := Ord(Ch);
        Regs.AH := $13;
        Intr(CommVect,Regs);
      End;

    {
    * Enable Watch Dog
    *
    * FOSSIL will force the system to reboot if Carrier Detect on the specified
    * port drops while "watchdog" is ON. It is not necessary for the port to
    * be "active" (Function 04h) for this function to be used.
    -----------------------------------------------------------------------------}
    Procedure X00Dvr.EnableWatchDog;
      Begin
        If MaxFuncs < $14 Then
            Exit;
        Regs.AL := 1;
        Regs.Dx := Port;
        Regs.Ah := $14;
        Intr(CommVect,Regs);
      End;

    {
    * disable Watch Dog
    *
    * FOSSIL will force the system to reboot if Carrier Detect on the specified
    * port drops while "watchdog" is ON. It is not necessary for the port to
    * be "active" (Function 04h) for this function to be used.
    -----------------------------------------------------------------------------}
    Procedure X00Dvr.DisableWatchDog;
      Begin
        If MaxFuncs < $14 Then
            Exit;
        Regs.AL := 0;
        Regs.Dx := Port;
        Regs.Ah := $14;
        Intr(CommVect,Regs);
      End;

    {
    * Write Character
    *
    * Write character to screen using re-entrant code. ANSI processing may
    * not be assumed. This call may be used by DOS device drivers.
    -----------------------------------------------------------------------------}
    Procedure  X00Dvr.WriteChar(Ch : Char);
      Begin
        If MaxFuncs < $15 Then
            Exit;
        Regs.AL := Ord(Ch);
        Regs.AH := $15;
        Intr(CommVect,Regs);
      End;

    {
    * Insert Timer Function
    *
    * Allows FOSSIL to manage timer tick chain, which provides some measure of
    * security over just snagging the interrupt. Use "insert" instead of
    * grabbing the vector and "remove" in place of restoring it.
    -----------------------------------------------------------------------------}
    Function X00Dvr.InsertTimerFunction(TF : TimerFunctionPtr) : Boolean;
      Begin
        If MaxFuncs < $16 Then
            Exit;
        Regs.AH := $16;
        Regs.AL := 1;
        Regs.ES := Seg(TF^);
        Regs.Dx := Ofs(TF^);
        Intr(CommVect,Regs);
        If Regs.Ax = 0 Then
            InsertTimerFunction := True
        Else
            InsertTimerFunction := False;
      End;

    Function X00Dvr.DeleteTimerFunction(TF : TimerFunctionPtr) : Boolean;
      Begin
        I„ÎîºD‘B6ñ9 < $16 Then
            Exit;
        Regs.AH := $16;
        Regs.AL := 0;
        Regs.ES := Seg(TF^);
        Regs.Dx := Ofs(TF^);
        Intr(CommVect,Regs);
        If Regs.Ax = 0 Then
            DeleteTimerFunction := True
        Else
            DeleteTimerFunction := False;
      End;

    {
    * Reboot
    *
    * Provides a machine-independent way for a "troubled" application to reset
    * the system. Some machines may not support both "flavors" of bootstrap,
    * in which case the setting of AL will not have any effect.
    -----------------------------------------------------------------------------}
    Procedure  X00Dvr.Reboot(Tp : Boolean);
      Begin
        If MaxFuncs < $17 Then
            Exit;
        Regs.AH := $17;
        Regs.Al := 0;
        If Tp Then
          Regs.Al := 1;
        Intr(CommVect,Regs);
        WriteLn('System Error - Unable to ReBoot');
        While (True) Do;
      End;

    {
    * Receive Buffer
    *
    * Transfer as many characters as are available into the specified user
    * buffer, up to the maximum specified in CX. ES and DI will not be modified
    * by this call. The actual number of characters transferred will be in AX.
    * This function does not wait for more characters to become available if the
    * number in CX exceeds the number of characters currently stored.
    -----------------------------------------------------------------------------}
    Procedure X00Dvr.RecvBuffer(Buffer : Pointer; Var Sz : Word);
      Begin
        If MaxFuncs < $18 Then
            Exit;
        If (Self.GetStatus And $0100) = 0 Then
          Begin
            Size := 0;
            Exit;
          End;
        Regs.Dx := Port;
        Regs.Es := Seg(Buffer^);
        Regs.Di := Ofs(Buffer^);
        Regs.Cx := Sz;
        Regs.Ah := $18;
        Intr(CommVect,Regs);
        Size := Regs.Ax;
      End;

    {
    * Send Buffer
    *
    * Transfer as many characters as will fit, from the specified user buffer
    * into the output buffer, up to the maximum specified in CX. ES and DI
    * will not be modified by this call. The actual number of characters
    * transferred will be in AX.
    -----------------------------------------------------------------------------}
    Procedure X00Dvr.SendBuffer(Buffer : Pointer; Sz : Word);
      Var
        Cptr   : ^Char;
        I     : Integer;
      Begin
        If MaxFuncs < $19 Then
            Exit;
        Cptr  := Buffer;
        Regs.Dx := Port;
        Regs.Es := Seg(Buffer^);
        Regs.Di := Ofs(Buffer^);
        Regs.Cx := Sz;
        Regs.Ah := $19;
        Intr(CommVect,Regs);
        If Regs.Ax <> Sz Then
          Begin
            Regs.Di := Regs.Di + Regs.Ax;
            Cptr := Ptr(Regs.Es, Regs.Di);
            For I := Regs.Ax To Sz Do
              Begin
                Self.TxChar(Cptr^);
                Cptr := Ptr(Seg(Cptr^),Ofs(Cptr^) + 1);
              End;
          End;
      End;

    {
    * Stop Break
    *
    * Used for special applications such as certain high speed modems. Resets
    * all transmit flow control restraints (such as an XOFF received from remote)
    * Init (Function 4) or UnInit (Function 5) will stop an in-progress Break.
    * Note: the application must determine the "length" of the BREAK.
    -----------------------------------------------------------------------------}
    Procedure X00Dvr.StopBreak;
      Begin
        If MaxFuncs < $1A Then
            Exit;
        Regs.Dx := Port;
        Regs.Ah := $1A;
        Regs.Al := 0;
        Intr(CommVect,Regs);
      End;

    {
    * Send Break
    *
    * Used for special applications such as certain high speed modems. Resets
    * all transmit flow control restraints (such as an XOFF received from remote)
    * Init (Function 4) or UnInit (Function 5) will stop an in-progress Break.
    * Note: the application must determine the "length" of the BREAK.
    -----------------------------------------------------------------------------}
    Procedure X00Dvr.SendBreak;
      Begin
        If MaxFuncs < $1A Then
            Exit;
        Regs.Dx := Port;
        Regs.Ah := $1A;
        Regs.Al := 1;
        Intr(CommVect,Regs);
      End;

    {
    * Get Info Block
    *
    * Get The Info Block Record from Fossil to usable memory. An Info Block is:
    *
    * Offset 0 (word) = Structure size
    *        2 (byte) = FOSSIL spec version
    *        3 (byte) = Driver rev level
    *        4 (dwrd) = Pointer to ASCII ID
    *        8 (word) = Input buffer size
    *       0A (word) = Bytes avail (input)
    *       0C (word) = Output buffer size
    *       0E (word) = Bytes avail (output)
    *       10 (byte) = Screen width, chars
    *       11 (byte) = Screen height, chars
    *       12 (byte) = Baud rate mask
    *                   (See call 00h)
    -----------------------------------------------------------------------------}
    Procedure  X00Dvr.GetInfo;
      Begin
        If MaxFuncs < $1B Then
            Exit;
        Regs.Cx := Sizeof(CurInfo);
        Regs.Es := Seg(CurInfo);
        Regs.Di := Ofs(CurInfo);
        Regs.Dx := Port;
        Regs.Ax := $1B;
        Intr(CommVect,Regs);
      End;

    {
    *
    *
    * Used to install user appendages into the INT 14h dispatcher.  Appendage
    * codes 80h - BF are supported.  Codes 80h - 83h are reserved.  The error
    * return,  BH = 00h and AX = 1954h, should mean that another appendage
    * has already been installed with the code specified in AL.  The appendage
    * will be entered via a far call whenever INT 14h call is made with AL
    * equal to the appendage code.  The appendage should return to the INT
    * 14h dispatcher via a far return.  The INT 14h dispatcher should not modify
    * any registers prior to making the far call to the appendage and after the
    * appendage returns control to the dispatcher.
    -----------------------------------------------------------------------------}
    {7E}
    {
    *
    *
    * Used to remove a user appendage that was installed using function 7Fh. An
    * error return means that either the entry point specified in ES:DX did
    * not match the entry point currently in the dispatcher table for the code
    * given in AL,  or that no entry for the code given in AL currently exits.
    -----------------------------------------------------------------------------}

    {7F}

    {$IFDEF LOCAL}
    Var
      t1,t2,t3 : Word;
    Begin
      Comm1.Init(0,2400,8,'N',2);
    {$ENDIF}
    End.

    --- FD 1.99c
     * Origin: If you clone around you'll end up talking to yourself! (1:105/324.1)

[Back to COMM SWAG index] [Back to Main SWAG index] [Original]