Assembler példaprogramok
 Készítette: Molnár Dávid (dimitrij)
 E-mail: mdavid626@gmail.com
 2008-05
 All rights reserved
 A fordításhoz


Program 01Írjon programot a téglatest térfogatának kiszámítására. A téglatest oldalainak hosszát kérje be a billentyűzetről, az eredményt pedig jelenítse meg a képernyőn. Az eredmény férjen bele 2 bájtba.Letöltés
Program 02Írjon programot a kocka felületének kiszámítására. A kocka oldalát kérje be a billentyűzetről, az ererdményt jelentítse meg a számítógép monitorán. Az eredmény férjen bele 2 bájtba.Letöltés
Program 03Írjon programot a kocka térfogatának a kiszámítására. A kocka oldalának hosszát kérje be a billentyűzetről, az eredményt jelenítse meg a képernyőn. Az eredmény férjen bele 2 bájtba.Letöltés
Program 04Írjon programot két hatjegyű billentyűzetről beadott BCD szám összeadására. Az eredményt (BCD szám) jelenítse meg a számítógép monitorán.Letöltés
Program 05Íjon programot, amely megjelenít a képernyő monitorán egy négyjegyű dekadikus számlálót, amely 0-tól 9999-ig számol. Az ESC lenyomására a program végetér.Letöltés
Program 06Írjatok programot 3 maximálisan kétjegyű szám beolvasására a billentyűzetről, és a megjelenítésükre a monitoron a legkisebbtől a legnagyobbig.Letöltés
Program 07Írjon programot, amely a beadott értékek halmazából kiválasztja a páros számokat, megjeleníti őket, és megjeleníti a mennyiségüket is. Jelentítse meg a beadott halmazt, amely 10 maximálisan kétjegyű egész számokból tartalmaz.Letöltés
Program 08Írjon programot, amely a beadott értékek halmazából kiválasztja a páros számokat, megjeleníti őket, és megjeleníti a mennyiségüket is. Jelentítse meg a beadott halmazt, amely 10 maximálisan kétjegyű egész számokból tartalmaz.Letöltés
Program 09Írjon programot, amely a beadott értékek halmazát rendezi kisebbtől a nagyobbig. Jelenítse meg a beadott halmazt, amely 10 maximálisan kétjegyű egész számokból áll.Letöltés
Program 10Írjon programot, amely beadott értékek halmazát rendezi nagyobbtól a kisebbig, és megjeleníti őket a képernyőn. Jelenítse meg a beadott halmazt is, amely 10 maximálisan kétjegyű egész számot tartalmaz.Letöltés
Program 11Írjon programot szöveges állomány létrehozására a lemezen, és a megtöltésére a bill. beadott karakterekkel. A tevékenység befejező karakterének az ESC bill. válassza. Megjegyzés: a vezérlő billentyűket, nyilakat és a Backspace bill. ignorálja!Letöltés
Program 12Írjon programot a szöveges állományok megjelenítésére a képernyőn. Az állomány nevét kérje be a billentyűzetről. Ha a megadott állomány nem létezik, jelenítsen meg hibaüzenetet: "A megadott állomány nem létezik!". A képernyő betelésekor az utolsó sorban jelenítse meg: "Üss le egy billentyűt a folytatáshoz...".Letöltés
Program 13Írjon programot, ami kitöröli az aktuális mappából az összes fájlt, amely régebbi mint a billentyűzetről megadott dátum.Letöltés
Program 14Írjon programot, amely szöveges állományt bővíti egy a billentyűzetről beadott sorral. A fájl nevét kérje be a billentyűzetről. Ha nem létezik, akkor jelenítsen meg hibaüzenetet.Letöltés
Program 15Írjon programot, amely megjeleníti a leütött billentyű hexadecimális és decimális kódját.Letöltés
Program 16Írjon programot, amely kinyomtat egy állományt. Az állomány nevét kérje be a billentyűzetről.Letöltés
Program 17Írjon programot, amely átnevez egy állományt. Az állomány régi és új nevét kérje be a billentyűzetről.Letöltés
Program 18>Írjon programot, amely megjeleníti a billentyűzetről megadott számú kiszolgáló alprogram logikai címét hexadecimálisan és dekadikusan.Letöltés
Program 19>Írjon programot, amely az aktuális mappában létrehoz egy mappát a bill. megadott névvel, és az aktuális könyvtárrá teszi.Letöltés
Program 20Írjon programot, amely az aktuális könyvtárban létrehoz egy állományt a könyvtárban levő állományok nevével.Letöltés
Program 21Írjon programot, amely a billentyűzetről karaktereket olvas be, és megjeleníti őket a képernyőn. A program az end szó beírásával ér véget, de ez a szó már nem jelenik meg a képernyőn.Letöltés
Program 22Írjon programot, amely szöveges állományt másol a képernyőre (a nevét a bill. adjuk meg) úgy, hogy minden Laci szót lecserél Péter-re. Az egyes szavak egymástól SP, HT, CR és LF karakterekkel vannak elválasztva.Letöltés
Program 23Írjon programot, amely a képernyőre másolja a szöveges állományt, melynek nevét a bil. adjuk meg, úgy, hogy minden Laci szavat áláhúz. Az egyes szavak SP, HT, CR és LF karakterekkel vannak elválasztva.Letöltés
Program 24Írjon programot, amely megszámolja az aktuális könyvtárban levő fájlokat, az eredményt pedig kiírja a képernyőre.Letöltés
Program 25Írjon programot, amely kiírja a képernyőre az összes állományt az aktuális mappából, amely megfelelnek a bill. megadott maszknak.Letöltés
Program 26Írjon programot, amely elkészíti két fájl "összegét". A két forrásfájl ill. a célfájl nevét kérje be a billentyűzetről.Letöltés
Program 27Írjon programot, amely megszámolja a Jani szavakat a szöveges állományban, és megjeleníti ezt a mennyiséget a képernyőn. Az egyes szavak SP, HT, CR és LF karakterekkel vannak elválasztva. Az állomány nevét kérje be a billentyűzetről, és hiba esetén jelenítsen meg hibaüzenetet.Letöltés
Program 28Írjon programot, amely kiírja az aktuális mappából azokat az állományokat, amelyek mérete nagyobb mint a bill. megadott érték.Letöltés
Program 29Írjon programot, amely bekér a bill. 3 kétjegyű egész számot, és ezeket megjeleníti a képernyőn a legnagyobbtól a legkisebbig.Letöltés
Program 30Írjon programot, amely megállapítja az aktuális dátumot, hozzáad egy napot, és lecseréli az aktuális dátumot erre az újra. Kiírja a régi és az új dátumokat is.Letöltés



;Program 01

01.zip 01.exe 01.asm

;Írjon programot a téglatest térfogatának kiszámítására. A téglatest oldalainak hosszát kérje be a billentyűzetről, az eredményt pedig jelenítse meg a képernyőn. Az eredmény férjen bele 2 bájtba.

code segment ;code nevű szegmens létrehozása
assume cs:code,ds:code ;hozzárendelés

;változók
text1 db 'A teglatest terfogatanak kiszamitasa.'
db 13,10,'Add meg az oldalakat (max. 40 mindegyik):$'
text2 db '. oldal: $'
text3 db 13,10,'A teglatest terfogata: $'
text4 db 13,10,'Nyomj le barmilyen billentyut a kilepeshez...$'
hibauz1 db 13,10,'Mondom, hogy negyvenig! Ember, nem erted?$'
newline db 13,10,36 ;új sor írására
buffer db 3,0,3 dup(0) ;ebbe olvassuk be a számot
buffer_save db 3 dup(0) ;ide pedig elmentjük
szemafor db ? ;binascii használja
index dw ? ;indexeljük a buffer_save-t

;macro stringek kiírására
kiir macro text ;text az egyetlen paraméter
mov ah,9 ;a 9-es DOS szolgáltatással írjuk ki a stringet
mov dx,offset text
int 21h
endm ;macro vége

;alprogram – a beolvasott karakterek átalakítására binárissá
asciibin proc near ; bemenet si - mutato buffer+1
; kimenet ax - bin ertek

mov cl,byte ptr[si] ;bevisszük a beolvasott kar. számát a cl-be
xor ax,ax ;ax-t nullázzuk
cmp cl,0 ;megnézzük volt-e beolvasva karakter
ja gop11 ;ha volt továbbmegyünk
ret ;ha nem vége

gop11:
mov bx,10 ;10-el fogunk szorozni

cikp11:
mul bx ;itt szorzunk, ax-et bx-el, dx nullazva
inc si ;si-t megnöveljük eggyel
mov dl,byte ptr[si] ;bevisszünk a bufferből egy bájtot a dl-be
sub dl,30h ;levonunk belőle 30h-t
add ax,dx ;így lesz belőle bináris szám, hozzáadjuk az ax- hez, az ax-ben van a végső bináris szám
dec cl ;cl eggyel csökkentjük
jnz cikp11 ;addig ismételjük ezt, míg cl nulla nem lesz

ret ;vissza a főprogramba

asciibin endp ;a procedúra vége

;ez a proc. kiírja a képernyőre az ax-ben lévő bin. értéket
binascii proc near ; bemenet ax
mov szemafor,0 ;szemafort nullázzuk
cmp ax,0 ;megnézzük, hogy nem-e egy nullát kell kiírnunk
jne gop21 ;ha nem akkor tovább
mov ah,2 ;ha igen, hát kiírjuk
mov dl,'0' ;azért így, mert így egyszerűbb
int 21h ;mint később törődni vele
ret ;vissza a főprogramba

gop21:
mov bx,10000 ;10000 fogunk osztani
xor dx,dx ;a dx-et nullázni kell, lásd div utasítás

cikp22:
div bx ;osztjuk az ax-et és kiterjesztését a dx-et bx-el
mov si,dx ;a maradékot kimentjük az si-be
cmp ax,0 ;ha ax nulla megnézzük ki kell-e írni
jne gop22 ;ha nem nulla akkor kiírjuk
cmp szemafor,0 ;ha szemafor nulla, nem írjuk ki
je gop23

gop22:
mov ah,2 ;itt írjuk ki
mov dl,al
add dl,30h ;előtte hozzáadunk 30h-t, lásd ASCII
int 21h
mov szemafor,1 ;már volt kiírva szám, szemafor 1-esbe

gop23:
mov ax,bx ;az osztót 10-el elosztjuk
mov bx,10
xor dx,dx
div bx ;kinullazza a dx-et, fent már nem fog kelleni
cmp ax,1
jb vegep2 ;ha kisebb mint vége
mov bx,ax ;vissza az osztót a bx-be
mov ax,si ;az osztandó meg a maradék
jmp cikp22 ;vissza az elejére

vegep2:
ret ;visszatérünk a főprogramba

binascii endp ;a proc. vége

start:
mov ax,cs ;adatszegmens kezdőcímének beállítása
mov ds,ax
cld ;df nullázása

mov ax,3 ;képernyő törlése, 80x25-ös mód beállításával
int 10h ;a 16-os BIOS szolgáltatást használjuk

kiir text1 ;kiírjuk a text1-et
mov index,1 ;index=1

cik1:
kiir newline ;írunk egy újsort
mov ax,index ;ax-be az index
call binascii ;hogy ki tudjuk írni
kiir text2 ;és kiírjuk, hogy .oldal:

mov ah,0ch ;bill. bufffer törlése
mov al,0ah ;string beolvasása
mov dx,offset buffer ;a buffer-ba
int 21h

xor bx,bx ;bx nullázása
cik2:
cmp buffer[bx+2],30h ;kisebb az aktuálisan nézett karakter mint 30h=’0’?
jb go1 ;ha igen, az akkor nem szám
cmp buffer[bx+2],39h ;nagyobb az aktuálisan nézett karakter mint 39h=’9’?
ja go1 ;akkor az nem szám
inc bl ;bl a köv. karakterre mutassson
cmp bl,buffer[1] ;megnézzük bl=a beolvasott karakterek számával?
jb cik2 ;ha kevesebb ismétlünk

;ha ide eljutunk a buffer minden egyes beolvasott karaktere szám

mov si,offset buffer+1 ;si-be buffer+1 offsetcím, lásd asciibin proc. bemente
call asciibin ;meghívjuk az asciiibin proc., ezzel alakítjuk át a beolvasott karaktereket számmá

cmp ax,40 ;megnézzük nem nagyobb-e a beolvasott szám mint 40
ja go1 ;ha nagyobb ugrunk
cmp al,0 ;nulla se lehet...
je go1
cmp buffer[1],0 ;ha nem volt beolvasott karakter
je go1 ;akkor is ugrunk
jmp go2 ;ha egyik se teljesült, akkor megyünk tovább

go1:
kiir hibauz1 ;kiírjuk a hibaüzit
jmp cik1 ;vissza a beolvasásra

go2:
mov si,index ;elmentjük a számot
mov buffer_save[si-1],al ;a buffer_save-ba
inc index ;index eggyel nagyobb
cmp index,3 ;index=3?
jbe cik1 ;ha kisebb vagy egyenlő mint 3, akkor ismétlünk

xor bx,bx ;bx nullázása

mov al,buffer_save[0] ;al-be az első szám
mov bl,buffer_save[1] ;bl-be a másik
mul bl ;szorozzuk az al-t bl-el
mov bl,buffer_save[2] ;a bl-be a harmadik szám, bh-t előbb nulláztuk
mul bx ;ax-et szorozzuk bx-el
push ax ;elmentjük a kapott számot a verembe

kiir text3 ;kiírjuk a text3-at

pop ax ;visszahozzuk a számot
call binascii ;és kiírjuk

kiir text4 ;majd kiírjuk a text4-et

mov ah,0ch ;bill. buffer törlése
mov al,7 ;várunk egy karakterre
int 21h

mov ah,4ch ;a vezérlés visszaadása a DOS-nak
int 21h

code ends ;code szegmens vége
end start ;start cimkénél kezdünk

;Program 02

02.zip 02.exe 02.asm

;Írjon programot a kocka felületének kiszámítására. A kocka oldalát kérje be a billentyűzetről, az ererdményt jelentítse meg a számítógép monitorán. Az eredmény férjen bele 2 bájtba.

code segment ;code nevű szegmens létrehozása
assume cs:code,ds:code ;hozzárendelés

;EQU direktíva, a max szó jelentse azt, hogy 104, a fordító minden max szó helyére ezt fogja tenni
max EQU 104

;változók
text1 db 'A kocka felszinenek kiszamitasa'
db 13,10,'~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~$'
text2 db 13,10,'Add meg az oldalat (max. 104): $'
text3 db 13,10,'A kocka felszine: $'
text4 db 13,10,'Nyomj le barmilyen billentyut a kilepeshez...$'
hibauz db 13,10,'Max. 104!$'
eredmeny dw ? ;ide mentjük az eredményt
buffer db 4,0,4 dup(0) ;ide olvassuk be a számot

;macro string kiírására
textkiir macro text
mov ah,9 ;9-es DOS szolgáltatás
mov dx,offset text ;dx-be a kiírandó string offsetcíme
int 21h
endm ;macro vége

;proc. ASCII kódú karakterek bináris számmá való alakítására
asciibin proc near ;bemenet si - mutato buffer+1
;kimenet ax - bin ertek
mov cl,byte ptr[si] ;elmentjük cl-be a beolvasott kar. számát
xor ax,ax ;ax-et nullázzuk
cmp cl,0 ;volt beolvasott karakter?
ja asciibin_go1 ;ha igen, akkor megyünk átszámolni
ret ;ha nem visszatérünk egy nullával az ax-ben

asciibin_go1:
mov bx,10 ;10-el fogunk szorozni

asciibin_cik1:
mul bx ;dx nullázva
inc si ;si növelése eggyel
mov dl,byte ptr[si] ;bevisszük a számjegyet
sub dl,30h ;hogy szám legyen, ASCII kódú most még!
add ax,dx ;a számunkhoz hozzáadjuk
dec cl ;cl dekrementálása
jnz asciibin_cik1 ;addig míg a cl 0 nem lesz

ret ;visszatérünk a főprogramba
asciibin endp ;proc. vége

;proc. ami kiírja az ax-ben megadott számot a képernyőre
binascii proc near ;bemenet ax
jmp binascii_start ;átugorjuk a változót

flag db ? ;volt már kiírt számjegy? ezt mondja meg

binascii_start:
mov flag,0 ;flag=0 ? még nem volt kiírt számjegy
cmp ax,0 ;ax=0?
jne binascii_go1 ;ha nem, akkor tovább
mov ah,2 ;ha igen, akkor kiírunk egy nullát
mov dl,'0'
int 21h
ret ;és visszatérünk

binascii_go1:
mov bx,10000 ;10000-rel fogunk osztani
xor dx,dx ;osztás ? dx-et nullázni kell! lásd füzet DIV utasítás

binascii_cik1:
div bx ;ax-et osztjuk bx-el
mov si,dx ;maradékot dx-ben kapjuk vissza, elmentjük si-be
cmp ax,0 ;ax=0?
jne binascii_go2 ;ha nem akkor tovább
cmp flag,0 ;ha igen, akkor flag=0?
je binascii_go3 ;ha igen, akkor még nem volt kiírt számjegy, ezért a kapott nullát nem írjuk ki

binascii_go2:
mov ah,2 ;ha ide eljutunk, kiírjuk a számjegyet
mov dl,al
add dl,30h ;előbb hozzáadunk 30h-t, ASCII!
int 21h
mov flag,1 ;és flag=1, mert már van kiírt számjegy

binascii_go3:
mov ax,bx ;bx-et osztani kell 10-el
mov bx,10 ;10-el
xor dx,dx ;dx-et nullázni
div bx ;kinullázza a dx-et
cmp ax,1 ;ax=1?
jb binascii_vege ;ha kisebb mint egy akkor vége
mov bx,ax ;ha nem, akkor bx vissza osztónak
mov ax,si ;ax-be meg az előbbi maradék
jmp binascii_cik1 ;és vissza a ciklus elejére

binascii_vege:
ret ;visszatérés a főprogramba
binascii endp ;proc. vége

start:
mov ax,cs ;adatszegmens beállítása
mov ds,ax
cld ;df nullázása

mov ax,3 ;képernyő törlése, 80x25-ös módba való lépéssel
int 10h

textkiir text1 ;text1 kiírása

cik1:
textkiir text2 ;text2 kiírása

mov ah,0ch ;bill. buffer törlése
mov al,0ah ;string beolvasása
mov dx,offset buffer ;a buffer-ba
int 21h

xor bx,bx ;bx nullázása, evvel címzünk

cik2:
cmp buffer[bx+2],30h ;megnézzük a beolvasott tömb minden egyes elemét, hogy szám volt-e: 30h és 39h közötti ASCII kódú karakternek kell lenni, ezek a számok ASCII kódjai
jb go1 ;ha kisebb volt, hiba
cmp buffer[bx+2],39h
ja go1 ;ha meg nagyobb, az is hiba
inc bl ;az összes elemet végignézzük
cmp bl,buffer[1] ;addig míg a bl el nem éri a beolvasott kar. számát
jb cik2 ;jobban mondva, nagyobb vagy egyenlő nem lesz nála, 0-val kezdjük az indexelést!

mov si,offset buffer+1 ;átalakítjuk a karaktereket számmá
call asciibin ;itt csináljuk

cmp ax,max ;ax-ben kaptuk vissza a számot
ja go1 ;megnézzük nem nagyobb-e mint, ami lehet
cmp al,0 ;nulla se lehet
je go1 ;ekkor is hiba
cmp buffer[1],0 ;ha meg nem ütött mást a user csak egy ENTERT, azt is lekezeljük, mint hiba
je go1
jmp go2 ;tovább, mert itt akkor nincs hiba

go1:
textkiir hibauz ;hibaüzenet kiírása
jmp cik1 ;új szám bekérése

go2:
mov bx,ax ;bx-be ax-et
mul bl ;ax szorzása bx-el ? ax-ben a kocka oldala ? szorozva önmagával, ez az a2, ezt még szorozzuk 6-al, és meg is van a felszíne

mov bx,6 ;6-al
mul bx ;ax és kiterjesztése a dx szorzása a bx-el
mov eredmeny,ax ;eredmény elmentése

textkiir text3 ;text3 kiírása

mov ax,eredmeny ;eredmény vissza az ax-be
call binascii ;kiírása

textkiir text4 ;text4 kiírása

mov ah,0ch ;bill. buffer törlése
mov al,7 ;várás egy karakterre echo nélkül
int 21h

mov ah,4ch ;a vezérlés visszaadása az op.-nek
int 21h

code ends ;code nevű szegmens vége
end start ;start cimkénél kezdünk

;Program 03

03.zip 03.exe 03.asm

;Írjon programot a kocka térfogatának a kiszámítására. A kocka oldalának hosszát kérje be a billentyűzetről, az eredményt jelenítse meg a képernyőn. Az eredmény férjen bele 2 bájtba.

code segment ;code nevű szegmens létrehozása
assume cs:code,ds:code ;hozzárendelés

;változók
text1 db 'A kocka terfogatanak kiszamitasa'
db 13,10,'################################',13,10,36
text2 db 13,10,'Add meg az oldalat (max. 40): $'
text3 db 13,10,'A kocka terfogata: $'
text4 db 13,10,'Nyomj le barmilyen billentyut a kilepeshez...$'
hibauz db 13,10,'Max. 40!$'
eredmeny dw ?
buffer db 3,0,3 dup(0)
szemafor db ?

;macro stringek kiírására
textkiir macro text ;text az egyetlen paraméter
mov ah,9 ;a 9-es DOS szolgáltatással írjuk ki a stringet
mov dx,offset text
int 21h
endm ;macro vége

;alprogram – a beolvasott karakterek átalakítására binárissá
asciibin proc near ;bemenet si - mutato buffer+1
;kimenet ax - bin ertek

mov cl,byte ptr[si] ;bevisszük a beolvasott kar. számát a cl-be
xor ax,ax ;ax-t nullázzuk
cmp cl,0 ;megnézzük volt-e beolvasva karakter
ja gop11 ;ha volt továbbmegyünk
ret ;ha nem vége

gop11:
mov bx,10 ;10-el fogunk szorozni

cikp11:
mul bx ;itt szorzunk, ax-et bx-el, dx nullazva
inc si ;si-t megnöveljük eggyel
mov dl,byte ptr[si] ;bevisszünk a bufferből egy bájtot a dl-be
sub dl,30h ;levonunk belőle 30h-t
add ax,dx ;így lesz belőle bináris szám, hozzáadjuk az ax- hez, az ax-ben van a végső bináris szám
dec cl ;cl eggyel csökkentjük
jnz cikp11 ;addig ismételjük ezt, míg cl nulla nem lesz

ret ;vissza a főprogramba

asciibin endp ;a procedúra vége

;ez a proc. kiírja a képernyőre az ax-ben lévő bin. értéket
binascii proc near ; bemenet ax
mov szemafor,0 ;szemafort nullázzuk
cmp ax,0 ;megnézzük, hogy nem-e egy nullát kell kiírnunk
jne gop21 ;ha nem akkor tovább
mov ah,2 ;ha igen, hát kiírjuk
mov dl,'0' ;azért így, mert így egyszerűbb
int 21h ;mint később törődni vele
ret ;vissza a főprogramba

gop21:
mov bx,10000 ;10000 fogunk osztani
xor dx,dx ;a dx-et nullázni kell, lásd div utasítás

cikp22:
div bx ;osztjuk az ax-et és kiterjesztését a dx-et bx-el
mov si,dx ;a maradékot kimentjük az si-be
cmp ax,0 ;ha ax nulla megnézzük ki kell-e írni
jne gop22 ;ha nem nulla akkor kiírjuk
cmp szemafor,0 ;ha szemafor nulla, nem írjuk ki
je gop23

gop22:
mov ah,2 ;itt írjuk ki
mov dl,al
add dl,30h ;előtte hozzáadunk 30h-t, lásd ASCII
int 21h
mov szemafor,1 ;már volt kiírva szám, szemafor 1-esbe

gop23:
mov ax,bx ;az osztót 10-el elosztjuk
mov bx,10
xor dx,dx
div bx ;kinullazza a dx-et, fent már nem fog kelleni
cmp ax,1
jb vegep2 ;ha kisebb mint vége
mov bx,ax ;vissza az osztót a bx-be
mov ax,si ;az osztandó meg a maradék
jmp cikp22 ;vissza az elejére

vegep2:
ret ;visszatérünk a főprogramba

binascii endp ;a proc. vége

;főprogram
start:
mov ax,cs ;adatszegmens kezdőcímének beállítása
mov ds,ax
cld ;df nullázása

mov ax,3 ;képernyő törlése, 80x25-ös mód beállításával
int 10h ;a 16-os BIOS szolgáltatást használjuk

textkiir text1 ;kiírjuk a text1-et

cik1:
textkiir text2

mov ah,0ch ;bill. buffer törlése
mov al,0ah ;string beolvasása a bill.-ről
mov dx,offset buffer ;a buffer-ba olvasunk
int 21h

