;  STDIO.HDR
;
;  READ and WRITE routines needed for Tiny Pascal
;
SYS_RCHAR   PROC   NEAR   ; Read single character from stdin
            MOV    AH,1
            INT    021H
            RET           ; value comes back in AL
            ENDP

SYS_WRCHAR  PROC   NEAR   ; Write a single character (in DL) to stdin
            MOV    AH,2
            INT    021H
            RET
            ENDP

SYS_WHEX    PROC   NEAR   ; Write a single HEX number (in DL) to stdin
            CMP    DL,10
            JL     SYS_01
            ADD    DL,55     ; 'A' - 10
            CALL   SYS_WRCHAR
            RET
SYS_01      ADD    DL,'0'
            CALL   SYS_WRCHAR
            RET
            ENDP

SYS_IWRT    PROC   NEAR   ; Write an integer to stdout in HEX
            MOV    DH,4   ; used as a counter
SYS_11      ROL    AX
            ROL    AX
            ROL    AX
            ROL    AX
            MOV    DL,AL
            AND    DL,0FH
            PUSH   AX
            CALL   SYS_WHEX
            POP    AX
            DEC    DH
            JNZ    SYS_11
            RET
            ENDP

SYS_SWRT    PROC   NEAR   ; Write a string terminated by 0 to stdout
SYS_21      MOV    DL,0[BX]
            CMP    DL,0
            JNZ    SYS_22   ; zero terminator?
            RET
SYS_22      CALL   SYS_WRCHAR
            INC    BX
            JMPS   SYS_21
            ENDP

SYS_WRTLN   PROC   NEAR    ; write carriage return/line feed to stdout
            MOV    DL,0DH
            CALL   SYS_WRCHAR
            MOV    DL,0AH
            CALL   SYS_WRCHAR
            RET
            ENDP

READ        PROC   NEAR         ; read a HEX number from STDIN
            MOV    DX,0         ; clear DX
READ_01     CALL   SYS_RCHAR    ; get one character in AL
                    ; won't affect DX
            CMP    AL,0DH
            JNZ    READ_02
            PUSH   DX           ; save the thing we've done
            CALL   SYS_WRTLN    ; send a carriage return/line feed
            POP    AX           ; was an ENTER
            RET
READ_02     CMP    AL,' '
            JZ     READ_01      ; ignore spaces
            SUB    AL,'0'       ; start conversion to binary
            CMP    AL,9
            JLE    READ_03
            SUB    AL,7         ; turn 'A' into 0AH
READ_03     CMP    AL,0FH
            JLE    READ_04
            SUB    AL,32        ; turn 'a' into 0AH
READ_04     AND    AL,0FH       ; clip for good measure
            SHL    DX           ; prepare DX for hex value
            SHL    DX
            SHL    DX
            SHL    DX
            OR     DL,AL
            JMPS   READ_01      ; go do some more
            ENDP

READLN      PROC   NEAR
            JMPS   READ         ; does the same thing
            ENDP