; Program zamienia wszystkie litery w podanym pliku z wielkich na male.
;
; Skladnia:
;   "na_duze"  i program poprosi o nazwe pliku do przetworzenia
;   "na_duze nazwa_pliku"
;
; Autor: Bogdan D.
; kontakt: bogdandr (at) op (dot) pl
;
; kompilacja:
;
; nasm -f elf na_male.asm
; ld -s -o na_male na_male.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	; na wszelki wypadek
	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
	jge	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
	jge	czyt_ok
	call	plik_blad

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

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

	mov	ecx, eax		; ECX = ilosc przeczytanych bajtow
zamiana:
					; zaczynamy zamieniac znaki:
	mov	dl, [bufor+edi]		; pobierz znak z bufora

	cmp	dl, 'A'			; sprawdz, czy jest to wielka litera
	jb	znak_ok2
	cmp	dl, 'Z'
	ja 	znak_ok2

	or	dl, 20h			; zamien litere na mala

					; 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
	jge	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
	jge	czytaj

	call	plik_blad
	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, 'A'			; sprawdz, czy jest to wielka litera
	jb	znak_ok2
	cmp	dl, 'Z'
	ja 	znak_ok2

	or	dl, 20h			; zamien litere na mala

	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
	jge	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
	jge	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
	jge	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
	push	esi

	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

	mov	eax, 4
	mov	ebx, 1
	mov	ecx, blad_plik
	mov	edx, 1			; znak przejscia do nowej linii
	int	80h

	pop	esi
	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 wielkie litery w pliku na male.', 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