init.asm

Dos6.0

                dw      DVR:set_auto
                db      4, 'BAUD'
                dw      DVR:set_baud
                db      1, 'V'
                dw      DVR:set_variable
                db      0

parse_line      PROC    NEAR
                PUBLIC  parse_line

                push    si

convert_upper:  mov     al, es:[si]
                cmp     al, ' '
                jb      convert_done

                call    toupper
                mov     es:[si], al
                inc     si
                jmp     convert_upper

convert_done:   pop     si

grab_char:      mov     al, es:[si]
                inc     si
                cmp     al, '/'
                je      found_arg

                cmp     al, '-'
                je      found_arg

                cmp     al, ' '
                je      grab_char

                jb      parse_exit

                mov     di, si
                jmp     short bad_option

found_arg:      mov     di, si
                mov     si, DVR:arg_table
                xor     ch, ch

arg_loop:       lodsb   
                or      al, al
                jz      bad_option

                mov     cl, al
                push    di
        repe    cmpsb
                mov     bl, es:[di]         ; Grab next character
                pop     di
                jne     no_match

                cmp     bl, 'A'
                jb      arg_match

                cmp     bl, 'Z'
                ja      arg_match

no_match:       add     si, cx
                add     si, 2
                jmp     arg_loop

arg_match:      mov     cl, al
                add     di, cx              ; Point past the arg
                lodsw
                mov     si, di
                call    ax
                jmp     grab_char

bad_option:     pmsg    invalid_switch

                mov     dl, es:[di - 1]
                mov     ah, 2
                int     21H

unrecog_loop:   mov     al, es:[di]
                cmp     al, '0'
                jb      unrecog_done

                mov     dl, al
                mov     ah, 2
                int     21H
                inc     di
                jmp     unrecog_loop

unrecog_done:   call    show_crlf
                stc
                jmp     short parse_ret

parse_exit:     clc

parse_ret:      ret

parse_line      ENDP

default_cl      DB      '/LPT* /COM*', CR

get_exe_name    PROC    NEAR

                push    di
                mov     di, DVR:Virt_Dev_File

;--- Skip any leading white space

skip_white:     mov     al, es:[si]
                cmp     al, ' '
                ja      skip_done

                or      al, al
                jz      get_exe_done

                inc     si
                jmp     skip_white

skip_done:      cmp     BYTE PTR es:[si + 1], ':'
                jne     unknown_drive

                mov     ah, es:[si + 1]
                mov     [di], ax
                add     di, 2
                add     si, 2
                jmp     check_root

unknown_drive:  
;                mov     WORD PTR [di], ":?"
                mov     ah, 19H             ;===> Can we really do this? <===
                int     21H
                add     al, 'A'
                mov     ah, ':'
                mov     WORD PTR [di], ax
                add     di, 2                

check_root:     cmp     BYTE PTR es:[si], '\'
                je      copy_exe_name

                mov     BYTE PTR [di], '\'
                inc     di

copy_exe_name:  mov     al, es:[si]
                cmp     al, '/'
                je      get_exe_done

                cmp     al, ' '
                jbe     get_exe_done

                mov     [di], al
                inc     di
                inc     si
                jmp     copy_exe_name

get_exe_done:   pop     di
                ret

get_exe_name    ENDP

parse_args      PROC    NEAR

                call    get_exe_name

IFDEF DEBUG
                push    si
                mov     si, DVR:Virt_Dev_File
                DBG     '<'
                DBG     '<'
                DBG     '<'

show_loop:      lodsb
                or      al, al
                jz      show_done

                DBG     al
                jmp     show_loop

show_done:
                DBG     '>'
                DBG     '>'
                DBG     '>'
                pop     si
ENDIF

;--- Skip any leading white space after .EXE file name

skip_white:     mov     al, es:[si]
                cmp     al, ' '
                jne     skip_non_white

                inc     si
                jmp     skip_white

skip_non_white: 
IFDEF OLD_CODE
                mov     al, es:[si]
                cmp     al, ' '
                jb      parse_default

                je      do_parse

                inc     si
                jmp     skip_non_white
ENDIF

do_parse:       call    parse_line
                jc      parse_fail

                cmp     num_ports, 0
                jne     parse_ok

parse_default:  push    cs
                pop     es
                mov     si, DVR:default_cl
                call    parse_line
                jmp     short parse_done

parse_ok:       clc
                jmp     short parse_done

parse_fail:     stc

parse_done:     ret

parse_args      ENDP

show_port_ser   PROC    NEAR

; Enter with BX = index into serial_ports[]

                mov     al, serial_ports[bx].SERIAL_PORT_DEF.sp_biosnum
                or      al, al
                jz      not_ser_bios

                add     al, '0'
                mov     cs:ser_port_number, al
                pmsg    ser_port_name
                jmp     short show_sp_done

not_ser_bios:   mov     cs:ser_port_number, '$'
                pmsg    ser_port_name
                mov     ax, serial_ports[bx].SERIAL_PORT_DEF.sp_address
                call    show_address

show_sp_done:   ret

show_port_ser   ENDP


show_port_par   PROC    NEAR

                mov     al, parallel_ports[bx].PARALLEL_PORT_DEF.pp_biosnum
                or      al, al
                jz      not_par_bios

                add     al, '0'
                mov     cs:par_port_number, al
                pmsg    par_port_name
                jmp     short show_pp_done

