Menerapkan Konversi Digit-ke-Word dan Penanganan File di Majelis 8086

Menguasai Manipulasi File dan Transformasi Data dalam Perakitan

Bekerja dengan bahasa assembly seringkali terasa seperti memecahkan teka-teki yang rumit. 🧩 Dibutuhkan pemahaman mendalam tentang perangkat keras dan penanganan data yang efisien. Tugas umum, seperti mengubah angka menjadi kata sambil mempertahankan karakter non-digit, mungkin tampak sederhana pada pandangan pertama, namun menghadirkan tantangan unik dalam pemrograman tingkat rendah.

Misalnya, Anda mungkin ingin memproses file yang berisi angka dan karakter. Bayangkan membaca "0a" dari file masukan dan mengubahnya menjadi "nulisa" di keluaran. Mencapai hal ini dalam perakitan tidak hanya melibatkan operasi logis tetapi juga manajemen buffer yang cermat untuk mencegah masalah yang tumpang tindih.

Dalam perjalanan saya sendiri dengan assembler 8086, saya mengalami masalah serupa ketika buffer keluaran saya mulai salah menimpa karakter. Rasanya seperti mencoba membangun struktur Lego yang sempurna, hanya saja bagian-bagiannya berantakan secara acak. 🛠️ Tantangan ini memerlukan pemeriksaan cermat terhadap setiap byte yang diproses dan ditulis untuk memastikan kebenarannya.

Melalui proses debug yang cermat dan pemahaman tentang penanganan buffer, saya dapat mengatasi masalah ini. Artikel ini akan memandu Anda langkah demi langkah dalam membuat program yang menangani konversi digit ke kata dan penulisan file dengan lancar tanpa kerusakan data. Baik Anda baru memulai perakitan atau ingin menyempurnakan keterampilan Anda, contoh ini akan memberikan wawasan yang berharga.

Menguasai Konversi Digit dan Manajemen Buffer di Majelis

Tujuan utama dari skrip ini adalah untuk mengambil file masukan yang berisi campuran angka dan karakter, mengubah angka tersebut menjadi kata-kata yang sesuai, dan menulis keluaran ke file baru tanpa menimpa karakter. Proses ini melibatkan manajemen buffer yang efisien dan penanganan string yang cermat. Misalnya, jika masukan berisi "0a", skrip akan mengubahnya menjadi "nulisa" pada keluaran. Namun, bug awal dalam program, seperti penimpaan karakter di buffer, dapat membuat tugas ini menantang dan memerlukan analisis dan koreksi lebih dalam. 🛠️

Perintah kunci seperti LODSB dan STOSB sangat penting dalam menangani string. LODSB membantu memuat byte dari input ke dalam register untuk diproses, sementara STOSB memastikan bahwa byte yang diproses disimpan secara berurutan dalam buffer output. Perintah-perintah ini bekerja sama untuk mencegah masalah tumpang tindih di buffer, yang merupakan akar penyebab masalah awal. Dengan menambah pointer seperti SI dan DI setelah setiap operasi, skrip mempertahankan aliran data logis antar buffer, memastikan kebenaran output.

Skrip ini juga menggunakan CMP untuk membandingkan nilai karakter dan mengidentifikasi angka. Misalnya, ia memeriksa apakah karakter berada dalam rentang '0' hingga '9' untuk menentukan apakah konversi diperlukan. Logika ini dipasangkan dengan subrutin seperti ConvertDigitToWord, di mana operasi SHL dan ADD menghitung offset dalam array kata. Hal ini memungkinkan program untuk mengambil kata yang tepat untuk sebuah digit, seperti "nulis" untuk 0 atau "vienas" untuk 1. Subrutin ini membuat kode menjadi modular dan dapat digunakan kembali, menyederhanakan proses debug dan modifikasi lebih lanjut. 🔧

Terakhir, penanganan kesalahan memainkan peran penting dalam eksekusi program yang kuat. Perintah JC digunakan untuk melompat ke bagian penanganan kesalahan ketika operasi file gagal, seperti ketika file input tidak dapat dibuka. Ditambah dengan panggilan sistem INT 21h, skrip mengelola pembacaan dan penulisan file dengan lancar. Kombinasi penanganan file yang optimal dan transformasi data yang kuat menunjukkan kekuatan pemrograman tingkat rendah dalam memecahkan masalah dunia nyata seperti manipulasi file dan pemformatan data. Dengan mengatasi bug terkait buffering dan meningkatkan modularitas, skrip kini memberikan hasil yang akurat, bahkan untuk kasus edge.

; 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")

Mengoptimalkan Operasi File dan Konversi String di Majelis

Saat bekerja dengan perakitan, operasi file memerlukan ketelitian dan pemahaman mendalam tentang mekanisme tingkat rendah. Menangani input dan output file melibatkan penggunaan interupsi seperti INT 21 jam, yang menyediakan akses tingkat sistem ke operasi seperti membaca, menulis, dan menutup file. Misalnya, MOV ah, 3Fh adalah perintah kunci untuk membaca isi file ke dalam buffer, sedangkan MOV ah, 40 jam menulis data dari buffer ke file. Perintah-perintah ini berinteraksi langsung dengan sistem operasi, menjadikan penanganan kesalahan penting jika terjadi kegagalan akses file. 🛠️

Aspek penting lainnya adalah mengelola string secara efisien. Instruksi perakitan LODSB Dan STOSB menyederhanakan proses ini dengan mengizinkan pemuatan dan penyimpanan karakter demi karakter. Misalnya, membaca urutan seperti "0a" melibatkan penggunaan LODSB untuk memuat byte ke dalam register, lalu menerapkan kondisi untuk memeriksa apakah itu berupa digit. Jika ya, digit tersebut diganti dengan padanan kata menggunakan rutinitas konversi. Jika tidak, itu ditulis tidak berubah ke output yang menggunakan STOSB. Perintah-perintah ini mencegah kerusakan data bila dikombinasikan dengan manipulasi pointer yang hati-hati.

Manajemen buffer juga penting untuk menghindari masalah penimpaan. Dengan menginisialisasi dan menambah pointer buffer seperti SI Dan DI, program memastikan bahwa setiap byte ditulis secara berurutan. Pendekatan ini menjaga integritas data, bahkan ketika berhadapan dengan string campuran. Penanganan buffer yang efektif tidak hanya meningkatkan kinerja namun juga memastikan skalabilitas untuk input yang lebih besar. Pengoptimalan ini sangat penting dalam pemrograman perakitan, di mana setiap instruksi penting. 🔧