Programmer 7500/MAX_PROGRAMMERS.iso/PASCAL/FCOMM240.ZIP/FCOMM.DOC

Text File | 1991-03-07 | 26.4 KB | 740 lines

{ The following is the INTERFACE section of FCOMM.PAS (FCOMM.TPU).
  It has all of the functions and code you will need, so please don't
  hesitate and give me a ring via the Doorware FidoNet Echomail Conference. }


UNIT FCOMM;

{
 --------------------------------------------------------------------------
 FComm - A FOSSIL driven I/O Library for Doors w/lots-of-goodies :)

  - for use with Turbo Pascal 6.0
  - for use with Remote Access v1.0
  - works with RA's *.BBS files, DOOR.SYS and DORINFO?.SYS
  - SysOp "hot-keys" (see documentation or source code)
  - Code supporting Interactive EMSI
  - Emulated "windowed" ANSI & AVATAR graphics
  - Status line on caller
  - Checks for carrier drop, keyhit timeout and time-limit timeout.
  - semi-intelligent code
  - nice programmer who takes suggestions.. (yuck)
  - and FREE.

 Copyright (c) 1991 by Michael Paine

  - I hope this gets improved by a few programmers out there..  all I ask
    for is to only have one "valid" copy floating around, or chaos will
    definately occur, so please send improvements to:

                   FidoNet NETMAIL @ 1:363/111
               or  Data [phone] (The SCSI Resource BBS)

 A "TRUST-ME" NOTE: THE BEST WAY TO LEARN THIS LIBRARY IS TO KEEP USING IT
                    UNTIL IT WORKS.  THAT SOUNDS BACKWARDS, BUT IT IS THE
                    BEST WAY TO LEARN OTHER PEOPLE'S WORK...
 --------------------------------------------------------------------------
}

INTERFACE

USES Crt, DOS;

{$I STRUCT.100}

CONST

  { ---[ Control Characters ]-------------- }

  NUL   = #0;    SOH   = #1;    STX   = #2;
  ETX   = #3;    EOT   = #4;    ENQ   = #5;
  ACK   = #6;    BELL  = #7;    BS    = #8;
  HT    = #9;    LF    = #10;   VT    = #11;
  FF    = #12;   CR    = #13;   SO    = #14;
  SI    = #15;   DLE   = #16;   DC1   = #17;
  DC2   = #18;   DC3   = #19;   DC4   = #20;
  NAK   = #21;   SYN   = #22;   EOB   = #23;
  CAN   = #24;   EOM   = #25;   SUB   = #26;
  ESC   = #27;   FS    = #28;   GS    = #29;
  RS    = #30;   US    = #31;   SP    = #32;
  DEL   = #127;  BLANK = #255;

  { --------------------------------------- }

  FCommVer : STRING[11] = 'FComm v2.40';

  DeadTime : BOOLEAN = False; { if true, will not reset time limits from
                                EXITINFO.BBS to current time in FcommInit. }
  ForceLocal      : BOOLEAN    = False;  {Make system Local no matter what!}
  Chat            : BOOLEAN    = False;
  HiRes           : BOOLEAN    = False;
  UseBBS          : BOOLEAN    = False;       { for FPAD only }
  QuitHOT         : BOOLEAN    = False;
  WaitCall        : BOOLEAN    = False;       { for FPAD only }
  AsyncCancelled  : BOOLEAN    = False;
  DoorType        : (RA,
                     DoorInfo,
                     DoorSYS1,
                     DoorSYS2) = RA;
  DefBoolean      : BOOLEAN    = True;   { for InputBoolean }
  DefYes          : STRING[5]  = 'Yes';
  DefNo           : STRING[5]  = 'No';
  DefPause        : STRING     = 'Press ENTER to continue.';
  DefEcho         : BOOLEAN    = TRUE;
  DefIns          : BOOLEAN    = FALSE;
  DefMaxLine      : BYTE       = 255;
  DefIndex        : BYTE       = 0;
  DefReadForm     : BOOLEAN    = FALSE;
  DefFormBack     : BOOLEAN    = FALSE;
  DefAVTattr      : BYTE       = Cyan + Black;  { cyan on black }
  DefMISCchar     : CHAR       = '|';

  Echo   = TRUE;
  NoEcho = FALSE;

TYPE
   DorInfoRec = Record
                   SystemName : String;
                   SysopFirst : String;
                   SysopLast  : String;
                   CommPort   : Integer;
                   BaudRate   : WORD;
                   Parity     : Char;
                   DataBits   : Integer;
                   StopBits   : Integer;
                   Blank      : Integer;
                   UserFirst  : String;
                   UserLast   : String;
                   City       : String;
                   Graphics   : Integer;
                   SecLvl     : Integer;
                   MinLeft    : Integer;
                 End;

   DoorSYS1Rec = RECORD
                Name        : MSGTOIDXrecord;
                CommPort    : INTEGER;               { 1..8=Active ComPort,
                                                       0=Local }
                BaudRate    : WORD;                  { 300 to 38400 }
                MinLeft     : INTEGER;               { Mins under 32767 }
                Graphics    : CHAR;                  { 'G'=Graphics,
                                                       'M'=Mono }
                Alarm       : CHAR;                  { 'A'=AlarmOn,
                                                       'S'=SilentOn }
              END;

   DoorSYS2Rec = RECORD
                CommPort          : STRING[5];  { COM0: = Local }
                BaudRate          : WORD;       { 300 to 38400 }
                Parity            : CHAR;       { 7 or 8 }
                Node              : BYTE;       { 1 to 99 (default=1) }
                DTERate           : WORD;       { Actual BPS rate to use }
                ScreenOn          : CHAR;       { 'Y', 'N' (Default=Y) }
                PrinterOn         : CHAR;       { 'Y', 'N' (Default=Y) }
                PageBellOn        : CHAR;       { 'Y', 'N' (Default=Y) }
                CallerAlarmOn     : CHAR;       { 'Y', 'N' (Default=Y) }
                Name              : MSGTOIDXrecord;
                Location          : STRING[25]; { City, State }
                VoicePhone        : STRING[12]; { ### ###-#### }
                DataPhone         : STRING[12]; { ### ###-#### }
                Password          : STRING[15]; { CAUTION! }
                Security          : INTEGER;
                NoCalls           : WORD;       { Total Times On }
                LastDate          : STRING[8];  { DD/MM/YY }
                SecLeft           : LONGINT;    { Seconds remaining online }
                MinLeft           : WORD;       { Minutes remaining online }
                Graphics          : STRING[2];  { 'GR' = Graphics,
                                                  'NG' = NO Graphics,
                                                  '7E' = 7 bit, even parity
                                                         Graphics }
                ScreenLength      : BYTE;       { RA recommends 24 }
                ExpertModeON      : CHAR;       { 'Y', 'N' (Default=N) }
                Conferences       : STRING[80]; { Confs Registered in
                                                  ie. 1,2,3,4,5,6,7
                                                   or ABCDEFG }
                InConference      : CHAR;       { Current conference }
                ExpireDate        : STRING[8];  { Access ends on DD/MM/YY }
                UserRecord        : WORD;       { User File's Record Number }
                DefaultProtocol   : CHAR;       { ie. X,C,Y,G,I,N,Z, etc. }
                Uploads           : WORD;       { Total Uploads }
                Downloads         : WORD;       { Total Downloads }
                TodayK            : LONGINT;    { KB downloaded today }
                MaxTodayK         : LONGINT;    { Max KB allowed today }
              END;

VAR
  Local        : BOOLEAN;
  Str_1        : STRING;
  Ch_1         : CHAR;
  ErrorLvl,
  ErrorLvl0,
  ErrorLvl1    : BYTE;

  LogFile      : TEXT;

  DorInfo      : DorInfoRec;
  DorInfoFile  : TEXT;

  DorSYS1      : DoorSYS1Rec;
  DorSYS2      : DoorSYS2Rec;
  DorSYSFile   : TEXT;

  User         : UsersRecord;
  UserFile     : FILE of UsersRecord;

  CFG          : ConfigRecord;
  CFGFile      : FILE of ConfigRecord;

  ExitInfo     : ExitInfoRecord;
  ExitInfoFile : FILE of ExitInfoRecord;

  UserOn       : UserOnRecord;
  UserOnFile   : FILE of UserOnRecord;


             { -----======[ Low-level Modem Area ]======----- }
{ ---  These were designed using X00 ver 1.24 FOSSIL Device Driver --- }

Procedure AsyncSend(var C: char);
          { Send a Character ONLY to the ComPort }

Function AsyncReceive: CHAR;
          { Receive a Character ONLY from the COM Port.  Returns a NUL char.
            if one is not present. }

Procedure AsyncResetPort(BR: word; P: char;
                           D, S: integer);
          { Reset the ComPort to many different modem/line settings }

Function  AsyncInitPort: boolean;
          { INITIALIZIES THE PORT. USE THIS BEFORE ANYTHING ELSE! }

Procedure AsyncDeInitPort;
          { De-Initializes the port, including all Modem/Line Registers }

Procedure AsyncStats;
          { Sends message on Local/Modem connection and Baud, etc. }

Procedure AsyncSendString(S: string);
          { Send a whole string ONLY to the ComPort }

Procedure AsyncSendStringWithDelays(S: string; CharDelay,
                                            EOSDelay: integer);
          { Send a whole string ONLY to the ComPort with delays between
            each character, and a delay when at the end of the string. }

Procedure AsyncReadString(VAR S: String);
          { Read a whole string ONLY from the ComPort }

Function  AsyncCarrierDetect: boolean;
          { Is there a modem connection present? }

Procedure AsyncReInitPort;
          { Re-Initialize the port/screen after caller. }

Function  AsyncIBufferCheck: boolean;
          { Is there anything inside the input buffer besides NUL's? }

Function  AsyncOBufferCheck: boolean;
          { Check to see if something is in the output buffer }

Procedure FlushTypeAheadBuffer;
          { Get rid of anything inside the host keyboard buffer }

Procedure AsyncPurgeInputBuffer;
          { Get rid of anything inside the input buffer }

Procedure AsyncPurgeOutputBuffer;
          { Get rid of anything inside the output buffer }

Procedure AsyncFlushOutputBuffer;
          { Wait and wait until Output buffer has emptied itself. CAUTION:
            Highly-Possible to "crash" the computer with this option. }

Procedure AsyncLowerDTR;
          { Drop the carrier signal quickly. "Turn off the modem" }

Procedure AsyncRaiseDTR;
          { Enable the modem for a carrier. "Turns on the modem" }

Procedure AsyncHangUp;
          { Hangs up the modem. Fast and simple }

Function  AsyncResultCode(Secs: integer): string;
    { Responds with a Number Modem Result Code ONLY. Secs = Timeout }

Function  FossilWhereX: byte;
          { Replaces WhereX Function.  Fossil controlled. }

Function  FossilWhereY: byte;
          { Replaces WhereY Function.  Fossil controlled. }

Function  FossilKeyPressed: boolean;
          { Replaces the KeyPressed command.  CAUTION: Do not mix the
            standard KeyPressed/ReadKey with the Fossil versions. Use
            one or the other! }

Function  FossilReadKey: char;
          { Replaces TP's ReadKey Function }

Procedure FossilWatchdogOn;
          { Turns on a internal WatchDog.  Reboots if carrier is dropped. }

Procedure FossilWatchdogOff;
          { Turns OFF a internal WatchDog.  CAUTION: Use WatchDog ONLY if
            necessary! }

Procedure FossilWarmBoot;
          { Re-boot the system with a warm-bootstrap (just boot). }

Procedure FossilColdBoot;
          { Re-boot the system with a cold-bootstrap (power-up, self-test and
            boot) }

{ -----=====[ Low Maintainance Modem Processing Area ]=====----- }

Function  TestBit(Num: INTEGER; Bit: INTEGER): BOOLEAN;
          { TEST a Bit of a Number whether it is ON or OFF }

Procedure SetBit(var Target; Bit : INTEGER);
          { 1 - Make a bit of a number (ON) }

Procedure ClearBit(var Target; Bit : INTEGER);
          { 0 - Make a bit of a number (OFF }

function ShowBit(TmpINT: INTEGER): STRING;
         { Show the contents of a integer from Lo-order to Hi-order bits.
           'X' = ON, and '-' = OFF }

function Timeout(Secs: BYTE): BOOLEAN;
         { Waits for a reply from COM Port in specified amount of time }

function  FKeyPressed: BOOLEAN;
          { Has a character been pressed (either side)? }

function  FReadKey: CHAR;
          { If FKeyPressed is true, then take that character }

function  Carrier: BOOLEAN;
          { Is a carrier detected? }

procedure SetBaud(BaudNum: BYTE);
          { Set the bps rate from 1 (300) to 5 (19.2K) w/o checks }

procedure SyncBaud;
          { Syncronize this modem's BPS to other side }

{ -----======[ Mid-level Modem/Screen OUTPUT Area ]======----- }

procedure WriteA(var C: CHAR);
          { Character is written w/emulated ANSI and AVATAR writes.
            Direct or BIOS writes are available. }

procedure WriteL(L: STRING);
          { A whole line of WriteA }

procedure PrintR(C: CHAR);
          { RAW, unformatted, one-character output w/echo to comm }

procedure PrintD(Out: STRING);
          { DIRECTLY writes a line to COM port and local }

Procedure StatusLine;
          { Display/Update status line }

procedure CheckTimeout;
          { Checks every SECMOD seconds for a timeout. Note, you must do a
            "Timer1 := TimerSet;"  prior to this call! }

procedure PrintO(C: CHAR);
          { OPTION version of the 'PrintR'.
            Checks for Pause, Stop and ScrnPause features }

procedure Print(Out: STRING);
          { Prints a whole line using the above method }

procedure PrintLn(Out: STRING);
          { Same as Print procedure, but w/CRLF }

procedure CRLF;
          { Down to new line. scrolls text }

{ -----======[ Mid-level Modem/Screen INPUT Area ]======----- }

procedure FRead(VAR TmpCH: CHAR);
          { Take a character.  Uses WithEcho, but sets it true
            when done. }

procedure FReadLn( VAR S1 );
          { Inputs a whole line of text as a type string }

function  InputBoolean: BOOLEAN;
          { Single Y or N input, and converts into a boolean response.
            Uses DEFAULTBOOLEAN global boolean if CR pressed }

function  ReadBoolean: BOOLEAN;
          { Same as InputBoolean, but works only locally }

Procedure AsyncPause;
          { Show DefaultPause to screen, then wait for a keypress. }

Procedure PauseOn;
          { Turn screen pausing on. }

Procedure PauseOff;
          { Turn screen pausing off. }

 { -----======[ Misc. String and Screen Utility Area ]======----- }

procedure LogEcho(S: STRING);
          { Echo RA formatted string to log file }

function  Misc(S: STRING): STRING;
          { Miscellanous ANSI & other special codes:

    EMULATED:
    00 = black,         01 = blue,          02 = green,
    03 = cyan,          04 = red,           05 = magenta,
    06 = brown,         07 = light gray,    08 = dark gray,
    09 = light blue,    10 = light green,   11 = light cyan,
    12 = light red,     13 = light magenta, 14 = yellow,
    15 = white

    20 = black BC,      21 = blue BC,       22 = green BC,
    23 = cyan BC,       24 = red BC,        25 = magenta BC,
    26 = brown BC,      27 = light gray BC  28 = Set TextAttr to N

    30 = Attr RESET,    31 = Blink ON,      32 = ClrScr,
    33 = ClrEol,        34 = Home,          35 = GotoXY(X,Y),
    36 = Up 1 line,     37 = Down 1 line,   38 = Right 1 line,
    39 = Left 1 line

    ANSI:
    40 = Bold ON,       41 = Faint ON,      42 = Italic ON,
    43 = Fast Blink ON, 44 = Rev. Video ON, 45 = Concealed ON,
    46 = Subscript ON,  47 = Superscript ON,
    48 = ClrScr ≤,      49 = ClrScr ≥,      50 = ClrEol ≤,
    51 = BlankLine,     52 = InsLine,       53 = DelLine,
    54 = Device Status Report (for auto-ANSI detecting),
    55 = Save pos,      56 = Restore pos,
    57 = Wrap at EOL,   58 = No wrap at EOL

    INTERNAL:
    70 = ANSI Toggle,   71 = AVATAR Toggle, 72 = MinsLeft Str,
    73 = SecsLeft Str,  74 = Hang-up User,  75 = SetBaud(N)

    AVT/0:
    80 = Fill_Char (Repeat sending Chr(X) Y times)

    NOTES:  ■ X = FHInfo.X, Y = FHInfo.Y and N = FHInfo.N
             (these have to be preset before execution!)
            ■ AVATAR is given highest priority,
              ANSI is second,
              NONE is last

  }

procedure Error(Job: BYTE);
          { Built-in time-programming saving for simply programming. }

Function PosNext(SubS: STRING; S: STRING): STRING;
         { Locates a next sub-string within a string seperated by
           commas.  If no more, then it returns '' }

function  StrToVal(S: STRING): WORD;
          { Convert a String to a Ordinal number }

function  LoCase(Ch: CHAR): CHAR;
          { Converts a character to Lower Case.  Supplement to the UpCase
            Function }

function  UpperCase(Letters: STRING): STRING;
          { Converts a line of text into Upper Case }

function  LowerCase(Letters: STRING): STRING;
          { Converts a line of text into Lower Case }

function  FirstCase(Letters: STRING): STRING;
          { Makes first character of line Upper Case, and rest Lower Case }

function  FirstName(Letters: STRING): STRING;
          { Returns the first name (or first word) within the Letters string }

function  RealName(Letters: STRING): STRING;
          { Returns first name in a two/more-word name or
            last name in a one-word name. }

function  LastName(Letters: STRING): STRING;
          { Returns the last name (or last word) within the Letters string }

function  PadStrL(Letters: STRING; Pad: BYTE): STRING;
          { Pad a string to a certain size.  Justified left side }

function  PadStrR(Letters: STRING; Pad: BYTE): STRING;
          { Same as PadStrL, but justifies to the right side }

function  FJustify( S: STRING; LeftBorder, RightBorder: BYTE ) : STRING;
          { Justify a string within these boundarys.
            Implants CRLF's and Spaces(s). WARNING: Truncates
            the orginal string at 255 characters (string)! }

Function  FExist(FName: STRING) : BOOLEAN;
          { See if "FName" can be found.  Should be in DOS unit :) }

function  FileExist(Fil: STRING; var Extension: STRING): BOOLEAN;
          { Checks for a existing file. If so, the extension is returned. }

procedure TypeFile(Fil: STRING; ShowHeader: BOOLEAN);
          { Types out a text file if exists and right graphics mode.
            ShowHeader is if Hot-Key List will be shown. }

procedure STDIO;
          { Lets redirrection of Input & Output }

procedure CLS;
          { Clears COM and local screens. }

procedure FINDLOCATE(var R,C: BYTE);
          { Finds Rows and Column of the cursor on the screen }

function  LOCATE(R,C: BYTE): STRING;
          { if ANSI toggled, locates cursor to new position. If R or C
            is = to 0, then it assumes the current position to substitute. }

procedure GotoRC(R1 , C1 : BYTE);
          { Uses LOCATE command within a nifty procedure. }

function  TAB(place: byte): string;
          { Place the cursor onto a tab position. !! Needs work. }

procedure Message(Msg: STRING);
          { write out a fast message for a local reader }

{ -----======[ Misc. Time and DOS File Utility Area ]======----- }

Procedure DumbTerminal(SmartMode: BOOLEAN);
          { A dumb terminal w/ANSI w/option of word-wrapping (SmartMode) }

Procedure DMYtoDate(Day,Month,Year: integer;var Julian: Word);
          { Convert from day,month,year to a date }
          { Stored as number of days since January 1, 1990 }
          { Note that no error checking takes place in this routine -- use ValidDate }

procedure DateToDMY(Julian: Word;var Day,Month,Year: integer);
          { Convert from a date to day,month,year }

function  TellTime: STRING;
          { Returns a string format of the current TIME }

function  TellAllTime: STRING;
          { Returns Hour:Minute:Seconds of the current time }

function  StrToMin(InTime: STRING): WORD;
          { 'TellTimeInMinutes' a word containing the time in minutes }

function  StrToSec(InTime: STRING): LONGINT;
          { Convert the "InTime" String to a longint number.
            24 hours = 86400 }

function  TimerSet: LONGINT;
          { Sets an internal variable with the current time in seconds }

function  TimeLeftSec: LONGINT;
          { Return the total seconds left for call.  Checks for midnight law.
            Returns a negative is no time left. }

function  MinsLeft: INTEGER;
          { Number of minutes left for call }

function  MinsUsed: INTEGER;
          { Number of minutes used for the caller so far }

function  MinsTimer(InTime: STRING): INTEGER;
          { If you use timers for some purpose, this will return the
            absolute difference of the present time and InTime }

function  SecsTimer(Timer: LONGINT): LONGINT;
          { Same as MinsTimer, though seconds returned. }

function  TellDate: STRING;
          { Returns a string format of the current DATE }

function  ANSI: boolean;
          { Does the user have ANSI graphics turned on? bitmapped }

function  AVATAR: boolean;
          { Does the user have AVATAR graphics turned on? bitmapped }

function  SoundOn: boolean;
          { Does the system have sound on?  Checks "WANT CHAT" config. }

procedure AssignFiles(S: STRING);
          { Initializes data files for use. S lists which files to Assign }

procedure CloseFiles(S: STRING);
          { Closes all data files. S lists which files to Close }

procedure SaveDorInfo;
          { Save infomation to DORINFO1.DEF }

procedure LoadDorInfo;
          { Load information from DORINFO1.DEF }

procedure SaveDoorSYS;
          { Save information to DOOR.SYS.  Checks DoorType for method }

procedure LoadDoorSYS;
          { Load information from DOOR.SYS.  Checks DoorType for method }

function  GetRAEnv: STRING;
          { Find location of RA directory from DOS enviroment }

Procedure SaveExitInfo;
          { Save current exit info record data file. }

procedure LoadExitInfo;
          { Load the EXITINFO.BBS per user. }

procedure LoadUser;
          { Load specific user information.  Information pre-included
            inside the exitinfo record. }

procedure SaveUser;
          { Save current user record data. }

function  FindUser(S: STRING): BOOLEAN;
          { Searchs for S (the full user name) inside USERS.BBS, true if
            found and USER/EXITINFO.USERINFO records are ready to be used. }

Procedure LoadConfig;
          { Load CONFIG.BBS data into record. }

{ ****************************************** }

PROCEDURE FCOMMINIT;
          { INITIALIZES FCOMM.  MUST BE USED BEFORE ANY I/O PROCEDURES! }

{ ****************************************** }

{ The following is VERY useful for Print and PrintLn (since everything
  has to be strings).  I just want to credit the person whom wrote them,
  but I found them somewhere long ago, and can't find the original
  author..  If anyone knows, please contact me!  Thank you }

function StrL   (L: longint):                       string;
         { Converts a Longint into a String }

function StrLF  (L: longint; Field: integer):       string;
         { Converts a Longint into a String w/Field parameter }

function StrR   (R: real):                          string;
         { Converts a Real into a String }

function StrRF  (R: real; Field: integer):          string;
         { Converts a Real into a String w/Field parameter }

function StrRFD (R: real; Field,Decimals: integer): string;
         { Converts a Real into a String w/Field width and Decimal Places }

{ -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- }

IMPLEMENTATION

{ -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- }

CONST
  UsersBBS       = 'USERS.BBS';
  ExitInfoBBS    = 'EXITINFO.BBS';
  ConfigRA       = 'CONFIG.RA';
  RaLOG          = 'RA.LOG';
  DorInfo1DEF    = 'DORINFO1.DEF';
  DoorSYS        = 'DOOR.SYS';
  CommandCOM     = 'COMMAND.COM';
  ChatOnLine     = 'is breaking in...';
  ChatOffLine    = 'is now gone.';

  UsersBBSopened    : BOOLEAN = FALSE;
  ExitInfoBBSopened : BOOLEAN = FALSE;
  ConfigRAopened    : BOOLEAN = FALSE;
  RaLOGopened       : BOOLEAN = FALSE;
  DorInfo1DEFopened : BOOLEAN = FALSE;
  DoorSYSopened     : BOOLEAN = FALSE;
  TripEndOfDay      : BOOLEAN = FALSE;
  ErrorJob          : BYTE = 1;
  ScrnPos           : BYTE = 1;
  SecMod            = 2;  { Check for Carrier drop, Keyhit timeout }
                          { and Timelimit every SecMod seconds }
TYPE
   Str4        = STRING[4];

   EMSIrec     = RECORD               { Reserved for Interactive EMSI }
                   InsertMode   : BOOLEAN;
                   GraphicsMode : BYTE;
                   ULX,
                   ULY,
                   LRX,
                   LRY          : BYTE;
                 END;

   StatLineRec = RECORD
                   Mode         : BYTE;
                   TextAttr     : BYTE;
                   ULX          : BYTE;
                   ULY          : BYTE;
                   LRX          : BYTE;
                   LRY          : BYTE;
                 END;

   ReadRec     = RECORD
                   FormMode     : BOOLEAN;
                   ReadIndex    : BYTE;
                   MaxIndex     : BYTE;
                   SplitLine    : BOOLEAN;
                   ContractLine : BOOLEAN;
                   Up           : BOOLEAN;
                   Down         : BOOLEAN;
                   OnL          : BOOLEAN;
                   OnR          : BOOLEAN;
                   ListHead     : POINTER;
                   ListTail     : POINTER;
                   WordWrap     : BOOLEAN;
                   StringMode   : BOOLEAN;
                   AttrBold     : BYTE;
                   SaveX        : BYTE;
                   SaveY        : BYTE;
                   SaveTextAttr : BYTE;
                 END;

   InterFHInfo = RECORD
     ReadInfo     : ReadRec; { Input (line, form) information }
     EMSI         : EMSIrec; { Interactive EMSI information }
     StatLine     : StatLineRec; { Status Line information }
     X            : BYTE;    { General purpose variable }
     Y            : BYTE;    {    "       "        "    }
     N            : BYTE;    {    "       "        "    }
   END;

VAR
  FHInfo       : InterFHInfo;
  Regs         : Registers;
  SaveExitProc : POINTER;
  StartTime,
  Timer1       : LONGINT;
  Hour,
  Minute,
  Second,
  Sec100,
  Year,
  Month,
  Day,
  DayOfWeek    : WORD;
  L1,
  L2           : INTEGER;
  FosInit      : BOOLEAN;
  SecCheck     : BYTE;
  AVTcmd       : STRING[10];
  ANSIcmd      : STRING[40];

{ ------------------------------------------------------------------------ }