home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD1.mdf / pascal / library / dos / pibsoft / terminal / source / pibtdcl2.glo < prev    next >
Encoding:
Text File  |  1988-03-06  |  55.9 KB  |  1,267 lines
  1. (*----------------------------------------------------------------------*)
  2. (*                 Global variables for file transfers                  *)
  3. (*----------------------------------------------------------------------*)
  4.  
  5. CONST
  6.                    (* Special characters used in XMODEM *)
  7.  
  8.    SOH   = $01;                    (* Start of XMODEM block       *)
  9.    STX   = $02;                    (* Start of Ymodem block       *)
  10.    EOT   = $04;                    (* End of XMODEM transmission  *)
  11.    ACK   = $06;                    (* Acknowledge an XMODEM block *)
  12.    NAK   = $15;                    (* Refuse an XMODEM block      *)
  13.    SYN   = $16;                    (* Start of Telink header      *)
  14.    CAN   = $18;                    (* Cancel XMODEM transfer      *)
  15.  
  16. CONST
  17.    MaxSectorLength         = 5000  (* Length of sector data storage *);
  18.    MaxFileHandleBuffer     = 2048  (* Length of file handle buffer  *);
  19.  
  20. TYPE
  21.    Sector_Type             = ARRAY[ 1 .. MaxSectorLength     ] OF BYTE;
  22.    File_Handle_Buffer_Type = ARRAY[ 1 .. MaxFileHandleBuffer ] OF BYTE;
  23.    File_Handle_Buffer_Ptr  = ^File_Handle_Buffer_Type;
  24.  
  25. VAR
  26.    Sector_Size      : INTEGER      (* Size of Xmodem sector             *);
  27.  
  28.                                    (* One sector of data                *)
  29.    Sector_Data      : Sector_Type;
  30.  
  31. (* VAR *) CONST
  32.    Sector_Number    : INTEGER      (* Current sector number being sent  *)
  33.                       = 0;
  34.  
  35.    Max_Write_Buffer : INTEGER      (* File transfer buffer size         *)
  36.                       = 2048;
  37.  
  38.                    (* Transfer Declarations *)
  39. TYPE
  40.    Transfer_Type = ( Ascii, Xmodem_Chk, Xmodem_CRC, Kermit, Telink,
  41.                      Modem7_Chk, Modem7_CRC, Xmodem_1K, Xmodem_1KG,
  42.                      Ymodem_Batch, Ymodem_G,
  43.                      PUser1, PUser2, PUser3, PUser4, PUser5,
  44.                      PUser6, PUser7, PUser8, PUser9, PUser10,
  45.                      None );
  46.  
  47. CONST
  48.    Max_Transfer_Types = 22;
  49.  
  50. (* VAR *) CONST
  51.                                    (* Vector of available transfer types *)
  52.  
  53.    Transfers            : ARRAY[ 1 .. Max_Transfer_Types ] OF Transfer_Type
  54.                           = ( Ascii, Xmodem_Chk, Xmodem_Crc, Kermit, Telink,
  55.                               Modem7_Chk, Modem7_CRC, Xmodem_1K,  Xmodem_1KG,
  56.                               Ymodem_Batch, Ymodem_G,
  57.                               PUser1, PUser2, PUser3, PUser4, PUser5,
  58.                               PUser6, PUser7, PUser8, PUser9, PUser10,
  59.                               None );
  60.  
  61.                                    (* Vector of long transfer type names *)
  62.  
  63.    Transfer_Name_List   : ARRAY[ 1 .. Max_Transfer_Types ] OF String12
  64.                           = ( '       Ascii', '  Xmodem Chk', '  Xmodem CRC',
  65.                               '      Kermit', '      Telink', '  Modem7 Chk',
  66.                               '  Modem7 CRC', '   Xmodem 1K', '  Xmodem 1Kg',
  67.                               'Ymodem Batch', '    Ymodem g', '            ',
  68.                               '            ', '            ', '            ',
  69.                               '            ', '            ', '            ',
  70.                               '            ', '            ', '            ',
  71.                               '        None' );
  72.  
  73.                                    (* Vector of short transfer type names *)
  74.  
  75.    Trans_Type_Name      : ARRAY[ Transfer_Type ] OF Char_2 =
  76.                           ( 'AS', 'XK', 'XC', 'KE', 'TE', 'MK', 'M7',
  77.                             'X1', 'XG', 'YB', 'YG', '  ', '  ', '  ',
  78.                             '  ', '  ', '  ', '  ', '  ', '  ', '  ',
  79.                             'NO' );
  80.  
  81.                                    (* If protocol OK for use in host mode *)
  82.  
  83.    Trans_OK_In_Host     : ARRAY[ Transfer_Type ] OF BOOLEAN
  84.                           = ( TRUE,   TRUE,   TRUE,   TRUE,   TRUE,
  85.                               TRUE,   TRUE,   TRUE,   TRUE,   TRUE,
  86.                               TRUE,   TRUE,   TRUE,   TRUE,   TRUE,
  87.                               TRUE,   TRUE,   TRUE,   TRUE,   TRUE,
  88.                               TRUE,   TRUE    );
  89.  
  90.                                    (* Non-batch protocols *)
  91.  
  92.    Single_File_Protocol : ARRAY[Transfer_Type] OF BOOLEAN
  93.                           = ( TRUE,   TRUE,   TRUE,   FALSE,  FALSE,
  94.                               FALSE,  FALSE,  TRUE,   TRUE,   FALSE,
  95.                               FALSE,  TRUE,   TRUE,   TRUE,   TRUE,
  96.                               TRUE,   TRUE,   TRUE,   TRUE,   TRUE,
  97.                               TRUE,   TRUE    );
  98.  
  99.                                    (* Script names for external handlers *)
  100.  
  101.    Receive_Script_Names : ARRAY[ Transfer_Type ] OF String12
  102.                           = ( '', '', '', '', '', '', '', '', '', '', '',
  103.                               '', '', '', '', '', '', '', '', '', '', '' );
  104.  
  105.    Send_Script_Names    : ARRAY[ Transfer_Type ] OF String12
  106.                           = ( '', '', '', '', '', '', '', '', '', '', '',
  107.                               '', '', '', '', '', '', '', '', '', '', '' );
  108.  
  109.    External_Trans_Def   : ARRAY[ 1 .. 10 ] OF String80
  110.                           = ( '', '', '', '', '', '', '', '', '', '' );
  111.  
  112.                    (* File for Xmodem family transfers *)
  113. VAR
  114.    FileName            : AnyStr    (* Name of file                      *);
  115.    Saved_Kbd_File_Name : AnyStr    (* Saved keyboard line with filename *);
  116.    XFile               : FILE      (* Xmodem/Kermit file to transfer    *);
  117.  
  118.                    (* Timing/Delay Constants and Variables *)
  119. CONST
  120.    One_Second     =  1             (* One second                       *);
  121.    Two_Seconds    =  2             (* Two seconds                      *);
  122.    Five_Seconds   =  5             (* Five seconds                     *);
  123.    Ten_Seconds    = 10             (* Ten seconds                      *);
  124.    Twenty_Seconds = 20             (* Twenty seconds                   *);
  125.    Sixty_Seconds  = 60             (* Sixty seconds                    *);
  126.    Trans_Time_Val = 1800.0         (* Fudge factor for transfer times  *);
  127.  
  128.                    (* Ascii transfer definitions  *)
  129.  
  130. (* VAR *) CONST
  131.    Ascii_Char_Delay  : INTEGER     (* Character delay for Ascii trans.  *)
  132.                        = 0;
  133.    Ascii_Line_Delay  : INTEGER     (* Line delay for Ascii transfers    *)
  134.                        = 0;
  135.    Ascii_CR_LF_String: STRING[2]   (* CR or CR+LF to end ASCII lines    *)
  136.                        = ^M;
  137.    Ascii_CRLF        : BOOLEAN     (* TRUE if CR+LF to end ASCII lines  *)
  138.                        = FALSE;
  139.    Ascii_Line_Size   : INTEGER     (* Line size for stream transfers    *)
  140.                        = 255;
  141.    Ascii_Use_CtrlZ   : BOOLEAN     (* TRUE if CtrlZ used as EOF marker  *)
  142.                        = FALSE;
  143.    Ascii_Show_Text   : BOOLEAN     (* TRUE to display text during trans.*)
  144.                        = TRUE;
  145.    Ascii_Send_Blank  : BOOLEAN     (* TRUE to send empty lines as blank *)
  146.                        = FALSE;
  147.    Ascii_Send_Asis   : BOOLEAN     (* TRUE to send text as is           *)
  148.                        = FALSE;
  149.    Ascii_Translate   : BOOLEAN     (* TRUE to use translate tab in down.*)
  150.                        = TRUE;
  151.    Ascii_Pacing_Char : CHAR        (* Pacing character for uploads      *)
  152.                        = #0;
  153.  
  154.                    (* Save/restore transmission params during XMODEM *)
  155.  
  156. VAR
  157.    Xmodem_Bits_Save  : INTEGER     (* Save # bits per character         *);
  158.    Xmodem_Parity_Save: CHAR        (* Save parity                       *);
  159.    Xmodem_Stop_Save  : INTEGER     (* Save stop bits                    *);
  160.  
  161. (* VAR *) CONST
  162.    Xmodem_Char_Wait   : INTEGER    (* Character wait for Xmodem trans.  *)
  163.                         = 1;
  164.    Xmodem_Block_Wait  : INTEGER    (* Interblock wait for Xmodem trans. *)
  165.                         = 10;
  166.    Xmodem_Ack_Wait    : INTEGER    (* ACK wait time for Xmodem trans.   *)
  167.                         = 10;
  168.    Xmodem_Max_Errors  : INTEGER    (* Maximum errors in Xmodem          *)
  169.                         = 20;
  170.  
  171. (* VAR *) CONST                    (* Default transfer type             *)
  172.  
  173.    Default_Transfer_Type : Transfer_Type
  174.                            = Xmodem_CHK;
  175.  
  176.    Stop_Receive      : BOOLEAN     (* TRUE to cancel receiving of file. *)
  177.                        = FALSE;
  178.    Stop_Send         : BOOLEAN     (* TRUE to cancel sending of file.   *)
  179.                        = FALSE;
  180.    Use_Time_Sent     : BOOLEAN     (* TRUE to stamp file with received  *)
  181.                                    (* time and date.                    *)
  182.                        = TRUE;
  183.    Null_File_Name    : BOOLEAN     (* TRUE if null file name in Ymodem  *)
  184.                        = FALSE;
  185.    Display_Status    : BOOLEAN     (* TRUE to display transfer status   *)
  186.                        = TRUE;
  187.    Downsize_Ymodem   : BOOLEAN     (* TRUE to allow downsize in Ymodem  *)
  188.                        = FALSE;
  189.    Script_Transfer   : BOOLEAN     (* TRUE if doing transfer in script  *)
  190.                        = FALSE;
  191.    GMT_Difference    : INTEGER     (* Difference in hours between local *)
  192.                                    (* time and Greenwich mean time      *)
  193.                        = 0;
  194.    Transfer_Bells    : INTEGER     (* Number of bells after transfer    *)
  195.                        = 6;
  196.    YTerm_Mode        : CHAR        (* YTERM transfer mode               *)
  197.                        = 'B';
  198.    Do_WXModem        : BOOLEAN     (* TRUE to do WXModem                *)
  199.                        = FALSE;
  200.    Do_SeaLink        : BOOLEAN     (* TRUE to do SeaLink                *)
  201.                        = FALSE;
  202.    Zmodem_BlockSize  : INTEGER     (* Length for Zmodem transfers       *)
  203.                        = 256;
  204.    Zmodem_Autodownload:BOOLEAN     (* Allow Zmodem autodownloads        *)
  205.                        = FALSE;
  206.    Use_Full_Path_Name: BOOLEAN     (* TRUE to use full path in Ymodem   *)
  207.                        = FALSE;
  208.  
  209. {.C-}
  210. (*----------------------------------------------------------------------*)
  211. (*              Definitions for Kermit protocol transfers               *)
  212. (*----------------------------------------------------------------------*)
  213.  
  214. CONST
  215.    MaxKermitWindowSize     = 31;
  216.    MaxLongPacketLength     = 1000;
  217.  
  218. TYPE
  219.    Kermit_Packet_Buffer     = ARRAY[1..94] OF CHAR;
  220.    Kermit_Packet_Ptr        = ^Kermit_Packet_Buffer;
  221.  
  222.    Kermit_State_Vars = ( Send_Init,      Send_File_Header,  Send_File,
  223.                          Send_EOF,       Send_Break,        Receive_Init,
  224.                          Receive_Header, Receive_File,      Send_Bye,
  225.                          Get_File );
  226.  
  227.    Kermit_File_Param   = ( Kermit_Ascii, Kermit_Binary, Kermit_None );
  228.  
  229.    Kermit_Packet_Param = ( Break_Pack,  Data_Pack, Error_Pack,
  230.                            Header_Pack, NAK_Pack,  Send_Pack, Reserved_Pack,
  231.                            ACK_Pack,    End_Pack,  Generic_Pack,
  232.                            Text_Pack,   Host_Pack, Attrib_Pack, Unknown );
  233.  
  234.    Kermit_File_Modes   = ( Read_Open, Write_Open );
  235.  
  236.    Kermit_Window_Type_Record = RECORD
  237.                                   Data_Slot   : INTEGER;
  238.                                   Data_Length : INTEGER;
  239.                                   ACK_Flag    : BOOLEAN;
  240.                                   Retry_Count : INTEGER;
  241.                                END;
  242.  
  243.                                    (* Window packet queue       *)
  244.  
  245.    Kermit_Window_Queue_Type = ARRAY[0..63] OF Kermit_Window_Type_Record;
  246.  
  247.    Kermit_Abort_Type         = (No_Abort, One_File, All_Files, Entire_Protocol);
  248.  
  249. (* VAR *) CONST
  250.    Kermit_Debug            : BOOLEAN  (* TRUE if Kermit debug mode *)
  251.                              = FALSE;
  252.                                    (* Type of file (Ascii, Binary) *)
  253.  
  254.    Kermit_File_Type_Var    : Kermit_File_Param = Kermit_None;
  255.  
  256.    Kermit_Init_Packet_Size : INTEGER  (* Initial max packet size *)
  257.                              = 90;
  258.  
  259.    Kermit_Packet_Size      : INTEGER  (* Size of current packet *)
  260.                              = 90;
  261.  
  262.    Kermit_Extended_Block   : INTEGER  (* Max size of long block *)
  263.                              = MaxLongPacketLength;
  264.  
  265.    Kermit_Timeout          : INTEGER  (* Timeout value in seconds *)
  266.                              = 5;
  267.    Kermit_Npad             : INTEGER  (* Number of padding characters *)
  268.                              = 0;
  269.    Kermit_EOL              : CHAR     (* End of line character *)
  270.                              = ^M;
  271.    Kermit_Header_Char      : CHAR     (* Block header character *)
  272.                              = ^A;
  273.  
  274.    Kermit_Pad_Char         : CHAR     (* Padding character *)
  275.                              = #0;
  276.    Kermit_Quote_Char       : CHAR     (* Control-quote character *)
  277.                              = '#';
  278.    Kermit_Quote_8_Char     : CHAR     (* 8-bit quoting character *)
  279.                              = '&';
  280.    Kermit_Chk_Type         : CHAR     (* Block-check type        *)
  281.                              = '3';
  282.    Kermit_Repeat_Char      : CHAR     (* Repeat character        *)
  283.                              = '~';
  284.    Kermit_Handshake_Char   : CHAR     (* Handshake character     *)
  285.                              = ' ';
  286.    Quoting                 : BOOLEAN    (* TRUE if 8th-bit quoting in effect *)
  287.                              = FALSE;
  288.    Repeating               : BOOLEAN    (* TRUE if repeating/compression in effect *)
  289.                              = FALSE;
  290.    My_Pad_Num              : INTEGER    (* Default number of padding characters *)
  291.                              = 0;
  292.    Kermit_Delay_Time       : INTEGER    (* Time to wait before send in host mode *)
  293.                              = 15;
  294.    Kermit_Window_Size      : INTEGER    (* No. of packets in window  *)
  295.                              = 16;
  296.    Kermit_Autodownload     : BOOLEAN    (* TRUE to allow Kermit autodownloads *)
  297.                              = FALSE;
  298.    Doing_Kermit_Autodown   : BOOLEAN    (* TRUE if doing Kermit autodownload *)
  299.                              = FALSE;
  300.  
  301. VAR
  302.  
  303.                                    (* Type of current Kermit packet *)
  304.  
  305.    Kermit_Packet_Type   : Kermit_Packet_Param;
  306.  
  307.                                    (* Current state of Kermit transfer *)
  308.  
  309.    Kermit_State         : Kermit_State_Vars;
  310.  
  311.                                    (* If remote kermit in server mode *)
  312.    Kermit_Remote_Server : BOOLEAN;
  313.  
  314.  
  315.    His_TimeOut          : INTEGER  (* Timeout desired by remote *);
  316.  
  317.  
  318.    Packet_OK          : BOOLEAN    (* TRUE if packet OK        *);
  319.    Ack_OK             : BOOLEAN    (* TRUE if packet ACK'd     *);
  320.    Open_OK            : BOOLEAN    (* TRUE if file to transfer opened OK *);
  321.    File_Done          : BOOLEAN    (* TRUE if file being sent done *);
  322.    Kermit_Abort       : BOOLEAN    (* TRUE if keyboard entry aborts transfer *);
  323.    Kermit_Retry       : BOOLEAN    (* TRUE to retry current packet *);
  324.    Kermit_Really_Done : BOOLEAN    (* TRUE if Kermit protocol done *);
  325.  
  326.                                    (* Type of keyboard-originated abort *)
  327.  
  328.    Kermit_Abort_Level : Kermit_Abort_Type;
  329.  
  330.    Packet_Num         : INTEGER    (* Packet number being sent *);
  331.    Rec_Packet_Num     : INTEGER    (* Received packet number *);
  332.    Packets_Sent       : LONGINT    (* Number of packets sent *);
  333.    Packets_Received   : LONGINT    (* Number of packets received *);
  334.    Packets_Bad        : LONGINT    (* Number of errors in transfer *);
  335.  
  336.    File_Open          : BOOLEAN    (* TRUE if file being transferred is open *);
  337.    Sending_File       : BOOLEAN    (* TRUE if uploading, FALSE if downloading *);
  338.    Logging_Out_Server : BOOLEAN    (* TRUE if logging out remote server       *);
  339.  
  340.    My_Pad_Char        : CHAR       (* Default pad character *);
  341.    His_Quote_Char     : CHAR       (* Remote kermit's quote character *);
  342.    His_Quote_8_Char   : CHAR       (* Remote kermit's 8th-bit quote character *);
  343.    His_Chk_Type       : CHAR       (* Remote kermit's block check type *);
  344.    His_Repeat_Char    : CHAR       (* Remote kermit's repeat quote char *);
  345.  
  346.    Send_EOL           : INTEGER    (* Send CR first time *);
  347.  
  348.    File_Records       : LONGINT    (* Number of bytes in disk file *);
  349.    Buffer_Num         : LONGINT    (* How many characters read/written *);
  350.    Receive_Done       : BOOLEAN    (* TRUE if file reception complete *);
  351.    Kermit_MaxTry      : INTEGER    (* Maximum number of retries allowed *);
  352.    Rec_Packet_Length  : INTEGER    (* Received packet data length *);
  353.                                    (* Points to received data     *)
  354.    Rec_Packet_Ptr     : Kermit_Packet_Ptr;
  355.    Send_Packet_Length : INTEGER    (* Send packet data length *);
  356.                                    (* Points to data to send  *)
  357.    Send_Packet_Ptr    : Kermit_Packet_Ptr;
  358.  
  359.    Kermit_Menu_Title  : AnyStr     (* Title for Kermit windows *);
  360.  
  361.    Finish_Kermit_Server : BOOLEAN  (* TRUE to stop remote server *);
  362.  
  363.    Kermit_Transfer_Start: LONGINT  (* Starting time of transfer *);
  364.    Kermit_Transfer_End  : LONGINT  (* Ending time of transfer   *);
  365.    Kermit_Transfer_Rate : REAL     (* Transfer rate in CPS      *);
  366.  
  367.    Kermit_Window_Top    : BYTE     (* Top packet in window      *);
  368.    Kermit_Window_Bottom : BYTE     (* Bottom packet in window   *);
  369.  
  370.                                    (* Window packet queue       *)
  371.  
  372.    Kermit_Queue         : Kermit_Window_Queue_Type;
  373.  
  374. (*----------------------------------------------------------------------*)
  375. (*                    Global script file variables                      *)
  376. (*----------------------------------------------------------------------*)
  377.  
  378. CONST
  379.    Max_Script_File_Commands = 97       (* # of script commands              *);
  380.    MaxScripts               = 100      (* Maximum # of compiled scripts     *);
  381.    MaxScriptCalls           = 64       (* Maximum call depth within script  *);
  382.    MaxScriptVariables       = 100      (* Maximum variables each script     *);
  383.    MaxNestedScripts         = 10       (* Maximum nesting depth for scripts *);
  384.    MaxOperandTypes          = 13       (* Maximum # of script data types    *);
  385.    MaxWhenStrings           = 10       (* Maximum # of WHEN strings         *);
  386.    MaxWaitStrings           = 20       (* Maximum # of WAIT strings         *);
  387.    MaxScriptOpenFiles       = 10       (* Maximum # of open script files    *);
  388.    MaxNewCommands           = 100      (* Maximum # of new commands         *);
  389.    MaxScriptArgs            = 20       (* Maximum # of script arguments     *);
  390.  
  391. TYPE
  392.    OperandType =    ( Bad_Operand_Type, Operator_Type, Integer_Variable_Type,
  393.                       Real_Variable_Type, String_Variable_Type,
  394.                       Char_Variable_Type,
  395.                       Integer_Constant_Type, Real_Constant_Type,
  396.                       String_Constant_Type,
  397.                       Char_Constant_Type,
  398.                       StackEnd_Type, Left_Paren_Type, Right_Paren_Type,
  399.                       Comma_Type );
  400.  
  401. (* VAR *) CONST
  402.                                    (* Script conversion table       *)
  403.  
  404.    PibTerm_Command_Table_2 : ARRAY[0..No_Of_PibTerm_Commands_Minus_One]
  405.                              OF PibTerm_Command_Type =
  406.       ( AddCommandSy,   AddLFSy,       AlarmSy,       AreaCodeSy,
  407.         BreakSy,        CallSy,        CaptureSy,     CaseSy,
  408.         ChDirSy,        ClearSy,       CloseSy,       ClrEolSy,
  409.         CommDrainSy,
  410.         CommFlushSy,    CopyFileSy,    DeclareSy,     DelaySy,
  411.         DelLineSy,      DialSy,        DirFirstSy,    DirNextSy,
  412.         DoCaseSy,       DosSy,         EchoSy,        EditSy,
  413.         EditFileSy,     ElseSy,        ElseIfSy,      EndCaseSy,
  414.         EndDoCaseSy,    EndForSy,      EndIfSy,       EndProcSy,
  415.         EndWhileSy,     EraseFileSy,   ExecuteSy,     ExeNewSy,
  416.         ExitSy,         ExitAllSy,     FastCSy,       FileSy,
  417.         ForSy,          FreeSpaceSy,   GetDirSy,      GetParamSy,
  418.         GetVarSy,       GossipSy,      GoToSy,        GoToXYSy,
  419.         HangUpSy,       HostSy,        IfConSy,       IfDialSy,
  420.         IfEofSy,        IfExistsSy,    IfFoundSy,     IfLocStrSy,
  421.         IfOkSy,         IfOpSy,        IfRemStrSy,    ImportSy,
  422.         InfoSy,         InputSy,       InsLineSy,     KeyDefSy,
  423.         KeyFlushSy,     KeySendSy,     KeySy,         LabelSy,
  424.         LogSy,          MenuSy,        MessageSy,     MuteSy,
  425.         OpenSy,         ParamSy,       PImportSy,     PrintFileSy,
  426.         ProcedureSy,    QuitSy,        QuitAllSy,     ReadSy,
  427.         ReadLnSy,       ReceiveSy,     ReDialSy,      RepeatSy,
  428.         ResetSy,        ReturnSy,      RInputSy,      ScriptSy,
  429.         SDumpSy,        SendSy,        SetSy,         SetParamSy,
  430.         SetVarSy,       STextSy,       SuspendSy,     TextSy,
  431.         TimersSy,       TranslateSy,   UntilSy,       ViewSy,
  432.         ViewFileSy,     WaitSy,        WaitCountSy,   WaitListSy,
  433.         WaitQuietSy,    WaitStrSy,     WaitTimeSy,    WhenSy,
  434.         WhenDropSy,     WhenListSy,    WhereXYSy,     WhileSy,
  435.         WriteSy,        WriteLnSy,     WriteLogSy,    ZapVarSy,
  436.         Bad_Command,    Null_Command
  437.       );
  438.  
  439. TYPE
  440.                                    (* Generic buffer type to hold script *)
  441.                                    
  442.    Script_Buffer_Type = ARRAY[1..1] OF BYTE;
  443.    
  444.                                    (* For pointing to start of script    *)
  445.                                    
  446.    Script_Buffer_Ptr  = ^Script_Buffer_Type;
  447.    
  448.                                    (* Script variable definition *)
  449.  
  450.    Script_Variable_Record   = RECORD
  451.                                  Var_Name   : String10;
  452.                                  Var_Type   : OperandType;
  453.                                  Var_Passed : BOOLEAN;
  454.                                  Var_Temp   : BOOLEAN;
  455.                                  Var_Value  : StringPtr;
  456.                               END;
  457.  
  458.    Script_Variable_Record_Ptr = ^Script_Variable_Record;
  459.  
  460.                                    (* Saves variables across CALLs *)
  461.  
  462.    Script_Save_Variable_Record_Ptr = ^Script_Save_Variable_Record;
  463.    
  464.    Script_Save_Variable_Record = RECORD
  465.                                     Save_Data : Script_Variable_Record_Ptr;
  466.                                     Prev_Var  : Script_Save_Variable_Record_Ptr;
  467.                                  END;
  468.                                  
  469.                                    (* Script variable list *)
  470.                                    
  471.    Script_Variable_List     = ARRAY[0..MaxScriptVariables] OF Script_Variable_Record;
  472.    Script_Variable_List_Ptr = ^Script_Variable_List;
  473.  
  474.                                    (* Holds variable indices of parameters *)
  475.  
  476.    Script_Parameter_Vector = ARRAY[1..MaxScriptArgs] OF INTEGER;
  477.    Script_Parameter_Ptr    = ^Script_Parameter_Vector;
  478.  
  479.                                    (* Defines a script record *)
  480.    Script_Record_Type = RECORD
  481.                            Script_Name         : STRING[8];
  482.                            Script_Ptr          : Script_Buffer_Ptr;
  483.                            Script_Len          : INTEGER;
  484.                            Script_Vars_Count   : INTEGER;
  485.                            Script_Vars         : Script_Variable_List_Ptr;
  486.                            Script_Params_Count : INTEGER;
  487.                            Script_Params       : Script_Parameter_Ptr;
  488.                         END;
  489.  
  490.                                    (* Saves stack of EXECUTEd scripts *)
  491.    Script_Buffer_Save = RECORD
  492.                            Script_Num  : INTEGER;
  493.                            Buffer_Pos  : INTEGER;
  494.                            Buffer_Ptr  : Script_Buffer_Ptr;
  495.                            Vars_Ptr    : Script_Variable_List_Ptr;
  496.                            Vars_Count  : INTEGER;
  497.                            Prev_Ptr    : Script_Variable_List_Ptr;
  498.                            Params_Ptr  : Script_Parameter_Ptr;
  499.                            Params_Count: INTEGER;
  500.                            Params_Got  : INTEGER;
  501.                         END;
  502.                                    (* Saves stack of CALLed scripts *)
  503.  
  504.    Script_Call_Stack_Type = RECORD
  505.                                Proc_Param  : Script_Parameter_Ptr;
  506.                                Proc_Got    : INTEGER;
  507.                                Proc_Count  : INTEGER;
  508.                                Return_Addr : INTEGER;
  509.                                Save_Vars   : Script_Save_Variable_Record_Ptr;
  510.                             END;
  511.  
  512.                                    (* Search order for scripts *)
  513.  
  514.    Script_Search_Order_Type = ( Dir_Then_Lib, Lib_Then_Dir, Dir_Only, Lib_Only );
  515.  
  516.  
  517.                                    (* Stack entry for script execution *)
  518.    Stack_Entry = RECORD
  519.                     TypVal : OperandType;
  520.                     IntVal : LONGINT;
  521.                     StrVal : AnyStr;
  522.                  END;
  523.  
  524.    Stack_Entry_Ptr = ^Stack_Entry;
  525.  
  526.    Script_When_Record = RECORD
  527.                            When_Found: BOOLEAN;
  528.                            When_Text : StringPtr;
  529.                            Reply_Text: StringPtr;
  530.                         END;
  531.  
  532.    Script_Wait_Record = RECORD
  533.                            Wait_Text : StringPtr;
  534.                            Wait_Reply: StringPtr;
  535.                         END;
  536.  
  537.    Script_File_Record = RECORD
  538.                            ReadOnly : BOOLEAN;
  539.                            Opened   : BOOLEAN;
  540.                            EOF_Seen : BOOLEAN;
  541.                            F        : Text_File;
  542.                         END;
  543.  
  544.    Script_File_Record_Ptr  = ^Script_File_Record;
  545.  
  546.  
  547. (* VAR *) CONST
  548.                                    (* Index of currently executing script *)
  549.    Current_Script_Num     : INTEGER = 0;
  550.  
  551.                                    (* WHEN text to wait for *)
  552.    Script_When_Text       : AnyStr = '';
  553.  
  554.                                    (* Response text for WHEN *)
  555.    Script_When_Reply_Text : AnyStr = '';
  556.  
  557.                                    (* Response text for WHENDROP *)
  558.    Script_When_Drop_Text  : AnyStr = '';
  559.  
  560.                                    (* Current input for WHEN checking *)
  561.    Script_When_Save       : AnyStr = '';
  562.  
  563.                                    (* Current input for WAITSTRING checking *)
  564.    Script_Wait_Save       : AnyStr = '';
  565.  
  566.                                    (* # of characters to wait for *)
  567.    Script_Wait_Char_Count : INTEGER = 0;
  568.  
  569.                                    (* # of 1/100 secs to wait quiet *)
  570.    Script_WaitQuiet_Time  : LONGINT = 0;
  571.  
  572.                                    (* Time to wait for input string     *)
  573.    Script_Wait_Time       : LONGINT = 0;
  574.  
  575.                                    (* Default time to wait for input string *)
  576.  
  577.    Script_Default_Wait_Time : LONGINT = 30;
  578.  
  579.                                    (* Starting time of day for wait         *)
  580.    Script_Wait_Start      : LONGINT = 0;
  581.  
  582.                                    (* Where to go to if wait string fails   *)
  583.    Script_Wait_Failure    : LONGINT = 0;
  584.  
  585.                                    (* Wait string appeared                  *)
  586.    Script_Wait_Found      : BOOLEAN = FALSE;
  587.  
  588.                                    (* Size of script buffer                 *)
  589.  
  590.    Script_Buffer_Size     : INTEGER = 0;
  591.  
  592.                                    (* Pointer to compiled script text       *)
  593.  
  594.    Script_Buffer          : Script_Buffer_Ptr = NIL;
  595.  
  596.                                    (* Current position in script buffer     *)
  597.  
  598.    Script_Buffer_Pos      : INTEGER = 0;
  599.  
  600.                                    (* Script integer values             *)
  601.  
  602.    Script_Integer_1       : LONGINT = 0;
  603.    Script_Integer_2       : LONGINT = 0;
  604.    Script_Integer_3       : LONGINT = 0;
  605.    Script_Integer_4       : LONGINT = 0;
  606.    Script_Integer_5       : LONGINT = 0;
  607.  
  608.                                    (* Script text values                *)
  609.  
  610.    Script_String          : AnyStr = '';
  611.    Script_String_2        : AnyStr = '';
  612.    Script_String_3        : AnyStr = '';
  613.    Script_String_4        : AnyStr = '';
  614.  
  615.                                    (* Reply to Script INPUT prompt      *)
  616.    Script_Reply           : AnyStr = '';
  617.  
  618.                                    (* Reply was OK                      *)
  619.    Script_Reply_Found     : BOOLEAN = FALSE;
  620.  
  621.                                    (* Script suspend time period        *)
  622.    Script_Suspend_Time    : LONGINT = 0;
  623.  
  624.                                    (* Script suspend starting time      *)
  625.    Script_Suspend_Start   : LONGINT = 0;
  626.  
  627.                                    (* Reply to Script RINPUT prompt     *)
  628.    Script_Remote_Reply    : AnyStr = '';
  629.  
  630.                                    (* Reply was OK                      *)
  631.    Script_Remote_Reply_OK : BOOLEAN = FALSE;
  632.  
  633.                                    (* Marker for parameter substitution *)
  634.    Script_Parameter_Marker: CHAR = '%';
  635.  
  636.                                    (* Scripts compiled and loaded       *)
  637. VAR
  638.    Scripts                : ARRAY[1..MaxScripts] OF Script_Record_Type;
  639.  
  640.                                    (* Number of compiled scripts        *)
  641. (* VAR *) CONST
  642.    Script_Count           : 0..MaxScripts = 0;
  643.  
  644.                                    (* Script variables                  *)
  645.  
  646.    Script_Variables       : Script_Variable_List_Ptr = NIL;
  647.  
  648.                                    (* Number of script variables active *)
  649.  
  650.    Script_Variable_Count  : 0..MaxScriptVariables = 2;
  651.  
  652.                                    (* Script parameter variables        *)
  653.  
  654.    Script_Parameters      : Script_Parameter_Ptr = NIL;
  655.  
  656.                                    (* Number of script parameters active *)
  657.  
  658.    Script_Parameter_Count : 0..MaxScriptVariables = 0;
  659.    Script_Parameter_Got   : 0..MaxScriptVariables = 0;
  660.  
  661.                                    (* Previous script's variables *)
  662.  
  663.    Prev_Script_Variables  : Script_Variable_List_Ptr = NIL;
  664.  
  665.                                    (* Save positions in nested scripts  *)
  666. VAR
  667.    Script_Stack_Position  : ARRAY[0..MaxNestedScripts] OF Script_Buffer_Save;
  668.  
  669. (* VAR *) CONST
  670.    Script_Stack_Depth     : 0..MaxNestedScripts = 0;
  671.  
  672.                                    (* Save positions in script procedures *)
  673. VAR
  674.    Script_Call_Stack     : ARRAY[0..MaxScriptCalls] OF Script_Call_Stack_Type;
  675.  
  676. (* VAR *) CONST
  677.    Script_Call_Depth     : 0..MaxScriptCalls = 0;
  678.  
  679.                                    (* Procedure parameter variables *)
  680. (* VAR *) CONST
  681.    Proc_Parameters       : Script_Parameter_Ptr = NIL;
  682.  
  683.                                    (* Number of script parameters active *)
  684.  
  685.    Proc_Parameter_Count  : 0..MaxScriptVariables = 0;
  686.    Proc_Parameter_Got    : 0..MaxScriptVariables = 0;
  687.  
  688.                                    (* Learn variables *)
  689. (* VAR *) CONST
  690.    Script_Learn_Buffer_Size : INTEGER (* Learning buffer size *)
  691.                               = 15;
  692.    Script_Learn_Lines       : INTEGER (* Max. # of successive WaitStrings *)
  693.                               = 1;
  694.    Script_Learn_Line_Count  : INTEGER (* Count of WaitStrings generated   *)
  695.                               = 0;
  696.    Script_Wait_Generated    : BOOLEAN (* TRUE if WaitString generated     *)
  697.                               = FALSE;
  698.  
  699. (* VAR *) CONST
  700.                                    (* Search order type *)
  701.  
  702.    Script_Search_Order      : Script_Search_Order_Type
  703.                               = Dir_Then_Lib;
  704.  
  705.    Script_Order_String      : ShortStr
  706.                               = 'Directory then library';
  707.  
  708.                                    (* Vector of WHEN strings *)
  709. VAR
  710.    Script_When_List         : ARRAY[1..MaxWhenStrings] OF Script_When_Record;
  711.  
  712. (* VAR *) CONST
  713.    Script_When_Count        : 0..MaxWhenStrings = 0;
  714.  
  715.                                    (* Vector of WAIT strings *)
  716. VAR
  717.    Script_Wait_List         : ARRAY[1..MaxWaitStrings] OF Script_Wait_Record;
  718.  
  719.                                    (* # of active waitstrings *)
  720. (* VAR *) CONST
  721.    Script_Wait_Count        : 0..MaxWaitStrings = 0;
  722.  
  723.                                    (* Variable to receive wait index *)
  724.  
  725.    Script_Wait_Result_Index : LONGINT = 0;
  726.  
  727.                                    (* # chars to save for wait check *)
  728.  
  729.    Script_Wait_Check_Length : INTEGER = 0;
  730.  
  731.                                    (* Vector of files for use in scripts *)
  732. VAR
  733.    Script_File_List         : ARRAY[0..MaxScriptOpenFiles] OF Script_File_Record_Ptr;
  734.  
  735.                                    (* If given file used in script *)
  736.  
  737.    Script_File_Used         : ARRAY[0..MaxScriptOpenFiles] OF BOOLEAN;
  738.  
  739.                                    (* # of files opened in script *)
  740.  
  741. (* VAR *) CONST
  742.    Script_File_Count        : 0..MaxScriptOpenFiles = 0;
  743.  
  744.    Script_IO_Error          : INTEGER    (* I/O error in script *)
  745.                               = 0;
  746.  
  747.                                    (* User-defined commands *)
  748. VAR
  749.    Script_New_Commands      : ARRAY[1..MaxNewCommands] OF STRING[8];
  750.  
  751. (* VAR *) CONST
  752.    Script_New_Command_Count : 0 .. MaxNewCommands = 0;
  753.  
  754. (* VAR *) CONST
  755.                                    (* TRUE if executing command key script *)
  756.  
  757.    Script_Command_Key_Mode  : BOOLEAN = FALSE;
  758.  
  759. VAR
  760.    Script_Search_Rec        : SearchRec (* Search record for DirFirst, DirNext *);
  761.  
  762. (*----------------------------------------------------------------------*)
  763. (*                    Command line mode variables                       *)
  764. (*----------------------------------------------------------------------*)
  765.  
  766. (* VAR *) CONST
  767.    Command_Key      : INTEGER      (* Function which invokes command  *)
  768.                       = 0;
  769.    Command_Key_Name : STRING[20]   (* Command key name                *)
  770.                       = '';
  771.    Command_Key_Text : AnyStr       (* Text of command line            *)
  772.                       = '';
  773.    Use_Prev_Key_Text: BOOLEAN      (* TRUE to use prev. text to start *)
  774.                       = FALSE;
  775.  
  776. (*----------------------------------------------------------------------*)
  777. (*                 Global error return from DOS                         *)
  778. (*----------------------------------------------------------------------*)
  779.  
  780. VAR
  781.    Ierr : INTEGER                  (* DOS return error *);
  782.    
  783. (*----------------------------------------------------------------------*)
  784. (*                 Global screen positioning for autodownloads          *)
  785. (*----------------------------------------------------------------------*)
  786.  
  787. VAR
  788.    NewX  : INTEGER;
  789.    OldX  : INTEGER;
  790.    NewY  : INTEGER;
  791.    OldY  : INTEGER;
  792.    
  793. (*----------------------------------------------------------------------*)
  794. (*                    Gossip mode definitions screen                    *)
  795. (*----------------------------------------------------------------------*)
  796.  
  797. (* VAR *) CONST
  798.    Gossip_Window_Size : INTEGER    (* Number of lines in top window *)
  799.                         = 18;
  800.    Gossip_Line_Mode   : BOOLEAN    (* TRUE if line-edit GOSSIP mode *)
  801.                         = FALSE;
  802.  
  803. (*----------------------------------------------------------------------*)
  804. (*                           Session timers                             *)
  805. (*----------------------------------------------------------------------*)
  806.  
  807. VAR
  808.    Session_Start_Time: LONGINT     (* Starting time of entire session *);
  809.    Dialing_Start_Time: LONGINT     (* Starting time current dialing   *);
  810.  
  811. (*----------------------------------------------------------------------*)
  812. (*                   Global graphics positions                          *)
  813. (*----------------------------------------------------------------------*)
  814.  
  815. VAR
  816.    Graphics_XPos: INTEGER;
  817.    Graphics_YPos: INTEGER;
  818.  
  819. (*----------------------------------------------------------------------*)
  820. (*                                                                      *)
  821. (*                  COMMUNICATIONS HARDWARE ADDRESSES                   *)
  822. (*                                                                      *)
  823. (*        These are specific to IBM PCs and close compatibles.          *)
  824. (*                                                                      *)
  825. (*----------------------------------------------------------------------*)
  826.  
  827. CONST
  828.  
  829.    UART_THR = $00;       (* offset from base of UART Registers for IBM PC *)
  830.    UART_RBR = $00;
  831.    UART_IER = $01;
  832.    UART_IIR = $02;
  833.    UART_LCR = $03;
  834.    UART_MCR = $04;
  835.    UART_LSR = $05;
  836.    UART_MSR = $06;
  837.  
  838.    I8088_IMR = $21;      (* port address of the Interrupt Mask Register *)
  839.  
  840.    COM1_Base = $03F8;    (* port addresses for the UART *)
  841.    COM2_Base = $02F8;
  842.    COM3_Base = $03E8;
  843.    COM4_Base = $02E8;
  844.  
  845.    COM1_Irq = 4;         (* Interrupt line for the UART *)
  846.    COM2_Irq = 3;
  847.    COM3_Irq = 4;
  848.    COM4_Irq = 3;
  849.  
  850.    COM1_Int = $0C;       (* Interrupt number for the UART *)
  851.    COM2_Int = $0B;
  852.    COM3_Int = $0C;
  853.    COM4_Int = $0B;
  854.  
  855.    RS232_Base = $0400    (* Address of RS 232 com port pointer *);
  856.  
  857.    MaxComPorts = 4       (* Four ports allowed by this code    *);
  858.  
  859. (* STRUCTURED *) CONST
  860.                                    (* Port addresses of each com port *)
  861.  
  862.    Default_Com_Base : ARRAY[1..MaxComPorts] OF WORD =
  863.                       ( COM1_Base, COM2_Base, COM3_Base, COM4_Base );
  864.  
  865.                                    (* IRQ line for each port *)
  866.  
  867.    Default_Com_Irq  : ARRAY[1..MaxComPorts] OF INTEGER =
  868.                       ( COM1_Irq, COM2_Irq, COM3_Irq, COM4_Irq );
  869.  
  870.                                    (* Interrupt for each port *)
  871.  
  872.    Default_Com_Int  : ARRAY[1..MaxComPorts] OF INTEGER =
  873.                       ( COM1_Int, COM2_Int, COM3_Int, COM4_Int );
  874.  
  875. (*----------------------------------------------------------------------*)
  876. (*                                                                      *)
  877. (*                   COMMUNICATIONS BUFFER VARIABLES                    *)
  878. (*                                                                      *)
  879. (*     The communications buffers are implemented as circular (ring)    *)
  880. (*     buffers, or double-ended queues.  The asynchronous I/O routines  *)
  881. (*     enter characters in the receive buffer as they arrive at the     *)
  882. (*     serial port.  Higher-level routines may extract characters from  *)
  883. (*     the receive buffer at leisure.  Higher-level routines insert     *)
  884. (*     characters into the send buffer.  The asynchronous I/O routines  *)
  885. (*     then send characters out the serial port when possible.          *)
  886. (*                                                                      *)
  887. (*----------------------------------------------------------------------*)
  888.  
  889. CONST
  890.  
  891.    TimeOut             = 256        (* TimeOut value                   *);
  892.    Async_XON           = ^Q         (* XON character                   *);
  893.    Async_XOFF          = ^S         (* XOFF character                  *);
  894.  
  895.    Async_Overrun_Error = 2          (*   overrun                       *);
  896.    Async_Parity_Error  = 4          (*   parity error                  *);
  897.    Async_Framing_Error = 8          (*   framing error                 *);
  898.    Async_Break_Found   = 16         (*   break interrupt               *);
  899.  
  900.    Async_CTS           = $10        (*   Clear to send                 *);
  901.    Async_RTS           = $20        (*   Request to send               *);
  902.  
  903.    Async_DSR           = $20        (*   Data set ready                *);
  904.    Async_DTR           = $10        (*   Data terminal ready           *);
  905.  
  906.    Async_RTSDTR        = $30        (*   RTS + DTR                     *);
  907.    
  908. TYPE
  909.                                     (* I/O buffer type for serial port *)
  910.  
  911.    Async_Buffer_Type   = ARRAY[0..1] OF CHAR;
  912.    Async_Ptr           = ^Async_Buffer_Type;
  913.  
  914.  
  915. VAR                                 (* Port addresses for serial ports *)
  916.  
  917.    Com_Base               : ARRAY[1..MaxComPorts] OF WORD;
  918.  
  919.                                     (* IRQ line for each serial port   *)
  920.  
  921.    Com_Irq                : ARRAY[1..MaxComPorts] OF INTEGER;
  922.  
  923.                                     (* Interrupt for each serial port   *)
  924.  
  925.    Com_Int                : ARRAY[1..MaxComPorts] OF INTEGER;
  926.  
  927. VAR
  928.    Async_Buffer_Ptr       : Async_Ptr  (* Input buffer address  *);
  929.    Async_OBuffer_Ptr      : Async_Ptr  (* Output buffer address *);
  930.  
  931.    Async_Open_Flag        : BOOLEAN    (* true if port opened               *);
  932.    Async_Port             : INTEGER    (* current open port number (1 -- 4) *);
  933.    Async_Base             : INTEGER    (* base for current open port        *);
  934.    Async_Irq              : INTEGER    (* IRQ for current open port         *);
  935.    Async_Int              : INTEGER    (* Interrupt # for current port      *);
  936.    Async_RS232            : INTEGER    (* RS232 address for current port    *);
  937.  
  938.    Async_Buffer_Overflow  : BOOLEAN    (* True if buffer overflow has happened *);
  939.    Async_Buffer_Used      : INTEGER    (* Amount of input buffer used so far   *);
  940.    Async_MaxBufferUsed    : INTEGER    (* Maximum amount of input buffer used  *);
  941.  
  942.                                        (* Async_Buffer empty if Head = Tail    *)
  943.    Async_Buffer_Head      : INTEGER    (* Loc in Async_Buffer to put next char *);
  944.    Async_Buffer_Tail      : INTEGER    (* Loc in Async_Buffer to get next char *);
  945.    Async_Buffer_NewTail   : INTEGER    (* For updating tail value              *);
  946.  
  947.    Async_OBuffer_Overflow : BOOLEAN    (* True if buffer overflow has happened *);
  948.    Async_OBuffer_Used     : INTEGER    (* Amount of output buffer used         *);
  949.    Async_MaxOBufferUsed   : INTEGER    (* Max amount of output buffer used     *);
  950.  
  951.                                        (* Async_Buffer empty if Head = Tail    *)
  952.    Async_OBuffer_Head     : INTEGER    (* Loc in Async_Buffer to put next char *);
  953.    Async_OBuffer_Tail     : INTEGER    (* Loc in Async_Buffer to get next char *);
  954.    Async_OBuffer_NewTail  : INTEGER    (* For updating tail value              *);
  955.  
  956.    Async_Buffer_Low       : INTEGER    (* Low point in receive buffer for XON  *);
  957.    Async_Buffer_High      : INTEGER    (* High point in receive buffer for XOFF*);
  958.    Async_Buffer_High_2    : INTEGER    (* Emergency point for XOFF             *);
  959.  
  960.    Async_XOFF_Sent        : BOOLEAN    (* If XOFF sent                      *);
  961.    Async_Sender_On        : BOOLEAN    (* If sender is enabled              *);
  962.    Async_Send_XOFF        : BOOLEAN    (* TRUE to send XOFF ASAP            *);
  963.    Async_XOFF_Received    : BOOLEAN    (* If XOFF received                  *);
  964.    Async_XOFF_Rec_Display : BOOLEAN    (* If XOFF received and displayed    *);
  965.    Async_XON_Rec_Display  : BOOLEAN    (* If XON received                   *);
  966.    Async_Baud_Rate        : WORD       (* Current baud rate                 *);
  967.  
  968.                                     (* Save previous serial interrupt status *)
  969.    Async_Save_IAddr       : POINTER;
  970.    Async_Do_CTS           : BOOLEAN (* TRUE to do clear-to-send checking    *);
  971.    Async_Do_DSR           : BOOLEAN (* TRUE to do data-set-ready checking   *);
  972.    Async_Do_XonXoff       : BOOLEAN (* TRUE to do XON/XOFF flow checking    *);
  973.    Async_OV_XonXoff       : BOOLEAN (* TRUE to do XON/XOFF if buffer overfl *);
  974.    Async_Hard_Wired_On    : BOOLEAN (* TRUE if hard-wired connection        *);
  975.    Async_Break_Length     : INTEGER (* Length of break in 1/10 seconds      *);
  976.    Async_Line_Status      : BYTE    (* Line Status Reg at interrupt         *);
  977.    Async_Modem_Status     : BYTE    (* Modem Status Reg at interrupt        *);
  978.    Async_Line_Error_Flags : BYTE    (* Line status bits accumulated         *);
  979.    Async_Buffer_Size      : INTEGER (* Stores input buffer size             *);
  980.    Async_OBuffer_Size     : INTEGER (* Stores output buffer size            *);
  981.    Async_Uart_IER         : INTEGER (* Interrupt enable register address    *);
  982.    Async_Uart_MCR         : INTEGER (* Interrupt enable register address    *);
  983.    Async_Uart_IIR         : INTEGER (* Interrupt ID register address        *);
  984.    Async_Uart_MSR         : INTEGER (* Modem status register address        *);
  985.    Async_Uart_LSR         : INTEGER (* Line status register address         *);
  986.    Async_Output_Delay     : INTEGER (* Delay in ms when output buffer full  *);
  987.    Async_OneMSDelay       : INTEGER (* Loop count value to effect 1 ms delay*);
  988.    Async_Buffer_Length    : INTEGER (* Receive buffer length                *);
  989.    Async_OBuffer_Length   : INTEGER (* Send buffer length                   *);
  990.                                     (* Pointer to Async_Send routine        *)
  991.    Async_Send_Addr        : Async_Ptr;
  992.  
  993. (*----------------------------------------------------------------------*)
  994. (*          Definitions for screen memory reading/writing               *)
  995. (*----------------------------------------------------------------------*)
  996.  
  997. CONST
  998.    EGA_Screen_Address      = $A000    (* Address of EGA color screen      *);
  999.    Color_Screen_Address    = $B800    (* Address of color screen          *);
  1000.    Mono_Screen_Address     = $B000    (* Address of mono screen           *);
  1001.    Screen_Length           = 4000     (* 80 x 25 x 2 = screen area length *);
  1002.    Graphics_Screen_Length  = 16000    (* Length of graphics screen area   *);
  1003.    EGA_Graphics_Scr_Length = 28000    (* Length of EGA graphics screen    *);
  1004.    Max_Saved_Screen        = 6        (* Maximum no. of saved screens     *);
  1005.    MedRes_GraphMode        = 4        (* Medium resolution graphics       *);
  1006.    HiRes_GraphMode         = 6        (* High resolution graphics mode    *);
  1007.    Mono_TextMode           = 7        (* Monochrome adapter text mode     *);
  1008.    EGA_GraphMode           = 16       (* EGA adapter graphics mode        *);
  1009.    CRT_Index               = $03D4    (* CRT index register               *);
  1010.    CRT_Data                = $03D5    (* CRT data register                *);
  1011.    CRT_Mode                = $03D8    (* CRT mode register                *);
  1012.    CRT_Color_Select        = $03D9    (* CRT color select register        *);
  1013.    CRT_Status              = $03DA    (* CRT status port                  *);
  1014.    CRT_Mode_Byte           = $0465    (* CRT mode byte                    *);
  1015.  
  1016. TYPE
  1017.                                      (* A screen image            *)
  1018.  
  1019.    Screen_Type       = ARRAY[ 1 .. EGA_Graphics_Scr_Length ] OF BYTE;
  1020.  
  1021.    Screen_Ptr        = ^Screen_Image_Type;
  1022.  
  1023.    Screen_Image_Type = RECORD
  1024.                           Screen_Image: Screen_Type;
  1025.                        END;
  1026.  
  1027.                                               (* Screen stack entries      *)
  1028.    Saved_Screen_Ptr  = ^Saved_Screen_Type;
  1029.  
  1030.    Saved_Screen_Type = RECORD
  1031.                           Screen_Row    : INTEGER;
  1032.                           Screen_Column : INTEGER;
  1033.                           Screen_X1     : INTEGER;
  1034.                           Screen_Y1     : INTEGER;
  1035.                           Screen_X2     : INTEGER;
  1036.                           Screen_Y2     : INTEGER;
  1037.                           Window_X1     : INTEGER;
  1038.                           Window_Y1     : INTEGER;
  1039.                           Window_X2     : INTEGER;
  1040.                           Window_Y2     : INTEGER;
  1041.                           Screen_Size   : WORD;
  1042.                           Video_Mode    : INTEGER;
  1043.                           If_BIOS       : BOOLEAN;
  1044.                           Screen_Image  : Screen_Type;
  1045.                        END;
  1046.  
  1047. CONST
  1048.    Video_Interrupt  = $10          (* Video interrupt number     *);
  1049.  
  1050. CONST                              (* Save previous video interrupt status. *)
  1051.  
  1052.    Video_Save_Iaddr  : Pointer = Nil;
  1053.  
  1054.    Video_Request     : INTEGER = 0     (* Current video request *);
  1055.    Video_Fill        : INTEGER = 0     (* Fill attribute        *);
  1056.    Video_Page        : BYTE    = 0     (* Text memory page      *);
  1057.    Video_Mode        : BYTE    = 3     (* Current text mode     *);
  1058.    Video_Screen_Addr : WORD    = $B800 (* Screen memory address *);
  1059.  
  1060. (* VAR *) CONST
  1061.    Max_Screen_Col       : INTEGER             (* PC's screen width         *)
  1062.                           = 80;
  1063.  
  1064.    Wrap_Screen_Col      : INTEGER             (* Column at which to wrap   *)
  1065.                           = 80;
  1066.  
  1067.    Max_Screen_Line      : INTEGER             (* PC's screen length        *)
  1068.                           = 25;
  1069.  
  1070.    New_Max_Screen_Col   : INTEGER             (* Width for param settings  *)
  1071.                           = 80;
  1072.  
  1073.    New_Max_Screen_Line  : INTEGER             (* Length for param settings *)
  1074.                           = 25;
  1075.  
  1076.    Font8x8Loaded        : BOOLEAN             (* TRUE if 8x8 font loaded   *)
  1077.                           = FALSE;
  1078.  
  1079.    Really_Save_EGA      : BOOLEAN             (* TRUE to save EGA memory   *)
  1080.                           = TRUE;
  1081.  
  1082. (* VAR *) CONST
  1083.                                               (* Memory-mapped screen area *)
  1084.    Actual_Screen        : Screen_Ptr = NIL;
  1085.                                               (* Saves screen behind menus *)
  1086.  
  1087.    Saved_Screen         : Saved_Screen_Ptr = NIL;
  1088.  
  1089.                                               (* Stack of saved screens    *)
  1090.  
  1091.    Saved_Screen_List    : ARRAY[ 1 .. Max_Saved_Screen ] OF Saved_Screen_Ptr
  1092.                           = ( NIL, NIL, NIL, NIL, NIL, NIL );
  1093.  
  1094.                                               (* Depth of saved screen stack *)
  1095.    Current_Saved_Screen : 0 .. Max_Saved_Screen = 0;
  1096.  
  1097.                                    (* Upper left corner of      *)
  1098.                                    (* current TURBO window      *)
  1099. (* VAR *) CONST
  1100.    Upper_Left_Column  : INTEGER = 1;
  1101.    Upper_Left_Row     : INTEGER = 1;
  1102.  
  1103.                                    (* Lower right corner of     *)
  1104.                                    (* current TURBO window      *)
  1105. (* VAR *) CONST
  1106.    Lower_Right_Column  : INTEGER = 80;
  1107.    Lower_Right_Row     : INTEGER = 25;
  1108.  
  1109. (* VAR *) CONST
  1110.    Global_ForeGround_Color : INTEGER = White;
  1111.    Global_BackGround_Color : INTEGER = Black;
  1112.    Global_Border_Color     : INTEGER = Black;
  1113.    Global_Text_Attribute   : INTEGER = White;
  1114.  
  1115. (*----------------------------------------------------------------------*)
  1116. (*                       Multitasker definitions                        *)
  1117. (*----------------------------------------------------------------------*)
  1118.  
  1119. TYPE
  1120.    MultiTaskerType     = ( MultiTasker_None, DoubleDos, DesqView, TopView,
  1121.                            MSWindows, APXCore, EZDosIt, Concurrent_DOS,
  1122.                            TaskView, MultiLink, Other );
  1123.  
  1124. VAR
  1125.    TimeSharingActive   : BOOLEAN   (* TRUE if multitasker active        *);
  1126.  
  1127.                                    (* Which multitasker active          *)
  1128.    MultiTasker         : MultiTaskerType;
  1129.  
  1130.    DesqView_Screen     : Screen_Ptr (* Alternate display buffer address *);
  1131.    Graphics_Screen     : Screen_Ptr (* Graphics display buffer address  *);
  1132.    
  1133. (*----------------------------------------------------------------------*)
  1134. (*                   Menu constants, types, and variables               *)
  1135. (*----------------------------------------------------------------------*)
  1136.  
  1137. CONST
  1138.  
  1139.    Up_Arrow         = ^E;    (* move up in menu code   *)
  1140.    Down_Arrow       = ^X;    (* move down in menu code *)
  1141.    Left_Arrow       = ^S;    (* move up in menu code   *)
  1142.    Right_Arrow      = ^D;    (* move down in menu code *)
  1143.    Space_Bar        = #32;   (* space bar              *)
  1144.    Ch_cr            = #13;   (* Carriage return *)
  1145.    Ch_esc           = #27;   (* Escape *)
  1146.    Ch_bell          = #07;   (* Bell *)
  1147.    
  1148.    Max_Menu_Items   = 21;    (* Maximum number of menu choices *)
  1149.  
  1150.    Dont_Erase_Menu  = FALSE;
  1151.    Erase_Menu       = TRUE;
  1152.    
  1153. TYPE
  1154.  
  1155.    String40   = STRING[40]         (* Menu entry string type               *);
  1156.  
  1157.    Menu_Entry = RECORD
  1158.       Menu_Item_Text   : String40; (* Text of entry                        *)
  1159.       Menu_Item_Row    : BYTE;     (* Row position of menu item            *)
  1160.       Menu_Item_Column : BYTE;     (* Column position of menu item         *)
  1161.    END;
  1162.  
  1163.    Menu_Type = RECORD
  1164.       Menu_Size     : 1 .. Max_Menu_Items;    (* No. of items in menu      *)
  1165.       Menu_Title    : String80;               (* Menu title                *)
  1166.       Menu_Row      : BYTE;                   (* Row position of menu      *)
  1167.       Menu_Column   : BYTE;                   (* Column position of menu   *)
  1168.       Menu_Width    : BYTE;                   (* Width of menu             *)
  1169.       Menu_Height   : BYTE;                   (* Height of menu            *)
  1170.       Menu_Default  : 1 .. Max_Menu_Items;    (* Default value position    *)
  1171.       Menu_TColor   : BYTE;                   (* Foreground text color     *)
  1172.       Menu_BColor   : BYTE;                   (* BackGround color          *)
  1173.       Menu_FColor   : BYTE;                   (* Frame color               *)
  1174.       Menu_HColor   : BYTE;                   (* Title color               *)
  1175.                                               (* Menu items themselves     *)
  1176.       Menu_Entries  : ARRAY[ 1 .. Max_Menu_Items ] Of Menu_Entry;
  1177.    END;
  1178.  
  1179. (* VAR *) CONST
  1180.    Menu_Explode_Mode : BOOLEAN     (* TRUE to use exploding menus *)
  1181.                        = FALSE;
  1182.    Menu_Beep_Mode    : BOOLEAN     (* TRUE to beep on errors      *)
  1183.                        = TRUE;
  1184.    Menu_Depth        : INTEGER     (* Depth of current menus      *)
  1185.                        = 0;
  1186.  
  1187. VAR
  1188.                                    (* Box-drawing characters for menus *)
  1189.    Menu_Box_Chars : RECORD
  1190.                        Top_Left_Corner     : CHAR;
  1191.                        Top_Line            : CHAR;
  1192.                        Top_Right_Corner    : CHAR;
  1193.                        Right_Line          : CHAR;
  1194.                        Bottom_Right_Corner : CHAR;
  1195.                        Bottom_Line         : CHAR;
  1196.                        Bottom_Left_Corner  : CHAR;
  1197.                        Left_Line           : CHAR;
  1198.                     END;
  1199.  
  1200.                                    (* For MENU command *)
  1201.    Script_Menu_Holder : ^Menu_Type;
  1202.  
  1203. CONST
  1204.    Access_Read_Mode           = 0;
  1205.    Access_Write_Mode          = 1;
  1206.    Access_Read_And_Write_Mode = 2;
  1207.    
  1208.    Attribute_None             = 0;
  1209.    Attribute_Read_Only        = 1;
  1210.    Attribute_Hidden           = 2;
  1211.    Attribute_System           = 4;
  1212.    Attribute_Volume_Label     = 8;
  1213.    Attribute_Subdirectory     = 16;
  1214.    Attribute_Archive          = 32;
  1215.    
  1216. VAR                                (* Easier addressing in INLINE *)
  1217.    Global_Crc : INTEGER;
  1218.  
  1219. VAR                                (* DOS error flag              *)
  1220.    Err      : INTEGER;
  1221.    ExitSave : Pointer              (* Exit procedure save area    *);
  1222.  
  1223. VAR
  1224.                                    (* Saves screen in batch transfers *)
  1225.  
  1226.    Batch_Screen_Ptr   : Saved_Screen_Ptr;
  1227.    Kermit_Local_Save  : Saved_Screen_Ptr (* Saves screen for Kermit  *);
  1228.  
  1229. (*----------------------------------------------------------------------*)
  1230. (*              Initialization/Parameter resetting variables            *)
  1231. (*----------------------------------------------------------------------*)
  1232.  
  1233. (* VAR *) CONST                    (* Hold new colors/video mode *)
  1234.    New_Text_Mode          : INTEGER = BW80;
  1235.    New_ForeGround_Color   : INTEGER = White;
  1236.    New_BackGround_Color   : INTEGER = Black;
  1237.    New_Menu_Text_Color    : INTEGER = White;
  1238.    New_Menu_Title_Color   : INTEGER = White;
  1239.    New_Menu_Frame_Color   : INTEGER = White;
  1240.    New_Border_Color       : INTEGER = White;
  1241.    New_Menu_Text_Color_2  : INTEGER = LightGray;
  1242.    Review_Buffer_Length   : INTEGER = 0;
  1243.    Last_Line_To_Set       : INTEGER = 0;
  1244.    Kbd_Interrupt_Change   : BOOLEAN = FALSE;
  1245.    Video_Interrupt_Change : BOOLEAN = FALSE;
  1246.  
  1247. (*----------------------------------------------------------------------*)
  1248. (*              Halt error codes                                        *)
  1249. (*----------------------------------------------------------------------*)
  1250.  
  1251. CONST
  1252.    HeapTooSmall  = 202;
  1253.    StackTooSmall = 203;
  1254.    BadOverlay    = 1;
  1255.    BadDosJump    = 2;
  1256.    BadPort       = 3;
  1257.    ErrorEnd      = 10;
  1258.    
  1259. (*----------------------------------------------------------------------*)
  1260. (*              DOS Jump stuff                                          *)
  1261. (*----------------------------------------------------------------------*)
  1262.  
  1263. (* VAR *) CONST
  1264.    HeapTop           : POINTER = NIL   (* Top of heap at program start       *);
  1265.    StackSafetyMargin : WORD    = 1000  (* Safety margin for stack            *);
  1266.    MinSpaceForDos    : WORD    = 20000 (* Minimum bytes for DOS shell to run *);
  1267.