如何将4位十六进制数字转换为带负数的二进制补码

Question

How can I convert a 4 digit hex number into Two's complement with neg

I want to input a 4 digit hex number, if it is negative, it will be switched to positive, and then I want to use two complement technique to find the result.

For example, if I input F520h , the output will be -F520h = 0AE0h

The problem is, when I input the 4 digits, it is in ASCII, how can I determine if it is a digit or a number without checking 0-9, AF..

Answer 1

Things you should understand to be prepared to design code for this:

How input "string" is stored in memory ( "F520h" are at least 5 bytes, maybe more, with some terminator value appended after) - depends on the method how you read input from user, consult the used API documentation.

What is ASCII table, ie how to convert single character [0-9A-Fa-f] to value 0 - 15 . Hint: if you examine closely encoding of 'a' and 'A' , you may find out way how to convert them into value 10 with one sub (or add ) and and (working for other letters too). Turning character '0' into value 0 is even easier.

How to build 16 bit value from four 0-15 (4 bit) values. Hint: 4 * 4 bits = 16 bits, so this can be achieved by bit manipulating operations only, without any multiply/divide math involved.

How to test if value is negative (probably the CPU already has "SF" flag set for you after that 16b value build last instruction, so all you need is js instruction then.

How to negate the 16b value... x86 has neg instruction .

How to output the resulting number:

Will require you to break 16 bit value into four 4b values (again bitwise operations should be enough, like and and shr instructions doing the most of the job).

Turn those 0 - 15 4 bit values values back into ASCII characters (so again understanding ASCII encoding should help).

Create output string from those characters in required format for your output API call (will probably require some terminator value at end, or exact length of string to output).

---

If you don't know anything about Assembly, this may be quite complex to write correctly in form of instructions and will take few days probably.

Although on algorithm side it's quite simple (the complexity is hidden more in the amount of work to be done), I would expect you can "see" the math behind each of the points I listed. And those steps are listed in order somewhat related to the algorithm I have on my mind.

Make sure you have first the idea how to calculate the output from the input on the theoretical level (algorithm), describe that in very simple steps involving only basic numerical operations (check overview of 8086 CPU ASM instructions to get idea what kind of operation is "basic" enough for the CPU and how it can manipulate numbers/bits).

Then you can focus how to achieve each step with few x86 instructions.

There're also many questions on stack overflow regarding particular steps you will encounter, like how to print hexadecimal value, etc, so you may check those for ideas (just make sure the target platform of answer is same as yours, or understand the idea behind the answer, so you can write it on your own).

---

EDIT: BTW, this task has another major way how to solve it, as you only need to negate ASCII encoded hexadecimal number, you don't even need it to convert it to numerical value, it's possible to patch the ASCII characters themselves to produce the neg result. Although neg is a bit tricky (but doable). I recall doing this for xor (in C++, but this compiles almost 1:1 to ASM instructions), when the high performance was required and conversion to number and back to string was too costly.

But if you are trying to learn Assembly, it's probably better to do it in the first way, so you can learn and understand all those conversions and how hexadecimal numbers can be converted between string<->value in assembly.

Answer 2

Next code does the job : user enters a hex number (up to 4 digits, example "F520") as string, converts the string to number in ax , neg is applied to ax , the result is converted back to hex string and displayed (example "0AE0"), you just copy-paste it and run it :

.model small
.stack 100h
.data

msg1 db 10,13,10,13,'ENTER 1 TO 4 HEX DIGITS:$'
msg2 db 10,13,'NEG IS:$'
msg3 db 10,13,10,13,'DO YOU WANT TO DO IT AGAIN (Y/N)?$'
msg4 db 10,13,'ILLEGAL CHARACTER- ENTER 0-9 OR A-F:$'

hex  db 5,?,5 dup(?) ;VARIABLE WITH 3 SECTIONS.
buffer  db '0000$'

.code
  mov  ax, @data
  mov  ds, ax

again:

;CLEAR BUFFER (IN CASE IT HOLDS PREVIOUS RESULT).
  call clear_buffer

;DISPLAY 'ENTER 1 TO 4 HEX DIGITS:$'
  mov  ah, 9
  lea  dx, msg1
  int  21h

;CAPTURE HEX NUMBER AS STRING.
  mov  ah, 0ah
  lea  dx, hex
  int  21h

;CONVERT HEX-STRING TO NUMBER.
  lea  si, hex+2        ;CHARS OF THE HEX-STRING.
  mov  bh, [si-1]       ;SECOND BYTE IS LENGTH.
  call hex2number       ;NUMBER RETURNS IN AX.

  neg  ax

;CONVERT NUMBER BACK TO HEX-STRING TO DISPLAY.
  lea  si, buffer
  call number2hex       ;STRING RETURNS IN SI (BUFFER).

;DISPLAY 'NEG IS :$'
  mov  ah, 9
  lea  dx, msg2
  int  21h            

;DISPLAY NUMBER AS STRING.
  mov  ah, 9
  lea  dx, buffer
  int  21h

illegal: ;JUMP HERE WHEN INVALID CHARACTER FOUND.

;DISPLAY 'DO YOU WANT TO DO IT AGAIN (Y/N)?$' 
  mov  ah, 9
  lea  dx, msg3
  int  21h

;CAPTURE KEY.
  mov  ah, 1
  int  21h
  cmp  al,'y'
  je   again
  cmp  al,'Y'
  je   again

;TERMINATE PROGRAM.  
  mov  ax, 4c00h
  int  21h 

;---------------------------------------------  
;FILL VARIABLE "BUFFER" WITH "0".
;EVERYTIME THE USER WANTS TO DO IT AGAIN, THE
;PREVIOUS RESULT MUST BE CLEARED.

clear_buffer proc
  lea  si, buffer
  mov  al, '0'
  mov  cx, 4  
clearing:
  mov  [si], al
  inc  si
  loop clearing

  ret
clear_buffer endp

;---------------------------------------------  
;INPUT  : BH = STRING LENGTH (1..4).
;         SI = OFFSET HEX-STRING.
;OUTPUT : AX = NUMBER.

hex2number proc
      MOV  AX, 0       ;THE NUMBER.
   Ciclo:
;---------------------------------------------
;     SHL  AX, 4       ;SHIFT LEFT LOWER 4 BITS.
;SHIFT LEFT AL AND AH MANUALLY 4 TIMES TO SIMULATE SHL AX,4.
      shl  al, 1
      rcl  ah, 1
      shl  al, 1
      rcl  ah, 1
      shl  al, 1
      rcl  ah, 1
      shl  al, 1
      rcl  ah, 1
;---------------------------------------------

      MOV  BL, [ SI ]  ;GET ONE HEX CHAR FROM STRING.

      call validate

      CMP  BL, 'A'     ;BL = 'A'..'F' : LETTER.
      JAE  letterAF    ;BL = '0'..'9' : DIGIT.
   ;CharIsDigit09.
      SUB  BL, 48      ;CONVERT DIGIT TO NUMBER.
      JMP  continue   
   letterAF:               
      SUB  BL, 55      ;CONVERT LETTER TO NUMBER.
   continue: 
      OR   AL, BL      ;CLEAR UPPER 4 BITS.
      INC  SI          ;NEXT HEX CHAR.
      DEC  BH          ;BH == 0 : FINISH.
      JNZ  Ciclo       ;BH != 0 : REPEAT.
   Fin:
      RET
hex2number endp

;---------------------------------------------  
;INPUT : BL = HEX CHAR TO VALIDATE.

validate proc
    cmp bl, '0'
    jb  error     ;IF BL < '0'
    cmp bl, 'F'
    ja  error     ;IF BL > 'F'
    cmp bl, '9'
    jbe ok        ;IF BL <= '9'
    cmp bl, 'A'
    jae ok        ;IF BL >= 'A'
error:    
    pop  ax       ;REMOVE CALL VALIDATE.
    pop  ax       ;REMOVE CALL HEX2NUMBER.
;DISPLAY 'ILLEGAL CHARACTER- ENTER 0-9 OR A-F$'
    mov  ah, 9
    lea  dx, msg4
    int  21h
    jmp  illegal  ;GO TO 'DO YOU WANT TO DO IT AGAIN (Y/N)?$'
ok:    
    ret
validate endp

;---------------------------------------------  
;INPUT : AX = NUMBER TO CONVERT TO DECIMAL.
;        SI = OFFSET STRING TO STORE THE HEX CHARS.
;ALGORITHM : EXTRACT LOWEST 4 BITS OF AX, CON-
;VERT THEM IN HEX DIGIT, SHIFT RIGHT AX 4 BITS, 
;REPEAT THE PROCESS 3 MORE TIMES (BECAUSE AX
;CONTAINS 4 GROUPS OF 4 BITS, EACH GROUP IS ONE
;HEX CHAR.

number2hex proc
  add  si, 3
n2h:     
;GET 4 BITS FROM AX.
  mov  bl, al        ;GET LOWEST 4 BITS OF AX.
  and  bl, 00001111b ;ISOLATE LOWER 4 BITS.
  shr  ax, 4         ;GET RID OF THOSE 4 BITS.
;CONVERT 4 BITS TO HEX CHAR.  
  cmp  bl, 9
  ja   letter                                 
  add  bl, 48        ;CONVERT TO DIGIT 0..9.  
  jmp  skip_letter
letter:
  add  bl, 55        ;CONVERT TO LETTER A..F.  
skip_letter:
  mov  [si], bl
  dec  si
  cmp  ax, 0
  jne  n2h

  ret
number2hex endp  

;------------------------------------------

end