Course cycliste
Contenu du snippet
gestion du tour de france
Source / Exemple :
******************************************************************************
******************************************************************************
TXT2DAT
******************************************************************************
******************************************************************************
/* ---------------------------------------------------------------------------
* Programme de conversion d'un fichier texte d'équipes en fichier binaire
* de coureurs
* Auteur(s) : DESPORTES BONIN
* Groupe TP :1 H
* Création :
* Entrées : un fichier texte donné sur la ligne de commande, equipes.txt
* par défaut.
* Syntaxe du fichier :
* <ÉQUIPES> ::= <ÉQUIPE> +
* <ÉQUIPE> ::= <ABR> <NOM COMPLET DE L'ÉQUIPE>'\n'<COUREUR> +
* <COUREUR> ::= '\t'<DOSSARD>' '<NOM>' ''('<NATIONALITÉ>')''\n'
* <ABR> ::= <chaîne de 3 caractères>
* <NOM COMPLET DE L'ÉQUIPE> ::= <chaîne de caractères>
* <DOSSARD> ::= <entier>
* <NOM> ::= <chaîne de caractères>
* <NATIONALITÉ> ::= <chaîne de 3 caractères>
* Sorties : un fichier binaire (coureurs.dat)
* Le fichier binaire contient un élément par coureur sous la forme
* d'un enregistrement (de taille fixe, voir la structure Coureur).
* Avancement :
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "temps.h"
#include "coureurs.h"
/* Nom par défaut du fichier des équipes */
#define FICHIER_EQUIPES "equipes.txt"
/* Taille maximum d'une ligne */
#define MAXLIGNE 128
/* Le caractère nul, plus facile à taper comme ça : */
#define NUL '\0'
void Usage(void);
/* ---------------------------------------------------------------------
* Programme principal :
* . Pour chaque équipe du fichier d'entrée :
* .. récupération de l'abréviation du nom
* .. pour chaque coureur de l'équipe :
* ... construction de la structure Coureur et enregistrement
* dans le fichier de sortie (et affichage).
*/
int main(int nbArgs, char *arg[])
{
char *nomEquipes, *nomCoureurs;
char ligne[MAXLIGNE]; /* pour lecture du fichier des équipes */
FILE *fEquipes;
FILE *fCoureurs;
Coureur c;
char Equipe[4];
char *s;
/* Analyse des arguments */
switch (nbArgs)
{
case 1: /* pas d'arguments : valeurs par défaut */
nomEquipes = FICHIER_EQUIPES;
nomCoureurs = FICHIER_COUREURS;
break;
case 2: /* fichier des équipes fourni en argument */
nomEquipes = arg[1];
nomCoureurs = FICHIER_COUREURS;
break;
case 3: /* fichier des équipes et fichier des coureurs
* fournis */
nomEquipes = arg[1];
nomCoureurs = arg[2];
break;
default:
Usage();
}
printf("Création du fichier %s à partir du fichier %s\n",
nomCoureurs, nomEquipes);
fEquipes=fopen("equipes.txt","r");
/*test*/
if (fEquipes==0)
printf("Erreur d'ouverture du fichier");
else
{
fCoureurs=fopen("coureurs.dat","wb");
/*test*/
if (fCoureurs==0)
printf("Erreur d'ouverture du fichier");
else
{
printf("***************ENREGISTREMENT***************\n");
fgets(ligne,MAXLIGNE,fEquipes);
c.temps.h=0;
c.temps.m=0;
c.temps.s=0;
while (!feof(fEquipes))
{
if (ligne[0]!='\t')
{
/*traitement pour une équipe*/
strncpy(Equipe,ligne,3);
Equipe[3]=NUL;
fgets(ligne,MAXLIGNE,fEquipes);
}
else
{
/*traitement pour un coureur*/
/*on mémorise son dossard*/
sscanf(ligne,"%d",&(c.dossard));
/*on mémorise le nom*/
/*on recherche la fin du nom*/
s=strchr(ligne,'(');
/*on insère une marque NUL*/
*(s-1)=NUL;
strcpy(c.nom,ligne+5);
/*on mémorise le pays*/
strncpy(c.pays,s+1,3);
c.pays[3]=NUL;
/*on mémorise l'équipe*/
strcpy(c.equipe,Equipe);
fgets(ligne,MAXLIGNE,fEquipes);
affCoureur(c,stdout);
fwrite(&c,sizeof(Coureur),1,fCoureurs);
}
}
fclose(fCoureurs);
printf("*****************FIN***********\n");
afficheCoureurs("coureurs.dat",stdout);
fclose(fEquipes);
}/*test des ouvertures*/
}
return EXIT_SUCCESS;
}
/*
* Affichage du mode d'emploi et sortie du programme
* Sorties : affichage sur la sortie erreur standard */
void Usage(void)
{
fprintf(stderr, "Usage : \n");
fprintf(stderr, "\ttxt2dat [[EQUIPES=equipes.txt [COUREURS=coureurs.dat]]\n");
exit(EXIT_FAILURE);
}
******************************************************************************
******************************************************************************
COUREURS
******************************************************************************
******************************************************************************
/* ---------------------------------------------------------------------------
* Module de gestion des coureurs.
* Auteur(s) :DESPORTES BONIN
* Groupe TP :1 H
* Création :
* Avancement : TERMINE
*/
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include "temps.h"
#define COUREURS_C
#include "coureurs.h"
/* Affichage d'un coureur sur un fichier texte
* Entrées : un coureur, out : fichier texte supposé ouvert en écriture
* Sorties : écriture du coureur sur out
* Exemple d'utilisation : (affichage sur l'écran)
* affCoureur(c, stdout); */
void affCoureur(Coureur c, FILE *out)
{
fprintf(out,"%d %s %s %s ",c.dossard,c.nom,c.equipe,c.pays);
affTemps(c.temps,out);
fprintf(out,"\n");
}
/* Affichage d'un fichier de coureurs sur un fichier texte
* Entrées : nomCoureurs, fichier binaire de coureurs ;
* out : fichier texte supposé ouvert en écriture
* Sorties : écriture du contenu de nomCoureurs sur out
* Exemple d'utilisation : (affichage sur l'écran)
* afficheCoureurs("coureurs.dat", stdout); */
void afficheCoureurs(char nomCoureurs[], FILE *out)
{
FILE* Fc;
Coureur c;
Fc=fopen(nomCoureurs,"rb");
/*A TEST*/
if (Fc==0)
printf("Erreur d'ouverture du fichier");
else
{
/*lecture*/
fread(&c,sizeof(Coureur),1,Fc);
while (!feof(Fc))
{
fprintf(out,"%d %s %s %s ",c.dossard,c.nom,c.equipe,c.pays);
affTemps(c.temps,out);
fprintf(out,"\n");
fread(&c,sizeof(Coureur),1,Fc);
}
fclose(Fc);
}
}
/* Recherche d'un coureur dans un fichier binaire de coureurs
* Entrées : le numéro de dossard du coureur ;
* coureurs : fichier binaire supposé ouvert en lecture ;
* Sorties : rang du coureur dans le fichier ou -1 s'il n'existe pas */
int chercheCoureur(int dossard, FILE *coureurs)
{
int rang=0;
Coureur c;
/*on se positionne au début*/
fseek(coureurs,0,SEEK_SET);
fread(&c,sizeof(Coureur),1,coureurs);
while (!feof(coureurs))
{
if (c.dossard==dossard)
break;
else
{
fread(&c,sizeof(Coureur),1,coureurs);
rang++;
}
}
if (feof(coureurs))
return -1;
else return rang;
}
******************************************************************************
******************************************************************************
TRI
******************************************************************************
******************************************************************************
/* ---------------------------------------------------------------------------
* Programme de tri d'un fichier de coureurs selon le numéro de dossard, tri
* par insertion en chargeant le fichier dans une table. La taille maximum
* de la table est fixée par constante.
* Auteur(s) :
* Groupe TP :
* Création :
* Entrées : le fichier de coureurs donné sur la ligne de commande, défaut
* coureurs.dat (voir module coureurs).
* Sorties : le même fichier trié.
* Avancement :
*/
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include "temps.h"
#include "coureurs.h"
void Usage(void);
/* ---------------------------------------------------------------------
* Programme principal :
* . Chargement du fichier à trier dans un table avec insertion dans
* l'ordre du numéro de dossard.
* . Réécriture du fichier trié sur disque
*/
int main(int nbArgs, char *arg[])
{
char *nomCoureurs;
int j,nbcoureur;
FILE* Fc;
Coureur c;
Coureur T[200];
switch (nbArgs)
{
case 1: /* pas d'arguments */
nomCoureurs = FICHIER_COUREURS;
break;
case 2: /* fichier des coureurs fourni en argument */
nomCoureurs = arg[1];
break;
default:
Usage();
}
c.temps.h=0;
c.temps.m=0;
c.temps.s=0;
/* chargement du fichier dans la table avec insertion à la volée */
Fc=fopen(nomCoureurs,"rb");
/*test*/
if (Fc==0)
printf("Erreur d'ouverture du fichier");
else
{
fread(&c,sizeof(Coureur),1,Fc);
j=0;nbcoureur=0;
while (!feof(Fc))
{
/*selon les differents cas*/
/*le tableau est vide*/
if (nbcoureur==0)
{
T[0]=c;nbcoureur++;
}
/*le tableau contient au moins un élément*/
else
{
/*insertion en fin de tableau*/
if (T[nbcoureur-1].dossard < c.dossard)
{ T[nbcoureur]= c;nbcoureur++;
}
/*insertion avec décalage*/
else
{
j=nbcoureur-1;
while ((j>=0) && (T[j].dossard > c.dossard))
{
T[j+1]=T[j];
j--;
}
T[j+1]=c;
nbcoureur++;
}
}
fread(&c,sizeof(Coureur),1,Fc);
}
fclose(Fc);
Fc=fopen(nomCoureurs,"wb");
/*a tester*/
/* Réécriture de la table dans le fichier */
for(j=0;j<nbcoureur;j++)
fwrite(&T[j],sizeof(Coureur),1,Fc);
fclose(Fc);
Fc=fopen(nomCoureurs,"rb");
/* Réaffichage pour trace */
afficheCoureurs("coureurs.dat",stdout);
fclose(Fc);
}
return EXIT_SUCCESS;
}
/*
* Affichage du mode d'emploi et sortie du programme
* Sorties : affichage sur la sortie erreur standard */
void Usage(void)
{
fprintf(stderr, "Usage : \n");
fprintf(stderr, "\ttri [COUREURS=coureurs.dat]\n");
exit(EXIT_FAILURE);
}
******************************************************************************
******************************************************************************
TEMPS
******************************************************************************
******************************************************************************
/* ---------------------------------------------------------------------------
* Module de gestion du temps en heure, minutes, secondes.
* Auteur(s) : Damien Genthial
* Création : 10 juillet 2000
*/
#include <stdio.h>
#include <time.h>
#define TEMPS_C
#include "temps.h"
/* Affichage d'un temps sur un fichier texte
* Entrées : un temps t, out : fichier texte supposé ouvert en écriture
* Sorties : écriture du temps sur out
* Exemple d'utilisation : (affichage sur l'écran)
* affTemps(t, stdout); */
void affTemps(Temps t, FILE *out)
{
fprintf(out, "%02d:%02d:%02d", t.h, t.m, t.s);
}
/* Addition des deux temps t1 et t2 */
Temps addTemps(Temps t1, Temps t2)
{
Temps res = {0, 0, 0};
res.s = t1.s + t2.s;
if (res.s >= 60)
{
res.s = res.s - 60;
res.m = 1;
}
res.m = res.m + t1.m + t2.m;
if (res.m >= 60)
{
res.m = res.m - 60;
res.h = 1;
}
res.h = res.h + t1.h + t2.h;
return res;
}
/* Différence gd - pt (on suppose gd >= pt) */
Temps diffTemps(Temps gd, Temps pt)
{
Temps res = {0, 0, 0};
res.s = gd.s - pt.s;
if (res.s < 0)
{
res.s = res.s + 60;
res.m = -1;
}
res.m = res.m + gd.m - pt.m;
if (res.m < 0)
{
res.m = res.m + 60;
res.h = -1;
}
res.h = res.h + gd.h - pt.h;
return res;
}
/* Comparaison de deux temps, retourne -1 si t1 < t2, 0 si t1 = t2 et
* 1 si t1 > t2 */
int compareTemps(Temps t1, Temps t2)
{
if (t1.h < t2.h)
return -1;
if (t1.h > t2.h)
return 1;
if (t1.m < t2.m)
return -1;
if (t1.m > t2.m)
return 1;
if (t1.s < t2.s)
return -1;
if (t1.s > t2.s)
return 1;
return 0;
}
/* Retourne l'heure système */
Temps Heure(void)
{
struct tm *temps;
time_t timer;
Temps res;
timer = time(NULL);
temps = localtime(&timer);
res.h = temps->tm_hour;
res.m = temps->tm_min;
res.s = temps->tm_sec;
return res;
}
******************************************************************************
******************************************************************************
BONIFICATION
******************************************************************************
******************************************************************************
/* ---------------------------------------------------------------------------
* Programme de bonification (on enlève un temps donné au temps d'un coureur)
* Auteur(s) : DESPORTES BONIN
* Groupe TP :1 H
* Création :
* Entrées : le fichier des coureurs (coureurs.dat par défaut)
* une liste de numéros de coureur et la bonification associée,
* terminée par le numéro 0
* Sorties : le fichier des coureurs mis à jour,
* des traces à l'écran.
* Avancement :
*/
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include "temps.h"
#include "coureurs.h"
void Usage(void);
/* ---------------------------------------------------------------------
* Programme principal :
* . Pour chaque numéro de coureur lu au clavier :
* .. recherche du rang dans le fichier
* .. saisie de la bonification (nombre de secondes)
* .. affichage de la valeur avant bonification et de valeur après
* bonification
* .. mise à jour du fichier
*/
int main(int nbArgs, char *arg[])
{
char *nomCoureurs;
FILE *fCoureurs;
int n, rang;
Temps bonif;
Coureur c;
char *r;
switch (nbArgs)
{
case 1: /* pas d'arguments, valeur par défaut (voir coureurs.h) */
nomCoureurs = FICHIER_COUREURS;
break;
case 2: /* fichier des coureurs fourni en argument */
nomCoureurs = arg[1];
break;
default:
Usage();
}
fCoureurs=fopen(nomCoureurs,"rw+b");
if (fCoureurs==0)
printf("Erreur d'ouverture du fichier");
else
{
/*saisie controlée*/
while (1)
{
printf("***************\nEntrez un numéro de dossard (0 pour STOP):");
scanf("%d",&n);
if (n==0)
break;
else
{
printf("\n");
rang=chercheCoureur(n,fCoureurs);
/*pour etre sure d'etre au debut -->*/
fseek(fCoureurs,0,SEEK_SET);
if (rang != -1)
{
/*deplacement de la taille de la structure*/
fseek(fCoureurs,rang*sizeof(Coureur),SEEK_SET);
/*mise en mémoire du coureur*/
fread(&c,sizeof(Coureur),1,fCoureurs);
/*vérification visuel pour l utilisateur*/
printf("DOSSARD [%d] TEMPS:",c.dossard);
affTemps(c.temps,stdout);
fseek(fCoureurs,-1*sizeof(Coureur),SEEK_CUR);
bonif.h=0;
bonif.m=0;
printf("\nENTRZ LA BONIFICATION : ");
scanf("%d",&(bonif.s));
c.temps=diffTemps(c.temps, bonif);
printf("nouveau temps :");
affTemps(c.temps,stdout);
printf("\n");
fwrite(&c,sizeof(Coureur),1,fCoureurs);
affCoureur(c,stdout);
}
/*AIDE A LA SAISIE DU DOSSARD*/
else
{ printf("Vérifier le numéro de dossard!! Voulez vous voir la liste ?(o/n)");
scanf("%s",r);
printf("\n*********\n");
if ((*r=='o') || (*r=='O'))
afficheCoureurs(nomCoureurs,stdout);
}
}
}
fclose(fCoureurs);
}
return EXIT_SUCCESS;
}
/*
* Affichage du mode d'emploi et sortie du programme
* Sorties : affichage sur la sortie erreur standard */
void Usage(void)
{
fprintf(stderr, "Usage : \n");
fprintf(stderr, "\ttri [COUREURS=coureurs.dat]\n");
exit(EXIT_FAILURE);
}
******************************************************************************
******************************************************************************
MAKEFILE
******************************************************************************
******************************************************************************
#Makefile pour les programmes du stage C
#Auteurs :
#Groupe TP :
#Pour compiler les modules
CC=cc -g -ansi -c -Wall
txt2dat: txt2dat.o coureurs.o temps.o
cc -g -o txt2dat txt2dat.o coureurs.o temps.o -Wall
#Module Principale
txt2dat.o: txt2dat.c coureurs.h temps.h
$(CC) txt2dat.c
#Module tri
tri: tri.o coureurs.o temps.o
cc -g -o tri tri.o coureurs.o temps.o -Wall
tri.o: tri.c coureurs.h temps.h
$(CC) tri.c
#Module bonification
bonification: bonification.o coureurs.o temps.o
cc -g -o bonification bonification.o coureurs.o temps.o -Wall
bonification.o: bonification.c coureurs.h temps.h
$(CC) bonification.c
#Module coureurs
coureurs.o: coureurs.c coureurs.h temps.h
$(CC) coureurs.c
#Module temps
temps.o: temps.c temps.h
$(CC) temps.c
#Pour faire le ménage
clean:
rm -f *.o txt2dat bonification tri
#Pour faire le compte rendu
cptrd:
@cat txt2dat.c > CR_TP
@echo -e "\f" >> CR_TP
@cat coureurs.c >> CR_TP
@echo -e "\f" >> CR_TP
@cat tri.c >> CR_TP
@echo -e "\f" >> CR_TP
@cat temps.c >> CR_TP
@echo -e "\f" >> CR_TP
@cat bonification.c >> CR_TP
@echo -e "\f" >> CR_TP
@echo -e "MAKEFILE\n" >> CR_TP
@cat Makefile >> CR_TP
@echo -e "\f" >> CR_TP
@echo -e "TRACE" >> CR_TP
@echo -e "TXT2DAT\n" >> CR_TP
@txt2dat >> CR_TP
@echo -e "\f" >> CR_TP
@echo -e "TRI" >> CR_TP
@tri >> CR_TP
@random >> CR_TP
@echo -e "\f" >> CR_TP
@bonification<test>test.txt >> CR_TP
#Pour ouvrir tout les programmes en arrière plan
open:
nedit txt2dat.c &
nedit coureurs.h &
nedit temps.h &
nedit coureurs.c &
nedit temps.c &
nedit bonification.c &
nedit tri.c &
TRACE
TXT2DAT
Création du fichier coureurs.dat à partir du fichier equipes.txt
***************ENREGISTREMENT***************
151 BROCHARD Laurent A2R FRA 00:00:00
152 ASTARLOZA Mikel A2R ESP 00:00:00
153 BOTCHAROV Alexandre A2R RUS 00:00:00
154 CHAURREAU Inigo A2R ESP 00:00:00
155 FLICKINGER Andy A2R FRA 00:00:00
156 KIRSIPUU Jaan A2R EST 00:00:00
157 ORIOL Christophe A2R FRA 00:00:00
158 PORTAL Nicolas A2R FRA 00:00:00
159 TURPIN Ludovic A2R FRA 00:00:00
201 DUFAUX Laurent ALS SUI 00:00:00
202 BALDATO Fabio ALS ITA 00:00:00
203 BERTOLINI Alessandro ALS ITA 00:00:00
...........
5 HINCAPIE George USP USA 00:00:00
6 LANDIS Floyd USP USA 00:00:00
7 PADRNOS Pavel USP CZE 00:00:00
8 PENA Victor-Hugo USP COL 00:00:00
9 RUBIERA José-Luis USP ESP 00:00:00
*****************FIN***********
151 BROCHARD Laurent A2R FRA 00:00:00
152 ASTARLOZA Mikel A2R ESP 00:00:00
153 BOTCHAROV Alexandre A2R RUS 00:00:00
154 CHAURREAU Inigo A2R ESP 00:00:00
155 FLICKINGER Andy A2R FRA 00:00:00
...........
26 KLÖDEN Andréas TEL GER 00:00:00
27 NARDELLO Daniele TEL ITA 00:00:00
28 VINOKOUROV Alexandre TEL KAZ 00:00:00
29 ZABEL Erik TEL GER 00:00:00
1 ARMSTRONG Lance USP USA 00:00:00
2 HERAS Roberto USP ESP 00:00:00
3 BELTRAN Manuel USP ESP 00:00:00
4 EKIMOV Vjatceslav USP RUS 00:00:00
5 HINCAPIE George USP USA 00:00:00
6 LANDIS Floyd USP USA 00:00:00
7 PADRNOS Pavel USP CZE 00:00:00
8 PENA Victor-Hugo USP COL 00:00:00
9 RUBIERA José-Luis USP ESP 00:00:00
TRI
1 ARMSTRONG Lance USP USA 00:00:00
2 HERAS Roberto USP ESP 00:00:00
3 BELTRAN Manuel USP ESP 00:00:00
4 EKIMOV Vjatceslav USP RUS 00:00:00
5 HINCAPIE George USP USA 00:00:00
6 LANDIS Floyd USP USA 00:00:00
7 PADRNOS Pavel USP CZE 00:00:00
8 PENA Victor-Hugo USP COL 00:00:00
9 RUBIERA José-Luis USP ESP 00:00:00
11 BELOKI Joseba ONE ESP 00:00:00
12 ANDRLE René ONE CZE 00:00:00
13 AZEVEDO José ONE POR 00:00:00
14 GONZALEZ-GALDEANO Alvaro ONE ESP 00:00:00
..............
214 EDALEINE Christophe DEL FRA 00:00:00
215 FINOT Frédéric DEL FRA 00:00:00
216 GOUBERT Stephane DEL FRA 00:00:00
217 KRIVTSOV Yuriy DEL UKR 00:00:00
218 LEFEVRE Laurent DEL FRA 00:00:00
219 NAZON Jean-Patrick DEL FRA 00:00:00
( 1) ARMSTRONG Lance (USP, USA) : 05:46:43
( 2) HERAS Roberto (USP, ESP) : 05:55:57
( 3) BELTRAN Manuel (USP, ESP) : 05:55:53
( 4) EKIMOV Vjatceslav (USP, RUS) : 05:12:46
( 5) HINCAPIE George (USP, USA) : 05:01:09
( 6) LANDIS Floyd (USP, USA) : 05:07:02
( 7) PADRNOS Pavel (USP, CZE) : 05:19:50
( 8) PENA Victor-Hugo (USP, COL) : 05:46:23
( 9) RUBIERA José-Luis (USP, ESP) : 05:06:00
( 11) BELOKI Joseba (ONE, ESP) : 05:16:52
( 12) ANDRLE René (ONE, CZE) : 05:08:11
..............
(207) MIHOLJEVIC Vladimir (ALS, CRO) : 05:55:12
(208) NOE Andrea (ALS, ITA) : 05:04:14
(209) PELLIZOTTI Franco (ALS, ITA) : 05:29:59
(211) HALGAND Patrice (DEL, FRA) : 05:56:33
(212) BOURQUENOUD Pierre (DEL, SUI) : 05:55:30
(213) DUMOULIN Samuel (DEL, FRA) : 05:22:40
(214) EDALEINE Christophe (DEL, FRA) : 05:04:59
(215) FINOT Frédéric (DEL, FRA) : 05:25:13
(216) GOUBERT Stephane (DEL, FRA) : 05:07:41
(217) KRIVTSOV Yuriy (DEL, UKR) : 05:13:44
(218) LEFEVRE Laurent (DEL, FRA) : 05:14:01
(219) NAZON Jean-Patrick (DEL, FRA) : 05:39:06
***************
Entrez un numéro de dossard (0 pour STOP):
DOSSARD [1] TEMPS:05:46:43
ENTRZ LA BONIFICATION : nouveau temps :05:45:43
1 ARMSTRONG Lance USP USA 05:45:43
***************
Entrez un numéro de dossard (0 pour STOP):
DOSSARD [2] TEMPS:05:55:57
ENTRZ LA BONIFICATION : nouveau temps :05:55:27
2 HERAS Roberto USP ESP 05:55:27
***************
Entrez un numéro de dossard (0 pour STOP):
Vous n'êtes pas encore membre ?
inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.