Recherche dans un fichier (grep)

Version imprimable

Bonjour,

Je voudrais creer un programme similaire a la commande "grep" de unix que je voudrais appeller "newgrep" ou :

Code:

newgrep trucachercher fichier.c

Imprimera tout les resultats dans la console et comptera les lignes trouvees.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 # include <stdio.h> int main ( int argc, char * argv [ ] ) { FILE * fp; char buffer [ 81 ]; if(argc != 3){ printf("Usage : newgrep searchstr searchfile [-o outputfile]\n"); } else { if ((fp = fopen(argv[2],"r")) == NULL) { printf ("\n Cannot open file specified.\n"); exit(1); } while ( fgets ( buffer, 81, fp ) ) { fputs ( buffer, stdout ); } } return 0; }
Pour l'instant le code ne fait que lire un fichier et imprimer le resultat dans la console. Je ne sais pas comment modifier :
Code:

1 2 3 4 while ( fgets ( buffer, 81, fp ) ) { fputs ( buffer, stdout ); }
De telle maniere a ce que le program interprete argv[1](trucachercher) en tant que chaine de caractere a chercher dans le fichier specifiee...

23/09/2007, 00h12
Gruik

Salut,

Premierement faut savoir ce que tu veux faire exactement, car grep ne permet pas de chercher une chaine dans un fichier, ça permet de faire des recherches de chaines définies par des expressions regulieres (plusieurs syntaxes sont d'ailleurs proposées) dans un ou plusieurs fichiers ou sur l'entrée standard.
C'est comme printf, ça sert pas à afficher une chaine, ça sert à afficher quelquechose suivant une chaine de format.

Admettons que tu veuilles afficher les lignes où apparait exactement la chaine recherchée, tu pourrais utiliser strstr pour rechercher une chaine dans un autre.
Un simple fgets ne suffira pas car tu pourras pas faire une recherche fiable sur des fichiers contenant des lignes de plus de sizeof buffer caractères. Un moyen serait d'utiliser realloc pour allouer et reallouer le buffer d'entrée (çe ne serait plus un tableau de char et il faudrait maintenir une variable contenant la taille de ce buffer).

Citation:

Envoyé par Gruik

Salut,

Premierement faut savoir ce que tu veux faire exactement, car grep ne permet pas de chercher une chaine dans un fichier, ça permet de faire des recherches de chaines définies par des expressions regulieres (plusieurs syntaxes sont d'ailleurs proposées) dans un ou plusieurs fichiers ou sur l'entrée standard.
C'est comme printf, ça sert pas à afficher une chaine, ça sert à afficher quelquechose suivant une chaine de format.

Admettons que tu veuilles afficher les lignes où apparait exactement la chaine recherchée, tu pourrais utiliser strstr pour rechercher une chaine dans un autre.
Un simple fgets ne suffira pas car tu pourras pas faire une recherche fiable sur des fichiers contenant des lignes de plus de sizeof buffer caractères. Un moyen serait d'utiliser realloc pour allouer et reallouer le buffer d'entrée (çe ne serait plus un tableau de char et il faudrait maintenir une variable contenant la taille de ce buffer).

C'est ce que je veux faire, mais pas aussi sophistiquee que "grep" d'Unix.
A ce que j'ai compris:
Il faut donner une variable au buffer de facon a ce qu'on lui realloue une memoire suffisante apres chaque recherche.
Code:

1 2 3 4 5 6 7 char buffer[search]; buffer = malloc(81); strcpy(buffer, search); buffer = realloc(buffer, sizeof(search));
La lecture se fera donc :
Code:

1 2 3 4 5 6 while ( fgets ( buffer, 81, fp ) ) { strstr( buffer, argv[1]); // trouver argv[1] dans buffer (ce qui a ete lu) fputs ( buffer, stdout ); // imprimer le nouveau contenu de buffer ?? }
Ou est l'erreur ? 8O

Citation:
Envoyé par virtuadrack
Code:

1 2 3 4 5 6 while ( fgets ( buffer, 81, fp ) ) { strstr( buffer, argv[1]); // trouver argv[1] dans buffer (ce qui a ete lu) fputs ( buffer, stdout ); // imprimer le nouveau contenu de buffer ?? }
Ou est l'erreur ?
Il faut lire la doc de strstr() et s'intéresser à son retour...

Ton mécanisme de réallocation est plus que douteux... Le tableau ne doit jamais déborder.

23/09/2007, 19h30
virtuadrack
Ajouter un if a regle le probleme. En principe avec ca :
Code:

1 2 3 4 5 6 while ( fgets ( buffer, sizeof(buffer), fp ) ) { if(strstr( buffer, argv[1])){ fputs ( buffer, stdout );} }
Le resultat est bon, toute les lignes recherche sont affichees. Mais est ce que c'est efficace ? (efficient)

Comment faire pour afficher les resultats en majuscules ? J'ai essaye avec toupper() de cette maniere:

Code:

fputs(toupper(buffer), stdout);

Mais ca na pas l'air de plaire au compiler.

Autre question, si je veux compter les lignes de resutats et de chaine caracteres trouvees, je procede comment ?

Merci

PS: pour la reallocation, j'ai prefere donner a 'buffer' 250, les lignes ne depasseront pas cette taille.
23/09/2007, 19h41
souviron34

:evilred:LA PROGRAMMATION N'EST PAS DE METTRE DES INSTRUCTIONS AU HASARD ET D'ESPERER QUE CA MARCHE !!!!

Lis la doc de toupper avant de demander de l'aide.... Et tu verras que tu fais n'importe quoi..

D'autre part, ton test de fgets n'est pa la meilleur manière d'écrire, mais plutôt

Code:

while ( fgets(...) != NULL )
23/09/2007, 19h48
Emmanuel Delahaye
Citation:
Envoyé par virtuadrack

Ajouter un if a regle le probleme. En principe avec ca :

Code:

1 2 3 4 5 6 while ( fgets ( buffer, sizeof(buffer), fp ) ) { if(strstr( buffer, argv[1])){ fputs ( buffer, stdout );} }

Le resultat est bon, toute les lignes recherche sont affichees. Mais est ce que c'est efficace ? (efficient)
C'est pas très efficace. Un automate traitant les caractères un par un devrait êre meilleur, mais c'est un peu plus complexe. Il y a aussi le problèmes des mots 'coupés' (sur 2 lignes...)

Citation:

Comment faire pour afficher les resultats en majuscules ? J'ai essaye avec toupper() de cette maniere:

Code:

fputs(toupper(buffer), stdout);

Mais ca na pas l'air de plaire au compiler.

toupper(), comme l'indique la doc que tu aurais du lire au lieu de faire n'importe quoi, ne traite qu'un caractère, pas une chaine. Je te laisse écrire la fonction de traitement de chaine.

Citation:

Autre question, si je veux compter les lignes de resutats et de chaine caracteres trouvees, je procede comment ?

Tu définis un compteur initialisé à 0, puis tu l'incrémentes de 1 à chaque fois que la condition correspondante est vérifiée. (C'était trop dur ! Je me suis pété 3 neurones en cherchant ça !)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
# include <stdio.h>
# include <ctype.h>
# include <string.h>
 
void uppercase(char *str) {   
        char *p;
        if (str == NULL) {
                return;
        }
        p = str;
        while (*p != '\0') {
                *p = toupper((unsigned char) (*p));
                p++;
        }
}
 
int main ( int argc, char * argv [ ] )
{
  FILE * fp;
  char buffer [ 250 ], *p;
  int r = 0;
 
  if (argv[1] = "-i"){
 
         if(argc != 4)
         {
                printf("Usage : newgrep [-i] searchstr searchfile [-o targetfile]\n");
         }
 
        else {
                if ((fp = fopen(argv[3],"r")) == NULL) 
                {
                        printf ("\n Cannot open file specified.\n");
                        exit(1);
                }
 
        while ( 
                fgets ( buffer, sizeof(buffer), fp ) != NULL ) 
                {
                        p = strstr ( buffer, argv[2]);
                        if(p)
                        {
                                uppercase(buffer);
                                fputs ( buffer, stdout );
                                r++;
                        }
                }
 
        printf("\n Found %s in %i Lines found \n", argv[2], r);
    }
 }
  return 0;
}

J'aimerais ajouter l'option [-i] lors de la saisie de la ligne de commande pour pouvoir rechercher une chaine de caractere et l'afficher qu'elle soit en majuscule ou en minuscule. J'ai commence par

Code:

if (argv[1] = "-i"){...} //si le premier argument est "-i" executer le code

mais je ne sais pas si c'est la bonne procedure pour programmer avec les options. Vos conseils sont les bienvenus.

Pour les compteurs, j'ai mis un compteur pour compter les lignes trouvees, mais j'ai pas reussi a mettre un compteur qui compte les chaine de caracteres dans toutes les lignes. Quelle fonction de string.h faut-il utiliser ?

Merci.

Citation:

Envoyé par virtuadrack

Code:

if (argv[1] = "-i"){...} //si le premier argument est "-i" executer le code

mais je ne sais pas si c'est la bonne procedure pour programmer avec les options.

Traditionnellement, les options utilisent un format et des procédures décrites par 'getopt()' qui est une fonction POSIX.1 donc très portable.

Ton code est horriblement mal présenté. Je propose le très classique :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
 
# include <stdio.h>
# include <ctype.h>
# include <string.h>
 
void uppercase (char *str)
{
   char *p;
   if (str == NULL)
   {
      return;
   }
   p = str;
   while (*p != '\0')
   {
      *p = toupper ((unsigned char) (*p));
      p++;
   }
}
 
int main (int argc, char *argv[])
{
   FILE *fp;
   char buffer[250], *p;
   int r = 0;
 
   if (argv[1] = "-i")
   {
      if (argc != 4)
      {
         printf
            ("Usage : newgrep [-i] searchstr searchfile [-o targetfile]\n");
      }
      else
      {
         if ((fp = fopen (argv[3], "r")) == NULL)
         {
            printf ("\n Cannot open file specified.\n");
            exit (1);
         }
         while (fgets (buffer, sizeof (buffer), fp) != NULL)
         {
            p = strstr (buffer, argv[2]);
            if (p)
            {
               uppercase (buffer);
               fputs (buffer, stdout);
               r++;
            }
         }
         printf ("\n Found %s in %i Lines found \n", argv[2], r);
      }
   }
   return 0;
}

Il y a des erreurs :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
Project   : Forums
Compiler  : GNU GCC Compiler (called directly)
Directory : C:\dev\forums\
--------------------------------------------------------------------------------
Switching to target: default
Compiling: main.c
main.c: In function `main':
main.c:26: warning: assignment discards qualifiers from pointer target type
main.c:26: warning: suggest parentheses around assignment used as truth value
main.c:38: warning: implicit declaration of function `exit'
Linking console executable: console.exe
Process terminated with status 0 (0 minutes, 1 seconds)
0 errors, 3 warnings

qu'un compilateur bien réglé sait détecter.

toupper() attend un unsigned int et non un unsigned char (qui sera promu en int).
La comparaison de chaines se fait avec strcmp()
Il manque le prototype de exit().
Le codage de uppercase() est inutilement complexe. Eviter d'avoir plus d'une sorties (return) par fonction. C'est en général inutile voire dangereux (mauvaise gestion des ressources).

Code:

1
2
3
4
5
6
7
8
9
10
11
12
 
void uppercase (char *str)
{
   if (str != NULL)
   {
      char *p;
      for (p = str; *p != '\0'; p++)
      {
         *p = toupper ((unsigned) (*p));
      }
   }
}

25/09/2007, 09h02
Thierry Chappuis
Citation:

Envoyé par virtuadrack

Code:

if (argv[1] = "-i"){...} //si le premier argument est "-i" executer le code

Je rappelle au passage que = est l'opérateur d'affectation, l'opérateur d'égalité étant ==. Par ailleurs, le test de l'égalité de deux chaînes de caractères n'utilise pas l'opérateur == mais la fonction strcmp() déclarée dans le fichier d'en-tête standard string.h:
Code:

1 2 3 4 5 6 7 8 #include <string.h> /* ... */ if (strcmp(argv[1], "-i") == 0) { /* ... */ }
Thierry

Merci pour vos reponse.

J'ai une autre question. Je suis arrive a compter les lignes ou apparait la chaine de caractere, mais je ne n'arrive pas a compter combien la chaine de caractereres apparaissent en tout.

voici le code

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
#include <stdio.h>
#include <ctype.h>
#include <string.h>
 
void lowercase(char *str)
{
        if(str != NULL)
        {
                char        *p;
                for(p = str; *p != '\0'; p++)
                {
                        *p = tolower((unsigned) (*p));
                }
        }
}
 
 
void uppercase(char *str)
{
        if(str != NULL)
        {
                char        *p;
                for(p = str; *p != '\0'; p++)
                {
                        *p = toupper((unsigned) (*p));
                }
        }
}
 
int isLow(char const *str)
{
    int rv = 0;
 
    if (str != NULL)
    {
        char const *p;
 
        for (p = str; *p != '\0' && islower((unsigned char) *p); p++)
        {
        }
 
        rv = (*p == '\0');
    }
 
    return rv;
}
 
int isUpp(char const *str)
{
    int rv = 0;
 
    if (str != NULL)
    {
        char const *p;
 
        for (p = str; *p != '\0' && isupper((unsigned char) *p); p++)
        {
        }
 
        rv = (*p == '\0');
    }
 
    return rv;
}
 
int main(int argc, char *argv[])
{
        FILE *fp;
        char buffer[250], *p, fname[15], searchstr[15] ;
        int r = 0;
        strcpy(fname, argv[argc - 1]);
        strcpy(searchstr, argv[argc - 2]);
 
        if(strcmp(argv[1], "-i") != 0)
        {
                if(argc != 3)
                {
                        printf("Usage : newgrep [-i] searchstr searchfile [-o targetfile]\n");
                }
                else
                {
                        if((fp = fopen(fname, "r")) == NULL)
                        {
                                printf("\n Cannot open file specified.\n");
                                exit(1);
                        }
 
                        while(fgets(buffer, sizeof(buffer), fp) != NULL)
                        {
                                p = strstr(buffer, searchstr);
 
                                if(p)
                                {
                                        uppercase(buffer);
                                        fputs(buffer, stdout);
                                        r++;
                                }
                        }
 
                        printf("\n Found %s in %i lines.\n", searchstr, r);
                }
        }
 
        if(strcmp(argv[1], "-i") == 0)
        {
                if(argc != 4)
                {
                        printf("Usage : newgrep [-i] searchstr searchfile [-o targetfile]\n");
                }
                else
                {
                        if((fp = fopen(fname, "r")) == NULL)
                        {
                                printf("\n Cannot open file specified.\n");
                                exit(1);
                        }
                        if(isUpp(searchstr)) lowercase(searchstr);
 
                        while(fgets(buffer, sizeof(buffer), fp) != NULL)
                        {
                                p = strstr(buffer, searchstr);
                                if(p)
                                {
                                        uppercase(buffer);
                                        fputs(buffer, stdout);
                                        r++;
                                }
                        }
 
                        printf("\n Found %s in %i lines 00 times.\n", searchstr, r);
                }
        }
 
        return 0;
}

ligne de commande > newgrep rent fichier.dat

de facon a ce que l'ouput soit Found rent in 13 lines 27 times.

J'ai pense a strlen() mais je ne sais pas comment l'utiliser.

Merci

27/09/2007, 06h42
virtuadrack

Pas d'idee ? :roll:
27/09/2007, 12h34
Emmanuel Delahaye

Citation:

Envoyé par virtuadrack

<...>mais je ne n'arrive pas a compter combien la chaine de caractereres apparaissent en tout.

Cette phrase est incompréhensible. C'est sans doute pour ça que tu n'as pas de réponse...

Je me suis mal explique en effet.

Supposons que j'ai un fichier "calendar.dat" qui contient les donnes suivante:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
         Jan                    Feb                    Mar
 S  M Tu  W Th  F  S    S  M Tu  W Th  F  S    S  M Tu  W Th  F  S
    1  2  3  4  5  6                1  2  3                1  2  3
 7  8  9 10 11 12 13    4  5  6  7  8  9 10    4  5  6  7  8  9 10
14 15 16 17 18 19 20   11 12 13 14 15 16 17   11 12 13 14 15 16 17
21 22 23 24 25 26 27   18 19 20 21 22 23 24   18 19 20 21 22 23 24
28 29 30 31            25 26 27 28            25 26 27 28 29 30 31
 
         Jan                    Feb                    Mar
 S  M Tu  W Th  F  S    S  M Tu  W Th  F  S    S  M Tu  W Th  F  S
    1  2  3  4  5  6                1  2  3                1  2  3
 7  8  9 10 11 12 13    4  5  6  7  8  9 10    4  5  6  7  8  9 10
14 15 16 17 18 19 20   11 12 13 14 15 16 17   11 12 13 14 15 16 17
21 22 23 24 25 26 27   18 19 20 21 22 23 24   18 19 20 21 22 23 24
28 29 30 31            25 26 27 28            25 26 27 28 29 30 31

Le code dans mon precedent post, arrive a chercher n'importe quel chaine de caractere dans n'importe quel fichier. Si la ligne de commande est entree de cette maniere : newgrep Th calendar.dat

Le programme me donne:

Code:

1
2
3
4
5
 
S  M Tu  W Th  F  S    S  M Tu  W Th  F  S    S  M Tu  W Th  F  S
S  M Tu  W Th  F  S    S  M Tu  W Th  F  S    S  M Tu  W Th  F  S
 
Found Th in 2 lines 00 times.

Je voudrais que la chaine de caractere (Th dans ce cas) soit comptée dans la meme ligne et dans toutes les ligne ou elle apparait, de facon a ce que le resultat soit :

Code:

1
2
3
4
 S  M Tu  W Th  F  S    S  M Tu  W Th  F  S    S  M Tu  W Th  F  S
 S  M Tu  W Th  F  S    S  M Tu  W Th  F  S    S  M Tu  W Th  F  S
 
Found Th in 2 lines 6 times.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
int nb=0 ;
char *p0=NULL ;
.....
                        while(fgets(buffer, sizeof(buffer), fp) != NULL)
                        {
                                p = buffer ;
                                while ( (p0 = strstr(p, searchstr)) != NULL )
                                {
                                    nb++ ;
                                    p = p0 + strlen(searchstr);
                                }
 
                               if ( p != buffer )
                                 {
                                     uppercase(buffer);
                                     fputs(buffer, stdout);
                                     r++;
                                 }
                       }

:mrgreen: