Era Definitivo

DEFINITIVO/asm_morati_mirko_murr_noè/src/Makefile

@@ -0,0 +1,46 @@
+# Progetto Assembly 2016
+# File: open_files.s
+# Autori: Noè Murr, Mirko Morati
+#
+# Descrizione: Makefile per il progetto assembly
+
+AS:=as
+ASFLAGS:=-gstabs --32
+LD:=ld
+LDFLAGS:=-m elf_i386
+BINNAME=elaborato
+OBJ= main.o open_files.o read_line.o check.o write_line.o itoa.o atoi.o close_files.o
+HEADERS=syscall.inc
+RM=rm -rf
+ECHO=/bin/echo
+
+.PHONY: all run clean rebuild help
+
+%.o: %.s $(HEADERS)
+	@$(ECHO) -n "Compiling $< 	"
+	@$(AS) -c -o $@ $< $(ASFLAGS)
+	@$(ECHO) "[ ok ]"
+
+$(BINNAME): $(OBJ)
+	@$(ECHO) -n "Linking $(BINNAME)		"
+	@$(LD) -o $@ $^ $(LDFLAGS)
+	@$(ECHO) "[ ok ]"
+
+all: $(BINNAME)
+
+debug: ASFLAGS += -g
+debug: LDFLAGS += -g
+debug: $(BINNAME)
+
+run: $(BINNAME)
+	@$(ECHO) "Running $(BINNAME)"
+	@./$(BINNAME)
+
+clean:
+	@$(ECHO) -n "Cleaning sources 	"
+	@$(RM) *.o
+	@$(RM) $(BINNAME)
+	@$(ECHO) "[ ok ]"
+
+
+rebuild: clean $(BINNAME)

DEFINITIVO/asm_morati_mirko_murr_noè/src/atoi.s

@@ -0,0 +1,43 @@
+# Progetto Assembly 2016
+# File: atoi.s
+# Autori: Alessandro Righi, Noè Murr, Mirko Morati
+#
+# Descrizione: Funzione che converte una stringa in intero.
+
+.section .text
+	.globl	_atoi
+	.type	_atoi, @function
+
+# Funzione che converte una stringa di input in numero
+# Prototipo C-style:
+#   uint32_t atoi(const char *string);
+# Parametri di input:
+#   EDI - Stringa da convertire
+# Parametri di output:
+#   EAX - Valore convertito
+
+_atoi:
+	xorl	%eax, %eax   # azzero il registro EAX per contenere il risultato
+	xorl	%ebx, %ebx   # azzero EBX
+	movl	$10, %ecx    # sposto 10 in ECX che conterrà il valore moltiplicativo
+
+_atoi_loop:
+	xorl	%ebx, %ebx
+	movb	(%edi), %bl  # sposto un byte dalla stringa in BL
+	subb	$48, %bl     # sottraggo il valore ASCII dello 0 a BL
+					     # per avere un valore intero
+
+	cmpb	$0, %bl      # Se il numero è minore di 0
+	jl		_atoi_end    # allora esco dal ciclo
+	cmpb	$10, %bl     # Se il numero è maggiore o uguale a 10
+	jge 	_atoi_end    # esco dal ciclo
+
+	mull	%ecx         # altrimenti moltiplico EAX per 10
+					     # (10 messo precedentemente in ECX)
+	addl	%ebx, %eax   # aggiungo a EAX il valore attuale
+	incl	%edi         # incremento EDI
+
+	jmp		_atoi_loop   # rieseguo il ciclo
+
+_atoi_end:
+	ret

DEFINITIVO/asm_morati_mirko_murr_noè/src/check.s

