; Program zamienia wszystkie polskie znaki w podanym pliku na "nie-polskie"
; (pozbawia polskie znaki "ogonkow").
;
; Skladnia:
;   "bez_pol"  i program poprosi o nazwe pliku do przetworzenia
;   "bez_pol nazwa_pliku"
;
; Autor: Bogdan D.
; kontakt: bogdandr (at) op (dot) pl
;
; kompilacja:
; nasm -f elf bez_pol.asm
; ld -s -o bez_pol bez_pol.o
;
; Copyright (C) 2005-2007 Bogdan 'bogdro' Drozdowski, bogdandr @ op . pl
;
; Ten program jest wolnym oprogramowaniem; mozesz go rozpowszechniac
; i/lub modyfikowac zgodnie z licencja GNU Lesser General Public License
; (GNU LGPL) w wersji wydanej przez Fundacje Wolnego Oprogramowania;
; wedlug wersji 3 Licencji lub (jesli wolisz) jednej z pozniejszych wersji.
;
; Ten program jest udostepniany z nadzieja, ze bedzie uzyteczny, lecz
; BEZ JAKIEJKOLWIEK GWARANCJI; nawet domyslnej gwarancji PRZYDATNOSCI
; HANDLOWEJ albo PRZYDATNOSCI DO OKRESLONYCH ZASTOSOWAN. W celu uzyskania
; blizszych informacji - Licencja GNU Lesser General Public License.
;
; Z pewnoscia wraz z niniejszym programem otrzymales tez egzemplarz
; Licencji GNU Lesser General Public License; jesli nie - napisz do
; Fundacji Wolnego Oprogramowania:
;		Free Software Foundation
;		51 Franklin Street, Fifth Floor
;		Boston, MA 02110-1301
;		USA

section .text

global _start

_start:
	push	ebp
	mov	ebp, esp

%idefine        argc    ebp+4
%idefine        argv    ebp+8

        mov     eax, [argc]		;sprawdzamy, ile podano nam argumentow
	cmp	eax, 1
	ja	z_arg

	mov	eax, 4			; funkcja zapisu do pliku
	mov	ebx, 1			; stdout ( ekran )
	mov	ecx, input1		; napis
	mov	edx, input1_dl		; ile bajtow piszemy
	int	80h			; wyswietlamy prosbe o nazwe pliku

	mov	eax, 3			; funkcja odczytu z pliku
	xor	ebx, ebx		; EBX = 0 = stdin ( klawiatura )
	mov	ecx, plik		; gdzie zapisujemy odczytane dane
	mov	edx, 200h		; ile bajtow chcemy
	int	80h			; wykonaj

	mov	byte [plik+1ffh], 0	; konczymy bajtem zerowym
	mov	byte [plik+eax-1], 0

input_juz:

	mov	eax, 5			; funkcja otwarcia pliku
	mov	ebx, plik		; nazwa pliku, ktory chcemy otworzyc
	mov	ecx, 2			; odczyt i zapis
	mov	edx, 600q		; - RW- --- ---
	int	80h

	cmp	eax, 0			; sprawdzamy, czy nie wystapil blad
	jae	otw_ok
	call	plik_blad
	jmp	zamk_ok

otw_ok:
	mov	ebx, eax		; zachowanie deskryptora pliku
	mov	esi, eax

	mov	ebp, 400h		; EBP = ilosc bajtow, ktore bedziemy
					; odczytywac

czytaj:
	mov	eax, 3			; funkcja czytania z pliku
;;;	mov	ebx, esi		; EBX juz ma w sobie deskryptor pliku
	mov	ecx, bufor		; gdzie umieszczac odczytane dane
	mov	edx, ebp		; ilosc bajtow, ktora nas interesuje
	int	80h			; wykonaj

	cmp	eax, 0			; sprawdzamy, czy nie wystapil blad
	jae	czyt_ok
	call	plik_blad

czyt_ok:
	xor	edi, edi		; EDI zawiera numery kolejnych znakow

	cmp	eax, edx		; czy odczytalismy tyle,
					; ile chcielismy?
	jne	przy_eof		; jesli nie, to plik nam sie skonczyl

	mov	ecx, edx		; ECX = ilosc zadanych bajtow