xor bx,bx ;bx nullázása
cik2:
cmp buffer[bx+2],30h ;kisebb az aktuálisan nézett karakter mint 30h=’0’?
jb go1 ;ha igen, az akkor nem szám
cmp buffer[bx+2],39h ;nagyobb az aktuálisan nézett karakter mint 39h=’9’?
ja go1 ;akkor az nem szám
inc bl ;bl a köv. karakterre mutassson
cmp bl,buffer[1] ;megnézzük bl=a beolvasott karakterek számával?
jb cik2 ;ha kevesebb ismétlünk

;ha ide eljutunk a buffer minden egyes beolvasott karaktere szám

mov si,offset buffer+1 ;si-be buffer+1 offsetcím, lásd asciibin proc. bemente
call asciibin ;meghívjuk az asciiibin proc., ezzel alakítjuk át a beolvasott karaktereket számmá

cmp al,40 ;megnézzük nem nagyobb-e a beolvasott szám mint 40
ja go1 ;ha nagyobb ugrunk
cmp al,0 ;al=0
je go1 ;ha igen, hiba
cmp buffer[1],0 ;ha nem volt beolvasott karakter
je go1 ;akkor is ugrunk
jmp go2 ;ha egyik se teljesült, akkor megyünk tovább

go1:
textkiir hibauz ;kiírjuk a hibaüzit
jmp cik1 ;vissza a beolvasásra

go2:
mov bx,ax ;itt számolunk, al-t fogjuk szorozni, bl-el
mul bl ;itt csináljuk
mul bx ;most már ax-ben található a számunk, ezért már 16 bit széles operandussal kell szoroznunk, nem gond, bh biztos nulla
mov eredmeny,ax ;elmentjük az eredményt

textkiir text3 ;kiírjuk a text3-at

mov ax,eredmeny ;kiiírjuk az eredményt
call binascii

textkiir text4 ;majd kiírjuk a text4-et

mov ah,0ch ;bill. buffer törlése
mov al,7 ;várunk egy karakterre
int 21h

mov ah,4ch ;a vezérlés visszaadása a DOS-nak
int 21h

code ends ;code szegmens vége
end start ;start cimkénél kezdünk

;Program 04

04.zip 04.exe 04.asm

;Írjon programot két hatjegyű billentyűzetről beadott BCD szám összeadására. Az eredményt (BCD szám) jelenítse meg a számítógép monitorán.

code segment ;code nevű szegmens létrehozása
assume cs:code,ds:code ;hozzárendelés

;szamjegy nevű konstans, írhattuk volna azt is, hogy szamjegy EQU 6, de nekem ez így jobban teccik
szamjegy = 6

;változók
;36 = ‘$’, 13,10 új sor írására, ha több új sort akarunk, nem kell többször a 13, elég a 10, mivel lényegében ez tesz új sort, a 13 csak a sor elejére viszi a kurzort
text1 db 'Adj meg ket hatjegyu szamot: ',13,10,10,36
text2 db '. szam: $'
text3 db 13,10,10,'Nyomj le egy billentyut a kilepeshez...$'
text4 db ' Ok!',13,10,36
text5 db ' -------'
db 13,10,'Az osszeguk: $'
szam1 db szamjegy dup(0) ;az első szám tárolására
szam2 db szamjegy dup(0) ;a második szám tárolására
eredmeny db szamjegy+1 dup(0) ;az eredmény tárolására, eggyel nagyobb, mert lehet, hogy a végén kimarad az egy, ezt valahova el kell tenni...
index1 db 0 ;ez arra, hogy amikor kiírja, hogy .szam, akkor tudja, hogy épp hanyadik számnál tartunk, lehet nyugodtan itt nullázni
kar db ? ;a beolvasott kar. tárolására
flag1 db ? ;volt már szám, nullán kívül? ezt mondja meg

;macro string kiírására
kiir macro text
mov ah,9
mov dx,offset text
int 21h
endm

;macro a BCD kódú szám beolvasására, a szám első bájtja a szam
beolvas macro szam
local beolvas_go1,beolvas_cik1 ;lokális cimkék
mov flag1,0 ;flag-et nullázzuk
xor si,si ;si-t szintén
inc index1 ;index legyen eggyel nagyobb
mov ah,2 ;írjuk ki az indexet
mov dl,index1
add dl,30h ;előbb hozzáadunk 30h-t, mivel számként akarjuk kiírni
int 21h

kiir text2 ;aztán a szöveg többi részét is kiírjuk

mov ah,0ch ;bill. buffert töröljük
int 21h

beolvas_cik1:
mov ah,7 ;beolvasunk egy karaktert
int 21h

mov kar,al ;elmentjük az al-be

cmp kar,30h ;megnézzük 0 volt? 30h = ’0’
jne beolvas_go1 ;ha nem akkor semmi, tovább megyünk
cmp flag1,0 ;ha igen, akkor volt már kiírt számjegy?
je beolvas_cik1 ;ha nem, akkor még ezt sem írjuk ki, mert ugyebár egy szám nem kezdődhet nullával

beolvas_go1:
cmp kar,30h ;meg kell nézni, hogy szám volt-e leütve
jb beolvas_cik1 ;ha kisebb volt mint 30h, az baj
cmp kar,39h ;ha nagyobb mint 39h az is, ezért nem érdekel minket, és egyszerűen kérünk egy új számot
ja beolvas_cik1

mov ah,2 ;ha minden rendben volt, kiírjuk a számot
mov dl,kar
int 21h
mov flag1,1 ;és flag egyesbe, mert már volt kiírt szám

sub kar,30h ;el is mentjük a számot, levonunk 30h-át, mert nem ASCII-ban akarjuk elmenteni, hanem egyszerű számként
mov al,kar
mov szam[si],al ;si-vel címezzük a szám indexet
inc si ;köv. számjegyre mutass!

cmp si,szamjegy ;van már elég számjegy?
jb beolvas_cik1 ;ha még nincs, akkor olvass!
endm

start:
mov ax,cs ;adatszegmens kezdőcímének beállítása
mov ds,ax
cld ;df nullázása, azért mert az alacsonyabb bájttól a magasabb bájtig fogjuk kiírni a stringeket, nem fordítva

mov ax,3 ;képernyő törlése, 80x25-ös módba való lépéssel
int 10h

kiir text1 ;text1 kiírása

beolvas szam1 ;első szám beolvasása
kiir text4 ;kiírjuk, hogy ok
beolvas szam2 ;ugyanaz
kiir text4

mov si,szamjegy ;na itt fogunk összeadnik, a végéről kezdjük, mint a normális összeadásnál

cik1:
dec si ;si dekrementálása
mov al,szam1[si] ;átvisszük az első számot az al-be
add al,szam2[si] ;hozzáadjuk a másikat
add eredmeny[si+1],al;itt menti el az eredménybe, si+1 azért, mert az eredmény egy bájttal el van tolva a két beolvasott számhoz képest, nem muszáj ez hogy így legyen, én így találtam ki
cmp eredmeny[si+1],al ;megnézzük túl csordul-e
jbe go1 ;ha nem akkor semmi gond, továbbmehetünk

sub eredmeny[si+1],10 ;ha igen, akkor le kell vonni belőle 10-et, gondolkozz el miért, és a köv. számjegyhez hozzáadni egyet
inc eredmeny[si] ;és menni tovább, nem?

go1:
cmp si,0 ;már a tömb végén vagyunk?
jnz cik1 ;ha nem akkor ismételj!

kiir text5 ;jó készen van az összeadás, írjuk ki az eredményt!

xor si,si ;az elejéről kezdjük kiírni, si-vel cimezzük
cmp eredmeny[0],0 ;ha nem volt a végén maradék, akkor az eredmény első bájtja, nulla maradt, de ez nem jó, ekkor helyette ki kell írni egy szóközt
jne cik2
mov ah,2
mov dl,' ' ;itt írunk helyette egy szóközt
int 21h
inc si ;és si eggyel nagyobb, mert az első számjegyet akkor már nem kell nézni, hisz most írtuk ki

cik2:
mov ah,2 ;kiírjuk a számjegyet
mov dl,eredmeny[si]
add dl,30h ;ASCII azért kell +30h
int 21h
inc si
cmp si,szamjegy ;már kiírtuk az összeset?
jbe cik2

kiir text3 ;ez már a vége

mov ah,0ch ;bill. buffer törlése
mov al,7 ;várás egy kar.-ra echo nélkül
int 21h

mov ah,4ch ;a vezérlés visszaadása az op.-nek
int 21h

code ends ;code nevű szegmens vége
end start ;a start cimkénél kezdünk

;Program 05

05.zip 05.exe 05.asm

;Íjon programot, amely megjelenít a képernyő monitorán egy négyjegyű dekadikus számlálót, amely 0-tól 9999-ig számol. Az ESC lenyomására a program végetér.

code segment ;code nevű szegmens létrehozása
assume cs:code,ds:code ;hozzárendelés

;változók
szam dw 0

;proc. bináris szám ASCII kódban való kiírására
binascii proc near ;bemenet ax
jmp binascii_start ;átugorjuk a flag változót

flag db ?

binascii_start:
mov flag,0 ;ez nekünk azért kell, hogy csak max 4 számjegyet írjunk ki, ne ötöt, szal az elsőt egyszerűen nem írjuk ki... :D lehetne másképp is, így egyszerűbb
mov bx,10000 ;10000 osztunk
xor dx,dx ;nullázni kell az osztás előtt

binascii_cik1:
div bx ;ax osztása bx-el
mov si,dx ;maradék si-be

cmp flag,0 ;flag=0?
je binascii_go1 ;ha igen akkor ugrunk

mov ah,2 ;ha nem kiírunk
mov dl,al ;egy számjegyet
add dl,30h ;előtt hozzá kell adni 30h, ASCII!
int 21h

binascii_go1:
mov flag,1 ;most már flag egyesbe
mov ax,bx ;bx-et 10-zel elosztjuk
mov bx,10
xor dx,dx
div bx ;az osztás kinullázza a dx-et, nincs maradék
cmp ax,1 ;ax=1?
jb binascii_vege ;ha kisebb, akkor vége
mov bx,ax ;ha nem, akkor az osztó vissza a bx-be
mov ax,si ;si-ből meg az ax-be vissza a maradék
jmp binascii_cik1

binascii_vege:
ret
binascii endp

;főprogram
start:
mov ax,cs ;adatszegmens kezdőcímének beállítása
mov ds,ax
cld ;df nullázása

mov ax,3 ;képernyő törlése, 80x25-ös módba való lépéssel
int 10h

mov ah,1 ;kurzor eltüntetése
mov ch,20h
int 10h

cik1:
mov ah,2 ;kurzor a 0,0-ás pozícióra
xor bh,bh
xor dx,dx
int 10h

mov ax,szam ;kiírjuk a szam-ot
call binascii

mov ah,86h ;várunk 500 ms-t
mov cx,7
mov dx,0a120h
int 15h

mov ah,6 ;valaki leütött egy bill.-t
mov dl,0ffh
int 21h
cmp al,27 ;az ESC volt az?
jz vege ;ha igen, kilépünk

inc szam ;szam-ot megnöveljük
cmp szam,10000 ;megnézzük nem vagyunk-e még a végén
jb cik1

mov ah,0ch ;bill. buffer törlése
mov al,7 ;várás egy bill.-re
int 21h

vege:
mov ah,1 ;kurzor unhide
mov cx,1f0eh
int 10h

mov ah,4ch ;vezérlés visszaadása az op.-nek
int 21h

code ends ;code nevű szegmens vége
end start ;start cimkénél kezdünk

;Program 06

06.zip 06.exe 06.asm

;Írjatok programot 3 maximálisan kétjegyű szám beolvasására a billentyűzetről, és a megjelenítésükre a monitoron a legkisebbtől a legnagyobbig.

code segment ;code nevű szegmens létrehozása
assume cs:code,ds:code ;hozzárendelés

;long szó jelentse azt, hogy 3, ez jelzi a beolvasandó számok számát, ha itt átírjuk, akkor mindenhol átíródik a programban, ha mondjuk 10 számot akarnánk bekérni, itt elég lenne átírni, és a program automatikusan 10 számot kérne be, és rendezne
long EQU 3

;változók
text1 db 'Legkisebbtol a legnagyobbig'
db 13,10,'***************************'
db 13,10,'Adj meg $'
text11 db ' szamot!',13,10,36
text2 db '. szam: $'
text3 db 13,10,13,10,'A szamok rendezve:',13,10,36
text4 db 13,10,13,10,'Nyomj le egy billentyut a kilepeshez...$'
hibauz1 db 13,10,'A megadhato legnagyobb szam a 99!$'
newline db 13,10,36 ;új sor írásához
buffer_key db 3,0,3 dup(0)
buffer_sort db long dup(0)
szemafor db ?
index dw ? ;a buffer_sort indexeléséhez

;macro string kiírására
kiir macro text
mov ah,9
mov dx,offset text
int 21h
endm ;macro vége

;macro egy karakter kiírására
putchar macro char
mov ah,2
mov dl,char
int 21h
endm ;macro vége

;procedúra bináris szám kiírására
binascii proc near ;bemenet ax
mov szemafor,0 ;szemafor nullázása
cmp ax,0 ;ax=0?
jne gop21 ;ha nem akkor megyünk tovább
putchar '0' ;ha ige, akkor kirakunk egy nullát
jmp vegep2 ;és megyünk a végére

gop21:
mov bx,10000 ;10000-rel fogunk osztani
xor dx,dx ;az osztás előtt nullázni kell a dx-et

cikp21:
div bx ;osztjuk az ax-et bx-el
mov si,dx ;a maradék az si-be
cmp ax,0 ;ax=0?
jne gop22 ;ha nem akkor gop22-re
cmp szemafor,0 ;ha igen, akkor szemafor=0?
je gop23 ;ha igen, ugrunk a gop23-ra

gop22:
add al,30h ;al-hez adjunk hozzá 30h, ASCII!
putchar al ;kitesszük a képernyőre
mov szemafor,1 ;már itt biztos volt kiírva karakter, ezért szemafor egyesbe

gop23:
mov ax,bx ;az osztót osztani kell 10-el
mov bx,10 ;10-el
xor dx,dx ;dx nullázása, mint fent
div bx ;kinullazza a dx-et, osztjuk az ax-et
cmp ax,1 ;megnézzük ax=1?
jb vegep2 ;ha kisebb mint 1, akkor vége
mov bx,ax ;ha nem, bx-be vissza az osztót
mov ax,si ;ax-be vissza a maradékot
jmp cikp21 ;vissza az elejére

vegep2:
ret ;visszatérünk a főprogramba
binascii endp ;proc. vége

;ASCII karaktereket alakít számmá
asciibin proc near ;bemenet si - mutato buffer+1
;kimenet ax - bin ertek
mov cl,byte ptr[si] ;bevisszük a cl-be a beolvasott karakterek számát
xor ax,ax ;ax-et nullázzuk
cmp cl,0 ;megnézzük volt-e beolvasott karakter
ja gop31 ;ha igen, akkor tovább
jmp vegep3 ;ha nem akkor vége

gop31:
mov bx,10 ;10-el fogunk szorozni

cikp31:
mul bx ;dx nullázva, szorozzuk az ax-et bx-el
inc si ;si köv. elemre mutasson
mov dl,byte ptr[si] ;bevisszük dl-be a karaktert
sub dl,30h ;levonunk belőle 30h, lásd ASCII!
add ax,dx ;hozzáadjuk az ax-hez a számjegyet
dec cl ;cl-1
jnz cikp31 ;addig míg cl!=0 vissza az elejére

vegep3:
ret ;visszatérés a főprogramba
asciibin endp ;proc. vége

;ez a lényeg, a rendező algoritmus
;bubblesort-ot használjuk, mivel kevés az elemszám
bubblesort proc near ;bemenet si - mutato a rendezendo tomb elso elemere, long a tomb hossza
jmp startp5 ;átugorjuk a változókat

;változók
p db ? ;egy szemafor, hogy tudjuk volt csere
buf dw ? ;buffer, amibe elmentjük az si kezdeti értékét

startp5:
mov buf,si ;előbb mondtam, itt mentjük el
mov dl,long ;dl-be azt, hogy mennyi bájtot kell rendezni

gop51:
mov p,0 ;p-t nullázzuk
mov si,buf ;si-be a kezdeti értékét
dec dl ;dl-be eggyel kevesebbet
jz vegep5 ;ha dl=0 akkor vége

mov cl,dl ;cl-be dl-t

atnezes:
mov al,byte ptr[si] ;bevisszük al-be, a buffer si-edik bájtját
cmp al,byte ptr[si+1] ;megnézzük hogyan viszonyul ez az elem a következővel
jbe gop52 ;LÉNYEGES RÉSZ! Ha kisebb akkor ugrunk, ha ezt átírjuk jae gop52-re akkor a legnagyobbtól a legkisebbig rendez

xchg al,byte ptr[si+1] ;felcseréljük a két elemet
mov byte ptr[si],al
mov p,1 ;és p-t egyesbe állítjuk

gop52:
inc si ;si köv. elemre mutasson
dec cl ;cl eggyel kevesebb
jnz atnezes ;ha cl még nem nulla, akkor vissza az elejére

cmp p,1 ;megnézzük p=1?
je gop51 ;ha igen, ugrunk

vegep5:
ret ;visszatérés a főprogramba
bubblesort endp ;proc. vége

;főprogram
start:
mov ax,cs ;adatszegmens kezdőcímének beállítása
mov ds,ax

mov ax,3 ;képernyő törlése, 80x25-ös módba való váltással
int 10h

kiir text1 ;kiírjuk a text1-et
mov ax,long ;bevisszük azt az ax-be, hogy mennyi számot kell megadni
call binascii ;kiírjukl ezt a számot
kiir text11 ;itt meg a szöveg többi része

mov index,1 ;index=1, ez egyben ciklusváltozó is

;itt olvassuk be a számokat
cik1:
kiir newline ;írunk egy új sort
mov ax,index ;kiírjuk, hogy hanyadik számot adjuk meg épp
call binascii
kiir text2 ;és kiírjuk, hogy . szám:

mov ah,0ch ;bill. buffer törlése
mov al,0ah ;string beolvasása
mov dx,offset buffer_key ;a buffer_key-be
int 21h ;csináld

xor bx,bx ;bx nullázása

cik3:
cmp buffer_key[bx+2],30h ;megnézzük, hogy a beolvasott két karakter szám volt-e
jb go1
cmp buffer_key[bx+2],39h
ja go1
inc bl ;végignézzük a tömböt
cmp bl,buffer_key[1]
jb cik3
jmp go2 ;ha ide eljutunk, akkor minden rendben, mehetünk tovább

go1:
kiir hibauz1 ;ha nem volt rendben, akkor kiírjuk, hogy hiba
jmp cik1 ;és bekérjük még 1x

go2:
mov si,offset buffer_key+1 ;si-be a buffer második bájtjára mutató mutató
call asciibin ;csinálunk belőle számot

mov si,index ;si-be index
mov buffer_sort[si-1],al ;elmentjük a buffer_sort-ba a számot
inc index ;index mutasson a buffer köv. elemére, a köv. mentéshez
cmp index,long ;megnézzük bekértük már az összes számot?
jbe cik1 ;ha még nem, akkor kérjük

mov si,offset buffer_sort ;na itt rendezzük
call bubblesort ;ez csinálja

kiir text3 ;kiírju, hogy a tömb rendezve
mov index,1 ;index=1

cik2:
kiir newline ;újsor
mov ax,index ;ax-be index
call binascii ;kiírjuk az index-et
kiir text2 ;kiírjuk, hogy . szám:

xor ah,ah ;ah-t nullázzuk
mov si,index ;si-be index
mov al,buffer_sort[si-1] ;buffer megfelelő bájtját al-be
call binascii ;kiírni

inc index ;index köv. elemre
cmp index,long ;megnézzük kiírtuk már az összes elemet?
jbe cik2 ;ha még nem, akkor vissza a cik2-re

kiir text4 ;kiírjuk, hogy nyomj bármilyen bill.-t

mov ah,0ch ;bill. buffer törlése
mov al,7 ;várás echo nélkül egy bill. lenyomására
int 21h

mov ah,4ch ;a vezérlés visszaadása az op.-nek
int 21h

code ends ;code szegmens vége
end start ;start cimkénél kezdünk

;Program 07

07.zip 07.exe 07.asm

;Írjon programot, amely a beadott értékek halmazából kiválasztja a páros számokat, megjeleníti őket, és megjeleníti a mennyiségüket is. Jelentítse meg a beadott halmazt, amely 10 maximálisan kétjegyű egész számokból tartalmaz.

code segment ;code nevű szegmens létrehozása
assume cs:code,ds:code ;hozzárendelés

;EQU direktíva, a long szó jelentse azt, hogy 10
long EQU 10 ;írhattuk volna azt is, hogy long=10

;változók
text1 db 'Paros szamok'
db 13,10,'------------$'
text2 db 13,10,'Adj meg $'
text3 db ' szamot!',13,10,36
text4 db '. szam: $'
text5 db 13,10,13,10,'A beadott szamsor:',13,10,36
text6 db 13,10,13,10,'A paros szamok:',13,10,36
text7 db 13,10,13,10,'A paros szamok szama: ',13,10,36
text8 db 13,10,13,10,'Nyomj le egy billentyut a kilepeshez...$'
newline db 13,10,36 ;új sor írására
hibauz1 db 13,10,'A megadhato legnagyobb szam a 99!$'
buffer_key db 3,0,3 dup(0) ;a bill.-ről beolvasott kar. számára buffer
buffer_sort db long dup(0) ;ebben tároljuk a beolvasott számokat
index dw ? ;a tömb indexelésére
parosokszama dw 0 ;a páros számok számánank tárolására

;macro string kiírására
kiir macro text
mov ah,9
mov dx,offset text
int 21h
endm ;macro vége

;macro egy karakter kiírására
putchar macro char
mov ah,2
mov dl,char
int 21h
endm

;macro szám kiírására
wnum macro param
mov ax,param
call binascii
endm

;macro ASCII kódú szám binárissá alakítására
num macro param
mov si,offset param
call asciibin
endm

;macro a számsor kiírására
wszamsor macro param
mov di,offset param
call kiirszamsor
endm

;macro a páros számok kiírására
wparos macro param
mov di,offset param
call kiirparos
endm

;macro a képernyő törlésére
clrscr macro
mov ax,3 ;80x25-ös mód beállítása, ezzel a kép. törlése
int 10h
endm

;proc. bináris szám ASCII kódban való kiírására
binascii proc near ;bemenet ax
jmp binascii_start ;átugorjuk a változót

flag db ?

binascii_start:
mov flag,0
cmp ax,0 ;ax=0?
jne binascii_go1 ;ha nem akkor megyünk tovább
putchar '0' ;ha igen, akkor kirakunk egy nullát
jmp binascii_vege ;és megyünk a végére

binascii_go1:
mov bx,10000 ;10000-rel fogunk osztani
xor dx,dx ;az osztás előtt nullázni kell a dx-et

binascii_cik1:
div bx ;osztjuk az ax-et bx-el
mov si,dx ;a maradék az si-be
cmp ax,0 ;ax=0?
jne binascii_go2 ;ha nem akkor binascii_go2-re
cmp flag,0 ;ha igen, akkor flag=0?
je binascii_go3 ;ha igen, ugrunk a binascii_go3-ra

binascii_go2:
add al,30h ;al-hez adjunk hozzá 30h, ASCII!
putchar al ;kitesszük a képernyőre
mov flag,1 ;már itt biztos volt kiírva karakter, ezért flag egyesbe

binascii_go3:
mov ax,bx ;az osztót osztani kell 10-el
mov bx,10 ;10-el
xor dx,dx ;dx nullázása, mint fent
div bx ;kinullazza a dx-et, osztjuk az ax-et
cmp ax,1 ;megnézzük ax=1?
jb binascii_vege ;ha kisebb mint 1, akkor vége
mov bx,ax ;ha nem, bx-be vissza az osztót
mov ax,si ;ax-be vissza a maradékot
jmp binascii_cik1 ;vissza az elejére

binascii_vege:
ret ;visszatérünk a főprogramba
binascii endp ;proc. vége

;ASCII karaktereket alakít számmá
asciibin proc near ;bemenet si - mutato buffer+1
;kimenet ax - bin ertek
mov cl,byte ptr[si] ;bevisszük a cl-be a beolvasott karakterek számát
xor ax,ax ;ax-et nullázzuk
cmp cl,0 ;megnézzük volt-e beolvasott karakter
ja asciibin_go1 ;ha igen, akkor tovább
jmp asciibin_vege ;ha nem akkor vége

asciibin_go1:
mov bx,10 ;10-el fogunk szorozni

asciibin_cik1:
mul bx ;dx nullázva, szorozzuk az ax-et bx-el
inc si ;si köv. elemre mutasson
mov dl,byte ptr[si] ;bevisszük dl-be a karaktert
sub dl,30h ;levonunk belőle 30h, lásd ASCII!
add ax,dx ;hozzáadjuk az ax-hez a számjegyet
dec cl ;cl-1
jnz asciibin_cik1 ;addig míg cl!=0 vissza az elejére

