dagli studi fatti dal mi oprof di programmazione, dagli studi fatti personalmente sulla rete, dopo non essere stato ammesso ad un esame ho riscritto da zero il programma ... risultato ??
peggio di prima ... secondo il professore ...
ora vorrei chiedervi, gentilmente, di testare questo programma su una piattaforma Linux perche' su Windows va perfetto ... oltretutto vorrei chiedere ad i piu' esperti una valutazione reale sul codice da me scritto, grazie
exam.c
codice:
/********************************************************************************/
/* CPRO - Computer Programming */
/* ____________________________________________________________________________ */
/* programma per creare una copia di un file di testo su un altro file con */
/* l' aggiunta di un header e con le linee ordinate in ordine crescente */
/* ---------------------------------------------------------------------------- */
/* @autore: Andrea Giammarchi */
/* @data: 17/02/2005 */
/* @ambiente: Windows 2000 SP4 */
/* @programma: Dev C++ V 4.9.9.1 */
/* @compilatore: GCC 3.3.1 */
/********************************************************************************/
/*****************************/
/* inclusione delle librerie */
/*****************************/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
/*****************************************/
/* definizione delle costanti simboliche */
/*****************************************/
#define OUTPUT_HEADER_PREFIX_SUFFIX "**********" /* informazioni suffisso e prefisso
per l' header del nuovo file */
#define AUTO_SUFFIX ".lis" /* suffisso predefinito del file creato
( usato qualora l'utente non indichi
il nome del nuovo file )*/
/*************************************************************/
/* descrizione del tipo di dato boolean_t : */
/* Questo dato indica una espressione di tipo booleana */
/* utilizzata nel programma per verificare se calloc */
/* e' stato utilizzato al fine di liberare la memoria */
/* occupata dalla funzione calloc */
/*************************************************************/
typedef enum {
falso,
vero
} boolean_t;
/************************************************************/
/* descrizione della funzione getFileOnExists : */
/* funzione ricorsiva per verificare il file scritto */
/* o indicato dall' utente. */
/* Se il file non e' presente si richiama dopo aver */
/* mandato un messaggio di informazione file mancante */
/* per riverificare se il nuovo file, digitato */
/* dall' utente, e' esistente cosi' da ritornare il */
/* puntatore al file aperto in sola lettura */
/************************************************************/
FILE *getFileOnExists(
char *input_source_file /* input, file da leggere */
);
/*************************************/
/* definizione della funzione main */
/*************************************/
int main(int argv, char **argc)
{
/* dichiarazione delle variabili locali alla funzione */
FILE *source_file, /* input: file sorgente */
*destination_file; /* output: file di destinazione */
char *input_file, /* input: nome file da leggere */
*output_file; /* input: nome file da scrivere */
unsigned int a; /* i/o: utilizzata per cicli e controlli */
boolean_t used_calloc = falso; /* i/o: specifica se il programma ha usato calloc */
/* output: informazioni a video sul programma */
printf("\n#####################################################");
printf("\n# CRPO - Computer Programming #");
printf("\n# _________________________________________________ #");
printf("\n# Questo programma crea una copia di un file di #");
printf("\n# testo aggiungendo un prefisso e, per ogni linea #");
printf("\n# del nuovo file, il corrispettivo numero di riga #");
printf("\n# seguito da uno spazio. #");
printf("\n# ------------------------------------------------- #");
printf("\n# Autore: Andrea Giammarchi #");
printf("\n# Versione: 2.0 #");
printf("\n# Data: 17/02/2005 #");
printf("\n# ------------------------------------------------- #");
printf("\n#####################################################\n");
/* controllo: verifica i parametri passati alla funzione main. */
/* Se non viene passato alcun parametro invia un help. */
/* Se viene passato un solo parametro, crea in modo */
/* dinamico il nuovo nome file da utilizzare. */
/* Se vengono passati 2 parametri utilizza il secondo */
/* come nome per il file che verra' creato. */
switch(argv)
{
case 2:
case 3:
/* azione: assegna argc[1] alla variabile input_file */
input_file = argc[1];
/* controllo: verifica esistenza file di input e lo assegna al puntatore di tipo FILE */
source_file = getFileOnExists( input_file );
/* controllo: verifica se il secondo parametro di input sia stato scritto */
if(argc[2] != NULL)
{
/* azione: assegna tale parametro come nome file da creare */
output_file = argc[2];
}
else
{
/* azione: creo 2 variabili di tipo int utili per non */
/* richiamare strlen al prossimo ciclo for */
int len_input_file = strlen(input_file); /* lunghezza stringa input */
int len_AUTO_SUFFIX = strlen(AUTO_SUFFIX); /* lunghezza stringa suffisso */
/* azione: richiede blocchi memoria per creare l' array stringa */
/* con caratteri pari alla somma della lunghezza del */
/* nome del file da leggere piu' la lunghezza del */
/* suffisso predefinito piu' 1 carattere per terminare */
output_file = (char *) calloc(
(len_input_file + len_AUTO_SUFFIX + 1),
sizeof(char)
);
/* azione: copia carattere per carattere il nome del file da */
/* leggere per poi accodare il suffisso */
for(a = 0; a < (len_input_file + len_AUTO_SUFFIX); a++)
{
if(a < len_input_file)
{
output_file[a] = input_file[a];
}
else
{
output_file[a] = AUTO_SUFFIX[(a-len_input_file)];
}
}
/* azione: aggiunge la terminazione della stringa */
output_file[a] = '\0';
used_calloc = vero;
}
/* controllo: verifica se e' possibile aprire in modalita' scrittura */
/* il file di output */
if((destination_file = fopen(output_file, "w")))
{
/* azione: scrivo l' header all' inzio del nuovo file */
fprintf(
destination_file,
"%s%s%s",
OUTPUT_HEADER_PREFIX_SUFFIX,
output_file,
OUTPUT_HEADER_PREFIX_SUFFIX
);
/* azione: azzero a per usarla nel prossimo ciclo while */
/* creo una variabile di tipo char per leggere */
/* carattere dopo carattere il file di input */
a = 0; /* contatore linee per il nuovo output */
char content; /* lettore caratteri per l' output */
/* azione: ciclo il file di input fino alla fine */
while(!feof(source_file))
{
/* azione: assegno a content il prossimo carattere del file di input */
content = (char)fgetc(source_file);
/* controllo: verifica che content non sia la fine del file */
if(content != EOF)
{
/* controllo: verifica che content non sia un "a capo" */
if(content != '\n')
{
/* controllo: verifica che a sia a uguale a 0 */
if(a == 0) {
/* azione: scrive in output l' inizio della prima linea */
/* dopo aver incrementato a di 1 */
fprintf(destination_file,
"\n[%d] ",
++a
);
}
/* azione: scrive in output il carattere corrente */
fprintf(destination_file,
"%c",
content
);
}
else
{
/* azione: scrive in output il ritorno a capo ed aggiunge */
/* le modifiche richieste dal programma */
fprintf(destination_file,
"\n[%d] ",
++a
);
}
}
}
/* azione: flush e chiusura del file di output ( prioritario ) */
fflush(destination_file);
fclose(destination_file);
/* azione: chiusura del file di input */
fclose( source_file );
/* azione: stampa in output le informazioni di programma terminato */
printf("\nIl file \"%s\" e' stato creato con successo, arrivederci .", output_file);
/* controllo: verifica se calloc e' stato utilizzato */
if( used_calloc ) {
/* azione: libera la memoria occupata dal nome del file di output */
free(output_file);
}
}
else
{
/* azione: non e' possibile creare il nuovo file. */
/* stampo a video l' informazione ed esco dal programma */
printf("\nLa prego di controllare i permessi in scrittura della cartella\n");
printf("\nprima di riavviare questo programma, grazie .");
}
break;
default:
/* azione: stampa in output esempi di come utilizzare il programma */
printf("\nPer utilizzare questo programma");
printf("\ne' necessario specificare il nome del file.");
printf("\n\nEsempio:");
printf("\n\t exam nomefile.txt");
printf("\n\nE' possibile inoltre specificare il nome");
printf("\ndel file copia che il programma andra' a creare.");
printf("\n\nEsempio:");
printf("\n\t exam nomefile.txt nuovofile.txt");
printf("\n\nSe il nome del nuovo file non verra' specificato");
printf("\nquesto avra' lo stesso nome del file originale");
printf("\ncon l' aggiunta del suffisso \"%s\"", AUTO_SUFFIX);
break;
}
/* fine funzione main */
return (0);
}
/**********************************************/
/* definizione della funzione getFileOnExists */
/**********************************************/
FILE *getFileOnExists(
char *input_source_file /* input, file da leggere */
)
{
/* dichiarazione delle variabili locali alla funzione */
FILE *source_file; /* puntatore di tipo FILE che verra' restituito */
/* controllo: verifica che il file esista tentando di aprirlo in lettura */
if(!(source_file = fopen(input_source_file, "r")))
{
/* azione: manda in output un messaggio di errore file inesistente */
/* e richiede di scrivere nuovamente il file */
printf("\nImpossibile trovare il file\n\"%s\"", input_source_file);
printf("\nScriva il nome del file da copiare:\n");
/* azione: attende l' input dell' utente per assegnare il nomed del file */
scanf("%s", input_source_file);
/* azione: richiama se stessa sul puntatore da restituire ( ricorsiva ) */
source_file = getFileOnExists( input_source_file );
}
/* fine funzione getFileOnExists */
return source_file;
}
Makefile
codice:
exam : exam.o
gcc -ansi -Wall -O exam.o -o exam
exam.o : exam.c
gcc -ansi -Wall -O -c exam.c
pulisci:
rm -f exam.o