Characters and Strings

In assembly language, character data is represented using ASCII (American Standard Code for Information Interchange) values, and specific instructions handle the manipulation and storage of these characters in memory.

ASCII Representation

Characters are represented by ASCII values, which are numerical codes assigned to each character. For example, the ASCII value for 'A' is 65.

; Example: Loading ASCII value of 'A' into a register MOV AL, 65 ; ASCII value for 'A'

Registers and Memory

Character data is stored in registers or memory locations, and assembly instructions like MOV are used to transfer data between them.

; Example: Storing and retrieving a character in memory MOV BYTE PTR [MemoryLocation], 'A' ; Store ASCII value of 'A' in memory MOV DL, BYTE PTR [MemoryLocation] ; Load the character from memory into DL

String Operations

Strings, which are sequences of characters, are manipulated using string-specific instructions. These include loading, storing, and comparing strings.

; Example: Loading a string into memory MOV DX, OFFSET StringExample ; DX points to the start of the string MOV AH, 09h ; Display the string using DOS interrupt INT 21h StringExample DB 'Hello, Assembly!', 0 ; Null-terminated string

Character Input/Output

Assembly language supports instructions for character input and output. For example, DOS interrupts can be used for displaying characters on the screen.

; Example: Displaying a character on the screen MOV AH, 02h ; Function to display character MOV DL, 'A' ; Character to be displayed INT 21h ; DOS interrupt

Comparison and Branching

Character data can be compared using instructions like CMP (compare) and conditional branches (e.g., JE for jump if equal).

; Example: Comparing two characters MOV AL, 'A' ; Load ASCII value of 'A' into AL MOV BL, 'B' ; Load ASCII value of 'B' into BL CMP AL, BL ; Compare the two characters JE EqualLabel ; Jump to EqualLabel if characters are equal

String Manipulation

Assembly language programmers can also use character data to implement more complex functions, such as string manipulation functions and text editors.

Here is an example of a simple assembly language function that copies a string from one memory location to another.

section .text global _start global copy_string copy_string: ; Input: Memory location of source string in 'src' ; Output: Memory location of copied string in 'dst' ; Parameters: ; src: Memory location of source string ; dst: Memory location of destination string ; Copy the first character of the source string to the destination string. mov al, [src] mov [dst], al ; Increment the source and destination pointers. inc dword [src] ; Assuming a 32-bit architecture, increment by 1 byte inc dword [dst] ; Check if the end of the string has been reached. cmp byte [src], 0 ; Compare the byte at the memory location pointed to by src jne copy_string ; Return from the function. ret _start: ; Example usage of the copy_string function ; Initialize source and destination strings mov ebx, src mov ecx, dst ; Call the copy_string function call copy_string ; Exit the program mov eax, 1 ; syscall number for exit xor ebx, ebx ; exit code 0 int 0x80 ; invoke syscall section .data src db "Hello, World!", 0 ; Null-terminated source string dst resb 20 ; Destination buffer with enough space

Above code defines a function named copy_string that copies a null-terminated string from a source memory location (src) to a destination memory location (dst). The function uses the AL register to temporarily store the current byte from the source and then stores it into the destination. It increments both the source and destination pointers, checks if the end of the string has been reached by comparing the byte at the source with 0 (null terminator), and repeats the process until the end of the string is encountered. The main section (_start) initializes source and destination strings, calls the copy_string function, and exits the program with a syscall. Note that the code assumes a 32-bit architecture and uses the x86 instruction set.


Character data is represented using ASCII values and manipulated through instructions like MOV for storage in registers or memory. Specific operations, such as string manipulation and character input/output, are facilitated by assembly language instructions tailored for handling character-based information.