asciibin_vege:
ret ;visszatérés a főprogramba
asciibin endp ;proc. vége

;proc. a számsor kiírására
kiirszamsor proc near ;bemenet di - mutato a kiirando tombre, long a tomb hossza
mov cl,long

kiirszamsor_cik1:
xor ah,ah ;ah nullázása
mov al,byte ptr[di] ;al-be bevisszük a számot
wnum ax ;kiírjuk
putchar ',' ;kiírunk egy vesszőt is
inc di ;köv. index
dec cl ;cl-1
jnz kiirszamsor_cik1 ;addig míg cl nem nulla

putchar 8 ;eggyel vissza
putchar 32 ;kiír egy szóközt, tehát utolsó kar. törölve, mit jelent ez? miért is kellett? azért, mert az utolsó szám után is tettünk vesszőt, ezt kell eltüntetni
ret ;visszatérés a főprogramba
kiirszamsor endp ;proc. végge

;proc. a páros számok kiírására
kiirparos proc near ;bemenet di - mutato a kiirando tombre, long a tomb hossza
mov parosokszama,0
mov cl,long

kiirparos_cik1:
xor ah,ah
mov al,byte ptr[di]

test al,1 ;ugyanaz mint előbb, csak itt meg kell nézni, hogy a szám páros-e vagy sem, és aszerint kiírni, ezt végzi a test al,1, tehát megnézi, hogy a szám legalsó bitje 1-es-e, ha igen akkor páratlan, ha nem akkor páros, jnz azért, mert ha 1- es akkor zf=0, ekkor elugrunk..
jnz kiirparos_go1
wnum ax ;kiírjuk
putchar ','
inc parosokszama ;itt meg megszámoljuk

kiirparos_go1:
inc di
dec cl
jnz kiirparos_cik1

putchar 8
putchar 32
ret
kiirparos endp

;főprogram
start:
mov ax,cs ;adatszegmens kezdőcímének beállítása
mov ds,ax

clrscr ;képernyő törlése

kiir text1 ;text1 kiírása
kiir text2
wnum long ;kiírja, hogy mennyi számot kell beadni
kiir text3

mov index,1 ;index=1

cik1:
kiir newline ;új sort ír
wnum index ;kiírja hanyadik számot adjuk épp meg
kiir text4

mov ah,0ch ;bill. buffer törlése
mov al,0ah ;string beolvasása
mov dx,offset buffer_key ;ide kell menteni a beolvasott kar.-eket
int 21h

xor bx,bx ;bx nullázása, ezzel fogunk címezni

cik3:
cmp buffer_key[bx+2],30h ;meg kell nézni, hogy amit beírtak szám-e
jb go1
cmp buffer_key[bx+2],39h ;a számok az ASCII-ban a 30h-39h- s tartományban vannak
ja go1
inc bl
cmp bl,buffer_key[1] ;ha nem ütött le semmit, az is hiba
jb cik3
jmp go2

go1:
kiir hibauz1 ;itt írjuk ki a hibaüzit
jmp cik1

go2:
num buffer_key+1 ;most már jó, átalakítjuk számmá

mov si,index ;és elmentjük a buffer-ba
mov buffer_sort[si-1],al

inc index ;ha még nincs elég számunk, akkor olvasunk be
cmp index,long
jbe cik1

clrscr ;letöröljük a képernyőt
kiir text1

kiir text5
wszamsor buffer_sort ;kiírjuk a beolvasott számokat

kiir text6
wparos buffer_sort ;most csak a páros számokat írjuk ki

kiir text7
wnum parosokszama ;kiírjuk mennyi páros szám volt

kiir text8 ;kiírjuk a text8-at

mov ah,0ch ;bill. buffer törlése
mov al,7 ;várás egy karakterre echo nélkül
int 21h

mov ah,4ch ;vezérlés visszaadása az op.-nek
int 21h

code ends ;code nevű szegmens vége
end start ;start cimkénél kezdünk

;Program 08

08.zip 08.exe 08.asm

;Írjon programot, amely a beadott értékek halmazából kiválasztja a páros számokat, megjeleníti őket, és megjeleníti a mennyiségüket is. Jelentítse meg a beadott halmazt, amely 10 maximálisan kétjegyű egész számokból tartalmaz.

code segment ;code nevű szegmens létrehozása
assume cs:code,ds:code ;hozzárendelés

;a hossz szó jelentse azt, hogy 10
hossz=10 ;írhattuk volna azt is, hogy hossz EQU 10

;változók
szoveg1 db 'A megadott szamokbol a parosak kiirasa',13,10,36
szoveg2 db 13,10,'Adj meg $'
szoveg3 db ' szamot!',13,10,36
szoveg4 db '. szam: $'
szoveg5 db 13,10,'A beadott szamsor:',13,10,36
szoveg6 db 13,10,'Ebbol a paros szamok:',13,10,36
szoveg7 db 13,10,'A paros szamok szama: $'
szoveg8 db 13,10,13,10,'Nyomj le egy billentyut a kilepeshez...$'
ujsor db 13,10,36 ;újsor írására 36=’$’
buffer_szamok db hossz dup(0) ;buffer a beolvasott számoknak
hibauz db 13,10,'Max. 99!$' ;hibaüzi
buffer db 3,0,3 dup(0) ;a beolvasott kar. tárolására
paros dw 0 ;a páros számok megszámolására
i dw ? ;a tömb indexelésére

;macro string kiírására
kiir macro szoveg
mov ah,9
mov dx,offset szoveg
int 21h
endm ;macro vége

;macro egy karakter kiírására
putchar macro char
mov ah,2
mov dl,char
int 21h
endm

;macro szám kiírására
wnum macro param
mov ax,param
call binascii
endm

;macro ASCII kódú szám binárissá alakítására
num macro param
mov si,offset param
call asciibin
endm

;macro a számsor kiírására
wszamsor macro param
mov di,offset param
call kiirszamsor
endm

;macro a páros számok kiírására
wparos macro param
mov di,offset param
call kiirparos
endm

;macro a képernyő törlésére
clrscr macro
mov ax,3 ;80x25-ös mód beállítása, ezzel a kép. törlése
int 10h
endm

;proc. bináris szám ASCII kódban való kiírására
binascii proc near ;bemenet ax
jmp binascii_start ;átugorjuk a változót

flag db ?

binascii_start:
mov flag,0
cmp ax,0 ;ax=0?
jne binascii_go1 ;ha nem akkor megyünk tovább
putchar '0' ;ha igen, akkor kirakunk egy nullát
jmp binascii_vege ;és megyünk a végére

binascii_go1:
mov bx,10000 ;10000-rel fogunk osztani
xor dx,dx ;az osztás előtt nullázni kell a dx-et

binascii_cik1:
div bx ;osztjuk az ax-et bx-el
mov si,dx ;a maradék az si-be
cmp ax,0 ;ax=0?
jne binascii_go2 ;ha nem akkor binascii_go2-re
cmp flag,0 ;ha igen, akkor flag=0?
je binascii_go3 ;ha igen, ugrunk a binascii_go3-ra

binascii_go2:
add al,30h ;al-hez adjunk hozzá 30h, ASCII!
putchar al ;kitesszük a képernyőre
mov flag,1 ;már itt biztos volt kiírva karakter, ezért szemafor egyesbe

binascii_go3:
mov ax,bx ;az osztót osztani kell 10-el
mov bx,10 ;10-el
xor dx,dx ;dx nullázása, mint fent
div bx ;kinullazza a dx-et, osztjuk az ax-et
cmp ax,1 ;megnézzük ax=1?
jb binascii_vege ;ha kisebb mint 1, akkor vége
mov bx,ax ;ha nem, bx-be vissza az osztót
mov ax,si ;ax-be vissza a maradékot
jmp binascii_cik1 ;vissza az elejére

binascii_vege:
ret ;visszatérünk a főprogramba
binascii endp ;proc. vége

;ASCII karaktereket alakít számmá
asciibin proc near ;bemenet si - mutato buffer+1
;kimenet ax - bin ertek
mov cl,byte ptr[si] ;bevisszük a cl-be a beolvasott karakterek számát
xor ax,ax ;ax-et nullázzuk
cmp cl,0 ;megnézzük volt-e beolvasott karakter
ja asciibin_go1 ;ha igen, akkor tovább
jmp asciibin_vege ;ha nem akkor vége

asciibin_go1:
mov bx,10 ;10-el fogunk szorozni

asciibin_cik1:
mul bx ;dx nullázva, szorozzuk az ax-et bx-el
inc si ;si köv. elemre mutasson
mov dl,byte ptr[si] ;bevisszük dl-be a karaktert
sub dl,30h ;levonunk belőle 30h, lásd ASCII!
add ax,dx ;hozzáadjuk az ax-hez a számjegyet
dec cl ;cl-1
jnz asciibin_cik1 ;addig míg cl!=0 vissza az elejére

asciibin_vege:
ret ;visszatérés a főprogramba
asciibin endp ;proc. vége

;proc. a számsor kiírására
kiirszamsor proc near ;bemenet di - mutato a kiirando tombre, hossz a tomb hossza
mov cl,hossz

kiirszamsor_cik1:
xor ah,ah ;ah nullázása
mov al,byte ptr[di] ;al-be bevisszük a számot
wnum ax ;kiírjuk
putchar ',' ;kiírunk egy vesszőt is
inc di ;köv. i
dec cl ;cl-1
jnz kiirszamsor_cik1 ;addig míg cl nem nulla

putchar 8 ;eggyel vissza
putchar 32 ;kiír egy szóközt, tehát utolsó kar. törölve, mit jelent ez? miért is kellett? azért, mert az utolsó szám után is tettünk vesszőt, ezt kell eltüntetni
ret ;visszatérés a főprogramba
kiirszamsor endp ;proc. végge

;proc. a páros számok kiírására
kiirparos proc near ;bemenet di - mutato a kiirando tombre, hossz a tomb hossza
mov paros,0
mov cl,hossz

kiirparos_cik1:
xor ah,ah
mov al,byte ptr[di]

test al,1 ;ugyanaz mint előbb, csak itt meg kell nézni, hogy a szám páros-e vagy sem, és aszerint kiírni, ezt végzi a test al,1, tehát megnézi, hogy a szám legalsó bitje 1-es-e, ha igen akkor páratlan, ha nem akkor páros, jnz azért, mert ha 1- es akkor zf=0, ekkor elugrunk..
jnz kiirparos_go1
wnum ax ;kiírjuk
putchar ','
inc paros ;itt meg megszámoljuk

kiirparos_go1:
inc di
dec cl
jnz kiirparos_cik1

putchar 8
putchar 32
ret
kiirparos endp

;főprogram
start:
mov ax,cs ;adatszegmens kezdőcímének beállítása
mov ds,ax

clrscr ;képernyő törlése

kiir szoveg1 ;szoveg1 kiírása
kiir szoveg2
wnum hossz ;kiírja, hogy mennyi számot kell beadni
kiir szoveg3

mov i,1 ;i=1

cik1:
kiir ujsor ;új sort ír
wnum i ;kiírja hanyadik számot adjuk épp meg
kiir szoveg4

mov ah,0ch ;bill. buffer törlése
mov al,0ah ;string beolvasása
mov dx,offset buffer ;ide kell menteni a beolvasott kar.-eket
int 21h

xor bx,bx ;bx nullázása, ezzel fogunk címezni

cik3:
cmp buffer[bx+2],30h ;meg kell nézni, hogy amit beírtak szám-e
jb go1
cmp buffer[bx+2],39h ;a számok az ASCII-ban a 30h-39h- s tartományban vannak
ja go1
inc bl
cmp bl,buffer[1] ;ha nem ütött le semmit, az is hiba
jb cik3
jmp go2

go1:
kiir hibauz ;itt írjuk ki a hibaüzit
jmp cik1

go2:
num buffer+1 ;most már jó, átalakítjuk számmá

mov si,i ;és elmentjük a buffer-ba
mov buffer_szamok[si-1],al

inc i ;ha még nincs elég számunk, akkor olvasunk be
cmp i,hossz
jbe cik1

clrscr ;letöröljük a képernyőt
kiir szoveg1

kiir szoveg5
wszamsor buffer_szamok ;kiírjuk a beolvasott számokat

kiir szoveg6
wparos buffer_szamok ;most csak a páros számokat írjuk ki

kiir szoveg7
wnum paros ;kiírjuk mennyi páros szám volt

kiir szoveg8 ;kiírjuk a szoveg8-at

mov ah,0ch ;bill. buffer törlése
mov al,7 ;várás egy karakterre echo nélkül
int 21h

mov ah,4ch ;vezérlés visszaadása az op.-nek
int 21h

code ends ;code nevű szegmens vége
end start ;start cimkénél kezdünk

;Program 09

09.zip 09.exe 09.asm

;Írjon programot, amely a beadott értékek halmazát rendezi kisebbtől a nagyobbig. Jelenítse meg a beadott halmazt, amely 10 maximálisan kétjegyű egész számokból áll.

code segment ;code nevű szegmens létrehozása
assume cs:code,ds:code ;hozzárendelés

long EQU 10 ;a long jelentse azt, hogy 10, ezzel jelezzük a beolvasandó számok mennyiségét, egyben a tárolásukra használt tömb hossza

;változók
text1 db 'Legkisebbtol a legnagyobbig'
db 13,10,'---------------------------$'
text11 db 13,10,'Adj meg $'
text2 db ' szamot!',13,10,36
text3 db '. szam: $'
text4 db 13,10,13,10,'A beadott szamsor:',13,10,36
text5 db 13,10,13,10,'A szamok rendezve:',13,10,36
text6 db 13,10,13,10,'Nyomj le egy billentyut a kilepeshez...$'
newline db 13,10,36 ;új sor irásához
hibauz1 db 13,10,'A megadhato legnagyobb szam a 99!$'
buffer_key db 3,0,3 dup(0) ;ide olvassuk be az egyes karaktereket
buffer_sort db long dup(0) ;ide mentjük a beolvasott számokat
szemafor db ? ;binascii procedúrának
index dw ? ;a buffer_sort tömb indexelésére

;macro string kiírására
kiir macro text
mov ah,9
mov dx,offset text
int 21h
endm ;macro vége

;macro egy karakter kiírására
putchar macro char
mov ah,2
mov dl,char
int 21h
endm

;macro szám kiírására
wnum macro param
mov ax,param
call binascii
endm

num macro param
mov si,offset param
call asciibin
endm


;macro a számsor kiírására
wszamsor macro param
mov di,offset param
call kiirszamsor
endm

;macro a képernyő törlésére
clrscr macro
mov ax,3 ;80x25-ös mód beállítása, ezzel a kép. törlése
int 10h
endm

;procedúra bináris szám kiírására
binascii proc near ;bemenet ax
mov szemafor,0 ;szemafor nullázása
cmp ax,0 ;ax=0?
jne gop21 ;ha nem akkor megyünk tovább
putchar '0' ;ha igen, akkor kirakunk egy nullát
jmp vegep2 ;és megyünk a végére

gop21:
mov bx,10000 ;10000-rel fogunk osztani
xor dx,dx ;az osztás előtt nullázni kell a dx-et

cikp21:
div bx ;osztjuk az ax-et bx-el
mov si,dx ;a maradék az si-be
cmp ax,0 ;ax=0?
jne gop22 ;ha nem akkor gop22-re
cmp szemafor,0 ;ha igen, akkor szemafor=0?
je gop23 ;ha igen, ugrunk a gop23-ra

gop22:
add al,30h ;al-hez adjunk hozzá 30h, ASCII!
putchar al ;kitesszük a képernyőre
mov szemafor,1 ;már itt biztos volt kiírva karakter, ezért szemafor egyesbe

gop23:
mov ax,bx ;az osztót osztani kell 10-el
mov bx,10 ;10-el
xor dx,dx ;dx nullázása, mint fent
div bx ;kinullazza a dx-et, osztjuk az ax-et
cmp ax,1 ;megnézzük ax=1?
jb vegep2 ;ha kisebb mint 1, akkor vége
mov bx,ax ;ha nem, bx-be vissza az osztót
mov ax,si ;ax-be vissza a maradékot
jmp cikp21 ;vissza az elejére

vegep2:
ret ;visszatérünk a főprogramba
binascii endp ;proc. vége

;ASCII karaktereket alakít számmá
asciibin proc near ;bemenet si - mutato buffer+1
;kimenet ax - bin ertek
mov cl,byte ptr[si] ;bevisszük a cl-be a beolvasott karakterek számát
xor ax,ax ;ax-et nullázzuk
cmp cl,0 ;megnézzük volt-e beolvasott karakter
ja gop31 ;ha igen, akkor tovább
jmp vegep3 ;ha nem akkor vége

gop31:
mov bx,10 ;10-el fogunk szorozni

cikp31:
mul bx ;dx nullázva, szorozzuk az ax-et bx-el
inc si ;si köv. elemre mutasson
mov dl,byte ptr[si] ;bevisszük dl-be a karaktert
sub dl,30h ;levonunk belőle 30h, lásd ASCII!
add ax,dx ;hozzáadjuk az ax-hez a számjegyet
dec cl ;cl-1
jnz cikp31 ;addig míg cl!=0 vissza az elejére

vegep3:
ret ;visszatérés a főprogramba
asciibin endp ;proc. vége

;ez a lényeg, a rendező algoritmus
;bubblesort-ot használjuk, mivel kevés az elemszám
bubblesort proc near ;bemenet si - mutato a rendezendo tomb elso elemere, long a tomb hossza
jmp startp5 ;átugorjuk a változókat

;változók
p db ? ;egy szemafor, hogy tudjuk volt csere
buf dw ? ;buffer, amibe elmentjük az si kezdeti értékét

startp5:
mov buf,si ;előbb mondtam, itt mentjük el
mov dl,long ;dl-be azt, hogy mennyi bájtot kell rendezni

gop51:
mov p,0 ;p-t nullázzuk
mov si,buf ;si-be a kezdeti értékét
dec dl ;dl-be eggyel kevesebbet
jz vegep5 ;ha dl=0 akkor vége

mov cl,dl ;cl-be dl-t

atnezes:
mov al,byte ptr[si] ;bevisszük al-be, a buffer si-edik bájtját
cmp al,byte ptr[si+1] ;megnézzük hogyan viszonyul ez az elem a következővel
jbe gop52 ;LÉNYEGES RÉSZ! Ha kisebb akkor ugrunk, ha ezt átírjuk jae gop52-re akkor a legnagyobbtól a legkisebbig rendez

xchg al,byte ptr[si+1] ;felcseréljük a két elemet
mov byte ptr[si],al
mov p,1 ;és p-t egyesbe állítjuk

gop52:
inc si ;si köv. elemre mutasson
dec cl ;cl eggyel kevesebb
jnz atnezes ;ha cl még nem nulla, akkor vissza az elejére

cmp p,1 ;megnézzük p=1?
je gop51 ;ha igen, ugrunk

vegep5:
ret ;visszatérés a főprogramba
bubblesort endp ;proc. vége

;proc. a számsor kiírására
kiirszamsor proc near ;bemenet di - mutato a kiirando tombre, long a tomb hossza
mov cl,long ;cl-be a tömb hosszát

cikp61:
xor ah,ah ;ah nullázása
mov al,byte ptr[di] ;al-be a di által közvetlenül megcímzett memóriarekesz tartalmát, egy bájtot
wnum ax ;kiírjuk az ax-ben levő számot
putchar ',' ;kiteszünk egy vesszőt
inc di ;di köv. elemre
dec cl ;cl-1, a cl a ciklusszámláló, evvel adom meg, hogy mennyiszer fusson le a ciklus
jnz cikp61 ;addig míg cl nem nulla

putchar 8 ;heh, a végén maradt egy fölösleges vessző, ez nekünk nem kell, ezért a 8-as ASCII karakterrel visszalépünk egyet
putchar 32 ;és kiírunk egy SPACE-t (szóközt)
ret ;visszatérünk a főprogramba
kiirszamsor endp

;főprogram
start:
mov ax,cs ;adatszegmens kezdőcímének beállítása
mov ds,ax

clrscr ;képernyő törlése

;kezdőképernyő felépítése
kiir text1 ;text1 kiírása
kiir text11
wnum long ;ez azért, hogy ha átírjuk fent a long-ot, akkor az alapján írja ki, hogy adj meg xxx számot
kiir text2

mov index,1 ;index 1-esbe

;ez a rész olvassa be a számokat
cik1:
kiir newline ;új sor
wnum index ;hanyadik számnál vagyunk? írjuk ki
kiir text3 ;és azt is, hogy . szám:

mov ah,0ch ;bill. buffer törlése
mov al,0ah ;string beolvasása a bill.-ről
mov dx,offset buffer_key ;a buffer_key-be
int 21h ;let’s go

;itt végignézzük a beolvasott karaktereket, ha mindegyik számjegy volt akkor ok, és elmentjük, ha nem akkor hibaüzi, és nem mentünk
xor bx,bx ;bx nullázása

cik3:
cmp buffer_key[bx+2],30h
jb go1 ;a karakter kisebb mint 30h=’0’? Ha igen az baj
cmp buffer_key[bx+2],39h
ja go1 ;a karakter nagyobb mint 39h=’9’ Ha igen az baj
inc bl ;köv. elem
cmp bl,buffer_key[1]
jb cik3 ;addig míg végig nem nézzük a tömb összes elemét
jmp go2 ;ha ide eljutuk, akkor mehetünk tovább

go1:
kiir hibauz1 ;hibaüzi kiírása
jmp cik1 ;és vissza az elejére

go2:
num buffer_key+1 ;átalakítjuk a buffer_key-ben levő számot, hogy miért buffer_key+1? Lásd a asciibin proc.!

mov si,index ;elmentjük a számot
mov buffer_sort[si-1],al ;a tömbünkbe

inc index ;index a köv. elemre
cmp index,long ;megnézzük kell-e még elem
jbe cik1 ;ha igen, akkor olvasunk még

;kész, a számokat beolvastuk
clrscr ;kép. törlése
kiir text1 ;text1 kiírása

kiir text4 ;text4 kiírása
wszamsor buffer_sort ;a beolvasott számok kiírása

mov si,offset buffer_sort ;rendezés
call bubblesort

kiir text5 ;a rendezett számsor kiírása
wszamsor buffer_sort

kiir text6 ;a nyomj egy bill.-t a kilépéshez kiírása

mov ah,0ch ;bill. buffer törlése
mov al,7 ;várás egy bill.-re echo nélkül
int 21h

mov ah,4ch ;vezérlés visszaadása az op.-nek
int 21h

code ends ;code szegmens vége
end start ;start cimkénél a program belépési pontja

;Program 10

10.zip 10.exe 10.asm

;Írjon programot, amely beadott értékek halmazát rendezi nagyobbtól a kisebbig, és megjeleníti őket a képernyőn. Jelenítse meg a beadott halmazt is, amely 10 maximálisan kétjegyű egész számot tartalmaz.

code segment ;code nevű szegmens létrehozása
assume cs:code,ds:code ;hozzárendelés

hossz EQU 10 ;a hossz jelentse azt, hogy 10, ezzel jelezzük a beolvasandó számok mennyiségét, egyben a tárolásukra használt tömb hossza

;változók
szoveg1 db 'Legkisebbtol a legnagyobbig',13,10,36
szoveg11 db 13,10,'Adj meg $'
szoveg2 db ' szamot!',13,10,36
szoveg3 db '. szam: $'
szoveg4 db 13,10,13,10,'A beadott szamsor:',13,10,36
szoveg5 db 13,10,13,10,'A szamok rendezve:',13,10,36
szoveg6 db 13,10,13,10,'Nyomj le egy billentyut a kilepeshez...$'
newline db 13,10,36 ;új sor irásához
hibauz1 db 13,10,'Min 0, max 99!$'
buffer_key db 3,0,3 dup(0) ;ide olvassuk be az egyes karaktereket
buffer_sort db hossz dup(0) ;ide mentjük a beolvasott számokat
szemafor db ? ;binascii procedúrának
i dw ? ;a buffer_sort tömb indexelésére

;macro string kiírására
pstring macro szoveg
mov ah,9
mov dx,offset szoveg
int 21h
endm ;macro vége

;macro egy karakter kiírására
putchar macro char
mov ah,2
mov dl,char
int 21h
endm

;macro szám kiírására
writenumber macro param
mov ax,param
call binascii
endm

number macro param
mov si,offset param
call asciibin
endm


;macro a számsor kiírására
writeszamsor macro param
mov di,offset param
call pstringszamsor
endm

;macro a képernyő törlésére
clrscr macro
mov ax,3 ;80x25-ös mód beállítása, ezzel a kép. törlése
int 10h
endm

