home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / PASCAL / FAQ-S.ZIP / GLOBTYPE.PAS < prev    next >
Encoding:
Pascal/Delphi Source File  |  1991-04-16  |  11.8 KB  |  255 lines
  1. UNIT GlobType;
  2.  
  3. INTERFACE
  4.  
  5.                         (* Global Declarations *)
  6. CONST
  7.  
  8.                    (* 8086/8088 hardware flags *)
  9.  
  10.    Carry_Flag     = 1;
  11.    Parity_Flag    = 4;
  12.    Aux_Carry_Flag = 16;
  13.    Zero_Flag      = 64;
  14.    Sign_Flag      = 128;
  15.  
  16. TYPE
  17.  
  18.    AnyStr   = STRING[255]  (* Matches any string for parameter passing *);
  19.  
  20.    ShortStr = STRING[30]   (* Short string *);
  21.  
  22.    KeyStr   = STRING[65]   (* Function key string *);
  23.  
  24.    FileStr  = STRING[65]   (* File name string *);
  25.  
  26.    Text_File = TEXT;
  27.  
  28. (*----------------------------------------------------------------------*)
  29. (*               ASCII character set definitions                        *)
  30. (*----------------------------------------------------------------------*)
  31.  
  32. CONST
  33.  
  34.    NUL  = 0          (* NULL Character  *);
  35.    SOH  = 1          (* SOH Character   *);
  36.    ETX  = 3          (* ETX = ^C        *);
  37.    ENQ  = 5          (* ENQ Character   *);
  38.    ACK  = 6;
  39.    BELL = 7          (* BELL Character  *);
  40.    BS   = 8          (* Backspace Char  *);
  41.    HT   = 9          (* Horizontal Tab  *);
  42.    LF   = 10         (* Line Feed       *);
  43.    VT   = 11         (* Vertical Tab    *);
  44.    FF   = 12         (* Form Feed       *);
  45.    CR   = 13         (* Carriage Return *);
  46.    SO   = 14         (* Start grahics   *);
  47.    SI   = 15         (* End graphics    *);
  48.    XON  = 17         (* XON  Character  *);
  49.    XOFF = 19         (* XOFF Character  *);
  50.    CAN  = 24;
  51.    SUB  = 26         (* EOF Character   *);
  52.    ESC  = 27         (* Escape          *);
  53.    SP   = 32         (* Space           *);
  54.    DEL  = 127        (* DEL  Character  *);
  55.  
  56. (*----------------------------------------------------------------------*)
  57. (*                                                                      *)
  58. (*                  COMMUNICATIONS HARDWARE ADDRESSES                   *)
  59. (*                                                                      *)
  60. (*        These are specific to IBM PCs and close compatibles.          *)
  61. (*                                                                      *)
  62. (*----------------------------------------------------------------------*)
  63.  
  64. CONST
  65.  
  66.    UART_THR   = $00;     (* offset from base of UART Registers for IBM PC *)
  67.    UART_RBR   = $00;
  68.    UART_IER   = $01;
  69.    UART_IIR   = $02;
  70.    UART_LCR   = $03;
  71.    UART_MCR   = $04;
  72.    UART_LSR   = $05;
  73.    UART_MSR   = $06;
  74.  
  75.    I8259_1    = $20      (* address of first 8259  *);
  76.    I8259_2    = $A0      (* address of second 8259 *);
  77.  
  78.    I8088_IMR1 = $21;     (* port address of the 1st Interrupt Mask Register *)
  79.    I8088_IMR2 = $A1;     (* port address of the 2nd Interrupt Mask Register *)
  80.  
  81.    COM1_Base  = $03F8;   (* port addresses for the UART *)
  82.    COM2_Base  = $02F8;
  83.    COM3_Base  = $03E8;
  84.    COM4_Base  = $02E8;
  85.  
  86.    COM1_Irq   = 4;       (* Interrupt line for the UART *)
  87.    COM2_Irq   = 3;
  88.    COM3_Irq   = 4;
  89.    COM4_Irq   = 3;
  90.  
  91.    COM1_Int   = $0C;     (* Interrupt number for the UART *)
  92.    COM2_Int   = $0B;
  93.    COM3_Int   = $0C;
  94.    COM4_Int   = $0B;
  95.  
  96.    RS232_Base = $0400    (* Address of RS 232 com port pointer *);
  97.  
  98.    MaxComPorts = 4       (* Four ports allowed by this code    *);
  99.  
  100. (* STRUCTURED *) CONST
  101.                                    (* Port addresses of each com port *)
  102.  
  103.    Default_Com_Base : ARRAY[1..MaxComPorts] OF WORD =
  104.                       ( COM1_Base, COM2_Base, COM3_Base, COM4_Base );
  105.  
  106.                                    (* IRQ line for each port *)
  107.  
  108.    Default_Com_Irq  : ARRAY[1..MaxComPorts] OF INTEGER =
  109.                       ( COM1_Irq, COM2_Irq, COM3_Irq, COM4_Irq );
  110.  
  111.                                    (* Interrupt for each port *)
  112.  
  113.    Default_Com_Int  : ARRAY[1..MaxComPorts] OF INTEGER =
  114.                       ( COM1_Int, COM2_Int, COM3_Int, COM4_Int );
  115.  
  116. (*----------------------------------------------------------------------*)
  117. (*                                                                      *)
  118. (*                   COMMUNICATIONS BUFFER VARIABLES                    *)
  119. (*                                                                      *)
  120. (*     The communications buffers are implemented as circular (ring)    *)
  121. (*     buffers, or double-ended queues.  The asynchronous I/O routines  *)
  122. (*     enter characters in the receive buffer as they arrive at the     *)
  123. (*     serial port.  Higher-level routines may extract characters from  *)
  124. (*     the receive buffer at leisure.  Higher-level routines insert     *)
  125. (*     characters into the send buffer.  The asynchronous I/O routines  *)
  126. (*     then send characters out the serial port when possible.          *)
  127. (*                                                                      *)
  128. (*----------------------------------------------------------------------*)
  129.  
  130. CONST
  131.  
  132.    TimeOut             = 256        (* TimeOut value                   *);
  133.    Async_XON           = ^Q         (* XON character                   *);
  134.    Async_XOFF          = ^S         (* XOFF character                  *);
  135.  
  136.    Async_Overrun_Error = 2          (*   overrun                       *);
  137.    Async_Parity_Error  = 4          (*   parity error                  *);
  138.    Async_Framing_Error = 8          (*   framing error                 *);
  139.    Async_Break_Found   = 16         (*   break interrupt               *);
  140.  
  141.    Async_CTS           = $10        (*   Clear to send                 *);
  142.    Async_RTS           = $20        (*   Request to send               *);
  143.  
  144.    Async_DSR           = $20        (*   Data set ready                *);
  145.    Async_DTR           = $10        (*   Data terminal ready           *);
  146.  
  147.    Async_RTSDTR        = $30        (*   RTS + DTR                     *);
  148.  
  149.    Async_THRE          = $20        (*   Transmit holder reg. empty    *);
  150.  
  151. TYPE
  152.                                     (* I/O buffer type for serial port *)
  153.  
  154.    Async_Buffer_Type   = ARRAY[0..1] OF CHAR;
  155.    Async_Ptr           = ^Async_Buffer_Type;
  156.  
  157.  
  158. VAR                                 (* Port addresses for serial ports *)
  159.  
  160.    Com_Base               : ARRAY[1..MaxComPorts] OF WORD;
  161.  
  162.                                     (* IRQ line for each serial port   *)
  163.  
  164.    Com_Irq                : ARRAY[1..MaxComPorts] OF INTEGER;
  165.  
  166.                                     (* Interrupt for each serial port   *)
  167.  
  168.    Com_Int                : ARRAY[1..MaxComPorts] OF INTEGER;
  169.  
  170. VAR
  171.    Async_Buffer_Ptr       : Async_Ptr  (* Input buffer address  *);
  172.    Async_OBuffer_Ptr      : Async_Ptr  (* Output buffer address *);
  173.  
  174.    Async_Open_Flag        : BOOLEAN    (* true if port opened               *);
  175.    Async_Port             : INTEGER    (* current open port number (1 -- 4) *);
  176.    Async_Base             : INTEGER    (* base for current open port        *);
  177.    Async_Irq              : INTEGER    (* IRQ for current open port         *);
  178.    Async_Int              : INTEGER    (* Interrupt # for current port      *);
  179.    Async_RS232            : INTEGER    (* RS232 address for current port    *);
  180.  
  181.    Async_Buffer_Overflow  : BOOLEAN    (* True if buffer overflow has happened *);
  182.    Async_Buffer_Used      : INTEGER    (* Amount of input buffer used so far   *);
  183.    Async_MaxBufferUsed    : INTEGER    (* Maximum amount of input buffer used  *);
  184.  
  185.                                        (* Async_Buffer empty if Head = Tail    *)
  186.    Async_Buffer_Head      : INTEGER    (* Loc in Async_Buffer to put next char *);
  187.    Async_Buffer_Tail      : INTEGER    (* Loc in Async_Buffer to get next char *);
  188.    Async_Buffer_NewTail   : INTEGER    (* For updating tail value              *);
  189.  
  190.    Async_OBuffer_Overflow : BOOLEAN    (* True if buffer overflow has happened *);
  191.    Async_OBuffer_Used     : INTEGER    (* Amount of output buffer used         *);
  192.    Async_MaxOBufferUsed   : INTEGER    (* Max amount of output buffer used     *);
  193.  
  194.                                        (* Async_Buffer empty if Head = Tail    *)
  195.    Async_OBuffer_Head     : INTEGER    (* Loc in Async_Buffer to put next char *);
  196.    Async_OBuffer_Tail     : INTEGER    (* Loc in Async_Buffer to get next char *);
  197.    Async_OBuffer_NewTail  : INTEGER    (* For updating tail value              *);
  198.  
  199.    Async_Buffer_Low       : INTEGER    (* Low point in receive buffer for XON  *);
  200.    Async_Buffer_High      : INTEGER    (* High point in receive buffer for XOFF*);
  201.    Async_Buffer_High_2    : INTEGER    (* Emergency point for XOFF             *);
  202.  
  203.    Async_XOFF_Sent        : BOOLEAN    (* If XOFF sent                      *);
  204.    Async_Sender_On        : BOOLEAN    (* If sender is enabled              *);
  205.    Async_Send_XOFF        : BOOLEAN    (* TRUE to send XOFF ASAP            *);
  206.    Async_XOFF_Received    : BOOLEAN    (* If XOFF received                  *);
  207.    Async_XOFF_Rec_Display : BOOLEAN    (* If XOFF received and displayed    *);
  208.    Async_XON_Rec_Display  : BOOLEAN    (* If XON received                   *);
  209.    Async_Baud_Rate        : WORD       (* Current baud rate                 *);
  210.  
  211.                                     (* Save previous serial interrupt status *)
  212.  
  213.    Async_Save_IAddr,
  214.    Get_Reboot_Vec,
  215.    Set_Reboot_Vector       : POINTER (* Interrupt procedure pointer          *);
  216.    Async_Save_LCR         : BYTE    (* Old LCR register contents            *);
  217.    Async_Save_MCR         : BYTE    (* Old MCR register contents            *);
  218.    Async_Save_IMR         : BYTE    (* Old interrupt enabled mask           *);
  219.    Async_Save_IER         : BYTE    (* Old interrupt enable register cont.  *);
  220.    Async_Save_DLR         : BYTE    (* Old divisor (low) contents           *);
  221.    Async_Save_DHR         : BYTE    (* Old divisor (high) contents          *);
  222.  
  223.    Async_Do_CTS           : BOOLEAN (* TRUE to do clear-to-send checking    *);
  224.    Async_Do_DSR           : BOOLEAN (* TRUE to do data-set-ready checking   *);
  225.    Async_Do_XonXoff       : BOOLEAN (* TRUE to do XON/XOFF flow checking    *);
  226.    Async_OV_XonXoff       : BOOLEAN (* TRUE to do XON/XOFF if buffer overfl *);
  227.    Async_Hard_Wired_On    : BOOLEAN (* TRUE if hard-wired connection        *);
  228.    Async_Break_Length     : INTEGER (* Length of break in 1/10 seconds      *);
  229.    Async_Line_Status      : BYTE    (* Line Status Reg at interrupt         *);
  230.    Async_Modem_Status     : BYTE    (* Modem Status Reg at interrupt        *);
  231.    Async_Line_Error_Flags : BYTE    (* Line status bits accumulated         *);
  232.    Async_Buffer_Size      : INTEGER (* Stores input buffer size             *);
  233.    Async_OBuffer_Size     : INTEGER (* Stores output buffer size            *);
  234.    Async_Uart_IER         : INTEGER (* Interrupt enable register address    *);
  235.    Async_Uart_MCR         : INTEGER (* Interrupt enable register address    *);
  236.    Async_Uart_IIR         : INTEGER (* Interrupt ID register address        *);
  237.    Async_Uart_MSR         : INTEGER (* Modem status register address        *);
  238.    Async_Uart_LSR         : INTEGER (* Line status register address         *);
  239.    Async_Uart_THR         : INTEGER (* Transmit hold register address       *);
  240.    Async_Uart_LCR         : INTEGER (* Line control register address        *);
  241.    Async_Uart_RBR         : INTEGER (* Read character register address      *);
  242.    Async_IMR              : INTEGER (* Interrupt mask register              *);
  243.    Async_Output_Delay     : INTEGER (* Delay in ms when output buffer full  *);
  244.    Async_OneMSDelay       : INTEGER (* Loop count value to effect 1 ms delay*);
  245.    Async_Buffer_Length    : INTEGER (* Receive buffer length                *);
  246.    Async_OBuffer_Length   : INTEGER (* Send buffer length                   *);
  247.                                     (* Pointer to Async_Send routine        *)
  248.    Async_Send_Addr        : Async_Ptr;
  249.    Async_Reject_Noise     : BOOLEAN (* TRUE to reject "bad" received chars  *);
  250.    Async_Noise_Char       : CHAR    (* Character to replace "noise"         *);
  251.  
  252. IMPLEMENTATION
  253.  
  254. END (* GlobType *).
  255.