zamiana:
					; zaczynamy zamieniac znaki:
	mov	dl, [bufor+edi]		; pobierz znak do sprawdzenia i
					; porownuj go z kazdym mozliwym
					; znaczkiem polskim. Jesli
					; pasuje, zamien na bezogonkowy
					; odpowiednik

	cmp	dl, 0cah		;'E'
	jnz	nie1
	mov	dl, 'E'
	jmp	juz_zamiana

nie1:
	cmp	dl, 0d3h		;'O'
	jnz	nie2
	mov	dl, 'O'
	jmp	juz_zamiana

nie2:
	cmp	dl, 0a1h		;'A'
	jnz	nie3
	mov	dl, 'A'
	jmp	juz_zamiana

nie3:
	cmp	dl, 0a6h		;'S'
	jnz	nie4
	mov	dl, 'S'
	jmp	short juz_zamiana

nie4:
	cmp	dl, 0a3h		;'L'
	jnz	nie5
	mov	dl, 'L'
	jmp	short juz_zamiana

nie5:
	cmp	dl, 0ach		;'Z'
	jnz	nie6
	mov	dl, 'Z'
	jmp	short juz_zamiana

nie6:
	cmp	dl, 0afh		;'Z'
	jnz	nie7
	mov	dl, 'Z'
	jmp	short juz_zamiana

nie7:
	cmp	dl, 0c6h		;'C'
	jnz	nie8
	mov	dl, 'C'
	jmp	short juz_zamiana

nie8:
	cmp	dl, 0d1h		;'N'
	jnz	nie9
	mov	dl, 'N'
	jmp	short juz_zamiana

nie9:
	cmp	dl, 0eah		;'e'
	jnz	nie10
	mov	dl, 'e'
	jmp	short juz_zamiana

nie10:
	cmp	dl, 0f3h		;'o'
	jnz	nie11
	mov	dl, 'o'
	jmp	short juz_zamiana

nie11:
	cmp	dl, 0b1h		;'a'
	jnz	nie12
	mov	dl, 'a'
	jmp	short juz_zamiana

nie12:
	cmp	dl, 0b6h		;'s'
	jnz	nie13
	mov	dl, 's'
	jmp	short juz_zamiana

nie13:
	cmp	dl, 0b3h		;'l'
	jnz	nie14
	mov	dl, 'l'
	jmp	short juz_zamiana

nie14:
	cmp	dl, 0bch		;'z'
	jnz	nie15
	mov	dl, 'z'
	jmp	short juz_zamiana

nie15:
	cmp	dl, 0bfh		;'z'
	jnz	nie16
	mov	dl, 'z'
	jmp	short juz_zamiana

nie16:
	cmp	dl, 0e6h		;'c'
	jnz	nie17
	mov	dl, 'c'
	jmp	short juz_zamiana

nie17:
	cmp	dl, 0f1h		;'n'
	jnz	juz_zamiana
	mov	dl, 'n'


juz_zamiana:				;ewentualnie zmieniony znak zapisujemy
					; z powrotem do bufora
	mov	[bufor+edi], dl

znak_ok:
	inc	edi			; przejdz na kolejny znak
	dec	ecx
	jnz	zamiana			;jesli bufor sie jeszcze nie skonczyl,
					; idz od nowa
					; i sprawdzaj kolejne znaki

					; sprawdzilismy wszystkie znaki.
					; Zapisz wynik do pliku.

	mov	eax, 19			; przejscie na inna pozycje w pliku
;;;	mov	ebx, esi		; EBX juz zawiera deskryptor pliku
	mov	ecx, -400h		; cofamy sie o dlugosc bufora
	mov	edx, 1			; od biezacej pozycji w pliku
	int	80h

	cmp	eax, 0			; sprawdzamy, czy nie wystapil blad
	jae	idz_ok
	call	plik_blad

idz_ok:
	mov	eax, 4			; funkcja zapisu do pliku