;procedúra bináris szám kiírására
binascii proc near ;bemenet ax
mov szemafor,0 ;szemafor nullázása
cmp ax,0 ;ax=0?
jne gop21 ;ha nem akkor megyünk tovább
putchar '0' ;ha igen, akkor kirakunk egy nullát
jmp vegep2 ;és megyünk a végére

gop21:
mov bx,10000 ;10000-rel fogunk osztani
xor dx,dx ;az osztás előtt nullázni kell a dx-et

cikp21:
div bx ;osztjuk az ax-et bx-el
mov si,dx ;a maradék az si-be
cmp ax,0 ;ax=0?
jne gop22 ;ha nem akkor binascii_go2-re
cmp szemafor,0 ;ha igen, akkor szemafor=0?
je gop23 ;ha igen, ugrunk a binascii_go3-ra

gop22:
add al,30h ;al-hez adjunk hozzá 30h, ASCII!
putchar al ;kitesszük a képernyőre
mov szemafor,1 ;már itt biztos volt kiírva karakter, ezért szemafor egyesbe

gop23:
mov ax,bx ;az osztót osztani kell 10-el
mov bx,10 ;10-el
xor dx,dx ;dx nullázása, mint fent
div bx ;kinullazza a dx-et, osztjuk az ax-et
cmp ax,1 ;megnézzük ax=1?
jb vegep2 ;ha kisebb mint 1, akkor vége
mov bx,ax ;ha nem, bx-be vissza az osztót
mov ax,si ;ax-be vissza a maradékot
jmp cikp21 ;vissza az elejére

vegep2:
ret ;visszatérünk a főprogramba
binascii endp ;proc. vége

;ASCII karaktereket alakít számmá
asciibin proc near ;bemenet si - mutato buffer+1
;kimenet ax - bin ertek
mov cl,byte ptr[si] ;bevisszük a cl-be a beolvasott karakterek számát
xor ax,ax ;ax-et nullázzuk
cmp cl,0 ;megnézzük volt-e beolvasott karakter
ja gop31 ;ha igen, akkor tovább
jmp vegep3 ;ha nem akkor vége

gop31:
mov bx,10 ;10-el fogunk szorozni

cikp31:
mul bx ;dx nullázva, szorozzuk az ax-et bx-el
inc si ;si köv. elemre mutasson
mov dl,byte ptr[si] ;bevisszük dl-be a karaktert
sub dl,30h ;levonunk belőle 30h, lásd ASCII!
add ax,dx ;hozzáadjuk az ax-hez a számjegyet
dec cl ;cl-1
jnz cikp31 ;addig míg cl!=0 vissza az elejére

vegep3:
ret ;visszatérés a főprogramba
asciibin endp ;proc. vége

;ez a lényeg, a rendező algoritmus
;bubblesort-ot használjuk, mivel kevés az elemszám
bubblesort proc near ;bemenet si - mutato a rendezendo tomb elso elemere, hossz a tomb hossza
jmp startp5 ;átugorjuk a változókat

;változók
p db ? ;egy szemafor, hogy tudjuk volt csere
buf dw ? ;buffer, amibe elmentjük az si kezdeti értékét

startp5:
mov buf,si ;előbb mondtam, itt mentjük el
mov dl,hossz ;dl-be azt, hogy mennyi bájtot kell rendezni

gop51:
mov p,0 ;p-t nullázzuk
mov si,buf ;si-be a kezdeti értékét
dec dl ;dl-be eggyel kevesebbet
jz vegep5 ;ha dl=0 akkor vége

mov cl,dl ;cl-be dl-t

atnezes:
mov al,byte ptr[si] ;bevisszük al-be, a buffer si-edik bájtját
cmp al,byte ptr[si+1] ;megnézzük hogyan viszonyul ez az elem a következővel
jae gop52 ;LÉNYEGES RÉSZ! Ha kisebb akkor ugrunk, ha ezt átírjuk jbe gop52-re akkor a legkisebbtől a legnagyobbig rendez

xchg al,byte ptr[si+1] ;felcseréljük a két elemet
mov byte ptr[si],al
mov p,1 ;és p-t egyesbe állítjuk

gop52:
inc si ;si köv. elemre mutasson
dec cl ;cl eggyel kevesebb
jnz atnezes ;ha cl még nem nulla, akkor vissza az elejére

cmp p,1 ;megnézzük p=1?
je gop51 ;ha igen, ugrunk

vegep5:
ret ;visszatérés a főprogramba
bubblesort endp ;proc. vége

;proc. a számsor kiírására
pstringszamsor proc near ;bemenet di - mutato a pstringando tombre, hossz a tomb hossza
mov cl,hossz ;cl-be a tömb hosszát

cikp61:
xor ah,ah ;ah nullázása
mov al,byte ptr[di] ;al-be a di által közvetlenül megcímzett memóriarekesz tartalmát, egy bájtot
writenumber ax ;kiírjuk az ax-ben levő számot
putchar ',' ;kiteszünk egy vesszőt
inc di ;di köv. elemre
dec cl ;cl-1, a cl a ciklusszámláló, evvel adom meg, hogy mennyiszer fusson le a ciklus
jnz cikp61 ;addig míg cl nem nulla

putchar 8 ;heh, a végén maradt egy fölösleges vessző, ez nekünk nem kell, ezért a 8-as ASCII karakterrel visszalépünk egyet
putchar 32 ;és kiírunk egy SPACE-t (szóközt)
ret ;visszatérünk a főprogramba
pstringszamsor endp

;főprogram
start:
mov ax,cs ;adatszegmens kezdőcímének beállítása
mov ds,ax

clrscr ;képernyő törlése

;kezdőképernyő felépítése
pstring szoveg1 ;szoveg1 kiírása
pstring szoveg11
writenumber hossz ;ez azért, hogy ha átírjuk fent a hossz-ot, akkor az alapján írja ki, hogy adj meg xxx számot
pstring szoveg2

mov i,1 ;i 1-esbe

;ez a rész olvassa be a számokat
cik1:
pstring newline ;új sor
writenumber i ;hanyadik számnál vagyunk? írjuk ki
pstring szoveg3 ;és azt is, hogy . szám:

mov ah,0ch ;bill. buffer törlése
mov al,0ah ;string beolvasása a bill.-ről
mov dx,offset buffer_key ;a buffer_key-be
int 21h ;let’s go

;itt végignézzük a beolvasott karaktereket, ha mindegyik számjegy volt akkor ok, és elmentjük, ha nem akkor hibaüzi, és nem mentünk
xor bx,bx ;bx nullázása

cik3:
cmp buffer_key[bx+2],30h
jb go1 ;a karakter kisebb mint 30h=’0’? Ha igen az baj
cmp buffer_key[bx+2],39h
ja go1 ;a karakter nagyobb mint 39h=’9’ Ha igen az baj
inc bl ;köv. elem
cmp bl,buffer_key[1]
jb cik3 ;addig míg végig nem nézzük a tömb összes elemét
jmp go2 ;ha ide eljutuk, akkor mehetünk tovább

go1:
pstring hibauz1 ;hibaüzi kiírása
jmp cik1 ;és vissza az elejére

go2:
number buffer_key+1 ;átalakítjuk a buffer_key-ben levő számot, hogy miért buffer_key+1? Lásd a asciibin proc.!

mov si,i ;elmentjük a számot
mov buffer_sort[si-1],al ;a tömbünkbe

inc i ;i a köv. elemre
cmp i,hossz ;megnézzük kell-e még elem
jbe cik1 ;ha igen, akkor olvasunk még

;kész, a számokat beolvastuk
clrscr ;kép. törlése
pstring szoveg1 ;szoveg1 kiírása

pstring szoveg4 ;szoveg4 kiírása
writeszamsor buffer_sort ;a beolvasott számok kiírása

mov si,offset buffer_sort ;rendezés
call bubblesort

pstring szoveg5 ;a rendezett számsor kiírása
writeszamsor buffer_sort

pstring szoveg6 ;a nyomj egy bill.-t a kilépéshez kiírása

mov ah,0ch ;bill. buffer törlése
mov al,7 ;várás egy bill.-re echo nélkül
int 21h

mov ah,4ch ;vezérlés visszaadása az op.-nek
int 21h

code ends ;code szegmens vége
end start ;start cimkénél a program belépési pontja

;Program 11

11.zip 11.exe 11.asm

;Írjon programot szöveges állomány létrehozására a lemezen, és a megtöltésére a bill. beadott karakterekkel. A tevékenység befejező karakterének az ESC bill. válassza. Megjegyzés: a vezérlő billentyűket, nyilakat és a Backspace bill. ignorálja!

code segment ;code nevű szegmens létrehozása
assume cs:code,ds:code ;hozzárendelés

;változók
text1 db 'Add meg a kivant fajlnevet: $'
text2 db 13,10,'Nyomj le egy billentyut a folytatashoz...$'
text3 db 13,10,'A szoveg sikeresen elmentve a(z) $'
text4 db ' allomanyba!$'
hibauz1 db 13,10,'Nem talalom az utat!$'
hibauz2 db 13,10,'Nincs engedelyezve a hozzaferes!$'
hibauz3 db 13,10,'Ismeretlen hiba!$'
hibauz4 db 13,10,'Nem tudom letrehozni a fajlt! (Lehet, hogy mar letezik?)$'
file dw ? ;FILE HANDLE szám eltárolására
szemaforfile db 0 ;volt-e megnyitott fájl
buffer_key db 65,0,65 dup(0) ;ide mentjük a beolvasott fájlnevet
ir db ? ;ide mentjük a beolvasott karaktert

;macro string kiírására
ps macro text
mov ah,9
mov dx,offset text
int 21h
endm ;macro vége

;macro egy karakter olvasására echo nélkül
olvas macro
mov ah,0ch
mov al,7
int 21h
endm

;macro a képernyő törlésére
clrscr macro
mov ax,3 ;váltunk 80x25-ös módba, evvel töröljük a kép.
int 10h
endm

;főprogram
start:
mov ax,cs ;adatszegmens kezdőcímének beállítása
mov ds,ax
cld ;df nullazása

clrscr ;képernyő törlése
ps text1 ;text1 kiírása

mov ah,0ch ;bill. buffer törlése
mov al,0ah ;fájlnév beolvasása
mov dx,offset buffer_key ;ide olvasunk
int 21h ;csináld!

xor bh,bh ;bh nullázása, azért, mert a bx-et fogjuk használni, de nem fogunk írni a bh-ba
mov bl,buffer_key[1] ;bl-be a beolvasott karakterek száma
mov buffer_key[bx+2],0 ;ez alapján a string végére egy nullát

mov ah,3dh ;a fájl megnyitása, azért, hogy ne írjuk felül
xor al,al ;normal file, al=0
mov dx,offset buffer_key[2] ;buffer_key első két bájtját át kell ugorni
int 21h
jc go1 ;ha megnyitotta, akkor az nekünk hiba

ps hibauz4 ;kiírjuk hogy hiba
jmp abort ;és kilépunk

go1:
mov ah,3ch ;létrehozunk fájlt írásra
xor cx,cx ;normal fájl, cx=0
mov dx,offset buffer_key[2] ;fájl neve
int 21h
jc hiba ;ha hiba keletkezett, akkor ugrunk
mov file,ax ;file-be a FILE HANDLE szám
mov szemaforfile,1 ;szemafor egyesbe, hisz most nyitottuk meg

ps text2 ;text2 kiírása
olvas ;várunk egy karakterre
clrscr ;képernyő törlése

cik1:
olvas ;egy karakter beolvasása echo nélkül
mov ir,al ;elmentjük ezt a karaktert

cmp ir,27 ;megnézzük nem ESCAPE-e
je go2 ;ha igen, ugrunk
;itt leellenőrizzuk, hogy „normális” karaktert ütött le, nem valami speciális vezérlőt
cmp ir,20h ;norm. karakterek 20h-tól 7fh-ig
jb cik1 ;ha kisebb mint ez, akkor vissza az elejére
cmp ir,7fh
ja cik1 ;szintén, csak ha nagyobb

mov ah,40h ;írás fájlba
mov bx,file ;file-ba
mov cx,1 ;1 bájtot
mov dx,offset ir ;„ir nevű bájtot”
int 21h

mov ah,2 ;kiírjuk a képernyőre is
mov dl,ir
int 21h

jmp cik1 ;vissza az elejére

go2:
xor bh,bh ;bh nullázása, mint előbb fent
mov bl,buffer_key[1]
mov buffer_key[bx+2],'$' ;csak most a végére egy dollárjelet teszünk, mert a 9-es DOS szolgáltatással akarjuk kiírni

ps text3 ;text3 kiírni
ps buffer_key[2] ;első két bájtot nem kell kiírni
ps text4 ;a szöveg további része

jmp vege ;ugrás végére, átugorjuk a hibaüziket

hiba:
cmp ax,3 ;ax=3?
jz hiba1 ;ha igen, akkor ugrunk
cmp ax,5 ;ax=5?
jz hiba2 ;ha igen, akkor ugrunk

ps hibauz3 ;ha egyik se, akkor ismeretlen hiba
jmp vege ;ugrunk végére

hiba1:
ps hibauz1 ;kiírjuk a hibauz1-et
jmp vege ;ugrás végére

hiba2:
ps hibauz2

vege:
cmp szemaforfile,1 ;megnézzük volt-e megnyitott fájl
jnz abort ;ha nem akkor vége

mov ah,3eh ;ha volt, lezárjuk
mov bx,file
int 21h

abort:
mov ah,4ch ;visszaadjuk a vezérlést az op.-nek
int 21h

code ends ;code nevű szegmens vége
end start ;start cimkénél kezdünk

;Program 12

12.zip 12.exe 12.asm

;Írjon programot a szöveges állományok megjelenítésére a képernyőn. Az állomány nevét kérje be a billentyűzetről. Ha a megadott állomány nem létezik, jelenítsen meg hibaüzenetet: "A megadott állomány nem létezik!". A képernyő betelésekor az utolsó sorban jelenítse meg: "Üss le egy billentyűt a folytatáshoz...".

code segment ;code szegmens létrehozása
assume cs:code,ds:code ;hozzárendelés

;változók
buffer_file db ?
buffer_key db 65,0,65 dup(0)
text1 db 'File: $'
text2 db 13,10,'Press any key to continue or q to terminate... $'
text3 db 13,10,'Press any key to terminate... $'
hibauz1 db 13,10,'Cant find the path$'
hibauz2 db 13,10,'Access denied!$'
hibauz3 db 13,10,'The file doesnt exist!$'
hibauz4 db 13,10,'Unknown error$'
file dw ?
szemafor db 0

;egy egyszerű procedúra, kiírja a képernyőre a dx-be megadott stringet, majd pedig vár egy bill. leütésére
waitproc proc near ; bemenet: dx, kimenet: con, al
mov ah,9 ;kiírjuk
int 21h

mov ah,0ch ;töröljük a buffert
mov al,07h ;várunk egy bill.-re
int 21h
ret ;visszatérünk
waitproc endp

start:
mov ax,cs ;adatszegmens beállítása
mov ds,ax
cld ;df nullázása, string kiírás miatt

mov ah,9 ;kiírjuk a kezdőszöveget
lea dx,text1 ;bevisszük a dx-be a text1 offsetcímét
int 21h

mov ah,0ch ;bill. buffer törlése
mov al,0ah ;fájlnév beolvasása
lea dx,buffer_key
int 21h

xor bh,bh ;bh törlése
mov bl,buffer_key[1] ;bevisszük bl-be hány karaktert olvastunk be
mov buffer_key[bx+2],0 ;a buffer végére teszünk egy 0-at

mov ah,3dh ;megnyitjuk a fájlt
xor al,al ;normal fájl
lea dx,buffer_key
add dx,2 ;az első két bájtot átugorjuk
int 21h
jc hiba ;ugrunk, ha hiba van
mov file,ax ;elmentjuk a FILE HANDLE-t
mov szemafor,1 ;szemafor egyesbe, mert van megnyitott fájl

mov ax,3 ;töröljük a képernyőt, 80x25 módba váltással
int 10h

cik1:
mov ah,3fh ;olvasunk a fájlból
mov bx,file ;FILE HANDLE bevitele bx-be
mov cx,1 ;1 bájtot fogunk olvasni
lea dx,buffer_file ;ide fogunk olvasni
int 21h
jc hiba ;hiba - ugrunk
cmp ax,0 ;ha ax = 0 és nem volt hiba, EOF – vége a fájlnak
jz vege ;tehát befejezzük a programot

mov ah,3 ;megnézzük a képernyő hányadik sorába vagyunk
mov bh,0 ;nulladik „lapon” vagyunk
int 10h
cmp dh,23 ;ha a 24. sorba vagyunk „figyelünk”
jz felt1 ;megnézzük, hogy mi teljesül még
jmp ird ;ha nem a 24. sorba kiírjuk a beolvasott bájtot

felt1:
cmp dl,79 ;vizsgálódunk tovább, 80. oszlopba vagyunk
jz varj ;ha igen, ez azt jelenti: 24. sor 80. oszlop > kiírjuk a „Press any key to continue”-t
cmp buffer_file,10 ;az is fontos, hogy ha nem is vagyunk a 80. oszlopba, ha a fájlban új sort kezdünk, már akkor is ki kell írni a szöveget
jz varj

ird:
mov ah,2 ;kiírjuk a beolvasott bájtot
mov dl,buffer_file
int 21h
jmp cik1 ;újra előre és olvasunk

varj:
lea dx,text2 ;megadjuk, hogy mit akarunk kiírni
call waitproc ;kiírjuk és várunk
cmp al,'q' ;megnézzük, mit nyomtunk le
jz abort ;ha q-t kilépünk

mov ax,3 ;töröljük a képernyőt, 80x25-s módba való lépéssel
int 10h

cmp buffer_file,10 ;ha új sort kezdtünk a fájlba, ezt nem írjuk ki az új képernyőre
jnz ird
jmp cik1 ;újra előre és olvasunk

hiba:
cmp ax,3 ;megnézzük milyen hiba keletkezett
jz hiba1 ;és aszerint ugrunk
cmp ax,5
jz hiba2
cmp ax,2
jz hiba3

mov ah,9 ;ha egyik se, kiírjuk, hogy ismeretlen
lea dx,hibauz4
int 21h
jmp vege

hiba1:
mov ah,9
lea dx,hibauz1
int 21h
jmp vege

hiba2:
mov ah,9
lea dx, hibauz2
int 21h
jmp vege

hiba3:
mov ah,9
lea dx,hibauz3
int 21h

vege:
lea dx,text3 ;kiírjuk a text3-at és várunk egy bill.-re
call waitproc

cmp szemafor,0 ;megnézzük volt-e megnyitva fájl
jz abort ;ha nem kilépünk

mov ah,3eh ;ha igen, bezárjuk
mov bx,file
int 21h

abort:
mov ah,4ch ;a vezérlés visszaadása az op-nek
int 21h

code ends ;code szegmens lezárása
end start ;start cimkénél lépünk be a programba]

;Program 13

13.zip 13.exe 13.asm

;Írjon programot, ami kitöröli az aktuális mappából az összes fájlt, amely régebbi mint a billentyűzetről megadott dátum.

code segment ;code nevű szegmens létrehozása
assume cs:code,ds:code ;hozzárendelés

;változók
asciiz db '*.*',0 ;4eh ill. 4fh szolg. mit keressen: az ;aktuális mappában az összes fájlt, utána döntjük el, hogy ;törölni kell vagy sem
text1 db 'Add meg a datumot nn-hh-ee formaban: $'
text2 db 13,10,10,'A program most kitorli az osszes allomanyt az aktualis mappabol,'
db 13,10, 'amelyek regebbiek mint az aktualis datum!'
db 13,10,10,'Szeretne folytatni? y/n: $'
text3 db 13,10,10,'Hiba keletkezett, a program most befejezodik...$'
text4 db 13,10,10,'Uss le barmilyen billentyut...$'
text5 db 13,10,10,'A fajlok kitorolve!$'
text6 db 13,10,10,'Nem lett kitorolve semmilyen allomany!$'
chyba1 db 13,10,10,'Hiba lepett fel, probald meg meg egyszer!$'
buffer db 9,0,9 dup(0) ;a beolvasott dátum tárolására
dta db 128 dup(0) ;a dta-nak
evm db ? ;a beolvasott dátumból az év tárolására
hom db ? ;a hónap
napm db ? ;ill. a nap
flag db ? ;volt törölve fájl? ez mondja meg, hogy igen vagy ;nem

;macro text kiírására
write macro text
mov ah,9
mov dx,offset text
int 21h
endm

;proc. ascii ==> bináris átalakításra
asciibin proc near ;bemenet si - mutato buffer, cl hossz
;kimenet ax - bin ertek
xor ax,ax
cmp cl,0 ;kicsit módosítottam, itt a hosszt a cl ;tartalmazza
ja asciibin_go1
ret

asciibin_go1:
mov bx,10

asciibin_cik1:
mul bx ;dx nullázva, ax szorozva bx-el
mov dl,byte ptr[si]
sub dl,30h ;levonunk 30h-át, mert ASCII kódú, és nekünk ;binárisan kell
add ax,dx ;hozzáadjuk a dx-et az ax-hez
inc si
dec cl
jnz asciibin_cik1

ret ;visszatérés a főprogramba
asciibin endp

;macro, a buf-ban levő két drb. karaktert alakítja számmá, és ;elmenti a kam nevű változóba
prem macro buf,kam
mov si,offset buf
mov cl,2
call asciibin
mov kam,al
endm

;főprogram
start:
mov ax,cs ;adatszegmens kezdőcímének beállítása
mov ds,ax
cld ;df nullázása

mov ah,1ah ;dta kezdőcímének beállítása
mov dx,offset dta
int 21h

mov flag,0 ;flag nullázása

go3:
mov ax,3 ;képernyő letörlése 80x25-ös módba való lépéssel
int 10h
write text1 ;text1 kiírása

mov ah,0ch ;bill. buffer törlése
mov al,0ah ;string beolvasása a bill.-ről
mov dx,offset buffer ;a buffer-ba
int 21h

cmp buffer[1],8 ;megvan az összes 8 drb karaktert?
jne go3 ;ha nincs, hát bazmeg mégegyszer elölről

cmp buffer[4],'-' ;a megadott dátumnak megadott formája ;van, két drb – jel van benne, ha ezek nincsenek a helyükön ;akkor hibás
jne go3 ;és ugyanúgy mint előbb, vissza az elejére
cmp buffer[7],'-'
jne go3

prem buffer[8],evm ;átalakítjuk a megadott stringet ;dátummá, most az évet
cmp evm,99 ;nem lehet nagyobb mint 99, ha csak 2 ;számjegyet lehet megadni, most hívom fel a figyelmet, hogy a ;program csak 2000 utáni fájlokat képes törölni
ja go3
add evm,20 ;hozzáadunk 20-at, mert a dta-ban 2008-1980=28 ;lesz, és nem 8, tehát ő 1980-tól számolja, te meg 2000-től ;adtad meg

prem buffer[5],hom ;átalakítjuk a hónapokat is
cmp hom,0 ;hónap nem lehet nulla...
je go3
cmp hom,12 ;se nagyobb mint 12
ja go3

prem buffer[2],napm ;a napok átalakítása
cmp napm,0 ;nem lehet nulla
je go3
cmp napm,31 ;se nagyobb mint 31
ja go3

write text2 ;text2 kiírása

go2:
mov ah,0ch ;bill. buffer törlése
mov al,7 ;egy karakter beolvasása echo nélkül
int 21h
cmp al,'y' ;ha igen, akkor ugrás tovább
je go1
cmp al,'n' ;ha nem, hát nem, tehát vége
jne go7
jmp konec ;ha egyik se, újból kar. bekérése

go7:
jmp go2 ;azért nem közvetlenül, mert túl messze van ahova ;ugorni akarunk, feltételes ugrás már oda nem tud ugorni

go1:
mov ah,4eh ;első fájl keresése
mov dx,offset asciiz ;minden fájl az aktuális mappában
mov cx,0 ;normal fájlokat keresünk
int 21h
jc nebolsubor ;nem volt fájl, akkor cf=1

cik1:
xor ah,ah ;ah nullázása
mov al,dta[19h] ;a fájl dátumának bevitele az al-be
shr al,1 ;eltoljuk 1-el, hogy miért? lásd dta felépítése

cmp al,evm ;az al-ben már az év van, összehasonlítjuk a ;mi évünkkel
jb vym ;ha kisebb, akkor lehet törölni
cmp al,evm ;ha nagyobb akkor nem
ja go5

;ha egyenlő akkor vagy igen, vagy nem.. megyünk tovább
mov ax,word ptr dta[18h] ;most a hónap jön
mov cl,5 ;5-el fogunk shiftelni
shr ax,cl ;shiftelünk
and al,0fh ;és itt and-elünk is, mert ki kell lőni az al ;felső négy bitjét, lásd dta felépítése, dátum rész

cmp al,hom ;ugyanaz mint előbb, csak most a hónappal
jb vym
cmp al,hom
ja go5

xor ah,ah ;ah nullázása
mov al,dta[18h] ;most ez a bájt kell a dta-ból
and al,1fh ;felső 3 bit kilövése

cmp al,napm ;ha kisebb a nap, csak akkor lehet törölni
jb vym
jmp go5

vym:
mov ah,41h ;itt törlünk
mov dx,offset dta[1eh] ;a fájlnév innen kezdődik
int 21h
jc chyba ;ha nem sikerült hiba
mov flag,1 ;már volt törölt fájl

go5:
mov ah,4fh ;köv. fájl keresése
mov dx,offset asciiz
mov cx,0 ;normal fájl
int 21h
jc vymkonec ;ha nincs több fájl, akkor vége
jmp cik1 ;máskülönben vissza az elejére

vymkonec:
cmp flag,1 ;ha vége, akkor megkérdi: volt kitörölt fájl?
jne nebolsubor ;ha nem, akkor kiírja hogy nem

write text5 ;ha igen, akkor hogy igen
jmp konec ;és vége

nebolsubor:
write text6 ;nem volt törölve fájl
jmp konec ;és vége

chyba:
write chyba1 ;ha valami hiba történt, akkor ezt írja ki

konec:
write text4 ;és vége

mov ah,0ch ;bill. buffer törlése
mov al,7 ;egy kar.-ra várás echo nélkül
int 21h

mov ah,4ch ;a vezérlés visszaadása az op.-nek
int 21h

code ends ;code nevű szegmens vége
end start ;start cimkénél kezdünk

;Program 14

14.zip 14.exe 14.asm

;Írjon programot, amely szöveges állományt bővíti egy a billentyűzetről beadott sorral. A fájl nevét kérje be a billentyűzetről. Ha nem létezik, akkor jelenítsen meg hibaüzenetet.

code segment ;code szegmens létrehozása
assume cs:code,ds:code ;hozzárendelés

;változók
buffer db 255,0,255 dup(0)
newline db 13,10,36
text1 db 'File: $'
text2 db 13,10,'Add text: ',13,10,36
text3 db 13,10,'The operation was successful!$'
hibauz1 db 13,10,'Cant find the path!$'
hibauz2 db 13,10,'Access denied!$'
hibauz3 db 13,10,'File doesnt exist!$'
hibauz4 db 13,10,'Unknown error!$'
file dw ?
szemafor db 0

start:
mov ax,cs ;adatszegmens kezdőcímének beállítása
mov ds,ax
cld ;df nullázása

mov ah,9 ;kiírjuk a text1-et
lea dx,text1
int 21h

mov ah,0ch ;bill. buffer törlése
mov al,0ah ;karakterek beolvasása a „buffer”-ba
lea dx,buffer
int 21h

xor bh,bh ;bh nullázása
mov bl,buffer[1] ;bl-be beolvasott karakterek száma
mov buffer[bx+2],0 ;a végére egy nulla

mov ah,3dh ;fájl megnyitása
lea dx,buffer[2] ;az első két bájtot átugorjuk
mov al,1 ;írni akarunk a fájlba
int 21h
jc hiba ;ha hiba, ugrunk
mov file,ax ;elmentjük a FILE HANDLE-t
mov szemafor,1 ;igen, van megnyitott fájl

mov ah,42h ;beállítjuk a fájlmutatót
mov al,2 ;a végétől számítva
mov bx,file
xor dx,dx ;nulla eltolás
xor cx,cx ;nulla eltolás, tehát a végén áll a fájlmutató
int 21h
jc hiba ;ha hiba történt ugrunk

mov ah,9 ;kiírjuk a text2-t
lea dx,text2
int 21h

mov ah,0ch ;bill. buffer törlése
mov al,0ah ;kar. beolvasása
lea dx,buffer ;a bufferba
int 21h

mov ah,40h ;írunk a fájlba
mov bx,file
mov cx,2 ;2 bájtot
lea dx,newline ;új sort
int 21h
jc hiba ;ha nem sikerült, ugrunk

mov ah,40h ;megint írunk
mov bx,file
xor ch,ch ;a ch-t nullázzuk
mov cl,buffer[1] ;a beolvasott kar. számának megfelelő bájtot írunk a fájlba
lea dx,buffer[2] ;első két bájt átugorva
int 21h
jc hiba ;ha hiba, ugrunk

mov ah,9 ;kiírjuk a text3-at
lea dx,text3
int 21h

jmp vege ;ugrunk a végére

hiba:
cmp ax,3 ;hibák lekezelése, megállapítjuk, mennyi volt az ax-be
jz hiba1 ;és aszerint ugrunk
cmp ax,5
jz hiba2
cmp ax,2
jz hiba3

mov ah,9 ;kiírjuk, hogy ismeretlen hiba...
lea dx,hibauz4
int 21h
jmp vege

hiba1:
mov ah,9 ;itt meg kiírjuk a megfelelő hibaüzit
lea dx,hibauz1
int 21h
jmp vege

hiba2:
mov ah,9
lea dx,hibauz2
int 21h
jmp vege

hiba3:
mov ah,9
lea dx,hibauz3
int 21h

;itt a vége, fuss el véle
vege:
cmp szemafor,1 ;ha volt megnyitott fájl, be kell zárni
jnz vege_v ;ha nem, hát nem

mov ah,3eh ;itt zárjuk be
mov bx,file
int 21h

vege_v:
mov ah,4ch ;vezérlés vissza op.-nek
int 21h
code ends ;code szegmens vége
end start ;start cimkénél kezdünk

;Program 15

15.zip 15.exe 15.asm

;Írjon programot, amely megjeleníti a leütött billentyű hexadecimális és decimális kódját.

code segment ;code nevű szegmens létrehozása
assume cs:code,ds:code ;hozzárendelés

;változók
text1 db 'A leutott billentyu kodjanak megjelenitese'
db 13,10,'------------------------------------------'
db 13,10,'Uss ESC-t a kilepeshez!',13,10,13,10
db 13,10,'A leutott billentyu kodja:'
db 13,10,'--------------------------'
db 13,10,'Decimalis :'
db 13,10,'Hexadecimalis:'
db 13,10,'--------------------------$'
newline db 13,10,36 ;újsor
spec db '0+$' ;ha speciális bill. volt leütve, ezzel jelezzük
torles db 10 dup(32) ;hehe, ez érdekes, kiírunk 10 szóközt
db 10 dup(8),36 ;aztán meg visszalépünk 10-et, tehát letöröltünk 10 karaktert
kar db ? ;ide mentjük a beolvasott karaktert
szemaforspec db 0 ;ezzel jelezzük, hogy speciális bill. volt leütve

;macro string kiírására
printstring macro text
mov ah,9
mov dx,offset text
int 21h
endm ;macro vége

;macro egy karakter kiírására
putchar macro char
mov ah,2
mov dl,char
int 21h
endm

;macro a kurzor áthelyezésére
gotoxy macro x,y
mov ah,2
xor bh,bh ;0-dik lap
mov dh,y ;dh-ba a sor koordinátája
mov dl,x ;dl-be az oszlopé
int 10h ;ezt egy BIOS szolgáltatás végzi
endm

;procedura bináris szám kiírására
binascii proc near ;bemenet ax
jmp startp1 ;átugorujuk a változókat

szemaforbin db ? ;kezdeti nullákat nem akarjuk kiírni, ezért kell ez, hogy tudjuk, már volt kiírva szám, már lehet írni a nullákat

startp1: ;itt kezdünk
mov szemaforbin,0 ;nullázzuk
cmp ax,0 ;megnézzük, nem nullát kaptunk-e
jne gop11 ;ha nem továbbugrunk
putchar '0' ;ha igen, kiírunk egy nullát
jmp vegep1 ;és ugrunk a végére

gop11:
mov bx,10000 ;10000-rel fogunk osztani
xor dx,dx ;dx-et nullázni kell, lásd div utasítás

cikp11:
div bx ;osztjuk az ax-et 10000-rel
mov si,dx ;maradék si-be
cmp ax,0 ;megnézzük ax-ben nulla van-e
jne gop12 ;ha nem akkor kiírjuk
cmp szemaforbin,0 ;ha volt már kiírva szám akkor kiírjuk, ha nem akkor nem írjuk ki
je gop13

gop12:
mov ah,2 ;kiírjuk a számjegyet
mov dl,al
add dl,30h ;ASCII kód! ezért kell +30h
int 21h
mov szemaforbin,1 ;itt már biztos volt kiírt szám, ezért a szemafor 1-esbe

gop13:
mov ax,bx ;az osztót osztjuk 10-el
mov bx,10
xor dx,dx ;mint az előbb, nullázni kell!
div bx ;osztunk
cmp ax,1 ;ax=1?
jb vegep1 ;ha kisebb akkor vége
mov bx,ax ;vissza a bx-be az osztót
mov ax,si ;ax-be meg az előbbi maradékot
jmp cikp11 ;vissz az elejére

vegep1:
ret ;visszatérés

binascii endp ;a proc. vége

;procedúra hexadecimális kiíráshoz
hexascii proc near ;bemenet ax
jmp startp2 ;átugorjuk a kezdeti változókat

;változók
szemaforhex1 db ? ;nullák indikálása
s1 db ? ;ennyivel kell majd shiftelni a számot
char db ? ;ide mentjük a számjegyet
temp dw ? ;elmentjük az elején az ax-et

startp2:
mov szemaforhex1,0 ;beálligatjuk a szemafort
mov bx,0f000h ;bx-ben lesz a maszk
mov s1,16 ;16-nyit shiftelünk először
mov temp,ax ;elmentjük az ax-et

cikp21:
mov ax,temp ;visszahozzuk az ax-et
sub s1,4 ;s1-4, mindig 4-el kevesebbet kell shiftelni

and ax,bx ;na itt a lényeg, az ax mindig csak 4 bitjét nézzük a többit kilőjük
mov cl,s1 ;shifteljük az al „elejére”
shr ax,cl ;itt
mov char,al ;és elmentjük a char-ba

mov cl,4 ;a maszkot is shiftelni kell
shr bx,cl

cmp char,0 ;megnézzük 0-át kaptunk-e
jne gop21 ;ha nem akkor tovább
cmp szemaforhex1,0 ;ha igen, megnézzük: volt már kiírva szám?
je gop22 ;ha nem akkor nem írjuk ki, ugrás végére

gop21:
cmp char,9 ;megnézzük számjegy, vagy betű amit kaptunk
ja gop23 ;ha betű, ugrunk

add char,30h ;ha számjegy, akkor 30h-t kell hozzáadni
putchar char ;és kiírni

jmp gop25 ;ugrás végére

;ha betű
gop23:
cmp szemaforhex1,0 ;megnézzük volt-e már kiírva számjegy
jne gop24 ;ha nem...
putchar '0' ;...akkor kiírunk egy nullát

gop24:
add char,37h ;a betűhez ennyit kell hozzáadni,
;65-10=55=37h, 65 az A betű kódja
putchar char ;és kiírjuk

gop25:
mov szemaforhex1,1 ;biztos volt kiírva karakter, szemafor egyesbe

gop22:
cmp s1,0 ;végén vagyunk már?
jne cikp21 ;ha s1-be nincs 0, akkor vissza az elejére

putchar 'h' ;a végére egy h betűt
ret ;visszatérünk
hexascii endp ;proc. vége

;főprogram
start:
mov ax,cs ;adatszegmens beállítása
mov ds,ax
cld ;df nullázása

mov ax,3 ;képernyő törlése, 80x25-ös módba való lépéssel
int 10h ;ezt egy BIOS szolgáltatás végzi

printstring text1 ;kiírjuk a text1-et

mov ah,1 ;eltüntetjük a kurzort
mov ch,20h
int 10h

cik1:
mov ah,0ch ;bill. buffer törlése
mov al,7 ;egy karakter beolvasása echo nélkül
int 21h
mov kar,al ;elmentjük a karaktert

cmp kar,0 ;megnézzük nem spec. bill. volt leütve
jne go1 ;ha nem, akkor tovább
mov ah,7 ;ha igen, lekéjük a második bájtot is
int 21h
mov kar,al ;és elmentjük a kar-ba
mov szemaforspec,1 ;igen, spec. karakter volt, elmentjük, hogy később tudjuk

go1:
gotoxy 15,7 ;kurzor mozgatása a 8. sor 16. oszlopára
printstring torles ;letörölni, ami ott van

cmp szemaforspec,1 ;volt spec. karakter?
jne go3 ;ha nem, tovább
printstring spec ;ha igen, kiírjunk egy jelet, hogy speciális kar., itt. egy 0+ -t

go3:
xor ah,ah ;ah nullázása
mov al,kar ;al-ba bevisszük a kar-t
call binascii ;kiírjuk

gotoxy 15,8 ;most ugyanez, csak hexa-ban
printstring torles

cmp szemaforspec,1
jne go4
printstring spec
mov szemaforspec,0 ;de itt már nullázni kell a spec. szemafort, hogy legközelebb is működjön

go4:
xor ah,ah
mov al,kar
call hexascii ;csak itt hexa-ban írjuk ki

cmp kar,27 ;addig ismételjük, míg ESC nem volt ütve
jz go2 ;itt ez enged ki ebből a ciklusból
jmp cik1

go2:
printstring newline ;írunk egy újsort, csak, hogy szép legyen

mov ah,1 ;a kurzort azért láthatóvá tesszük
mov cx,1f0eh
int 10h

mov ah,4ch ;a vezérlés vissza az op.-nek
int 21h

code ends ;code szegmens vége
end start ;start cimke a program belépési pontja

;Program 16

16.zip 16.exe 16.asm

;Írjon programot, amely kinyomtat egy állományt. Az állomány nevét kérje be a billentyűzetről.

code segment ;code nevű szegmens létrehozása
assume cs:code,ds:code ;hozzárendelés

;változók
buffer db 65,0,65 dup(0) ;buffer a fájl nevére
kar db ? ;egy karaktert olvasunk mindig a fájlból, ide mentjük
text1 db 'Fajl: $' ;szövegek, amiket kiírunk a képernyőre
text2 db 13,10,'Press any key...$'
text3 db 13,10,'A nyomtatas kesz!$'
hibauz1 db 13,10,'Nem talalom az utat$'
hibauz2 db 13,10,'Hozzaferes megtagadva!$'
hibauz3 db 13,10,'A fajl nem letezik!$'
hibauz4 db 13,10,'Szamomra ismeretlen hiba$$'
file dw ? ;FILE HANDLE elmentésére
szemafor db 0 ;szemafor – volt-e megnyitva fájl

;macor string kiírására
pstring macro text
mov ah,9
mov dx,offset text
int 21h
endm

;főprogram
start:
mov ax,cs ;adatszegmens kezdőcímének beállítása
mov ds,ax
cld ;df nullázása

pstring text1 ;text1 kiírása

mov ah,0ch ;bill. buffer törlése
mov al,0ah ;string beolvasása
mov dx,offset buffer ;a buffer-ba
int 21h

xor bh,bh ;bh nullázása
mov bl,buffer[1] ;mennyi karaktert olvastunk be ? bl-be
mov buffer[bx+2],0 ;a végére egy nulla

mov ah,3dh ;fájl megnyitása
xor al,al ;csak olvasásra
mov dx,offset buffer[2] ;a buffer 3. bájtjától a fájlnév
int 21h
jc hiba ;ha hiba, ugorj
mov file,ax ;FILE HANDLE elmentése
mov szemafor,1 ;szem. egyesbe

cik1:
mov ah,3fh ;olvasunk
mov bx,file ;a fájlból
mov cx,1 ;egy bájtot
mov dx,offset kar ;a kar-ba
int 21h
jc hiba ;ha nem sikerült, hiba
cmp ax,0 ;ha ax=0, fájlvége
jz veg

mov ah,5 ;kiírjuk a nyomdára, LPT1
mov dl,kar ;a kar-t
int 21h

jmp cik1 ;és vissza az elejére, a cmp ax,0 // jz veg enged ki

veg:
mov ah,5 ;még kiírunk egy 13,10-et, hogy a buffer-ba levő dolgokat kinyomtassa
mov dl,13
int 21h
mov dl,10
int 21h

pstring text3 ;text3 kiírása
jmp vege ;a hibaüzik átugrása

hiba:
cmp ax,3 ;ax=3?
jz hiba1 ;ezek alapján kezeljük le a hibát
cmp ax,5
jz hiba2
cmp ax,2
jz hiba3

pstring hibauz4 ;ha egyik se, ismeretlen
jmp vege

hiba1:
pstring hibauz1
jmp vege

hiba2:
pstring hibauz2
jmp vege

hiba3:
pstring hibauz3

vege:
pstring text2

mov ah,0ch ;bill. buffer törlése
mov al,7 ;várás egy karakterre echo nélkül
int 21h

cmp szemafor,0 ;volt megnyitott fájl?
jz abort

mov ah,3eh ;ha igen, lezárjuk
mov bx,file
int 21h

abort:
mov ah,4ch ;vezérlés vissza az op.-nek
int 21h

code ends ;code szegmens vége
end start ;start cimkénél kezdünk

;Program 17

17.zip 17.exe 17.asm

;Írjon programot, amely átnevez egy állományt. Az állomány régi és új nevét kérje be a billentyűzetről.

code segment ;code nevű szegmens létrehozása
assume cs:code,ds:code,es:code ;hozzárendelés

;változók
oldname db 65,0,65 dup(0) ;a régi név tárolására
newname db 65,0,65 dup(0) ;az új név tárolására
text1 db 'Regi nev: $' ;szövegek
text2 db 13,10,'Uj nev: $'
text3 db 13,10,'A muvelet sikeresen elvegezve!$'
hibauz1 db 13,10,'A muvelet vegrehajtasa kozben hiba keletkezett!$'

;macro string kiírására
kiir macro text
mov ah,9
mov dx,offset text
int 21h
endm ;macro vége

;macro szöveg beolvasására
beolvas macro mibe
mov ah,0ch ;bill. buffer törlése
mov al,0ah
mov dx,offset mibe ;hova mentjük
int 21h
endm

;a megadott string végére egy 0-t tesz
vegenulla macro minek
push bx ;elmentjük a bx-et
xor bh,bh ;a bh-t nullázzuk
mov bl,minek[1] ;a második bájtja a string hossza
mov minek[bx+2],0 ;itt tesszük a végére a nullát
pop bx ;visszatesszük a bx-et
endm ;macro vége

;főprogram
start:
mov ax,cs ;szegmenscímek beállítása
mov ds,ax ;adatszegmens
mov es,ax ;extraszegmens
cld ;df nullázása

kiir text1 ;text1 kiírása
beolvas oldname ;régi fájlnév beolvasása
vegenulla oldname ;a végére egy nulla, lásd ASCIIZ

kiir text2 ;ugyanez csak az új névvel
beolvas newname
vegenulla newname

mov ah,56h ;evvel a szolg. nevezem át
mov dx,offset oldname[2] ;csak a 3. bájttól van a fájlnév
mov di,offset newname[2] ;ugyanúgy
int 21h
jc hiba ;ha hiba akkor azt írjuk ki hogy hiba

kiir text3 ;ha nem, akkor azt, hogy sikeres
jmp vege

hiba:
kiir hibauz1

vege:
mov ah,4ch ;a vezérlés visszaadása az op.-nek
int 21h

code ends ;code nevű szegmens vége
end start ;start cimke a program belépési pontja

;Program 18

18.zip 18.exe 18.asm

;Írjon programot, amely megjeleníti a billentyűzetről megadott számú kiszolgáló alprogram logikai címét hexadecimálisan és dekadikusan.

code segment ;code nevű szegmens létrehozása
assume cs:code,ds:code ;hozzárendelés

;változók
text1 db 'Alprogram logikai cime'
db 13,10,'**********************$'
text2 db 13,10,'Add meg az alprogram szamat (0-255): $'
text3 db 13,10,13,10,'A megadott alprogram logikai cime:'
db 13,10,'**********************************'
db 13,10,'Decimalis : $'
text4 db 13,10,'Hexadecimalis: $'
text5 db 13,10,'**********************************'
db 13,10,13,10,'Nyomj le barmilyen billentyut a kilepeshez...$'
hibauz1 db 13,10,'Az alprogram szama 0-255!$'
buffer db 4,0,4 dup(0) ;buffer a szám beolvasására
szam dw ? ;ide mentjük a beolvasott számot
szegmens dw ? ;ide a kiolvasott szegmenscímet
offsetcim dw ? ;ide a kiolvasott offsetcímet

;macor egy string kiírására
kiir macro text
mov ah,9
mov dx,offset text
int 21h
endm

;macro egy karakter kiírására
putchar macro char
mov ah,2
mov dl,char
int 21h
endm

;procedúra egy bináris szám kiírására
binascii proc near ;bemenet ax
mov bx,10000 ;10000-rel fogunk osztani
xor dx,dx ;az osztás előtt dx-et nullázni

cikp11:
div bx ;osztjuk az ax-et bx-el
mov si,dx ;a maradékot az si-be

mov ah,2 ;kiírjuk az al-ben megkapott számjegyet
mov dl,al
add dl,30h ;ASCII karakter!, ezért kell a +30h
int 21h

mov ax,bx ;az osztót 10-zel osztjuk
mov bx,10 ;10-zel
xor dx,dx ;mint fent
div bx ;osztjuk akkor végre
cmp ax,1 ;megnézzük ax=1?
jb vegep1 ;ha kisebb mint 1, akkor vége
mov bx,ax ;az osztót a bx-be
mov ax,si ;vissza a maradékot az ax-be
jmp cikp11 ;vissza az elejére

vegep1:
ret ;visszatérés a főprogramba

binascii endp

;procedúra hexadecimális kiírásra
hexascii proc near ;bemenet ax
jmp startp2 ;átugorjuk a változókat

s1 db ? ;ennyivel fogjuk shiftelni az ax-et
char db ? ;ide tesszük a kapott karaktert
temp dw ? ;tároljuk az ax-et

startp2:
mov bx,0f000h ;a bx-ben lesz a maszk, amivel mindig kiütjuk az ax bizonyos bitjeit,mindig csak 4 fog maradni, ez jelentve egy számjegyeet
mov s1,16 ;először ennyivel shifteljük az ax-et
mov temp,ax ;elmentjük az ax-et

cikp21:
mov ax,temp ;minden ciklus elején visszatesszük az ax eredeti tartalmát
sub s1,4 ;az s1-ből levonunk 4-et, mert minden egyes futás után 4-el kevesebbszer kell shiftelni

and ax,bx ;na itt ütjük ki az ax bizonyos bitjeit
mov cl,s1
shr ax,cl ;és shifteljük s1-el
mov char,al ;így a 4 bit átkerül az al aljára, el tudjuk már menteni

mov cl,4 ;a bx-et is „arrébb” kell tenni
shr bx,cl

cmp char,9 ;megnézzük, hogy a karakter, amit kaptunk nagyobb mint 9?
ja gop21 ;ha igen akkor valami A,B,C,... kell kiírni, tehát elugrunk

add char,30h ;ha ide eljutunk, akkor számjegyet írunk ki
putchar char ;kiírjuk

jmp gop22 ;megyünk a gop22-re

gop21:
add char,37h ;itt írjuk betűket
putchar char ;na akkor írjuk

gop22:
cmp s1,0 ;s1 már nulla?
jne cikp21 ;ha nem akkor még ismétlünk

putchar 'h' ;a végén kiteszünk egy h-t
ret ;visszatérünk
hexascii endp ;a proc. vége

;proc. ascii-bináris átalakításra
;a beolvasott karakter átalakítására
asciibin proc near ; bemenet si - mutato buffer+1
; kimenet ax - bin ertek

mov cl,byte ptr[si] ;a beolvasott karakterek számát elmentjük a cl-be
xor ax,ax ;ax-et nullázzuk
cmp cl,0 ;ha nem volt beolvasott karakter, nullát adunk vissza
ja gop31 ;ha volt akkor, tovább
ret ;visszatérünk

gop31:
mov bx,10 ;10-el fogunk szorozni

cikp31:
mul bx ;dx nullazva, szorozzuk az ax-et
inc si ;si növelése 1-el
mov dl,byte ptr[si] ;dl-be az aktuális karakter
sub dl,30h ;levonunk belőle 30h-t, ASCII!
add ax,dx ;hozzáadjuk az ax-hez
dec cl ;cl dekrementálása
jnz cikp31 ;addig míg cl nulla nem lesz

ret ;visszatérés a főprogramba

asciibin endp ;proc. vége

;főprogram
start:
mov ax,cs ;adatszegmens kezdőcímének beállítása
mov ds,ax
cld ;df nullázása

mov ax,3 ;képernyő letörlése, 80x25-ös módba való lépéssel
int 10h

kiir text1 ;kiírjuk a kezdeti dolgokat

cik1:
kiir text2 ;kiírjuk, hogy add meg a számot
mov ah,0ch ;bill. buffer törlése
mov al,0ah ;karakterek beolvasása a bill.-ről
mov dx,offset buffer ;a buffer-ba
int 21h

