IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

C Discussion :

Récriture stdio.c des années 90


Sujet :

C

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre confirmé Avatar de Echyzen
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Décembre 2012
    Messages
    123
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Décembre 2012
    Messages : 123
    Par défaut Récriture stdio.c des années 90
    Salut à tous,

    Voilà j'ai un exercice a faire et j'ai vraiment du mal a comprendre par ou commencer mais surtout comment tester mon travail.
    On m'a passé un stdio.h qui date de l'époque de SUN MicroSystem :

    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
    # ifndef FILE
    #define	BUFSIZ	1024
     
    #define _SBFSIZ	8
    extern	struct	_iobuf {
    	int		_cnt; 
    	unsigned char*  _ptr; 
    	unsigned char*  _base; 
    	int		_bufsiz; 
    	short		_flag; 
    	char		_file; 
    } _IOB[];
     
    #define _IOFBF	 0 
    #define	_IOREAD	 01
    #define	_IOWRT	 02
    #define	_IONBF	 04 
    #define	_IOMYBUF 010
    #define	_IOEOF	 020
    #define	_IOERR	 040
    #define	_IOSTRG	 0100
    #define	_IOLBF	 0200 
    #define	_IORW	 0400
    #define	NULL	 ((void*) 0)
    #define	FILE	 struct _iobuf
    #define	EOF	 (-1)
     
    #define	stdin	 (&_IOB[0])
    #define	stdout	 (&_IOB[1])
    #define	stderr	 (&_IOB[2])
     
     
    extern int _flsbuf(unsigned char c, FILE *f);
    extern int _filbuf(FILE * f);
     
    #ifdef lint	/* so that lint likes (void)putc(a,b) */
    extern int putc();
    extern int getc();
     
    #else
    #define	getc(p)		(--(p)->_cnt>=0? ((int)*(p)->_ptr++):_filbuf(p))
    #define putc(x, p)	(--(p)->_cnt >= 0 ?\
    	(int)(*(p)->_ptr++ = (unsigned char)(x)) :\
    	(((p)->_flag & _IOLBF) && -(p)->_cnt < (p)->_bufsiz ?\
    		((*(p)->_ptr = (unsigned char)(x)) != '\n' ?\
    			(int)(*(p)->_ptr++) :\
    			_flsbuf(*(unsigned char *)(p)->_ptr, p)) :\
    		_flsbuf((unsigned char)(x), p)))
    #endif
    #define	getchar()	getc(stdin)
    #define	putchar(x)	putc((x),stdout)
    #define	feof(p)		(((p)->_flag&_IOEOF)!=0)
    #define	ferror(p)	(((p)->_flag&_IOERR)!=0)
    #define	fileno(p)	((p)->_file)
    #define	clearerr(p)	(void) ((p)->_flag &= ~(_IOERR|_IOEOF))
     
     
    FILE *fopen(const char *path, const char *mode);
    FILE *fdopen(int fd, const char *mode);
    FILE *freopen(const char *path, const char *mode, FILE *stream);
    int fclose(FILE *fp);
     
    FILE *popen(const char *command, const char *type);
    int pclose(FILE *stream);
     
    FILE *tmpfile(void);
     
    int fgetc(FILE *stream);
    char *fgets(char *s, int size, FILE *stream);
    char *gets(char *s);
     
    int fputc(int c, FILE *stream);
    int fputs(const char *s, FILE *stream);
    int puts(const char *s);
     
    int printf(const char *format, ...);
    int fprintf(FILE *stream, const char *format, ...);
    int sprintf(char *str, const char *format, ...);
     
    void setbuf(FILE *stream, char *buf);
    int setvbuf(FILE *stream, char *buf, int mode, int size);
    # endif
    A partir de là je doit commencer par les fonctions : _filbuf et fopen à l'heure le problème c'est que je ne sait pas comment vérifier mon travail....

    Voilà mon travail pour filbuf :

    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
    extern int _filbuf(FILE * f) {
     
    	int bufsize;
     
    	bufsize = (f->_flag & _IONBF) ? 1 : BUFSIZ;
    	if (f->_base == NULL)     // no buffer yet
    	   if ((f->_base = (char *) malloc(bufsize)) == NULL)
    		   return EOF;       // can't get buffer
    	f->_ptr = f->_base;
     
    	f->_cnt = read(f->_file, f->_ptr, bufsize);
    	if (--f->_cnt < 0) {
    	   if (f->_cnt == -1)
    		   f->_flag |= _IOEOF;
    	   else
    		   f->_flag |= _IOERR;
    	   f->_cnt = 0;
    	   return EOF;
    	}
    	return (unsigned char) *f->_ptr++;
    } //_filbuf()

  2. #2
    Membre Expert
    Avatar de Metalman
    Homme Profil pro
    Enseignant-Chercheur
    Inscrit en
    Juin 2005
    Messages
    1 049
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 36
    Localisation : France, Hauts de Seine (Île de France)

    Informations professionnelles :
    Activité : Enseignant-Chercheur
    Secteur : Enseignement

    Informations forums :
    Inscription : Juin 2005
    Messages : 1 049
    Par défaut
    Tout d'abord : quel est le but exact du projet ? Peut être que tout refaire en détails n'est pas nécessaire.

    Ensuite : les fonctions commençant par un _ sont rarement nécessaires pour l'usage "final"/publique, il s'agit généralement de fonctions techniques "internes" à celles effectuant d'autres choses.
    S'il faut recoder stdio.c, il faut recoder les fonctions "normales" telles que fopen, fwrite, fread, fclose....

    Après, si c'est du sujet d'école : les fonctions "exactes" à recoder sont indiquées ! Ou alors demande au prof/aux assistants !
    Partir du .h d'un OS est une très mauvaise idée car tu n'as probablement pas la même façon de penser que ceux qui ont réalisé ces sources.
    Par contre, tu peux lire les structures et comprendre quels membres sont "vraiment" importants !

    Dans la libF (comme je l'appelais à l'époque), il est utile de conserver dans la structure FILE* :
    - le file descriptor (nécessaire)
    - le pointeur de lecture dans le fichier (nécessaire)
    - le pointeur d'écriture dans le fichier (nécessaire)
    - un buffer d'écriture & un buffer de lecture, ou seulement un buffer ("nécessaire" pour limiter le nombre de read/write, car c'est la grosse utilité des fread/fwrite par rapport à read/write)
    - un pointeur dans ton buffer (où tu en es dans la lecture/écriture)
    - les flags que l'on t'a donné (au cas "où" tu veuilles la gestion en amont des read/write)
    - le nom du fichier
    --
    Metalman !

    Attendez 5 mins après mes posts... les EDIT vont vite avec moi...
    Les flags de la vie : gcc -W -Wall -Werror -ansi -pedantic mes_sources.c
    gcc -Wall -Wextra -Werror -std=c99 -pedantic mes_sources.c
    (ANSI retire quelques fonctions comme strdup...)
    L'outil de la vie : valgrind --show-reachable=yes --leak-check=full ./mon_programme
    Et s'assurer que la logique est bonne "aussi" !

    Ma page Developpez.net

  3. #3
    Membre confirmé Avatar de Echyzen
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Décembre 2012
    Messages
    123
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Décembre 2012
    Messages : 123
    Par défaut
    Alors la question est :

    Ecrivez les primitives filbuf et flsbuf dont vous "devinerez" la specifi cation en
    fonction de leur utilisation dans le fichier <stdio.h> qui vous a ete fourni. La primitive
    filbuf est beaucoup plus simple a ecrire. ecrivez cette fonction en premier.

    Les noms des fonctions avec _ c'est déclarées comme çà dans le stdio.h fourni voir premier message.

    Pour le reste le iobuf struct je l'avais bien compris çà

    Du coup je vous presente mon filbuf dans mon premier message mais je ne sais pas comment tester cela...

  4. #4
    Membre confirmé Avatar de Echyzen
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Décembre 2012
    Messages
    123
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Décembre 2012
    Messages : 123
    Par défaut
    Le professeur ma dit de tester la fonction filbuf avec cat (stdin->stdout)

    Mais honnêtement je ne comprend toujours pas comment XD

    SVP personne pour m'aider?

Discussions similaires

  1. [Recherche] Techno des années 90
    Par DavidDeTroyes dans le forum Musique
    Réponses: 31
    Dernier message: 26/09/2007, 14h46
  2. Réponses: 3
    Dernier message: 07/09/2007, 15h29
  3. Remplir un <select> avec des années
    Par belzeluc dans le forum Général JavaScript
    Réponses: 2
    Dernier message: 21/02/2007, 10h24
  4. Récuparation des années par une requête
    Par 973thom dans le forum Access
    Réponses: 3
    Dernier message: 14/06/2005, 18h33
  5. [MEA] Comment modéliser la gestion des années ?
    Par ronando dans le forum Schéma
    Réponses: 6
    Dernier message: 10/11/2004, 17h25

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo