faire une namelist

Version imprimable

16/10/2009, 10h29
Ladgalen

faire une namelist
Bonjour

Je voudrais savoir s'il existe en C des commandes pour faire une namelist ?

Par namelist, je veux dire qu'on a définit un ensemble de variable qui sont donnée dans un fichier sous la forme :
Code:

1 2 3 4 5 flag1 = 10, flag2 = 20, flag3 = "plop", ....
la lecture de la namelist renvoi les valeurs de chaque flag qu'elle contient.

Merci
16/10/2009, 10h32
ram-0000

Je ne connais rien de tel en C.

Un truc approchant serait peut être d'utiliser les directives du préprocesseur #define puisqu'on peut les fournit dans le script makefile avec l'option -D.

Mais bon, c'est pas tout à fait pour cela que c'est prévu.
16/10/2009, 17h36
Mac LAK

La seule chose que je connais d'approchant, mais c'est propre à chaque plate-forme, c'est la lecture d'un fichier .INI... Sous Windows, c'est bien sûr trivial à utiliser (car natif), c'est moins évident pour les autres OS.
16/10/2009, 18h22
Franck.H

Citation:

Envoyé par Mac LAK

La seule chose que je connais d'approchant, mais c'est propre à chaque plate-forme, c'est la lecture d'un fichier .INI... Sous Windows, c'est bien sûr trivial à utiliser (car natif), c'est moins évident pour les autres OS.

Je ne vois pas trop ce qu'est une namelist mais si tu parles de *.ini j'ai une bibliothèque perso qui permet de créer des fichiers de ce genre et de les lire: http://franckh.developpez.com/cinifile/... si jamais ca peut être utile :mrgreen:
17/10/2009, 10h57
Mac LAK

A peu de choses près, pour ce que j'ai compris du besoin de l'OP, c'est une map associant un identifiant texte à une valeur quelconque... En gros, une map<string,variant>, si tu préfères, ou un tableau associatif de langage interprété.
17/10/2009, 11h10
Franck.H

Citation:

Envoyé par Mac LAK

A peu de choses près, pour ce que j'ai compris du besoin de l'OP, c'est une map associant un identifiant texte à une valeur quelconque... En gros, une map<string,variant>, si tu préfères, ou un tableau associatif de langage interprété.

Ok, typiquement clé/valeur en somme !

:merci:
17/10/2009, 11h30
Mac LAK

Citation:

Envoyé par Franck.H

Ok, typiquement clé/valeur en somme !

Yep, d'où le .INI qui est je pense le plus approchant en C (et même en C++ si l'on n'utilise pas de librairies fournissant un équivalent de variant...).
17/10/2009, 16h16
souviron34

si, pour ça il y a le format "défaut" des fichiers de ressources de X11..

Exemples :

Citation:

ValeurBooléene : True
ValeurRéelle : 18.6
ValeurAscii : "Ceci est un texte"
...

Qui peut être hiérarchisé du niveau le plus général (sous X11 le Window Manager) jusqu'au niveau le plus particulier (tel bouton de tel fenêtre de telle appli de tel WM) simplement par des *.

Exemple :

Citation:

mwm.background : 0xFF background du WM
appli.background : 0xFF background de l'appli
appli*background : 0xFF background de tous les objets de l'appli
appli.win1.background : 0xFF background de la fenêtre win1 de l'appli
appli.win1*background : 0xFF background de tous les objets de la fenêtre win1 de l'appli
appli.win1*label.background : 0xFF background de tous les objets de type label de la fenêtre win1 de l'appli
appli.win1.label3.background : 0xFF background de l'objet label3 de la fenêtre win1 de l'appli
appli*label.background : 0xFF background de tous les objets de type label de l'appli

J'ai un petit code C qui lit un tel fichier de ressources (version simple (non hiérachisé)..

Merci pour toutes vos réponses, je crois que la meilleur idée qu'on peut se faire d'une namelist est comme vous l'avez dis l'association

< clé , valeur >

un fichier d'input classique avec une namelist ayant pour nom cntrl :
Code:

1 2 3 4 5 6 7 8 9 &cntrl IMIN = 1, NTPR = 100, NTR = 1, RESTRAINT_WT = 5.0, RESTRAINTMASK = ":1-227", MAXCYC = 4000, NCYC = 1000, NTB = 1, CUT = 10.0, /
la nameliste commence par &nom et se termine par / tous les flags (clé) sont dans un ordre quelconque de type quelconque sur une ou plusieurs lignes.

