Conditional compilation/fr: what changed

Revision 1 to 2. Removed lines have a minus sign; added lines have a plus sign.

Old	New		Line
1	1		# Directive à la compilation \$DEFINE et \$IFDEF
2	2
3	3		## Pourquoi ?
4	4
5	5		Si vous avez une application qui demande plusieurs variantes, disons pour deux clients ou pour deux systèmes d'exploitation alors les directives de compilation sont faites pour vous. Un exemple pratique est quand vous codez pour plusieurs plates-formes. Les applications 32 bit permettent des fichiers de 4 Go parce c'est la taille maximale d'un Integer mais d'autres systèmes d'exploitation n'ont pas cette limitation. Ainsi une définition de FileSize peut être la suivante :
6	6
7	7		``` pascal
8	8		var
9	9		MyFilesize:
10	10		{$ifdef Win32}
11	11		Cardinal
12	12		{$else}
13	13		int64
14	14		{$endif}
15	15		```
16	16
17	17		Rien de ceci n'est sensible à la casse. {\$ifdef}, {\$else}, etc sont appelés symboles. Quand ils sont assemblés pour réaliser une logique, le code résultant est appelé une macro. Pour d'autres exemples pratiques, voir : [[Code Conversion Guide/fr\|Code_Conversion_Guide/fr#Les_variables_utiles_pour_le_compilateur]].
18	18
19	19		Une autre façon de faire la même chose est d'utiliser les macros de l'IDE [[IDE Macros in paths and filenames/fr]].
20	20
21	21		Il ne reste plus qu'à savoir où est placé {\$DEFINE WIN32}, dans le code ou l'IDE.
22	22
23	23		Il y a trois façons de faire cela.
24	24
25	25		### Unité basée sur les instructions {\$DEFINE} et {\$IFDEF}
26	26
27	27		``` pascal
28	28		//Insérez le symbole $DEFINE à un point antérieur du code de l'unité
29	29		{$DEFINE Win32}
30	30		var
31	31		MyFilesize:
32	32		{$ifdef Win32}
33	33		Cardinal
34	34		{$else}
35	35		int64
36	36		{$endif}
37	37		//Insert $UNDEF symbol
38	38		{UNDEF $Win32}
39	39
40	40		```
41	41
42	42		### Utiliser l'EDI
43	43
44	44		Dans l'EDI, aller dans la page Projet \\| Options du projet \\| Options du compilateur \\| Options personnalisées et entrez -dWin32 ou Win32, selon la version. Dans Lazarus 1.2.4, le -d est entré automatiquement.
45	45
46	46		Dans les options personnalisées
47	47
48		-	~~`-d est identique à #DEFINE`\~~
49		-	~~`-u est identique à #UNDEF`~~
	48	+	```text
	49	+	-d est identique à #DEFINE
	50	+	-u est identique à #UNDEF
	51	+	```
50	52
51	53		Ces entrées s'appliquent à la totalité du projet.
52	54
53	55		### Utilisez un fichier d'inclusion
54	56
55	57		Voir l'exemple plus détaillé plus bas.
56	58
57	59		## Symboles
58	60
59	61		Les \$IFNDEF, \$IFDEF, \$ENDIF, \$ELSE, \$DEFINE, \$UNDEF imbriqués sont permis. Voir [[local compiler directives/fr\|Conditonnelle de compilation]] pour une liste complète.
60	62
61	63		## Exemples complexes
62	64
63	65		Les defines et les fichiers d'inclusion (.inc) basés unité doivent ajoutés dans chaque unité concernée. Alors qu'une option personnalisée s'applique à toutes les unités du projet.
64	66
65	67		### Instructions {\$DEFINE} et {\$IFDEF} basés unité
66	68
67	69		Créez un projet avec une simple fiche comme ci-dessous. Commentez et décommentez les deux instructions {\$DEFINE} tour à tour et regardez ce qui se passe. Si vous ajoutez une seconde fiche (Form2) qui s'ouvre quand la première (Form1) est cliquée, des instructions similaires fonctionneront indépendamment des instructions {\$DEFINE} de Form1.
68	70
69	71		``` pascal
70	72		var
71	73		Form1: TForm1;
72	74
73	75		implementation
74	76
75	77		{$R *.lfm}
76	78		{$DEFINE RED}
77	79		//{$DEFINE BLUE}
78	80		{ TForm1 }
79	81
80	82		procedure TForm1.FormClick(Sender: TObject);
81	83		begin
82	84		{$IFDEF RED} Form1.Color := clRed; {$ENDIF}
83	85		{$IFDEF BLUE} Form1.Color := clBlue; {$ENDIF}
84	86		{$IFDEF BLUE AND $IFDEF RED} Form1.Color := clYellow; {$ENDIF}
85	87		{$IFNDEF RED AND $IFNDEF BLUE} Form1.Color := clAqua; {$ENDIF}
86	88		end;
87	89		```
88	90
89	91		### Fichiers d'inclusion
90	92
91	93		Les fichiers d'inclusion ajoute du code dans toute unité .pas.
92	94
93	95		Créez un fichier appelé unit1.inc (il pourrait s'appeler n_importe_quoi.pas) qui contient :
94	96
95	97		``` pascal
96	98		{$DEFINE RED}
97	99		//{$DEFINE BLUE}
98	100		```
99	101
100	102		Créeez une autre appelée unit1a.inc qui contient :
101	103
102	104		``` pascal
103	105		{$IFDEF RED} Form1.Color := clRed; {$ENDIF}
104	106		{$IFDEF BLUE} Form1.Color := clBlue; {$ENDIF}
105	107		{$IFDEF BLUE AND $IFDEF RED} Form1.Color := clYellow; {$ENDIF}
106	108		{$IFNDEF RED AND $IFNDEF BLUE} Form1.Color := clAqua; {$ENDIF}
107	109		```
108	110
109	111		Ajoutez-les dans le dossier du projet. Une fois compilées, ces lignes remplaceront les instructions \$INCLUDE ci-dessous. Les deux méthodes présentent le même code au compilateur. Néanmoins, employer des fichiers d'inclusion permet de répondre à des exigences plus complexes.
110	112
111	113		``` pascal
112	114		var
113	115		Form1: TForm1;
114	116
115	117		implementation
116	118
117	119		{$R *.lfm}
118	120		{$INCLUDE unit1.inc}
119	121		{ TForm1 }
120	122
121	123		procedure TForm1.FormClick(Sender: TObject);
122	124		begin
123	125		{$INCLUDE unit1a.inc}
124	126		end;
125	127		```
126	128
127	129		Maintenant, nous pouvons l'étendre à ceci :
128	130
129	131		``` pascal
130	132		var
131	133		Form1: TForm1;
132	134
133	135		implementation
134	136
135	137		{$R *.lfm}
136	138		{$IFDEF ABC}
137	139		{$INCLUDE abc.inc}
138	140		{$ELSE}
139	141		{$INCLUDE xyz.inc}
140	142		{$ENDIF}
141	143
142	144		{ TForm1 }
143	145
144	146		procedure TForm1.FormClick(Sender: TObject);
145	147		begin
146	148		... some code ...
147	149		{$IFDEF ABC}
148	150		{$INCLUDE abcCode.inc}
149	151		{$ELSE}
150	152		{$INCLUDE xyzCode.inc}
151	153		{$ENDIF}
152	154		... some more code ...
153	155		end;
154	156		```
155	157
156	158		### Projet \\| Options du projet \\| Options du compilateur \\| Options personnalisées
157	159
158	160		Mettre en commentaire ou effacer les symboles {\$DEFINE} dans votre code et ajouter les directives comme ci-dessous. Dans ce cas, les directives s'appliqueront à toutes les unités.
159	161
160	162		Ceci définit les symboles FPC. Par exemple, -dDEBUG -dVerbose définiront les symboles FPC DEBUG et Verbose, ainsi vous pouvez utiliser {\$IFDEF Debug}. Voir [[IDE Macros in paths and filenames]].
161	163
162	164		Remarquez le préfixe -d.
163	165
164		-	~~`-dRED`\~~
165		-	~~`-dBLUE`~~
	166	+	```text
	167	+	-dRED
	168	+	-dBLUE
	169	+	```
166	170
167	171		Une approche similaire peut être utilisée en compilant avec FPC au lieu de Lazarus : spécifiez l'argument -d... dans la ligne de commande en appelant FPC (p.ex. dans un fichier de commandes).
168	172
169	173		Depuis Lazarus 1.2, la nouvelle IHM des options offre un choix : soit entrer la directive avec -d comme précédemment, soit utiliser l'interface graphique. L'interface graphique stocke toutes les directives entrées et active celles que vous avez sélectionnées. Celles-ci sont alors affichées comme dans la pré version 1.2 avec le préfixe -d.
170	174
171	175		---
172	176		From the Free Pascal wiki, page "Conditional compilation/fr", as it stood on 2020-02-11 after a change by Trev, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).

Back to history