xor bx,bx ;a bx törlése
cik2:
cmp buffer[bx+2],30h ;megnézzük itt, hogy mindegyik beolvasott karakter szám volt-e
jb go1 ;ha nem, ugrunk a go1-re, ahol kiírjuk, hogy hiba, és megadja újból
cmp buffer[bx+2],39h
ja go1
inc bl
cmp bl,buffer[1]
jb cik2

mov si,offset buffer+1
call asciibin ;átalakítjuk a buffer-ban lévő karaktereket számmá

cmp ax,00ffh ;megnézzük nem adott-e túl nagy számot,
;255-nél nagyobbat
ja go1 ;ha igen, hiba
cmp buffer[1],0 ;ha nem adott meg számot, hiba
je go1
jmp go2

go1:
kiir hibauz1 ;itt írjuk ki a hibaüzit
jmp cik1 ;és visszaküldjük az elejére

go2:
mov szam,ax ;a számot elmenjtük az ax-be

mov ax,0000h ;ax-be nulla
mov es,ax ;ezt az es-be

mov cl,2 ;a szam-ot megszorozzuk kettővel
shl szam,cl

mov si,szam ;si-be a szam

mov ax,word ptr es:[si] ;na itt hozzuk be az ax-be az offsetcímet
mov offsetcim,ax ;és elmentjük az offsetcim nevű változóba
mov ax,word ptr es:[si+2] ;ez ugyanaz csak a szegmenscímmel, lásd a megszakításvektor-táblázat
mov szegmens,ax

;most már csak kiírjuk
kiir text3 ;kiírjuk, hogy decimális
mov ax,szegmens ;átvisszük ax-be
call binascii ;kiírjuk
putchar ':' ;kiírunk egy kettőspontot
mov ax,offsetcim ;kiírjuk az offsetet is
call binascii

kiir text4 ;ugyanaz pepitába – hexába
mov ax,szegmens
call hexascii
putchar ':'
mov ax,offsetcim
call hexascii

kiir text5 ;kiírjuk, hogy nyomj bármilyen bill.-t

mov ah,0ch ;bill. buffer törlése
mov al,7 ;várunk egy bill.-re
int 21h

mov ah,4ch ;vezérlés vissza az op.-nek
int 21h

code ends ;code nevű szegmens vége
end start ;start cimkénél kezdünk

;Program 19

19.zip 19.exe 19.asm

;Írjon programot, amely az aktuális mappában létrehoz egy mappát a bill. megadott névvel, és az aktuális könyvtárrá teszi.

code segment ;szegmens nyitása
assume cs:code,ds:code ;hozzárendelés a kód ill. adatszeg.hez

;változók létrehozása
text1 db 'Almappa neve (max 8 karakter): $'
hibauz1 db 13,10,'Hiba: az ut nem talalhato!$'
hibauz2 db 13,10,'Hiba: az eleres nincs engedelyezve!$'
hibauz3 db 13,10,'Hiba: nem adtal meg eleresi utat!',13,10,36
hibauz4 db 13,10,'Hiba: ismeretlen!$'
buffer db 9,0,9 dup(0)

start:
mov ax,cs ;beállítjuk az adatszegmens-t
mov ds,ax
cld ;0-ba állítjuk a DF-et, a szövegkiíráshoz

cik1:
mov ah,09h ;kiírjuk a text1-et
mov dx,offset text1
int 21h

mov ah,0ch ;billentyűzetbuffer törlése
mov al,0ah ;mappanév beolvasása a bufferba
mov dx,offset buffer
int 21h

cmp buffer[1],0 ;megnézzük, hogy van-e beolvasott karakter
jnz tovabb ;ha van továbbmegyünk

mov ah,9 ;ha nincs hibaüzi
mov dx,offset hibauz3
int 21h
jmp cik1 ;és vissza az elejére

tovabb:
xor dh,dh ; dh törlése
mov dl,buffer[1] ;beolvasott karakterek számának bevitele a dl-be
mov di,dx ;ezt átvisszük a di-be
mov buffer[di+2],0 ;a végére teszünk egy 0-át

mov ah,39h ;létrehozom az alkönyvtárat
mov dx,offset buffer
add dx,2 ;ez azért kell, hogy a buffer első két bájtját átugorjuk
int 21h
jc hiba ;ha hiba történt ugrunk

mov ah,3bh ;aktuálissá tesszük a létrehozott alkönyvtárat
mov dx,offset buffer
add dx,2 ;ugyanaz mint előbb
int 21h
jc hiba ;ugrunk, ha hiba történt

jmp vege ;átugorjuk a hibaüziket

hiba:
cmp ax,3 ;megnézzük, melyik „hiba” történt
jz hiba1
cmp ax,5
jz hiba2

mov ah,09h ;nem tudjuk pontosan, kiírjuk, hogy ismeretlen
mov dx,offset hibauz4
int 21h

jmp vege ;ugrunk a végére

hiba1:
mov ah,09h ;hibaüzi kiírása
mov dx,offset hibauz1
int 21h
jmp vege

hiba2:
mov ah,09h ;hibaüzi kiírása
mov dx,offset hibauz2
int 21h

vege:
mov ah,4ch ;befejezzük a programot
int 21h

code ends ;lezárjuk a code nevű szegmenst
end start ;start cimkénél kezdünk

;Program 20

20.zip 20.exe 20.asm

;Írjon programot, amely az aktuális könyvtárban létrehoz egy állományt a könyvtárban levő állományok nevével.

code segment ;code nevű szegmens létrehozása
assume cs:code,ds:code ;hozzárendelés

;változók
dta db 128 dup(0)
asciiz1 db 'FILELIST.TXT',0
asciiz2 db '*.*',0
newline db 13,10,36
text1 db 'A lista sikeresen letrehozva a FILELIST.TXT allomanyba!$'
hibauz1 db 'Nem talalom az utat!$'
hibauz2 db 'Nincs engedelyezve a hozzaferes!$'
hibauz3 db 'Nem talalhato fajl!$'
hibauz4 db 'Ismeretlen hiba!$'
hibauz5 db 'Nem tudom letrehozni a fajlt! (Lehet, hogy mar letezik?)$'
file dw ?
szemaforfile db 0
szemaforelso db 0

start:
mov ax,cs ;adatszegmens kezdőcímének beállítása
mov ds,ax
cld ;df nullázása

mov ah,1ah ;dta beállítása
mov dx,offset dta
int 21h

mov ah,4eh ;fájl keresése az adott mappában
mov dx,offset asciiz2
mov cx,0 ;normal fájlokat keresünk
int 21h
jc hiba ;ha hiba keletkezett, ugrunk

mov ah,3dh ;megpróbáljuk megnyitni a FILELIST.TXT fájlt
;ha megnyitja, akkor létezik, ha nem akkor létrehozzuk
xor al,al ;csak olvasásra nyitjuk meg
mov dx,offset asciiz1 ;a fájlnév címét a dx-be
int 21h
jc go1 ;ha nem létezik akkor továbbmegyünk

mov ah,9 ;ha igen, hibaüzenet
mov dx,offset hibauz5
int 21h
jmp abort ;és kilépünk

go1:
mov ah,3ch ;létrehozzuk a fájlt
xor cx,cx ;normal fájl
mov dx,offset asciiz1 ;átadjuk a nevét
int 21h
jc hiba ;ha nem sikerült létrehozni, ugrunk a hibára
mov file,ax ;elmentjük a FILE HANDLE-t
mov szemaforfile,1 ;beállítjuk a szemaforfile-t 1-re, hogy
;a végén tudjuk, hogy volt megnyitott fájl

cik1:
cmp szemaforelso,0 ;először nem kell új sor
jz go2 ;tehát átugorjuk

mov ah,40h ;itt írjuk az új sort a fájlba
mov bx,file ;bxbe tesszük, hogy melyik fájlba akarunk írni
mov cx,2 ;két bájtot írunk
mov dx,offset newline ;ezt írjuk
int 21h
jc hiba ;ha hiba ugrunk

go2:
mov szemaforelso,1 ;többször már nem kell átugorni
mov di,1eh ;innen nézzük végig a dta-t

cik2:
cmp dta[di],0 ;meg kell számolni mennyi bájtot kell kiírni
lea di,[di+1] ;ezt nem vettük, de így szinte tökéletes:D
jnz cik2

mov cx,di ;cx-be kell a kiírni kívánt bájtok száma
sub cx,1fh ;de a di-be pont 1fh-val több van

mov ah,40h ;beírjuk a fájlba
mov bx,file ;melyikbe?
mov dx,offset dta[1eh] ;mit?
int 21h

mov ah,4fh ;keressük tovább a további fájlokat
int 21h
jnc cik1 ;ha van akkor kiírjuk, ha nincs akkor kész

mov ah,9 ;kiírunk egy üzit, hogy kész
mov dx,offset text1
int 21h

jmp vege ;és ugrunk a végére

;hibák kezelése
hiba:
cmp ax,3 ;megnézzük mi volt az ax-be, aszerint ugrunk
jz hiba1
cmp ax,5
jz hiba2
cmp ax,12h
jz hiba3

mov ah,9
mov dx,offset hibauz4
int 21h
jmp vege

hiba1:
mov ah,9 ;ezekkel kiírjuk a hibaüziket
mov dx,offset hibauz1
int 21h
jmp vege

hiba2:
mov ah,9
mov dx,offset hibauz2
int 21h
jmp vege

hiba3:
mov ah,9
mov dx,offset hibauz3
int 21h
jmp vege

;itt a vége, fuss el véle... :D
vege:
cmp szemaforfile,1 ;ha volt megnyitva fájl akkor a szemafor 1-es, és be kell zárni
jnz abort ;ha nem akkor vége

mov ah,3eh
mov bx,file
int 21h

abort:
mov ah,4ch ;korrektül bezárjuk a programot
int 21h

code ends ;code szegmens vége
end start ;start cimkén kezdünk

;Program 21

21.zip 21.exe 21.asm

;Írjon programot, amely a billentyűzetről karaktereket olvas be, és megjeleníti őket a képernyőn. A program az end szó beírásával ér véget, de ez a szó már nem jelenik meg a képernyőn.

code segment ;code nevű szegmens létrehozása
assume cs:code,ds:code ;hozzárendelés

long EQU 3 ;long szó jelentse azt, hogy 3, a fordító minden long szó helyére 3-at fog írni, az kilépő szó hosszát jelöli

;változók
escape db 'end' ;erre a karakterláncra fogunk kilépni
text db 'Karakterek elolvasasa a bill.-rol az end szo beirasaig.',13,10,36 ;36 = ’$’
kar db ?
torleskar db 8,32,8,36
newline db 13,10,36

;egy macro a képernyőn lévő karakterek törlésére
;a hanyszor jelöli, hogy hány karaktert fog letörölni
;ez az egyetlen paramétere
torles macro hanyszor
local cikm1 ;lokális cimke

push cx ;elmentjük a cx-et
mov cx,hanyszor ;a cx lesz a ciklusváltozónk

cikm1:
mov ah,9 ;kiírjuk a torleskar-t, ezzel törlünk egy karaktert, lásd torleskar felépítése, 8-as ASCII karakter
mov dx,offset torleskar
int 21h
loop cikm1 ;addig ismételjük, ameddig a cx nulla nem lesz
;azaz annyiszor amennyit a hanyszor-ban megadtunk

pop cx ;visszatesszük a cx tartalmát
endm ;vége a macro-nak

start:
mov ax,cs ;beállítjuk az adatszegmenst
mov ds,ax
mov ax,0b800h ;az es-t beállítjuk a videomemória kezdőcímére
mov es,ax
cld ;df=0

mov ax,3 ;letöröljük a képernyőt, 80x25-ös módba lépéssel
int 10h ;BIOS szolgáltatás

mov ah,9 ;kiírjuk a text1-et
mov dx,offset text
int 21h

;a cik1 ciklust fogjuk ismételgetni
cik1:
mov ah,0ch ;bill. buffer törlése
mov al,7 ;egy karakter beolvasása echo nélkül
int 21h
mov kar,al ;elmentjük a beolvasott karaktert a kar változóba

;itt megnézzük mi volt az elolvasott karakter
cmp kar,13 ;ha 13 volt akkor az ENTER volt leütve
je go1 ;tehát egy új sor kell, hát ugrunk oda, ahol ezt tesszük
cmp kar,8 ;ha 8-as, akkor a BACKSPACE volt leütve
je go1 ;ekkor törlünk egy karaktert
cmp kar,32 ;ez 32-127 közötti karakterek azok, amiket kiírunk, a többi vezérlőkarakter, ezekkel nem foglalkozunk
jb cik1
cmp kar,127
jae cik1

mov ah,2 ;ha ide eljutunk, akkor kiírjuk a kar-t
mov dl,kar
int 21h

mov ah,3 ;lekérjük az aktuális kurzorpozíciót
mov bh,0 ;nulladik lapon vagyunk, ez nem olyan fontos
int 10h ;egy BIOS szolgáltatással kérjük le

;na a helyzet az, hogy mi közvetlenül a videomemóriát fogjuk vizsgálni, nincs e a képernyőn az end szó
;ehhez viszont az aktuális lekért kurzorpozíciókat át kell kicsit alakítani

shl dl,1 ;az oszlopokat meg kell szorozni kettővel
mov al,dh ;a sorokat meg 160-al
mov bl,160
mul bl ;itt csináljuk ezt

mov si,ax ;az si-vel címezzük a videomemóriát
mov al,dl
xor ah,ah
add si,ax

;itt már az si az aktuális pozícióra mutat a videomem-ben
;azt a bájtot címzi, ahol épp villog a kurzor

mov di,long ;egy ciklus, összehasonlítjuk az utolsó 3 karaktert az end szóval
cik2:
sub si,2 ;a videomem-ben kettővel kell lépkednünk
dec di ;a end szóban eggyel
mov al,byte ptr es:[si]
cmp al,escape[di] ;itt hasonlítunk egy karaktert
jne cik1 ;ha nem egyezik vissza az elejére
cmp di,0 ;ha már di 0 akkor végignéztük az egészet
jnz cik2

jmp vege ;ha ide eljutunk vége a proginak, end volt beírva

go1:
cmp kar,13 ;ide ugrunk ha ENTER vagy BACKSPACE volt leütve
je go2 ;ha ENTER akkor ugrunk

torles 1 ;ha BAKCSPACE akkor törlünk egy karaktert
jmp cik1 ;ugrunk vissza a cik1-re, hisz nincs még vége

go2:
mov ah,9 ;ENTER, tehát új sor
mov dx,offset newline
int 21h
jmp cik1 ;ugrunk vissza a cik1-re, hisz nincs még vége

vege:
torles long ;letörlünk az end szó hosszúságának megfelelő karaktert

mov ah,4ch ;visszaadjuk a vezérlést az op.-nek
int 21h

code ends ;code szegmens vége
end start ;start cimkénél kezdünk

;Program 22

22.zip 22.exe 22.asm

;Írjon programot, amely szöveges állományt másol a képernyőre (a nevét a bill. adjuk meg) úgy, hogy minden Laci szót lecserél Péter-re. Az egyes szavak egymástól SP, HT, CR és LF karakterekkel vannak elválasztva.

code segment ;code nevű szegmens létrehozása
assume cs:code,ds:code ;hozzárendelés

long EQU 4 ;long nevű konstans, értéke 4, EQU direktíva

;változók
buffer db 65,0,65 dup(0) ;egy buffer, először a fájl nevét (elérési útját), majd pedig a fájlból való olvasás
mit db 'Laci' ;mit akarunk lecserélni
mire db 'Peter$' ;mire akarjuk lecserélni
;szövegek, amiket ki akarunk írni
text1 db 'File: $'
text2 db 13,10,'Press any key...$'
hibauz1 db 13,10,'Cant find the path$'
hibauz2 db 13,10,'Access denied!$'
hibauz3 db 13,10,'The file doesnt exist!$'
hibauz4 db 13,10,'Unknown error$'
file dw ? ;a FILE HANDLE szám tárolására
szemafor db 0 ;volt-e megnyitva fájl
fajlvege db 0 ;a fájl végén vagyunk már, nincs több olvasnivaló karakter
szo db 1 ;ez aminek most a végén egy vezerlő karaktert (sorvége, tabulátor, space) találtunk egy szó vagy még az előző szó része? Ezt jelzi...

;macro egy karakter kiírására
putchar macro char
mov ah,2 ;kettes DOS szolgáltatással írjuk ki
mov dl,char ;a dl-ben lévő karaktert
int 21h
endm

;macro string kiírására
pstring macro text
mov ah,9 ;kilences DOS szolgáltatás
mov dx,offset text
int 21h
endm

;ez egy procedúra, fontos, mindig si+1 darab karakert ír ki a buffer-ből
buf proc near
xor di,di ;di az index
buf_cik1:
putchar buffer[di]
inc di
cmp di,si ;addig míg ki nem írunk si+1 darabot
jbe buf_cik1
ret
buf endp

start:
mov ax,cs ;adatszegmens kezdőcímének beállítása
mov ds,ax
cld ;df nullázása

pstring text1 ;text1 kiírása

mov ah,0ch ;bill. buffer törlése
mov al,0ah ;string beolvasása a bill.-ről
mov dx,offset buffer ;a buffer-ba
int 21h

xor bh,bh ;a bh nullázása, mer mi az egész bx-et használjuk
mov bl,buffer[1] ;és csak a bl-be teszünk értéket
mov buffer[bx+2],0 ;a buffer végére teszünk egy nullát, azért mert ami megnyitja a fájlt, annak ASCIIZ kell

mov ah,3dh ;megnyitjuk a fájlt
xor al,al ;csak olvasásra
mov dx,offset buffer[2] ;a buf. 3. bájtjától van a fájlnév
int 21h
jnc go3 ;ha nem történt hiba továbbugrunk
jmp hiba

go3:
mov file,ax ;a FILE HANDLE elmentése
mov szemafor,1 ;a szemafor 1esbe

mov ax,3 ;a képernyő törlése 80x25 módba lépéssel
int 10h

xor si,si ;si kezdeti nullázása, a buffer indexet tartalmazza mindig
cik1:
mov ah,3fh ;olvasás fájlból
mov bx,file ;a megnyitott fájlból, FILE HANDLE
mov cx,1 ;egy bájtot
mov dx,offset buffer ;a buffer-ba
add dx,si ;pontosabban az si-edik bájtjába
int 21h
jnc go8 ;ha nem történt hiba ugrunk tovább
jmp hiba
go8:
cmp ax,0 ;ha ax=0 akkor fájlvége
jnz go1 ;ha nem akkor jo, tovább
mov fajlvege,1 ;ha igen, akkor szem. egyesbe, és így ugrunk
jmp go9

go1:
cmp buffer[si],13 ;ha itt vagyunk akkor beolvastunk már egy karaktert a fájlból a buffer[si]-be, és nem vagyunk a fájl végén, megnézzük a beolvasott karakter vezérlő karakter-e
jz go9 ;ha igen, akkor kiértékeljük, mert akkor itt egy szó vége van
cmp buffer[si],10 ;13,10 - sorvége
jz go9
cmp buffer[si],9 ;tabulátor
jz go9
cmp buffer[si],32 ;space
jz go9
jmp go10

go9:
cmp szo,1 ;ha a fentiek egyike teljesült ide jutunk, na most ha a szo egyesbe volt állítva akkor oké, mert akkor ami a buffer első négy bájtjába van az egy szó, ha nem egyes akkor a szó vége itt is van, csak ez a négy betű még az előző szóhoz tartozik, nem különálló szó
mov szo,1 ;mindenképp már vége a szónak új szó miatt egyesbe állítom
jne go12 ;az előbb a cmp-vel beállítottam a jelzőbiteket, most ugrok
cmp si,long ;ha előbb nem ugortam el, itt még mindig megnézem hogy meg van-e megfelelő mennyiségű karakterem, ha igen csak akkor ugrok el megnézni hogy Laci szó van benne
je go2
go12:
call buf ;ha itt vagyok akkor a buf megtelt ki kell írni
cmp fajlvege,1 ;ha fájlvége van akkor ugorni a végére
jne go11
jmp vege
go11:
xor si,si ;az index nulla
jmp cik1 ;és vissza az elejére, újra olvasn a buffer-ba

go10:
cmp si,long ;ha itt vagyok, megtelt már a buffer?
jb go5 ;ha nem
call buf ;buffer kiírása mert megtelt
xor si,si ;si nulla
mov szo,0 ;szo nulla mert ami most fog jönni még ehhez tartozik
jmp cik1
go5:
inc si ;akkor si növelése eggyel
jmp cik1

go2:
xor di,di ;di nulla
cik2:
mov al,mit[di] ;átnézem az egész buf. Hogy minden betűje egyezik-e a mit betűivel
cmp al,buffer[di]
jne go4 ;ha nem, akkor ugrunk
inc di
cmp di,long
jb cik2

;ha minden stimmelt, akkor kiírjuk hogy pavel
pstring mire
cmp si,long ;megnézzük ki kell-e írni a buffer utolsó karakterjét
jb go6
putchar buffer[long] ;ha igen kiírjuk, fájlvégénél van ennek jelentősége
jmp go6

go4:
call buf ;amúgy ha nem Laci volt kiírjuk a buffert

go6:
cmp fajlvege,1 ;ha fájlvége akkor vége
je go7
xor si,si ;ha nem si nulla és elölről
jmp cik1
go7:
jmp vege

;hiba lekezelése
hiba:
cmp ax,3 ;ax=3?
jz hiba1
cmp ax,5
jz hiba2
cmp ax,2
jz hiba3

;ha egyik se hiba ismeretlen
pstring hibauz4
jmp vege

hiba1:
pstring hibauz1
jmp vege

hiba2:
pstring hibauz2
jmp vege

hiba3:
pstring hibauz3

vege:
pstring text2

mov ah,0ch ;bill buffer törlése
mov al,7 ;várás egy bill-re echo nélkül
int 21h

cmp szemafor,0 ;volt megnyitot fájl?
jz abort

mov ah,3eh ;ha igen bezárjuk
mov bx,file
int 21h

abort:
mov ah,4ch ;a vezérlés visszaadása a DOSnak
int 21h

code ends ;code nevű szegmens vége
end start ;start cimkénél kezdünk

;olvasunk a fájlból addig amíg vezérlő karakterre nem bukkanunk, ha ez megtörténk akkor eldöntjük hogy ez az előző szó része meg, vagy új szó (szo=1?). Ha külön szó akkor long karakterből áll? Ha igen akkor megnézzük hogy Laci van-e benne, ha igen kiirjuk hogy pavel, minden más esetben a buffert irjuk ki. Ha betelik akkor kiírjuk, és si nulla, újra elölről írunk bele...

;Program 23

23.zip 23.exe 23.asm

;Írjon programot, amely a képernyőre másolja a szöveges állományt, melynek nevét a bil. adjuk meg, úgy, hogy minden Laci szavat áláhúz. Az egyes szavak SP, HT, CR és LF karakterekkel vannak elválasztva.

code segment ;code nevű szegmens létrehozása
assume cs:code,ds:code ;hozzárendelem a code nevű szegmenshez a kódszegmenst, és az adatszegmenst

long EQU 4 ;long konstans, értéke 4

;változók
buffer db 65,0,65 dup(0) ;buffer a fájlnév, majd a beolvasott karakterek tárolására
mit db 'Laci' ;mit akarunk aláhúzni
alahuzas db 'ßßßß' ;mivel legyen aláhúzva
;szövegek
text1 db 'File: $'
text2 db 13,10,10,'Press any key...$'
hibauz1 db 13,10,'Cant find the path$'
hibauz2 db 13,10,'Access denied!$'
hibauz3 db 13,10,'The file doesnt exist!$'
hibauz4 db 13,10,'Unknown error$'
file dw ? ;FILE HANDLE eltárolására
szemafor db 0 ;volt megnyitott fájl?
fajlvege db 0 ;fájl végén vagyunk már?
szo db 1 ;új szavunk van, vagy az előző ért véget?
x db ? ;pozíciók elmentésére
y db ?
x1 db ? ;ugyanúgy, később kiderül mire is kell
y1 db ?

;a kurzor áthelyezése
gotoxy macro x0,y0
mov ah,02h
mov bh,0 ;nulladik lap
mov dl,x0
mov dh,y0
int 10h
endm

;a kurzorpozíció lekérdezése
getxy macro x0,y0
mov ah,03h
mov bh,0 ;nulladik lap, hisz több nincs :D
int 10h
mov x0,dl
mov y0,dh
endm

;egy karakter kiírása
putchar macro char
mov ah,2
mov dl,char
int 21h
endm
;string kiírása
pstring macro text
mov ah,9
mov dx,offset text
int 21h
endm

;proc. fontos, kiírja a megadott stringet, si+1 darabot, de úgy hogy ha a monitoron a sor végén vagyunk és tovább kell írni, egy üres sort üt pluszba, így a szöveg minden második sorba lesz, és a kimaradt sorokba mehet az aláhúzás
buf proc near ;bx - mit irjunk ki, si - mennyit
jmp buf_start
x2 db ?
y2 db ?
tab db ' ' ;ha tabulátor (9) kell írni, akkor ő helyette 3 spacet ír, hogy miért? Hehehehe :D mert ez így egyszerűbb... az érdekesség az hogy a proc. saját magát hívja meg ennek a kiírására

