Implementering af ciffer-til-ord-konvertering og filhåndtering i 8086 Assembly

Mestring af filmanipulation og datatransformation i samling

At arbejde med assemblersprog kan ofte føles som at løse et indviklet puslespil. 🧩 Det kræver en dyb forståelse af hardware og effektiv datahåndtering. En almindelig opgave, såsom at konvertere cifre til ord og samtidig bevare ikke-cifrede tegn, kan virke simpel ved første øjekast, men det giver unikke udfordringer i lav-niveau programmering.

For eksempel vil du måske behandle en fil, der indeholder både cifre og tegn. Forestil dig at læse "0a" fra en inputfil og konvertere den til "nulisa" i outputtet. At opnå dette ved montering involverer ikke kun logiske operationer, men omhyggelig bufferstyring for at forhindre overlappende problemer.

På min egen rejse med 8086 assembler stødte jeg på lignende problemer, da min outputbuffer begyndte at overskrive tegn forkert. Det føltes som at prøve at bygge en perfekt Lego-struktur, blot for at få brikker til at falde fra hinanden. 🛠️ Disse udfordringer krævede en nøje inspektion af hver byte, der blev behandlet og skrevet for at sikre korrekthed.

Gennem omhyggelig debugging og forståelse af bufferhåndtering var jeg i stand til at løse disse problemer. Denne artikel vil guide dig trin-for-trin gennem oprettelse af et program, der problemfrit håndterer tal-til-ord-konvertering og filskrivning uden datakorruption. Uanset om du lige er begyndt med montering eller ønsker at forbedre dine færdigheder, vil dette eksempel give værdifuld indsigt.

Mestring af cifferkonvertering og bufferstyring i montage

Det primære mål med scriptet er at tage en inputfil, der indeholder en blanding af cifre og tegn, konvertere cifrene til tilsvarende ord og skrive outputtet til en ny fil uden at overskrive tegn. Denne proces involverer effektiv bufferstyring og omhyggelig håndtering af strenge. For eksempel, når inputtet indeholder "0a", transformerer scriptet det til "nulisa" i outputtet. Men indledende fejl i programmet, som tegn, der overskriver i bufferen, kan gøre denne opgave udfordrende og kræve dybere analyser og rettelser. 🛠️

Tastekommandoer som LODSB og STOSB er essentielle ved håndtering af strenge. LODSB hjælper med at indlæse bytes fra input til et register til behandling, mens STOSB sikrer, at behandlede bytes lagres sekventielt i outputbufferen. Disse kommandoer arbejder hånd i hånd for at forhindre overlappende problemer i bufferen, som var hovedårsagen til det oprindelige problem. Ved at øge pointere som SI og DI efter hver operation, opretholder scriptet et logisk dataflow mellem buffere, hvilket sikrer korrekthed i outputtet.

Scriptet bruger også CMP til at sammenligne tegnværdier og identificere cifre. For eksempel tjekker den, om et tegn falder inden for intervallet '0' til '9' for at afgøre, om en konvertering er nødvendig. Denne logik er parret med underrutiner som ConvertDigitToWord, hvor SHL og ADD operationer beregner offset i ordarrayet. Dette gør det muligt for programmet at hente det korrekte ord for et ciffer, såsom "nulis" for 0 eller "vienas" for 1. Disse underrutiner gør koden modulær og genbrugelig, hvilket forenkler fejlfinding og yderligere ændringer. 🔧

Endelig spiller fejlhåndtering en afgørende rolle i robust programudførelse. Kommandoen JC bruges til at springe til fejlhåndteringssektioner, når filhandlinger mislykkes, f.eks. når en inputfil ikke kan åbnes. Sammen med INT 21h systemopkald styrer scriptet fillæsning og skrivning problemfrit. Denne kombination af optimeret filhåndtering og robust datatransformation demonstrerer styrken ved lavniveauprogrammering til at løse virkelige problemer som filmanipulation og dataformatering. Ved at adressere buffer-relaterede fejl og forbedre modulariteten giver scriptet nu nøjagtige resultater, selv 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")

Optimering af filoperationer og strengkonvertering i samling

Når du arbejder med montering, kræver filoperationer præcision og en dyb forståelse af mekanismer på lavt niveau. Håndtering af filinput og -output involverer brug af interrupts som INT 21h, som giver adgang på systemniveau til handlinger såsom læsning, skrivning og lukning af filer. f.eks. MOV ah, 3Fh er en nøglekommando til at læse filindhold i en buffer, mens MOV ah, 40 timer skriver data fra en buffer til en fil. Disse kommandoer interagerer direkte med operativsystemet, hvilket gør fejlhåndtering kritisk i tilfælde af filadgangsfejl. 🛠️

Et andet væsentligt aspekt er at administrere strenge effektivt. Monteringsvejledningen LODSB og STOSB strømline denne proces ved at tillade indlæsning og lagring af tegn for tegn. For eksempel indebærer at læse en sekvens som "0a" at bruge LODSB at indlæse byten i et register, og derefter anvende betingelser for at kontrollere, om det er et ciffer. Hvis det er tilfældet, erstattes cifferet med dets ordækvivalent ved hjælp af en konverteringsrutine. Ellers skrives det uændret til outputtet vha STOSB. Disse kommandoer forhindrer datakorruption, når de kombineres med omhyggelig markørmanipulation.

Bufferstyring er også afgørende for at undgå problemer med overskrivning. Ved at initialisere og øge bufferpointere som SI og DI, sikrer programmet, at hver byte skrives sekventielt. Denne tilgang bevarer dataintegriteten, selv når der er tale om blandede strenge. Effektiv bufferhåndtering forbedrer ikke kun ydeevnen, men sikrer også skalerbarhed til større input. Disse optimeringer er afgørende i assembly programmering, hvor hver instruktion betyder noget. 🔧