;;;	mov	ebx, esi		; EBX juz zawiera deskryptor pliku
	mov	ecx, bufor		; gdzie sa dane do zapisania
	mov	edx, 400h		; ile danych zapiszemy
	int	80h

	cmp	eax, 0			; sprawdzamy, czy nie wystapil blad
	jae	zapis_ok
	call	plik_blad

zapis_ok:
	jmp	czytaj


;**************************************


przy_eof:
	xor	edi, edi		; EDI zawiera numery kolejnych znakow
	mov	ebp, eax
	mov	ecx, eax		; ECX=EBP=ilosc przeczytanych znakow



zamiana2:				; petla zamieniajaca znaki na ich
					; odpowiedniki
	mov	dl, [bufor+edi]

	cmp	dl, 0cah		;'E'
	jnz	nie1_2
	mov	dl, 'E'
	jmp	juz_zamiana_2

nie1_2:
	cmp	dl, 0d3h		;'O'
	jnz	nie2_2
	mov	dl, 'O'
	jmp	juz_zamiana_2

nie2_2:
	cmp	dl, 0a1h		;'A'
	jnz	nie3_2
	mov	dl, 'A'
	jmp	juz_zamiana_2

nie3_2:
	cmp	dl, 0a6h		;'S'
	jnz	nie4_2
	mov	dl, 'S'
	jmp	short juz_zamiana_2

nie4_2:
	cmp	dl, 0a3h		;'L'
	jnz	nie5_2
	mov	dl, 'L'
	jmp	short juz_zamiana_2

nie5_2:
	cmp	dl, 0ach		;'Z'
	jnz	nie6_2
	mov	dl, 'Z'
	jmp	short juz_zamiana_2

nie6_2:
	cmp	dl, 0afh		;'Z'
	jnz	nie7_2
	mov	dl, 'Z'
	jmp	short juz_zamiana_2

nie7_2:
	cmp	dl, 0c6h		;'C'
	jnz	nie8_2
	mov	dl, 'C'
	jmp	short juz_zamiana_2

nie8_2:
	cmp	dl, 0d1h		;'N'
	jnz	nie9_2
	mov	dl, 'N'
	jmp	short juz_zamiana_2

nie9_2:
	cmp	dl, 0eah		;'e'
	jnz	nie10_2
	mov	dl, 'e'
	jmp	short juz_zamiana_2

nie10_2:
	cmp	dl, 0f3h		;'o'
	jnz	nie11_2
	mov	dl, 'o'
	jmp	short juz_zamiana_2

nie11_2:
	cmp	dl, 0b1h		;'a'
	jnz	nie12_2
	mov	dl, 'a'
	jmp	short juz_zamiana_2

nie12_2:
	cmp	dl, 0b6h		;'s'
	jnz	nie13_2
	mov	dl, 's'
	jmp	short juz_zamiana_2

nie13_2:
	cmp	dl, 0b3h		;'l'
	jnz	nie14_2
	mov	dl, 'l'
	jmp	short juz_zamiana_2

nie14_2:
	cmp	dl, 0bch		;'z'
	jnz	nie15_2
	mov	dl, 'z'
	jmp	short juz_zamiana_2

nie15_2:
	cmp	dl, 0bfh		;'z'
	jnz	nie16_2
	mov	dl, 'z'
	jmp	short juz_zamiana_2

nie16_2:
	cmp	dl, 0e6h		;'c'
	jnz	nie17_2
	mov	dl, 'c'
	jmp	short juz_zamiana_2

nie17_2:
	cmp	dl, 0f1h		;'n'
	jnz	juz_zamiana_2
	mov	dl, 'n'

juz_zamiana_2:
	mov	[bufor+edi], dl		; zapisanie zmienionego znaku
					; z powrotem

znak_ok2:
	inc	edi
	dec	ecx
	jnz	zamiana2		; jesli zostaly jeszcze znaki,
					; to sprawdz je

					; zapisz wynik do pliku:

	mov	ecx, ebp
	neg	ecx			; ECX = -ilosc przeczytanych bajtow
	mov	eax, 19			; funkcja zmiany pozycji w pliku