buf_start:
xor di,di ;di az indexeléshez
buf_cik1:
cmp byte ptr [bx+di],9 ;megnézzük nem tabulátort kell véletlenül kiírni, ha nem akkor elugrunk innen
jnz buf_go3
mov byte ptr[bx+di],32 ;a tab helyett teszünk szóközt
push si bx di ;elmentünk mindent
mov si,2 ;3 drb kar. kell kiírni
mov bx,offset tab ;a tab-ot
call buf ;és itt hívjuk megint a buf-ot, hogy írjon ki nekünk 3 szóközt a tab helyett
pop di bx si ;amikor végzett, vissza mindent és tovább
buf_go3:
putchar [bx+di] ;kiírjuk a karaktert

getxy x2,y2 ;lekérjük a kurzorpozíciót
cmp x2,0 ;megnézzük nem sor elején vagyunk-e
jnz buf_go2 ;ha nem akkor tovább
cmp byte ptr [bx+di],13 ;ha igen akkor és nem sor végét írtunk ki akkor egy sorral lejjebb megyünk
jz buf_go2
inc y2
gotoxy x2,y2 ;itt ugrunk lejjebb

buf_go2:
inc di ;köv. betűre léptetjük az indexet
cmp di,si ;megnézzük nem írtuk ki még az összeset
jbe buf_cik1 ;ha nem akkor még írjuk
ret
buf endp
;főprogram
start:
mov ax,cs ;adatszegmens kezdőcímének beállítása
mov ds,ax
cld ;df nullázása

pstring text1 ;text1 kiírása

mov ah,0ch ;bill. buffer törlése
mov al,0ah ;string beolvasása a bill.-ről
mov dx,offset buffer
int 21h

xor bh,bh ;bh nullázása
mov bl,buffer[1] ;bl-be a beolvasott kar. száma
mov buffer[bx+2],0 ;a string végére egy nulla karaktert

mov ah,3dh ;fájl megnyitása
xor al,al ;csak olvasásra
mov dx,offset buffer[2] ;a 3. bájttól kezdődik a fájlnév
int 21h
jnc go3 ;ha nem történt hiba akkor ugrunk
jmp hiba

go3:
mov file,ax ;FILE HANDLE elmentése
mov szemafor,1 ;szem. egyesbe

mov ax,3 ;képernyő törlése 80x25 módba lépéssel
int 10h

xor si,si ;si kezdeti nullázása, si az index
cik1:
mov ah,3fh ;olvasás fájlból
mov bx,file ;az előbb megnyitott fájlból akarunk olvasni
mov cx,1 ;egy bájtot fogunk olvasni
mov dx,offset buffer ;a buffer-ba
add dx,si ;si-edik helyre
int 21h
jnc go8 ;ha nincs hiba akkor tovább
jmp hiba
go8:
cmp ax,0 ;fájlvége?
jnz go1 ;ha nem tovább
mov fajlvege,1 ;ha igen, akkor flag egyesbe és vége
jmp go9

;itt most megnézzük a beolvasott kar. vezérlő kar.-e, 13,10 sorvége, 9 tabulátor, 32 space

go1:
cmp buffer[si],13
jz go9 ;ha valamelyik stimmel elugrunk innen
cmp buffer[si],10
jz go9
cmp buffer[si],9
jz go9
cmp buffer[si],32
jz go9
jmp go10 ;ha egyik se stimmelt, akkor ugrunk a go10-re

go9:
cmp szo,1 ;ha egy új szavunk van akkor ugrunk, ha nem akkor mindenképp a szo flaget egyesbe kell állítani mert már biztos új szó lesz legközelebb
mov szo,1
jne go12 ;és el kell ugorni ha a szo egyes volt megnézni nem Laci van-e
cmp si,long ;jaj, de csak akkor ugrunk el, ha van kellő mennyiségű karakter, ha nincs minek ugorjunk el?
je go2
go12:
mov bx,offset buffer ;ha itt vagyunk akkor a long+1 kar. beolvasása után jött vezérlő karakter, tehát még mindig egy szót olvasunk be, de a szo flag nullába volt, ezért nem mentünk megnézni mi van benne.. szal kiírjuk azt si nullázása és újra olvasás
call buf ;kiírjuk
cmp fajlvege,1 ;ha ez a flag egyes akkor vége van...
jne go11
jmp vege ;ugrunk a végére
go11:
xor si,si
jmp cik1

go10:
cmp si,long ;itt megnézzük buffer-ba elég kar. van-e
jb go5 ;ha még kevés olvasunk
mov bx,offset buffer ;ha betelt kiírju
call buf
xor si,si ;si nulla és szo nulla, mert még nem ért véget a szó
mov szo,0
jmp cik1 ;és újra olvasás
go5:
inc si ;ha itt vagyunk a buffer még nincs tele, nincs benne elég kar, ezért inc si--index, és olvasunk még bele
jmp cik1

go2:
xor di,di ;di nulla

;összehasonlítjuk a mit-et és a buffer-t ha minden stimmel akkor van Laci
cik2:
mov al,mit[di]
cmp al,buffer[di]
jne go4 ;ha már egy nem stimmel akkor nem Laci van
inc di
cmp di,long
jb cik2

;ha ide eljutunk Laci van
getxy x,y ;elmentjük az aktuális kurzor pozíciót
mov bx,offset buffer ;kiírjuk a Laci-t
call buf
getxy x1,y1 ;elmentjük a mostanit is, figyeled hogy hova? x1, 1

inc y ;egy sorral fogunk lejjebb menni, de mihez képest? nézd y!!!
gotoxy x,y ;na menjünk
mov si,3 ;si-be 3, így ír ki 4 kar-t
mov bx,offset alahuzas ;kiírja az aláhúzást
call buf
gotoxy x1,y1 ;és visszamegy oda ahol a Laci szó végetért, és már alá is van húzva... :o
jmp go6

go4:
mov bx,offset buffer ;ha nem Laci volt, akkor meg csak simán kiírjuk a buffert
call buf

go6:
cmp fajlvege,1 ;ez meg már a vége, ha nem Laci volt vagy ha az is, itt kötünk ki, ha fajlvege flag egyesbe van akkor vége, ha nem akkor si-t nullázzuk, és újra olvasunk... :P
je go7
xor si,si
jmp cik1
go7:
jmp vege

;itt lekezeljük a hibaüziket
hiba:
cmp ax,3 ;ax=3?
jz hiba1
cmp ax,5
jz hiba2
cmp ax,2
jz hiba3
;ha egyik se akkor a hiba ismeretlen

pstring hibauz4
jmp vege

hiba1:
pstring hibauz1
jmp vege

hiba2:
pstring hibauz2
jmp vege

hiba3:
pstring hibauz3

vege:
pstring text2

mov ah,0ch ;bill. buffer törlése
mov al,7 ;várás egy bill.-re echo nélkül
int 21h

cmp szemafor,0 ;volt megnyitott fájl?
jz abort

mov ah,3eh ;ha volt hát zárd be
mov bx,file
int 21h

abort:
mov ah,4ch ;vezérlés visszaadása a DOS-nak
int 21h

code ends ;code nevű szegmens vége
end start ;start cimkénél kezdünk

;Algoritmusa:
;olvasunk a fájlból egy bájtot, megnézzük ez mi: vezérlő karakter, vagy csak sima karakter, ha vezérlő akkor valamit kell csinálni, ha nem az, akkor megnézzük betelt már a buffer van elég kar. benne, ha igen akkor kiírjuk a buffert, indexet nullára állítjuk a szo flaget szintén nullába és újra olvasunk, ha nem volt benne elég akkor indexet eggyel tovább teszem és újra olvasok. Mit jelent az hogy van benne elég? Azt hogy van benne long+1 drb, tehát a Laci szónak meg a vezérlő karaktertnek, tehát hogy tudjuk vége van a szónak. A másik ami történhet hogy vezérlő karakterbe botlunk, ekkor ha szo egyes volt akkor oké mehetünk megnézni hogy a keresett szó van-e benne, ja és még előtt hogy van-e egyáltalán benne annyi, ha igen akkor ugrunk oda ahol ezt lekezeljük. Ha a szo nulla, akkor az azt jelenti hogy nincs külön szó, az előző ért véget, most már a szo biztos egyes, ezért egyesbe állítom, és kiírom a buffert aztán vissza újra olvasni. Mindig nézem hogy nincs-e véletlenül fájlvége, ha az van, akkor ki kell lépni, erre figyelni kell... Az ami kiírja az nagyon fontos, fentebb már írtam, dupla sorközzel írja, hogy legyen hely az aláhúzásnak!!!
;Ha oda kerül hogy megtalálta a Laci szót, akkor először megnézi hol van a kurzor, elmenti, majd kiírja a Laci-t. Megint elmenti a pozíciót, aztán visszamegy a Laci szó elejére, eggyel lejjebb teszi a kurzort, egy sorral, ez ugyebár biztos üres, ide kiírja az aláhúzást, és visszamegy oda ahol a Laci végetért. Így van egy Laconk kiírva plusz az aláhúzás, de nem gond a kurzor a Laci után villog. Mehet szépen tovább, alá van húzva ahogy kell... :D
;Ha ez nem jött össze nem Laci volt, könnyű kitalálni: kiírja a buffer-t és olvas tovább.. persze si—index nullázza..

;nagyjából ennyi...
;Enjoy!

;Program 24

24.zip 24.exe 24.asm

;Írjon programot, amely megszámolja az aktuális könyvtárban levő fájlokat, az eredményt pedig kiírja a képernyőre.

code segment ;code nevű szegmens létrehozása
assume cs:code,ds:code ;hozzárendelés

;változók
dta db 128 dup(0)
asciiz db '*.*',0
text1 db 'Az aktualis mappaban $'
text2 db ' fajl talalhato.$'
hibauz1 db 13,10,'Nem talalhato fajl!$'
szemaforbin db ?
szam dw 0 ;ide mentjük a fájlok számát

;evvel a procedúrával írjunk ki egy bináris számot a képernyőre, ebben a programban a szam nevű változót
;ezt a procedúrát szőccsel órán vettük...

binascii proc near ;bemenet ax
mov szemaforbin,0 ;szemafort nullába állítjuk
cmp ax,0 ;megnézzük, hogy a kiírandó szám nem nulla e
jne gop1 ;ha nem továbbmegyünk
mov ah,2 ;ha igen akkor kiírunk egy nullát
mov dl,'0'
int 21h
jmp vegeproc ;és a proc. végére ugrunk

gop1:
mov bx,10000 ;10000 fogunk osztani
xor dx,dx ;osztani fogunk, fontos a dx-et kinullázni, lást div utasítás

cikp1:
div bx ;itt osztjuk az ax-et és a kiterjesztését a dx-et a bx-ben levő számmal
mov si,dx ;átvisszük a dx-et az si-be, a dx-ben van a maradék
cmp ax,0 ;megnézzük ax-ben nulla van e
jne gop2 ;ha nem akkor kiírjuk
cmp szemaforbin,0 ;ha igen, és a szemafor 0 akkor nem írjuk ki
je gop3

gop2:
mov ah,2 ;itt írjuk ki az ax-ben osztás után megkapott számot
mov dl,al
add dl,30h ;hozzáadunk 30h-t, mert ASCII karakterként írjuk ki
int 21h
mov szemaforbin,1 ;már itt egy karaktert biztos kiírtunk, ezért szemafort egyesbe állítjuk

gop3:
mov ax,bx ;az osztót el kell osztani 10-zel
mov bx,10
xor dx,dx
div bx ;itt osztjuk
cmp ax,1 ;megnézzük, hogy az osztó egy e már
jb vegeproc ;ha kisebb mint egy akkor vége
mov bx,ax ;ha nem, akkor bx-be bevisszük az osztót
mov ax,si ;ax-be vissza az előző maradékot
jmp cikp1 ;és elölről az egészet

vegeproc:
ret

binascii endp

start:
mov ax,cs ;adatszegmens kezdőcímének beállítása
mov ds,ax
cld ;df nullázása

mov ah,1ah ;dta kezdőcímének beállitása
;ez a 4eh ill. 4fh szolgáltatásoknak kell, most igazából különösebb szerepe nincs
mov dx,offset dta
int 21h

mov ah,4eh ;itt lekérjük (keressük) az első fájlt
mov dx,offset asciiz ;az aktuális mappát figyeljük
mov cx,0 ;normal fájlokat
int 21h
jc hiba ;ha nem találtunk fájlt, kiírjuk, hogy nincs fájl

cik1:
inc szam ;megnöveljük a fájlokat számláló változó értékét eggyel, mivel ha már itt vagyunk, akkor 1 fájl biztosan van
mov ah,4fh ;itt kezdjük lekérni a további fájlokat
int 21h
jnc cik1 ;addig fogjuk ezt ismételni, ameddig talál fájlt

mov ah,9 ;oké, nincs több fájl, most kiírjuk, hogy mennyi is volt
mov dx,offset text1 ;először a szöveg első fele
int 21h

mov ax,szam ;itt fogjuk „átcsinálni” a szam-ot ASCII-vá, azaz kiírjuk a képernyőre
call binascii ;ez a procedúra végzi ezt, az ax-ben kapja meg a kiírandó fájlt

mov ah,9 ;itt meg kiírjuk a szöveg további részét
mov dx,offset text2
int 21h

jmp vege ;átugorjuk a hibaüzenetet

hiba:
mov ah,9 ;itt írjuk ki, hogy nincs fájl
mov dx,offset hibauz1
int 21h

vege:
mov ah,4ch ;visszaadjuk a vezérlést az op.-nek
int 21h

code ends ;code nevű szegmens lezárása
end start ;start cimkénel fogunk belépni a programba

;Program 25

25.zip 25.exe 25.asm

;Írjon programot, amely kiírja a képernyőre az összes állományt az aktuális mappából, amely megfelelnek a bill. megadott maszknak.

code segment ;code szegmens létrehozása
assume cs:code,ds:code ;hozzárendelés

;változók
dta db 128 dup(0)
buffer db 13,0,13 dup(0) ;8+11 + pont meg az ENTER
newline db 13,10,36 ;újsor
text1 db 'Maszk: $'
text2 db 13,10,'Az aktualis mappaban talalhato fajlok:$'
hibauz1 db 13,10,'Nem talalhato fajl!$'
hibauz2 db 13,10,'Nem adtal meg maszkot!',13,10,36

start:
mov ax,cs ;adatszegmens kezdőcímének beállítása
mov ds,ax
cld ;df nullázása

mov ah,1ah ;dta beállítása
mov dx,offset dta
int 21h

cik1:
mov ah,9 ;kiírjuk a text1-et
mov dx,offset text1
int 21h

mov ah,0ch ;bill. buffer törlése
mov al,0ah ;karakterek beolvasása bill.-ről
mov dx,offset buffer
int 21h

cmp buffer[1],0 ;megnézzük a volt-e beadva karakter
;vagy csak ENTER volt leütve
jnz go1 ;ha nem csak ENTER megyünk tovább

mov ah,9 ;ha csak ENTER, hibaüzi
mov dx,offset hibauz2
int 21h
jmp cik1 ;és nyomás vissza az elejére

go1:
xor bh,bh ;bh=0
mov bl,buffer[1] ;bl-be bevisszük mennyi kar. volt beolvasva
mov buffer[bx+2],0 ;a végére dobunk egy 0-at

mov ah,9 ;kiírjuk a text2-t
mov dx,offset text2
int 21h

mov ah,4eh ;megkeressük az első fájlt
mov dx,offset buffer[2] ;első két bájtot át kell ugornunk
mov cx,0 ;normal fájlokat keresünk
int 21h
jc hiba ;ha hiba történt, ugrunk

cik2:
mov si,1eh ;dta-ba ettől a címtől kezdődik a fájlnév

mov ah,9 ;kiírunk egy újsort
mov dx,offset newline
int 21h

cik3:
mov ah,2 ;és elkezdjük kiírni a fájlnevet
mov dl,byte ptr dta[si]
int 21h
inc si ;mindig a köv. bájtra állítjuk az si-t
cmp byte ptr dta[si],0 ;megnézzük nincs-e még vége
jnz cik3 ;ha nincs akkor kiírjuk

mov ah,4fh ;keressük a köv. fájlt
int 21h
jnc cik2 ;ha talált fájlt, azt kiírjuk, szóval vissza cik2-re

jmp vege ;itt ugrunk már a végére, átugorjuk a hibaüziket

hiba:
mov ah,9 ;kiírjuk a hibaüzit
mov dx,offset hibauz1
int 21h

;itt a vége, fuss el véle
vege:
mov ah,4ch ;korrektül befejezzük a programot
int 21h

code ends ;code szegmens vége
end start ;start cimkénél kezdünk

;Program 26

26.zip 26.exe 26.asm

;Írjon programot, amely elkészíti két fájl "összegét". A két forrásfájl ill. a célfájl nevét kérje be a billentyűzetről.

code segment ;code nevű szegmens létrehozása
assume cs:code,ds:code ;hozzárendelés

;változók
filename db 65,0,65 dup(0) ;fájlnév elmentésére
kar db ? ;ebbe olvasunk a fájlból, ebből írunk fájlba
text1 db '1. fajl: $'
text2 db 13,10,'2. fajl: $'
text3 db 13,10,'Celfajl: $'
text4 db 13,10,'A masolas kesz!$'
text5 db 13,10,'Press any key...$'
hibauz1 db 13,10,'Nem talalom az utat$' ;hibaüzenetek
hibauz2 db 13,10,'Hozzaferes megtagadva!$'
hibauz3 db 13,10,'A fajl nem letezik!$'
hibauz4 db 13,10,'Szamomra ismeretlen hiba$$'
hibauz5 db 13,10,'A celfájl mar letezik!$'
file1 dw ? ;a FILE HANDLE számok elmentésére
file2 dw ?
file3 dw ?
szemafor1 db 0 ;volt megnyitott fájl? evvel jelezzük
szemafor2 db 0
szemafor3 db 0
letezik db 0 ;hehe, ez annak az indikálása, hogy van fájl, de ez nekünk nem jó, tehát ha NINCS az a jó, de akkor a hiba-ra ugortunk már, megnézzük letezik=1, ha igen, akkor nekünk vissza kell menni, és tovább kell folytatni a programot

;macro string kiírására
pstring macro text
mov ah,9
mov dx,offset text
int 21h
endm

;fájl lezárása
lezar macro file,szemafor
local vege
cmp szemafor,0 ;ha szemafor=1, akkor le kell zárni
je vege
mov ah,3eh
mov bx,file
int 21h
vege:
endm

;macro string beolvasására
beolvas macro buffer
mov ah,0ch ;bill. buffer törlése
mov al,0ah
mov dx,offset buffer
int 21h

xor bh,bh
mov bl,buffer[1] ;hova is?
mov buffer[bx+2],0 ;a végére kell egy 0
endm

;macro fájl megnyitására
megnyit macro file,szemafor
local ok
mov ah,3dh
xor al,al ;olvasásra
mov dx,offset filename[2] ;a filename 3. bájtjától kezdődika fájlnév
int 21h
jnc ok
jmp hiba ;ez azért így mert ide már near jump kell, shor nem elég, túl messze van

ok:
mov file,ax ;FILE HANDLE elmentése
mov szemafor,1 ;szem. egyesbe
endm

;olvasás fájlból a kar-ba
olvasfajlbol macro file
mov ah,3fh
mov bx,file
mov cx,1 ;egy bájt
mov dx,offset kar ;a kar-ba
int 21h
jc hiba
endm

;írás fájlba egy kar-t
irasfajlba macro file
mov ah,40h
mov bx,file
mov cx,1 ;egy bájtot
mov dx,offset kar
int 21h
jc hiba ;ha hiba ugrunk
endm

;fájl létrehozása, nevét a filename adja, mint eddig is :D
letrehozas macro file,szemafor
mov ah,3ch ;létrehozás
xor cx,cx ;normal fájl
mov dx,offset filename[2]
int 21h
jc hiba
mov file,ax ;FILE HANDLE elmentése
mov szemafor,1 ;bla-bla-bla, mint előbb
endm

;text kiír, és vár egy karakterre
_wait macro text
mov ah,9
mov dx,offset text
int 21h

mov ah,0ch
mov al,7
int 21h
endm

;főprogram
start:
mov ax,cs ;adatszegmens kezdőcímének beállítása
mov ds,ax
cld ;df=0

pstring text1 ;text1 kiírása
beolvas filename ;fájlnév beolvasása
megnyit file1,szemafor1 ;fájl megnyitása

pstring text2 ;ugyanaz, csak másik fájl
beolvas filename
megnyit file2,szemafor2

pstring text3 ;célfájl
beolvas filename
mov letezik,1 ;hehe, ha létezik az nekünk nem JÓ, ezért ha hiba lett, akkor visszajövünk, ha nem akkor kiírjuk, hogy hiba és vége
megnyit file3,szemafor3

pstring hibauz5
jmp vege ;mondom, VÉGE

letrehoz:
letrehozas file3,szemafor3 ;célfájl létrehozása

elsofajl:
olvasfajlbol file1 ;olvasunk első fájlból míg vége nem lesz
cmp ax,0
jz masikfajl

irasfajlba file3 ;és írunk a célfájlba
jmp elsofajl

masikfajl:
olvasfajlbol file2 ;ugyanaz, csak a másik fájlból olvasunk
cmp ax,0
jz vegeazirasnak

irasfajlba file3
jmp masikfajl

vegeazirasnak:
pstring text4 ;kiírjuk a végső szöveget, hogy minden ok
jmp vege ;átugorjuk a hibaüziket

hiba:
cmp letezik,1 ;ha letezik=1 akkor vissza kell menni ha hiba lett
je letrehoz ;tehát VISSZA
cmp ax,3 ;hibák lekezelése a hibakód alapján
je hiba1
cmp ax,5
je hiba2
cmp ax,2
je hiba3

pstring hibauz4 ;ha egyik se, akkor ismeretlen
jmp vege

hiba1:
pstring hibauz1
jmp vege

hiba2:
pstring hibauz2
jmp vege

hiba3:
pstring hibauz3

vege:
_wait text5 ;várj

lezar file1,szemafor1 ;zárd le a fájlokat
lezar file2,szemafor2
lezar file3,szemafor3

mov ah,4ch ;add vissza a vezérlést
int 21h

code ends ;code nevű szegmens vége
end start ;start cimkénél kezdünk

;Program 27

27.zip 27.exe 27.asm

;Írjon programot, amely megszámolja a Jani szavakat a szöveges állományban, és megjeleníti ezt a mennyiséget a képernyőn. Az egyes szavak SP, HT, CR és LF karakterekkel vannak elválasztva. Az állomány nevét kérje be a billentyűzetről, és hiba esetén jelenítsen meg hibaüzenetet.

code segment ;code nevű szegmens létrehozása
assume cs:code,ds:code ;hozzárendelés

long EQU 4 ;long konstans értéke 4

;változók
buffer db 65,0,65 dup(0) ;buffer a fájl nevének, majd pedig a fájlból való olvasásra is
mit db 'Jani' ;Jani szót keressük
;szövegek, amiket ki akarunk írni
text1 db 'File: $'
text2 db 13,10,'A Jani szo $'
text3 db '-szor jelenik meg a fajlban.$'
text4 db 13,10,'Press any key...$'
hibauz1 db 13,10,'Nem talalhato az ut!$'
hibauz2 db 13,10,'Hozzaferes megtagadva!$'
hibauz3 db 13,10,'A fajl nem letezik!$'
hibauz4 db 13,10,'Ismeretlen hiba!$'
file dw ? ;FILE HANDLE elmentésére
szemafor db 0 ;volt megnyitot fájl?
fajlvege db 0 ;fájlvége van?
szo db 1 ;szavat találtunk, vagy csak az előző szónak van vége
t dw 0 ;számolunk..mennyi is van?

;macro string kiírására
pstring macro text
mov ah,9 ;kilences DOS szolgáltatás
mov dx,offset text
int 21h
endm

;proc. bináris szám kiírására a képernyőre
binascii proc near ;bemenet ax
jmp binascii_start

flag db ? ;van már kiírt karakter?

binascii_start:
mov flag,0 ;még nincs kiirt karakter, ezért flag nulla
cmp ax,0 ;ax=0?
jne binascii_go1
mov ah,2 ;ha igen akkor kiírunk egy nullát
mov dl,'0'
int 21h
ret

binascii_go1:
mov bx,10000 ;ha nem nulla, akkor szépen kiírjuk a számot
xor dx,dx ;először 10ezerrel osztunk, majd szépen ezerrel, százzal...

