Implementing Digit-to-Word Conversion and File Handling in 8086 Assembly

Mastering File Manipulation and Data Transformation in Assembly

Working with assembly language can often feel like solving an intricate puzzle. 🧩 It requires a deep understanding of hardware and efficient data handling. A common task, such as converting digits to words while maintaining non-digit characters, might seem simple at first glance, but it presents unique challenges in low-level programming.

For instance, you might want to process a file containing both digits and characters. Imagine reading "0a" from an input file and converting it into "nulisa" in the output. Achieving this in assembly involves not just logical operations but meticulous buffer management to prevent overlapping issues.

In my own journey with 8086 assembler, I encountered similar problems when my output buffer began overwriting characters incorrectly. It felt like trying to build a perfect Lego structure, only to have pieces randomly fall apart. 🛠️ These challenges required a close inspection of every byte processed and written to ensure correctness.

Through careful debugging and understanding of buffer handling, I was able to resolve these issues. This article will guide you step-by-step through creating a program that seamlessly handles digit-to-word conversion and file writing without data corruption. Whether you're just starting with assembly or looking to refine your skills, this example will offer valuable insights.

Mastering Digit Conversion and Buffer Management in Assembly

The primary goal of the script is to take an input file containing a mix of digits and characters, convert the digits into corresponding words, and write the output to a new file without overwriting characters. This process involves efficient buffer management and careful handling of strings. For example, when the input contains "0a", the script transforms it to "nulisa" in the output. However, initial bugs in the program, like characters overwriting in the buffer, can make this task challenging and require deeper analysis and corrections. 🛠️

Key commands such as LODSB and STOSB are essential in handling strings. LODSB helps load bytes from the input into a register for processing, while STOSB ensures that processed bytes are stored sequentially in the output buffer. These commands work hand-in-hand to prevent overlapping issues in the buffer, which was the root cause of the initial problem. By incrementing pointers like SI and DI after each operation, the script maintains a logical flow of data between buffers, ensuring correctness in the output.

The script also uses CMP to compare character values and identify digits. For example, it checks if a character falls within the range of '0' to '9' to determine if a conversion is needed. This logic is paired with subroutines like ConvertDigitToWord, where SHL and ADD operations calculate the offset in the word array. This allows the program to fetch the correct word for a digit, such as "nulis" for 0 or "vienas" for 1. These subroutines make the code modular and reusable, simplifying debugging and further modifications. 🔧

Finally, error handling plays a crucial role in robust program execution. The JC command is used to jump to error-handling sections when file operations fail, such as when an input file cannot be opened. Coupled with INT 21h system calls, the script manages file reads and writes seamlessly. This combination of optimized file handling and robust data transformation demonstrates the power of low-level programming in solving real-world problems like file manipulation and data formatting. By addressing buffer-related bugs and enhancing modularity, the script now provides accurate results, even for edge cases.

; Solution 1: Enhanced buffer handling and optimized digit-to-word conversion
.model small
.stack 100h
.data
    msgHelp DB "Usage: program.exe <input_file> <output_file>$"
    msgFileError DB "Error: File not found or cannot be opened.$"
    input db 200 dup (0)
    output db 200 dup (0)
    skBuf db 20 dup (?)
    raBuf db 200 dup (?)
    words db "nulis", 0, "vienas", 0, "du", 0, "trys", 0, "keturi", 0, "penki", 0, "sesi", 0, "septyni", 0, "astuoni", 0, "devyni", 0
    wordOffsets dw 0, 6, 13, 16, 21, 28, 34, 39, 47, 55
    dFail dw ?
    rFail dw ?
    raBufPos dw 0
.code
start:
    MOV ax, @data
    MOV ds, ax
    MOV di, offset raBuf
    ; Open input file
    MOV ah, 3Dh
    MOV al, 00
    MOV dx, offset input
    INT 21h
    JC file_error
    MOV dFail, ax
    ; Open output file
    MOV ah, 3Ch
    MOV cx, 0
    MOV dx, offset output
    INT 21h
    JC file_error
    MOV rFail, ax
read:
    ; Read from input
    MOV bx, dFail
    CALL ReadBuf
    CMP ax, 0
    JE closeInput
    MOV cx, ax
    MOV si, offset skBuf
processLoop:
    LODSB
    CMP al, '0'
    JB notDigit
    CMP al, '9'
    JA notDigit
    PUSH cx
    CALL ConvertDigitToWord
    POP cx
    JMP skip
notDigit:
    STOSB
    INC raBufPos
skip:
    LOOP processLoop
writeOutput:
    ; Write to output
    MOV bx, rFail
    MOV dx, offset raBuf
    MOV cx, raBufPos
    CALL WriteBuf
    MOV raBufPos, 0
    JMP read
closeOutput:
    MOV ah, 3Eh
    MOV bx, rFail
    INT 21h
closeInput:
    MOV ah, 3Eh
    MOV bx, dFail
    INT 21h
programEnd:
    MOV ah, 4Ch
    INT 21h
ConvertDigitToWord PROC
    SUB al, '0'
    MOV bx, ax
    SHL bx, 1
    ADD bx, offset wordOffsets
    MOV si, bx
    ADD si, offset words
copyWord:
    LODSB
    STOSB
    INC raBufPos
    CMP al, 0
    JNE copyWord
    RET
ConvertDigitToWord ENDP
ReadBuf PROC
    MOV ah, 3Fh
    MOV bx, dFail
    MOV dx, offset skBuf
    MOV cx, 20
    INT 21h
    RET
ReadBuf ENDP
WriteBuf PROC
    MOV ah, 40h
    MOV bx, rFail
    MOV dx, offset raBuf
    MOV cx, raBufPos
    INT 21h
    RET
WriteBuf ENDP
END start

def digit_to_word(digit):
    words = ["nulis", "vienas", "du", "trys", "keturi", "penki", "sesi", "septyni", "astuoni", "devyni"]
    return words[int(digit)] if digit.isdigit() else digit
def process_file(input_file, output_file):
    with open(input_file, 'r') as infile, open(output_file, 'w') as outfile:
        for line in infile:
            result = []
            for char in line:
                result.append(digit_to_word(char) if char.isdigit() else char)
            outfile.write("".join(result))
process_file("input.txt", "output.txt")

Optimizing File Operations and String Conversion in Assembly

When working with assembly, file operations require precision and a deep understanding of low-level mechanisms. Handling file input and output involves using interrupts like INT 21h, which provide system-level access to operations such as reading, writing, and closing files. For example, MOV ah, 3Fh is a key command for reading file contents into a buffer, while MOV ah, 40h writes data from a buffer to a file. These commands interact directly with the operating system, making error handling critical in case of file access failures. 🛠️

Another essential aspect is managing strings efficiently. The assembly instructions LODSB and STOSB streamline this process by allowing character-by-character loading and storing. For example, reading a sequence like "0a" involves using LODSB to load the byte into a register, then applying conditions to check if it's a digit. If it is, the digit is replaced with its word equivalent using a conversion routine. Otherwise, it’s written unchanged to the output using STOSB. These commands prevent data corruption when combined with careful pointer manipulation.

Buffer management is also pivotal to avoiding overwriting issues. By initializing and incrementing buffer pointers like SI and DI, the program ensures that each byte is written sequentially. This approach maintains data integrity, even when dealing with mixed strings. Effective buffer handling not only improves performance but also ensures scalability for larger inputs. These optimizations are crucial in assembly programming, where every instruction matters. 🔧