;;;	mov	ebx, esi		; EBX ma deskryptor
	mov	edx, 1			; licz od biezacej pozycji w pliku
	int	80h

	cmp	eax, 0			; sprawdzamy, czy nie wystapil blad
	jae	idz_ok2
	call	plik_blad

idz_ok2:
	mov	eax, 4			; funkcja zapisu do pliku
;;;	mov	ebx, esi		; EBX zawiera deskryptor pliku
	mov	ecx, bufor		; co zapisac
	mov	edx, ebp		; ile zapisac
	int	80h

	cmp	eax, 0			; sprawdzamy, czy nie wystapil blad
	jae	zamk
	call	plik_blad

zamk:
	mov	eax, 6			; funkcja zamkniecia pliku
;;;	mov	ebx, esi		; EBX juz ma deskryptor pliku
	int	80h

	cmp	eax, 0			; sprawdzamy, czy nie wystapil blad
	jae	zamk_ok
	call	plik_blad

zamk_ok:
	mov	eax, 1			; wyjscie z programu
	xor	ebx, ebx
	int	80h


;**************************************

z_arg:
        cld
        mov     al, 0
        mov     esi, [argv+4]
        mov     edi, [argv+4]
        mov     ecx, 200h
        repne   scasb                   ; znajdz koniec argumentu

					; pierwszy arg. to nazwa programu
        mov     ecx, edi                ; przepisz drugi arg. do nazwy pliku
        sub     ecx, esi
        inc     ecx
        mov     edi, plik
	rep     movsb

	mov     byte [plik+1ffh], 0
        jmp     input_juz

;**************************************


plik_blad:
	push	eax
	push	ebx
	push	ecx
	push	edx

	mov	esi, eax

	mov	eax, 4			; funkcja zapisu do pliku
	mov	ebx, 1			; na ekran
	mov	ecx, blad_plik		; co napisac
	mov	edx, blad_plik_dl	; ile napisac
	int	80h			; wykonaj

	mov	eax, esi

	call	_pisz_ld

	pop	edx
	pop	ecx
	pop	ebx
	pop	eax

	ret


;**************************************


_pisz_ld:

; pisz32e
; we: EAX=liczba bez znaku do wypisania

	pushfd
	push	ecx
	push	edx
	push	eax
	push	esi

	xor	esi, esi
	mov	ecx, 10

._pisz_ld_petla:
	xor	edx, edx
	div	ecx

	or	dl, '0'
	mov	[_pisz_bufor+esi], dl		; do bufora ida reszty z
						; dzielenia przez 10,
	inc	esi				; czyli cyfry wspak

	test	eax, eax
	jnz	._pisz_ld_petla

._pisz_ld_wypis:
	mov	al, [_pisz_bufor+esi-1]		; wypisujemy reszty wspak
	call	_pisz_z

	dec	esi
	jnz	._pisz_ld_wypis

	pop	esi
	pop	eax
	pop	edx
	pop	ecx
	popfd

	ret

;**************************************

_pisz_z:

; pisz_z
; we: AL=znak do wypisania

	push	eax
	push	ebx
	push	ecx
	push	edx

	mov	[_pisz_bufor+39], al

	mov	eax, 4			; funkcja zapisu do pliku
	mov	ebx, 1			; kierujemy na standardowe wyjscie
	lea	ecx, [_pisz_bufor+39]	; mowimy, co chcemy napisac
	mov	edx, 1			; ile bajtow?
	int	80h

	pop	edx
	pop	ecx
	pop	ebx
	pop	eax

	ret


; ==========================================================

section .data

info		db 'Program zamienia polskie litery w pliku na zwykle.', 10
info_dl		equ	$ - info

input1		db	'Podaj nazwe pliku do przetworzenia: '
input1_dl	equ	$ - input1

plik		times	200h	db 0
zla_nazwa	db	10, 'Zla nazwa pliku.'
zla_nazwa_dl	equ	$ - zla_nazwa

blad_plik	db	10, 'Blad operacji na pliku. Kod: '
blad_plik_dl	equ	$ - blad_plik

_pisz_bufor	times	40	db	0

bufor		times	400h db 0