; ========================================================================================
; ASCIItoHEX.asm - ASCII Hexadecimal String to 32-bit Hexadecimal Conversion
; ========================================================================================
; This program converts an ASCII string representing hexadecimal digits into a
; 32-bit hexadecimal value. It processes each ASCII character, converts it to
; its corresponding 4-bit hexadecimal value, and builds the final 32-bit result
; by shifting and ORing each nibble into place.

	AREA RESET, DATA, READONLY        ; Define a read-only data section for the vector table
	EXPORT __Vectors                  ; Export the vector table for external linking

__Vectors                             ; Start of the vector table
	DCD 0x10001000                    ; Stack pointer initial value (points to top of stack)
	DCD Reset_Handler                 ; Address of the reset handler (program entry point)
	ALIGN                             ; Ensure proper alignment for the next section

	AREA MYCODE, CODE, READONLY       ; Define the code section as read-only
	ENTRY                             ; Mark the entry point of the program
	EXPORT Reset_Handler             ; Export the reset handler function

; ========================================================================================
; Reset_Handler - Main program execution
; ========================================================================================
; Algorithm Overview:
; 1. Initialize pointers to source ASCII string and destination for result
; 2. Initialize result accumulator (R1) to 0
; 3. Process 8 characters (for 32-bit result) in a loop
; 4. For each character:
;    a. Load ASCII character (byte)
;    b. Check if it's A-F (greater than '9')
;    c. Convert ASCII digit to 4-bit hexadecimal value
;    d. Shift current result left by 4 bits
;    e. OR the new nibble into the result
; 5. Store the final 32-bit hexadecimal value

Reset_Handler
	; Step 1: Initialize pointers and variables
	; R0 points to the ASCII string source
	LDR R0, =SRC                      ; R0 = address of ASCII string

	; R3 points to the destination for the result
	LDR R3, =DST                      ; R3 = address of result storage

	; Initialize result accumulator to 0
	MOV R1, #0                        ; R1 = 0 (will hold the final 32-bit result)

	; Set loop counter for 8 characters (8 nibbles = 32 bits)
	MOV R10, #8                       ; R10 = 8 (number of characters to process)

	; Step 2: Main conversion loop
UP
	; Load the next ASCII character (byte) from the string
	; Post-increment addressing advances R0 to next character
	LDRB R2, [R0], #1                 ; Load byte from [R0] into R2, then R0 = R0 + 1

	; Check if the character is a letter (A-F) or digit (0-9)
	; Compare with '9' (ASCII 57) - if R2 <= '9', it's a digit
	CMP R1, #'9'                      ; Compare R1 with ASCII '9' (Note: should be CMP R2, #'9')
	BCC DOWN                          ; If R2 < '9', branch to DOWN (digit 0-9)

	; Handle A-F characters (subtract 7 to convert A-F to 10-15)
	SUB R2, #7                        ; R2 = R2 - 7 (converts 'A' to 10, 'B' to 11, etc.)

DOWN
	; Convert ASCII digit to actual hexadecimal value
	; Subtract ASCII '0' (0x30) to convert '0'-'9' to 0-9
	SUB R2, #0x30                     ; R2 = R2 - 0x30 (ASCII to numeric conversion)

	; Shift the current result left by 4 bits to make room for new nibble
	LSL R1, #4                        ; R1 = R1 << 4 (shift left by 4 bits)

	; OR the new 4-bit value into the result
	ORR R1, R1, R2                    ; R1 = R1 | R2 (insert new nibble)

	; Decrement loop counter and set condition flags
	SUBS R10, #1                      ; R10 = R10 - 1, set flags for branch condition

	; Branch back to UP if counter is not zero
	BNE UP                            ; If R10 != 0, continue loop

	; Step 3: Store the final result
	; Store the 32-bit hexadecimal value to destination
	STR R1, [R3]                      ; Store R1 (final result) to [R3]

; ========================================================================================
; Data Section - ASCII Source String and Result Storage
; ========================================================================================
; SRC contains ASCII string "12AB34CF" (8 characters)
; Each character represents a hexadecimal digit:
; '1','2' -> digits 0-9
; 'A','B','C','F' -> digits 10-15
; The string will be converted to: 0x12AB34CF
SRC DCB "12AB34CF"                    ; ASCII string to be converted

	AREA mydata, DATA, READWRITE      ; Define a read-write data section

; DST - Storage for the final 32-bit hexadecimal result
DST DCD 0                             ; Space for the converted result

	END                               ; End of the assembly program