;;============================================================================
;;
;;	puthex8 will do the conversion of a unsigned byte from binary to
;;      hex characters.  Two subprograms are used.  One is to convert a
;;      nybble to a hex character and is invoked twice, once for each nybble.
;;      This improves the version in Lecture 06, but we still have the limitation
;;      that this only works with a single byte.  The solution to that part
;;      will be covered when we get to arrays.
;;
;;============================================================================

section .data
hex	DW	0
	DB	10
prompt  DB      'Enter a number in the range of 0 - 255: ', 0
input	DB	'%d',0

section .bss
inbyte	resd	1		;  scanf will get an int

section .text
    global main                       ;must be declared for linker (ld)
    extern scanf
    extern printf

main:                                 ;tell linker entry point

;; We need a clean eax register
	mov	eax, 0
	
;; Get the value to convert
	push	prompt
	call	printf
	add	esp, 4

	push	inbyte
	push	input
	call	scanf			; scanf will but the value into binary for us.
	add	esp, 8

;; 
	mov 	al, byte [ inbyte ]     ; the number must fit into a single byte

;;	
	call    mkhex8
	mov	[hex], ax

;;
;;	getting fancy here, explain:
;;      We have the most significant nybble in the lower half of AX.
;;      When that gets transferred to memory, the two bytes will be reverse,
;;      because things are stored in little-endian format.  I have also
;;      put a CR in the following byte, so I don't have to write additional code to
;;      output the newline if it piggy-backs along, so I output one more byte.
;;
	mov	edx, 3                        
	mov	ecx, hex
	mov	ebx, 1
	mov	eax, 4
	int	80h	


;; The final part of the program must be a call to the operating system to exit
;; the program.
        mov     ebx,0   ;successful termination of program
        mov     eax,1   ;system call number (sys_exit)
        int     0x80    ;call kernel

;;============================================================================
;;
;; Analysis:  
;;      input:        AL holds a byte to convert to two hex digits
;;      output:       AL holds the high hex character
;;                    AH holds the low hex character
;;      formula:      Get the high nybble and put it into the low nybble.
;;                    convert using mkHex.
;; 		      Get the low nybble and convert it.
;;                    Store in memory in output order.
;;      constraints:  Number must be in the range of 0 to 255.
;;      assumptions:  No negative numbers will be attempted.
;;                    No range checking is necessary, because by definition
;;                    AL can only hold the proper values.
;;
;;============================================================================

mkhex8:
	push	cx		; Play nice and no not affect any register	
	push	dx		; except AX to return the results.

	push	ax
	and	al, 0F0h        ; Clear out the bottom four bits
	mov	cl, 4           ; Adjust the upper nybble so it is in bits 0-3
	shr	ax, cl
	call	mkHex
	mov	dl, al          ; Save it until the other character is converted.

;; Now we need to get back the original value and convert the bottom nybble.
	pop	ax
	and	al, 0Fh

	call	mkHex

;; Now set up to return the two characters, but put them into reverse order first.

	mov	ah, al
	mov	al, dl

	pop	dx		; Clean up your mess!
	pop	cx

	ret

;;============================================================================
;;
;; Analysis:  
;;      input:        AL holds the four bits that will be converted
;;                    to a single hex character 
;;      output:       AL holds the hex character
;;      formula:      0 becomes '0', the difference from zero is added to '0'
;;                    to get the hex digit.  Howver, there is a gap of
;;                    seven between '9' and 'A' that must be accounted for.
;;      constraints:  None
;;      assumptions:  AL holds a value for 0 to 15.
;;                    No output will be done in the subprogram
;;
;;============================================================================

mkHex:
;; The conversion algorithm starts here.

	cmp	al, 10                  ; Is this a digit or letter?
	jl	OK1
	add	al, 7                   ; There is a gap in the ASCII table to account for
OK1:
	add	al, '0'                 ; Convert to a hex character
	ret

©2004, Gary L. Burt