home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / INFO / MODEM / MUFUS32R.ZIP / MUFGLOBS.PAS < prev    next >
Encoding:
Pascal/Delphi Source File  |  1991-09-02  |  22.0 KB  |  503 lines
  1. UNIT MufGlobs;
  2.  
  3. INTERFACE
  4.  
  5. USES
  6.    Dos, Crt;
  7.  
  8. (*----------------------------------------------------------------------*)
  9. (*                   GLOBAL VARIABLE DEFINITIONS                        *)
  10. (*----------------------------------------------------------------------*)
  11.  
  12. CONST
  13.                    (* 8086/8088 hardware flags *)
  14.  
  15.    Carry_Flag     = 1;
  16.    Parity_Flag    = 4;
  17.    Aux_Carry_Flag = 16;
  18.    Zero_Flag      = 64;
  19.    Sign_Flag      = 128;
  20.  
  21. TYPE
  22.  
  23.    AnyStr    = STRING[255]  (* Matches any string for parameter passing *);
  24.  
  25.    StringPtr = ^AnyStr      (* Points to a string                       *);
  26.  
  27.    ShortStr  = STRING[30]   (* Short string *);
  28.  
  29.    String1   = STRING[1]    (* 1-character string  *);
  30.  
  31.    String10  = STRING[10]   (* 10-character string *);
  32.  
  33.    String12  = STRING[12]   (* 12-character string *);
  34.  
  35.    FileStr   = STRING[65]   (* File name string *);
  36.  
  37.    String80  = STRING[80]   (* 80-character string *);
  38.  
  39.    Text_File = TEXT         (* General text file                 *);
  40.  
  41.                                    (* Comparison types for string tests *)
  42.  
  43.    Comparer       = ( Less, Equal, Greater );
  44.  
  45.                                    (* Character set definitions *)
  46.    CharSet        = SET OF CHAR;
  47.  
  48. (*----------------------------------------------------------------------*)
  49. (*               ASCII character set definitions                        *)
  50. (*----------------------------------------------------------------------*)
  51.  
  52. CONST
  53.  
  54.    NUL  = 0          (* NULL            *);
  55.    ETX  = 3          (* ETX = ^C        *);
  56.    ENQ  = 5          (* ENQ = Enquiry   *);
  57.    BELL = 7          (* BELL = bell     *);
  58.    BS   = 8          (* Backspace       *);
  59.    HT   = 9          (* Horizontal Tab  *);
  60.    LF   = 10         (* Line Feed       *);
  61.    VT   = 11         (* Vertical Tab    *);
  62.    FF   = 12         (* Form Feed       *);
  63.    CR   = 13         (* Carriage Return *);
  64.    SO   = 14         (* Start grahics   *);
  65.    SI   = 15         (* End graphics    *);
  66.    DLE  = 16         (* Data link esc.  *);
  67.    XON  = 17         (* XON             *);
  68.    XOFF = 19         (* XOFF            *);
  69.    SUB  = 26         (* End of file     *);
  70.    ESC  = 27         (* Escape          *);
  71.    FS   = 28         (* Graphics start  *);
  72.    GS   = 29         (* Graphics start  *);
  73.    RS   = 30         (* Inc. plot start *);
  74.    US   = 31         (* Graphics end    *);
  75.    SP   = 32         (* Space           *);
  76.    DEL  = 127        (* Delete          *);
  77.  
  78.  
  79.  
  80. (*----------------------------------------------------------------------*)
  81. (*                Timing constants and variables                        *)
  82. (*----------------------------------------------------------------------*)
  83.  
  84. TYPE
  85.    Date_Format_Type = ( MDY_Style, YMD_Style, DMY_Style );
  86.    Time_Format_Type = ( Military_Time, AMPM_Time        );
  87.  
  88. CONST
  89.    Half_Second_Delay       =  500  (* Delay argument for 1/2 sec. delay *);
  90.    One_Second_Delay        = 1000  (* Delay argument for 1 second delay *);
  91.    Two_Second_Delay        = 2000  (* Delay argument for 2 second delay *);
  92.    Three_Second_Delay      = 3000  (* Delay argument for 3 second delay *);
  93.    Tenth_of_a_second_Delay = 100   (* 1/10 second delay                 *);
  94.  
  95. (* VAR *) CONST
  96.    Delay_Time            : INTEGER (* Time to delay in response to DELAY *)
  97.                                    (* command                            *)
  98.                            = 0;
  99.  
  100.    Current_Status_Time   : INTEGER (* Current time for status line       *)
  101.                            = 0;
  102.  
  103.    New_Status_Time       : INTEGER (* Updated time for status line       *)
  104.                            = 0;
  105.  
  106.    Time_Format           : Time_Format_Type (* Time format               *)
  107.                            = Military_Time;
  108.  
  109.    Date_Format           : Date_Format_Type (* Date format               *)
  110.                            = YMD_Style;
  111.  
  112.    Date_Format_String    : STRING[10]       (* Date format in string form*)
  113.                            = 'YY/MM/DD';
  114.  
  115.    Use_Military          : BOOLEAN (* TRUE to use 24 hour time           *)
  116.                            = TRUE;
  117.  
  118.    Window_Hold_Time      : INTEGER (* Time to wait when clearing window  *)
  119.                            = 10;
  120.  
  121.  
  122. (*----------------------------------------------------------------------*)
  123. (*                      Program Option Flags                            *)
  124. (*----------------------------------------------------------------------*)
  125.  
  126. CONST
  127.    ON   = TRUE                       (* Convenient synonym for switches *);
  128.    OFF  = FALSE                      (* Likewise                        *);
  129.  
  130. (* VAR *) CONST
  131.    Reset_Comm_Port     : BOOLEAN   (* TRUE to reset comm port           *)
  132.                          = TRUE;
  133.    Comm_Port_Changed   : BOOLEAN   (* TRUE if comm port number changed  *)
  134.                          = TRUE;
  135.    Write_Screen_Memory : BOOLEAN   (* TRUE to write video memory direct *)
  136.                          = FALSE;
  137.    Write_Screen_Memory_Par : BOOLEAN (* TRUE to write video direct -- param *)
  138.                          = FALSE;
  139.    Alter_Baud_Rate     : BOOLEAN   (* TRUE to get baud rate from modem  *)
  140.                          = TRUE;
  141.    Check_CTS           : BOOLEAN   (* TRUE to check clear-to-send line  *)
  142.                          = TRUE;
  143.    Check_DSR           : BOOLEAN   (* TRUE to check data-set-ready line *)
  144.                          = FALSE;
  145.    Hard_Wired          : BOOLEAN   (* TRUE if hard-wired connection     *)
  146.                          = FALSE;
  147.    Drop_Dtr_At_End     : BOOLEAN   (* TRUE to drop DTR when closing port*)
  148.                          = FALSE;
  149.    Close_Comm_For_Dos  : BOOLEAN   (* TRUE to drop DTR when Alt-J done  *)
  150.                          = TRUE;
  151.    Wait_For_Retrace    : BOOLEAN   (* TRUE to wait for retrace in DSW   *)
  152.                          = TRUE;
  153.    Wait_For_Retrace_Par: BOOLEAN   (* TRUE to wait for retrace -- param *)
  154.                          = TRUE;
  155.    Current_Carrier_Status : BOOLEAN (* Has current carrier detect status*)
  156.                             = FALSE;
  157.    New_Carrier_Status     : BOOLEAN (* Has new carrier detect status    *)
  158.                             = FALSE;
  159.    Carrier_Dropped        : BOOLEAN (* TRUE if carrier dropped          *)
  160.                             = FALSE;
  161.    Video_Handler_Installed: BOOLEAN (* TRUE if new int $10 handler inst.*)
  162.                             = FALSE;
  163.  
  164.  
  165. (*----------------------------------------------------------------------*)
  166. (*               Global communications variables                        *)
  167. (*----------------------------------------------------------------------*)
  168.  
  169. (* VAR *) CONST
  170.    Data_Bits     : 5..8 = 8;
  171.    Parity        : CHAR = 'N';
  172.    Stop_Bits     : 0..2 = 1;
  173.    Comm_Port     : 1..4 = 1;
  174.    Baud_Rate     : 110..38400 = 2400;
  175.    Cmd_Line_Port : 0..4 = 0;
  176.  
  177. (* STRUCTURED *) CONST
  178.    N_Baud_Rates = 11;
  179.  
  180.    Baud_Rates: ARRAY[ 1 .. N_Baud_Rates ] OF WORD
  181.                = ( 110, 150, 300, 600, 1200, 2400, 4800, 9600, 19200,
  182.                    38400, 57600 );
  183.  
  184.  
  185. (*----------------------------------------------------------------------*)
  186. (*                                                                      *)
  187. (*                  COMMUNICATIONS HARDWARE ADDRESSES                   *)
  188. (*                                                                      *)
  189. (*        These are specific to IBM PCs and close compatibles.          *)
  190. (*                                                                      *)
  191. (*----------------------------------------------------------------------*)
  192.  
  193. CONST
  194.  
  195.    UART_THR = $00;       (* offset from base of UART Registers for IBM PC *)
  196.    UART_RBR = $00;
  197.    UART_IER = $01;
  198.    UART_IIR = $02;
  199.    UART_LCR = $03;
  200.    UART_MCR = $04;
  201.    UART_LSR = $05;
  202.    UART_MSR = $06;
  203.  
  204.    I8088_IMR = $21;      (* port address of the Interrupt Mask Register *)
  205.  
  206.    COM1_Base = $03F8;    (* port addresses for the UART *)
  207.    COM2_Base = $02F8;
  208.    COM3_Base = $03E8;
  209.    COM4_Base = $02E8;
  210.  
  211.    COM1_Irq = 4;         (* Interrupt line for the UART *)
  212.    COM2_Irq = 3;
  213.    COM3_Irq = 4;
  214.    COM4_Irq = 3;
  215.  
  216.    COM1_Int = $0C;       (* Interrupt number for the UART *)
  217.    COM2_Int = $0B;
  218.    COM3_Int = $0C;
  219.    COM4_Int = $0B;
  220.  
  221.    RS232_Base = $0400    (* Address of RS 232 com port pointer *);
  222.  
  223.    MaxComPorts = 4       (* Four ports allowed by this code    *);
  224.  
  225. (* STRUCTURED *) CONST
  226.                                    (* Port addresses of each com port *)
  227.  
  228.    Default_Com_Base : ARRAY[1..MaxComPorts] OF WORD =
  229.                       ( COM1_Base, COM2_Base, COM3_Base, COM4_Base );
  230.  
  231.                                    (* IRQ line for each port *)
  232.  
  233.    Default_Com_Irq  : ARRAY[1..MaxComPorts] OF INTEGER =
  234.                       ( COM1_Irq, COM2_Irq, COM3_Irq, COM4_Irq );
  235.  
  236.                                    (* Interrupt for each port *)
  237.  
  238.    Default_Com_Int  : ARRAY[1..MaxComPorts] OF INTEGER =
  239.                       ( COM1_Int, COM2_Int, COM3_Int, COM4_Int );
  240.  
  241. (*----------------------------------------------------------------------*)
  242. (*                                                                      *)
  243. (*                   COMMUNICATIONS BUFFER VARIABLES                    *)
  244. (*                                                                      *)
  245. (*     The communications buffers are implemented as circular (ring)    *)
  246. (*     buffers, or double-ended queues.  The asynchronous I/O routines  *)
  247. (*     enter characters in the receive buffer as they arrive at the     *)
  248. (*     serial port.  Higher-level routines may extract characters from  *)
  249. (*     the receive buffer at leisure.  Higher-level routines insert     *)
  250. (*     characters into the send buffer.  The asynchronous I/O routines  *)
  251. (*     then send characters out the serial port when possible.          *)
  252. (*                                                                      *)
  253. (*----------------------------------------------------------------------*)
  254.  
  255. CONST
  256.  
  257.    TimeOut             = 256        (* TimeOut value                   *);
  258.    Async_XON           = ^Q         (* XON character                   *);
  259.    Async_XOFF          = ^S         (* XOFF character                  *);
  260.  
  261.    Async_Overrun_Error = 2          (*   overrun                       *);
  262.    Async_Parity_Error  = 4          (*   parity error                  *);
  263.    Async_Framing_Error = 8          (*   framing error                 *);
  264.    Async_Break_Found   = 16         (*   break interrupt               *);
  265.  
  266.    Async_CTS           = $10        (*   Clear to send                 *);
  267.    Async_RTS           = $20        (*   Request to send               *);
  268.  
  269.    Async_DSR           = $20        (*   Data set ready                *);
  270.    Async_DTR           = $10        (*   Data terminal ready           *);
  271.  
  272.    Async_RTSDTR        = $30        (*   RTS + DTR                     *);
  273.    
  274. TYPE
  275.                                     (* I/O buffer type for serial port *)
  276.  
  277.    Async_Buffer_Type   = ARRAY[0..1] OF CHAR;
  278.    Async_Ptr           = ^Async_Buffer_Type;
  279.  
  280.  
  281. VAR                                 (* Port addresses for serial ports *)
  282.  
  283.    Com_Base               : ARRAY[1..MaxComPorts] OF WORD;
  284.  
  285.                                     (* IRQ line for each serial port   *)
  286.  
  287.    Com_Irq                : ARRAY[1..MaxComPorts] OF INTEGER;
  288.  
  289.                                     (* Interrupt for each serial port   *)
  290.  
  291.    Com_Int                : ARRAY[1..MaxComPorts] OF INTEGER;
  292.  
  293. VAR
  294.    Async_Buffer_Ptr       : Async_Ptr  (* Input buffer address  *);
  295.    Async_OBuffer_Ptr      : Async_Ptr  (* Output buffer address *);
  296.  
  297.    Async_Open_Flag        : BOOLEAN    (* true if port opened               *);
  298.    Async_Port             : INTEGER    (* current open port number (1 -- 4) *);
  299.    Async_Base             : INTEGER    (* base for current open port        *);
  300.    Async_Irq              : INTEGER    (* IRQ for current open port         *);
  301.    Async_Int              : INTEGER    (* Interrupt # for current port      *);
  302.    Async_RS232            : INTEGER    (* RS232 address for current port    *);
  303.  
  304.    Async_Buffer_Overflow  : BOOLEAN    (* True if buffer overflow has happened *);
  305.    Async_Buffer_Used      : INTEGER    (* Amount of input buffer used so far   *);
  306.    Async_MaxBufferUsed    : INTEGER    (* Maximum amount of input buffer used  *);
  307.  
  308.                                        (* Async_Buffer empty if Head = Tail    *)
  309.    Async_Buffer_Head      : INTEGER    (* Loc in Async_Buffer to put next char *);
  310.    Async_Buffer_Tail      : INTEGER    (* Loc in Async_Buffer to get next char *);
  311.    Async_Buffer_NewTail   : INTEGER    (* For updating tail value              *);
  312.  
  313.    Async_OBuffer_Overflow : BOOLEAN    (* True if buffer overflow has happened *);
  314.    Async_OBuffer_Used     : INTEGER    (* Amount of output buffer used         *);
  315.    Async_MaxOBufferUsed   : INTEGER    (* Max amount of output buffer used     *);
  316.  
  317.                                        (* Async_Buffer empty if Head = Tail    *)
  318.    Async_OBuffer_Head     : INTEGER    (* Loc in Async_Buffer to put next char *);
  319.    Async_OBuffer_Tail     : INTEGER    (* Loc in Async_Buffer to get next char *);
  320.    Async_OBuffer_NewTail  : INTEGER    (* For updating tail value              *);
  321.  
  322.    Async_Buffer_Low       : INTEGER    (* Low point in receive buffer for XON  *);
  323.    Async_Buffer_High      : INTEGER    (* High point in receive buffer for XOFF*);
  324.    Async_Buffer_High_2    : INTEGER    (* Emergency point for XOFF             *);
  325.  
  326.    Async_XOFF_Sent        : BOOLEAN    (* If XOFF sent                      *);
  327.    Async_Sender_On        : BOOLEAN    (* If sender is enabled              *);
  328.    Async_Send_XOFF        : BOOLEAN    (* TRUE to send XOFF ASAP            *);
  329.    Async_XOFF_Received    : BOOLEAN    (* If XOFF received                  *);
  330.    Async_XOFF_Rec_Display : BOOLEAN    (* If XOFF received and displayed    *);
  331.    Async_XON_Rec_Display  : BOOLEAN    (* If XON received                   *);
  332.    Async_Baud_Rate        : WORD       (* Current baud rate                 *);
  333.  
  334.                                     (* Save previous serial interrupt status *)
  335.    Async_Save_IAddr       : POINTER;
  336.    Async_Do_CTS           : BOOLEAN (* TRUE to do clear-to-send checking    *);
  337.    Async_Do_DSR           : BOOLEAN (* TRUE to do data-set-ready checking   *);
  338.    Async_Do_XonXoff       : BOOLEAN (* TRUE to do XON/XOFF flow checking    *);
  339.    Async_OV_XonXoff       : BOOLEAN (* TRUE to do XON/XOFF if buffer overfl *);
  340.    Async_Hard_Wired_On    : BOOLEAN (* TRUE if hard-wired connection        *);
  341.    Async_Break_Length     : INTEGER (* Length of break in 1/10 seconds      *);
  342.    Async_Line_Status      : BYTE    (* Line Status Reg at interrupt         *);
  343.    Async_Modem_Status     : BYTE    (* Modem Status Reg at interrupt        *);
  344.    Async_Line_Error_Flags : BYTE    (* Line status bits accumulated         *);
  345.    Async_Buffer_Size      : INTEGER (* Stores input buffer size             *);
  346.    Async_OBuffer_Size     : INTEGER (* Stores output buffer size            *);
  347.    Async_Uart_IER         : INTEGER (* Interrupt enable register address    *);
  348.    Async_Uart_MCR         : INTEGER (* Interrupt enable register address    *);
  349.    Async_Uart_IIR         : INTEGER (* Interrupt ID register address        *);
  350.    Async_Uart_MSR         : INTEGER (* Modem status register address        *);
  351.    Async_Uart_LSR         : INTEGER (* Line status register address         *);
  352.    Async_Output_Delay     : INTEGER (* Delay in ms when output buffer full  *);
  353.    Async_OneMSDelay       : INTEGER (* Loop count value to effect 1 ms delay*);
  354.    Async_Buffer_Length    : INTEGER (* Receive buffer length                *);
  355.    Async_OBuffer_Length   : INTEGER (* Send buffer length                   *);
  356.                                     (* Pointer to Async_Send routine        *)
  357.    Async_Send_Addr        : Async_Ptr;
  358.  
  359. (*----------------------------------------------------------------------*)
  360. (*          Definitions for screen memory reading/writing               *)
  361. (*----------------------------------------------------------------------*)
  362.  
  363. CONST
  364.    EGA_Screen_Address      = $A000    (* Address of EGA color screen      *);
  365.    Color_Screen_Address    = $B800    (* Address of color screen          *);
  366.    Mono_Screen_Address     = $B000    (* Address of mono screen           *);
  367.    Screen_Length           = 4000     (* 80 x 25 x 2 = screen area length *);
  368.    Graphics_Screen_Length  = 16000    (* Length of graphics screen area   *);
  369.    EGA_Graphics_Scr_Length = 28000    (* Length of EGA graphics screen    *);
  370.    Max_Saved_Screen        = 6        (* Maximum no. of saved screens     *);
  371.    MedRes_GraphMode        = 4        (* Medium resolution graphics       *);
  372.    HiRes_GraphMode         = 6        (* High resolution graphics mode    *);
  373.    Mono_TextMode           = 7        (* Monochrome adapter text mode     *);
  374.    EGA_GraphMode           = 16       (* EGA adapter graphics mode        *);
  375.    CRT_Index               = $03D4    (* CRT index register               *);
  376.    CRT_Data                = $03D5    (* CRT data register                *);
  377.    CRT_Mode                = $03D8    (* CRT mode register                *);
  378.    CRT_Color_Select        = $03D9    (* CRT color select register        *);
  379.    CRT_Status              = $03DA    (* CRT status port                  *);
  380.    CRT_Mode_Byte           = $0465    (* CRT mode byte                    *);
  381.  
  382. TYPE
  383.                                      (* A screen image            *)
  384.  
  385.    Screen_Type       = ARRAY[ 1 .. EGA_Graphics_Scr_Length ] OF BYTE;
  386.  
  387.    Screen_Ptr        = ^Screen_Image_Type;
  388.  
  389.    Screen_Image_Type = RECORD
  390.                           Screen_Image: Screen_Type;
  391.                        END;
  392.  
  393.                                               (* Screen stack entries      *)
  394.    Saved_Screen_Ptr  = ^Saved_Screen_Type;
  395.  
  396.    Saved_Screen_Type = RECORD
  397.                           Screen_Row    : INTEGER;
  398.                           Screen_Column : INTEGER;
  399.                           Screen_X1     : INTEGER;
  400.                           Screen_Y1     : INTEGER;
  401.                           Screen_X2     : INTEGER;
  402.                           Screen_Y2     : INTEGER;
  403.                           Window_X1     : INTEGER;
  404.                           Window_Y1     : INTEGER;
  405.                           Window_X2     : INTEGER;
  406.                           Window_Y2     : INTEGER;
  407.                           Screen_Size   : WORD;
  408.                           Video_Mode    : INTEGER;
  409.                           If_BIOS       : BOOLEAN;
  410.                           Screen_Image  : Screen_Type;
  411.                        END;
  412.  
  413. CONST
  414.    Video_Interrupt  = $10          (* Video interrupt number     *);
  415.  
  416. CONST                              (* Save previous video interrupt status. *)
  417.  
  418.    Video_Save_Iaddr  : Pointer = Nil;
  419.  
  420.    Video_Request     : INTEGER = 0     (* Current video request *);
  421.    Video_Fill        : INTEGER = 0     (* Fill attribute        *);
  422.    Video_Page        : BYTE    = 0     (* Text memory page      *);
  423.    Video_Mode        : BYTE    = 3     (* Current text mode     *);
  424.    Video_Screen_Addr : WORD    = $B800 (* Screen memory address *);
  425.  
  426. (* VAR *) CONST
  427.    Max_Screen_Col       : INTEGER             (* PC's screen width         *)
  428.                           = 80;
  429.  
  430.    Wrap_Screen_Col      : INTEGER             (* Column at which to wrap   *)
  431.                           = 80;
  432.  
  433.    Max_Screen_Line      : INTEGER             (* PC's screen length        *)
  434.                           = 25;
  435.  
  436.    New_Max_Screen_Col   : INTEGER             (* Width for param settings  *)
  437.                           = 80;
  438.  
  439.    New_Max_Screen_Line  : INTEGER             (* Length for param settings *)
  440.                           = 25;
  441.  
  442.    Font8x8Loaded        : BOOLEAN             (* TRUE if 8x8 font loaded   *)
  443.                           = FALSE;
  444.  
  445.    Really_Save_EGA      : BOOLEAN             (* TRUE to save EGA memory   *)
  446.                           = TRUE;
  447.  
  448. (* VAR *) CONST
  449.                                               (* Memory-mapped screen area *)
  450.    Actual_Screen        : Screen_Ptr = NIL;
  451.                                               (* Saves screen behind menus *)
  452.  
  453.    Saved_Screen         : Saved_Screen_Ptr = NIL;
  454.  
  455.                                               (* Stack of saved screens    *)
  456.  
  457.    Saved_Screen_List    : ARRAY[ 1 .. Max_Saved_Screen ] OF Saved_Screen_Ptr
  458.                           = ( NIL, NIL, NIL, NIL, NIL, NIL );
  459.  
  460.                                               (* Depth of saved screen stack *)
  461.    Current_Saved_Screen : 0 .. Max_Saved_Screen = 0;
  462.  
  463.                                    (* Upper left corner of      *)
  464.                                    (* current TURBO window      *)
  465. (* VAR *) CONST
  466.    Upper_Left_Column  : INTEGER = 1;
  467.    Upper_Left_Row     : INTEGER = 1;
  468.  
  469.                                    (* Lower right corner of     *)
  470.                                    (* current TURBO window      *)
  471. (* VAR *) CONST
  472.    Lower_Right_Column  : INTEGER = 80;
  473.    Lower_Right_Row     : INTEGER = 25;
  474.  
  475. (* VAR *) CONST
  476.    Global_ForeGround_Color : INTEGER = White;
  477.    Global_BackGround_Color : INTEGER = Black;
  478.    Global_Border_Color     : INTEGER = Black;
  479.    Global_Text_Attribute   : INTEGER = White;
  480.  
  481. (*----------------------------------------------------------------------*)
  482. (*                       Multitasker definitions                        *)
  483. (*----------------------------------------------------------------------*)
  484.  
  485. TYPE
  486.    MultiTaskerType     = ( MultiTasker_None, DoubleDos, DesqView, TopView,
  487.                            MSWindows, APXCore, EZDosIt, Concurrent_DOS,
  488.                            TaskView, MultiLink, Other );
  489.  
  490. VAR
  491.    TimeSharingActive   : BOOLEAN   (* TRUE if multitasker active        *);
  492.  
  493.                                    (* Which multitasker active          *)
  494.    MultiTasker         : MultiTaskerType;
  495.  
  496.    DesqView_Screen     : Screen_Ptr (* Alternate display buffer address *);
  497.    Graphics_Screen     : Screen_Ptr (* Graphics display buffer address  *);
  498.    
  499.  
  500. IMPLEMENTATION
  501.  
  502. END   (* GlobType *).
  503.