fpurge()

Salut,

J'utilise fgets() pour lire une ligne sur l'entrée standard et le resultat est mis dans un tableau de caractere de taille fixe.
Le truc c'est que si la ligne est plus grande que ce tableau, le prochain fgets() va d'abord traiter ce qui depassait du precedent fgets()
J'imagine que c'est un probleme courant, mais je m'y étais jamais confronté
Donc, je m'aperçois que fflush(stdin) ne sert à rien, ça doit marcher que pour les flux de sortie. J'ai donc noté la presence d'une fonction fpurge(), mais le man dit que c'est pas du tout standard et normalement on ne doit pas avoir besoin d'ignorer ce qui a été entré. De toute façon ce n'est pas present sur mon systeme.
Par contre <stdio_ext.h> declare __fpurge(), que j'ai essayé et qui marche bien.

Alors, qu'est ce que je devrais faire?

Merci

Tu vides ton buffer d'entrée à coup de fgetc(stdin)

Mmm, c'est bien ce que je pensais, merci

(ou alors a coup de fgets(), ca doit être pareil)

Citation:

Envoyé par Gruik

J'utilise fgets() pour lire une ligne sur l'entrée standard et le resultat est mis dans un tableau de caractere de taille fixe.
Le truc c'est que si la ligne est plus grande que ce tableau, le prochain fgets() va d'abord traiter ce qui depassait du precedent fgets()
J'imagine que c'est un probleme courant, mais je m'y étais jamais confronté

Voici une fonction qui doit furieusement ressembler à ton fpurge()...
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 void clean (char *s, FILE *fp) { /* search ... */ char *p = strchr (s, '\n'); if (p != NULL) { /* ... and kill */ *p = 0; } else { /* purge */ int c; while ((c = fgetc(fp)) != '\n' && c != EOF) { } } }
Elle a 2 actions :

tester et supprimmer le '\n'
purger les caractères non lus.

fflush() ne marche pas pour les flux d'entrée, c'est vrai.
En tout cas j'ai remarqué que sous windows fflush(stdin) fonctionnait.
En revanche sous Linux j'utilise, à chaque fois, la fonction la fonction décrite par Emmanuel delahaye.
Doit-on utiliser fflush(stdin) sous windows ( vu que ça marche ), ou faut il utiliser la fonction de Emmanuel Delahaye ? Pour plus de portabilité il semble être préférable d'utiliser cette dernière, non ?

Citation:

Envoyé par flocks

fflush() ne marche pas pour les flux d'entrée, c'est vrai.
En tout cas j'ai remarqué que sous windows fflush(stdin) fonctionnait.

Oui, c'est une extension bien connue et bien confusante...

Citation:

En revanche sous Linux j'utilise, à chaque fois, la fonction la fonction décrite par Emmanuel delahaye.
Doit-on utiliser fflush(stdin) sous windows ( vu que ça marche ), ou faut il utiliser la fonction de Emmanuel Delahaye ? Pour plus de portabilité il semble être préférable d'utiliser cette dernière, non ?

Oui, la portabilité est un facteur déterminant. Et ce n'est pas 'ma fonction'. mais celle de la communauté...

Citation:

Envoyé par Emmanuel Delahaye

Et ce n'est pas 'ma fonction'. mais celle de la communauté...

Bien sur, c'était une façon de dire : la fonction que tu as donné..

Merci Emdel, mais je prefere ma boucle

Code:

1
2
3
4
 
do {
    fgets(buffer, sizeof buffer, stdin);
} while (buffer[strlen(buffer)] != '\n');

Citation:
Envoyé par Gruik
Merci Emdel, mais je prefere ma boucle
Code:

1 2 3 4 do { fgets(buffer, sizeof buffer, stdin); } while (buffer[strlen(buffer)] != '\n');
Et ça retire le'\n' comment ?

Dans mon cas, j'ignorais les lignes trop grandes et je redemandais de saisir
Mais avant cette boucle j'avais un truc du genre
Code:

1 2 3 4 5 6 7 8 9 fgets(zone_memoire, taille_zone_memoire, stdin); tmplg = strlen(zone_memoire) - 1; if (zone_memoire[tmplg] != '\n') { /* erreur et vidage de stdin */ } else { zone_memoire[tmplg] = '\0'; /* traitement normal */ }

Citation:

Envoyé par Gruik

Dans mon cas, j'ignorais les lignes trop grandes et je redemandais de saisir
Mais avant cette boucle j'avais un truc du genre

Ca me parait bien compliqué... Tu peux donner un exemple de code complet opérationnel ?

Demain ,)

Je prete un peu plus d'attention a ton "clean()" et c'est vrai que c'est cool, le strchr() n'est pas plus long que le strlen()
Je me demande juste pourquoi on passe le FILE * alors qu'on sait qu'il s'agit de stdin

Voici la fonction
En fait j'ai créé un module utilitaire de recuperation de formulaire pour les CGIs, et, si le programme est appelé par ligne de commande au lieu d'etre appelé par le serveur web, le "mode interactif" est lancé

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
static void interactive_mode ()
{
    data_buff = (char *) malloc (INTERACTIVE_MAX_LG);
 
    for(;;) {
        fputs ("Query string (au format urlencoded) :\n", stdout);
        fgets (data_buff, INTERACTIVE_MAX_LG, stdin);
 
        data_lg = strlen(data_buff);
        if (data_buff[data_lg - 1] == '\n') {
            data_lg--; /* compte pas le \n */
            data_buff[data_lg] = '\0'; /* car on le vire */
 
            return;
        }
        /* Sinon, l'entrée de l'utilisateur était trop grande => il faut recommencer */
        fputs ("\nVotre query string est trop grande !\n", stdout);
 
        do {    /* vidage du buffer d'entrée */
            fgets (data_buff, INTERACTIVE_MAX_LG, stdin);
        } while (data_buff[strlen(data_buff) - 1] != '\n');
    }
}

Citation:

Envoyé par Gruik

Je prete un peu plus d'attention a ton "clean()" et c'est vrai que c'est cool, le strchr() n'est pas plus long que le strlen()
Je me demande juste pourquoi on passe le FILE * alors qu'on sait qu'il s'agit de stdin

Parce que la problématique est la même avec n'importe quel flux. Par défaut, je l'utilise après fgets().

Citation:
Envoyé par Gruik
Voici la fonction
En fait j'ai créé un module utilitaire de recuperation de formulaire pour les CGIs, et, si le programme est appelé par ligne de commande au lieu d'etre appelé par le serveur web, le "mode interactif" est lancé
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 static void interactive_mode () { data_buff = (char *) malloc (INTERACTIVE_MAX_LG); for(;;) { fputs ("Query string (au format urlencoded) :\n", stdout); fgets (data_buff, INTERACTIVE_MAX_LG, stdin); data_lg = strlen(data_buff); if (data_buff[data_lg - 1] == '\n') { data_lg--; /* compte pas le \n */ data_buff[data_lg] = '\0'; /* car on le vire */ return; } /* Sinon, l'entrée de l'utilisateur était trop grande => il faut recommencer */ fputs ("\nVotre query string est trop grande !\n", stdout); do { /* vidage du buffer d'entrée */ fgets (data_buff, INTERACTIVE_MAX_LG, stdin); } while (data_buff[strlen(data_buff) - 1] != '\n'); } }
C'est bien ce que je craignais, c'est beaucoup plus compliqué et en cas de purge, tu rappelles strlen(), alors que clean() appelle une seule fois strchr().

De plus, il est un peu absurde de ne pas profiter de l'allocation dynamique pour, au lieu de purger, réallouer jusqu'à prendre ce qui manque...

Voici mes solutions industrielles :

http://emmanuel-delahaye.developpez.com/clib.htm
Module IO

Citation:

Envoyé par Emmanuel Delahaye

C'est bien ce que je craignais, c'est beaucoup plus compliqué et en cas de purge, tu rappelles strlen(), alors que clean() appelle une seule fois strchr().

Mais clean appelles plein de fois fgetc()
De toutes façon, ce cas ne se presentera pas souvent