not_par_bios:   mov     cs:par_port_number, '$'
                pmsg    par_port_name
                mov     ax, parallel_ports[bx].PARALLEL_PORT_DEF.pp_address
                call    show_address

show_pp_done:   ret

show_port_par   ENDP


is_alpha        PROC    NEAR
                PUBLIC  is_alpha

                cmp     al, 'A'
                jb      out_of_range

                cmp     al, 'Z'
                jbe     in_range

                cmp     al, 'z'
                ja      out_of_range

                cmp     al, 'a'
                jb      out_of_range

in_range:       clc
                jmp     short alpha_ret

out_of_range:   stc

alpha_ret:      ret

is_alpha        ENDP

find_arg        PROC    NEAR

; Skip the optional colon (or equal sign) and point at the numeric argument
; (if present).
; Error if next character is alphabetic.
; Error if end of command line (< ' ') or '/' seen before argument.

                mov     al, es:[si]
                cmp     al, ':'
                je      colon_or_equal

                cmp     al, '='
                je      colon_or_equal

                jmp     short grab_first

colon_or_equal: inc     si

grab_first:     mov     al, es:[si]
                call    is_alpha
                jnc     arg_error

                clc
                jmp     short arg_ret

arg_error:      stc
                
arg_ret:        ret

find_arg        ENDP

find_port_arg   PROC    NEAR

                mov     al, es:[si]
                cmp     al, ' '
                jbe     fpa_ok                  ; /COM or /LPT is OK

                call    find_arg
                jc      fpa_fail

                mov     al, es:[si]
                cmp     al, '*'
                je      fpa_incr

                cmp     al, '0'
                jb      fpa_fail

                cmp     al, '9'
                jbe     fpa_ok

fpa_fail:       stc
                jmp     short fpa_ret

fpa_incr:       inc     si

fpa_ok:         clc

fpa_ret:        ret

find_port_arg   ENDP

set_force_low   PROC    NEAR

                mov     force_low, 1
                ret

set_force_low   ENDP

set_num_drives  PROC    NEAR

                mov     ax, es:[si]
                cmp     al, ':'
                je      colon_equal

                cmp     al, '='
                je      colon_equal

                jmp     short set_nd_error

colon_equal:    cmp     ah, '0'
                jb      set_nd_error

                cmp     ah, '9'
                ja      set_nd_error

                inc     si
                call    decimal_number
                jc      set_nd_error

                cmp     ax, MAX_DEVICES     ; #### Can we really do this many?
                ja      set_nd_error

                mov     default_units, al
                jmp     short snd_ret

set_nd_error:   pmsg    drives_error

snd_ret:        ret

set_num_drives  ENDP

baud_table_low  dw      1200                ;   1200 baud   (index 0)     
                dw      2400                ;   2400 baud   (index 1)
                dw      4800                ;   4800 baud   (index 2)
                dw      9600                ;   9600 baud   (index 3)
                dw      19200               ;  19200 baud   (index 4)
                dw      38400               ;  38400 baud   (index 5)
                dw      57600               ;  57600 baud   (index 6)
                dw      49664               ; 115200 baud   (index 7)
NUM_BAUD_VALUES EQU     (($ - baud_table_low) / 2)

baud_table_high db      0                   ;   1200 baud   (index 0) 
                db      0                   ;   2400 baud   (index 1)
                db      0                   ;   4800 baud   (index 2)
                db      0                   ;   9600 baud   (index 3)
                db      0                   ;  19200 baud   (index 4)
                db      0                   ;  38400 baud   (index 5)
                db      0                   ;  57600 baud   (index 6)
                db      1                   ; 115200 baud   (index 7)

set_baud        PROC    NEAR
                PUBLIC  set_baud

                mov     ax, es:[si]
                inc     si
                cmp     al, ':'
                je      sb_colon_equal

                cmp     al, '='
                jne     set_baud_error

sb_colon_equal: cmp     ah, '0'
                jb      set_baud_error

                cmp     ah, '9'
                ja      set_baud_error

                call    decimal_number
                jc      set_baud_error

                push    es
                push    cs
                pop     es
                mov     di, DVR:baud_table_low + (2 * 3)
                mov     cx, NUM_BAUD_VALUES
        repne   scasw
                pop     es
                jne     set_baud_error

                sub     di, DVR:baud_table_low + 2
                mov     bx, di
                shr     bx, 1
                cmp     dl, cs:baud_table_high[bx]
                jne     set_baud_error

                mov     client_max_baud, bl
                mov     max_baud, bl
                jmp     short set_baud_ret

set_baud_error: pmsg    m_baud_error

set_baud_ret:   ret

set_baud        ENDP

set_noscan      PROC    NEAR

                inc     noscan
                ret

set_noscan      ENDP


set_auto        PROC    NEAR

                inc     auto
                ret

set_auto        ENDP


set_variable    PROC    NEAR

                inc     fx_force_variable
                ret

set_variable    ENDP


set_noprinter   PROC    NEAR

                mov     printer_loaded, 0
                ret

set_noprinter   ENDP


set_com_port    PROC    NEAR

                call    find_port_arg
                jc      com_bad

                cmp     al, ' '
                jbe     com_wild

                cmp     al, '*'
                jne     com_not_wild

com_wild:       mov     cl, num_com
                xor     ch, ch
                jcxz    c_get_port_ret

                mov     bios_port_num, 1