Convert 16-bit decimal number to other bases using NASM assembly

I am having some problems implementing the correct decimal conversion to binary, octal and hex using NASM assembly. I have most of the code as shown below. I have some problems that I am still working on. I have commented out the relevant information in the code.

    %include "io.mac"
    .STACK 100H
    msg1        db "Please enter a positive integer (max 16 bits): ",0
    msg2        db "The binary (base-2) representation of the number is: ",0
    msg3        db "The octal (base-8) representation of the number is: ",0
    msg4        db "The hex (base-16) representation of the number is: ",0
    msg5        db "A",0 ;These will be implemented when I get the 
    msg6        db "B",0 ;hexadecimal loop working to change 10, 11, 
    msg7        db "C",0 ;etc. to their hex equivalents.
    msg8        db "D",0
    msg9        db "E",0
    msg10       db "F",0

    num1            resw 1
    quotient        resw 1
    remainder       resw 1

    PutStr msg1
    GetInt [num1]

    PutStr msg2
    mov AX, [num1]      
    sub BH, BH

    push AX 
    mov BH, byte 2 
    div BH ;All loops output the remainders in reverse order at the moment.
    mov [remainder], AH ;I was thinking of maybe moving the remainder value
    PutInt [remainder] ;to a stack then calling it at the end of the loop,
    mov [quotient], AL ;when the quotient value is zero. However,  
    mov AX, [quotient] ;I do not know enough to make that work. Any help
    cmp [quotient], byte 0 ;would be greatly appreciated
    jz binary_done ;Could also be je, as both do the same thing
    loop binary_loop

    PutStr msg3
    mov AX, [num1]
    sub BH, BH      

    push AX
    mov BH, byte 8
    div BH
    mov [remainder], AH
    PutInt [remainder]
    mov [quotient], AL
    mov AX, [quotient]
    cmp [quotient], byte 0
    jz octal_done
    loop octal_loop

    PutStr msg4
    mov AX, [num1]      
    sub BH, BH  

    push AX
    mov BH, byte 16
    div BH
    mov [remainder], AH
    PutInt [remainder]
    mov [quotient], AL
    mov AX, [quotient]
    cmp [quotient], byte 0
    jz done
    loop hex_loop



Current output for test 16-bit number 155: Binary: 11011001 Eighth: 332 Hex: 119


source to share

1 answer

There are 3 main problems in your code:

  • It displays numbers in reverse order
  • It displays hex digits as whole numbers (e.g. 0xB is displayed as 11)
  • It is very badly commented (assembly is not high level language)

There are other problems in your code as well:

  • It's inefficient to use registers (store things in slower variables instead)
  • Duplicate code - the only procedure that takes "base" as input will halve the code size
  • Violation of macros ("language within a language"); which makes the code difficult to understand (for example, I can't tell if a PutInt

    function call or inline code, or which logs its use / trashes), and makes it impossible to optimize the instructions around it correctly

For the first problem, it is best to construct the string in memory in reverse order and then print the resulting string. For the second problem, you need to stop using PutInt

- every digit needs to be converted to a character.

For example (32-bit 80x86, NASM, untested):

;Convert unsigned integer to string
; eax = integer
; ebx = base
; edi = address of string
; eax,edx

    section .bss
tempString: resb 33              ;Worst case string size is 32 digits
                                 ; (for base2), plus string terminator
    section .text

    mov byte [tempStringEnd-1],0 ;Store string terminator
    mov edi,tempStringEnd-2      ;edi = address to store last character

    xor edx,edx                  ;edx:eax = current value
    div ebx                      ;eax = new current value, edx = next digit
    add dl,'0'                   ;dl = character for next digit maybe
    cmp dl,'9'                   ;Is the character correct?
    jbe .gotChar                 ; yes
    add dl,'A'-'0'-10            ; no, fix it up
    mov [edi],dl                 ;Store the character
    dec edi                      ;edi = address for next character
    test eax,eax                 ;Is the current value zero?
    jne .nextDigit               ; no, do the next digit

    ret                          ;Done, EDI = address of completed string




All Articles