bonjours tout le monde.
Voici mon problème :
je fil un text à mon programme en paramètre, et il doit le filtrer en fonction d'un autre fichier stop.list (il indexe les mots du text : par exemple il inscrit qui: 1 2 3 5 9 ça veut dire que le mot qui se trouve à la ligne 1 2 3 5 9 etc).
En premier tout ce qui n'est pas en rouge n'est pas de moi mais de l'énoncé.
Donc le but c'est d'ouvrir le fichier stop.list qui contient (.,; '\n!\t<>\"/=), de récuper la chaine et d'enregistrer cette chaine dans split_chars.
Donc j'ai une fonction do_split_chars, tout en bas, elle capture bien la chaine, mais lorsque je fais la copie ça ne marche pas.
Au début j'avais fait la fonction du deuxième code, qui fonctionnait bien, sauf qu'elle découpe \n en deux caractères distinct au lieu de garder ça comme un saut de ligne et que je ne peux pas mettre de caractère espace dans la stoplist.

Bref c'est la honte parce que normalement ça doit être fait genre en 4 lignes propre et là chez moi c'est n'importe quoi et en plus ça ne marche pas.
Help
edit : ce qui est de moi apparait pas en rouge mais entre les balises rouge.


Code : Sélectionner tout - Visualiser dans une fenêtre à part
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
 
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define max_mots 128 // nombre maximum d'éléments dans la table mots
#define max_refs 16 // nombre maximum de références par mot
#define maximum 128
#define max_stop_list 60
typedef unsigned idx ;
typedef char * str ;
typedef enum {False, True} bool ;
 
char *mots [max_mots] ; // table de max_mots
idx mot_libre = 0 ; // où le premier est libre
idx refs [max_mots][max_refs] ;// matrice de max_mots par max_refs
idx ref_libre [max_mots] ;// table de max_mot
str split_chars;
<couleur nom="rouge">//str split_chars = "(.,; '\n!\t<>\"/=)"</couleur>
void indexe(str ligne, idx ref);
void usage(str message) {
    fprintf(stderr, "%s\n", message) ;
    exit(1) ;
}
                 // nouveau type
bool pareil(str x, str y) {
    return strcasecmp(x, y) ? False : True ;
}
int indice(str mot);
void ajoute_mot(idx x, str mot, idx ref);
void ajoute_ref(idx x, idx ref);
void dump(idx k);
void do_split_char(str fichier);
 
int main(int k, const str ldc []) {
    if (k < 2) usage("manque le nom du fichier...") ; // il manque l'argument : dégage
    char ligne [maximum] ;                            // espace pour une ligne
    FILE * flux = fopen(ldc [1], "r") ;               // ouvre le texte
    if (! flux) usage("fichier pas bon du tout...") ; // erreur à l'ouverture : dégage
    <couleur nom="rouge">do_split_char("stop.list"); </couleur>                      // initialisation de la stop liste
    idx x = 0 ;                                       // à partir de l'index 0
    while (fgets(ligne, maximum, flux))               // tant qu'il y a du texte
        indexe(ligne, ++x) ;                          // indexe la ligne suivante
    fclose(flux) ;                                    // ferme
    dump(mot_libre) ;                                 // affiche ? jusqu'au mot inutilisé
    return 0 ;
}
 
void indexe(str ligne, idx ref) {// étant donnée une ligne de texte
    <couleur nom="rouge">printf("%s\n", split_chars);</couleur>
    str mot = strtok(strdup(ligne), split_chars) ;    // attrape le 1er mot
    while (mot) {                                     // si ce n'est pas la chaîne vide
        int x = indice(mot) ;                         // regarde s'il n'y est pas déjà
        if (x < 0) ajoute_mot(mot_libre, mot, ref) ;  // et rajoute-le à la suite
        else ajoute_ref(x, ref) ;                     // sinon ajoute une nouvelle référence
        mot = strtok(NULL, split_chars);             // attrape le mot suivant
    }
}
int indice(str mot) {                                 // soit un mot
    idx x ;                                           // soit un index dans la table des mots
    for (x = 0; mots [x] ; ++x)                       // ce mot est-il déjà mémorisé ?
        if (pareil(mot, mots [x])) return x ;         // oui : retourne cet index
    return -1 ;                                       // non : retourne négatif
}
 
void ajoute_mot(idx x, str mot, idx ref) {            // un index, un mot, une référence
    mots [x] = mot ;                                  // met le mot là où on te dit
    refs [x][0] = ref ;                               // met la référence correspondante
    ++ref_libre [x] ;                                 // décale pour la réf suivante
    ++mot_libre ;                                     // décale le mot libre
}
 
void ajoute_ref(idx x, idx ref) {                     // un index, une référence
    idx r = ref_libre [x] ;                           // intermédiaire inutile
    if(ref != refs [x][r]){                           // ajoute la référence
        refs [x][r] = ref ;                           // décale pour la réf suivante
        ++ref_libre [x] ;
    }
}
 
void dump(idx k) {                                     // déverse le contenu de la mémoire
    idx x, z ;                                         // scanne les mots un par un
    for (x = 0 ; x < k ; ++x) {                        // test redondant, en l'état
        if (mots [x]) {                                // affiche le mot
            printf("%s :", mots [x]) ;                 // scanne ses références
            for (z = 0 ; refs [x][z] ; ++z)            // affiche-les sur la même ligne
                printf(" %i", refs [x][z]) ;           // termine par un alinéa
            printf("\n") ;
        }
    }
}
 
<couleur nom="rouge">void do_split_char(str fichier)
{
    int nombre_split_char =0;
    FILE *zap = fopen(fichier, "r");
    if(!zap) usage("stop.list introuvable");
    while (fgetc(zap) != EOF) nombre_split_char++;        //on compte le nombre de carractère
    fclose(zap);
    zap = fopen(fichier, "r");
    char sas[nombre_split_char];                           //sas contenant la stop liste
    while (fgets(sas,nombre_split_char, zap))
    split_chars = sas;
    fclose(zap);
}
</couleur>