Assembly Converter bases

Question

Could someone help me, please? These are the details of the task:

You must build a binary, decimal octal decimal converter. (up to 16-bit numbers) 1 The program asks the user to select a base (H, D, O, B) 2 The program asks to enter a number in the above base. 3 If the n

umber is incorrect, an error message and a return to the beginning of the program. 4 The program will display this number in the various bases

And here is what I have done so far. Could you please check and help me fulfill the above requirements, please?

MY CODE

`DATA SEGMENT
 
 N=16
    
 START_MSG DB "WELCOME TO THE ONLINE BASE CONVERTOR:",'$' 
 
 CR  DB 10,13,'$'              
                                                                                     
 MSG DB "PLEASE ENTER YOUR BASE TO CONVERT FROM",'$'
  
 CHOOSE DB "FOR HEX='H', DEC='D', OCT='O', BIN='B'.",'$'  
 
 MSG_ENTER_NUM DB "PLEASE ENTER YOUR NUMBER:", '$'
 
 NUMBER_H DB N+1, N+2 DUP (?)   
 NUMBER_D DB N+1, N+2 DUP (?) 
 NUMBER_B DB N+1, B+2 DUP (?)
 NUMBER_O DB N+1, N+2 DUP (?)
 LEN DW 0
 START_STRING DW 2
 NUM_DEC DW 0  
 USER_CHOOSE DB ?  
 END_OF_STR DW 0
 POWER_LOOP DW 1 
 LENB DW 0
 
DATA ENDS

SSEG SEGMENT STACK
    
  DW 100 DUP (?)   
  
SSEG ENDS

CODE SEGMENT 
    
ASSUME CS:CODE,DS:DATA,SS:SSEG

START:   MOV AX, DATA
         MOV DS, AX
         
         
        MOV DX, OFFSET START_MSG
        MOV AH, 9
        INT 21H
                 
        MOV DX, OFFSET CR
        MOV AH, 9
        INT 21H 
        
        MOV DX, OFFSET MSG
        MOV AH, 9
        INT 21H 
        
        MOV DX, OFFSET CR
        MOV AH, 9
        INT 21H 
        
        MOV DX, OFFSET CHOOSE
        MOV AH, 9
        INT 21H   
        
        MOV DX, OFFSET CR
        MOV AH, 9
        INT 21H
        
        MOV AH, 1
        INT 21H
        MOV USER_CHOOSE, AL
        
        MOV DX, OFFSET CR
        MOV AH, 9
        INT 21H 
        
        MOV DX, OFFSET MSG_ENTER_NUM
        MOV AH, 9
        INT 21H   
        
        MOV DX, OFFSET CR
        MOV AH, 9
        INT 21H
        
        
        CMP USER_CHOOSE, 72 ; ASCII for H
        JE HEX
        
        CMP USER_CHOOSE, 66 ; ASCII for B 
        JE BINARY  
        
        CMP USER_CHOOSE, 68 ; ASCII for D
        JE DECIMAL   
          
        CMP USER_CHOOSE, 79 ; ASCII for O
        JE OCT   
        
        
HEX:   
     LEA DX, NUMBER_H
     MOV AH, 0AH
     INT 21H 
            
     MOV SI, 2       
       
COUNT_LEN:   
    
    CMP NUMBER_H[SI], 0DH 
    JE CONTT
    INC LEN
    INC SI
    JMP COUNT_LEN  
              
              
CONTT:           
    MOV CX, LEN                                            
    MOV SI, START_STRING
    MOV END_OF_STR, CX
    INC END_OF_STR
    MOV DI, END_OF_STR

FROM_CHAR_TO_HEX_NUM:   

    CMP NUMBER_H[SI], 41H
    JNB CONVERT_LATTERS
        
    AND NUMBER_H[SI], 0FH   ; Convert ASCII character to hexadecimal digit
    CMP NUMBER_H[SI], 9
    INC SI                  
    LOOP FROM_CHAR_TO_HEX_NUM 
    MOV CX, LEN 
    MOV POWER_LOOP,CX 
    ADD POWER_LOOP,1
    MOV SI, START_STRING
    ;; MOV SI, LEN
 
    JMP CHANGE_TO_DEC
        
CONVERT_LATTERS:             
    AND NUMBER_H[SI], 0FH
    ADD NUMBER_H[SI], 9     ; ADJUST FOR LETTERS A-F
    JMP FROM_CHAR_TO_HEX_NUM                    
               
CHANGE_TO_DEC:  
    XOR AX, AX  
    MOV AL, NUMBER_H[SI] 
    MOV BL, 16
    DEC POWER_LOOP
    MOV CX, POWER_LOOP  ; Initialize CX with LEN
    CMP SI, DI
    JE ADD_TO_DEC1
               
    ;MOV CX, SI
    DEC CX
    MOV BX, 16
    MOV AX, 1

POWER:  
    MUL BX 
    LOOP POWER
    JMP ADD_TO_DEC

ADD_TO_DEC:
    MOV BL, NUMBER_H[SI]
    MUL BX
    ADD NUM_DEC, AX
    CMP NUMBER_H[SI], 0DH 
    JE BINARY
    INC SI
    JMP CHANGE_TO_DEC 
           
ADD_TO_DEC1:
    MOV AL, NUMBER_H[DI] 
    MOV BL, 1
    MUL BL 
    ADD NUM_DEC, AX 
    DEC DI  
    INC SI              
    JMP CHANGE_BIN 
    
    
CHANGE_BIN:
   MOV SI, START_STRING
   XOR AX, AX
   XOR BX, BX

   MOV AX, NUM_DEC
   MOV BL, 2

DIVIDE:
   DIV BX
   MOV NUMBER_B[SI], DL
   ADD NUMBER_B[SI],30H
   INC SI
   CMP AL, 1
   JNE DIVIDE
           
BINARY:
    MOV NUMBER_B[SI], 31H
    MOV SI,2 
    
COUNT_LEN1:    
    CMP NUMBER_B[SI], 0     
    JE CONTT1
    INC LENB
    INC SI
    JMP COUNT_LEN1 
     
CONTT1:                                       
    LEA DX, NUMBER_B
    MOV AH, 0AH
    INT 21H
    JMP CONTINUE
                                                
DECIMAL:
    LEA DX, NUMBER_D
    MOV AH, 0AH
    INT 21H
    JMP CONTINUE    

OCT: 
    LEA DX, NUMBER_O
    MOV AH, 0AH
    INT 21;kH
    JMP CONTINUE
  
CONTINUE:               
                         
    
EXIT:
    MOV AH, 4CH
    INT 21H   

CODE ENDS
END START
`

I TRY THIS AND THE DIVIDE NOT WORK WELL WITH A FOUR DIGIT NUMBER AND I LOSE MY WAY DONT KNOW HOW TO CONTINUE

Welcome to the site. Please ask a more focused question. Asking to generally check and improve your program is too broad. Your last sentence seems to ask about a specific bug, which would make a better question, but you will need to give more details. What is a specific four-digit number that causes the problem, and what exactly happens when you try it? — Nate Eldredge, Jul 02 '23 at 17:10
binary to hex: [Converting bin to hex in assembly](https://stackoverflow.com/q/40818086) works for 16-bit numbers, using 16-bit code. See also [How to convert a binary integer number to a hex string?](https://stackoverflow.com/q/53823756) and [How do I print an integer in Assembly Level Programming without printf from the c library? (itoa, integer to decimal ASCII string)](https://stackoverflow.com/a/46301894) for general stuff about the algorithms (and 32-bit and 64-bit code examples, some of which translate easily to 16-bit.) — Peter Cordes, Jul 02 '23 at 17:48

hs takeuchi · Answer 1 · 2023-07-02T21:41:45.433

0

I TRY THIS AND THE DIVIDE NOT WORK WELL WITH A FOUR DIGIT NUMBER AND I LOSE MY WAY DONT KNOW HOW TO CONTINUE

You did not set DX to 0 before dividing. Use XOR DX,DX before the DIV BX. DX must contain the correct upper 16 bits of the 32-bit dividend.

edited Jul 02 '23 at 21:41

answered Jul 02 '23 at 18:09

hs takeuchi

126
3

Use `xor dx,dx` before `div` (zero-extend AX into DX:AX), or `cwd` before 16-bit `idiv` (sign-extend AX into DX:AX). If that's the only bug in the question, it's a duplicate of [Why should EDX be 0 before using the DIV instruction?](https://stackoverflow.com/q/38416593) – Peter Cordes Jul 02 '23 at 18:12
Oops. Should I edit that? – hs takeuchi Jul 02 '23 at 18:45
Yes, editing to improve your answers is always a good thing. – Peter Cordes Jul 02 '23 at 19:48
I try this and its still give a wrong answer – Jack Jul 02 '23 at 20:20
Fixed the answer. – hs takeuchi Jul 02 '23 at 21:45
1

If you zeroed DX then you also have problems elsewhere. – hs takeuchi Jul 02 '23 at 21:46
its become when i divided by 2 to get the remain for the binary number then after two time divide the resulet not good – Jack Jul 03 '23 at 05:43
FOR EXAMPLE I DIVIDED ABCD/2 THE FIRST TIME ITS CORRECR GIVE ME RESULT IN AX OF 55E6 AFTER THAT I DIVIDE AGAIN 55E6/2 AND INSTED OF GET THE RIGHT RESULT 2AF3 I GOT AAF3 – Jack Jul 03 '23 at 06:54
That’s why you need to zero DX with xor dx,dx. You’ve got a remainder in DX of 1 and you are dividing 0001 55E6 (combined DX and AX) by 2, which is AAF3. – hs takeuchi Jul 04 '23 at 13:28

Assembly Converter bases

1 Answers1