Sorting by Functions in Assembly Language

; Sometimes we'll want to sort a collection by something
; other than its natural order. For example, suppose we
; wanted to sort strings by their length instead of
; alphabetically. Here's an example of custom sorts
; in Assembly Language.

section .data
    fruits db "peach", 0, "banana", 0, "kiwi", 0
    fruits_len equ $ - fruits
    fmt db "%s", 10, 0

section .bss
    sorted_fruits resb fruits_len

section .text
    global _start
    extern printf

_start:
    ; We implement a comparison function for string
    ; lengths. We'll use this in our bubble sort routine.
    mov esi, fruits
    mov edi, sorted_fruits
    mov ecx, 3  ; number of strings
    call bubble_sort

    ; Print the sorted fruits
    mov esi, sorted_fruits
    mov ecx, 3
print_loop:
    push ecx
    push esi
    push fmt
    call printf
    add esp, 8
    pop ecx
    loop print_loop

    ; Exit the program
    mov eax, 1
    xor ebx, ebx
    int 0x80

; Bubble sort implementation
bubble_sort:
    push ebp
    mov ebp, esp
    push esi
    push edi
    push ecx

outer_loop:
    mov edx, ecx
    dec edx
    mov esi, [ebp + 8]  ; fruits array
inner_loop:
    mov edi, esi
    add edi, [esi]  ; next string
    push esi
    push edi
    call compare_lengths
    add esp, 8
    test eax, eax
    jle no_swap
    ; Swap the strings
    xchg [esi], [edi]
no_swap:
    add esi, 4
    dec edx
    jnz inner_loop
    loop outer_loop

    pop ecx
    pop edi
    pop esi
    pop ebp
    ret

; Compare lengths of two null-terminated strings
compare_lengths:
    push ebp
    mov ebp, esp
    mov esi, [ebp + 8]  ; first string
    mov edi, [ebp + 12] ; second string
    xor eax, eax
    xor ebx, ebx
count_loop1:
    lodsb
    test al, al
    jz done_count1
    inc eax
    jmp count_loop1
done_count1:
count_loop2:
    mov al, [edi]
    test al, al
    jz done_count2
    inc ebx
    inc edi
    jmp count_loop2
done_count2:
    sub eax, ebx
    pop ebp
    ret

; Note: This assembly code provides a simplified version of the sorting
; functionality. It sorts an array of string pointers based on string length.
; The code assumes a simplified memory model and doesn't include error handling
; or more advanced features that would be present in a full implementation.

This Assembly Language code demonstrates a basic implementation of sorting strings by their length. Here’s a breakdown of what the code does:

We define an array of strings (fruits) in the data section.
In the _start function, we call our bubble_sort routine to sort the strings.
The bubble_sort function implements a simple bubble sort algorithm, comparing adjacent strings and swapping them if they’re in the wrong order.
The compare_lengths function is used to compare the lengths of two strings. It’s called by the bubble sort routine to determine the order of strings.
After sorting, we print the sorted strings using the printf function.

This assembly code provides a low-level implementation of custom sorting. It’s worth noting that assembly language doesn’t have high-level constructs like slices or built-in sorting functions, so we have to implement these algorithms manually.

In a real-world scenario, you’d typically use higher-level languages for tasks like this, as they provide more abstraction and built-in functions for sorting and other complex operations. Assembly is usually reserved for performance-critical sections of code or when direct hardware manipulation is necessary.

Sorting in Assembly Language

Panic in Assembly Language

Learn X By Example

Title here

Sorting by Functions in Assembly Language