Newsgroup: it.comp.lang.c
Titolo: problemino relativo alla gestione dei file

Allora, il programma seguente funziona, ma non fa quello che dovrebbe fare.
La mia richiesta non di sapere perchè non funziona o come migliorarlo (è
infatti una versione per niente ottimizzata del programma che sarà alla
fine) ma solo come ovviare a due problemi incontrati nella gestione di due
funzioni: _findfirst e _findnext.
Il programma per ora deve trovare tutti i file .txt contenuti nella
directory corrente e cambiarne il nome, lasciando l'estensione, solo che
cambiato il nome del primo file, va avanti e poi ne cambia nuovamente il
nome a casusa di _findnext...
Credo che le due funzioni incriminate si creino una lista di puntatori ai
vari file e quindi operino su tale lista, ma non so se tale lista viene
fatta una sola volta o se viene aggiornata ad ogni richiamo della
funzione...
L'altro problema è relativo all'estensione dei file a cui cambiare il nome:
io vorrei specificarla come parametro di ingresso del programma, ma non so
come farla "vedere" al primo parametro delle funzioni.
Secondo voi c'è una funzione più adatta ad individuare tutti i file
contenuti in una directory?
Dimenticavo: il sorgente contiene sicuramente almeno una funzione non
standard, che non saprei come sostituire con una standard... itoa()
#include <stdio.h>
#include <io.h>
#include <time.h>
#include <string.h>
const char DOT[5]={'.','t','x','t'};
void createname(int p, char *b, char *c);
void main (int argc, char *argv[]) {
 struct _finddata_t nomefile;
    long hFile;
 char prefix[6]={'p','r','o','v','a'};
 char newname[13];
 char exension[4];
 short int counter = 0;
 /* if (argc == 1) printf("\nInserire il prefisso (max 5 caratteri) da
applicare ai file\n");
 else {
    /* Find first file in current directory */
  if( (hFile = _findfirst( "*.txt", &nomefile )) == -1L )    /* cos'è 1L? */
   printf( "No files in current directory!\n" );
  else
  {
   createname( counter++, prefix, newname );
            printf( " %-12s %9ld is changing to %-12s\n", 
nomefile.name
,
nomefile.size, newname );
   rename( 
nomefile.name
, newname );
            /* Find the rest of the .txt files */
            while( _findnext( hFile, &nomefile ) == 0 )
            {
    createname( counter++, prefix, newname );
                printf( " %-12s %9ld is changing to %-12s\n", 
nomefile.name
,
nomefile.size, newname );
    rename( 
nomefile.name
, newname );
            }
  _findclose( hFile );
  /*} /* secondo else */
 } /* primo else */
}
void createname(int p, char *b, char *c) {
 char postfix[4];
 char *a, *dot;
 dot = &DOT;
 a = (char *)itoa(p, postfix, 10);
 c = strcpy(c, b);
 c = strcat(c, a);
 c = strcat(c, dot);
}
San Vegeta from Hell

Scusami se rispondo prima di aver esaminato a fondo il sorgente che accludi,
ma mi è parso di capire che tu cambi "al volo" il nome.
Se questo è vero, sappi che (secondo me) stai commettendo un errore enorme.
Nessuno, infatti ti garantisce che, dopo aver cambiato il nome al primo
file, poi la successiva chiamata a findnext ti restituisca il secondo file
piuttosto che uno qualsiasi, magari lo stesso di prima o magari nessuno!
La cosa migliore, secondo me, sarebbe quella di crearsi prima una lista di
files presenti nella directory e poi cambiarli tutti in fila.
Potrei sbagliarmi, ma il fatto che il tuo programma non funzioni, potrebbe
essere una prova.
Ciao
--
Alessandro Monti

Allora, il programma seguente funziona, ma non fa quello che dovrebbe fare.
Avrei voluto spedirti un programmino completo, ma sto reinstallando il
DJGPP per l'ennesima volta, in seguito all'installazione di Linux.
Comunque, ti conviene creare una lista dei nomi dei file e poi
rinominarli in un secondo momento.
--
Andrea Laforgia
andrea_...@bigfoot.com

 wrote in message
YGg34.6121$3L.6...@typhoon.libero.it...


 wrote in message
38656c27...@diesel.cu.mi.it...


 Se puoi aiutarmi...
Il programma completo non ho tempo, ma magari qualche accenno...
In simil-C, perň, magari mischio qualcosa del C++ per sbaglio...
struct lista_nomi{
    char nome[256];    /* dovrebbe bastare, ma l'alternativa č usare
l'allocazione dinamica */
    struct lista_nomi *successivo;
}capo_lista=NULL;
void inserisci_nome (const char *nome){
struct lista_nomi *nuovo;
nuovo = malloc (sizeof (struct lista_nomi));    /* Decidi se controllare
l'esito con un if (nuovo) */
strcpy (nuovo->nome, nome);
nuovo->successivo = capo_lista;
capo_lista = nuovo;
}
void estrai_nome (char **nome){
struct lista_nomi *delenda;
if (capo_lista){
    strcpy (*nome, capo_lista->nome);
    delenda = capolista;
    capolista = capolista->successivo;
    free (delenda);
}else
    *nome = NULL;
}
int main (){    /* abbozzato */
char nome[256];
...
for (/*ciclo che scandisce la directory){
    inserisci_nome (nome);
}
while (estrai_nome(&nome)){    // va bene cosě
    ... // fa delle elaborazioni sul nome, creando cosě nome_nuovo
    rename (nome, nome_nuovo);
}
}

 rinominarli in un secondo momento.
Comunque, utilizzando le findfirst()/findnext() del mio vecchio TurboC++
1.01 il problema non si manifesta e si possono tranquillamente
rinominare i files man mano che si scorre la directory.
EMG

una lista di file con una certa estensione.
Il codice seguente e' per DJGPP, dovresti modificarlo leggermente :
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <dir.h>
#define ALLFILES        0x3F
#define MASK            "*.c"
main()
{
    int errore, i ;
    long numero = 0L ;
    char **lista ;
    struct ffblk FileInfo ;
    /*-------------------------------------------*/
    /* il ciclo seguente conta il numero di file */
    /*-------------------------------------------*/
    errore = findfirst( MASK, &FileInfo, ALLFILES ) ;
    while ( ! errore )
    {
          numero++ ;
          errore = findnext( &FileInfo ) ;
    }
    lista = malloc( numero * sizeof( char * ) ) ;
    /*---------------------------------------------*/
    /* il ciclo seguente memorizza i nomi dei file */
    /*---------------------------------------------*/
    i = 0 ;
    errore = findfirst( MASK, &FileInfo, ALLFILES ) ;
    while ( ! errore )
    {
          lista[i] = malloc( strlen( FileInfo.ff_name ) + 1 ) ;
          strcpy( lista[i], FileInfo.ff_name ) ;
          i++ ;
          errore = findnext( &FileInfo ) ;
    }
    for ( i = 0 ; i < numero ; i++ )
    {
        puts( lista[i] ) ;
    }
    return 0 ;
}
--
Andrea Laforgia
andrea_...@bigfoot.com

rinominare i files man mano che si scorre la directory.
Infatti, pero' in questo caso, non essendo un comportamento portabile,
conviene andare sul sicuro...
--
Andrea Laforgia
andrea_...@bigfoot.com

 }
Ti ringrazio per l'aiuto, ma queste cose le so fare, ciň di cui non sono
capace č scandire opportunamente la directory per avere i nomi dei file :-)
grazie mille per la considerazione :-)
San Vegeta

 capace č scandire opportunamente la directory per avere i nomi dei file
:-)
Ma come? Pensavo che nell'help delle funzioni findfirst e findnext ci fosse
un esempio d'uso.
Comunque credo l'esempio di Laforgia vada bene, provalo.
Ah, forse ho visto delle funzioni non-standard che cominciano con un
underscore. Inoltre passi hFile a findnext, che credo non sappia che
farsene. Le funzioni che conoscevano funzionavano cosě:
- chiami Findfirst, controlli che ci sia almeno 1 file, e fai tutte le
operazioni che ti servono
- con un while, continui a chiamare findnext CON GLI STESSI CRITERI DI
RICERCA che hai usato per findfirst e li elabori finchč hai esaurito i files
nella directory.
- eventualmente cambi directory e ricominci
Nota che il tutto potrebbe essere eseguito in un ciclo for unico, ma
probabilmente non č il caso di complicare le cose...
--
Alessandro Monti