En fortran il y a une commende spéciale pour ça de l'instruction read, du genre :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 ! declaration nameliste cntrl ! les variables ayant ete déclarée avant namelist /cntrl/ imin, nmropt, ntx, irest, ntrx, ntxo, & ntpr, ntave, ntwr, iwrap, ntwx, ntwv, & ntwe, ioutfm, ntwprt, idecomp, ntf, ntb, & dielc, cut, scnb, scee, nsnb, ipol, ig ! plus loin ! lecture de la nameliste cntrl read(mdin, nml = cntrl) ! et le tour est joué
Au vu des premières réponses j'avais commencé à écrire un code simple pour lire quelque chose du genre mais avec un item par ligne.

Si je m'en sort pas je reviens vers vous :mrgreen:

18/10/2009, 22h28
Trap D

Citation:

Envoyé par Ladgalen

Au vu des premières réponses j'avais commencé à écrire un code simple pour lire quelque chose du genre mais avec un item par ligne.

D'après ce qu'on voit de ton fichier tu peux considérer qu'un item commence par une lettre majuscule et se termine par une virgule (,) ça te facilitera la vie.

Je comprend pas trop pourquoi utiliser les majuscules et les virgules simplifierais ?

Voilà le code de la fonction que j'ai écrite, je met d'abord un exemple de fichier input. Le nom du fichier est récupéré en argument dans le programme main() . Toutes les variables de la namelist sont définit dans un fichier .h que j'ai mis après. C'est probablement lourdingue mais je trouve ça assez simple de lecture et d'utilisation. Point de vue robustesse j'ai également des doutes (merci à Little du chat pour son aide). J'ai aussi limité l'utilisation à 1 flag et une valeur par ligne mais l'ordre n'a pas d'importance.

Voilà le fichier

Code:

1
2
3
4
5
6
7
8
9
10
11
12
 
# commentaire
temperature	350.0
methode		brownien	
graine		15041983
dt		0.001e-12
nstep		100000
# rcut		8.0
# rverlet		10.0
# masse		6.e-23
cristal		CFC
A0		5.2

Voilà 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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*                                                                           */
/* lecture du fichier input                                                  */
/*                                                                           */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
int lecture_input( void ) {
 
	int erreur = 0 ;
 
	int 	i , existe ;
	char	ligne[ LEN ] = "" ;
	char	poubelle[ LEN ] = "" ;
 
	FILE* 	finput ;
 
	// structure namelist
	struct namelist {
		char	flag[NFLAG][100] ;
		char	valeur[NFLAG][100] ;
		int	lu[NFLAG] ;
		int	type[NFLAG] ;
	} ;
	struct namelist	maliste ;
 
	// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//
	//		initialisation de la namelist				//
	// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//
 
	// liste des flags de la nameliste
	// parametres spécifique au calcul
	strcpy( maliste.flag[ 0] , "methode" ) ;
	strcpy( maliste.flag[ 1] , "nstep" ) ;
	strcpy( maliste.flag[ 2] , "dt" ) ;
	strcpy( maliste.flag[ 3] , "xi" ) ;
	strcpy( maliste.flag[ 4] , "temperature" ) ;
	strcpy( maliste.flag[ 5] , "rcut" ) ;
	strcpy( maliste.flag[ 6] , "rverlet" ) ; 
	// nombre aleatoires
	strcpy( maliste.flag[ 7] , "graine" ) ;
	// parametre du potentiel et des atomes
	strcpy( maliste.flag[ 8] , "aname" ) ;
	strcpy( maliste.flag[ 9] , "masse" ) ;
	strcpy( maliste.flag[10] , "LJsigma" ) ;
	strcpy( maliste.flag[11] , "LJeps" ) ;
	// parametres geometries initiales
	strcpy( maliste.flag[12] , "cristal" ) ;
	strcpy( maliste.flag[13] , "A0" ) ;
	strcpy( maliste.flag[14] , "dimension" ) ;
 
	// pour savoir si le flag a ete lu ou pas
	for ( i = 0 ; i < NFLAG ; i++ ) maliste.lu[ i] = 0 ; 
 
	// type des flags : 1 = entier, 2 = reel, 3 = caracteres 
	maliste.type[ 0]	= 3 ;
	maliste.type[ 1]	= 1 ;
	maliste.type[ 2]	= 2 ;
	maliste.type[ 3]	= 2 ;
	maliste.type[ 4]	= 2 ;
	maliste.type[ 5]	= 2 ;
	maliste.type[ 6]	= 2 ;
	maliste.type[ 7]	= 1 ;
	maliste.type[ 8]	= 3 ;
	maliste.type[ 9]	= 2 ;
	maliste.type[10]	= 2 ;
	maliste.type[11]	= 2 ;
	maliste.type[12]	= 3 ;
	maliste.type[13]	= 2 ;
	maliste.type[14]	= 1 ;
 
	// fichier contenant la namelist
	finput = fopen ( input , "r" ) ;
 
	// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//
 
 
	// test existance du fichier input
	if ( finput == NULL ) {
		fprintf ( stdout, "\n\n FICHIER D'INPUT N'EXISTE PAS   : %s \n",input ) ;
		exit(0) ;
	}
 
	// lecture du fichier input qui contient la namelist
	while ( fgets( ligne, LEN, finput ) != NULL ) {
 
		// test ligne blanche
		i = 0 ;
		while ( ligne[i] != '\n' && ( ligne[i] == ' ' || ligne[i] == '\t' ) ) {
			++i ;
		}
		if ( ligne[i] == '\n' ) continue ;
 
		// si c'est un commentaire
		if ( strchr( ligne, '#' ) != NULL || 
		     strchr( ligne, '*' ) != NULL ) continue ; 
 
		// identification du flag et lecture de la valeur
		existe = 0 ;
		for ( i = 0 ; i < NFLAG ; i++ ) {
			if ( strstr( ligne, maliste.flag[i] ) != NULL ) {
				// on a identifié un flag 
				if ( maliste.lu[i] == 1 ) {
					fprintf ( stdout, "\n\n le flag %s apparait plusieurs fois \n\n", maliste.flag[i] );
					exit(0) ;
				} else {
					maliste.lu[i] = 1 ;
					existe = 1 ;
					sscanf ( ligne , "%s %s", poubelle, maliste.valeur[i] ) ;
					break ;
				}
			}
		}
 
		fprintf ( stdout, "valeur : %s \n", maliste.valeur[i] ) ;
 
		if ( existe == 0 ) {
			fprintf ( stdout, "\n\nErreur sur cette ligne du fichier %s : %s \n", input, ligne) ;
			fprintf ( stdout, "flag inconnu !\n\n" ) ;
			exit(0) ;
		}
        }
 
	fclose( finput ) ;
 
	// si un flag a été lu on attribue la valeur à la variables globales correspondante
	if ( maliste.lu[0] == 1 ) {
		strcpy( methode, maliste.valeur[0] ) ;
	}
 
	if ( maliste.lu[1] == 1 ) {
		nstep = atoi ( maliste.valeur[1] ) ;
	}
 
	if ( maliste.lu[2] == 1 ) {
		dt = atof ( maliste.valeur[2] ) ;
	}
 
	if ( maliste.lu[3] == 1 ) {
		xi = atof ( maliste.valeur[3] ) ;
	}
 
	if ( maliste.lu[4] == 1 ) {
		temperature = atof ( maliste.valeur[4] ) ;
	}
 
	if ( maliste.lu[5] == 1 ) {
		rcut = atof ( maliste.valeur[5] ) ;
	}
 
	if ( maliste.lu[6] == 1 ) {
		rverlet = atof ( maliste.valeur[6] ) ;
	}
 
	if ( maliste.lu[7] == 1 ) {
		graine = atoi ( maliste.valeur[7] ) ;
	}
 
	if ( maliste.lu[8] == 1 ) {
		strcpy( aname, maliste.valeur[8] ) ;
	}
 
	if ( maliste.lu[9] == 1 ) {
		masse = atof ( maliste.valeur[9] ) ;
	}
 
	if ( maliste.lu[10] == 1 ) {
		LJsigma = atof ( maliste.valeur[10] ) ;
	}
 
	if ( maliste.lu[11] == 1 ) {
		LJeps = atof ( maliste.valeur[11] ) ;
	}
 
	if ( maliste.lu[12] == 1 ) {
		strcpy( cristal, maliste.valeur[12] ) ;
	}
 
	if ( maliste.lu[13] == 1 ) {
		a0 = atof ( maliste.valeur[13] ) ;
	}
 
	return erreur ;
}

