Newsgroup: it.comp.lang.c
Titolo: FiNd

Ciao! 
avrei scritto il codice di una versione ristretta di "find"...
ma non funge, non riesco a trovare l'errore, mi date una mano? grazie!
ecco il codice...:
#include<stdio.h>
#define MAX 1000
int getline(FILE *fp, char s[]);
int strindex(char t[], char s[]);
main(int argc, char *argv[])
{
     FILE *fp;
     char riga[MAX];
     char found;
     if(argc==1)
       {
         printf("uso: find [FILE] [PATTERN]...\n");
         return 0;
       }
     if((fp=fopen(*++argv, "r"))==NULL)
       {
         printf("\nfind: impossibile aprire il file d'origine\n");
         return 0;
       }
     while(getline(fp, riga)>0)
       if(strindex(riga, *++argv)>=(int) 0)
         {
           printf("%s", riga);
           found++;
         }
          fclose(fp);
     return found;
}
int getline(FILE *fp, char s[])
{
  int  i, c;
  while((c=fgetc(fp))!=EOF && c!='\n')
   s[i++]=c;
 
  if(c=='\n')
    s[i++]=c;
 
  s[i]='\0';
  return i;
}
int strindex(char t[], char s[])
{
  int k, i, j;
  for(i=0; t[i]!='\0'; i++)
    {
      for(j=i, k=0; s[k]!='\0' && t[j]==s[k]; j++, k++)
        ;
      if(k>0 && s[k]=='\0')
        return i;
    }
  return -1;
}

ehm... diciamo scopiazzato e "aggiustato".. piuttosto che "scritto".. 
ihihihihi

    s[i++]=c;
i non inizializzato (e sullo stack, e quindi sicuramente non 0)
e penso che proprio quest ti dovrebbe dare qualche mal di testa!

fai delle robe strane con argv... ma puo' andare...
Non capisco perche' "strane".
--
Andrea Laforgia - walkietalkie(at)
libero.it
http://www.geocities.com/AndreaLaforgia

 analizzata da sinsitra a destra?
Mi pare  che lo standard dica  proprio cosi`. Non ho il  K&R sotto mano,
ma, se non  ricordo male, la valutazione avviene da  sinistra a destra e
si  blocca  appena  e`  possibile  determinare  la  verita`  dell'intera
proposizione.
ciao
Kronos
-- 
Home: 
http://kronoz.cjb.net
Io mi ricordo sempre il compleanno della mia ragazza:
cade il giorno dopo di quando lei me lo ricorda

Kronos
oh si viene analizzata da sx a dx, ma in questo caso con la presenza
dell'&& è opportuno valutare entrambe le espressioni.
--
Rhymes
--------------------------
rhy...@myself.com
http://www.foxhound-games.it
http://embyte.mascanc.net
--------------------------
Linux User #219707

 dell'&& e` opportuno valutare entrambe le espressioni.
Viene prima valutato (c != EOF); se e solo se l'espressione risulta vera
prosegue  il controllo. Cmq,  penso che  il dubbio  di Jurgen  fosse che
potesse  essere  eseguito il  controllo  (c  !=  '\n')  *prima* di  c  =
fgetc(fp).
ciao
Kronos
-- 
Home: 
http://kronoz.cjb.net
Windows /win'dohz/ n. : thirty-two  bit extension and graphical shell to
a sixteen  bit patch to an  eight bit operating system  originally coded
for a  four bit microprocessor  which was  written by a  two-bit company
that can't stand a bit of competition.

fgetc(fp).
No, non puo'.
Gli operatori , (virgola), && e ?: introducono un ulteriore
"sequence point" nella valutazione delle espressioni e
quindi fanno in modo che le espressioni vengano valutate
esattamente nell'ordine in cui sono scritte.


dell'&& è opportuno valutare entrambe le espressioni.
No, non e' vero.
Perche' l'espressione sia falsa, basta che la prima
espressione sia falsa.


espressione sia falsa.
mi sono espresso male.


 dell'&& è opportuno valutare entrambe le espressioni.
no. Appunto per il fatto che c'e' && la valutazione si blocca appena trova 
una espressione falsa. La stessa cosa avviene per ||: la valutazione si 
blocca appena trova una espressione vera.
ciao Anto
-- 
Antonio Cuni, 19 anni, studente
Brainbench C++ Master: 4.6, higher than 98% of all previous test takers.
C Language: 3.32, higher than 79% of all previous test takers.
Guida C/C++ di Programmazione.it: 
http://cpp.programmazione.it

ecco ho "aggiustato" un po' il codice..
non c'è nessun errore in compilazione, ma quando avvio il programma 
fornendo tutti e 3 gli argomenti a main(), non ricevo nessuna risposta..
continuo ad "inputtare" senza mai finire...
ps: ho da poco imparato a usare i puntatori... quindi ci sarà sicuramente 
qualche errore.. ma anche provando con la versione SENZA puntatori, il 
risultato è lo stesso.
#include<stdio.h>
#define MAXLINE 1000
int getline(char *s, FILE *fp);
int strindex(char *s, char *t);
main(int argc, char **argv)
{
        FILE  *fp;
        char line[MAXLINE];
        int found=0;
        if(argc<3)
        {
                printf("\nuso: find [FILE] [PATTERN]... \n");
                return 0;
        }
        if((fp=fopen(argv[1[]], "r"))==NULL)
        {
                printf("\nerrore: impossibile aprire il file specificato\n");
                return 0;
        }
        while (getline(line, fp)>0)
                if (strindex(line, argv[2][]) >=0)
                {       
                        printf("%s", line);
                        found++;
                }
        fclose(fp);
        return found;
}
int getline(char *s, FILE *fp)
{
        int c, n;
        for (n=0; (c=fgetc(fp))!=EOF && c!='\n'; n++)
                *s++=c;
        if(c=='\n')
                *s++='\n';
        *s='\0';
        return n+2;
}
int strindex(char *s, char *t)
{
        int i, j, k;
        for(; *s!='\0'; s++)
        {
                        for(j=i, k=0; *(t+k)!='\0' && *(s+j)==*(t+k); j++, k++);
 
                        if(k > 0 && *t=='\0')
                                        return i;
        }
        return -1;
}
 

int strindex(char *s, char *t)
...
usa strstr() per individuare se una stringa e' contenuta
nell'altra


[.....]
ti ringrazio, con le funzioni standard il programma funge, ma scusa se 
insisto.. potresti dirmi qual'era l'errore nelle funzioni scritte 
"artigianalmente"? grazie ancora
ciao

"artigianalmente"? grazie ancora
Non ho controllato se vi siano o meno errori, ritengo piu'
veloce e affidabile, pero', sfruttare le funzioni standard.