binascii_cik1:
div bx ;oszd el az ax-et bx-el
mov si,dx ;maradékot az si-be
cmp ax,0 ;ax=0
jne binascii_go2 ;a szám amit kaptunk 0? Ha igen akkor a flagtől függ ki írunk-e valamit
cmp flag,0 ;ha flag nulla akkor nem írunk ki semmit
je binascii_go3

binascii_go2:
mov ah,2 ;ha minden ok akkor kiírjuk a számjegyet
mov dl,al
add dl,30h ;ASCII
int 21h
mov flag,1 ;flag már egyesbe

binascii_go3:
mov ax,bx ;elosztjuk a bx-et 10-el
mov bx,10
xor dx,dx
div bx ;kinullazza a dx-et, elosztja az ax-et bx-el
cmp ax,1 ;addig míg ax nagyobb vagy egyenlő 1el
jb binascii_vege
mov bx,ax ;ax vissza bx-be
mov ax,si ;siből a maradék vissza az ax-be
jmp binascii_cik1 ;vissza az elejére

binascii_vege:
ret
binascii endp

;főprogram
start:
mov ax,cs ;adatszegmens kezdőcímének beállítása
mov ds,ax
cld ;df nullázása

mov ax,3 ;képernyő törlése
int 10h

pstring text1 ;text1 kiírása

mov ah,0ch ;bill. buffer törlése
mov al,0ah ;string beolvasása
mov dx,offset buffer ;a buffer-ba
int 21h

xor bh,bh ;bh nullázása, mert bx-et használjuk
mov bl,buffer[1] ;bx-be a beolvasott kar. száma
mov buffer[bx+2],0 ;végére egy nulla

mov ah,3dh ;fájl megnyitása
xor al,al ;csak olvasása
mov dx,offset buffer[2] ;buff. 3. bájtjától van a fájlnév
int 21h
jnc go3
jmp hiba

go3:
mov file,ax ;FILE HANDLE elmentése
mov szemafor,1 ;szem. egyesbe

;a fájlból való olvasás, ellenőrzés hogy Jani-e, ha igen akkor t-hez hozzáadni egyet

xor si,si
cik1:
mov ah,3fh ;fájlból olvasás
mov bx,file ;FILE HANDLE – bx-be
mov cx,1 ;egy bájtot
mov dx,offset buffer ;a bufferba
add dx,si ;pontosabban si-edik bájtjába
int 21h
jnc go8
jmp hiba
go8:
cmp ax,0 ;ha ax nulla akkor fájlvége
jnz go1
mov fajlvege,1 ;ezt álljtjuk itt be
jmp go9

;megnézzük hogy amit beolvastunk: vezérlő karakter? Vezérlő karakter: 13,10,9,32 – 13,10 sorvége, 9 tabulátor, 32 szóköz
go1:
cmp buffer[si],13
jz go9 ;ha igen, akkor elugrunk, és lekezeljük
cmp buffer[si],10
jz go9
cmp buffer[si],9
jz go9
cmp buffer[si],32
jz go9
jmp go10

go9:
cmp szo,1 ;van új szavunk, vagy ez ami most ért véget még az előző része?
mov szo,1 ;mind1, most már ami jön biztos új szó
jne go12 ;de ha nem volt új szavunk nem ugrunk el
cmp si,long ;si ben már van kellő mennyiségű karakter?
je go2 ;ha igen csak akkor ugrunk el
go12:
cmp fajlvege,1 ;ha fájlvége van akkor vége
jne go11
jmp vege
go11:
xor si,si ;ha nem akkor si nullázása és tovább olvassuk a szavakat
jmp cik1

go10:
cmp si,long ;ha az si már long hosszú akkor nullázni kell
jb go5
xor si,si
mov szo,0
jmp cik1
go5:
inc si ;ha viszont nem az akkor plusz egy hozzá
jmp cik1

go2:
xor di,di
cik2:
mov al,mit[di] ;itt nézzük meg, hogy a keresett szó van e a bufferban
cmp al,buffer[di]
jne go4 ;ha nem itt ugrunk el
inc di
cmp di,long
jb cik2

inc t ;ha igen minden rendben, akkor t++

go4:
cmp fajlvege,1 ;fájlvége van már?
je go7
xor si,si ;ha nem akkor tovább keress új szót
jmp cik1
go7:
jmp vege

;hibák lekezelése
hiba:
cmp ax,3 ;ax=3?
jz hiba1
cmp ax,5
jz hiba2
cmp ax,2
jz hiba3

;ha egyik se, akkor ismeretlen hiba
pstring hibauz4
jmp vege

hiba1:
pstring hibauz1
jmp vege

hiba2:
pstring hibauz2
jmp vege

hiba3:
pstring hibauz3

vege:
pstring text2

;kiírjuk mennyi is volt
mov ax,t
call binascii ;binascii proc. lásd előbb

pstring text3
pstring text4

mov ah,0ch ;bill. buffer törlése
mov al,7 ;várás egy bill.re echo nélkül
int 21h

cmp szemafor,0 ;volt megnyitot fájl?
jz abort

mov ah,3eh ;ha volt bezárjuk
mov bx,file
int 21h

abort:
mov ah,4ch ;a vezérlés visszaadása a DOS-nak
int 21h

code ends ;code nevű szegmens vége
end start ;start cimkénél kezdünk

;beolvasunk egy karaktert a fájlból, megnézzük vezérlő karakter-e, ha igen akkor megnézzük az előző szó része, vagy különálló szó. Ha különálló, akkor megnézzük Jani-e. Ha igen akkor a számlálóhoz hozzáadunk egyet. Ha a buffer betelik, akkor si-t nullázzuk, és újból elkezdünk bele olvasni. Az si a mutatója, az indexe...

;Program 28

28.zip 28.exe 28.asm

;Írjon programot, amely kiírja az aktuális mappából azokat az állományokat, amelyek mérete nagyobb mint a bill. megadott érték.

code segment ;code nevű szegmens létrehozása
assume cs:code,ds:code ;hozzárendelés

;változój
dta db 128 dup(0) ;dta tárolására
path db '*.*',0 ;elérési út az akt. mappa, minden fájlja
newline db 13,10,36 ;új sor írására
text1 db 'Fajlok listazasa, amelyek nagyobbak mint (bajtokban, max. 4 GB): $'
text2 db 13,10,'Press any key to continue...$'
hibauz1 db 13,10,'Nem talalhato fajl!$'
buffer db 11,0,11 dup(0) ;a szám beolvasása
meret_al dw ? ;meret alacsonyabb bájt
meret_mag dw ? ;meret magasabb bájt
flag db 0 ;volt fájl?

;macro text kiírására
kiir macro text
mov ah,9
mov dx,offset text
int 21h
endm ;macro vége

;macro szöveg beolvasására
beolvas macro hova
mov ah,0ch ;bill. buffer törlése
mov al,0ah
mov dx,offset hova
int 21h
endm

;proc. 32 bites bináris számmá való alakításra ASCIIkódból
;nem magyarázom, ezt nem vettük
;de ide ez kell, lehetne 16 bites is, csak az nem az igazi...
asciibin_32 proc near ;bemenet si - mutato buffer+2
;kimenet dx:ax - bin ertek
jmp start_asciibin_32

magasabb_szo dw ?
alacsonyabb_szo dw ?

start_asciibin_32:

cmp byte ptr [si],13
jne asciibin_32_go1
xor ax,ax
xor dx,dx
ret

asciibin_32_go1:
mov magasabb_szo,0
mov alacsonyabb_szo,0

asciibin_32_ciklus:
mov cx,magasabb_szo
mov bx,alacsonyabb_szo
xor dx,dx
mov ax,10
call longmul
push ax
mov al,byte ptr [si]
cbw ;elojeles kiterjesztese az al-nek az az-be
push dx
cwd ;ax > dx-be valo kiterjesztese
pop bx
pop cx
add cx,ax
adc bx,dx
sub cx,30h
sbb bx,0
mov magasabb_szo,bx
mov alacsonyabb_szo,cx
inc si
cmp byte ptr [si],13
jne asciibin_32_ciklus

mov dx,magasabb_szo
mov ax,alacsonyabb_szo
ret

asciibin_32 endp

;ez a proc. a asciibin_32-nek kell
longmul proc near
push si
xchg si,ax
xchg dx,ax
jcxz longmul_go1 ;teszteli, hogy a cx-ben 0 ertek van-e
xchg cx,ax
mul si

longmul_go1:
xchg si,ax
mul bx
add dx,si
pop si
ret
longmul endp ;proc. vége

;főprogram
start:
mov ax,cs ;adatszegmens kezdőcímének beállítása
mov ds,ax
cld ;df nullázása

kiir text1 ;text1 kiírása
beolvas buffer ;a szám beolvasása
mov si,offset [buffer+2]
call asciibin_32 ;átalakítása binárissa
mov meret_al,ax ;és elmentése
mov meret_mag,dx

mov ah,1ah ;dta kezdőcímének beállítása
mov dx,offset dta
int 21h

mov ah,4eh ;első fájl keresése
mov dx,offset path ;a path által adott mappában
mov cx,0 ;normal fájlokat keress
int 21h
jnc tovabb ;ha nincs hiba, vagyis találtál, akkor tovább

jmp vege ;ha hiba akkor ugrunk a végére

tovabb:
mov si,1ch ;megnézzük a fájlméretet
mov ax,word ptr dta[si] ;először a magasabb bájtot
cmp ax,meret_mag ;ha ez kisebb akkor az nem jó, következő
jb kov
mov ax,word ptr dta[si-2] ;alacsonyabb bájt
cmp ax,meret_al ;ha ez kisebb vagy egyenlő akkor nem jó
jbe kov ;és jöhet a következő

kiir newline ;új sor írása
mov si,1eh ;innen kezdődik a fájlnév

cik1:
mov ah,2 ;egy kar. kiírása
mov dl,byte ptr dta[si] ;ezen kar. kiírása
int 21h ;tedd meg!
inc si ;köv. karra mutass
cmp byte ptr dta[si],0 ;az nulla?
jnz cik1 ;ha még nem akkor ismételj
mov flag,1 ;egy fájlnév már biztos ki volt írva, ezért flag egyesbe

kov:
mov ah,4fh ;köv. fájl keresése
int 21h
jnc tovabb ;ha cf=0, már nincs fájl

vege:
cmp flag,0 ;flag=0?
jne abort ;ha nem, akkor vége
kiir hibauz1 ;ha igen kiírunk egy hibaüzit, hogy nem volt fájl

abort:
kiir text2 ;várás egy bill.-re szöveg
mov ah,0ch ;bill. buffer törlése
mov al,7 ;várás egy bill.-re
int 21h

mov ah,4ch ;vezérlés vissza az op.-nek
int 21h

code ends ;code nevű szegmens vége
end start ;start cimkénél kezdünk

;Program 29

29.zip 29.exe 29.asm

;Írjon programot, amely bekér a bill. 3 kétjegyű egész számot, és ezeket megjeleníti a képernyőn a legnagyobbtól a legkisebbig.

code segment ;code nevű szegmens létrehozása
assume cs:code,ds:code ;hozzárendelés

;long szó jelentse azt, hogy 3, ez jelzi a beolvasandó számok számát, ha itt átírjuk, akkor mindenhol átíródik a programban, ha mondjuk 10 számot akarnánk bekérni, itt elég lenne átírni, és a program automatikusan 10 számot kérne be, és rendezne
long EQU 3

;változók
text1 db 'Legnagyobbtol a legkisebbig'
db 13,10,'***************************'
db 13,10,'Adj meg $'
text11 db ' szamot!',13,10,36
text2 db '. szam: $'
text3 db 13,10,13,10,'A szamok rendezve:',13,10,36
text4 db 13,10,13,10,'Nyomj le egy billentyut a kilepeshez...$'
hibauz1 db 13,10,'A megadhato legkisebb szam a 10, a legnagyobb a 99!$'
newline db 13,10,36 ;új sor írásához
buffer_key db 3,0,3 dup(0)
buffer_sort db long dup(0)
szemafor db ?
index dw ? ;a buffer_sort indexeléséhez

;macro string kiírására
kiir macro text
mov ah,9
mov dx,offset text
int 21h
endm ;macro vége

;macro egy karakter kiírására
putchar macro char
mov ah,2
mov dl,char
int 21h
endm ;macro vége

;procedúra bináris szám kiírására
binascii proc near ;bemenet ax
mov szemafor,0 ;szemafor nullázása
cmp ax,0 ;ax=0?
jne gop21 ;ha nem akkor megyünk tovább
putchar '0' ;ha ige, akkor kirakunk egy nullát
jmp vegep2 ;és megyünk a végére

gop21:
mov bx,10000 ;10000-rel fogunk osztani
xor dx,dx ;az osztás előtt nullázni kell a dx-et

cikp21:
div bx ;osztjuk az ax-et bx-el
mov si,dx ;a maradék az si-be
cmp ax,0 ;ax=0?
jne gop22 ;ha nem akkor gop22-re
cmp szemafor,0 ;ha igen, akkor szemafor=0?
je gop23 ;ha igen, ugrunk a gop23-ra

gop22:
add al,30h ;al-hez adjunk hozzá 30h, ASCII!
putchar al ;kitesszük a képernyőre
mov szemafor,1 ;már itt biztos volt kiírva karakter, ezért szemafor egyesbe

gop23:
mov ax,bx ;az osztót osztani kell 10-el
mov bx,10 ;10-el
xor dx,dx ;dx nullázása, mint fent
div bx ;kinullazza a dx-et, osztjuk az ax-et
cmp ax,1 ;megnézzük ax=1?
jb vegep2 ;ha kisebb mint 1, akkor vége
mov bx,ax ;ha nem, bx-be vissza az osztót
mov ax,si ;ax-be vissza a maradékot
jmp cikp21 ;vissza az elejére

vegep2:
ret ;visszatérünk a főprogramba
binascii endp ;proc. vége

;ASCII karaktereket alakít számmá
asciibin proc near ;bemenet si - mutato buffer+1
;kimenet ax - bin ertek
mov cl,byte ptr[si] ;bevisszük a cl-be a beolvasott karakterek számát
xor ax,ax ;ax-et nullázzuk
cmp cl,0 ;megnézzük volt-e beolvasott karakter
ja gop31 ;ha igen, akkor tovább
jmp vegep3 ;ha nem akkor vége

gop31:
mov bx,10 ;10-el fogunk szorozni

cikp31:
mul bx ;dx nullázva, szorozzuk az ax-et bx-el
inc si ;si köv. elemre mutasson
mov dl,byte ptr[si] ;bevisszük dl-be a karaktert
sub dl,30h ;levonunk belőle 30h, lásd ASCII!
add ax,dx ;hozzáadjuk az ax-hez a számjegyet
dec cl ;cl-1
jnz cikp31 ;addig míg cl!=0 vissza az elejére

vegep3:
ret ;visszatérés a főprogramba
asciibin endp ;proc. vége

;ez a lényeg, a rendező algoritmus
;bubblesort-ot használjuk, mivel kevés az elemszám
bubblesort proc near ;bemenet si - mutato a rendezendo tomb elso elemere, long a tomb hossza
jmp startp5 ;átugorjuk a változókat

;változók
p db ? ;egy szemafor, hogy tudjuk volt csere
buf dw ? ;buffer, amibe elmentjük az si kezdeti értékét

startp5:
mov buf,si ;előbb mondtam, itt mentjük el
mov dl,long ;dl-be azt, hogy mennyi bájtot kell rendezni

gop51:
mov p,0 ;p-t nullázzuk
mov si,buf ;si-be a kezdeti értékét
dec dl ;dl-be eggyel kevesebbet
jz vegep5 ;ha dl=0 akkor vége

mov cl,dl ;cl-be dl-t

atnezes:
mov al,byte ptr[si] ;bevisszük al-be, a buffer si-edik bájtját
cmp al,byte ptr[si+1] ;megnézzük hogyan viszonyul ez az elem a következővel
jae gop52 ;LÉNYEGES RÉSZ! Ha nagyobb vagy egyenlő akkor ugrunk, ha ezt átírjuk jbe gop52-re akkor legkisebbtől legnagyobbig rendez

xchg al,byte ptr[si+1] ;felcseréljük a két elemet
mov byte ptr[si],al
mov p,1 ;és p-t egyesbe állítjuk

gop52:
inc si ;si köv. elemre mutasson
dec cl ;cl eggyel kevesebb
jnz atnezes ;ha cl még nem nulla, akkor vissza az elejére

cmp p,1 ;megnézzük p=1?
je gop51 ;ha igen, ugrunk

vegep5:
ret ;visszatérés a főprogramba
bubblesort endp ;proc. vége

;főprogram
start:
mov ax,cs ;adatszegmens kezdőcímének beállítása
mov ds,ax

mov ax,3 ;képernyő törlése, 80x25-ös módba való váltással
int 10h

kiir text1 ;kiírjuk a text1-et
mov ax,long ;bevisszük azt az ax-be, hogy mennyi számot kell megadni
call binascii ;kiírjukl ezt a számot
kiir text11 ;itt meg a szöveg többi része

mov index,1 ;index=1, ez egyben ciklusváltozó is

;itt olvassuk be a számokat
cik1:
kiir newline ;írunk egy új sort
mov ax,index ;kiírjuk, hogy hanyadik számot adjuk meg épp
call binascii
kiir text2 ;és kiírjuk, hogy . szám:

mov ah,0ch ;bill. buffer törlése
mov al,0ah ;string beolvasása
mov dx,offset buffer_key ;a buffer_key-be
int 21h ;csináld

xor bx,bx ;bx nullázása

cik3:
cmp buffer_key[bx+2],30h ;megnézzük, hogy a beolvasott két karakter szám volt-e
jb go1
cmp buffer_key[bx+2],39h
ja go1
inc bl ;végignézzük a tömböt
cmp bl,buffer_key[1]
jb cik3
jmp go2 ;ha ide eljutunk, akkor minden rendben, mehetünk tovább

go1:
kiir hibauz1 ;ha nem volt rendben, akkor kiírjuk, hogy hiba
jmp cik1 ;és bekérjük még 1x

go2:
mov si,offset buffer_key+1 ;si-be a buffer második bájtjára mutató mutató
call asciibin ;csinálunk belőle számot
cmp al,10 ;az ax-be lesz ez a szám, megnézzük nagyobb mint 10?
jb go1 ;ha kisebb, akkor baj van, megyünk a hibára

mov si,index ;si-be index
mov buffer_sort[si-1],al ;elmentjük a buffer_sort-ba a számot
inc index ;index mutasson a buffer köv. elemére, a köv. mentéshez
cmp index,long ;megnézzük bekértük már az összes számot?
jbe cik1 ;ha még nem, akkor kérjük

mov si,offset buffer_sort ;na itt rendezzük
call bubblesort ;ez csinálja

kiir text3 ;kiírju, hogy a tömb rendezve
mov index,1 ;index=1

cik2:
kiir newline ;újsor
mov ax,index ;ax-be index
call binascii ;kiírjuk az index-et
kiir text2 ;kiírjuk, hogy . szám:

xor ah,ah ;ah-t nullázzuk
mov si,index ;si-be index
mov al,buffer_sort[si-1] ;buffer megfelelő bájtját al-be
call binascii ;kiírni

inc index ;index köv. elemre
cmp index,long ;megnézzük kiírtuk már az összes elemet?
jbe cik2 ;ha még nem, akkor vissza a cik2-re

kiir text4 ;kiírjuk, hogy nyomj bármilyen bill.-t

mov ah,0ch ;bill. buffer törlése
mov al,7 ;várás echo nélkül egy bill. lenyomására
int 21h

mov ah,4ch ;a vezérlés visszaadása az op.-nek
int 21h

code ends ;code szegmens vége
end start ;start cimkénél kezdünk

;Program 30

30.zip 30.exe 30.asm

;Írjon programot, amely megállapítja az aktuális dátumot, hozzáad egy napot, és lecseréli az aktuális dátumot erre az újra. Kiírja a régi és az új dátumokat is.

code segment ;code nevű szegmens létrehozása
assume cs:code,ds:code ;hozzárendelés

;változók
text1 db 'Aktualis datum: $'
text2 db 13,10,'Uj datum: $'
text3 db 13,10,'Nyomj le barmilyen billentyut a kilepeshez...$'
hibauz1 db 13,10,'A datum megvaltoztatasa sikertelen!$'
ev dw ? ;ide mentjük az évet
ho db ? ;hónapot
nap db ? ;napot :D

;macro string kiírására
pstring macro string
mov ah,9
mov dx,offset string
int 21h
endm ;macro vége

;macro egy kar. kiírására
putchar macro kar
mov ah,2
mov dl,kar
int 21h
endm

;macro a dátum megváltoztatására
change_datum macro
mov ah,2bh
mov cx,ev ;az új dátum az ev, ho, nap nevű változókban
mov dh,ho ;vannak, ezeket változtatjuk meg
mov dl,nap
int 21h
endm

;macro a dátum kiírására
print_datum macro
mov ax,ev
call binascii ;a binascii írja ki nekünk
putchar '.' ;teszünk egy .-ot
xor ah,ah ;ah-t nullázzuk, mert a binascii az ax-et írja ki, mi csak az al-be rakunk számot, az ah-t ezért nullázni kell
mov al,ho
call binascii
putchar '.'
xor ah,ah ;ez ugyanaz mint előbb, csak a nap-ot írjuk ki
mov al,nap
call binascii
endm
;proc. ami kiírja az ax-ben megadott számot a képernyőre
binascii proc near ;bemenet ax
jmp binascii_start ;átugorjuk a változót

flag db ? ;volt már kiírt számjegy? ezt mondja meg

binascii_start:
mov flag,0 ;flag=0 ? még nem volt kiírt számjegy
cmp ax,0 ;ax=0?
jne binascii_go1 ;ha nem, akkor tovább
mov ah,2 ;ha igen, akkor kiírunk egy nullát
mov dl,'0'
int 21h
ret ;és visszatérünk

binascii_go1:
mov bx,10000 ;10000-rel fogunk osztani
xor dx,dx ;osztás ? dx-et nullázni kell! lásd füzet DIV utasítás

binascii_cik1:
div bx ;ax-et osztjuk bx-el
mov si,dx ;maradékot dx-ben kapjuk vissza, elmentjük si-be
cmp ax,0 ;ax=0?
jne binascii_go2 ;ha nem akkor tovább
cmp flag,0 ;ha igen, akkor flag=0?
je binascii_go3 ;ha igen, akkor még nem volt kiírt számjegy, ezért a kapott nullát nem írjuk ki

binascii_go2:
mov ah,2 ;ha ide eljutunk, kiírjuk a számjegyet
mov dl,al
add dl,30h ;előbb hozzáadunk 30h-t, ASCII!
int 21h
mov flag,1 ;és flag=1, mert már van kiírt számjegy

binascii_go3:
mov ax,bx ;bx-et osztani kell 10-el
mov bx,10 ;10-el
xor dx,dx ;dx-et nullázni
div bx ;kinullázza a dx-et
cmp ax,1 ;ax=1?
jb binascii_vege ;ha kisebb mint egy akkor vége
mov bx,ax ;ha nem, akkor bx vissza osztónak
mov ax,si ;ax-be meg az előbbi maradék
jmp binascii_cik1 ;és vissza a ciklus elejére

binascii_vege:
ret ;visszatérés a főprogramba
binascii endp ;proc. vége

;főprogram
start:
mov ax,cs ;adatszegmens kezdőcímének beállítása
mov ds,ax
cld ;df nullázása

mov ah,2ah ;dátum lekérésse
int 21h
mov ev,cx ;cx-ben az évet
mov ho,dh ;dh-ban a hónapot
mov nap,dl ;dl-ben pedig a napot kapjuk vissza

pstring text1 ;kiírjuk a text1-et
print_datum ;kiírjuk a dátumot is

inc nap ;nap eggyel nagyobb legyen!
change_datum ;megpróbáljuk megváltoztatni a dátumot
or al,al ;aktualizáljuk a jelzőbiteket
jz oke ;ha a dátum megváltozott, akkor al=0, jz ugorni fog

mov nap,1 ;ha nem jó, akkor hó végén vagyunk, ugrunk köv. hó elejére
inc ho
change_datum ;megváltoztatjuk a dátumont
or al,al ;ugyanúgy mint előbb, ha sikerül akkor ugrunk
jz oke

mov ho,1 ;ha nem, akkor az azt jelenti, hogy év vége
inc ev ;minden egyesbe, év eggyel növeljük
change_datum ;megváltoztatjuk a dátumot
or al,al
jz oke ;ha ez sem jön be, akkor valami más hiba van, kiírjuk, hogy nem sikerült

pstring hibauz1
jmp vege ;és ugrunk a végére

oke:
pstring text2 ;kiírjuk az új dátumot
print_datum

pstring text3
mov ah,0ch ;bill. buffer törlése
mov al,7 ;várás egy karakterre, echo nélkül
int 21h

vege:
mov ah,4ch ;a vezérlés visszaadása az op.-nek
int 21h

code ends ;code nevű szegmens vége
end start ;start cimkénél kezdünk

acme-web-design.info
acme-web-design.info