@@ -0,0 +1,106 @@
+# Progetto Assembly 2016
+# File: check.s
+# Autori: Noè Murr, Mirko Morati
+#
+# Descrizione: Funzione che controlla le variabili
+# init, reset, rpm e setta le variabili alm, mod e numb
+
+.section .data
+
+.section .text
+    .globl  _check
+    .type   _check, @function
+
+_check:
+    pushl   %ebp
+    movl    %esp, %ebp
+
+    # Caso init == 0: alm = 0; mod = 0; numb = 0;
+    cmpl    $0, init
+    je      _init_0
+
+    # Caso SG: alm = 0; mod = 1; numb = reset == 1 ? 0 : numb + 1;
+    cmpl    $2000, rpm
+    jl      _sg
+
+    # Caso OPT: alm = 0; mod = 2; numb = reset == 1 ? 0 : numb + 1;
+    cmpl    $4000, rpm
+    jle     _opt
+
+    # Caso FG: alm = numb >= 15? 1 : 0; mod = 3; numb = reset == 1 ? 0 : numb + 1;
+_fg:
+    # Salviamo la nuova modalita' in %eax e controlliamo reset
+    movl    $3, %eax
+    cmpl    $1, reset
+    je      _reset_numb
+
+    # Se la nuova modalità non è la stessa si resetta il numero di secondi
+    cmpl    $3, mod
+    jne     _reset_numb
+
+    incl    numb
+    movl    %eax, mod
+
+    # Se il numero di secondi è maggiore o uguale a 15 viene alzata l'allarme
+    cmpl    $15, numb
+    jge      _set_alm
+
+    jmp     _end_check
+
+_opt:
+    movl    $2, %eax
+    cmpl    $1, reset
+    je      _reset_numb
+
+    cmpl    $2, mod
+    jne     _reset_numb
+
+    incl    numb
+    movl    %eax, mod
+
+    jmp     _end_check
+
+_sg:
+    movl    $1, %eax
+    cmpl    $1, reset
+    je      _reset_numb
+
+    cmpl    $1, mod
+    jne      _reset_numb
+
+    incl    numb
+    movl    %eax, mod
+
+    jmp     _end_check
+
+_reset_numb:
+    movl    %eax, mod
+    movl    $0, numb
+    movl    $0, alm
+
+    jmp     _end_check
+
+_set_alm:
+    movl    $1, alm
+
+
+    jmp     _end_check
+
+_init_0:
+    movl    $0, alm
+    movl    $0, numb
+    movl    $0, mod
+
+_end_check:
+
+    # Se il numero di secondi supera i 99 allora dobbiamo ricominciare il conteggio
+    cmpl    $99, numb
+    jg      _numb_overflow
+    movl    %ebp, %esp
+    popl    %ebp
+
+    ret
+
+_numb_overflow:
+    movl    $0, numb
+    jmp     _end_check

DEFINITIVO/asm_morati_mirko_murr_noè/src/close_files.s

@@ -0,0 +1,32 @@
+# Progetto Assembly 2016
+# File: check.s
+# Autori: Noè Murr, Mirko Morati
+#
+# Descrizione: Funzione che chiude i file aperti precedentemente
+
+.include "syscall.inc"
+
+.section .text
+	.globl 	_close_files 			 # Dichiaro la funzione globale
+	.type 	_close_files, @function  # Dichiaro l' etichetta come una funzione
+
+_close_files:
+
+	pushl	%ebp
+	movl 	%esp, %ebp
+
+	# sys_close(input_fd);
+	movl	$SYS_CLOSE, %eax
+	movl	input_fd, %ebx
+	int 	$SYSCALL
+
+	# sys_close(output_fd);
+	movl	$SYS_CLOSE, %eax
+	movl	output_fd, %ebx
+	int 	$SYSCALL
+
+
+	movl    %ebp, %esp
+    popl    %ebp
+
+    ret

DEFINITIVO/asm_morati_mirko_murr_noè/src/itoa.s

@@ -0,0 +1,52 @@
+# Progetto Assembly 2016
+# File: itoa.s
+# Autori: Alessandro Righi, Noè Murr, Mirko Morati
+#
+# Descrizione: Funzione che converte un intero in stringa
+# Prototipo C-style:
+#   u_int32_t itoa(uint32_t val, char *string);
+# Parametri di input:
+#   EAX - Valore intero unsigned a 64bit da convertire
+#   EDI - Puntatore alla stringa su cui salvare il risultato
+# Parametri di output:
+#   EAX - Lunghezza della stringa convertita (compresiva di \0 finale)
+
+.section .text
+    .global _itoa
+    .type   _itoa, @function
+
+_itoa:
+    movl    $10, %ecx   # porto il fattore moltiplicativo in ECX
+    movl    %eax, %ebx  # salvo temporaneamente il valore di EAX in EBX
+    xorl    %esi, %esi  # azzero il registro ESI
+
+_itoa_dividi:
+    xorl    %edx, %edx  # azzero EDX per fare la divisione
+    divl    %ecx        # divide EAX per ECX, salva il resto in EDX
+    incl    %esi        # incrementa il contatore
+    testl   %eax, %eax  # se il valore di EAX non è zero ripeti il ciclo
+    jnz     _itoa_dividi
+
+    addl    %esi, %edi  # somma all'indirizzo del buffer
+                        # il numero di caratteri del numero
+    movl    %ebx, %eax  # rimette il valore da convertire in EAX
+    movl    %esi, %ebx  # salvo il valore della lunghezza della stringa in EBX
+
+    movl    $0, (%edi)  # aggiungo un null terminator alla fine della stringa
+    decl    %edi        # decremento il contatore della stringa di 1
+
+_itoa_converti:
+    xorl    %edx, %edx  # azzero EDX per fare la divisione
+    divl    %ecx        # divido EAX per ECX, salvo il valore del resto in EDX
+    addl    $48, %edx   # sommo 48 a EDX
+    movb    %dl, (%edi) # sposto il byte inferiore di EDX (DL)
+                        # nella locazione di memoria puntata da EDI
+    decl    %edi        # decremento il puntatore della stringa
+    decl    %esi        # decremento il contatore
+    testl   %esi, %esi  # se il contatore non è 0 continua ad eseguire il loop
+    jnz     _itoa_converti
+
+    movl    %ebx, %eax  # porto il valore della lunghezza
+                        # della stringa in EAX per ritornarlo
+    incl    %eax        # incremento di 1 EAX (in modo da includere il \0)
+    ret

DEFINITIVO/asm_morati_mirko_murr_noè/src/main.s

@@ -0,0 +1,95 @@
+# Progetto Assembly 2016
+# File: main.s
+# Autori: Noè Murr, Mirko Morati
+#
+# Descrizione: File principale, punto di inizio del programma.
+.include    "syscall.inc"
+
+.section    .data
+    input_fd:   .long 0         # variabile globale che conterrà il file
+                                # descriptor del file di input
+
+    output_fd:  .long 0         # variabile globale che conterrà il file
+                                # descriptor del file di output
+
+    # Variabili globali per i segnali di input
+    init:   .long 0
+    reset:  .long 0
+    rpm:    .long 0
+
+    # Variabili globali per i segnali di output
+    alm:    .long 0
+    numb:   .long 0
+    mod:    .long 0
+
+# Codice del programma
+
+.section    .text
+    .globl  input_fd
+    .globl  output_fd
+    .globl  init
+    .globl  reset
+    .globl  rpm
+    .globl  alm
+    .globl  numb
+    .globl  mod
+    .globl  _start
+
+    # Stringa per mostrare l'utilizzo del programma in caso di parametri errati
+    usage:  .asciz "usage: programName inputFilePath outputFilePath\n"
+    .equ    USAGE_LENGTH, .-usage
+
+_start:
+    # Recupero i parametri del main
+    popl    %eax                # Numero parametri
+
+    # Controllo argomenti, se sbagliati mostro l'utilizzo corretto
+    cmpl    $3, %eax
+    jne     _show_usage
+
+    popl    %eax                # Nome programma
+    popl    %eax                # Primo parametro (nome file di input)
+    popl    %ebx                # Secondo parametro (nome file di output)
+
+    # NB: non salvo ebp in quanto non ha alcuna utilità
+    # nella funzione start che comunque non ritorna
+
+    movl    %esp, %ebp
+
+    call    _open_files         # Apertura dei file
+
+_main_loop:
+
+    call    _read_line          # Leggiamo la riga
+
+    cmpl    $-1, %ebx           # EOF se ebx == -1
+    je      _end
+
+    call    _check              # Controllo delle variabili
+
+    call    _write_line         # Scrittura delle variabili di output su file
+
+    jmp     _main_loop          # Leggi un altra riga finché non è EOF
+
+_end:
+
+    call    _close_files        # Chiudi correttamente i file
+
+    # sys_exit(0);
+    movl    $SYS_EXIT, %eax
+    movl    $0, %ebx
+    int     $SYSCALL
+
+_show_usage:
+    # esce in caso di errore con codice 1
+    # sys_write(stdout, usage, USAGE_LENGTH);
+    movl    $SYS_WRITE, %eax
+    movl    $STDOUT, %ebx
+    movl    $usage, %ecx
+    movl    $USAGE_LENGTH, %edx
+    int     $SYSCALL
+
+    # sys_exit(1);
+    movl    $SYS_EXIT, %eax
+    movl    $1, %ebx
+    int     $SYSCALL