et voilà le fichier entete :

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
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*                                                                           */
/* fichier variables_globales.h                                              */
/*                                                                           */
/* contient toutes les variables globales de main.h                          */
/*                                                                           */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
#define	NFLAG	15
#define LEN	100
 
/* thermo */
int	nat ;
double	volume ;
double	temperature ;
double	pression ;
 
/* atome */
double	masse ;
char 	aname[ LEN ] ;
 
/* potentiel Lennard Jones */
double	LJsigma ;
double	LJeps ;
double	LJsigma6 ;
double	LJ4eps ;
 
/* cut off */
double	rcut ;
double	rverlet ;
 
/* calcul */
char	methode[ LEN ] ;
int	nstep ;
double	dt ;
double 	xi ;
 
// nombre aléatoire
int	graine ;

19/10/2009, 00h20
souviron34
quelle complication :aie:

Et on dit que c'est le C qui est compliqué..
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 typedef union pValue { int i ; double d ; char c ; char *s ; } Value ; typedef pParam { char *Name ; Value Val ; } Param ; Param *NameList ;
Avec cette structure, tu as quelque chose de générique qui lit et stocke tout, et qui est simple....

Sans avoir à redéfinir les noms ou quoi que soit...

M'enfin, si tu veux te compliquer la vie...
19/10/2009, 00h42
Mac LAK

Le souci avec une union, c'est que tu perds le typage... Ce qui peut être gênant.
Il faudrait rajouter une énumération stockant l'information de type avec l'union, et mettre le tout dans une structure, pour réellement avoir quelque chose de générique.

hmmm, je comprend rien à ce que tu me dis mais ça me fais penser à un truc que j'ai vu.

voilà la structure :
Code:

1 2 3 4 5 6 7 8 9 10 typedef struct { char *vName; void *vPtr; enum { NI, NR, NC } vType; int vDim; int vStatus; } NameList;
Des define utilisant l'enumération :
Code:

1 2 3 #define INAME(x) {#x, &x, NI, sizeof(x) / sizeof(int)} #define RNAME(x) {#x, &x, NR, sizeof(x) / sizeof(double)}
La declaration de la namelist :
Code:

1 2 3 4 5 6 7 8 NameList nameList[] = { INAME(Vitesse), INAME(StepAvg), INAME(StepLimit), RNAME(Rcut), RNAME(rVerlet), RNAME(A0), };
et plus loin :
Code:

1 2 3 4 5 6 7 8 9 10 11 switch (nameList[k].vType) { case NI: *((int *) (nameList[k].vPtr) + j) = atol(token); break; case NR: *((double *) (nameList[k].vPtr) + j) = (double) atof(token); break; case NC: strcpy((nameList[k].vPtr), token); break;
Par contre je n'y ai pas compris grand chose. J'ai l'impression qu'il arrive grace au nom de la variable à définir si le flag existe puis les NI, NR et NC lui permette de ne pas perdre le type contrairement à moi.

Quand j'aurais fếté mon premier moi de C je m'y replongerai :D

19/10/2009, 09h51
Mac LAK

Citation:

Envoyé par Ladgalen

J'ai l'impression qu'il arrive grace au nom de la variable à définir si le flag existe puis les NI, NR et NC lui permette de ne pas perdre le type contrairement à moi.

C'est exactement ça. Tu stockes l'information "type de la variable" conjointement à l'union qui permet l'abstraction, et zou.

A noter qu'en C mode "je suis un barbare", l'union est en général remplacée par un void* casté sauvagement vers le type approprié en fonction du type stocké... Je ne saurais trop te déconseiller d'utiliser une telle méthode si tu n'es pas absolument sûr et certain de ce que tu fais. Utilises plutôt une union, c'est plus fiable, surtout pour un débutant.
19/10/2009, 11h55
Ladgalen

Qu'est ce qu'une "union" ?
19/10/2009, 12h21
diogene

Voir la FAQ : Quelle est la différence entre une structure et une union ?
19/10/2009, 13h20
souviron34

Citation:

Envoyé par Mac LAK

Le souci avec une union, c'est que tu perds le typage... Ce qui peut être gênant.
Il faudrait rajouter une énumération stockant l'information de type avec l'union, et mettre le tout dans une structure, pour réellement avoir quelque chose de générique.

c'est exact je l'ai oublié dans la structure Param...

:oops: