Real-mode Integer Converter

; AX: converted integer.
; DX: where it stopped reading.
; DX=0 and AX!=0xFFFF indicate reading error.
; DX=0 and AX==0xFFFF indicate overflow error.
; unsigned long str2int(const char* str, int base, int bSigned);
str2int:
    push bp
    mov bp, sp
    sub sp, 2
    push cx
    push bx
    push si

    mov si, [bp+4]
    mov bx, [bp+6]
    cmp bx, 2
    jl .fail
    cmp bx, 36
    jg .fail
    push si
    call skipSpace
    mov si, ax
    xor cx, cx
    xor ax, ax

    mov [bp-2], ax
    mov cl, [si]
    cmp cl, '-'
    jne .notMinus
        cmp word [bp+8], 0
        je .notMinus
        mov word [bp-2], 1
        inc si
    .notMinus:
    mov cl, [si]
    cmp cl, '0'
    jb .fail
    cmp cl, '9'
    jbe .isDigit
    cmp cl, 'z'
    ja .fail
    cmp cl, 'a'
    jae .isLower
    cmp cl, 'A'
    jb .fail
    cmp cl, 'Z'
    ja .fail
    jmp .isUpper
.loop:
    mov cl, [si]
    cmp cl, '0'
    jb .notDigit
    cmp cl, '9'
    ja .notDigit
.isDigit:
        sub cl, '0'
        jmp .continue
    .notDigit:
    cmp cl, 'A'
    jb .notUpper
    cmp cl, 'Z'
    ja .notUpper
.isUpper:
        sub cl, 'A'
        add cl, 10
        jmp .continue
    .notUpper:
    cmp cl, 'a'
    jb .break
    cmp cl, 'z'
    ja .break
.isLower:
        sub cl, 'a'
        add cl, 10
.continue:
    cmp cl, bl
    jae .break

    mul bx
    or dx, dx
    jnz .overflow
    add ax, cx
    jc .overflow
    inc si
    jmp .loop
.break:
    cmp word [bp-2], 0
    je .notNeg
        test ax, 0x8000
        jnz .overflow
        neg ax
    .notNeg:
    sub si, [bp+4]
    mov dx, si
    jmp .done
.overflow:
    mov ax, 0xFFFF
    xor dx, dx
    jmp .done
.fail:
    xor ax, ax
    xor dx, dx
.done:
    pop si
    pop bx
    pop cx
    add sp, 2
    pop bp
    ret 6

; "buffer" must be large enough to fit.
; int int2str(char* buffer, int num, int base, int bSigned);
int2str:
    push bp
    mov bp, sp
    push bx
    push si
    push di

    mov di, [bp+4]
    mov ax, [bp+6]
    mov bx, [bp+8]
    cmp bx, 2
    jl .fail
    cmp bx, 36
    jg .fail
    cmp word [bp+10], 0
    je .loop
        cmp ax, 0
        jge .loop
        mov byte [di], '-'
        inc di
        neg ax
.loop:
    xor dx, dx
    div bx
    mov si, .digits
    add si, dx
    mov dl, [si]
    mov [di], dl
    inc di
    or ax, ax
    jnz .loop

    mov byte [di], 0
    mov di, [bp+4]
    cmp byte [di], '-'
    jne .notNeg
        inc di
    .notNeg:
    push di
    call strrev
    mov ax, 1
    jmp .done
.fail:
    xor ax, ax
.done:
    pop di
    pop si
    pop bx
    pop bp
    ret 8

; void strrev(char* str);
strrev:
    push bp
    mov bp, sp
    push cx
    push si
    push di

    mov cx, 0xFFFF
    mov si, [bp+4]
    mov di, si
    xor ax, ax
    repne scasb
    sub di, 2
.loop:
    cmp si, di
    jae .done
    mov al, [di]
    mov ah, [si]
    mov [di], ah
    mov [si], al
    inc si
    dec di
    jmp .loop

.done:
    pop di
    pop si
    pop cx
    pop bp
    ret 2

; const char* skipSpace(const char* str);
skipSpace:
    push bp
    mov bp, sp
    push si

    mov si, [bp+4]
.loop:
    mov al, [si]
    or al, al
    jz .done
    cmp al, ' '
    ja .done
    inc si
    jmp .loop
.done:
    mov ax, si

    pop si
    pop bp
    ret 2


int2str.digits: db '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'